llm-api-gateway-cli 1.0.4 → 1.0.6

package/lib/hub.js

@@ -32,9 +32,19 @@ import {
   resolveStatic,
   sessionBaggage,
 } from './common.js';
+// 命令行侧的输出语言：只要 `pick()`，语言由入口（runHub）在输出之前设一次
+import { pick, setLang, resolveLang } from './i18n.js';
 import { availableTools, checkWorkDir, browseDir, listRoots, describeCall, setBashEnabled, isBashEnabled } from './tools.js';
 // MCP 工具清单按**当次密钥**从网关取：页面上的工具列表与任务运行共用这一份缓存
-import { refreshMcpTools } from './mcp.js';
+import { refreshMcpTools, mcpToolList } from './mcp.js';
+// 网页版 MCP 面板（用户视角）：管理面复用 CLI 那一套，**密钥只留在服务端**
+import {
+  configureMcpAdmin,
+  getMcpBinding,
+  patchMcpBinding,
+  createMcpServer,
+  deleteMcpServer,
+} from './mcpadmin.js';
 import { readMemory, initInstructions } from './memory.js';
 import {
   runAgent,
@@ -56,6 +66,14 @@ import { buildTaskSystemPrompt, pushUser } from './runner.js';
 import { savePlanDoc, lastAssistantText, firstUserText } from './plandoc.js';
 import { TaskStore, resolveStoreDir, isSafeId, TTL_MS as TASK_TTL_MS } from './taskstore.js';
 import { createRunStore } from './runstore.js';
+// 命令行会话（模式六）的**只读**查看：与 cli-agent 用同一处落盘（sessions/），只读不写
+import {
+  createSessionStore,
+  resolveSessionDir,
+  SESSION_TTL_DAYS,
+  SESSION_TTL_MS,
+  MAX_SESSIONS,
+} from './sessionstore.js';
 import {
   createTaskSessionStore,
   loadOrCreateTaskSession,
@@ -124,7 +142,24 @@ const STORE_SOURCE_TEXT = {
   temp: '主目录不可写，退到系统临时目录',
 };
 
-const HELP = `用法：node server.js [选项]
+/** 上面几句的英文分支；认不出的来源仍照原样打印（同 pick 的回落口径） */
+const STORE_SOURCE_TEXT_EN = {
+  explicit: 'given by --store',
+  'user-data': '.llm-api-gateway-cli under your home directory',
+  legacy: 'old location (home directory not writable — see the warning below)',
+  temp: 'home directory not writable, fell back to the system temp directory',
+};
+
+/**
+ * 存储目录来源的双语取词。
+ * 必须包成函数：模块顶层调 `pick()` 会赶在 `setLang()` 之前求值，永远拿到中文（lib/i18n.js 第 3 条）。
+ */
+function storeSourceText(source) {
+  const zh = STORE_SOURCE_TEXT[source] || source;
+  return pick(zh, STORE_SOURCE_TEXT_EN[source] || zh);
+}
+
+const HELP_ZH = `用法：node server.js [选项]
 
 本地 Web UI：聊天（模式四）、任务（模式五）、操作手册跑在同一个端口、同一个页面里，
 顶部 Tab 切换（不再新开标签页）；三个面板也能各自单独打开。
@@ -133,6 +168,7 @@ const HELP = `用法：node server.js [选项]
     http://127.0.0.1:${DEFAULT_PORT}/chat    只打开聊天面板
     http://127.0.0.1:${DEFAULT_PORT}/task    只打开任务面板（选目录，模型真读写）
     http://127.0.0.1:${DEFAULT_PORT}/manual  只打开操作手册
+    http://127.0.0.1:${DEFAULT_PORT}/sessions 命令行会话的只读存档（终端 gateway-agent -i 聊过的对话）
 
 选项：
       --port <端口>           监听端口（默认 ${DEFAULT_PORT}，也可用 WEB_PORT / TASK_WEB_PORT）
@@ -146,6 +182,7 @@ const HELP = `用法：node server.js [选项]
       --allow-remote-fs       允许非本机访问时开放目录浏览与任务记录接口（危险）
       --allow-bash            开启 bash 工具，让任务页的模型能真的执行命令（默认关闭；危险）
       --verbose               打印每个请求的转发日志
+      --lang <zh|en>          输出语言（默认 zh，也可用环境变量 LLM_GATEWAY_LANG）
   -h, --help                  显示帮助
 
 三种审批模式（任务页可随时切换）：
@@ -157,6 +194,47 @@ const HELP = `用法：node server.js [选项]
 单个任务默认最多 ${AGENT_LIMITS.MAX_STEPS} 轮模型调用（--max-steps / TASK_MAX_STEPS 可调）。撞到上限不会「干到一半就停」：先自动走一轮不带工具的收尾把结论给你，页面再给一个「继续执行」按钮接着干。待批准的挂起态保留 ${AGENT_LIMITS.APPROVAL_TTL_MS / 60000} 分钟、最多 ${AGENT_LIMITS.MAX_RUNS} 个，且会落盘 —— 刷新页面或重启服务后仍可批准。
 `;
 
+/** 英文分支：与 HELP_ZH 逐行对应（选项顺序、缩进、占位符、插值都一致） */
+const HELP_EN = `Usage: node server.js [options]
+
+Local Web UI: chat (mode 4), tasks (mode 5) and the manual share one port and one page,
+switched by the tabs at the top (no extra browser tabs); each panel also opens on its own.
+
+    http://127.0.0.1:${DEFAULT_PORT}/        chat / task / manual (tab shell)
+    http://127.0.0.1:${DEFAULT_PORT}/chat    chat panel only
+    http://127.0.0.1:${DEFAULT_PORT}/task    task panel only (pick a directory, the model really reads and writes)
+    http://127.0.0.1:${DEFAULT_PORT}/manual  manual only
+    http://127.0.0.1:${DEFAULT_PORT}/sessions read-only archive of CLI sessions (gateway-agent -i)
+
+Options:
+      --port <port>           listen port (default ${DEFAULT_PORT}; WEB_PORT / TASK_WEB_PORT also work)
+      --host <address>        listen address (default 127.0.0.1, local access only)
+  -m, --model <model>         default model (default ${DEFAULT_MODEL})
+  -k, --key <sk-key>          gateway key (or env SK/GATEWAY_KEY, or .env)
+      --base-url <url>        gateway base URL (default ${DEFAULT_BASE_URL})
+      --store <dir>           task data directory (default ~/.llm-api-gateway-cli; TASK_STORE_DIR also works)
+      --mode <mode>           default approval mode: manual / auto / plan (default manual)
+      --max-steps <n>         max model calls per task (default ${AGENT_LIMITS.MAX_STEPS}; TASK_MAX_STEPS also works)
+      --allow-remote-fs       allow directory browsing and task-record APIs when not bound to localhost (dangerous)
+      --allow-bash            enable the bash tool so the task-page model can really run commands (off by default; dangerous)
+      --verbose               print a forward log line for every request
+      --lang <zh|en>          Output language (default zh; env LLM_GATEWAY_LANG)
+  -h, --help                  show this help
+
+Three approval modes (switchable any time on the task page):
+  manual  every write waits for your click in the UI (default)
+  auto    writes go straight through, no interruptions; the UI still lists each change
+          (with --allow-bash, commands take this path too: no per-command confirmation)
+  plan    the model gets read-only tools; plan first, touch no files, execute after you approve
+
+A task runs at most ${AGENT_LIMITS.MAX_STEPS} model calls by default (tune with --max-steps / TASK_MAX_STEPS). Hitting the limit does not stop it half-way: one final tool-free call wraps up with a conclusion, then the page offers a "continue" button. Pending approvals are kept for ${AGENT_LIMITS.APPROVAL_TTL_MS / 60000} minutes (at most ${AGENT_LIMITS.MAX_RUNS}) and are persisted — you can still approve after a page refresh or a restart.
+`;
+
+/** `--help` 的正文：必须在这里取词（模块顶层 pick 会赶在 setLang 之前） */
+function helpText() {
+  return pick(HELP_ZH, HELP_EN);
+}
+
 const VALUE_FLAGS = {
   '--port': 'port',
   '--host': 'host',
@@ -168,6 +246,7 @@ const VALUE_FLAGS = {
   '--store': 'store',
   '--mode': 'mode',
   '--max-steps': 'max-steps',
+  '--lang': 'lang',
 };
 const BOOL_FLAGS = { '--verbose': 'verbose', '--allow-remote-fs': 'allow-remote-fs', '--allow-bash': 'allow-bash', '--help': 'help', '-h': 'help' };
 
@@ -205,6 +284,10 @@ function pageFile(urlPath) {
   if (urlPath === '/index.html') return 'index.html'; // 老链接：直接给聊天页
   if (urlPath === '/task' || urlPath === '/task/' || urlPath === '/task.html') return 'task.html';
   if (urlPath === '/manual' || urlPath === '/manual/' || urlPath === '/manual.html') return 'manual.html';
+  // 命令行会话的只读存档（模式六）：终端 `gateway-agent -i` 的对话，网页侧只读回放
+  if (urlPath === '/sessions' || urlPath === '/sessions/' || urlPath === '/sessions.html') return 'sessions.html';
+  // 网页版 MCP 面板（用户视角，密钥留在服务端）
+  if (urlPath === '/mcp' || urlPath === '/mcp/' || urlPath === '/mcp.html') return 'mcp.html';
   return null;
 }
 
@@ -997,6 +1080,193 @@ async function handleApprove(req, res, cfg) {
   }
 }
 
+/* ---------- 网页版 MCP 面板（用户视角，密钥留在服务端） ----------
+ * 背景：终端有 `/mcp`（bind/mode/add/rm），但用网页的人（任务页/聊天页）此前一行 MCP 都没有 ——
+ * 用户手里只有 `sk-` 密钥、没有管理员登录，所以网页需要一个**用户视角**的面板。
+ *
+ * 关键设计：**浏览器不碰密钥**。页面只打本机的 `/api/mcp*`，hub 用服务端保存的
+ * baseUrl/key 去调网关（与 `/api/chat` 完全同一套姿势）。管理动作（改绑/登记/删除）
+ * 直接复用 `lib/mcpadmin.js` —— 那层的失败语义是「必须吵」，正好原样透给页面。
+ */
+
+/** 页面每次调用前同步一次连接：不依赖「先刷过工具清单」这个副作用（终端那边踩过同一个坑） */
+function syncMcpAdmin(cfg) {
+  if (cfg.baseUrl || cfg.key) configureMcpAdmin({ baseUrl: cfg.baseUrl, key: cfg.key });
+}
+
+/** mcpadmin 的失败对象 → HTTP 状态 + 页面可读的 {error, hint} */
+function mcpFail(res, r) {
+  const code = Number(r && r.code) || 0;
+  const status = code === 0 ? 400 : code;
+  return sendJson(res, status, { error: (r && r.message) || '管理面调用失败', hint: (r && r.hint) || '' });
+}
+
+/** 面板上要显示的工具清单（截断说明，避免一次传几百 KB） */
+function mcpToolsBrief() {
+  return mcpToolList().map((t) => ({
+    name: t.name,
+    server: t.server,
+    tool: t.tool,
+    description: String(t.description || '').split('\n')[0].slice(0, 200),
+  }));
+}
+
+async function handleMcpPanel(req, res, cfg, p) {
+  syncMcpAdmin(cfg);
+  if (!cfg.key) {
+    return sendJson(res, 409, {
+      error: '还没有配置网关密钥：在「设置 → 网关密钥」里填 sk-xxx，或跑 gateway-agent config set key sk-xxx',
+      hint: 'MCP 的绑定与登记都要用你手里这把密钥去问网关',
+    });
+  }
+
+  if (p === '/api/mcp') {
+    if (req.method !== 'GET') return sendJson(res, 405, { error: `/api/mcp 只支持 GET，收到 ${req.method}` });
+    const binding = await getMcpBinding();
+    const info = await refreshMcpTools({ force: true, baseUrl: cfg.baseUrl, key: cfg.key });
+    return sendJson(res, 200, {
+      binding: binding.ok
+        ? {
+          mode: binding.mode,
+          enabled: binding.enabled,
+          bound: binding.bound,
+          addable: binding.addable,
+          mine: binding.mine,
+          selectableIds: binding.selectableIds,
+          selfServer: binding.selfServer,
+        }
+        : null,
+      bindingError: binding.ok ? null : { error: binding.message, hint: binding.hint },
+      tools: mcpToolsBrief(),
+      toolsError: info && info.error ? String(info.error) : null,
+    });
+  }
+
+  if (p === '/api/mcp/binding') {
+    if (req.method !== 'PATCH') return sendJson(res, 405, { error: `/api/mcp/binding 只支持 PATCH，收到 ${req.method}` });
+    let body;
+    try {
+      body = await readBody(req, TASK_BODY_LIMIT);
+    } catch (e) {
+      return sendJson(res, e.status || 400, { error: e.message });
+    }
+    const mode = typeof body.mode === 'string' ? body.mode.trim() : '';
+    if (mode && !['off', 'inject', 'loop'].includes(mode)) {
+      return sendJson(res, 400, { error: `模式只支持 off / inject / loop，收到 ${mode}` });
+    }
+    if (!mode && !Array.isArray(body.serverIds)) {
+      return sendJson(res, 400, { error: '没有要改的内容：给 serverIds 数组或 mode' });
+    }
+    const r = await patchMcpBinding({
+      serverIds: Array.isArray(body.serverIds) ? body.serverIds : undefined,
+      mode: mode || undefined,
+    });
+    if (!r.ok) return mcpFail(res, r);
+    // 改完立刻重拉：否则「改成功了但工具数还是旧的」看起来像没生效
+    await refreshMcpTools({ force: true, baseUrl: cfg.baseUrl, key: cfg.key });
+    return sendJson(res, 200, { ok: true, toolCount: mcpToolList().length });
+  }
+
+  if (p === '/api/mcp/servers') {
+    if (req.method !== 'POST') return sendJson(res, 405, { error: `/api/mcp/servers 只支持 POST，收到 ${req.method}` });
+    let body;
+    try {
+      body = await readBody(req, TASK_BODY_LIMIT);
+    } catch (e) {
+      return sendJson(res, e.status || 400, { error: e.message });
+    }
+    const headers = body.headers && typeof body.headers === 'object' ? body.headers : undefined;
+    const r = await createMcpServer({ name: body.name, url: body.url, headers });
+    if (!r.ok) return mcpFail(res, r);
+    await refreshMcpTools({ force: true, baseUrl: cfg.baseUrl, key: cfg.key });
+    return sendJson(res, 200, {
+      ok: true,
+      server: r.server,
+      probeError: r.probeError || '',
+      note: r.note || '',
+      toolCount: mcpToolList().length,
+    });
+  }
+
+  if (p.startsWith('/api/mcp/servers/')) {
+    if (req.method !== 'DELETE') return sendJson(res, 405, { error: `/api/mcp/servers/<id> 只支持 DELETE，收到 ${req.method}` });
+    const id = decodeURIComponent(p.slice('/api/mcp/servers/'.length));
+    const r = await deleteMcpServer(id);
+    if (!r.ok) return mcpFail(res, r);
+    await refreshMcpTools({ force: true, baseUrl: cfg.baseUrl, key: cfg.key });
+    return sendJson(res, 200, { ok: true, message: r.message, note: r.note || '', toolCount: mcpToolList().length });
+  }
+
+  return sendJson(res, 404, { error: `未知的 MCP 接口：${p}` });
+}
+
+/* ---------- 命令行会话（模式六）的只读存档 ----------
+ * 由来（实测踩到）：终端 `gateway-agent -i` 的对话落在 `<数据根>/sessions/`，而网页侧从来不读它，
+ * 用户会以为「记录丢了」。这里补一个**只读**入口：列表给元信息、单条给完整消息供回放；
+ * 不写、不改、不删（列表时的 TTL 清理沿用 CLI 本身的口径，与 `/api/tasks` 的 prune 同理）。
+ * 目录用 `resolveSessionDir()`，所以 `--session-dir` / `LLM_GATEWAY_DATA_DIR` 与命令行落在同一处。
+ */
+
+/** 懒解析 + 可注入（测试直接塞一个 store）；`null` = 目录不可用，接口据此回 503 */
+function cliSessionStore(cfg) {
+  if (cfg.cliSessions !== undefined) return cfg.cliSessions;
+  try {
+    cfg.cliSessions = createSessionStore(resolveSessionDir('', ROOT_DIR).dir);
+  } catch {
+    cfg.cliSessions = null;
+  }
+  return cfg.cliSessions;
+}
+
+/** 列表用的形状：**不带 messages**（一条会话可以几百 KB，列表不该拖着正文走） */
+function cliSessionMeta(rec) {
+  const messages = Array.isArray(rec.messages) ? rec.messages : [];
+  return {
+    id: rec.id,
+    workingDir: rec.workingDir || '',
+    model: rec.model || '',
+    mode: rec.mode || 'manual',
+    // 注意字段名：这里是**条数**，正文只出现在 `/api/cli-sessions/<id>` 的 `session.messages` 里
+    messageCount: messages.length,
+    userTurns: messages.filter((m) => m && m.role === 'user').length,
+    usage: { prompt: Number(rec.usage?.prompt) || 0, completion: Number(rec.usage?.completion) || 0 },
+    pending: Boolean(rec.pending),
+    touchedAt: Number(rec.touchedAt) || 0,
+  };
+}
+
+async function handleCliSessions(req, res, cfg, p) {
+  const store = cliSessionStore(cfg);
+  if (!store) return sendJson(res, 503, { error: '命令行会话目录不可用（主目录与临时目录都不可写）' });
+
+  if (p === '/api/cli-sessions') {
+    if (req.method !== 'GET') return sendJson(res, 405, { error: `/api/cli-sessions 只支持 GET，收到 ${req.method}` });
+    return sendJson(res, 200, {
+      dir: store.dir,
+      ttlDays: SESSION_TTL_DAYS,
+      maxSessions: MAX_SESSIONS,
+      sessions: store.list(SESSION_TTL_MS).map(cliSessionMeta),
+    });
+  }
+
+  const id = decodeURIComponent(p.slice('/api/cli-sessions/'.length));
+  if (req.method !== 'GET') {
+    return sendJson(res, 405, { error: `/api/cli-sessions/<id> 只支持 GET，收到 ${req.method}` });
+  }
+  if (!isSafeId(id)) return sendJson(res, 400, { error: '会话 id 必须是 UUID（这也是防目录穿越的那道校验）' });
+  const rec = store.read(id);
+  if (!rec) return sendJson(res, 404, { error: `没有这条命令行会话：${id}（可能已被滑动 TTL 清理）` });
+  return sendJson(res, 200, {
+    session: {
+      ...cliSessionMeta(rec),
+      // system 在 messages[0] 里（CLI 就是这么落的），页面自己决定要不要展开
+      messages: Array.isArray(rec.messages) ? rec.messages : [],
+      resumeCommand: `gateway-agent -i --resume ${rec.id}`,
+      resumeCommandSource: `node cli-agent.js -i --resume ${rec.id}`,
+    },
+  });
+}
+
 /** 任务数据存到磁盘后，服务端就是唯一真相；这里把增删改查都收口 */
 async function handleStore(req, res, cfg, p) {
   const store = cfg.store;
@@ -1290,6 +1560,22 @@ export function createHubServer(cfg) {
         }
       }
 
+      // 网页版 MCP 面板：能改网关侧的绑定/登记，且回传服务器清单 → 与任务记录同级别看待
+      if (p === '/api/mcp' || p.startsWith('/api/mcp/')) {
+        if (!fsAllowed()) {
+          return sendJson(res, 403, { error: 'MCP 面板已禁用：服务未绑定在本机地址（可用 --allow-remote-fs 放行）' });
+        }
+        return await handleMcpPanel(req, res, cfg, p);
+      }
+
+      // 命令行会话的存档里是完整对话正文与本机路径，与任务记录同级别看待
+      if (p === '/api/cli-sessions' || p.startsWith('/api/cli-sessions/')) {
+        if (!fsAllowed()) {
+          return sendJson(res, 403, { error: '命令行会话已禁用：服务未绑定在本机地址（可用 --allow-remote-fs 放行）' });
+        }
+        return await handleCliSessions(req, res, cfg, p);
+      }
+
       // 任务记录里含工具读过的文件正文，属于本机数据：和目录浏览一样只对本机开放
       if (p === '/api/store' || p === '/api/tasks' || p.startsWith('/api/tasks/')) {
         if (!fsAllowed()) {
@@ -1339,8 +1625,11 @@ export function createHubServer(cfg) {
 
 export function runHub(argv, { entry = 'web' } = {}) {
   const args = parseArgs(argv, VALUE_FLAGS, BOOL_FLAGS);
+  // 语言必须在**任何输出之前**定下来：`--help`、参数错误、启动横幅都要按同一语言输出。
+  // 默认仍是 zh（没给 --lang / LLM_GATEWAY_LANG 时一个字符都不变）。
+  setLang(resolveLang(args, process.env));
   if (args.help) {
-    console.log(HELP);
+    console.log(helpText());
     return null;
   }
 
@@ -1350,11 +1639,11 @@ export function runHub(argv, { entry = 'web' } = {}) {
   const secret = resolveSecretKey({ args, env: process.env, file: secretFile });
   const key = secret.key;
   const keyFromEnv = Boolean(resolveKey(args));
-  for (const w of [secret.warning].filter(Boolean)) console.warn(`[警告] ${w}`);
+  for (const w of [secret.warning].filter(Boolean)) console.warn(pick(`[警告] ${w}`, `[warn] ${w}`));
   // 配置的唯一解析口径（lib/settings.js）：--flag > 环境变量 > config.json > 内置默认
   const settingsFile = settingsFilePath();
   const settings = resolveSettings({ file: settingsFile, env: process.env, args });
-  for (const w of settings.warnings) console.warn(`[警告] ${w}`);
+  for (const w of settings.warnings) console.warn(pick(`[警告] ${w}`, `[warn] ${w}`));
   // 网关地址与模型：事实来源是 lib/settings.js 的四层优先级（flag > 环境变量/.env > config.json > 内置默认）。
   // 这里曾经用 resolveBaseUrl（只认 flag/env），于是**横幅把 config.json 里的地址显示成内置默认**，
   // 而 applySettings 之后的运行态用的却是配置文件里的值 —— 横幅与事实打架，用户以为配置没生效。
@@ -1371,23 +1660,44 @@ export function runHub(argv, { entry = 'web' } = {}) {
   // 没有密钥**不再退出**：以前这里 exit(1)，用户连界面都进不去，只能去手写 .env。
   // 现在照常起服务，页面能打开、设置面板能填密钥 —— 缺密钥的请求由各接口回 409 needsKey。
   if (!key) {
-    console.warn('[警告] 还没有配置密钥：页面能打开，但聊天与任务会提示缺少密钥。');
-    console.warn('       三种给法（任选其一）：');
-    console.warn('         ① 在页面「设置」里填（存到 credentials.json，仅本用户可读）');
-    console.warn('         ② gateway-agent config set key sk-xxx');
-    console.warn('         ③ 环境变量 GATEWAY_KEY / SK，或启动参数 --key sk-xxx');
+    console.warn(pick(
+      '[警告] 还没有配置密钥：页面能打开，但聊天与任务会提示缺少密钥。',
+      '[warn] no key configured yet: the pages open, but chat and tasks will report a missing key.',
+    ));
+    console.warn(pick('       三种给法（任选其一）：', '       three ways to set it (pick one):'));
+    console.warn(pick(
+      '         ① 在页面「设置」里填（存到 credentials.json，仅本用户可读）',
+      '         1) fill it in the page\'s "Settings" (stored in credentials.json, readable by this user only)',
+    ));
+    console.warn(pick(
+      '         ② gateway-agent config set key sk-xxx',
+      '         2) gateway-agent config set key sk-xxx',
+    ));
+    console.warn(pick(
+      '         ③ 环境变量 GATEWAY_KEY / SK，或启动参数 --key sk-xxx',
+      '         3) env GATEWAY_KEY / SK, or the --key sk-xxx flag',
+    ));
   }
   if (port === null) {
-    console.error(`[错误] 端口非法：${strArg(args.port) || process.env.WEB_PORT || process.env.TASK_WEB_PORT}`);
+    console.error(pick(
+      `[错误] 端口非法：${strArg(args.port) || process.env.WEB_PORT || process.env.TASK_WEB_PORT}`,
+      `[error] invalid port: ${strArg(args.port) || process.env.WEB_PORT || process.env.TASK_WEB_PORT}`,
+    ));
     process.exit(1);
   }
 
   const loopback = isLoopbackHost(host);
   const fsEnabled = loopback || Boolean(args['allow-remote-fs']);
   if (!loopback && !fsEnabled) {
-    console.warn(`[警告] 绑定在 ${host} 且未加 --allow-remote-fs：目录浏览与任务记录接口将返回 403。`);
+    console.warn(pick(
+      `[警告] 绑定在 ${host} 且未加 --allow-remote-fs：目录浏览与任务记录接口将返回 403。`,
+      `[warn] bound to ${host} without --allow-remote-fs: directory browsing and task-record APIs will return 403.`,
+    ));
   } else if (!loopback) {
-    console.warn('[警告] 已用 --allow-remote-fs 开放目录浏览与任务记录，任何能访问该端口的人都能浏览本机目录、读取任务历史。');
+    console.warn(pick(
+      '[警告] 已用 --allow-remote-fs 开放目录浏览与任务记录，任何能访问该端口的人都能浏览本机目录、读取任务历史。',
+      '[warn] --allow-remote-fs is on: directory browsing and task records are open, so anyone who can reach this port can browse local directories and read task history.',
+    ));
   }
 
   // bash 与 --allow-remote-fs 是同一性质：显式、危险、默认关。
@@ -1396,10 +1706,13 @@ export function runHub(argv, { entry = 'web' } = {}) {
   // 只能反复说已静态复核」的根因：不是权限被拒，是这支笔从没发给过它。
   setBashEnabled(Boolean(args['allow-bash']));
   if (isBashEnabled()) {
-    console.warn(
+    console.warn(pick(
       '[警告] 已用 --allow-bash 开启命令执行：任务页「自动」模式下模型跑命令不会再逐个问你'
       + '（手动模式仍会挂起等你批准）。命令仍在工作目录内执行，风险请自行评估。',
-    );
+      '[warn] --allow-bash enables command execution: on the task page, "auto" mode no longer asks you'
+      + ' before every command (manual mode still waits for your approval). Commands still run inside the'
+      + ' working directory; judge the risk yourself.',
+    ));
   }
 
   // 任务数据落盘。即使只用聊天页也要初始化 —— 任务页随时能打开
@@ -1408,19 +1721,20 @@ export function runHub(argv, { entry = 'web' } = {}) {
     // args/env 已经被 settings 合并过了（flag > env > config.json），这里再传一次也无妨
     resolved = resolveStoreDir(strArg(settings.values['store.dir']) || args.store || null, ROOT_DIR);
   } catch (e) {
-    console.error(`[错误] ${e.message}`);
+    // e.message 来自 lib/taskstore.js（中文）：英文分支里它按 pick 的回落口径原样保留
+    console.error(pick(`[错误] ${e.message}`, `[error] ${e.message}`));
     process.exit(1);
   }
   let store;
   try {
     store = new TaskStore(resolved.dir).init();
   } catch (e) {
-    console.error(`[错误] 任务存储初始化失败：${e.message}`);
+    console.error(pick(`[错误] 任务存储初始化失败：${e.message}`, `[error] failed to initialize task storage: ${e.message}`));
     process.exit(1);
   }
-  if (resolved.notice) console.log(`[提示] ${resolved.notice}`);
-  if (resolved.warning) console.warn(`[警告] ${resolved.warning}`);
-  for (const w of store.warnings) console.warn(`[警告] ${w}`);
+  if (resolved.notice) console.log(pick(`[提示] ${resolved.notice}`, `[info] ${resolved.notice}`));
+  if (resolved.warning) console.warn(pick(`[警告] ${resolved.warning}`, `[warn] ${resolved.warning}`));
+  for (const w of store.warnings) console.warn(pick(`[警告] ${w}`, `[warn] ${w}`));
 
   const mode = normalizeMode(args.mode || process.env.TASK_MODE || 'manual');
   // 挂起态落盘：刷新页面、甚至重启服务后，待批准的写入都还在
@@ -1460,48 +1774,126 @@ export function runHub(argv, { entry = 'web' } = {}) {
     sessionLimits(cfg),
   );
   const orphans = sweepOrphanSessions(cfg);
+  // 命令行会话（模式六）的只读存档：与 cli-agent 同一处落盘。目录不可写不算致命 ——
+  // 服务照起，/api/cli-sessions 回 503 说明原因（存档本来就不是服务写的）
+  try {
+    cfg.cliSessions = createSessionStore(resolveSessionDir('', ROOT_DIR).dir);
+  } catch (e) {
+    cfg.cliSessions = null;
+    console.warn(pick(
+      `[警告] 命令行会话目录不可用（${e.message}）：网页里的「命令行会话」只读页会显示不可用`,
+      `[warn] CLI session directory unavailable (${e.message}); the read-only "CLI sessions" page will report it`,
+    ));
+  }
   const server = createHubServer(cfg);
 
   server.on('error', (e) => {
-    if (e.code === 'EADDRINUSE') console.error(`[错误] 端口 ${port} 已被占用：换一个 --port，或先关掉占用进程`);
-    else console.error(`[错误] 服务启动失败：${e.message}`);
+    if (e.code === 'EADDRINUSE') {
+      console.error(pick(
+        `[错误] 端口 ${port} 已被占用：换一个 --port，或先关掉占用进程`,
+        `[error] port ${port} is already in use: pick another --port, or stop the process holding it`,
+      ));
+    } else {
+      console.error(pick(`[错误] 服务启动失败：${e.message}`, `[error] failed to start the service: ${e.message}`));
+    }
     process.exit(1);
   });
 
   server.listen(port, host, () => {
     const s = store.stats();
-    console.log('LLM API Gateway · 本地 Web UI');
-    console.log(`  页面   http://${host}:${port}/（聊天 / 任务 / 手册，顶部 Tab 切换）`);
-    console.log(`  面板   /chat 聊天 · /task 任务 · /manual 手册（都能单独打开）`);
+    console.log(pick('LLM API Gateway · 本地 Web UI', 'LLM API Gateway · Local Web UI'));
+    console.log(pick(
+      `  页面   http://${host}:${port}/（聊天 / 任务 / 手册，顶部 Tab 切换）`,
+      `  Page     http://${host}:${port}/ (chat / task / manual, switch with the tabs on top)`,
+    ));
+    console.log(pick(
+      '  面板   /chat 聊天 · /task 任务 · /manual 手册（都能单独打开）',
+      '  Panels   /chat chat · /task task · /manual manual (each opens on its own)',
+    ));
+    console.log(pick(
+      `  命令行 http://${host}:${port}/sessions 命令行会话的只读存档（终端 gateway-agent -i 聊过的对话）`,
+      `  CLI     http://${host}:${port}/sessions read-only archive of terminal gateway-agent -i conversations`,
+    ));
     // 网关 / 模型也要带来源：新机器上「有值」不等于「配过」——默认值、当前目录的 .env、
     // config.json 三者长得很像，不说清来源就只能靠猜（与 CLI 横幅同一套文案）
-    console.log(`  网关   ${baseUrl}（${settingSourceText(settings, 'baseUrl')}）`);
-    console.log(`  模型   ${model}（${settingSourceText(settings, 'model')}）`);
+    console.log(pick(
+      `  网关   ${baseUrl}（${settingSourceText(settings, 'baseUrl')}）`,
+      `  Gateway  ${baseUrl} (${settingSourceText(settings, 'baseUrl')})`,
+    ));
+    console.log(pick(
+      `  模型   ${model}（${settingSourceText(settings, 'model')}）`,
+      `  Model    ${model} (${settingSourceText(settings, 'model')})`,
+    ));
     // 密钥一行要能回答「配没配、从哪来」——来源是环境时，credentials.json 不参与，这一点要说清
-    console.log(`  密钥   ${key ? `${maskKey(key)}（${secretSourceText(secret)}）` : '未配置'}`);
+    console.log(pick(
+      `  密钥   ${key ? `${maskKey(key)}（${secretSourceText(secret)}）` : '未配置'}`,
+      `  Key      ${key ? `${maskKey(key)} (${secretSourceText(secret)})` : 'not configured'}`,
+    ));
     if (!key) {
       const srcInfo = summarizeConfigSources({ keys: ['baseUrl', 'model'], env: cfg.env, args });
       if (srcInfo.allDefault && !srcInfo.configExists) {
-        console.log('         这台机器还没有任何配置：上面的网关与模型是**内置默认值**，不是「已经配好了」');
+        console.log(pick(
+          '         这台机器还没有任何配置：上面的网关与模型是**内置默认值**，不是「已经配好了」',
+          '         this machine has no config at all yet: the gateway and model above are **built-in defaults**, not "already configured"',
+        ));
       }
-      console.log('         填法：页面「设置」里填（存 credentials.json，仅本用户可读）');
-      console.log('               或 gateway-agent config set key sk-xxx；或环境变量 GATEWAY_KEY / --key');
+      console.log(pick(
+        '         填法：页面「设置」里填（存 credentials.json，仅本用户可读）',
+        '         how to set it: the page\'s "Settings" (stored in credentials.json, readable by this user only)',
+      ));
+      console.log(pick(
+        '               或 gateway-agent config set key sk-xxx；或环境变量 GATEWAY_KEY / --key',
+        '         or gateway-agent config set key sk-xxx; or env GATEWAY_KEY / --key',
+      ));
     }
-    console.log(`  工具   ${availableTools().map((t) => t.function.name).join(' / ')}（计划模式只给只读工具）`);
-    console.log(`  模式   默认 ${MODE_LABELS[mode]}（${mode}）· 任务页可随时切换`);
-    console.log(`  存储   ${s.dir}`);
-    console.log(`         （${STORE_SOURCE_TEXT[resolved.source] || resolved.source}，当前 ${s.taskCount}/${s.maxTasks} 条，滑动保留 ${s.ttlDays} 天）`);
+    console.log(pick(
+      `  工具   ${availableTools().map((t) => t.function.name).join(' / ')}（计划模式只给只读工具）`,
+      `  Tools    ${availableTools().map((t) => t.function.name).join(' / ')} (plan mode gets read-only tools only)`,
+    ));
+    console.log(pick(
+      `  模式   默认 ${MODE_LABELS[mode]}（${mode}）· 任务页可随时切换`,
+      // 英文分支直接用模式 id：MODE_LABELS 是中文标签，且 /api/config 也下发它（契约不能动）
+      `  Mode     default ${mode} · switchable any time on the task page`,
+    ));
+    console.log(pick(`  存储   ${s.dir}`, `  Store    ${s.dir}`));
+    console.log(pick(
+      `         （${storeSourceText(resolved.source)}，当前 ${s.taskCount}/${s.maxTasks} 条，滑动保留 ${s.ttlDays} 天）`,
+      `         (${storeSourceText(resolved.source)}; ${s.taskCount}/${s.maxTasks} tasks now, sliding retention ${s.ttlDays} days)`,
+    ));
     const sess = cfg.taskSessions.stats();
-    console.log(`  会话   ${sess.count} 条 / ${(sess.bytes / 1024).toFixed(0)}KB（模型态消息，让模型不必重复读文件）`);
-    if (orphans) console.log(`         启动时清掉了 ${orphans} 个没有任务的孤儿会话`);
-    console.log(`  配置   ${settingsFile}${settings.exists ? '' : '（还没有，用默认值；gateway-agent config set 可改）'}`);
-    console.log(`  密钥文件 ${secretFile}${secret.source === 'file' ? '' : '（当前没用它：密钥来自环境变量或启动参数）'}`);
-    console.log('  停止   Ctrl+C');
+    console.log(pick(
+      `  会话   ${sess.count} 条 / ${(sess.bytes / 1024).toFixed(0)}KB（模型态消息，让模型不必重复读文件）`,
+      `  Sessions ${sess.count} / ${(sess.bytes / 1024).toFixed(0)}KB (model-state messages, so the model need not re-read files)`,
+    ));
+    if (orphans) {
+      console.log(pick(
+        `         启动时清掉了 ${orphans} 个没有任务的孤儿会话`,
+        `         cleaned up ${orphans} orphan session(s) that had no task at startup`,
+      ));
+    }
+    console.log(pick(
+      `  配置   ${settingsFile}${settings.exists ? '' : '（还没有，用默认值；gateway-agent config set 可改）'}`,
+      `  Config   ${settingsFile}${settings.exists ? '' : ' (not there yet, using the defaults; gateway-agent config set can change it)'}`,
+    ));
+    console.log(pick(
+      `  密钥文件 ${secretFile}${secret.source === 'file' ? '' : '（当前没用它：密钥来自环境变量或启动参数）'}`,
+      `  Key file ${secretFile}${secret.source === 'file' ? '' : ' (not used right now: the key comes from env or a startup flag)'}`,
+    ));
+    console.log(pick('  停止   Ctrl+C', '  Stop     Ctrl+C'));
     console.log('');
-    console.log(`  轮次   单个任务最多 ${cfg.maxSteps} 轮模型调用（--max-steps 可调）；撞到上限会先收尾给结论，再给「继续执行」`);
-    console.log('         写入按当前模式处理：手动逐个批准 / 自动直接执行 / 计划只读先出方案。');
+    console.log(pick(
+      `  轮次   单个任务最多 ${cfg.maxSteps} 轮模型调用（--max-steps 可调）；撞到上限会先收尾给结论，再给「继续执行」`,
+      `  Turns    at most ${cfg.maxSteps} model calls per task (tune with --max-steps); hitting the limit wraps up with a conclusion first, then offers "continue"`,
+    ));
+    console.log(pick(
+      '         写入按当前模式处理：手动逐个批准 / 自动直接执行 / 计划只读先出方案。',
+      '         writes follow the current mode: manual approves one by one / auto runs directly / plan stays read-only and proposes first.',
+    ));
     if (entry === 'task') {
-      console.log('  提示   / 是 Tab 外壳（聊天 / 任务 / 手册同页切换），/task 直接落到任务面板。');
+      console.log(pick(
+        '  提示   / 是 Tab 外壳（聊天 / 任务 / 手册同页切换），/task 直接落到任务面板。',
+        '  Note     / is the tab shell (chat / task / manual on one page); /task drops straight into the task panel.',
+      ));
     }
   });