mocode-ai 0.6.7 → 0.6.9

package/dist/mcp/client.js

@@ -0,0 +1,389 @@
+import { spawn } from 'node:child_process';
+const PROTOCOL_VERSION = '2025-03-26';
+const DEFAULT_TIMEOUT_MS = 30_000;
+class McpTransport {
+    receive;
+    constructor(receive) {
+        this.receive = receive;
+    }
+}
+class StdioTransport extends McpTransport {
+    spec;
+    child = null;
+    buffer = Buffer.alloc(0);
+    constructor(receive, spec) {
+        super(receive);
+        this.spec = spec;
+    }
+    async start() {
+        if (this.child)
+            return;
+        const shell = process.platform === 'win32' && /\.(cmd|bat)$/i.test(this.spec.command);
+        const child = spawn(this.spec.command, this.spec.args ?? [], {
+            cwd: this.spec.cwd,
+            env: { ...process.env, ...this.spec.env },
+            shell,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        this.child = child;
+        child.stdout?.on('data', (chunk) => this.onData(chunk));
+        child.stderr?.on('data', () => { });
+        child.on('exit', (code, signal) => { this.child = null; if (code !== 0 && signal == null)
+            this.receive({ error: { message: `stdio server 已退出 (${code})` } }); });
+        await new Promise((resolve, reject) => {
+            const onSpawn = () => { child.off('error', onError); resolve(); };
+            const onError = (error) => { child.off('spawn', onSpawn); reject(error); };
+            child.once('spawn', onSpawn);
+            child.once('error', onError);
+        });
+    }
+    async send(message) {
+        if (!this.child?.stdin?.writable)
+            throw new Error('MCP stdio server 未连接');
+        const body = `${JSON.stringify(message)}\n`;
+        // MCP stdio 传输使用 NDJSON；接收端仍兼容 Content-Length，方便接入历史 LSP 风格服务。
+        await new Promise((resolve, reject) => this.child.stdin.write(body, (error) => error ? reject(error) : resolve()));
+    }
+    async close() {
+        const child = this.child;
+        this.child = null;
+        if (!child || child.killed)
+            return;
+        child.kill();
+    }
+    onData(chunk) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        while (this.buffer.length > 0) {
+            const headerEnd = this.buffer.indexOf('\r\n\r\n');
+            if (headerEnd === -1) {
+                const newline = this.buffer.indexOf('\n');
+                if (newline === -1)
+                    return;
+                const line = this.buffer.subarray(0, newline).toString('utf8').trim();
+                this.buffer = this.buffer.subarray(newline + 1);
+                this.receiveJson(line);
+                continue;
+            }
+            const header = this.buffer.subarray(0, headerEnd).toString('ascii');
+            const match = /content-length\s*:\s*(\d+)/i.exec(header);
+            if (!match) {
+                this.buffer = this.buffer.subarray(headerEnd + 4);
+                continue;
+            }
+            const length = Number(match[1]);
+            const bodyStart = headerEnd + 4;
+            if (this.buffer.length < bodyStart + length)
+                return;
+            this.receiveJson(this.buffer.subarray(bodyStart, bodyStart + length).toString('utf8'));
+            this.buffer = this.buffer.subarray(bodyStart + length);
+        }
+    }
+    receiveJson(raw) {
+        try {
+            this.receive(JSON.parse(raw));
+        }
+        catch { /* 忽略 server 的非协议 stdout，避免打断会话。 */ }
+    }
+}
+class StreamableHttpTransport extends McpTransport {
+    spec;
+    sessionId = null;
+    constructor(receive, spec) {
+        super(receive);
+        this.spec = spec;
+    }
+    async start() { }
+    async send(message) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutFor(this.spec));
+        try {
+            const headers = {
+                accept: 'application/json, text/event-stream',
+                'content-type': 'application/json',
+                ...this.spec.headers,
+            };
+            if (this.sessionId)
+                headers['mcp-session-id'] = this.sessionId;
+            const response = await fetch(this.spec.url, {
+                method: 'POST', headers, body: JSON.stringify(message), signal: controller.signal, redirect: 'error',
+            });
+            this.captureSession(response);
+            if (!response.ok)
+                throw new Error(`HTTP ${response.status}: ${(await response.text()).slice(0, 500)}`);
+            const contentType = response.headers.get('content-type') ?? '';
+            if (contentType.includes('text/event-stream')) {
+                await consumeSse(response.body, (event) => this.receiveEvent(event), controller.signal);
+            }
+            else {
+                const text = await response.text();
+                if (text.trim())
+                    this.receiveEvent({ event: 'message', data: text });
+            }
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async close() { this.sessionId = null; }
+    captureSession(response) { this.sessionId = response.headers.get('mcp-session-id') ?? this.sessionId; }
+    receiveEvent(event) { try {
+        this.receive(JSON.parse(event.data));
+    }
+    catch { /* 非 JSON SSE event 无法作为 MCP 响应。 */ } }
+}
+class SseTransport extends McpTransport {
+    spec;
+    endpoint = null;
+    controller = null;
+    connecting = null;
+    resolveEndpoint = null;
+    rejectEndpoint = null;
+    constructor(receive, spec) {
+        super(receive);
+        this.spec = spec;
+    }
+    async start() {
+        if (this.connecting)
+            return this.connecting;
+        this.controller = new AbortController();
+        this.connecting = new Promise((resolve, reject) => { this.resolveEndpoint = resolve; this.rejectEndpoint = reject; });
+        void this.open();
+        return this.connecting;
+    }
+    async send(message) {
+        await this.start();
+        if (!this.endpoint)
+            throw new Error('SSE MCP server 未提供 message endpoint');
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutFor(this.spec));
+        try {
+            const response = await fetch(this.endpoint, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json', ...this.spec.headers },
+                body: JSON.stringify(message), signal: controller.signal, redirect: 'error',
+            });
+            if (!response.ok)
+                throw new Error(`HTTP ${response.status}: ${(await response.text()).slice(0, 500)}`);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async close() {
+        this.controller?.abort();
+        this.controller = null;
+        this.endpoint = null;
+        this.connecting = null;
+    }
+    async open() {
+        try {
+            const response = await fetch(this.spec.url, {
+                headers: { accept: 'text/event-stream', ...this.spec.headers }, signal: this.controller?.signal, redirect: 'error',
+            });
+            if (!response.ok)
+                throw new Error(`HTTP ${response.status}: ${(await response.text()).slice(0, 500)}`);
+            await consumeSse(response.body, (event) => {
+                if (event.event === 'endpoint') {
+                    this.endpoint = new URL(event.data, this.spec.url);
+                    this.resolveEndpoint?.();
+                    return;
+                }
+                try {
+                    this.receive(JSON.parse(event.data));
+                }
+                catch { /* 忽略非 MCP SSE event。 */ }
+            }, this.controller?.signal);
+            if (!this.endpoint)
+                throw new Error('SSE MCP server 在连接关闭前未提供 endpoint');
+        }
+        catch (error) {
+            if (!this.controller?.signal.aborted)
+                this.rejectEndpoint?.(asError(error));
+        }
+    }
+}
+/** 统一的 MCP client：完成 initialize、tools/list、tools/call 及请求超时/abort 管理。 */
+export class McpClient {
+    name;
+    spec;
+    transport;
+    pending = new Map();
+    nextId = 1;
+    initialized = false;
+    closed = false;
+    cachedTools = [];
+    constructor(name, spec) {
+        this.name = name;
+        this.spec = spec;
+        const receive = (message) => this.onMessage(message);
+        // 向后兼容早期仅提供 command/args 的 stdio 配置；新配置显式写 transport 更清晰。
+        this.transport = spec.transport === 'stdio' || ('command' in spec && typeof spec.command === 'string')
+            ? new StdioTransport(receive, spec)
+            : spec.transport === 'sse'
+                ? new SseTransport(receive, spec)
+                : new StreamableHttpTransport(receive, spec);
+    }
+    isReady() { return this.initialized && !this.closed; }
+    async initialize() {
+        if (this.isReady())
+            return;
+        this.closed = false;
+        await this.transport.start();
+        const result = await this.request('initialize', {
+            protocolVersion: PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: { name: 'mocode-ai', version: '0.6.8' },
+        });
+        if (!result || typeof result !== 'object')
+            throw new Error('MCP initialize 返回了无效响应');
+        await this.notify('notifications/initialized', {});
+        this.initialized = true;
+        await this.listTools();
+    }
+    async listTools() {
+        if (this.closed)
+            throw new Error('MCP client 已关闭');
+        const tools = [];
+        let cursor;
+        do {
+            const result = await this.request('tools/list', cursor ? { cursor } : {});
+            if (!Array.isArray(result.tools))
+                throw new Error('MCP tools/list 返回了无效 tools');
+            for (const tool of result.tools) {
+                if (!isRecord(tool) || typeof tool.name !== 'string')
+                    continue;
+                tools.push({
+                    name: tool.name,
+                    description: typeof tool.description === 'string' ? tool.description : undefined,
+                    inputSchema: isRecord(tool.inputSchema) ? tool.inputSchema : { type: 'object', properties: {} },
+                });
+            }
+            cursor = typeof result.nextCursor === 'string' && result.nextCursor ? result.nextCursor : undefined;
+        } while (cursor);
+        this.cachedTools = tools;
+        return tools;
+    }
+    async callTool(name, arguments_, signal) {
+        if (!this.isReady())
+            throw new Error(`MCP server ${this.name} 未连接`);
+        const result = await this.request('tools/call', { name, arguments: arguments_ }, signal);
+        return {
+            content: Array.isArray(result.content) ? result.content : [],
+            ...(result.structuredContent === undefined ? {} : { structuredContent: result.structuredContent }),
+            ...(result.isError === true ? { isError: true } : {}),
+        };
+    }
+    async close() {
+        this.closed = true;
+        this.initialized = false;
+        for (const [id] of this.pending)
+            this.fail(id, new Error('MCP client 已关闭'));
+        await this.transport.close();
+    }
+    async notify(method, params) {
+        await this.transport.send({ jsonrpc: '2.0', method, params });
+    }
+    request(method, params, signal) {
+        if (this.closed)
+            return Promise.reject(new Error('MCP client 已关闭'));
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => this.fail(id, new Error(`MCP ${method} 请求超时`)), timeoutFor(this.spec));
+            const onAbort = () => this.fail(id, new Error(`MCP ${method} 已中断`));
+            const pending = { resolve: (value) => resolve(value), reject, timer, signal, onAbort };
+            this.pending.set(id, pending);
+            if (signal) {
+                if (signal.aborted)
+                    return onAbort();
+                signal.addEventListener('abort', onAbort, { once: true });
+            }
+            void this.transport.send({ jsonrpc: '2.0', id, method, params }).catch((error) => this.fail(id, asError(error)));
+        });
+    }
+    onMessage(raw) {
+        if (!isRecord(raw) || (typeof raw.id !== 'number' && typeof raw.id !== 'string'))
+            return;
+        const id = typeof raw.id === 'number' ? raw.id : Number(raw.id);
+        if (!Number.isInteger(id) || !this.pending.has(id))
+            return;
+        if (isRecord(raw.error)) {
+            this.fail(id, new Error(typeof raw.error.message === 'string' ? raw.error.message : 'MCP JSON-RPC error'));
+        }
+        else {
+            this.succeed(id, raw.result);
+        }
+    }
+    succeed(id, value) {
+        const pending = this.pending.get(id);
+        if (!pending)
+            return;
+        this.pending.delete(id);
+        clearTimeout(pending.timer);
+        if (pending.signal && pending.onAbort)
+            pending.signal.removeEventListener('abort', pending.onAbort);
+        pending.resolve(value);
+    }
+    fail(id, error) {
+        const pending = this.pending.get(id);
+        if (!pending)
+            return;
+        this.pending.delete(id);
+        clearTimeout(pending.timer);
+        if (pending.signal && pending.onAbort)
+            pending.signal.removeEventListener('abort', pending.onAbort);
+        pending.reject(error);
+    }
+}
+function timeoutFor(spec) {
+    return spec.requestTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+}
+async function consumeSse(body, onEvent, signal) {
+    if (!body)
+        throw new Error('MCP SSE 响应没有 body');
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffered = '';
+    try {
+        while (true) {
+            if (signal?.aborted)
+                throw new Error('MCP SSE 请求已中断');
+            const { done, value } = await reader.read();
+            buffered += decoder.decode(value, { stream: !done });
+            let boundary;
+            while ((boundary = buffered.search(/\r?\n\r?\n/)) !== -1) {
+                const block = buffered.slice(0, boundary);
+                const separatorLength = buffered[boundary] === '\r' ? (buffered[boundary + 2] === '\r' ? 4 : 3) : (buffered[boundary + 1] === '\r' ? 3 : 2);
+                buffered = buffered.slice(boundary + separatorLength);
+                const event = parseSseBlock(block);
+                if (event)
+                    onEvent(event);
+            }
+            if (done)
+                break;
+        }
+        const finalEvent = parseSseBlock(buffered);
+        if (finalEvent)
+            onEvent(finalEvent);
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function parseSseBlock(block) {
+    let event = 'message';
+    const data = [];
+    for (const line of block.split(/\r?\n/)) {
+        if (line.startsWith('event:'))
+            event = line.slice(6).trim();
+        else if (line.startsWith('data:'))
+            data.push(line.slice(5).trimStart());
+    }
+    return data.length ? { event, data: data.join('\n') } : null;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function asError(value) {
+    return value instanceof Error ? value : new Error(String(value));
+}

package/dist/mcp/config.js

@@ -0,0 +1,128 @@
+import fs from 'node:fs';
+import path from 'node:path';
+/**
+ * 加载 MCP server 定义。支持 MCP_CONFIG_PATH 指向的 JSON 文件，以及 MCP_SERVERS JSON 环境变量；
+ * 后者按 server name 覆盖前者，便于把 token 仅放在本机环境变量中。
+ *
+ * JSON 格式兼容常见的 { "mcpServers": { name: { command/url/... } } }，也允许直接 server map。
+ */
+export function readMcpServers() {
+    const warnings = [];
+    const servers = new Map();
+    const fromFile = process.env.MCP_CONFIG_PATH;
+    if (fromFile) {
+        try {
+            const target = path.resolve(process.cwd(), expandEnv(fromFile));
+            mergeServerMap(JSON.parse(fs.readFileSync(target, 'utf8')), servers, warnings, target);
+        }
+        catch (error) {
+            warnings.push(`无法读取 MCP_CONFIG_PATH: ${formatError(error)}`);
+        }
+    }
+    if (process.env.MCP_SERVERS) {
+        try {
+            mergeServerMap(JSON.parse(process.env.MCP_SERVERS), servers, warnings, 'MCP_SERVERS');
+        }
+        catch (error) {
+            warnings.push(`MCP_SERVERS 不是合法 JSON: ${formatError(error)}`);
+        }
+    }
+    return { servers: Array.from(servers.values()).filter((server) => !server.disabled), warnings };
+}
+function mergeServerMap(raw, target, warnings, source) {
+    const root = isRecord(raw) && isRecord(raw.mcpServers) ? raw.mcpServers : raw;
+    if (Array.isArray(root)) {
+        for (const entry of root) {
+            if (!isRecord(entry) || typeof entry.name !== 'string') {
+                warnings.push(`${source} 中的 MCP 数组项必须含 name`);
+                continue;
+            }
+            const parsed = parseServer(entry.name, entry, source, warnings);
+            if (parsed)
+                target.set(parsed.name, parsed);
+        }
+        return;
+    }
+    if (!isRecord(root)) {
+        warnings.push(`${source} 必须是 MCP server 对象或 { mcpServers: ... }`);
+        return;
+    }
+    for (const [name, entry] of Object.entries(root)) {
+        const parsed = parseServer(name, entry, source, warnings);
+        if (parsed)
+            target.set(parsed.name, parsed);
+    }
+}
+function parseServer(name, raw, source, warnings) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$/.test(name) || !isRecord(raw)) {
+        warnings.push(`${source} 中的 MCP server 名称或配置无效: ${name}`);
+        return null;
+    }
+    const transport = normalizeTransport(raw.transport ?? raw.type, raw);
+    const requestTimeoutMs = positiveNumber(raw.requestTimeoutMs ?? raw.timeoutMs);
+    const common = { name, transport, disabled: raw.disabled === true, ...(requestTimeoutMs ? { requestTimeoutMs } : {}) };
+    if (transport === 'stdio') {
+        if (typeof raw.command !== 'string' || !raw.command.trim()) {
+            warnings.push(`${source}.${name} (stdio) 缺少 command`);
+            return null;
+        }
+        return {
+            ...common,
+            transport,
+            command: expandEnv(raw.command),
+            args: stringArray(raw.args),
+            env: stringRecord(raw.env),
+            cwd: typeof raw.cwd === 'string' ? path.resolve(process.cwd(), expandEnv(raw.cwd)) : undefined,
+        };
+    }
+    if (typeof raw.url !== 'string') {
+        warnings.push(`${source}.${name} (${transport}) 缺少 url`);
+        return null;
+    }
+    try {
+        const url = new URL(expandEnv(raw.url));
+        if (url.protocol !== 'https:' && url.protocol !== 'http:')
+            throw new Error('只允许 http 或 https URL');
+        return { ...common, transport, url: url.toString(), headers: stringRecord(raw.headers) };
+    }
+    catch (error) {
+        warnings.push(`${source}.${name} 的远程 URL 无效: ${formatError(error)}`);
+        return null;
+    }
+}
+function normalizeTransport(value, raw) {
+    if (value === 'sse')
+        return 'sse';
+    if (value === 'streamable-http' || value === 'http' || value === 'streamableHttp')
+        return 'streamable-http';
+    return typeof raw.command === 'string' ? 'stdio' : 'streamable-http';
+}
+function positiveNumber(value) {
+    const n = typeof value === 'number' ? value : Number(value);
+    return Number.isFinite(n) && n > 0 ? Math.floor(n) : undefined;
+}
+function stringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string')
+        ? value.map(expandEnv)
+        : undefined;
+}
+function stringRecord(value) {
+    if (!isRecord(value))
+        return undefined;
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (typeof item === 'string')
+            result[key] = expandEnv(item);
+    }
+    return result;
+}
+/** 展开 ${NAME}；缺失变量保留为空，避免把宿主环境变量字面量送往远端。 */
+function expandEnv(value) {
+    return value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, key) => process.env[key] ?? '');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/mcp/index.js

