Pup - the AI's own browser

@@ -5530,7 +5530,12 @@ async function resolveSessionHwndByBounds(session, sessionId) {     // the sole-window-of-a-profile check below — none of which touch window geometry. A window none of     // those can resolve is left BARE (no overlay), which is fine; mangling the user's window is not.     // markerW stays null, so the matching loop below is pure read-only geometry (no setWindowBounds).-    const scriptPath = path.join(require('os').tmpdir(), `_adom_hwnd_${process.pid}.ps1`);+    // v2.0.13 (John): UNIQUE temp file per invocation. This used a single `_adom_hwnd_<pid>.ps1`, so+    // two concurrent hwnd resolutions (e.g. the startup brandSweep touching several windows at once)+    // collided on the same path and threw `EBUSY: resource busy or locked`. On a shared-profile window+    // that never resolved (many wiggle-matches), the retry hammered that same file in a tight loop,+    // spamming EBUSY and burning CPU (John's laptop-load report). A per-call filename removes the race.+    const scriptPath = path.join(require('os').tmpdir(), `_adom_hwnd_${process.pid}_${Date.now().toString(36)}_${Math.floor(Math.random() * 1e6).toString(36)}.ps1`);     // CSS bounds -> physical px via the DPI scale, then match a top-level window of ANY chrome.exe     // in this profile's process tree by position (a small tolerance absorbs frame/DPI rounding).     const ps = [@@ -5561,7 +5566,11 @@ async function resolveSessionHwndByBounds(session, sessionId) {       '[WEnum]::Find() | ForEach-Object { Write-Output $_ }',     ].join('\r\n');     fs.writeFileSync(scriptPath, ps);-    const out = (await runPsHiddenPromise(scriptPath, { timeout: 9000 }) || '').trim();+    // v2.0.13 (John): unique per-call filename (above) means we MUST clean it up or a persistent bridge+    // leaks a tiny .ps1 into tmpdir on every resolution. Unlink in finally regardless of outcome.+    let out = '';+    try { out = (await runPsHiddenPromise(scriptPath, { timeout: 9000 }) || '').trim(); }+    finally { try { fs.unlinkSync(scriptPath); } catch (e) {} }     if (!out) return null;     // Every chrome.exe under this profile counts (renderers have no windows, so PID may be the parent     // or a sibling in the tree — accept any, then disambiguate purely on geometry).@@ -9969,7 +9978,12 @@ const server = http.createServer(async (req, res) => {   // v1.9.334 (#468): everything except the lightweight /health probe needs the deferred native modules   // (puppeteer/sharp/keytar/chrome). Load them on first use; /health stays answerable during the ~8s   // one-time load so AD never mistakes a warming bridge for a wedged one.-  if (pathname !== '/health') ensureHeavyInit();+  // v2.0.13 (John, "everyone keeps saying pup is down"): ALSO exclude /status. pup declares /status as+  // its healthEndpoint (for the rich cold-start chip), so ab's spawn-ready probe hits /status; when+  // /status triggered the ~8s heavy init it blocked the event loop and ab timed out and reaped the+  // bridge ("never bound its port 64230"), the exact cold-spawn flap. /status now answers instantly+  // (it guards `chrome` for the pre-init window) and never gates on the native load.+  if (pathname !== '/health' && pathname !== '/status') ensureHeavyInit();    try {     // GET /health@@ -14114,6 +14128,19 @@ const server = http.createServer(async (req, res) => {      // GET /status     if (pathname === '/status') {+      // v2.0.13 (John): /status no longer triggers ensureHeavyInit, so on a cold spawn `chrome` may+      // not be loaded yet. Answer the chip probe INSTANTLY with a warming state rather than throwing+      // on chrome.readiness() — that is what let ab's spawn-ready probe succeed instead of reaping us.+      if (!chrome || !chrome.readiness) {+        sendJSON(res, {+          ok: true, bridge: 'puppeteer', version: BRIDGE_VERSION,+          led: 'yellow', summary: 'starting',+          tooltip: `Puppeteer bridge v${BRIDGE_VERSION} — warming up (loading runtime, recovering sessions)`,+          warming: true, ready: false,+          sessionCount: sessions.size, activeSession: activeSessionId,+        });+        return;+      }       const list = [];       for (const [id, s] of sessions) {         let pageUrl = null;@@ -14209,16 +14236,22 @@ server.keepAliveTimeout = 30_000; const BIND_HOST = process.env.ADOM_BIND_HOST || '127.0.0.1'; server.listen(PORT, BIND_HOST, async () => {   console.log(`Puppeteer Bridge running on http://${BIND_HOST}:${PORT} (bind=${BIND_HOST}; no firewall prompt)`);-  // v1.9.334 (#468): the PORT IS NOW BOUND (this callback fires after the OS bind), so AD already sees-  // the bridge listening and will not reap it. NOW do the heavy native loading that was deferred out of-  // the synchronous module-load path. It blocks briefly, but the port is up, so a reap can't happen.-  ensureHeavyInit();   console.log('Multi-session support: sessions are tabs sharing Chrome profiles via userDataDir');   console.log('Endpoints: /health, /command, /launch, /navigate, /reload, /screenshot, /screenshot.png, /errors, /eval, /wait, /status, /close');-  // Self-warm: detect browsers + disk the moment the bridge spawns (right after AD-  // installs/updates it), so the FIRST open is instant. Only fetches CfT if the box-  // has literally no Chrome/Edge and no cached CfT — otherwise it's a cheap no-op.-  try { chrome.warmup(); } catch (e) { console.error('warmup failed:', e.message); }+  // v2.0.13 (John, "everyone keeps saying pup is down"): DEFER the heavy native load + warm-up ++  // session recovery OFF the bind tick with setImmediate, so the event loop is free to answer /health+  // and /status (ab's spawn-ready probe) the instant the port binds. Previously ensureHeavyInit() ran+  // synchronously here and blocked the loop for the whole ~8s native load; a probe landing in that+  // window stalled and ab reaped the bridge ("never bound its port 64230") — the cold-spawn flap.+  // Verbs still force ensureHeavyInit() on first use (idempotent), so nothing races ahead of its deps.+  setImmediate(async () => {+    try { ensureHeavyInit(); } catch (e) { console.error('heavy init failed:', e.message); }+    // Self-warm: detect browsers + disk so the FIRST open is instant (cheap no-op if a browser exists).+    try { if (chrome && chrome.warmup) chrome.warmup(); } catch (e) { console.error('warmup failed:', e.message); }+    // Recover sessions from disk (reconnect to Chrome windows that survived a bridge restart).+    // Fire-and-forget: recovery must NEVER gate readiness or block the health probe.+    try { await recoverSessions(); } catch (e) { console.error('Session recovery failed:', e.message); }+  });   // v1.8.73: register the Adom.Pup app identity once per bridge run (HKCU AUMID + Start Menu   // shortcut whose pin launches a managed pup window). Loopback call from the bridge itself —   // trusted transport, no relay gating. Self-gates on AD <1.9.134 (unknown verb).@@ -14243,12 +14276,8 @@ server.listen(PORT, BIND_HOST, async () => {   }, 8000);   setTimeout(() => { ensureWindowOpenedWatch().catch(() => {}); }, 9000); -  // Recover sessions from disk (reconnect to Chrome windows that survived bridge restart)-  try {-    await recoverSessions();-  } catch (e) {-    console.error('Session recovery failed:', e.message);-  }+  // Session recovery now runs in the setImmediate above (fire-and-forget), so it never gates the+  // health probe or blocks the bind tick.    // v1.9.45: sweep orphaned AUMID keys, but LATE. Running it straight after recoverSessions() looked   // right and was wrong: when recovery legitimately ends with zero sessions (or is still settling),