vexp-cli 2.0.11 → 2.0.12

package/dist/agent-config.js

@@ -16,6 +16,66 @@ import { VEXP_GUARD_HOOK } from "./hook-template.js";
 // ---------------------------------------------------------------------------
 const VEXP_MARKER_RE = /<!-- vexp(?:\s+v[\d.]+)? -->/;
 const VEXP_MARKER_END = "<!-- /vexp -->";
+// Matches LEGACY vexp entry keys ONLY — "vexp-mcp", "vexp-core", "vexp-stdio",
+// "vexp_old", etc. Explicitly excludes the canonical "vexp" key so that idempotency
+// checks (command+args+env identical?) work: we only remove siblings, not the entry
+// we're about to upsert.
+const LEGACY_VEXP_KEY_RE = /^vexp[_-][a-z0-9_-]+$/i;
+// Matches TOML sections for LEGACY vexp keys only: [mcp_servers.vexp-mcp],
+// [mcp_servers.vexp_old], etc. Explicitly excludes the canonical
+// [mcp_servers.vexp] to preserve idempotency.
+// Stops at the next top-level header (`\n[` followed by a letter/underscore)
+// so that array-valued TOML keys like `args = ["--legacy"]` do not prematurely
+// terminate the section.
+const LEGACY_VEXP_TOML_SECTION_RE = /\n?\[mcp_servers\.vexp[_-][a-z0-9_-]+(?:\.[a-z_]+)?\][\s\S]*?(?=\n\[[A-Za-z_]|$)/gi;
+// Matches the canonical [mcp_servers.vexp] section (and its .http_headers
+// sub-section), used when we need to overwrite it with new URL/token.
+const CANONICAL_VEXP_TOML_SECTION_RE = /\n?\[mcp_servers\.vexp(?:\.[a-z_]+)?\][\s\S]*?(?=\n\[[A-Za-z_]|$)/gi;
+/**
+ * FNV-1a 64-bit hash (first 8 hex chars) of the workspace root.
+ * Duplicates the helper in packages/vexp-mcp/src/daemon-client.ts:fnvHash
+ * to avoid a runtime dependency from the CLI on the MCP package.
+ * MUST stay in lockstep with that function.
+ */
+function workspaceHash(workspaceRoot) {
+    const input = workspaceRoot.toLowerCase();
+    let hash = BigInt("0xcbf29ce484222325");
+    const prime = BigInt("0x100000001b3");
+    const mask = BigInt("0xffffffffffffffff");
+    const bytes = Buffer.from(input, "utf-8");
+    for (const byte of bytes) {
+        hash ^= BigInt(byte);
+        hash = (hash * prime) & mask;
+    }
+    return hash.toString(16).padStart(16, "0").slice(0, 8);
+}
+/**
+ * Remove every legacy vexp entry from a JSON-shaped MCP config object.
+ * `key` selects which container to scrub: "mcpServers" (Claude Code,
+ * Cursor, Windsurf), "servers" (.vscode/mcp.json), "context_servers" (Zed).
+ * Returns the list of removed keys for logging.
+ */
+function stripLegacyVexpEntries(config, key) {
+    const container = config[key];
+    if (!container || typeof container !== "object")
+        return [];
+    const removed = [];
+    for (const k of Object.keys(container)) {
+        if (LEGACY_VEXP_KEY_RE.test(k)) {
+            delete container[k];
+            removed.push(`${key}.${k}`);
+        }
+    }
+    return removed;
+}
+/** Emit a one-line removal notice to stdout (chalk-less to avoid churn). */
+function logRemoval(removed) {
+    if (removed.length === 0)
+        return;
+    for (const entry of removed) {
+        process.stdout.write(`  · Removed legacy entry: ${entry}\n`);
+    }
+}
 // All vexp MCP tools (all read-only — safe to pre-approve).
 const VEXP_TOOLS = [
     "run_pipeline",
@@ -426,29 +486,35 @@ function writeMcpConfig(mcpConfigPath, binaryPath, alwaysAllow, mcpServerPath, w
             // Malformed JSON: overwrite
         }
     }
-    const servers = existing.mcpServers;
     const useNode = mcpServerPath && fs.existsSync(mcpServerPath);
     const targetCmd = useNode ? "node" : binaryPath;
     const targetArgs = useNode ? [mcpServerPath] : ["mcp"];
     const targetEnv = workspaceRoot ? { VEXP_WORKSPACE: workspaceRoot } : undefined;
-    if (servers && "vexp" in servers) {
-        const cur = servers["vexp"];
-        if (cur?.["command"] === targetCmd &&
-            Array.isArray(cur?.["args"]) &&
-            JSON.stringify(cur["args"]) === JSON.stringify(targetArgs) &&
-            JSON.stringify(cur["env"]) === JSON.stringify(targetEnv)) {
-            return false; // Already up to date
-        }
+    const beforeServers = existing.mcpServers;
+    const previousVexp = beforeServers?.["vexp"];
+    const currentCmd = previousVexp?.["command"];
+    const prevArgs = Array.isArray(previousVexp?.["args"]) ? previousVexp?.["args"] : undefined;
+    const prevEnv = previousVexp?.env;
+    const identical = currentCmd === targetCmd &&
+        prevArgs !== undefined &&
+        JSON.stringify(prevArgs) === JSON.stringify(targetArgs) &&
+        JSON.stringify(prevEnv) === JSON.stringify(targetEnv);
+    // Legacy cleanup: remove any vexp/vexp-* keys; if the canonical 'vexp'
+    // entry points at a command path that no longer exists on disk, drop it
+    // too so we don't keep a stale pointer.
+    const removed = stripLegacyVexpEntries(existing, "mcpServers");
+    logRemoval(removed);
+    if (identical && removed.length === 0) {
+        return false; // Already up to date and no legacy to clean
     }
-    existing.mcpServers = {
-        ...(servers ?? {}),
-        vexp: {
-            command: targetCmd,
-            args: targetArgs,
-            ...(targetEnv ? { env: targetEnv } : {}),
-            ...(alwaysAllow && alwaysAllow.length > 0 ? { alwaysAllow } : {}),
-        },
+    const servers = existing.mcpServers ?? {};
+    servers["vexp"] = {
+        command: targetCmd,
+        args: targetArgs,
+        ...(targetEnv ? { env: targetEnv } : {}),
+        ...(alwaysAllow && alwaysAllow.length > 0 ? { alwaysAllow } : {}),
     };
+    existing.mcpServers = servers;
     fs.mkdirSync(path.dirname(mcpConfigPath), { recursive: true });
     fs.writeFileSync(mcpConfigPath, JSON.stringify(existing, null, 2), "utf-8");
     return true;
@@ -508,20 +574,34 @@ function configureCodexGlobal(binaryPath, mcpServerPath, workspaceRoot) {
     const configPath = path.join(home, ".codex", "config.toml");
     const mcpPort = readMcpPort(workspaceRoot);
     const token = resolveCodexToken();
-    const newSection = `\n[mcp_servers.vexp]\nurl = "http://127.0.0.1:${mcpPort}/mcp"\ntool_timeout_sec = 120\n\n[mcp_servers.vexp.http_headers]\nAuthorization = "Bearer ${token}"\n`;
+    // Per-workspace URL path — lets the single MCP server on :port route
+    // each codex request to the correct daemon in multi-workspace setups.
+    // Falls back to /mcp if no workspace is known (e.g. global bootstrap).
+    const wsHash = workspaceRoot ? workspaceHash(workspaceRoot) : "";
+    const urlPath = wsHash ? `/ws/${wsHash}/mcp` : "/mcp";
+    const desiredUrl = `http://127.0.0.1:${mcpPort}${urlPath}`;
+    const newSection = `\n[mcp_servers.vexp]\nurl = "${desiredUrl}"\ntool_timeout_sec = 120\n\n[mcp_servers.vexp.http_headers]\nAuthorization = "Bearer ${token}"\n`;
     let content = "";
     if (fs.existsSync(configPath)) {
         content = fs.readFileSync(configPath, "utf-8");
     }
     fs.mkdirSync(path.dirname(configPath), { recursive: true });
-    if (content.includes("[mcp_servers.vexp]")) {
-        // Check if already up to date (same URL and token)
-        if (content.includes(`url = "http://127.0.0.1:${mcpPort}/mcp"`) &&
-            content.includes(`Authorization = "Bearer ${token}"`))
-            return false;
-        // Remove old section(s) — handles both stdio (command=) and http (url=) formats
-        content = content.replace(/\n?\[mcp_servers\.vexp(?:\.http_headers)?\][^\[]*/g, "");
+    // Step 1: strip LEGACY vexp-* sections (not the canonical one).
+    const beforeLegacy = content.length;
+    content = content.replace(LEGACY_VEXP_TOML_SECTION_RE, "");
+    const legacyStripped = content.length !== beforeLegacy;
+    if (legacyStripped) {
+        process.stdout.write(`  · Removed legacy codex entries from ${configPath}\n`);
     }
+    // Step 2: check if the canonical section already has the desired URL+token.
+    // If yes and no legacy was stripped, this is a true no-op.
+    const canonicalOk = content.includes(`url = "${desiredUrl}"`) &&
+        content.includes(`Authorization = "Bearer ${token}"`);
+    if (canonicalOk && !legacyStripped) {
+        return false;
+    }
+    // Step 3: rewrite canonical section (strip it if present, then append).
+    content = content.replace(CANONICAL_VEXP_TOML_SECTION_RE, "");
     content += newSection;
     fs.writeFileSync(configPath, content, "utf-8");
     return true;
@@ -540,29 +620,29 @@ function writeVsCodeMcpConfig(p, binaryPath, mcpServerPath, workspaceRoot) {
             // Malformed JSON: overwrite
         }
     }
-    const servers = existing.servers;
     const useNode = mcpServerPath && fs.existsSync(mcpServerPath);
     const targetCmd = useNode ? "node" : binaryPath;
     const targetArgs = useNode ? [mcpServerPath] : ["mcp"];
     const targetEnv = workspaceRoot ? { VEXP_WORKSPACE: workspaceRoot } : undefined;
-    if (servers && "vexp" in servers) {
-        const cur = servers["vexp"];
-        if (cur?.["command"] === targetCmd &&
-            Array.isArray(cur?.["args"]) &&
-            JSON.stringify(cur["args"]) === JSON.stringify(targetArgs) &&
-            JSON.stringify(cur["env"]) === JSON.stringify(targetEnv)) {
-            return false; // Already up to date
-        }
-    }
-    existing.servers = {
-        ...(servers ?? {}),
-        vexp: {
-            type: "stdio",
-            command: targetCmd,
-            args: targetArgs,
-            ...(targetEnv ? { env: targetEnv } : {}),
-        },
+    const beforeServers = existing.servers;
+    const previousVexp = beforeServers?.["vexp"];
+    const prevArgs = Array.isArray(previousVexp?.["args"]) ? previousVexp?.["args"] : undefined;
+    const identical = previousVexp?.["command"] === targetCmd &&
+        prevArgs !== undefined &&
+        JSON.stringify(prevArgs) === JSON.stringify(targetArgs) &&
+        JSON.stringify(previousVexp?.env) === JSON.stringify(targetEnv);
+    const removed = stripLegacyVexpEntries(existing, "servers");
+    logRemoval(removed);
+    if (identical && removed.length === 0)
+        return false;
+    const servers = existing.servers ?? {};
+    servers["vexp"] = {
+        type: "stdio",
+        command: targetCmd,
+        args: targetArgs,
+        ...(targetEnv ? { env: targetEnv } : {}),
     };
+    existing.servers = servers;
     fs.mkdirSync(path.dirname(p), { recursive: true });
     fs.writeFileSync(p, JSON.stringify(existing, null, 2), "utf-8");
     return true;
@@ -580,31 +660,30 @@ function writeZedMcpConfig(p, binaryPath, mcpServerPath, workspaceRoot) {
             // Malformed JSON: overwrite
         }
     }
-    const cs = settings.context_servers;
     const useNode = mcpServerPath && fs.existsSync(mcpServerPath);
     const targetCmd = useNode ? "node" : binaryPath;
     const targetArgs = useNode ? [mcpServerPath] : ["mcp"];
     const targetEnv = workspaceRoot ? { VEXP_WORKSPACE: workspaceRoot } : undefined;
-    if (cs && "vexp" in cs) {
-        const cur = cs["vexp"];
-        const curCmd = cur?.["command"];
-        if (curCmd?.["path"] === targetCmd &&
-            Array.isArray(curCmd?.["args"]) &&
-            JSON.stringify(curCmd["args"]) === JSON.stringify(targetArgs) &&
-            JSON.stringify(curCmd["env"]) === JSON.stringify(targetEnv)) {
-            return false; // Already up to date
-        }
-    }
-    settings.context_servers = {
-        ...(cs ?? {}),
-        vexp: {
-            command: {
-                path: targetCmd,
-                args: targetArgs,
-                ...(targetEnv ? { env: targetEnv } : {}),
-            },
+    const beforeCs = settings.context_servers;
+    const previousVexp = beforeCs?.["vexp"];
+    const curCmd = previousVexp?.["command"];
+    const identical = curCmd?.["path"] === targetCmd &&
+        Array.isArray(curCmd?.["args"]) &&
+        JSON.stringify(curCmd["args"]) === JSON.stringify(targetArgs) &&
+        JSON.stringify(curCmd["env"]) === JSON.stringify(targetEnv);
+    const removed = stripLegacyVexpEntries(settings, "context_servers");
+    logRemoval(removed);
+    if (identical && removed.length === 0)
+        return false;
+    const cs = settings.context_servers ?? {};
+    cs["vexp"] = {
+        command: {
+            path: targetCmd,
+            args: targetArgs,
+            ...(targetEnv ? { env: targetEnv } : {}),
         },
     };
+    settings.context_servers = cs;
     // Pre-approve all vexp tools
     const agent = (settings.agent ?? {});
     const tp = (agent.tool_permissions ?? {});
@@ -635,27 +714,27 @@ function configureClaudeCodeGlobal(binaryPath, mcpServerPath, workspaceRoot) {
             // Malformed JSON: overwrite
         }
     }
-    const servers = config.mcpServers;
-    const existing = servers?.["vexp"];
+    const beforeServers = config.mcpServers;
+    const existing = beforeServers?.["vexp"];
     const useNode = mcpServerPath && fs.existsSync(mcpServerPath);
     const desiredCommand = useNode ? "node" : binaryPath;
     const desiredArgs = useNode ? [mcpServerPath] : ["mcp"];
     const desiredEnv = workspaceRoot ? { VEXP_WORKSPACE: workspaceRoot } : undefined;
-    // Skip if already configured with identical command+args+env
-    if (existing?.["command"] === desiredCommand &&
+    const identical = existing?.["command"] === desiredCommand &&
         Array.isArray(existing?.["args"]) &&
         JSON.stringify(existing["args"]) === JSON.stringify(desiredArgs) &&
-        JSON.stringify(existing["env"]) === JSON.stringify(desiredEnv)) {
+        JSON.stringify(existing?.env) === JSON.stringify(desiredEnv);
+    const removed = stripLegacyVexpEntries(config, "mcpServers");
+    logRemoval(removed);
+    if (identical && removed.length === 0)
         return false;
-    }
-    config.mcpServers = {
-        ...(servers ?? {}),
-        vexp: {
-            command: desiredCommand,
-            args: desiredArgs,
-            ...(desiredEnv ? { env: desiredEnv } : {}),
-        },
+    const servers = config.mcpServers ?? {};
+    servers["vexp"] = {
+        command: desiredCommand,
+        args: desiredArgs,
+        ...(desiredEnv ? { env: desiredEnv } : {}),
     };
+    config.mcpServers = servers;
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
     return true;
 }