@ouro.bot/cli 0.1.0-alpha.66 → 0.1.0-alpha.660

package/dist/repertoire/mcp-client.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpClient = void 0;
+exports.isMcpTransportError = isMcpTransportError;
+const child_process_1 = require("child_process");
+const readline_1 = require("readline");
+const runtime_1 = require("../nerves/runtime");
+const runtime_cwd_1 = require("../heart/runtime-cwd");
+const MCP_PROTOCOL_VERSION = "2024-11-05";
+const DEFAULT_REQUEST_TIMEOUT = 10_000;
+const DEFAULT_TOOL_CALL_TIMEOUT = 30_000;
+function isMcpTransportError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const normalized = message.toLowerCase();
+    return normalized.includes("disconnected")
+        || normalized.includes("transport")
+        || normalized.includes("closed")
+        || normalized.includes("econnreset")
+        || normalized.includes("econnrefused")
+        || normalized.includes("enoent")
+        || normalized.includes("epipe")
+        || normalized.includes("broken pipe")
+        || normalized.includes("not writable");
+}
+class McpClient {
+    config;
+    process = null;
+    nextId = 1;
+    pending = new Map();
+    connected = false;
+    cachedTools = null;
+    onCloseCallback = null;
+    constructor(config) {
+        this.config = config;
+    }
+    async connect() {
+        if (this.connected)
+            return;
+        this.shutdownProcessOnly();
+        (0, runtime_1.emitNervesEvent)({
+            event: "mcp.connect_start",
+            component: "repertoire",
+            message: "starting MCP server connection",
+            meta: { command: this.config.command },
+        });
+        const env = { ...process.env, ...this.config.env };
+        const spawnCwd = this.config.cwd ?? (0, runtime_cwd_1.recoverRuntimeCwd)();
+        this.process = (0, child_process_1.spawn)(this.config.command, this.config.args ?? [], {
+            env,
+            stdio: ["pipe", "pipe", "pipe"],
+            cwd: spawnCwd,
+        });
+        this.setupLineReader();
+        this.setupProcessHandlers();
+        try {
+            await this.initialize();
+            this.connected = true;
+            (0, runtime_1.emitNervesEvent)({
+                event: "mcp.connect_end",
+                component: "repertoire",
+                message: "MCP server connected",
+                meta: { command: this.config.command },
+            });
+        }
+        catch (error) {
+            this.connected = false;
+            this.shutdownProcessOnly();
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "mcp.connect_error",
+                component: "repertoire",
+                message: "MCP server connection failed",
+                meta: {
+                    command: this.config.command,
+                    /* v8 ignore next -- defensive: spawn errors are always Error instances @preserve */
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+            throw error;
+        }
+    }
+    async listTools() {
+        if (this.cachedTools) {
+            return this.cachedTools;
+        }
+        const allTools = [];
+        let cursor;
+        do {
+            const params = {};
+            if (cursor) {
+                params.cursor = cursor;
+            }
+            const result = await this.sendRequest("tools/list", params);
+            allTools.push(...result.tools);
+            cursor = result.nextCursor;
+        } while (cursor);
+        this.cachedTools = allTools;
+        return allTools;
+    }
+    async refreshTools() {
+        this.cachedTools = null;
+        return this.listTools();
+    }
+    async callTool(name, args, timeout = DEFAULT_TOOL_CALL_TIMEOUT) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "mcp.tool_call_start",
+            component: "repertoire",
+            message: `calling MCP tool: ${name}`,
+            meta: { tool: name },
+        });
+        try {
+            const result = await this.sendRequest("tools/call", {
+                name,
+                arguments: args,
+            }, timeout);
+            (0, runtime_1.emitNervesEvent)({
+                event: "mcp.tool_call_end",
+                component: "repertoire",
+                message: `MCP tool call completed: ${name}`,
+                meta: { tool: name },
+            });
+            return result;
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "mcp.tool_call_error",
+                component: "repertoire",
+                message: `MCP tool call failed: ${name}`,
+                meta: {
+                    tool: name,
+                    /* v8 ignore next -- defensive: callTool errors are always Error instances @preserve */
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+            throw error;
+        }
+    }
+    shutdown() {
+        this.connected = false;
+        this.rejectAllPending(new Error("Client shutdown"));
+        /* v8 ignore next -- defensive: process always exists during normal shutdown @preserve */
+        if (this.process && !this.process.killed) {
+            this.process.kill();
+        }
+        this.process = null;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    onClose(callback) {
+        this.onCloseCallback = callback;
+    }
+    async initialize() {
+        const result = await this.sendRequest("initialize", {
+            protocolVersion: MCP_PROTOCOL_VERSION,
+            clientInfo: { name: "ouroboros", version: "1.0" },
+            capabilities: {},
+        });
+        // Send initialized notification (no id, no response expected)
+        this.writeMessage({
+            jsonrpc: "2.0",
+            method: "initialized",
+        });
+        return result;
+    }
+    sendRequest(method, params, timeout = DEFAULT_REQUEST_TIMEOUT) {
+        return new Promise((resolve, reject) => {
+            if (!this.process || !this.connected && method !== "initialize") {
+                reject(new Error("MCP client is disconnected"));
+                return;
+            }
+            const id = this.nextId++;
+            const pending = { resolve, reject };
+            if (timeout) {
+                pending.timer = setTimeout(() => {
+                    this.pending.delete(id);
+                    reject(new Error(`MCP request timeout after ${timeout}ms: ${method}`));
+                }, timeout);
+            }
+            this.pending.set(id, pending);
+            const request = {
+                jsonrpc: "2.0",
+                id,
+                method,
+                params,
+            };
+            if (!this.writeMessage(request)) {
+                this.pending.delete(id);
+                if (pending.timer) {
+                    clearTimeout(pending.timer);
+                }
+                reject(new Error(`MCP transport is not writable for request: ${method}`));
+            }
+        });
+    }
+    writeMessage(message) {
+        if (this.process?.stdin?.writable) {
+            this.process.stdin.write(JSON.stringify(message) + "\n");
+            return true;
+        }
+        return false;
+    }
+    setupLineReader() {
+        /* v8 ignore next -- defensive: stdout always exists after spawn @preserve */
+        if (!this.process?.stdout)
+            return;
+        const rl = (0, readline_1.createInterface)({ input: this.process.stdout });
+        rl.on("line", (line) => {
+            this.handleLine(line);
+        });
+    }
+    handleLine(line) {
+        let response;
+        try {
+            response = JSON.parse(line);
+        }
+        catch {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                event: "mcp.connect_error",
+                component: "repertoire",
+                message: "received malformed JSON from MCP server",
+                meta: { line },
+            });
+            return;
+        }
+        if (response.id === undefined || response.id === null) {
+            // Notification or invalid — ignore
+            return;
+        }
+        const pending = this.pending.get(response.id);
+        if (!pending)
+            return;
+        this.pending.delete(response.id);
+        if (pending.timer) {
+            clearTimeout(pending.timer);
+        }
+        if (response.error) {
+            pending.reject(new Error(response.error.message));
+        }
+        else {
+            pending.resolve(response.result);
+        }
+    }
+    setupProcessHandlers() {
+        /* v8 ignore next -- defensive: process always exists after spawn @preserve */
+        if (!this.process)
+            return;
+        this.process.on("error", (error) => {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "mcp.connect_error",
+                component: "repertoire",
+                message: "MCP server process error",
+                meta: { reason: error.message },
+            });
+        });
+        this.process.on("close", (code) => {
+            const wasConnected = this.connected;
+            this.connected = false;
+            this.rejectAllPending(new Error(`MCP server process closed with code ${code}`));
+            if (wasConnected) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    event: "mcp.connect_error",
+                    component: "repertoire",
+                    message: "MCP server process exited unexpectedly",
+                    meta: { exitCode: code },
+                });
+            }
+            if (this.onCloseCallback) {
+                this.onCloseCallback();
+            }
+        });
+    }
+    rejectAllPending(error) {
+        for (const [id, pending] of this.pending) {
+            if (pending.timer) {
+                clearTimeout(pending.timer);
+            }
+            pending.reject(error);
+            this.pending.delete(id);
+        }
+    }
+    shutdownProcessOnly() {
+        this.rejectAllPending(new Error("MCP transport closed during reconnect"));
+        /* v8 ignore next -- defensive: process may already be absent @preserve */
+        if (this.process && !this.process.killed) {
+            this.process.kill();
+        }
+        this.process = null;
+    }
+}
+exports.McpClient = McpClient;