fullcourtdefense-cli 1.14.7 → 1.14.9

package/dist/commands/discover.js

@@ -39,6 +39,7 @@ const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
 const config_1 = require("../config");
 const discoverProxy_1 = require("./discoverProxy");
 const discoverSchedule_1 = require("./discoverSchedule");
@@ -227,7 +228,7 @@ const RISK_RULES = [
     { test: /stripe|payment|refund|payout|invoice|billing/i, level: 'critical', tag: 'payments' },
     { test: /filesystem|file[-_]?system|\bfs\b|read[-_]?file|write[-_]?file/i, level: 'high', tag: 'filesystem' },
     { test: /github|gitlab|bitbucket/i, level: 'high', tag: 'source-control' },
-    { test: /aws|gcp|azure|cloud|kubernetes|k8s|terraform/i, level: 'high', tag: 'cloud-infra' },
+    { test: /aws|gcp|azure|cloud|kubernetes|k8s|terraform|docker|container|podman/i, level: 'high', tag: 'cloud-infra' },
     { test: /slack|email|gmail|smtp|sendgrid|twilio|notification/i, level: 'high', tag: 'messaging' },
     { test: /browser|puppeteer|playwright|fetch|http[-_]?request|web[-_]?search/i, level: 'medium', tag: 'web/network' },
     { test: /drive|gdrive|dropbox|s3|storage|notion|confluence/i, level: 'medium', tag: 'data-store' },
@@ -361,7 +362,94 @@ async function mcpJsonRpc(endpoint, method, params, timeoutMs, sessionId) {
         clearTimeout(timer);
     }
 }
