@orion-agents/orion-code 0.1.8 → 0.2.0

package/dist/tools/mcp.js

@@ -1,695 +0,0 @@
-"use strict";
-/**
- * orion code - MCP (Model Context Protocol) Support
- *
- * MCP client with auto-startup, heartbeat, and reconnection.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MCP_TOOLS = exports.mcpCallTool = exports.mcpListTool = exports.mcpManager = void 0;
-exports.getMcpConfigPath = getMcpConfigPath;
-exports.buildMcpToolName = buildMcpToolName;
-exports.buildMcpChildEnv = buildMcpChildEnv;
-const child_process_1 = require("child_process");
-const fs_1 = require("fs");
-const path_1 = require("path");
-const tool_1 = require("../framework/tool");
-const config_dir_1 = require("../services/config-dir");
-const identity_1 = require("../product/identity");
-const version_1 = require("../product/version");
-const errors_1 = require("../utils/errors");
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-/**
- * Keep only the entries a `tools/list` response can actually be used as.
- * An entry without a string `name` cannot be registered — `buildMcpToolName`
- * would produce `mcp__server__tool` for every one of them and they would
- * collide — so drop it instead of letting it through.
- */
-function parseToolDefinitions(payload) {
-    if (!isRecord(payload) || !Array.isArray(payload.tools))
-        return [];
-    return payload.tools.filter((tool) => isRecord(tool) && typeof tool.name === 'string');
-}
-const HEARTBEAT_INTERVAL_MS = 30000;
-const RECONNECT_MAX_ATTEMPTS = 3;
-const RECONNECT_BASE_DELAY_MS = 1000;
-const MCP_REQUEST_TIMEOUT_MS = 30000;
-function getMcpConfigPath() {
-    return (0, path_1.join)((0, config_dir_1.getConfigHome)(), 'mcp.json');
-}
-function sanitizeMcpNamePart(name, fallback) {
-    const sanitized = name
-        .replace(/[^A-Za-z0-9_-]/g, '_')
-        .replace(/_+/g, '_')
-        .replace(/^_+|_+$/g, '');
-    return sanitized || fallback;
-}
-function buildMcpToolName(serverName, toolName) {
-    return `mcp__${sanitizeMcpNamePart(serverName, 'server')}__${sanitizeMcpNamePart(toolName, 'tool')}`;
-}
-function expandEnvValue(value) {
-    return value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, key) => process.env[key] ?? '');
-}
-function expandServerConfig(config) {
-    const args = config.args?.map(arg => expandEnvValue(arg));
-    const env = config.env
-        ? Object.fromEntries(Object.entries(config.env).map(([key, value]) => [key, expandEnvValue(value)]))
-        : undefined;
-    return {
-        ...config,
-        command: config.command ? expandEnvValue(config.command) : undefined,
-        cwd: config.cwd ? (0, path_1.resolve)(expandEnvValue(config.cwd)) : undefined,
-        args,
-        env,
-    };
-}
-function normalizeMcpInputSchema(schema) {
-    const rawProperties = schema?.type === 'object' && isRecord(schema.properties) ? schema.properties : {};
-    const properties = {};
-    for (const [name, raw] of Object.entries(rawProperties)) {
-        if (!isRecord(raw)) {
-            properties[name] = { type: 'string', description: name };
-            continue;
-        }
-        const prop = { ...raw };
-        // A property is usable as-is only if it declares a type or a composite
-        // (anyOf/oneOf/allOf); otherwise fall back to string so the provider does
-        // not reject the whole tool schema over one under-specified field.
-        if (typeof prop.type !== 'string' && !prop.anyOf && !prop.oneOf && !prop.allOf) {
-            prop.type = 'string';
-        }
-        if (typeof prop.description !== 'string') {
-            prop.description = name;
-        }
-        properties[name] = prop;
-    }
-    const required = Array.isArray(schema?.required)
-        ? schema.required.filter((value) => typeof value === 'string')
-        : [];
-    return { type: 'object', properties, required };
-}
-function isTextContent(value) {
-    return isRecord(value) && value.type === 'text' && typeof value.text === 'string';
-}
-function formatMcpResult(result) {
-    const record = isRecord(result) ? result : undefined;
-    const textContent = Array.isArray(record?.content)
-        ? record.content
-            .filter(isTextContent)
-            .map(c => c.text)
-            .join('\n')
-        : '';
-    const output = textContent || JSON.stringify(result ?? {});
-    if (record?.isError) {
-        return { success: false, output, error: output || 'MCP tool returned an error' };
-    }
-    const metadata = {};
-    if (record?.structuredContent !== undefined) {
-        metadata.structuredContent = record.structuredContent;
-    }
-    return {
-        success: true,
-        output,
-        metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
-    };
-}
-// ============================================================================
-// MCP Client
-// ============================================================================
-// Issue #78: a third-party MCP stdio server must not inherit the parent
-// process's full environment — that leaks API keys, cloud credentials
-// (AWS_*, GCP_*, AZURE_*), and any other secret exported into the shell. We
-// pass only a small set of infrastructure variables plus whatever the user
-// explicitly configures (config.env), never the secret-laden parent env.
-const MCP_SAFE_ENV_KEYS = new Set([
-    'PATH',
-    'HOME',
-    'USER',
-    'LOGNAME',
-    'SHELL',
-    'TERM',
-    'LANG',
-    'LC_ALL',
-    'TMPDIR',
-    'TEMP',
-    'TMP',
-    'XDG_CONFIG_HOME',
-    'XDG_CACHE_HOME',
-    'XDG_DATA_HOME',
-    'XDG_RUNTIME_DIR',
-    'HTTP_PROXY',
-    'HTTPS_PROXY',
-    'NO_PROXY',
-    'http_proxy',
-    'https_proxy',
-    'no_proxy',
-]);
-function buildMcpChildEnv(configEnv) {
-    const env = {};
-    for (const [key, value] of Object.entries(process.env)) {
-        if (value === undefined)
-            continue;
-        if (MCP_SAFE_ENV_KEYS.has(key) || key.startsWith('LC_')) {
-            env[key] = value;
-        }
-    }
-    // Explicitly configured variables win (and may intentionally include secrets
-    // the server needs), but they never come from the parent environment.
-    if (configEnv) {
-        for (const [key, value] of Object.entries(configEnv)) {
-            env[key] = expandEnvValue(value);
-        }
-    }
-    return env;
-}
-class SimpleMCPClient {
-    constructor() {
-        this.state = {
-            process: null,
-            tools: [],
-            connected: false,
-            pendingRequests: new Map(),
-            buffer: '',
-        };
-        this.name = '';
-        this.serverConfig = null;
-        this.heartbeatTimer = null;
-        this.reconnectTimer = null;
-        this.reconnectAttempts = 0;
-        this.intentionallyDisconnected = false;
-        this.onDeadCallback = null;
-    }
-    setOnDead(cb) {
-        this.onDeadCallback = cb;
-    }
-    async connect(name, config) {
-        this.name = name;
-        this.serverConfig = config;
-        this.intentionallyDisconnected = false;
-        try {
-            await this.spawnAndInit();
-        }
-        catch (err) {
-            this.disconnect();
-            throw err;
-        }
-        this.startHeartbeat();
-    }
-    async spawnAndInit() {
-        const config = this.serverConfig;
-        if (!config)
-            throw new Error('No server config');
-        if (config.type && config.type !== 'stdio') {
-            throw new Error(`MCP transport "${config.type}" is not supported yet; only stdio is available`);
-        }
-        if (!config.command) {
-            throw new Error('MCP stdio server requires a command');
-        }
-        // A fresh process must start from a clean line buffer. The previous
-        // connection may have died mid-frame, leaving a half-JSON fragment that
-        // would otherwise be prepended to the new process's first chunk and break
-        // JSON parsing of the initialize response (#41 item 2).
-        this.state.buffer = '';
-        const env = buildMcpChildEnv(config.env);
-        this.state.process = (0, child_process_1.spawn)(config.command, config.args || [], {
-            env,
-            cwd: config.cwd,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        this.state.process.stdout?.on('data', (data) => {
-            this.handleData(data.toString());
-        });
-        this.state.process.stderr?.on('data', (data) => {
-            console.error(`[MCP ${this.name} stderr]:`, data.toString().trim());
-        });
-        // A destroyed/invalid pipe (spawn failed with ENOENT, or the child already
-        // exited) makes a later stdin.write emit 'error' asynchronously. An
-        // unhandled stream 'error' is rethrown as an uncaught exception and kills
-        // the whole CLI. Treat it like a disconnect: fail pending work and let the
-        // reconnect path (or graceful failure) take over instead of crashing (#41
-        // item 1).
-        this.state.process.stdin?.on('error', err => {
-            console.error(`[MCP ${this.name} stdin error]:`, err.message);
-            this.failPendingRequests(`MCP server stdin error: ${err.message}`);
-            this.state.connected = false;
-            if (!this.intentionallyDisconnected) {
-                this.scheduleReconnect();
-            }
-        });
-        this.state.process.on('error', err => {
-            console.error(`[MCP ${this.name} error]:`, err.message);
-            this.state.connected = false;
-            // A spawn failure (e.g. ENOENT for a missing binary) would otherwise
-            // leave the in-flight initialize request hanging until its 30s timeout.
-            // Fail it now so connect() rejects promptly and degrades instead of
-            // blocking startup (#41 item 1).
-            this.failPendingRequests(`MCP server error: ${err.message}`);
-        });
-        this.state.process.on('close', () => {
-            this.state.connected = false;
-            this.failPendingRequests('MCP server disconnected');
-            if (!this.intentionallyDisconnected) {
-                this.scheduleReconnect();
-            }
-        });
-        await this.sendRequest('initialize', {
-            protocolVersion: '2024-11-05',
-            capabilities: {},
-            clientInfo: { name: identity_1.MCP_CLIENT_NAME, version: version_1.PACKAGE_VERSION },
-        });
-        this.sendNotification('notifications/initialized', {});
-        const toolsResult = await this.sendRequest('tools/list', {});
-        this.state.tools = parseToolDefinitions(toolsResult);
-        this.state.connected = true;
-        this.reconnectAttempts = 0;
-    }
-    failPendingRequests(reason) {
-        for (const [, { reject, timer }] of this.state.pendingRequests) {
-            clearTimeout(timer);
-            reject(new Error(reason));
-        }
-        this.state.pendingRequests.clear();
-    }
-    startHeartbeat() {
-        this.stopHeartbeat();
-        this.heartbeatTimer = setInterval(() => {
-            if (!this.state.connected)
-                return;
-            // tools/list is cheap and supported by all MCP servers — use as ping
-            this.sendRequest('tools/list', {}).catch(() => {
-                // request failure → mark disconnected and let close handler reconnect
-                this.state.connected = false;
-                try {
-                    this.state.process?.kill();
-                }
-                catch {
-                    /* noop */
-                }
-            });
-        }, HEARTBEAT_INTERVAL_MS);
-    }
-    stopHeartbeat() {
-        if (this.heartbeatTimer) {
-            clearInterval(this.heartbeatTimer);
-            this.heartbeatTimer = null;
-        }
-    }
-    scheduleReconnect() {
-        if (this.intentionallyDisconnected || this.reconnectTimer)
-            return;
-        if (this.reconnectAttempts >= RECONNECT_MAX_ATTEMPTS) {
-            console.error(`[MCP ${this.name}] giving up after ${RECONNECT_MAX_ATTEMPTS} failed reconnects`);
-            this.stopHeartbeat();
-            this.onDeadCallback?.();
-            return;
-        }
-        this.reconnectAttempts++;
-        const delay = RECONNECT_BASE_DELAY_MS * Math.pow(2, this.reconnectAttempts - 1);
-        console.error(`[MCP ${this.name}] reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${RECONNECT_MAX_ATTEMPTS})`);
-        this.reconnectTimer = setTimeout(() => {
-            this.reconnectTimer = null;
-            if (this.intentionallyDisconnected)
-                return;
-            this.spawnAndInit().catch(err => {
-                console.error(`[MCP ${this.name}] reconnect failed:`, err.message);
-                this.scheduleReconnect();
-            });
-        }, delay);
-    }
-    handleData(data) {
-        this.state.buffer += data;
-        const lines = this.state.buffer.split('\n');
-        this.state.buffer = lines.pop() || '';
-        for (const line of lines) {
-            if (!line.trim())
-                continue;
-            try {
-                const msg = JSON.parse(line);
-                if (msg.id && this.state.pendingRequests.has(msg.id)) {
-                    const { resolve, reject, timer } = this.state.pendingRequests.get(msg.id);
-                    this.state.pendingRequests.delete(msg.id);
-                    clearTimeout(timer);
-                    if (msg.error) {
-                        reject(new Error(msg.error.message || 'MCP error'));
-                    }
-                    else {
-                        resolve(msg.result);
-                    }
-                }
-            }
-            catch {
-                // Each entry here was newline-terminated, so malformed or banner output is complete noise.
-            }
-        }
-    }
-    async sendRequest(method, params) {
-        if (!this.state.process) {
-            throw new Error('MCP client not connected');
-        }
-        const id = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
-        const request = JSON.stringify({
-            jsonrpc: '2.0',
-            id,
-            method,
-            params,
-        }) + '\n';
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                if (this.state.pendingRequests.has(id)) {
-                    this.state.pendingRequests.delete(id);
-                    reject(new Error('MCP request timeout'));
-                }
-            }, MCP_REQUEST_TIMEOUT_MS);
-            this.state.pendingRequests.set(id, { resolve, reject, timer });
-            if (!this.writeStdin(request)) {
-                clearTimeout(timer);
-                this.state.pendingRequests.delete(id);
-                reject(new Error('MCP server stdin is not writable (server disconnected)'));
-            }
-        });
-    }
-    /**
-     * Write to the child's stdin, but never let a dead/destroyed pipe throw an
-     * uncaught error. Returns false if the stream was not writable so callers can
-     * surface a tool error instead of crashing the CLI (#41 item 1).
-     */
-    writeStdin(data) {
-        const stdin = this.state.process?.stdin;
-        if (!stdin || stdin.destroyed || !stdin.writable) {
-            return false;
-        }
-        try {
-            stdin.write(data);
-            return true;
-        }
-        catch (err) {
-            console.error(`[MCP ${this.name} stdin write error]:`, (0, errors_1.errorMessage)(err));
-            return false;
-        }
-    }
-    sendNotification(method, params) {
-        if (!this.state.process)
-            return;
-        const notification = JSON.stringify({
-            jsonrpc: '2.0',
-            method,
-            params,
-        }) + '\n';
-        this.writeStdin(notification);
-    }
-    async callTool(name, args) {
-        const result = await this.sendRequest('tools/call', {
-            name,
-            arguments: args,
-        });
-        return formatMcpResult(result);
-    }
-    getTools() {
-        return this.state.tools;
-    }
-    isConnected() {
-        return this.state.connected;
-    }
-    disconnect() {
-        this.intentionallyDisconnected = true;
-        this.stopHeartbeat();
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = null;
-        }
-        this.failPendingRequests('MCP client disconnected');
-        if (this.state.process) {
-            try {
-                this.state.process.kill();
-            }
-            catch {
-                /* noop */
-            }
-            this.state.process = null;
-        }
-        this.state.connected = false;
-        this.state.tools = [];
-        // Drop any half-read JSON frame so a later reconnect starts clean (#41).
-        this.state.buffer = '';
-    }
-}
-// ============================================================================
-// MCP Server Manager
-// ============================================================================
-class MCPServerManager {
-    constructor() {
-        this.clients = new Map();
-        this.dead = new Set();
-        this.configured = new Map();
-    }
-    loadConfig() {
-        const configPath = getMcpConfigPath();
-        if (!(0, fs_1.existsSync)(configPath)) {
-            return null;
-        }
-        try {
-            const content = (0, fs_1.readFileSync)(configPath, 'utf-8');
-            const parsed = JSON.parse(content);
-            const servers = parsed.mcpServers ?? parsed.servers;
-            if (!servers || typeof servers !== 'object' || Array.isArray(servers)) {
-                console.error('[MCP] Invalid config: expected "mcpServers" object');
-                return null;
-            }
-            return { mcpServers: servers };
-        }
-        catch (err) {
-            console.error('[MCP] Failed to load config:', (0, errors_1.errorMessage)(err));
-            return null;
-        }
-    }
-    async connectAll() {
-        const config = this.loadConfig();
-        if (!config || !config.mcpServers)
-            return;
-        this.configured = new Map(Object.entries(config.mcpServers));
-        for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
-            if (serverConfig.disabled) {
-                continue;
-            }
-            const existing = this.clients.get(name);
-            if (existing?.isConnected()) {
-                continue;
-            }
-            try {
-                const expandedConfig = expandServerConfig(serverConfig);
-                if (expandedConfig.type && expandedConfig.type !== 'stdio') {
-                    throw new Error(`transport "${expandedConfig.type}" is not supported yet; only stdio is available`);
-                }
-                const client = new SimpleMCPClient();
-                client.setOnDead(() => {
-                    this.clients.delete(name);
-                    this.dead.add(name);
-                    console.error(`[MCP] server "${name}" removed from registry after repeated failures.`);
-                });
-                await client.connect(name, expandedConfig);
-                this.clients.set(name, client);
-                this.dead.delete(name);
-                console.log(`[MCP] connected to ${name}, tools: ${client.getTools().length}`);
-            }
-            catch (err) {
-                console.error(`[MCP] failed to connect to ${name}:`, (0, errors_1.errorMessage)(err));
-                this.dead.add(name);
-            }
-        }
-    }
-    getClient(name) {
-        return this.clients.get(name);
-    }
-    getAllTools() {
-        const allTools = [];
-        for (const [serverName, client] of this.clients) {
-            if (!client.isConnected())
-                continue;
-            for (const tool of client.getTools()) {
-                allTools.push({ server: serverName, tool });
-            }
-        }
-        return allTools;
-    }
-    getOrionCodeTools() {
-        const seen = new Set();
-        return this.getAllTools().map(({ server, tool }) => {
-            const baseName = buildMcpToolName(server, tool.name);
-            let orionCodeName = baseName;
-            let suffix = 2;
-            while (seen.has(orionCodeName)) {
-                orionCodeName = `${baseName}_${suffix++}`;
-            }
-            seen.add(orionCodeName);
-            return (0, tool_1.buildTool)({
-                name: orionCodeName,
-                description: `[MCP:${server}/${tool.name}] ${tool.description || 'External MCP tool'}`,
-                parameters: normalizeMcpInputSchema(tool.inputSchema),
-                execute: async (args) => {
-                    const client = this.getClient(server);
-                    if (!client?.isConnected()) {
-                        return {
-                            success: false,
-                            output: '',
-                            error: `MCP server not connected: ${server}`,
-                        };
-                    }
-                    return client.callTool(tool.name, args);
-                },
-                checkPermissions: () => ({
-                    behavior: 'ask',
-                    reason: `Calling external MCP tool ${server}/${tool.name}`,
-                }),
-                isReadOnly: () => tool.annotations?.readOnlyHint === true,
-                isDestructive: () => tool.annotations?.destructiveHint === true,
-                userFacingName: () => `MCP ${server}/${tool.name}`,
-                getSummary: (_args, result) => result.success
-                    ? `MCP ${server}/${tool.name}`
-                    : result.error || `MCP ${server}/${tool.name} failed`,
-            });
-        });
-    }
-    disconnectAll() {
-        for (const client of this.clients.values()) {
-            client.disconnect();
-        }
-        this.clients.clear();
-        this.dead.clear();
-        this.configured.clear();
-    }
-    getConnectedServers() {
-        return Array.from(this.clients.keys()).filter(name => this.clients.get(name)?.isConnected());
-    }
-    /** Snapshot for /mcp command */
-    getStatus() {
-        const all = new Set([...this.configured.keys(), ...this.clients.keys(), ...this.dead]);
-        return Array.from(all).map(name => {
-            const client = this.clients.get(name);
-            return {
-                name,
-                connected: !!client?.isConnected(),
-                toolCount: client?.getTools().length ?? 0,
-                dead: this.dead.has(name),
-            };
-        });
-    }
-}
-exports.mcpManager = new MCPServerManager();
-// ============================================================================
-// MCP Tools for Orion Code
-// ============================================================================
-exports.mcpListTool = (0, tool_1.buildTool)({
-    name: 'mcp_list',
-    description: 'List available MCP tools from connected MCP servers.',
-    parameters: {
-        type: 'object',
-        properties: {
-            server: {
-                type: 'string',
-                description: 'Filter by server name (optional)',
-            },
-        },
-        required: [],
-    },
-    execute: async (args) => {
-        const serverFilter = args.server;
-        const allTools = exports.mcpManager.getAllTools();
-        if (allTools.length === 0) {
-            return {
-                success: true,
-                output: 'No MCP servers connected. Configure servers in ~/.orion-code/mcp.json',
-            };
-        }
-        const filteredTools = serverFilter ? allTools.filter(t => t.server === serverFilter) : allTools;
-        if (filteredTools.length === 0) {
-            return {
-                success: true,
-                output: `No tools found for server: ${serverFilter}`,
-            };
-        }
-        const lines = [];
-        lines.push('MCP Tools Available:');
-        lines.push('');
-        for (const { server, tool } of filteredTools) {
-            lines.push(`[${server}] ${tool.name}`);
-            lines.push(`  ${tool.description || 'External MCP tool'}`);
-            if (tool.inputSchema?.properties) {
-                const props = Object.keys(tool.inputSchema.properties);
-                lines.push(`  Parameters: ${props.join(', ')}`);
-            }
-            lines.push('');
-        }
-        return {
-            success: true,
-            output: lines.join('\n'),
-        };
-    },
-    isReadOnly: () => true,
-    userFacingName: () => 'List MCP tools',
-});
-exports.mcpCallTool = (0, tool_1.buildTool)({
-    name: 'mcp_call',
-    description: 'Call an MCP tool from a connected MCP server.',
-    parameters: {
-        type: 'object',
-        properties: {
-            server: {
-                type: 'string',
-                description: 'MCP server name',
-            },
-            tool: {
-                type: 'string',
-                description: 'Tool name to call',
-            },
-            args: {
-                type: 'object',
-                description: 'Tool arguments',
-            },
-        },
-        required: ['server', 'tool'],
-    },
-    execute: async (args) => {
-        const server = args.server;
-        const tool = args.tool;
-        const toolArgs = (args.args || {});
-        if (!server) {
-            return { success: false, output: '', error: 'mcp_call requires a server parameter' };
-        }
-        if (!tool) {
-            return { success: false, output: '', error: 'mcp_call requires a tool parameter' };
-        }
-        const client = exports.mcpManager.getClient(server);
-        if (!client) {
-            return {
-                success: false,
-                output: '',
-                error: `MCP server not connected: ${server}. Available servers: ${exports.mcpManager.getConnectedServers().join(', ') || 'none'}`,
-            };
-        }
-        if (!client.isConnected()) {
-            return {
-                success: false,
-                output: '',
-                error: `MCP server ${server} is not connected`,
-            };
-        }
-        try {
-            const result = await client.callTool(tool, toolArgs);
-            return result;
-        }
-        catch (err) {
-            return {
-                success: false,
-                output: '',
-                error: `MCP tool call failed: ${(0, errors_1.errorMessage)(err)}`,
-            };
-        }
-    },
-    checkPermissions: () => {
-        return { behavior: 'ask', reason: 'Calling external MCP tool' };
-    },
-    userFacingName: args => `Call ${args.server}/${args.tool}`,
-});
-exports.MCP_TOOLS = [exports.mcpListTool, exports.mcpCallTool];
-//# sourceMappingURL=mcp.js.map