fullcourtdefense-cli 1.4.0 → 1.5.1

package/dist/commands/mcpGateway.d.ts

@@ -58,6 +58,12 @@ export interface InstallMcpGatewayArgs extends McpGatewayArgs {
 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>;
+export interface ProtectAllArgs extends McpGatewayArgs {
+    dryRun?: string;
+    config?: string;
+}
+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>;
 export declare function installClaudeDesktopMcpGatewayCommand(args: InstallClaudeDesktopMcpGatewayArgs, config: BotGuardConfig): Promise<void>;
 export declare function installCodexMcpGatewayCommand(args: InstallCodexMcpGatewayArgs, config: BotGuardConfig): Promise<void>;

package/dist/commands/mcpGateway.js

@@ -37,6 +37,8 @@ exports.ALL_GATEWAY_CLIENTS = void 0;
 exports.mcpGatewayCommand = mcpGatewayCommand;
 exports.installCursorMcpGatewayCommand = installCursorMcpGatewayCommand;
 exports.installMcpGatewayCommand = installMcpGatewayCommand;
+exports.protectAllCommand = protectAllCommand;
+exports.unprotectAllCommand = unprotectAllCommand;
 exports.installClaudeCodeMcpGatewayCommand = installClaudeCodeMcpGatewayCommand;
 exports.installClaudeDesktopMcpGatewayCommand = installClaudeDesktopMcpGatewayCommand;
 exports.installCodexMcpGatewayCommand = installCodexMcpGatewayCommand;
@@ -940,6 +942,377 @@ async function installMcpGatewayCommand(args, config) {
         console.log('Add --upload to refresh AI Fleet after install.');
     }
 }
