chrome-devtools-mcp-for-extension 0.25.4 → 0.25.6

package/build/src/main.js

@@ -132,11 +132,6 @@ async function getContext() {
         process.env.MCP_PROJECT_ROOT ||
         rootFromRoots ||
         process.cwd();
-    // Debug: Log the source of project root
-    logger(`[project-root] DEBUG: args.projectRoot=${args.projectRoot}`);
-    logger(`[project-root] DEBUG: env.MCP_PROJECT_ROOT=${process.env.MCP_PROJECT_ROOT}`);
-    logger(`[project-root] DEBUG: rootFromRoots=${rootFromRoots}`);
-    logger(`[project-root] DEBUG: process.cwd()=${process.cwd()}`);
     setProjectRoot(projectRootToSet);
     logger(`[project-root] Initialized: ${projectRootToSet}`);
     const browserOptions = {

package/build/src/profile-resolver.js

@@ -23,8 +23,42 @@ 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 stableProfilePath = path.join(CACHE_ROOT, 'profiles', opts.rootsInfo.profileKey, opts.rootsInfo.clientName, channel);
+        const normalized = pathNormalize(stableProfilePath);
+        // v0.25.5: Migration from directory-based profile to stable identity profile
+        // Check if directory-based profile exists (for projects that added git later)
+        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;
+                    const realRoot = realpathSafe(rootPath);
+                    const dirHash = shortHash(realRoot);
+                    const dirBasedKey = `${opts.rootsInfo.projectName}_${dirHash}`;
+                    const dirBasedPath = path.join(CACHE_ROOT, 'profiles', dirBasedKey, opts.rootsInfo.clientName, channel);
+                    // If directory-based profile exists, create symlink for migration
+                    if (fs.existsSync(dirBasedPath)) {
+                        console.error(`[profiles] Migration: Found directory-based profile: ${dirBasedPath}`);
+                        console.error(`[profiles] Migration: Creating symlink to stable profile: ${stableProfilePath}`);
+                        try {
+                            // Create parent directories
+                            fs.mkdirSync(path.dirname(stableProfilePath), { recursive: true });
+                            // Create symlink: stable -> directory-based
+                            fs.symlinkSync(dirBasedPath, stableProfilePath, 'dir');
+                            console.error(`[profiles] Migration: ✅ Symlink created successfully`);
+                        }
+                        catch (e) {
+                            console.error(`[profiles] Migration: ⚠️ Failed to create symlink: ${e}`);
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                // Ignore migration errors, continue with normal flow
+                console.error(`[profiles] Migration check failed: ${e}`);
+            }
+        }
         const result = {
             path: normalized,
             reason: opts.rootsInfo.source,
@@ -223,20 +257,6 @@ export function resolveUserDataDir(opts) {
     if (initializedRoot) {
         console.error(`[profiles] Using initialized project root: "${initializedRoot}"`);
         try {
-            // Debug: Check package.json existence
-            const pjPath = path.join(initializedRoot, 'package.json');
-            const pjExists = fs.existsSync(pjPath);
-            console.error(`[profiles] DEBUG: package.json at ${pjPath} exists=${pjExists}`);
-            if (pjExists) {
-                try {
-                    const pkg = JSON.parse(fs.readFileSync(pjPath, 'utf8'));
-                    console.error(`[profiles] DEBUG: package.json name="${pkg?.name}"`);
-                }
-                catch (e) {
-                    console.error(`[profiles] DEBUG: package.json parse error: ${e}`);
-                }
-            }
-            console.error(`[profiles] DEBUG: basename="${path.basename(initializedRoot)}"`);
             const name = detectProjectName(initializedRoot);
             console.error(`[profiles] Initialized root name="${name}"`);
             // v0.25.0: Check profiles in priority order

package/build/src/roots-manager.js

@@ -10,6 +10,10 @@
  * Implements the MCP Roots protocol for project-scoped Chrome profiles.
  */
 import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { detectProjectName } from './project-detector.js';
+import { resolveStableIdentity } from './stable-identity.js';
 /**
  * Fetch roots from MCP client using roots/list protocol
  */
@@ -33,18 +37,28 @@ export async function fetchRootsFromClient(server) {
 /**
  * Generate stable profile key from roots and client info
  * Format: projectName_hash (e.g., "my-app_2ca5dbf5")
+ *
+ * @param rootsUris - Array of root URIs (used for fallback hash if stableIdentityHash not provided)
+ * @param clientName - Client name (e.g., "claude-code")
+ * @param clientVersion - Client version (not used in hash for stability)
+ * @param projectName - Human-readable project name
+ * @param stableIdentityHash - Optional stable identity hash (from git remote, etc.)
  */
-export function generateProfileKey(rootsUris, clientName, clientVersion, projectName) {
-    // Sort URIs for consistent hashing across multi-root workspaces
-    const sortedUris = [...rootsUris].sort();
-    // Note: clientVersion is intentionally excluded from hash
-    // to keep profiles stable across client updates
-    const keyMaterial = JSON.stringify({
-        roots: sortedUris,
-        client: clientName,
-    });
-    // Use first 8 chars of SHA-256 for stable, collision-resistant key
-    const hash = createHash('sha256').update(keyMaterial).digest('hex').slice(0, 8);
+export function generateProfileKey(rootsUris, clientName, clientVersion, projectName, stableIdentityHash) {
+    let hash;
+    if (stableIdentityHash) {
+        // Use stable identity hash (preferred - survives directory moves)
+        hash = stableIdentityHash;
+    }
+    else {
+        // Fallback: URI-based hash
+        const sortedUris = [...rootsUris].sort();
+        const keyMaterial = JSON.stringify({
+            roots: sortedUris,
+            client: clientName,
+        });
+        hash = createHash('sha256').update(keyMaterial).digest('hex').slice(0, 8);
+    }
     // Include project name for clarity (if available)
     if (projectName) {
         const sanitized = projectName.replace(/[^a-z0-9_-]/gi, '-').toLowerCase();
@@ -54,23 +68,35 @@ export function generateProfileKey(rootsUris, clientName, clientVersion, project
 }
 /**
  * Extract project name from roots URIs
+ * Uses detectProjectName() to read package.json name (preferred)
+ * Falls back to directory name if package.json not found
  */
 export function extractProjectName(roots) {
     if (roots.length === 0) {
         return 'unknown';
     }
-    // Prefer explicit name if provided
+    // Prefer explicit name if provided by MCP client
     const firstRoot = roots[0];
     if (firstRoot.name) {
         return sanitizeProjectName(firstRoot.name);
     }
-    // Extract from file:// URI
+    // Extract from file:// URI using detectProjectName (reads package.json)
     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);
+            // Convert URI to file path
+            const rootPath = fileURLToPath(url);
+            // Resolve realpath for symlink handling
+            let realPath;
+            try {
+                realPath = fs.realpathSync(rootPath);
+            }
+            catch {
+                realPath = rootPath; // Use original if realpath fails
+            }
+            // Use detectProjectName to read package.json name
+            const name = detectProjectName(realPath);
+            return sanitizeProjectName(name);
         }
     }
     catch {
@@ -84,6 +110,44 @@ export function extractProjectName(roots) {
 function sanitizeProjectName(name) {
     return name.toLowerCase().replace(/[^a-z0-9-_]/g, '-');
 }
+/**
+ * Get stable identity hash from a root path
+ * Returns undefined if stable identity cannot be resolved
+ */
+function getStableIdentityHash(rootPath) {
+    try {
+        const identity = resolveStableIdentity(rootPath);
+        // Only use stable identity for high-confidence sources (git-based)
+        if (identity.confidence === 'high' || identity.source === 'MCP_PROFILE_ID') {
+            return identity.id;
+        }
+    }
+    catch {
+        // Fall through to URI-based hash
+    }
+    return undefined;
+}
+/**
+ * Get root path from URI
+ */
+function getRootPathFromUri(uri) {
+    try {
+        const url = new URL(uri);
+        if (url.protocol === 'file:') {
+            const rootPath = fileURLToPath(url);
+            try {
+                return fs.realpathSync(rootPath);
+            }
+            catch {
+                return rootPath;
+            }
+        }
+    }
+    catch {
+        // Ignore
+    }
+    return undefined;
+}
 /**
  * Resolve roots information from MCP client or fallbacks
  */
@@ -96,8 +160,11 @@ export async function resolveRoots(server, fallbackOptions) {
     if (rootsResult && rootsResult.roots.length > 0) {
         const rootsUris = rootsResult.roots.map(r => r.uri);
         const projectName = extractProjectName(rootsResult.roots);
-        const profileKey = generateProfileKey(rootsUris, clientName, clientVersion, projectName);
-        console.error(`[roots] Resolved via roots/list: key=${profileKey}, project=${projectName}, client=${clientName}`);
+        // Get stable identity hash from first root
+        const rootPath = getRootPathFromUri(rootsUris[0]);
+        const stableHash = rootPath ? getStableIdentityHash(rootPath) : undefined;
+        const profileKey = generateProfileKey(rootsUris, clientName, clientVersion, projectName, stableHash);
+        console.error(`[roots] Resolved via roots/list: key=${profileKey}, project=${projectName}, client=${clientName}, stableId=${stableHash || 'none'}`);
         return {
             profileKey,
             projectName,
@@ -111,8 +178,10 @@ export async function resolveRoots(server, fallbackOptions) {
     if (fallbackOptions.cliProjectRoot) {
         const uri = pathToFileUri(fallbackOptions.cliProjectRoot);
         const projectName = extractProjectName([{ uri }]);
-        const profileKey = generateProfileKey([uri], clientName, clientVersion, projectName);
-        console.error(`[roots] Resolved via --project-root: key=${profileKey}, project=${projectName}`);
+        // Get stable identity hash
+        const stableHash = getStableIdentityHash(fallbackOptions.cliProjectRoot);
+        const profileKey = generateProfileKey([uri], clientName, clientVersion, projectName, stableHash);
+        console.error(`[roots] Resolved via --project-root: key=${profileKey}, project=${projectName}, stableId=${stableHash || 'none'}`);
         return {
             profileKey,
             projectName,
@@ -126,8 +195,10 @@ export async function resolveRoots(server, fallbackOptions) {
     if (fallbackOptions.envProjectRoot) {
         const uri = pathToFileUri(fallbackOptions.envProjectRoot);
         const projectName = extractProjectName([{ uri }]);
-        const profileKey = generateProfileKey([uri], clientName, clientVersion, projectName);
-        console.error(`[roots] Resolved via MCP_PROJECT_ROOT: key=${profileKey}, project=${projectName}`);
+        // Get stable identity hash
+        const stableHash = getStableIdentityHash(fallbackOptions.envProjectRoot);
+        const profileKey = generateProfileKey([uri], clientName, clientVersion, projectName, stableHash);
+        console.error(`[roots] Resolved via MCP_PROJECT_ROOT: key=${profileKey}, project=${projectName}, stableId=${stableHash || 'none'}`);
         return {
             profileKey,
             projectName,
@@ -141,8 +212,10 @@ export async function resolveRoots(server, fallbackOptions) {
     if (fallbackOptions.autoCwd) {
         const uri = pathToFileUri(fallbackOptions.autoCwd);
         const projectName = extractProjectName([{ uri }]);
-        const profileKey = generateProfileKey([uri], clientName, clientVersion, projectName);
-        console.error(`[roots] Resolved via AUTO (cwd): key=${profileKey}, project=${projectName}`);
+        // Get stable identity hash
+        const stableHash = getStableIdentityHash(fallbackOptions.autoCwd);
+        const profileKey = generateProfileKey([uri], clientName, clientVersion, projectName, stableHash);
+        console.error(`[roots] Resolved via AUTO (cwd): key=${profileKey}, project=${projectName}, stableId=${stableHash || 'none'}`);
         return {
             profileKey,
             projectName,

package/package.json

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