Pup - the AI's own browser

@@ -857,6 +857,47 @@ function _isCrashedFrameError(e) {   return /detached Frame|Target crashed|Session closed|Execution context was destroyed|no live page/i.test(m); } +// The CDP target id behind a page — the stable identity of a Chrome tab across bridge reconnects+// (the puppeteer Page OBJECT is recreated on every reconnect; the target id is not).+function _pageTargetId(page) {+  try { const t = page.target(); return (t && (t._targetId || (t._targetInfo && t._targetInfo.targetId))) || null; } catch (e) { return null; }+}++// v1.9.179: prune DEAD (closed / detached-frame) and DUPLICATE tab entries from a session. Rapid+// bridge restarts + crash reconnects bound the same Chrome tab multiple times (rescan keyed on the+// page OBJECT, which changes on reconnect), so a single-page window accumulated 4 identical entries —+// inflating the taskbar count badge to "4" and, because the active entry was a detached phantom, the+// favicon read (page.evaluate) threw and the overlay fell back to that wrong count. This makes the tab+// list reflect the REAL live tabs again. A probe TIMEOUT means "busy", not dead — those are kept, so a+// merely-slow tab is never wrongly dropped.+async function reconcileSessionTabs(session, sessionId) {+  if (!session || !Array.isArray(session.tabs) || session.tabs.length === 0) return 0;+  const kept = []; const seenTargets = new Set(); let dropped = 0;+  for (const t of session.tabs) {+    let dead = false;+    try {+      if (!t.page || t.page.isClosed()) dead = true;+      else {+        try { await withTimeout(t.page.evaluate('1'), 1500, 'tab-reconcile'); }+        catch (e) { if (_isCrashedFrameError(e)) dead = true; /* timeout = busy → keep */ }+      }+    } catch (e) { dead = true; }+    const tid = dead ? null : _pageTargetId(t.page);+    if (dead || (tid && seenTargets.has(tid))) { dropped++; continue; }+    if (tid) seenTargets.add(tid);+    kept.push(t);+  }+  if (dropped > 0) {+    session.tabs = kept;+    if (session.activeTabId && !kept.find(t => t.tabId === session.activeTabId)) {+      session.activeTabId = kept.length ? kept[kept.length - 1].tabId : null;+    }+    console.log(`[tabs] session "${sessionId}" reconciled: dropped ${dropped} dead/duplicate tab(s) → ${kept.length} live`);+    try { refreshWindowChrome(session, sessionId).catch(() => {}); } catch (e) {}  // re-stamp count/favicon overlay+  }+  return dropped;+}+ function _throwIfCrashed(t, sessionId) {   if (!t || !t._crashed) return;   const secs = Math.round((Date.now() - (t._crashedAt || Date.now())) / 1000);@@ -1250,25 +1291,31 @@ async function attemptReconnectProfile(profileName) { // in place. async function rescanProfile(browser, profileName, { adoptOrphans = false } = {}) {   const pages = await browser.pages();-  // Build the "page → existing tab" map so we know what's already attached.+  // v1.9.179: key the "already attached" map on the CDP TARGET ID, not the page OBJECT. On a+  // reconnect (bridge restart / crash recovery) puppeteer hands back a BRAND-NEW Page object for the+  // SAME Chrome tab, so an object-keyed map never matched and re-attached the tab as a duplicate —+  // which is how a 1-tab window grew to 4 identical entries. Target ids survive reconnects, so this+  // matches the existing tab and skips it instead of duplicating. (Falls back to the object when a+  // target id can't be read, preserving the old behaviour for that edge.)   const existingPageTab = new Map();+  const keyFor = (pg) => _pageTargetId(pg) || pg;   for (const s of sessions.values()) {     if (s.profileName !== profileName) continue;-    for (const t of s.tabs) existingPageTab.set(t.page, { sid: null, t });+    for (const t of s.tabs) existingPageTab.set(keyFor(t.page), { sid: null, t });   }   for (const [sid, s] of sessions.entries()) {     if (s.profileName !== profileName) continue;     for (const t of s.tabs) {-      const cur = existingPageTab.get(t.page);+      const cur = existingPageTab.get(keyFor(t.page));       if (cur) cur.sid = sid;     }   }   let reattached = 0, adopted = 0, alreadyLive = 0;   const seenSessions = new Set();   for (const page of pages) {-    if (existingPageTab.has(page)) {+    if (existingPageTab.has(keyFor(page))) {       alreadyLive++;-      const cur = existingPageTab.get(page);+      const cur = existingPageTab.get(keyFor(page));       if (cur && cur.sid) seenSessions.add(cur.sid);       continue;     }@@ -1322,6 +1369,11 @@ async function rescanProfile(browser, profileName, { adoptOrphans = false } = {}     `[rescan] profile "${profileName}": ${reattached} reattached, ${adopted} orphans adopted, ` +     `${alreadyLive} pages already live`   );+  // v1.9.179: after re-binding, prune any dead/duplicate tab entries this or a prior reconnect left+  // behind, so the tab count + overlay are correct immediately (browser_rescan triggers this).+  for (const [sid, s] of sessions.entries()) {+    if (s.profileName === profileName) { try { await reconcileSessionTabs(s, sid); } catch (e) {} }+  }   // v1.8.57: after a reattach, self-heal a window stranded off-screen by an older build's   // failed park (one heal per profile — all this profile's sessions share the window).   if (reattached > 0) {@@ -10180,6 +10232,12 @@ 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.179 — TAB RECONCILER. Prune dead/detached and duplicate tab entries so the taskbar count+  // badge reflects the REAL live tabs (rapid reconnects had inflated 1-tab windows to "4") and the+  // favicon overlay reads from a LIVE active tab instead of a detached phantom. Runs on a gentle+  // cadence; only sessions whose tab list actually changed re-stamp their overlay.+  setTimeout(() => { for (const [sid, s] of [...sessions]) reconcileSessionTabs(s, sid).catch(() => {}); }, 8000);+  setInterval(() => { for (const [sid, s] of [...sessions]) reconcileSessionTabs(s, sid).catch(() => {}); }, 45000);   // 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:   //