fullcourtdefense-cli 1.1.17 → 1.2.0

package/README.md

@@ -53,8 +53,41 @@ fullcourtdefense init
 - `fullcourtdefense install-claude-code-mcp-gateway ...` — registers the protected MCP gateway in Claude Code.
 - `fullcourtdefense install-claude-desktop-mcp-gateway ...` — registers the protected MCP gateway in Claude Desktop.
 - `fullcourtdefense credits` — checks hosted scan credits for CI/CD API-key scans.
+- `fullcourtdefense discover` — scans local MCP client configs and reports risk; `--upload` sends desktop inventory to AI Inventory.
 - `fullcourtdefense init` — creates a starter config file.
 
+## Shadow AI / Desktop Discovery
+
+Find MCP servers configured on developer machines without reading chat history or spawning stdio servers by default:
+
+```bash
+# Scan this machine and print results
+fullcourtdefense discover
+
+# JSON output (includes host fingerprint + servers)
+fullcourtdefense discover --json
+
+# Upload to AI Inventory (requires CI/CD API key with audit:write)
+fullcourtdefense discover --upload --api-key YOUR_KEY
+
+# Live-probe HTTP/SSE MCP servers for tools/list (stdio stays config-only)
+fullcourtdefense discover --deep
+
+# Fleet / MDM script — silent upload with user attribution
+fullcourtdefense discover --upload --silent --user-email you@company.com --api-key YOUR_KEY
+
+# Daily automatic scan on this laptop (uses API key from env or ~/.fullcourtdefense.yml)
+fullcourtdefense discover --schedule daily --user-email you@company.com
+
+# Remove daily schedule
+fullcourtdefense discover --unschedule true
+
+# Scan an extra config path
+fullcourtdefense discover --path /path/to/mcp.json
+```
+
+Each upload includes host metadata (`machineId`, `hostname`, `platform`, `user`) so the same MCP server on different laptops appears as separate desktop inventory rows. The CLI is also available as `fcd` or `botguard` after global install.
+
 ## Config File
 
 Create a `.fullcourtdefense.yml` to avoid passing flags every time:

package/dist/commands/discover.d.ts

@@ -7,5 +7,19 @@ export interface DiscoverArgs {
     upload?: string;
     connectorName?: string;
     extraPath?: string;
+    deep?: string;
+    silent?: string;
+    userEmail?: string;
+    schedule?: string;
+    unschedule?: string;
+    scheduleHour?: string;
+}
+export interface DesktopDiscoveryHost {
+    machineId: string;
+    hostname: string;
+    platform: string;
+    user: string;
+    scannedAt: string;
+    probeMode: 'config' | 'deep';
 }
 export declare function discoverCommand(args: DiscoverArgs, config: BotGuardConfig): Promise<void>;

package/dist/commands/discover.js

@@ -34,12 +34,30 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.discoverCommand = discoverCommand;
+const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const discoverProxy_1 = require("./discoverProxy");
+const discoverSchedule_1 = require("./discoverSchedule");
 const DEFAULT_API_URL = 'https://api.fullcourtdefense.ai';
 const SECRET_VALUE = /sk-[A-Za-z0-9_-]{12,}|ghp_[A-Za-z0-9_]{20,}|xox[baprs]-[A-Za-z0-9-]{20,}|AKIA[0-9A-Z]{16}|AIza[0-9A-Za-z_-]{20,}/;
 const SECRET_KEY = /key|token|secret|password|credential|api[_-]?key/i;
