pi-web-ui 0.31.0 → 0.34.0

package/dist/server/index.js

@@ -20,7 +20,6 @@ import { existsSync } from "node:fs";
 import { stat } from "node:fs/promises";
 import { createServer } from "node:http";
 import { createConnection } from "node:net";
-import { spawn } from "node:child_process";
 import { basename, delimiter, dirname, join, resolve, sep } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
@@ -36,6 +35,7 @@ import { startControlServer } from "./control-socket.js";
 import { scheduleUploadCleanup } from "./uploads.js";
 import { ensureWindowsBash, windowsBashDir } from "./ensure-bash.js";
 import { listThemes, resolveThemeFile } from "./themes.js";
+import { PluginManager, resolvePluginClientFile } from "./plugins.js";
 const PORT = Number(process.env.PORT ?? 8787);
 const CWD = resolve(process.env.PI_WEB_CWD ?? process.cwd());
 const DATA_DIR = resolve(process.env.PI_WEB_DATA_DIR ?? join(homedir(), ".pi-web"));
@@ -210,6 +210,30 @@ app.get("/themes/:id.css", (req, res) => {
     res.setHeader("Cache-Control", "no-cache");
     res.sendFile(file);
 });
+// Plugin client bundles: <dataDir>/plugins/<id>/client/* served at
+// /plugins/<id>/client/* so the frontend can import() plugin views. Only the
+// client/ subtree is exposed — manifest.json and the server-side index.mjs
+// (which may hold credentials) never leave the machine. Registered BEFORE the
+// SPA catch-all below.
+const PLUGINS_DIR = join(DATA_DIR, "plugins");
+app.get("/plugins/:id/client/*", (req, res) => {
+    // express 4 的通配参数在运行时落在 params[0]，但类型声明里没有 —— 显式取
+    const rest = String(req.params[0] ?? "");
+    const abs = resolvePluginClientFile(PLUGINS_DIR, req.params.id, rest);
+    if (!abs) {
+        res.status(404).end("plugin not found");
+        return;
+    }
+    // .mjs 常不在老 mime 表里，手动定 Content-Type 保证 import() 可用
+    if (/\.(mjs|js)$/.test(abs)) {
+        res.setHeader("Content-Type", "text/javascript; charset=utf-8");
+    }
+    res.setHeader("Cache-Control", "no-cache"); // 开发期改文件即生效
+    res.sendFile(abs, (err) => {
+        if (err && !res.headersSent)
+            res.status(err.statusCode === 404 ? 404 : 500).end("not found");
+    });
+});
 /** Set in the env of the replacement child spawned by a self-update restart. */
 const RESTART_CHILD_ENV = "PI_WEB_RESTART_CHILD";
 const webDist = join(pkgRoot, "web", "dist");
