chrome-devtools-mcp-for-extension 0.14.1 → 0.15.1

package/build/src/browser.js

@@ -7,6 +7,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import puppeteer from 'puppeteer-core';
+import { resolveUserDataDir } from './profile-resolver.js';
 let browser;
 const ignoredPrefixes = new Set([
     'chrome://',
@@ -418,20 +419,37 @@ export async function launch(options) {
     const { channel, executablePath, customDevTools, headless, isolated, loadExtension, loadExtensionsDir, loadSystemExtensions, chromeProfile, } = options;
     // Reset development extension paths
     developmentExtensionPaths = [];
-    const profileDirName = channel && channel !== 'stable'
-        ? `chrome-profile-${channel}`
-        : 'chrome-profile';
-    let userDataDir = options.userDataDir;
+    // Resolve user data directory using new profile resolver (v0.15.0+)
+    const resolved = resolveUserDataDir({
+        cliUserDataDir: options.userDataDir,
+        env: process.env,
+        cwd: process.cwd(),
+        channel: channel || 'stable',
+    });
+    const userDataDir = resolved.path;
+    await fs.promises.mkdir(userDataDir, { recursive: true });
+    // Legacy profile warning (shown if legacy path exists)
+    try {
+        const legacy = path.join(os.homedir(), '.cache', 'chrome-devtools-mcp', 'chrome-profile');
+        if (fs.existsSync(legacy)) {
+            console.error(`⚠️  Legacy profile detected: ${legacy}\n` +
+                `ℹ️  New profile location: ${path.join(os.homedir(), '.cache', 'chrome-devtools-mcp', 'profiles', 'project-default', 'stable')}\n` +
+                `💡 To continue using the legacy profile, set: MCP_USER_DATA_DIR=${legacy}`);
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    // Profile resolution logs
+    console.error(`[profiles] Using: ${userDataDir}`);
+    console.error(`           Reason: ${resolved.reason}`);
+    console.error(`           Project: ${resolved.projectName} (${resolved.hash})`);
+    console.error(`           Client:  ${resolved.clientId}`);
+    if (resolved.reason === 'AUTO') {
+        console.error(`           Root: ${process.cwd()}`);
+    }
     let usingSystemProfile = false;
     let profileDirectory = 'Default';
-    if (!userDataDir) {
-        // Use isolated profile (independent from system Chrome)
-        userDataDir = path.join(os.homedir(), '.cache', 'chrome-devtools-mcp', profileDirName);
-        await fs.promises.mkdir(userDataDir, {
-            recursive: true,
-        });
-        console.error(`📁 Using isolated profile: ${userDataDir}`);
-    }
     const args = [
         '--hide-crash-restore-bubble',
         `--profile-directory=${profileDirectory}`,
@@ -529,15 +547,17 @@ export async function launch(options) {
     console.error(`  Headless: ${headless}`);
     console.error(`  Args: ${JSON.stringify(args, null, 2)}`);
     console.error(`  Ignored Default Args: ["--disable-extensions", "--enable-automation"]`);
+    // IMPORTANT: Chrome extensions (especially MV3 content scripts and service workers)
+    // DO NOT work in headless mode. Always use headless:false when loading extensions.
+    // Reference: https://groups.google.com/a/chromium.org/g/headless-dev/c/nEoeUkoNI0o/m/9KZ4Os46AQAJ
+    const effectiveHeadless = extensionPaths.length > 0 ? false : headless;
+    if (extensionPaths.length > 0 && headless) {
+        console.warn('⚠️  WARNING: Extensions require headful mode. Forcing headless:false');
+    }
+    let browser;
+    let finalUserDataDir = userDataDir;
     try {
-        // IMPORTANT: Chrome extensions (especially MV3 content scripts and service workers)
-        // DO NOT work in headless mode. Always use headless:false when loading extensions.
-        // Reference: https://groups.google.com/a/chromium.org/g/headless-dev/c/nEoeUkoNI0o/m/9KZ4Os46AQAJ
-        const effectiveHeadless = extensionPaths.length > 0 ? false : headless;
-        if (extensionPaths.length > 0 && headless) {
-            console.warn('⚠️  WARNING: Extensions require headful mode. Forcing headless:false');
-        }
-        const browser = await puppeteer.launch({
+        browser = await puppeteer.launch({
             ...connectOptions,
             channel: puppeterChannel,
             executablePath: effectiveExecutablePath,
@@ -548,6 +568,50 @@ export async function launch(options) {
             args,
             ignoreDefaultArgs: ['--disable-extensions', '--enable-automation'],
         });
+    }
+    catch (e) {
+        // Profile lock collision fallback (v0.15.1)
+        const errorMsg = String(e.message || '').toLowerCase();
+        const isProfileLocked = errorMsg.includes('in use') ||
+            errorMsg.includes('lock') ||
+            errorMsg.includes('another chrome') ||
+            errorMsg.includes('profile appears to be');
+        if (isProfileLocked) {
+            // Fallback to ephemeral session
+            const sessionId = `${process.pid}-${Date.now()}`;
+            const tempPath = path.join(os.homedir(), '.cache', 'chrome-devtools-mcp', 'sessions', sessionId, channel || 'stable');
+            await fs.promises.mkdir(tempPath, { recursive: true });
+            console.error(`⚠️  Profile locked: ${userDataDir}`);
+            console.error(`📁 Falling back to ephemeral session: ${tempPath}`);
+            console.error(`💡 To avoid this, set MCP_CLIENT_ID (e.g., "claude-code", "codex")`);
+            // Clean up on exit
+            process.on('exit', () => {
+                try {
+                    fs.rmSync(tempPath, { recursive: true, force: true });
+                }
+                catch {
+                    /* ignore */
+                }
+            });
+            finalUserDataDir = tempPath;
+            // Retry with ephemeral profile
+            browser = await puppeteer.launch({
+                ...connectOptions,
+                channel: puppeterChannel,
+                executablePath: effectiveExecutablePath,
+                defaultViewport: null,
+                userDataDir: tempPath,
+                pipe: true,
+                headless: effectiveHeadless,
+                args,
+                ignoreDefaultArgs: ['--disable-extensions', '--enable-automation'],
+            });
+        }
+        else {
+            throw e;
+        }
+    }
+    try {
         // Log actual spawn args for debugging
         const spawnArgs = browser.process()?.spawnargs;
         if (spawnArgs) {

package/build/src/profile-resolver.js

@@ -0,0 +1,199 @@
+// src/profile-resolver.ts
+// Phase 1 (v0.15.0) + v0.15.1 (MCP_CLIENT_ID support)
+// - Hybrid priority (CLI > MCP_USER_DATA_DIR > MCP_PROJECT_ID > AUTO > DEFAULT)
+// - Auto-detection (git root -> nearest package.json -> cwd)
+// - Realpath normalization
+// - Tilde (~) expansion
+// - Short SHA-256 hash (8 chars)
+// - CI detection => ephemeral session profile (unless MCP_PERSIST_PROFILES)
+// - Client ID isolation (MCP_CLIENT_ID environment variable)
+// - Minimal console.error() logging of decision
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { detectProjectName, detectProjectRoot } from './project-detector.js';
+const CACHE_ROOT = path.join(os.homedir(), '.cache', 'chrome-devtools-mcp');
+// --- Public API ---
+export function resolveUserDataDir(opts) {
+    const channel = opts.channel || 'stable';
+    const clientId = sanitize(opts.env.MCP_CLIENT_ID || 'default');
+    // 0) CI detection → ephemeral session directory (unless MCP_PERSIST_PROFILES)
+    //    - This happens before other priorities to keep CI clean by default.
+    if (isCI(opts.env) && !opts.env.MCP_PERSIST_PROFILES) {
+        const sessionId = `${process.pid}-${Date.now()}`;
+        const tempPath = realpathSafe(path.join(CACHE_ROOT, 'sessions', sessionId, channel));
+        // best-effort cleanup on exit
+        process.on('exit', () => {
+            try {
+                fs.rmSync(tempPath, { recursive: true, force: true });
+            }
+            catch {
+                /* ignore */
+            }
+        });
+        const result = {
+            path: tempPath,
+            reason: 'AUTO', // keep enum as specified (no EPHEMERAL type in Phase 1)
+            projectKey: `session-${sessionId}_${clientId}`,
+            projectName: 'ci-session',
+            hash: sessionId,
+            clientId,
+            channel,
+        };
+        // concise decision log (resolver-side)
+        console.error(`[profiles] resolved(AUTO, ci-ephemeral): ${result.path} (session=${sessionId}, client=${clientId})`);
+        return result;
+    }
+    // 1) CLI explicit userDataDir
+    if (opts.cliUserDataDir && opts.cliUserDataDir.trim().length > 0) {
+        const p = realpathOrExpand(opts.cliUserDataDir);
+        const result = {
+            path: p,
+            reason: 'CLI',
+            projectKey: `${stripHomeForKey(p)}_${clientId}`,
+            projectName: 'cli',
+            hash: shortHash(p),
+            clientId,
+            channel,
+        };
+        console.error(`[profiles] resolved(CLI): ${result.path} (client=${clientId})`);
+        return result;
+    }
+    // 2) ENV: MCP_USER_DATA_DIR (full path)
+    const envUserData = opts.env.MCP_USER_DATA_DIR?.trim();
+    if (envUserData) {
+        const p = realpathOrExpand(envUserData);
+        const result = {
+            path: p,
+            reason: 'MCP_USER_DATA_DIR',
+            projectKey: `${stripHomeForKey(p)}_${clientId}`,
+            projectName: 'env',
+            hash: shortHash(p),
+            clientId,
+            channel,
+        };
+        console.error(`[profiles] resolved(MCP_USER_DATA_DIR): ${result.path} (client=${clientId})`);
+        return result;
+    }
+    // 3) ENV: MCP_PROJECT_ID (project-scoped persistent profile)
+    const projectId = sanitize(opts.env.MCP_PROJECT_ID || '');
+    if (projectId) {
+        const key = `${projectId}_${clientId}`;
+        const p = projectProfilePath(key, channel);
+        const result = {
+            path: p,
+            reason: 'MCP_PROJECT_ID',
+            projectKey: key,
+            projectName: projectId,
+            hash: shortHash(projectId),
+            clientId,
+            channel,
+        };
+        console.error(`[profiles] resolved(MCP_PROJECT_ID): ${result.path} (projectId=${projectId}, client=${clientId})`);
+        return result;
+    }
+    // 4) AUTO: detect by root -> name -> hash
+    try {
+        const root = detectProjectRoot(opts.cwd);
+        const name = detectProjectName(root);
+        const realRoot = realpathSafe(root);
+        const hash = shortHash(realRoot);
+        const key = `${sanitize(name)}_${hash}_${clientId}`;
+        const p = projectProfilePath(key, channel);
+        const result = {
+            path: p,
+            reason: 'AUTO',
+            projectKey: key,
+            projectName: sanitize(name),
+            hash,
+            clientId,
+            channel,
+        };
+        console.error(`[profiles] resolved(AUTO): ${result.path} (root=${root}, name=${name}, hash=${hash}, client=${clientId})`);
+        return result;
+    }
+    catch (e) {
+        // 5) DEFAULT fallback
+        const key = `project-default_${clientId}`;
+        const p = projectProfilePath(key, channel);
+        const result = {
+            path: p,
+            reason: 'DEFAULT',
+            projectKey: key,
+            projectName: 'project-default',
+            hash: '00000000',
+            clientId,
+            channel,
+        };
+        console.error(`[profiles] resolved(DEFAULT): ${result.path} (reason=${e?.message || 'fallback'}, client=${clientId})`);
+        return result;
+    }
+}
+// --- Helpers ---
+function isCI(env) {
+    // Common CI signals
+    return env.CI === 'true' || env.GITHUB_ACTIONS === 'true';
+}
+function projectProfilePath(projectKey, channel) {
+    const base = path.join(CACHE_ROOT, 'profiles', projectKey, channel);
+    return pathNormalize(base);
+}
+function shortHash(s) {
+    try {
+        return crypto.createHash('sha256').update(s).digest('hex').slice(0, 8);
+    }
+    catch {
+        // Extremely unlikely; fallback for robustness
+        return '00000000';
+    }
+}
+function sanitize(s) {
+    const base = (s || 'project').toLowerCase().replace(/[^a-z0-9-_]/g, '-');
+    // Avoid empty string after sanitize
+    return base.length ? base : 'project';
+}
+function expandTilde(p) {
+    if (!p)
+        return p;
+    if (p.startsWith('~')) {
+        return path.join(os.homedir(), p.slice(1));
+    }
+    return p;
+}
+function realpathSafe(p) {
+    try {
+        // Use native realpath if available for speed/behavior
+        // (Node 18+ has fs.realpathSync.native)
+        const rp = fs.realpathSync.native
+            ? fs.realpathSync.native(p)
+            : fs.realpathSync(p);
+        return rp;
+    }
+    catch {
+        // The path may not exist yet; normalize current form
+        return pathNormalize(p);
+    }
+}
+function realpathOrExpand(p) {
+    const expanded = expandTilde(p);
+    return realpathSafe(expanded);
+}
+function pathNormalize(p) {
+    // Normalize but do not resolve symlinks here
+    // (realpathSafe is used where resolution is desired)
+    return path.normalize(p);
+}
+/**
+ * Best-effort readable key when user supplied an absolute path.
+ * We do not want slashes in the key, so hash + tail dir name.
+ */
+function stripHomeForKey(absPath) {
+    try {
+        const name = path.basename(absPath);
+        return `${sanitize(name)}_${shortHash(absPath)}`;
+    }
+    catch {
+        return `abs_${shortHash(absPath)}`;
+    }
+}

package/build/src/project-detector.js

@@ -0,0 +1,66 @@
+// src/project-detector.ts
+// Phase 1 (v0.15.0)
+// - detectProjectRoot: git root → nearest package.json → cwd
+// - detectProjectName: package.json "name" → dirname
+// - Use spawnSync with 500ms timeout to avoid blocking long
+// - Realpath normalization
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+export function detectProjectRoot(cwd) {
+    const realCwd = realpathSafe(cwd);
+    // 1) Try 'git rev-parse --show-toplevel' with 500ms timeout
+    const git = spawnSync('git', ['rev-parse', '--show-toplevel'], {
+        cwd: realCwd,
+        timeout: 500,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+        windowsHide: true,
+    });
+    if (git.status === 0 && git.stdout) {
+        const out = git.stdout.toString().trim();
+        if (out)
+            return realpathSafe(out);
+    }
+    // If git is not available or command failed/timed out → fall through
+    // 2) Walk up to nearest package.json
+    let cur = realCwd;
+    while (true) {
+        if (fs.existsSync(path.join(cur, 'package.json')))
+            return cur;
+        const next = path.dirname(cur);
+        if (next === cur)
+            break; // reached filesystem root
+        cur = next;
+    }
+    // 3) Fallback to cwd
+    return realCwd;
+}
+export function detectProjectName(root) {
+    const realRoot = realpathSafe(root);
+    const pj = path.join(realRoot, 'package.json');
+    if (fs.existsSync(pj)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pj, 'utf8'));
+            if (pkg && typeof pkg.name === 'string' && pkg.name.trim()) {
+                return String(pkg.name).trim();
+            }
+        }
+        catch {
+            // ignore parse errors and fall back to directory name
+        }
+    }
+    return path.basename(realRoot);
+}
+// --- helpers ---
+function realpathSafe(p) {
+    try {
+        const rp = fs.realpathSync.native
+            ? fs.realpathSync.native(p)
+            : fs.realpathSync(p);
+        return rp;
+    }
+    catch {
+        return path.normalize(p);
+    }
+}

package/package.json

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