-/** Best-effort live tools/list for HTTP/SSE MCP servers (stdio skipped — would spawn processes). */
+function extractJsonRpcMessages(chunk) {
+    const messages = [];
+    let buffer = chunk;
+    while (true) {
+        const headerEnd = buffer.indexOf('\r\n\r\n');
+        if (headerEnd < 0)
+            break;
+        const header = buffer.slice(0, headerEnd);
+        const match = header.match(/Content-Length:\s*(\d+)/i);
+        if (!match)
+            break;
+        const length = Number(match[1]);
+        const bodyStart = headerEnd + 4;
+        const bodyEnd = bodyStart + length;
+        if (buffer.length < bodyEnd)
+            break;
+        try {
+            messages.push(JSON.parse(buffer.slice(bodyStart, bodyEnd)));
+        }
+        catch {
+            // Ignore malformed frames from noisy local servers.
+        }
+        buffer = buffer.slice(bodyEnd);
+    }
+    for (const line of chunk.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('{'))
+            continue;
+        try {
+            messages.push(JSON.parse(trimmed));
+        }
+        catch {
+            // Ignore logs or partial lines.
+        }
+    }
+    return messages;
+}
+function normalizeMcpToolList(tools) {
+    if (!Array.isArray(tools))
+        return [];
+    return tools
+        .map((t) => (t && typeof t.name === 'string'
+        ? { name: t.name, description: typeof t.description === 'string' ? t.description : undefined }
+        : null))
+        .filter(Boolean);
+}
+async function probeStdioMcpTools(command, args = [], timeoutMs = 8000) {
+    return new Promise(resolve => {
+        const child = (0, child_process_1.spawn)(command, args, {
+            cwd: process.cwd(),
+            env: process.env,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        let done = false;
+        const finish = (tools = []) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            child.kill();
+            resolve(tools);
+        };
+        const timer = setTimeout(() => finish([]), timeoutMs);
+        child.on('error', () => finish([]));
+        child.on('exit', () => finish([]));
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', chunk => {
+            for (const message of extractJsonRpcMessages(String(chunk))) {
+                if (message?.id !== 2)
+                    continue;
+                const tools = normalizeMcpToolList(message?.result?.tools);
+                finish(tools);
+            }
+        });
+        const send = (id, method, params = {}) => {
+            child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n');
+        };
+        send(1, 'initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'fullcourtdefense-discover', version: '1.0.0' },
+        });
+        child.stdin.write(JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized', params: {} }) + '\n');
+        send(2, 'tools/list');
+    });
+}
+/** Best-effort live tools/list for HTTP/SSE MCP servers. */
 async function probeHttpMcpTools(url, timeoutMs = 8000) {
     const normalized = url.replace(/\/$/, '');
     const candidates = [...new Set([
@@ -384,9 +472,7 @@ async function probeHttpMcpTools(url, timeoutMs = 8000) {
             const listed = await mcpJsonRpc(endpoint, 'tools/list', {}, timeoutMs, sid);
             const tools = listed.json?.result?.tools;
             if (Array.isArray(tools) && tools.length > 0) {
-                return tools
-                    .map((t) => (t && typeof t.name === 'string' ? { name: t.name, description: typeof t.description === 'string' ? t.description : undefined } : null))
-                    .filter(Boolean);
+                return normalizeMcpToolList(tools);
             }
         }
         catch {
@@ -398,8 +484,23 @@ async function probeHttpMcpTools(url, timeoutMs = 8000) {
 async function enrichWithDeepProbe(servers, silent) {
     for (const server of servers) {
         if (server.transport !== 'http' && server.transport !== 'sse') {
-            if (!silent && server.transport === 'stdio') {
-                server.warnings.push('Deep probe skipped for stdio server (config-only inventory).');
+            if (server.transport === 'stdio' && server.command) {
+                const downstream = (0, discoverProxy_1.isFcdGatewayServer)(server) ? (0, discoverProxy_1.extractGatewayDownstream)(server) : null;
+                const command = downstream?.command || server.command;
+                const args = downstream?.args || server.args || [];
+                const liveTools = await probeStdioMcpTools(command, args);
+                if (liveTools.length > 0) {
+                    const byName = new Map(server.tools.map(t => [t.name, t]));
+                    for (const tool of liveTools)
+                        byName.set(tool.name, tool);
+                    server.tools = [...byName.values()];
+                    server.probeMode = 'deep';
+                    continue;
+                }
+                server.warnings.push('Deep probe could not list tools from stdio server (server may require auth or failed to start).');
+            }
+            else if (!silent && server.transport === 'stdio') {
+                server.warnings.push('Deep probe skipped for stdio server without a command.');
             }
             continue;
         }
@@ -678,7 +779,7 @@ async function discoverCommand(args, config) {
         clientCoverage = applyProxyClassification(found, scanned, cwd);
         if (deep && found.length > 0) {
             if (!silent)
-                console.log(`${COLOR.gray}Running deep probe (HTTP/SSE tools/list)…${COLOR.reset}`);
+                console.log(`${COLOR.gray}Running deep probe (HTTP/SSE/stdio tools/list)…${COLOR.reset}`);
             await enrichWithDeepProbe(found, silent);
         }
     }

package/dist/commands/knownMcpServers.js

@@ -39,6 +39,51 @@ const KNOWN = [
             recommendGateway: true,
         },
     },
+    {
+        match: /docker|container|podman/i,
+        info: {
+            title: 'Container runtime',
+            description: 'Controls local containers or registry access from the AI client.',
+            category: 'other',
+            recommendGateway: true,
+        },
+    },
+    {
+        match: /kubernetes|k8s/i,
+        info: {
+            title: 'Kubernetes',
+            description: 'Controls Kubernetes resources from the AI client.',
+            category: 'other',
+            recommendGateway: true,
+        },
+    },
+    {
+        match: /aws|gcp|azure|terraform|cloud/i,
+        info: {
+            title: 'Cloud infrastructure',
+            description: 'Controls cloud infrastructure or deployment resources.',
+            category: 'other',
+            recommendGateway: true,
+        },
+    },
+    {
+        match: /slack|gmail|email|sendgrid|twilio/i,
+        info: {
+            title: 'Messaging',
+            description: 'Can send messages or notifications through external services.',
+            category: 'other',
+            recommendGateway: true,
+        },
+    },
+    {
+        match: /memory/i,
+        info: {
+            title: 'Memory',
+            description: 'Stores local agent memory; review content, but this is usually lower risk than shell, database, or cloud tools.',
+            category: 'other',
+            recommendGateway: false,
+        },
+    },
     {
         match: /agentguard-gateway|fullcourtdefense-gateway|fcd-gateway/i,
         info: {

package/dist/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.14.7"
+  "version": "1.14.9"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullcourtdefense-cli",
-  "version": "1.14.7",
+  "version": "1.14.9",
   "description": "Full Court Defense CLI — security scanning for AI agents from your terminal",
   "main": "dist/index.js",
   "bin": {
@@ -23,6 +23,7 @@
     "test:secret-posture": "npm run build && node scripts/test-secret-posture-fixtures.js",
     "test:agent-file-posture": "npm run build && node scripts/test-agent-file-posture.js",
     "test:realworld-posture": "npm run build && node scripts/test-realworld-posture-fixtures.js",
+    "test:discover-stdio-mcp": "npm run build && node scripts/test-discover-stdio-mcp-tools.js",
     "test:posture-blast": "npm run build && node scripts/test-posture-blast-radius.js",
     "test:ping-e2e": "npm run build && node scripts/test-ping-e2e.js",
     "prepublishOnly": "npm run build"