chrome-devtools-mcp-for-extension 0.25.8 → 0.26.1

package/README.md

@@ -169,9 +169,12 @@ vim src/tools/extensions.ts
 chrome-devtools-mcp/
 ├── src/
 │   ├── tools/              # MCP tool definitions
-│   │   ├── extensions.ts   # Extension management (list, reload, debug)
+│   │   ├── core-tools.ts   # Core tool exports (v0.26.0)
+│   │   ├── optional-tools.ts # Web-LLM tool exports (v0.26.0)
 │   │   ├── chatgpt-web.ts  # ChatGPT automation
+│   │   ├── gemini-web.ts   # Gemini automation
 │   │   └── ...
+│   ├── plugin-api.ts       # Plugin architecture (v0.26.0)
 │   ├── browser.ts          # Browser/profile management
 │   ├── main.ts             # MCP server entry point
 │   └── graceful.ts         # Graceful shutdown
@@ -264,7 +267,8 @@ git push && git push --tags
 - 🔧 **Browser Testing**: Test extensions in real user environments
 - 🐛 **Advanced Debugging**: Service worker inspection, console monitoring
 - 📸 **Screenshot Generation**: Auto-create store listing images
-- 🤖 **ChatGPT Integration**: Automated ChatGPT interactions for research
+- 🤖 **ChatGPT/Gemini Integration**: Automated AI interactions for research
+- 🔌 **Plugin Architecture** (v0.26.0): Extensible tool system with external plugins
 
 ---
 
@@ -376,6 +380,85 @@ pkill -f mcp-wrapper
 
 ---
 
+## 🔌 Plugin Architecture (v0.26.0)
+
+### Tool Categories
+
+**Core Tools (18)** - Stable, site-independent:
+- Input: click, hover, fill, drag, fill_form, upload_file
+- Navigation: pages, navigate, resize_page, handle_dialog
+- Debugging: list_console_messages, take_screenshot, evaluate_script, take_snapshot, wait_for
+- Analysis: emulate, network, performance
+
+**Optional Tools (2)** - Web-LLM, site-dependent (may break with UI changes):
+- `ask_chatgpt_web` - ChatGPT browser automation
+- `ask_gemini_web` - Gemini browser automation
+
+### Disable Web-LLM Tools
+
+If you don't need ChatGPT/Gemini integration:
+
+```json
+{
+  "mcpServers": {
+    "chrome-devtools-extension": {
+      "command": "npx",
+      "args": ["chrome-devtools-mcp-for-extension@latest"],
+      "env": {
+        "MCP_DISABLE_WEB_LLM": "true"
+      }
+    }
+  }
+}
+```
+
+### External Plugins
+
+Load custom plugins at startup:
+
+```json
+{
+  "mcpServers": {
+    "chrome-devtools-extension": {
+      "command": "npx",
+      "args": ["chrome-devtools-mcp-for-extension@latest"],
+      "env": {
+        "MCP_PLUGINS": "./my-plugin.js,@org/another-plugin"
+      }
+    }
+  }
+}
+```
+
+**Plugin Interface:**
+```typescript
+// my-plugin.js
+export default {
+  id: 'my-plugin',
+  name: 'My Custom Plugin',
+  version: '1.0.0',
+
+  async register(ctx) {
+    ctx.registry.register({
+      name: 'my_custom_tool',
+      description: 'Does something useful',
+      schema: { /* zod schema */ },
+      annotations: { category: 'automation' },
+      async handler(input, response, context) {
+        // Tool implementation
+      }
+    });
+    ctx.log('Plugin registered!');
+  },
+
+  async unload() {
+    // Cleanup if needed
+  }
+};
+```
+
+---
+
 ## 🙏 Credits
 
 This project is a fork of [Chrome DevTools MCP](https://github.com/ChromeDevTools/chrome-devtools-mcp) by Google LLC.
@@ -393,5 +476,5 @@ This project is a fork of [Chrome DevTools MCP](https://github.com/ChromeDevTool
 
 Apache-2.0
 
-**Version**: 0.18.0
+**Version**: 0.26.0
 **Repository**: https://github.com/usedhonda/chrome-devtools-mcp

package/build/src/main.js

@@ -46,17 +46,9 @@ import { McpResponse } from './McpResponse.js';
 import { Mutex } from './Mutex.js';
 import { setProjectRoot } from './project-root-state.js';
 import { resolveRoots } from './roots-manager.js';
-import * as chatgptWebTools from './tools/chatgpt-web.js';
-import * as consoleTools from './tools/console.js';
-import * as emulationTools from './tools/emulation.js';
-import * as geminiWebTools from './tools/gemini-web.js';
-import { click, fill, fillForm } from './tools/input.js';
-import * as networkTools from './tools/network.js';
-import { pages, navigate } from './tools/pages.js';
-import * as performanceTools from './tools/performance.js';
-import * as screenshotTools from './tools/screenshot.js';
-import * as scriptTools from './tools/script.js';
-import * as snapshotTools from './tools/snapshot.js';
+import { ToolRegistry, PluginLoader } from './plugin-api.js';
+import { registerCoreTools, getCoreToolCount } from './tools/core-tools.js';
+import { registerOptionalTools, WEB_LLM_TOOLS_INFO } from './tools/optional-tools.js';
 function readPackageJson() {
     const currentDir = import.meta.dirname;
     const packageJsonPath = path.join(currentDir, '..', '..', 'package.json');
@@ -237,25 +229,33 @@ function registerTool(tool) {
         }
     });
 }
