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

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,36 @@ 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})`);
+    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}`,

package/build/src/profile-resolver.js

@@ -0,0 +1,190 @@
+// src/profile-resolver.ts
+// Phase 1 (v0.15.0)
+// - 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)
+// - 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';
+    // 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}`,
+            projectName: 'ci-session',
+            hash: sessionId,
+            channel,
+        };
+        // concise decision log (resolver-side)
+        console.error(`[profiles] resolved(AUTO, ci-ephemeral): ${result.path} (session=${sessionId})`);
+        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),
+            projectName: 'cli',
+            hash: shortHash(p),
+            channel,
+        };
+        console.error(`[profiles] resolved(CLI): ${result.path}`);
+        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),
+            projectName: 'env',
+            hash: shortHash(p),
+            channel,
+        };
+        console.error(`[profiles] resolved(MCP_USER_DATA_DIR): ${result.path}`);
+        return result;
+    }
+    // 3) ENV: MCP_PROJECT_ID (project-scoped persistent profile)
+    const projectId = sanitize(opts.env.MCP_PROJECT_ID || '');
+    if (projectId) {
+        const p = projectProfilePath(projectId, channel);
+        const result = {
+            path: p,
+            reason: 'MCP_PROJECT_ID',
+            projectKey: projectId,
+            projectName: projectId,
+            hash: shortHash(projectId),
+            channel,
+        };
+        console.error(`[profiles] resolved(MCP_PROJECT_ID): ${result.path} (projectId=${projectId})`);
+        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}`;
+        const p = projectProfilePath(key, channel);
+        const result = {
+            path: p,
+            reason: 'AUTO',
+            projectKey: key,
+            projectName: sanitize(name),
+            hash,
+            channel,
+        };
+        console.error(`[profiles] resolved(AUTO): ${result.path} (root=${root}, name=${name}, hash=${hash})`);
+        return result;
+    }
+    catch (e) {
+        // 5) DEFAULT fallback
+        const key = 'project-default';
+        const p = projectProfilePath(key, channel);
+        const result = {
+            path: p,
+            reason: 'DEFAULT',
+            projectKey: key,
+            projectName: key,
+            hash: '00000000',
+            channel,
+        };
+        console.error(`[profiles] resolved(DEFAULT): ${result.path} (reason=${e?.message || 'fallback'})`);
+        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.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",