chrome-ai-bridge 1.0.0

package/build/src/profile-resolver.js

@@ -0,0 +1,555 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// src/profile-resolver.ts
+// Phase 1 (v0.15.0) + v0.15.1 (MCP_CLIENT_ID support) + v0.17.0 (Hierarchical profiles)
+// - 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)
+// - Hierarchical structure: {project}/{client}/{channel} (v0.17.0)
+// - Minimal console.error() logging of decision
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { detectClientType } from './client-detector.js';
+import { detectProjectName, detectProjectRoot } from './project-detector.js';
+import { getProjectRoot } from './project-root-state.js';
+import { resolveStableIdentity, } from './stable-identity.js';
+const CACHE_ROOT = path.join(os.homedir(), '.cache', 'chrome-ai-bridge');
+// --- 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 stableProfilePath = path.join(CACHE_ROOT, 'profiles', opts.rootsInfo.profileKey, opts.rootsInfo.clientName, channel);
+        const normalized = pathNormalize(stableProfilePath);
+        // v0.25.8: Comprehensive migration from legacy profile formats to stable identity profile
+        // Handles:
+        // - v0.18.x: URI+client+version hash, directory name as project name
+        // - v0.19.0-v0.25.4: URI+client hash (no version), directory name as project name
+        // - v0.25.5+: stable identity hash, package.json name as project name
+        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:') {
+                    // Extract directory name for OLD project name (v0.25.4以前)
+                    const rootPath = fileURLToPath(url);
+                    const realRoot = realpathSafe(rootPath);
+                    const dirName = path.basename(realRoot);
+                    const oldProjectName = sanitize(dirName); // e.g., "adlogger" from "adLogger"
+                    const newProjectName = opts.rootsInfo.projectName; // e.g., "adblocker" from package.json
+                    // Try both old and new project names
+                    const projectNamesToTry = [oldProjectName];
+                    if (newProjectName !== oldProjectName) {
+                        projectNamesToTry.push(newProjectName);
+                    }
+                    // Legacy hash formats to try
+                    const sortedUris = [...opts.rootsInfo.rootsUris].sort();
+                    const clientName = opts.rootsInfo.clientName;
+                    const clientVersion = opts.rootsInfo.clientVersion;
+                    const legacyHashFormats = [
+                        // Format 1: v0.19.0-v0.25.4 (URI+client, no version)
+                        {
+                            name: 'uri+client',
+                            hash: crypto
+                                .createHash('sha256')
+                                .update(JSON.stringify({
+                                roots: sortedUris,
+                                client: clientName,
+                            }))
+                                .digest('hex')
+                                .slice(0, 8),
+                        },
+                        // Format 2: v0.18.x (URI+client+version) - try common version strings
+                        ...['1.0.0', '0.1.0', clientVersion].map(version => ({
+                            name: `uri+client+version(${version})`,
+                            hash: crypto
+                                .createHash('sha256')
+                                .update(JSON.stringify({
+                                roots: sortedUris,
+                                client: clientName,
+                                version,
+                            }))
+                                .digest('hex')
+                                .slice(0, 8),
+                        })),
+                        // Format 3: Directory path hash
+                        {
+                            name: 'directory-path',
+                            hash: shortHash(realRoot),
+                        },
+                    ];
+                    // Try all combinations of project name × hash format
+                    let migrated = false;
+                    for (const projName of projectNamesToTry) {
+                        if (migrated)
+                            break;
+                        for (const format of legacyHashFormats) {
+                            const legacyKey = `${projName}_${format.hash}`;
+                            const legacyPath = path.join(CACHE_ROOT, 'profiles', legacyKey, opts.rootsInfo.clientName, channel);
+                            if (fs.existsSync(legacyPath)) {
+                                console.error(`[profiles] Migration: Found legacy profile (${format.name}, project=${projName}): ${legacyPath}`);
+                                console.error(`[profiles] Migration: Creating symlink to stable profile: ${stableProfilePath}`);
+                                try {
+                                    fs.mkdirSync(path.dirname(stableProfilePath), {
+                                        recursive: true,
+                                    });
+                                    fs.symlinkSync(legacyPath, stableProfilePath, 'dir');
+                                    console.error(`[profiles] Migration: ✅ Symlink created successfully`);
+                                    migrated = true;
+                                    break;
+                                }
+                                catch (e) {
+                                    console.error(`[profiles] Migration: ⚠️ Failed to create symlink: ${e}`);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                console.error(`[profiles] Migration check failed: ${e}`);
+            }
+        }
+        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) {
+        clientId = sanitize(opts.env.MCP_CLIENT_ID);
+        console.error(`[profiles] Using explicit MCP_CLIENT_ID: ${clientId}`);
+    }
+    else {
+        const detected = detectClientType();
+        clientId = sanitize(detected);
+        console.error(`[profiles] Auto-detected client from parent process: ${clientId}`);
+    }
+    // 0a) MCP_SHARED_PROFILE → shared profile across all projects
+    //     - Uses a single profile for all projects to avoid re-login
+    if (opts.env.MCP_SHARED_PROFILE === 'true') {
+        const key = 'shared';
+        const p = projectProfilePath(key, clientId, channel);
+        const result = {
+            path: p,
+            reason: 'MCP_USER_DATA_DIR', // Treat as explicit user choice
+            projectKey: key,
+            projectName: 'shared',
+            hash: '00000000',
+            clientId,
+            channel,
+        };
+        console.error(`[profiles] resolved(MCP_SHARED_PROFILE): ${result.path} (client=${clientId})`);
+        console.error(`[profiles] ℹ️  Using shared profile - login state persists across all projects`);
+        return result;
+    }
+    // 0b) 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; // v0.17.0: clientId removed from projectKey
+        const p = projectProfilePath(key, clientId, 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;
+    }
+    // 3.5) ENV: MCP_PROJECT_ROOT (MCP Roots protocol - actual project directory)
+    const projectRoot = opts.env.MCP_PROJECT_ROOT;
+    if (projectRoot) {
+        console.error(`[profiles] MCP_PROJECT_ROOT detected: "${projectRoot}"`);
+        try {
+            const name = detectProjectName(projectRoot);
+            console.error(`[profiles] MCP_PROJECT_ROOT name="${name}"`);
+            // 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);
+            // 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',
+                    projectKey: legacyKey,
+                    projectName: sanitize(name),
+                    hash: legacyHash,
+                    clientId,
+                    channel,
+                    identitySource: 'directory-fallback',
+                };
+                return result;
+            }
+            // 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: stablePath,
+                reason: 'MCP_PROJECT_ROOT',
+                projectKey: stableKey,
+                projectName: sanitize(name),
+                hash: identity.id,
+                clientId,
+                channel,
+                identitySource: identity.source,
+            };
+            return result;
+        }
+        catch (e) {
+            console.error(`[profiles] MCP_PROJECT_ROOT resolution failed: ${e}`);
+            // Fall through to AUTO detection
+        }
+    }
+    // 4) INITIALIZED_PROJECT_ROOT: Use globally initialized project root (highest priority for AUTO mode)
+    const initializedRoot = getProjectRoot();
+    if (initializedRoot) {
+        console.error(`[profiles] Using initialized project root: "${initializedRoot}"`);
+        try {
+            const name = detectProjectName(initializedRoot);
+            console.error(`[profiles] Initialized root name="${name}"`);
+            // 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);
+            // 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',
+                    projectKey: legacyKey,
+                    projectName: sanitize(name),
+                    hash: legacyHash,
+                    clientId,
+                    channel,
+                    identitySource: 'directory-fallback',
+                };
+                return result;
+            }
+            // 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: stablePath,
+                reason: 'AUTO',
+                projectKey: stableKey,
+                projectName: sanitize(name),
+                hash: identity.id,
+                clientId,
+                channel,
+                identitySource: identity.source,
+            };
+            return result;
+        }
+        catch (e) {
+            console.error(`[profiles] Initialized root resolution failed: ${e}`);
+            // Fall through to cwd-based AUTO detection
+        }
+    }
+    // 5) AUTO: detect by root -> name -> hash (fallback if no initialized root)
+    try {
+        console.error(`[profiles] AUTO detection (cwd fallback): cwd="${opts.cwd}"`);
+        const root = detectProjectRoot(opts.cwd);
+        console.error(`[profiles] AUTO detection: root="${root}"`);
+        const name = detectProjectName(root);
+        console.error(`[profiles] AUTO detection: name="${name}"`);
+        // 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);
+        // 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',
+                projectKey: legacyKey,
+                projectName: sanitize(name),
+                hash: legacyHash,
+                clientId,
+                channel,
+                identitySource: 'directory-fallback',
+            };
+            console.error(`[profiles] resolved(AUTO, legacy): ${result.path} (root=${root}, name=${name}, hash=${legacyHash}, client=${clientId})`);
+            return result;
+        }
+        // 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: stablePath,
+            reason: 'AUTO',
+            projectKey: stableKey,
+            projectName: sanitize(name),
+            hash: identity.id,
+            clientId,
+            channel,
+            identitySource: identity.source,
+        };
+        console.error(`[profiles] resolved(AUTO, stable-new): ${result.path} (root=${root}, name=${name}, identity=${identity.source}, client=${clientId})`);
+        return result;
+    }
+    catch (e) {
+        console.error(`[profiles] AUTO detection FAILED: ${e}`);
+        // 5) DEFAULT fallback
+        const key = 'project-default'; // v0.17.0: clientId removed from projectKey
+        const p = projectProfilePath(key, clientId, 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, clientId, channel) {
+    // v0.17.0: Hierarchical structure - {project}/{client}/{channel}
+    const base = path.join(CACHE_ROOT, 'profiles', projectKey, clientId, 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,71 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// 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 { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+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/build/src/project-root-state.js

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// src/project-root-state.ts
+// Global state for MCP project root (set during initialization)
+let projectRoot;
+export function setProjectRoot(path) {
+    projectRoot = path;
+    console.error(`[MCP] Project root initialized: ${path}`);
+}
+export function getProjectRoot() {
+    return projectRoot;
+}
+export function isProjectRootInitialized() {
+    return projectRoot !== undefined;
+}