Pup - the AI's own browser

@@ -17,6 +17,15 @@ function runPsHidden(scriptPath, { timeout = 6000 } = {}) { function runPsHiddenAsync(scriptPath, { timeout = 6000 } = {}) {   execFile('powershell.exe', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-WindowStyle', 'Hidden', '-File', scriptPath], { timeout, windowsHide: true }, () => {}); }+// Promise variant: resolves with stdout (trimmed) or '' on error. For PS whose RESULT matters+// but which must not block the event loop (e.g. the background watchdog).+function runPsHiddenPromise(scriptPath, { timeout = 8000 } = {}) {+  return new Promise(resolve => {+    execFile('powershell.exe', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-WindowStyle', 'Hidden', '-File', scriptPath], { encoding: 'utf8', timeout, windowsHide: true }, (err, stdout) => {+      resolve((stdout || '').trim());+    });+  });+} const puppeteer = require('puppeteer'); const credentialVault = require('./credential_vault'); const chrome = require('./chrome'); // Chrome-for-Testing self-heal: detect / auto-install / readiness (cold-start fix)@@ -1686,6 +1695,122 @@ function osBackgroundWindowByPid(pid, cdpPort, restoreHwnd, respectUser) {   } catch (e) { console.error(`[bg] pid ${pid} port ${cdpPort}: ${e.message}`); return 'error'; } } +// v1.8.50: THE background algorithm — ONE event-driven watchdog, no blind timers.+// Replaces the "park + re-park at 300/700/1200ms" kludge. What it does, in order:+//   1. WAIT for the real browser window to EXIST (poll EnumWindows @50ms, up to ~4s — reacting+//      to the event "window created", not guessing a delay). The window is OFF-SCREEN, invisible.+//   2. The moment it exists: hand keyboard focus back to the user's window (AttachThreadInput+//      dance — only if Chrome actually took the foreground), THEN move it on-screen at z-bottom+//      (deactivate-first order = no visible pop). ONE park.+//   3. STABILITY WATCH: for up to 2s, check the foreground @50ms. If Chrome re-grabs it+//      (startup self-raise), hand back + re-park INSTANTLY (50ms reaction, not a 400ms timer+//      gap). Exit as soon as the foreground has been non-pup for 500ms straight — typically+//      well under a second after first paint.+//   4. EXIT. After this process ends, NOTHING ever re-parks the window. A user click on the+//      taskbar button brings it up full-size and pup never touches it again. No input-timing+//      heuristics anywhere (GetLastInputInfo false-fired while the user typed — removed).+// Returns: 'backgrounded' | 'still-foreground' | 'no-window' | 'error' (self-verified).+async function osBackgroundWatchdog(pid, cdpPort, restoreHwnd) {+  if (process.platform !== 'win32' || (!pid && !cdpPort)) return 'error';+  try {+    const port = Number(cdpPort) || 0;+    const restore = (restoreHwnd && /^-?\d+$/.test(String(restoreHwnd))) ? String(restoreHwnd) : '0';+    const scriptPath = path.join(require('os').tmpdir(), `_adom_bgwd_${pid || port}.ps1`);+    const ps = [+      'Add-Type @"',+      'using System; using System.Runtime.InteropServices; using System.Text;',+      'public class WinWd {',+      '  public delegate bool EnumProc(IntPtr h, IntPtr l);',+      '  [DllImport("user32.dll")] public static extern bool EnumWindows(EnumProc cb, IntPtr l);',+      '  [DllImport("user32.dll")] public static extern bool IsWindowVisible(IntPtr h);',+      '  [DllImport("user32.dll")] public static extern int GetClassName(IntPtr h, StringBuilder s, int m);',+      '  public struct RECT { public int L; public int T; public int R; public int B; }',+      '  [DllImport("user32.dll")] public static extern bool GetWindowRect(IntPtr h, out RECT r);',+      '  [DllImport("user32.dll")] public static extern bool SetWindowPos(IntPtr h, IntPtr a, int x, int y, int cx, int cy, uint f);',+      '  [DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();',+      '  [DllImport("user32.dll")] public static extern int GetSystemMetrics(int i);',+      '  [DllImport("user32.dll")] public static extern uint GetWindowThreadProcessId(IntPtr h, out uint pid);',+      '  [DllImport("user32.dll")] public static extern bool AttachThreadInput(uint a, uint b, bool f);',+      '  [DllImport("user32.dll")] public static extern bool SetForegroundWindow(IntPtr h);',+      '  [DllImport("user32.dll")] public static extern bool BringWindowToTop(IntPtr h);',+      '  [DllImport("kernel32.dll")] public static extern uint GetCurrentThreadId();',+      '  public static IntPtr BestWindow(int[] pids) {',+      '    IntPtr best = IntPtr.Zero; long bestArea = -1;',+      '    EnumWindows(delegate(IntPtr h, IntPtr l) {',+      '      if (!IsWindowVisible(h)) return true;',+      '      uint wp; GetWindowThreadProcessId(h, out wp);',+      '      bool m = false; foreach (int p in pids) { if ((uint)p == wp) { m = true; break; } }',+      '      if (!m) return true;',+      '      StringBuilder sb = new StringBuilder(256); GetClassName(h, sb, 256);',+      '      if (sb.ToString() != "Chrome_WidgetWin_1") return true;',+      '      RECT r; GetWindowRect(h, out r); long a = (long)(r.R - r.L) * (r.B - r.T);',+      '      if (a > bestArea) { bestArea = a; best = h; }',+      '      return true;',+      '    }, IntPtr.Zero);',+      '    return best;',+      '  }',+      '}',+      '"@',+      `$targetPid = ${Number(pid) || 0}`,+      `$cdpPort = ${port}`,+      `$restore = [IntPtr]${restore}`,+      '$BOTTOM = [IntPtr]1',+      '$SWP = 0x10',                            // SWP_NOACTIVATE+      '$scrW = [WinWd]::GetSystemMetrics(0)',+      '$scrH = [WinWd]::GetSystemMetrics(1)',+      '$myTid = [WinWd]::GetCurrentThreadId()',+      // Focus handback: only acts when pup IS the foreground (Chrome stole it); else a no-op.+      'function HandBack([IntPtr]$pup) {',+      '  $fg = [WinWd]::GetForegroundWindow()',+      '  if ($fg -eq $pup -and $restore -ne [IntPtr]::Zero) {',+      '    $procId = [uint32]0',+      '    $pupTid = [WinWd]::GetWindowThreadProcessId($fg, [ref]$procId)',+      '    [WinWd]::AttachThreadInput($pupTid, $myTid, $true) | Out-Null',+      '    [WinWd]::SetForegroundWindow($restore) | Out-Null',+      '    [WinWd]::BringWindowToTop($restore) | Out-Null',+      '    [WinWd]::AttachThreadInput($pupTid, $myTid, $false) | Out-Null',+      '  }',+      '}',+      // 1. Wait for the window to EXIST (the event, not a guessed delay). Re-resolve the pid+      //    list every ~500ms (child browser pids can appear late).+      '$pup = [IntPtr]::Zero',+      '$deadline = [Environment]::TickCount + 4000',+      'while ([Environment]::TickCount -lt $deadline) {',+      '  $pidList = New-Object System.Collections.ArrayList',+      '  if ($targetPid -ne 0) { [void]$pidList.Add([int]$targetPid) }',+      '  if ($cdpPort -ne 0) { try { $own = Get-NetTCPConnection -LocalPort $cdpPort -State Listen -ErrorAction SilentlyContinue | Select-Object -First 1 -ExpandProperty OwningProcess; if ($own) { [void]$pidList.Add([int]$own) } } catch {} }',+      '  $anchors = @($pidList.ToArray())',+      '  foreach ($tp in $anchors) { Get-CimInstance Win32_Process -Filter "ParentProcessId=$tp" -ErrorAction SilentlyContinue | Where-Object { $_.Name -in @("chrome.exe","msedge.exe") } | ForEach-Object { [void]$pidList.Add([int]$_.ProcessId) } }',+      '  $pup = [WinWd]::BestWindow([int[]]@($pidList.ToArray()))',+      '  if ($pup -ne [IntPtr]::Zero) { break }',+      '  Start-Sleep -Milliseconds 50',+      '}',+      'if ($pup -eq [IntPtr]::Zero) { Write-Output "no-window"; exit }',+      // 2. Deactivate FIRST (while still off-screen), THEN park on-screen at z-bottom.+      'HandBack $pup',+      '[WinWd]::SetWindowPos($pup, $BOTTOM, 0, 0, $scrW, $scrH, $SWP) | Out-Null',+      // 3. Stability watch: react to Chrome re-grabs within 50ms; exit after 500ms of calm.+      '$calmSince = [Environment]::TickCount',+      '$watchEnd = [Environment]::TickCount + 2000',+      'while ([Environment]::TickCount -lt $watchEnd) {',+      '  $fg = [WinWd]::GetForegroundWindow()',+      '  if ($fg -eq $pup) {',+      '    HandBack $pup',+      '    [WinWd]::SetWindowPos($pup, $BOTTOM, 0, 0, $scrW, $scrH, $SWP) | Out-Null',+      '    $calmSince = [Environment]::TickCount',+      '  } elseif (([Environment]::TickCount - $calmSince) -ge 500) { break }',+      '  Start-Sleep -Milliseconds 50',+      '}',+      // 4. Self-verify and exit. Nothing runs after this — the user owns the window now.+      '$fg2 = [WinWd]::GetForegroundWindow()',+      'if ($fg2 -eq $pup) { Write-Output "still-foreground" } else { Write-Output "backgrounded" }',+    ].join('\r\n');+    fs.writeFileSync(scriptPath, ps);+    const out = await runPsHiddenPromise(scriptPath, { timeout: 9000 });+    return out || 'error';+  } catch (e) { console.error(`[bgwd] pid ${pid} port ${cdpPort}: ${e.message}`); return 'error'; }+}+ // v1.8.47: THE background primitive, rebuilt around MINIMIZE (replaces the on-screen-z-bottom // park + its re-park retry loop, which fought the user's clicks). Why minimize is correct: //  • Minimizing a foreground window hands the foreground back to the user's window AUTOMATICALLY@@ -2266,25 +2391,15 @@ async function getOrLaunchBrowser(profileName, { freshProfile = false, strictPer       // can re-raise itself during startup (first paint, restore prompts). Resolve the       // window via the CDP-port owner (reliable across launcher→browser pid relaunches).       if (!foreground && process.platform === 'win32') {-        // v1.8.49: background = ON-SCREEN at z-bottom (occluded, still renders → screenshots-        // work; minimize was tried and REJECTED — visibilityState 'hidden' hangs-        // Page.captureScreenshot ~27s even with occlusion disabled). The park deactivates FIRST-        // then moves on-screen behind everything (no pop), using the EnumWindows handle (the-        // real window, not a phantom). The launch passes ALWAYS park, no user detection: within-        // ~1.2s of launch the taskbar button barely exists, so a foreground pup window is-        // Chrome's startup self-raise, not the user — and input-timing heuristics false-fire-        // whenever the user is typing anywhere (the 1.8.44-48 bug that mis-sized fresh windows).-        // After this window ends, pup NEVER auto-re-parks, so a user click is never fought.-        b._bgResult = osBackgroundWindowByPid(child.pid, debugPort, priorForeground);-        console.log(`[bg] initial park for "${profileName}": ${b._bgResult}`);-        for (const delay of [300, 700, 1200]) {-          setTimeout(() => {-            try {-              const r = osBackgroundWindowByPid(child.pid, debugPort, priorForeground);-              if (r && r !== 'no-window') b._bgResult = r;-            } catch (e) {}-          }, delay);-        }+        // v1.8.50: ONE event-driven watchdog (see osBackgroundWatchdog) — waits for the window+        // to EXIST, parks it once (deactivate-first, on-screen z-bottom so screenshots keep+        // working), reacts to Chrome startup re-grabs within 50ms, exits after 500ms of calm.+        // After it exits NOTHING re-parks — a user's taskbar click brings the window up+        // full-size and pup never touches it again. No blind timers, no input heuristics.+        b._bgResult = 'parking';+        b._bgPromise = osBackgroundWatchdog(child.pid, debugPort, priorForeground)+          .then(r => { b._bgResult = r; console.log(`[bgwd] "${profileName}": ${r}`); return r; })+          .catch(() => (b._bgResult = 'error'));       }       return b;     };@@ -3340,6 +3455,13 @@ const server = http.createServer(async (req, res) => {           // Stash on the session so attachTab uses it for any subsequent           // tab open or popup auto-attach in this session.           if (session) session._downloadPath = downloadPath;+          // v1.8.50: the background watchdog runs concurrently with navigation. Await its+          // SELF-VERIFIED verdict (bounded) so the response's `background` field is the real+          // outcome ('backgrounded'/'still-foreground'), never a guess mid-park.+          try {+            const bp = session && browsers.get(session.profileName)?.browser?._bgPromise;+            if (bp) await Promise.race([bp, new Promise(r => setTimeout(r, 7000))]);+          } catch (e) {}           const info = await getSessionInfo(sessionId, session);           // v1.8.0: BACKGROUND BY DEFAULT. pup is the AI's workspace, not the user's —           // a window that pops to the foreground and covers what the user is doing is