ysagc-agent 0.9.5 → 0.9.13

package/dist/mcp.js

@@ -0,0 +1,746 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpManager = exports.MCP_PREFIX = void 0;
+exports.mcpDisabled = mcpDisabled;
+exports.mcpConfigPath = mcpConfigPath;
+exports.loadMcpConfig = loadMcpConfig;
+exports.loadMcpConfigDetailed = loadMcpConfigDetailed;
+exports.mcpToolName = mcpToolName;
+exports.parseMcpToolName = parseMcpToolName;
+exports.renderMcpResult = renderMcpResult;
+exports.writeSampleMcpConfig = writeSampleMcpConfig;
+// ============================================================================
+// MCP（Model Context Protocol）客户端
+// ----------------------------------------------------------------------------
+// 为什么放在 Agent 侧而不是平台侧：MCP server 是**本机**进程（stdio），
+// 平台在服务器上，够不到用户机器上的 `npx -y @modelcontextprotocol/server-filesystem`。
+// 所以由 Agent 拉起子进程、走 JSON-RPC，再把工具清单报给平台，平台合并进工具表交给模型。
+//
+// 配置：工作区 `.ysagc/mcp.json`，格式与 Claude Desktop / Cursor 一致：
+//   { "mcpServers": { "fs": { "command": "npx", "args": ["-y", "..."], "env": {...} } } }
+//
+// 安全：
+//  - `YSAGC_MCP=0` 可整体关闭；
+//  - 启动命令过一遍 isDangerCommand，命中危险模式（rm -rf / 下载即执行 等）直接拒绝启动；
+//  - 只读权限档（read-only）下所有 mcp__* 调用被 preExecute 拦下 —— MCP 工具对我们是黑盒，
+//    无法判断它是否写文件，因此保守地当作写操作。
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const childProcess = __importStar(require("node:child_process"));
+const security_1 = require("./security");
+const MCP_REL = path.join('.ysagc', 'mcp.json');
+/** 单次 JSON-RPC 请求超时（tools/call 可能慢，给足） */
+const CALL_TIMEOUT_MS = Number(process.env.YSAGC_MCP_TIMEOUT || 60000);
+/** 握手/列举超时（server 起不来要快速失败，不要卡住整个任务） */
+const HANDSHAKE_TIMEOUT_MS = Number(process.env.YSAGC_MCP_HANDSHAKE_TIMEOUT || 20000);
+const PROTOCOL_VERSION = '2024-11-05';
+const MAX_TOOLS_PER_SERVER = Number(process.env.YSAGC_MCP_MAX_TOOLS || 64);
+function mcpDisabled() {
+    return String(process.env.YSAGC_MCP || '').trim() === '0';
+}
+function mcpConfigPath(root) {
+    return path.join(root, MCP_REL);
+}
+/** 读取工作区 MCP 配置；不存在/格式不对返回 null（不抛，避免拖垮 Agent 启动） */
+function loadMcpConfig(root) {
+    return loadMcpConfigDetailed(root).config;
+}
+/**
+ * 带原因的版本。
+ *
+ * 为什么需要它：JSON 里写 Windows 路径时 `\m` 这种是**非法转义**，JSON.parse 直接抛，
+ * 配置整个作废。以前这种情况只会表现为「一个 MCP 工具都没有」，用户完全看不出是自己
+ * 把反斜杠写错了。现在把原因带出来，经 mcp_tools 消息里的 failures 一路报到 UI。
+ */
+function loadMcpConfigDetailed(root) {
+    if (mcpDisabled())
+        return { config: null };
+    const p = mcpConfigPath(root);
+    try {
+        if (!fs.existsSync(p))
+            return { config: null };
+        let raw;
+        try {
+            raw = JSON.parse(fs.readFileSync(p, 'utf8'));
+        }
+        catch (err) {
+            return { config: null, error: `${p} 不是合法 JSON：${err?.message || err}（Windows 路径里的反斜杠要写成 \\\\）` };
+        }
+        const servers = raw?.mcpServers;
+        if (!servers || typeof servers !== 'object') {
+            return { config: null, error: `${p} 缺少 mcpServers 字段` };
+        }
+        const out = {};
+        for (const [name, cfg] of Object.entries(servers)) {
+            if (!cfg || typeof cfg !== 'object')
+                continue;
+            const command = String(cfg.command || '').trim();
+            const url = String(cfg.url || '').trim();
+            // 两个都没配 = 这条配置没法用；都配了以 url 为准（HTTP 更明确）
+            if (!command && !url)
+                continue;
+            if (url && !/^https?:\/\//i.test(url)) {
+                return { config: null, error: `${p} 里 server "${name}" 的 url 必须是 http/https：${url}` };
+            }
+            // 云元数据地址（169.254.169.254）是经典的 SSRF 打点目标，任何情况下都不该被连
+            if (/^https?:\/\/169\.254\.169\.254/i.test(url)) {
+                return { config: null, error: `${p} 里 server "${name}" 的 url 指向云元数据地址，已拒绝` };
+            }
+            out[name] = {
+                ...(url ? { url } : { command }),
+                args: Array.isArray(cfg.args) ? cfg.args.map((a) => String(a)) : [],
+                env: cfg.env && typeof cfg.env === 'object'
+                    ? Object.fromEntries(Object.entries(cfg.env).map(([k, v]) => [k, String(v)]))
+                    : undefined,
+                // 请求头支持 ${ENV} 展开：让用户把密钥放环境变量里，而不是提交进 .ysagc/mcp.json
+                headers: cfg.headers && typeof cfg.headers === 'object'
+                    ? Object.fromEntries(Object.entries(cfg.headers).map(([k, v]) => [
+                        k, String(v).replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_m, env) => process.env[env] || ''),
+                    ]))
+                    : undefined,
+                cwd: typeof cfg.cwd === 'string' ? cfg.cwd : undefined,
+                enabled: cfg.enabled !== false,
+            };
+        }
+        return Object.keys(out).length ? { config: { mcpServers: out } } : { config: null };
+    }
+    catch (err) {
+        return { config: null, error: `读取 ${p} 失败：${err?.message || err}` };
+    }
+}
+/** 工具名里的 server/tool 分隔符。用双下划线，和 Claude 的 mcp__server__tool 命名保持一致。 */
+exports.MCP_PREFIX = 'mcp__';
+/** 把 server+tool 拼成平台可见的工具名。名字里不允许再出现分隔符，否则解析会歧义。 */
+function mcpToolName(server, tool) {
+    return `${exports.MCP_PREFIX}${server}__${tool}`;
+}
+/** 反向解析；不是 mcp__ 前缀或格式不对返回 null */
+function parseMcpToolName(name) {
+    if (!name.startsWith(exports.MCP_PREFIX))
+        return null;
+    const rest = name.slice(exports.MCP_PREFIX.length);
+    const i = rest.indexOf('__');
+    if (i <= 0 || i >= rest.length - 2)
+        return null;
+    return { server: rest.slice(0, i), tool: rest.slice(i + 2) };
+}
+/** 一个 MCP server（stdio 子进程 或 HTTP 端点）+ 它的 JSON-RPC 通道 */
+class McpClient {
+    constructor(name, cfg, root) {
+        this.child = null;
+        this.buf = '';
+        this.nextId = 1;
+        this.pending = new Map();
+        this.ready = null;
+        this.tools = [];
+        this.closed = false;
+        /** HTTP 传输：POST 目标地址（旧版 SSE 握手后会拿到一个独立的 endpoint） */
+        this.httpEndpoint = '';
+        /** HTTP 传输：正在读的 SSE 响应流（旧版 SSE 用它收所有响应） */
+        this.sseReader = null;
+        this.sseAbort = null;
+        this.name = name;
+        this.cfg = cfg;
+        this.root = root;
+    }
+    get isHttp() {
+        return !!this.cfg.url;
+    }
+    get toolDefs() {
+        return this.tools;
+    }
+    get alive() {
+        if (this.isHttp)
+            return !this.closed;
+        return !!this.child && !this.closed && this.child.exitCode === null;
+    }
+    /** 启动子进程并完成 initialize 握手（幂等：并发调用共享同一个 Promise） */
+    start(log) {
+        if (this.ready)
+            return this.ready;
+        this.ready = this.doStart(log).catch((err) => {
+            // 失败不缓存，下次调用可以重试（比如用户刚把依赖装上）
+            this.ready = null;
+            throw err;
+        });
+        return this.ready;
+    }
+    async doStart(log) {
+        const cfg = this.cfg;
+        if (cfg.url)
+            return this.doStartHttp(log);
+        // 危险命令闸门：MCP server 是本机任意进程，命令串命中危险模式就不启动。
+        // 只做「命令串」层面的判断 —— 它拦不住恶意的合法程序，但能挡住最典型的一类配置。
+        const cmdline = [cfg.command, ...(cfg.args || [])].join(' ');
+        const danger = (0, security_1.isDangerCommand)(cmdline);
+        if (danger.danger) {
+            throw new Error(`MCP server "${this.name}" 的启动命令被安全策略拒绝（${danger.reason}）`);
+        }
+        // cwd：显式配置按「工作区根」解析相对路径（不是 Agent 进程目录 —— 那是安装目录，
+        // server 写相对路径文件会落到 Agent 自己的文件夹里，用户找不到）；
+        // 没配置就用工作区根，这也符合「MCP 配置属于工作区」的直觉。
+        const cwd = cfg.cwd ? path.resolve(this.root, cfg.cwd) : this.root;
+        // 走到这里 cfg.command 一定有值（没配 command 的 server 在读取配置时就被过滤掉了），
+        // 但 TS 看不到那层约束，显式取一次更清楚。
+        const command = String(cfg.command || '');
+        // Windows 上 npx/uvx 是 .cmd 批处理，直接 spawn 会 ENOENT；shell 模式让系统自己解析。
+        const needShell = process.platform === 'win32' && !/\.(exe|cmd|bat|com)$/i.test(command);
+        const child = childProcess.spawn(command, cfg.args || [], {
+            cwd,
+            shell: needShell,
+            env: { ...process.env, ...(cfg.env || {}) },
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        this.child = child;
+        child.stdout?.setEncoding('utf8');
+        child.stdout?.on('data', (chunk) => this.onData(chunk));
+        child.stderr?.setEncoding('utf8');
+        child.stderr?.on('data', (chunk) => {
+            const s = String(chunk).trim();
+            if (s)
+                log?.(`[mcp:${this.name}] ${s.slice(0, 400)}`);
+        });
+        child.on('error', (err) => this.failAll(new Error(`MCP server "${this.name}" 启动失败：${err.message}`)));
+        child.on('exit', (code) => {
+            this.closed = true;
+            this.failAll(new Error(`MCP server "${this.name}" 已退出（code=${code}）`));
+        });
+        const init = await this.request('initialize', {
+            protocolVersion: PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: { name: 'ysagc-agent', version: '1' },
+        }, HANDSHAKE_TIMEOUT_MS);
+        if (!init || typeof init !== 'object') {
+            throw new Error(`MCP server "${this.name}" initialize 返回异常`);
+        }
+        // 通知（无 id、无响应）：告诉 server 客户端准备好了
+        this.notify('notifications/initialized', {});
+        const listed = await this.request('tools/list', {}, HANDSHAKE_TIMEOUT_MS);
+        const arr = Array.isArray(listed?.tools) ? listed.tools : [];
+        this.tools = arr.slice(0, MAX_TOOLS_PER_SERVER).map((t) => ({
+            name: mcpToolName(this.name, String(t?.name || '')),
+            server: this.name,
+            tool: String(t?.name || ''),
+            description: String(t?.description || '').slice(0, 1000),
+            inputSchema: (t?.inputSchema && typeof t.inputSchema === 'object')
+                ? t.inputSchema
+                : { type: 'object', properties: {} },
+        })).filter((t) => t.tool);
+        log?.(`[mcp:${this.name}] 已连接，暴露 ${this.tools.length} 个工具`);
+    }
+    /** 逐行 JSON 解析：MCP 走 stdio 时用换行分隔的 JSON-RPC 帧 */
+    onData(chunk) {
+        this.buf += chunk;
+        let nl = this.buf.indexOf('\n');
+        while (nl >= 0) {
+            const line = this.buf.slice(0, nl).trim();
+            this.buf = this.buf.slice(nl + 1);
+            if (line)
+                this.onLine(line);
+            nl = this.buf.indexOf('\n');
+        }
+        // 防御：单个超长帧（server 打日志忘了换行）不能把内存吃干
+        if (this.buf.length > 4 * 1024 * 1024)
+            this.buf = '';
+    }
+    onLine(line) {
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            return;
+        } // 非 JSON 行 = server 的日志输出，忽略
+        if (!msg || typeof msg !== 'object')
+            return;
+        if (msg.id === undefined || msg.id === null)
+            return; // 通知，忽略
+        const p = this.pending.get(Number(msg.id));
+        if (!p)
+            return;
+        this.pending.delete(Number(msg.id));
+        clearTimeout(p.timer);
+        if (msg.error)
+            p.reject(new Error(String(msg.error?.message || 'MCP 调用失败')));
+        else
+            p.resolve(msg.result);
+    }
+    write(obj) {
+        if (!this.child?.stdin || this.closed)
+            throw new Error(`MCP server "${this.name}" 未运行`);
+        this.child.stdin.write(JSON.stringify(obj) + '\n');
+    }
+    notify(method, params) {
+        if (this.isHttp) {
+            void this.httpNotify(method, params);
+            return;
+        }
+        try {
+            this.write({ jsonrpc: '2.0', method, params });
+        }
+        catch { /* 忽略 */ }
+    }
+    request(method, params, timeoutMs) {
+        // 按传输方式分流：HTTP 走 fetch，stdio 走子进程 stdin。
+        // （踩过：call() 一律走这里，结果 HTTP server 被当成子进程，报「未运行」。）
+        if (this.isHttp)
+            return this.httpRequest(method, params, timeoutMs);
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`MCP ${method} 超时（${timeoutMs}ms）`));
+            }, timeoutMs);
+            timer.unref?.();
+            this.pending.set(id, { resolve, reject, timer });
+            try {
+                this.write({ jsonrpc: '2.0', id, method, params });
+            }
+            catch (err) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(err instanceof Error ? err : new Error(String(err)));
+            }
+        });
+    }
+    failAll(err) {
+        for (const [, p] of this.pending) {
+            clearTimeout(p.timer);
+            p.reject(err);
+        }
+        this.pending.clear();
+    }
+    /** 调用某个工具，返回 MCP 的原始 result（content 数组等） */
+    async call(tool, args) {
+        await this.start();
+        return this.request('tools/call', { name: tool, arguments: args }, CALL_TIMEOUT_MS);
+    }
+    stop() {
+        this.closed = true;
+        this.failAll(new Error(`MCP server "${this.name}" 已关闭`));
+        try {
+            this.child?.kill();
+        }
+        catch { /* 忽略 */ }
+        this.child = null;
+        try {
+            this.sseAbort?.abort();
+        }
+        catch { /* 忽略 */ }
+        this.sseAbort = null;
+        this.sseReader = null;
+    }
+    // ===== HTTP 传输（Streamable HTTP / 旧版 SSE）=====
+    /**
+     * 两种 HTTP 形态，靠一次探测自动区分：
+     *  - **Streamable HTTP**（2025-03-26）：所有请求都 POST 到同一个 url，
+     *    响应可能是 application/json，也可能是 text/event-stream（SSE 流里带结果）。
+     *  - **旧版 SSE**（2024-11-05）：先 GET url 建一条长连接，服务端先发一个 `endpoint` 事件
+     *    告诉客户端「POST 到哪」，之后的响应都从这条 GET 流里回来。
+     *
+     * 先按 Streamable 试；如果服务端回的是 SSE 且给了 endpoint，就切到旧版 SSE 模式。
+     */
+    async doStartHttp(log) {
+        const url = String(this.cfg.url || '');
+        const headers = {
+            'Content-Type': 'application/json',
+            Accept: 'application/json, text/event-stream',
+            ...(this.cfg.headers || {}),
+        };
+        this.httpEndpoint = url;
+        // 旧版 SSE：先开长连接拿 endpoint（失败不致命，Streamable 可能直接可用）
+        await this.openSseIfNeeded(url, headers, log).catch(() => { });
+        const init = await this.httpRequest('initialize', {
+            protocolVersion: PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: { name: 'ysagc-agent', version: '1' },
+        }, HANDSHAKE_TIMEOUT_MS);
+        if (!init || typeof init !== 'object') {
+            throw new Error(`MCP server "${this.name}" initialize 返回异常`);
+        }
+        await this.httpNotify('notifications/initialized', {});
+        const listed = await this.httpRequest('tools/list', {}, HANDSHAKE_TIMEOUT_MS);
+        const arr = Array.isArray(listed?.tools) ? listed.tools : [];
+        this.tools = arr.slice(0, MAX_TOOLS_PER_SERVER).map((t) => ({
+            name: mcpToolName(this.name, String(t?.name || '')),
+            server: this.name,
+            tool: String(t?.name || ''),
+            description: String(t?.description || '').slice(0, 1000),
+            inputSchema: (t?.inputSchema && typeof t.inputSchema === 'object')
+                ? t.inputSchema
+                : { type: 'object', properties: {} },
+        })).filter((t) => t.tool);
+        log?.(`[mcp:${this.name}] HTTP 已连接（${this.httpEndpoint === url ? 'Streamable HTTP' : 'SSE'}），暴露 ${this.tools.length} 个工具`);
+    }
+    /** 探测旧版 SSE：拿到 endpoint 就切过去 */
+    async openSseIfNeeded(url, headers, log) {
+        const ctrl = new AbortController();
+        const res = await fetch(url, {
+            method: 'GET',
+            headers: { ...headers, Accept: 'text/event-stream' },
+            signal: ctrl.signal,
+        });
+        const ctype = String(res.headers.get('content-type') || '');
+        if (!res.ok || !ctype.includes('text/event-stream') || !res.body) {
+            ctrl.abort();
+            return; // 不是 SSE：交给 Streamable 路径
+        }
+        this.sseAbort = ctrl;
+        this.sseReader = res.body.getReader();
+        // 从流里读第一个 endpoint 事件（其余响应交给 pumpSse 一直读）
+        const endpoint = await this.readEndpointFromSse(this.sseReader, ctrl.signal);
+        if (endpoint) {
+            this.httpEndpoint = new URL(endpoint, url).toString();
+            log?.(`[mcp:${this.name}] 检测到旧版 SSE 传输，POST 目标 ${this.httpEndpoint}`);
+        }
+        // 后台持续读这条流：旧版 SSE 的所有响应都从这里回来
+        void this.pumpSse();
+    }
+    /** 读 SSE 流直到出现 endpoint 事件（或超时） */
+    async readEndpointFromSse(reader, signal) {
+        const dec = new TextDecoder();
+        let buf = '';
+        const deadline = Date.now() + Math.min(HANDSHAKE_TIMEOUT_MS, 8000);
+        while (Date.now() < deadline && !signal.aborted) {
+            const { value, done } = await reader.read().catch(() => ({ value: undefined, done: true }));
+            if (done || !value)
+                return '';
+            buf += dec.decode(value, { stream: true });
+            const blocks = buf.split('\n\n');
+            buf = blocks.pop() || '';
+            for (const b of blocks) {
+                const ev = /^event:\s*(.+)$/m.exec(b)?.[1]?.trim();
+                const data = b.split('\n').filter((l) => l.startsWith('data:')).map((l) => l.slice(5).trim()).join('');
+                if (ev === 'endpoint' && data)
+                    return data;
+            }
+        }
+        return '';
+    }
+    /** 持续读 SSE 流，把 JSON-RPC 响应分发给等待者 */
+    async pumpSse() {
+        const reader = this.sseReader;
+        if (!reader)
+            return;
+        const dec = new TextDecoder();
+        let buf = '';
+        try {
+            for (;;) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                buf += dec.decode(value, { stream: true });
+                const blocks = buf.split('\n\n');
+                buf = blocks.pop() || '';
+                for (const b of blocks) {
+                    const data = b.split('\n').filter((l) => l.startsWith('data:')).map((l) => l.slice(5).trim()).join('');
+                    if (data)
+                        this.onLine(data);
+                }
+            }
+        }
+        catch { /* 流断开：等待者会各自超时 */ }
+    }
+    /** 发一个 JSON-RPC 请求（HTTP 传输） */
+    async httpRequest(method, params, timeoutMs) {
+        const id = this.nextId++;
+        const body = { jsonrpc: '2.0', id, method, params };
+        const res = await fetch(this.httpEndpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json, text/event-stream',
+                ...(this.cfg.headers || {}),
+            },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (res.status === 202 || res.status === 204) {
+            // Streamable HTTP 允许「202 Accepted，结果稍后从 SSE 流回来」
+            return this.waitPending(id, method, timeoutMs);
+        }
+        if (!res.ok) {
+            throw new Error(`MCP server "${this.name}" 返回 HTTP ${res.status}${await res.text().then((t) => (t ? `：${t.slice(0, 200)}` : '')).catch(() => '')}`);
+        }
+        const ctype = String(res.headers.get('content-type') || '');
+        if (ctype.includes('text/event-stream') && res.body) {
+            // 响应本身就是一条 SSE 流：读到我们那个 id 的结果为止
+            const dec = new TextDecoder();
+            const reader = res.body.getReader();
+            let buf = '';
+            const deadline = Date.now() + timeoutMs;
+            try {
+                while (Date.now() < deadline) {
+                    const { value, done } = await reader.read();
+                    if (done)
+                        break;
+                    buf += dec.decode(value, { stream: true });
+                    const blocks = buf.split('\n\n');
+                    buf = blocks.pop() || '';
+                    for (const b of blocks) {
+                        const data = b.split('\n').filter((l) => l.startsWith('data:')).map((l) => l.slice(5).trim()).join('');
+                        if (!data)
+                            continue;
+                        let msg;
+                        try {
+                            msg = JSON.parse(data);
+                        }
+                        catch {
+                            continue;
+                        }
+                        if (Number(msg?.id) === id) {
+                            if (msg.error)
+                                throw new Error(String(msg.error?.message || 'MCP 调用失败'));
+                            return msg.result;
+                        }
+                    }
+                }
+            }
+            finally {
+                try {
+                    reader.cancel();
+                }
+                catch { /* 忽略 */ }
+            }
+            throw new Error(`MCP ${method} 的 SSE 响应里没有等到结果`);
+        }
+        const text = await res.text();
+        let msg;
+        try {
+            msg = JSON.parse(text);
+        }
+        catch {
+            throw new Error(`MCP server "${this.name}" 返回了非 JSON 响应：${text.slice(0, 200)}`);
+        }
+        if (msg?.error)
+            throw new Error(String(msg.error?.message || 'MCP 调用失败'));
+        return msg?.result;
+    }
+    /** 等一个已在 pending 里的 id（Streamable HTTP 的 202 场景） */
+    waitPending(id, method, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`MCP ${method} 超时（${timeoutMs}ms）`));
+            }, timeoutMs);
+            timer.unref?.();
+            this.pending.set(id, { resolve, reject, timer });
+        });
+    }
+    async httpNotify(method, params) {
+        try {
+            await fetch(this.httpEndpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Accept: 'application/json, text/event-stream',
+                    ...(this.cfg.headers || {}),
+                },
+                body: JSON.stringify({ jsonrpc: '2.0', method, params }),
+                signal: AbortSignal.timeout(5000),
+            });
+        }
+        catch { /* 通知发不出去不影响主流程 */ }
+    }
+}
+/**
+ * 一个工作区对应一个 Manager：懒启动、缓存工具清单。
+ * 配置变化（mtime 变了）时整体重启 —— MCP server 不支持热加载，重建是最稳的做法。
+ */
+class McpManager {
+    constructor(root, log) {
+        this.clients = new Map();
+        this.errors = new Map();
+        this.loadedMtime = -1;
+        this.starting = null;
+        this.root = root;
+        this.log = log;
+    }
+    configMtime() {
+        try {
+            return fs.statSync(mcpConfigPath(this.root)).mtimeMs;
+        }
+        catch {
+            return -1;
+        }
+    }
+    /** 确保按当前配置把所有 server 拉起来（幂等） */
+    async ensure() {
+        if (mcpDisabled())
+            return;
+        const mtime = this.configMtime();
+        if (mtime < 0) {
+            // 配置文件被删了：停掉已有连接，清空工具表
+            if (this.clients.size)
+                this.reset();
+            return;
+        }
+        if (mtime === this.loadedMtime && this.starting)
+            return this.starting;
+        if (mtime === this.loadedMtime)
+            return;
+        if (this.starting)
+            return this.starting;
+        this.loadedMtime = mtime;
+        this.starting = this.doEnsure().finally(() => { this.starting = null; });
+        return this.starting;
+    }
+    async doEnsure() {
+        const loaded = loadMcpConfigDetailed(this.root);
+        // 配置变了 → 全部重启，避免「旧 server 还在跑、新配置没生效」的混乱状态
+        this.reset();
+        if (loaded.error) {
+            // 配置坏了要让人知道：否则表现只是「工具凭空消失」，用户会以为是平台的问题
+            this.errors.set('(config)', loaded.error);
+            this.log?.(`[mcp] 配置无效：${loaded.error}`);
+            return;
+        }
+        const cfg = loaded.config;
+        if (!cfg)
+            return;
+        const jobs = Object.entries(cfg.mcpServers)
+            .filter(([, c]) => c.enabled !== false)
+            .map(async ([name, c]) => {
+            const client = new McpClient(name, c, this.root);
+            this.clients.set(name, client);
+            try {
+                await client.start(this.log);
+            }
+            catch (err) {
+                const msg = err?.message || String(err);
+                this.errors.set(name, msg);
+                this.log?.(`[mcp:${name}] 启动失败：${msg}`);
+                this.clients.delete(name);
+                try {
+                    client.stop();
+                }
+                catch { /* 忽略 */ }
+            }
+        });
+        await Promise.all(jobs);
+    }
+    reset() {
+        for (const [, c] of this.clients) {
+            try {
+                c.stop();
+            }
+            catch { /* 忽略 */ }
+        }
+        this.clients.clear();
+        this.errors.clear();
+    }
+    /** 平台可见的工具清单（已带 mcp__server__tool 名字） */
+    async listTools() {
+        await this.ensure();
+        const out = [];
+        for (const [, c] of this.clients)
+            out.push(...c.toolDefs);
+        return out;
+    }
+    /** 启动失败的 server 及其原因（用于在工具清单里如实说明，而不是静默消失） */
+    failures() {
+        return [...this.errors.entries()].map(([server, error]) => ({ server, error }));
+    }
+    /** 按平台工具名分发一次 MCP 调用 */
+    async callByName(name, args) {
+        const parsed = parseMcpToolName(name);
+        if (!parsed)
+            throw new Error(`不是合法的 MCP 工具名：${name}`);
+        await this.ensure();
+        const client = this.clients.get(parsed.server);
+        if (!client) {
+            const why = this.errors.get(parsed.server);
+            throw new Error(why
+                ? `MCP server "${parsed.server}" 不可用：${why}`
+                : `MCP server "${parsed.server}" 未配置或未启动`);
+        }
+        return client.call(parsed.tool, args);
+    }
+    /** 进程退出时收尾（Agent 关闭时调用） */
+    shutdown() {
+        this.reset();
+    }
+}
+exports.McpManager = McpManager;
+/**
+ * 把 MCP 的 tools/call 结果压成模型好读的文本。
+ * MCP 返回 { content: [{type:'text', text} | {type:'image', data, mimeType}], isError? }，
+ * 图片没法直接塞进文本结果，用占位说明代替（否则模型会以为拿到了空结果）。
+ */
+function renderMcpResult(result) {
+    const isError = result?.isError === true;
+    const parts = [];
+    const content = Array.isArray(result?.content) ? result.content : [];
+    for (const c of content) {
+        if (!c || typeof c !== 'object')
+            continue;
+        if (c.type === 'text')
+            parts.push(String(c.text ?? ''));
+        else if (c.type === 'image')
+            parts.push(`[图片内容 ${c.mimeType || 'image'}，${Math.round(String(c.data || '').length / 1024)}KB，未在本通道内联展示]`);
+        else if (c.type === 'resource')
+            parts.push(`[资源 ${c.resource?.uri || ''}]`);
+        else
+            parts.push(`[${c.type}]`);
+    }
+    let text = parts.join('\n').trim();
+    if (!text) {
+        // 有的 server 把结构化数据放在 structuredContent 里
+        text = result?.structuredContent ? JSON.stringify(result.structuredContent) : '';
+    }
+    if (!text)
+        text = '（该 MCP 工具没有返回任何内容）';
+    return { ok: !isError, text };
+}
+/** 给工作区写一份示例配置（用户点「添加 MCP」时用） */
+function writeSampleMcpConfig(root) {
+    const p = mcpConfigPath(root);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    if (!fs.existsSync(p)) {
+        fs.writeFileSync(p, JSON.stringify({
+            mcpServers: {
+                filesystem: {
+                    command: 'npx',
+                    args: ['-y', '@modelcontextprotocol/server-filesystem', '.'],
+                    enabled: false,
+                },
+            },
+        }, null, 2) + '\n', 'utf8');
+    }
+    return p;
+}
+//# sourceMappingURL=mcp.js.map