Pup - the AI's own browser

@@ -971,6 +971,59 @@ function activeProgress() {   } catch (e) {}   return rows; }+// ── v2.0.386 (#83 ask 3): IDENTITY AUDIT — read back what the OS window is ACTUALLY stamped with+// and compare it to what pup believes (_curAppId). A mismatch (a stale generation, a stamp that+// never landed, a window Chrome recreated) is re-stamped through the normal path, which also+// re-registers and nudges the button. One PowerShell per sweep for every live hwnd; every 5 min.+function readStampedAumids(hwnds) {+  return new Promise((resolve) => {+    if (process.platform !== 'win32' || !hwnds.length) return resolve({});+    const ps = `$code=@'+using System; using System.Runtime.InteropServices;+public static class AumidRead {+  [StructLayout(LayoutKind.Sequential)] public struct PROPERTYKEY { public Guid fmtid; public uint pid; }+  [StructLayout(LayoutKind.Sequential)] public struct PROPVARIANT { public ushort vt; public ushort r1; public ushort r2; public ushort r3; public IntPtr p; public IntPtr p2; }+  [ComImport, Guid("886d8eeb-8cf2-4446-8d02-cdba1dbdcf99"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]+  public interface IPropertyStore { int GetCount(out uint c); int GetAt(uint i, out PROPERTYKEY pk); int GetValue(ref PROPERTYKEY key, out PROPVARIANT pv); int SetValue(ref PROPERTYKEY key, ref PROPVARIANT pv); int Commit(); }+  [DllImport("shell32.dll")] public static extern int SHGetPropertyStoreForWindow(IntPtr hwnd, ref Guid iid, out IPropertyStore pps);+  static Guid AUM = new Guid("9F4C2855-9F79-4B39-A8D0-E1D42DE1D5F3");+  static Guid IID = new Guid("886d8eeb-8cf2-4446-8d02-cdba1dbdcf99");+  public static string Read(IntPtr hwnd) {+    IPropertyStore ps; if (SHGetPropertyStoreForWindow(hwnd, ref IID, out ps) != 0) return null;+    PROPERTYKEY k = new PROPERTYKEY(); k.fmtid = AUM; k.pid = 5;+    PROPVARIANT pv; if (ps.GetValue(ref k, out pv) != 0) return null;+    return (pv.vt == 31 && pv.p != IntPtr.Zero) ? Marshal.PtrToStringUni(pv.p) : null;+  }+}+'@+Add-Type -TypeDefinition $code+foreach($h in @(${hwnds.join(',')})){ $a=[AumidRead]::Read([IntPtr]$h); Write-Output ("$h" + [char]9 + $a) }`;+    execFile('powershell', ['-NoProfile', '-Command', ps], { windowsHide: true, timeout: 20000 }, (err, stdout) => {+      const out = {};+      if (!err) for (const line of String(stdout || '').split(/\r?\n/)) { const [h, a] = line.split('\t'); if (h) out[String(h).trim()] = (a || '').trim() || null; }+      resolve(out);+    });+  });+}+async function auditStampedIdentities() {+  if (process.platform !== 'win32' || pupSettings().aumidIcons !== 'on') return;+  const targets = [];+  for (const [sid, s] of sessions) { if (s && s._hwnd && s._curAppId) targets.push({ sid, hwnd: String(s._hwnd), expect: s._curAppId }); }+  if (!targets.length) return;+  const actual = await readStampedAumids(targets.map(t => t.hwnd));+  let mismatches = 0;+  for (const t of targets) {+    const got = actual[t.hwnd];+    if (got === undefined) continue;                       // window not readable this pass (gone, or PS failed)+    if (got === t.expect) continue;+    mismatches++;+    console.log(`[identity] AUDIT MISMATCH "${t.sid}": stamped=${got || '(none)'} expected=${t.expect} — re-stamping (#83)`);+    const s = sessions.get(t.sid); if (!s) continue;+    s._curAppId = null; s._recoveryIdentityVerified = true;+    stampPupIdentity(t.sid, { _commit: true }).catch(() => {});+  }+  if (!mismatches) console.log(`[identity] audit ok: ${targets.length} window(s) stamped as expected`);+} function findAnyPendingDialog() {   for (const [sid, session] of sessions) {     const d = findPendingDialog(session);@@ -15923,6 +15976,7 @@ const server = http.createServer(async (req, res) => {           return;         }         case 'pup_rescan': {+          try { await auditStampedIdentities(); } catch (e) {}   // v2.0.386 (#83): rescan also re-checks every window's stamped identity           // v1.5.1+: orphan-recovery primitive. Walk every known profile           // (in-memory + on-disk session files), attempt reconnect for any           // whose CDP socket dropped, then walk pages of every connected@@ -17317,14 +17371,48 @@ const server = http.createServer(async (req, res) => {           const _fgBefore = await osGetForegroundWindow().catch(() => null);           // v2.0.289: show a determinate taskbar progress bar for the length of the capture, sized to           // the running-average screenshot time (John: progress bars instead of the flash).-          let screenshotBuf = await withTaskbarProgress(resolvedId, 'screenshot', () => withTimeout(-            // v2.0.186 (#50): captureBeyondViewport defaults TRUE in current puppeteer, which renders-            // from the document ORIGIN — so a viewport screenshot ignored the page's live scroll-            // position (scroll via pup_eval, screenshot still showed the top). Viewport shots now-            // capture the compositor's real viewport; fullPage keeps beyond-viewport ON (it needs it).-            raceCrash(tab, resolvedId, tab.page.screenshot({ type: 'png', fullPage, captureBeyondViewport: fullPage })),-            20_000, 'page.screenshot'-          ));+          let screenshotBuf = null, _capturedVia = 'cdp';+          try {+            screenshotBuf = await withTaskbarProgress(resolvedId, 'screenshot', () => withTimeout(+              // v2.0.186 (#50): captureBeyondViewport defaults TRUE in current puppeteer, which renders+              // from the document ORIGIN — so a viewport screenshot ignored the page's live scroll+              // position (scroll via pup_eval, screenshot still showed the top). Viewport shots now+              // capture the compositor's real viewport; fullPage keeps beyond-viewport ON (it needs it).+              raceCrash(tab, resolvedId, tab.page.screenshot({ type: 'png', fullPage, captureBeyondViewport: fullPage })),+              20_000, 'page.screenshot'+            ));+          } catch (e1) {+            // v2.0.386 (#80): a CDP capture on a fully OCCLUDED background window can hang until the+            // compositor produces a frame (pup deliberately lets background windows throttle, #14), and+            // the old path surfaced that as a bare timeout with an empty output. Two fallbacks that+            // never touch OS focus, then an honest error: (1) CDP lifecycle 'active' + one retry;+            // (2) an OS-level PrintWindow capture of the window (works while occluded); (3) errorCode.+            if (!/timed out/i.test(String(e1 && e1.message))) throw e1;+            console.log(`[screenshot] "${resolvedId}" CDP capture timed out — trying lifecycle-active retry, then OS window capture`);+            try {+              await pageSetLifecycleActive(tab.page);+              screenshotBuf = await withTimeout(raceCrash(tab, resolvedId, tab.page.screenshot({ type: 'png', fullPage, captureBeyondViewport: fullPage })), 8000, 'page.screenshot(retry)');+              _capturedVia = 'cdp-after-lifecycle-active';+            } catch (e2) {+              let _osBuf = null;+              try {+                if (!session._hwnd) { try { await resolveSessionHwndByBounds(session, resolvedId); } catch (e) {} }+                if (session._hwnd && !fullPage) {+                  const r = await chrome.abCommand('desktop_screenshot_window', { hwnd: Number(session._hwnd) }, { timeoutMs: 25000, callerThread: _callerThread || undefined, callerReason: 'pup screenshot fallback (CDP capture timed out on an occluded window)' });+                  const p = abPayload(r) || {};+                  const fp = p.fullPath || p.safePath || (r && (r.fullPath || r.safePath));+                  if (fp && fs.existsSync(fp)) _osBuf = fs.readFileSync(fp);+                }+              } catch (e) {}+              if (!_osBuf) {+                sendJSON(res, { success: false, errorCode: 'screenshot_timeout', error: `page.screenshot timed out (CDP), a lifecycle-active retry timed out, and the OS window capture was unavailable${fullPage ? ' (fullPage has no OS fallback)' : ''}`,+                  _hint: 'The window is probably fully occluded and its compositor is idle (background windows throttle on purpose, #14). pup_eval still works, so the page is fine. Options: retry in a moment; call pup_raise_os_window with a foregroundReason if the user asked to see it; or open the window with highFps:true when you need continuous frames. Read errorCode, not output: this failure used to arrive as an empty output.' });+                return;+              }+              screenshotBuf = _osBuf; _capturedVia = 'os-window';+              console.log(`[screenshot] "${resolvedId}" served by OS window capture after CDP timeouts`);+            }+          }           // If the capture foregrounded THIS window AND there was no recent user input (so it was pup,           // not the user clicking it), caption "<thread> · screenshotting" so the user knows what put it           // on their screen. No-op on the common CDP path, which never foregrounds (measured 0/101).@@ -18679,6 +18767,7 @@ const server = http.createServer(async (req, res) => {             }             const magic = (() => { try { return fs.readFileSync(abs).slice(0, 5).toString('latin1').replace(/[^\x20-\x7e]/g, '.'); } catch (e) { return null; } })();             sendJSON(res, { success: true, output: JSON.stringify({+              ok: true, capturedVia: _capturedVia,   // v2.0.386 (#80): cdp | cdp-after-lifecycle-active | os-window               ok: true, savedTo: abs, filename: fname, bytes: (ev.totalReceivedBytes || ev.receivedBytes || sizeOnDisk), sizeOnDisk, magic,               triggeredBy: args.selector ? ('click ' + args.selector) : ('a[download] ' + args.url),               sessionId: resolvedId, tabId,@@ -20298,6 +20387,7 @@ const _onPupBound = async () => {   // reconnects, and every rescan already reconciles inline — the patrol is just a backstop, and a   // hot one multiplies any probe-judgement bug across every window (today's lesson).   setTimeout(() => { for (const [sid, s] of [...sessions]) reconcileSessionTabs(s, sid).catch(() => {}); }, 8000);+  setInterval(trackedLoop('identity-audit', 300000, () => { if (minimalTouch()) return; auditStampedIdentities().catch(() => {}); }), 300000);   // v2.0.386 (#83 ask 3)   setInterval(trackedLoop('reconcile-session-tabs', 300000, () => { if (minimalTouch()) return; for (const [sid, s] of [...sessions]) reconcileSessionTabs(s, sid).catch(() => {}); }), 300000);   // v1.9.171 — CRASH SELF-HEAL. The shared Chrome dies two ways on heavy/hostile pages (measured   // repeatedly on the Autodesk sign-in flow), and pup must recover from BOTH without a human: