pi-web-ui 0.86.2 → 0.87.0

package/dist/server/mcp-bridge.js

@@ -40,7 +40,9 @@ export class McpClient {
     starting = null;
     /** 已启动次数（含自愈重启；诊断/测试用）。 */
     startedCount = 0;
-    constructor(name, spec, log) {
+    constructor(name, 
+    /** 启动规格；热加载按它判断「这个服务器要不要重启」（见 McpBridge.reload）。 */
+    spec, log) {
         this.spec = spec;
         this.name = name;
         this.log = log ?? (() => { });
@@ -290,27 +292,65 @@ export class McpClient {
         this.pending.clear();
     }
 }
+/**
+ * 解析 <dataDir>/mcp.json 的文本 → 规范化服务器清单。
+ * `null` = 不是合法 JSON 对象（**与「没有服务器」区分开**：热加载遇到坏配置要保留在跑的
+ * 服务器，而 `{ "servers": {} }` 或删掉文件是「确实没有服务器」的明确意图）。
+ */
+export function parseMcpConfig(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return null;
+    const servers = {};
+    for (const [name, s] of Object.entries(parsed.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,
+            protocolVersion: typeof s.protocolVersion === "string" ? s.protocolVersion : undefined,
+        };
+    }
+    return { servers };
+}
 /** 读取 <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 };
+        return parseMcpConfig(readFileSync(join(dataDir, "mcp.json"), "utf8")) ?? { servers: {} };
     }
     catch {
         return { servers: {} };
     }
 }
+/**
+ * 服务器的规范化快照：只保留影响行为的字段，env 键序无关。
+ * 热加载的「配置变了吗」与「这个服务器要不要重启」都按它比较 —— 改缩进、重排键名、加尾随
+ * 换行都不算变更，不该重启任何子进程。
+ */
+export function mcpServerSnapshot(spec) {
+    const env = {};
+    for (const k of Object.keys(spec.env ?? {}).sort())
+        env[k] = spec.env[k];
+    return {
+        command: spec.command,
+        args: spec.args ?? [],
+        cwd: spec.cwd ?? null,
+        env,
+        protocolVersion: spec.protocolVersion ?? null,
+    };
+}
+/** 两个规格是否等价（等价 = 该服务器的子进程不必重启）。 */
+function sameMcpSpec(a, b) {
+    return JSON.stringify(mcpServerSnapshot(a)) === JSON.stringify(mcpServerSnapshot(b));
+}
 /**
  * 整个 MCP 管理器的工具适配：把每个 MCP 工具变成 PluginAgentTool。
  * getAllToolsTool(name, callFn) 生成 execute → 转发到对应 McpClient.call。
@@ -349,17 +389,81 @@ export class McpBridge {
     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));
+            const client = await this.startOne(name, spec);
+            if (!client)
+                return;
+            this.clients.push(client);
+            for (const t of client.getTools())
+                this.tools.push(adaptMcpTool(name, t, client));
+        }));
+    }
+    /** 启动单个服务器：失败只记日志并返回 null（load / reload 共用）。 */
+    async startOne(name, spec) {
+        try {
+            const client = new McpClient(name, spec, this.log);
+            await client.start();
+            return client;
+        }
+        catch (err) {
+            this.log(`[mcp] 服务器「${name}」启动失败：`, err instanceof Error ? err.message : err);
+            return null;
+        }
+    }
+    /**
+     * 按磁盘上的最新配置**整体换入**服务器集合（`mcp.json` 热加载用），可重复调用。
+     * 三步的顺序都有讲究：
+     *  1. 规格没变的服务器**沿用原实例** —— 改一个服务器不该连带重启其它服务器（子进程、
+     *     浏览器会话、在途调用全都不动）；
+     *  2. 新增/变更的**先启动成功才换入**，失败则沿用旧实例 —— 配置写坏不等于把还能用的
+     *     工具一起下线；
+     *  3. 最后才 close 掉被移除/被替换的旧实例，并按新集合重建工具表。
+     */
+    async reload() {
+        const cfg = optsOverrideOrRead(this.opts.specOverride, this.dataDir);
+        const next = new Map();
+        let kept = 0;
+        for (const client of this.clients) {
+            const spec = cfg.servers[client.name];
+            if (!spec || !sameMcpSpec(spec, client.spec))
+                continue;
+            next.set(client.name, client);
+            kept++;
+        }
+        let started = 0;
+        let failed = 0;
+        await Promise.all(Object.entries(cfg.servers)
+            .filter(([name]) => !next.has(name))
+            .map(async ([name, spec]) => {
+            const previous = this.clients.find((c) => c.name === name);
+            const fresh = await this.startOne(name, spec);
+            if (fresh) {
+                next.set(name, fresh);
+                started++;
+                return;
             }
-            catch (err) {
-                this.log(`[mcp] 服务器「${name}」启动失败：`, err instanceof Error ? err.message : err);
+            failed++;
+            // 新规格没起来：留住旧实例，别把还能用的服务器一起下线。
+            if (previous) {
+                next.set(name, previous);
+                kept++;
             }
         }));
+        const stale = this.clients.filter((c) => next.get(c.name) !== c);
+        this.clients = [...next.values()];
+        this.tools = [];
+        for (const c of this.clients)
+            for (const t of c.getTools())
+                this.tools.push(adaptMcpTool(c.name, t, c));
+        for (const c of stale)
+            c.close();
+        return {
+            kept,
+            started,
+            stopped: stale.length,
+            failed,
+            servers: this.clients.length,
+            tools: this.tools.length,
+        };
     }
     getTools() {
         return this.tools;

package/dist/server/mcp-hot-reload.js

@@ -0,0 +1,117 @@
+/**
+ * `mcp.json` 热加载 —— 改完文件即生效，不必再重启 pi-web-ui。
+ *
+ * 为什么是「盯文件」而不是加协议消息 / 设置面板按钮：`mcp.json` 是用文本编辑器手改的
+ * 外部文件（README 一直写着「改完要重启」），没有任何 UI 参与保存；监视文件是唯一不需要
+ * 新增协议字段与多语言文案的形态（对照 `reload_models_config`：它有设置面板按钮，所以走协议）。
+ *
+ * 三条不变量（都有回归用例）：
+ *  1. **内容没变就不动任何子进程**：指纹按「规范化后的服务器集合」算（服务器顺序无关、
+ *     只看影响行为的字段）—— 编辑器保存、重排键、改缩进都不触发重启；
+ *  2. **配置写坏不停掉在跑的服务器**：JSON 解析失败只记日志 + 提示一次，绝不碰现有实例
+ *     （保存过程中的半写状态很常见）；
+ *  3. **删掉文件 = 清空配置**：与「坏配置」区分开 —— 用户删掉 `mcp.json` 是有意关掉全部
+ *     MCP 服务器，照常应用。
+ */
+import { readFileSync, watch } from "node:fs";
+import { join } from "node:path";
+import { mcpServerSnapshot, parseMcpConfig } from "./mcp-bridge.js";
+/** 规范化指纹：只含影响行为的字段、服务器顺序无关 —— 「内容变了吗」的判据。 */
+function fingerprint(servers) {
+    const names = Object.keys(servers).sort();
+    return JSON.stringify(names.map((n) => [n, mcpServerSnapshot(servers[n])]));
+}
+export function createMcpHotReload(deps) {
+    const file = join(deps.dataDir, "mcp.json");
+    const log = deps.log ?? (() => { });
+    const debounceMs = deps.debounceMs ?? 300;
+    const pollIntervalMs = deps.pollIntervalMs ?? 2000;
+    /** 上次应用到运行时的内容指纹；null = 还没播种。 */
+    let applied = null;
+    let debounce = null;
+    let poller = null;
+    let watcher = null;
+    /** 读一次磁盘：指纹 + 清单（`servers` 为 null = 坏配置）。文件不在按「没有服务器」算。 */
+    function readOnce() {
+        let raw;
+        try {
+            raw = readFileSync(file, "utf8");
+        }
+        catch {
+            // 读不到（文件/目录不在）→ 空配置：删掉 mcp.json 就是「关掉全部 MCP 服务器」。
+            return { fp: "empty", servers: {} };
+        }
+        const parsed = parseMcpConfig(raw);
+        if (!parsed)
+            return { fp: `invalid:${raw}`, servers: null };
+        return { fp: `ok:${fingerprint(parsed.servers)}`, servers: parsed.servers };
+    }
+    async function apply() {
+        const { fp, servers } = readOnce();
+        if (fp === applied)
+            return "unchanged";
+        // 先记账再动手：同一个坏文件不反复刷屏，配置没再变也不重试。
+        applied = fp;
+        if (!servers) {
+            log("[mcp] mcp.json 解析失败，保留在跑的 MCP 服务器");
+            deps.onNotice?.("warning", "mcp.json 解析失败，已保留当前 MCP 服务器（改好保存后会自动重载）", "Failed to parse mcp.json — keeping the running MCP servers (saving a valid file reloads automatically)");
+            return "invalid";
+        }
+        const summary = await deps.reload();
+        deps.onToolsChanged?.();
+        log(`[mcp] 配置已热加载：${summary.servers} 个服务器 / ${summary.tools} 个工具` +
+            `（沿用 ${summary.kept}、启动 ${summary.started}、关闭 ${summary.stopped}、失败 ${summary.failed}）`);
+        deps.onNotice?.("info", `mcp.json 已热加载：${summary.servers} 个服务器 / ${summary.tools} 个工具`, `mcp.json reloaded: ${summary.servers} server(s) / ${summary.tools} tool(s)`);
+        return "reloaded";
+    }
+    function run() {
+        void apply().catch((err) => log("[mcp] 热加载失败：", err instanceof Error ? err.message : err));
+    }
+    function schedule() {
+        if (debounce)
+            return;
+        debounce = setTimeout(() => {
+            debounce = null;
+            run();
+        }, debounceMs);
+    }
+    /** fs.watch 用不了（目录还不存在、网络盘、容器）→ 回落到轮询：单文件不值得上更重的机制。 */
+    function fallBackToPolling() {
+        watcher?.close();
+        watcher = null;
+        if (poller)
+            return;
+        log(`[mcp] 目录监视不可用，mcp.json 热加载回落到 ${pollIntervalMs}ms 轮询`);
+        poller = setInterval(run, pollIntervalMs);
+        poller.unref();
+    }
+    function start() {
+        if (watcher || poller)
+            return;
+        // 播种：启动时 load() 已按同一份文件启动过服务器，别在第一个事件里白重载一次。
+        applied = readOnce().fp;
+        try {
+            watcher = watch(deps.dataDir, { persistent: false }, (_event, filename) => {
+                // 有些平台/编辑器（保存 = 临时文件 + rename）给不出文件名，拿不到就当命中。
+                if (typeof filename === "string" && filename && filename !== "mcp.json")
+                    return;
+                schedule();
+            });
+            watcher.on("error", () => fallBackToPolling());
+        }
+        catch {
+            fallBackToPolling();
+        }
+    }
+    function dispose() {
+        if (debounce)
+            clearTimeout(debounce);
+        debounce = null;
+        if (poller)
+            clearInterval(poller);
+        poller = null;
+        watcher?.close();
+        watcher = null;
+    }
+    return { apply, start, dispose };
+}

package/dist/server/model-admin.js

@@ -14,6 +14,7 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { pick } from "./i18n.js";
+import { ProviderOAuthFlowManager } from "./provider-oauth-flow.js";
 /** Strip // and /* *\/ comments without touching string literals (URLs contain //). */
 function stripJsonComments(src) {
     let out = "";
@@ -177,8 +178,68 @@ function parseGoogleModel(m) {
 }
 export class ModelAdminService {
     host;
+    oauthFlows;
     constructor(host) {
         this.host = host;
+        this.oauthFlows = new ProviderOAuthFlowManager({
+            modelRuntime: host.modelRuntime,
+            emit: host.emit,
+            isDisposed: host.isDisposed,
+            onLoginSuccess: (provider) => this.onOAuthLoginSuccess(provider),
+        });
+    }
+    startProviderOAuth(provider) {
+        return this.oauthFlows.start(provider);
+    }
+    replyProviderOAuth(flowId, promptId, value) {
+        this.oauthFlows.reply(flowId, promptId, value);
+    }
+    cancelProviderOAuth(flowId) {
+        this.oauthFlows.cancel(flowId);
+    }
+    listProviderOAuthFlows() {
+        this.oauthFlows.list();
+    }
+    dispose() {
+        this.oauthFlows.dispose();
+    }
+    async logoutProviderOAuth(provider) {
+        const providerId = provider.trim();
+        try {
+            const runtime = this.host.modelRuntime();
+            if (!providerId || !runtime.getProvider(providerId)?.auth.oauth) {
+                throw new Error("该服务商不支持 OAuth 登录");
+            }
+            await runtime.logout(providerId);
+            this.host.invalidatePiConfig();
+            await this.host.pushModels();
+            await this.listProviders();
+            this.host.emit({ type: "provider_oauth_logout_result", provider: providerId, ok: true });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "provider_oauth_logout_result",
+                provider: providerId,
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        finally {
+            this.host.flushSnapshot();
+        }
+    }
+    async onOAuthLoginSuccess(provider) {
+        const keys = this.readProviderKeys();
+        if (keys[provider]) {
+            keys[provider].activeKeyName = null;
+            this.writeProviderKeys(keys);
+        }
+        this.host.onOAuthActivated?.(provider);
+        this.host.invalidatePiConfig();
+        await this.host.pushModels();
+        await this.listProviders();
+        this.listProviderKeys();
+        this.host.flushSnapshot();
     }
     // ---------------------------------------------------------------------------
     // Built-in provider multiple key store (one provider, several API keys).
@@ -200,7 +261,11 @@ export class ModelAdminService {
                 const keys = Array.isArray(entry?.keys) ? entry.keys.filter((k) => k?.name && k?.apiKey) : [];
                 if (!pid || keys.length === 0)
                     continue;
-                const activeKeyName = entry.activeKeyName && keys.some((k) => k.name === entry.activeKeyName) ? entry.activeKeyName : keys[0].name;
+                const activeKeyName = entry.activeKeyName === null
+                    ? null
+                    : entry.activeKeyName && keys.some((k) => k.name === entry.activeKeyName)
+                        ? entry.activeKeyName
+                        : keys[0].name;
                 out[pid] = { activeKeyName, keys };
             }
             return out;
@@ -606,6 +671,16 @@ export class ModelAdminService {
             this.host.emit({ type: "notice", level: "error", text: "请填写服务商 ID", textEn: "Enter a provider ID" });
             return;
         }
+        if (this.host.modelRuntime().isUsingOAuth(pid)) {
+            this.host.emit({
+                type: "notice",
+                level: "error",
+                text: "请使用 OAuth 登出操作清除当前登录",
+                textEn: "Use the OAuth sign-out action to clear the current login",
+            });
+            this.host.flushSnapshot();
+            return;
+        }
         try {
             // Remove from auth.json ({ <provider>: { type: "api_key", key } }).
             const authPath = join(this.host.agentDir, "auth.json");
@@ -756,12 +831,15 @@ export class ModelAdminService {
         }
         this.host.flushSnapshot();
     }
-    /** Enumerate pi's built-in providers with auth status (key-only config). */
+    /** Enumerate pi's built-in providers with auth capabilities and status. */
     async listProviders() {
         const mr = this.host.modelRuntime();
         let providers;
         try {
             providers = mr.getProviders().map((p) => {
+                const supportsApiKey = p.auth.apiKey !== undefined;
+                const supportsOAuth = p.auth.oauth !== undefined;
+                const oauthName = p.auth.oauth?.name;
                 try {
                     const st = mr.getProviderAuthStatus(p.id);
                     return {
@@ -769,11 +847,23 @@ export class ModelAdminService {
                         name: p.name,
                         configured: st?.configured ?? false,
                         source: st?.source,
+                        supportsApiKey,
+                        supportsOAuth,
+                        oauthName,
+                        usingOAuth: mr.isUsingOAuth(p.id),
                     };
                 }
                 catch {
                     // One odd provider must not blank the whole list.
-                    return { id: p.id, name: p.name, configured: false };
+                    return {
+                        id: p.id,
+                        name: p.name,
+                        configured: false,
+                        supportsApiKey,
+                        supportsOAuth,
+                        oauthName,
+                        usingOAuth: false,
+                    };
                 }
             });
         }

package/dist/server/plugin-dom.js

@@ -0,0 +1,83 @@
+/**
+ * 特权 DOM 访问授权表（`<dataDir>/plugin-dom.json`）。
+ *
+ * 背景：插件 client bundle 与主应用同源，JS 层面拦不住它碰 `document`——真正的门禁
+ * 只能放在 bundle 下发处（`/plugins/:id/client/*`）。manifest.permissions 含 "dom"
+ * 族的插件，其 bundle 默认 403；用户在设置面板逐个授权后才放行（并 epoch+1 让
+ * 浏览器重拉）。授权是整机全局的（与 plugin-grants.json 同口径），任何浏览器看到
+ * 的都是同一份。
+ *
+ * 语义：
+ * - 读不出来 / JSON 坏 / 形状不对 → 当空表，且**不在读路径回写**（一次磁盘抖动不
+ *   能静默清空用户授权；与 PluginGrantsStore 同一条纪律）。
+ * - 只有真正发生变更的写才落盘（临时文件 + rename 原子写）；写失败 best-effort
+ *   （内存态仍生效，本次会话可用）。
+ */
+import { readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+const FILE = "plugin-dom.json";
+/** manifest.permissions 条目 → 是否请求特权 DOM（只看 `:` 前的族名，与宿主 can() 同口径）。
+ *  例外：`dom:anchor` 只是客户端锚点挂载点的范围 DOM（免用户授权），不触发 bundle 403；
+ *  完整 document 访问仍需 `dom`（或除 anchor 外的其它 dom 子族）+ 用户授权。 */
+export function declarationWantsDom(permissions) {
+    if (!Array.isArray(permissions))
+        return false;
+    return permissions.some((p) => {
+        if (typeof p !== "string")
+            return false;
+        const [fam, sub] = p.split(":").map((s) => s.trim().toLowerCase());
+        if (fam !== "dom")
+            return false;
+        return sub === undefined || sub === "" || sub !== "anchor";
+    });
+}
+/** 静态门禁判定：纯函数，单测覆盖。未知插件（wantsDom=false）一律放行——向后兼容。 */
+export function isDomBundleBlocked(wantsDom, granted) {
+    return wantsDom && !granted;
+}
+function readGranted(dataDir) {
+    try {
+        const raw = JSON.parse(readFileSync(join(dataDir, FILE), "utf8"));
+        const list = Array.isArray(raw?.granted) ? raw.granted : [];
+        return new Set(list.filter((x) => typeof x === "string" && x.length > 0));
+    }
+    catch {
+        return new Set();
+    }
+}
+export class PluginDomConsent {
+    dataDir;
+    granted;
+    constructor(dataDir) {
+        this.dataDir = dataDir;
+        this.granted = readGranted(dataDir);
+    }
+    has(pluginId) {
+        return this.granted.has(pluginId);
+    }
+    list() {
+        return [...this.granted].sort();
+    }
+    /** 授权/撤销。返回是否真的发生了变更（没变就不落盘、不推快照）。 */
+    set(pluginId, granted) {
+        const id = String(pluginId ?? "").trim();
+        if (!id)
+            return false;
+        const had = this.granted.has(id);
+        if (granted === had)
+            return false;
+        if (granted)
+            this.granted.add(id);
+        else
+            this.granted.delete(id);
+        try {
+            const tmp = join(this.dataDir, `${FILE}.tmp.${process.pid}`);
+            writeFileSync(tmp, JSON.stringify({ v: 1, granted: this.list() }), "utf8");
+            renameSync(tmp, join(this.dataDir, FILE));
+        }
+        catch {
+            /* 写失败 best-effort：内存态仍生效，本次会话可用 */
+        }
+        return true;
+    }
+}

package/dist/server/plugin-facilities.js

@@ -199,10 +199,24 @@ export class PluginSecrets {
 // deps（宿主代插件自动补装运行时依赖）
 // ---------------------------------------------------------------------------
 const DEP_TIMEOUT_MS = 180_000; // 慢网安装兜底（含第一次拉取包元数据）
+/** spec（`name` / `name@range` / `@scope/name@range`）→ 裸包名。
+ *  require.resolve 不认 `@版本号` 后缀（`foo@1.2.3` 会被当成字面目录名，
+ *  恒判缺失 → 带版本 pin 的 ensureDeps 永远装完还报缺，voice-input 踩过）。
+ *  非标准形状（URL / 本地路径 / tag）原样返回，resolve 失败即判缺失，行为不变。
+ *  纯函数，单测覆盖。 */
+export function depName(spec) {
+    const m = /^(?:(@[^/\s]+\/[^/\s@]+)|([^/\s@:.]+))(?:@[^/\s]*)?$/.exec(str(spec));
+    if (!m)
+        return spec;
+    return m[1] ?? m[2] ?? spec;
+}
+function str(v) {
+    return typeof v === "string" ? v.trim() : "";
+}
 /** 从插件目录出发能否解析到这个模块（模拟插件自身 import() 的查找链）。 */
 export function isDepAvailable(pluginDir, spec) {
     try {
-        createRequire(join(pluginDir, "index.mjs")).resolve(spec);
+        createRequire(join(pluginDir, "index.mjs")).resolve(depName(spec));
         return true;
     }
     catch {

package/dist/server/plugin-installer.js

@@ -50,8 +50,14 @@ export function buildPluginJobArgs(spec, dataDir, lang) {
     const args = ["install", source, "--name", id, "--data-dir", dataDir];
     if (spec.action === "update")
         args.push("--force");
+    if (spec.build && spec.noBuild)
+        return {
+            error: pick(l, "--build 与 --no-build 不能同时用", "--build and --no-build are mutually exclusive", "plugininstaller.build.conflict"),
+        };
     if (spec.build)
         args.push("--build");
+    else if (spec.noBuild)
+        args.push("--no-build");
     return { args };
 }
 export class PluginInstaller {