Pup - the AI's own browser

@@ -2240,6 +2240,84 @@ function osGetForegroundWindow() {   } catch (e) { return null; } } +// v1.9.180 — STUCK-OCCLUSION UNSTICK. Root-caused live on John's Slides window (2026-07-29): after a+// browser-process hang, Chrome's native occlusion state for a window can come back CORRUPTED — the+// window is frontmost on screen, yet the page reports document.visibilityState 'hidden', so Chrome+// withholds every frame. The user sees DWM's last composited frame (looks perfect in screenshots) but+// scrolling/typing repaints NOTHING — "pup is frozen" while the page is healthy. Programmatic raise+// (SWP_NOACTIVATE) and even minimize/restore do NOT recompute it; a REAL activation does. So: when a+// pup window IS the OS-foreground window but its page claims hidden, that state is impossible-if-+// healthy — unstick it (CDP lifecycle 'active' first, then a real forced activation) and tell the user.+async function pageSetLifecycleActive(page) {+  let cdp = null;+  try {+    cdp = await withTimeout(page.target().createCDPSession(), 3000, 'cdp-lifecycle');+    await withTimeout(cdp.send('Page.setWebLifecycleState', { state: 'active' }), 3000, 'lifecycle');+    return true;+  } catch (e) { return false; }+  finally { try { if (cdp) await cdp.detach(); } catch (e) {} }+}++// Force a REAL activation of a window (AttachThreadInput + ALT-nudge + SetForegroundWindow) — the+// user-input-equivalent activation that actually recomputes Chrome's occlusion, unlike a plain raise.+function forceActivateHwnd(hwnd) {+  if (process.platform !== 'win32' || !hwnd) return false;+  try {+    const scriptPath = path.join(require('os').tmpdir(), `_adom_act_${process.pid}.ps1`);+    const ps = [+      'Add-Type @"',+      'using System; using System.Runtime.InteropServices;',+      'public class WinAct {',+      '  [DllImport("user32.dll")] public static extern bool SetForegroundWindow(IntPtr h);',+      '  [DllImport("user32.dll")] public static extern bool BringWindowToTop(IntPtr h);',+      '  [DllImport("user32.dll")] public static extern void keybd_event(byte k, byte s, uint f, UIntPtr x);',+      '}',+      '"@',+      // The ALT-nudge: a real (harmless) modifier keypress releases Windows' foreground lock so+      // SetForegroundWindow performs a TRUE activation instead of a taskbar flash.+      '[WinAct]::keybd_event(0xA4,0,0,[UIntPtr]::Zero); [WinAct]::keybd_event(0xA4,0,2,[UIntPtr]::Zero)',+      `$h=[IntPtr]${Number(hwnd)}`,+      '[void][WinAct]::BringWindowToTop($h); [void][WinAct]::SetForegroundWindow($h)',+    ].join('\r\n');+    fs.writeFileSync(scriptPath, ps);+    runPsHidden(scriptPath, { timeout: 4000 });+    return true;+  } catch (e) { return false; }+}++const _unstickLast = new Map();   // sessionId -> ts of last unstick attempt (don't nag every tick)+async function unstickIfHiddenWhileFront(sessionId, session, fgHwnd) {+  if (process.platform !== 'win32' || !session) return false;+  const tab = (session.tabs || []).find(t => t.tabId === session.activeTabId) || (session.tabs || [])[0];+  if (!tab || !tab.page || tab._crashed) return false;+  let vis = null;+  try { vis = await withTimeout(tab.page.evaluate('document.visibilityState'), 1500, 'vis-probe'); } catch (e) { return false; }+  if (vis !== 'hidden') return false;+  // hidden is NORMAL for a background window — only frontmost-yet-hidden is the broken state.+  const hwnd = await sessionHwnd(sessionId);+  if (!hwnd || String(fgHwnd) !== String(hwnd)) return false;+  const last = _unstickLast.get(sessionId) || 0;+  if (Date.now() - last < 30000) return false;+  _unstickLast.set(sessionId, Date.now());+  console.log(`[unstick] "${sessionId}" is the FOREGROUND window but its page reports hidden — stuck occlusion; unsticking`);+  await pageSetLifecycleActive(tab.page);+  await new Promise(r => setTimeout(r, 700));+  try { vis = await withTimeout(tab.page.evaluate('document.visibilityState'), 1500, 'vis-probe'); } catch (e) {}+  if (vis === 'hidden') {+    forceActivateHwnd(hwnd);+    await new Promise(r => setTimeout(r, 900));+    try { vis = await withTimeout(tab.page.evaluate('document.visibilityState'), 1500, 'vis-probe'); } catch (e) {}+  }+  const fixed = vis !== 'hidden';+  if (fixed) {+    recordCleanup(`pup detected your "${sessionId}" window was front-and-center but Chrome had stopped painting it (stuck occlusion after a hang) — pup unstuck it automatically; scrolling and rendering work again.`);+  } else {+    recordCleanup(`pup detected your "${sessionId}" window is frontmost but Chrome is refusing to paint it (stuck occlusion). One real click anywhere on that window fixes it — pup's automatic nudges did not clear it this time.`);+  }+  console.log(`[unstick] "${sessionId}" ${fixed ? 'UNSTUCK — page visible again' : 'still hidden after nudges (needs one real user click)'}`);+  return fixed;+}+ // v1.8.40: badge each pup window's TASKBAR BUTTON with the white Adom leaves, so users can // tell a pup-driven window from their own browser. Done via AD-core desktop_taskbar (custom // PNG overlay, AD ≥1.9.106) — AD paints it cross-process natively; pup just hands over the@@ -8387,6 +8465,16 @@ const server = http.createServer(async (req, res) => {                 console.error(`SetForegroundWindow failed for session "${sessionId}":`, e.message);               }             }+            // v1.9.180: a raise can land on a stuck-occlusion window (frontmost yet page-hidden →+            // frame-frozen in front of the user). Check shortly after the reveal and unstick at once+            // rather than waiting for the 15s sweep.+            setTimeout(async () => {+              try {+                const s = sessions.get(sessionId);+                const fg = osGetForegroundWindow();+                if (s && fg) await unstickIfHiddenWhileFront(sessionId, s, fg);+              } catch (e) {}+            }, 2000);             sendJSON(res, { success: true, output: JSON.stringify({ ok: true, sessionId, focused: true }) });           } catch (e) {             sendJSON(res, { success: false, error: `Focus failed: ${e.message}` });@@ -10319,6 +10407,15 @@ server.listen(PORT, BIND_HOST, async () => {         _healingIds.delete(sid);       }     }+    // (3) STUCK-OCCLUSION check (v1.9.180) — a pup window that IS the OS-foreground window while its+    // page claims hidden is frame-frozen in front of the user's eyes; unstick it. One cheap OS read+    // per tick, and the per-session probe is timeout-bounded.+    try {+      if (sessions.size > 0) {+        const fg = osGetForegroundWindow();+        if (fg) { for (const [sid, sess] of [...sessions]) { try { await unstickIfHiddenWhileFront(sid, sess, fg); } catch (e) {} } }+      }+    } catch (e) {}   }, 15000);   // v1.9.166: taskbar-progress reconciler — clear any bar that is lit but shouldn't be.   setInterval(async () => {