mocode-ai 1.3.9 → 1.4.0

package/dist/repl/commands/pet.js

@@ -0,0 +1,70 @@
+/**
+ * 桌宠命令组:/pet quit · /pet skin · /pet
+ *
+ * 顺序敏感:`/pet quit`、`/pet skin` 必须排在裸 `/pet` 之前(后者是完整匹配,
+ * 前两者也是完整匹配,但语义上前者更具体)。保持原 if 链的相对顺序。
+ */
+import * as layout from '../../ui/layout.js';
+import { ui } from '../../ui/theme.js';
+import { togglePet, killPetProcess, listSkins, setSkin } from '../../pet/bridge.js';
+import { promptThemePicker } from '../../ui/prompt.js';
+import { unhandled, next } from './types.js';
+export const petCommands = [
+    // /pet quit:完全关闭桌宠进程(区别于 /pet 的仅断开本连接)。方案C的 CLI 侧退出入口,
+    // 另一入口是桌宠托盘菜单"退出桌宠"(见 packages/pet-app/src/main.ts)。
+    async (ctx) => {
+        if (ctx.line !== '/pet quit')
+            return unhandled();
+        const { ok, reason } = await killPetProcess();
+        layout.contentWrite(`${ui.dim}(${ok ? '已关闭桌宠进程' : (reason ?? '关闭失败')})${ui.reset}\n`);
+        return next();
+    },
+    // /pet skin:菜单选皮(↑↓ 选,Enter 切换,Esc 取消),仿 /theme 的交互。要求桌宠已在运行
+    // (未运行则先提示 /pet 打开;不在此处自动 spawn,避免选皮命令产生"顺带开桌宠"的意外副作用)。
+    async (ctx) => {
+        if (ctx.line !== '/pet skin')
+            return unhandled();
+        let skinList;
+        try {
+            skinList = await listSkins();
+        }
+        catch (e) {
+            layout.contentWrite(`${ui.dim}(${e instanceof Error ? e.message : '获取皮肤列表失败'})${ui.reset}\n`);
+            return next();
+        }
+        const items = [
+            { id: 'default', title: '默认(mascot)', subtitle: skinList.currentSkinId === 'default' ? '当前' : '' },
+            ...skinList.skins.map((s) => ({
+                id: s.id,
+                title: s.name,
+                subtitle: skinList.currentSkinId === s.id ? '当前' : '',
+            })),
+        ];
+        let pick;
+        try {
+            pick = await promptThemePicker(items);
+        }
+        catch {
+            return next(); // Ctrl+C(SIGINT)→ 取消
+        }
+        if (pick === null)
+            return next(); // Esc / Ctrl+D 取消
+        setSkin(pick.id);
+        layout.contentWrite(`${ui.dim}(已切换桌宠皮肤:${pick.title})${ui.reset}\n`);
+        return next();
+    },
+    // /pet:开关桌宠。已连接→断开;未连接→探测端口(已有实例则直连)或 spawn 拉起 + 退避重试连接。
+    // togglePet 不抛异常,所有失败路径转为返回值——桌宠是可选增强,任何异常都不能影响 REPL 主流程。
+    async (ctx) => {
+        if (ctx.line !== '/pet')
+            return unhandled();
+        const { connected, reason } = await togglePet();
+        if (connected) {
+            layout.contentWrite(`${ui.dim}(桌宠已连接)${ui.reset}\n`);
+        }
+        else {
+            layout.contentWrite(`${ui.dim}(${reason ?? '桌宠已断开'})${ui.reset}\n`);
+        }
+        return next();
+    },
+];

package/dist/repl/commands/registry.js

