pi-web-ui 0.36.0 → 0.43.0

package/dist/server/mcp-bridge.js

@@ -0,0 +1,268 @@
+/**
+ * MCP 工具桥 —— 把外部 Model Context Protocol（stdio）服务器暴露的工具接入
+ * pi 会话，让 AI 能调用真实的第三方工具（文件、数据库、GitHub…）。
+ *
+ * 约定（MCP 规范流式子集）：
+ *  - stdio 传输 = stdin/stdout 上换行分隔的 JSON-RPC 2.0（NDJSON），不依赖任何
+ *    第三方包；stderr 是自由日志通道。
+ *  - 握手：initialize（带 protocolVersion）→ notifications/initialized →
+ *    tools/list → tools/call。
+ *  - 工具工具入会：本模块把每个远端工具适配成 PluginAgentTool，经
+ *    pluginToolsProvider 走与插件工具完全相同的 customTools 管线。
+ *
+ * 配置：<PI_WEB_DATA_DIR>/mcp.json，形如
+ *   { "servers": { "gitserv": { "command": "node", "args": ["mcp.js"], "cwd": "/x" } } }
+ */
+import { spawn } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+const PROTOCOL_VERSION = "2025-03-26"; // 广泛支持的工具版本
+let rpcSeq = 0;
+/**
+ * 单个 MCP 服务器的客户端：管理子进程、请求/响应按 id 关联、握手与工具调用。
+ * 线程模型：无需并发控制（MCP 允许乱序 + 我们按请求 id 匹配响应）。
+ */
+export class McpClient {
+    spec;
+    child = null;
+    buffer = "";
+    nextId = 1;
+    pending = new Map();
+    log;
+    name;
+    /** 已握手的工具列表（tools/list 结果缓存）。 */
+    tools = [];
+    shuttingDown = false;
+    constructor(name, spec, log) {
+        this.spec = spec;
+        this.name = name;
+        this.log = log ?? (() => { });
+    }
+    /** 启动子进程 + 握手 + 拉取工具列表。 */
+    async start(timeoutMs = 8000) {
+        if (this.child)
+            return;
+        const { command, args = [], cwd, env } = this.spec;
+        this.log(`[mcp:${this.name}] starting: ${command} ${args.join(" ")}`);
+        const child = spawn(command, args, {
+            cwd: cwd ?? undefined,
+            env: { ...process.env, ...env },
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        this.child = child;
+        child.stderr.on("data", (d) => this.log(`[mcp:${this.name}] stderr:`, d.toString().trimEnd()));
+        child.on("error", (err) => this.rejectAll(new Error(`[mcp:${this.name}] spawn error: ${err.message}`)));
+        child.on("exit", (code, sig) => {
+            this.child = null;
+            if (!this.shuttingDown)
+                this.rejectAll(new Error(`[mcp:${this.name}] 进程退出 (${sig ?? code})`));
+        });
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => this.onData(chunk));
+        // 握手
+        const handshake = await this.request("initialize", {
+            protocolVersion: this.spec.protocolVersion ?? PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: { name: "pi-web-ui", version: "0.41.0" },
+        });
+        const version = handshake?.protocolVersion ?? this.spec.protocolVersion ?? PROTOCOL_VERSION;
+        // 通知 initialized（无 id 的 notification）
+        this.send({ jsonrpc: "2.0", method: "notifications/initialized" });
+        // 仍以协商协议版本调用 tools（多数服务器对新版本容忍，这里用协商结果）
+        void version;
+        const listed = (await this.request("tools/list", {}) ?? {});
+        this.tools = Array.isArray(listed.tools) ? listed.tools : [];
+        this.log(`[mcp:${this.name}] ready, ${this.tools.length} tools`);
+    }
+    /** 已发现工具。 */
+    getTools() {
+        return this.tools.map((t) => ({ ...t }));
+    }
+    /** 调用一个工具，返回结果文本（多 content 拼接为 JSON 字符串保真）。 */
+    async call(name, args, timeoutMs = 60000) {
+        const res = (await this.request("tools/call", { name, arguments: args }, timeoutMs));
+        if (res?.isError) {
+            const msg = (res.content ?? []).map((c) => c.text ?? "").join("\n").trim() || "MCP 工具错误";
+            throw new Error(msg);
+        }
+        // 结构化结果优先，其次文本内容。
+        if (res?.structuredContent !== undefined)
+            return res.structuredContent;
+        const text = (res.content ?? []).map((c) => c.text ?? "").filter((x) => x).join("\n");
+        return { content: text, isError: !!res.isError };
+    }
+    /** 关闭：kill 子进程，拒绝所有在途请求。 */
+    close() {
+        this.shuttingDown = true;
+        this.rejectAll(new Error("[mcp] client closed"));
+        if (this.child) {
+            try {
+                this.child.kill();
+            }
+            catch {
+                /* 已退出 */
+            }
+            this.child = null;
+        }
+    }
+    // -- 内部 -------------------------------------------------------------
+    send(msg) {
+        const stdin = this.child?.stdin;
+        if (!stdin || !stdin.writable)
+            return;
+        stdin.write(JSON.stringify(msg) + "\n");
+    }
+    request(method, params, timeoutMs = 8000) {
+        const id = (rpcSeq++);
+        const outId = String(id);
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(outId);
+                reject(new Error(`[mcp:${this.name}] ${method} 超时 (${timeoutMs}ms)`));
+            }, timeoutMs);
+            this.pending.set(outId, { resolve, reject, timer });
+            this.send({ jsonrpc: "2.0", id: id, method, params });
+        });
+    }
+    onData(chunk) {
+        this.buffer += chunk;
+        let nl;
+        while ((nl = this.buffer.indexOf("\n")) >= 0) {
+            const line = this.buffer.slice(0, nl).trim();
+            this.buffer = this.buffer.slice(nl + 1);
+            if (!line)
+                continue;
+            let msg;
+            try {
+                msg = JSON.parse(line);
+            }
+            catch {
+                this.log(`[mcp:${this.name}] 非 JSON 行（忽略）：`, line.slice(0, 120));
+                continue;
+            }
+            this.handleMessage(msg);
+        }
+    }
+    handleMessage(msg) {
+        if (msg.id !== undefined) {
+            const pending = this.pending.get(String(msg.id));
+            if (!pending) {
+                this.log(`[mcp:${this.name}] 未知响应 id=${msg.id}`);
+                return;
+            }
+            this.pending.delete(String(msg.id));
+            clearTimeout(pending.timer);
+            if (msg.error)
+                pending.reject(new Error(`[mcp:${this.name}] ${msg.error.message ?? "MCP 错误"}`));
+            else
+                pending.resolve(msg.result);
+            return;
+        }
+        // 服务端主动通知（log / cancelled 等）——仅记录。
+        if (msg.method === "notifications/message") {
+            const p = msg.params;
+            if (p?.message)
+                this.log(`[mcp:${this.name}] ${p.level ?? "message"}:`, p.message);
+        }
+    }
+    rejectAll(err) {
+        for (const [, p] of this.pending) {
+            clearTimeout(p.timer);
+            p.reject(err);
+        }
+        this.pending.clear();
+    }
+}
+/** 读取 <dataDir>/mcp.json 里的服务器清单（尽力而为）。 */
+export function readMcpConfig(dataDir) {
+    try {
+        const raw = JSON.parse(readFileSync(join(dataDir, "mcp.json"), "utf8"));
+        const servers = {};
+        for (const [name, s] of Object.entries(raw.servers ?? {})) {
+            if (!s || typeof s.command !== "string" || !s.command.trim())
+                continue;
+            servers[name] = {
+                command: s.command,
+                args: Array.isArray(s.args) ? s.args.map(String) : [],
+                cwd: typeof s.cwd === "string" ? s.cwd : undefined,
+                env: s.env && typeof s.env === "object" ? s.env : undefined,
+            };
+        }
+        return { servers };
+    }
+    catch {
+        return { servers: {} };
+    }
+}
+/**
+ * 整个 MCP 管理器的工具适配：把每个 MCP 工具变成 PluginAgentTool。
+ * getAllToolsTool(name, callFn) 生成 execute → 转发到对应 McpClient.call。
+ */
+function adaptMcpTool(serverName, mcpTool, client) {
+    const name = sanitizeToolName(mcpTool.name);
+    return {
+        name,
+        label: `${serverName} · ${mcpTool.name}`,
+        description: mcpTool.description ?? `从 MCP 服务器「${serverName}」提供的工具 ${mcpTool.name}`,
+        parameters: mcpTool.inputSchema ?? {},
+        execute: async (_toolCallId, params, _signal) => {
+            return client.call(mcpTool.name, params ?? {});
+        },
+    };
+}
+/** 工具名必须是 [A-Za-z0-9_-]+（与插件工具同规则），MCP 可能含冒号/斜杠 — 归一化。 */
+function sanitizeToolName(name) {
+    const cleaned = (name || "").replace(/[^A-Za-z0-9_-]/g, "_");
+    return cleaned || "mcp_tool";
+}
+/** MCP 服务器管理器：自管多服务器生命周期 + 聚合工具。 */
+export class McpBridge {
+    dataDir;
+    log;
+    opts;
+    clients = [];
+    tools = [];
+    constructor(dataDir, log = () => { }, opts = {}) {
+        this.dataDir = dataDir;
+        this.log = log;
+        this.opts = opts;
+    }
+    /** 读取配置并启动全部服务器（顺序 fail-fast：单个失败记日志不拖垮其它）。 */
+    async load() {
+        const cfg = optsOverrideOrRead(this.opts.specOverride, this.dataDir);
+        await Promise.all(Object.entries(cfg.servers).map(async ([name, spec]) => {
+            try {
+                const client = new McpClient(name, spec, this.log);
+                await client.start();
+                this.clients.push(client);
+                for (const t of client.getTools())
+                    this.tools.push(adaptMcpTool(name, t, client));
+            }
+            catch (err) {
+                this.log(`[mcp] 服务器「${name}」启动失败：`, err instanceof Error ? err.message : err);
+            }
+        }));
+    }
+    getTools() {
+        return this.tools;
+    }
+    hasServers() {
+        return this.clients.length > 0;
+    }
+    dispose() {
+        for (const c of this.clients)
+            c.close();
+        this.clients = [];
+        this.tools = [];
+    }
+}
+function optsOverrideOrRead(specOverride, dataDir) {
+    if (specOverride && specOverride.length > 0) {
+        const servers = {};
+        for (const o of specOverride)
+            servers[o.name] = o.spec;
+        return { servers };
+    }
+    return readMcpConfig(dataDir);
+}

