pi-web-ui 0.64.0 → 0.64.2

package/dist/server/files-service.js

@@ -10,6 +10,47 @@ import { resolve, relative, sep } from "node:path";
 import { previewKind, looksLikeText, decodeText, hexDump, countLines } from "./text-sniff.js";
 import { gitDirOf, isNotRepoError, scmStatus, scmHistory, scmFileDiff, scmCommitDetail } from "./scm.js";
 export const IS_WIN32 = process.platform === "win32";
+/** 机器根虚拟路径：工作区「上一级」到达此处，列出所有盘符（Windows）/ "/"（posix）。
+ *  这是 wire 字面量，前端 web/src/components/{RightPanel,FooterBar}.tsx 里同值使用。 */
+export const MACHINE_ROOT = "@root";
+/** wire 路径统一用 "/"。绝对 = posix "/..."；win32 还有 "C:/..." / 裸 "C:"。
+ *  机器浏览（越过工作区根换盘符）发送这些路径；工作区相对树不会产生它们（Windows
+ *  文件名不能含 ":"，相对路径经 relative() 归一化后也不以 "/" 开头）。 */
+export function isAbsoluteWirePath(p) {
+    if (p === MACHINE_ROOT || p.startsWith("/"))
+        return true;
+    return IS_WIN32 && /^[A-Za-z]:([\\/]|$)/.test(p);
+}
+/** 去掉结尾 "/"（保留 posix 根 "/" 本身），归一成规范的 wire 形式。前端面包屑
+ *  不产生结尾斜杠，这里只对补全/直接输入做防御性清理。 */
+export function normWirePath(p) {
+    if (p.endsWith("/") && p !== "/")
+        return p.slice(0, -1);
+    return p;
+}
+/** wire 绝对路径（"C:/Users/x" / "/Users/x" / "C:"）→ 原生绝对路径。
+ *  裸盘符根（"C:"）在 win32 的 resolve 里会落到「C: 上的当前目录」，必须显式转 "C:\\"。 */
+export function wireToAbs(wire) {
+    const w = normWirePath(wire);
+    if (IS_WIN32) {
+        const m = /^([A-Za-z]):$/.exec(w);
+        if (m)
+            return `${m[1].toUpperCase()}:\\`;
+    }
+    return resolve(w);
+}
+/** 机器浏览模式下某目录的父级 wire 路径：盘符根（"C:"）→ 机器根；posix "/" 无父级。 */
+export function absoluteParent(wire) {
+    const s = normWirePath(wire);
+    if (s === "" || s === MACHINE_ROOT)
+        return null;
+    const i = s.lastIndexOf("/");
+    if (i < 0)
+        return IS_WIN32 && /^[A-Za-z]:$/.test(s) ? MACHINE_ROOT : null;
+    if (i === 0)
+        return "/"; // posix "/a" → "/"
+    return s.slice(0, i);
+}
 /** 预览只读文件前 512KB。 */
 export const MAX_PREVIEW_BYTES = 512 * 1024;
 /** 右键上传单文件上限（内存中转 base64 → Buffer）。 */
