chrome-devtools-mcp-for-extension 0.25.1 → 0.25.3

package/build/src/profile-resolver.js

@@ -149,14 +149,29 @@ export function resolveUserDataDir(opts) {
         try {
             const name = detectProjectName(projectRoot);
             console.error(`[profiles] MCP_PROJECT_ROOT name="${name}"`);
-            // v0.25.0: Legacy-first approach - check if legacy profile exists
+            // v0.25.0: Check profiles in priority order
+            // 1. Legacy profile
             const realRoot = realpathSafe(projectRoot);
             const legacyHash = shortHash(realRoot);
             const legacyKey = `${sanitize(name)}_${legacyHash}`;
             const legacyPath = projectProfilePath(legacyKey, clientId, channel);
-            // If legacy profile exists, use it
+            // Pre-calculate stable identity
+            const identity = resolveStableIdentity(projectRoot, opts.env);
+            const stableKey = `${sanitize(name)}_${identity.id}`;
+            const stablePath = projectProfilePath(stableKey, clientId, channel);
             if (fs.existsSync(legacyPath)) {
                 console.error(`[profiles] Legacy profile exists, using it: ${legacyPath}`);
+                // Create stable identity symlink for future moves
+                if (legacyPath !== stablePath && !fs.existsSync(stablePath)) {
+                    try {
+                        fs.mkdirSync(path.dirname(stablePath), { recursive: true });
+                        fs.symlinkSync(legacyPath, stablePath, 'dir');
+                        console.error(`[profiles] ✅ Created stable identity link: ${stablePath} -> ${legacyPath}`);
+                    }
+                    catch (e) {
+                        console.error(`[profiles] ⚠️ Failed to create stable identity link: ${e}`);
+                    }
+                }
                 const result = {
                     path: legacyPath,
                     reason: 'MCP_PROJECT_ROOT',
@@ -167,25 +182,35 @@ export function resolveUserDataDir(opts) {
                     channel,
                     identitySource: 'directory-fallback',
                 };
-                console.error(`[profiles] resolved(MCP_PROJECT_ROOT, legacy): ${result.path} (root=${projectRoot}, name=${name}, hash=${legacyHash}, client=${clientId})`);
                 return result;
             }
-            // Legacy profile doesn't exist - use stable identity
-            const identity = resolveStableIdentity(projectRoot, opts.env);
-            console.error(`[profiles] No legacy profile, using stable identity: ${identity.source} (${identity.confidence}) raw="${identity.raw}"`);
-            const key = `${sanitize(name)}_${identity.id}`;
-            const p = projectProfilePath(key, clientId, channel);
+            // 2. Check stable identity profile
+            if (fs.existsSync(stablePath)) {
+                console.error(`[profiles] Stable identity profile exists: ${stablePath}`);
+                const result = {
+                    path: stablePath,
+                    reason: 'MCP_PROJECT_ROOT',
+                    projectKey: stableKey,
+                    projectName: sanitize(name),
+                    hash: identity.id,
+                    clientId,
+                    channel,
+                    identitySource: identity.source,
+                };
+                return result;
+            }
+            // 3. Create new with stable identity
+            console.error(`[profiles] Creating new profile with stable identity: ${identity.source}`);
             const result = {
-                path: p,
+                path: stablePath,
                 reason: 'MCP_PROJECT_ROOT',
-                projectKey: key,
+                projectKey: stableKey,
                 projectName: sanitize(name),
                 hash: identity.id,
                 clientId,
                 channel,
                 identitySource: identity.source,
             };
-            console.error(`[profiles] resolved(MCP_PROJECT_ROOT, stable): ${result.path} (root=${projectRoot}, name=${name}, identity=${identity.source}, client=${clientId})`);
             return result;
         }
         catch (e) {
@@ -200,14 +225,29 @@ export function resolveUserDataDir(opts) {
         try {
             const name = detectProjectName(initializedRoot);
             console.error(`[profiles] Initialized root name="${name}"`);
-            // v0.25.0: Legacy-first approach - check if legacy profile exists
+            // v0.25.0: Check profiles in priority order
+            // 1. Legacy profile
             const realRoot = realpathSafe(initializedRoot);
             const legacyHash = shortHash(realRoot);
             const legacyKey = `${sanitize(name)}_${legacyHash}`;
             const legacyPath = projectProfilePath(legacyKey, clientId, channel);
-            // If legacy profile exists, use it
+            // Pre-calculate stable identity
+            const identity = resolveStableIdentity(initializedRoot, opts.env);
+            const stableKey = `${sanitize(name)}_${identity.id}`;
+            const stablePath = projectProfilePath(stableKey, clientId, channel);
             if (fs.existsSync(legacyPath)) {
                 console.error(`[profiles] Legacy profile exists, using it: ${legacyPath}`);
+                // Create stable identity symlink for future moves
+                if (legacyPath !== stablePath && !fs.existsSync(stablePath)) {
+                    try {
+                        fs.mkdirSync(path.dirname(stablePath), { recursive: true });
+                        fs.symlinkSync(legacyPath, stablePath, 'dir');
+                        console.error(`[profiles] ✅ Created stable identity link: ${stablePath} -> ${legacyPath}`);
+                    }
+                    catch (e) {
+                        console.error(`[profiles] ⚠️ Failed to create stable identity link: ${e}`);
+                    }
+                }
                 const result = {
                     path: legacyPath,
                     reason: 'AUTO',
@@ -218,25 +258,35 @@ export function resolveUserDataDir(opts) {
                     channel,
                     identitySource: 'directory-fallback',
                 };
-                console.error(`[profiles] resolved(INITIALIZED_ROOT, legacy): ${result.path} (root=${initializedRoot}, name=${name}, hash=${legacyHash}, client=${clientId})`);
                 return result;
             }
-            // Legacy profile doesn't exist - use stable identity
-            const identity = resolveStableIdentity(initializedRoot, opts.env);
-            console.error(`[profiles] No legacy profile, using stable identity: ${identity.source} (${identity.confidence}) raw="${identity.raw}"`);
-            const key = `${sanitize(name)}_${identity.id}`;
-            const p = projectProfilePath(key, clientId, channel);
+            // 2. Check stable identity profile
+            if (fs.existsSync(stablePath)) {
+                console.error(`[profiles] Stable identity profile exists: ${stablePath}`);
+                const result = {
+                    path: stablePath,
+                    reason: 'AUTO',
+                    projectKey: stableKey,
+                    projectName: sanitize(name),
+                    hash: identity.id,
+                    clientId,
+                    channel,
+                    identitySource: identity.source,
+                };
+                return result;
+            }
+            // 3. Create new with stable identity
+            console.error(`[profiles] Creating new profile with stable identity: ${identity.source}`);
             const result = {
-                path: p,
+                path: stablePath,
                 reason: 'AUTO',
-                projectKey: key,
+                projectKey: stableKey,
                 projectName: sanitize(name),
                 hash: identity.id,
                 clientId,
                 channel,
                 identitySource: identity.source,
             };
-            console.error(`[profiles] resolved(INITIALIZED_ROOT, stable): ${result.path} (root=${initializedRoot}, name=${name}, identity=${identity.source}, client=${clientId})`);
             return result;
         }
         catch (e) {
@@ -251,14 +301,32 @@ export function resolveUserDataDir(opts) {
         console.error(`[profiles] AUTO detection: root="${root}"`);
         const name = detectProjectName(root);
         console.error(`[profiles] AUTO detection: name="${name}"`);
-        // v0.25.0: Legacy-first approach - check if legacy profile exists
+        // v0.25.0: Check profiles in priority order:
+        // 1. Legacy (realpath-based) profile
+        // 2. Stable identity profile (for moved projects)
+        // 3. Create new with stable identity
+        // 1. Check legacy profile
         const realRoot = realpathSafe(root);
         const legacyHash = shortHash(realRoot);
         const legacyKey = `${sanitize(name)}_${legacyHash}`;
         const legacyPath = projectProfilePath(legacyKey, clientId, channel);
-        // If legacy profile exists, use it (no migration needed)
+        // Pre-calculate stable identity for potential symlink creation
+        const identity = resolveStableIdentity(root, opts.env);
+        const stableKey = `${sanitize(name)}_${identity.id}`;
+        const stablePath = projectProfilePath(stableKey, clientId, channel);
         if (fs.existsSync(legacyPath)) {
             console.error(`[profiles] Legacy profile exists, using it: ${legacyPath}`);
+            // Also create stable identity symlink for future moves (if different and not exists)
+            if (legacyPath !== stablePath && !fs.existsSync(stablePath)) {
+                try {
+                    fs.mkdirSync(path.dirname(stablePath), { recursive: true });
+                    fs.symlinkSync(legacyPath, stablePath, 'dir');
+                    console.error(`[profiles] ✅ Created stable identity link for future moves: ${stablePath} -> ${legacyPath}`);
+                }
+                catch (e) {
+                    console.error(`[profiles] ⚠️ Failed to create stable identity link: ${e}`);
+                }
+            }
             const result = {
                 path: legacyPath,
                 reason: 'AUTO',
@@ -272,22 +340,35 @@ export function resolveUserDataDir(opts) {
             console.error(`[profiles] resolved(AUTO, legacy): ${result.path} (root=${root}, name=${name}, hash=${legacyHash}, client=${clientId})`);
             return result;
         }
-        // Legacy profile doesn't exist - use stable identity for new profile
-        const identity = resolveStableIdentity(root, opts.env);
-        console.error(`[profiles] No legacy profile, using stable identity: ${identity.source} (${identity.confidence}) raw="${identity.raw}"`);
-        const key = `${sanitize(name)}_${identity.id}`;
-        const p = projectProfilePath(key, clientId, channel);
+        // 2. Check stable identity profile (for moved projects)
+        if (fs.existsSync(stablePath)) {
+            console.error(`[profiles] Stable identity profile exists (project may have moved): ${stablePath}`);
+            const result = {
+                path: stablePath,
+                reason: 'AUTO',
+                projectKey: stableKey,
+                projectName: sanitize(name),
+                hash: identity.id,
+                clientId,
+                channel,
+                identitySource: identity.source,
+            };
+            console.error(`[profiles] resolved(AUTO, stable-existing): ${result.path} (root=${root}, name=${name}, identity=${identity.source}, client=${clientId})`);
+            return result;
+        }
+        // 3. Neither exists - create new with stable identity
+        console.error(`[profiles] No existing profile, creating with stable identity: ${identity.source} (${identity.confidence}) raw="${identity.raw}"`);
         const result = {
-            path: p,
+            path: stablePath,
             reason: 'AUTO',
-            projectKey: key,
+            projectKey: stableKey,
             projectName: sanitize(name),
             hash: identity.id,
             clientId,
             channel,
             identitySource: identity.source,
         };
-        console.error(`[profiles] resolved(AUTO, stable): ${result.path} (root=${root}, name=${name}, identity=${identity.source}, client=${clientId})`);
+        console.error(`[profiles] resolved(AUTO, stable-new): ${result.path} (root=${root}, name=${name}, identity=${identity.source}, client=${clientId})`);
         return result;
     }
     catch (e) {

package/package.json

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