chore: Implement install_extension command

scripts/generate-docs.ts

@@ -278,9 +278,15 @@ async function generateToolDocumentation(): Promise<void> {
     // Convert ToolDefinitions to ToolWithAnnotations
     const toolsWithAnnotations: ToolWithAnnotations[] = tools
       .filter(tool => {
+        // Filter out extension tools
+        if (tool.name === 'install_extension') {
+          return false;
+        }
+
         if (!tool.annotations.conditions) {
           return true;
         }
+
         // Only include unconditional tools.
         return tool.annotations.conditions.length === 0;
       })

src/McpContext.ts

@@ -690,4 +690,8 @@ export class McpContext implements Context {
     });
     await this.#networkCollector.init(await this.browser.pages());
   }
+
+  async installExtension(path: string): Promise<string> {
+    return this.browser.installExtension(path);
+  }
 }

src/browser.ts

@@ -145,6 +145,7 @@ interface McpLaunchOptions {
   chromeArgs?: string[];
   ignoreDefaultChromeArgs?: string[];
   devtools: boolean;
+  enableExtensions?: boolean;
 }
 
 export async function launch(options: McpLaunchOptions): Promise<Browser> {
@@ -201,6 +202,7 @@ export async function launch(options: McpLaunchOptions): Promise<Browser> {
       ignoreDefaultArgs: ignoreDefaultArgs,
       acceptInsecureCerts: options.acceptInsecureCerts,
       handleDevToolsAsPage: true,
+      enableExtensions: options.enableExtensions,
     });
     if (options.logFile) {
       // FIXME: we are probably subscribing too late to catch startup logs. We

src/cli.ts

@@ -198,6 +198,12 @@ export const cliOptions = {
     default: true,
     describe: 'Set to false to exclude tools related to network.',
   },
+  categoryExtensions: {
+    type: 'boolean',
+    default: false,
+    hidden: true,
+    describe: 'Set to false to exclude tools related to extensions.',
+  },
   usageStatistics: {
     type: 'boolean',
     // Marked as `false` until the feature is ready to be enabled by default.

src/main.ts

@@ -91,6 +91,7 @@ async function getContext(): Promise<McpContext> {
           ignoreDefaultChromeArgs,
           acceptInsecureCerts: args.acceptInsecureCerts,
           devtools,
+          enableExtensions: args.categoryExtensions,
         });
 
   if (context?.browser !== browser) {
@@ -139,6 +140,12 @@ function registerTool(tool: ToolDefinition): void {
   ) {
     return;
   }
+  if (
+    tool.annotations.category === ToolCategory.EXTENSIONS &&
+    args.categoryExtensions === false
+  ) {
+    return;
+  }
   if (
     tool.annotations.conditions?.includes('computerVision') &&
     !args.experimentalVision

src/tools/ToolDefinition.ts

@@ -121,6 +121,7 @@ export type Context = Readonly<{
    * Returns a reqid for a cdpRequestId.
    */
   resolveCdpElementId(cdpBackendNodeId: number): string | undefined;
+  installExtension(path: string): Promise<string>;
 }>;
 
 export function defineTool<Schema extends zod.ZodRawShape>(

src/tools/categories.ts

@@ -11,6 +11,7 @@ export enum ToolCategory {
   PERFORMANCE = 'performance',
   NETWORK = 'network',
   DEBUGGING = 'debugging',
+  EXTENSIONS = 'extensions',
 }
 
 export const labels = {
@@ -20,4 +21,5 @@ export const labels = {
   [ToolCategory.PERFORMANCE]: 'Performance',
   [ToolCategory.NETWORK]: 'Network',
   [ToolCategory.DEBUGGING]: 'Debugging',
+  [ToolCategory.EXTENSIONS]: 'Extensions',
 };

src/tools/extensions.ts

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {zod} from '../third_party/index.js';
+
+import {ToolCategory} from './categories.js';
+import {defineTool} from './ToolDefinition.js';
+
+export const installExtension = defineTool({
+  name: 'install_extension',
+  description: 'Installs a Chrome extension from the given path.',
+  annotations: {
+    category: ToolCategory.EXTENSIONS,
+    readOnlyHint: false,
+  },
+  schema: {
+    path: zod
+      .string()
+      .describe('Absolute path to the unpacked extension folder.'),
+  },
+  handler: async (request, response, context) => {
+    const {path} = request.params;
+    const id = await context.installExtension(path);
+    response.appendResponseLine(`Extension installed. Id: ${id}`);
+  },
+});

src/tools/tools.ts

@@ -5,6 +5,7 @@
  */
 import * as consoleTools from './console.js';
 import * as emulationTools from './emulation.js';
+import * as extensionTools from './extensions.js';
 import * as inputTools from './input.js';
 import * as networkTools from './network.js';
 import * as pagesTools from './pages.js';
@@ -17,6 +18,7 @@ import type {ToolDefinition} from './ToolDefinition.js';
 const tools = [
   ...Object.values(consoleTools),
   ...Object.values(emulationTools),
+  ...Object.values(extensionTools),
   ...Object.values(inputTools),
   ...Object.values(networkTools),
   ...Object.values(pagesTools),

tests/cli.test.ts

@@ -15,6 +15,8 @@ describe('cli args parsing', () => {
     categoryEmulation: true,
     'category-performance': true,
     categoryPerformance: true,
+    'category-extensions': false,
+    categoryExtensions: false,
     'category-network': true,
     categoryNetwork: true,
     'auto-connect': undefined,

tests/index.test.ts

@@ -108,6 +108,9 @@ describe('e2e', () => {
             ) {
               continue;
             }
+            if (maybeTool.name === 'install_extension') {
+              continue;
+            }
             definedNames.push(maybeTool.name);
           }
         }
@@ -117,6 +120,17 @@ describe('e2e', () => {
     });
   });
 
+  it('has experimental extensions tools', async () => {
+    await withClient(
+      async client => {
+        const {tools} = await client.listTools();
+        const clickAt = tools.find(t => t.name === 'install_extension');
+        assert.ok(clickAt);
+      },
+      ['--category-extensions'],
+    );
+  });
+
   it('has experimental vision tools', async () => {
     await withClient(
       async client => {

tests/tools/extensions.test.ts

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import assert from 'node:assert';
+import path from 'node:path';
+import {describe, it} from 'node:test';
+
+import {installExtension} from '../../src/tools/extensions.js';
+import {withMcpContext} from '../utils.js';
+
+const EXTENSION_PATH = path.join(
+  import.meta.dirname,
+  '../../../tests/tools/fixtures/extension',
+);
+
+describe('extension', () => {
+  it('installs an extension and verifies it is listed in chrome://extensions', async () => {
+    await withMcpContext(async (response, context) => {
+      await installExtension.handler(
+        {params: {path: EXTENSION_PATH}},
+        response,
+        context,
+      );
+
+      const responseLine = response.responseLines[0];
+      assert.ok(responseLine, 'Response should not be empty');
+      const match = responseLine.match(/Extension installed\. Id: (.+)/);
+      const extensionId = match ? match[1] : null;
+      assert.ok(extensionId, 'Response should contain a valid key');
+
+      const page = context.getSelectedPage();
+      await page.goto('chrome://extensions');
+
+      const element = await page.waitForSelector(
+        `extensions-manager >>> extensions-item[id="${extensionId}"]`,
+      );
+      assert.ok(
+        element,
+        `Extension with ID "${extensionId}" should be visible on chrome://extensions`,
+      );
+    });
+  });
+});

tests/tools/fixtures/extension/manifest.json

@@ -0,0 +1,8 @@
+{
+  "manifest_version": 3,
+  "name": "Test Extension",
+  "version": "1.0",
+  "action": {
+    "default_popup": "popup.html"
+  }
+}

tests/tools/fixtures/extension/popup.html

@@ -0,0 +1,6 @@
+<!doctype html>
+<html>
+  <body>
+    <h1>Test Popup</h1>
+  </body>
+</html>

tests/utils.ts

@@ -56,6 +56,7 @@ export async function withBrowser(
     pipe: true,
     handleDevToolsAsPage: true,
     args: ['--screen-info={3840x2160}'],
+    enableExtensions: true,
   };
   const key = JSON.stringify(launchOptions);