fullcourtdefense-cli 1.14.10 → 1.14.12

package/dist/commands/discover.js

@@ -43,6 +43,7 @@ const child_process_1 = require("child_process");
 const config_1 = require("../config");
 const discoverProxy_1 = require("./discoverProxy");
 const discoverSchedule_1 = require("./discoverSchedule");
+const mcpGateway_1 = require("./mcpGateway");
 const discoverPaths_1 = require("./discoverPaths");
 const knownMcpServers_1 = require("./knownMcpServers");
 const discoverAgentFiles_1 = require("./discoverAgentFiles");
@@ -770,6 +771,17 @@ async function discoverCommand(args, config) {
     let clientCoverage = [];
     if (runMcp) {
         const candidates = candidateConfigPaths(cwd, args.extraPath);
+        // Self-heal BEFORE parsing: configs written by old CLI versions can carry a stale
+        // generic `--agent-name` that breaks dashboard policy matching. Fix them in place so
+        // every discovery run converges the fleet to the per-server identity contract.
+        const healedIdentities = (0, mcpGateway_1.healGatewayAgentIdentities)(candidates.map(c => c.path).filter(p => fs.existsSync(p)));
+        if (healedIdentities.length > 0 && !silent) {
+            console.log(`${COLOR.yellow}Healed ${healedIdentities.length} stale gateway identit${healedIdentities.length === 1 ? 'y' : 'ies'} (old CLI defaults):${COLOR.reset}`);
+            for (const heal of healedIdentities) {
+                console.log(`  ${COLOR.dim}•${COLOR.reset} ${heal.server}: ${heal.from} → ${heal.to} (${heal.file})`);
+            }
+            console.log(`${COLOR.gray}Restart the affected AI clients to pick up the corrected identity.${COLOR.reset}\n`);
+        }
         for (const c of candidates) {
             scanned.push({ path: c.path, source: c.source });
             if (fs.existsSync(c.path)) {

package/dist/commands/mcpGateway.d.ts

@@ -63,6 +63,22 @@ export interface ProtectAllArgs extends McpGatewayArgs {
     config?: string;
     clients?: string;
 }
+export interface GatewayIdentityHealResult {
+    file: string;
+    server: string;
+    from: string;
+    to: string;
+}
+/**
+ * SELF-HEAL for the policy-identity contract. Scans MCP client config files (JSON and Codex
+ * TOML) for FCD-gateway-wrapped servers whose baked-in `--agent-name` is a stale generic
+ * `<developer>-<client>` default, and rewrites it to `<developer>-<server>` so dashboard
+ * policies targeting the MCP server (`agentName contains <server>`) match at runtime.
+ *
+ * Runs automatically from `discover` and `protect-all`, so a customer machine with configs
+ * written by an old CLI version converges to the correct identity without manual edits.
+ */
+export declare function healGatewayAgentIdentities(files: string[], dryRun?: boolean): GatewayIdentityHealResult[];
 export declare function protectAllCommand(args: ProtectAllArgs, config: BotGuardConfig): Promise<void>;
 export declare function unprotectAllCommand(args: ProtectAllArgs, config: BotGuardConfig): Promise<void>;
 export declare function installClaudeCodeMcpGatewayCommand(args: InstallClaudeCodeMcpGatewayArgs, config: BotGuardConfig): Promise<void>;

package/dist/commands/mcpGateway.js

@@ -37,6 +37,7 @@ exports.ALL_GATEWAY_CLIENTS = void 0;
 exports.mcpGatewayCommand = mcpGatewayCommand;
 exports.installCursorMcpGatewayCommand = installCursorMcpGatewayCommand;
 exports.installMcpGatewayCommand = installMcpGatewayCommand;
+exports.healGatewayAgentIdentities = healGatewayAgentIdentities;
 exports.protectAllCommand = protectAllCommand;
 exports.unprotectAllCommand = unprotectAllCommand;
 exports.installClaudeCodeMcpGatewayCommand = installClaudeCodeMcpGatewayCommand;
@@ -967,7 +968,7 @@ function clientInstallArgs(args) {
     };
 }
 async function installCursorMcpGatewayCommand(args, config) {
-    const gatewayConfig = resolveGatewayConfig(args, config, {
+    const baseGatewayConfig = resolveGatewayConfig(args, config, {
         agentClient: 'cursor',
         agentNamePrefix: 'cursor',
         userObjective: 'Developer requested this action from Cursor.',
@@ -976,6 +977,7 @@ async function installCursorMcpGatewayCommand(args, config) {
     const file = cursorMcpPath(projectScope);
     const nodeExe = process.execPath;
     const serverName = args.serverName || MANAGED_SERVER_NAME;
+    const gatewayConfig = applyPerServerAgentName(baseGatewayConfig, args, serverName);
     const downstreamCommand = args.mcpCommand || process.env.FCD_MCP_COMMAND;
     if (!downstreamCommand)
         throw new Error('Pass --mcp-command for the real MCP server you want to protect.');
@@ -1141,6 +1143,147 @@ function backupFile(file) {
 function perServerAgentName(developerName, _agentClient, serverName) {
     return `${safeIdentityPart(developerName)}-${safeIdentityPart(serverName)}`;
 }
+/**
+ * Generic `<developer>-<client>` identities that pre-1.14.11 per-server installs baked into
+ * configs. These are the ONLY values self-heal is allowed to rewrite — a custom --agent-name
+ * an admin chose on purpose is never touched.
+ */
+const GENERIC_CLIENT_AGENT_SUFFIXES = ['cursor', 'claude-code', 'claude-desktop', 'codex', 'gemini', 'gemini-cli', 'windsurf', 'vscode'];
+/**
+ * Rewrite a wrapped entry's `--agent-name` to the per-server contract (`<developer>-<server>`)
+ * when it still carries a known-buggy generic client default. Mutates `args` in place.
+ */
+function healAgentNameInArgs(args, serverName) {
+    const nameIdx = args.indexOf('--agent-name');
+    if (nameIdx === -1 || nameIdx + 1 >= args.length)
+        return { changed: false };
+    const current = String(args[nameIdx + 1]);
+    const devIdx = args.indexOf('--developer-name');
+    const developerName = devIdx !== -1 && args[devIdx + 1] ? String(args[devIdx + 1]) : machineScopedUser();
+    const devPart = safeIdentityPart(developerName);
+    const expected = `${devPart}-${safeIdentityPart(serverName)}`;
+    if (current === expected)
+        return { changed: false };
+    const isGenericDefault = GENERIC_CLIENT_AGENT_SUFFIXES.some(suffix => current === `${devPart}-${suffix}`);
+    if (!isGenericDefault)
+        return { changed: false };
+    args[nameIdx + 1] = expected;
+    return { changed: true, from: current, to: expected };
+}
+/**
+ * SELF-HEAL for the policy-identity contract. Scans MCP client config files (JSON and Codex
+ * TOML) for FCD-gateway-wrapped servers whose baked-in `--agent-name` is a stale generic
+ * `<developer>-<client>` default, and rewrites it to `<developer>-<server>` so dashboard
+ * policies targeting the MCP server (`agentName contains <server>`) match at runtime.
+ *
+ * Runs automatically from `discover` and `protect-all`, so a customer machine with configs
+ * written by an old CLI version converges to the correct identity without manual edits.
+ */
+function healGatewayAgentIdentities(files, dryRun = false) {
+    const healed = [];
+    const seen = new Set();
+    for (const file of files) {
+        let resolvedKey;
+        try {
+            resolvedKey = path.resolve(file).toLowerCase();
+        }
+        catch {
+            continue;
+        }
+        if (seen.has(resolvedKey))
+            continue;
+        seen.add(resolvedKey);
+        if (/\.toml$/i.test(file)) {
+            healed.push(...healCodexTomlAgentIdentities(file, dryRun));
+            continue;
+        }
+        let raw;
+        try {
+            raw = fs.readFileSync(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        let json;
+        try {
+            json = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        const maps = collectJsonServerMaps(json);
+        let changed = false;
+        for (const map of maps) {
+            for (const [name, entry] of Object.entries(map)) {
+                if (name === MANAGED_SERVER_NAME || !isGatewayWrappedEntry(entry))
+                    continue;
+                const args = Array.isArray(entry.args) ? entry.args.map(String) : [];
+                const result = healAgentNameInArgs(args, name);
+                if (result.changed) {
+                    entry.args = args;
+                    healed.push({ file, server: name, from: result.from, to: result.to });
+                    changed = true;
+                }
+            }
+        }
+        if (changed && !dryRun) {
+            backupFile(file);
+            fs.writeFileSync(file, `${JSON.stringify(json, null, 2)}\n`, 'utf8');
+        }
+    }
+    return healed;
+}
+/** Codex config.toml variant of the identity self-heal (args are written as a JSON-style array). */
+function healCodexTomlAgentIdentities(file, dryRun) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const healed = [];
+    const updated = raw.replace(/\[mcp_servers\.("?)([^\]"]+)\1\]([\s\S]*?)(?=\n\[|$)/g, (section, _q, serverName, body) => {
+        if (serverName === MANAGED_SERVER_NAME || !body.includes('mcp-gateway'))
+            return section;
+        const newBody = body.replace(/("--agent-name",\s*")([^"]+)(")/, (m, pre, current, post) => {
+            const devMatch = body.match(/"--developer-name",\s*"([^"]+)"/);
+            const devPart = safeIdentityPart(devMatch?.[1] || machineScopedUser());
+            const expected = `${devPart}-${safeIdentityPart(serverName)}`;
+            if (current === expected)
+                return m;
+            const isGenericDefault = GENERIC_CLIENT_AGENT_SUFFIXES.some(suffix => current === `${devPart}-${suffix}`);
+            if (!isGenericDefault)
+                return m;
+            healed.push({ file, server: serverName, from: current, to: expected });
+            return `${pre}${expected}${post}`;
+        });
+        return section.replace(body, newBody);
+    });
+    if (healed.length > 0 && !dryRun) {
+        backupFile(file);
+        fs.writeFileSync(file, updated, 'utf8');
+    }
+    return healed;
+}
+/**
+ * Per-server installs (`install-*-mcp-gateway --server-name foo`) must report the SAME
+ * runtime-agnostic agent identity that protect-all/auto-protect produce (`<developer>-<server>`).
+ * Otherwise the gateway reports a generic `<developer>-<client>` name and a dashboard policy
+ * targeting the MCP server (agentName contains <server>) silently never matches — the exact
+ * bug where a block policy on `patria-bank-finance` did not fire because the Claude Desktop
+ * entry reported `boazl-claude-desktop`. An explicit --agent-name / FCD_AGENT_NAME still wins.
+ */
+function applyPerServerAgentName(gatewayConfig, args, serverName) {
+    if (args.agentName || process.env.FCD_AGENT_NAME)
+        return gatewayConfig;
+    if (!serverName || serverName === MANAGED_SERVER_NAME)
+        return gatewayConfig;
+    return {
+        ...gatewayConfig,
+        agentName: perServerAgentName(gatewayConfig.developerName, gatewayConfig.agentClient, serverName),
+    };
+}
 function wrapJsonConfigFile(file, gatewayConfig, agentClient, dryRun) {
     const stats = newWrapStats();
     let json;
@@ -1411,6 +1554,15 @@ async function protectAllCommand(args, config) {
         return;
     }
     console.log(`\x1b[2mAuto-searching every known MCP client on this machine — ${files.length} config file(s) found.\x1b[0m\n`);
+    // Converge stale generic gateway identities (old CLI defaults) to the per-server
+    // contract before wrapping, so policy matching works on already-wrapped entries too.
+    const healedIdentities = healGatewayAgentIdentities(files.map(f => f.path), dryRun);
+    if (healedIdentities.length > 0) {
+        console.log(`\x1b[32m✓ ${dryRun ? 'would fix' : 'fixed'} ${healedIdentities.length} stale gateway identit${healedIdentities.length === 1 ? 'y' : 'ies'}:\x1b[0m`);
+        for (const heal of healedIdentities)
+            console.log(`  \x1b[2m•\x1b[0m ${heal.server}: ${heal.from} → ${heal.to}`);
+        console.log('');
+    }
     let totalWrapped = 0;
     let totalHealed = 0;
     let totalManaged = 0;
@@ -1495,7 +1647,7 @@ async function unprotectAllCommand(args, config) {
     console.log(`\n${dryRun ? 'Would restore' : 'Restored'} ${total} server(s) to their original commands. Restart each client.`);
 }
 async function installClaudeCodeMcpGatewayCommand(args, config) {
-    const gatewayConfig = resolveGatewayConfig(args, config, {
+    const baseGatewayConfig = resolveGatewayConfig(args, config, {
         agentClient: 'claude-code',
         agentNamePrefix: 'claude-code',
         userObjective: 'Developer requested this action from Claude Code.',
@@ -1503,6 +1655,7 @@ async function installClaudeCodeMcpGatewayCommand(args, config) {
     const scope = normalizeClaudeCodeScope(args.scope);
     const nodeExe = process.execPath;
     const serverName = args.serverName || MANAGED_SERVER_NAME;
+    const gatewayConfig = applyPerServerAgentName(baseGatewayConfig, args, serverName);
     const downstreamCommand = args.mcpCommand || process.env.FCD_MCP_COMMAND;
     if (!downstreamCommand)
         throw new Error('Pass --mcp-command for the real MCP server you want to protect.');
@@ -1513,7 +1666,13 @@ async function installClaudeCodeMcpGatewayCommand(args, config) {
         includeShieldKey,
     });
     const claudeArgs = ['mcp', 'add', '--scope', scope, '--transport', 'stdio', serverName, '--', nodeExe, ...commandArgs];
-    let result = (0, child_process_1.spawnSync)('claude', claudeArgs, {
+    // On Windows `claude` is a .cmd shim, so spawnSync needs shell:true — but with shell:true
+    // Node does NOT quote args. Unquoted args with spaces/JSON (e.g. --mcp-args '["C:\\..."]',
+    // --user-objective 'Developer requested...') get word-split by cmd.exe and written mangled
+    // into the config. Quote them ourselves before handing the line to the shell.
+    const shellQuote = (value) => (/[\s"]/.test(value) ? `"${value.replace(/"/g, '\\"')}"` : value);
+    const spawnClaudeArgs = process.platform === 'win32' ? claudeArgs.map(shellQuote) : claudeArgs;
+    let result = (0, child_process_1.spawnSync)('claude', spawnClaudeArgs, {
         stdio: 'inherit',
         shell: process.platform === 'win32',
     });
@@ -1523,7 +1682,7 @@ async function installClaudeCodeMcpGatewayCommand(args, config) {
             shell: process.platform === 'win32',
         });
         if (removeResult.status === 0) {
-            result = (0, child_process_1.spawnSync)('claude', claudeArgs, {
+            result = (0, child_process_1.spawnSync)('claude', spawnClaudeArgs, {
                 stdio: 'inherit',
                 shell: process.platform === 'win32',
             });
@@ -1555,7 +1714,7 @@ async function installClaudeCodeMcpGatewayCommand(args, config) {
     throw new Error('Claude Code CLI was not available. Install Claude Code or rerun with --scope project to write .mcp.json directly.');
 }
 async function installClaudeDesktopMcpGatewayCommand(args, config) {
-    const gatewayConfig = resolveGatewayConfig(args, config, {
+    const baseGatewayConfig = resolveGatewayConfig(args, config, {
         agentClient: 'claude-desktop',
         agentNamePrefix: 'claude-desktop',
         userObjective: 'Developer requested this action from Claude Desktop.',
@@ -1563,6 +1722,7 @@ async function installClaudeDesktopMcpGatewayCommand(args, config) {
     const targets = (0, discoverPaths_1.claudeDesktopInstallTargets)(args.configPath);
     const nodeExe = process.execPath;
     const serverName = args.serverName || MANAGED_SERVER_NAME;
+    const gatewayConfig = applyPerServerAgentName(baseGatewayConfig, args, serverName);
     const downstreamCommand = args.mcpCommand || process.env.FCD_MCP_COMMAND;
     if (!downstreamCommand)
         throw new Error('Pass --mcp-command for the real MCP server you want to protect.');
@@ -1580,7 +1740,7 @@ async function installClaudeDesktopMcpGatewayCommand(args, config) {
     console.log('Restart Claude Desktop to load the protected tools.');
 }
 async function installCodexMcpGatewayCommand(args, config) {
-    const gatewayConfig = resolveGatewayConfig(args, config, {
+    const baseGatewayConfig = resolveGatewayConfig(args, config, {
         agentClient: 'codex',
         agentNamePrefix: 'codex',
         userObjective: 'Developer requested this action from Codex.',
@@ -1589,6 +1749,7 @@ async function installCodexMcpGatewayCommand(args, config) {
     const file = codexConfigPath(projectScope);
     const nodeExe = process.execPath;
     const serverName = args.serverName || MANAGED_SERVER_NAME;
+    const gatewayConfig = applyPerServerAgentName(baseGatewayConfig, args, serverName);
     const downstreamCommand = args.mcpCommand || process.env.FCD_MCP_COMMAND;
     if (!downstreamCommand)
         throw new Error('Pass --mcp-command for the real MCP server you want to protect.');
@@ -1601,7 +1762,7 @@ async function installCodexMcpGatewayCommand(args, config) {
     console.log('Restart Codex or reload MCP servers. Project config requires a trusted project.');
 }
 async function installGeminiMcpGatewayCommand(args, config) {
-    const gatewayConfig = resolveGatewayConfig(args, config, {
+    const baseGatewayConfig = resolveGatewayConfig(args, config, {
         agentClient: 'gemini-cli',
         agentNamePrefix: 'gemini',
         userObjective: 'Developer requested this action from Gemini CLI.',
@@ -1610,6 +1771,7 @@ async function installGeminiMcpGatewayCommand(args, config) {
     const file = geminiSettingsPath(projectScope);
     const nodeExe = process.execPath;
     const serverName = args.serverName || MANAGED_SERVER_NAME;
+    const gatewayConfig = applyPerServerAgentName(baseGatewayConfig, args, serverName);
     const downstreamCommand = args.mcpCommand || process.env.FCD_MCP_COMMAND;
     if (!downstreamCommand)
         throw new Error('Pass --mcp-command for the real MCP server you want to protect.');
@@ -1622,7 +1784,7 @@ async function installGeminiMcpGatewayCommand(args, config) {
     console.log('Restart Gemini CLI to load the protected tools.');
 }
 async function installWindsurfMcpGatewayCommand(args, config) {
-    const gatewayConfig = resolveGatewayConfig(args, config, {
+    const baseGatewayConfig = resolveGatewayConfig(args, config, {
         agentClient: 'windsurf',
         agentNamePrefix: 'windsurf',
         userObjective: 'Developer requested this action from Windsurf.',
@@ -1630,6 +1792,7 @@ async function installWindsurfMcpGatewayCommand(args, config) {
     const file = windsurfConfigPath();
     const nodeExe = process.execPath;
     const serverName = args.serverName || MANAGED_SERVER_NAME;
+    const gatewayConfig = applyPerServerAgentName(baseGatewayConfig, args, serverName);
     const downstreamCommand = args.mcpCommand || process.env.FCD_MCP_COMMAND;
     if (!downstreamCommand)
         throw new Error('Pass --mcp-command for the real MCP server you want to protect.');
@@ -1642,7 +1805,7 @@ async function installWindsurfMcpGatewayCommand(args, config) {
     console.log('Restart Windsurf to load the protected tools.');
 }
 async function installVscodeMcpGatewayCommand(args, config) {
-    const gatewayConfig = resolveGatewayConfig(args, config, {
+    const baseGatewayConfig = resolveGatewayConfig(args, config, {
         agentClient: 'vscode',
         agentNamePrefix: 'vscode',
         userObjective: 'Developer requested this action from VS Code.',
@@ -1650,6 +1813,7 @@ async function installVscodeMcpGatewayCommand(args, config) {
     const projectScope = args.project !== 'false';
     const nodeExe = process.execPath;
     const serverName = args.serverName || MANAGED_SERVER_NAME;
+    const gatewayConfig = applyPerServerAgentName(baseGatewayConfig, args, serverName);
     const downstreamCommand = args.mcpCommand || process.env.FCD_MCP_COMMAND;
     if (!downstreamCommand)
         throw new Error('Pass --mcp-command for the real MCP server you want to protect.');

package/dist/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.14.10"
+  "version": "1.14.12"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullcourtdefense-cli",
-  "version": "1.14.10",
+  "version": "1.14.12",
   "description": "Full Court Defense CLI — security scanning for AI agents from your terminal",
   "main": "dist/index.js",
   "bin": {
@@ -24,6 +24,7 @@
     "test:agent-file-posture": "npm run build && node scripts/test-agent-file-posture.js",
     "test:realworld-posture": "npm run build && node scripts/test-realworld-posture-fixtures.js",
     "test:discover-stdio-mcp": "npm run build && node scripts/test-discover-stdio-mcp-tools.js",
+    "test:per-server-agent-name": "npm run build && node scripts/test-per-server-agent-name.js",
     "test:posture-blast": "npm run build && node scripts/test-posture-blast-radius.js",
     "test:ping-e2e": "npm run build && node scripts/test-ping-e2e.js",
     "prepublishOnly": "npm run build"