@keyou007/agent-bot 0.1.12 → 0.1.13-alpha.1

package/src/cli/ServerStarter.ts

@@ -11,7 +11,11 @@ import {
 import { refreshedSystemEnvironment } from "../supervision/systemEnvironment.js";
 import { controlEndpoint } from "./controlProtocol.js";
 import { cliText } from "./i18n.js";
-import { isServerReachable, isServerRunning } from "./LocalControlClient.js";
+import {
+  isServerReachable,
+  isServerRunning,
+  sendControlRequest,
+} from "./LocalControlClient.js";
 
 export interface ServerStartResult {
   status: "started" | "already-running";
@@ -19,6 +23,7 @@ export interface ServerStartResult {
 
 export type InitializationServerResult =
   | ServerStartResult
+  | { status: "restart-scheduled" }
   | { status: "skipped"; reason: "feishu-skipped" };
 
 export interface ServerStarterDependencies {
@@ -33,6 +38,7 @@ const SERVER_START_TIMEOUT_MS = 45_000;
 interface InitializationServerDependencies {
   loadConfig(configPath?: string): AppConfig;
   startServer(config: AppConfig): Promise<ServerStartResult>;
+  restartServer(config: AppConfig): Promise<void>;
 }
 
 export async function startInitializedServer(
@@ -42,7 +48,11 @@ export async function startInitializedServer(
   if (options.skipFeishu) {
     return { status: "skipped", reason: "feishu-skipped" };
   }
-  return dependencies.startServer(dependencies.loadConfig(options.configPath));
+  const config = dependencies.loadConfig(options.configPath);
+  const result = await dependencies.startServer(config);
+  if (result.status !== "already-running") return result;
+  await dependencies.restartServer(config);
+  return { status: "restart-scheduled" };
 }
 
 export async function startServer(
@@ -116,6 +126,19 @@ const defaultDependencies: ServerStarterDependencies = {
 const defaultInitializationDependencies: InitializationServerDependencies = {
   loadConfig,
   startServer: (config) => startServer(config),
+  restartServer: async (config) => {
+    const response = await sendControlRequest(controlEndpoint(config.storage.sqlitePath), {
+      action: "server_restart",
+      mode: "safe",
+      reason: "Agent Bot 初始化完成，需要加载当前版本",
+    });
+    if (!response.ok) {
+      throw new Error(response.message?.trim() || cliText(
+        "Could not schedule the Agent Bot restart after initialization.",
+        "初始化完成后无法安排 Agent Bot 重启。",
+      ));
+    }
+  },
 };
 
 async function waitForServer(endpoint: string, timeoutMs: number): Promise<boolean> {

package/src/cli/controlProtocol.ts

@@ -6,7 +6,12 @@ import type { SessionRecord } from "../state/StateStore.js";
 
 export type ControlRequest =
   | { action: "health" }
-  | { action: "server_restart"; mode: "safe" | "immediate"; reason: string }
+  | {
+      action: "server_restart";
+      mode: "safe" | "immediate";
+      reason: string;
+      notificationSessionId?: string;
+    }
   | { action: "server_stop" }
   | { action: "task_status"; localSessionId: string }
   | { action: "task_stop"; localSessionId: string }

package/src/cli/help.ts

@@ -3,18 +3,18 @@ import { cliLanguage, type CliLanguage } from "./i18n.js";
 export function renderCliHelp(version: string, language: CliLanguage = cliLanguage): string {
   if (language === "zh") {
     return `Agent Bot ${version}
-通过飞书使用本地 Codex 和 ACP Agent。
+通过飞书使用本地 Codex、TraeX 和兼容 ACP 的 Agent。
 
 用法：
   agentbot [选项] <命令>
 
 常用命令：
-  init                              初始化飞书应用并启动服务
+  init                              检查并选择 Agent，初始化飞书应用和服务
   init --reset                      重置并重新配置显式指定的 Profile
   console                           打开本地控制台
   server start                      在后台启动 Agent Bot
   server status                     显示服务、飞书 App ID 和安全重启状态
-  server restart                    安排安全重启
+  server restart [--task <任务>]    安排安全重启并将状态发回指定任务会话
   server stop                       停止 Agent Bot
   task list                         列出任务
   task status <任务>                显示任务状态
@@ -39,6 +39,11 @@ export function renderCliHelp(version: string, language: CliLanguage = cliLangua
   --skip-feishu                     仅初始化 Console 环境
   --reconfigure-feishu              仅替换现有飞书凭据
 
+重启选项：
+  --task <任务>                     将安全重启状态发回任务所在会话
+  --reason <原因>                   设置重启原因
+  --immediate                       立即重启，可能中断任务
+
 示例：
   agentbot init
   agentbot --profile ~/.agent-bot init --reset
@@ -51,18 +56,18 @@ export function renderCliHelp(version: string, language: CliLanguage = cliLangua
   }
 
   return `Agent Bot ${version}
-Use local Codex and ACP agents from Lark/Feishu.
+Use Codex, TraeX, and compatible ACP agents from Lark/Feishu.
 
 Usage:
   agentbot [options] <command>
 
 Common commands:
-  init                              Initialize the Lark app and start the service
+  init                              Check and select an Agent; initialize the Lark app and service
   init --reset                      Reset and reconfigure an explicit profile
   console                           Open the local console
   server start                      Start Agent Bot in the background
   server status                     Show the server, Lark App ID, and safe-restart status
-  server restart                    Schedule a safe restart
+  server restart [--task <task>]    Schedule a safe restart and return status to the task's conversation
   server stop                       Stop Agent Bot
   task list                         List tasks
   task status <task>                Show task status
@@ -87,6 +92,11 @@ Init options:
   --skip-feishu                     Initialize for Console only
   --reconfigure-feishu              Replace only the existing Lark credentials
 
+Restart options:
+  --task <task>                     Return safe-restart status to the task's conversation
+  --reason <reason>                 Set the restart reason
+  --immediate                       Restart immediately and possibly interrupt tasks
+
 Examples:
   agentbot init
   agentbot --profile ~/.agent-bot init --reset

package/src/cli.ts

@@ -2,6 +2,7 @@
 import fs from "node:fs";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline";
 import { loadConfig, loadConfigWithoutEnvironmentMutation } from "./config/loadConfig.js";
 import { sendControlRequest, isServerReachable } from "./cli/LocalControlClient.js";
 import {
@@ -14,8 +15,10 @@ import {
   acquireInitializationLock,
   cleanupFeishuCredentialTemporaryFiles,
   initializeAgentBot,
+  readConfiguredAgentSelection,
   readFeishuCredentials,
   shouldCreateFeishuApp,
+  writeDefaultAgent,
   writeFeishuCredentials,
   type InitializationResult,
   type InitializationStatus,
@@ -38,6 +41,18 @@ import {
 } from "./cli/FeishuAppConfiguration.js";
 import { renderCliHelp } from "./cli/help.js";
 import { cliLanguage, cliText, localizeCliErrorMessage } from "./cli/i18n.js";
+import {
+  inspectSupportedAgent,
+  inspectSupportedAgents,
+  runSupportedAgentMaintenance,
+  type SupportedAgentInspection,
+} from "./cli/AgentPrerequisites.js";
+import {
+  parseMaintenanceSelection,
+  resolveDefaultAgentChoice,
+  selectableDefaultAgents,
+  type SelectableDefaultAgent,
+} from "./cli/DefaultAgentSelection.js";
 import { formatServerStatus, withConfiguredFeishuAppId } from "./cli/serverStatus.js";
 import { resolveSystemSkillsRoot, SkillRegistry, type SkillRegistrationStatus } from "./cli/SkillRegistry.js";
 import { readPackageVersion } from "./cli/packageVersion.js";
@@ -50,6 +65,8 @@ import {
   type ServerStartResult,
 } from "./cli/ServerStarter.js";
 import { taskChatRoute } from "./cli/taskChatRoute.js";
+import { isThreadContextKey } from "./feishu/contextKey.js";
+import { refreshedSystemEnvironment } from "./supervision/systemEnvironment.js";
 import {
   parseTaskForkGroupOptions,
   parseTaskNewGroupOptions,
@@ -112,14 +129,27 @@ async function main(input: string[]): Promise<void> {
 type FeishuInitializationStatus = "created" | "existing" | "skipped";
 
 interface InitCommandResult extends InitializationResult {
+  agents: InitializedAgent[];
+  defaultAgent: {
+    name: string;
+    status: "selected" | "existing";
+  };
   feishu: {
     status: FeishuInitializationStatus;
     appId?: string;
+    userOpenIdStatus?: "configured" | "pending";
     configuration?: EnsureFeishuAppConfigurationResult;
   };
   server: InitializationServerResult;
 }
 
+interface InitializedAgent extends SupportedAgentInspection {
+  assistance?: {
+    status: "completed" | "skipped" | "unavailable" | "failed";
+    error?: string;
+  };
+}
+
 async function initCommand(
   input: string[],
   configPath: string | undefined,
@@ -135,13 +165,15 @@ async function initCommand(
     if (options.reset) await assertResetProfileServerStopped(configPath);
     paths = initializeAgentBot({ configPath, reset: options.reset });
     if (!options.json) printInitializationPaths(paths);
+    const agents = await initializeSupportedAgents(options.json);
+    const defaultAgent = await selectDefaultAgent(paths.config.path, agents, options.json);
     initializationLock ??= acquireInitializationLock(paths.home.path);
     cleanupFeishuCredentialTemporaryFiles(paths.env.path);
     const feishu = await initializeFeishu(
       paths,
       options,
     );
-    initialized = { ...paths, feishu };
+    initialized = { ...paths, agents, defaultAgent, feishu };
   } finally {
     initializationLock?.release();
   }
@@ -156,6 +188,259 @@ async function initCommand(
   else printInitializationServerResult(server);
 }
 
+async function initializeSupportedAgents(json: boolean): Promise<InitializedAgent[]> {
+  const output = json ? process.stderr : process.stdout;
+  output.write(cliText(
+    "\nAgent setup\nChecking Codex and TraeX...\n",
+    "\nAgent 设置\n正在检查 Codex 和 TraeX...\n",
+  ));
+  const inspections = await inspectSupportedAgents();
+  for (const inspection of inspections) printAgentInspection(inspection, output);
+  const actionable = inspections.filter((inspection) => inspection.action);
+  if (actionable.length === 0) return inspections;
+
+  output.write(cliText("\nAvailable actions:\n", "\n可执行的操作：\n"));
+  for (const [index, inspection] of actionable.entries()) {
+    output.write(cliText(
+      `  ${index + 1}. ${inspection.action?.kind === "install" ? "Install" : "Upgrade"} ${inspection.name}: ${inspection.action?.command}\n`,
+      `  ${index + 1}. ${inspection.action?.kind === "install" ? "安装" : "升级"} ${inspection.name}：${inspection.action?.command}\n`,
+    ));
+  }
+
+  let selected = new Set<number>();
+  if (!process.stdin.isTTY) {
+    output.write(cliText(
+      "No interactive terminal is available. Run the commands above manually if needed.\n",
+      "当前没有交互式终端，如有需要请手动执行上面的命令。\n",
+    ));
+  } else {
+    selected = new Set(await promptForAgentMaintenance(actionable.length));
+    if (selected.size === 0) {
+      output.write(cliText("No Agent changes selected.\n", "已跳过 Agent 安装和升级。\n"));
+    }
+  }
+
+  const initialized: InitializedAgent[] = [];
+  for (const inspection of inspections) {
+    if (!inspection.action) {
+      initialized.push(inspection);
+      continue;
+    }
+    const actionIndex = actionable.indexOf(inspection);
+    if (!selected.has(actionIndex)) {
+      initialized.push({
+        ...inspection,
+        assistance: { status: process.stdin.isTTY ? "skipped" : "unavailable" },
+      });
+      continue;
+    }
+
+    output.write(cliText(
+      `\nRunning ${inspection.name} ${inspection.action.kind}: ${inspection.action.command}\n`,
+      `\n正在${inspection.action.kind === "install" ? "安装" : "升级"} ${inspection.name}：${inspection.action.command}\n`,
+    ));
+    const maintenance = await runSupportedAgentMaintenance(inspection.id, inspection.action.kind);
+    if (maintenance.status !== 0 || maintenance.error) {
+      const error = maintenance.error ?? cliText(
+        `Command exited with code ${maintenance.status ?? "unknown"}.`,
+        `命令退出码为 ${maintenance.status ?? "未知"}。`,
+      );
+      output.write(cliText(
+        `${inspection.name} ${inspection.action.kind} did not complete; initialization will continue.\n`,
+        `${inspection.name}${inspection.action.kind === "install" ? "安装" : "升级"}未完成，初始化将继续。\n`,
+      ));
+      initialized.push({ ...inspection, assistance: { status: "failed", error } });
+      continue;
+    }
+
+    refreshCurrentProcessPath();
+    const refreshed = await inspectSupportedAgent(inspection.id);
+    if (refreshed.installedVersion) {
+      output.write(cliText(
+        `${inspection.name} is ready (${refreshed.installedVersion}).\n`,
+        `${inspection.name} 已就绪（${refreshed.installedVersion}）。\n`,
+      ));
+    } else {
+      output.write(cliText(
+        `${inspection.name} command completed, but the CLI is not visible in this process. Open a new terminal and run agentbot init again.\n`,
+        `${inspection.name} 命令已完成，但当前进程仍无法找到该 CLI。请打开新终端后重新运行 agentbot init。\n`,
+      ));
+    }
+    initialized.push({ ...refreshed, assistance: { status: "completed" } });
+  }
+  return initialized;
+}
+
+async function selectDefaultAgent(
+  configPath: string,
+  inspections: InitializedAgent[],
+  json: boolean,
+): Promise<InitCommandResult["defaultAgent"]> {
+  const output = json ? process.stderr : process.stdout;
+  const configured = readConfiguredAgentSelection(configPath);
+  const choices = selectableDefaultAgents(configured.agents, inspections);
+  if (!process.stdin.isTTY) {
+    if (!configured.defaultAgent || !configured.agents.some((agent) => agent.name === configured.defaultAgent)) {
+      throw new Error(cliText(
+        "A default Agent is not configured. Run agentbot init in an interactive terminal and select one.",
+        "尚未配置默认 Agent。请在交互式终端中运行 agentbot init 并选择一个 Agent。",
+      ));
+    }
+    output.write(cliText(
+      `Default Agent: ${configured.defaultAgent} (kept because no interactive terminal is available)\n`,
+      `默认 Agent：${configured.defaultAgent}（当前没有交互式终端，已保留现有设置）\n`,
+    ));
+    return { name: configured.defaultAgent, status: "existing" };
+  }
+  if (choices.length === 0) {
+    throw new Error(cliText(
+      "No available configured Agent can be selected. Install Codex or TraeX, then run agentbot init again.",
+      "没有可选择的已配置 Agent。请安装 Codex 或 TraeX，然后重新运行 agentbot init。",
+    ));
+  }
+
+  output.write(cliText("\nSelect the default Agent:\n", "\n请选择默认 Agent：\n"));
+  for (const [index, choice] of choices.entries()) {
+    const version = choice.installedVersion ? ` (${choice.installedVersion})` : "";
+    const current = choice.name === configured.defaultAgent
+      ? cliText(" [current]", " [当前]")
+      : "";
+    output.write(`  ${index + 1}. ${choice.name} - ${choice.title}${version}${current}\n`);
+  }
+  const selected = choices[await promptForDefaultAgent(choices, configured.defaultAgent)];
+  if (!selected) throw new Error(cliText("Default Agent selection failed.", "默认 Agent 选择失败。"));
+  const updated = writeDefaultAgent(configPath, selected.name);
+  output.write(updated
+    ? cliText(`Saved default Agent: ${selected.name}\n`, `已保存默认 Agent：${selected.name}\n`)
+    : cliText(`Default Agent unchanged: ${selected.name}\n`, `默认 Agent 保持不变：${selected.name}\n`));
+  return { name: selected.name, status: updated ? "selected" : "existing" };
+}
+
+function promptForAgentMaintenance(choiceCount: number): Promise<number[]> {
+  const readline = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (selection: number[]): void => {
+      settled = true;
+      readline.close();
+      resolve(selection);
+    };
+    const ask = (): void => {
+      readline.question(cliText(
+        "Enter action numbers separated by commas, type all, or press Enter to skip: ",
+        "请输入要执行的操作编号（多个用逗号分隔），输入 all 选择全部，直接回车跳过：",
+      ), (answer) => {
+        const selection = parseMaintenanceSelection(answer, choiceCount);
+        if (selection) {
+          finish(selection);
+          return;
+        }
+        process.stderr.write(cliText(
+          `Enter numbers from 1 to ${choiceCount}, all, or press Enter to skip.\n`,
+          `请输入 1 到 ${choiceCount} 之间的编号、all，或直接回车跳过。\n`,
+        ));
+        ask();
+      });
+    };
+    listenForPromptCancellation(readline, () => {
+      settled = true;
+      reject(new Error(cliText("Initialization was cancelled.", "初始化已取消。")));
+    }, () => settled);
+    ask();
+  });
+}
+
+function promptForDefaultAgent(
+  choices: SelectableDefaultAgent[],
+  currentAgent?: string,
+): Promise<number> {
+  const readline = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (index: number): void => {
+      settled = true;
+      readline.close();
+      resolve(index);
+    };
+    const ask = (): void => {
+      const currentAvailable = choices.some((choice) => choice.name === currentAgent);
+      readline.question(cliText(
+        `Enter a number or Agent name${currentAvailable ? ` [${currentAgent}]` : ""}: `,
+        `请输入编号或 Agent 标准名${currentAvailable ? ` [${currentAgent}]` : ""}：`,
+      ), (answer) => {
+        const index = resolveDefaultAgentChoice(answer, choices, currentAgent);
+        if (index !== undefined) {
+          finish(index);
+          return;
+        }
+        process.stderr.write(cliText(
+          `Enter a number from 1 to ${choices.length} or an Agent standard name.\n`,
+          `请输入 1 到 ${choices.length} 之间的编号，或 Agent 标准名。\n`,
+        ));
+        ask();
+      });
+    };
+    listenForPromptCancellation(readline, () => {
+      settled = true;
+      reject(new Error(cliText("Initialization was cancelled.", "初始化已取消。")));
+    }, () => settled);
+    ask();
+  });
+}
+
+function listenForPromptCancellation(
+  readline: ReturnType<typeof createInterface>,
+  cancel: () => void,
+  isSettled: () => boolean,
+): void {
+  readline.once("SIGINT", () => {
+    if (!isSettled()) cancel();
+    readline.close();
+  });
+  readline.once("close", () => {
+    if (!isSettled()) cancel();
+  });
+}
+
+function printAgentInspection(
+  inspection: SupportedAgentInspection,
+  output: NodeJS.WriteStream,
+): void {
+  if (inspection.state === "missing") {
+    output.write(cliText(
+      `  ${inspection.name}: not installed\n`,
+      `  ${inspection.name}：未安装\n`,
+    ));
+    return;
+  }
+  if (inspection.state === "outdated") {
+    output.write(cliText(
+      `  ${inspection.name}: ${inspection.installedVersion}; update available (${inspection.latestVersion})\n`,
+      `  ${inspection.name}：${inspection.installedVersion}；可升级到 ${inspection.latestVersion}\n`,
+    ));
+    return;
+  }
+  if (inspection.latestCheckFailed) {
+    output.write(cliText(
+      `  ${inspection.name}: ${inspection.installedVersion}; latest-version check unavailable\n`,
+      `  ${inspection.name}：${inspection.installedVersion}；无法检查最新版本\n`,
+    ));
+    return;
+  }
+  output.write(cliText(
+    `  ${inspection.name}: ${inspection.installedVersion} (up to date)\n`,
+    `  ${inspection.name}：${inspection.installedVersion}（已是最新）\n`,
+  ));
+}
+
+function refreshCurrentProcessPath(): void {
+  const refreshed = refreshedSystemEnvironment();
+  if (!refreshed.refreshed) return;
+  const pathEntry = Object.entries(refreshed.environment)
+    .find(([name]) => name.toLowerCase() === "path");
+  if (pathEntry?.[1]) process.env.PATH = pathEntry[1];
+}
+
 async function initializeFeishu(
   paths: InitializationResult,
   options: InitCommandOptions,
@@ -165,8 +450,14 @@ async function initializeFeishu(
     return {
       status: "skipped",
       ...(existing.appId ? { appId: existing.appId } : {}),
+      ...(existing.appId && existing.appSecret
+        ? { userOpenIdStatus: existing.userOpenId ? "configured" as const : "pending" as const }
+        : {}),
     };
   }
+  if (!options.json) {
+    process.stdout.write(cliText("\nLark setup\n", "\n飞书设置\n"));
+  }
 
   const controller = new AbortController();
   const onInterrupt = (): void => controller.abort(new Error(cliText(
@@ -202,8 +493,8 @@ async function initializeFeishu(
 
     if (!options.json) {
       process.stdout.write(cliText(
-        "\nChecking Lark app permissions, events, and callbacks...\n",
-        "\n正在检查飞书应用权限、事件和回调...\n",
+        "Checking app permissions, events, and callbacks...\n",
+        "正在检查应用权限、事件和回调...\n",
       ));
     }
     const manualPermissionSkip = new AbortController();
@@ -227,6 +518,7 @@ async function initializeFeishu(
     return {
       status,
       appId: credentials.appId,
+      userOpenIdStatus: credentials.userOpenId ? "configured" : "pending",
       configuration,
     };
   } finally {
@@ -373,12 +665,14 @@ async function serverCommand(input: string[]): Promise<void> {
   }
   if (action === "restart") {
     const immediate = rest.includes("--immediate") || rest.includes("--force");
+    const notificationSessionId = resolveRestartNotificationSessionId(config.storage.sqlitePath, rest);
     const reason = optionValue(rest, "--reason")
       ?? (immediate ? "通过 Agent Bot CLI 立即重启" : "通过 Agent Bot CLI 安全重启");
     ensureOk(await sendControlRequest(endpoint, {
       action: "server_restart",
       mode: immediate ? "immediate" : "safe",
       reason,
+      notificationSessionId,
     }));
     process.stdout.write(immediate
       ? cliText("Immediate restart requested.\n", "已请求立即重启。\n")
@@ -388,6 +682,42 @@ async function serverCommand(input: string[]): Promise<void> {
   throw new Error(cliText(`Unknown server command: ${action}`, `未知的 server 命令：${action}`));
 }
 
+function resolveRestartNotificationSessionId(sqlitePath: string, args: string[]): string | undefined {
+  const store = new StateStore(sqlitePath);
+  try {
+    const sessions = store.listAllSessions();
+    if (args.includes("--task")) {
+      const reference = optionValue(args, "--task")?.trim();
+      if (!reference || reference.startsWith("--")) throw new Error(cliText(
+        "server restart --task requires a task number or task ID.",
+        "server restart --task 需要任务序号或任务 ID。",
+      ));
+      const session = resolveTask(sessions, reference);
+      if (
+        isThreadContextKey(session.contextKey)
+        && !store.findLatestMessageIdForSession(session.localSessionId, session.contextKey)
+        && !store.findLatestMessageIdForContext(session.contextKey)
+      ) {
+        throw new Error(cliText(
+          "The task topic has no message anchor for restart notifications. Send /restart in that topic instead.",
+          "该任务话题没有可用于重启通知的消息锚点，请直接在该话题中发送 /restart。",
+        ));
+      }
+      return session.localSessionId;
+    }
+    const runningContexts = new Set(
+      sessions.filter((session) => session.status === "running").map((session) => session.contextKey),
+    );
+    if (runningContexts.size > 1) throw new Error(cliText(
+      "Multiple conversations are running. Pass --task <task> so restart notifications return to the requester.",
+      "当前有多个会话正在运行。请传入 --task <任务>，确保重启通知返回发起会话。",
+    ));
+    return undefined;
+  } finally {
+    store.close();
+  }
+}
+
 async function taskCommand(input: string[]): Promise<void> {
   const [action = "list", ...rest] = input;
   const config = loadConfig();
@@ -624,8 +954,8 @@ function printSkillStatus(status: SkillRegistrationStatus): void {
 
 function printInitializationPaths(result: InitializationResult): void {
   process.stdout.write(cliText(
-    "Preparing the Agent Bot user environment...\n",
-    "正在准备 Agent Bot 用户环境...\n",
+    "Profile setup\n",
+    "Profile 设置\n",
   ));
   if (result.reset) {
     process.stdout.write(`${cliText("Reset backup: ", "重置备份：")}${result.reset.backupPath}\n`);
@@ -642,6 +972,7 @@ function printInitializationResult(result: Omit<InitCommandResult, "server">): v
     "\nAgent Bot initialization completed.\n",
     "\nAgent Bot 初始化完成。\n",
   ));
+  process.stdout.write(`${cliText("Default Agent: ", "默认 Agent：")}${result.defaultAgent.name}\n`);
   if (result.feishu.status === "created") {
     process.stdout.write(cliText(
       `Lark app: created and credentials saved (${result.feishu.appId})\n`,
@@ -658,6 +989,12 @@ function printInitializationResult(result: Omit<InitCommandResult, "server">): v
       "飞书应用：已跳过；请使用 Console 模式或稍后重新运行 init。\n",
     ));
   }
+  if (result.feishu.userOpenIdStatus === "pending") {
+    process.stdout.write(cliText(
+      "Lark user: pending; send the bot a direct message to save FEISHU_USER_OPEN_ID\n",
+      "飞书用户：等待补全；请私聊机器人以保存 FEISHU_USER_OPEN_ID\n",
+    ));
+  }
   if (result.feishu.configuration?.status === "updated") {
     const added = result.feishu.configuration.added;
     process.stdout.write(cliText(
@@ -697,6 +1034,13 @@ function printInitializationServerResult(result: InitCommandResult["server"]): v
     ));
     return;
   }
+  if (result.status === "restart-scheduled") {
+    process.stdout.write(cliText(
+      "Agent Bot server: safe restart scheduled to load the current version.\n",
+      "Agent Bot 服务：已安排安全重启，以加载当前版本。\n",
+    ));
+    return;
+  }
   printServerStartResult(result);
 }
 
@@ -852,6 +1196,7 @@ function feishuFeatureWarnings(missing: FeishuConfigurationChallenge["missing"])
 
 function initializationStatusLabel(status: InitializationStatus): string {
   if (status === "created") return cliText("created", "已创建");
+  if (status === "updated") return cliText("updated with missing settings", "已补全缺失配置");
   if (status === "reset") return cliText("reset from template", "已从模板重置");
   return cliText("already exists; unchanged", "已存在，未修改");
 }

package/src/codex/AppServerConnection.ts

@@ -108,7 +108,7 @@ export class AppServerConnection {
       try {
         message = JSON.parse(line) as AppServerMessage;
       } catch (error) {
-        this.logger.warn({ line, error }, "Ignoring non-JSON Codex App Server stdout line.");
+        this.logger.warn({ line, error }, "Ignoring non-JSON App Server stdout line.");
         return;
       }
       this.handleMessage(message);
@@ -128,7 +128,7 @@ export class AppServerConnection {
       for (const listener of this.notificationListeners) listener(message.method, message.params);
       return;
     }
-    this.logger.warn({ message }, "Ignoring unknown Codex App Server message shape.");
+    this.logger.warn({ message }, "Ignoring unknown App Server message shape.");
   }
 
   private handleResponse(message: AppServerResponse): void {
@@ -139,7 +139,7 @@ export class AppServerConnection {
           responseId: message.id,
           responseKind: "error" in message ? "error" : "result",
         },
-        "Received Codex App Server response for unknown request.",
+        "Received App Server response for unknown request.",
       );
       return;
     }

package/src/codex/CodexProcessManager.ts

@@ -27,15 +27,15 @@ export class CodexProcessManager implements AppServerClientProvider {
     const client = new AppServerConnection(child, this.logger.child({ component: "codex-app-server" }));
     this.client = client;
     readline.createInterface({ input: child.stderr, crlfDelay: Infinity }).on("line", (line) => {
-      this.logger.debug({ line }, "Codex App Server stderr.");
+      this.logger.debug({ line }, "App Server stderr.");
     });
-    child.once("error", (error) => this.logger.error({ error }, "Codex App Server process error."));
+    child.once("error", (error) => this.logger.error({ error }, "App Server process error."));
     child.once("exit", (code, signal) => {
-      this.logger.warn({ code, signal }, "Codex App Server process exited.");
+      this.logger.warn({ code, signal }, "App Server process exited.");
       client.close();
       if (this.client === client) this.client = undefined;
       if (this.child === child) this.child = undefined;
-      const error = new Error(`Codex App Server exited (code=${code ?? "null"}, signal=${signal ?? "null"}).`);
+      const error = new Error(`App Server exited (code=${code ?? "null"}, signal=${signal ?? "null"}).`);
       for (const listener of this.disconnectListeners) listener(error);
     });
     await client.request("initialize", {