@@ -0,0 +1,46 @@
+import { unhandled } from './types.js';
+import { systemCommands } from './system.js';
+import { modeCommands } from './mode.js';
+import { petCommands } from './pet.js';
+import { imageCommands } from './image.js';
+import { contextCommands } from './context.js';
+import { sessionCommands } from './session.js';
+import { memoryCommands } from './memory.js';
+import { skillCommands } from './skill.js';
+import { compactCommands } from './compact.js';
+import { appearanceCommands } from './appearance.js';
+import { modelCommands } from './model.js';
+import { toolGroupCommands } from './tool-group.js';
+/**
+ * 命令注册表。顺序即匹配优先级 —— 更具体的分支放前面。
+ * 组内顺序由各文件自己保证(见文件头注释);组间顺序互不影响(条件互斥)。
+ *
+ * dispatch 返回 unhandled = 没有这条命令,runtime.ts 据此走未知命令兜底。
+ */
+export const commandHandlers = [
+    ...systemCommands,
+    ...modeCommands,
+    ...petCommands,
+    ...imageCommands,
+    ...contextCommands,
+    ...sessionCommands,
+    ...memoryCommands,
+    ...skillCommands,
+    ...compactCommands,
+    ...appearanceCommands,
+    ...modelCommands,
+    ...toolGroupCommands,
+];
+/**
+ * 依次询问 handler,返回第一个非 unhandled 的结果。
+ * 全部 unhandled 时返回 unhandled —— 调用方(runtime.ts)据此走未知命令兜底
+ * (isCommandShape + suggestCommand),或把非命令输入当普通消息发给 agent。
+ */
+export async function dispatchCommand(ctx) {
+    for (const handler of commandHandlers) {
+        const outcome = await handler(ctx);
+        if (outcome.kind !== 'unhandled')
+            return outcome;
+    }
+    return unhandled();
+}

package/dist/repl/commands/session.js

@@ -0,0 +1,102 @@
+/**
+ * 会话命令组:/clear · /sessions · /resume · /rollback
+ *
+ * /clear 是这批里唯一**写**闭包状态的命令(currentSessionId / turnCount / lastTurnUsage),
+ * 全部经 ctx.state 访问器写回 startRepl 的 `let`。
+ */
+import * as layout from '../../ui/layout.js';
+import { ui } from '../../ui/theme.js';
+import { bannerLines } from '../../ui/render.js';
+import { t } from '../../i18n/index.js';
+import { newSessionId, listSessions } from '../../session/index.js';
+import { resetState } from '../../rollback/index.js';
+import { setCurrentSessionId } from '../../session/state.js';
+import { promptSessionPicker } from '../../ui/prompt.js';
+import { unhandled, next } from './types.js';
+export const sessionCommands = [
+    (ctx) => {
+        if (ctx.line !== '/clear')
+            return unhandled();
+        ctx.history.length = 1; // 保留 system 提示
+        resetState(); // 同步清空回滚轮次/快照
+        // /clear 立刻换新会话 id:之前延后到 turn 收尾分配,但 runAgent 期间模型
+        // 调 plan_update / note_append 会命中「no active session」——它们写 notes.md 靠
+        // getNotesFilePath(getCurrentSessionId()),而下一个 turn 还没走完。改为与启动对齐
+        // 立即分配:notes.md 由写入时按需建文件,这里预分配 id 不触盘。
+        ctx.state.currentSessionId = newSessionId();
+        setCurrentSessionId(ctx.state.currentSessionId, process.cwd()); // 同步到 session/state
+        ctx.state.turnCount = 0; // 反思 cadence 重新计数
+        ctx.contextState.lastUsage = undefined;
+        ctx.contextState.lifecycleStats = undefined;
+        ctx.contextState.ephemeralText = undefined;
+        ctx.state.lastTurnUsage = undefined; // 清空旧轮的 token 累计
+        ctx.state.lastToolGroups = []; // 新会话不得继承旧会话的路由回退
+        ctx.attachments.clear(); // 一并清空待发图片
+        layout.clearContent();
+        layout.writeBanner(bannerLines(ctx.banner()));
+        layout.contentWrite(`${ui.dim}${t('repl.historyCleared')}${ui.reset}\n`);
+        layout.writeWelcomeBlock(ctx.welcomeLines()); // 回到空会话状态,欢迎引导重新出现
+        return next();
+    },
+    // /sessions:浏览全部已保存会话(慢路径,readdir+全量 JSON.parse,目录 N 大时会有可感知卡顿)。
+    // 默认走 /resume(仅最近 10 条,瞬开);要翻历史续接更早的会话才用这条。
+    // picker 走全显(cap=items.length,无 a 展开提示),靠 picker 自身开窗(以选中为中心分屏)。
+    async (ctx) => {
+        if (ctx.line !== '/sessions')
+            return unhandled();
+        const sessions = listSessions(); // 不传 limit = 全量
+        if (sessions.length === 0) {
+            layout.contentWrite(`${ui.dim}(没有已保存的会话)${ui.reset}\n`);
+            return next();
+        }
+        const items = sessions.map((s) => ({
+            id: s.id,
+            title: s.firstUser || '(无)',
+            subtitle: `${s.id}  ${s.model}`,
+        }));
+        let pick;
+        try {
+            pick = await promptSessionPicker(items, items.length);
+        }
+        catch {
+            return next(); // Ctrl+C(SIGINT)→ 取消
+        }
+        await ctx.resumeFromPick(pick);
+        return next();
+    },
+    // /resume:打开会话菜单(↑/↓ 选,Enter 续接,Esc 取消)。只加载最近 10 条,
+    // 避免 sessions 目录堆了几百个会话时 readdir+全量 JSON.parse 卡顿。
+    // 仿 /rollback 菜单化(promptSessionPicker);选中项 cyan+bold + ▸ 高亮。
+    // 要续接更早的会话请用 /sessions 翻全表,或 CLI `mocode --resume <id>`。
+    async (ctx) => {
+        if (ctx.line !== '/resume')
+            return unhandled();
+        const sessions = listSessions(10);
+        if (sessions.length === 0) {
+            layout.contentWrite(`${ui.dim}(没有已保存的会话)${ui.reset}\n`);
+            return next();
+        }
+        const items = sessions.map((s) => ({
+            id: s.id,
+            title: s.firstUser || '(无)',
+            subtitle: `${s.id}  ${s.model}`,
+        }));
+        let pick;
+        try {
+            pick = await promptSessionPicker(items);
+        }
+        catch {
+            return next(); // Ctrl+C(SIGINT)→ 取消
+        }
+        await ctx.resumeFromPick(pick);
+        return next();
+    },
+    // /rollback:打开轮次菜单(↑/↓ 选,Enter 回滚到该轮并预填其输入,再 Enter 重新跑)。
+    // 忽略任何数字参数(原「输数字选回滚」已删,统一走菜单)。无快照的旧轮次(/resume 重建)文件改动不可撤销。
+    async (ctx) => {
+        if (ctx.line !== '/rollback' && !ctx.line.startsWith('/rollback '))
+            return unhandled();
+        await ctx.rollbackFlow();
+        return next();
+    },
+];