@@ -341,50 +365,22 @@ const heartbeatTimer = setInterval(() => {
 const service = new AgentService(CWD, 
 // Per-client persisted UI state: last-used workspace + recent projects.
 join(DATA_DIR, "client-state.json"));
+// Optional UI plugins (<dataDir>/plugins/<id>/): scanned on every client
+// attach so freshly dropped plugins appear without a server restart.
+const pluginMgr = new PluginManager(DATA_DIR, CWD);
+// 插件扩展点：SDK 工具执行事件（bash/读文件等 start+end）转发给已注册的插件。
+service.onToolEvent = (ev) => pluginMgr.emitToolEvent(ev);
+// 插件扩展点：插件注册的 AI 工具（registerAgentTool）→ 会话创建时带上 +
+// 变化时动态注入/移除已有会话。
+service.pluginToolsProvider = () => pluginMgr.getAgentTools();
+pluginMgr.onAgentToolsChanged = () => service.applyPluginAgentTools();
 // ---------------------------------------------------------------------------
-// Self-update auto-restart
+// Self-update
 // ---------------------------------------------------------------------------
-// npm i -g writes new code to disk but the running process keeps the old
-// code in memory — so a successful in-app update hands the process over:
-//   macOS launchd (KeepAlive) and systemd (Restart) relaunch us on exit;
-//   foreground runs get a replacement child that waits for our port to free.
-// Docker containers can't self-restart (the orchestrator owns that), so they
-// keep the manual-restart notice.
-function scheduleUpdateRestart() {
-    const isLaunchd = process.platform === "darwin" && process.ppid === 1;
-    const isSystemd = process.platform === "linux" && !!process.env.INVOCATION_ID;
-    const inDocker = existsSync("/.dockerenv");
-    if (isLaunchd || isSystemd || inDocker) {
-        // Supervisors relaunch on exit; Docker restarts externally. Nothing to
-        // spawn — just exit after the notice has flushed.
-        if (isLaunchd || isSystemd) {
-            setTimeout(() => {
-                console.log("update applied — auto-restarting…");
-                if (isSystemd) {
-                    // Non-zero exit: legacy units use Restart=on-failure.
-                    process.exit(3);
-                }
-                void shutdown();
-            }, 1500);
-            return true;
-        }
-        return false;
-    }
-    // Foreground / Windows: spawn a replacement from the updated install and
-    // exit. Same stdio (logs keep flowing), same args/env (port, cwd, data
-    // dir…); the child waits for this port to free before binding.
-    setTimeout(() => {
-        console.log("update applied — spawning replacement…");
-        spawn(process.execPath, process.argv.slice(1), {
-            stdio: "inherit",
-            env: { ...process.env, [RESTART_CHILD_ENV]: "1" },
-            ...(process.platform === "win32" ? { windowsHide: true } : {}),
-        });
-        void shutdown();
-    }, 1500);
-    return true;
-}
-service.onUpdateReady = scheduleUpdateRestart;
+// In-app updates now run `npm i -g pi-web-ui@latest` in a visible terminal
+// tab (frontend-initiated); after it finishes the user restarts via
+// `pi-web-ui server restart`. The PI_WEB_RESTART_CHILD port-wait handshake
+// below stays: an externally orchestrated replacement child still needs it.
 function scheduleQuit() {
     const isLaunchd = process.platform === "darwin" && process.ppid === 1;
     const isSystemd = process.platform === "linux" && !!process.env.INVOCATION_ID;
@@ -410,6 +406,11 @@ service.onQuit = scheduleQuit;
  *  ~10MB——连半份都没发完就丢，前端频繁跳帧；短会话又太迟钝。相对阈值语义稳定在
  *  「缓冲堆了约 N 份快照」，不随会话长短漂移。 */
 const SNAPSHOT_BACKPRESSURE_FACTOR = 3;
+/** 背压绝对下限：低于此积压永不丢快照（小会话的相对阈值只有几 KB，会被
+ *  正常的消息突发误伤，见 send() 内注释）。 */
+const SNAPSHOT_BACKPRESSURE_MIN_BYTES = 262_144;
+/** 背压丢弃后的延迟重发间隔。 */
+const SNAPSHOT_RETRY_MS = 250;
 /**
  * Multi-tab serialization sharing: emit() hands the SAME message object to
  * every socket of a client, but each send() used to JSON.stringify it
@@ -436,6 +437,8 @@ wss.on("connection", (ws) => {
     let lastSnapshotBytes = 0;
     /** Commands received while the session is still being created — replayed after attach. */
     let pending = [];
+    /** 背压丢快照后的延迟重发定时器（去重：一次只排一个）。 */
+    let snapshotRetryTimer = null;
     // 协议层错误（非法帧/未 masked 帧等）：不注册 handler 会作为 uncaught
     // exception 打崩整个进程（issue #11 附带发现）。记日志并按坏连接关闭。
     ws.on("error", (err) => {
@@ -452,13 +455,27 @@ wss.on("connection", (ws) => {
             return;
         // 发送背压（issue #11）：socket 消费不过来时（前端慢/网络差），堆里会堆积
         // 每份可达 ~10MB 的全量 snapshot 字符串，低内存主机直接 OOM。snapshot 是全量
-        // 幂等的且 60ms 后必有更新的一份，可以安全丢弃——在序列化之前丢，连
+        // 幂等的且稍后必有更新的一份，可以安全丢弃——在序列化之前丢，连
         // stringify 的分配都省掉。ready/notice/error/tool_delta 等消息必须送达。
         // 阈值相对化（评论区建议）：用「最近一份 snapshot 的字节数 × 倍数」做基准，
         // 首份无基准不丢（首次必达）。wire.length 是 UTF-16 字符数，×2 估算字节。
+        // 下限保护（小会话误伤修复）：小会话一份 snapshot 才 ~1KB，相对阈值只有几
+        // KB——前面一批 settings_state/slash_commands 的正常突发就能把 bufferedAmount
+        // 抬过阈值，把紧随其后的 snapshot_delta 静默丢掉；而丢弃后若无后续事件就
+        // 再也没有快照，客户端永远停在旧状态（前端靠 rev 缺口 get_state 自愈，
+        // 协议测试则直接卡死）。绝对下限保证小会话永不触发背压。
         if ((msg.type === "snapshot" || msg.type === "snapshot_delta") &&
             lastSnapshotBytes > 0 &&
-            ws.bufferedAmount > SNAPSHOT_BACKPRESSURE_FACTOR * lastSnapshotBytes) {
+            ws.bufferedAmount > Math.max(SNAPSHOT_BACKPRESSURE_MIN_BYTES, SNAPSHOT_BACKPRESSURE_FACTOR * lastSnapshotBytes)) {
+            // 真正的慢客户端：丢弃是安全的，但不能「丢完就没了」——安排一次延迟
+            // 重发，等缓冲排空后快照最终必达（否则若此后再无事件，客户端将永久
+            // 停留在旧快照）。重发仍走 flushSnapshot：缓冲未排空则再次顺延。
+            if (!snapshotRetryTimer) {
+                snapshotRetryTimer = setTimeout(() => {
+                    snapshotRetryTimer = null;
+                    service.get(clientId ?? "")?.flushSnapshot();
+                }, SNAPSHOT_RETRY_MS);
+            }
             return;
         }
         const wire = serializeShared(msg);
@@ -466,6 +483,10 @@ wss.on("connection", (ws) => {
             lastSnapshotBytes = wire.length * 2;
         ws.send(wire);
     };
+    // Plugins broadcast to every open socket; unregister on close below.
+    // Plugins broadcast to every open socket; unregister on close below. The
+    // cid getter lets plugins target THIS socket via host.sendTo(clientId).
+    const removePluginSender = pluginMgr.addSender(send, () => clientId);
     const dispatch = (msg) => {
         if (!clientId) {
             pending.push(msg);
@@ -522,6 +543,12 @@ wss.on("connection", (ws) => {
             case "list_projects":
                 void cs.pushProjects();
                 break;
+            case "remove_project":
+                void cs.removeProject(msg.path);
+                break;
+            case "delete_session":
+                void cs.deleteSession(msg.path);
+                break;
             case "switch_session":
                 void cs.switchSession(msg.path);
                 break;
@@ -570,9 +597,6 @@ wss.on("connection", (ws) => {
             case "check_update":
                 void cs.checkUpdate();
                 break;
-            case "update_app":
-                void cs.updateApp();
-                break;
             case "dialog_response":
                 cs.resolveDialog(msg.id, msg.value);
                 break;
@@ -603,6 +627,9 @@ wss.on("connection", (ws) => {
             case "refresh_provider_models":
                 void cs.refreshProviderModels(msg.providerId, msg.reqId);
                 break;
+            case "clone_provider":
+                void cs.cloneProvider(msg.provider, msg.reqId);
+                break;
             case "terminal_create": {
                 const tm = cs.getTerminalManager(msg.conversationId);
                 if (tm)
@@ -660,7 +687,10 @@ wss.on("connection", (ws) => {
                     customSystemPrompt: msg.customSystemPrompt,
                     disabledSkills: msg.disabledSkills,
                     disabledExtensions: msg.disabledExtensions,
+                    disabledPlugins: msg.disabledPlugins,
                     terminalToolsEnabled: msg.terminalToolsEnabled,
+                    terminalBash: msg.terminalBash,
+                    terminalBashIdleMs: msg.terminalBashIdleMs,
                     visionBridgeEnabled: msg.visionBridgeEnabled,
                     visionBridgeModel: msg.visionBridgeModel,
                     visionBridgePromptMode: msg.visionBridgePromptMode,
@@ -672,6 +702,12 @@ wss.on("connection", (ws) => {
             case "extensions_reload":
                 void cs.reloadExtensions();
                 break;
+            case "plugin_message":
+                pluginMgr.handleMessage(msg.pluginId, msg.payload, clientId ?? undefined);
+                break;
+            case "plugins_reload":
+                void pluginMgr.reload().then(() => pluginMgr.pushToAll());
+                break;
             case "save_preset":
                 void cs.savePreset(msg.name);
                 break;
@@ -708,6 +744,12 @@ wss.on("connection", (ws) => {
                     protocolVersion: PROTOCOL_VERSION,
                 });
                 cs.flushSnapshot();
+                // Plugin catalog: re-scan + activate new dirs on every attach so
+                // freshly dropped plugins show up without a server restart.
+                pluginMgr
+                    .ensureLoaded()
+                    .then((plugins) => send({ type: "plugins", plugins, epoch: pluginMgr.epoch }))
+                    .catch(() => { });
                 // Replay anything that arrived while the session was starting.
                 const queued = pending;
                 pending = [];
@@ -742,6 +784,11 @@ wss.on("connection", (ws) => {
         service.noteSocketClose();
         closed = true;
         pending = [];
+        removePluginSender();
+        if (snapshotRetryTimer) {
+            clearTimeout(snapshotRetryTimer);
+            snapshotRetryTimer = null;
+        }
         if (clientId)
             service.detach(clientId, send);
     });
@@ -792,6 +839,7 @@ async function shutdown() {
     console.log("\nshutting down…");
     clearInterval(heartbeatTimer);
     stopControl();
+    pluginMgr.dispose();
     await service.disposeAll();
     wss.close();
     httpServer.close();

package/dist/server/model-admin.js

@@ -233,6 +233,100 @@ export class ModelAdminService {
         }
         this.host.flushSnapshot();
     }
+    /**
+     * Copy a BUILT-IN provider (baseUrl + current model catalog) into an
+     * editable custom-provider draft and return it via clone_provider_result.
+     * Nothing is persisted — the user renames the draft, pastes a DIFFERENT
+     * API key in the form, then saves via save_model_config. Credentials are
+     * never copied: the whole point is running a second key alongside the
+     * built-in one without touching it.
+     */
+    async cloneProvider(providerId, reqId) {
+        const pid = providerId.trim();
+        const fail = (error) => this.host.emit({ type: "clone_provider_result", reqId, ok: false, error });
+        try {
+            if (!pid) {
+                fail("请填写服务商 ID");
+                return;
+            }
+            const mr = this.host.modelRuntime();
+            const p = mr.getProvider(pid);
+            if (!p) {
+                fail(`供应商 ${pid} 不存在`);
+                return;
+            }
+            if (!p.baseUrl) {
+                fail(`${pid} 没有 baseUrl（OAuth/环境变量型供应商），无法复制为自定义服务商`);
+                return;
+            }
+            // Map runtime models → models.json rows; dynamic providers ship an
+            // empty catalog until refreshed over the network.
+            const readModels = () => {
+                try {
+                    return mr.getModels(pid).map((m) => ({
+                        api: m.api,
+                        entry: {
+                            id: m.id,
+                            ...(m.name && m.name !== m.id ? { name: m.name } : {}),
+                            ...(m.reasoning ? { reasoning: true } : {}),
+                            ...(m.input?.includes("image")
+                                ? { input: ["text", "image"] }
+                                : {}),
+                            ...(m.contextWindow ? { contextWindow: m.contextWindow } : {}),
+                            ...(m.maxTokens ? { maxTokens: m.maxTokens } : {}),
+                        },
+                    }));
+                }
+                catch {
+                    return [];
+                }
+            };
+            let models = readModels();
+            if (models.length === 0) {
+                await mr.refresh({ allowNetwork: true });
+                models = readModels();
+            }
+            if (models.length === 0) {
+                fail(`${pid} 的模型列表为空，无法复制（请稍后重试）`);
+                return;
+            }
+            // models.json 的 api 是 provider 级：取占比最高的 api，只复制该 api 的模型。
+            const counts = new Map();
+            for (const m of models)
+                counts.set(m.api, (counts.get(m.api) ?? 0) + 1);
+            let api = models[0].api;
+            for (const [k, v] of counts)
+                if (v > (counts.get(api) ?? 0))
+                    api = k;
+            const kept = models.filter((m) => m.api === api).map((m) => m.entry);
+            // Suggest a free id (<pid>-2, -3, …) — save_model_config would silently
+            // overwrite an existing custom entry with the same id.
+            const taken = new Set([
+                ...Object.keys(this.readModelsConfig().providers),
+                ...mr.getRegisteredProviderIds(),
+            ]);
+            let newId = `${pid}-2`;
+            for (let n = 2; taken.has(newId); n++)
+                newId = `${pid}-${n}`;
+            const config = {
+                providerId: newId,
+                name: p.name,
+                api,
+                baseUrl: p.baseUrl,
+                models: kept,
+            };
+            this.host.emit({
+                type: "notice",
+                level: "info",
+                text: `📋 已复制 ${pid} → ${newId}（${kept.length} 个模型），请填入新的 API 密钥后保存`,
+            });
+            this.host.emit({ type: "clone_provider_result", reqId, ok: true, config });
+        }
+        catch (err) {
+            fail(`复制服务商失败：${err.message}`);
+        }
+        this.host.flushSnapshot();
+    }
     /** Enumerate pi's built-in providers with auth status (key-only config). */
     async listProviders() {
         const mr = this.host.modelRuntime();