fullcourtdefense-cli 1.14.11 → 1.14.13

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/discoverProxy.d.ts

@@ -25,6 +25,7 @@ export declare function isFcdGatewayServer(server: ProxyClassifiableServer): boo
 export declare function extractGatewayDownstream(server: ProxyClassifiableServer): {
     command?: string;
     args?: string[];
+    url?: string;
     label?: string;
 } | null;
 /** Per-client downstream targets wrapped by FCD gateway entries in the same config file. */

package/dist/commands/discoverProxy.js

@@ -64,6 +64,16 @@ function isFcdGatewayServer(server) {
 }
 function extractGatewayDownstream(server) {
     const args = server.args || [];
+    const urlIdx = args.indexOf('--mcp-url');
+    if (urlIdx >= 0 && args[urlIdx + 1]) {
+        const url = args[urlIdx + 1];
+        let label;
+        try {
+            label = new URL(url).hostname;
+        }
+        catch { /* leave undefined */ }
+        return { url, label };
+    }
     const cmdIdx = args.indexOf('--mcp-command');
     if (cmdIdx < 0 || !args[cmdIdx + 1])
         return null;
@@ -138,6 +148,8 @@ function buildGatewayWrapIndex(servers) {
                 wrapped.add(downstream.label.toLowerCase());
             if (downstream?.command)
                 wrapped.add(downstreamFingerprint(downstream.command, downstream.args));
+            if (downstream?.url)
+                wrapped.add(downstream.url.toLowerCase());
             wrapped.add(server.serverName.toLowerCase());
         }
         wrapsByConfig.set(configPath, wrapped);

package/dist/commands/mcpGateway.d.ts

@@ -5,6 +5,10 @@ export declare const ALL_GATEWAY_CLIENTS: GatewayClient[];
 export interface McpGatewayArgs {
     mcpCommand?: string;
     mcpArgs?: string;
+    /** Remote MCP server URL (Streamable HTTP / SSE) — alternative to --mcp-command. */
+    mcpUrl?: string;
+    /** Optional JSON object of extra HTTP headers for the remote MCP (e.g. auth). */
+    mcpHeaders?: string;
     agentName?: string;
     agentClient?: string;
     developerName?: string;
@@ -55,6 +59,20 @@ export interface InstallMcpGatewayArgs extends McpGatewayArgs {
     upload?: string;
     apiKey?: string;
 }
+/**
+ * How the gateway reaches the real MCP server: spawn a local process (stdio)
+ * or speak Streamable HTTP/SSE to a remote URL. Both flow through the exact
+ * same policy enforcement in McpGatewayServer.
+ */
+export type DownstreamSpec = {
+    kind: 'stdio';
+    command: string;
+    args: string[];
+} | {
+    kind: 'http';
+    url: string;
+    headers?: Record<string, string>;
+};
 export declare function mcpGatewayCommand(args: McpGatewayArgs, config: BotGuardConfig): Promise<void>;
 export declare function installCursorMcpGatewayCommand(args: InstallCursorMcpGatewayArgs, config: BotGuardConfig): Promise<void>;
 export declare function installMcpGatewayCommand(args: InstallMcpGatewayArgs, config: BotGuardConfig): Promise<void>;
@@ -63,6 +81,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;
@@ -78,6 +79,18 @@ const CLIENT_LABELS = {
     windsurf: 'Windsurf',
     vscode: 'VS Code',
 };
+function parseHeadersFlag(value) {
+    if (!value?.trim())
+        return undefined;
+    try {
+        const parsed = JSON.parse(value);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return Object.fromEntries(Object.entries(parsed).map(([k, v]) => [k, String(v)]));
+        }
+    }
+    catch { /* fall through */ }
+    throw new Error('--mcp-headers must be a JSON object, e.g. {"Authorization":"Bearer ..."}');
+}
 function parseArgsList(value) {
     if (!value?.trim())
         return [];
@@ -398,6 +411,127 @@ class StdioMcpClient {
         this.pending.clear();
     }
 }
+/**
+ * Downstream client for remote HTTP/SSE MCP servers (MCP Streamable HTTP
+ * transport). JSON-RPC messages are POSTed to the server; responses may come
+ * back as plain JSON or as a text/event-stream body. Session continuity uses
+ * the Mcp-Session-Id header. Endpoint variants (base, /mcp, stripped /sse)
+ * are tried on initialize — the first one that answers wins.
+ */
+class HttpMcpClient {
+    url;
+    extraHeaders;
+    endpoint;
+    sessionId;
+    nextId = 1;
+    constructor(url, extraHeaders = {}) {
+        this.url = url;
+        this.extraHeaders = extraHeaders;
+        if (!url)
+            throw new Error('Missing downstream MCP URL. Pass --mcp-url.');
+    }
+    async initialize() {
+        const normalized = this.url.replace(/\/$/, '');
+        const candidates = [...new Set([
+                normalized,
+                normalized.replace(/\/sse(\?.*)?$/i, ''),
+                `${normalized}/mcp`,
+                normalized.replace(/\/sse(\?.*)?$/i, '/mcp'),
+            ])].filter(Boolean);
+        let lastError;
+        for (const endpoint of candidates) {
+            try {
+                const init = await this.post(endpoint, 'initialize', {
+                    protocolVersion: '2024-11-05',
+                    capabilities: {},
+                    clientInfo: { name: 'agentguard-mcp-gateway', version: '0.1.0' },
+                }, 15000);
+                if (init?.error) {
+                    lastError = new Error(init.error.message || `MCP initialize failed at ${endpoint}`);
+                    continue;
+                }
+                this.endpoint = endpoint;
+                await this.post(endpoint, 'notifications/initialized', {}, 15000, true).catch(() => undefined);
+                return;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+            }
+        }
+        throw lastError || new Error(`Could not initialize remote MCP server at ${this.url}`);
+    }
+    async listTools() {
+        const response = await this.request('tools/list', {});
+        const tools = response?.tools;
+        if (!Array.isArray(tools))
+            return [];
+        return tools
+            .filter(tool => typeof tool.name === 'string')
+            .map(tool => ({
+            name: String(tool.name),
+            description: typeof tool.description === 'string'
+                ? String(tool.description)
+                : undefined,
+            inputSchema: tool.inputSchema,
+        }));
+    }
+    async callTool(name, args) {
+        return this.request('tools/call', { name, arguments: args });
+    }
+    close() {
+        // Stateless HTTP transport — nothing to tear down.
+    }
+    async request(method, params) {
+        if (!this.endpoint)
+            throw new Error('Remote MCP client not initialized.');
+        const message = await this.post(this.endpoint, method, params, 60000);
+        if (message?.error)
+            throw new Error(message.error.message || `MCP request failed: ${method}`);
+        return message?.result;
+    }
+    async post(endpoint, method, params, timeoutMs, isNotification = false) {
+        const headers = {
+            'Content-Type': 'application/json',
+            Accept: 'application/json, text/event-stream',
+            ...this.extraHeaders,
+        };
+        if (this.sessionId)
+            headers['Mcp-Session-Id'] = this.sessionId;
+        const body = { jsonrpc: '2.0', method, params };
+        if (!isNotification)
+            body.id = this.nextId++;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const resp = await fetch(endpoint, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            const nextSession = resp.headers.get('mcp-session-id');
+            if (nextSession)
+                this.sessionId = nextSession;
+            if (isNotification)
+                return null;
+            if (!resp.ok && resp.status !== 202) {
+                throw new Error(`Remote MCP server returned HTTP ${resp.status} for ${method}`);
+            }
+            const contentType = resp.headers.get('content-type') || '';
+            if (contentType.includes('text/event-stream')) {
+                const text = await resp.text();
+                const dataLine = text.split('\n').find(line => line.startsWith('data: '));
+                if (!dataLine)
+                    throw new Error(`Remote MCP server sent an empty event stream for ${method}`);
+                return JSON.parse(dataLine.slice(6));
+            }
+            return await resp.json();
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
 class AgentGuardApi {
     config;
     constructor(config) {
@@ -514,16 +648,14 @@ class AgentGuardApi {
 }
 class McpGatewayServer {
     gatewayConfig;
-    downstreamCommand;
-    downstreamArgs;
+    downstreamSpec;
     downstream;
     downstreamReady;
     buffer = '';
     api;
-    constructor(gatewayConfig, downstreamCommand, downstreamArgs) {
+    constructor(gatewayConfig, downstreamSpec) {
         this.gatewayConfig = gatewayConfig;
-        this.downstreamCommand = downstreamCommand;
-        this.downstreamArgs = downstreamArgs;
+        this.downstreamSpec = downstreamSpec;
         this.api = new AgentGuardApi(gatewayConfig);
     }
     start() {
@@ -580,7 +712,9 @@ class McpGatewayServer {
     }
     async ensureDownstream() {
         if (!this.downstreamReady) {
-            this.downstream = new StdioMcpClient(this.downstreamCommand, this.downstreamArgs);
+            this.downstream = this.downstreamSpec.kind === 'http'
+                ? new HttpMcpClient(this.downstreamSpec.url, this.downstreamSpec.headers)
+                : new StdioMcpClient(this.downstreamSpec.command, this.downstreamSpec.args);
             this.downstreamReady = this.downstream.initialize();
         }
         await this.downstreamReady;
@@ -721,10 +855,17 @@ class McpGatewayServer {
 }
 async function mcpGatewayCommand(args, config) {
     const gatewayConfig = resolveGatewayConfig(args, config);
-    const downstreamCommand = args.mcpCommand || process.env.FCD_MCP_COMMAND || '';
-    const downstreamArgs = parseArgsList(args.mcpArgs || process.env.FCD_MCP_ARGS);
-    const server = new McpGatewayServer(gatewayConfig, downstreamCommand, downstreamArgs);
-    process.stderr.write(`AgentGuard MCP Gateway running for ${gatewayConfig.agentName}. Downstream: ${downstreamCommand} ${downstreamArgs.join(' ')}\n`);
+    const downstreamUrl = args.mcpUrl || process.env.FCD_MCP_URL || '';
+    const spec = downstreamUrl
+        ? { kind: 'http', url: downstreamUrl, headers: parseHeadersFlag(args.mcpHeaders || process.env.FCD_MCP_HEADERS) }
+        : {
+            kind: 'stdio',
+            command: args.mcpCommand || process.env.FCD_MCP_COMMAND || '',
+            args: parseArgsList(args.mcpArgs || process.env.FCD_MCP_ARGS),
+        };
+    const server = new McpGatewayServer(gatewayConfig, spec);
+    const downstreamLabel = spec.kind === 'http' ? spec.url : `${spec.command} ${spec.args.join(' ')}`;
+    process.stderr.write(`AgentGuard MCP Gateway running for ${gatewayConfig.agentName}. Downstream: ${downstreamLabel}\n`);
     server.start();
 }
 function cursorMcpPath(projectScope) {
@@ -750,12 +891,38 @@ function readJson(file) {
 function gatewayScriptPath() {
     return path.resolve(process.argv[1] || path.join(__dirname, '..', 'index.js'));
 }
-function buildGatewayCommandArgs(gatewayConfig, downstreamCommand, downstreamArgs, options = {}) {
+/**
+ * Resolve which real MCP server an installer should protect: a local stdio
+ * command (--mcp-command/--mcp-args) or a remote HTTP/SSE URL (--mcp-url,
+ * optionally with --mcp-headers for auth).
+ */
+function resolveDownstreamSpec(args) {
+    const url = args.mcpUrl || process.env.FCD_MCP_URL;
+    if (url) {
+        return { kind: 'http', url, headers: parseHeadersFlag(args.mcpHeaders || process.env.FCD_MCP_HEADERS) };
+    }
+    const command = args.mcpCommand || process.env.FCD_MCP_COMMAND;
+    if (!command) {
+        throw new Error('Pass --mcp-command (local stdio MCP) or --mcp-url (remote HTTP/SSE MCP) for the server you want to protect.');
+    }
+    return { kind: 'stdio', command, args: parseArgsList(args.mcpArgs || process.env.FCD_MCP_ARGS) };
+}
+function downstreamSpecLabel(spec) {
+    return spec.kind === 'http' ? spec.url : `${spec.command} ${spec.args.join(' ')}`.trim();
+}
+function buildGatewayCommandArgs(gatewayConfig, downstream, options = {}) {
+    const downstreamFlags = downstream.kind === 'http'
+        ? [
+            '--mcp-url', downstream.url,
+            ...(downstream.headers && Object.keys(downstream.headers).length > 0
+                ? ['--mcp-headers', JSON.stringify(downstream.headers)]
+                : []),
+        ]
+        : ['--mcp-command', downstream.command, '--mcp-args', JSON.stringify(downstream.args)];
     const commandArgs = [
         gatewayScriptPath(),
         'mcp-gateway',
-        '--mcp-command', downstreamCommand,
-        '--mcp-args', JSON.stringify(downstreamArgs),
+        ...downstreamFlags,
         '--agent-name', gatewayConfig.agentName,
         '--agent-client', gatewayConfig.agentClient,
         '--developer-name', gatewayConfig.developerName,
@@ -977,16 +1144,13 @@ async function installCursorMcpGatewayCommand(args, config) {
     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.');
-    const downstreamArgs = parseArgsList(args.mcpArgs || process.env.FCD_MCP_ARGS);
-    const commandArgs = buildGatewayCommandArgs(gatewayConfig, downstreamCommand, downstreamArgs, INSTALL_GATEWAY_ARGS);
+    const downstream = resolveDownstreamSpec(args);
+    const commandArgs = buildGatewayCommandArgs(gatewayConfig, downstream, INSTALL_GATEWAY_ARGS);
     writeMcpServerConfig(file, serverName, nodeExe, commandArgs);
     console.log(`AgentGuard MCP Gateway installed for Cursor (${projectScope ? 'project' : 'global'}).`);
     console.log(`Config: ${file}`);
     console.log(`Server: ${serverName}`);
-    console.log(`Downstream: ${downstreamCommand} ${downstreamArgs.join(' ')}`);
+    console.log(`Downstream: ${downstreamSpecLabel(downstream)}`);
     console.log('Restart Cursor or reload MCP servers to use the protected tools.');
 }
 async function installMcpGatewayCommand(args, config) {
@@ -1091,9 +1255,21 @@ function wrappedEntryNeedsHeal(entry) {
     const args = Array.isArray(entry?.args) ? entry.args.map(String) : [];
     return args.includes('--shield-id') && !args.includes('--shield-key');
 }
-/** Recover the original downstream command+args from a wrapped entry's args. */
+/** Recover the original downstream server (stdio command or remote URL) from a wrapped entry's args. */
 function extractWrappedDownstream(entry) {
     const args = Array.isArray(entry?.args) ? entry.args.map(String) : [];
+    const ui = args.indexOf('--mcp-url');
+    if (ui !== -1 && args[ui + 1]) {
+        let headers;
+        const hi = args.indexOf('--mcp-headers');
+        if (hi !== -1 && args[hi + 1]) {
+            try {
+                headers = parseHeadersFlag(args[hi + 1]);
+            }
+            catch { /* leave undefined */ }
+        }
+        return { kind: 'http', url: args[ui + 1], headers };
+    }
     const ci = args.indexOf('--mcp-command');
     if (ci === -1 || ci + 1 >= args.length)
         return null;
@@ -1108,7 +1284,7 @@ function extractWrappedDownstream(entry) {
         }
         catch { /* leave empty */ }
     }
-    return { command, args: downstreamArgs };
+    return { kind: 'stdio', command, args: downstreamArgs };
 }
 /** All server maps inside a parsed JSON config, across every known client shape. */
 function collectJsonServerMaps(json) {
@@ -1142,6 +1318,129 @@ 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>`).
@@ -1190,7 +1489,7 @@ function wrapJsonConfigFile(file, gatewayConfig, agentClient, dryRun) {
                     if (downstream) {
                         const perServer = { ...gatewayConfig, agentClient, agentName: perServerAgentName(gatewayConfig.developerName, agentClient, name) };
                         entry.command = nodeExe;
-                        entry.args = buildGatewayCommandArgs(perServer, downstream.command, downstream.args, INSTALL_GATEWAY_ARGS);
+                        entry.args = buildGatewayCommandArgs(perServer, downstream, INSTALL_GATEWAY_ARGS);
                         stats.healed.push(name);
                         changed = true;
                         continue;
@@ -1199,14 +1498,35 @@ function wrapJsonConfigFile(file, gatewayConfig, agentClient, dryRun) {
                 stats.skippedManaged.push(name);
                 continue;
             }
+            const perServer = { ...gatewayConfig, agentClient, agentName: perServerAgentName(gatewayConfig.developerName, agentClient, name) };
             if (typeof entry.command !== 'string' || !entry.command) {
-                stats.skippedRemote.push(name);
+                // Remote HTTP/SSE MCP: wrap the URL behind a local stdio gateway that
+                // enforces policies, then forwards over Streamable HTTP. Original url,
+                // headers, and transport type are baked into the args for full unwrap.
+                const remoteUrl = typeof entry.url === 'string' && entry.url
+                    ? entry.url
+                    : (typeof entry.serverUrl === 'string' ? entry.serverUrl : '');
+                if (!remoteUrl || !/^https?:\/\//i.test(remoteUrl)) {
+                    stats.skippedRemote.push(name);
+                    continue;
+                }
+                const headers = entry.headers && typeof entry.headers === 'object' && !Array.isArray(entry.headers)
+                    ? Object.fromEntries(Object.entries(entry.headers).map(([k, v]) => [k, String(v)]))
+                    : undefined;
+                entry.command = nodeExe;
+                entry.args = buildGatewayCommandArgs(perServer, { kind: 'http', url: remoteUrl, headers }, INSTALL_GATEWAY_ARGS);
+                delete entry.url;
+                delete entry.serverUrl;
+                delete entry.headers;
+                if (typeof entry.type === 'string')
+                    entry.type = 'stdio'; // VS Code-style configs must match the new transport
+                stats.wrapped.push(name);
+                changed = true;
                 continue;
             }
             const downstreamCommand = entry.command;
             const downstreamArgs = Array.isArray(entry.args) ? entry.args.map(String) : [];
-            const perServer = { ...gatewayConfig, agentClient, agentName: perServerAgentName(gatewayConfig.developerName, agentClient, name) };
-            const wrappedArgs = buildGatewayCommandArgs(perServer, downstreamCommand, downstreamArgs, INSTALL_GATEWAY_ARGS);
+            const wrappedArgs = buildGatewayCommandArgs(perServer, { kind: 'stdio', command: downstreamCommand, args: downstreamArgs }, INSTALL_GATEWAY_ARGS);
             entry.command = nodeExe;
             entry.args = wrappedArgs;
             // entry.env and any other fields are preserved as-is.
@@ -1245,8 +1565,19 @@ function unwrapJsonConfigFile(file, dryRun) {
             const downstream = extractWrappedDownstream(entry);
             if (!downstream)
                 continue;
-            entry.command = downstream.command;
-            entry.args = downstream.args;
+            if (downstream.kind === 'http') {
+                delete entry.command;
+                delete entry.args;
+                entry.url = downstream.url;
+                if (downstream.headers && Object.keys(downstream.headers).length > 0)
+                    entry.headers = downstream.headers;
+                if (typeof entry.type === 'string')
+                    entry.type = /\/sse(\?|$)/i.test(downstream.url) ? 'sse' : 'http';
+            }
+            else {
+                entry.command = downstream.command;
+                entry.args = downstream.args;
+            }
             restored.push(name);
             changed = true;
         }
@@ -1357,7 +1688,7 @@ function transformCodexToml(file, mode, gatewayConfig, dryRun) {
                 continue;
             }
             const perServer = { ...gatewayConfig, agentClient: 'codex', agentName: perServerAgentName(gatewayConfig.developerName, 'codex', section.name) };
-            const wrappedArgs = buildGatewayCommandArgs(perServer, section.command, section.args || [], INSTALL_GATEWAY_ARGS);
+            const wrappedArgs = buildGatewayCommandArgs(perServer, { kind: 'stdio', command: section.command, args: section.args || [] }, INSTALL_GATEWAY_ARGS);
             const indent = lines[section.cmdLine].match(/^\s*/)?.[0] || '';
             lines[section.cmdLine] = `${indent}command = ${JSON.stringify(nodeExe)}`;
             const argsLineText = `${indent}args = ${tomlStringArrayLiteral(wrappedArgs)}`;
@@ -1372,7 +1703,8 @@ function transformCodexToml(file, mode, gatewayConfig, dryRun) {
             if (!wrappedAlready)
                 continue;
             const downstream = extractWrappedDownstream({ args: section.args });
-            if (!downstream)
+            // Codex TOML wraps are always stdio (remote URLs never get wrapped into TOML).
+            if (!downstream || downstream.kind !== 'stdio')
                 continue;
             const indent = lines[section.cmdLine].match(/^\s*/)?.[0] || '';
             lines[section.cmdLine] = `${indent}command = ${JSON.stringify(downstream.command)}`;
@@ -1430,6 +1762,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;
@@ -1523,17 +1864,20 @@ async function installClaudeCodeMcpGatewayCommand(args, config) {
     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.');
-    const downstreamArgs = parseArgsList(args.mcpArgs || process.env.FCD_MCP_ARGS);
+    const downstream = resolveDownstreamSpec(args);
     const includeShieldKey = false;
-    const commandArgs = buildGatewayCommandArgs(gatewayConfig, downstreamCommand, downstreamArgs, {
+    const commandArgs = buildGatewayCommandArgs(gatewayConfig, downstream, {
         ...INSTALL_GATEWAY_ARGS,
         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',
     });
@@ -1543,7 +1887,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',
             });
@@ -1552,7 +1896,7 @@ async function installClaudeCodeMcpGatewayCommand(args, config) {
     if (result.status === 0) {
         console.log(`AgentGuard MCP Gateway installed for Claude Code (${scope}).`);
         console.log(`Server: ${serverName}`);
-        console.log(`Downstream: ${downstreamCommand} ${downstreamArgs.join(' ')}`);
+        console.log(`Downstream: ${downstreamSpecLabel(downstream)}`);
         if (!includeShieldKey && gatewayConfig.shieldKey) {
             console.log('Note: Shield key was loaded from local config/env and omitted from project .mcp.json. Runtime will use the developer machine config/env.');
         }
@@ -1565,7 +1909,7 @@ async function installClaudeCodeMcpGatewayCommand(args, config) {
         console.log('Claude Code CLI was not available, so project config was written directly.');
         console.log(`Config: ${file}`);
         console.log(`Server: ${serverName}`);
-        console.log(`Downstream: ${downstreamCommand} ${downstreamArgs.join(' ')}`);
+        console.log(`Downstream: ${downstreamSpecLabel(downstream)}`);
         if (!includeShieldKey && gatewayConfig.shieldKey) {
             console.log('Note: Shield key was loaded from local config/env and omitted from project .mcp.json. Runtime will use the developer machine config/env.');
         }
@@ -1584,11 +1928,8 @@ async function installClaudeDesktopMcpGatewayCommand(args, config) {
     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.');
-    const downstreamArgs = parseArgsList(args.mcpArgs || process.env.FCD_MCP_ARGS);
-    const commandArgs = buildGatewayCommandArgs(gatewayConfig, downstreamCommand, downstreamArgs, INSTALL_GATEWAY_ARGS);
+    const downstream = resolveDownstreamSpec(args);
+    const commandArgs = buildGatewayCommandArgs(gatewayConfig, downstream, INSTALL_GATEWAY_ARGS);
     for (const target of targets) {
         writeMcpServerConfig(target.file, serverName, nodeExe, commandArgs);
     }
@@ -1597,7 +1938,7 @@ async function installClaudeDesktopMcpGatewayCommand(args, config) {
         console.log(`Config: ${target.file} (${target.source})`);
     }
     console.log(`Server: ${serverName}`);
-    console.log(`Downstream: ${downstreamCommand} ${downstreamArgs.join(' ')}`);
+    console.log(`Downstream: ${downstreamSpecLabel(downstream)}`);
     console.log('Restart Claude Desktop to load the protected tools.');
 }
 async function installCodexMcpGatewayCommand(args, config) {
@@ -1611,11 +1952,8 @@ async function installCodexMcpGatewayCommand(args, config) {
     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.');
-    const downstreamArgs = parseArgsList(args.mcpArgs || process.env.FCD_MCP_ARGS);
-    const commandArgs = buildGatewayCommandArgs(gatewayConfig, downstreamCommand, downstreamArgs, INSTALL_GATEWAY_ARGS);
+    const downstream = resolveDownstreamSpec(args);
+    const commandArgs = buildGatewayCommandArgs(gatewayConfig, downstream, INSTALL_GATEWAY_ARGS);
     writeCodexMcpServer(file, serverName, nodeExe, commandArgs);
     console.log(`AgentGuard MCP Gateway installed for Codex (${projectScope ? 'project' : 'global'}).`);
     console.log(`Config: ${file}`);
@@ -1633,11 +1971,8 @@ async function installGeminiMcpGatewayCommand(args, config) {
     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.');
-    const downstreamArgs = parseArgsList(args.mcpArgs || process.env.FCD_MCP_ARGS);
-    const commandArgs = buildGatewayCommandArgs(gatewayConfig, downstreamCommand, downstreamArgs, INSTALL_GATEWAY_ARGS);
+    const downstream = resolveDownstreamSpec(args);
+    const commandArgs = buildGatewayCommandArgs(gatewayConfig, downstream, INSTALL_GATEWAY_ARGS);
     writeJsonMcpServer(file, serverName, nodeExe, commandArgs);
     console.log(`AgentGuard MCP Gateway installed for Gemini CLI (${projectScope ? 'project' : 'user'}).`);
     console.log(`Config: ${file}`);
@@ -1654,11 +1989,8 @@ async function installWindsurfMcpGatewayCommand(args, config) {
     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.');
-    const downstreamArgs = parseArgsList(args.mcpArgs || process.env.FCD_MCP_ARGS);
-    const commandArgs = buildGatewayCommandArgs(gatewayConfig, downstreamCommand, downstreamArgs, INSTALL_GATEWAY_ARGS);
+    const downstream = resolveDownstreamSpec(args);
+    const commandArgs = buildGatewayCommandArgs(gatewayConfig, downstream, INSTALL_GATEWAY_ARGS);
     writeJsonMcpServer(file, serverName, nodeExe, commandArgs);
     console.log('AgentGuard MCP Gateway installed for Windsurf.');
     console.log(`Config: ${file}`);
@@ -1675,11 +2007,8 @@ async function installVscodeMcpGatewayCommand(args, config) {
     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.');
-    const downstreamArgs = parseArgsList(args.mcpArgs || process.env.FCD_MCP_ARGS);
-    const commandArgs = buildGatewayCommandArgs(gatewayConfig, downstreamCommand, downstreamArgs, INSTALL_GATEWAY_ARGS);
+    const downstream = resolveDownstreamSpec(args);
+    const commandArgs = buildGatewayCommandArgs(gatewayConfig, downstream, INSTALL_GATEWAY_ARGS);
     const targets = [];
     if (projectScope)
         targets.push(vscodeMcpPath(true));

package/dist/index.js

@@ -342,7 +342,9 @@ function printHelp() {
     $ fullcourtdefense install-claude-code-mcp-gateway --scope local --mcp-command npm --mcp-args "run mcp"
     $ fullcourtdefense install-claude-code-mcp-gateway --scope project --mcp-command npm --mcp-args "run mcp"
     $ fullcourtdefense install-claude-desktop-mcp-gateway --mcp-command npm --mcp-args "run mcp"
+    $ fullcourtdefense install-cursor-mcp-gateway --server-name my-remote --mcp-url https://mcp.company.com/mcp
     $ fullcourtdefense mcp-gateway --mcp-command npm --mcp-args "run mcp"
+    $ fullcourtdefense mcp-gateway --mcp-url https://mcp.company.com/mcp --mcp-headers "{\"Authorization\":\"Bearer TOKEN\"}"
     $ fullcourtdefense login --token <fleet-enrollment-token>
     $ fullcourtdefense install-all
     $ fullcourtdefense install-all --auto-protect true --upload
@@ -366,6 +368,8 @@ async function main() {
         serverName: flags['server-name'],
         mcpCommand: flags['mcp-command'],
         mcpArgs: flags['mcp-args'],
+        mcpUrl: flags['mcp-url'],
+        mcpHeaders: flags['mcp-headers'],
         agentName: flags['agent-name'],
         developerName: flags['developer-name'],
         shieldId: flags['shield-id'],
@@ -385,6 +389,8 @@ async function main() {
     const buildGatewayArgs = () => ({
         mcpCommand: flags['mcp-command'],
         mcpArgs: flags['mcp-args'],
+        mcpUrl: flags['mcp-url'],
+        mcpHeaders: flags['mcp-headers'],
         agentName: flags['agent-name'],
         agentClient: flags['agent-client'],
         developerName: flags['developer-name'],

package/dist/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.14.11"
+  "version": "1.14.13"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullcourtdefense-cli",
-  "version": "1.14.11",
+  "version": "1.14.13",
   "description": "Full Court Defense CLI — security scanning for AI agents from your terminal",
   "main": "dist/index.js",
   "bin": {
@@ -24,6 +24,8 @@
     "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:remote-mcp-gateway": "npm run build && node scripts/test-remote-mcp-gateway.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"