fullcourtdefense-cli 1.7.16 → 1.7.18

package/dist/commands/agentCi.d.ts

@@ -0,0 +1,12 @@
+import { BotGuardConfig } from '../config';
+export interface AgentCiArgs {
+    failOn?: string;
+    format?: string;
+    upload?: string;
+    requireGateway?: string;
+    requireApprovalFor?: string;
+    extraPath?: string;
+    apiKey?: string;
+    apiUrl?: string;
+}
+export declare function agentCiCommand(args: AgentCiArgs, config: BotGuardConfig): Promise<void>;

package/dist/commands/agentCi.js

@@ -0,0 +1,303 @@
+"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.agentCiCommand = agentCiCommand;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../config");
+const discoverPaths_1 = require("./discoverPaths");
+const discoverAgentFiles_1 = require("./discoverAgentFiles");
+const discoverSecrets_1 = require("./discoverSecrets");
+const discover_1 = require("./discover");
+const SEVERITY_RANK = { low: 0, medium: 1, high: 2, critical: 3 };
+function stableId(parts) {
+    return crypto.createHash('sha256').update(parts.join('|')).digest('hex').slice(0, 16);
+}
+function parseJsonFile(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function parseTomlMcpServers(content) {
+    const servers = {};
+    const lines = content.split(/\r?\n/);
+    let current = null;
+    for (const raw of lines) {
+        const line = raw.trim();
+        const section = line.match(/^\[mcp_servers\.([^\]]+)\]$/);
+        if (section) {
+            current = section[1].replace(/^["']|["']$/g, '');
+            servers[current] = {};
+            continue;
+        }
+        if (!current || !line || line.startsWith('#'))
+            continue;
+        const match = line.match(/^([A-Za-z0-9_-]+)\s*=\s*(.+)$/);
+        if (!match)
+            continue;
+        const key = match[1];
+        const rawValue = match[2].trim().replace(/,$/, '');
+        if (rawValue.startsWith('[')) {
+            servers[current][key] = rawValue
+                .replace(/^\[|\]$/g, '')
+                .split(',')
+                .map(part => part.trim().replace(/^["']|["']$/g, ''))
+                .filter(Boolean);
+        }
+        else {
+            servers[current][key] = rawValue.replace(/^["']|["']$/g, '');
+        }
+    }
+    return servers;
+}
+function extractServerMap(parsed) {
+    if (!parsed || typeof parsed !== 'object')
+        return {};
+    if (parsed.mcpServers && typeof parsed.mcpServers === 'object')
+        return parsed.mcpServers;
+    if (parsed.servers && typeof parsed.servers === 'object')
+        return parsed.servers;
+    if (parsed.mcp?.servers && typeof parsed.mcp.servers === 'object')
+        return parsed.mcp.servers;
+    if (parsed['mcp.servers'] && typeof parsed['mcp.servers'] === 'object')
+        return parsed['mcp.servers'];
+    return {};
+}
+function riskSignalsForServer(name, server) {
+    const text = [
+        name,
+        server?.command,
+        ...(Array.isArray(server?.args) ? server.args : []),
+        server?.url,
+    ].filter(Boolean).join(' ').toLowerCase();
+    const signals = [
+        [/\b(shell|exec|command|terminal|powershell|bash|cmd\.exe)\b/, 'shell'],
+        [/\b(file|filesystem|readfile|writefile|directory|path)\b/, 'filesystem'],
+        [/\b(database|postgres|mysql|mongo|sql|db)\b/, 'database'],
+        [/\b(secret|token|key|password|credential|env)\b/, 'secrets'],
+        [/\b(payment|wire|transfer|bank|iban|invoice|billing)\b/, 'payment'],
+        [/\b(customer|user|pii|ssn|email|phone|record)\b/, 'pii'],
+        [/\b(browser|web|http|fetch|request|webhook)\b/, 'network'],
+        [/\b(delete|remove|destroy|drop|wipe|purge|write|update|create)\b/, 'write'],
+    ];
+    return signals.filter(([re]) => re.test(text)).map(([, signal]) => signal);
+}
+function discoverMcpServers(cwd, extraPath) {
+    const out = [];
+    for (const candidate of (0, discoverPaths_1.discoverScanTargets)(cwd, extraPath)) {
+        if (!fs.existsSync(candidate.path))
+            continue;
+        const isToml = candidate.path.endsWith('.toml');
+        const parsed = isToml
+            ? parseTomlMcpServers(fs.readFileSync(candidate.path, 'utf8'))
+            : parseJsonFile(candidate.path);
+        const map = extractServerMap(parsed);
+        for (const [name, server] of Object.entries(map)) {
+            const cfg = server;
+            const command = typeof cfg.command === 'string' ? cfg.command : undefined;
+            const args = Array.isArray(cfg.args) ? cfg.args.map(String) : [];
+            const url = typeof cfg.url === 'string' ? cfg.url : typeof cfg.endpoint === 'string' ? cfg.endpoint : undefined;
+            const targetText = [command, ...args, url].filter(Boolean).join(' ');
+            const protectedGateway = /fullcourtdefense|agentguard|mcp-gateway|5066|fcd/i.test(targetText);
+            out.push({
+                name,
+                source: candidate.source,
+                filePath: candidate.path,
+                command,
+                args,
+                url,
+                direct: !protectedGateway,
+                protectedGateway,
+                riskSignals: riskSignalsForServer(name, cfg),
+            });
+        }
+    }
+    return out;
+}
+function parseRequiredControls(value) {
+    return (value || 'payment,delete,shell,secrets')
+        .split(',')
+        .map(part => part.trim().toLowerCase())
+        .filter(Boolean);
+}
+function finding(input) {
+    return { ...input, id: stableId([input.category, input.title, input.filePath || '', input.detail]) };
+}
+function evaluateAgentGate(args) {
+    const cwd = process.cwd();
+    const mcpServers = discoverMcpServers(cwd, args.extraPath);
+    const agentFiles = (0, discoverAgentFiles_1.scanAgentFiles)({ cwd });
+    const secrets = (0, discoverSecrets_1.scanSecrets)({ cwd, maxEnvDepth: 3 });
+    const requireGateway = args.requireGateway !== 'false';
+    const requiredControls = parseRequiredControls(args.requireApprovalFor);
+    const findings = [];
+    for (const server of mcpServers) {
+        if (requireGateway && server.direct && server.riskSignals.length > 0) {
+            findings.push(finding({
+                severity: server.riskSignals.includes('payment') || server.riskSignals.includes('shell') || server.riskSignals.includes('secrets') ? 'critical' : 'high',
+                category: 'mcp',
+                title: `Unprotected MCP server: ${server.name}`,
+                detail: `${server.source} exposes ${server.riskSignals.join(', ')} without Full Court Defense gateway wrapping.`,
+                filePath: server.filePath,
+                remediation: 'Wrap this MCP server with fullcourtdefense protect-all or install-mcp-gateway before merging.',
+            }));
+        }
+        const missingControls = server.riskSignals.filter(signal => requiredControls.includes(signal));
+        if (missingControls.length > 0 && server.direct) {
+            findings.push(finding({
+                severity: 'high',
+                category: 'policy',
+                title: `Missing approval policy evidence for ${server.name}`,
+                detail: `Risky tool signals need approval/block policy before merge: ${missingControls.join(', ')}.`,
+                filePath: server.filePath,
+                remediation: 'Add an AgentGuard action policy requiring approval/block for this tool class, then route through the gateway.',
+            }));
+        }
+    }
+    for (const file of agentFiles.filter(item => item.riskTags.length > 0)) {
+        findings.push(finding({
+            severity: file.riskTags.includes('allows_shell') || file.riskTags.includes('broad_filesystem') ? 'high' : 'medium',
+            category: 'agent-file',
+            title: `Risky agent instruction: ${file.title}`,
+            detail: `${file.filePath} contains agent risk tags: ${file.riskTags.join(', ')}.`,
+            filePath: file.filePath,
+            remediation: 'Review the instruction/rule and add explicit least-privilege boundaries.',
+        }));
+    }
+    for (const secret of secrets.findings.filter(item => item.severity === 'critical' || item.severity === 'high')) {
+        findings.push(finding({
+            severity: secret.severity === 'critical' ? 'critical' : 'high',
+            category: 'secret',
+            title: secret.title,
+            detail: secret.detail,
+            filePath: secret.filePath,
+            remediation: secret.remediation,
+        }));
+    }
+    let score = 100;
+    for (const item of findings) {
+        score -= item.severity === 'critical' ? 25 : item.severity === 'high' ? 12 : item.severity === 'medium' ? 5 : 2;
+    }
+    return { findings: findings.sort((a, b) => SEVERITY_RANK[b.severity] - SEVERITY_RANK[a.severity]), score: Math.max(0, score), mcpServers };
+}
+function shouldFail(findings, failOn) {
+    return findings.some(item => SEVERITY_RANK[item.severity] >= SEVERITY_RANK[failOn]);
+}
+function toSarif(findings) {
+    return {
+        version: '2.1.0',
+        $schema: 'https://json.schemastore.org/sarif-2.1.0.json',
+        runs: [{
+                tool: {
+                    driver: {
+                        name: 'Full Court Defense Agent CI Gate',
+                        informationUri: 'https://fullcourtdefense.ai',
+                        rules: findings.map(item => ({
+                            id: item.id,
+                            name: item.title,
+                            shortDescription: { text: item.title },
+                            fullDescription: { text: item.detail },
+                            help: { text: item.remediation },
+                            defaultConfiguration: {
+                                level: item.severity === 'critical' || item.severity === 'high' ? 'error' : item.severity === 'medium' ? 'warning' : 'note',
+                            },
+                        })),
+                    },
+                },
+                results: findings.map(item => ({
+                    ruleId: item.id,
+                    level: item.severity === 'critical' || item.severity === 'high' ? 'error' : item.severity === 'medium' ? 'warning' : 'note',
+                    message: { text: `${item.title}: ${item.detail}` },
+                    locations: item.filePath ? [{
+                            physicalLocation: {
+                                artifactLocation: { uri: path.relative(process.cwd(), item.filePath).replace(/\\/g, '/') },
+                                region: { startLine: 1 },
+                            },
+                        }] : [],
+                })),
+            }],
+    };
+}
+function printSummary(report, failed, failOn) {
+    console.log(`Agent CI Gate: ${failed ? 'FAIL' : 'PASS'}`);
+    console.log(`Score: ${report.score}/100`);
+    console.log(`MCP servers: ${report.mcpServers.length}`);
+    console.log(`Findings: ${report.findings.length} (fail-on: ${failOn})`);
+    for (const item of report.findings.slice(0, 20)) {
+        console.log(`- [${item.severity.toUpperCase()}] ${item.title}`);
+        console.log(`  ${item.detail}`);
+        if (item.filePath)
+            console.log(`  ${path.relative(process.cwd(), item.filePath)}`);
+    }
+    if (report.findings.length > 20)
+        console.log(`... and ${report.findings.length - 20} more findings`);
+}
+async function agentCiCommand(args, config) {
+    const failOn = (['critical', 'high', 'medium', 'low'].includes(String(args.failOn || '').toLowerCase())
+        ? String(args.failOn).toLowerCase()
+        : 'high');
+    const format = (['summary', 'json', 'sarif'].includes(String(args.format || '').toLowerCase())
+        ? String(args.format).toLowerCase()
+        : 'summary');
+    const report = evaluateAgentGate(args);
+    const failed = shouldFail(report.findings, failOn);
+    if (format === 'json') {
+        console.log(JSON.stringify({ ...report, failed, failOn }, null, 2));
+    }
+    else if (format === 'sarif') {
+        console.log(JSON.stringify(toSarif(report.findings), null, 2));
+    }
+    else {
+        printSummary(report, failed, failOn);
+    }
+    if (args.upload === 'true') {
+        const creds = (0, config_1.resolveCliCredentials)(config, { apiKey: args.apiKey, apiUrl: args.apiUrl });
+        if (creds.apiKey || (creds.shieldId && creds.shieldKey)) {
+            await (0, discover_1.runDiscoverUpload)({ apiKey: args.apiKey, apiUrl: args.apiUrl, silent: true }, config).catch(error => {
+                if (format === 'summary')
+                    console.error(`Upload skipped: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        }
+        else if (format === 'summary') {
+            console.error('Upload skipped: run fullcourtdefense login first or pass --api-key.');
+        }
+    }
+    if (failed)
+        process.exit(1);
+}

package/dist/commands/local-scan.js

@@ -1111,7 +1111,7 @@ function compactScanHtml(args) {
     .workflowCard { min-height: 118px; }
     .workflowCard b { font-size: 18px; }
     .workflowCard span { font-size: 13px; }
-    .landingScanGrid { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 10px; }
+    .landingScanGrid { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 10px; }
     .scanTypeGrid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 10px; margin: 12px 0; }
     .advancedScanGrid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 10px; margin: 8px 0 12px; }
     .card:hover, .card.active { border-color: #2563eb; background: #eff6ff; transform: translateY(-1px); }
@@ -1203,6 +1203,7 @@ function compactScanHtml(args) {
             <button class="card workflowCard" data-workflow="bot"><b>Bot Scan</b><span>Red-team an internal bot, agent, or chat API.</span></button>
             <button class="card workflowCard" data-workflow="posture"><b>Security Posture Scan</b><span>Run web-style endpoint security checkup.</span></button>
             <button class="card workflowCard" data-workflow="mcp"><b>MCP Scan</b><span>Scan an MCP server or protected gateway for risky tool paths.</span></button>
+            <button class="card workflowCard" data-workflow="mcp-posture"><b>MCP Posture Scan</b><span>Inventory exposed MCP tools without invoking them.</span></button>
           </div>
         </div>
         <div class="menuGroup">
@@ -1281,6 +1282,7 @@ function compactScanHtml(args) {
         <div class="advancedScanGrid">
           <button class="card scanTypeCard" data-target="rag"><b>RAG Scan</b><span>Test retrieval URL or local corpus path.</span></button>
           <button class="card scanTypeCard" data-target="mcp"><b>MCP Scan</b><span>Scan tool responses and tool-abuse paths.</span></button>
+          <button class="card scanTypeCard" data-target="mcp-posture"><b>MCP Posture Scan</b><span>List tools and flag risky exposed capabilities.</span></button>
         </div>
       </div>
 
@@ -1329,6 +1331,7 @@ function compactScanHtml(args) {
       </div>
 
       <div id="mcp-fields" class="hidden">
+        <div class="note" id="mcpModeNote">MCP Scan runs red-team templates against MCP tool behavior. MCP Posture Scan lists exposed tools and flags risky capabilities without invoking them.</div>
         <div class="two">
           <div><label>MCP HTTP/SSE URL</label><input id="mcpUrl" placeholder="http://127.0.0.1:5066/mcp" /></div>
           <div><label>MCP tool</label><input id="mcpTool" value="all" /></div>
@@ -1414,19 +1417,25 @@ Local targets stay on this machine; saved scan reports go to Full Court Defense.
     </section>
   </main>
   <script>
-    const scanTargets = ['endpoint','posture','rag','mcp'];
+    const scanTargets = ['endpoint','posture','rag','mcp','mcp-posture'];
     let target = 'home';
     let step = 1;
     const qs = new URLSearchParams(location.search);
-    if (['runner','endpoint','posture','rag','mcp','help'].includes(qs.get('target'))) target = qs.get('target');
+    if (['runner','endpoint','posture','rag','mcp','mcp-posture','help'].includes(qs.get('target'))) target = qs.get('target');
     const byId = id => document.getElementById(id);
     const workflow = () => target === 'endpoint' ? 'bot' : target === 'posture' ? 'posture' : target === 'home' ? '' : target;
     const sync = () => {
       document.querySelectorAll('.workflowCard').forEach(c => c.classList.toggle('active', c.dataset.workflow === workflow()));
       document.querySelectorAll('.scanTypeCard').forEach(c => c.classList.toggle('active', c.dataset.target === target));
       byId('workflowPanel').classList.toggle('hidden', target === 'home');
-      ['runner','endpoint','posture','rag','mcp','help'].forEach(id => byId(id + '-fields').classList.toggle('hidden', id !== target));
+      ['runner','endpoint','posture','rag','mcp','help'].forEach(id => {
+        const show = id === 'mcp' ? ['mcp','mcp-posture'].includes(target) : id === target;
+        byId(id + '-fields').classList.toggle('hidden', !show);
+      });
       const scanTarget = scanTargets.includes(target);
+      byId('mcpModeNote').textContent = target === 'mcp-posture'
+        ? 'MCP Posture Scan lists exposed tools, checks whether the server appears protected, and flags risky capabilities without invoking any tool.'
+        : 'MCP Scan runs red-team templates against MCP tool behavior. Use MCP Posture Scan for inventory-only posture.';
       byId('scan-picker').classList.toggle('hidden', !scanTarget);
       byId('scanSteps').classList.toggle('hidden', !scanTarget);
       byId('scanActions').classList.toggle('hidden', !scanTarget);
@@ -1434,12 +1443,16 @@ Local targets stay on this machine; saved scan reports go to Full Court Defense.
         ? 'Run MCP Tool'
         : target === 'help'
           ? 'Local workflow options'
-          : 'Choose scan target';
+          : target === 'mcp-posture'
+            ? 'MCP posture scan'
+            : 'Choose scan target';
       byId('connectSubtitle').textContent = target === 'runner'
         ? 'Call one MCP tool from this machine. This is not a scan.'
         : target === 'help'
           ? 'Choose one-off tool run or local red-team scan.'
-          : 'Select Endpoint, RAG, or MCP, then connect the internal target.';
+          : target === 'mcp-posture'
+            ? 'Connect an MCP server or protected gateway. No tools are invoked.'
+            : 'Select Endpoint, RAG, or MCP, then connect the internal target.';
       if (!scanTarget || target === 'home') setStep(1);
     };
     const setStep = next => {
@@ -1512,6 +1525,7 @@ Local targets stay on this machine; saved scan reports go to Full Court Defense.
       if (p.target === 'endpoint') parts.push('--endpoint', JSON.stringify(p.endpoint), '--method POST --request-format custom --input-field', p.inputField || 'message', '--output-field', p.outputField || 'response');
       if (p.target === 'posture') return 'Security Posture Scan runs through this local web UI and calls the Full Court Defense posture checkup API for ' + (p.postureUrl || '<endpoint-url>');
       if (p.target === 'rag') { if (p.ragUrl) parts.push('--rag-url', JSON.stringify(p.ragUrl), '--method POST --request-format custom --input-field', p.ragInputField || 'query', '--output-field', p.ragOutputField || 'chunks'); else parts.push('--rag-path', JSON.stringify(p.ragPath || '.\\\\docs')); }
+      if (p.target === 'mcp-posture') return 'MCP Posture Scan runs through this local web UI and inventories exposed tools for ' + (p.mcpUrl || ((p.mcpCommand || 'node') + ' ' + (p.mcpArgs || '.\\\\server.js')));
       if (p.target === 'mcp') { if (p.mcpUrl) parts.push('--mcp-url', JSON.stringify(p.mcpUrl)); else parts.push('--mcp-command', p.mcpCommand || 'node', '--mcp-args', JSON.stringify(p.mcpArgs || '.\\\\server.js')); parts.push('--mcp-tool', p.mcpTool || 'all'); }
       return parts.join(' ');
     };
@@ -1767,6 +1781,20 @@ Local targets stay on this machine; saved scan reports go to Full Court Defense.
       byId('run').disabled = true;
       byId('run').textContent = 'Running...';
       clearScanSummary();
+      if (target === 'mcp-posture') {
+        try {
+          setConsole('Starting MCP Posture Scan...\\nNo MCP tools will be invoked; this only lists exposed tools.\\n', 'Running MCP posture');
+          const postureRes = await fetch('/mcp/posture', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(payload()) });
+          const postureData = await postureRes.json();
+          setConsole(JSON.stringify(postureData, null, 2), postureData.ok ? 'MCP posture complete' : 'MCP posture failed');
+        } catch (error) {
+          setConsole('MCP Posture Scan failed: ' + (error && error.message ? error.message : String(error)), 'MCP posture failed');
+        } finally {
+          byId('run').disabled = false;
+          byId('run').textContent = 'Run local scan';
+        }
+        return;
+      }
       const backendOk = await checkBackend();
       if (!backendOk) {
         setConsole('Outbound backend check failed. Fix backend connectivity before scanning so verdicts and reports can be generated.', 'Blocked');
@@ -2039,6 +2067,84 @@ async function runMcpToolFromBrowser(body) {
         client.close();
     }
 }
+function mcpPostureSignals(tool) {
+    const text = `${tool.name || ''} ${tool.description || ''} ${JSON.stringify(tool.inputSchema || {})}`.toLowerCase();
+    const checks = [
+        [/\b(delete|remove|destroy|drop|wipe|purge|erase)\b/, 'destructive operation'],
+        [/\b(write|update|create|insert|modify|patch|replace)\b/, 'write-capable operation'],
+        [/\b(exec|shell|command|process|spawn|powershell|bash|terminal)\b/, 'shell/command execution'],
+        [/\b(file|filesystem|path|readfile|writefile|directory|upload|download)\b/, 'file-system access'],
+        [/\b(secret|token|key|password|credential|env|private)\b/, 'secret/credential access'],
+        [/\b(payment|wire|transfer|invoice|billing|bank|account|iban)\b/, 'financial operation'],
+        [/\b(http|request|fetch|webhook|url|network|browser)\b/, 'network/browser access'],
+        [/\b(customer|user|email|phone|address|ssn|pii|record)\b/, 'customer/PII data access'],
+    ];
+    return checks.filter(([pattern]) => pattern.test(text)).map(([, label]) => label);
+}
+async function runMcpPostureScanFromBrowser(body) {
+    const rawUrl = typeof body.mcpUrl === 'string' ? body.mcpUrl.trim() : '';
+    const rawCommand = typeof body.mcpCommand === 'string' ? body.mcpCommand.trim() : '';
+    const rawArgs = typeof body.mcpArgs === 'string' ? body.mcpArgs.trim() : '';
+    if (!rawUrl && !rawCommand)
+        throw new Error('Provide either an MCP HTTP/SSE URL or stdio command.');
+    const transport = rawUrl
+        ? (/\/sse\/?$/.test(new URL(rawUrl).pathname) ? 'sse' : 'http')
+        : 'stdio';
+    const options = {
+        transport,
+        url: rawUrl || undefined,
+        command: rawCommand || undefined,
+        args: parseArgsList(rawArgs),
+        authType: 'none',
+        toolName: 'all',
+        toolArgs: {},
+    };
+    const destination = rawUrl || `${rawCommand} ${options.args?.join(' ') || ''}`.trim();
+    const protectedGatewayDetected = /fullcourtdefense|agentguard|fcd|5066|gateway|proxy/i.test(destination);
+    const client = createMcpClient(options);
+    const startedAt = Date.now();
+    try {
+        await client.initialize();
+        const tools = await client.listTools();
+        const toolFindings = tools.map(tool => {
+            const signals = mcpPostureSignals(tool);
+            return {
+                name: tool.name,
+                description: tool.description || '',
+                risk: signals.length >= 3 ? 'high' : signals.length >= 1 ? 'medium' : 'low',
+                signals,
+            };
+        });
+        const highRiskTools = toolFindings.filter(tool => tool.risk === 'high').length;
+        const mediumRiskTools = toolFindings.filter(tool => tool.risk === 'medium').length;
+        const findings = [
+            ...(protectedGatewayDetected ? [] : ['MCP target does not look like a protected Full Court Defense gateway/proxy.']),
+            ...(highRiskTools ? [`${highRiskTools} high-risk MCP tool(s) exposed.`] : []),
+            ...(mediumRiskTools ? [`${mediumRiskTools} medium-risk MCP tool(s) exposed.`] : []),
+            ...(tools.length > 20 ? [`Large MCP surface: ${tools.length} tools exposed.`] : []),
+        ];
+        return {
+            ok: true,
+            scanType: 'mcp_posture',
+            posture: findings.length === 0 ? 'pass' : highRiskTools || !protectedGatewayDetected ? 'fail' : 'warn',
+            transport,
+            destination,
+            protectedGatewayDetected,
+            elapsedMs: Date.now() - startedAt,
+            summary: {
+                totalTools: tools.length,
+                highRiskTools,
+                mediumRiskTools,
+                lowRiskTools: toolFindings.filter(tool => tool.risk === 'low').length,
+            },
+            findings,
+            tools: toolFindings,
+        };
+    }
+    finally {
+        client.close();
+    }
+}
 function startCompactWebServer(args) {
     const server = http.createServer(async (req, res) => {
         try {
@@ -2100,6 +2206,13 @@ function startCompactWebServer(args) {
                 res.end(JSON.stringify(result));
                 return;
             }
+            if (req.method === 'POST' && url.pathname === '/mcp/posture') {
+                const body = await readRequestBody(req);
+                const result = await runMcpPostureScanFromBrowser(body);
+                res.writeHead(200, { 'content-type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify(result));
+                return;
+            }
             if (req.method === 'POST' && url.pathname === '/posture/run') {
                 const body = await readRequestBody(req);
                 const result = await runPostureScanFromBrowser(args, body);

package/dist/index.js

@@ -43,6 +43,7 @@ const configure_1 = require("./commands/configure");
 const login_1 = require("./commands/login");
 const flushSpool_1 = require("./commands/flushSpool");
 const discover_1 = require("./commands/discover");
+const agentCi_1 = require("./commands/agentCi");
 const hook_1 = require("./commands/hook");
 const installCursorHook_1 = require("./commands/installCursorHook");
 const mcpGateway_1 = require("./commands/mcpGateway");
@@ -125,6 +126,8 @@ function printHelp() {
     discover    Finds MCP servers, local secrets, agent rules/skills, and machine
                 blast radius on this laptop. Use --surface all --upload for AI Fleet.
                 Use --schedule logon to upload inventory/posture at machine login.
+    agent-ci    CI/CD gate for agents and tools only. Fails builds on risky MCP,
+                agent instruction, gateway, policy, or secret drift. Not a bot scan.
     install-cursor-hook
                 Installs a Cursor hook so EVERY agent action on this machine is
                 checked against your org's Action Policies — in any repo/folder.
@@ -218,6 +221,8 @@ function printHelp() {
   \x1b[1mRecommended Commands:\x1b[0m
     fullcourtdefense doctor
     fullcourtdefense configure
+    fullcourtdefense agent-ci --fail-on high --require-gateway --format summary
+    fullcourtdefense agent-ci --fail-on high --format sarif --upload
     fullcourtdefense scan --local
     fullcourtdefense scan --local --type mcp --mcp-command node --mcp-args ./server.js --mcp-tool all --mode full --format report
     fullcourtdefense scan --local --type mcp --mcp-url https://internal.company.com/mcp --mcp-auth-type bearer --mcp-token TOKEN --mcp-tool all --mode full --format report
@@ -256,6 +261,9 @@ function printHelp() {
     --rag-url <url>         Live RAG HTTP endpoint to scan
     --shield-id <id>        Shield ID for local outbound Shield verdicts
     --shield-key <key>      Optional Shield key for locked Shields
+    --fail-on <severity>    agent-ci fail threshold: critical, high, medium, low
+    --require-gateway       agent-ci requires risky MCP servers to use FCD gateway
+    --require-approval-for  agent-ci risky controls list, e.g. payment,delete,shell,secrets
     --method <GET|POST>     Local endpoint method
     --request-format <fmt>  Local endpoint request format: custom or openai
     --auth-type <type>      none, bearer, basic, api-key
@@ -489,6 +497,20 @@ async function main() {
             await (0, discover_1.discoverCommand)(args, config);
             break;
         }
+        case 'agent-ci': {
+            const args = {
+                failOn: flags['fail-on'],
+                format: flags.format,
+                upload: flags.upload,
+                requireGateway: flags['require-gateway'],
+                requireApprovalFor: flags['require-approval-for'],
+                extraPath: flags.path,
+                apiKey: flags['api-key'],
+                apiUrl: flags['api-url'],
+            };
+            await (0, agentCi_1.agentCiCommand)(args, config);
+            break;
+        }
         case 'install-cursor-hook': {
             const args = {
                 project: flags.project,

package/dist/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.7.16"
+  "version": "1.7.18"
 }

package/package.json

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