Implement install_extension command

Natallia Harshunova · Natallia Harshunova · commit aa0875892077 · 2026-01-16T11:21:52.000Z
Fix pr comments
diff --git a/README.md b/README.md
@@ -360,6 +360,8 @@ If you run into any issues, checkout our [troubleshooting guide](./docs/troubles
   - [`list_console_messages`](docs/tool-reference.md#list_console_messages)
   - [`take_screenshot`](docs/tool-reference.md#take_screenshot)
   - [`take_snapshot`](docs/tool-reference.md#take_snapshot)
+- **Extensions** (1 tools)
+  - [`install_extension`](docs/tool-reference.md#install_extension)
 
 <!-- END AUTO GENERATED TOOLS -->
 
diff --git a/docs/tool-reference.md b/docs/tool-reference.md
@@ -34,6 +34,8 @@
   - [`list_console_messages`](#list_console_messages)
   - [`take_screenshot`](#take_screenshot)
   - [`take_snapshot`](#take_snapshot)
+- **[Extensions](#extensions)** (1 tools)
+  - [`install_extension`](#install_extension)
 
 ## Input automation
 
@@ -345,3 +347,15 @@ in the DevTools Elements panel (if any).
 - **verbose** (boolean) _(optional)_: Whether to include all possible information available in the full a11y tree. Default is false.
 
 ---
+
+## Extensions
+
+### `install_extension`
+
+**Description:** Installs a Chrome extension from the given path.
+
+**Parameters:**
+
+- **path** (string) **(required)**: Absolute path to the unpacked extension folder.
+
+---
diff --git a/src/browser.ts b/src/browser.ts
@@ -201,6 +201,7 @@ export async function launch(options: McpLaunchOptions): Promise<Browser> {
       ignoreDefaultArgs: ignoreDefaultArgs,
       acceptInsecureCerts: options.acceptInsecureCerts,
       handleDevToolsAsPage: true,
+      enableExtensions: true,
     });
     if (options.logFile) {
       // FIXME: we are probably subscribing too late to catch startup logs. We
diff --git a/src/cli.ts b/src/cli.ts
@@ -198,9 +198,9 @@ export const cliOptions = {
     default: true,
     describe: 'Set to false to exclude tools related to network.',
   },
-  categoryExtension: {
+  categoryExtensions: {
     type: 'boolean',
-    default: true,
+    default: false,
     hidden: true,
     describe: 'Set to false to exclude tools related to extensions.',
   },
@@ -267,7 +267,6 @@ 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',
diff --git a/src/main.ts b/src/main.ts
@@ -64,37 +64,34 @@ 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, {
@@ -143,8 +140,8 @@ function registerTool(tool: ToolDefinition): void {
     return;
   }
   if (
-    tool.annotations.category === ToolCategory.EXTENSION &&
-    args.categoryExtension === false
+    tool.annotations.category === ToolCategory.EXTENSIONS &&
+    args.categoryExtensions === false
   ) {
     return;
   }
diff --git a/src/tools/categories.ts b/src/tools/categories.ts
@@ -11,7 +11,7 @@ export enum ToolCategory {
   PERFORMANCE = 'performance',
   NETWORK = 'network',
   DEBUGGING = 'debugging',
-  EXTENSION = 'extension',
+  EXTENSIONS = 'extensions',
 }
 
 export const labels = {
@@ -21,5 +21,5 @@ export const labels = {
   [ToolCategory.PERFORMANCE]: 'Performance',
   [ToolCategory.NETWORK]: 'Network',
   [ToolCategory.DEBUGGING]: 'Debugging',
-  [ToolCategory.EXTENSION]: 'Extensions',
+  [ToolCategory.EXTENSIONS]: 'Extensions',
 };
diff --git a/src/tools/extensions.ts b/src/tools/extensions.ts
@@ -4,17 +4,17 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { logger } from '../logger.js';
-import { zod } from '../third_party/index.js';
+import {logger} from '../logger.js';
+import {zod} from '../third_party/index.js';
 
-import { ToolCategory } from './categories.js';
-import { defineTool } from './ToolDefinition.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,
+    category: ToolCategory.EXTENSIONS,
     readOnlyHint: false,
   },
   schema: {
@@ -23,10 +23,10 @@ export const installExtension = defineTool({
       .describe('Absolute path to the unpacked extension folder.'),
   },
   handler: async (request, response, context) => {
-    const { path } = request.params;
+    const {path} = request.params;
     try {
       const id = await context.installExtension(path);
-      response.appendResponseLine(`Extension installed: ${id}`);
+      response.appendResponseLine(`Extension installed. Id: ${id}`);
     } catch (error) {
       logger('Extension installation error: ', error);
       throw error;
diff --git a/src/tools/tools.ts b/src/tools/tools.ts
@@ -5,7 +5,7 @@
  */
 import * as consoleTools from './console.js';
 import * as emulationTools from './emulation.js';
-import * as extensionTools from './extension.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';
diff --git a/tests/cli.test.ts b/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,
diff --git a/tests/index.test.ts b/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 => {
diff --git a/tests/tools/extension.test.ts b/tests/tools/extension.test.ts
@@ -0,0 +1,68 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import assert from 'node:assert';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {describe, it, after} from 'node:test';
+
+import {installExtension} from '../../src/tools/extensions.js';
+import {withMcpContext} from '../utils.js';
+
+describe('extension', () => {
+  let tmpDir: string;
+
+  it('installs an extension and verifies it is listed in chrome://extensions', async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'extension-test-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'manifest.json'),
+      JSON.stringify({
+        manifest_version: 3,
+        name: 'Test Extension',
+        version: '1.0',
+        action: {
+          default_popup: 'popup.html',
+        },
+      }),
+    );
+    fs.writeFileSync(
+      path.join(tmpDir, 'popup.html'),
+      '<!DOCTYPE html><html><body><h1>Test Popup</h1></body></html>',
+    );
+
+    await withMcpContext(async (response, context) => {
+      await installExtension.handler(
+        {params: {path: tmpDir}},
+        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`,
+      );
+    });
+  });
+
+  after(() => {
+    if (tmpDir) {
+      fs.rmSync(tmpDir, {recursive: true, force: true});
+    }
+  });
+});
diff --git a/tests/tools/extensions.test.ts b/tests/tools/extensions.test.ts
@@ -0,0 +1,69 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import assert from 'node:assert';
+import {describe, it} from 'node:test';
+
+import {installExtension} from '../../src/tools/extensions.js';
+import {withMcpContext} from '../utils.js';
+
+const EXTENSION_PATH = '/usr/local/google/home/nharshunova/test/extensions';
+const EXTENSION_ID = 'emhhlofcjnaambdnpppkpbcimdeaccnn';
+
+describe('extension', () => {
+  it('installs an extension and verifies it is listed in chrome://extensions', async () => {
+    await withMcpContext(async (response, context) => {
+      // 1. Install the extension
+      await installExtension.handler(
+        {params: {path: EXTENSION_PATH}},
+        response,
+        context,
+      );
+
+      // 2. Verify response
+      assert.ok(
+        response.responseLines[0]?.includes(EXTENSION_ID),
+        `Response should include extension ID ${EXTENSION_ID}`,
+      );
+
+      // 3. Verify extension is accessible by navigating to its popup
+      const page = context.getSelectedPage();
+      await page.goto(`chrome-extension://${EXTENSION_ID}/popup.html`);
+      const popupContent = await page.content();
+      assert.ok(
+        popupContent.includes('Popup Action'),
+        'Extension popup should be accessible',
+      );
+
+      // 4. Verify extension presence in chrome://extensions UI
+      // 4. Verify extension presence in chrome://extensions UI
+      await page.goto('chrome://extensions');
+
+      // Wait for usage to ensure page is loaded
+      await new Promise(r => setTimeout(r, 2000));
+
+      const EXTENSION_NAME = 'Simple Popup Action';
+      const found = await page.evaluate(extName => {
+        function deepSearch(root: Element | ShadowRoot): boolean {
+          if (root.textContent?.includes(extName)) return true;
+          if ('shadowRoot' in root && root.shadowRoot) {
+            if (deepSearch(root.shadowRoot)) return true;
+          }
+          for (const child of Array.from(root.children)) {
+            if (deepSearch(child)) return true;
+          }
+          return false;
+        }
+        return deepSearch(document.body);
+      }, EXTENSION_NAME);
+
+      assert.ok(
+        found,
+        `Extension "${EXTENSION_NAME}" should be visible on chrome://extensions`,
+      );
+    });
+  });
+});
diff --git a/tests/utils.ts b/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);
 
