teamshare-bridge 0.21.36 → 0.21.38

package/dist/cli/commands/browse.js

@@ -622,9 +622,20 @@ async function cmdBrowse(flags) {
     let doneRetries = 0;
     /** How often to re-check which tab is active (ms). */
     const TAB_CHECK_MS = 2000;
+    /**
+     * Background tab-watch interval (ms). The main loop only calls
+     * `refreshTabIfNeeded` once per iteration and an iteration can include a
+     * 30-120s vision call, so a separate watcher probes the active tab while the
+     * loop is busy and raises `tabSwitchPending`.
+     */
+    const TAB_WATCH_MS = 1500;
     let lastTabCheck = 0;
     let consecutiveScreenshotFailures = 0;
     let reattachFailures = 0;
+    /** Set by the background watcher when a different tab became active. */
+    let tabSwitchPending = false;
+    /** Guards against overlapping `pickActiveTab` probes from the watcher. */
+    let tabProbeInFlight = false;
     // Latency observability: rolling average of vision-call latency plus
     // abort/timeout/stall counts, so the operator can see how slow the model is.
     const llmStats = { calls: 0, ok: 0, screenAborts: 0, timeouts: 0, stalls: 0, totalMs: 0 };
@@ -655,6 +666,9 @@ async function cmdBrowse(flags) {
         codeConfirmedOptimal = false;
         consecutiveFailures = 0;
         consecutiveScreenshotFailures = 0;
+        // The switch we were following is now applied.
+        tabSwitchPending = false;
+        page._tabSwitchedAt = undefined;
         console.log(`[browse] Re-attached to tab: ${page.title} (${page.targetId.slice(0, 8)})`);
     }
     /**
@@ -695,6 +709,27 @@ async function cmdBrowse(flags) {
             return false;
         }
     }
+    /**
+     * Background watcher: the human (or the site/tool action) can change the
+     * active tab at any moment, and the main loop cannot notice while it is
+     * inside a long vision call. Probe the active tab every `TAB_WATCH_MS` and
+     * flag a switch; the vision heartbeat aborts the in-flight call so the loop
+     * re-binds to the newly active tab immediately. We never activate a tab.
+     */
+    const tabWatcher = setInterval(() => {
+        if (stopped || page.disconnected || tabProbeInFlight)
+            return;
+        tabProbeInFlight = true;
+        void (0, cdp_1.pickActiveTab)(port, page.targetId)
+            .then((active) => {
+            if (active && active.id !== page.targetId) {
+                tabSwitchPending = true;
+                page._tabSwitchedAt = Date.now();
+            }
+        })
+            .catch(() => { })
+            .finally(() => { tabProbeInFlight = false; });
+    }, TAB_WATCH_MS);
     process.on('SIGINT', () => {
         console.log('\n[browse] Stopped by user');
         stopped = true;
@@ -703,9 +738,17 @@ async function cmdBrowse(flags) {
     console.log(`[browse] Agent started. ${continuous ? 'Running until Ctrl+C.' : `Max ${maxActions} actions.`} Press Ctrl+C to stop.\n`);
     while (!stopped && actionCount < maxActions) {
         try {
-            // Follow the human's active tab: re-attach if the bound tab was closed or
-            // the user switched to another one.
-            await refreshTabIfNeeded();
+            // Follow the active tab: re-attach if the bound tab was closed, or if the
+            // watcher flagged a switch (force skips the throttle so we re-bind at once
+            // rather than working a stale tab for the rest of this iteration).
+            if (tabSwitchPending) {
+                tabSwitchPending = false;
+                page._tabSwitchedAt = undefined;
+                await refreshTabIfNeeded(true);
+            }
+            else {
+                await refreshTabIfNeeded();
+            }
             // Take screenshot and extract elements in parallel
             const [screenshot, elements, pageContext] = await Promise.all([
                 captureScreenshot(page, quality, SCREENSHOT_MAX_EDGE),
@@ -778,10 +821,14 @@ async function cmdBrowse(flags) {
                     fatalAuthError = true;
                     break;
                 }
-                // The screen changed while the LLM was thinking: its answer is stale.
-                // Bail out of the retry loop and re-analyze the NEW screen right away
-                // (speed matters: a 30s backoff here livelocked on dynamic pages).
-                if (result.error === 'screen_changed') {
+                // The screen changed (or a new tab became active) while the LLM was
+                // thinking: its answer is stale. Bail out of the retry loop and
+                // re-analyze the active tab right away (speed matters: a 30s backoff
+                // here livelocked on dynamic pages).
+                if (result.error === 'screen_changed' || result.error === 'tab_switch') {
+                    if (result.error === 'tab_switch') {
+                        console.log('[browse] Active tab changed during analysis — re-analyzing the new tab');
+                    }
                     screenChangedDuringLlm = true;
                     llmStats.screenAborts++;
                     logLlmStats();
@@ -1267,6 +1314,7 @@ Do NOT simplify variable names or change the function signature. Only optimize t
             await sleep(intervalMs);
         }
     }
+    clearInterval(tabWatcher);
     if (actionCount >= maxActions && !continuous) {
         console.log(`[browse] Reached max actions (${maxActions})`);
     }
@@ -1285,12 +1333,14 @@ Do NOT simplify variable names or change the function signature. Only optimize t
 /**
  * Connect directly to a page's WebSocket from /json/list.
  * This avoids the Target.attachToTarget complexity.
+ *
+ * Uses the ACTIVE-tab picker (`resolveActivePage`): the loop must bind to the
+ * tab the human/site has focused right now, not the first entry of /json/list.
+ * `resolveActivePage` falls back to the general attachable-page picker (which
+ * may open a blank tab) only when no page can be probed.
  */
 async function connectToPage(port, preferTargetId) {
-    // Shared picker (cdp.ts): prefers a real page, accepts about:blank/new-tab,
-    // and opens a blank tab if none exists - so a Chrome launched on the NTP is
-    // still attachable. (Was a local chrome:// filter that could never match.)
-    const pageTarget = await (0, cdp_1.resolveAttachablePage)(port, preferTargetId);
+    const pageTarget = await (0, cdp_1.resolveActivePage)(port, preferTargetId);
     const wsUrl = pageTarget.webSocketDebuggerUrl;
     return new Promise((resolve, reject) => {
         const ws = new ws_1.default(wsUrl);
@@ -3396,6 +3446,14 @@ async function analyzeScreenshot(baseUrl, apiKey, model, screenshotBase64, eleme
     let heartbeatTicks = 0;
     const heartbeat = setInterval(async () => {
         const elapsed = Math.round((Date.now() - startTime) / 1000);
+        // The human/page made a different tab active: this answer belongs to the
+        // old tab, so abort and let the loop re-bind to the active one.
+        if (page?._tabSwitchedAt && page._tabSwitchedAt > startTime) {
+            console.log(`[browse] Active tab switched (${elapsed}s) — aborting LLM`);
+            abortReason = 'tab_switch';
+            controller.abort();
+            return;
+        }
         // Check for screen change via CDP navigation event or MutationObserver flag
         let screenChanged = false;
         if (page?._cdpNavigated && page._cdpNavigated > startTime) {
@@ -3512,11 +3570,19 @@ async function analyzeScreenshot(baseUrl, apiKey, model, screenshotBase64, eleme
     catch (err) {
         if (err instanceof Error && err.name === 'AbortError') {
             const elapsed = Math.round((Date.now() - startTime) / 1000);
-            if (abortReason === 'screen_change') {
-                // The page changed while we were waiting: the answer is already stale.
-                // Signal the caller to re-analyze right away (no backoff).
-                console.log(`[browse] LLM aborted at ${elapsed}s — screen changed, re-analyzing now`);
-                return { actions: [], attempt, durationMs: Date.now() - startTime, error: 'screen_changed' };
+            if (abortReason === 'screen_change' || abortReason === 'tab_switch') {
+                // The page changed (or a new tab became active) while we were waiting:
+                // the answer is already stale. Signal the caller to re-analyze the
+                // active tab right away (no backoff).
+                console.log(abortReason === 'tab_switch'
+                    ? `[browse] LLM aborted at ${elapsed}s — active tab changed, re-analyzing now`
+                    : `[browse] LLM aborted at ${elapsed}s — screen changed, re-analyzing now`);
+                return {
+                    actions: [],
+                    attempt,
+                    durationMs: Date.now() - startTime,
+                    error: abortReason === 'tab_switch' ? 'tab_switch' : 'screen_changed',
+                };
             }
             console.error(`[browse] LLM request timed out (${Math.round(timeoutMs / 1000)}s)`);
             return { actions: [], attempt, durationMs: Date.now() - startTime, error: 'timeout' };
@@ -3564,6 +3630,12 @@ async function analyzeScreenshotWithPrompt(baseUrl, apiKey, model, screenshotBas
     // wipes it) must also abort - check `_cdpNavigated` too, as in the main call.
     const heartbeat = setInterval(async () => {
         const elapsed = Math.round((Date.now() - startTime) / 1000);
+        if (page?._tabSwitchedAt && page._tabSwitchedAt > startTime) {
+            console.log(`[browse] Active tab switched in opt pass (${elapsed}s) — aborting`);
+            optAbortReason = 'screen_change';
+            controller.abort();
+            return;
+        }
         if (page?._cdpNavigated && page._cdpNavigated > startTime) {
             console.log(`[browse] CDP navigation detected in opt pass (${elapsed}s) — aborting`);
             optAbortReason = 'screen_change';