+function machineFingerprint() {
+    const seed = [os.hostname(), os.userInfo().username, os.platform(), os.arch()].join('|');
+    return crypto.createHash('sha256').update(seed).digest('hex').slice(0, 16);
+}
+function buildHostMetadata(userEmail, probeMode = 'config') {
+    const info = os.userInfo();
+    return {
+        machineId: machineFingerprint(),
+        hostname: os.hostname(),
+        platform: os.platform(),
+        user: userEmail || info.username,
+        scannedAt: new Date().toISOString(),
+        probeMode,
+    };
+}
 /** Where MCP client configs live, by client + OS. */
 function candidateConfigPaths(cwd, extra) {
     const home = os.homedir();
@@ -50,10 +68,25 @@ function candidateConfigPaths(cwd, extra) {
         // Cursor
         { path: path.join(home, '.cursor', 'mcp.json'), source: 'Cursor (global)' },
         { path: path.join(cwd, '.cursor', 'mcp.json'), source: 'Cursor (project)' },
+        // Cursor managed (enterprise)
+        { path: path.join(appData, 'Cursor', 'managed-mcp.json'), source: 'Cursor (managed, win)' },
+        { path: path.join(home, 'Library', 'Application Support', 'Cursor', 'managed-mcp.json'), source: 'Cursor (managed, mac)' },
+        { path: '/etc/cursor/managed-mcp.json', source: 'Cursor (managed, linux)' },
         // Claude Desktop
         { path: path.join(appData, 'Claude', 'claude_desktop_config.json'), source: 'Claude Desktop (win)' },
         { path: path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'), source: 'Claude Desktop (mac)' },
         { path: path.join(xdg, 'Claude', 'claude_desktop_config.json'), source: 'Claude Desktop (linux)' },
+        // Claude Code
+        { path: path.join(home, '.claude.json'), source: 'Claude Code' },
+        { path: path.join(home, '.claude', 'settings.json'), source: 'Claude Code (global)' },
+        { path: path.join(cwd, '.claude', 'settings.json'), source: 'Claude Code (project)' },
+        { path: path.join(cwd, '.mcp.json'), source: 'Claude Code (.mcp.json project)' },
+        // Gemini CLI
+        { path: path.join(home, '.gemini', 'settings.json'), source: 'Gemini CLI' },
+        { path: path.join(xdg, 'gemini', 'settings.json'), source: 'Gemini CLI (xdg)' },
+        // OpenAI Codex
+        { path: path.join(home, '.codex', 'mcp.json'), source: 'Codex' },
+        { path: path.join(xdg, 'codex', 'mcp.json'), source: 'Codex (xdg)' },
         // VS Code (project + user settings)
         { path: path.join(cwd, '.vscode', 'mcp.json'), source: 'VS Code (project)' },
         { path: path.join(appData, 'Code', 'User', 'settings.json'), source: 'VS Code (user, win)' },
@@ -61,11 +94,14 @@ function candidateConfigPaths(cwd, extra) {
         { path: path.join(xdg, 'Code', 'User', 'settings.json'), source: 'VS Code (user, linux)' },
         // Windsurf
         { path: path.join(home, '.codeium', 'windsurf', 'mcp_config.json'), source: 'Windsurf' },
+        // Kiro / generic
+        { path: path.join(home, '.kiro', 'mcp.json'), source: 'Kiro' },
         // Generic / repo-root
         { path: path.join(cwd, '.mcp.json'), source: 'Repo (.mcp.json)' },
         { path: path.join(cwd, 'mcp.json'), source: 'Repo (mcp.json)' },
     ];
     if (process.platform === 'win32') {
+        list.push({ path: path.join(process.env.ProgramData || 'C:\\ProgramData', 'Cursor', 'managed-mcp.json'), source: 'Cursor (managed, program data)' });
         const packagesDir = path.join(localAppData, 'Packages');
         try {
             for (const packageName of fs.readdirSync(packagesDir)) {
@@ -137,7 +173,7 @@ function parseConfigFile(filePath, source) {
         parsed = JSON.parse(raw);
     }
     catch {
-        return []; // settings.json with comments/JSONC — best-effort skip
+        return [];
     }
     const servers = extractServerMap(parsed);
     const out = [];
@@ -152,7 +188,15 @@ function parseConfigFile(filePath, source) {
             ? (/\/sse(\b|$)/.test(url) ? 'sse' : 'http')
             : command ? 'stdio' : 'unknown';
         const tools = Array.isArray(cfg.tools)
-            ? cfg.tools.map((t) => (typeof t === 'string' ? t : t?.name)).filter(Boolean).map(String)
+            ? cfg.tools
+                .map((t) => {
+                if (typeof t === 'string')
+                    return { name: t };
+                if (t && typeof t.name === 'string')
+                    return { name: t.name, description: typeof t.description === 'string' ? t.description : undefined };
+                return null;
+            })
+                .filter(Boolean)
             : [];
         const { level, tags } = scoreRisk({ serverName: name, command, args, url });
         const warnings = [];
@@ -178,10 +222,97 @@ function parseConfigFile(filePath, source) {
             riskLevel: level,
             riskTags: tags,
             warnings,
+            probeMode: 'config',
+            proxyStatus: 'unknown',
         });
     }
     return out;
 }
+async function mcpJsonRpc(endpoint, method, params, timeoutMs, sessionId) {
+    const headers = {
+        'Content-Type': 'application/json',
+        Accept: 'application/json, text/event-stream',
+    };
+    if (sessionId)
+        headers['Mcp-Session-Id'] = sessionId;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const resp = await fetch(endpoint, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({ jsonrpc: '2.0', id: Date.now(), method, params }),
+            signal: controller.signal,
+        });
+        const nextSession = resp.headers.get('mcp-session-id') || sessionId;
+        const ct = resp.headers.get('content-type') || '';
+        if (ct.includes('text/event-stream')) {
+            const text = await resp.text();
+            const dataLine = text.split('\n').find(line => line.startsWith('data: '));
+            return { json: dataLine ? JSON.parse(dataLine.slice(6)) : null, sessionId: nextSession || undefined };
+        }
+        return { json: await resp.json(), sessionId: nextSession || undefined };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** Best-effort live tools/list for HTTP/SSE MCP servers (stdio skipped — would spawn processes). */
+async function probeHttpMcpTools(url, timeoutMs = 8000) {
+    const normalized = url.replace(/\/$/, '');
+    const candidates = [...new Set([
+            normalized,
+            normalized.replace(/\/sse(\?.*)?$/i, ''),
+            `${normalized}/mcp`,
+            normalized.replace(/\/sse(\?.*)?$/i, '/mcp'),
+        ])];
+    for (const endpoint of candidates) {
+        try {
+            const init = await mcpJsonRpc(endpoint, 'initialize', {
+                protocolVersion: '2024-11-05',
+                capabilities: {},
+                clientInfo: { name: 'fullcourtdefense-discover', version: '1.0.0' },
+            }, timeoutMs);
+            const sid = init.sessionId;
+            if (init.json?.error)
+                continue;
+            await mcpJsonRpc(endpoint, 'notifications/initialized', {}, timeoutMs, sid);
+            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);
+            }
+        }
+        catch {
+            // try next endpoint variant
+        }
+    }
+    return [];
+}
+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).');
+            }
+            continue;
+        }
+        if (!server.url)
+            continue;
+        const liveTools = await probeHttpMcpTools(server.url);
+        if (liveTools.length === 0) {
+            server.warnings.push('Deep probe could not list tools (server may require auth or be offline).');
+            continue;
+        }
+        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';
+    }
+}
 /** Merge servers found in multiple files; keep richest record, union sources. */
 function dedupe(servers) {
     const byName = new Map();
@@ -195,8 +326,13 @@ function dedupe(servers) {
             existing.source += `, ${s.source}`;
         existing.command = existing.command || s.command;
         existing.url = existing.url || s.url;
-        existing.tools = Array.from(new Set([...existing.tools, ...s.tools]));
+        const toolMap = new Map(existing.tools.map(t => [t.name, t]));
+        for (const t of s.tools)
+            toolMap.set(t.name, t);
+        existing.tools = [...toolMap.values()];
         existing.warnings = Array.from(new Set([...existing.warnings, ...s.warnings]));
+        if (s.probeMode === 'deep')
+            existing.probeMode = 'deep';
     }
     return [...byName.values()];
 }
