pi-web-ui 0.68.1 → 0.69.0

package/dist/server/goal-service.js

@@ -15,6 +15,7 @@
 import { join } from "node:path";
 import { Type } from "typebox";
 import { createAgentSessionFromServices, createAgentSessionServices, defineTool, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { bilingual, pick } from "./i18n.js";
 import { parseModelSpec } from "./attachments.js";
 /** System prompt for the goal-wizard session. The wizard asks the user a few
  *  questions (via its goal_ask tool) to scope a raw requirement into a precise,
@@ -75,6 +76,14 @@ export class GoalService {
     get reviewPrefs() {
         return this.prefs;
     }
+    /** 当前服务端语言（英文默认，未接线前保持原有英文行为）。 */
+    lang() {
+        return this.host.lang?.() ?? "en";
+    }
+    /** 目标模式总开关（设置面板可关）。关 → 所有目标入口拒绝、审查不再触发。 */
+    goalEnabled() {
+        return this.host.goalModeEnabled();
+    }
     /** Create independent goal state for one conversation. Preferences are
      * client-wide defaults, while goal text/review progress is not shared. */
     makeGoalStatus() {
@@ -120,6 +129,15 @@ export class GoalService {
             await this.clearGoal();
             return;
         }
+        if (!this.goalEnabled()) {
+            this.host.emit({
+                type: "notice",
+                level: "warning",
+                text: "目标模式已关闭：请先在设置「目标审查」中启用目标模式。",
+                textEn: "Goal mode is off: enable it under Settings → Goal review first.",
+            });
+            return;
+        }
         // A goal is scoped to the conversation that is active when it is set.
         // This prevents an agent_end from a newly-created/switched conversation
         // from consuming the previous conversation's goal.
@@ -175,7 +193,8 @@ export class GoalService {
         if (opts?.autoStart !== false) {
             try {
                 const s = conv.session;
-                await s.sendUserMessage(`【目标已设定】\n\n${text}\n\n请现在开始实现这个目标。`, {
+                const kick = pick(this.lang(), `【目标已设定】\n\n${text}\n\n请现在开始实现这个目标。`, `[Goal set]\n\n${text}\n\nStart implementing this goal now.`, "goal.set.kick", { text: text });
+                await s.sendUserMessage(kick, {
                     deliverAs: s.isStreaming ? "steer" : "followUp",
                 });
             }
@@ -196,6 +215,15 @@ export class GoalService {
     async startGoalWizard(text, opts) {
         if (this.host.quiesceBlocked())
             return;
+        if (!this.goalEnabled()) {
+            this.host.emit({
+                type: "notice",
+                level: "warning",
+                text: "目标模式已关闭：请先在设置「目标审查」中启用目标模式。",
+                textEn: "Goal mode is off: enable it under Settings → Goal review first.",
+            });
+            return;
+        }
         const draft = (text ?? "").trim();
         if (!draft)
             return;
@@ -272,7 +300,7 @@ export class GoalService {
             idleTimer = setTimeout(() => {
                 if (!ac.signal.aborted) {
                     this.wizardCancelled = true;
-                    ac.abort(new Error("目标调研超时（等待回答过久）"));
+                    ac.abort(new Error(pick(this.lang(), "目标调研超时（等待回答过久）", "Goal survey timed out (waited too long for an answer)", "goal.wizard.idle.timeout")));
                 }
             }, GoalService.WIZARD_IDLE_TIMEOUT_MS);
             idleTimer.unref?.();
@@ -289,7 +317,7 @@ export class GoalService {
         const totalTimer = setTimeout(() => {
             if (!ac.signal.aborted) {
                 this.wizardCancelled = true;
-                ac.abort(new Error("目标调研超过总时长上限"));
+                ac.abort(new Error(pick(this.lang(), "目标调研超过总时长上限", "Goal survey exceeded the total time limit", "goal.wizard.total.timeout")));
             }
         }, GoalService.WIZARD_MAX_TOTAL_MS);
         totalTimer.unref?.();
@@ -326,9 +354,9 @@ export class GoalService {
             const goalAsk = defineTool({
                 name: "goal_ask",
                 label: "Ask the user",
-                description: "Ask the user ONE question at a time to scope down the goal. Provide a clear question and 2-4 concise options; or ask an open question. Returns the user's chosen answer.",
+                description: bilingual("Ask the user ONE question at a time to scope down the goal. Provide a clear question and 2-4 concise options; or ask an open question. Returns the user's chosen answer.", "一次只向用户提一个问题，以明确目标范围。给出清晰的问题和 2-4 个简洁选项；或提开放式问题。返回用户选择的答案。"),
                 parameters: Type.Object({
-                    question: Type.String({ description: "The question to ask" }),
+                    question: Type.String({ description: bilingual("The question to ask", "要问的问题") }),
                     options: Type.Optional(Type.Array(Type.String())),
                 }),
                 // ONE question at a time. Sequential execution prevents the agent from
@@ -337,13 +365,14 @@ export class GoalService {
                 // reported "调研卡住").
                 executionMode: "sequential",
                 execute: async (_id, params, _sig, _onUpdate, ctx) => {
+                    const lang = this.lang();
                     qStep += 1;
                     if (qStep > maxSteps) {
                         return {
                             content: [
                                 {
                                     type: "text",
-                                    text: "(达到最大提问数，请直接给出收敛后的目标文本作为最终答案)",
+                                    text: pick(lang, "(达到最大提问数，请直接给出收敛后的目标文本作为最终答案)", "(Max questions reached — stop asking and reply with the converged goal text as your final answer)", "goal.wizard.max.questions"),
                                 },
                             ],
                             details: {},
@@ -358,16 +387,23 @@ export class GoalService {
                     try {
                         armIdle();
                         const isChoice = !!(params.options && params.options.length > 0);
-                        await this.pushWizardCard(mainSession, `🔍 第 ${qStep} 题：${params.question}${isChoice ? `【${params.options.join(" / ")}】` : ""}`, { question: params.question });
+                        const qTitle = pick(lang, `🔍 第 ${qStep} 题：${params.question}`, `🔍 Question ${qStep}: ${params.question}`, "goal.wizard.question.title", { qStep: qStep, "params.question": params.question });
+                        const optionsJoined = params.options.join(" / ");
+                        const choiceSuffixZh = isChoice ? `【${optionsJoined}】` : "";
+                        const choiceSuffixEn = isChoice ? ` [${optionsJoined}]` : "";
+                        await this.pushWizardCard(mainSession, pick(lang, `🔍 第 ${qStep} 题：${params.question}${choiceSuffixZh}`, `🔍 Question ${qStep}: ${params.question}${choiceSuffixEn}`, "goal.wizard.question.card", {
+                            qStep: qStep,
+                            "params.question": params.question,
+                            choiceSuffixZh: choiceSuffixZh,
+                            choiceSuffixEn: choiceSuffixEn,
+                        }), { question: params.question });
                         // Resolve the pending dialog as cancelled if the wizard is aborted.
                         let aborted = false;
                         const onAbort = () => {
                             aborted = true;
                         };
                         ac.signal.addEventListener("abort", onAbort, { once: true });
-                        const choose = isChoice
-                            ? ctx.ui.select(`🔍 第 ${qStep} 题：${params.question}`, params.options)
-                            : ctx.ui.input(`🔍 第 ${qStep} 题：${params.question}`);
+                        const choose = isChoice ? ctx.ui.select(qTitle, params.options) : ctx.ui.input(qTitle);
                         const ans = (await choose);
                         ac.signal.removeEventListener("abort", onAbort);
                         if (aborted || ac.signal.aborted) {
@@ -375,7 +411,7 @@ export class GoalService {
                                 content: [
                                     {
                                         type: "text",
-                                        text: "(调研已取消，请不要继续提问，直接结束对话)",
+                                        text: pick(lang, "(调研已取消，请不要继续提问，直接结束对话)", "(The survey was cancelled — stop asking and end the conversation)", "goal.wizard.cancelled.stop"),
                                     },
                                 ],
                                 details: {},
@@ -386,30 +422,40 @@ export class GoalService {
                                 content: [
                                     {
                                         type: "text",
-                                        text: "(用户已取消调研，请直接给出你当前收敛的目标文本作为最终答案)",
+                                        text: pick(lang, "(用户已取消调研，请直接给出你当前收敛的目标文本作为最终答案)", "(The user cancelled the survey — reply with your best-effort goal text as the final answer)", "goal.wizard.cancelled.best"),
                                     },
                                 ],
                                 details: {},
                             };
                         }
                         // Record the answer in the flow too (instant append, main session idle).
-                        await this.pushWizardCard(mainSession, `↳ 您的回答：${ans}`, {
+                        await this.pushWizardCard(mainSession, pick(lang, `↳ 您的回答：${ans}`, `↳ Your answer: ${ans}`, "goal.wizard.answer.card", { ans: ans }), {
                             question: params.question,
                             answer: String(ans),
                         });
                         return {
-                            content: [{ type: "text", text: `用户回答：${ans}` }],
+                            content: [
+                                {
+                                    type: "text",
+                                    text: pick(lang, `用户回答：${ans}`, `User answer: ${ans}`, "goal.wizard.answer.return", {
+                                        ans: ans,
+                                    }),
+                                },
+                            ],
                             details: {},
                         };
                     }
                     catch (err) {
+                        const errMsg = err.message;
                         return {
                             content: [
                                 {
                                     type: "text",
                                     text: ac.signal.aborted
-                                        ? "(调研已取消，请不要继续提问，直接结束对话)"
-                                        : `提问失败：${err.message}`,
+                                        ? pick(lang, "(调研已取消，请不要继续提问，直接结束对话)", "(The survey was cancelled — stop asking and end the conversation)", "goal.wizard.cancelled.aborted")
+                                        : pick(lang, `提问失败：${errMsg}`, `Failed to ask: ${errMsg}`, "goal.wizard.ask.failed", {
+                                            errMsg: errMsg,
+                                        }),
                                 },
                             ],
                             details: {},
@@ -526,7 +572,8 @@ export class GoalService {
         // The kick-off is a user message so it appears in the flow and triggers a
         // normal turn; the finishing agent_end then runs the review loop.
         try {
-            await mainSession.sendUserMessage(`【目标已设定】\n\n${wgoal.goal}\n\n请现在开始实现这个目标。`, {
+            const wizardKick = pick(this.lang(), `【目标已设定】\n\n${wgoal.goal}\n\n请现在开始实现这个目标。`, `[Goal set]\n\n${wgoal.goal}\n\nStart implementing this goal now.`, "goal.wizard.kick", { "wgoal.goal": wgoal.goal });
+            await mainSession.sendUserMessage(wizardKick, {
                 deliverAs: mainSession.isStreaming ? "steer" : "followUp",
             });
         }
@@ -538,6 +585,8 @@ export class GoalService {
      *  touching the active goal — so changes in the goal bar are remembered across
      *  reloads. maxRounds 0 = unlimited. Emits goal_status so the UI stays synced. */
     async setGoalPrefs(opts) {
+        if (!this.goalEnabled())
+            return;
         const goal = this.host.activeConv().goal;
         if (opts?.reviewModel !== undefined)
             goal.reviewModel = opts.reviewModel || null;
@@ -621,7 +670,12 @@ export class GoalService {
         // Goal review hook: after the run finished normally, if a goal is
         // active (and it belonged to the ACTIVE conversation) and we're not
         // already mid-review, spawn the isolated reviewer.
-        if (g.goal && g.conversationId === conv.id && !g.reviewing && !conv.wizardRunning && !this.host.isDisposed()) {
+        if (g.goal &&
+            g.conversationId === conv.id &&
+            !g.reviewing &&
+            !conv.wizardRunning &&
+            !this.host.isDisposed() &&
+            this.goalEnabled()) {
             void this.runGoalReview(conv);
         }
         return null;
@@ -743,7 +797,7 @@ export class GoalService {
             return;
         }
         let reviewerVerdict = "fail";
-        let reviewerFeedback = "（审查无法完成）";
+        let reviewerFeedback = pick(this.lang(), "（审查无法完成）", "(The review could not be completed)", "goal.review.incomplete");
         try {
             const rmSpec = this.resolveReviewModel(g.reviewModel);
             const services = await createAgentSessionServices({
@@ -800,8 +854,9 @@ export class GoalService {
             await srv.session.dispose();
         }
         catch (err) {
+            const reviewErrMsg = err.message;
             reviewerVerdict = "fail";
-            reviewerFeedback = `审查过程中出错：${err.message}`;
+            reviewerFeedback = pick(this.lang(), `审查过程中出错：${reviewErrMsg}`, `Error during review: ${reviewErrMsg}`, "goal.review.error", { reviewErrMsg: reviewErrMsg });
         }
         // The user may have switched chats or replaced/cleared the goal while the
         // isolated reviewer was running. Never apply a stale verdict or inject it
@@ -833,7 +888,8 @@ export class GoalService {
             // USER the outcome and hands the main agent back out of "goal mode", so a
             // follow-up instruction like "发布" is a normal request — not a confirm echo.
             try {
-                await mainSession.sendUserMessage(`✅ 目标已达成并通过审查（第 ${round} 轮）。\n\n目标：${goalText}\n\n${feedback}\n\n（目标模式已解除，接下来按你的普通指令响应。）`, { deliverAs: mainSession.isStreaming ? "steer" : "followUp" });
+                const passText = pick(this.lang(), `✅ 目标已达成并通过审查（第 ${round} 轮）。\n\n目标：${goalText}\n\n${feedback}\n\n（目标模式已解除，接下来按你的普通指令响应。）`, `✅ Goal achieved and passed review (round ${round}).\n\nGoal: ${goalText}\n\n${feedback}\n\n(Goal mode is off — respond to further instructions normally.)`, "goal.review.pass", { round: round, goalText: goalText, feedback: feedback });
+                await mainSession.sendUserMessage(passText, { deliverAs: mainSession.isStreaming ? "steer" : "followUp" });
             }
             catch {
                 // Best-effort.
@@ -856,8 +912,11 @@ export class GoalService {
             // Inject the reviewer's feedback into the main session to revise (this IS
             // the fail review result, as an ordinary user message — no separate card).
             try {
-                const steerText = `【目标审查：第 ${g.round}/${budgetForCard > 0 ? budgetForCard : "不限"} 轮未通过】\n\n目标：${goalText}\n\n` +
-                    `审查意见：${feedback}\n\n请根据以上意见修改你的成果，使其完全满足目标。`;
+                const capped = budgetForCard > 0 ? budgetForCard : "不限";
+                const cappedEn = budgetForCard > 0 ? budgetForCard : "unlimited";
+                const steerText = pick(this.lang(), `【目标审查：第 ${g.round}/${capped} 轮未通过】\n\n目标：${goalText}\n\n` +
+                    `审查意见：${feedback}\n\n请根据以上意见修改你的成果，使其完全满足目标。`, `[Goal review: round ${g.round}/${cappedEn} failed]\n\nGoal: ${goalText}\n\n` +
+                    `Feedback: ${feedback}\n\nRevise your work based on the feedback above so it fully satisfies the goal.`, "goal.review.revise", { "g.round": g.round, capped: capped, goalText: goalText, feedback: feedback, cappedEn: cappedEn });
                 await mainSession.sendUserMessage(steerText, {
                     deliverAs: mainSession.isStreaming ? "steer" : "followUp",
                 });
@@ -882,7 +941,9 @@ export class GoalService {
             g.statusEn = `Goal failed (${roundsEn})`;
         }
         try {
-            await mainSession.sendUserMessage(`❌ 目标未通过审查（第 ${round}/${budgetForCard > 0 ? budgetForCard : "不限"} 轮）。\n\n目标：${goalText}\n\n审查意见：${feedback}`, { deliverAs: mainSession.isStreaming ? "steer" : "followUp" });
+            const capped = budgetForCard > 0 ? budgetForCard : "不限";
+            const cappedEn = budgetForCard > 0 ? budgetForCard : "unlimited";
+            await mainSession.sendUserMessage(pick(this.lang(), `❌ 目标未通过审查（第 ${round}/${capped} 轮）。\n\n目标：${goalText}\n\n审查意见：${feedback}`, `❌ Goal failed review (round ${round}/${cappedEn}).\n\nGoal: ${goalText}\n\nFeedback: ${feedback}`, "goal.review.fail", { round: round, capped: capped, goalText: goalText, feedback: feedback, cappedEn: cappedEn }), { deliverAs: mainSession.isStreaming ? "steer" : "followUp" });
         }
         catch {
             // Best-effort.

package/dist/server/i18n.js

@@ -0,0 +1,157 @@
+/**
+ * i18n — server-side language negotiation (issue #91).
+ *
+ * Two tracks:
+ *  - Browser UI strings live in `locales/<code>.json` packs (`strings`).
+ *  - Server-authored strings the model relays to the user (tool return
+ *    values, prompt segments, guidance blocks) are keyed through THIS module.
+ *    zh/en stay inline at the call site (zero-cost, always available); every
+ *    OTHER language resolves through a per-language table that translators
+ *    ship inside the SAME pack file (`serverStrings` section — one download
+ *    covers UI + server). Missing key → English fallback, so partial
+ *    translations are safe and adding a language is just filling a table.
+ *
+ * Conventions for contributors:
+ *  - `pick(lang, zh, en, key?)` — key format `<module>.<slug>`, e.g.
+ *    `subagents.spawn.started`. Slugs derive from the English source text.
+ *    Keys must be globally unique (module prefix guarantees it).
+ *  - `getServerBlock(lang, key, zhLines, enLines)` — multi-line blocks
+ *    (guidance arrays, prompt sections); tables store one `\n`-joined string.
+ *  - `bilingual(en, zh)` — tool DEFINITIONS stay static en+zh (baked into the
+ *    session at creation; the model works fine with English definitions
+ *    under any UI language). No keys needed.
+ *  - Template DATA (subagent_templates content, user overrides) stays zh/en
+ *    fields — it is user-editable config, not code copy.
+ *
+ * Pure functions + a tiny in-memory registry (no node imports) — unit-tested.
+ * Tables are loaded from `<dataDir>/locales/*.json` at startup (see
+ * loadServerStringsFromDir + index.ts hooks); tests register synthetic tables.
+ */
+/**
+ * Normalize a UI locale code to a server language code.
+ * "zh-CN"/"zh_TW" → "zh"; "pt-BR" → "pt"; "en-US" → "en"; "" → "en".
+ */
+export function resolveServerLang(locale) {
+    if (typeof locale !== "string")
+        return "en";
+    const code = locale.trim().toLowerCase();
+    if (!code)
+        return "en";
+    const m = code.match(/^([a-z]{2,3})(?:[-_].*)?$/);
+    return m?.[1] ?? "en";
+}
+/** True when the server language is Chinese. */
+export function isZh(lang) {
+    return lang === "zh";
+}
+/* ------------------------------------------------------------------ */
+/* translator tables                                                   */
+/* ------------------------------------------------------------------ */
+const serverTables = new Map();
+/** Normalize a table code the same way locales resolve ("PT-br" → "pt"). */
+function tableCode(code) {
+    return resolveServerLang(code);
+}
+/** Register (or replace) a translator table, e.g. from a pack's
+ *  `serverStrings` section. Empty tables are ignored. */
+export function registerServerStrings(code, table) {
+    const entries = Object.entries(table ?? {}).filter(([k, v]) => typeof k === "string" && k.length > 0 && typeof v === "string");
+    if (entries.length === 0)
+        return;
+    serverTables.set(tableCode(code), Object.fromEntries(entries));
+}
+/** Drop a translator table (pack removed). */
+export function unregisterServerStrings(code) {
+    serverTables.delete(tableCode(code));
+}
+/** Visible for tests / diagnostics. */
+export function registeredServerLangs() {
+    return [...serverTables.keys()].sort();
+}
+/** Look up one key for a non-Chinese language (undefined = fall back). */
+export function getServerString(lang, key) {
+    if (isZh(lang) || !key)
+        return undefined;
+    const v = serverTables.get(tableCode(lang))?.[key];
+    return typeof v === "string" && v.length > 0 ? v : undefined;
+}
+/**
+ * Pick the zh/en variant of a user-visible or model-facing string, with
+ * translator-table override for other languages:
+ *   pick(lang, "当前没有子代理。", "No subagents running.", "subagents.list.empty")
+ * zh → inline Chinese; other → table hit or inline English.
+ *
+ * Interpolated strings pass `vars` (5th arg). Table values use `{expr}`
+ * slots where `expr` is the EXACT text inside the call site's `${...}`
+ * (translators copy it verbatim; complex sub-expressions should be hoisted
+ * to a named const at the call site first):
+ *   pick(lang, `剩${n}个`, `${n} left`, "k.items.left", { n })
+ *   → table: `"残り{n}件"`. Slots missing from `vars` stay literal.
+ */
+export function pick(lang, zh, en, key, vars) {
+    if (isZh(lang))
+        return zh;
+    if (key) {
+        const hit = getServerString(lang, key);
+        if (hit !== undefined)
+            return formatTable(hit, vars);
+    }
+    return en;
+}
+/** Fill `{name}` slots from vars (unknown slots stay literal so a stale
+ *  table never eats text silently; null/undefined render as empty). */
+export function formatTable(template, vars) {
+    if (!vars)
+        return template;
+    let out = template;
+    for (const [k, v] of Object.entries(vars)) {
+        out = out.split(`{${k}}`).join(v === undefined || v === null ? "" : String(v));
+    }
+    return out;
+}
+/**
+ * Multi-line variant for guidance blocks / prompt sections. Tables store one
+ * `\n`-joined string per key; zh/en stay inline arrays at the call site:
+ *   getServerBlock(lang, "markers.todo.guidance", TODO_GUIDANCE_ZH, TODO_GUIDANCE_EN)
+ */
+export function getServerBlock(lang, key, zhLines, enLines) {
+    if (isZh(lang))
+        return zhLines;
+    const hit = getServerString(lang, key);
+    if (hit !== undefined)
+        return hit.split("\n");
+    return enLines;
+}
+/**
+ * Join English-first bilingual copy for tool *definitions* (baked into the
+ * session at creation, so they cannot be lang-switched without rebuilding
+ * the runtime — inline both instead). English leads per the English-default
+ * policy; the Chinese half keeps zh-UI behavior identical to before.
+ */
+export function bilingual(en, zh) {
+    if (!en)
+        return zh;
+    if (!zh)
+        return en;
+    if (en === zh)
+        return en;
+    return `${en}\n${zh}`;
+}
+/** Pull a translator table out of a parsed pack file (null = none usable). */
+export function extractServerStrings(data) {
+    if (!data || typeof data !== "object")
+        return null;
+    const d = data;
+    if (typeof d.code !== "string" || !d.code)
+        return null;
+    if (!d.serverStrings || typeof d.serverStrings !== "object")
+        return null;
+    const table = {};
+    for (const [k, v] of Object.entries(d.serverStrings)) {
+        if (typeof k === "string" && k.length > 0 && typeof v === "string" && v.length > 0)
+            table[k] = v;
+    }
+    if (Object.keys(table).length === 0)
+        return null;
+    return { code: d.code, table };
+}