chore: list extension pages

nroscino · nroscino · commit 3539a8083f67 · 2026-02-27T19:32:07.000+01:00
diff --git a/src/McpContext.ts b/src/McpContext.ts
@@ -109,6 +109,7 @@ export class McpContext implements Context {
     null;
 
   #nextPageId = 1;
+  #extensionPopupPages = new WeakMap<Target, Page>();
 
   #extensionServiceWorkerMap = new WeakMap<Target, string>();
   #nextExtensionServiceWorkerId = 1;
@@ -558,6 +559,32 @@ export class McpContext implements Context {
   async createPagesSnapshot(): Promise<Page[]> {
     const {pages: allPages, isolatedContextNames} = await this.#getAllPages();
 
+    const allTargets = await this.browser.targets();
+    const extensionTargets = allTargets.filter(target => {
+      return (
+        target.url().startsWith('chrome-extension://') &&
+        (target.type() === 'page' || target.type() === 'other')
+      );
+    });
+
+    for (const target of extensionTargets) {
+      let page = await target.page();
+      if (!page) {
+        page = this.#extensionPopupPages.get(target) ?? null;
+        if (!page) {
+          try {
+            page = await target.asPage();
+            this.#extensionPopupPages.set(target, page);
+          } catch (e) {
+            this.logger('Failed to get page for extension target', e);
+          }
+        }
+      }
+      if (page && !allPages.includes(page)) {
+        allPages.push(page);
+      }
+    }
+
     for (const page of allPages) {
       let mcpPage = this.#mcpPages.get(page);
       if (!mcpPage) {
diff --git a/src/McpResponse.ts b/src/McpResponse.ts
@@ -42,6 +42,7 @@ interface TraceInsightData {
 export class McpResponse implements Response {
   #includePages = false;
   #includeExtensionServiceWorkers = false;
+  #includeExtensionPages = false;
   #snapshotParams?: SnapshotParams;
   #attachedNetworkRequestId?: number;
   #attachedNetworkRequestOptions?: {
@@ -94,6 +95,7 @@ export class McpResponse implements Response {
 
     if (this.#args.categoryExtensions) {
       this.#includeExtensionServiceWorkers = value;
+      this.#includeExtensionPages = value;
     }
   }
 
@@ -501,6 +503,7 @@ export class McpResponse implements Response {
       pages?: object[];
       pagination?: object;
       extensionServiceWorkers?: object[];
+      extensionPages?: object[];
     } = {};
 
     const response = [`# ${toolName} response`];
@@ -564,38 +567,66 @@ Call ${handleDialog.name} to handle it before continuing.`);
     }
 
     if (this.#includePages) {
-      const parts = [`## Pages`];
-      for (const page of context.getPages()) {
-        const isolatedContextName = context.getIsolatedContextName(page);
-        const contextLabel = isolatedContextName
-          ? ` isolatedContext=${isolatedContextName}`
-          : '';
-        parts.push(
-          `${context.getPageId(page)}: ${page.url()}${context.isPageSelected(page) ? ' [selected]' : ''}${contextLabel}`,
-        );
+      const allPages = context.getPages();
+      const regularPages = this.#includeExtensionPages
+        ? allPages.filter(p => !p.url().startsWith('chrome-extension://'))
+        : allPages;
+
+      if (regularPages.length) {
+        const parts = [`## Pages`];
+        for (const page of regularPages) {
+          const isolatedContextName = context.getIsolatedContextName(page);
+          const contextLabel = isolatedContextName
+            ? ` isolatedContext=${isolatedContextName}`
+            : '';
+          parts.push(
+            `${context.getPageId(page)}: ${page.url()}${context.isPageSelected(page) ? ' [selected]' : ''}${contextLabel}`,
+          );
+        }
+        response.push(...parts);
+        structuredContent.pages = regularPages.map(page => {
+          const isolatedContextName = context.getIsolatedContextName(page);
+          const entry: {
+            id: number | undefined;
+            url: string;
+            selected: boolean;
+            isolatedContext?: string;
+          } = {
+            id: context.getPageId(page),
+            url: page.url(),
+            selected: context.isPageSelected(page),
+          };
+          if (isolatedContextName) {
+            entry.isolatedContext = isolatedContextName;
+          }
+          return entry;
+        });
       }
-      response.push(...parts);
-      structuredContent.pages = context.getPages().map(page => {
-        const isolatedContextName = context.getIsolatedContextName(page);
-        const entry: {
-          id: number | undefined;
-          url: string;
-          selected: boolean;
-          isolatedContext?: string;
-        } = {
-          id: context.getPageId(page),
-          url: page.url(),
-          selected: context.isPageSelected(page),
-        };
-        if (isolatedContextName) {
-          entry.isolatedContext = isolatedContextName;
+
+      if (this.#includeExtensionPages) {
+        const extensionPages = allPages.filter(p =>
+          p.url().startsWith('chrome-extension://'),
+        );
+        if (extensionPages.length) {
+          response.push(`## Extension Pages`);
+          for (const page of extensionPages) {
+            response.push(
+              `${context.getPageId(page)}: ${page.url()}${context.isPageSelected(page) ? ' [selected]' : ''}`,
+            );
+          }
+          structuredContent.extensionPages = extensionPages.map(page => {
+            return {
+              id: context.getPageId(page),
+              url: page.url(),
+              selected: context.isPageSelected(page),
+            };
+          });
         }
-        return entry;
-      });
+      }
     }
 
     if (this.#includeExtensionServiceWorkers) {
-      if (!context.getExtensionServiceWorkers().length) {
+      if (context.getExtensionServiceWorkers().length) {
         response.push(`## Extension Service Workers`);
       }
 
diff --git a/src/browser.ts b/src/browser.ts
@@ -20,12 +20,11 @@ import {puppeteer} from './third_party/index.js';
 
 let browser: Browser | undefined;
 
-function makeTargetFilter() {
-  const ignoredPrefixes = new Set([
-    'chrome://',
-    'chrome-extension://',
-    'chrome-untrusted://',
-  ]);
+function makeTargetFilter(enableExtensions = false) {
+  const ignoredPrefixes = new Set(['chrome://', 'chrome-untrusted://']);
+  if (!enableExtensions) {
+    ignoredPrefixes.add('chrome-extension://');
+  }
 
   return function targetFilter(target: Target): boolean {
     if (target.url() === 'chrome://newtab/') {
@@ -51,14 +50,15 @@ export async function ensureBrowserConnected(options: {
   devtools: boolean;
   channel?: Channel;
   userDataDir?: string;
+  enableExtensions?: boolean;
 }) {
-  const {channel} = options;
+  const {channel, enableExtensions} = options;
   if (browser?.connected) {
     return browser;
   }
 
   const connectOptions: Parameters<typeof puppeteer.connect>[0] = {
-    targetFilter: makeTargetFilter(),
+    targetFilter: makeTargetFilter(enableExtensions),
     defaultViewport: null,
     handleDevToolsAsPage: true,
   };
@@ -215,7 +215,7 @@ export async function launch(options: McpLaunchOptions): Promise<Browser> {
   try {
     const browser = await puppeteer.launch({
       channel: puppeteerChannel,
-      targetFilter: makeTargetFilter(),
+      targetFilter: makeTargetFilter(options.enableExtensions),
       executablePath,
       defaultViewport: null,
       userDataDir,
diff --git a/src/server.ts b/src/server.ts
@@ -79,6 +79,7 @@ export async function createMcpServer(
               : undefined,
             userDataDir: serverArgs.userDataDir,
             devtools,
+            enableExtensions: serverArgs.categoryExtensions,
           })
         : await ensureBrowserLaunched({
             headless: serverArgs.headless,
diff --git a/tests/tools/pages.test.ts b/tests/tools/pages.test.ts
@@ -12,7 +12,10 @@ import type {Dialog} from 'puppeteer-core';
 import sinon from 'sinon';
 
 import type {ParsedArguments} from '../../src/cli.js';
-import {installExtension} from '../../src/tools/extensions.js';
+import {
+  installExtension,
+  triggerExtensionAction,
+} from '../../src/tools/extensions.js';
 import {
   listPages,
   newPage,
@@ -25,6 +28,8 @@ import {
 } from '../../src/tools/pages.js';
 import {html, withMcpContext} from '../utils.js';
 
+import {extractId} from './extensions.test.js';
+
 const EXTENSION_PATH = path.join(
   import.meta.dirname,
   '../../../tests/tools/fixtures/extension-sw',
@@ -46,8 +51,61 @@ describe('pages', () => {
         assert.ok(response.includePages);
       });
     });
+    it(`list pages for extension pages with --category-extensions`, async () => {
+      await withMcpContext(
+        async (response, context) => {
+          await installExtension.handler(
+            {params: {path: EXTENSION_PATH}},
+            response,
+            context,
+          );
+
+          const extensionId = extractId(response);
+          assert.ok(extensionId);
+
+          await triggerExtensionAction.handler(
+            {params: {id: extensionId}},
+            response,
+            context,
+          );
+          const popupTarget = await context.browser.waitForTarget(
+            t => t.type() === 'page' && t.url().includes('chrome-extension://'),
+          );
+
+          response.resetResponseLineForTesting();
+
+          const listPageDef = listPages({
+            categoryExtensions: true,
+          } as ParsedArguments);
+          await listPageDef.handler(
+            {params: {}, page: context.getSelectedMcpPage()},
+            response,
+            context,
+          );
+
+          const result = await response.handle(listPageDef.name, context);
+          const textContent = result.content.find(c => c.type === 'text') as {
+            type: 'text';
+            text: string;
+          };
+          assert.ok(textContent);
+
+          assert.ok(textContent.text.includes(popupTarget.url()));
+        },
+        {
+          channel: process.env.CANARY_EXECUTABLE_PATH
+            ? undefined
+            : 'chrome-canary',
+          executablePath: process.env.CANARY_EXECUTABLE_PATH,
+        },
+        {
+          categoryExtensions: true,
+        } as ParsedArguments,
+      );
+    });
+
     for (const categoryExtensions of [true, false]) {
-      it(`list pages ${categoryExtensions ? 'with' : 'without'} --category-extensions`, async () => {
+      it(`list pages for extension service workers ${categoryExtensions ? 'with' : 'without'} --category-extensions`, async () => {
         await withMcpContext(
           async (response, context) => {
             await installExtension.handler(
