chrome-devtools-mcp-for-extension 0.25.7 → 0.26.0

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/profile-resolver.js

@@ -18,6 +18,7 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { detectClientType } from './client-detector.js';
 import { detectProjectName, detectProjectRoot } from './project-detector.js';
 import { getProjectRoot } from './project-root-state.js';
@@ -30,49 +31,84 @@ export function resolveUserDataDir(opts) {
     if (opts.rootsInfo) {
         const stableProfilePath = path.join(CACHE_ROOT, 'profiles', opts.rootsInfo.profileKey, opts.rootsInfo.clientName, channel);
         const normalized = pathNormalize(stableProfilePath);
-        // v0.25.6: Migration from legacy profile formats to stable identity profile
-        // Supports: (1) v0.25.4以前のURI+clientベースハッシュ, (2) ディレクトリパスベースハッシュ
+        // v0.25.8: Comprehensive migration from legacy profile formats to stable identity profile
+        // Handles:
+        // - v0.18.x: URI+client+version hash, directory name as project name
+        // - v0.19.0-v0.25.4: URI+client hash (no version), directory name as project name
+        // - v0.25.5+: stable identity hash, package.json name as project name
         if (!fs.existsSync(stableProfilePath) && opts.rootsInfo.rootsUris.length > 0) {
             try {
                 const firstUri = opts.rootsInfo.rootsUris[0];
                 const url = new URL(firstUri);
                 if (url.protocol === 'file:') {
-                    const rootPath = url.pathname;
+                    // Extract directory name for OLD project name (v0.25.4以前)
+                    const rootPath = fileURLToPath(url);
                     const realRoot = realpathSafe(rootPath);
-                    // Try multiple legacy hash formats
+                    const dirName = path.basename(realRoot);
+                    const oldProjectName = sanitize(dirName); // e.g., "adlogger" from "adLogger"
+                    const newProjectName = opts.rootsInfo.projectName; // e.g., "adblocker" from package.json
+                    // Try both old and new project names
+                    const projectNamesToTry = [oldProjectName];
+                    if (newProjectName !== oldProjectName) {
+                        projectNamesToTry.push(newProjectName);
+                    }
+                    // Legacy hash formats to try
+                    const sortedUris = [...opts.rootsInfo.rootsUris].sort();
+                    const clientName = opts.rootsInfo.clientName;
+                    const clientVersion = opts.rootsInfo.clientVersion;
                     const legacyHashFormats = [
-                        // Format 1: v0.25.4以前 roots-manager.ts (URI + client JSON hash)
+                        // Format 1: v0.19.0-v0.25.4 (URI+client, no version)
                         {
                             name: 'uri+client',
-                            hash: (() => {
-                                const sortedUris = [firstUri].sort();
-                                const keyMaterial = JSON.stringify({
-                                    roots: sortedUris,
-                                    client: opts.rootsInfo.clientName,
-                                });
-                                return crypto.createHash('sha256').update(keyMaterial).digest('hex').slice(0, 8);
-                            })(),
+                            hash: crypto
+                                .createHash('sha256')
+                                .update(JSON.stringify({
+                                roots: sortedUris,
+                                client: clientName,
+                            }))
+                                .digest('hex')
+                                .slice(0, 8),
                         },
-                        // Format 2: Directory path hash (shortHash)
+                        // Format 2: v0.18.x (URI+client+version) - try common version strings
+                        ...['1.0.0', '0.1.0', clientVersion].map((version) => ({
+                            name: `uri+client+version(${version})`,
+                            hash: crypto
+                                .createHash('sha256')
+                                .update(JSON.stringify({
+                                roots: sortedUris,
+                                client: clientName,
+                                version,
+                            }))
+                                .digest('hex')
+                                .slice(0, 8),
+                        })),
+                        // Format 3: Directory path hash
                         {
                             name: 'directory-path',
                             hash: shortHash(realRoot),
                         },
                     ];
-                    for (const format of legacyHashFormats) {
-                        const legacyKey = `${opts.rootsInfo.projectName}_${format.hash}`;
-                        const legacyPath = path.join(CACHE_ROOT, 'profiles', legacyKey, opts.rootsInfo.clientName, channel);
-                        if (fs.existsSync(legacyPath)) {
-                            console.error(`[profiles] Migration: Found legacy profile (${format.name}): ${legacyPath}`);
-                            console.error(`[profiles] Migration: Creating symlink to stable profile: ${stableProfilePath}`);
-                            try {
-                                fs.mkdirSync(path.dirname(stableProfilePath), { recursive: true });
-                                fs.symlinkSync(legacyPath, stableProfilePath, 'dir');
-                                console.error(`[profiles] Migration: ✅ Symlink created successfully`);
-                                break; // Stop after first successful migration
-                            }
-                            catch (e) {
-                                console.error(`[profiles] Migration: ⚠️ Failed to create symlink: ${e}`);
+                    // Try all combinations of project name × hash format
+                    let migrated = false;
+                    for (const projName of projectNamesToTry) {
+                        if (migrated)
+                            break;
+                        for (const format of legacyHashFormats) {
+                            const legacyKey = `${projName}_${format.hash}`;
+                            const legacyPath = path.join(CACHE_ROOT, 'profiles', legacyKey, opts.rootsInfo.clientName, channel);
+                            if (fs.existsSync(legacyPath)) {
+                                console.error(`[profiles] Migration: Found legacy profile (${format.name}, project=${projName}): ${legacyPath}`);
+                                console.error(`[profiles] Migration: Creating symlink to stable profile: ${stableProfilePath}`);
+                                try {
+                                    fs.mkdirSync(path.dirname(stableProfilePath), { recursive: true });
+                                    fs.symlinkSync(legacyPath, stableProfilePath, 'dir');
+                                    console.error(`[profiles] Migration: ✅ Symlink created successfully`);
+                                    migrated = true;
+                                    break;
+                                }
+                                catch (e) {
+                                    console.error(`[profiles] Migration: ⚠️ Failed to create symlink: ${e}`);
+                                }
                             }
                         }
                     }

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,6 +1,6 @@
 {
   "name": "chrome-devtools-mcp-for-extension",
-  "version": "0.25.7",
+  "version": "0.26.0",
   "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",