-const tools = [
-    ...Object.values(chatgptWebTools),
-    ...Object.values(geminiWebTools),
-    ...Object.values(consoleTools),
-    ...Object.values(emulationTools),
-    click,
-    fill,
-    fillForm,
-    ...Object.values(networkTools),
-    pages,
-    navigate,
-    ...Object.values(performanceTools),
-    ...Object.values(screenshotTools),
-    ...Object.values(scriptTools),
-    ...Object.values(snapshotTools),
-];
-for (const tool of tools) {
+// v0.26.0: Use ToolRegistry for plugin architecture
+const toolRegistry = new ToolRegistry();
+// Register core tools (stable, site-independent)
+registerCoreTools(toolRegistry);
+logger(`[tools] Registered ${getCoreToolCount()} core tools`);
+// Register optional tools (web-llm, site-dependent)
+const optionalCount = registerOptionalTools(toolRegistry);
+if (optionalCount > 0) {
+    logger(`[tools] ${WEB_LLM_TOOLS_INFO.disclaimer}`);
+}
+// Load external plugins from MCP_PLUGINS environment variable
+const pluginList = process.env.MCP_PLUGINS;
+if (pluginList) {
+    const pluginLoader = new PluginLoader(toolRegistry, logger);
+    const { loaded, failed } = await pluginLoader.loadFromList(pluginList);
+    if (loaded.length > 0) {
+        logger(`[plugins] Successfully loaded: ${loaded.join(', ')}`);
+    }
+    if (failed.length > 0) {
+        logger(`[plugins] Failed to load: ${failed.join(', ')}`);
+    }
+}
+// Register all tools with MCP server
+for (const tool of toolRegistry.getAll()) {
     registerTool(tool);
 }
+logger(`[tools] Total registered: ${toolRegistry.size} tools`);
 // Set initialization callback
 server.server.oninitialized = () => {
     initializationComplete = true;

package/build/src/plugin-api.js

@@ -0,0 +1,189 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Registry for managing MCP tools.
+ * Allows dynamic registration and querying of tools.
+ */
+export class ToolRegistry {
+    tools = new Map();
+    categories = new Map();
+    /**
+     * Register a single tool.
+     * @throws Error if a tool with the same name already exists
+     */
+    register(tool) {
+        if (this.tools.has(tool.name)) {
+            throw new Error(`Tool "${tool.name}" is already registered`);
+        }
+        this.tools.set(tool.name, tool);
+        // Track by category
+        const category = tool.annotations.category;
+        if (!this.categories.has(category)) {
+            this.categories.set(category, new Set());
+        }
+        this.categories.get(category).add(tool.name);
+    }
+    /**
+     * Register multiple tools at once.
+     */
+    registerBatch(tools) {
+        for (const tool of tools) {
+            this.register(tool);
+        }
+    }
+    /**
+     * Get all registered tools.
+     */
+    getAll() {
+        return Array.from(this.tools.values());
+    }
+    /**
+     * Get tools by category.
+     */
+    getByCategory(category) {
+        const names = this.categories.get(category);
+        if (!names)
+            return [];
+        return Array.from(names)
+            .map((name) => this.tools.get(name))
+            .filter(Boolean);
+    }
+    /**
+     * Get a specific tool by name.
+     */
+    get(name) {
+        return this.tools.get(name);
+    }
+    /**
+     * Check if a tool is registered.
+     */
+    has(name) {
+        return this.tools.has(name);
+    }
+    /**
+     * Get count of registered tools.
+     */
+    get size() {
+        return this.tools.size;
+    }
+    /**
+     * Unregister a tool by name.
+     * Returns true if the tool was removed, false if it didn't exist.
+     */
+    unregister(name) {
+        const tool = this.tools.get(name);
+        if (!tool)
+            return false;
+        this.tools.delete(name);
+        const category = tool.annotations.category;
+        this.categories.get(category)?.delete(name);
+        return true;
+    }
+    /**
+     * Clear all registered tools.
+     */
+    clear() {
+        this.tools.clear();
+        this.categories.clear();
+    }
+}
+/**
+ * Plugin loader for dynamically loading plugins.
+ */
+export class PluginLoader {
+    plugins = new Map();
+    registry;
+    log;
+    config;
+    constructor(registry, log = console.error, config = {}) {
+        this.registry = registry;
+        this.log = log;
+        this.config = config;
+    }
+    /**
+     * Load a plugin from a module path or package name.
+     * @param moduleId - Path to module or npm package name
+     */
+    async load(moduleId) {
+        try {
+            this.log(`[plugins] Loading plugin: ${moduleId}`);
+            // Dynamic import
+            const module = await import(moduleId);
+            const plugin = module.default || module.plugin || module;
+            if (!plugin.id || !plugin.register) {
+                this.log(`[plugins] Invalid plugin (missing id or register): ${moduleId}`);
+                return false;
+            }
+            if (this.plugins.has(plugin.id)) {
+                this.log(`[plugins] Plugin already loaded: ${plugin.id}`);
+                return false;
+            }
+            // Create plugin context
+            const ctx = {
+                registry: this.registry,
+                log: (msg) => this.log(`[${plugin.id}] ${msg}`),
+                config: this.config,
+            };
+            // Register the plugin
+            await plugin.register(ctx);
+            this.plugins.set(plugin.id, plugin);
+            this.log(`[plugins] Loaded: ${plugin.name} v${plugin.version} (${plugin.id})`);
+            return true;
+        }
+        catch (error) {
+            this.log(`[plugins] Failed to load ${moduleId}: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    }
+    /**
+     * Load multiple plugins from environment variable or config.
+     * @param pluginIds - Comma-separated list of plugin module IDs
+     */
+    async loadFromList(pluginIds) {
+        const ids = pluginIds
+            .split(',')
+            .map((id) => id.trim())
+            .filter(Boolean);
+        const loaded = [];
+        const failed = [];
+        for (const id of ids) {
+            const success = await this.load(id);
+            if (success) {
+                loaded.push(id);
+            }
+            else {
+                failed.push(id);
+            }
+        }
+        return { loaded, failed };
+    }
+    /**
+     * Unload a plugin by ID.
+     */
+    async unload(pluginId) {
+        const plugin = this.plugins.get(pluginId);
+        if (!plugin)
+            return false;
+        try {
+            if (plugin.unload) {
+                await plugin.unload();
+            }
+            this.plugins.delete(pluginId);
+            this.log(`[plugins] Unloaded: ${pluginId}`);
+            return true;
+        }
+        catch (error) {
+            this.log(`[plugins] Failed to unload ${pluginId}: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    }
+    /**
+     * Get list of loaded plugins.
+     */
+    getLoaded() {
+        return Array.from(this.plugins.values());
+    }
+}

package/build/src/tools/core-tools.js

@@ -0,0 +1,71 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// Input tools
+import { click, hover, fill, drag, fillForm, uploadFile } from './input.js';
+// Navigation tools
+import { pages, navigate, resizePage, handleDialog } from './pages.js';
+// Console tools
+import * as consoleTools from './console.js';
+// Emulation tools
+import * as emulationTools from './emulation.js';
+// Network tools
+import * as networkTools from './network.js';
+// Performance tools
+import * as performanceTools from './performance.js';
+// Screenshot tools
+import * as screenshotTools from './screenshot.js';
+// Script tools
+import * as scriptTools from './script.js';
+// Snapshot tools
+import * as snapshotTools from './snapshot.js';
+/**
+ * All core tools as an array.
+ */
+export const coreTools = [
+    // Input automation
+    click,
+    hover,
+    fill,
+    drag,
+    fillForm,
+    uploadFile,
+    // Navigation
+    pages,
+    navigate,
+    resizePage,
+    handleDialog,
+    // Console
+    ...Object.values(consoleTools),
+    // Emulation
+    ...Object.values(emulationTools),
+    // Network
+    ...Object.values(networkTools),
+    // Performance
+    ...Object.values(performanceTools),
+    // Screenshot
+    ...Object.values(screenshotTools),
+    // Script
+    ...Object.values(scriptTools),
+    // Snapshot
+    ...Object.values(snapshotTools),
+];
+/**
+ * Register all core tools with a ToolRegistry.
+ */
+export function registerCoreTools(registry) {
+    for (const tool of coreTools) {
+        // Skip non-tool exports (like constants)
+        if (tool && typeof tool === 'object' && 'name' in tool && 'handler' in tool) {
+            registry.register(tool);
+        }
+    }
+}
+/**
+ * Get count of core tools.
+ */
+export function getCoreToolCount() {
+    return coreTools.filter((tool) => tool && typeof tool === 'object' && 'name' in tool && 'handler' in tool).length;
+}

package/build/src/tools/optional-tools.js

@@ -0,0 +1,68 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// ChatGPT web tools
+import * as chatgptWebTools from './chatgpt-web.js';
+// Gemini web tools
+import * as geminiWebTools from './gemini-web.js';
+/**
+ * All optional (web-llm) tools as an array.
+ */
+export const optionalTools = [
+    ...Object.values(chatgptWebTools),
+    ...Object.values(geminiWebTools),
+];
+/**
+ * Check if web-llm tools should be loaded.
+ * Returns false if MCP_DISABLE_WEB_LLM is set to 'true'.
+ */
+export function shouldLoadWebLlmTools() {
+    const disable = process.env.MCP_DISABLE_WEB_LLM;
+    return disable !== 'true' && disable !== '1';
+}
+/**
+ * Register optional tools with a ToolRegistry.
+ * Respects MCP_DISABLE_WEB_LLM environment variable.
+ */
+export function registerOptionalTools(registry) {
+    if (!shouldLoadWebLlmTools()) {
+        console.error('[tools] Web-LLM tools disabled via MCP_DISABLE_WEB_LLM');
+        return 0;
+    }
+    let count = 0;
+    for (const tool of optionalTools) {
+        // Skip non-tool exports (like constants)
+        if (tool && typeof tool === 'object' && 'name' in tool && 'handler' in tool) {
+            try {
+                registry.register(tool);
+                count++;
+            }
+            catch (error) {
+                // Log but don't fail - optional tools should not block startup
+                console.error(`[tools] Failed to register optional tool: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    if (count > 0) {
+        console.error(`[tools] Loaded ${count} optional web-llm tools (experimental, may break)`);
+    }
+    return count;
+}
+/**
+ * Get count of optional tools.
+ */
+export function getOptionalToolCount() {
+    return optionalTools.filter((tool) => tool && typeof tool === 'object' && 'name' in tool && 'handler' in tool).length;
+}
+/**
+ * Metadata about optional tools for documentation.
+ */
+export const WEB_LLM_TOOLS_INFO = {
+    disclaimer: 'Web-LLM tools (ask_chatgpt_web, ask_gemini_web) are experimental and best-effort. ' +
+        'They depend on specific website UIs and may break when those UIs change. ' +
+        'For production use, consider using official APIs instead.',
+    disableEnvVar: 'MCP_DISABLE_WEB_LLM',
+    tools: ['ask_chatgpt_web', 'ask_gemini_web'],
+};

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "chrome-devtools-mcp-for-extension",
-  "version": "0.25.8",
+  "version": "0.26.1",
   "description": "MCP server for Chrome extension development with Web Store automation. Fork of chrome-devtools-mcp with extension-specific tools.",
   "type": "module",
   "bin": "./scripts/cli.mjs",
   "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./plugin-api": "./build/src/plugin-api.js"
+  },
   "scripts": {
     "build": "tsc && node --experimental-strip-types --no-warnings=ExperimentalWarning scripts/post-build.ts",
     "dev": "MCP_ENV=development node scripts/mcp-wrapper.mjs",