fix: skip frozen/discarded targets in page enumeration

Author: 20syldev

src/McpContext.ts

@@ -562,11 +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,
-    );
 
+    // Enumerate targets individually instead of calling browser.pages() so
+    // that a single frozen/discarded background tab that times out on
+    // Network.enable cannot abort the entire page enumeration (see #1230).
     const allTargets = this.browser.targets();
+    const pageTargets = allTargets.filter(target => {
+      const type = target.type();
+      if (type === 'page') return true;
+      if (this.#options.experimentalIncludeAllPages) {
+        return type === 'background_page' || type === 'webview';
+      }
+      return false;
+    });
+    const pageResults = await Promise.all(
+      pageTargets.map(async target => {
+        try {
+          const page = await Promise.race([
+            target.page(),
+            new Promise<null>(resolve =>
+              setTimeout(() => resolve(null), DEFAULT_TIMEOUT),
+            ),
+          ]);
+          if (!page) {
+            this.logger(
+              'Timed out attaching to target at',
+              target.url(),
+              '— likely frozen or discarded',
+            );
+          }
+          return page;
+        } catch (err) {
+          this.logger(
+            'Skipping frozen/discarded target at',
+            target.url(),
+            err,
+          );
+          return null;
+        }
+      }),
+    );
+    const allPages = pageResults.filter((p): p is Page => p !== null);
     const extensionTargets = allTargets.filter(target => {
       return (
         target.url().startsWith('chrome-extension://') &&
@@ -576,7 +612,12 @@ export class McpContext implements Context {
 
     for (const target of extensionTargets) {
       // Right now target.page() returns null for popup and side panel pages.
-      let page = await target.page();
+      let page = await Promise.race([
+        target.page(),
+        new Promise<null>(resolve =>
+          setTimeout(() => resolve(null), DEFAULT_TIMEOUT),
+        ),
+      ]);
       if (!page) {
         // We need to cache pages instances for targets because target.asPage()
         // returns a new page instance every time.

tests/McpContext.test.ts

@@ -7,6 +7,7 @@
 import assert from 'node:assert';
 import {afterEach, describe, it} from 'node:test';
 
+import type {Target} from 'puppeteer-core';
 import sinon from 'sinon';
 
 import {NetworkFormatter} from '../src/formatters/NetworkFormatter.js';
@@ -208,4 +209,29 @@ describe('McpContext', () => {
       fromStub.restore();
     });
   });
+
+  it('should skip frozen targets that hang on target.page()', async () => {
+    await withMcpContext(async (_response, context) => {
+      const browser = context.browser;
+      const realTargets = browser.targets();
+
+      // Inject a fake target whose page() never resolves (simulates a frozen tab).
+      const frozenTarget = {
+        type: () => 'page',
+        url: () => 'https://frozen-tab.example.com',
+        page: () => new Promise<null>(() => {}),
+      } as unknown as Target;
+
+      sinon.stub(browser, 'targets').returns([...realTargets, frozenTarget]);
+
+      const start = Date.now();
+      const pages = await context.createPagesSnapshot();
+      const elapsed = Date.now() - start;
+
+      // The frozen target should be skipped, not block for 180s.
+      assert.ok(elapsed < 15_000, `Took ${elapsed}ms, expected < 15s`);
+      // Real pages should still be enumerated.
+      assert.ok(pages.length > 0, 'Should still enumerate healthy pages');
+    });
+  });
 });