codex-linux 1.0.0

package/dist/main/mcp/MCPManager.js

@@ -0,0 +1,710 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcpManager = exports.MCPManager = void 0;
+const events_1 = require("events");
+const child_process_1 = require("child_process");
+const http = __importStar(require("http"));
+const url = __importStar(require("url"));
+const electron_log_1 = __importDefault(require("electron-log"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const MCPRegistry_1 = require("./MCPRegistry");
+const MCPConfigurationManager_1 = require("./MCPConfigurationManager");
+class MCPManager extends events_1.EventEmitter {
+    servers = new Map();
+    registry;
+    configManager;
+    messageId = 0;
+    pendingRequests = new Map();
+    toolSearchCache = new Map();
+    toolSearchTTL = 5 * 60 * 1000;
+    constructor() {
+        super();
+        this.registry = new MCPRegistry_1.MCPRegistry();
+        this.configManager = new MCPConfigurationManager_1.MCPConfigurationManager();
+    }
+    async initialize(projectPath) {
+        await this.registry.initialize();
+        await this.configManager.initialize(projectPath);
+        // Load configured servers
+        await this.loadConfiguredServers();
+        electron_log_1.default.info('MCP Manager initialized with registry and config support');
+    }
+    async loadConfiguredServers() {
+        const servers = this.configManager.getAllServers();
+        for (const [id, config] of servers) {
+            this.servers.set(id, {
+                config,
+                process: null,
+                tools: [],
+                resources: [],
+                prompts: [],
+                status: 'stopped',
+                toolsLoaded: false,
+                toolsByCategory: new Map(),
+            });
+            // Auto-start enabled servers
+            if (!config.disabled) {
+                try {
+                    await this.startServer(id);
+                }
+                catch (error) {
+                    electron_log_1.default.warn(`Failed to auto-start MCP server ${id}:`, error);
+                }
+            }
+        }
+    }
+    async addServer(config) {
+        // Save to configuration
+        await this.configManager.addServer(config);
+        // Register in memory
+        this.servers.set(config.id, {
+            config,
+            process: null,
+            tools: [],
+            resources: [],
+            prompts: [],
+            status: 'stopped',
+            toolsLoaded: false,
+            toolsByCategory: new Map(),
+        });
+        this.emit('server:added', config);
+        electron_log_1.default.info(`Registered MCP server: ${config.name} (${config.scope})`);
+    }
+    async removeServer(serverId) {
+        const server = this.servers.get(serverId);
+        if (!server)
+            return;
+        // Stop if running
+        if (server.status === 'running') {
+            await this.stopServer(serverId);
+        }
+        // Remove from config
+        await this.configManager.removeServer(serverId, server.config.scope);
+        // Remove from memory
+        this.servers.delete(serverId);
+        this.emit('server:removed', serverId);
+        electron_log_1.default.info(`Removed MCP server: ${serverId}`);
+    }
+    async startServer(serverId) {
+        const server = this.servers.get(serverId);
+        if (!server)
+            throw new Error(`Server ${serverId} not found`);
+        if (server.config.disabled)
+            throw new Error(`Server ${serverId} is disabled`);
+        if (server.status === 'running')
+            return;
+        server.status = 'starting';
+        this.emit('server:starting', serverId);
+        try {
+            if (server.config.transport === 'stdio' && server.config.command) {
+                await this.startStdioServer(server);
+            }
+            else if ((server.config.transport === 'http' || server.config.transport === 'streamable-http') && server.config.url) {
+                await this.startHttpServer(server);
+            }
+            else if (server.config.transport === 'sse' && server.config.url) {
+                await this.startSseServer(server);
+            }
+            else {
+                throw new Error(`Unsupported transport type: ${server.config.transport}`);
+            }
+            // Initialize connection
+            await this.initializeConnection(serverId);
+            // Fetch tools, resources, and prompts
+            await this.discoverCapabilities(serverId);
+            server.status = 'running';
+            this.emit('server:started', serverId);
+            electron_log_1.default.info(`MCP server started: ${server.config.name}`);
+        }
+        catch (error) {
+            server.status = 'error';
+            server.lastError = error.message;
+            this.emit('server:error', { serverId, error });
+            throw error;
+        }
+    }
+    async startStdioServer(server) {
+        const { command, args, env } = server.config;
+        server.process = (0, child_process_1.spawn)(command, args || [], {
+            env: { ...process.env, ...env },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        // Handle stdout
+        server.process.stdout?.on('data', (data) => {
+            this.handleServerOutput(server.config.id, data);
+        });
+        // Handle stderr
+        server.process.stderr?.on('data', (data) => {
+            electron_log_1.default.error(`MCP server ${server.config.id} stderr:`, data.toString());
+        });
+        // Handle exit
+        server.process.on('exit', (code) => {
+            server.status = code === 0 ? 'stopped' : 'error';
+            this.emit('server:stopped', { serverId: server.config.id, code });
+        });
+    }
+    async startHttpServer(server) {
+        // For HTTP servers, we just verify connectivity
+        const response = await (0, node_fetch_1.default)(`${server.config.url}/health`, {
+            method: 'GET',
+            headers: server.config.headers,
+        }).catch(() => null);
+        if (!response || !response.ok) {
+            electron_log_1.default.warn(`HTTP MCP server ${server.config.id} health check failed, will retry on use`);
+        }
+    }
+    async startSseServer(server) {
+        // SSE servers establish connection on first use
+        electron_log_1.default.info(`SSE MCP server ${server.config.id} registered, connection on first use`);
+    }
+    async initializeConnection(serverId) {
+        const response = await this.sendMessage(serverId, {
+            jsonrpc: '2.0',
+            id: this.getNextMessageId(),
+            method: 'initialize',
+            params: {
+                protocolVersion: '2024-11-05',
+                capabilities: {
+                    tools: {},
+                    resources: {},
+                    prompts: {},
+                    logging: {},
+                },
+                clientInfo: {
+                    name: 'codex-linux',
+                    version: '1.0.0',
+                },
+            },
+        });
+        if (response.error) {
+            throw new Error(`Initialize failed: ${response.error.message}`);
+        }
+        // Send initialized notification
+        await this.sendNotification(serverId, 'initialized', {});
+    }
+    async discoverCapabilities(serverId) {
+        const server = this.servers.get(serverId);
+        if (!server)
+            return;
+        // Discover tools
+        try {
+            const toolsResponse = await this.sendMessage(serverId, {
+                jsonrpc: '2.0',
+                id: this.getNextMessageId(),
+                method: 'tools/list',
+                params: {},
+            });
+            if (toolsResponse.result?.tools) {
+                server.tools = toolsResponse.result.tools.map((t) => ({
+                    ...t,
+                    serverId,
+                }));
+                // Build category index for lazy loading
+                this.buildToolsCategoryIndex(server);
+                server.toolsLoaded = true;
+            }
+        }
+        catch (error) {
+            electron_log_1.default.warn(`Failed to discover tools for ${serverId}:`, error);
+        }
+        // Discover resources
+        try {
+            const resourcesResponse = await this.sendMessage(serverId, {
+                jsonrpc: '2.0',
+                id: this.getNextMessageId(),
+                method: 'resources/list',
+                params: {},
+            });
+            if (resourcesResponse.result?.resources) {
+                server.resources = resourcesResponse.result.resources.map((r) => ({
+                    ...r,
+                    serverId,
+                }));
+            }
+        }
+        catch (error) {
+            electron_log_1.default.warn(`Failed to discover resources for ${serverId}:`, error);
+        }
+        // Discover prompts
+        try {
+            const promptsResponse = await this.sendMessage(serverId, {
+                jsonrpc: '2.0',
+                id: this.getNextMessageId(),
+                method: 'prompts/list',
+                params: {},
+            });
+            if (promptsResponse.result?.prompts) {
+                server.prompts = promptsResponse.result.prompts.map((p) => ({
+                    ...p,
+                    serverId,
+                }));
+            }
+        }
+        catch (error) {
+            electron_log_1.default.warn(`Failed to discover prompts for ${serverId}:`, error);
+        }
+        this.emit('server:capabilities', {
+            serverId,
+            tools: server.tools,
+            resources: server.resources,
+            prompts: server.prompts,
+        });
+    }
+    async stopServer(serverId) {
+        const server = this.servers.get(serverId);
+        if (!server)
+            return;
+        if (server.process) {
+            server.process.kill();
+            server.process = null;
+        }
+        server.status = 'stopped';
+        server.tools = [];
+        server.resources = [];
+        server.prompts = [];
+        this.emit('server:stopped', serverId);
+        electron_log_1.default.info(`MCP server stopped: ${server.config.name}`);
+    }
+    async sendMessage(serverId, message) {
+        const server = this.servers.get(serverId);
+        if (!server)
+            throw new Error(`Server ${serverId} not found`);
+        if (server.config.transport === 'stdio') {
+            return this.sendStdioMessage(server, message);
+        }
+        else {
+            return this.sendHttpMessage(server, message);
+        }
+    }
+    async sendStdioMessage(server, message) {
+        if (!server.process?.stdin) {
+            throw new Error(`Server ${server.config.id} not running`);
+        }
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(message.id);
+                reject(new Error('MCP request timeout'));
+            }, 30000);
+            this.pendingRequests.set(message.id, { resolve, reject, timeout });
+            server.process.stdin.write(JSON.stringify(message) + '\n');
+        });
+    }
+    async sendHttpMessage(server, message) {
+        const response = await (0, node_fetch_1.default)(`${server.config.url}/mcp`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...server.config.headers,
+            },
+            body: JSON.stringify(message),
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error: ${response.status}`);
+        }
+        return response.json();
+    }
+    async sendNotification(serverId, method, params) {
+        await this.sendMessage(serverId, {
+            jsonrpc: '2.0',
+            method,
+            params,
+        });
+    }
+    handleServerOutput(serverId, data) {
+        const messages = data.toString().trim().split('\n');
+        for (const messageStr of messages) {
+            if (!messageStr)
+                continue;
+            try {
+                const message = JSON.parse(messageStr);
+                // Handle responses
+                if (message.id !== undefined && this.pendingRequests.has(message.id)) {
+                    const pending = this.pendingRequests.get(message.id);
+                    clearTimeout(pending.timeout);
+                    this.pendingRequests.delete(message.id);
+                    if (message.error) {
+                        pending.reject(new Error(message.error.message));
+                    }
+                    else {
+                        pending.resolve(message);
+                    }
+                }
+                // Handle notifications
+                if (message.method) {
+                    this.handleNotification(serverId, message);
+                }
+            }
+            catch (error) {
+                electron_log_1.default.debug(`MCP server ${serverId} output:`, messageStr);
+            }
+        }
+    }
+    handleNotification(serverId, message) {
+        const server = this.servers.get(serverId);
+        if (!server)
+            return;
+        switch (message.method) {
+            case 'notifications/tools/list_changed':
+                this.discoverCapabilities(serverId);
+                break;
+            case 'notifications/resources/list_changed':
+                this.discoverCapabilities(serverId);
+                break;
+            case 'notifications/prompts/list_changed':
+                this.discoverCapabilities(serverId);
+                break;
+            case 'notifications/message':
+                electron_log_1.default.info(`MCP server ${serverId}:`, message.params);
+                break;
+        }
+    }
+    async callTool(serverId, toolName, args) {
+        const response = await this.sendMessage(serverId, {
+            jsonrpc: '2.0',
+            id: this.getNextMessageId(),
+            method: 'tools/call',
+            params: {
+                name: toolName,
+                arguments: args,
+            },
+        });
+        if (response.error) {
+            throw new Error(response.error.message);
+        }
+        return response.result;
+    }
+    async readResource(serverId, uri) {
+        const response = await this.sendMessage(serverId, {
+            jsonrpc: '2.0',
+            id: this.getNextMessageId(),
+            method: 'resources/read',
+            params: { uri },
+        });
+        if (response.error) {
+            throw new Error(response.error.message);
+        }
+        return response.result;
+    }
+    async getPrompt(serverId, promptName, args) {
+        const response = await this.sendMessage(serverId, {
+            jsonrpc: '2.0',
+            id: this.getNextMessageId(),
+            method: 'prompts/get',
+            params: {
+                name: promptName,
+                arguments: args,
+            },
+        });
+        if (response.error) {
+            throw new Error(response.error.message);
+        }
+        return response.result;
+    }
+    // Tool Search Optimization
+    async searchTools(query) {
+        const result = {
+            query,
+            tools: [],
+            resources: [],
+            prompts: [],
+        };
+        const lowerQuery = query.toLowerCase();
+        for (const server of this.servers.values()) {
+            if (server.status !== 'running')
+                continue;
+            // Search tools
+            for (const tool of server.tools) {
+                if (tool.name.toLowerCase().includes(lowerQuery) ||
+                    tool.description?.toLowerCase().includes(lowerQuery)) {
+                    result.tools.push(tool);
+                }
+            }
+            // Search resources
+            for (const resource of server.resources) {
+                if (resource.name.toLowerCase().includes(lowerQuery) ||
+                    resource.uri.toLowerCase().includes(lowerQuery)) {
+                    result.resources.push(resource);
+                }
+            }
+            // Search prompts
+            for (const prompt of server.prompts) {
+                if (prompt.name.toLowerCase().includes(lowerQuery) ||
+                    prompt.description?.toLowerCase().includes(lowerQuery)) {
+                    result.prompts.push(prompt);
+                }
+            }
+        }
+        return result;
+    }
+    // OAuth Authentication
+    async authenticateServer(serverId) {
+        const server = this.servers.get(serverId);
+        if (!server?.config.oauth) {
+            return false;
+        }
+        const { clientId, callbackPort = 8080 } = server.config.oauth;
+        // Start local HTTP server for OAuth callback
+        const redirectUri = `http://localhost:${callbackPort}/callback`;
+        return new Promise((resolve, reject) => {
+            const httpServer = http.createServer(async (req, res) => {
+                const parsedUrl = url.parse(req.url || '', true);
+                if (parsedUrl.pathname === '/callback') {
+                    const code = parsedUrl.query.code;
+                    if (code) {
+                        try {
+                            // Exchange code for token (implementation depends on OAuth provider)
+                            // This is a simplified version
+                            const token = {
+                                serverId,
+                                accessToken: code, // In real implementation, exchange code
+                                expiresAt: new Date(Date.now() + 3600 * 1000), // 1 hour
+                            };
+                            server.authToken = token;
+                            res.writeHead(200, { 'Content-Type': 'text/html' });
+                            res.end('<h1>Authentication successful!</h1><p>You can close this window.</p>');
+                            httpServer.close();
+                            resolve(true);
+                        }
+                        catch (error) {
+                            res.writeHead(500, { 'Content-Type': 'text/html' });
+                            res.end('<h1>Authentication failed</h1>');
+                            httpServer.close();
+                            reject(error);
+                        }
+                    }
+                    else {
+                        res.writeHead(400, { 'Content-Type': 'text/html' });
+                        res.end('<h1>Authentication failed</h1><p>No authorization code received.</p>');
+                        httpServer.close();
+                        resolve(false);
+                    }
+                }
+            });
+            httpServer.listen(callbackPort, () => {
+                electron_log_1.default.info(`OAuth callback server started on port ${callbackPort}`);
+                // Open browser for OAuth (would need electron shell.openExternal)
+                const authUrl = `${server.config.url}/auth?client_id=${clientId}&redirect_uri=${encodeURIComponent(redirectUri)}&response_type=code`;
+                electron_log_1.default.info(`Please visit: ${authUrl}`);
+            });
+            // Timeout after 5 minutes
+            setTimeout(() => {
+                httpServer.close();
+                reject(new Error('OAuth timeout'));
+            }, 5 * 60 * 1000);
+        });
+    }
+    getAllTools() {
+        const tools = [];
+        for (const server of this.servers.values()) {
+            if (server.status === 'running') {
+                tools.push(...server.tools);
+            }
+        }
+        return tools;
+    }
+    getAllResources() {
+        const resources = [];
+        for (const server of this.servers.values()) {
+            if (server.status === 'running') {
+                resources.push(...server.resources);
+            }
+        }
+        return resources;
+    }
+    getAllPrompts() {
+        const prompts = [];
+        for (const server of this.servers.values()) {
+            if (server.status === 'running') {
+                prompts.push(...server.prompts);
+            }
+        }
+        return prompts;
+    }
+    getServerStatus(serverId) {
+        return this.servers.get(serverId)?.status || 'stopped';
+    }
+    getServers() {
+        return Array.from(this.servers.values()).map(s => ({
+            id: s.config.id,
+            name: s.config.name,
+            status: s.status,
+            disabled: s.config.disabled,
+            scope: s.config.scope,
+            transport: s.config.transport,
+            tools: s.tools.length,
+            resources: s.resources.length,
+        }));
+    }
+    getRegistry() {
+        return this.registry;
+    }
+    getConfigManager() {
+        return this.configManager;
+    }
+    // Lazy Loading - Build category index for tools
+    buildToolsCategoryIndex(server) {
+        server.toolsByCategory.clear();
+        for (const tool of server.tools) {
+            const category = this.categorizeTool(tool);
+            const existing = server.toolsByCategory.get(category) || [];
+            existing.push(tool);
+            server.toolsByCategory.set(category, existing);
+        }
+    }
+    categorizeTool(tool) {
+        const name = tool.name.toLowerCase();
+        const inputSchema = JSON.stringify(tool.inputSchema).toLowerCase();
+        if (name.includes('file') || name.includes('read') || name.includes('write') || inputSchema.includes('path')) {
+            return 'filesystem';
+        }
+        if (name.includes('git') || name.includes('branch') || name.includes('commit')) {
+            return 'git';
+        }
+        if (name.includes('search') || name.includes('find') || name.includes('query')) {
+            return 'search';
+        }
+        if (name.includes('db') || name.includes('database') || name.includes('sql')) {
+            return 'database';
+        }
+        if (name.includes('api') || name.includes('http') || name.includes('fetch')) {
+            return 'api';
+        }
+        if (name.includes('run') || name.includes('execute') || name.includes('command')) {
+            return 'execution';
+        }
+        return 'other';
+    }
+    // Get tools by category (lazy loaded)
+    async getToolsByCategory(serverId, category) {
+        const server = this.servers.get(serverId);
+        if (!server)
+            return [];
+        if (!server.toolsLoaded) {
+            await this.discoverCapabilities(serverId);
+        }
+        return server.toolsByCategory.get(category) || [];
+    }
+    // Smart tool retrieval - only loads tools when needed
+    async getRelevantTools(serverId, context) {
+        const server = this.servers.get(serverId);
+        if (!server)
+            return [];
+        if (!server.toolsLoaded) {
+            await this.discoverCapabilities(serverId);
+        }
+        const contextLower = context.toLowerCase();
+        const relevantTools = [];
+        for (const tool of server.tools) {
+            const name = tool.name.toLowerCase();
+            const desc = (tool.description || '').toLowerCase();
+            // Score tool relevance
+            let score = 0;
+            if (name.includes(contextLower) || desc.includes(contextLower)) {
+                score = 3;
+            }
+            else if (this.categorizeTool(tool) === this.inferCategoryFromContext(contextLower)) {
+                score = 2;
+            }
+            if (score > 0) {
+                relevantTools.push(tool);
+            }
+        }
+        // If no specific tools found, return all (for broader context)
+        return relevantTools.length > 0 ? relevantTools : server.tools.slice(0, 10);
+    }
+    inferCategoryFromContext(context) {
+        if (context.includes('file') || context.includes('folder') || context.includes('directory')) {
+            return 'filesystem';
+        }
+        if (context.includes('git') || context.includes('commit') || context.includes('branch')) {
+            return 'git';
+        }
+        if (context.includes('search') || context.includes('find')) {
+            return 'search';
+        }
+        if (context.includes('database') || context.includes('query') || context.includes('sql')) {
+            return 'database';
+        }
+        return 'other';
+    }
+    // Cached search with TTL
+    async searchToolsCached(query) {
+        const cached = this.toolSearchCache.get(query);
+        if (cached && Date.now() - cached.timestamp < this.toolSearchTTL) {
+            return {
+                query,
+                tools: cached.tools,
+                resources: [],
+                prompts: [],
+            };
+        }
+        const result = await this.searchTools(query);
+        this.toolSearchCache.set(query, {
+            tools: result.tools,
+            timestamp: Date.now(),
+        });
+        return result;
+    }
+    // Clear tool cache
+    clearToolCache() {
+        this.toolSearchCache.clear();
+    }
+    // Get tools count for UI
+    getToolsCount() {
+        let count = 0;
+        for (const server of this.servers.values()) {
+            if (server.status === 'running') {
+                count += server.tools.length;
+            }
+        }
+        return count;
+    }
+    getNextMessageId() {
+        return ++this.messageId;
+    }
+    async cleanup() {
+        for (const [serverId] of this.servers) {
+            await this.stopServer(serverId);
+        }
+        this.pendingRequests.clear();
+    }
+}
+exports.MCPManager = MCPManager;
+exports.mcpManager = new MCPManager();
+//# sourceMappingURL=MCPManager.js.map