fullcourtdefense-cli 1.1.5 → 1.1.6

package/dist/commands/hook.js

@@ -48,18 +48,34 @@ function dbg(obj) {
 }
 function readStdin() {
     return new Promise((resolve) => {
-        let data = '';
         const stdin = process.stdin;
         if (stdin.isTTY) {
             resolve('');
             return;
         }
-        stdin.setEncoding('utf8');
-        stdin.on('data', (chunk) => { data += chunk; });
-        stdin.on('end', () => resolve(data));
-        stdin.on('error', () => resolve(data));
+        // Read raw BYTES (no setEncoding) and decode the whole payload as UTF-8 once.
+        // Per-chunk string decoding + concat corrupts multibyte chars (e.g. Hebrew),
+        // turning them into Latin-1 mojibake before they ever reach the backend.
+        const chunks = [];
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            let buf = Buffer.concat(chunks);
+            // Strip UTF-8 BOM at the byte level (Cursor on Windows prepends EF BB BF).
+            if (buf.length >= 3 && buf[0] === 0xEF && buf[1] === 0xBB && buf[2] === 0xBF) {
+                buf = buf.subarray(3);
+            }
+            resolve(buf.toString('utf8'));
+        };
+        stdin.on('data', (chunk) => {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        });
+        stdin.on('end', finish);
+        stdin.on('error', finish);
         // Safety: if nothing arrives, don't hang forever.
-        setTimeout(() => resolve(data), 2000).unref?.();
+        setTimeout(finish, 2000).unref?.();
     });
 }
 /** Load ~/.fullcourtdefense.yml (machine-wide creds) as a fallback to project config. */

package/dist/commands/mcpGateway.d.ts

@@ -0,0 +1,21 @@
+import { BotGuardConfig } from '../config';
+export interface McpGatewayArgs {
+    mcpCommand?: string;
+    mcpArgs?: string;
+    agentName?: string;
+    shieldId?: string;
+    shieldKey?: string;
+    apiUrl?: string;
+    environment?: string;
+    approvalMode?: string;
+    approvalTimeoutMs?: string;
+    approvalPollMs?: string;
+    scanResponse?: string;
+    failClosed?: string;
+}
+export interface InstallCursorMcpGatewayArgs extends McpGatewayArgs {
+    project?: string;
+    serverName?: string;
+}
+export declare function mcpGatewayCommand(args: McpGatewayArgs, config: BotGuardConfig): Promise<void>;
+export declare function installCursorMcpGatewayCommand(args: InstallCursorMcpGatewayArgs, config: BotGuardConfig): Promise<void>;

package/dist/commands/mcpGateway.js