@@ -106,9 +147,11 @@ async function readDirForUI(abs, rel) {
         else {
             type = d.isDirectory() ? "dir" : "file";
         }
+        // 机器浏览（绝对路径）下 rel 是绝对 wire 路径；posix 根 "/" 特殊处理避免 "//name"。
+        const entryPath = rel === "" ? d.name : rel.endsWith("/") ? `${rel.slice(0, -1)}/${d.name}` : `${rel}/${d.name}`;
         const entry = {
             name: d.name,
-            path: rel === "" ? d.name : `${rel}/${d.name}`,
+            path: entryPath,
             type,
         };
         if (type === "file")
@@ -141,10 +184,69 @@ export class FilesService {
     constructor(host) {
         this.host = host;
     }
+    /** 机器根列目录（此电脑/盘符列表）；posix 上就是根 "/"。 */
+    async machineRootEntries() {
+        const fsp = await import("node:fs/promises");
+        if (IS_WIN32) {
+            const out = [];
+            for (let c = 65; c <= 90; c++) {
+                const drive = `${String.fromCharCode(c)}:`;
+                try {
+                    const st = await fsp.stat(`${drive}\\`);
+                    if (st.isDirectory())
+                        out.push({ name: drive, path: drive, type: "dir" });
+                }
+                catch {
+                    // 空口/未挂载盘符 —— 跳过
+                }
+            }
+            return out;
+        }
+        return [{ name: "/", path: "/", type: "dir" }];
+    }
     async listFiles(relPath) {
         const { resolve, sep, relative } = await import("node:path");
         const root = resolve(this.host.getCwd());
-        const target = relPath ? resolve(root, relPath) : root;
+        const raw = relPath ?? "";
+        // ---- 机器根（此电脑：盘符列表）—— 工作区之上的虚拟层 ----
+        if (raw === MACHINE_ROOT || raw === MACHINE_ROOT + "/") {
+            const entries = await this.machineRootEntries();
+            this.host.emit({
+                type: "files",
+                path: MACHINE_ROOT,
+                parent: null,
+                entries,
+                truncated: false,
+                absolute: true,
+            });
+            return;
+        }
+        // ---- 绝对路径浏览（Windows 盘符 / posix "/"）：允许越过工作区根 ----
+        // 机器模式不设 watcher（工作区递归 watch 不覆盖别的盘），文件变动靠 10s 轮询。
+        if (isAbsoluteWirePath(raw)) {
+            const wire = normWirePath(raw);
+            const abs = wireToAbs(wire);
+            const { entries, truncated, error } = await readDirForUI(abs, wire);
+            this.host.emit({
+                type: "files",
+                path: wire,
+                parent: absoluteParent(wire),
+                entries,
+                truncated,
+                absolute: true,
+            });
+            if (error) {
+                this.host.emit({
+                    type: "notice",
+                    level: "warning",
+                    text: `目录不可读：${error}`,
+                    textEn: `Directory is not readable: ${error}`,
+                });
+            }
+            return;
+        }
+        // ---- 工作区相对视图（原有行为） ----
+        const target = raw ? resolve(root, raw) : root;
         const rawRel = relative(root, target);
         if (rawRel.startsWith("..") || rawRel.includes(`${sep}..`)) {
             this.host.emit({
@@ -175,7 +277,8 @@ export class FilesService {
         this.host.emit({
             type: "files",
             path: rel === "" ? "" : rel,
-            parent: rel === "" ? null : rel.includes("/") ? rel.slice(0, rel.lastIndexOf("/")) : "",
+            // 工作区根也允许「上一级」→ 机器根（Windows 换盘符 / posix 到 /）。
+            parent: rel === "" ? MACHINE_ROOT : rel.includes("/") ? rel.slice(0, rel.lastIndexOf("/")) : "",
             entries,
             truncated,
         });
@@ -508,17 +611,28 @@ export class FilesService {
         try {
             const fs = await import("node:fs/promises");
             const root = this.host.getCwd();
-            const wp = workspacePath(resolve(root), relPath);
-            if (!wp) {
-                this.host.emit({
-                    type: "notice",
-                    level: "warning",
-                    text: `路径超出工作区：${relPath}`,
-                    textEn: `Path is outside the workspace: ${relPath}`,
-                });
-                return;
+            const absWire = isAbsoluteWirePath(relPath);
+            let abs;
+            let rel;
+            if (absWire) {
+                // 机器浏览：绝对路径直接读；回显用绝对 wire 形式（前端按 path 匹配）。
+                abs = wireToAbs(relPath);
+                rel = abs.split(sep).join("/");
+            }
+            else {
+                const w = workspacePath(resolve(root), relPath);
+                if (!w) {
+                    this.host.emit({
+                        type: "notice",
+                        level: "warning",
+                        text: `路径超出工作区：${relPath}`,
+                        textEn: `Path is outside the workspace: ${relPath}`,
+                    });
+                    return;
+                }
+                abs = w.abs;
+                rel = w.rel;
             }
-            const { abs, rel } = wp;
             const stat = await fs.stat(abs);
             if (!stat.isFile()) {
                 this.host.emit({
@@ -600,15 +714,26 @@ export class FilesService {
     async writeFile(relPath, text) {
         try {
             const root = this.host.getCwd();
-            const wp = workspacePath(resolve(root), relPath);
-            if (!wp) {
-                this.host.emit({
-                    type: "notice",
-                    level: "warning",
-                    text: `路径超出工作区：${relPath}`,
-                    textEn: `Path is outside the workspace: ${relPath}`,
-                });
-                return;
+            const absWire = isAbsoluteWirePath(relPath);
+            let abs;
+            let rel;
+            if (absWire) {
+                abs = wireToAbs(relPath);
+                rel = abs.split(sep).join("/");
+            }
+            else {
+                const w = workspacePath(resolve(root), relPath);
+                if (!w) {
+                    this.host.emit({
+                        type: "notice",
+                        level: "warning",
+                        text: `路径超出工作区：${relPath}`,
+                        textEn: `Path is outside the workspace: ${relPath}`,
+                    });
+                    return;
+                }
+                abs = w.abs;
+                rel = w.rel;
             }
             if (Buffer.byteLength(text, "utf8") > 2 * 1024 * 1024) {
                 this.host.emit({
@@ -619,7 +744,7 @@ export class FilesService {
                 });
                 return;
             }
-            const stat = statSync(wp.abs);
+            const stat = statSync(abs);
             if (!stat.isFile()) {
                 this.host.emit({
                     type: "notice",
@@ -629,16 +754,16 @@ export class FilesService {
                 });
                 return;
             }
-            writeFileSync(wp.abs, text, "utf8");
+            writeFileSync(abs, text, "utf8");
             this.host.emit({
                 type: "notice",
                 level: "info",
-                text: `已保存：${wp.rel}`,
-                textEn: `Saved: ${wp.rel}`,
+                text: `已保存：${rel}`,
+                textEn: `Saved: ${rel}`,
             });
             // Re-read through the same path as the preview request so the client
             // gets the canonical content, line count and file size after saving.
-            await this.readFile(wp.rel);
+            await this.readFile(rel);
         }
         catch (err) {
             this.host.emit({
@@ -657,17 +782,22 @@ export class FilesService {
      * for the target dir (the recursive watcher may not cover it on posix).
      */
     async uploadFile(relDir, name, data) {
-        const emitErr = (text) => this.host.emit({ type: "notice", level: "error", text });
+        const emitErr = (text, textEn) => this.host.emit({ type: "notice", level: "error", text, textEn });
         try {
             const root = this.host.getCwd();
+            const absDir = relDir ? isAbsoluteWirePath(relDir) : false;
             let wp;
-            if (relDir) {
+            if (relDir && !absDir) {
                 wp = workspacePath(resolve(root), relDir);
                 if (!wp) {
-                    emitErr(`路径超出工作区：${relDir}`);
+                    emitErr(`路径超出工作区：${relDir}`, `Path outside workspace: ${relDir}`);
                     return;
                 }
             }
+            else if (relDir) {
+                // 机器浏览的目录（可能是盘符根 "C:"）：按绝对路径解析。
+                wp = { abs: wireToAbs(relDir), rel: wireToAbs(relDir).split(sep).join("/") };
+            }
             else {
                 wp = { abs: root, rel: "" };
             }
@@ -676,18 +806,26 @@ export class FilesService {
             const base = name.split(/[\\/]/).pop() ?? "";
             const safe = (base.replace(/[/:*?"<>|\x00-\x1f]/g, "_").trim() || "file").slice(0, 200);
             const abs = resolve(wp.abs, safe);
-            const rawRel = relative(root, abs);
-            if (rawRel.startsWith("..") || rawRel.includes(`${sep}..`)) {
-                emitErr(`文件名不合法：${name}`);
-                return;
+            let uploadRel;
+            if (absDir) {
+                // 绝对目录模式不再校验工作区归属（机器浏览）。
+                uploadRel = abs.split(sep).join("/");
+            }
+            else {
+                const rawRel = relative(root, abs);
+                if (rawRel.startsWith("..") || rawRel.includes(`${sep}..`)) {
+                    emitErr(`文件名不合法：${name}`, `Invalid file name: ${name}`);
+                    return;
+                }
+                uploadRel = rawRel.split(sep).join("/");
             }
             const buf = Buffer.from(data, "base64");
             if (buf.length === 0) {
-                emitErr(`空文件：${name}`);
+                emitErr(`空文件：${name}`, `Empty file: ${name}`);
                 return;
             }
             if (buf.length > MAX_UPLOAD_BYTES) {
-                emitErr(`文件过大：${name}（上限 ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)}MB）`);
+                emitErr(`文件过大：${name}（上限 ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)}MB）`, `File too large: ${name} (max ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)}MB)`);
                 return;
             }
             mkdirSync(wp.abs, { recursive: true });
@@ -695,8 +833,8 @@ export class FilesService {
             this.host.emit({
                 type: "notice",
                 level: "info",
-                text: `已上传：${rawRel.split(sep).join("/")}`,
-                textEn: `Uploaded: ${rawRel.split(sep).join("/")}`,
+                text: `已上传：${uploadRel}`,
+                textEn: `Uploaded: ${uploadRel}`,
             });
             // Emit for the target directory itself so the panel refreshes even
             // when the active listing/preview isn't that dir (posix watcher only
@@ -707,7 +845,7 @@ export class FilesService {
             });
         }
         catch (err) {
-            emitErr(`上传文件失败：${err.message}`);
+            emitErr(`上传文件失败：${err.message}`, `Upload failed: ${err.message}`);
         }
     }
     /**
@@ -764,13 +902,67 @@ export class FilesService {
             const { homedir } = await import("node:os");
             const home = homedir();
             const cwd = this.host.getCwd();
-            // Expand ~ and relative inputs to an absolute path. Windows users type
-            // backslashes (P:\agent) and ~\ — handle both separator styles.
-            let expanded = input.trim();
-            if (expanded === "") {
+            const isWin = IS_WIN32;
+            const rawInput = input.trim();
+            if (rawInput === "") {
                 empty();
                 return;
             }
+            // ---- 机器根（此电脑/盘符列表）----
+            if (rawInput === MACHINE_ROOT || rawInput === MACHINE_ROOT + "/") {
+                this.host.emit({ type: "path_completions", completions: await this.machineRootEntries() });
+                return;
+            }
+            // ---- Windows 盘符输入："D"（补全到盘符，Tab 即换盘）/ "D:"（列盘根）----
+            if (isWin && /^[A-Za-z]:?$/.test(rawInput)) {
+                const letter = rawInput[0].toUpperCase();
+                const drive = `${letter}:`;
+                let st;
+                try {
+                    st = await fs.stat(`${drive}\\`);
+                }
+                catch {
+                    empty();
+                    return;
+                }
+                if (!st.isDirectory()) {
+                    empty();
+                    return;
+                }
+                if (rawInput.length === 2) {
+                    // 已带冒号：直接列出盘根条目。
+                    const dirents = await fs.readdir(`${drive}\\`, { withFileTypes: true }).catch(() => null);
+                    if (!dirents) {
+                        empty();
+                        return;
+                    }
+                    const items = dirents
+                        .filter((d) => !ignoredEntries().has(d.name))
+                        .map((d) => ({
+                        name: d.name,
+                        path: `${drive}/${d.name}`,
+                        type: (d.isDirectory() ? "dir" : "file"),
+                    }))
+                        .sort((a, b) => {
+                        const aHidden = a.name.startsWith(".");
+                        const bHidden = b.name.startsWith(".");
+                        if (aHidden !== bHidden)
+                            return aHidden ? 1 : -1;
+                        if (a.type !== b.type)
+                            return a.type === "dir" ? -1 : 1;
+                        return a.name.localeCompare(b.name);
+                    })
+                        .slice(0, 100);
+                    this.host.emit({ type: "path_completions", completions: items });
+                    return;
+                }
+                // 只有字母：补全到盘符本身。
+                this.host.emit({ type: "path_completions", completions: [{ name: drive, path: drive, type: "dir" }] });
+                return;
+            }
+            // Expand ~ and relative inputs to an absolute path. Windows users type
+            // backslashes (P:\agent) and ~\ — handle both separator styles.
+            let expanded = rawInput;
             if (expanded === "~" || expanded === "~\\") {
                 expanded = home;
             }

package/dist/server/goal-service.js

@@ -611,7 +611,10 @@ export class GoalService {
                 g.status = "已手动停止，目标审查已中止";
                 g.statusEn = "Stopped manually, goal review aborted";
                 this.emitGoalStatus();
-                return "⏹ 已手动停止，目标审查已中止（想继续可重新设定目标）";
+                return {
+                    text: "⏹ 已手动停止，目标审查已中止（想继续可重新设定目标）",
+                    textEn: "⏹ Stopped manually, goal review aborted (set a new goal to continue)",
+                };
             }
             return null;
         }

package/dist/server/index.js

@@ -30,6 +30,7 @@ import { WebSocket, WebSocketServer } from "ws";
 import { VERSION, getAgentDir } from "@earendil-works/pi-coding-agent";
 import { PROTOCOL_VERSION } from "./protocol-version.js";
 import { AgentService, workspacePath, QuiesceRejectedError } from "./agent-service.js";
+import { isAbsoluteWirePath, wireToAbs } from "./files-service.js";
 import { previewKind } from "./text-sniff.js";
 import { startControlServer } from "./control-socket.js";
 import { scheduleUploadCleanup } from "./uploads.js";
@@ -118,21 +119,47 @@ function requestTokens(req) {
 function tokenOk(req) {
     return requestTokens(req).includes(AUTH_TOKEN);
 }
+/** 请求携带的 pi_web_token cookie 值（未带/损坏时为空串）。 */
+function cookieToken(req) {
+    const cookie = req.headers.cookie;
+    if (typeof cookie !== "string")
+        return "";
+    for (const part of cookie.split(";")) {
+        const [k, ...rest] = part.trim().split("=");
+        if (k === "pi_web_token")
+            return rest.join("=").trim();
+    }
+    return "";
+}
 if (AUTH_TOKEN) {
     // /api/health 保持开放：无敏感信息，容器/监控探针需要它。
-    // 但绝不能因命中 /api/health 就反射下发真实 token cookie（安全漏洞）。
+    // 但绝不能因命中 /api/health 就反射下发真实 token cookie（安全漏洞：issue #45）。
     app.use((req, res, next) => {
         const ok = tokenOk(req);
-        // 浏览器经 ?token= 首次进入后下发 HttpOnly cookie，后续导航/资源请求免带参数；
-        // 只有请求确实携带着有效 token 时才下发——匿名命中 /api/health 不触发。
-        if (ok && !req.headers.cookie?.includes("pi_web_token=")) {
-            res.setHeader("Set-Cookie", `pi_web_token=${encodeURIComponent(AUTH_TOKEN)}; Path=/; HttpOnly; SameSite=Strict; Max-Age=31536000`);
+        const cookie = cookieToken(req);
+        // 浏览器经 ?token= 首次进入后下发 HttpOnly cookie，后续导航/资源请求免带参数。
+        // 重要：只要请求携带着有效 token（query/header/cookie 任一匹配）就把 cookie 刷新为
+        // 当前 AUTH_TOKEN——服务端重启改了 PI_WEB_TOKEN 后，旧 cookie 经一次正确的
+        // ?token= 进入即被重新同步，无需用户清缓存（issue #71）。
+        if (ok) {
+            if (cookie !== encodeURIComponent(AUTH_TOKEN)) {
+                res.setHeader("Set-Cookie", `pi_web_token=${encodeURIComponent(AUTH_TOKEN)}; Path=/; HttpOnly; SameSite=Strict; Max-Age=31536000`);
+            }
+        }
+        else if (cookie) {
+            // 请求带的 cookie 已是失效旧值（服务端口令已更换）——立即让其过期，
+            // 避免浏览器被残留 cookie 卡死一年（本来也不该再信任它鉴权）。
+            res.setHeader("Set-Cookie", "pi_web_token=; Path=/; HttpOnly; SameSite=Strict; Max-Age=0");
         }
         if (req.path === "/api/health" || ok) {
             next();
             return;
         }
-        res.status(401).send("unauthorized: PI_WEB_TOKEN required (?token=…)");
+        res
+            .status(401)
+            .send(cookie
+            ? "unauthorized: PI_WEB_TOKEN required — 服务端口令已变更？已清除旧 token cookie，请用当前 ?token= 重新进入"
+            : "unauthorized: PI_WEB_TOKEN required (?token=…)");
     });
 }
 /** 引擎选择：PI_WEB_ENGINE=pi|dsh（默认 pi）。重启生效。 */
@@ -160,12 +187,20 @@ app.get("/api/file", async (req, res) => {
         // back to the server cwd for requests without a known client.
         const cid = typeof req.query.clientId === "string" ? req.query.clientId : "";
         const cs = cid ? service.get(cid) : undefined;
-        const wp = workspacePath(cs?.cwd ?? CWD, raw);
-        if (!wp) {
-            res.status(400).end("path outside workspace");
-            return;
+        const root = cs?.cwd ?? CWD;
+        const absWire = isAbsoluteWirePath(raw);
+        let abs;
+        if (absWire) {
+            abs = wireToAbs(raw);
+        }
+        else {
+            const wp = workspacePath(root, raw);
+            if (!wp) {
+                res.status(400).end("path outside workspace");
+                return;
+            }
+            abs = wp.abs;
         }
-        const abs = wp.abs;
         const name = basename(abs);
         const kind = previewKind(name);
         const isDownload = req.query.download === "1";
@@ -803,10 +838,10 @@ wss.on("connection", (ws) => {
             case "plugin_settings": {
                 const r = pluginMgr.savePluginSettings(msg.pluginId, msg.values ?? {});
                 if (r.error) {
-                    cs?.emitNotice("error", `插件设置保存失败：${r.error}`);
+                    cs?.emitNotice("error", `插件设置保存失败：${r.error}`, `Failed to save plugin settings: ${r.error}`);
                 }
                 else {
-                    cs?.emitNotice("info", "插件设置已保存");
+                    cs?.emitNotice("info", "插件设置已保存", "Plugin settings saved");
                 }
                 break;
             }

package/dist/server/marker-service.js

@@ -155,8 +155,8 @@ export class MarkerService {
             const state = getOrInit(token.tool);
             const ctx = {
                 conversationId,
-                notify: (msg, level) => {
-                    this.host.emit({ type: "notice", level: level ?? "info", text: msg });
+                notify: (msg, level, msgEn) => {
+                    this.host.emit({ type: "notice", level: level ?? "info", text: msg, textEn: msgEn });
                 },
                 renameConversation: (title) => {
                     this.host.renameConversation(conversationId, title);
@@ -183,7 +183,12 @@ export class MarkerService {
                     dirty.add(token.tool);
             }
             else if (result.error) {
-                this.host.emit({ type: "notice", level: "warning", text: `[${token.tool}] ${result.error}` });
+                this.host.emit({
+                    type: "notice",
+                    level: "warning",
+                    text: `[${token.tool}] ${result.error}`,
+                    textEn: `[${token.tool}] ${result.error}`,
+                });
             }
         }
         for (const ns of dirty) {

package/dist/server/markers/builtins/rename.js

@@ -43,7 +43,7 @@ export const renameMarker = {
             return { applied: false, error: "当前环境不支持重命名" };
         try {
             ctx.renameConversation(title);
-            ctx.notify(`已重命名为：${title}`, "info");
+            ctx.notify(`已重命名为：${title}`, "info", `Renamed to: ${title}`);
             return { applied: true, feedback: `renamed to "${title}"` };
         }
         catch (e) {
@@ -69,7 +69,7 @@ export const renameAliasMarker = {
             return { applied: false, error: "当前环境不支持重命名" };
         try {
             ctx.renameConversation(trimmed);
-            ctx.notify(`已重命名为：${trimmed}`, "info");
+            ctx.notify(`已重命名为：${trimmed}`, "info", `Renamed to: ${trimmed}`);
             return { applied: true, feedback: `renamed to "${trimmed}"` };
         }
         catch (e) {
@@ -92,7 +92,7 @@ export const titleAliasMarker = {
         if (!ctx.renameConversation)
             return { applied: false, error: "当前环境不支持重命名" };
         ctx.renameConversation(title.slice(0, 80));
-        ctx.notify(`已重命名为：${title.slice(0, 80)}`, "info");
+        ctx.notify(`已重命名为：${title.slice(0, 80)}`, "info", `Renamed to: ${title.slice(0, 80)}`);
         return { applied: true, feedback: `renamed` };
     },
     overlay: undefined,

package/dist/server/model-admin.js

@@ -575,19 +575,19 @@ export class ModelAdminService {
      */
     async cloneProvider(providerId, reqId) {
         const pid = providerId.trim();
-        const fail = (error) => {
-            this.host.emit({ type: "notice", level: "error", text: error });
+        const fail = (error, errorEn) => {
+            this.host.emit({ type: "notice", level: "error", text: error, textEn: errorEn });
             this.host.emit({ type: "clone_provider_result", reqId, ok: false, error });
         };
         try {
             if (!pid) {
-                fail("请填写服务商 ID");
+                fail("请填写服务商 ID", "Enter a provider ID");
                 return;
             }
             const mr = this.host.modelRuntime();
             const p = mr.getProvider(pid);
             if (!p) {
-                fail(`供应商 ${pid} 不存在`);
+                fail(`供应商 ${pid} 不存在`, `Provider ${pid} does not exist`);
                 return;
             }
             const noBaseUrl = !p.baseUrl;
@@ -617,7 +617,7 @@ export class ModelAdminService {
                 models = readModels();
             }
             if (models.length === 0) {
-                fail(`${pid} 的模型列表为空，无法复制（请稍后重试）`);
+                fail(`${pid} 的模型列表为空，无法复制（请稍后重试）`, `Model list for ${pid} is empty, cannot clone (retry later)`);
                 return;
             }
             // 供应商级 api 取占比最高，模型保留全量去重（避免 muse-spark 被过滤）
@@ -652,11 +652,14 @@ export class ModelAdminService {
                 text: noBaseUrl
                     ? `📋 已复制 ${pid} → ${newId}（${kept.length} 个模型），该供应商无远程 baseUrl，已生成模板请手动填写 baseUrl 和新的 API 密钥后保存`
                     : `📋 已复制 ${pid} → ${newId}（${kept.length} 个模型），请填入新的 API 密钥后保存`,
+                textEn: noBaseUrl
+                    ? `📋 Cloned ${pid} → ${newId} (${kept.length} models); this provider has no remote baseUrl — template generated, fill in baseUrl and a new API key, then save`
+                    : `📋 Cloned ${pid} → ${newId} (${kept.length} models); fill in the new API key, then save`,
             });
             this.host.emit({ type: "clone_provider_result", reqId, ok: true, config, configs: [config] });
         }
         catch (err) {
-            fail(`复制服务商失败：${err.message}`);
+            fail(`复制服务商失败：${err.message}`, `Failed to clone provider: ${err.message}`);
         }
         this.host.flushSnapshot();
     }
@@ -1015,6 +1018,9 @@ export class ModelAdminService {
                 text: added > 0
                     ? `🔄 已刷新 ${pid}：新增 ${added} 个模型，共 ${merged.length} 个`
                     : `🔄 已刷新 ${pid}：无新增模型（共 ${merged.length} 个）`,
+                textEn: added > 0
+                    ? `🔄 Refreshed ${pid}: ${added} new models, ${merged.length} total`
+                    : `🔄 Refreshed ${pid}: no new models (${merged.length} total)`,
             });
             return done(true, { added, total: merged.length });
         }

package/dist/server/plugins.js

@@ -308,7 +308,7 @@ export class PluginManager {
             if (prev === key)
                 return; // 同版本能力清单，不再打扰
             const list = perms.length ? perms.join(", ") : "无";
-            this.notifyAll(perms.length ? "warning" : "info", `插件「${info.name}」已激活（${prev ? "能力清单变更" : "首次安装"}；声明能力：${list}）——请确认来源可信`);
+            this.notifyAll(perms.length ? "warning" : "info", `插件「${info.name}」已激活（${prev ? "能力清单变更" : "首次安装"}；声明能力：${list}）——请确认来源可信`, `Plugin "${info.name}" activated (${prev ? "capability list changed" : "first install"}; declared: ${list}) — verify the source is trusted`);
             writeFileSync(markerFile, JSON.stringify({ v: 1, key, perms }), "utf8");
         }
         catch (err) {
@@ -344,8 +344,8 @@ export class PluginManager {
         this.deliverAll({ type: "plugin_data", pluginId, payload });
     }
     /** 系统通知：发给所有 socket（复用 notice 消息，前端 toast 展示）。 */
-    notifyAll(level, text) {
-        this.deliverAll({ type: "notice", level, text });
+    notifyAll(level, text, textEn) {
+        this.deliverAll({ type: "notice", level, text, textEn });
     }
     /** 给指定客户端定向发一条插件消息；找不到该 socket 时静默忽略。 */
     sendTo(clientId, pluginId, payload) {
@@ -708,7 +708,7 @@ export class PluginManager {
         const self = this; // 对象字面量 getter 里不能用插件宿主的 this (oxlint no-this-alias: 誤報, getter closure 需要 host)
         const host = {
             broadcast: (payload) => this.broadcast(info.id, payload),
-            notify: (level, text) => this.notifyAll(level, text),
+            notify: (level, text, textEn) => this.notifyAll(level, text, textEn),
             sendTo: (clientId, payload) => this.sendTo(clientId, info.id, payload),
             onMessage: (h) => {
                 handlers.add(h);

package/dist/server/slash-commands.js

@@ -174,6 +174,9 @@ export class SlashCommandsService {
                         text: current
                             ? `当前模型：${current.name}（${current.provider}/${current.id}）。用法：/model <名称>`
                             : `用法：/model <名称>`,
+                        textEn: current
+                            ? `Current model: ${current.name} (${current.provider}/${current.id}). Usage: /model <name>`
+                            : `Usage: /model <name>`,
                     });
                     return true;
                 }