@theowlops/boombot 0.0.0-stage → 1.1.0

package/dist/gateway/turns/mcp-client.js

@@ -0,0 +1,643 @@
+import { spawn } from 'node:child_process';
+import { sanitizeToolSchema } from './tool-schema.js';
+const LEGACY_PROTOCOL_VERSION = '2025-11-25';
+const MODERN_PROTOCOL_VERSION = '2026-07-28';
+const TASKS_EXTENSION = 'io.modelcontextprotocol/tasks';
+const REQUEST_TIMEOUT_MS = 30_000;
+const MAX_FRAME_BYTES = 4 * 1024 * 1024;
+const MAX_TOOL_OUTPUT_CHARS = 256 * 1024;
+class McpHttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = 'McpHttpError';
+    }
+}
+class McpRpcError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'McpRpcError';
+    }
+}
+async function initializeClient(client) {
+    let modern = false;
+    try {
+        const discovery = await client.probeModern();
+        modern = isRecord(discovery)
+            && discovery['resultType'] === 'complete'
+            && Array.isArray(discovery['supportedVersions'])
+            && discovery['supportedVersions'].includes(MODERN_PROTOCOL_VERSION);
+    }
+    catch (error) {
+        if (error instanceof McpHttpError && (error.status === 401 || error.status === 403 || error.status >= 500)) {
+            throw error;
+        }
+        if (error instanceof McpRpcError && error.code === -32022)
+            throw error;
+        // An unrecognized probe response identifies a legacy server.
+    }
+    client.setEra(modern ? 'modern' : 'legacy');
+    if (!modern) {
+        await client.request('initialize', {
+            protocolVersion: LEGACY_PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: { name: 'boombot', version: '2.0.0' },
+        });
+        await client.notify('notifications/initialized');
+    }
+    const tools = [];
+    let cursor;
+    for (let page = 0; page < 100; page += 1) {
+        const result = await client.request('tools/list', cursor === undefined ? {} : { cursor });
+        if (!isRecord(result) || !Array.isArray(result['tools'])) {
+            throw new Error(`MCP server '${client.serverName}' returned an invalid tools/list result`);
+        }
+        for (const raw of result['tools']) {
+            if (!isRecord(raw) || typeof raw['name'] !== 'string' || raw['name'].trim() === '')
+                continue;
+            tools.push({
+                name: raw['name'],
+                ...(typeof raw['description'] === 'string' ? { description: raw['description'] } : {}),
+                ...(raw['inputSchema'] === undefined ? {} : { inputSchema: raw['inputSchema'] }),
+            });
+        }
+        cursor = typeof result['nextCursor'] === 'string' && result['nextCursor'] !== ''
+            ? result['nextCursor']
+            : undefined;
+        if (cursor === undefined)
+            return tools;
+    }
+    throw new Error(`MCP server '${client.serverName}' returned too many tools/list pages`);
+}
+function requestParams(era, method, params) {
+    if (era !== 'modern' && method !== 'server/discover')
+        return params;
+    const base = isRecord(params) ? params : {};
+    const existingMeta = isRecord(base['_meta']) ? base['_meta'] : {};
+    return {
+        ...base,
+        _meta: {
+            ...existingMeta,
+            'io.modelcontextprotocol/protocolVersion': MODERN_PROTOCOL_VERSION,
+            'io.modelcontextprotocol/clientInfo': { name: 'boombot', version: '2.0.0' },
+            'io.modelcontextprotocol/clientCapabilities': {
+                extensions: { [TASKS_EXTENSION]: {} },
+            },
+        },
+    };
+}
+async function resolveToolResult(client, value, signal) {
+    if (!isRecord(value)) {
+        throw new Error(`MCP server '${client.serverName}' returned an invalid tools/call result`);
+    }
+    if (value['resultType'] !== 'task')
+        return value;
+    const taskId = value['taskId'];
+    if (client.era !== 'modern' || typeof taskId !== 'string' || taskId === '') {
+        throw new Error(`MCP server '${client.serverName}' returned an invalid task result`);
+    }
+    let task = value;
+    try {
+        for (;;) {
+            const status = task['status'];
+            if (status === 'completed') {
+                if (!isRecord(task['result']))
+                    throw new Error(`MCP task '${taskId}' completed without a result`);
+                return task['result'];
+            }
+            if (status === 'failed') {
+                throw new Error(`MCP task '${taskId}' failed: ${taskMessage(task)}`);
+            }
+            if (status === 'cancelled')
+                throw new Error(`MCP task '${taskId}' was cancelled`);
+            if (status === 'input_required') {
+                await client.request('tasks/cancel', { taskId }).catch(() => undefined);
+                throw new Error(`MCP task '${taskId}' requires interactive input`);
+            }
+            if (status !== 'working')
+                throw new Error(`MCP task '${taskId}' has invalid status`);
+            await waitForPoll(task['pollIntervalMs'], signal);
+            const next = await client.request('tasks/get', { taskId }, signal);
+            if (!isRecord(next) || next['taskId'] !== taskId) {
+                throw new Error(`MCP server '${client.serverName}' returned an invalid tasks/get result`);
+            }
+            task = next;
+        }
+    }
+    catch (error) {
+        if (signal?.aborted === true) {
+            await client.request('tasks/cancel', { taskId }).catch(() => undefined);
+            throw abortError();
+        }
+        throw error;
+    }
+}
+function taskMessage(task) {
+    if (typeof task['statusMessage'] === 'string' && task['statusMessage'] !== '')
+        return task['statusMessage'];
+    return isRecord(task['error']) && typeof task['error']['message'] === 'string'
+        ? task['error']['message']
+        : 'unknown error';
+}
+function waitForPoll(value, signal) {
+    signal?.throwIfAborted();
+    const delay = typeof value === 'number' && Number.isFinite(value)
+        ? Math.min(30_000, Math.max(10, value))
+        : 1_000;
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, delay);
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(abortError());
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
+class McpStdioClient {
+    serverName;
+    config;
+    era = 'unknown';
+    child;
+    pending = new Map();
+    nextId = 1;
+    stdoutBuffer = '';
+    closed = false;
+    failure;
+    constructor(serverName, config) {
+        this.serverName = serverName;
+        this.config = config;
+    }
+    async probeModern() {
+        const probe = new McpStdioClient(`${this.serverName} probe`, this.config);
+        try {
+            return await probe.request('server/discover', {});
+        }
+        finally {
+            await probe.close();
+        }
+    }
+    setEra(era) {
+        this.era = era;
+    }
+    async call(toolName, args, signal) {
+        const result = await this.request('tools/call', { name: toolName, arguments: args }, signal);
+        return resolveToolResult(this, result, signal);
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.failAll(new Error(`MCP server '${this.serverName}' closed`));
+        const child = this.child;
+        this.child = undefined;
+        if (child === undefined)
+            return;
+        child.stdin.end();
+        if (child.exitCode === null && child.signalCode === null)
+            child.kill();
+    }
+    request(method, params, signal) {
+        if (this.closed)
+            return Promise.reject(new Error(`MCP server '${this.serverName}' is closed`));
+        if (this.failure !== undefined)
+            return Promise.reject(this.failure);
+        signal?.throwIfAborted();
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                this.pending.delete(id);
+                clearTimeout(timer);
+                this.notify('notifications/cancelled', { requestId: id, reason: 'caller aborted' });
+                reject(abortError());
+            };
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                signal?.removeEventListener('abort', onAbort);
+                reject(new Error(`MCP request '${method}' timed out after ${String(REQUEST_TIMEOUT_MS)}ms`));
+            }, REQUEST_TIMEOUT_MS);
+            const cleanup = () => signal?.removeEventListener('abort', onAbort);
+            this.pending.set(id, { resolve, reject, timer, cleanup });
+            signal?.addEventListener('abort', onAbort, { once: true });
+            this.write({ jsonrpc: '2.0', id, method, params: requestParams(this.era, method, params) });
+        });
+    }
+    notify(method, params) {
+        if (!this.closed)
+            this.write({
+                jsonrpc: '2.0',
+                method,
+                params: requestParams(this.era, method, params ?? {}),
+            });
+    }
+    write(message) {
+        this.ensureChild().stdin.write(`${JSON.stringify(message)}\n`);
+    }
+    ensureChild() {
+        if (this.child !== undefined)
+            return this.child;
+        const child = spawn(this.config.command, [...(this.config.args ?? [])], {
+            cwd: this.config.cwd,
+            env: { ...process.env, ...this.config.env },
+            shell: false,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        this.child = child;
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => this.consume(chunk));
+        child.stderr.resume();
+        child.on('error', (error) => {
+            if (this.child !== child)
+                return;
+            this.failure = error;
+            this.failAll(error);
+        });
+        child.on('exit', (code, signal) => {
+            if (this.child !== child)
+                return;
+            this.child = undefined;
+            const error = new Error(`MCP server '${this.serverName}' exited (${String(code ?? signal ?? 'unknown')})`);
+            this.failure = error;
+            this.failAll(error);
+        });
+        return child;
+    }
+    consume(chunk) {
+        this.stdoutBuffer += chunk;
+        if (Buffer.byteLength(this.stdoutBuffer) > MAX_FRAME_BYTES && !this.stdoutBuffer.includes('\n')) {
+            this.failAll(new Error(`MCP server '${this.serverName}' exceeded the ${String(MAX_FRAME_BYTES)} byte frame limit`));
+            this.child?.kill();
+            return;
+        }
+        for (;;) {
+            const newline = this.stdoutBuffer.indexOf('\n');
+            if (newline < 0)
+                return;
+            const line = this.stdoutBuffer.slice(0, newline).trim();
+            this.stdoutBuffer = this.stdoutBuffer.slice(newline + 1);
+            if (line === '')
+                continue;
+            if (Buffer.byteLength(line) > MAX_FRAME_BYTES) {
+                this.failAll(new Error(`MCP server '${this.serverName}' exceeded the ${String(MAX_FRAME_BYTES)} byte frame limit`));
+                this.child?.kill();
+                return;
+            }
+            let message;
+            try {
+                message = JSON.parse(line);
+            }
+            catch {
+                this.failAll(new Error(`MCP server '${this.serverName}' wrote non-JSON data to stdout`));
+                this.child?.kill();
+                return;
+            }
+            this.handleMessage(message);
+        }
+    }
+    handleMessage(message) {
+        if (message.method === 'ping' && message.id !== undefined) {
+            this.write({ jsonrpc: '2.0', id: message.id, result: {} });
+            return;
+        }
+        if (typeof message.id !== 'number')
+            return;
+        const pending = this.pending.get(message.id);
+        if (pending === undefined)
+            return;
+        this.pending.delete(message.id);
+        clearTimeout(pending.timer);
+        pending.cleanup();
+        if (message.error !== undefined) {
+            const detail = typeof message.error.message === 'string'
+                ? message.error.message
+                : JSON.stringify(message.error);
+            pending.reject(new McpRpcError(typeof message.error.code === 'number' ? message.error.code : undefined, `MCP ${this.serverName}: ${detail}`));
+        }
+        else {
+            pending.resolve(message.result);
+        }
+    }
+    failAll(error) {
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.cleanup();
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+}
+class McpHttpClient {
+    serverName;
+    config;
+    era = 'unknown';
+    nextId = 1;
+    sessionId;
+    protocolVersion = LEGACY_PROTOCOL_VERSION;
+    closed = false;
+    constructor(serverName, config) {
+        this.serverName = serverName;
+        this.config = config;
+    }
+    probeModern() {
+        return this.request('server/discover', {});
+    }
+    setEra(era) {
+        this.era = era;
+        this.protocolVersion = era === 'modern' ? MODERN_PROTOCOL_VERSION : LEGACY_PROTOCOL_VERSION;
+        if (era === 'modern')
+            this.sessionId = undefined;
+    }
+    async request(method, params, signal) {
+        if (this.closed)
+            throw new Error(`MCP server '${this.serverName}' is closed`);
+        const id = this.nextId++;
+        const message = await this.post({
+            jsonrpc: '2.0',
+            id,
+            method,
+            params: requestParams(this.era, method, params),
+        }, method, signal);
+        if (message === undefined || message.id !== id) {
+            throw new Error(`MCP server '${this.serverName}' returned no response for '${method}'`);
+        }
+        if (message.error !== undefined) {
+            const detail = typeof message.error.message === 'string'
+                ? message.error.message
+                : JSON.stringify(message.error);
+            throw new McpRpcError(typeof message.error.code === 'number' ? message.error.code : undefined, `MCP ${this.serverName}: ${detail}`);
+        }
+        if (this.era !== 'modern' && method === 'initialize' && isRecord(message.result) &&
+            typeof message.result['protocolVersion'] === 'string') {
+            this.protocolVersion = message.result['protocolVersion'];
+        }
+        return message.result;
+    }
+    async notify(method, params) {
+        if (this.closed)
+            return;
+        await this.post({ jsonrpc: '2.0', method, params: requestParams(this.era, method, params ?? {}) }, method, undefined, true);
+    }
+    async call(toolName, args, signal) {
+        const result = await this.request('tools/call', { name: toolName, arguments: args }, signal);
+        return resolveToolResult(this, result, signal);
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.era === 'modern' || this.sessionId === undefined)
+            return;
+        try {
+            await fetch(this.config.url, {
+                method: 'DELETE',
+                headers: this.headers('close', {}),
+                redirect: 'error',
+                signal: AbortSignal.timeout(5_000),
+            });
+        }
+        catch {
+            // Session cleanup is best effort; gateway shutdown must continue.
+        }
+    }
+    headers(method, body, includeProtocol = true) {
+        const headers = new Headers(this.config.headers);
+        headers.set('Accept', 'application/json, text/event-stream');
+        headers.set('Content-Type', 'application/json');
+        if (includeProtocol)
+            headers.set('MCP-Protocol-Version', method === 'server/discover' ? MODERN_PROTOCOL_VERSION : this.protocolVersion);
+        if (this.era === 'modern' || method === 'server/discover') {
+            headers.set('Mcp-Method', method);
+            const name = routingName(method, body);
+            if (name !== undefined)
+                headers.set('Mcp-Name', name);
+        }
+        else if (this.sessionId !== undefined) {
+            headers.set('Mcp-Session-Id', this.sessionId);
+        }
+        return headers;
+    }
+    async post(body, method, signal, notification = false) {
+        signal?.throwIfAborted();
+        const controller = new AbortController();
+        let timedOut = false;
+        const onAbort = () => controller.abort(signal?.reason);
+        signal?.addEventListener('abort', onAbort, { once: true });
+        const timer = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, REQUEST_TIMEOUT_MS);
+        try {
+            const response = await fetch(this.config.url, {
+                method: 'POST',
+                headers: this.headers(method, body, method !== 'initialize'),
+                body: JSON.stringify(body),
+                redirect: 'error',
+                signal: controller.signal,
+            });
+            const assignedSession = response.headers.get('mcp-session-id');
+            if (this.era !== 'modern' && assignedSession !== null && assignedSession !== '') {
+                this.sessionId = assignedSession;
+            }
+            if (notification && response.ok) {
+                await response.body?.cancel();
+                return undefined;
+            }
+            const text = await readBoundedResponse(response);
+            if (!response.ok) {
+                throw new McpHttpError(response.status, `MCP ${this.serverName}: HTTP ${String(response.status)}${text === '' ? '' : `: ${text}`}`);
+            }
+            if (response.status === 202) {
+                throw new Error(`MCP server '${this.serverName}' accepted '${method}' without returning a result`);
+            }
+            const messages = response.headers.get('content-type')?.toLowerCase().includes('text/event-stream') === true
+                ? parseSseMessages(text)
+                : [parseJsonResponse(text, this.serverName)];
+            const id = isRecord(body) ? body['id'] : undefined;
+            return messages.find((message) => message.id === id);
+        }
+        catch (error) {
+            if (timedOut) {
+                throw new Error(`MCP request '${method}' timed out after ${String(REQUEST_TIMEOUT_MS)}ms`);
+            }
+            if (signal?.aborted === true)
+                throw abortError();
+            throw error;
+        }
+        finally {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
+        }
+    }
+}
+function routingName(method, body) {
+    if (!isRecord(body) || !isRecord(body['params']))
+        return undefined;
+    const params = body['params'];
+    if (method === 'tasks/get' || method === 'tasks/update' || method === 'tasks/cancel') {
+        return typeof params['taskId'] === 'string' ? params['taskId'] : undefined;
+    }
+    return typeof params['name'] === 'string'
+        ? params['name']
+        : typeof params['uri'] === 'string'
+            ? params['uri']
+            : undefined;
+}
+async function readBoundedResponse(response) {
+    if (response.body === null)
+        return '';
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let bytes = 0;
+    let text = '';
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            return text + decoder.decode();
+        bytes += value.byteLength;
+        if (bytes > MAX_FRAME_BYTES) {
+            await reader.cancel();
+            throw new Error(`MCP HTTP response exceeded the ${String(MAX_FRAME_BYTES)} byte limit`);
+        }
+        text += decoder.decode(value, { stream: true });
+    }
+}
+function parseSseMessages(text) {
+    const messages = [];
+    for (const event of text.split(/\r?\n\r?\n/gu)) {
+        const data = event.split(/\r?\n/gu)
+            .filter((line) => line.startsWith('data:'))
+            .map((line) => line.slice(5).trimStart())
+            .join('\n');
+        if (data !== '')
+            messages.push(parseJsonResponse(data, 'HTTP'));
+    }
+    return messages;
+}
+function parseJsonResponse(text, serverName) {
+    try {
+        const parsed = JSON.parse(text);
+        if (!isRecord(parsed))
+            throw new Error();
+        return parsed;
+    }
+    catch {
+        throw new Error(`MCP server '${serverName}' returned invalid JSON`);
+    }
+}
+export class McpManager {
+    clients;
+    tools;
+    constructor(clients, tools) {
+        this.clients = clients;
+        this.tools = tools;
+    }
+    static async connect(servers, log = () => { }) {
+        const clients = [];
+        const tools = [];
+        const names = new Set();
+        for (const [serverName, config] of Object.entries(servers ?? {})) {
+            if (config.enabled === false)
+                continue;
+            const client = isHttpConfig(config)
+                ? new McpHttpClient(serverName, config)
+                : new McpStdioClient(serverName, config);
+            try {
+                const remoteTools = await initializeClient(client);
+                for (const tool of remoteTools) {
+                    const name = localToolName(serverName, tool.name);
+                    if (names.has(name))
+                        throw new Error(`duplicate local MCP tool name '${name}'`);
+                    names.add(name);
+                    tools.push({
+                        client,
+                        remoteName: tool.name,
+                        definition: {
+                            name,
+                            description: `[MCP ${serverName}/${tool.name}] ${tool.description ?? 'External MCP tool.'}`,
+                            parameters: sanitizeToolSchema(tool.inputSchema, (message) => log('warn', 'MCP tool schema sanitized', { server: serverName, tool: tool.name, message })),
+                        },
+                    });
+                }
+                clients.push(client);
+                log('info', 'MCP server connected', { server: serverName, tools: remoteTools.length });
+            }
+            catch (error) {
+                await client.close();
+                log('warn', 'MCP server failed to connect', {
+                    server: serverName,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        return new McpManager(clients, tools);
+    }
+    get toolNames() {
+        return this.tools.map((tool) => tool.definition.name);
+    }
+    registerTools(registry) {
+        for (const tool of this.tools) {
+            registry.registerTool(tool.definition, async (call, signal) => {
+                try {
+                    const result = await tool.client.call(tool.remoteName, call.arguments, signal);
+                    return {
+                        callId: call.id,
+                        name: call.name,
+                        output: formatResult(result),
+                        error: result.isError === true,
+                    };
+                }
+                catch (error) {
+                    if (signal?.aborted === true)
+                        throw error;
+                    return failure(call, error instanceof Error ? error.message : 'unknown MCP error');
+                }
+            });
+        }
+    }
+    async close() {
+        await Promise.all(this.clients.map((client) => client.close()));
+    }
+}
+function localToolName(serverName, remoteName) {
+    const safe = remoteName.replace(/[^A-Za-z0-9_-]/g, '_');
+    if (safe === '')
+        throw new Error(`MCP server '${serverName}' advertised an invalid empty tool name`);
+    return `mcp_${serverName}_${safe}`.slice(0, 64);
+}
+function isHttpConfig(config) {
+    return typeof config.url === 'string';
+}
+function formatResult(result) {
+    const parts = [];
+    for (const block of result.content ?? []) {
+        if (isRecord(block) && block['type'] === 'text' && typeof block['text'] === 'string') {
+            parts.push(block['text']);
+        }
+        else {
+            parts.push(JSON.stringify(block));
+        }
+    }
+    if (result.structuredContent !== undefined)
+        parts.push(JSON.stringify(result.structuredContent));
+    const output = parts.join('\n');
+    return output.length <= MAX_TOOL_OUTPUT_CHARS
+        ? output
+        : `${output.slice(0, MAX_TOOL_OUTPUT_CHARS)}\n[truncated]`;
+}
+function failure(call, message) {
+    return { callId: call.id, name: call.name, output: message, error: true };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function abortError() {
+    const error = new Error('MCP request cancelled');
+    error.name = 'AbortError';
+    return error;
+}