@@ -0,0 +1,569 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcpGatewayCommand = mcpGatewayCommand;
+exports.installCursorMcpGatewayCommand = installCursorMcpGatewayCommand;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const DEFAULT_API_URL = 'https://api.fullcourtdefense.ai';
+const MANAGED_SERVER_NAME = 'agentguard-gateway';
+function parseArgsList(value) {
+    if (!value?.trim())
+        return [];
+    const trimmed = value.trim();
+    if (trimmed.startsWith('[')) {
+        const parsed = JSON.parse(trimmed);
+        if (!Array.isArray(parsed) || parsed.some(item => typeof item !== 'string')) {
+            throw new Error('MCP args JSON must be an array of strings.');
+        }
+        return parsed;
+    }
+    return trimmed.match(/(?:[^\s"]+|"[^"]*")+/g)?.map(part => part.replace(/^"|"$/g, '')) ?? [];
+}
+function loadHomeShield() {
+    try {
+        for (const name of ['.fullcourtdefense.yml', '.fullcourtdefense.yaml']) {
+            const file = path.join(os.homedir(), name);
+            if (!fs.existsSync(file))
+                continue;
+            const text = fs.readFileSync(file, 'utf8');
+            const pick = (key) => {
+                const match = text.match(new RegExp(`^\\s*${key}\\s*:\\s*(.+)\\s*$`, 'm'));
+                return match?.[1]?.replace(/^["']|["']$/g, '').trim() || undefined;
+            };
+            return { shieldId: pick('shieldId'), shieldKey: pick('shieldKey'), apiUrl: pick('apiUrl') };
+        }
+    }
+    catch {
+        // Ignore config read errors; command-line flags/env can still provide config.
+    }
+    return {};
+}
+function resolveGatewayConfig(args, config) {
+    const home = loadHomeShield();
+    const shieldId = args.shieldId || process.env.FCD_SHIELD_ID || process.env.FULLCOURTDEFENSE_SHIELD_ID || process.env.AGENTGUARD_SHIELD_ID || config.shieldId || home.shieldId;
+    if (!shieldId)
+        throw new Error('Missing Shield ID. Pass --shield-id or run fullcourtdefense configure.');
+    return {
+        shieldId,
+        shieldKey: args.shieldKey || process.env.FCD_SHIELD_KEY || process.env.FULLCOURTDEFENSE_SHIELD_KEY || process.env.AGENTGUARD_SHIELD_KEY || config.shieldKey || home.shieldKey,
+        apiUrl: (args.apiUrl || process.env.FCD_API_URL || process.env.FULLCOURTDEFENSE_API_URL || config.apiUrl || home.apiUrl || DEFAULT_API_URL).replace(/\/$/, ''),
+        agentName: args.agentName || process.env.FCD_AGENT_NAME || 'cursor-local-agent',
+        environment: args.environment || process.env.FCD_ENVIRONMENT || 'developer-workstation',
+        approvalMode: args.approvalMode === 'block' ? 'block' : 'wait',
+        approvalTimeoutMs: Number(args.approvalTimeoutMs) > 0 ? Number(args.approvalTimeoutMs) : 300000,
+        approvalPollMs: Math.max(1000, Number(args.approvalPollMs) > 0 ? Number(args.approvalPollMs) : 3000),
+        scanResponse: args.scanResponse === 'true',
+        failClosed: args.failClosed !== 'false',
+    };
+}
+function machineMetadata() {
+    return {
+        machineName: os.hostname(),
+        os: `${os.platform()} ${os.release()}`,
+        username: safeUserName(),
+        cwd: process.cwd(),
+        workspacePath: process.env.WORKSPACE_PATH || process.cwd(),
+        agentClient: 'cursor',
+        gateway: 'agentguard-mcp-gateway',
+    };
+}
+function safeUserName() {
+    try {
+        return os.userInfo().username;
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function summarizeToolArgs(args) {
+    const out = { ...machineMetadata() };
+    for (const [key, value] of Object.entries(args || {})) {
+        if (/token|secret|password|credential|key/i.test(key)) {
+            out[key] = '[redacted]';
+        }
+        else if (typeof value === 'string') {
+            out[key] = value.length > 500 ? `${value.slice(0, 500)}...` : value;
+        }
+        else if (typeof value === 'number' || typeof value === 'boolean') {
+            out[key] = value;
+        }
+        else if (value === null || value === undefined) {
+            out[key] = value;
+        }
+        else {
+            out[key] = `[${Array.isArray(value) ? 'array' : 'object'}]`;
+        }
+    }
+    return out;
+}
+function resultSummary(result) {
+    const text = contentToText(result);
+    return text.length > 500 ? `${text.slice(0, 500)}...` : text || 'Tool executed after policy check.';
+}
+function contentToText(result) {
+    if (typeof result === 'string')
+        return result;
+    const content = result?.content;
+    if (Array.isArray(content)) {
+        return content
+            .filter(item => item.type === 'text' && typeof item.text === 'string')
+            .map(item => item.text)
+            .join('\n\n');
+    }
+    try {
+        return JSON.stringify(result);
+    }
+    catch {
+        return String(result);
+    }
+}
+class StdioMcpClient {
+    child;
+    buffer = '';
+    nextId = 1;
+    pending = new Map();
+    constructor(command, args) {
+        if (!command)
+            throw new Error('Missing downstream MCP command. Pass --mcp-command.');
+        this.child = (0, child_process_1.spawn)(command, args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            shell: process.platform === 'win32',
+        });
+        this.child.stdout.setEncoding('utf8');
+        this.child.stdout.on('data', chunk => this.onData(chunk));
+        this.child.stderr.on('data', chunk => process.stderr.write(String(chunk)));
+        this.child.on('error', error => this.rejectAll(error));
+        this.child.on('exit', code => this.rejectAll(new Error(`Downstream MCP server exited (${code ?? 'signal'}).`)));
+    }
+    async initialize() {
+        await this.request('initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'agentguard-mcp-gateway', version: '0.1.0' },
+        });
+        this.notify('notifications/initialized', {});
+    }
+    async listTools() {
+        const result = await this.request('tools/list', {});
+        const tools = result?.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() {
+        this.child.kill();
+    }
+    request(method, params) {
+        const id = this.nextId++;
+        this.write({ jsonrpc: '2.0', id, method, params });
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`MCP request timed out: ${method}`));
+            }, 60000);
+            this.pending.set(id, { resolve, reject, timeout });
+        });
+    }
+    notify(method, params) {
+        this.write({ jsonrpc: '2.0', method, params });
+    }
+    write(message) {
+        this.child.stdin.write(`${JSON.stringify(message)}\n`);
+    }
+    onData(chunk) {
+        this.buffer += chunk;
+        while (true) {
+            const lineEnd = this.buffer.indexOf('\n');
+            if (lineEnd === -1)
+                return;
+            const raw = this.buffer.slice(0, lineEnd).trim();
+            this.buffer = this.buffer.slice(lineEnd + 1);
+            if (!raw)
+                continue;
+            if (!raw.startsWith('{')) {
+                process.stderr.write(`[downstream] ${raw}\n`);
+                continue;
+            }
+            let message;
+            try {
+                message = JSON.parse(raw);
+            }
+            catch {
+                process.stderr.write(`[downstream] ${raw}\n`);
+                continue;
+            }
+            if (typeof message.id !== 'number')
+                continue;
+            const pending = this.pending.get(message.id);
+            if (!pending)
+                continue;
+            clearTimeout(pending.timeout);
+            this.pending.delete(message.id);
+            if (message.error)
+                pending.reject(new Error(message.error.message || 'MCP request failed'));
+            else
+                pending.resolve(message.result);
+        }
+    }
+    rejectAll(error) {
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timeout);
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+}
+class AgentGuardApi {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async checkToolCall(input) {
+        const result = await this.post('/api/agent-security/runtime/check-tool-call', {
+            shieldId: this.config.shieldId,
+            agentName: this.config.agentName,
+            toolName: input.toolName,
+            operation: input.operation,
+            toolArgs: input.toolArgs,
+            argsSummary: summarizeToolArgs(input.toolArgs),
+            environment: this.config.environment,
+            source: 'runtime_sdk',
+        });
+        if (!result.success || !result.data) {
+            throw new Error(result.error || 'Tool-call policy check failed.');
+        }
+        return result.data;
+    }
+    async recordToolCall(input) {
+        await this.post('/api/agent-security/runtime/tool-call', {
+            shieldId: this.config.shieldId,
+            agentName: this.config.agentName,
+            toolName: input.toolName,
+            operation: input.operation,
+            toolArgs: input.toolArgs,
+            argsSummary: summarizeToolArgs(input.toolArgs),
+            environment: this.config.environment,
+            decision: input.decision,
+            reason: input.reason,
+            source: 'runtime_sdk',
+        });
+    }
+    async waitForApproval(actionId) {
+        const deadline = Date.now() + this.config.approvalTimeoutMs;
+        while (Date.now() <= deadline) {
+            const status = await this.get(`/api/agent-security/runtime/approvals/${encodeURIComponent(actionId)}?shieldId=${encodeURIComponent(this.config.shieldId)}`);
+            const approval = status.data?.approval;
+            if (approval?.approvalStatus === 'approved') {
+                if (approval.executionStatus === 'executed')
+                    throw new Error(`Approval ${actionId} was already executed.`);
+                return;
+            }
+            if (approval?.approvalStatus === 'rejected')
+                throw new Error(`Approval rejected for ${approval.toolName}.`);
+            if (approval?.approvalStatus === 'expired')
+                throw new Error(`Approval expired for ${approval.toolName}.`);
+            await new Promise(resolve => setTimeout(resolve, Math.min(this.config.approvalPollMs, Math.max(0, deadline - Date.now()))));
+        }
+        throw new Error(`Approval timed out. Request ${actionId} is still waiting for review.`);
+    }
+    async markApprovalExecuted(actionId, input) {
+        await this.post(`/api/agent-security/runtime/approvals/${encodeURIComponent(actionId)}/executed`, {
+            shieldId: this.config.shieldId,
+            ...input,
+        });
+    }
+    async scanToolResponse(input) {
+        const text = contentToText(input.result);
+        const response = await this.post(`/api/mcp/proxy/${encodeURIComponent(this.config.shieldId)}`, {
+            toolResponse: text,
+            toolName: input.toolName,
+            agentName: this.config.agentName,
+            operation: input.operation,
+            toolArgs: input.toolArgs,
+        });
+        if (!response.success && response.error)
+            throw new Error(response.error);
+        const data = response.data;
+        if (data?.blocked) {
+            throw new Error(data.reason || 'MCP tool response blocked by Shield.');
+        }
+        return data?.safeResponse
+            ? { content: [{ type: 'text', text: data.safeResponse }] }
+            : input.result;
+    }
+    async post(pathValue, body) {
+        const resp = await fetch(`${this.config.apiUrl}${pathValue}`, {
+            method: 'POST',
+            headers: this.headers(),
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(120000),
+        });
+        const data = await resp.json().catch(() => ({}));
+        if (!resp.ok)
+            return { success: false, error: data.error || `AgentGuard API error (${resp.status})` };
+        return data;
+    }
+    async get(pathValue) {
+        const resp = await fetch(`${this.config.apiUrl}${pathValue}`, {
+            method: 'GET',
+            headers: this.headers(),
+            signal: AbortSignal.timeout(120000),
+        });
+        const data = await resp.json().catch(() => ({}));
+        if (!resp.ok)
+            return { success: false, error: data.error || `AgentGuard API error (${resp.status})` };
+        return data;
+    }
+    headers() {
+        return {
+            'Content-Type': 'application/json',
+            ...(this.config.shieldKey ? { 'x-shield-key': this.config.shieldKey } : {}),
+        };
+    }
+}
+class McpGatewayServer {
+    gatewayConfig;
+    downstreamCommand;
+    downstreamArgs;
+    downstream;
+    downstreamReady;
+    buffer = '';
+    api;
+    constructor(gatewayConfig, downstreamCommand, downstreamArgs) {
+        this.gatewayConfig = gatewayConfig;
+        this.downstreamCommand = downstreamCommand;
+        this.downstreamArgs = downstreamArgs;
+        this.api = new AgentGuardApi(gatewayConfig);
+    }
+    start() {
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', chunk => this.onData(String(chunk)));
+        process.stdin.on('end', () => this.downstream?.close());
+    }
+    onData(chunk) {
+        this.buffer += chunk;
+        while (true) {
+            const lineEnd = this.buffer.indexOf('\n');
+            if (lineEnd === -1)
+                return;
+            const raw = this.buffer.slice(0, lineEnd).trim();
+            this.buffer = this.buffer.slice(lineEnd + 1);
+            if (!raw)
+                continue;
+            void this.handleMessage(JSON.parse(raw));
+        }
+    }
+    async handleMessage(message) {
+        if (!message.id && message.method?.startsWith('notifications/'))
+            return;
+        try {
+            if (message.method === 'initialize') {
+                this.respond(message.id, {
+                    protocolVersion: '2024-11-05',
+                    capabilities: { tools: {} },
+                    serverInfo: { name: 'agentguard-mcp-gateway', version: '0.1.0' },
+                });
+                return;
+            }
+            if (message.method === 'tools/list') {
+                await this.ensureDownstream();
+                const tools = await this.downstream.listTools();
+                this.respond(message.id, {
+                    tools: tools.map(tool => ({
+                        ...tool,
+                        description: `[AgentGuard protected] ${tool.description || ''}`.trim(),
+                    })),
+                });
+                return;
+            }
+            if (message.method === 'tools/call') {
+                const result = await this.handleToolCall(message.params || {});
+                this.respond(message.id, result);
+                return;
+            }
+            this.error(message.id, -32601, `Unsupported MCP method: ${message.method || 'unknown'}`);
+        }
+        catch (error) {
+            this.error(message.id, -32000, error instanceof Error ? error.message : String(error));
+        }
+    }
+    async ensureDownstream() {
+        if (!this.downstreamReady) {
+            this.downstream = new StdioMcpClient(this.downstreamCommand, this.downstreamArgs);
+            this.downstreamReady = this.downstream.initialize();
+        }
+        await this.downstreamReady;
+    }
+    async handleToolCall(params) {
+        await this.ensureDownstream();
+        const toolName = String(params.name || '');
+        if (!toolName)
+            throw new Error('Missing MCP tool name.');
+        const toolArgs = params.arguments && typeof params.arguments === 'object' ? params.arguments : {};
+        let approvalActionId;
+        let operation;
+        try {
+            const preflight = await this.api.checkToolCall({ toolName, toolArgs });
+            operation = preflight.operation;
+            if (!preflight.allowed) {
+                if (preflight.decision === 'approval' && this.gatewayConfig.approvalMode === 'wait') {
+                    approvalActionId = preflight.approvalActionId;
+                    if (!approvalActionId)
+                        throw new Error('Policy requires approval, but no approval request id was returned.');
+                    process.stderr.write(`AgentGuard approval required for ${toolName}. Waiting for human review (${approvalActionId})...\n`);
+                    await this.api.waitForApproval(approvalActionId);
+                }
+                else {
+                    const reason = preflight.actionPolicy?.reason || preflight.intentEvaluation?.reasons?.[0] || `Tool call ${preflight.decision}.`;
+                    throw new Error(reason);
+                }
+            }
+            const rawResult = await this.downstream.callTool(toolName, toolArgs);
+            const finalResult = this.gatewayConfig.scanResponse
+                ? await this.api.scanToolResponse({ toolName, operation, toolArgs, result: rawResult })
+                : rawResult;
+            if (approvalActionId) {
+                await this.api.markApprovalExecuted(approvalActionId, { success: true, resultSummary: resultSummary(finalResult) });
+            }
+            else {
+                await this.api.recordToolCall({ toolName, operation, toolArgs, decision: 'allow' });
+            }
+            return finalResult;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (approvalActionId) {
+                await this.api.markApprovalExecuted(approvalActionId, { success: false, error: message }).catch(() => undefined);
+            }
+            else {
+                await this.api.recordToolCall({ toolName, operation, toolArgs, decision: 'block', reason: message }).catch(() => undefined);
+            }
+            return {
+                isError: true,
+                content: [{ type: 'text', text: JSON.stringify({ blocked: true, toolName, reason: message }, null, 2) }],
+            };
+        }
+    }
+    respond(id, result) {
+        process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id, result })}\n`);
+    }
+    error(id, code, message) {
+        process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id, error: { code, message } })}\n`);
+    }
+}
+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`);
+    server.start();
+}
+function cursorMcpPath(projectScope) {
+    return projectScope
+        ? path.join(process.cwd(), '.cursor', 'mcp.json')
+        : path.join(os.homedir(), '.cursor', 'mcp.json');
+}
+function readJson(file) {
+    if (!fs.existsSync(file))
+        return { mcpServers: {} };
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        if (!parsed || typeof parsed !== 'object')
+            return { mcpServers: {} };
+        if (!parsed.mcpServers || typeof parsed.mcpServers !== 'object')
+            parsed.mcpServers = {};
+        return parsed;
+    }
+    catch {
+        return { mcpServers: {} };
+    }
+}
+async function installCursorMcpGatewayCommand(args, config) {
+    const gatewayConfig = resolveGatewayConfig(args, config);
+    const projectScope = args.project === 'true';
+    const file = cursorMcpPath(projectScope);
+    const nodeExe = process.execPath;
+    const scriptPath = path.resolve(process.argv[1] || path.join(__dirname, '..', 'index.js'));
+    const serverName = args.serverName || MANAGED_SERVER_NAME;
+    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 commandArgs = [
+        scriptPath,
+        'mcp-gateway',
+        '--mcp-command', downstreamCommand,
+        '--mcp-args', JSON.stringify(parseArgsList(args.mcpArgs || process.env.FCD_MCP_ARGS)),
+        '--agent-name', gatewayConfig.agentName,
+        '--shield-id', gatewayConfig.shieldId,
+        '--approval-mode', gatewayConfig.approvalMode,
+        '--approval-timeout-ms', String(gatewayConfig.approvalTimeoutMs),
+        '--approval-poll-ms', String(gatewayConfig.approvalPollMs),
+        '--scan-response', String(gatewayConfig.scanResponse),
+        '--fail-closed', String(gatewayConfig.failClosed),
+    ];
+    if (gatewayConfig.shieldKey)
+        commandArgs.push('--shield-key', gatewayConfig.shieldKey);
+    if (gatewayConfig.apiUrl)
+        commandArgs.push('--api-url', gatewayConfig.apiUrl);
+    if (gatewayConfig.environment)
+        commandArgs.push('--environment', gatewayConfig.environment);
+    const json = readJson(file);
+    json.mcpServers[serverName] = {
+        command: nodeExe,
+        args: commandArgs,
+    };
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(json, null, 2)}\n`, 'utf8');
+    console.log(`AgentGuard MCP Gateway installed for Cursor (${projectScope ? 'project' : 'global'}).`);
+    console.log(`Config: ${file}`);
+    console.log(`Server: ${serverName}`);
+    console.log(`Downstream: ${downstreamCommand} ${parseArgsList(args.mcpArgs || process.env.FCD_MCP_ARGS).join(' ')}`);
+    console.log('Restart Cursor or reload MCP servers to use the protected tools.');
+}

