fix: enable extensions when connecting to existing Chrome

Author: luisnomad

README.md

@@ -625,6 +625,9 @@ In these cases, start Chrome first and let the Chrome DevTools MCP server connec
 - **Automatic connection (available in Chrome 144)**: best for sharing state between manual and agent-driven testing.
 - **Manual connection via remote debugging port**: best when running inside a sandboxed environment.
 
+> [!NOTE]
+> To include extension pages and extension service workers while connecting to an existing Chrome instance, add `--category-extensions`. This applies to `--autoConnect`, `--browserUrl`, and `--wsEndpoint`.
+
 #### Automatically connecting to a running Chrome instance
 
 **Step 1:** Set up remote debugging in Chrome

src/index.ts

@@ -28,8 +28,65 @@ import {pageIdSchema} from './tools/ToolDefinition.js';
 import {createTools} from './tools/tools.js';
 import {VERSION} from './version.js';
 
+type ServerArgs = ReturnType<typeof parseArguments>;
+
+interface BrowserResolvers {
+  ensureBrowserConnected: typeof ensureBrowserConnected;
+  ensureBrowserLaunched: typeof ensureBrowserLaunched;
+}
+
+export async function resolveBrowser(
+  serverArgs: ServerArgs,
+  options: {
+    logFile?: fs.WriteStream;
+  },
+  resolvers: BrowserResolvers = {
+    ensureBrowserConnected,
+    ensureBrowserLaunched,
+  },
+) {
+  const chromeArgs: string[] = (serverArgs.chromeArg ?? []).map(String);
+  const ignoreDefaultChromeArgs: string[] = (
+    serverArgs.ignoreDefaultChromeArg ?? []
+  ).map(String);
+  if (serverArgs.proxyServer) {
+    chromeArgs.push(`--proxy-server=${serverArgs.proxyServer}`);
+  }
+  const devtools = serverArgs.experimentalDevtools ?? false;
+  return serverArgs.browserUrl ||
+    serverArgs.wsEndpoint ||
+    serverArgs.autoConnect
+    ? await resolvers.ensureBrowserConnected({
+        browserURL: serverArgs.browserUrl,
+        wsEndpoint: serverArgs.wsEndpoint,
+        wsHeaders: serverArgs.wsHeaders,
+        // Important: only pass channel, if autoConnect is true.
+        channel: serverArgs.autoConnect
+          ? (serverArgs.channel as Channel)
+          : undefined,
+        userDataDir: serverArgs.userDataDir,
+        devtools,
+        enableExtensions: serverArgs.categoryExtensions,
+      })
+    : await resolvers.ensureBrowserLaunched({
+        headless: serverArgs.headless,
+        executablePath: serverArgs.executablePath,
+        channel: serverArgs.channel as Channel,
+        isolated: serverArgs.isolated ?? false,
+        userDataDir: serverArgs.userDataDir,
+        logFile: options.logFile,
+        viewport: serverArgs.viewport,
+        chromeArgs,
+        ignoreDefaultChromeArgs,
+        acceptInsecureCerts: serverArgs.acceptInsecureCerts,
+        devtools,
+        enableExtensions: serverArgs.categoryExtensions,
+        viaCli: serverArgs.viaCli,
+      });
+}
+
 export async function createMcpServer(
-  serverArgs: ReturnType<typeof parseArguments>,
+  serverArgs: ServerArgs,
   options: {
     logFile?: fs.WriteStream;
   },
@@ -59,42 +116,8 @@ export async function createMcpServer(
 
   let context: McpContext;
   async function getContext(): Promise<McpContext> {
-    const chromeArgs: string[] = (serverArgs.chromeArg ?? []).map(String);
-    const ignoreDefaultChromeArgs: string[] = (
-      serverArgs.ignoreDefaultChromeArg ?? []
-    ).map(String);
-    if (serverArgs.proxyServer) {
-      chromeArgs.push(`--proxy-server=${serverArgs.proxyServer}`);
-    }
     const devtools = serverArgs.experimentalDevtools ?? false;
-    const browser =
-      serverArgs.browserUrl || serverArgs.wsEndpoint || serverArgs.autoConnect
-        ? await ensureBrowserConnected({
-            browserURL: serverArgs.browserUrl,
-            wsEndpoint: serverArgs.wsEndpoint,
-            wsHeaders: serverArgs.wsHeaders,
-            // Important: only pass channel, if autoConnect is true.
-            channel: serverArgs.autoConnect
-              ? (serverArgs.channel as Channel)
-              : undefined,
-            userDataDir: serverArgs.userDataDir,
-            devtools,
-          })
-        : await ensureBrowserLaunched({
-            headless: serverArgs.headless,
-            executablePath: serverArgs.executablePath,
-            channel: serverArgs.channel as Channel,
-            isolated: serverArgs.isolated ?? false,
-            userDataDir: serverArgs.userDataDir,
-            logFile: options.logFile,
-            viewport: serverArgs.viewport,
-            chromeArgs,
-            ignoreDefaultChromeArgs,
-            acceptInsecureCerts: serverArgs.acceptInsecureCerts,
-            devtools,
-            enableExtensions: serverArgs.categoryExtensions,
-            viaCli: serverArgs.viaCli,
-          });
+    const browser = await resolveBrowser(serverArgs, options);
 
     if (context?.browser !== browser) {
       context = await McpContext.from(browser, logger, {

tests/resolveBrowser.test.ts

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import assert from 'node:assert';
+import {describe, it} from 'node:test';
+
+import {parseArguments} from '../src/bin/chrome-devtools-mcp-cli-options.js';
+import {resolveBrowser} from '../src/index.js';
+import type {Browser} from '../src/third_party/index.js';
+
+describe('resolveBrowser', () => {
+  for (const [label, args] of [
+    [
+      'browserUrl',
+      ['--browser-url', 'http://127.0.0.1:9222', '--category-extensions'],
+    ],
+    [
+      'wsEndpoint',
+      [
+        '--ws-endpoint',
+        'ws://127.0.0.1:9222/devtools/browser/test',
+        '--category-extensions',
+      ],
+    ],
+    [
+      'autoConnect',
+      [
+        '--auto-connect',
+        '--user-data-dir',
+        '/tmp/profile',
+        '--category-extensions',
+      ],
+    ],
+  ] as const) {
+    it(`passes enableExtensions on the connected-browser path via ${label}`, async () => {
+      const serverArgs = parseArguments('0.0.0', [
+        'node',
+        'chrome-devtools-mcp',
+        ...args,
+      ]);
+      const browser = {} as Browser;
+      const connectedCalls: Array<Record<string, unknown>> = [];
+      let launchedCallCount = 0;
+
+      const resolvedBrowser = await resolveBrowser(
+        serverArgs,
+        {},
+        {
+          ensureBrowserConnected: async options => {
+            connectedCalls.push(options as Record<string, unknown>);
+            return browser;
+          },
+          ensureBrowserLaunched: async () => {
+            launchedCallCount += 1;
+            return browser;
+          },
+        },
+      );
+
+      assert.strictEqual(resolvedBrowser, browser);
+      assert.strictEqual(launchedCallCount, 0);
+      assert.strictEqual(connectedCalls.length, 1);
+      assert.strictEqual(connectedCalls[0]?.['enableExtensions'], true);
+    });
+  }
+});