Implement install_extension command

Author: Natallia Harshunova

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/cli.ts

@@ -198,6 +198,12 @@ export const cliOptions = {
     default: true,
     describe: 'Set to false to exclude tools related to network.',
   },
+  categoryExtension: {
+    type: 'boolean',
+    default: true,
+    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.
@@ -261,6 +267,7 @@ export function parseArguments(version: string, argv = process.argv) {
         'Disable tools in the performance category',
       ],
       ['$0 --no-category-network', 'Disable tools in the network category'],
+      ['$0 --no-category-extension', 'Disable tools in the extension category'],
       [
         '$0 --user-data-dir=/tmp/user-data-dir',
         'Use a custom user data directory',

src/main.ts

@@ -64,34 +64,37 @@ async function getContext(): Promise<McpContext> {
   const ignoreDefaultChromeArgs: string[] = (
     args.ignoreDefaultChromeArg ?? []
   ).map(String);
+  if (args.categoryExtension) {
+    chromeArgs.push('--enable-unsafe-extension-debugging');
+  }
   if (args.proxyServer) {
     chromeArgs.push(`--proxy-server=${args.proxyServer}`);
   }
   const devtools = args.experimentalDevtools ?? false;
   const browser =
     args.browserUrl || args.wsEndpoint || args.autoConnect
       ? await ensureBrowserConnected({
-          browserURL: args.browserUrl,
-          wsEndpoint: args.wsEndpoint,
-          wsHeaders: args.wsHeaders,
-          // Important: only pass channel, if autoConnect is true.
-          channel: args.autoConnect ? (args.channel as Channel) : undefined,
-          userDataDir: args.userDataDir,
-          devtools,
-        })
+        browserURL: args.browserUrl,
+        wsEndpoint: args.wsEndpoint,
+        wsHeaders: args.wsHeaders,
+        // Important: only pass channel, if autoConnect is true.
+        channel: args.autoConnect ? (args.channel as Channel) : undefined,
+        userDataDir: args.userDataDir,
+        devtools,
+      })
       : await ensureBrowserLaunched({
-          headless: args.headless,
-          executablePath: args.executablePath,
-          channel: args.channel as Channel,
-          isolated: args.isolated ?? false,
-          userDataDir: args.userDataDir,
-          logFile,
-          viewport: args.viewport,
-          chromeArgs,
-          ignoreDefaultChromeArgs,
-          acceptInsecureCerts: args.acceptInsecureCerts,
-          devtools,
-        });
+        headless: args.headless,
+        executablePath: args.executablePath,
+        channel: args.channel as Channel,
+        isolated: args.isolated ?? false,
+        userDataDir: args.userDataDir,
+        logFile,
+        viewport: args.viewport,
+        chromeArgs,
+        ignoreDefaultChromeArgs,
+        acceptInsecureCerts: args.acceptInsecureCerts,
+        devtools,
+      });
 
   if (context?.browser !== browser) {
     context = await McpContext.from(browser, logger, {
@@ -139,6 +142,12 @@ function registerTool(tool: ToolDefinition): void {
   ) {
     return;
   }
+  if (
+    tool.annotations.category === ToolCategory.EXTENSION &&
+    args.categoryExtension === 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',
+  EXTENSION = 'extension',
 }
 
 export const labels = {
@@ -20,4 +21,5 @@ export const labels = {
   [ToolCategory.PERFORMANCE]: 'Performance',
   [ToolCategory.NETWORK]: 'Network',
   [ToolCategory.DEBUGGING]: 'Debugging',
+  [ToolCategory.EXTENSION]: 'Extensions',
 };

src/tools/extension.ts

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { logger } from '../logger.js';
+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.EXTENSION,
+    readOnlyHint: false,
+  },
+  schema: {
+    path: zod
+      .string()
+      .describe('Absolute path to the unpacked extension folder.'),
+  },
+  handler: async (request, response, context) => {
+    const { path } = request.params;
+    try {
+      const id = await context.installExtension(path);
+      response.appendResponseLine(`Extension installed: ${id}`);
+    } catch (error) {
+      logger('Extension installation error: ', error);
+      throw error;
+    }
+  },
+});

src/tools/tools.ts

@@ -5,6 +5,7 @@
  */
 import * as consoleTools from './console.js';
 import * as emulationTools from './emulation.js';
+import * as extensionTools from './extension.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),