chrome-devtools-mcp-for-extension 0.17.0 → 0.18.0

package/build/src/browser.js

@@ -425,6 +425,7 @@ export async function launch(options) {
         env: process.env,
         cwd: process.cwd(),
         channel: channel || 'stable',
+        rootsInfo: options.rootsInfo, // v0.18.0: Pass Roots info
     });
     const userDataDir = resolved.path;
     await fs.promises.mkdir(userDataDir, { recursive: true });

package/build/src/cli.js

@@ -74,6 +74,11 @@ export const cliOptions = {
         type: 'string',
         describe: 'Path to a file to write debug logs to. Set the env variable `DEBUG` to `*` to enable verbose logs. Useful for submitting bug reports.',
     },
+    projectRoot: {
+        type: 'string',
+        description: 'Explicitly specify the project root directory for profile isolation. Overrides MCP roots/list. Useful when roots/list is not available.',
+        conflicts: 'browserUrl',
+    },
 };
 export function parseArguments(version, argv = process.argv) {
     const yargsInstance = yargs(hideBin(argv))

package/build/src/main.js

@@ -8,13 +8,14 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { SetLevelRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { SetLevelRequestSchema, RootsListChangedNotificationSchema } from '@modelcontextprotocol/sdk/types.js';
 import { resolveBrowser } from './browser.js';
 import { parseArguments } from './cli.js';
 import { logger, saveLogsToFile } from './logger.js';
 import { McpContext } from './McpContext.js';
 import { McpResponse } from './McpResponse.js';
 import { Mutex } from './Mutex.js';
+import { resolveRoots } from './roots-manager.js';
 import { runStartupCheck } from './startup-check.js';
 import * as bookmarkTools from './tools/bookmarks.js';
 import * as chatgptWebTools from './tools/chatgpt-web.js';
@@ -57,9 +58,34 @@ const server = new McpServer({
 server.server.setRequestHandler(SetLevelRequestSchema, () => {
     return {};
 });
+// Handle roots/list_changed notification
+server.server.setNotificationHandler(RootsListChangedNotificationSchema, async () => {
+    logger('[roots] Received roots/list_changed notification - roots have changed');
+    // Invalidate cached roots info
+    cachedRootsInfo = null;
+    logger('[roots] Cached roots cleared - will re-fetch on next browser launch');
+});
 let context;
 let uiHealthCheckRun = false; // Track if UI health check has been run
+let cachedRootsInfo = null; // Cache roots info
+let initializationComplete = false; // Track if MCP initialization is complete
 async function getContext() {
+    // Wait for initialization to complete before resolving roots
+    if (!initializationComplete) {
+        logger('[roots] Waiting for MCP initialization to complete...');
+        await new Promise(resolve => setTimeout(resolve, 100)); // Brief wait
+        if (!initializationComplete) {
+            logger('[roots] WARNING: MCP not yet initialized, proceeding without roots');
+        }
+    }
+    // Resolve roots info (cached or fresh)
+    if (!cachedRootsInfo) {
+        cachedRootsInfo = await resolveRoots(server.server, {
+            cliProjectRoot: args.projectRoot,
+            envProjectRoot: process.env.MCP_PROJECT_ROOT,
+            autoCwd: process.cwd(),
+        });
+    }
     const browserOptions = {
         browserUrl: args.browserUrl,
         headless: args.headless,
@@ -73,6 +99,7 @@ async function getContext() {
         chromeProfile: args.chromeProfile,
         userDataDir: args.userDataDir,
         logFile,
+        rootsInfo: cachedRootsInfo, // Pass roots info to browser
     };
     const browser = await resolveBrowser(browserOptions);
     // Browser factory function for reconnection
@@ -176,6 +203,11 @@ const tools = [
 for (const tool of tools) {
     registerTool(tool);
 }
+// Set initialization callback
+server.server.oninitialized = () => {
+    initializationComplete = true;
+    logger('[roots] MCP initialization complete');
+};
 const transport = new StdioServerTransport();
 await server.connect(transport);
 logger('Chrome DevTools MCP Server connected');

package/build/src/profile-resolver.js

@@ -19,6 +19,23 @@ const CACHE_ROOT = path.join(os.homedir(), '.cache', 'chrome-devtools-mcp');
 // --- Public API ---
 export function resolveUserDataDir(opts) {
     const channel = opts.channel || 'stable';
+    // v0.18.0: PRIORITY 0 - Use Roots info if available
+    if (opts.rootsInfo) {
+        const profilePath = path.join(CACHE_ROOT, 'profiles', opts.rootsInfo.profileKey, opts.rootsInfo.clientName, channel);
+        const normalized = pathNormalize(profilePath);
+        const result = {
+            path: normalized,
+            reason: opts.rootsInfo.source,
+            projectKey: opts.rootsInfo.profileKey,
+            projectName: opts.rootsInfo.projectName,
+            hash: opts.rootsInfo.profileKey.slice(0, 8), // Use first 8 chars as hash
+            clientId: opts.rootsInfo.clientName,
+            channel,
+        };
+        console.error(`[profiles] Resolved via Roots (${opts.rootsInfo.source}): ${result.path}`);
+        console.error(`[profiles]   project=${opts.rootsInfo.projectName}, client=${opts.rootsInfo.clientName}, key=${opts.rootsInfo.profileKey}`);
+        return result;
+    }
     // Auto-detect client type from parent process if MCP_CLIENT_ID not set
     let clientId;
     if (opts.env.MCP_CLIENT_ID) {

package/build/src/roots-manager.js

@@ -0,0 +1,171 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Roots Manager
+ *
+ * Manages MCP roots (project directories) and generates stable profile keys.
+ * Implements the MCP Roots protocol for project-scoped Chrome profiles.
+ */
+import { createHash } from 'node:crypto';
+/**
+ * Fetch roots from MCP client using roots/list protocol
+ */
+export async function fetchRootsFromClient(server) {
+    const clientCaps = server.getClientCapabilities();
+    if (!clientCaps?.roots) {
+        console.error('[roots] Client does not support roots capability');
+        return null;
+    }
+    try {
+        console.error('[roots] Requesting roots/list from client...');
+        const result = await server.listRoots({}, { timeout: 5000 });
+        console.error(`[roots] Received ${result.roots.length} roots from client`);
+        return result;
+    }
+    catch (error) {
+        console.error(`[roots] Failed to fetch roots from client: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Generate stable profile key from roots and client info
+ */
+export function generateProfileKey(rootsUris, clientName, clientVersion) {
+    // Sort URIs for consistent hashing across multi-root workspaces
+    const sortedUris = [...rootsUris].sort();
+    const keyMaterial = JSON.stringify({
+        roots: sortedUris,
+        client: clientName,
+        version: clientVersion,
+    });
+    // Use first 12 chars of SHA-256 for stable, collision-resistant key
+    const hash = createHash('sha256').update(keyMaterial).digest('hex').slice(0, 12);
+    return hash;
+}
+/**
+ * Extract project name from roots URIs
+ */
+export function extractProjectName(roots) {
+    if (roots.length === 0) {
+        return 'unknown';
+    }
+    // Prefer explicit name if provided
+    const firstRoot = roots[0];
+    if (firstRoot.name) {
+        return sanitizeProjectName(firstRoot.name);
+    }
+    // Extract from file:// URI
+    try {
+        const url = new URL(firstRoot.uri);
+        if (url.protocol === 'file:') {
+            const pathParts = url.pathname.split('/').filter(Boolean);
+            const dirName = pathParts[pathParts.length - 1] || 'root';
+            return sanitizeProjectName(dirName);
+        }
+    }
+    catch {
+        // Fall through to default
+    }
+    return 'unknown';
+}
+/**
+ * Sanitize project name for use in file paths
+ */
+function sanitizeProjectName(name) {
+    return name.toLowerCase().replace(/[^a-z0-9-_]/g, '-');
+}
+/**
+ * Resolve roots information from MCP client or fallbacks
+ */
+export async function resolveRoots(server, fallbackOptions) {
+    const clientInfo = server.getClientVersion();
+    const clientName = clientInfo?.name || 'unknown-client';
+    const clientVersion = clientInfo?.version || '0.0.0';
+    // 1) Try roots/list from client (preferred)
+    const rootsResult = await fetchRootsFromClient(server);
+    if (rootsResult && rootsResult.roots.length > 0) {
+        const rootsUris = rootsResult.roots.map(r => r.uri);
+        const profileKey = generateProfileKey(rootsUris, clientName, clientVersion);
+        const projectName = extractProjectName(rootsResult.roots);
+        console.error(`[roots] Resolved via roots/list: key=${profileKey}, project=${projectName}, client=${clientName}`);
+        return {
+            profileKey,
+            projectName,
+            rootsUris,
+            clientName,
+            clientVersion,
+            source: 'roots/list',
+        };
+    }
+    // 2) Fallback: CLI argument --project-root
+    if (fallbackOptions.cliProjectRoot) {
+        const uri = pathToFileUri(fallbackOptions.cliProjectRoot);
+        const profileKey = generateProfileKey([uri], clientName, clientVersion);
+        const projectName = extractProjectName([{ uri }]);
+        console.error(`[roots] Resolved via --project-root: key=${profileKey}, project=${projectName}`);
+        return {
+            profileKey,
+            projectName,
+            rootsUris: [uri],
+            clientName,
+            clientVersion,
+            source: '--project-root',
+        };
+    }
+    // 3) Fallback: Environment variable MCP_PROJECT_ROOT
+    if (fallbackOptions.envProjectRoot) {
+        const uri = pathToFileUri(fallbackOptions.envProjectRoot);
+        const profileKey = generateProfileKey([uri], clientName, clientVersion);
+        const projectName = extractProjectName([{ uri }]);
+        console.error(`[roots] Resolved via MCP_PROJECT_ROOT: key=${profileKey}, project=${projectName}`);
+        return {
+            profileKey,
+            projectName,
+            rootsUris: [uri],
+            clientName,
+            clientVersion,
+            source: 'MCP_PROJECT_ROOT',
+        };
+    }
+    // 4) Fallback: AUTO (cwd-based, last resort)
+    if (fallbackOptions.autoCwd) {
+        const uri = pathToFileUri(fallbackOptions.autoCwd);
+        const profileKey = generateProfileKey([uri], clientName, clientVersion);
+        const projectName = extractProjectName([{ uri }]);
+        console.error(`[roots] Resolved via AUTO (cwd): key=${profileKey}, project=${projectName}`);
+        return {
+            profileKey,
+            projectName,
+            rootsUris: [uri],
+            clientName,
+            clientVersion,
+            source: 'AUTO',
+        };
+    }
+    // Absolute fallback
+    const fallbackUri = 'file:///unknown';
+    const profileKey = generateProfileKey([fallbackUri], clientName, clientVersion);
+    console.error('[roots] WARNING: No roots available, using fallback');
+    return {
+        profileKey,
+        projectName: 'unknown',
+        rootsUris: [fallbackUri],
+        clientName,
+        clientVersion,
+        source: 'AUTO',
+    };
+}
+/**
+ * Convert absolute file path to file:// URI
+ */
+function pathToFileUri(absPath) {
+    // Normalize path and convert to file:// URI
+    const normalized = absPath.replace(/\\/g, '/');
+    const withoutLeadingSlash = normalized.startsWith('/')
+        ? normalized
+        : '/' + normalized;
+    return `file://${withoutLeadingSlash}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-devtools-mcp-for-extension",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "MCP server for Chrome extension development with Web Store automation. Fork of chrome-devtools-mcp with extension-specific tools.",
   "type": "module",
   "bin": "./build/src/index.js",