pi-web-ui 0.62.0 → 0.63.0

package/dist/server/subagents.js

@@ -0,0 +1,150 @@
+// ---------------------------------------------------------------------------
+// subagents.ts — 第一方轻量子代理：工具定义与运行态模型
+// ---------------------------------------------------------------------------
+// 架构（相对参考项目的大幅简化）：
+//
+// 参考项目（tintinweb / nicobailon 的 pi-subagents）把子代理做成「完整子会话」
+// —— 独立 SessionManager / SettingsManager / 模型 / 工具隔离 / resume /
+// steer / 并发池 / 工作区隔离，复杂度来自「要独立支撑一个完整会话」。
+//
+// pi-web-ui 的 ClientSession 天生就是多会话并发的：一个 conversation 就有
+// 一个独立 AgentSessionRuntime + TerminalManager，所有 conversation 共享
+// 同一个 modelRuntime，创建走 createAgentSessionServices + FromServices（已
+// 封装好）。因此本模块把子代理定义为：
+//
+//   子代理 = 一个标记了 isSubagent 的普通 Conversation（inMemory session，
+//   不落盘、不进历史/resume 列表）
+//   - 出现在左栏「运行的对话」列表，带「子代理」徽标
+//   - 用户可以像普通对话一样：点开查看实时消息流、输入补充（= steer）、
+//     中止（= abort）、完成后移出（= dismiss）
+//   - 运行态经现有快照/消息管线推送，不需要单独的可视化桥
+//
+// 本文件只定义：运行态快照类型、host 接口（由 ClientSession 实现，操作的是
+// 它的 conversation 体系）、以及注册给每个会话的 subagent_* 工具。真正创建
+// conversation / 跑 prompt 全部在 agent-service.ts 的 spawnSubagent 里完成。
+// ---------------------------------------------------------------------------
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+/** 从 prompt 取首行作为标题（截断 40 字符）。 */
+export function subagentTitle(prompt) {
+    const line = prompt.split("\n")[0]?.trim() ?? "";
+    return line.length > 40 ? `${line.slice(0, 40)}…` : line;
+}
+/**
+ * 子代理工具集（注册进每个会话的 customTools，供主 agent 驱动子代理）。
+ * 用 `subagent_*` 前缀命名，避免与第三方 pi-subagents 的
+ * `Agent`/`get_subagent_result`/`steer_subagent` 冲突。
+ */
+export function makeSubagentTools(host) {
+    const text = (t, details = {}) => ({
+        content: [{ type: "text", text: t }],
+        details,
+    });
+    return [
+        defineTool({
+            name: "subagent_spawn",
+            label: "Spawn subagent",
+            description: "在后台启动一个独立的子代理对话，用一个明确的指令去完成一项可独立交付的工作（调研/实现/审查等）。" +
+                "子代理会出现在左栏「运行的对话」列表（带子代理标识），用户可点开查看、补充、中止。主 agent 可并行派发多个：" +
+                "用 subagent_list 查看运行态、subagent_get_result 取结果、subagent_steer 中途改向、subagent_stop 停止。" +
+                "适合：长耗时探索、并行调研、独立子任务委派。可选 template 参数：使用设置面板配置的子代理模板" +
+                "（角色系统提示词 + 技能/扩展白名单）；用 subagent_templates 查看可用清单，不传 = 不用模板。",
+            promptSnippet: "spawn an independent background subagent for a deliverable task (parallel work)",
+            parameters: Type.Object({
+                prompt: Type.String({ description: "交给子代理的完整指令（要达成的目标 + 约束 + 期望产出）。" }),
+                type: Type.Optional(Type.String({ description: "子代理类型/角色名（如 explore/implement/review），用于展示。默认 general。" })),
+                template: Type.Optional(Type.String({
+                    description: "可选：子代理模板名（设置面板「子代理模板」配置的预设，见 subagent_templates 工具）。" +
+                        "模板 = 角色系统提示词 + 技能/扩展白名单；不传 = 不使用模板，按主会话默认配置运行。",
+                })),
+                cwd: Type.Optional(Type.String({ description: "子代理工作目录（相对/绝对）。默认继承主会话工作目录。" })),
+            }),
+            execute: async (_id, p, _signal, _onUpdate, ctx) => {
+                if (p.template && !host.isTemplateUsable(p.template)) {
+                    return text(`子代理模板不可用：${p.template}（不存在或已停用）。用 subagent_templates 查看当前可用模板清单；不传 template 则按默认配置运行。`);
+                }
+                const convId = await host.spawnSubagent(p.prompt, p.type ?? "general", p.cwd ?? ctx.cwd, p.template);
+                return text(`子代理已启动（运行列表可见）：${convId}\n类型：${p.type ?? "general"} · 标题：${subagentTitle(p.prompt)}` +
+                    (p.template ? `\n模板：${p.template}` : "") +
+                    `\n用 subagent_get_result 取结果，subagent_list 看运行态，subagent_steer 改向，subagent_stop 停止。`, { convId, template: p.template });
+            },
+        }),
+        defineTool({
+            name: "subagent_get_result",
+            label: "Get subagent result",
+            description: "取一个子代理的结果或当前运行态。若尚未完成，返回当前状态与已产出的文本。",
+            promptSnippet: "fetch a subagent's result / current progress",
+            parameters: Type.Object({
+                runId: Type.String({ description: "subagent_spawn 返回的 convId。左栏点击同名对话可直接查看。" }),
+            }),
+            execute: async (_id, p) => {
+                const r = host.getSubagent(p.runId);
+                if (!r)
+                    return text(`未找到子代理 ${shortId(p.runId)}（可能已移出）。`, undefined);
+                if (r.streaming || r.state === "running") {
+                    return text(`子代理 ${shortId(r.convId)}（${r.type}）仍在运行（状态 ${r.state}）。\n当前输出：\n${r.output || "（暂无输出）"}`, r);
+                }
+                return text(`子代理 ${shortId(r.convId)}（${r.type}）状态：${r.state}\n${r.output || "（无结果）"}`, r);
+            },
+        }),
+        defineTool({
+            name: "subagent_steer",
+            label: "Steer subagent",
+            description: "向一个子代理注入一条消息，重定向/补充它的工作方向（等同用户在它的对话里发消息）。",
+            promptSnippet: "inject a message into a running subagent to redirect its work",
+            parameters: Type.Object({
+                runId: Type.String({ description: "目标子代理 convId。" }),
+                message: Type.String({ description: "要注入的方向调整/补充信息。" }),
+            }),
+            execute: async (_id, p) => {
+                await host.steerSubagent(p.runId, p.message);
+                return text(`已向子代理 ${shortId(p.runId)} 注入消息。`);
+            },
+        }),
+        defineTool({
+            name: "subagent_list",
+            label: "List subagents",
+            description: "列出全部子代理的运行态：convId、类型、状态、标题、消息数。",
+            promptSnippet: "list all subagents and their live status",
+            parameters: Type.Object({}),
+            execute: async () => {
+                const list = host.listSubagents();
+                if (list.length === 0)
+                    return text("当前没有子代理。");
+                const lines = list.map((r) => `- ${r.convId} · ${r.type} · ${r.state} · ${r.title}（msg: ${r.messageCount}）`);
+                return text(lines.join("\n"));
+            },
+        }),
+        defineTool({
+            name: "subagent_stop",
+            label: "Stop subagent",
+            description: "停止一个运行中的子代理（等同用户在它的对话里点中止）。已完成的不受影响。",
+            promptSnippet: "stop a running subagent",
+            parameters: Type.Object({ runId: Type.String({ description: "目标子代理 convId。" }) }),
+            execute: async (_id, p) => {
+                await host.stopSubagent(p.runId);
+                return text(`已请求停止子代理 ${shortId(p.runId)}。`);
+            },
+        }),
+        defineTool({
+            name: "subagent_templates",
+            label: "List subagent templates",
+            description: "列出设置面板「子代理模板」配置的可用模板（角色系统提示词 + 技能/扩展白名单的组合预设），" +
+                "供 subagent_spawn 的 template 参数选用。已停用的模板不会出现在这里。list 为空 = 未配置模板，子代理按默认配置运行。",
+            promptSnippet: "list configurable subagent templates (role prompt + skills/extensions whitelist presets)",
+            parameters: Type.Object({}),
+            execute: async () => {
+                const list = host.listTemplates();
+                if (list.length === 0) {
+                    return text("当前没有可用的子代理模板（设置面板 → 子代理模板 添加后可用）。子代理默认按主会话配置运行。");
+                }
+                const lines = list.map((t) => `- ${t.name}${t.description ? `：${t.description}` : ""}`);
+                return text(`可用的子代理模板（subagent_spawn 的 template 参数传名字，如 subagent_spawn(template="${list[0]?.name}"))：\n${lines.join("\n")}`);
+            },
+        }),
+    ];
+}
+/** 短 id 前缀（前端展示/日志用）。 */
+function shortId(id) {
+    return id.slice(0, 8);
+}

