pi-web-ui 0.31.0 → 0.32.0

package/dist/server/agent-service.js

@@ -79,14 +79,14 @@ export class QuiesceRejectedError extends Error {
  *  programs wait for input that never comes. Legacy Chinese files are often
  *  GBK/GB2312 — read them with the right encoding, never paste mojibake into
  *  reasoning/answers. */
-const WINDOWS_PERSONA = `You are a coding agent running on Windows. The bash tool runs Git Bash (bash.exe), not PowerShell. Follow these rules to avoid hanging the session:
-
-
-
-- ALWAYS pass a timeout parameter to the bash tool (in seconds). There is NO default timeout — a command that never finishes (servers, watchers, infinite loops, slow downloads/installs) will hang the entire conversation indefinitely. Pick a generous timeout for long-running work, but never omit it.
-- NEVER run interactive or foreground long-running commands through the bash tool (vi, less, top, python -, node -, npm run dev, sleep 10000). For servers/daemons use background execution with output redirected to a log file, then poll the log; stop them when done.
-- In the interactive terminal (TTY) — which is Git Bash too, not PowerShell — NEVER use heredocs (<<'EOF' ... EOF) or here-strings, and NEVER start interactive programs (vi, less, python -, node -, npm init): they wait for keyboard input that never arrives and hang the terminal forever. Prefer writing a temp script file (e.g. .pi-tmp.sh) and running it non-interactively. ALWAYS pass a timeout to long-running commands (e.g. \`timeout 120 npm run dev\`).
-
+const WINDOWS_PERSONA = `You are a coding agent running on Windows. The bash tool runs Git Bash (bash.exe), not PowerShell. Follow these rules to avoid hanging the session:
+
+
+
+- ALWAYS pass a timeout parameter to the bash tool (in seconds). There is NO default timeout — a command that never finishes (servers, watchers, infinite loops, slow downloads/installs) will hang the entire conversation indefinitely. Pick a generous timeout for long-running work, but never omit it.
+- NEVER run interactive or foreground long-running commands through the bash tool (vi, less, top, python -, node -, npm run dev, sleep 10000). For servers/daemons use background execution with output redirected to a log file, then poll the log; stop them when done.
+- In the interactive terminal (TTY) — which is Git Bash too, not PowerShell — NEVER use heredocs (<<'EOF' ... EOF) or here-strings, and NEVER start interactive programs (vi, less, python -, node -, npm init): they wait for keyboard input that never arrives and hang the terminal forever. Prefer writing a temp script file (e.g. .pi-tmp.sh) and running it non-interactively. ALWAYS pass a timeout to long-running commands (e.g. \`timeout 120 npm run dev\`).
+
 Many legacy Chinese text files (.html/.txt/.md/.log, exported documents) are GBK/GB2312 encoded: the read tool decodes UTF-8 only and will show mojibake (乱码) for them. If a file's content looks garbled, read it through the terminal instead: in Git Bash use \`cat file | iconv -f GBK -t UTF-8\` (or \`iconv -f GBK -t UTF-8 file\`); in cmd use \`chcp 65001 && type file\`; in PowerShell use \`Get-Content -Encoding Default file\`. Never paste mojibake into your reasoning or answer — describe the decoded content instead.`;
 /**
  * Killable bash tool: wraps the SDK bash tool with operations that register
@@ -1238,13 +1238,6 @@ export class ClientSession {
         }
         return 0;
     }
-    /** True once updateApp succeeded — the process must restart to run new code. */
-    pendingRestart = false;
-    /**
-     * Set by index.ts: called after a successful self-update; returns whether
-     * the process is going to restart itself (so the notice can say so).
-     */
-    onUpdateReady = undefined;
     /** Set by index.ts: called when /pi-web-ui:quit is invoked. */
     onQuit = undefined;
     /** Ask the npm registry for the latest pi-web-ui version and report it. */
@@ -1269,7 +1262,6 @@ export class ClientSession {
                 latest,
                 latestPublishedAt,
                 upToDate,
-                pendingRestart: this.pendingRestart,
             });
         }
         catch (err) {
@@ -1279,115 +1271,10 @@ export class ClientSession {
                 latest: null,
                 latestPublishedAt: null,
                 upToDate: false,
-                pendingRestart: this.pendingRestart,
                 error: `检查更新失败：${err.message}`,
             });
         }
     }
