Implement list_extensions tool for local unpacked extensions

Author: Natallia Harshunova

src/McpContext.ts

@@ -35,6 +35,7 @@ import {takeSnapshot} from './tools/snapshot.js';
 import {CLOSE_PAGE_ERROR} from './tools/ToolDefinition.js';
 import type {Context, DevToolsData} from './tools/ToolDefinition.js';
 import type {TraceResult} from './trace-processing/parse.js';
+import { ExtensionRegistry, type InstalledExtension } from './utils/ExtensionRegistry.js';
 import {WaitForHelper} from './WaitForHelper.js';
 
 export interface TextSnapshotNode extends SerializedAXNode {
@@ -112,6 +113,7 @@ export class McpContext implements Context {
   #networkCollector: NetworkCollector;
   #consoleCollector: ConsoleCollector;
   #devtoolsUniverseManager: UniverseManager;
+  #extensionRegistry = new ExtensionRegistry();
 
   #isRunningTrace = false;
   #networkConditionsMap = new WeakMap<Page, string>();
@@ -753,11 +755,19 @@ export class McpContext implements Context {
     await this.#networkCollector.init(await this.browser.pages());
   }
 
-  async installExtension(path: string): Promise<string> {
-    return this.browser.installExtension(path);
+  async installExtension(extensionPath: string): Promise<string> {
+    const id = await this.browser.installExtension(extensionPath);
+    await this.#extensionRegistry.registerExtension(id, extensionPath);
+    return id;
   }
 
   async uninstallExtension(id: string): Promise<void> {
-    return this.browser.uninstallExtension(id);
+    await this.browser.uninstallExtension(id);
+    this.#extensionRegistry.remove(id);
+  }
+
+  listExtensions(): InstalledExtension[] {
+    return this.#extensionRegistry.list();
   }
 }
+

src/tools/ToolDefinition.ts

@@ -13,6 +13,7 @@ import type {
   Viewport,
 } from '../third_party/index.js';
 import type {InsightName, TraceResult} from '../trace-processing/parse.js';
+import type { InstalledExtension } from '../utils/ExtensionRegistry.js';
 import type {PaginationOptions} from '../utils/types.js';
 
 import type {ToolCategory} from './categories.js';
@@ -141,6 +142,7 @@ export type Context = Readonly<{
   resolveCdpElementId(cdpBackendNodeId: number): string | undefined;
   installExtension(path: string): Promise<string>;
   uninstallExtension(id: string): Promise<void>;
+  listExtensions(): InstalledExtension[];
 }>;
 
 export function defineTool<Schema extends zod.ZodRawShape>(

src/tools/extensions.ts

@@ -22,6 +22,7 @@ export const installExtension = defineTool({
   schema: {
     path: zod
       .string()
+      .trim()
       .describe('Absolute path to the unpacked extension folder.'),
   },
   handler: async (request, response, context) => {
@@ -48,3 +49,29 @@ export const uninstallExtension = defineTool({
     response.appendResponseLine(`Extension uninstalled. Id: ${id}`);
   },
 });
+
+export const listExtensions = defineTool({
+  name: 'list_extensions',
+  description:
+    'Lists all installed extensions, including their name, ID, version, and enabled status.',
+  annotations: {
+    category: ToolCategory.EXTENSIONS,
+    readOnlyHint: true,
+    conditions: [EXTENSIONS_CONDITION],
+  },
+  schema: {},
+  handler: async (request, response, context) => {
+    const extensions = context.listExtensions();
+    if (extensions.length === 0) {
+      response.appendResponseLine('No extensions installed.');
+      return;
+    }
+    const table = extensions.map(ext => ({
+      Name: ext.name,
+      ID: ext.id,
+      Version: ext.version,
+      Enabled: ext.isEnabled ? 'Yes' : 'No',
+    }));
+    response.appendResponseLine(JSON.stringify(table, null, 2));
+  },
+});

src/utils/ExtensionRegistry.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+export interface InstalledExtension {
+  id: string;
+  name: string;
+  version: string;
+  isEnabled: boolean;
+  path: string;
+}
+
+export class ExtensionRegistry {
+  #extensions = new Map<string, InstalledExtension>();
+
+  async registerExtension(id: string, extensionPath: string): Promise<InstalledExtension> {
+    const manifestPath = path.join(extensionPath, 'manifest.json');
+    const manifestContent = await fs.readFile(manifestPath, 'utf-8');
+    const manifest = JSON.parse(manifestContent);
+    const name = manifest.name ?? 'Unknown';
+    const version = manifest.version ?? 'Unknown';
+
+    const extension: InstalledExtension = {
+      id,
+      name,
+      version,
+      isEnabled: true,
+      path: extensionPath,
+    };
+    this.add(extension);
+    return extension;
+  }
+
+  add(extension: InstalledExtension): void {
+    this.#extensions.set(extension.id, extension);
+  }
+
+  remove(id: string): void {
+    this.#extensions.delete(id);
+  }
+
+  list(): InstalledExtension[] {
+    return Array.from(this.#extensions.values());
+  }
+
+  getById(id: string): InstalledExtension | undefined {
+    return this.#extensions.get(id);
+  }
+}
+

tests/tools/extensions.test.ts

@@ -11,6 +11,7 @@ import {describe, it} from 'node:test';
 import {
   installExtension,
   uninstallExtension,
+  listExtensions,
 } from '../../src/tools/extensions.js';
 import {withMcpContext} from '../utils.js';
 
@@ -71,4 +72,36 @@ describe('extension', () => {
       );
     });
   });
+  it('lists installed extensions', async () => {
+    await withMcpContext(async (response, context) => {
+      await installExtension.handler(
+        { params: { path: EXTENSION_PATH } },
+        response,
+        context,
+      );
+
+      await listExtensions.handler({ params: {} }, response, context);
+
+      const listResponseLine = response.responseLines[1];
+      assert.ok(listResponseLine, 'Response should not be empty');
+      const extensions = JSON.parse(listResponseLine);
+      assert.strictEqual(extensions.length, 1);
+      assert.strictEqual(extensions[0].Name, 'Test Extension');
+      assert.strictEqual(extensions[0].Version, '1.0');
+      assert.strictEqual(extensions[0].Enabled, 'Yes');
+
+      const extensionId = extensions[0].ID;
+      await uninstallExtension.handler(
+        { params: { id: extensionId } },
+        response,
+        context,
+      );
+
+      response.resetResponseLineForTesting();
+      await listExtensions.handler({ params: {} }, response, context);
+
+      const emptyListResponse = response.responseLines[0];
+      assert.strictEqual(emptyListResponse, 'No extensions installed.');
+    });
+  });
 });