package/dist/repl/commands/skill.js

@@ -0,0 +1,95 @@
+/**
+ * Skill 命令组:/skills · /skill <name> [args-json]
+ *
+ * 顺序敏感:`/skills` 必须排在 `/skill` 之前——`/skill` 用 startsWith('/skill ')
+ * 匹配带参形式,裸 '/skills' 不会命中它,但保持原 if 链的相对顺序最稳妥。
+ *
+ * /skill 的 inline 分支只预览:正文不进模型 history,不激活工具面约束。
+ */
+import * as layout from '../../ui/layout.js';
+import { ui } from '../../ui/theme.js';
+import { listSkills, findSkill } from '../../skills/index.js';
+import { runSkill, renderSkillBody } from '../../skills/runner.js';
+import { isSkillTrusted } from '../../skills/trust.js';
+import { unhandled, next } from './types.js';
+export const skillCommands = [
+    (ctx) => {
+        if (ctx.line !== '/skills')
+            return unhandled();
+        const skills = listSkills();
+        if (skills.length === 0) {
+            layout.contentWrite(`${ui.dim}(没有已发现的 skill)${ui.reset}\n`);
+        }
+        else {
+            layout.contentWrite(`${ui.dim}已发现 ${skills.length} 个 skill:${ui.reset}\n`);
+            for (const s of skills) {
+                const badges = [];
+                if (s.context === 'fork')
+                    badges.push('fork');
+                if (!s.modelInvocable)
+                    badges.push('manual-only');
+                badges.push(s.origin);
+                if (s.origin === 'project') {
+                    badges.push(isSkillTrusted(s) ? 'trusted' : 'untrusted');
+                }
+                const badgeStr = badges.length ? ` ${ui.dim}[${badges.join('|')}]${ui.reset}` : '';
+                layout.contentWrite(`  ${ui.accent}${s.name}${ui.reset}${badgeStr}  ${ui.dim}${s.description}${ui.reset}\n`);
+                if (s.allowedTools?.length) {
+                    layout.contentWrite(`    ${ui.dim}allowed: ${s.allowedTools.join(', ')}${ui.reset}\n`);
+                }
+                if (s.disallowedTools?.length) {
+                    layout.contentWrite(`    ${ui.dim}disallowed: ${s.disallowedTools.join(', ')}${ui.reset}\n`);
+                }
+                if (s.warnings.length) {
+                    layout.contentWrite(`    ${ui.dim}warnings: ${s.warnings.join('; ')}${ui.reset}\n`);
+                }
+            }
+            layout.contentWrite(`${ui.dim}(用 use_skill 加载指令; fork 类用 run_skill 执行; 也支持 /skill <name> [args-json])${ui.reset}\n`);
+        }
+        return next();
+    },
+    // /skill <name> [args-json]:直接执行一个 skill(fork 走 run_skill,inline 打印渲染后正文)。
+    async (ctx) => {
+        const { line } = ctx;
+        if (line !== '/skill' && !line.startsWith('/skill '))
+            return unhandled();
+        const rest = line.slice('/skill'.length).trim();
+        const sp = rest.indexOf(' ');
+        const name = sp === -1 ? rest : rest.slice(0, sp);
+        const argStr = sp === -1 ? '' : rest.slice(sp + 1).trim();
+        if (!name) {
+            layout.contentWrite(`${ui.dim}用法: /skill <name> [args-json]${ui.reset}\n`);
+            return next();
+        }
+        let args;
+        if (argStr) {
+            try {
+                args = JSON.parse(argStr);
+            }
+            catch {
+                layout.contentWrite(`${ui.dim}args 不是合法 JSON,已忽略。${ui.reset}\n`);
+            }
+        }
+        const skill = findSkill(name);
+        if (!skill) {
+            layout.contentWrite(`错误:未找到 skill "${name}"。\n`);
+            return next();
+        }
+        if (skill.context === 'fork') {
+            layout.contentWrite(`${ui.dim}执行 fork skill "${name}"…${ui.reset}\n`);
+            const out = await runSkill({ name, args });
+            layout.contentWrite((out.status === 'success' ? '' : `[${out.status}] `) + out.output + '\n');
+        }
+        else {
+            const body = await renderSkillBody(skill, args);
+            if (body === null)
+                layout.contentWrite(`错误:未找到 skill "${name}" 的正文。\n`);
+            else {
+                // 仅预览:inline 正文未进入模型 history,不激活工具面约束;
+                // 要让模型按此 skill 工作,请让它调 use_skill(name) 或在下条消息里提及该 skill。
+                layout.contentWrite(`# Skill: ${name}(预览,模型尚未看到此内容)\n\n${body}\n`);
+            }
+        }
+        return next();
+    },
+];