+const CLIENT_KEY_TO_AGENT = {
+    cursor: 'cursor',
+    claude_code: 'claude-code',
+    claude_desktop: 'claude-desktop',
+    codex: 'codex',
+    gemini_cli: 'gemini-cli',
+    windsurf: 'windsurf',
+    vscode: 'vscode',
+};
+function newWrapStats() { return { wrapped: [], skippedManaged: [], skippedRemote: [] }; }
+/** True when an MCP server entry already runs through the AgentGuard gateway. */
+function isGatewayWrappedEntry(entry) {
+    if (!entry || typeof entry !== 'object')
+        return false;
+    const args = Array.isArray(entry.args) ? entry.args.map(String) : [];
+    return args.includes('mcp-gateway');
+}
+/** Recover the original downstream command+args from a wrapped entry's args. */
+function extractWrappedDownstream(entry) {
+    const args = Array.isArray(entry?.args) ? entry.args.map(String) : [];
+    const ci = args.indexOf('--mcp-command');
+    if (ci === -1 || ci + 1 >= args.length)
+        return null;
+    const command = args[ci + 1];
+    let downstreamArgs = [];
+    const ai = args.indexOf('--mcp-args');
+    if (ai !== -1 && args[ai + 1]) {
+        try {
+            const parsed = JSON.parse(args[ai + 1]);
+            if (Array.isArray(parsed))
+                downstreamArgs = parsed.map(String);
+        }
+        catch { /* leave empty */ }
+    }
+    return { command, args: downstreamArgs };
+}
+/** All server maps inside a parsed JSON config, across every known client shape. */
+function collectJsonServerMaps(json) {
+    const maps = [];
+    const pushIfMap = (m) => { if (m && typeof m === 'object' && !Array.isArray(m))
+        maps.push(m); };
+    if (json && typeof json === 'object') {
+        pushIfMap(json.mcpServers); // Cursor, Claude, Gemini, Windsurf, Kiro, Codex mcp.json
+        pushIfMap(json.servers); // VS Code .vscode/mcp.json
+        if (json.mcp && typeof json.mcp === 'object')
+            pushIfMap(json.mcp.servers); // VS Code settings.json
+        if (json.projects && typeof json.projects === 'object') {
+            for (const proj of Object.values(json.projects))
+                pushIfMap(proj?.mcpServers); // Claude Code .claude.json
+        }
+    }
+    return maps;
+}
+function backupFile(file) {
+    try {
+        const bak = `${file}.fcd-backup-${Date.now()}`;
+        fs.copyFileSync(file, bak);
+    }
+    catch { /* best effort */ }
+}
+function perServerAgentName(developerName, agentClient, serverName) {
+    return `${safeIdentityPart(developerName)}-${agentClient}-${safeIdentityPart(serverName)}`;
+}
+function wrapJsonConfigFile(file, gatewayConfig, agentClient, dryRun) {
+    const stats = newWrapStats();
+    let json;
+    try {
+        json = JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null; // not JSON / unreadable — skip silently
+    }
+    if (!json || typeof json !== 'object')
+        return null;
+    const maps = collectJsonServerMaps(json);
+    if (maps.length === 0)
+        return stats;
+    const nodeExe = process.execPath;
+    let changed = false;
+    for (const map of maps) {
+        for (const [name, entry] of Object.entries(map)) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            if (name === MANAGED_SERVER_NAME || isGatewayWrappedEntry(entry)) {
+                stats.skippedManaged.push(name);
+                continue;
+            }
+            if (typeof entry.command !== 'string' || !entry.command) {
+                stats.skippedRemote.push(name);
+                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);
+            entry.command = nodeExe;
+            entry.args = wrappedArgs;
+            // entry.env and any other fields are preserved as-is.
+            stats.wrapped.push(name);
+            changed = true;
+        }
+    }
+    if (changed && !dryRun) {
+        backupFile(file);
+        fs.writeFileSync(file, `${JSON.stringify(json, null, 2)}\n`, 'utf8');
+    }
+    return stats;
+}
+function unwrapJsonConfigFile(file, dryRun) {
+    let json;
+    try {
+        json = JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+    if (!json || typeof json !== 'object')
+        return null;
+    const maps = collectJsonServerMaps(json);
+    const restored = [];
+    let changed = false;
+    for (const map of maps) {
+        for (const [name, entry] of Object.entries(map)) {
+            if (name === MANAGED_SERVER_NAME) {
+                delete map[name];
+                changed = true;
+                continue;
+            }
+            if (!isGatewayWrappedEntry(entry))
+                continue;
+            const downstream = extractWrappedDownstream(entry);
+            if (!downstream)
+                continue;
+            entry.command = downstream.command;
+            entry.args = downstream.args;
+            restored.push(name);
+            changed = true;
+        }
+    }
+    if (changed && !dryRun) {
+        backupFile(file);
+        fs.writeFileSync(file, `${JSON.stringify(json, null, 2)}\n`, 'utf8');
+    }
+    return { restored };
+}
+/** Parse a single-line TOML scalar string value: command = "x" or command = 'x'. */
+function parseTomlInlineString(line) {
+    const rhs = line.slice(line.indexOf('=') + 1).trim();
+    const basic = rhs.match(/^"((?:[^"\\]|\\.)*)"/);
+    if (basic) {
+        try {
+            return JSON.parse(`"${basic[1]}"`);
+        }
+        catch {
+            return basic[1];
+        }
+    }
+    const literal = rhs.match(/^'([^']*)'/); // TOML literal string — no escapes
+    if (literal)
+        return literal[1];
+    return undefined;
+}
+/** Parse a single-line TOML string array: args = ["a", 'b'] (mixed quotes ok). */
+function parseTomlInlineStringArray(line) {
+    const rhs = line.slice(line.indexOf('=') + 1).trim();
+    if (!rhs.startsWith('[') || !rhs.endsWith(']'))
+        return undefined; // multi-line / not an inline array
+    const inner = rhs.slice(1, -1).trim();
+    if (inner === '')
+        return [];
+    const out = [];
+    const re = /"((?:[^"\\]|\\.)*)"|'([^']*)'/g;
+    let match;
+    while ((match = re.exec(inner)) !== null) {
+        if (match[1] !== undefined) {
+            try {
+                out.push(JSON.parse(`"${match[1]}"`));
+            }
+            catch {
+                out.push(match[1]);
+            }
+        }
+        else
+            out.push(match[2] ?? '');
+    }
+    return out;
+}
+function tomlStringArrayLiteral(values) {
+    return `[${values.map(v => JSON.stringify(v)).join(', ')}]`;
+}
+/**
+ * Wrap/unwrap Codex config.toml in place, line by line, so [mcp_servers.NAME.env]
+ * subtables and unrelated config are preserved. Only single-line command/args
+ * are handled; multi-line arrays are skipped (rare for MCP servers).
+ */
+function transformCodexToml(file, mode, gatewayConfig, dryRun) {
+    let content;
+    try {
+        content = fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const lines = content.split(/\r?\n/);
+    const stats = newWrapStats();
+    const nodeExe = process.execPath;
+    const sections = [];
+    let current = null;
+    for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        const header = trimmed.match(/^\[(.+?)\]\s*$/);
+        if (header) {
+            const tablePath = header[1];
+            const isServer = /^mcp_servers\.[^.]+$/.test(tablePath);
+            if (isServer) {
+                current = { name: tablePath.slice('mcp_servers.'.length), cmdLine: -1, argsLine: -1 };
+                sections.push(current);
+            }
+            else
+                current = null;
+            continue;
+        }
+        if (current) {
+            if (/^command\s*=/.test(trimmed) && current.cmdLine === -1) {
+                current.cmdLine = i;
+                current.command = parseTomlInlineString(lines[i]);
+            }
+            else if (/^args\s*=/.test(trimmed) && current.argsLine === -1) {
+                current.argsLine = i;
+                current.args = parseTomlInlineStringArray(lines[i]);
+            }
+        }
+    }
+    let changed = false;
+    for (const section of sections) {
+        if (section.cmdLine === -1 || !section.command) {
+            continue;
+        }
+        const wrappedAlready = section.command === nodeExe && (section.args || []).includes('mcp-gateway');
+        if (mode === 'wrap') {
+            if (section.name === MANAGED_SERVER_NAME || wrappedAlready) {
+                stats.skippedManaged.push(section.name);
+                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 indent = lines[section.cmdLine].match(/^\s*/)?.[0] || '';
+            lines[section.cmdLine] = `${indent}command = ${JSON.stringify(nodeExe)}`;
+            const argsLineText = `${indent}args = ${tomlStringArrayLiteral(wrappedArgs)}`;
+            if (section.argsLine !== -1)
+                lines[section.argsLine] = argsLineText;
+            else
+                lines.splice(section.cmdLine + 1, 0, argsLineText);
+            stats.wrapped.push(section.name);
+            changed = true;
+        }
+        else {
+            if (!wrappedAlready)
+                continue;
+            const downstream = extractWrappedDownstream({ args: section.args });
+            if (!downstream)
+                continue;
+            const indent = lines[section.cmdLine].match(/^\s*/)?.[0] || '';
+            lines[section.cmdLine] = `${indent}command = ${JSON.stringify(downstream.command)}`;
+            if (section.argsLine !== -1)
+                lines[section.argsLine] = `${indent}args = ${tomlStringArrayLiteral(downstream.args)}`;
+            stats.wrapped.push(section.name);
+            changed = true;
+        }
+    }
+    if (changed && !dryRun) {
+        backupFile(file);
+        fs.writeFileSync(file, lines.join('\n'), 'utf8');
+    }
+    return stats;
+}
+function protectAllTargetFiles(extra) {
+    const cwd = process.cwd();
+    const seen = new Set();
+    const files = [];
+    for (const candidate of (0, discoverPaths_1.candidateConfigPaths)(cwd, extra)) {
+        const key = path.resolve(candidate.path).toLowerCase();
+        if (seen.has(key))
+            continue;
+        if (!fs.existsSync(candidate.path))
+            continue;
+        seen.add(key);
+        files.push(candidate);
+    }
+    for (const target of (0, discoverPaths_1.claudeDesktopInstallTargets)()) {
+        const key = path.resolve(target.file).toLowerCase();
+        if (target.exists && !seen.has(key)) {
+            seen.add(key);
+            files.push({ path: target.file, source: target.source, clientKey: 'claude_desktop' });
+        }
+    }
+    return files;
+}
+async function protectAllCommand(args, config) {
+    (0, config_1.requireCliSetup)(config, { shieldId: args.shieldId, shieldKey: args.shieldKey, apiUrl: args.apiUrl }, { requireOrganizationId: false });
+    const gatewayConfig = resolveGatewayConfig(args, config);
+    const dryRun = args.dryRun === 'true';
+    const files = protectAllTargetFiles(args.config);
+    console.log('\n\x1b[1m\x1b[36mFullCourtDefense — protect every MCP server in every client\x1b[0m');
+    console.log(`\x1b[2mRuntime identity: ${gatewayConfig.developerName}  |  Shield: ${gatewayConfig.shieldId}${dryRun ? '  |  DRY RUN' : ''}\x1b[0m\n`);
+    if (files.length === 0) {
+        console.log('No MCP client config files found on this machine. Configure an MCP server in any client, then re-run.');
+        return;
+    }
+    let totalWrapped = 0;
+    let totalManaged = 0;
+    let totalRemote = 0;
+    for (const file of files) {
+        const agentClient = CLIENT_KEY_TO_AGENT[file.clientKey] || 'cursor';
+        const isToml = /\.toml$/i.test(file.path);
+        const stats = isToml
+            ? transformCodexToml(file.path, 'wrap', gatewayConfig, dryRun)
+            : wrapJsonConfigFile(file.path, gatewayConfig, agentClient, dryRun);
+        if (!stats)
+            continue;
+        if (stats.wrapped.length === 0 && stats.skippedManaged.length === 0 && stats.skippedRemote.length === 0)
+            continue;
+        totalWrapped += stats.wrapped.length;
+        totalManaged += stats.skippedManaged.length;
+        totalRemote += stats.skippedRemote.length;
+        console.log(`\x1b[1m${file.source}\x1b[0m  \x1b[2m${file.path}\x1b[0m`);
+        if (stats.wrapped.length)
+            console.log(`  \x1b[32m✓ wrapped:\x1b[0m ${stats.wrapped.join(', ')}`);
+        if (stats.skippedManaged.length)
+            console.log(`  \x1b[2m• already protected:\x1b[0m ${stats.skippedManaged.join(', ')}`);
+        if (stats.skippedRemote.length)
+            console.log(`  \x1b[33m• skipped (remote/no command):\x1b[0m ${stats.skippedRemote.join(', ')}`);
+        console.log('');
+    }
+    console.log('\x1b[1mSummary\x1b[0m');
+    console.log(`  ${dryRun ? 'would wrap' : 'wrapped'}: ${totalWrapped}   already protected: ${totalManaged}   skipped remote: ${totalRemote}`);
+    console.log(`  Each protected server enforces your org Action Policies (allow / block / wait-for-human-approval) on its tool calls.`);
+    if (!dryRun && totalWrapped > 0)
+        console.log('  Backups saved next to each edited file (*.fcd-backup-*). Restart each client to load the protected servers.');
+    console.log('  Reverse anytime with: \x1b[1mfullcourtdefense unprotect-all\x1b[0m');
+}
+async function unprotectAllCommand(args, config) {
+    const dryRun = args.dryRun === 'true';
+    const files = protectAllTargetFiles(args.config);
+    let gatewayConfig;
+    try {
+        gatewayConfig = resolveGatewayConfig(args, config);
+    }
+    catch { /* unwrap doesn't need creds */ }
+    const fallbackConfig = gatewayConfig || { developerName: 'local-user' };
+    console.log('\n\x1b[1m\x1b[36mFullCourtDefense — remove gateway wrapping from all clients\x1b[0m\n');
+    let total = 0;
+    for (const file of files) {
+        const isToml = /\.toml$/i.test(file.path);
+        if (isToml) {
+            const stats = transformCodexToml(file.path, 'unwrap', fallbackConfig, dryRun);
+            if (stats && stats.wrapped.length) {
+                total += stats.wrapped.length;
+                console.log(`\x1b[1m${file.source}\x1b[0m restored: ${stats.wrapped.join(', ')}`);
+            }
+        }
+        else {
+            const res = unwrapJsonConfigFile(file.path, dryRun);
+            if (res && res.restored.length) {
+                total += res.restored.length;
+                console.log(`\x1b[1m${file.source}\x1b[0m restored: ${res.restored.join(', ')}`);
+            }
+        }
+    }
+    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, {
         agentClient: 'claude-code',

package/dist/index.js

@@ -124,6 +124,12 @@ function printHelp() {
                 are allowed, blocked, or paused for human approval per policy.
     uninstall-cursor-hook
                 Removes the FullCourtDefense Cursor hook entries.
+    protect-all Auto-detect EVERY MCP server already configured in EVERY client
+                (Cursor, Claude Code/Desktop, Codex, Gemini, Windsurf, VS Code)
+                and wrap each through the Shield proxy — no --mcp-command needed.
+                Enforces your org Action Policies on every tool. --dry-run to preview.
+    unprotect-all
+                Reverse protect-all: restore every server to its original command.
     install-mcp-gateway
                 Install MCP gateway into selected clients (--clients all for every tool).
     install-cursor-mcp-gateway
@@ -499,6 +505,26 @@ async function main() {
             await (0, mcpGateway_1.installMcpGatewayCommand)(buildInstallArgs(), config);
             break;
         }
+        case 'protect-all':
+        case 'wrap-all': {
+            const args = {
+                ...buildGatewayArgs(),
+                dryRun: flags['dry-run'],
+                config: flags.config,
+            };
+            await (0, mcpGateway_1.protectAllCommand)(args, config);
+            break;
+        }
+        case 'unprotect-all':
+        case 'unwrap-all': {
+            const args = {
+                ...buildGatewayArgs(),
+                dryRun: flags['dry-run'],
+                config: flags.config,
+            };
+            await (0, mcpGateway_1.unprotectAllCommand)(args, config);
+            break;
+        }
         case 'install-cursor-mcp-gateway': {
             const args = {
                 ...buildGatewayArgs(),

package/dist/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.4.0"
+  "version": "1.5.1"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullcourtdefense-cli",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "description": "Full Court Defense CLI — security scanning for AI agents from your terminal",
   "main": "dist/index.js",
   "bin": {