@@ -207,14 +343,47 @@ const COLOR = {
 function riskColor(level) {
     return level === 'critical' || level === 'high' ? COLOR.red : level === 'medium' ? COLOR.yellow : COLOR.green;
 }
-async function upload(servers, apiUrl, apiKey, connectorName) {
+function applyProxyClassification(servers, scanned, cwd) {
+    const wrapsByConfig = (0, discoverProxy_1.buildGatewayWrapIndex)(servers);
+    for (const server of servers) {
+        server.proxyStatus = (0, discoverProxy_1.classifyProxyStatus)(server, wrapsByConfig);
+        if (server.proxyStatus === 'fcd_gateway') {
+            server.wrapsServerName = (0, discoverProxy_1.extractGatewayDownstream)(server)?.label;
+        }
+        if (server.proxyStatus === 'direct' && server.riskLevel !== 'low') {
+            server.warnings.push('Direct MCP — not proxied through Full Court Defense gateway.');
+        }
+    }
+    return (0, discoverProxy_1.buildClientCoverage)(scanned, servers, cwd);
+}
+function proxyStatusLabel(status) {
+    if (status === 'fcd_gateway')
+        return 'FCD gateway';
+    if (status === 'proxied')
+        return 'Proxied';
+    if (status === 'direct')
+        return 'Direct — needs gateway';
+    return 'Unknown';
+}
+async function upload(servers, host, clientCoverage, apiUrl, apiKey, connectorName) {
     const payload = {
-        connectorName: connectorName || 'Local MCP discovery (CLI)',
+        connectorName: connectorName || `Desktop MCP · ${host.hostname}`,
+        host,
+        clientCoverage,
         servers: servers.map(s => ({
             serverName: s.serverName,
             command: s.command,
             url: s.url,
-            tools: s.tools.map(name => ({ name })),
+            transport: s.transport,
+            clientSource: s.source,
+            configPath: s.configPath,
+            riskLevel: s.riskLevel,
+            riskTags: s.riskTags,
+            warnings: s.warnings,
+            probeMode: s.probeMode,
+            proxyStatus: s.proxyStatus,
+            wrapsServerName: s.wrapsServerName,
+            tools: s.tools,
         })),
     };
     const resp = await fetch(`${apiUrl.replace(/\/$/, '')}/api/cicd/discovery/mcp`, {
@@ -227,12 +396,30 @@ async function upload(servers, apiUrl, apiKey, connectorName) {
         throw new Error(data.error || `Upload failed (${resp.status})`);
     }
     const ingested = data.data?.ingested ?? servers.length;
-    console.log(`${COLOR.green}Uploaded ${ingested} MCP server(s) to your AI Inventory.${COLOR.reset}`);
+    console.log(`${COLOR.green}Uploaded ${ingested} MCP server(s) from ${host.hostname} to your AI Inventory.${COLOR.reset}`);
 }
 async function discoverCommand(args, config) {
     const type = (args.type || 'mcp').toLowerCase();
+    const silent = args.silent === 'true';
+    const deep = args.deep === 'true';
+    if (args.unschedule === 'true') {
+        (0, discoverSchedule_1.uninstallDailyDiscoverSchedule)();
+        if (!silent)
+            console.log('Removed daily desktop discovery schedule.');
+        return;
+    }
+    if (args.schedule === 'daily') {
+        const hour = args.scheduleHour ? Number.parseInt(args.scheduleHour, 10) : 9;
+        (0, discoverSchedule_1.installDailyDiscoverSchedule)({ userEmail: args.userEmail, hour: Number.isFinite(hour) ? hour : 9 });
+        if (!silent) {
+            console.log(`Daily desktop discovery scheduled (runs discover --upload --silent${args.userEmail ? ` --user-email ${args.userEmail}` : ''}).`);
+            console.log('Requires FULLCOURTDEFENSE_API_KEY or apiKey in ~/.fullcourtdefense.yml');
+        }
+        return;
+    }
     if (type !== 'mcp') {
-        console.error(`Unsupported discover type "${type}". Supported: mcp`);
+        if (!silent)
+            console.error(`Unsupported discover type "${type}". Supported: mcp`);
         process.exit(1);
     }
     const cwd = process.cwd();
@@ -242,24 +429,49 @@ async function discoverCommand(args, config) {
     for (const c of candidates) {
         if (!fs.existsSync(c.path))
             continue;
-        scanned.push(`${c.source} → ${c.path}`);
+        scanned.push({ path: c.path, source: c.source });
         found.push(...parseConfigFile(c.path, c.source));
     }
     found = dedupe(found);
+    const 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}`);
+        await enrichWithDeepProbe(found, silent);
+    }
+    const host = buildHostMetadata(args.userEmail, deep && found.some(s => s.probeMode === 'deep') ? 'deep' : 'config');
     if (args.json === 'true') {
-        console.log(JSON.stringify({ scannedFiles: scanned, servers: found }, null, 2));
+        console.log(JSON.stringify({
+            host,
+            scannedFiles: scanned.map(s => `${s.source} → ${s.path}`),
+            clientCoverage,
+            servers: found,
+        }, null, 2));
+        return;
+    }
+    if (silent) {
+        if (args.upload === 'true') {
+            const apiKey = args.apiKey || config.apiKey || process.env.FULLCOURTDEFENSE_API_KEY;
+            const apiUrl = args.apiUrl || config.apiUrl || DEFAULT_API_URL;
+            if (!apiKey)
+                process.exit(1);
+            if (found.length === 0)
+                return;
+            await upload(found, host, clientCoverage, apiUrl, apiKey, args.connectorName);
+        }
         return;
     }
     console.log(`\n${COLOR.bold}${COLOR.cyan}MCP server discovery${COLOR.reset}`);
+    console.log(`${COLOR.gray}Host ${host.hostname} · ${host.platform} · machine ${host.machineId}${COLOR.reset}`);
     console.log(`${COLOR.gray}Scanned ${candidates.length} known config locations on this machine.${COLOR.reset}\n`);
     if (scanned.length === 0) {
         console.log(`${COLOR.yellow}No MCP config files found.${COLOR.reset}`);
-        console.log(`${COLOR.gray}Looked in Cursor, Claude Desktop, VS Code, Windsurf, and repo-root configs.${COLOR.reset}`);
+        console.log(`${COLOR.gray}Looked in Cursor, Claude Desktop/Code, VS Code, Windsurf, Codex, Gemini CLI, and repo-root configs.${COLOR.reset}`);
         return;
     }
     console.log(`${COLOR.bold}Config files found:${COLOR.reset}`);
     for (const s of scanned)
-        console.log(`  ${COLOR.dim}•${COLOR.reset} ${s}`);
+        console.log(`  ${COLOR.dim}•${COLOR.reset} ${s.source} → ${s.path}`);
     console.log('');
     if (found.length === 0) {
         console.log(`${COLOR.yellow}Config files exist but declare no MCP servers.${COLOR.reset}`);
@@ -267,16 +479,30 @@ async function discoverCommand(args, config) {
     }
     const order = { critical: 0, high: 1, medium: 2, low: 3 };
     found.sort((a, b) => order[a.riskLevel] - order[b.riskLevel]);
+    if (clientCoverage.length > 0) {
+        console.log(`${COLOR.bold}Client coverage:${COLOR.reset}`);
+        for (const row of clientCoverage) {
+            const gateway = row.mcpGatewayInstalled ? `${COLOR.green}gateway ✓${COLOR.reset}` : `${COLOR.red}no gateway${COLOR.reset}`;
+            const hooks = row.clientKey === 'cursor'
+                ? (row.cursorHooksInstalled ? `${COLOR.green}hooks ✓ (${row.cursorHookEvents.join(', ')})${COLOR.reset}` : `${COLOR.yellow}no hooks${COLOR.reset}`)
+                : '';
+            console.log(`  ${COLOR.dim}•${COLOR.reset} ${row.client} — ${row.mcpServerCount} MCP · ${gateway}${hooks ? ` · ${hooks}` : ''}`);
+        }
+        console.log('');
+    }
     console.log(`${COLOR.bold}${found.length} MCP server(s) discovered:${COLOR.reset}\n`);
     for (const s of found) {
         const col = riskColor(s.riskLevel);
         const target = s.command ? `${s.command} ${(s.args || []).join(' ')}`.trim() : (s.url || 'unknown');
-        console.log(`  ${col}${COLOR.bold}[${s.riskLevel.toUpperCase()}]${COLOR.reset} ${COLOR.bold}${s.serverName}${COLOR.reset} ${COLOR.gray}(${s.transport})${COLOR.reset}`);
+        const proxyCol = s.proxyStatus === 'direct' ? COLOR.red : s.proxyStatus === 'proxied' || s.proxyStatus === 'fcd_gateway' ? COLOR.green : COLOR.yellow;
+        console.log(`  ${col}${COLOR.bold}[${s.riskLevel.toUpperCase()}]${COLOR.reset} ${COLOR.bold}${s.serverName}${COLOR.reset} ${COLOR.gray}(${s.transport}${s.probeMode === 'deep' ? ', deep' : ''})${COLOR.reset} ${proxyCol}${proxyStatusLabel(s.proxyStatus)}${COLOR.reset}`);
         console.log(`        ${COLOR.gray}target:${COLOR.reset} ${target}`);
         if (s.riskTags.length)
             console.log(`        ${COLOR.gray}tags:${COLOR.reset} ${s.riskTags.join(', ')}`);
-        if (s.tools.length)
-            console.log(`        ${COLOR.gray}tools:${COLOR.reset} ${s.tools.slice(0, 12).join(', ')}${s.tools.length > 12 ? ' …' : ''}`);
+        if (s.tools.length) {
+            const names = s.tools.map(t => t.name);
+            console.log(`        ${COLOR.gray}tools:${COLOR.reset} ${names.slice(0, 12).join(', ')}${names.length > 12 ? ' …' : ''}`);
+        }
         console.log(`        ${COLOR.gray}from:${COLOR.reset} ${s.source}`);
         for (const w of s.warnings)
             console.log(`        ${COLOR.red}⚠ ${w}${COLOR.reset}`);
@@ -292,9 +518,12 @@ async function discoverCommand(args, config) {
             process.exit(1);
         }
         console.log('');
-        await upload(found, apiUrl, apiKey, args.connectorName);
+        await upload(found, host, clientCoverage, apiUrl, apiKey, args.connectorName);
     }
     else {
         console.log(`${COLOR.gray}Run with --upload to push these into your AI Inventory.${COLOR.reset}`);
+        if (!deep)
+            console.log(`${COLOR.gray}Add --deep to live-probe HTTP/SSE servers for tools/list.${COLOR.reset}`);
+        console.log(`${COLOR.gray}Add --schedule daily for automatic daily upload (MDM/fleet).${COLOR.reset}`);
     }
 }

package/dist/commands/discoverProxy.d.ts

@@ -0,0 +1,42 @@
+export type DesktopProxyStatus = 'fcd_gateway' | 'proxied' | 'direct' | 'unknown';
+export declare const FCD_GATEWAY_SERVER_NAMES: Set<string>;
+export declare const FCD_HOOK_MARKER = "--fcd-managed true";
+export declare const FCD_HOOK_TAG = "fullcourtdefense";
+export interface ClientCoverageRow {
+    client: string;
+    clientKey: string;
+    configPath: string;
+    configPresent: boolean;
+    mcpServerCount: number;
+    mcpGatewayInstalled: boolean;
+    cursorHooksInstalled: boolean;
+    cursorHookEvents: string[];
+    cursorHookShadow: boolean;
+}
+export interface ProxyClassifiableServer {
+    serverName: string;
+    command?: string;
+    args?: string[];
+    url?: string;
+    source: string;
+    configPath: string;
+}
+export declare function isFcdGatewayServer(server: ProxyClassifiableServer): boolean;
+export declare function extractGatewayDownstream(server: ProxyClassifiableServer): {
+    command?: string;
+    args?: string[];
+    label?: string;
+} | null;
+/** Per-client downstream targets wrapped by FCD gateway entries in the same config file. */
+export declare function buildGatewayWrapIndex(servers: ProxyClassifiableServer[]): Map<string, Set<string>>;
+export declare function classifyProxyStatus(server: ProxyClassifiableServer, wrapsByConfig: Map<string, Set<string>>): DesktopProxyStatus;
+export declare function scanCursorHooks(projectPath?: string): {
+    installed: boolean;
+    events: string[];
+    shadow: boolean;
+};
+export declare function clientKeyFromSource(source: string): string;
+export declare function buildClientCoverage(scanned: Array<{
+    path: string;
+    source: string;
+}>, servers: ProxyClassifiableServer[], cwd: string): ClientCoverageRow[];

package/dist/commands/discoverProxy.js

@@ -0,0 +1,256 @@
+"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.FCD_HOOK_TAG = exports.FCD_HOOK_MARKER = exports.FCD_GATEWAY_SERVER_NAMES = void 0;
+exports.isFcdGatewayServer = isFcdGatewayServer;
+exports.extractGatewayDownstream = extractGatewayDownstream;
+exports.buildGatewayWrapIndex = buildGatewayWrapIndex;
+exports.classifyProxyStatus = classifyProxyStatus;
+exports.scanCursorHooks = scanCursorHooks;
+exports.clientKeyFromSource = clientKeyFromSource;
+exports.buildClientCoverage = buildClientCoverage;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+exports.FCD_GATEWAY_SERVER_NAMES = new Set([
+    'agentguard-gateway',
+    'fullcourtdefense-gateway',
+    'fcd-gateway',
+]);
+exports.FCD_HOOK_MARKER = '--fcd-managed true';
+exports.FCD_HOOK_TAG = 'fullcourtdefense';
+function commandBlob(server) {
+    return `${server.serverName} ${server.command || ''} ${(server.args || []).join(' ')} ${server.url || ''}`.toLowerCase();
+}
+function isFcdGatewayServer(server) {
+    const name = server.serverName.toLowerCase();
+    if (exports.FCD_GATEWAY_SERVER_NAMES.has(name))
+        return true;
+    const blob = commandBlob(server);
+    return blob.includes('mcp-gateway')
+        && (blob.includes('fullcourtdefense') || blob.includes('agentguard') || blob.includes('botguard') || blob.includes('fcd-managed'));
+}
+function extractGatewayDownstream(server) {
+    const args = server.args || [];
+    const cmdIdx = args.indexOf('--mcp-command');
+    if (cmdIdx < 0 || !args[cmdIdx + 1])
+        return null;
+    let downstreamArgs = [];
+    const argsIdx = args.indexOf('--mcp-args');
+    if (argsIdx >= 0 && args[argsIdx + 1]) {
+        try {
+            downstreamArgs = JSON.parse(args[argsIdx + 1]);
+        }
+        catch {
+            downstreamArgs = [args[argsIdx + 1]];
+        }
+    }
+    const command = args[cmdIdx + 1];
+    const label = inferDownstreamLabel(command, downstreamArgs);
+    return { command, args: downstreamArgs, label };
+}
+function inferDownstreamLabel(command, args) {
+    const hay = `${command || ''} ${(args || []).join(' ')}`.toLowerCase();
+    const pkgMatch = hay.match(/@([a-z0-9._-]+\/mcp[a-z0-9._-]*|[a-z0-9._-]+-mcp[a-z0-9._-]*)/i);
+    if (pkgMatch)
+        return pkgMatch[1].replace(/^@/, '').split('@')[0];
+    const fileMatch = hay.match(/([^/\\]+\.(js|ts|py|mjs))(?:\s|$)/i);
+    if (fileMatch)
+        return fileMatch[1].replace(/\.(js|ts|py|mjs)$/i, '');
+    if (command)
+        return path.basename(command).replace(/\.(cmd|exe|js)$/i, '');
+    return undefined;
+}
+function downstreamFingerprint(command, args) {
+    return `${command || ''}|${(args || []).join(' ')}`.trim().toLowerCase();
+}
+function serverFingerprints(server) {
+    const out = new Set();
+    out.add(server.serverName.toLowerCase());
+    const blob = commandBlob(server);
+    out.add(blob);
+    if (server.command)
+        out.add(downstreamFingerprint(server.command, server.args));
+    const label = inferDownstreamLabel(server.command, server.args);
+    if (label)
+        out.add(label.toLowerCase());
+    return [...out];
+}
+/** Per-client downstream targets wrapped by FCD gateway entries in the same config file. */
+function buildGatewayWrapIndex(servers) {
+    const byConfig = new Map();
+    for (const server of servers) {
+        const key = server.configPath.toLowerCase();
+        const list = byConfig.get(key) || [];
+        list.push(server);
+        byConfig.set(key, list);
+    }
+    const wrapsByConfig = new Map();
+    for (const [configPath, list] of byConfig.entries()) {
+        const wrapped = new Set();
+        for (const server of list) {
+            if (!isFcdGatewayServer(server))
+                continue;
+            const downstream = extractGatewayDownstream(server);
+            if (downstream?.label)
+                wrapped.add(downstream.label.toLowerCase());
+            if (downstream?.command)
+                wrapped.add(downstreamFingerprint(downstream.command, downstream.args));
+            wrapped.add(server.serverName.toLowerCase());
+        }
+        wrapsByConfig.set(configPath, wrapped);
+    }
+    return wrapsByConfig;
+}
+function classifyProxyStatus(server, wrapsByConfig) {
+    if (isFcdGatewayServer(server))
+        return 'fcd_gateway';
+    const wrapped = wrapsByConfig.get(server.configPath.toLowerCase());
+    if (!wrapped || wrapped.size === 0)
+        return 'direct';
+    for (const fp of serverFingerprints(server)) {
+        if (wrapped.has(fp))
+            return 'proxied';
+        for (const w of wrapped) {
+            if (fp.includes(w) || w.includes(fp))
+                return 'proxied';
+        }
+    }
+    return 'direct';
+}
+const CURSOR_HOOK_EVENTS = {
+    beforeSubmitPrompt: 'prompt',
+    beforeShellExecution: 'shell',
+    beforeMCPExecution: 'mcp',
+    afterFileEdit: 'file',
+    beforeReadFile: 'read',
+};
+function readHooksJson(file) {
+    if (!fs.existsSync(file))
+        return { hooks: {} };
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return { hooks: parsed?.hooks && typeof parsed.hooks === 'object' ? parsed.hooks : {} };
+    }
+    catch {
+        return { hooks: {} };
+    }
+}
+function scanCursorHooks(projectPath) {
+    const globalFile = path.join(os.homedir(), '.cursor', 'hooks.json');
+    const projectFile = projectPath ? path.join(projectPath, '.cursor', 'hooks.json') : '';
+    const files = [globalFile, projectFile].filter(Boolean);
+    const events = new Set();
+    let shadow = false;
+    let installed = false;
+    for (const file of files) {
+        const { hooks } = readHooksJson(file);
+        for (const [hookKey, entries] of Object.entries(hooks)) {
+            for (const entry of entries || []) {
+                const cmd = entry?.command || '';
+                if (!cmd.includes(exports.FCD_HOOK_MARKER) && !cmd.includes(exports.FCD_HOOK_TAG))
+                    continue;
+                installed = true;
+                const mapped = CURSOR_HOOK_EVENTS[hookKey] || hookKey;
+                events.add(mapped);
+                if (cmd.includes('--shadow true'))
+                    shadow = true;
+            }
+        }
+    }
+    return { installed, events: [...events].sort(), shadow };
+}
+function clientKeyFromSource(source) {
+    const s = source.toLowerCase();
+    if (s.includes('cursor'))
+        return 'cursor';
+    if (s.includes('claude desktop'))
+        return 'claude_desktop';
+    if (s.includes('claude code'))
+        return 'claude_code';
+    if (s.includes('vs code'))
+        return 'vscode';
+    if (s.includes('windsurf'))
+        return 'windsurf';
+    if (s.includes('gemini'))
+        return 'gemini_cli';
+    if (s.includes('codex'))
+        return 'codex';
+    if (s.includes('kiro'))
+        return 'kiro';
+    return 'other';
+}
+function buildClientCoverage(scanned, servers, cwd) {
+    const hooks = scanCursorHooks(cwd);
+    const serversByConfig = new Map();
+    for (const server of servers) {
+        const key = server.configPath.toLowerCase();
+        const list = serversByConfig.get(key) || [];
+        list.push(server);
+        serversByConfig.set(key, list);
+    }
+    const rows = [];
+    for (const item of scanned) {
+        const list = serversByConfig.get(item.path.toLowerCase()) || [];
+        const clientKey = clientKeyFromSource(item.source);
+        const mcpGatewayInstalled = list.some(isFcdGatewayServer);
+        rows.push({
+            client: item.source,
+            clientKey,
+            configPath: item.path,
+            configPresent: true,
+            mcpServerCount: list.filter(s => !isFcdGatewayServer(s)).length,
+            mcpGatewayInstalled,
+            cursorHooksInstalled: clientKey === 'cursor' ? hooks.installed : false,
+            cursorHookEvents: clientKey === 'cursor' ? hooks.events : [],
+            cursorHookShadow: clientKey === 'cursor' ? hooks.shadow : false,
+        });
+    }
+    // Cursor hooks apply globally even if only project mcp.json was scanned
+    if (!rows.some(r => r.clientKey === 'cursor') && hooks.installed) {
+        rows.push({
+            client: 'Cursor (hooks)',
+            clientKey: 'cursor',
+            configPath: path.join(os.homedir(), '.cursor', 'hooks.json'),
+            configPresent: fs.existsSync(path.join(os.homedir(), '.cursor', 'hooks.json')),
+            mcpServerCount: 0,
+            mcpGatewayInstalled: false,
+            cursorHooksInstalled: true,
+            cursorHookEvents: hooks.events,
+            cursorHookShadow: hooks.shadow,
+        });
+    }
+    return rows.sort((a, b) => a.client.localeCompare(b.client));
+}

package/dist/commands/discoverSchedule.d.ts

@@ -0,0 +1,6 @@
+export interface ScheduleArgs {
+    userEmail?: string;
+    hour?: number;
+}
+export declare function installDailyDiscoverSchedule(args?: ScheduleArgs): void;
+export declare function uninstallDailyDiscoverSchedule(): void;

package/dist/commands/discoverSchedule.js

@@ -0,0 +1,132 @@
+"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.installDailyDiscoverSchedule = installDailyDiscoverSchedule;
+exports.uninstallDailyDiscoverSchedule = uninstallDailyDiscoverSchedule;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const TASK_NAME = 'FullCourtDefenseDesktopDiscover';
+function discoverCommandLine(userEmail) {
+    const node = process.execPath;
+    const script = path.resolve(process.argv[1] || path.join(__dirname, '..', 'index.js'));
+    const q = (value) => (/\s/.test(value) ? `"${value}"` : value);
+    const parts = [q(node), q(script), 'discover', '--upload', '--silent'];
+    if (userEmail)
+        parts.push('--user-email', q(userEmail));
+    return parts.join(' ');
+}
+function installWindowsSchedule(hour, userEmail) {
+    const tr = discoverCommandLine(userEmail);
+    const st = `${String(hour).padStart(2, '0')}:00`;
+    try {
+        (0, child_process_1.execSync)(`schtasks /Delete /TN "${TASK_NAME}" /F`, { stdio: 'ignore' });
+    }
+    catch {
+        // task may not exist
+    }
+    (0, child_process_1.execSync)(`schtasks /Create /F /TN "${TASK_NAME}" /SC DAILY /ST ${st} /TR "${tr.replace(/"/g, '\\"')}"`, { stdio: 'inherit' });
+}
+function installMacSchedule(hour, userEmail) {
+    const label = 'ai.fullcourtdefense.discover';
+    const plistDir = path.join(os.homedir(), 'Library', 'LaunchAgents');
+    const plistPath = path.join(plistDir, `${label}.plist`);
+    fs.mkdirSync(plistDir, { recursive: true });
+    const cmd = discoverCommandLine(userEmail).split(/\s+/);
+    const program = cmd.shift() || process.execPath;
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${label}</string>
+  <key>ProgramArguments</key>
+  <array>${[program, ...cmd].map(part => `<string>${part.replace(/&/g, '&amp;').replace(/</g, '&lt;')}</string>`).join('')}</array>
+  <key>StartCalendarInterval</key>
+  <dict><key>Hour</key><integer>${hour}</integer><key>Minute</key><integer>0</integer></dict>
+  <key>StandardOutPath</key><string>${path.join(os.homedir(), '.fullcourtdefense-discover.log')}</string>
+  <key>StandardErrorPath</key><string>${path.join(os.homedir(), '.fullcourtdefense-discover.err.log')}</string>
+</dict>
+</plist>`;
+    fs.writeFileSync(plistPath, plist, 'utf8');
+    (0, child_process_1.spawnSync)('launchctl', ['unload', plistPath], { stdio: 'ignore' });
+    (0, child_process_1.spawnSync)('launchctl', ['load', plistPath], { stdio: 'inherit' });
+}
+function installLinuxCron(hour, userEmail) {
+    const line = `0 ${hour} * * * ${discoverCommandLine(userEmail)} >> ${path.join(os.homedir(), '.fullcourtdefense-discover.log')} 2>&1`;
+    const marker = '# fullcourtdefense-discover';
+    let crontab = '';
+    try {
+        crontab = (0, child_process_1.execSync)('crontab -l', { encoding: 'utf8' });
+    }
+    catch {
+        crontab = '';
+    }
+    const filtered = crontab.split('\n').filter(l => !l.includes(marker) && !l.includes('discover --upload --silent'));
+    filtered.push(`${marker}`);
+    filtered.push(line);
+    (0, child_process_1.execSync)(`echo "${filtered.join('\\n')}" | crontab -`, { stdio: 'inherit', shell: '/bin/bash' });
+}
+function installDailyDiscoverSchedule(args = {}) {
+    const hour = Number.isFinite(args.hour) ? Math.min(23, Math.max(0, args.hour)) : 9;
+    if (process.platform === 'win32')
+        installWindowsSchedule(hour, args.userEmail);
+    else if (process.platform === 'darwin')
+        installMacSchedule(hour, args.userEmail);
+    else
+        installLinuxCron(hour, args.userEmail);
+}
+function uninstallDailyDiscoverSchedule() {
+    if (process.platform === 'win32') {
+        (0, child_process_1.execSync)(`schtasks /Delete /TN "${TASK_NAME}" /F`, { stdio: 'inherit' });
+        return;
+    }
+    if (process.platform === 'darwin') {
+        const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', 'ai.fullcourtdefense.discover.plist');
+        (0, child_process_1.spawnSync)('launchctl', ['unload', plistPath], { stdio: 'ignore' });
+        if (fs.existsSync(plistPath))
+            fs.unlinkSync(plistPath);
+        return;
+    }
+    let crontab = '';
+    try {
+        crontab = (0, child_process_1.execSync)('crontab -l', { encoding: 'utf8' });
+    }
+    catch {
+        return;
+    }
+    const filtered = crontab.split('\n').filter(l => !l.includes('fullcourtdefense-discover') && !l.includes('discover --upload --silent'));
+    (0, child_process_1.execSync)(`echo "${filtered.join('\\n')}" | crontab -`, { stdio: 'inherit', shell: '/bin/bash' });
+}

package/dist/index.js

@@ -66,8 +66,9 @@ function printHelp() {
     configure   Saves Shield ID, Shield key, and API URL to .fullcourtdefense.yml.
     scan        Runs the scan. Use --local for inside-organization scans.
     discover    Finds MCP servers configured on this machine (Cursor, Claude,
-                VS Code, Windsurf) and reports their risk. Use --upload to add
-                them to your AI Inventory.
+                VS Code, Windsurf, Codex, Gemini CLI) and reports their risk.
+                Use --upload to add them to your AI Inventory. Use --deep for
+                live HTTP/SSE tools/list. Use --silent for fleet/MDM scripts.
     install-cursor-hook
                 Installs a Cursor hook so every AI prompt + agent action
                 (shell, MCP) on this machine is scanned by your Shield.
@@ -199,6 +200,7 @@ function printHelp() {
     $ fullcourtdefense scan --local --type mcp --mcp-command node --mcp-args ./server.js --mcp-tool all --mode full --format report
     $ fullcourtdefense discover
     $ fullcourtdefense discover --upload
+    $ fullcourtdefense discover --deep --upload --silent --user-email you@company.com
     $ fullcourtdefense discover --type mcp --json
     $ fullcourtdefense install-cursor-hook --shield-id <id> --shield-key <key>
     $ fullcourtdefense install-cursor-hook --shadow true        # monitor only
@@ -320,6 +322,12 @@ async function main() {
                 upload: flags.upload,
                 connectorName: flags['connector-name'],
                 extraPath: flags.path,
+                deep: flags.deep,
+                silent: flags.silent,
+                userEmail: flags['user-email'],
+                schedule: flags.schedule,
+                unschedule: flags.unschedule,
+                scheduleHour: flags['schedule-hour'],
             };
             await (0, discover_1.discoverCommand)(args, config);
             break;

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "fullcourtdefense-cli",
-  "version": "1.1.17",
+  "version": "1.2.0",
   "description": "Full Court Defense CLI — security scanning for AI agents from your terminal",
   "main": "dist/index.js",
   "bin": {
     "fullcourtdefense": "dist/index.js",
+    "fcd": "dist/index.js",
     "botguard": "dist/index.js"
   },
   "files": [