package/dist/repl/commands/system.js

@@ -0,0 +1,202 @@
+/**
+ * 系统命令组:/help · /language · /init · /upgrade
+ *
+ * 控制流改写说明(/upgrade now 成功路径):
+ * 原分支在 try 块内直接 `break` 跳出 while 主循环(finally 里 stopRunningListener 仍执行)。
+ * 搬进 handler 后无法 break 调用方的循环,改为置 `exitAfter = true`,handler 返回
+ * outcome.kind === 'exit',runtime.ts 的 switch 负责 break——finally 时序不变。
+ */
+import * as layout from '../../ui/layout.js';
+import { ui } from '../../ui/theme.js';
+import { bannerLines } from '../../ui/render.js';
+import { t, getLanguage, normalizeLanguage } from '../../i18n/index.js';
+import { updateLanguageConfig, languageFromShell, hasCodegraphIndex } from '../../config/index.js';
+import { updateConfigKey } from '../../config/file.js';
+import { getAgentMode } from '../../agent/mode.js';
+import { buildSlashCommands, slashHelpLines, HELP_GROUPS } from '../commands.js';
+import { startRunningListener, stopRunningListener } from '../running-input.js';
+import { checkVersion, fetchLatestVersion, getCurrentVersion, runUpgradeForeground } from '../../commands/upgrade.js';
+import { unhandled, next, exit, forward } from './types.js';
+/**
+ * /init 指令:发给 agent 扫描项目并生成 AGENTS.md。已存在则让 agent 读后更新(不丢失事实)。写完供 memory 子系统下轮加载。
+ *
+ * 函数化(非 const):.codegraph/ 索引是否存在的探测放在调用瞬间,没索引时不提 codegraph,
+ * 避免 LLM 调出失败。/init 是冷启动动作,IO 开销可忽略。
+ */
+function buildInitPrompt() {
+    const cg = hasCodegraphIndex()
+        ? '- 若有 .codegraph/:用 use_skill 加载 codegraph skill 后用 run_command 调 codegraph explore "<架构或入口符号>" 一次拿相关源码+调用路径,别逐文件读！！！\n'
+        : '';
+    return `分析当前项目(process.cwd()),生成 AGENTS.md 项目记忆文件,供 mocode 后续会话自动加载——目标是让后续会话无需重新摸索就能上手。
+
+先探查(尽量少调用拿全貌):
+${cg}- read_file package.json(或 Cargo.toml/pyproject.toml/go.mod 等):scripts、依赖、入口、模块类型。
+- glob 顶层目录;read_file 入口文件 + 各子系统 index.ts/README。
+- 若 AGENTS.md 已存在:read_file 读它,在其基础上更新(补缺、修正过时),不丢已有准确事实。
+
+AGENTS.md 按以下结构写(每节简短,只写稳定、非显然的事实):
+## 项目
+一两句:是什么、技术栈、运行环境。
+## 命令
+install / dev / build / test / typecheck / lint 等——从 package.json scripts 提炼,写原样命令行(如 \`npm run typecheck\`);没有的注明"无测试"/"无 lint"。
+## 目录结构
+顶层各目录与子系统职责,一句话/个;不逐文件列。
+## 约定
+从代码与现有文档提炼的硬约定:模块系统(ESM?)、命名、错误处理、工具/函数契约、易踩坑点。只写非显然、会让人踩坑的;不写"保持简洁"这种正确废话。
+## 扩展点
+加工具/命令/provider/模块的接缝(改哪个文件、加在哪)。
+
+硬要求:
+- 从实际代码提炼,引用具体文件名/命令/符号;不编造、不泛泛。
+- 总长 ≤ 3000 字;只写后续会话有用的稳定事实,不写易变项(当前 bug、临时文件、未决 TODO)。
+- 用 write_file 写入项目根 AGENTS.md。
+- 写完简述:写了哪几节 + 从代码里发现的 2-3 条非显然关键约定(供用户校验)。`;
+}
+export const systemCommands = [
+    (ctx) => {
+        if (ctx.line !== '/help')
+            return unhandled();
+        const nodes = buildSlashCommands();
+        layout.contentWrite(`${ui.bold}${t('help.title')}${ui.reset}\n`);
+        layout.contentWrite(`${ui.dim}${t('help.hint')}${ui.reset}\n`);
+        // 按使用场景分组输出,常用置顶;未归组命令(如 /exit)兜底进「其他」。
+        let first = true;
+        for (const group of HELP_GROUPS) {
+            const picked = nodes.filter((n) => group.names.includes(n.name));
+            if (!picked.length)
+                continue;
+            if (!first)
+                layout.contentWrite('\n');
+            first = false;
+            layout.contentWrite(`${ui.accent}${ui.bold}${t(group.key)}${ui.reset}\n`);
+            layout.contentWrite(`${slashHelpLines(picked).join('\n')}\n`);
+        }
+        const rest = nodes.filter((n) => !HELP_GROUPS.some((g) => g.names.includes(n.name)));
+        if (rest.length) {
+            if (!first)
+                layout.contentWrite('\n');
+            layout.contentWrite(`${ui.accent}${ui.bold}${t('help.groupOther')}${ui.reset}\n`);
+            layout.contentWrite(`${slashHelpLines(rest).join('\n')}\n`);
+        }
+        return next();
+    },
+    (ctx) => {
+        const { line } = ctx;
+        if (line !== '/language' && !line.startsWith('/language '))
+            return unhandled();
+        const arg = line === '/language' ? '' : line.slice('/language '.length).trim();
+        if (!arg) {
+            const currentName = getLanguage() === 'zh-CN' ? t('language.zh') : t('language.en');
+            layout.contentWrite(`${ui.dim}${t('language.current', { language: currentName })}${ui.reset}\n`);
+            layout.contentWrite(`${ui.dim}${t('language.usage')}${ui.reset}\n\n`);
+            return next();
+        }
+        const nextLang = normalizeLanguage(arg);
+        if (!nextLang) {
+            layout.contentWrite(`${ui.yellow}${t('language.invalid', { value: arg })}${ui.reset}\n\n`);
+            return next();
+        }
+        updateLanguageConfig(nextLang);
+        updateConfigKey('MOCODE_LANGUAGE', nextLang);
+        ctx.history[0] = { role: 'system', content: ctx.buildSystemMessage(getAgentMode() === 'plan') };
+        ctx.refreshStatusBase(ctx.history);
+        // 横幅是内容缓冲顶部的固定区域；语言切换后等长原地替换，不移动后续对话。
+        layout.rewriteBanner(bannerLines(ctx.banner()));
+        layout.contentWrite(`${ui.cyan}${t('language.changed')}${ui.reset}\n`);
+        if (languageFromShell) {
+            layout.contentWrite(`${ui.dim}${t('language.shellOverride')}${ui.reset}\n`);
+        }
+        layout.contentWrite('\n');
+        return next();
+    },
+    (ctx) => {
+        if (ctx.line !== '/init')
+            return unhandled();
+        // /init:把 init 指令当 user 输入发给 agent(扫描项目 + 生成 AGENTS.md),fall through 走 runAgent
+        return forward(buildInitPrompt());
+    },
+    async (ctx) => {
+        const { line } = ctx;
+        if (line !== '/upgrade' && !line.startsWith('/upgrade '))
+            return unhandled();
+        const arg = line === '/upgrade' ? '' : line.slice('/upgrade '.length).trim().toLowerCase();
+        // /upgrade check — 联网检查当前版本与最新版本差异
+        if (arg === 'check') {
+            startRunningListener(t('running.upgrading'));
+            try {
+                const info = await checkVersion();
+                if (!info.latest) {
+                    layout.contentWrite(`${ui.yellow}⚠ ${t('upgrade.fetchFailed')}${ui.reset}\n`);
+                }
+                else if (info.hasUpdate) {
+                    layout.contentWrite(`${ui.cyan}● ${t('upgrade.hasUpdate', { current: info.current, latest: info.latest })}${ui.reset}\n`);
+                    layout.contentWrite(`${ui.dim}${t('upgrade.checkHint')}${ui.reset}\n`);
+                }
+                else {
+                    layout.contentWrite(`${ui.green}✓ ${t('upgrade.noUpdate', { version: info.current })}${ui.reset}\n`);
+                }
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                layout.contentWrite(`${ui.red}${t('upgrade.failed', { message: msg })}${ui.reset}\n`);
+            }
+            finally {
+                stopRunningListener();
+            }
+            return next();
+        }
+        // /upgrade status — 只显示本地当前版本(不联网)
+        if (arg === 'status') {
+            const current = getCurrentVersion();
+            layout.contentWrite(`${ui.dim}${t('upgrade.currentVersion', { version: `v${current}` })}${ui.reset}\n`);
+            layout.contentWrite(`${ui.dim}${t('upgrade.pkgName')}${ui.reset}\n`);
+            return next();
+        }
+        // /upgrade 或 /upgrade now — 前台执行升级,实时显示 npm 输出
+        if (arg === '' || arg === 'now') {
+            // 原实现升级成功后在 try 内 `break` 跳出 REPL 主循环;handler 无法 break 调用方,
+            // 改为置标志 + 返回 exit,由 runtime.ts 的 switch 执行 break(finally 时序不变)。
+            let exitAfterUpgrade = false;
+            startRunningListener(t('running.upgrading'));
+            try {
+                const latest = await fetchLatestVersion();
+                const current = getCurrentVersion();
+                if (latest && latest === current) {
+                    layout.contentWrite(`${ui.green}✓ ${t('upgrade.noUpdate', { version: current })}${ui.reset}\n`);
+                    return next();
+                }
+                const target = latest ?? 'latest';
+                layout.contentWrite(`${ui.cyan}● ${t('upgrade.begin', { version: target })}${ui.reset}\n`);
+                const result = await runUpgradeForeground((chunk) => {
+                    layout.contentWrite(chunk);
+                });
+                if (result.ok) {
+                    layout.contentWrite(`\n${ui.green}${ui.bold}✓ ${t('upgrade.completed')}${ui.reset}\n`);
+                    // 给用户 2.5 秒看清提示,然后自动退出,下次启动即使用新版本。
+                    await new Promise((resolve) => setTimeout(resolve, 2500));
+                    exitAfterUpgrade = true;
+                }
+                else {
+                    layout.contentWrite(`${ui.red}✗ ${t('upgrade.failedWithCode', { code: String(result.exitCode ?? 'unknown') })}${ui.reset}\n`);
+                    if (result.output.includes('ETARGET') || result.output.includes('No matching version found')) {
+                        layout.contentWrite(`${ui.yellow}${t('upgrade.etargetHint')}${ui.reset}\n`);
+                    }
+                    else {
+                        layout.contentWrite(`${ui.dim}${t('upgrade.manualHint')}${ui.reset}\n`);
+                    }
+                }
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                layout.contentWrite(`${ui.red}${t('upgrade.failed', { message: msg })}${ui.reset}\n`);
+            }
+            finally {
+                stopRunningListener();
+            }
+            return exitAfterUpgrade ? exit() : next();
+        }
+        // 未知子命令
+        layout.contentWrite(`${ui.yellow}${t('upgrade.usage')}${ui.reset}\n`);
+        return next();
+    },
+];