-    /**
-     * After `npm i -g`, confirm the on-disk package this process serves from
-     * actually changed to the new version and is complete. Windows npm updates
-     * can fail partway (locked files / Defender / npm rollback) and leave the
-     * global install without its bin links — restarting into that is a silent
-     * crash (web/dist missing + `pi-web-ui` no longer on PATH). Returns null
-     * when OK, else a human-readable problem description.
-     */
-    static verifyGlobalInstall() {
-        try {
-            const here = dirname(fileURLToPath(import.meta.url));
-            const pkgRoot = resolve(here, "..", "..");
-            const pkg = JSON.parse(readFileSync(join(pkgRoot, "package.json"), "utf8"));
-            if (!pkg.version || pkg.version === ClientSession.currentAppVersion()) {
-                return `安装目录版本未变化（${pkg.version ?? "未知"}）`;
-            }
-            if (!existsSync(join(pkgRoot, "web", "dist", "index.html"))) {
-                return "web/dist/index.html 缺失（前端产物未安装完整）";
-            }
-            if (!existsSync(join(pkgRoot, "bin", "pi-web-ui.mjs"))) {
-                return "bin/pi-web-ui.mjs 缺失";
-            }
-            if (process.platform === "win32") {
-                const prefix = dirname(process.execPath);
-                const hasShim = existsSync(join(prefix, "pi-web-ui.cmd")) ||
-                    existsSync(join(prefix, "pi-web-ui.ps1"));
-                if (!hasShim)
-                    return "pi-web-ui 命令入口（bin 链接）未生成";
-            }
-            return null;
-        }
-        catch (err) {
-            return `读取安装目录失败：${err.message}`;
-        }
-    }
-    /** npm i -g pi-web-ui@latest — the new code only takes effect after a restart. */
-    async updateApp() {
-        try {
-            this.emit({
-                type: "notice",
-                level: "info",
-                text: "正在更新 pi-web-ui（npm i -g pi-web-ui@latest）…",
-            });
-            const { code, out } = await this.runAsync("npm", ["i", "-g", "pi-web-ui@latest"], 180_000);
-            if (code !== 0) {
-                this.emit({
-                    type: "update_result",
-                    ok: false,
-                    detail: `npm i 失败（${code ?? "timeout"}）：${out.slice(0, 400)}`,
-                });
-                this.emit({
-                    type: "notice",
-                    level: "error",
-                    text: `更新 pi-web-ui 失败（${code ?? "timeout"}）：${out.slice(0, 300)}`,
-                });
-                return;
-            }
-            // npm reported success, but on Windows the replacement can be partial
-            // (locked files, rollback) — restarting into a broken install is a
-            // crash with no hint. Verify before handing over.
-            const problem = ClientSession.verifyGlobalInstall();
-            if (problem) {
-                this.emit({
-                    type: "update_result",
-                    ok: false,
-                    detail: `npm i 成功但安装不完整（${problem}）。请手动执行 npm i -g pi-web-ui@latest 修复后再重启服务。`,
-                });
-                this.emit({
-                    type: "notice",
-                    level: "error",
-                    text: `更新未完整生效（${problem}）。请手动执行 npm i -g pi-web-ui@latest 修复`,
-                });
-                return;
-            }
-            this.pendingRestart = true;
-            this.emit({
-                type: "update_result",
-                ok: true,
-                detail: out.slice(0, 400),
-            });
-            const autoRestart = this.onUpdateReady?.() ?? false;
-            this.emit({
-                type: "notice",
-                level: "info",
-                text: autoRestart
-                    ? "✅ 已更新 pi-web-ui，正在自动重启…"
-                    : "✅ 已更新 pi-web-ui，重启服务后生效（pi-web-ui server restart）",
-            });
-        }
-        catch (err) {
-            this.emit({
-                type: "update_result",
-                ok: false,
-                detail: String(err),
-            });
-            this.emit({
-                type: "notice",
-                level: "error",
-                text: `更新 pi-web-ui 失败：${err.message}`,
-            });
-        }
-        // Re-check so the UI reflects the new state (pendingRestart included).
-        void this.checkUpdate();
-    }
     async installPiAgent() {
         try {
             mkdirSync(this.agentDir, { recursive: true });
@@ -1491,6 +1378,12 @@ export class ClientSession {
     refreshProviderModels(providerId, reqId) {
         return this.modelAdmin.refreshProviderModels(providerId, reqId);
     }
+    /** Copy a built-in provider into an editable custom-provider draft
+     *  (clone_provider_result) — lets the user run a second API key without
+     *  overwriting the built-in one. */
+    cloneProvider(providerId, reqId) {
+        return this.modelAdmin.cloneProvider(providerId, reqId);
+    }
     saveModelConfig(providerId, config) {
         return this.modelAdmin.saveModelConfig(providerId, config);
     }
@@ -2485,11 +2378,6 @@ export class AgentService {
     socketCount = 0;
     pending = new Map();
     stateStore;
-    /**
-     * Set by index.ts: called by a client session after a successful
-     * self-update; returns whether the process will restart itself.
-     */
-    onUpdateReady = undefined;
     /** Set by index.ts: called when /pi-web-ui:quit is invoked. */
     onQuit = undefined;
     constructor(cwd, stateFile) {
@@ -2603,7 +2491,6 @@ export class AgentService {
         cs.notifyInterrupted(this.stateStore.takeInterrupted(clientId));
         cs.attachSink(send);
         // Forward hooks (set once by index.ts) to every session.
-        cs.onUpdateReady = this.onUpdateReady;
         cs.onQuit = this.onQuit;
         cs.isQuiesced = () => this.quiesced;
         return cs;

package/dist/server/attachments.js

@@ -397,9 +397,9 @@ export async function buildAttachmentMessages(ctx, attachments) {
                         content: [
                             {
                                 type: "text",
-                                text: `
-<vision-bridge>
-${transcript}
+                                text: `
+<vision-bridge>
+${transcript}
 </vision-bridge>`,
                             },
                             ...(pathImg

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";
@@ -342,49 +341,12 @@ const service = new AgentService(CWD,
 // Per-client persisted UI state: last-used workspace + recent projects.
 join(DATA_DIR, "client-state.json"));
 // ---------------------------------------------------------------------------
-// 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 +372,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 +403,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 +421,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);
@@ -570,9 +553,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 +583,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)
@@ -742,6 +725,10 @@ wss.on("connection", (ws) => {
         service.noteSocketClose();
         closed = true;
         pending = [];
+        if (snapshotRetryTimer) {
+            clearTimeout(snapshotRetryTimer);
+            snapshotRetryTimer = null;
+        }
         if (clientId)
             service.detach(clientId, send);
     });

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();

package/dist/server/terminals.js

@@ -790,10 +790,10 @@ export const TERMINAL_TOOL_NAMES = [
 /** System-prompt guidance teaching the model WHEN to prefer the terminal tools
  *  over one-shot bash. Without it models almost never pick them — bash returns
  *  complete output in a single call, so it always wins on convenience. */
-export const TERMINAL_TOOLS_GUIDANCE = `Persistent interactive terminal tools are available (terminal_create / terminal_list / terminal_close / terminal_input / terminal_key / terminal_read). The one-shot bash tool stays the DEFAULT for ordinary commands - it runs once and returns the full output. Switch to the terminal tools only when:
-- The program is interactive or TUI-based (REPLs like python/node, vim/htop, installers asking y/n, anything waiting on stdin).
-- You start a long-running server or watcher and want to keep watching its output (terminal_read with waitMs) or send keys to it later (e.g. interrupt via terminal_key with Ctrl+c).
-- The user explicitly asks you to work in the visible terminal panel.
+export const TERMINAL_TOOLS_GUIDANCE = `Persistent interactive terminal tools are available (terminal_create / terminal_list / terminal_close / terminal_input / terminal_key / terminal_read). The one-shot bash tool stays the DEFAULT for ordinary commands - it runs once and returns the full output. Switch to the terminal tools only when:
+- The program is interactive or TUI-based (REPLs like python/node, vim/htop, installers asking y/n, anything waiting on stdin).
+- You start a long-running server or watcher and want to keep watching its output (terminal_read with waitMs) or send keys to it later (e.g. interrupt via terminal_key with Ctrl+c).
+- The user explicitly asks you to work in the visible terminal panel.
 Do NOT use them for simple one-shot commands; bash remains cheaper and simpler there.`;
 /** Build the agent-facing persistent terminal tools for one conversation. */
 export function makePersistentTerminalTools(terminals, cwd) {