pi-web-ui 0.68.2 → 0.70.0

package/dist/server/terminals.js

@@ -24,6 +24,7 @@ import "./patch-node-pty.js";
 import { spawn } from "node-pty";
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { bilingual, pick } from "./i18n.js";
 /** Location of the command list for a project: <workspaceRoot>/.pi/commands.json */
 export function commandsFilePath(workspaceRoot) {
     return join(workspaceRoot, ".pi", "commands.json");
@@ -642,6 +643,7 @@ export function encodeTerminalKey(key, modifiers = {}) {
 export class TerminalManager {
     emit;
     workspaceRoot;
+    lang;
     /** Live PTYs only. Exited entries move to history so they no longer consume
      * the live-terminal limit while their output remains readable/replayable. */
     terms = new Map();
@@ -651,9 +653,12 @@ export class TerminalManager {
     /** 宿主回调：AI 触碰过的终端静默 ≥ 阈值时触发（一次性/纪元语义见
      *  noteAgentActivity）。宿主自行判断会话是否在运行并决定是否注入。 */
     onAgentIdle = null;
-    constructor(emit, workspaceRoot) {
+    constructor(emit, workspaceRoot, 
+    // issue #91：按键/输入校验错误按客户端 UI 语言出中英（英文默认）。
+    lang) {
         this.emit = emit;
         this.workspaceRoot = workspaceRoot;
+        this.lang = lang;
     }
     /** Start a plain interactive shell in the given directory. */
     create(id, cwd, cols, rows, fallbackCwd, title, opts) {
@@ -1004,6 +1009,17 @@ export class TerminalManager {
     list() {
         return [...this.terms.values(), ...this.history.values()].map((entry) => this.info(entry));
     }
+    /** Count of LIVE PTYs only — exited terminals that merely retain their
+     *  output for review (history) do NOT count. Conversations are kept in the
+     *  running list while a live terminal exists; exited leftovers must not
+     *  pin an idle conversation forever. */
+    countLive() {
+        let n = 0;
+        for (const entry of this.terms.values())
+            if (!entry.exited)
+                n++;
+        return n;
+    }
     emitList() {
         this.emit({ type: "terminal_list", terminals: this.list() });
     }
@@ -1053,7 +1069,7 @@ export class TerminalManager {
             return `输入过长（上限 ${MAX_INPUT} 字符） Input too long (max ${MAX_INPUT} chars)`;
         const entry = this.terms.get(id);
         if (!entry || entry.exited)
-            return "终端不存在或进程已退出";
+            return pick(this.lang?.() ?? "en", "终端不存在或进程已退出", "Terminal not found or its process has exited", "terminals.not.found.exited");
         // 已武装的纪元里任何人（含用户手动敲键盘）写了输入都算新活动，重置倒计时。
         entry.lastActivityAt = Date.now();
         if (entry.idleTimer)
@@ -1377,29 +1393,33 @@ export function makeTerminalBashTool(terminals, opts) {
     return defineTool({
         name: "bash",
         label: "Run bash command",
-        description: "Run a shell command and return its full output plus exit code. Commands run in a visible terminal.\n" +
+        description: bilingual("Run a shell command and return its full output plus exit code. Commands run in a visible terminal.\n" +
             "persist=false (default, one-shot): a fresh terminal is created per call, run to completion, then the shell exits (the process ends) while its output stays in the terminal list for later review — like a normal bash call, but each command also leaves a viewable terminal record.\n" +
             "persist=true: commands run in the PERSISTENT visible terminal 'ai-bash' — shell state such as cd, venv activation or ssh sessions is retained across calls; you can use terminal_wait to re-block on a backgrounded command, or terminal_read / terminal_input / terminal_key on 'ai-bash' to observe or interact anytime.\n" +
-            "Run the bare command — do NOT pipe through head/tail/more/less (output is returned complete anyway, and pipes hide live progress in the terminal). Use the head/tail parameters instead to trim the returned output. For interactive commands (REPLs, prompts, installers asking y/n) set persist=true and drive them with terminal_input / terminal_key.",
-        promptSnippet: "run shell commands (persist=true keeps the terminal alive across calls)",
+            "Run the bare command — do NOT pipe through head/tail/more/less (output is returned complete anyway, and pipes hide live progress in the terminal). Use the head/tail parameters instead to trim the returned output. For interactive commands (REPLs, prompts, installers asking y/n) set persist=true and drive them with terminal_input / terminal_key.", "运行 shell 命令并返回完整输出与退出码。命令在可见终端中运行。\n" +
+            "persist=false（默认，一次性）：每次调用新建一个终端，运行至结束，然后 shell 退出（进程结束），输出保留在终端列表中供稍后查看——如同普通 bash 调用，但每条命令都会留下一条可查看的终端记录。\n" +
+            "persist=true：命令在常驻可见终端 'ai-bash' 中运行——cd、venv 激活、ssh 会话等 shell 状态跨调用保留；可用 terminal_wait 重新阻塞等待后台命令，或随时用 terminal_read / terminal_input / terminal_key 观察或交互。\n" +
+            "直接运行裸命令——不要经 head/tail/more/less 管道（反正会返回完整输出，管道还会挡住终端里的实时进度）。用 head/tail 参数截断返回的输出。交互式命令（REPL、提示符、问 y/n 的安装程序）请设 persist=true 并用 terminal_input / terminal_key 驱动。"),
+        promptSnippet: bilingual("run shell commands (persist=true keeps the terminal alive across calls)", "运行 shell 命令（persist=true 让终端跨调用保持存活）"),
         parameters: Type.Object({
-            command: Type.String({ description: "The shell command to run" }),
-            timeout: Type.Optional(Type.Number({ description: "Optional timeout in seconds" })),
+            command: Type.String({ description: bilingual("The shell command to run", "要运行的 shell 命令") }),
+            timeout: Type.Optional(Type.Number({ description: bilingual("Optional timeout in seconds", "可选的超时秒数") })),
             persist: Type.Optional(Type.Boolean({
-                description: "Keep the terminal alive after the command (default: false → a one-shot terminal that exits when the command finishes while its output is retained for review). true runs in the persistent 'ai-bash' terminal so shell state (cd/venv/ssh) is retained across calls and the terminal stays interactive.",
+                description: bilingual("Keep the terminal alive after the command (default: false → a one-shot terminal that exits when the command finishes while its output is retained for review). true runs in the persistent 'ai-bash' terminal so shell state (cd/venv/ssh) is retained across calls and the terminal stays interactive.", "运行后保持终端存活（默认 false → 命令结束时退出的、输出保留供查看的一次性终端）。true 则在常驻 'ai-bash' 终端中运行，shell 状态（cd/venv/ssh）跨调用保留、终端保持可交互。"),
             })),
             head: Type.Optional(Type.Integer({
                 minimum: 1,
                 maximum: 5000,
-                description: "Only return the FIRST N lines of output (like `| head -N`). Use this for verbose commands instead of piping through head.",
+                description: bilingual("Only return the FIRST N lines of output (like `| head -N`). Use this for verbose commands instead of piping through head.", "只返回输出的前 N 行（如 `| head -N`）。输出冗长的命令请用它，而不要经 head 管道。"),
             })),
             tail: Type.Optional(Type.Integer({
                 minimum: 1,
                 maximum: 5000,
-                description: "Only return the LAST N lines of output (like `| tail -N`). Use this for verbose commands instead of piping through tail.",
+                description: bilingual("Only return the LAST N lines of output (like `| tail -N`). Use this for verbose commands instead of piping through tail.", "只返回输出的后 N 行（如 `| tail -N`）。输出冗长的命令请用它，而不要经 tail 管道。"),
             })),
         }),
         execute: async (_id, p, signal) => {
+            const lang = opts.lang?.() ?? "en";
             const persist = p.persist ?? opts.defaultPersist();
             // create() 对已存活的同名终端原样返回、对已退出的原地重启。
             // forceBash：该终端永远跑 bash（而非用户登录 shell），模型写的
@@ -1412,7 +1432,7 @@ export function makeTerminalBashTool(terminals, opts) {
                 forceBash: true,
                 agentBash: true,
             }) === null) {
-                throw new Error(`无法打开 AI bash 终端（${termId}）`);
+                throw new Error(pick(lang, `无法打开 AI bash 终端（${termId}）`, `Failed to open the AI bash terminal (${termId})`, "terminals.bash.open.failed", { termId }));
             }
             // 阻塞等待期间挂起活力提醒（我们自己在检测静默，避免双重通知）。
             terminals.suspendIdleWatch(termId);
@@ -1439,12 +1459,15 @@ export function makeTerminalBashTool(terminals, opts) {
             // tail 文件让模型看到日志尾部与真实退出码（否则输出为空）。
             const redirect = stripped && limiter.kind === "tail" ? detectStdoutRedirect(runCommand) : null;
             const tailFile = redirect ? { file: redirect.file, lines: limiter.lines ?? 10 } : undefined;
+            // 复杂子表达式先 hoist 成干净 const（issue #91 v2：vars key 不写复杂表达式）。
+            const limiterSegment = limiter.segment;
+            const limiterTailLines = limiter.lines ?? 10;
+            const limiterTailZh = limiter.kind === "tail" ? `本次返回末尾 ${limiterTailLines} 行。` : "本次返回全部输出。";
+            const limiterTailEn = limiter.kind === "tail"
+                ? `Returning the last ${limiterTailLines} lines this time.`
+                : "Returning the full output this time.";
             const limiterNote = stripped
-                ? "\n[注：检测到你带了「" +
-                    limiter.segment +
-                    "」这类限输出/过滤管道——已在终端里直跑底层命令（实时可见 + 真实退出码），只按参数返回片段。" +
-                    (limiter.kind === "tail" ? "本次返回末尾 " + (limiter.lines ?? 10) + " 行。" : "本次返回全部输出。") +
-                    " 后续直接用 bash(command, tail=N) 参数限输出。]"
+                ? pick(lang, `\n[注：检测到你带了「${limiterSegment}」这类限输出/过滤管道——已在终端里直跑底层命令（实时可见 + 真实退出码），只按参数返回片段。${limiterTailZh} 后续直接用 bash(command, tail=N) 参数限输出。]`, `\n[Note: detected a trailing output-limiting pipe "${limiterSegment}" — ran the underlying command directly in the terminal (live output + real exit code) and trimmed only the returned slice. ${limiterTailEn} Next time use the bash(command, tail=N) parameter to limit output.]`, "terminals.bash.limiter.note", { limiterSegment, limiterTailZh, limiterTailEn })
                 : "";
             try {
                 let collected = "";
@@ -1461,7 +1484,7 @@ export function makeTerminalBashTool(terminals, opts) {
                         terminals.setSentinelPending(termId, false);
                         terminals.inputChecked(termId, "\x03");
                         closeOneShot();
-                        throw new Error("Command aborted");
+                        throw new Error(pick(lang, "命令已中止", "Command aborted", "terminals.bash.aborted"));
                     }
                     await sleep(60);
                     const read = terminals.read(termId, cursor);
@@ -1489,11 +1512,12 @@ export function makeTerminalBashTool(terminals, opts) {
                         terminals.setSentinelPending(termId, false);
                         terminals.inputChecked(termId, "\x03");
                         closeOneShot();
-                        throw new Error(`Command timed out after ${p.timeout}s（已发 Ctrl+C；已有输出：${truncateMiddle(stripAnsi(collected), 4000)}）`);
+                        const timeoutPartial = truncateMiddle(stripAnsi(collected), 4000);
+                        throw new Error(pick(lang, `Command timed out after ${p.timeout}s（已发 Ctrl+C；已有输出：${timeoutPartial}）`, `Command timed out after ${p.timeout}s (sent Ctrl+C; partial output: ${timeoutPartial})`, "terminals.bash.timeout", { "p.timeout": p.timeout, timeoutPartial }));
                     }
                     // 静默解阻（仅持久终端）：转后台 + 注册完成观察器，立即把控制权还给模型。
                     if (persist && idleMs > 0 && Date.now() - lastDataAt >= idleMs) {
-                        return backgroundResult(terminals, opts, runCommand, applyHeadTail(cleanBashOutput(collected), p.head, effectiveTail), Math.round((Date.now() - lastDataAt) / 1000));
+                        return backgroundResult(terminals, opts, runCommand, applyHeadTail(cleanBashOutput(collected), p.head, effectiveTail), Math.round((Date.now() - lastDataAt) / 1000), lang);
                     }
                 }
             }
@@ -1504,7 +1528,7 @@ export function makeTerminalBashTool(terminals, opts) {
     });
 }
 /** 静默解阻路径：注册完成观察器后立即返回「仍在后台运行」。 */
-function backgroundResult(terminals, opts, command, partialText, silentSeconds) {
+function backgroundResult(terminals, opts, command, partialText, silentSeconds, lang) {
     terminals.watchOutput("ai-bash", BASH_SENTINEL_RE, (m) => {
         // 后台命令最终结束（或终端被关）→ 清除待决标记，terminal_wait 不再适用。
         terminals.setSentinelPending("ai-bash", false);
@@ -1516,14 +1540,20 @@ function backgroundResult(terminals, opts, command, partialText, silentSeconds)
     });
     // partialText 已在调用方做过 cleanBashOutput + applyTail。
     const partial = truncateMiddle(partialText, 6000);
+    // 空输出占位按语言预渲染（issue #91 v2：vars 只收干净标识）。
+    const partialZh = partial || "（暂无输出）";
+    const partialEn = partial || "(no output yet)";
     return {
         content: [
             {
                 type: "text",
-                text: `命令仍在持久终端 ai-bash 中运行（已连续 ${silentSeconds} 秒无输出，未结束）。` +
+                text: pick(lang, `命令仍在持久终端 ai-bash 中运行（已连续 ${silentSeconds} 秒无输出，未结束）。` +
                     `本次调用不阻塞——命令继续在后台执行，结束时你会收到自动通知。\n` +
-                    `已有输出：\n${partial || "（暂无输出）"}\n` +
-                    `要重新阻塞等它结束就用 terminal_wait(terminalId="ai-bash")（无需反复轮询）；需要交互用 terminal_input / terminal_key（Ctrl+C 可终止）。`,
+                    `已有输出：\n${partialZh}\n` +
+                    `要重新阻塞等它结束就用 terminal_wait(terminalId="ai-bash")（无需反复轮询）；需要交互用 terminal_input / terminal_key（Ctrl+C 可终止）。`, `Command still running in the persistent terminal ai-bash (no output for ${silentSeconds}s, not finished). ` +
+                    `This call does not block — the command keeps running in the background and you will be notified automatically when it finishes.\n` +
+                    `Partial output:\n${partialEn}\n` +
+                    `To block until it finishes, use terminal_wait(terminalId="ai-bash") (no polling needed); use terminal_input / terminal_key to interact (Ctrl+C aborts).`, "terminals.bash.background.running", { silentSeconds, partialZh, partialEn }),
             },
         ],
         details: { running: true, terminalId: "ai-bash", silentSeconds },
@@ -1548,7 +1578,10 @@ export const TERMINAL_TOOLS_GUIDANCE = `Persistent interactive terminal tools ar
 - The user explicitly asks you to work in the visible terminal panel.
 Liveness watchdog: terminals you touched (create/input/key) are monitored - if one goes silent with no new output while you are working (default 15s), an automatic system reminder is injected into the conversation. Treat it as a prompt to check that terminal (terminal_read), respond to an input prompt (terminal_input / terminal_key), or close it (terminal_close) if it is no longer needed.`;
 /** Build the agent-facing persistent terminal tools for one conversation. */
-export function makePersistentTerminalTools(terminals, cwd) {
+export function makePersistentTerminalTools(terminals, cwd, 
+/** per-call 返回文本的服务端语言（默认英文）；工具 definition 走 bilingual 内联双语。 */
+lang) {
+    const getLang = lang ?? (() => "en");
     const result = (text, details = {}) => ({ content: [{ type: "text", text }], details });
     const failIf = (error) => {
         if (error)
@@ -1558,62 +1591,70 @@ export function makePersistentTerminalTools(terminals, cwd) {
         defineTool({
             name: "terminal_create",
             label: "Create terminal",
-            description: "Create a named persistent interactive PTY in the current workspace. Use terminal_input or terminal_key to interact with it and terminal_read to inspect incremental output. Prefer this over bash when the program is interactive/TUI-based (REPLs, vim/htop, y/n prompts), when starting a long-running server you want to keep observing or interrupt, or when the user asks to work in the visible terminal. For simple one-shot commands use bash instead.",
-            promptSnippet: "run interactive programs or long-running servers in a persistent visible PTY (multi-step: create → input/key → read)",
+            description: bilingual("Create a named persistent interactive PTY in the current workspace. Use terminal_input or terminal_key to interact with it and terminal_read to inspect incremental output. Prefer this over bash when the program is interactive/TUI-based (REPLs, vim/htop, y/n prompts), when starting a long-running server you want to keep observing or interrupt, or when the user asks to work in the visible terminal. For simple one-shot commands use bash instead.", "在当前工作区创建具名常驻交互式 PTY。用 terminal_input 或 terminal_key 与之交互，用 terminal_read 查看增量输出。程序是交互式/TUI（REPL、vim/htop、y/n 提示）、要启动长驻服务并持续观察或中断、或用户明确要求在可见终端里操作时，优先用它而非 bash。简单的一次性命令请用 bash。"),
+            promptSnippet: bilingual("run interactive programs or long-running servers in a persistent visible PTY (multi-step: create → input/key → read)", "在常驻可见 PTY 中运行交互式程序或长驻服务（多步：create → input/key → read）"),
             parameters: Type.Object({
-                terminalId: Type.String({ description: "Stable terminal name" }),
-                cwd: Type.Optional(Type.String({ description: "Workspace-relative directory" })),
+                terminalId: Type.String({ description: bilingual("Stable terminal name", "稳定的终端名称") }),
+                cwd: Type.Optional(Type.String({ description: bilingual("Workspace-relative directory", "工作区相对目录") })),
                 cols: Type.Optional(Type.Integer({ minimum: 2, maximum: 500 })),
                 rows: Type.Optional(Type.Integer({ minimum: 2, maximum: 200 })),
             }),
             execute: async (_id, p) => {
+                const lang = getLang();
                 const info = terminals.create(p.terminalId, p.cwd ?? cwd, p.cols ?? 120, p.rows ?? 40, cwd, p.terminalId);
+                const infoJson = JSON.stringify(info);
                 if (!info)
-                    throw new Error(`创建终端失败：${p.terminalId}`);
+                    throw new Error(pick(lang, `创建终端失败：${p.terminalId}`, `Failed to create terminal: ${p.terminalId}`, "terminals.create.failed", { "p.terminalId": p.terminalId }));
                 // AI 创建 → 启动活力检测纪元（静默提醒只针对 agent 触碰过的终端）。
                 terminals.noteAgentActivity(p.terminalId);
-                return result(`终端已创建：${JSON.stringify(info)}`, info);
+                return result(pick(lang, `终端已创建：${infoJson}`, `Terminal created: ${infoJson}`, "terminals.create.done", { infoJson }), info);
             },
         }),
         defineTool({
             name: "terminal_list",
             label: "List terminals",
-            description: "List all persistent PTY terminals owned by this conversation.",
-            promptSnippet: "list persistent terminals",
+            description: bilingual("List all persistent PTY terminals owned by this conversation.", "列出本对话拥有的全部常驻 PTY 终端。"),
+            promptSnippet: bilingual("list persistent terminals", "列出常驻终端"),
             parameters: Type.Object({}),
             execute: async () => result(JSON.stringify(terminals.list()), terminals.list()),
         }),
         defineTool({
             name: "terminal_close",
             label: "Close terminal",
-            description: "Close a persistent PTY and terminate its process tree.",
+            description: bilingual("Close a persistent PTY and terminate its process tree.", "关闭常驻 PTY 并终止其进程树。"),
             parameters: Type.Object({ terminalId: Type.String() }),
             execute: async (_id, p) => {
+                const lang = getLang();
                 if (!terminals.has(p.terminalId))
-                    throw new Error(`终端不存在：${p.terminalId}`);
+                    throw new Error(pick(lang, `终端不存在：${p.terminalId}`, `Terminal not found: ${p.terminalId}`, "terminals.close.not.found", { "p.terminalId": p.terminalId }));
                 terminals.kill(p.terminalId);
-                return result(`终端已关闭：${p.terminalId}`);
+                return result(pick(lang, `终端已关闭：${p.terminalId}`, `Terminal closed: ${p.terminalId}`, "terminals.close.done", {
+                    "p.terminalId": p.terminalId,
+                }));
             },
         }),
         defineTool({
             name: "terminal_input",
             label: "Send terminal input",
-            description: "Send arbitrary text to a persistent PTY. Include newline when a command should be submitted.",
+            description: bilingual("Send arbitrary text to a persistent PTY. Include newline when a command should be submitted.", "向常驻 PTY 发送任意文本。需要提交命令时带上换行。"),
             parameters: Type.Object({ terminalId: Type.String(), data: Type.String() }),
             execute: async (_id, p) => {
+                const lang = getLang();
                 failIf(terminals.inputChecked(p.terminalId, p.data));
                 // AI 发了输入 = 在等结果，重开一个静默纪元。
                 terminals.noteAgentActivity(p.terminalId);
-                return result(`已发送 ${p.data.length} 个字符到 ${p.terminalId}`);
+                return result(pick(lang, `已发送 ${p.data.length} 个字符到 ${p.terminalId}`, `Sent ${p.data.length} chars to ${p.terminalId}`, "terminals.input.sent", { "p.data.length": p.data.length, "p.terminalId": p.terminalId }));
             },
         }),
         defineTool({
             name: "terminal_key",
             label: "Send terminal key",
-            description: "Send Enter, Tab, arrows, function keys, or Ctrl/Alt combinations to a persistent PTY.",
+            description: bilingual("Send Enter, Tab, arrows, function keys, or Ctrl/Alt combinations to a persistent PTY.", "向常驻 PTY 发送 Enter、Tab、方向键、功能键或 Ctrl/Alt 组合键。"),
             parameters: Type.Object({
                 terminalId: Type.String(),
-                key: Type.String({ description: "Enter, Tab, ArrowUp, c, etc." }),
+                key: Type.String({
+                    description: bilingual("Enter, Tab, ArrowUp, c, etc.", "按键名，如 Enter、Tab、ArrowUp、c 等"),
+                }),
                 modifiers: Type.Optional(Type.Object({
                     ctrl: Type.Optional(Type.Boolean()),
                     alt: Type.Optional(Type.Boolean()),
@@ -1621,16 +1662,17 @@ export function makePersistentTerminalTools(terminals, cwd) {
                 })),
             }),
             execute: async (_id, p) => {
+                const lang = getLang();
                 failIf(terminals.key(p.terminalId, p.key, p.modifiers));
                 // 同 terminal_input：AI 主动交互后重新计时。
                 terminals.noteAgentActivity(p.terminalId);
-                return result(`已发送按键 ${p.key} 到 ${p.terminalId}`);
+                return result(pick(lang, `已发送按键 ${p.key} 到 ${p.terminalId}`, `Sent key ${p.key} to ${p.terminalId}`, "terminals.key.sent", { "p.key": p.key, "p.terminalId": p.terminalId }));
             },
         }),
         defineTool({
             name: "terminal_read",
             label: "Read terminal output",
-            description: "Read incremental output from a persistent PTY. Keep the returned cursor and pass it on the next read; optionally wait for new output or process exit.",
+            description: bilingual("Read incremental output from a persistent PTY. Keep the returned cursor and pass it on the next read; optionally wait for new output or process exit.", "从常驻 PTY 读取增量输出。保留返回的 cursor，下次读取时传回；可选择等待新输出或进程退出。"),
             parameters: Type.Object({
                 terminalId: Type.String(),
                 cursor: Type.Optional(Type.Integer({ minimum: 0 })),
@@ -1638,35 +1680,44 @@ export function makePersistentTerminalTools(terminals, cwd) {
                 waitMs: Type.Optional(Type.Integer({ minimum: 0, maximum: 120000 })),
             }),
             execute: async (_id, p, signal) => {
+                const lang = getLang();
                 const cursor = p.cursor ?? 0;
                 if (p.waitMs)
                     await terminals.waitForOutput(p.terminalId, cursor, p.waitMs, signal);
                 const read = terminals.read(p.terminalId, cursor, p.maxBytes ?? 20000);
                 if (!read)
-                    throw new Error(`终端不存在：${p.terminalId}`);
+                    throw new Error(pick(lang, `终端不存在：${p.terminalId}`, `Terminal not found: ${p.terminalId}`, "terminals.read.not.found", { "p.terminalId": p.terminalId }));
                 return result(JSON.stringify(read), read);
             },
         }),
         defineTool({
             name: "terminal_wait",
             label: "Wait for terminal command",
-            description: "Block until a command started THROUGH THE BASH TOOL finishes (its exit marker appears) or the timeout expires — no polling needed. Only applies to terminals with a pending bash-tool command; terminals driven manually via terminal_input (e.g. interactive programs) have no completion marker — use terminal_read(waitMs=…) to observe those instead. Returns {finished, exitCode} plus the output produced while waiting; finished=false means it is STILL running (call again to keep waiting).",
-            promptSnippet: "block until a terminal's current command finishes (no polling)",
+            description: bilingual("Block until a command started THROUGH THE BASH TOOL finishes (its exit marker appears) or the timeout expires — no polling needed. Only applies to terminals with a pending bash-tool command; terminals driven manually via terminal_input (e.g. interactive programs) have no completion marker — use terminal_read(waitMs=…) to observe those instead. Returns {finished, exitCode} plus the output produced while waiting; finished=false means it is STILL running (call again to keep waiting).", "阻塞等待经 BASH 工具启动的命令结束（出现退出标记）或超时——无需轮询。仅适用于有待决 bash 工具命令的终端；经 terminal_input 手动驱动的终端（如交互式程序）没有完成标记——观察它们请用 terminal_read(waitMs=…)。返回 {finished, exitCode} 及等待期间产生的输出；finished=false 表示仍在运行（可再次调用继续等）。"),
+            promptSnippet: bilingual("block until a terminal's current command finishes (no polling)", "阻塞等待终端当前命令结束（无需轮询）"),
             parameters: Type.Object({
                 terminalId: Type.String(),
-                cursor: Type.Optional(Type.Integer({ minimum: 0, description: "Ignore exit markers before this absolute offset (default: now)" })),
-                maxWaitMs: Type.Optional(Type.Integer({ minimum: 100, maximum: 600000, description: "Max wait in ms (default 300000)" })),
+                cursor: Type.Optional(Type.Integer({
+                    minimum: 0,
+                    description: bilingual("Ignore exit markers before this absolute offset (default: now)", "忽略该绝对偏移之前的退出标记（默认：现在）"),
+                })),
+                maxWaitMs: Type.Optional(Type.Integer({
+                    minimum: 100,
+                    maximum: 600000,
+                    description: bilingual("Max wait in ms (default 300000)", "最长等待毫秒数（默认 300000）"),
+                })),
             }),
             execute: async (_id, p, signal) => {
+                const lang = getLang();
                 if (!terminals.has(p.terminalId)) {
-                    throw new Error(`终端不存在：${p.terminalId}（可能已被关闭或会话重置，请先 terminal_create）`);
+                    throw new Error(pick(lang, `终端不存在：${p.terminalId}（可能已被关闭或会话重置，请先 terminal_create）`, `Terminal not found: ${p.terminalId} (it may have been closed or the session was reset — run terminal_create first)`, "terminals.wait.not.found", { "p.terminalId": p.terminalId }));
                 }
                 // 没有带哨兵的待决命令：shell 空闲在提示符，或该终端的命令是经
                 // terminal_input 手动发的（无完成标记）——等哨兵永远等不到，直接
                 // 说明并引导改用 terminal_read，避免 AI 无限重试。（显式传 cursor
                 // 的调用是有目的的追溯查询，不拦。）
                 if (p.cursor === undefined && !terminals.isSentinelPending(p.terminalId)) {
-                    const why = `终端 ${p.terminalId} 当前没有正在等待完成的 bash 工具命令（shell 空闲，或该命令是通过 terminal_input 发出的、没有完成标记）。terminal_wait 不适用；要观察输出请用 terminal_read(terminalId="${p.terminalId}", waitMs=…)。`;
+                    const why = pick(lang, `终端 ${p.terminalId} 当前没有正在等待完成的 bash 工具命令（shell 空闲，或该命令是通过 terminal_input 发出的、没有完成标记）。terminal_wait 不适用；要观察输出请用 terminal_read(terminalId="${p.terminalId}", waitMs=…)。`, `Terminal ${p.terminalId} has no pending bash-tool command to wait for (the shell is idle, or the command was sent via terminal_input and has no completion marker). terminal_wait does not apply; use terminal_read(terminalId="${p.terminalId}", waitMs=…) to observe output.`, "terminals.wait.no.pending", { "p.terminalId": p.terminalId });
                     return result(JSON.stringify({ applicable: false, reason: why }), { applicable: false });
                 }
                 const cursor = p.cursor ?? terminals.endCursor(p.terminalId) ?? 0;

package/dist/server/update-check.js

@@ -9,6 +9,7 @@
  */
 import { readdirSync, readFileSync, realpathSync, existsSync } from "node:fs";
 import { delimiter, dirname, join } from "node:path";
+import { pick } from "./i18n.js";
 const PI_CORE_PACKAGE = "@earendil-works/pi-coding-agent";
 const REGISTRY = "https://registry.npmjs.org";
 const FETCH_TIMEOUT_MS = 8_000;
@@ -274,7 +275,10 @@ export async function fetchLatest(fetcher, name) {
  * error item (upToDate: false) without failing the rest. Results keep the
  * input order. Bounded concurrency (CONCURRENCY) keeps registry load polite.
  */
-export async function checkAll(targets, fetcher = defaultFetcher) {
+export async function checkAll(targets, fetcher = defaultFetcher, 
+/** 单项 registry 查询失败时的 error 文案语言（默认英文）。 */
+lang) {
+    const l = lang?.() ?? "en";
     const results = Array.from({ length: targets.length });
     let cursor = 0;
     async function worker() {
@@ -293,6 +297,7 @@ export async function checkAll(targets, fetcher = defaultFetcher) {
                 };
             }
             catch (err) {
+                const errMessage = err.message;
                 results[i] = {
                     name: t.name,
                     kind: t.kind,
@@ -300,7 +305,7 @@ export async function checkAll(targets, fetcher = defaultFetcher) {
                     latest: null,
                     latestPublishedAt: null,
                     upToDate: false,
-                    error: `检查更新失败：${err.message}`,
+                    error: pick(l, `检查更新失败：${errMessage}`, `Failed to check for updates: ${errMessage}`, "updatecheck.check.failed", { errMessage }),
                 };
             }
         }

package/dist/server/vision-bridge.js

@@ -1,3 +1,4 @@
+import { getServerBlock, pick } from "./i18n.js";
 /** Per-batch timeout; a slow vision provider shouldn't stall a prompt forever. */
 const TRANSCRIBE_TIMEOUT_MS = Number(process.env.PI_WEB_VISION_TIMEOUT_MS ?? 90_000);
 /** Cap the transcript length so it doesn't blow up the main context. */
@@ -45,6 +46,24 @@ Follow these rules:
 5. If part of the image is too blurry/low-resolution to read, say "（读不清）" or "unclear" for that part — NEVER invent or guess content you cannot see.
 6. If there are multiple images, address them in order (图 1 / Image 1, 图 2 / Image 2, ...).
 7. Output only the transcript. No preamble, no commentary about the image itself.`;
+/**
+ * 中文版内置转写提示词（调用方按 lang 选用，默认英文）。与 SYSTEM_PROMPT 同义，
+ * 仅语言不同——英文版是默认行为，保持原有转写质量不变。
+ */
+export const SYSTEM_PROMPT_ZH = `你是文本模型的视觉桥。你会收到一张或多张图片，必须把它们转写成精确的结构化文字证据，让看不到图片的模型也能准确回答相关问题。
+
+规则：
+1. 逐字转写所有可见文本，保留措辞、拼写、标点与换行。这是最重要的部分——阅读者依赖你的转写，而非图片本身。
+2. 按阅读顺序描述版式：标题、段落、列表、表格、按钮、面板——说明它们出现的位置。
+3. 表格/图表/示意图：读出坐标轴、刻度（注意对数轴）、图例项、系列名、高亮点及其坐标，以及能辨认的数据值。
+4. 点名实体：人物、产品、公司、颜色、风格、物体、动作。
+5. 图片局部太模糊/分辨率太低读不清时，对该部分写“（读不清）”或 "unclear”——绝不编造或猜测看不见的内容。
+6. 多张图片时按顺序逐张处理（图 1 / Image 1，图 2 / Image 2，……）。
+7. 只输出转写结果，不加开场白，不评论图片本身。`;
+/** 按服务端语言选用内置转写提示词（默认英文）。 */
+export function getVisionSystemPrompt(lang = "en") {
+    return getServerBlock(lang, "vision.system", SYSTEM_PROMPT_ZH.split("\n"), SYSTEM_PROMPT.split("\n")).join("\n");
+}
 /**
  * Assemble the final vision-model system prompt from the settings-panel prefs.
  * mode "append": custom text appended after the default prompt (empty custom =
@@ -52,36 +71,38 @@ Follow these rules:
  * an empty custom text still falls back to the default (never send an empty
  * system prompt to the vision model).
  */
-export function buildVisionBridgePrompt(mode, custom) {
+export function buildVisionBridgePrompt(mode, custom, lang = "en") {
     const text = custom?.trim() ?? "";
+    const base = getVisionSystemPrompt(lang);
     if (mode === "replace" && text)
         return text;
     if (text)
-        return `${SYSTEM_PROMPT}\n\n${text}`;
-    return SYSTEM_PROMPT;
+        return `${base}\n\n${text}`;
+    return base;
 }
 /** Per-batch user instruction appended after the images. */
-function buildUserPrompt(count) {
+function buildUserPrompt(count, lang = "en") {
     if (count <= 1) {
-        return "请逐字转写这张图片的内容，并按上述规则输出结构化文字证据。";
+        return pick(lang, "请逐字转写这张图片的内容，并按上述规则输出结构化文字证据。", "Transcribe this image verbatim and output structured text evidence following the rules above.", "vision.transcribe.single");
     }
-    return `请按图片顺序（图 1 到 图 ${count}）逐张转写每张图片的内容，并按上述规则输出结构化文字证据。`;
+    return pick(lang, `请按图片顺序（图 1 到 图 ${count}）逐张转写每张图片的内容，并按上述规则输出结构化文字证据。`, `Transcribe each image in order (Image 1 to Image ${count}) and output structured text evidence following the rules above.`, "vision.transcribe.batch", { count });
 }
 /**
  * Send one batch of images to a vision model and return its transcript.
  * Throws on timeout, abort, provider error or an empty response.
  */
 export async function transcribeImages(runtime, images, options = {}) {
+    const lang = options.lang ?? "en";
     const model = options.model ??
         (() => {
             const found = findVisionModels(runtime);
             if (found.length === 0) {
-                throw new Error("未找到可用的视觉模型（models.json 中没有任何 input 含 image 的模型）");
+                throw new Error(pick(lang, "未找到可用的视觉模型（models.json 中没有任何 input 含 image 的模型）", "No vision-capable model found (no model with image input in models.json)", "vision.model.not.found"));
             }
             return runtime.getModel(found[0].provider, found[0].id);
         })();
     if (!model)
-        throw new Error("视觉模型不可用（ModelRuntime.getModel 返回空）");
+        throw new Error(pick(lang, "视觉模型不可用（ModelRuntime.getModel 返回空）", "Vision model unavailable (ModelRuntime.getModel returned empty)", "vision.model.unavailable"));
     const ac = new AbortController();
     const timer = setTimeout(() => ac.abort(), TRANSCRIBE_TIMEOUT_MS);
     const onOuterAbort = () => ac.abort();
@@ -93,12 +114,12 @@ export async function transcribeImages(runtime, images, options = {}) {
             mimeType: img.mimeType?.startsWith("image/") ? img.mimeType : "image/png",
         }));
         const context = {
-            systemPrompt: options.systemPrompt ?? SYSTEM_PROMPT,
+            systemPrompt: options.systemPrompt ?? getVisionSystemPrompt(lang),
             messages: [
                 {
                     role: "user",
                     timestamp: Date.now(),
-                    content: [...imageBlocks, { type: "text", text: buildUserPrompt(images.length) }],
+                    content: [...imageBlocks, { type: "text", text: buildUserPrompt(images.length, lang) }],
                 },
             ],
         };
@@ -107,7 +128,8 @@ export async function transcribeImages(runtime, images, options = {}) {
             maxTokens: MAX_TRANSCRIBE_TOKENS,
         });
         if (msg.stopReason === "error" || msg.stopReason === "aborted") {
-            throw new Error(msg.errorMessage || `视觉模型异常终止（${msg.stopReason}）`);
+            throw new Error(msg.errorMessage ||
+                pick(lang, `视觉模型异常终止（${msg.stopReason}）`, `Vision model terminated abnormally (${msg.stopReason})`, "vision.model.terminated", { "msg.stopReason": msg.stopReason }));
         }
         const text = msg.content
             .filter((b) => b.type === "text")
@@ -115,7 +137,7 @@ export async function transcribeImages(runtime, images, options = {}) {
             .join("\n")
             .trim();
         if (!text) {
-            throw new Error("视觉模型返回了空的转写结果");
+            throw new Error(pick(lang, "视觉模型返回了空的转写结果", "Vision model returned an empty transcript", "vision.transcript.empty"));
         }
         return text;
     }

package/dist/server/webui-context.js

@@ -45,6 +45,15 @@ export class WebUIContext {
         this.emit = emit;
     }
     // -- widgets -------------------------------------------------------------
+    /** Register a widget whose lines come from a plain getter, re-evaluated on
+     *  every render/refresh (no SDK Component required). Used for
+     *  conversation-scoped overlays (e.g. markers) so switching conversations
+     *  re-renders them without re-registering. */
+    setDynamicWidget(key, lines) {
+        this.widgets.set(key, { render: () => lines() });
+        this.lastLines.delete(key);
+        this.push();
+    }
     /** Matches ExtensionUIContext's overloaded setWidget exactly. */
     setWidget = (key, content, options) => {
         void options;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-web-ui",
-	"version": "0.68.2",
+	"version": "0.70.0",
 	"description": "Web chat interface for the pi coding agent, powered by the pi SDK (@earendil-works/pi-coding-agent) — one-command run, Docker/systemd/launchd deployable",
 	"license": "MIT",
 	"author": {
@@ -85,6 +85,7 @@
 		"react-markdown": "^9.0.1",
 		"rehype-highlight": "^7.0.1",
 		"rehype-raw": "^7.0.0",
+		"remark-breaks": "^4.0.0",
 		"remark-gfm": "^4.0.0",
 		"typebox": "^1.3.14",
 		"ws": "^8.18.0"