package/dist/index.js

@@ -10,7 +10,8 @@ const configure_1 = require("./commands/configure");
 const discover_1 = require("./commands/discover");
 const hook_1 = require("./commands/hook");
 const installCursorHook_1 = require("./commands/installCursorHook");
-const VERSION = '1.1.5';
+const mcpGateway_1 = require("./commands/mcpGateway");
+const VERSION = '1.1.6';
 function parseArgs(argv) {
     const flags = {};
     let command = '';
@@ -72,6 +73,11 @@ function printHelp() {
                 (shell, MCP) on this machine is scanned by your Shield.
     uninstall-cursor-hook
                 Removes the FullCourtDefense Cursor hook entries.
+    mcp-gateway
+                Runs a local MCP gateway that checks AgentGuard runtime/action
+                policies before forwarding tool calls to a real MCP server.
+    install-cursor-mcp-gateway
+                Adds the AgentGuard MCP Gateway to Cursor's mcp.json.
     hook        Internal: invoked by Cursor per agent event (reads stdin JSON,
                 returns an allow/deny verdict). Not run by hand.
     credits     Shows hosted scan credits for CI/CD API-key scans.
@@ -183,6 +189,8 @@ function printHelp() {
     $ fullcourtdefense install-cursor-hook --events prompt,shell,mcp,file
     $ fullcourtdefense install-cursor-hook --project true       # this repo only
     $ fullcourtdefense uninstall-cursor-hook
+    $ fullcourtdefense install-cursor-mcp-gateway --project true --shield-id <id> --shield-key <key> --mcp-command npm --mcp-args "run mcp"
+    $ fullcourtdefense mcp-gateway --shield-id <id> --mcp-command npm --mcp-args "run mcp"
     $ fullcourtdefense configure
     $ fullcourtdefense doctor
     $ fullcourtdefense scan --system-prompt ./prompts/system.md --fail-threshold 80
@@ -326,6 +334,44 @@ async function main() {
             await (0, hook_1.hookCommand)(args, config);
             break;
         }
+        case 'mcp-gateway': {
+            const args = {
+                mcpCommand: flags['mcp-command'],
+                mcpArgs: flags['mcp-args'],
+                agentName: flags['agent-name'],
+                shieldId: flags['shield-id'],
+                shieldKey: flags['shield-key'],
+                apiUrl: flags['api-url'],
+                environment: flags.environment,
+                approvalMode: flags['approval-mode'],
+                approvalTimeoutMs: flags['approval-timeout-ms'],
+                approvalPollMs: flags['approval-poll-ms'],
+                scanResponse: flags['scan-response'],
+                failClosed: flags['fail-closed'],
+            };
+            await (0, mcpGateway_1.mcpGatewayCommand)(args, config);
+            break;
+        }
+        case 'install-cursor-mcp-gateway': {
+            const args = {
+                project: flags.project,
+                serverName: flags['server-name'],
+                mcpCommand: flags['mcp-command'],
+                mcpArgs: flags['mcp-args'],
+                agentName: flags['agent-name'],
+                shieldId: flags['shield-id'],
+                shieldKey: flags['shield-key'],
+                apiUrl: flags['api-url'],
+                environment: flags.environment,
+                approvalMode: flags['approval-mode'],
+                approvalTimeoutMs: flags['approval-timeout-ms'],
+                approvalPollMs: flags['approval-poll-ms'],
+                scanResponse: flags['scan-response'],
+                failClosed: flags['fail-closed'],
+            };
+            await (0, mcpGateway_1.installCursorMcpGatewayCommand)(args, config);
+            break;
+        }
         case 'init': {
             await (0, init_1.initCommand)();
             break;

package/package.json

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