package/dist/server/plugin-facilities.js

@@ -0,0 +1,299 @@
+/**
+ * 插件宿主设施：插件私有 KV 存储 + 加密 secrets，从 plugins.ts 抽出的纯设施。
+ *
+ * storage —— <pluginDir>/storage.json 单文件 JSON KV：
+ *   - 全内存缓存、写入 tmp+rename 原子落盘（同 client-state.ts 的做法）；
+ *   - 供插件存非敏感配置（窗口布局、上次选中项…），替代各家手搓的
+ *     read/write config.json 样板；
+ *   - 生命周期跟插件目录绑定（uninstall 即删除），跨升级保留。
+ *
+ * secrets —— AES-256-GCM 加密的机密存储（密码/API key/token）：
+ *   - 密钥文件 <dataDir>/secrets.key（随机 32 字节，首次生成；chmod 0600 仅对
+ *     POSIX 有意义，Windows 上 NTFS 权限继承用户目录默认 ACL）；
+ *   - 密文文件随插件目录 <pluginDir>/secrets.bin——拷到别的机器因无密钥解不开
+ *     （fail closed）；卸载插件即连密文一起删除；
+ *   - 威胁模型：防「 casually 复制/查看文件」（混淆级保护）与「密文外泄」，
+ *     不能防同一用户账号下的完整进程妥协——本地个人工具的合理折衷。
+ */
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { readFile as fspReadFile, readdir as fspReaddir, rm as fspRm, mkdir as fspMkdir, writeFile as fspWriteFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { createRequire } from "node:module";
+import { spawnSync } from "node:child_process";
+/** tmp+rename 原子写（错误由调用方隔离——插件设施的 IO 一律尽力而为）。 */
+function atomicWrite(file, data) {
+    mkdirSync(dirname(file), { recursive: true });
+    const tmp = `${file}.tmp-${process.pid}`;
+    writeFileSync(tmp, data);
+    renameSync(tmp, file);
+}
+// ---------------------------------------------------------------------------
+// storage
+// ---------------------------------------------------------------------------
+/** 每插件的 JSON 文件 KV。所有方法同步（数据量小，避免并发写乱序）。 */
+export class PluginStorage {
+    file;
+    cache;
+    constructor(file) {
+        this.file = file;
+    }
+    load() {
+        if (this.cache)
+            return this.cache;
+        try {
+            const parsed = JSON.parse(readFileSync(this.file, "utf8"));
+            this.cache = parsed && typeof parsed === "object" ? parsed : {};
+        }
+        catch {
+            this.cache = {}; // 不存在/损坏 = 空表（损坏不致命，重新积累）
+        }
+        return this.cache;
+    }
+    get(key, fallback) {
+        const v = this.load()[key];
+        return v === undefined ? fallback : v;
+    }
+    all() {
+        return { ...this.load() };
+    }
+    set(key, value) {
+        if (!key)
+            throw new Error("storage.set: key 不能为空");
+        const store = this.load();
+        store[key] = value;
+        try {
+            atomicWrite(this.file, JSON.stringify(store));
+        }
+        catch (err) {
+            console.error(`[plugin-storage] 写入失败 (${this.file}):`, err);
+        }
+    }
+    delete(key) {
+        const store = this.load();
+        if (!(key in store))
+            return;
+        delete store[key];
+        try {
+            atomicWrite(this.file, JSON.stringify(store));
+        }
+        catch (err) {
+            console.error(`[plugin-storage] 写入失败 (${this.file}):`, err);
+        }
+    }
+}
+function seal(key, plaintext) {
+    const iv = randomBytes(12);
+    const cipher = createCipheriv("aes-256-gcm", key, iv);
+    const ct = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+    return { iv: iv.toString("hex"), tag: cipher.getAuthTag().toString("hex"), ct: ct.toString("hex") };
+}
+function unseal(key, blob) {
+    const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(blob.iv, "hex"));
+    decipher.setAuthTag(Buffer.from(blob.tag, "hex"));
+    return Buffer.concat([decipher.update(Buffer.from(blob.ct, "hex")), decipher.final()]).toString("utf8");
+}
+/** 读或创建全局密钥文件（懒加载一次）。 */
+function loadOrCreateKey(dataDir) {
+    const keyFile = join(dataDir, "secrets.key");
+    try {
+        if (existsSync(keyFile))
+            return Buffer.from(readFileSync(keyFile).toString("hex").trim(), "hex");
+    }
+    catch {
+        /* fallthrough → regenerate */
+    }
+    const key = randomBytes(32);
+    atomicWrite(keyFile, `${key.toString("hex")}\n`);
+    try {
+        chmodSync(keyFile, 0o600); // best-effort（win 无效，不抛错）
+    }
+    catch { }
+    return key;
+}
+/** 每插件的加密 KV。所有方法同步；任何读写失败都静默回退（机密丢失优于崩进程）。 */
+export class PluginSecrets {
+    store;
+    file;
+    constructor(dataDir, pluginDir) {
+        this.file = join(pluginDir, "secrets.bin");
+        this.key = PluginSecrets.keyFor(dataDir);
+    }
+    key;
+    static keys = new Map();
+    /** 按 dataDir 惰性生成/复用密钥（同进程内共享，避免重复 IO）。 */
+    static keyFor(dataDir) {
+        let k = PluginSecrets.keys.get(dataDir);
+        if (!k) {
+            k = loadOrCreateKey(dataDir);
+            PluginSecrets.keys.set(dataDir, k);
+        }
+        return k;
+    }
+    load() {
+        if (this.store)
+            return this.store;
+        try {
+            const parsed = JSON.parse(readFileSync(this.file, "utf8"));
+            this.store =
+                parsed && parsed.v === 1 && parsed.items && typeof parsed.items === "object"
+                    ? parsed
+                    : { v: 1, items: {} };
+        }
+        catch {
+            this.store = { v: 1, items: {} };
+        }
+        return this.store;
+    }
+    set(name, value) {
+        if (!name)
+            throw new Error("secrets.set: name 不能为空");
+        const s = this.load();
+        s.items[name] = seal(this.key, value);
+        try {
+            atomicWrite(this.file, JSON.stringify(s));
+        }
+        catch (err) {
+            console.error("[plugin-secrets] 写入失败:", err);
+        }
+    }
+    get(name) {
+        const blob = this.load().items[name];
+        if (!blob)
+            return undefined;
+        try {
+            return unseal(this.key, blob);
+        }
+        catch {
+            return undefined; // 换机器 / 密钥轮换 → 解不开返回空（fail closed）
+        }
+    }
+    has(name) {
+        return name in this.load().items;
+    }
+    delete(name) {
+        const s = this.load();
+        if (!(name in s.items))
+            return;
+        delete s.items[name];
+        try {
+            atomicWrite(this.file, JSON.stringify(s));
+        }
+        catch (err) {
+            console.error("[plugin-secrets] 写入失败:", err);
+        }
+    }
+    list() {
+        return Object.keys(this.load().items);
+    }
+}
+// ---------------------------------------------------------------------------
+// deps（宿主代插件自动补装运行时依赖）
+// ---------------------------------------------------------------------------
+const DEP_TIMEOUT_MS = 180_000; // 慢网安装兜底（含第一次拉取包元数据）
+/** 从插件目录出发能否解析到这个模块（模拟插件自身 import() 的查找链）。 */
+export function isDepAvailable(pluginDir, spec) {
+    try {
+        createRequire(join(pluginDir, "index.mjs")).resolve(spec);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const depInstallLocks = new Map();
+/** 确保依赖就绪：先逐个解析，缺了才一次性 `npm install` 补装，装完复查。
+ *  返回 true = 全部可用；false = 安装失败或超时。同目录并发调用单飞合并。
+ *
+ *  这是 webmail / db-client / vscode-editor 三家手搓 ensureXxxMod 的上收——
+ *  之前每家都自己拼 spawn 参数、自己处理 win32 的 npm.cmd、自己等 install 完成。 */
+export function ensurePluginDeps(pluginDir, specs, onProgress) {
+    if (specs.length === 0)
+        return Promise.resolve(true);
+    const missing = specs.filter((s) => !isDepAvailable(pluginDir, s));
+    if (missing.length === 0)
+        return Promise.resolve(true);
+    const lockKey = join(pluginDir, missing.sort().join("|"));
+    const inflight = depInstallLocks.get(lockKey);
+    if (inflight)
+        return inflight;
+    const run = async () => {
+        // 无 package.json 时 npm 会沿目录树向上找最近一个，可能把依赖装进父目录——
+        // 先落一个最小 package.json 钉住安装位置。
+        if (!existsSync(join(pluginDir, "package.json"))) {
+            try {
+                atomicWrite(join(pluginDir, "package.json"), JSON.stringify({ name: "plugin-runtime-deps", private: true }, null, 2));
+            }
+            catch { }
+        }
+        onProgress?.(`正在安装依赖：${missing.join(", ")}…（首次约需几分钟）`);
+        // win32 的 npm 是 .cmd——spawnSync 直接跑会被 EINVAL 拒绝，必须走 shell；
+        // posix 不用 shell（路径不含空格假设成立，与宿主其它 spawn 一致）。
+        const res = spawnSync(process.platform === "win32" ? "npm.cmd" : "npm", ["install", "--no-audit", "--no-fund", ...missing], { cwd: pluginDir, timeout: DEP_TIMEOUT_MS, shell: process.platform === "win32", encoding: "utf8" });
+        if (res.error || res.status !== 0) {
+            console.error(`[plugin-deps] ${join(pluginDir)} npm install 失败:`, res.error ?? res.stderr?.slice(0, 500));
+            return false;
+        }
+        const stillMissing = specs.filter((s) => !isDepAvailable(pluginDir, s));
+        if (stillMissing.length) {
+            console.error(`[plugin-deps] 安装完成但仍缺：${stillMissing.join(", ")}`);
+            return false;
+        }
+        onProgress?.("依赖安装完成");
+        return true;
+    };
+    const p = run().finally(() => depInstallLocks.delete(lockKey));
+    depInstallLocks.set(lockKey, p);
+    return p;
+}
+export class WorkspaceFS {
+    root;
+    /** root 是活值 getter（返回当前工作区绝对路径），跟随 set_cwd。 */
+    constructor(root) {
+        this.root = root;
+    }
+    /** 相对路径 → 活根下的绝对路径；越界抛错。空串 = 根本身。 */
+    abs(rel) {
+        const rootDir = resolve(this.root());
+        const target = resolve(rootDir, typeof rel === "string" ? rel : "");
+        if (target !== rootDir && !target.startsWith(rootDir + sepOf())) {
+            throw new Error(`路径越界：${String(rel)}`);
+        }
+        return target;
+    }
+    /** 单层目录列表（浅层；深度遍历请插件自行递归）。 */
+    async list(relDir = "") {
+        try {
+            const dirents = await fspReaddir(this.abs(relDir), { withFileTypes: true });
+            return dirents
+                .slice(0, 2000)
+                .map((d) => ({ name: d.name, type: d.isDirectory() ? "dir" : "file" }));
+        }
+        catch (err) {
+            throw new Error(`读取目录失败：${err.message}`);
+        }
+    }
+    /** 读文件（二进制）。声明为 async：路径校验失败以 rejected promise 表达
+     * （非 async 版本会同步 throw，破坏调用方 .catch/.rejects 契约）。 */
+    async read(relPath) {
+        return fspReadFile(this.abs(relPath));
+    }
+    /** 读文本（默认上限 512KB，超出截断——预览同款约定）。 */
+    async readText(relPath, maxBytes = 512 * 1024) {
+        const buf = await this.read(relPath);
+        return buf.subarray(0, maxBytes).toString("utf8");
+    }
+    /** 写文件（自动补父目录；注意相对路径锚定当前项目——切换 cwd 后写进新项目）。 */
+    async write(relPath, data) {
+        const target = this.abs(relPath);
+        await fspMkdir(dirname(target), { recursive: true });
+        await fspWriteFile(target, data);
+    }
+    /** 删除文件/目录（递归；只允许删工作区内的路径）。 */
+    async remove(relPath) {
+        await fspRm(this.abs(relPath), { recursive: true, force: false });
+    }
+}
+function sepOf() {
+    return process.platform === "win32" ? "\\" : "/";
+}