fullcourtdefense-cli 1.7.17 → 1.7.19

package/dist/commands/agentCi.d.ts

@@ -0,0 +1,13 @@
+import { BotGuardConfig } from '../config';
+export interface AgentCiArgs {
+    failOn?: string;
+    format?: string;
+    upload?: string;
+    requireUpload?: 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,311 @@
+"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);
+    }
+    const uploadRequested = args.upload === 'true' || args.requireUpload === 'true';
+    if (uploadRequested) {
+        const creds = (0, config_1.resolveCliCredentials)(config, { apiKey: args.apiKey, apiUrl: args.apiUrl });
+        if (creds.apiKey || (creds.shieldId && creds.shieldKey)) {
+            try {
+                await (0, discover_1.runDiscoverUpload)({ apiKey: args.apiKey, apiUrl: args.apiUrl, silent: true }, config);
+                console.error('AgentGuard evidence upload: uploaded to AI Fleet / discovery posture inventory.');
+            }
+            catch (error) {
+                console.error(`AgentGuard evidence upload: failed (${error instanceof Error ? error.message : String(error)})`);
+                if (args.requireUpload === 'true')
+                    process.exit(1);
+            }
+        }
+        else {
+            console.error('AgentGuard evidence upload: missing credentials. Run fullcourtdefense login or pass FULLCOURTDEFENSE_API_KEY.');
+            if (args.requireUpload === 'true')
+                process.exit(1);
+        }
+    }
+    if (failed)
+        process.exit(1);
+}

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,10 @@ 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
+    --require-upload        agent-ci fails if evidence cannot upload to AgentGuard UI
     --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 +498,21 @@ 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,
+                requireUpload: flags['require-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.17"
+  "version": "1.7.19"
 }

package/package.json

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