fix: tolerate unresponsive tabs when connecting to existing browser

When connecting to a running browser via --browserUrl, browser.pages()
hangs indefinitely if any tab is unresponsive (discarded by memory
management, dead localhost, etc). This blocks all tool calls since page
enumeration runs on every request.

Two changes:

1. Add protocolTimeout (15s) to puppeteer.connect() so CDP commands
   fail with an error instead of hanging forever.

2. Wrap browser.pages() in #getAllPages() with a 10s timeout. If it
   fails, fall back to per-target enumeration: iterate browser.targets(),
   call target.page() on each with a 5s timeout, and skip tabs that
   don't respond. This way one unresponsive tab doesn't block the
   entire server.

Tested with Chrome/Brave 145, 28 open tabs (5 discarded). Without this
fix the server hangs forever on the first tool call. With the fix it
returns 23 responsive pages in ~12s and logs the 5 it skipped.

Related: puppeteer/puppeteer#5633, puppeteer/puppeteer#14708, #870, #978

Author: jaidhyani

src/McpContext.ts

@@ -562,9 +562,47 @@ export class McpContext implements Context {
     isolatedContextNames: Map<Page, string>;
   }> {
     const defaultCtx = this.browser.defaultBrowserContext();
-    const allPages = await this.browser.pages(
-      this.#options.experimentalIncludeAllPages,
-    );
+
+    // Tolerant page enumeration: browser.pages() hangs indefinitely when
+    // any tab is unresponsive (e.g. discarded/sleeping tabs). Fall back to
+    // per-target enumeration so that one bad tab doesn't block the server.
+    let allPages: Page[];
+    try {
+      allPages = await Promise.race([
+        this.browser.pages(this.#options.experimentalIncludeAllPages),
+        new Promise<never>((_, reject) =>
+          setTimeout(
+            () => reject(new Error('browser.pages() timed out')),
+            10_000,
+          ),
+        ),
+      ]);
+    } catch {
+      this.logger(
+        'browser.pages() timed out — falling back to per-target enumeration',
+      );
+      const pageTargets = this.browser
+        .targets()
+        .filter(t => t.type() === 'page');
+      allPages = [];
+      await Promise.all(
+        pageTargets.map(async target => {
+          try {
+            const page = await Promise.race([
+              target.page(),
+              new Promise<never>((_, reject) =>
+                setTimeout(() => reject(new Error('timeout')), 5_000),
+              ),
+            ]);
+            if (page) {
+              allPages.push(page);
+            }
+          } catch {
+            this.logger(`Skipping unresponsive tab: ${target.url()}`);
+          }
+        }),
+      );
+    }
 
     const allTargets = this.browser.targets();
     const extensionTargets = allTargets.filter(target => {

src/browser.ts

@@ -61,6 +61,7 @@ export async function ensureBrowserConnected(options: {
     targetFilter: makeTargetFilter(enableExtensions),
     defaultViewport: null,
     handleDevToolsAsPage: true,
+    protocolTimeout: 15_000,
   };
 
   let autoConnect = false;