Pup - the AI's own browser

@@ -9974,16 +9974,33 @@ server.listen(PORT, BIND_HOST, async () => {   // net, so an unbranded window can never persist even if its window-opened event was missed.   setTimeout(() => { reclaimUnmanagedWindows().catch(() => {}); }, 12000);   setInterval(() => { reclaimUnmanagedWindows().catch(() => {}); }, 90000);-  // v1.9.170 — BROWSER-HEALTH WATCHDOG. When the shared Chrome crashes or hangs (measured repeatedly-  // on the Autodesk sign-in flow), the browsers-map entry becomes a DEAD handle: the next verb fails-  // 'Connection closed' and pup LOOKS frozen (John: 'pup seems frozen again'). This proactively probes-  // each browser with a real CDP call; a browser that fails TWO consecutive probes (~30s — a real-  // crash/hang, not a transient slow beat) is discarded, its zombie Chromes reaped, its sessions-  // marked _lostBrowser so the next verb relaunches them, and the recovery is REPORTED via the cleanup-  // queue. So pup self-heals instead of stranding the user, and the next open relaunches clean.-  const _healthStrikes = new Map();+  // 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:+  //+  //   (1) CRASHED — Chrome's process exits. puppeteer fires 'disconnected', handleBrowserDisconnect+  //       DELETES the browsers entry and marks each affected session `_lostBrowser`. So by the time+  //       any watchdog runs the browsers map is already EMPTY — probing it finds nothing (this is why+  //       the v1.9.170 browsers-probe never fired). The real signal is the orphaned `_lostBrowser`+  //       sessions, and the real fix is to RELAUNCH them from disk. On the one durable profile they+  //       come back SIGNED IN at their last URL, in the background frame (no foreground steal).+  //   (2) HUNG — Chrome is alive but its CDP socket stops answering (no 'disconnected' fires, so the+  //       entry LINGERS as a dead handle; the next verb returns 'Connection closed' and passive verbs+  //       return null → pup LOOKS frozen, John: 'pup seems frozen again'). A real CDP probe with a+  //       timeout catches this; two consecutive misses (~30s, not a transient slow beat) = discard ++  //       reap + mark sessions lost, which then feed into the same (1) relaunch path.+  //+  // Backoff is mandatory: a page that crashes-Chrome-on-load (Kepler) would otherwise spin an endless+  // relaunch loop and cook the laptop. Cap auto-relaunches per session; after the cap, hands off and+  // tells the user via the cleanup queue that the page itself looks unstable.+  const _healthStrikes = new Map();       // profileName -> consecutive hung-probe misses+  const _healRelaunch = new Map();        // sessionId -> { count, last, gaveUp }+  const _healingIds = new Set();          // sessionIds with a relaunch in flight (guards the 15s re-tick)+  const MAX_HEAL_ATTEMPTS = 2;+  const HEAL_COOLDOWN_MS = 5 * 60 * 1000;   setInterval(async () => {     if (process.platform !== 'win32') return;+    // (2) HUNG detection — probe each LIVE browser entry; on 2 misses, tear it down so its sessions+    // become `_lostBrowser` and fall into the relaunch path below.     for (const [profileName, entry] of [...browsers]) {       let alive = false;       try {@@ -9998,13 +10015,46 @@ server.listen(PORT, BIND_HOST, async () => {       _healthStrikes.set(profileName, strikes);       if (strikes < 2) { console.log(`[health] "${profileName}" failed a liveness probe (strike ${strikes}/2) — watching`); continue; }       _healthStrikes.delete(profileName);-      console.log(`[health] "${profileName}" DEAD/HUNG (2 strikes) — discarding + recovering so pup self-heals`);-      recordCleanup(`pup detected the "${profileName}" Chrome had crashed or hung and cleaned it up — your window(s) will relaunch signed-in on the next open (logins are safe on disk).`);+      console.log(`[health] "${profileName}" HUNG (2 strikes) — discarding the dead handle so its windows can relaunch`);       try { await entry.browser.close(); } catch (e) {}       browsers.delete(profileName);       try { await killOrphanChromesForProfile(profileName); } catch (e) {}       for (const [, sess] of sessions) { if (sess.profileName === profileName) sess._lostBrowser = true; }     }+    // (1) CRASH recovery — proactively relaunch every `_lostBrowser` session (from a crash OR from the+    // hung-teardown above) so the user's windows come back on their own, signed in, where they left off.+    for (const [sid, sess] of [...sessions]) {+      if (!sess._lostBrowser || _healingIds.has(sid)) continue;+      const rec = _healRelaunch.get(sid) || { count: 0, last: 0, gaveUp: false };+      const now = Date.now();+      if (rec.count >= MAX_HEAL_ATTEMPTS) {+        if (now - rec.last < HEAL_COOLDOWN_MS) {+          if (!rec.gaveUp) {+            rec.gaveUp = true; _healRelaunch.set(sid, rec);+            console.log(`[heal] "${sid}" exceeded ${MAX_HEAL_ATTEMPTS} relaunch attempts — backing off ${Math.round(HEAL_COOLDOWN_MS/60000)}m (the page looks like it destabilizes Chrome)`);+            recordCleanup(`pup tried to bring your "${sid}" window back after a Chrome crash but it kept crashing on load — that page may be destabilizing Chrome, so pup has stopped retrying it. Reopen it manually when you're ready; your logins are safe on disk.`);+          }+          continue;+        }+        rec.count = 0; rec.gaveUp = false;   // cooldown elapsed — allow a fresh round+      }+      _healingIds.add(sid);+      rec.count += 1; rec.last = now; _healRelaunch.set(sid, rec);+      console.log(`[heal] "${sid}" lost to a Chrome crash — proactively relaunching (attempt ${rec.count}/${MAX_HEAL_ATTEMPTS}) at its last URL`);+      try {+        const r = await recoverOrRelaunchSession({ sessionId: sid });+        if (r && r.session) {+          console.log(`[heal] "${sid}" relaunched OK — window is back signed-in`);+          recordCleanup(`pup auto-recovered your "${sid}" window after a Chrome crash — it relaunched in the background, signed in, at where it left off (logins are safe on disk).`);+        } else {+          console.log(`[heal] "${sid}" relaunch did not resolve a live session yet — will retry next tick`);+        }+      } catch (e) {+        console.log(`[heal] "${sid}" relaunch failed: ${e.message} — will retry next tick`);+      } finally {+        _healingIds.delete(sid);+      }+    }   }, 15000);   // v1.9.166: taskbar-progress reconciler — clear any bar that is lit but shouldn't be.   setInterval(async () => {