@@ -0,0 +1,105 @@
+import { readMcpServers } from './config.js';
+import { McpClient } from './client.js';
+const clients = new Map();
+let startupWarnings = [];
+/** 连接所有已配置 server；单个连接失败不阻断 CLI，其余 server 仍可用。 */
+export async function initializeAllMcp() {
+    await closeAllMcp();
+    const { servers, warnings } = readMcpServers();
+    startupWarnings = [...warnings];
+    const connected = [];
+    for (const spec of servers) {
+        const client = new McpClient(spec.name, spec);
+        try {
+            await client.initialize();
+            clients.set(spec.name, client);
+            connected.push(spec.name);
+        }
+        catch (error) {
+            await client.close().catch(() => undefined);
+            startupWarnings.push(`MCP ${spec.name} 连接失败: ${formatError(error)}`);
+        }
+    }
+    return { connected, warnings: [...startupWarnings] };
+}
+/** 把已发现的远程工具包装为内部 Tool；所有 MCP 工具默认 dangerous，逐次经权限面板确认。 */
+export function getMcpTools() {
+    const usedNames = new Set();
+    const tools = [];
+    for (const client of clients.values()) {
+        const serverPart = sanitizeName(client.name);
+        for (const remote of client.cachedTools) {
+            const localName = `mcp__${serverPart}__${sanitizeName(remote.name)}`;
+            if (usedNames.has(localName)) {
+                startupWarnings.push(`MCP ${client.name} 的工具 ${remote.name} 名称冲突，已忽略`);
+                continue;
+            }
+            usedNames.add(localName);
+            tools.push({
+                name: localName,
+                description: `[MCP: ${client.name}] ${remote.description || `调用 ${remote.name}`}`,
+                parameters: remote.inputSchema && typeof remote.inputSchema === 'object'
+                    ? remote.inputSchema
+                    : { type: 'object', properties: {} },
+                // 远程/本地 server 均可能读写系统或网络；协议没有副作用声明，必须保守处理。
+                risk: 'dangerous',
+                execute: async (args, ctx) => formatToolResult(await client.callTool(remote.name, args, ctx?.signal)),
+            });
+        }
+    }
+    return tools;
+}
+export async function closeAllMcp() {
+    const active = Array.from(clients.values());
+    clients.clear();
+    await Promise.allSettled(active.map((client) => client.close()));
+}
+export function getMcpWarnings() { return [...startupWarnings]; }
+function sanitizeName(name) {
+    return name.replace(/[^A-Za-z0-9_-]+/g, '_').replace(/^_+|_+$/g, '') || 'tool';
+}
+function formatToolResult(result) {
+    const parts = [];
+    for (const item of result.content) {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            parts.push(safeJson(item));
+            continue;
+        }
+        const content = item;
+        if (content.type === 'text' && typeof content.text === 'string') {
+            parts.push(content.text);
+        }
+        else if (content.type === 'image') {
+            parts.push(`[MCP image: ${typeof content.mimeType === 'string' ? content.mimeType : 'unknown'}，已省略二进制数据]`);
+        }
+        else if (content.type === 'resource_link') {
+            parts.push(`[MCP resource: ${String(content.name ?? content.uri ?? 'unknown')}]`);
+        }
+        else if (content.type === 'resource' && content.resource && typeof content.resource === 'object') {
+            const resource = content.resource;
+            parts.push(typeof resource.text === 'string' ? resource.text : `[MCP resource: ${String(resource.uri ?? 'unknown')}]`);
+        }
+        else {
+            parts.push(safeJson(content));
+        }
+    }
+    if (result.structuredContent !== undefined)
+        parts.push(`\nstructuredContent:\n${safeJson(result.structuredContent)}`);
+    const body = parts.join('\n').trim() || '(MCP 工具未返回内容)';
+    return result.isError ? `MCP 工具报告错误:\n${body}` : body;
+}
+function safeJson(value) {
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** 仅供 MCP smoke test 注入已握手的假 client；生产路径必须走 initializeAllMcp。 */
+export function __testInjectClient(client) {
+    clients.set(client.name, client);
+}

package/dist/mcp/registry.js

@@ -0,0 +1,5 @@
+/**
+ * 兼容旧的 MCP registry 导入路径；运行时注册逻辑集中在 index.ts。
+ * 保留该叶子模块也便于测试在不读取环境配置时注入已握手 client。
+ */
+export { __testInjectClient } from './index.js';

package/dist/mcp/types.js

@@ -0,0 +1 @@
+export {};