fullcourtdefense-cli 1.1.17 → 1.3.0

package/dist/commands/discoverPaths.js

@@ -0,0 +1,194 @@
+"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.claudeDesktopMsixCandidates = claudeDesktopMsixCandidates;
+exports.claudeDesktopConfigCandidates = claudeDesktopConfigCandidates;
+exports.claudeDesktopLikelyInstalled = claudeDesktopLikelyInstalled;
+exports.claudeDesktopInstallTargets = claudeDesktopInstallTargets;
+exports.candidateConfigPaths = candidateConfigPaths;
+exports.discoverScanTargets = discoverScanTargets;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+function claudeDesktopDocumentedPath() {
+    const home = os.homedir();
+    if (process.platform === 'win32') {
+        const appData = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
+        return path.join(appData, 'Claude', 'claude_desktop_config.json');
+    }
+    if (process.platform === 'darwin') {
+        return path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    }
+    const xdg = process.env.XDG_CONFIG_HOME || path.join(home, '.config');
+    return path.join(xdg, 'Claude', 'claude_desktop_config.json');
+}
+function claudeDesktopMsixCandidates() {
+    if (process.platform !== 'win32')
+        return [];
+    const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+    const packagesDir = path.join(localAppData, 'Packages');
+    try {
+        return fs.readdirSync(packagesDir)
+            .filter(name => /^Claude_/i.test(name))
+            .map(name => ({
+            file: path.join(packagesDir, name, 'LocalCache', 'Roaming', 'Claude', 'claude_desktop_config.json'),
+            source: 'Claude Desktop (win MSIX)',
+            exists: fs.existsSync(path.join(packagesDir, name, 'LocalCache', 'Roaming', 'Claude', 'claude_desktop_config.json')),
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+function claudeDesktopConfigCandidates() {
+    const documented = claudeDesktopDocumentedPath();
+    const normal = {
+        file: documented,
+        source: process.platform === 'win32'
+            ? 'Claude Desktop (win)'
+            : process.platform === 'darwin'
+                ? 'Claude Desktop (mac)'
+                : 'Claude Desktop (linux)',
+        exists: fs.existsSync(documented),
+    };
+    const seen = new Set();
+    return [...claudeDesktopMsixCandidates(), normal].filter(candidate => {
+        const key = path.resolve(candidate.file).toLowerCase();
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function claudeDesktopLikelyInstalled() {
+    if (claudeDesktopConfigCandidates().some(candidate => candidate.exists))
+        return true;
+    if (claudeDesktopMsixCandidates().length > 0)
+        return true;
+    if (process.platform === 'darwin' && fs.existsSync('/Applications/Claude.app'))
+        return true;
+    if (process.platform === 'win32') {
+        const pf = process.env.ProgramFiles || 'C:\\Program Files';
+        if (fs.existsSync(path.join(pf, 'Claude', 'Claude.exe')))
+            return true;
+    }
+    return fs.existsSync(path.dirname(claudeDesktopDocumentedPath()));
+}
+function claudeDesktopInstallTargets(configPath) {
+    if (configPath) {
+        const file = path.resolve(configPath);
+        return [{ file, source: 'Claude Desktop (custom)', exists: fs.existsSync(file) }];
+    }
+    const candidates = claudeDesktopConfigCandidates();
+    const existing = candidates.filter(candidate => candidate.exists);
+    if (existing.length > 0)
+        return existing;
+    const msix = candidates.find(candidate => candidate.source.includes('MSIX'));
+    if (msix)
+        return [msix];
+    return [candidates[candidates.length - 1] || {
+            file: claudeDesktopDocumentedPath(),
+            source: 'Claude Desktop',
+            exists: false,
+        }];
+}
+/** All MCP client config locations discover / install should check. */
+function candidateConfigPaths(cwd, extra) {
+    const home = os.homedir();
+    const appData = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
+    const xdg = process.env.XDG_CONFIG_HOME || path.join(home, '.config');
+    const list = [
+        { path: path.join(home, '.cursor', 'mcp.json'), source: 'Cursor (global)', clientKey: 'cursor' },
+        { path: path.join(cwd, '.cursor', 'mcp.json'), source: 'Cursor (project)', clientKey: 'cursor' },
+        { path: path.join(appData, 'Cursor', 'managed-mcp.json'), source: 'Cursor (managed, win)', clientKey: 'cursor' },
+        { path: path.join(home, 'Library', 'Application Support', 'Cursor', 'managed-mcp.json'), source: 'Cursor (managed, mac)', clientKey: 'cursor' },
+        { path: '/etc/cursor/managed-mcp.json', source: 'Cursor (managed, linux)', clientKey: 'cursor' },
+        { path: path.join(home, '.claude.json'), source: 'Claude Code', clientKey: 'claude_code' },
+        { path: path.join(home, '.claude', 'settings.json'), source: 'Claude Code (global)', clientKey: 'claude_code' },
+        { path: path.join(cwd, '.claude', 'settings.json'), source: 'Claude Code (project)', clientKey: 'claude_code' },
+        { path: path.join(cwd, '.mcp.json'), source: 'Claude Code (.mcp.json project)', clientKey: 'claude_code' },
+        { path: path.join(home, '.gemini', 'settings.json'), source: 'Gemini CLI', clientKey: 'gemini_cli' },
+        { path: path.join(xdg, 'gemini', 'settings.json'), source: 'Gemini CLI (xdg)', clientKey: 'gemini_cli' },
+        { path: path.join(home, '.codex', 'mcp.json'), source: 'Codex', clientKey: 'codex' },
+        { path: path.join(xdg, 'codex', 'mcp.json'), source: 'Codex (xdg)', clientKey: 'codex' },
+        { path: path.join(cwd, '.vscode', 'mcp.json'), source: 'VS Code (project)', clientKey: 'vscode' },
+        { path: path.join(appData, 'Code', 'User', 'settings.json'), source: 'VS Code (user, win)', clientKey: 'vscode' },
+        { path: path.join(home, 'Library', 'Application Support', 'Code', 'User', 'settings.json'), source: 'VS Code (user, mac)', clientKey: 'vscode' },
+        { path: path.join(xdg, 'Code', 'User', 'settings.json'), source: 'VS Code (user, linux)', clientKey: 'vscode' },
+        { path: path.join(home, '.codeium', 'windsurf', 'mcp_config.json'), source: 'Windsurf', clientKey: 'windsurf' },
+        { path: path.join(home, '.kiro', 'mcp.json'), source: 'Kiro', clientKey: 'kiro' },
+        { path: path.join(cwd, '.mcp.json'), source: 'Repo (.mcp.json)', clientKey: 'other' },
+        { path: path.join(cwd, 'mcp.json'), source: 'Repo (mcp.json)', clientKey: 'other' },
+    ];
+    for (const candidate of claudeDesktopConfigCandidates()) {
+        list.push({ path: candidate.file, source: candidate.source, clientKey: 'claude_desktop' });
+    }
+    if (process.platform === 'win32') {
+        list.push({
+            path: path.join(process.env.ProgramData || 'C:\\ProgramData', 'Cursor', 'managed-mcp.json'),
+            source: 'Cursor (managed, program data)',
+            clientKey: 'cursor',
+        });
+    }
+    if (extra) {
+        list.push({ path: path.resolve(extra), source: 'Custom path', clientKey: 'other' });
+    }
+    const seen = new Set();
+    return list.filter(item => {
+        const key = path.resolve(item.path).toLowerCase();
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+/** Include config paths for apps that exist on disk even when the MCP file is not created yet. */
+function discoverScanTargets(cwd, extra) {
+    const candidates = candidateConfigPaths(cwd, extra);
+    const existing = candidates.filter(item => fs.existsSync(item.path));
+    const implicit = [];
+    if (claudeDesktopLikelyInstalled()) {
+        for (const target of claudeDesktopInstallTargets()) {
+            if (!existing.some(item => path.resolve(item.path).toLowerCase() === path.resolve(target.file).toLowerCase())) {
+                implicit.push({ path: target.file, source: target.source, clientKey: 'claude_desktop' });
+            }
+        }
+    }
+    const cursorGlobal = path.join(os.homedir(), '.cursor', 'mcp.json');
+    if (fs.existsSync(path.join(os.homedir(), '.cursor')) && !existing.some(item => path.resolve(item.path).toLowerCase() === cursorGlobal.toLowerCase())) {
+        implicit.push({ path: cursorGlobal, source: 'Cursor (global)', clientKey: 'cursor' });
+    }
+    return [...existing, ...implicit];
+}

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/commands/knownMcpServers.d.ts

@@ -0,0 +1,8 @@
+export interface KnownMcpServerInfo {
+    title: string;
+    description: string;
+    category: 'browser' | 'filesystem' | 'database' | 'gateway' | 'other';
+    recommendGateway: boolean;
+}
+export declare function knownMcpServerInfo(serverName: string, command?: string): KnownMcpServerInfo | undefined;
+export declare function directServerFixHint(serverName: string): string | undefined;