package/dist/server/terminals.js

@@ -22,7 +22,7 @@ import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 // module itself for details).
 import "./patch-node-pty.js";
 import { spawn } from "node-pty";
-import { defineTool, } from "@earendil-works/pi-coding-agent";
+import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 /** Location of the command list for a project: <workspaceRoot>/.pi/commands.json */
 export function commandsFilePath(workspaceRoot) {
@@ -162,6 +162,7 @@ export function buildTerminalBashLine(command, tailFile) {
     // 留下的 141 不是真失败，而是“按要求截断=成功”。只有恰好 141 才转 0，真失败照报。
     // tailFile：`cmd > log 2>&1 | tail -N`——拆掉 tail 后 stdout 进文件、终端为空；
     // 在哨兵前补一个 `tail -N log` 让模型看到日志尾部，退出码仍是底层命令的。
+    // eslint-disable-next-line no-useless-escape -- \$? must reach the shell literally
     const rcGuard = `__pi_rc=\${PIPESTATUS:-\$?}; [ "$__pi_rc" -eq 141 ] && __pi_rc=0`;
     const tailPart = tailFile
         ? `; tail -n ${Math.max(1, Math.floor(tailFile.lines))} -- '${tailFile.file.replace(/'/g, `'\\''`)}'`
@@ -234,10 +235,26 @@ export function detectTrailingLimiter(command) {
         if (/(?:^|\s)(?:-f|--follow(?:=|\b))/.test(rest))
             return null;
         const lines = parseTailLines(rest) ?? 10; // 裸 `| tail` 默认 10 行
-        return { base: parts.slice(0, -1).map((s) => s.trim()).join(" | "), kind, lines, segment: last };
+        return {
+            base: parts
+                .slice(0, -1)
+                .map((s) => s.trim())
+                .join(" | "),
+            kind,
+            lines,
+            segment: last,
+        };
     }
     // less / more / cat：纯透传，拆掉只为修正退出码 + 避免交互分页器在 PTY 里挂起。
-    return { base: parts.slice(0, -1).map((s) => s.trim()).join(" | "), kind, lines: null, segment: last };
+    return {
+        base: parts
+            .slice(0, -1)
+            .map((s) => s.trim())
+            .join(" | "),
+        kind,
+        lines: null,
+        segment: last,
+    };
 }
 /** 识别命令里把 stdout 重定向到文件的 `> file` / `>> file`（忽略 2>N / >&N / /dev/null）。
  *  用于 `cmd > log 2>&1 | tail -N`：拆掉 tail 后输出进文件，终端为空——补一个 tail 文件
@@ -260,7 +277,10 @@ export function queryTerminalOutput(output, q, running = false, exitCode = null)
         .split("\n")
         .filter((l) => {
         const t = l.trim();
-        return !/^\[pi-exit:\d+\]$/.test(t) && !/^\[进程已退出/.test(t);
+        return (!/^\[pi-exit:\d+\]$/.test(t) &&
+            !t.startsWith("[进程已退出") &&
+            !t.startsWith("[Process exited") &&
+            !/^\[.*(已退出|exited)/.test(t));
     });
     while (lines.length > 0 && !lines[lines.length - 1].trim())
         lines.pop();
@@ -529,11 +549,29 @@ function launchdSpawnedOnMac() {
  */
 export function encodeTerminalKey(key, modifiers = {}) {
     const named = {
-        Enter: "\r", Return: "\r", Tab: "\t", Backspace: "\x7f", Escape: "\x1b",
-        Up: "\x1b[A", ArrowUp: "\x1b[A", Down: "\x1b[B", ArrowDown: "\x1b[B",
-        Left: "\x1b[D", ArrowLeft: "\x1b[D", Right: "\x1b[C", ArrowRight: "\x1b[C",
-        Home: "\x1b[H", End: "\x1b[F", Delete: "\x1b[3~", Insert: "\x1b[2~",
-        PageUp: "\x1b[5~", PageDown: "\x1b[6~", F1: "\x1bOP", F2: "\x1bOQ", F3: "\x1bOR", F4: "\x1bOS",
+        Enter: "\r",
+        Return: "\r",
+        Tab: "\t",
+        Backspace: "\x7f",
+        Escape: "\x1b",
+        Up: "\x1b[A",
+        ArrowUp: "\x1b[A",
+        Down: "\x1b[B",
+        ArrowDown: "\x1b[B",
+        Left: "\x1b[D",
+        ArrowLeft: "\x1b[D",
+        Right: "\x1b[C",
+        ArrowRight: "\x1b[C",
+        Home: "\x1b[H",
+        End: "\x1b[F",
+        Delete: "\x1b[3~",
+        Insert: "\x1b[2~",
+        PageUp: "\x1b[5~",
+        PageDown: "\x1b[6~",
+        F1: "\x1bOP",
+        F2: "\x1bOQ",
+        F3: "\x1bOR",
+        F4: "\x1bOS",
     };
     let data = named[key] ?? (key.length === 1 ? key : "");
     if (!data)
@@ -544,8 +582,17 @@ export function encodeTerminalKey(key, modifiers = {}) {
     const arrow = /^\x1b\[([A-DHF])$/.exec(data);
     const functionKey = /^\x1bO([P-S])$/.exec(data);
     const namedCode = {
-        Enter: 13, Return: 13, Tab: 9, Backspace: 127, Escape: 27,
-        Insert: 2, Delete: 3, Home: 1, End: 4, PageUp: 5, PageDown: 6,
+        Enter: 13,
+        Return: 13,
+        Tab: 9,
+        Backspace: 127,
+        Escape: 27,
+        Insert: 2,
+        Delete: 3,
+        Home: 1,
+        End: 4,
+        PageUp: 5,
+        PageDown: 6,
     };
     if (arrow && modifier !== 1) {
         data = `\x1b[1;${modifier}${arrow[1]}`;
@@ -602,7 +649,7 @@ export class TerminalManager {
     create(id, cwd, cols, rows, fallbackCwd, title, opts) {
         const valid = this.validateId(id);
         if (valid) {
-            this.fail(id, valid);
+            this.fail(id, valid.text, valid.textEn);
             return null;
         }
         if (this.terms.has(id))
@@ -616,10 +663,10 @@ export class TerminalManager {
         this.history.delete(id);
         const safeCwd = this.safeCwd(cwd || fallbackCwd);
         if (!safeCwd) {
-            this.fail(id, "终端工作目录必须位于当前工作区内");
+            this.fail(id, "终端工作目录必须位于当前工作区内", "Terminal cwd must be inside the current workspace");
             return null;
         }
-        if (this.spawnShell(id, safeCwd, cols, rows, title || `终端 ${++this.seq}`, undefined, opts?.forceBash, opts?.agentBash)) {
+        if (this.spawnShell(id, safeCwd, cols, rows, title || `终端 ${++this.seq}`, undefined, opts?.forceBash, opts?.agentBash, opts?.locale)) {
             this.maybeEmitTccHint(id);
             this.emitList();
             return this.info(this.terms.get(id));
@@ -640,10 +687,10 @@ export class TerminalManager {
      * running process is killed and a fresh shell runs the command again in the
      * same terminal (used when re-running a command by clicking its entry).
      */
-    runCommand(id, def, cols, rows, pwd) {
+    runCommand(id, def, cols, rows, pwd, locale) {
         const invalidId = this.validateId(id);
         if (invalidId) {
-            this.fail(id, invalidId);
+            this.fail(id, invalidId.text, invalidId.textEn);
             return;
         }
         const existing = this.terms.get(id);
@@ -653,13 +700,12 @@ export class TerminalManager {
         // the cap could push the live count past MAX_TERMINALS.
         if (!existing && !this.ensureSpawnAllowed(id))
             return;
-        const hasHistory = this.history.has(id);
         const rawDir = resolveCommandCwd(def.cwd, pwd);
         const dir = this.safeCwd(rawDir);
         const command = expandPwd(def.command.trim(), pwd);
         const title = def.name || command || `终端 ${++this.seq}`;
         if (!dir) {
-            this.fail(id, "终端工作目录必须位于当前工作区内");
+            this.fail(id, "终端工作目录必须位于当前工作区内", "Terminal cwd must be inside the current workspace");
             return;
         }
         if (existing) {
@@ -681,14 +727,14 @@ export class TerminalManager {
             this.terms.delete(id);
         }
         this.history.delete(id);
-        const ok = this.spawnShell(id, dir, cols, rows, title, def);
+        const keepLocale = locale ?? existing?.locale;
+        const ok = this.spawnShell(id, dir, cols, rows, title, def, undefined, false, keepLocale);
         if (!ok)
             return;
         this.emitList();
         // Clear the previous run's output, then show a banner and run the command
         // (the PTY input buffer holds it until the shell is ready).
-        const banner = "\x1b[2J\x1b[3J\x1b[H" +
-            `\x1b[90m> ${command}\x1b[0m  \x1b[90m(${dir})\x1b[0m\r\n`;
+        const banner = "\x1b[2J\x1b[3J\x1b[H" + `\x1b[90m> ${command}\x1b[0m  \x1b[90m(${dir})\x1b[0m\r\n`;
         const fresh = this.terms.get(id);
         if (fresh)
             this.appendOutput(fresh, banner);
@@ -698,7 +744,7 @@ export class TerminalManager {
             this.input(id, command + "\r");
     }
     /** Spawn the user's shell as a PTY. Returns false when the spawn failed. */
-    spawnShell(id, cwd, cols, rows, title, command, forceBash, agentBash = false) {
+    spawnShell(id, cwd, cols, rows, title, command, forceBash, agentBash = false, locale) {
         let abs = cwd;
         if (!abs)
             abs = homedir();
@@ -706,12 +752,12 @@ export class TerminalManager {
             abs = resolve(abs);
         try {
             if (!existsSync(abs) || !statSync(abs).isDirectory()) {
-                this.fail(id, `目录不存在或不是目录：${abs}`);
+                this.fail(id, `目录不存在或不是目录：${abs}`, `Directory does not exist or is not a directory: ${abs}`);
                 return false;
             }
         }
         catch {
-            this.fail(id, `无法访问终端目录：${abs}`);
+            this.fail(id, `无法访问终端目录：${abs}`, `Cannot access terminal directory: ${abs}`);
             return false;
         }
         // node-pty's spawn-helper may have lost its +x bit since the last repair
@@ -732,7 +778,9 @@ export class TerminalManager {
             const helper = brokenSpawnHelper();
             this.fail(id, helper
                 ? `启动终端失败：${err.message}（node-pty 的 spawn-helper 缺少执行权限，请运行：chmod +x "${helper}"）`
-                : `启动终端失败：${err.message}`);
+                : `启动终端失败：${err.message}`, helper
+                ? `Failed to start terminal: ${err.message} (node-pty spawn-helper is not executable, run: chmod +x "${helper}")`
+                : `Failed to start terminal: ${err.message}`);
             return false;
         }
         const entry = {
@@ -755,6 +803,7 @@ export class TerminalManager {
             idleTimer: null,
             watches: [],
             agentBash,
+            locale,
         };
         this.terms.set(id, entry);
         // The closures capture `entry`: after a restart the map points at the
@@ -881,7 +930,10 @@ export class TerminalManager {
     }
     validateId(id) {
         if (!id || id.length > MAX_ID || !/^[A-Za-z0-9._:-]+$/.test(id)) {
-            return "终端名称无效：只能使用字母、数字、.-、_ 或 :（最长 80 字符）";
+            return {
+                text: "终端名称无效：只能使用字母、数字、.-、_ 或 :（最长 80 字符）",
+                textEn: "Invalid terminal name: use letters, digits, .-_ or : (max 80 chars)",
+            };
         }
         return null;
     }
@@ -901,7 +953,7 @@ export class TerminalManager {
             return true;
         const liveUser = [...this.terms.values()].filter((t) => !t.agentBash).length;
         if (liveUser >= MAX_TERMINALS) {
-            this.fail(id, `终端数量已达上限（${MAX_TERMINALS}）`);
+            this.fail(id, `终端数量已达上限（${MAX_TERMINALS}）`, `Terminal limit reached (${MAX_TERMINALS})`);
             return false;
         }
         return true;
@@ -958,7 +1010,12 @@ export class TerminalManager {
             return null;
         const start = Math.max(entry.outputOffset, Math.min(cursor, entry.outputOffset + entry.output.length));
         const end = Math.min(start + Math.max(1, Math.floor(maxBytes) || 20_000), entry.outputOffset + entry.output.length);
-        return { data: entry.output.slice(start - entry.outputOffset, end - entry.outputOffset), cursor: end, running: !entry.exited, exitCode: entry.exitCode };
+        return {
+            data: entry.output.slice(start - entry.outputOffset, end - entry.outputOffset),
+            cursor: end,
+            running: !entry.exited,
+            exitCode: entry.exitCode,
+        };
     }
     async waitForOutput(id, cursor, timeoutMs, signal) {
         const current = this.read(id, cursor, 1);
@@ -983,7 +1040,7 @@ export class TerminalManager {
     }
     inputChecked(id, data) {
         if (data.length > MAX_INPUT)
-            return `输入过长（上限 ${MAX_INPUT} 字符）`;
+            return `输入过长（上限 ${MAX_INPUT} 字符） Input too long (max ${MAX_INPUT} chars)`;
         const entry = this.terms.get(id);
         if (!entry || entry.exited)
             return "终端不存在或进程已退出";
@@ -1102,8 +1159,8 @@ export class TerminalManager {
         };
     }
     /** Emit a terminal failure (bad cwd, spawn error) and mark the terminal dead. */
-    fail(id, text) {
-        this.emit({ type: "notice", level: "error", text });
+    fail(id, text, textEn) {
+        this.emit({ type: "notice", level: "error", text, textEn });
         this.emit({
             type: "terminal_output",
             terminalId: id,
@@ -1118,7 +1175,9 @@ export class TerminalManager {
         this.disarmIdleWatch(entry);
         // Flush queued output BEFORE the exit banner so ordering is preserved.
         this.flushPending(entry);
-        const banner = `\r\n\x1b[90m[进程已退出，退出码 ${exitCode}]\x1b[0m\r\n`;
+        const banner = entry.locale === "en"
+            ? `\r\n\x1b[90m[Process exited with code ${exitCode}]\x1b[0m\r\n`
+            : `\r\n\x1b[90m[进程已退出，退出码 ${exitCode}]\x1b[0m\r\n`;
         this.appendOutput(entry, banner);
         this.emit({ type: "terminal_output", terminalId: id, data: banner });
         entry.exited = true;
@@ -1358,11 +1417,13 @@ export function makeTerminalBashTool(terminals, opts) {
             // `cmd > log 2>&1 | tail -N`：拆掉 tail 后 stdout 进文件、终端为空 → 补一个
             // tail 文件让模型看到日志尾部与真实退出码（否则输出为空）。
             const redirect = stripped && limiter.kind === "tail" ? detectStdoutRedirect(runCommand) : null;
-            const tailFile = redirect
-                ? { file: redirect.file, lines: limiter.lines ?? 10 }
-                : undefined;
+            const tailFile = redirect ? { file: redirect.file, lines: limiter.lines ?? 10 } : undefined;
             const limiterNote = stripped
-                ? "\n[注：检测到你带了「" + limiter.segment + "」这类限输出/过滤管道——已在终端里直跑底层命令（实时可见 + 真实退出码），只按参数返回片段。" + (limiter.kind === "tail" ? "本次返回末尾 " + (limiter.lines ?? 10) + " 行。" : "本次返回全部输出。") + " 后续直接用 bash(command, tail=N) 参数限输出。]"
+                ? "\n[注：检测到你带了「" +
+                    limiter.segment +
+                    "」这类限输出/过滤管道——已在终端里直跑底层命令（实时可见 + 真实退出码），只按参数返回片段。" +
+                    (limiter.kind === "tail" ? "本次返回末尾 " + (limiter.lines ?? 10) + " 行。" : "本次返回全部输出。") +
+                    " 后续直接用 bash(command, tail=N) 参数限输出。]"
                 : "";
             try {
                 let collected = "";
@@ -1460,10 +1521,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 / terminal_wait). The bash tool stays the DEFAULT for ordinary commands - it runs in a visible terminal and returns the full output (persist=false, one-shot terminal that exits when the command finishes). Switch to the bash tool's persist=true, or to the terminal tools, when:
-- The program is interactive or TUI-based (REPLs like python/node, vim/htop, installers asking y/n, anything waiting on stdin). For these, prefer bash({ persist: true }) which runs it in the persistent 'ai-bash' terminal and returns immediately; then drive it with terminal_input / terminal_key (and terminal_read) on terminalId='ai-bash'.
-- You start a long-running server or watcher and want to keep watching its output (terminal_read with waitMs), send keys to it later (e.g. interrupt via terminal_key with Ctrl+c), or block until a backgrounded command finishes without polling (terminal_wait).
-- 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 / terminal_wait). The bash tool stays the DEFAULT for ordinary commands - it runs in a visible terminal and returns the full output (persist=false, one-shot terminal that exits when the command finishes). Switch to the bash tool's persist=true, or to the terminal tools, when:
+- The program is interactive or TUI-based (REPLs like python/node, vim/htop, installers asking y/n, anything waiting on stdin). For these, prefer bash({ persist: true }) which runs it in the persistent 'ai-bash' terminal and returns immediately; then drive it with terminal_input / terminal_key (and terminal_read) on terminalId='ai-bash'.
+- You start a long-running server or watcher and want to keep watching its output (terminal_read with waitMs), send keys to it later (e.g. interrupt via terminal_key with Ctrl+c), or block until a backgrounded command finishes without polling (terminal_wait).
+- The user explicitly asks you to work in the visible terminal panel.
 Use head/tail on bash to trim verbose output instead of piping through head/tail. 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) {

package/dist/server/text-sniff.js

@@ -19,19 +19,7 @@ const PREVIEW_IMAGE_EXTS = new Set([
     "tif",
     "tiff",
 ]);
-const PREVIEW_VIDEO_EXTS = new Set([
-    "mp4",
-    "webm",
-    "mov",
-    "mkv",
-    "avi",
-    "m4v",
-    "ogv",
-    "mpg",
-    "mpeg",
-    "wmv",
-    "flv",
-]);
+const PREVIEW_VIDEO_EXTS = new Set(["mp4", "webm", "mov", "mkv", "avi", "m4v", "ogv", "mpg", "mpeg", "wmv", "flv"]);
 const PREVIEW_TEXT_EXTS = new Set([
     // code
     "ts",
@@ -204,11 +192,7 @@ export function decodeText(buf) {
  *  Returns null when the bytes don't look like a known raster format —
  *  callers keep such files as plain path references. */
 export function sniffImageMime(buf, ext) {
-    if (buf.length >= 8 &&
-        buf[0] === 0x89 &&
-        buf[1] === 0x50 &&
-        buf[2] === 0x4e &&
-        buf[3] === 0x47) {
+    if (buf.length >= 8 && buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47) {
         return "image/png";
     }
     if (buf.length >= 3 && buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff) {
@@ -242,12 +226,8 @@ export function hexDump(buf, maxBytes = 4096) {
     const rows = [];
     for (let off = 0; off < data.length; off += 16) {
         const chunk = data.subarray(off, off + 16);
-        const hex = [...chunk]
-            .map((b) => b.toString(16).padStart(2, "0"))
-            .join(" ");
-        const ascii = [...chunk]
-            .map((b) => (b >= 0x20 && b < 0x7f ? String.fromCharCode(b) : "."))
-            .join("");
+        const hex = [...chunk].map((b) => b.toString(16).padStart(2, "0")).join(" ");
+        const ascii = [...chunk].map((b) => (b >= 0x20 && b < 0x7f ? String.fromCharCode(b) : ".")).join("");
         rows.push(`${off.toString(16).padStart(8, "0")}  ${hex.padEnd(47, " ")}  ${ascii}`);
     }
     return rows.join("\n");

package/dist/server/update-check.js

@@ -203,9 +203,7 @@ function readVendoredPiCore(agentDir) {
  * two rows for the same package.
  */
 export function collectTargets(agentDir, webuiVersion, probePiCore = defaultProbePiCore) {
-    const targets = [
-        { name: "pi-web-ui", version: webuiVersion, kind: "webui" },
-    ];
+    const targets = [{ name: "pi-web-ui", version: webuiVersion, kind: "webui" }];
     const coreVersion = probePiCore() ?? readVendoredPiCore(agentDir);
     if (coreVersion) {
         targets.push({
@@ -239,7 +237,7 @@ export async function fetchLatest(fetcher, name) {
  * input order. Bounded concurrency (CONCURRENCY) keeps registry load polite.
  */
 export async function checkAll(targets, fetcher = defaultFetcher) {
-    const results = new Array(targets.length);
+    const results = Array.from({ length: targets.length });
     let cursor = 0;
     async function worker() {
         while (cursor < targets.length) {

package/dist/server/uploads.js

@@ -27,9 +27,7 @@ export function uploadRetentionDays() {
 export function saveUpload(clientId, name, buf, dataDir = resolveDataDir()) {
     const dir = join(uploadsRoot(dataDir), clientId);
     mkdirSync(dir, { recursive: true });
-    const displayName = name
-        .replace(/[\\/:*?"<>|\x00-\x1f]/g, "_")
-        .slice(0, 80) || "file";
+    const displayName = name.replace(/[\\/:*?"<>|\x00-\x1f]/g, "_").slice(0, 80) || "file";
     const abs = join(dir, `${Date.now()}-${displayName}`);
     writeFileSync(abs, buf);
     return { abs, displayName };

package/dist/server/vision-bridge.js

@@ -90,9 +90,7 @@ export async function transcribeImages(runtime, images, options = {}) {
         const imageBlocks = images.map((img) => ({
             type: "image",
             data: img.data.replace(/^data:[^;]*;base64,/, ""),
-            mimeType: img.mimeType?.startsWith("image/")
-                ? img.mimeType
-                : "image/png",
+            mimeType: img.mimeType?.startsWith("image/") ? img.mimeType : "image/png",
         }));
         const context = {
             systemPrompt: options.systemPrompt ?? SYSTEM_PROMPT,
@@ -100,10 +98,7 @@ export async function transcribeImages(runtime, images, options = {}) {
                 {
                     role: "user",
                     timestamp: Date.now(),
-                    content: [
-                        ...imageBlocks,
-                        { type: "text", text: buildUserPrompt(images.length) },
-                    ],
+                    content: [...imageBlocks, { type: "text", text: buildUserPrompt(images.length) }],
                 },
             ],
         };