u1s1-cli 1.7.0 → 1.8.0

package/dist/mcp/client.js

@@ -0,0 +1,452 @@
+import { spawn } from "node:child_process";
+import { VERSION } from "../config.js";
+/**
+ * 极简 MCP 客户端:只做 initialize / tools/list / tools/call 三件事,
+ * 支持 stdio(本机进程,按行 JSON-RPC)和 Streamable HTTP(POST JSON,
+ * 响应可能是 JSON 也可能是 SSE)两种传输。不引 SDK:pi 本身没有 MCP client,
+ * 我们只需要把远端工具挂成 pi 工具,协议面很窄,自己写反而少一坨依赖。
+ */
+export const MCP_PROTOCOL_VERSION = "2025-06-18";
+export const DEFAULT_CONNECT_TIMEOUT_MS = 20_000;
+export const DEFAULT_CALL_TIMEOUT_MS = 120_000;
+export class McpError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "McpError";
+    }
+}
+/** 谁先到算谁的:结果、超时、取消三者任一落定就清掉定时器与监听,别让悬着的定时器吊住进程 */
+function withTimeout(promise, timeoutMs, signal, what) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (fn) => (v) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+            fn(v);
+        };
+        const onAbort = () => finish(reject)(new McpError(`${what} 已取消`));
+        const timer = setTimeout(() => finish(reject)(new McpError(`${what} 超过 ${Math.round(timeoutMs / 1000)}s 未响应`)), timeoutMs);
+        promise.then(finish(resolve), finish(reject));
+        if (signal?.aborted)
+            onAbort();
+        else
+            signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+// ---------------- stdio ----------------
+class StdioTransport {
+    command;
+    args;
+    env;
+    onLog;
+    child;
+    buffer = "";
+    pending = new Map();
+    exited;
+    stderrTail = [];
+    constructor(command, args, env, onLog) {
+        this.command = command;
+        this.args = args;
+        this.env = env;
+        this.onLog = onLog;
+    }
+    start() {
+        const child = spawn(this.command, this.args, {
+            env: { ...process.env, ...this.env },
+            stdio: ["pipe", "pipe", "pipe"],
+            // Windows 上 npx / *.cmd 只能经 shell 启动
+            shell: process.platform === "win32",
+            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) => {
+            for (const line of chunk.split(/\r?\n/)) {
+                if (!line.trim())
+                    continue;
+                this.stderrTail.push(line);
+                if (this.stderrTail.length > 20)
+                    this.stderrTail.shift();
+                this.onLog?.(line);
+            }
+        });
+        // CLI 自己退出时把服务进程一起带走,别留孤儿
+        const onParentExit = () => {
+            try {
+                child.kill("SIGKILL");
+            }
+            catch { }
+        };
+        process.once("exit", onParentExit);
+        child.on("error", (err) => {
+            // spawn 失败(ENOENT 等)不会再有 exit 事件
+            if (child.pid === undefined)
+                process.removeListener("exit", onParentExit);
+            this.fail(new McpError(`启动 ${this.command} 失败:${err.message}`));
+        });
+        child.on("exit", (code, sig) => {
+            process.removeListener("exit", onParentExit);
+            const tail = this.stderrTail.slice(-5).join("\n");
+            this.fail(new McpError(`MCP 服务进程已退出(${sig ?? `code ${code ?? 0}`})${tail ? `\n${tail}` : ""}`));
+        });
+    }
+    fail(err) {
+        if (this.exited)
+            return;
+        this.exited = err;
+        for (const p of this.pending.values())
+            p.reject(err);
+        this.pending.clear();
+    }
+    onData(chunk) {
+        this.buffer += chunk;
+        let idx = this.buffer.indexOf("\n");
+        while (idx >= 0) {
+            const line = this.buffer.slice(0, idx).trim();
+            this.buffer = this.buffer.slice(idx + 1);
+            if (line)
+                this.onLine(line);
+            idx = this.buffer.indexOf("\n");
+        }
+    }
+    onLine(line) {
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            this.onLog?.(line);
+            return;
+        }
+        if (msg.id !== undefined && msg.method === undefined) {
+            const p = this.pending.get(msg.id);
+            if (p) {
+                this.pending.delete(msg.id);
+                p.resolve(msg);
+            }
+            return;
+        }
+        if (msg.id !== undefined && msg.method) {
+            // 服务端反向请求(sampling / roots 等)不支持,回一个 method not found 免得它挂着
+            this.write({ jsonrpc: "2.0", id: msg.id, error: { code: -32601, message: `Method not supported by u1s1: ${msg.method}` } });
+        }
+    }
+    write(msg) {
+        if (this.exited)
+            throw this.exited;
+        const stdin = this.child?.stdin;
+        if (!stdin || stdin.destroyed)
+            throw new McpError("MCP 服务进程 stdin 已关闭");
+        stdin.write(`${JSON.stringify(msg)}\n`);
+    }
+    request(msg, timeoutMs, signal) {
+        const id = msg.id;
+        const promise = new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            try {
+                this.write(msg);
+            }
+            catch (err) {
+                this.pending.delete(id);
+                reject(err);
+            }
+        });
+        return withTimeout(promise, timeoutMs, signal, msg.method ?? "请求").finally(() => this.pending.delete(id));
+    }
+    async notify(msg) {
+        this.write(msg);
+    }
+    async close() {
+        const child = this.child;
+        if (!child)
+            return;
+        this.fail(new McpError("MCP 连接已关闭"));
+        try {
+            child.stdin?.end();
+        }
+        catch { }
+        // 没 pid = 根本没启动起来(spawn error),不会有 exit 事件,别等
+        if (child.pid !== undefined && child.exitCode === null && child.signalCode === null) {
+            await new Promise((resolve) => {
+                const done = () => {
+                    clearTimeout(soft);
+                    clearTimeout(hard);
+                    resolve();
+                };
+                child.once("exit", done);
+                child.kill();
+                const soft = setTimeout(() => child.kill("SIGKILL"), 2_000);
+                const hard = setTimeout(done, 3_000);
+            });
+        }
+    }
+}
+// ---------------- Streamable HTTP ----------------
+/** 解析 SSE 正文,返回每个 event 的 data 拼接结果 */
+export function parseSseData(body) {
+    const out = [];
+    let data = [];
+    for (const rawLine of body.split(/\r?\n/)) {
+        if (rawLine === "") {
+            if (data.length)
+                out.push(data.join("\n"));
+            data = [];
+            continue;
+        }
+        if (rawLine.startsWith(":"))
+            continue;
+        const idx = rawLine.indexOf(":");
+        const field = idx === -1 ? rawLine : rawLine.slice(0, idx);
+        if (field !== "data")
+            continue;
+        let value = idx === -1 ? "" : rawLine.slice(idx + 1);
+        if (value.startsWith(" "))
+            value = value.slice(1);
+        data.push(value);
+    }
+    if (data.length)
+        out.push(data.join("\n"));
+    return out;
+}
+class HttpTransport {
+    url;
+    headers;
+    sessionId;
+    protocolVersion;
+    constructor(url, headers) {
+        this.url = url;
+        this.headers = headers;
+    }
+    setProtocolVersion(v) {
+        this.protocolVersion = v;
+    }
+    buildHeaders() {
+        const h = {
+            "content-type": "application/json",
+            accept: "application/json, text/event-stream",
+            ...this.headers,
+        };
+        if (this.sessionId)
+            h["mcp-session-id"] = this.sessionId;
+        if (this.protocolVersion)
+            h["mcp-protocol-version"] = this.protocolVersion;
+        return h;
+    }
+    async post(msg, timeoutMs, signal) {
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+        const onAbort = () => ctrl.abort();
+        signal?.addEventListener("abort", onAbort, { once: true });
+        try {
+            return await fetch(this.url, { method: "POST", headers: this.buildHeaders(), body: JSON.stringify(msg), signal: ctrl.signal });
+        }
+        catch (err) {
+            if (signal?.aborted)
+                throw new McpError(`${msg.method ?? "请求"} 已取消`);
+            if (ctrl.signal.aborted)
+                throw new McpError(`${msg.method ?? "请求"} 超过 ${Math.round(timeoutMs / 1000)}s 未响应`);
+            throw new McpError(`连接 ${this.url} 失败:${err.message}`);
+        }
+        finally {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+        }
+    }
+    async request(msg, timeoutMs, signal) {
+        const resp = await this.post(msg, timeoutMs, signal);
+        const sid = resp.headers.get("mcp-session-id");
+        if (sid)
+            this.sessionId = sid;
+        if (!resp.ok) {
+            const text = (await resp.text().catch(() => "")).slice(0, 300);
+            if (resp.status === 401 || resp.status === 403) {
+                throw new McpError(`服务拒绝访问(HTTP ${resp.status}),请检查 headers 里的鉴权信息${text ? `:${text}` : ""}`, resp.status);
+            }
+            throw new McpError(`HTTP ${resp.status}${text ? `:${text}` : ""}`, resp.status);
+        }
+        const ctype = (resp.headers.get("content-type") ?? "").toLowerCase();
+        const body = await resp.text();
+        const candidates = ctype.includes("text/event-stream") ? parseSseData(body) : [body];
+        for (const raw of candidates) {
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch {
+                continue;
+            }
+            const list = Array.isArray(parsed) ? parsed : [parsed];
+            for (const item of list) {
+                const m = item;
+                if (m && m.id === msg.id && m.method === undefined)
+                    return m;
+            }
+        }
+        throw new McpError(`服务没有返回 ${msg.method ?? "请求"} 的结果(content-type ${ctype || "unknown"})`);
+    }
+    async notify(msg) {
+        const resp = await this.post(msg, 10_000);
+        // 规范要求 202;有些实现回 200/204,都当成功。鉴权失败要冒出来
+        if (resp.status === 401 || resp.status === 403)
+            throw new McpError(`服务拒绝访问(HTTP ${resp.status})`, resp.status);
+        await resp.body?.cancel().catch(() => { });
+    }
+    async close() {
+        if (!this.sessionId)
+            return;
+        try {
+            await fetch(this.url, { method: "DELETE", headers: this.buildHeaders(), signal: AbortSignal.timeout(3_000) });
+        }
+        catch { }
+        this.sessionId = undefined;
+    }
+}
+// ---------------- client ----------------
+/** 把 tools/call 返回的 content 数组压成模型可读的文本 */
+export function contentToText(result) {
+    const rec = asRecord(result) ?? {};
+    const parts = [];
+    const content = Array.isArray(rec["content"]) ? rec["content"] : [];
+    for (const raw of content) {
+        const item = asRecord(raw);
+        if (!item)
+            continue;
+        const type = item["type"];
+        if (type === "text" && typeof item["text"] === "string") {
+            parts.push(item["text"]);
+        }
+        else if (type === "image" || type === "audio") {
+            const data = typeof item["data"] === "string" ? item["data"] : "";
+            parts.push(`[${type} ${String(item["mimeType"] ?? "")} ${Buffer.from(data, "base64").length} bytes, omitted]`);
+        }
+        else if (type === "resource") {
+            const res = asRecord(item["resource"]);
+            if (res && typeof res["text"] === "string")
+                parts.push(res["text"]);
+            else
+                parts.push(`[resource ${String(res?.["uri"] ?? "")} (binary, omitted)]`);
+        }
+        else if (type === "resource_link") {
+            parts.push(`[link] ${String(item["uri"] ?? "")}${item["name"] ? ` ${String(item["name"])}` : ""}`);
+        }
+    }
+    if (parts.length === 0 && rec["structuredContent"] !== undefined) {
+        parts.push(JSON.stringify(rec["structuredContent"], null, 2));
+    }
+    return { text: parts.join("\n").trim(), isError: rec["isError"] === true };
+}
+export function normalizeToolInfo(raw) {
+    const rec = asRecord(raw);
+    if (!rec || typeof rec["name"] !== "string" || !rec["name"])
+        return undefined;
+    const schema = asRecord(rec["inputSchema"]) ?? { type: "object", properties: {} };
+    return {
+        name: rec["name"],
+        description: typeof rec["description"] === "string" ? rec["description"] : "",
+        inputSchema: { ...schema, type: "object" },
+    };
+}
+export class McpClient {
+    name;
+    config;
+    opts;
+    transport;
+    nextId = 1;
+    connectTimeoutMs;
+    callTimeoutMs;
+    connected;
+    info;
+    constructor(name, config, opts = {}) {
+        this.name = name;
+        this.config = config;
+        this.opts = opts;
+        this.connectTimeoutMs = opts.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+        this.callTimeoutMs = opts.callTimeoutMs ?? DEFAULT_CALL_TIMEOUT_MS;
+    }
+    /** 建连并完成 initialize 握手;重复调用返回同一个 promise,失败后可重试 */
+    connect() {
+        if (!this.connected) {
+            this.connected = this.doConnect().catch(async (err) => {
+                this.connected = undefined;
+                await this.close().catch(() => { });
+                throw err;
+            });
+        }
+        return this.connected;
+    }
+    async doConnect() {
+        const transport = this.config.type === "stdio"
+            ? new StdioTransport(this.config.command, this.config.args, this.config.env, this.opts.onLog)
+            : new HttpTransport(this.config.url, this.config.headers);
+        if (transport instanceof StdioTransport)
+            transport.start();
+        this.transport = transport;
+        const result = await this.rpc("initialize", {
+            protocolVersion: MCP_PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: { name: "u1s1", version: VERSION },
+        }, this.connectTimeoutMs);
+        const rec = asRecord(result) ?? {};
+        const serverInfo = asRecord(rec["serverInfo"]);
+        const protocolVersion = typeof rec["protocolVersion"] === "string" ? rec["protocolVersion"] : MCP_PROTOCOL_VERSION;
+        if (transport instanceof HttpTransport)
+            transport.setProtocolVersion(protocolVersion);
+        await transport.notify({ jsonrpc: "2.0", method: "notifications/initialized" });
+        this.info = {
+            serverName: typeof serverInfo?.["name"] === "string" ? serverInfo["name"] : undefined,
+            serverVersion: typeof serverInfo?.["version"] === "string" ? serverInfo["version"] : undefined,
+            protocolVersion,
+        };
+        return this.info;
+    }
+    async rpc(method, params, timeoutMs, signal) {
+        const transport = this.transport;
+        if (!transport)
+            throw new McpError("尚未连接");
+        const id = this.nextId++;
+        const resp = await transport.request({ jsonrpc: "2.0", id, method, params }, timeoutMs, signal);
+        if (resp.error) {
+            throw new McpError(`${resp.error.message}${resp.error.data !== undefined ? ` ${JSON.stringify(resp.error.data).slice(0, 300)}` : ""}`, resp.error.code);
+        }
+        return resp.result;
+    }
+    async listTools() {
+        await this.connect();
+        const tools = [];
+        let cursor;
+        for (let page = 0; page < 50; page++) {
+            const result = asRecord(await this.rpc("tools/list", cursor ? { cursor } : {}, this.connectTimeoutMs)) ?? {};
+            for (const raw of Array.isArray(result["tools"]) ? result["tools"] : []) {
+                const tool = normalizeToolInfo(raw);
+                if (tool)
+                    tools.push(tool);
+            }
+            cursor = typeof result["nextCursor"] === "string" && result["nextCursor"] ? result["nextCursor"] : undefined;
+            if (!cursor)
+                break;
+        }
+        return tools;
+    }
+    async callTool(name, args, signal) {
+        await this.connect();
+        const result = await this.rpc("tools/call", { name, arguments: args }, this.callTimeoutMs, signal);
+        return contentToText(result);
+    }
+    async close() {
+        const t = this.transport;
+        this.transport = undefined;
+        this.connected = undefined;
+        if (t)
+            await t.close();
+    }
+}

package/dist/mcp/command.d.ts

@@ -0,0 +1,25 @@
+import { type McpServerConfig } from "./config.js";
+/**
+ * `u1s1 mcp` 子命令:管理自定义 MCP 服务。
+ * add 时先连一次拉工具清单再落盘,坏配置不会拖慢每次启动。
+ */
+export declare function printMcpHelp(): void;
+export declare class McpUsageError extends Error {
+}
+export interface ParsedAdd {
+    name: string;
+    server: McpServerConfig;
+    force: boolean;
+}
+export declare function parseAddArgs(args: string[]): ParsedAdd;
+export interface ImportCandidate {
+    name: string;
+    server: McpServerConfig;
+    source: string;
+}
+/** Claude Code 的 MCP 配置:~/.claude.json(用户级 + 各项目)与项目 .mcp.json */
+export declare function collectClaudeMcpServers(home?: string, cwd?: string): {
+    candidates: ImportCandidate[];
+    unsupported: string[];
+};
+export declare function mcpCommand(args: string[]): Promise<void>;