genesis-ai-cli 7.4.5

package/dist/src/mcp/index.js

@@ -0,0 +1,657 @@
+"use strict";
+/**
+ * Genesis 6.8 - Real MCP Client Module
+ *
+ * Connects to actual MCP servers using @modelcontextprotocol/sdk.
+ * Spawns servers on demand and manages connections.
+ *
+ * Environment Variables:
+ * - GENESIS_MCP_MODE: 'real' | 'simulated' | 'hybrid' (default: 'simulated')
+ * - GENESIS_MCP_TIMEOUT: Timeout in ms (default: 30000)
+ * - GENESIS_MCP_LOG: Enable MCP call logging (default: false)
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCP_SERVER_REGISTRY = exports.mcpClient = void 0;
+exports.getMCPClient = getMCPClient;
+exports.resetMCPClient = resetMCPClient;
+exports.isSimulatedMode = isSimulatedMode;
+exports.isSimulatedResult = isSimulatedResult;
+exports.logMCPMode = logMCPMode;
+// Re-export Phase 8: Resilient MCP Wrapper
+__exportStar(require("./resilient.js"), exports);
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
+const crypto_1 = require("crypto");
+/**
+ * Registry of MCP servers and how to spawn them.
+ * These are the 13 MCP servers Genesis uses.
+ *
+ * Package sources (verified on npm):
+ * - Official: @modelcontextprotocol/server-*
+ * - Third-party: arxiv-mcp-server, @brave/brave-search-mcp-server, etc.
+ */
+const MCP_SERVER_REGISTRY = {
+    // KNOWLEDGE
+    'arxiv': {
+        command: 'npx',
+        args: ['-y', '@iflow-mcp/arxiv-paper-mcp@latest'],
+        tools: ['search_arxiv', 'parse_paper_content', 'get_recent_ai_papers', 'get_arxiv_pdf_url'],
+    },
+    'semantic-scholar': {
+        command: 'npx',
+        args: ['-y', 'researchmcp', 'semantic'],
+        tools: ['search_semantic_scholar', 'get_semantic_scholar_paper', 'get_paper_citations', 'semantic_scholar_to_bibtex'],
+    },
+    'context7': {
+        command: 'npx',
+        args: ['-y', '@upstash/context7-mcp@latest'],
+        tools: ['resolve-library-id', 'query-docs'],
+    },
+    'wolfram': {
+        command: 'npx',
+        args: ['-y', 'wolfram-mcp'],
+        envVars: () => ({ WOLFRAM_APP_ID: process.env.WOLFRAM_APP_ID || '' }),
+        tools: ['wolfram_query'],
+    },
+    // RESEARCH
+    'gemini': {
+        command: 'npx',
+        args: ['-y', 'mcp-gemini-web'],
+        envVars: () => ({ GOOGLE_API_KEY: process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY || '' }),
+        tools: ['web_search', 'web_search_batch', 'health_check'],
+    },
+    'brave-search': {
+        command: 'npx',
+        args: () => ['-y', '@brave/brave-search-mcp-server', '--brave-api-key', process.env.BRAVE_API_KEY || ''],
+        tools: ['brave_web_search', 'brave_local_search', 'brave_news_search', 'brave_image_search', 'brave_video_search'],
+    },
+    'exa': {
+        command: 'npx',
+        args: ['-y', 'exa-mcp-server'],
+        envVars: () => ({ EXA_API_KEY: process.env.EXA_API_KEY || '' }),
+        tools: ['web_search_exa', 'get_code_context_exa'],
+    },
+    'firecrawl': {
+        command: 'npx',
+        args: ['-y', 'firecrawl-mcp'],
+        envVars: () => ({ FIRECRAWL_API_KEY: process.env.FIRECRAWL_API_KEY || '' }),
+        tools: ['firecrawl_scrape', 'firecrawl_search', 'firecrawl_map', 'firecrawl_crawl', 'firecrawl_extract'],
+    },
+    // CREATION
+    'openai': {
+        command: 'npx',
+        args: ['-y', '@mzxrai/mcp-openai'],
+        envVars: () => ({ OPENAI_API_KEY: process.env.OPENAI_API_KEY || '' }),
+        tools: ['openai_chat'],
+    },
+    'github': {
+        command: 'npx',
+        args: ['-y', '@modelcontextprotocol/server-github'],
+        // v7.3: Accept both variable names for compatibility
+        envVars: () => ({
+            GITHUB_PERSONAL_ACCESS_TOKEN: process.env.GITHUB_PERSONAL_ACCESS_TOKEN || process.env.GITHUB_TOKEN || ''
+        }),
+        tools: ['create_repository', 'search_repositories', 'create_issue', 'create_pull_request', 'get_file_contents'],
+    },
+    // VISUAL
+    'stability-ai': {
+        command: 'npx',
+        args: ['-y', 'mcp-server-stability-ai'],
+        envVars: () => ({ STABILITY_AI_API_KEY: process.env.STABILITY_AI_API_KEY || '' }),
+        tools: ['stability-ai-generate-image', 'stability-ai-generate-image-sd35', 'stability-ai-0-list-resources'],
+    },
+    // STORAGE
+    'memory': {
+        command: 'npx',
+        args: ['-y', '@modelcontextprotocol/server-memory'],
+        tools: ['create_entities', 'create_relations', 'search_nodes', 'read_graph', 'add_observations'],
+    },
+    'filesystem': {
+        command: 'npx',
+        args: () => ['-y', '@modelcontextprotocol/server-filesystem', process.env.HOME || '/tmp'],
+        tools: ['read_file', 'read_text_file', 'write_file', 'list_directory', 'search_files', 'create_directory'],
+    },
+};
+exports.MCP_SERVER_REGISTRY = MCP_SERVER_REGISTRY;
+class MCPConnectionManager {
+    connections = new Map();
+    connecting = new Map();
+    timeout;
+    logCalls;
+    constructor(timeout = 30000, logCalls = false) {
+        this.timeout = timeout;
+        this.logCalls = logCalls;
+    }
+    /**
+     * Get or create connection to MCP server
+     */
+    async getConnection(server) {
+        // Return existing connection if available
+        const existing = this.connections.get(server);
+        if (existing?.connected) {
+            existing.lastUsed = new Date();
+            return existing;
+        }
+        // Check if already connecting
+        const pending = this.connecting.get(server);
+        if (pending) {
+            return pending;
+        }
+        // Create new connection
+        const connectPromise = this.createConnection(server);
+        this.connecting.set(server, connectPromise);
+        try {
+            const connection = await connectPromise;
+            this.connections.set(server, connection);
+            return connection;
+        }
+        finally {
+            this.connecting.delete(server);
+        }
+    }
+    /**
+     * Create new connection to MCP server
+     */
+    async createConnection(server) {
+        const serverInfo = MCP_SERVER_REGISTRY[server];
+        if (!serverInfo) {
+            throw new Error(`Unknown MCP server: ${server}`);
+        }
+        // v7.3: Check required API keys before spawning
+        const missingKey = this.checkRequiredKeys(server);
+        if (missingKey) {
+            throw new Error(`MCP server '${server}' requires ${missingKey} to be set. Please add it to your .env file.`);
+        }
+        // Resolve args and envVars at connection time (supports functions for dynamic values)
+        const args = typeof serverInfo.args === 'function' ? serverInfo.args() : serverInfo.args;
+        const envVars = typeof serverInfo.envVars === 'function' ? serverInfo.envVars() : serverInfo.envVars;
+        if (this.logCalls) {
+            console.log(`[MCP] Spawning ${server}: ${serverInfo.command} ${args.join(' ')}`);
+        }
+        const client = new index_js_1.Client({
+            name: `genesis-${server}`,
+            version: '6.0.0',
+        });
+        // Build environment, filtering out undefined values
+        const env = {};
+        for (const [key, value] of Object.entries(process.env)) {
+            if (value !== undefined) {
+                env[key] = value;
+            }
+        }
+        if (envVars) {
+            Object.assign(env, envVars);
+        }
+        const transport = new stdio_js_1.StdioClientTransport({
+            command: serverInfo.command,
+            args,
+            env,
+        });
+        await client.connect(transport);
+        if (this.logCalls) {
+            console.log(`[MCP] Connected to ${server}`);
+        }
+        return {
+            client,
+            transport,
+            connected: true,
+            lastUsed: new Date(),
+        };
+    }
+    /**
+     * Call a tool on an MCP server
+     */
+    async callTool(server, tool, args) {
+        const connection = await this.getConnection(server);
+        if (this.logCalls) {
+            console.log(`[MCP] ${server}.${tool}(${JSON.stringify(args).slice(0, 100)}...)`);
+        }
+        const result = await connection.client.callTool({
+            name: tool,
+            arguments: args,
+        });
+        // Parse result content
+        const content = result.content;
+        if (content && content.length > 0) {
+            const first = content[0];
+            if (first.type === 'text' && typeof first.text === 'string') {
+                try {
+                    return JSON.parse(first.text);
+                }
+                catch {
+                    return first.text;
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * List available tools on an MCP server (names only)
+     */
+    async listTools(server) {
+        const connection = await this.getConnection(server);
+        const result = await connection.client.listTools();
+        return result.tools.map((t) => t.name);
+    }
+    /**
+     * List available tools with full schema (for dynamic prompt building)
+     */
+    async listToolsWithSchema(server) {
+        const connection = await this.getConnection(server);
+        const result = await connection.client.listTools();
+        return result.tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema,
+        }));
+    }
+    /**
+     * Check if a server is available (can connect)
+     */
+    async isAvailable(server) {
+        try {
+            await this.getConnection(server);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Close connection to a server
+     */
+    async closeConnection(server) {
+        const connection = this.connections.get(server);
+        if (connection) {
+            try {
+                await connection.client.close();
+            }
+            catch {
+                // Ignore close errors
+            }
+            connection.connected = false;
+            this.connections.delete(server);
+        }
+    }
+    /**
+     * Close all connections
+     */
+    async closeAll() {
+        const servers = Array.from(this.connections.keys());
+        await Promise.all(servers.map((s) => this.closeConnection(s)));
+    }
+    /**
+     * v7.3: Check if required API keys are set for a server
+     * Returns the name of the missing key, or null if all keys are present
+     */
+    checkRequiredKeys(server) {
+        // Map of servers to their required environment variables
+        const requiredKeys = {
+            'wolfram': ['WOLFRAM_APP_ID'],
+            'brave-search': ['BRAVE_API_KEY'],
+            'exa': ['EXA_API_KEY'],
+            'firecrawl': ['FIRECRAWL_API_KEY'],
+            'openai': ['OPENAI_API_KEY'],
+            'github': ['GITHUB_PERSONAL_ACCESS_TOKEN', 'GITHUB_TOKEN'], // Either one
+            'stability-ai': ['STABILITY_AI_API_KEY'],
+            'gemini': ['GOOGLE_API_KEY', 'GEMINI_API_KEY'], // Either one
+            // These don't need API keys:
+            // 'arxiv', 'semantic-scholar', 'context7', 'memory', 'filesystem'
+        };
+        const keys = requiredKeys[server];
+        if (!keys)
+            return null; // No required keys
+        // For servers that accept either of multiple keys (like github, gemini)
+        // Check if at least one is set
+        const hasAtLeastOne = keys.some(key => !!process.env[key]);
+        if (!hasAtLeastOne) {
+            return keys.join(' or ');
+        }
+        return null; // All required keys present
+    }
+}
+// ============================================================================
+// Real MCP Client
+// ============================================================================
+class RealMCPClient {
+    manager;
+    mode = 'real';
+    config;
+    constructor(config = {}) {
+        this.config = {
+            mode: 'real',
+            timeout: 30000,
+            logCalls: false,
+            ...config,
+        };
+        this.mode = this.config.mode;
+        this.manager = new MCPConnectionManager(this.config.timeout, this.config.logCalls);
+    }
+    async call(server, tool, params, options = {}) {
+        const startTime = Date.now();
+        if (this.config.onCall) {
+            this.config.onCall(server, tool, params);
+        }
+        try {
+            const data = await this.manager.callTool(server, tool, params);
+            const result = {
+                success: true,
+                data,
+                server,
+                tool,
+                mode: 'real',
+                latency: Date.now() - startTime,
+                timestamp: new Date(),
+            };
+            if (this.config.onResult) {
+                this.config.onResult(result);
+            }
+            return result;
+        }
+        catch (error) {
+            const result = {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                server,
+                tool,
+                mode: 'real',
+                latency: Date.now() - startTime,
+                timestamp: new Date(),
+            };
+            if (this.config.onResult) {
+                this.config.onResult(result);
+            }
+            return result;
+        }
+    }
+    async listTools(server) {
+        return this.manager.listTools(server);
+    }
+    async listToolsWithSchema(server) {
+        return this.manager.listToolsWithSchema(server);
+    }
+    async discoverAllTools() {
+        const result = {};
+        const servers = Object.keys(MCP_SERVER_REGISTRY);
+        // Discover tools from all servers in parallel
+        await Promise.allSettled(servers.map(async (server) => {
+            try {
+                result[server] = await this.listToolsWithSchema(server);
+            }
+            catch {
+                // Server not available, use registry fallback
+                result[server] = MCP_SERVER_REGISTRY[server].tools.map(name => ({ name }));
+            }
+        }));
+        return result;
+    }
+    async isAvailable(server) {
+        return this.manager.isAvailable(server);
+    }
+    getMode() {
+        return this.mode;
+    }
+    setMode(mode) {
+        this.mode = mode;
+    }
+    async close() {
+        await this.manager.closeAll();
+    }
+}
+// ============================================================================
+// Simulated MCP Client (for testing without real servers)
+// ============================================================================
+class SimulatedMCPClient {
+    mode = 'simulated';
+    config;
+    constructor(config = {}) {
+        this.config = {
+            mode: 'simulated',
+            timeout: 30000,
+            logCalls: false,
+            ...config,
+        };
+        this.mode = this.config.mode;
+    }
+    async call(server, tool, params, options = {}) {
+        const startTime = Date.now();
+        if (this.config.onCall) {
+            this.config.onCall(server, tool, params);
+        }
+        if (this.config.logCalls) {
+            console.log(`[MCP:SIM] ${server}.${tool}(${JSON.stringify(params).slice(0, 100)}...)`);
+        }
+        // Simulate latency
+        await new Promise((r) => setTimeout(r, 50 + Math.random() * 150));
+        const data = this.generateSimulatedResponse(server, tool, params);
+        const result = {
+            success: true,
+            data,
+            server,
+            tool,
+            mode: 'simulated',
+            latency: Date.now() - startTime,
+            timestamp: new Date(),
+        };
+        if (this.config.onResult) {
+            this.config.onResult(result);
+        }
+        return result;
+    }
+    async listTools(server) {
+        return MCP_SERVER_REGISTRY[server]?.tools || [];
+    }
+    async listToolsWithSchema(server) {
+        // In simulated mode, return basic tool info from registry
+        const tools = MCP_SERVER_REGISTRY[server]?.tools || [];
+        return tools.map(name => ({
+            name,
+            description: `[Simulated] ${name} tool`,
+        }));
+    }
+    async discoverAllTools() {
+        const result = {};
+        const servers = Object.keys(MCP_SERVER_REGISTRY);
+        for (const server of servers) {
+            result[server] = await this.listToolsWithSchema(server);
+        }
+        return result;
+    }
+    async isAvailable(server) {
+        return true; // Always available in simulated mode
+    }
+    getMode() {
+        return this.mode;
+    }
+    setMode(mode) {
+        this.mode = mode;
+    }
+    async close() {
+        // No-op for simulated
+    }
+    generateSimulatedResponse(server, tool, params) {
+        const query = params.query || params.q || params.input || 'query';
+        switch (server) {
+            case 'arxiv':
+                return {
+                    papers: [{
+                            id: 'arxiv:' + (0, crypto_1.randomUUID)().slice(0, 8),
+                            title: `[SIM] Research on ${query}`,
+                            authors: ['Author A', 'Author B'],
+                            abstract: `Simulated paper about ${query}.`,
+                            url: `https://arxiv.org/abs/${(0, crypto_1.randomUUID)().slice(0, 8)}`,
+                        }],
+                    _simulated: true,
+                };
+            case 'semantic-scholar':
+                return {
+                    papers: [{
+                            paperId: (0, crypto_1.randomUUID)().slice(0, 8),
+                            title: `[SIM] ${query} Study`,
+                            citationCount: Math.floor(Math.random() * 100),
+                        }],
+                    _simulated: true,
+                };
+            case 'brave-search':
+            case 'gemini':
+            case 'exa':
+                return {
+                    results: [{
+                            title: `[SIM] ${query} Result`,
+                            url: 'https://example.com/sim',
+                            description: `Simulated result for ${query}`,
+                        }],
+                    _simulated: true,
+                };
+            case 'firecrawl':
+                return {
+                    content: `[SIM] Scraped content for ${params.url || query}`,
+                    _simulated: true,
+                };
+            case 'memory':
+                return { entities: [], relations: [], _simulated: true };
+            case 'filesystem':
+                return { content: `[SIM] File content`, _simulated: true };
+            default:
+                return { success: true, _simulated: true };
+        }
+    }
+}
+// ============================================================================
+// Hybrid MCP Client
+// ============================================================================
+class HybridMCPClient {
+    realClient;
+    simClient;
+    mode = 'hybrid';
+    config;
+    constructor(config = {}) {
+        this.config = {
+            mode: 'hybrid',
+            timeout: 30000,
+            logCalls: false,
+            ...config,
+        };
+        this.realClient = new RealMCPClient(config);
+        this.simClient = new SimulatedMCPClient(config);
+    }
+    async call(server, tool, params, options = {}) {
+        // Try real first
+        const result = await this.realClient.call(server, tool, params, options);
+        // Fallback to simulated if real fails
+        if (!result.success && (options.fallbackToSimulated ?? true)) {
+            if (this.config.logCalls) {
+                console.log(`[MCP] Real call failed, falling back to simulated: ${result.error}`);
+            }
+            return this.simClient.call(server, tool, params, options);
+        }
+        return result;
+    }
+    async listTools(server) {
+        try {
+            return await this.realClient.listTools(server);
+        }
+        catch {
+            return this.simClient.listTools(server);
+        }
+    }
+    async listToolsWithSchema(server) {
+        try {
+            return await this.realClient.listToolsWithSchema(server);
+        }
+        catch {
+            return this.simClient.listToolsWithSchema(server);
+        }
+    }
+    async discoverAllTools() {
+        try {
+            return await this.realClient.discoverAllTools();
+        }
+        catch {
+            return this.simClient.discoverAllTools();
+        }
+    }
+    async isAvailable(server) {
+        return (await this.realClient.isAvailable(server)) ||
+            (await this.simClient.isAvailable(server));
+    }
+    getMode() {
+        return this.mode;
+    }
+    setMode(mode) {
+        this.mode = mode;
+    }
+    async close() {
+        await this.realClient.close();
+    }
+}
+// ============================================================================
+// Factory & Singleton
+// ============================================================================
+function createMCPClient(config = {}) {
+    // v7.0: Default changed from 'simulated' to 'real'
+    const mode = process.env.GENESIS_MCP_MODE || config.mode || 'real';
+    const timeout = parseInt(process.env.GENESIS_MCP_TIMEOUT || '') || config.timeout || 30000;
+    const logCalls = process.env.GENESIS_MCP_LOG === 'true' || config.logCalls || false;
+    const fullConfig = {
+        ...config,
+        mode,
+        timeout,
+        logCalls,
+    };
+    // Log mode for transparency
+    if (logCalls) {
+        console.log(`[MCP] Mode: ${mode} (timeout: ${timeout}ms)`);
+    }
+    switch (mode) {
+        case 'real':
+            return new RealMCPClient(fullConfig);
+        case 'hybrid':
+            return new HybridMCPClient(fullConfig);
+        case 'simulated':
+        default:
+            return new SimulatedMCPClient(fullConfig);
+    }
+}
+let mcpClientInstance = null;
+function getMCPClient(config) {
+    if (!mcpClientInstance) {
+        mcpClientInstance = createMCPClient(config);
+    }
+    return mcpClientInstance;
+}
+function resetMCPClient() {
+    if (mcpClientInstance) {
+        mcpClientInstance.close().catch(() => { });
+    }
+    mcpClientInstance = null;
+}
+exports.mcpClient = getMCPClient();
+// ============================================================================
+// Utilities
+// ============================================================================
+function isSimulatedMode() {
+    return exports.mcpClient.getMode() === 'simulated';
+}
+function isSimulatedResult(result) {
+    return result.mode === 'simulated' || result.data?._simulated === true;
+}
+function logMCPMode() {
+    const mode = exports.mcpClient.getMode();
+    const emoji = mode === 'real' ? '🔌' : mode === 'hybrid' ? '🔀' : '🎭';
+    console.log(`[Genesis] MCP Mode: ${emoji} ${mode.toUpperCase()}`);
+}