@keyou007/agent-bot 0.1.13-alpha.3 → 0.1.13-alpha.4

package/docs/technical-reference.md

@@ -60,7 +60,7 @@ Relative `storage.sqlitePath` and `logging.path` values resolve against the dire
 
 Early in initialization, `agentbot init` checks the supported Codex and TraeX CLIs in parallel and reports each installed version. Codex is compared with the latest stable `@openai/codex` package, while TraeX is compared with its Alpha channel. Missing or outdated Agents are gathered into one numbered list containing their exact install or upgrade commands. An interactive user can enter comma- or space-separated action numbers, `all`, or an empty answer to skip maintenance. Selected commands run sequentially with inherited stdio; skipped and failed actions are recorded and initialization continues. In a non-interactive terminal, commands are printed for manual use. With `--json`, progress and prompts use stderr and the final `agents` array records detection and assistance results. Codex upgrades first use `codex update` and fall back to the current npm package command when an older updater fails.
 
-After version and maintenance checks, an interactive `init` requires a default-Agent selection by number or standard name. Configured custom Agents remain selectable without a version check; Codex or TraeX is omitted while its CLI is missing. When the current default remains selectable, an empty answer confirms it. The selected standard name is written to `defaults.agent` through the same comment-preserving atomic YAML update used for configuration upgrades. A non-interactive invocation retains an existing valid configured default because it cannot prompt, and fails when no valid default exists. The JSON result reports this as `defaultAgent.name` and `defaultAgent.status` (`selected` or `existing`).
+After version and maintenance checks, a first fresh interactive `init` and every explicit `--reset` build the Profile's Agent configuration from the supported Agents that were actually detected with an installed version. Missing Codex or TraeX entries are not selectable. When multiple Agents are available, the user may select one or more by number or standard name; `all` or an empty answer selects all. Unselected Agent definitions are removed from the new configuration through a comment-preserving atomic YAML update. One selected Agent becomes the default automatically. When multiple Agents are selected, a second prompt chooses `defaults.agent` by number or standard name. Later upgrades and refreshes preserve both the configured Agent list and default without showing either selector, including custom Agents already present in the Profile. A non-interactive first initialization or reset configures every detected installed Agent and keeps the template default when selected, otherwise the first detected Agent. An existing Profile without a valid configured default fails with an instruction to set `defaults.agent` in `config.yaml`. JSON output reports the final names in `configuredAgents`, adds `configured` to each supported-Agent inspection, and returns `defaultAgent.name` plus `defaultAgent.status` (`selected` or `existing`).
 
 `agentbot init` copies the packaged `config.example.yaml` and `.env.example` when their target files do not exist, creates the data and log directories, and restricts `.env` permissions where the platform supports POSIX modes.
 
@@ -103,7 +103,7 @@ The generated authorization links do not contain the app secret.
 
 After Feishu initialization succeeds, the CLI releases the initialization lock and starts the detached supervisor through the same readiness path as `agentbot server start`. It waits up to 45 seconds for the worker to connect to Feishu and become ready. If the selected profile is already running, no second supervisor is created; instead, initialization requests a safe restart so the current installed code and refreshed configuration are loaded after active work and final delivery finish. The JSON result reports this as `server.status: "restart-scheduled"`. `--skip-feishu` skips automatic server startup, and `--json` includes the resulting `server.status` without adding non-JSON output.
 
-After the Server starts or a safe restart is successfully scheduled, `init` sends a Card 2.0 welcome card directly to `feishu.userOpenId`. The card uploads the packaged `assets/agent-bot-logo.png`, follows the CLI language, and reports the installed version, default Agent, and configured Agents. When a safe restart is pending, the card says that the refreshed version takes effect after that restart instead of claiming it is already active. A Profile receipt at `<profile>/data/initialization.json` records the last successfully initialized package version so the card can distinguish first setup, version upgrade, and same-version refresh. Welcome delivery is reported in the JSON `welcome` object. A missing user Open ID or delivery failure produces an explicit warning without undoing completed configuration or stopping an already-ready Server; `--skip-feishu` records a skipped welcome.
+After the Server starts or a safe restart is successfully scheduled, `init` sends a Card 2.0 welcome card directly to `feishu.userOpenId`. The card uploads the packaged `assets/agent-bot-logo.png`, is always rendered in Chinese regardless of the CLI locale, and reports the installed version, default Agent, and configured Agents. When a safe restart is pending, the card says that the refreshed version takes effect after that restart instead of claiming it is already active. A Profile receipt at `<profile>/data/initialization.json` records the last successfully initialized package version so the card can distinguish first setup, version upgrade, and same-version refresh. Welcome delivery is reported in the JSON `welcome` object. A missing user Open ID or delivery failure produces an explicit warning without undoing completed configuration or stopping an already-ready Server; `--skip-feishu` records a skipped welcome.
 
 ## Feishu App Requirements
 

package/docs/technical-reference.zh.md

@@ -60,7 +60,7 @@ CLI 通过 Node.js 国际化能力读取系统 Locale。以 `zh` 开头的 Local
 
 初始化开始阶段，`agentbot init` 会并行检查目前支持的 Codex 和 TraeX CLI，并显示各自已安装的版本。Codex 与最新稳定版 `@openai/codex` 比较，TraeX 与 Alpha 通道比较。未安装或版本较旧的 Agent 会汇总到一个编号列表，并显示准确的安装或升级命令。交互式用户可以输入用逗号或空格分隔的操作编号、输入 `all`，或直接回车跳过维护；所选命令按顺序执行并继承终端输入输出，跳过或失败的操作都会记录结果，初始化继续。非交互式终端只显示供手动执行的命令。使用 `--json` 时，进度与询问写入 stderr，最终 `agents` 数组记录检测和辅助执行结果。Codex 升级会先执行 `codex update`，旧版 updater 失败时回退到当前 npm 包安装命令。
 
-版本与维护检查完成后，交互式 `init` 会要求用户输入编号或标准名选择默认 Agent。自定义 Agent 无需版本检测即可选择；Codex 或 TraeX CLI 仍缺失时，对应 Agent 不会进入候选列表。当前默认 Agent 仍可选择时，直接回车即可确认。所选标准名通过保留注释的 YAML 原子更新写入 `defaults.agent`。非交互式调用无法询问，因此保留已有且仍在配置中的默认 Agent；没有有效默认值时会失败并提示改用交互式终端。JSON 结果通过 `defaultAgent.name` 和 `defaultAgent.status`（`selected` 或 `existing`）报告选择状态。
+版本与维护检查完成后，第一次全新交互式 `init` 和每次显式 `--reset` 都会根据实际检测到安装版本的受支持 Agent 生成 Profile 的 Agent 配置；仍未安装的 Codex 或 TraeX 不会进入候选列表。检测到多个 Agent 时，用户可以通过编号或标准名选择一个或多个，输入 `all` 或直接回车选择全部。未选择的 Agent 定义会通过保留注释的 YAML 原子更新从新配置中移除。只选择一个 Agent 时自动将其设为默认值；选择多个时再显示一次默认 Agent 选择，可输入编号或标准名写入 `defaults.agent`。后续升级和同版本刷新直接保留已配置 Agent 列表与默认值，不再显示这两类选择器，已有自定义 Agent 也会保留。第一次非交互式初始化或 reset 会配置所有检测到且已安装的 Agent；模板默认值在所选列表中时继续使用，否则选择第一个检测结果。已有 Profile 没有有效默认值时会失败，并提示在 `config.yaml` 中设置 `defaults.agent`。JSON 输出通过 `configuredAgents` 报告最终列表，在每个受支持 Agent 的检测结果中增加 `configured`，并通过 `defaultAgent.name` 和 `defaultAgent.status`（`selected` 或 `existing`）报告默认值。
 
 目标文件不存在时，`agentbot init` 会复制随包提供的 `config.example.yaml` 和 `.env.example`，创建数据和日志目录，并在平台支持时把 `.env` 权限限制为 POSIX `0600`。
 
@@ -103,7 +103,7 @@ https://open.feishu.cn/app/<appId>/auth?q=im%3Amessage.group_msg&op_from=openapi
 
 飞书初始化成功后，CLI 会先释放初始化锁，再通过与 `agentbot server start` 相同的就绪检查流程启动后台 Supervisor，并等待最多 45 秒，直到 Worker 连接飞书并进入就绪状态。如果当前 Profile 的服务已经运行，不会创建第二个 Supervisor，而是安排安全重启，在活动任务和最终结果投递完成后加载当前安装的代码及更新后的配置；JSON 结果将其表示为 `server.status: "restart-scheduled"`。`--skip-feishu` 会跳过自动启动；`--json` 会把结果写入 `server.status`，不会混入非 JSON 文本。
 
-Server 成功启动或安全重启成功安排后，`init` 会直接向 `feishu.userOpenId` 发送 Card 2.0 私聊欢迎卡。卡片会上传随包提供的 `assets/agent-bot-logo.png`，跟随 CLI 语言，并显示当前安装版本、默认 Agent 和已配置 Agent。如果安全重启仍在等待，卡片会明确说明刷新后的版本将在重启完成后生效，而不会声称新版已经接管。`<profile>/data/initialization.json` 会记录上次成功初始化的包版本，用于区分首次初始化、版本升级和同版本配置刷新。JSON 输出通过 `welcome` 对象报告发送结果。缺少用户 Open ID 或卡片发送失败时会明确警告，但不会撤销已完成的配置，也不会停止已经就绪的 Server；`--skip-feishu` 会记录欢迎卡已跳过。
+Server 成功启动或安全重启成功安排后，`init` 会直接向 `feishu.userOpenId` 发送 Card 2.0 私聊欢迎卡。无论 CLI 使用什么系统语言，欢迎卡都固定显示中文；卡片会上传随包提供的 `assets/agent-bot-logo.png`，并显示当前安装版本、默认 Agent 和已配置 Agent。如果安全重启仍在等待，卡片会明确说明刷新后的版本将在重启完成后生效，而不会声称新版已经接管。`<profile>/data/initialization.json` 会记录上次成功初始化的包版本，用于区分首次初始化、版本升级和同版本配置刷新。JSON 输出通过 `welcome` 对象报告发送结果。缺少用户 Open ID 或卡片发送失败时会明确警告，但不会撤销已完成的配置，也不会停止已经就绪的 Server；`--skip-feishu` 会记录欢迎卡已跳过。
 
 ## 飞书应用要求
 

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@keyou007/agent-bot",
-  "version": "0.1.13-alpha.3",
+  "version": "0.1.13-alpha.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@keyou007/agent-bot",
-      "version": "0.1.13-alpha.3",
+      "version": "0.1.13-alpha.4",
       "license": "GPL-3.0-only",
       "dependencies": {
         "@agentclientprotocol/sdk": "1.2.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keyou007/agent-bot",
-  "version": "0.1.13-alpha.3",
+  "version": "0.1.13-alpha.4",
   "type": "module",
   "description": "Use Codex, TraeX, and compatible coding agents from Lark/Feishu.",
   "license": "GPL-3.0-only",

package/skills/agent-bot/SKILL.md

@@ -61,7 +61,7 @@ agentbot init
 
 Initialization detects the supported Codex and TraeX CLIs and reports each installed version. Missing or outdated Agents are presented in one numbered maintenance list with their exact commands. In an interactive terminal, the user may enter comma-separated action numbers, `all`, or press Enter to skip maintenance. A failed maintenance command or the absence of an interactive terminal does not block the remaining initialization. Do not select maintenance actions on the user's behalf without permission. Agent Bot uses the latest stable Codex release and the TraeX Alpha channel for these checks.
 
-After the maintenance choice, interactive initialization requires the user to select the default Agent by number or standard name. It lists configured custom Agents and installed supported Agents, omits Codex or TraeX when that CLI is still missing, and writes the selected standard name to `defaults.agent` in `config.yaml`. If the current default remains available, an empty answer explicitly confirms it. Always relay the choices and let the user decide. A non-interactive invocation keeps an already configured default; it fails with an instruction to rerun interactively when no valid default exists. With `--json`, read the result from `defaultAgent.name` and `defaultAgent.status`.
+After the maintenance choice, a first fresh interactive initialization and every explicit `--reset` ask which detected installed Agents to configure. Missing supported Agents are omitted. The user may select one or more by number or standard name; `all` or an empty answer selects all. Relay the choices and let the user decide. Agent Bot removes unselected Agent definitions from the newly generated Profile. One selected Agent becomes the default automatically; multiple selected Agents produce a second number-or-name prompt for `defaults.agent`. Later upgrades and refreshes preserve the existing Agent list and default without either prompt, including custom configured Agents. A non-interactive first initialization or reset configures all detected installed Agents and chooses the template default when available, otherwise the first detected Agent. With `--json`, read the final list from `configuredAgents`, each supported inspection's `configured` flag, and `defaultAgent.name` plus `defaultAgent.status`.
 
 Initialization creates the Agent Bot home, `config.yaml`, `.env`, `data/`, and `logs/` from the bundled examples. If Feishu credentials are absent, it starts Feishu one-click app registration, prints a QR code followed by its authorization URL, waits for the user to approve the request, and stores the returned app ID and secret in `.env`. It then audits the app's currently published tenant permissions, event subscriptions, and callbacks. Core and optional missing items produce separate configuration challenges. Core configuration is polled until ready, except that the manually configured all-group-message permission may be explicitly skipped with `Y`. For optional configuration, the CLI prints the QR code followed by the authorization URL and immediately waits up to five minutes for activation. The only terminal choice is also `Y`, which skips optional authorization and continues initialization.
 

package/src/cli/DefaultAgentSelection.ts

@@ -12,14 +12,31 @@ export function selectableDefaultAgents(
   const supported = new Map(inspections.map((inspection) => [inspection.id, inspection]));
   return configured.flatMap((agent) => {
     const inspection = supported.get(agent.name as SupportedAgentInspection["id"]);
-    if (inspection && !inspection.installedVersion) return [];
+    if (!inspection?.installedVersion) return [];
     return [{
       ...agent,
-      ...(inspection?.installedVersion ? { installedVersion: inspection.installedVersion } : {}),
+      installedVersion: inspection.installedVersion,
     }];
   });
 }
 
+export function resolveAgentConfigurationChoices(
+  input: string,
+  choices: SelectableDefaultAgent[],
+): number[] | undefined {
+  const value = input.trim();
+  if (!value || /^(?:a|all)$/iu.test(value)) {
+    return choices.map((_choice, index) => index);
+  }
+  const selected = new Set<number>();
+  for (const token of value.split(/[,，\s]+/u).filter(Boolean)) {
+    const index = resolveDefaultAgentChoice(token, choices);
+    if (index === undefined) return undefined;
+    selected.add(index);
+  }
+  return selected.size > 0 ? [...selected].sort((left, right) => left - right) : undefined;
+}
+
 export function parseMaintenanceSelection(input: string, choiceCount: number): number[] | undefined {
   const value = input.trim();
   if (!value) return [];

package/src/cli/InitializationWelcome.ts

@@ -10,7 +10,6 @@ import {
   type InitializationWelcomeKind,
 } from "../feishu/CardRenderer.js";
 import { FeishuMessageClient } from "../feishu/FeishuMessageClient.js";
-import type { CliLanguage } from "./i18n.js";
 
 export interface InitializationReceipt {
   version: string;
@@ -24,7 +23,6 @@ export type InitializationWelcomeResult =
 
 export interface SendInitializationWelcomeInput {
   configPath?: string;
-  language: CliLanguage;
   version: string;
   previousVersion?: string;
   kind: InitializationWelcomeKind;
@@ -83,7 +81,6 @@ export async function sendInitializationWelcome(
   const renderer = new CardRenderer();
   const card = renderer.renderInitializationWelcome({
     kind: input.kind,
-    language: input.language,
     version: input.version,
     previousVersion: input.previousVersion,
     activationPending: input.activationPending,
@@ -91,7 +88,7 @@ export async function sendInitializationWelcome(
     defaultAgentTitle: defaultAgent.title,
     availableAgents: Object.values(config.agents).map((agent) => agent.title),
     logoPath: dependencies.logoPath,
-    features: welcomeFeatures(input.kind, input.language),
+    features: welcomeFeatures(input.kind),
   });
   await dependencies.sendCard(config, `open_id:${userOpenId}`, card);
   return { status: "sent", kind: input.kind };
@@ -103,51 +100,29 @@ function initializationReceiptPath(homePath: string): string {
 
 function welcomeFeatures(
   kind: InitializationWelcomeKind,
-  language: CliLanguage,
 ): InitializationWelcomeFeature[] {
   if (kind === "upgrade") {
-    return language === "zh"
-      ? [
-          { icon: "⚙️", title: "Agent 状态更透明", description: "Server 状态会显示每个 Agent 的 PID 与版本。" },
-          { icon: "🧭", title: "快速定位当前任务", description: "CLI 可识别正在调用它的 Codex 或 TraeX 任务。" },
-          { icon: "🗂️", title: "卡片操作更顺手", description: "Help 命令可点击，Sessions 翻页与操作更清晰。" },
-          { icon: "🛡️", title: "Crash 恢复更完整", description: "服务重启后会修复历史 Turn 的父子连接。" },
-        ]
-      : [
-          { icon: "⚙️", title: "Clearer Agent status", description: "Server status now shows each Agent's PID and version." },
-          { icon: "🧭", title: "Find the current task", description: "The CLI can identify its invoking Codex or TraeX task." },
-          { icon: "🗂️", title: "Better card actions", description: "Clickable Help commands and clearer Sessions pagination." },
-          { icon: "🛡️", title: "Stronger crash recovery", description: "Turn graph links are repaired after service recovery." },
-        ];
+    return [
+      { icon: "⚙️", title: "Agent 状态更透明", description: "Server 状态会显示每个 Agent 的 PID 与版本。" },
+      { icon: "🧭", title: "快速定位当前任务", description: "CLI 可识别正在调用它的 Codex 或 TraeX 任务。" },
+      { icon: "🗂️", title: "卡片操作更顺手", description: "Help 命令可点击，Sessions 翻页与操作更清晰。" },
+      { icon: "🛡️", title: "Crash 恢复更完整", description: "服务重启后会修复历史 Turn 的父子连接。" },
+    ];
   }
   if (kind === "refresh") {
-    return language === "zh"
-      ? [
-          { icon: "💬", title: "随时开始对话", description: "私聊或群聊发送消息，即可继续当前任务。" },
-          { icon: "🧠", title: "统一运行设置", description: "在同一张卡片中切换 Agent、模型、思考和权限。" },
-          { icon: "🌿", title: "任务分支", description: "使用 New Group 或 Fork Group 并行处理工作。" },
-          { icon: "🔄", title: "安全恢复", description: "任务、进度与服务状态会持久保存并恢复。" },
-        ]
-      : [
-          { icon: "💬", title: "Start anywhere", description: "Continue work from a private chat or group conversation." },
-          { icon: "🧠", title: "Unified settings", description: "Switch Agent, model, thinking, and permissions in one card." },
-          { icon: "🌿", title: "Branch tasks", description: "Use New Group or Fork Group for parallel work." },
-          { icon: "🔄", title: "Safe recovery", description: "Tasks, progress, and service state persist across restarts." },
-        ];
+    return [
+      { icon: "💬", title: "随时开始对话", description: "私聊或群聊发送消息，即可继续当前任务。" },
+      { icon: "🧠", title: "统一运行设置", description: "在同一张卡片中切换 Agent、模型、思考和权限。" },
+      { icon: "🌿", title: "任务分支", description: "使用 New Group 或 Fork Group 并行处理工作。" },
+      { icon: "🔄", title: "安全恢复", description: "任务、进度与服务状态会持久保存并恢复。" },
+    ];
   }
-  return language === "zh"
-    ? [
-        { icon: "💬", title: "飞书直接对话", description: "私聊、群聊和话题分别维护自己的任务上下文。" },
-        { icon: "🤖", title: "连接本地 Agent", description: "目前支持 Codex、TraeX 和兼容的编程 Agent。" },
-        { icon: "🌿", title: "新建与分支", description: "把新任务或对话分支放进独立群聊并行推进。" },
-        { icon: "📍", title: "进度始终可见", description: "通过思考卡片查看工具调用、文件变更和最终结果。" },
-      ]
-    : [
-        { icon: "💬", title: "Work from Lark", description: "Private chats, groups, and topics keep separate task context." },
-        { icon: "🤖", title: "Connect local Agents", description: "Use Codex, TraeX, and compatible coding Agents." },
-        { icon: "🌿", title: "Create and branch", description: "Move fresh tasks or conversation branches into new groups." },
-        { icon: "📍", title: "See every step", description: "Follow tools, file changes, and final results in progress cards." },
-      ];
+  return [
+    { icon: "💬", title: "飞书直接对话", description: "私聊、群聊和话题分别维护自己的任务上下文。" },
+    { icon: "🤖", title: "连接本地 Agent", description: "目前支持 Codex、TraeX 和兼容的编程 Agent。" },
+    { icon: "🌿", title: "新建与分支", description: "把新任务或对话分支放进独立群聊并行推进。" },
+    { icon: "📍", title: "进度始终可见", description: "通过思考卡片查看工具调用、文件变更和最终结果。" },
+  ];
 }
 
 const defaultDependencies: InitializationWelcomeDependencies = {

package/src/cli/Initializer.ts

@@ -39,6 +39,10 @@ export interface InitializationOptions {
   reset?: boolean;
 }
 
+export function shouldConfigureAgentsDuringInitialization(status: InitializationStatus): boolean {
+  return status === "created" || status === "reset";
+}
+
 export interface ConfiguredAgentOption {
   name: string;
   title: string;
@@ -171,6 +175,69 @@ export function writeDefaultAgent(configPath: string, agentName: string): boolea
   return true;
 }
 
+export function writeConfiguredAgentSelection(
+  configPath: string,
+  agentNames: string[],
+  defaultAgent: string,
+): boolean {
+  const selected = new Set(agentNames.map((name) => name.trim()).filter(Boolean));
+  if (selected.size === 0) {
+    throw new Error(cliText(
+      "At least one Agent must be configured.",
+      "必须至少配置一个 Agent。",
+    ));
+  }
+  if (!selected.has(defaultAgent)) {
+    throw new Error(cliText(
+      `Default Agent must be included in the configured Agents: ${defaultAgent}`,
+      `默认 Agent 必须包含在已配置 Agent 中：${defaultAgent}`,
+    ));
+  }
+
+  const original = fs.readFileSync(configPath, "utf8");
+  const document = parseConfigurationDocument(original, configPath);
+  if (!isMap(document.contents)) {
+    throw new Error(cliText(
+      `Configuration file must contain a YAML mapping: ${configPath}`,
+      `配置文件必须包含 YAML 映射：${configPath}`,
+    ));
+  }
+  const configuredAgents = document.contents.get("agents", true);
+  if (!isMap(configuredAgents)) {
+    throw new Error(cliText(
+      `Configuration file must contain an agents mapping: ${configPath}`,
+      `配置文件必须包含 agents 映射：${configPath}`,
+    ));
+  }
+  for (const agentName of selected) {
+    if (!configuredAgents.has(agentName)) {
+      throw new Error(cliText(
+        `Cannot configure an Agent that is not defined: ${agentName}`,
+        `不能配置尚未定义的 Agent：${agentName}`,
+      ));
+    }
+  }
+  for (const pair of [...configuredAgents.items]) {
+    const name = yamlMappingKey(pair.key);
+    if (name && !selected.has(name)) configuredAgents.delete(name);
+  }
+
+  const defaults = document.contents.get("defaults", true);
+  if (defaults !== undefined && !isMap(defaults)) {
+    throw new Error(cliText(
+      `Configuration defaults must contain a YAML mapping: ${configPath}`,
+      `配置文件的 defaults 必须是 YAML 映射：${configPath}`,
+    ));
+  }
+  if (isMap(defaults)) defaults.set("agent", defaultAgent);
+  else document.setIn(["defaults"], { agent: defaultAgent });
+
+  const updated = document.toString();
+  if (updated === original) return false;
+  writeFileAtomically(configPath, updated);
+  return true;
+}
+
 export function readFeishuCredentials(envPath: string, env: NodeJS.ProcessEnv = process.env): FeishuCredentialState {
   const fileValues = fs.existsSync(envPath) ? parseDotEnv(fs.readFileSync(envPath, "utf8")) : {};
   const appId = firstNonBlank(env.FEISHU_APP_ID, fileValues.FEISHU_APP_ID);

package/src/cli/help.ts

@@ -9,7 +9,7 @@ export function renderCliHelp(version: string, language: CliLanguage = cliLangua
   agentbot [选项] <命令>
 
 常用命令：
-  init                              检查并选择 Agent，初始化飞书应用和服务
+  init                              检查并配置 Agent，初始化飞书应用和服务
   init --reset                      重置并重新配置显式指定的 Profile
   console                           打开本地控制台
   server start                      在后台启动 Agent Bot
@@ -63,7 +63,7 @@ Usage:
   agentbot [options] <command>
 
 Common commands:
-  init                              Check and select an Agent; initialize the Lark app and service
+  init                              Check and configure Agents; 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

package/src/cli.ts

@@ -18,7 +18,8 @@ import {
   readConfiguredAgentSelection,
   readFeishuCredentials,
   shouldCreateFeishuApp,
-  writeDefaultAgent,
+  shouldConfigureAgentsDuringInitialization,
+  writeConfiguredAgentSelection,
   writeFeishuCredentials,
   type InitializationResult,
   type InitializationStatus,
@@ -49,6 +50,7 @@ import {
 } from "./cli/AgentPrerequisites.js";
 import {
   parseMaintenanceSelection,
+  resolveAgentConfigurationChoices,
   resolveDefaultAgentChoice,
   selectableDefaultAgents,
   type SelectableDefaultAgent,
@@ -143,6 +145,7 @@ type FeishuInitializationStatus = "created" | "existing" | "skipped";
 
 interface InitCommandResult extends InitializationResult {
   agents: InitializedAgent[];
+  configuredAgents: string[];
   defaultAgent: {
     name: string;
     status: "selected" | "existing";
@@ -158,6 +161,7 @@ interface InitCommandResult extends InitializationResult {
 }
 
 interface InitializedAgent extends SupportedAgentInspection {
+  configured?: boolean;
   assistance?: {
     status: "completed" | "skipped" | "unavailable" | "failed";
     error?: string;
@@ -181,15 +185,26 @@ 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);
+    const inspectedAgents = await initializeSupportedAgents(options.json);
+    const defaultAgent = await configureAgentsAndDefault(
+      paths.config.path,
+      inspectedAgents,
+      options.json,
+      shouldConfigureAgentsDuringInitialization(paths.config.status),
+    );
+    const configuredAgents = readConfiguredAgentSelection(paths.config.path).agents.map((agent) => agent.name);
+    const configuredAgentNames = new Set(configuredAgents);
+    const agents = inspectedAgents.map((agent) => ({
+      ...agent,
+      configured: configuredAgentNames.has(agent.id),
+    }));
     initializationLock ??= acquireInitializationLock(paths.home.path);
     cleanupFeishuCredentialTemporaryFiles(paths.env.path);
     const feishu = await initializeFeishu(
       paths,
       options,
     );
-    initialized = { ...paths, agents, defaultAgent, feishu };
+    initialized = { ...paths, agents, configuredAgents, defaultAgent, feishu };
   } finally {
     initializationLock?.release();
   }
@@ -211,7 +226,6 @@ async function initCommand(
     try {
       welcome = await sendInitializationWelcome({
         configPath,
-        language: cliLanguage,
         version,
         previousVersion: previousInitialization?.version,
         kind: welcomeKind,
@@ -324,49 +338,81 @@ async function initializeSupportedAgents(json: boolean): Promise<InitializedAgen
   return initialized;
 }
 
-async function selectDefaultAgent(
+async function configureAgentsAndDefault(
   configPath: string,
   inspections: InitializedAgent[],
   json: boolean,
+  configureAgents: 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)) {
+  const configuredDefaultIsValid = Boolean(
+    configured.defaultAgent
+    && configured.agents.some((agent) => agent.name === configured.defaultAgent),
+  );
+  if (!configureAgents) {
+    if (!configuredDefaultIsValid) {
       throw new Error(cliText(
-        "A default Agent is not configured. Run agentbot init in an interactive terminal and select one.",
-        "尚未配置默认 Agent。请在交互式终端中运行 agentbot init 并选择一个 Agent。",
+        "The existing Profile has no valid default Agent. Set defaults.agent in config.yaml, then run agentbot init again.",
+        "现有 Profile 没有有效的默认 Agent。请在 config.yaml 中设置 defaults.agent，然后重新运行 agentbot init。",
       ));
     }
     output.write(cliText(
-      `Default Agent: ${configured.defaultAgent} (kept because no interactive terminal is available)\n`,
-      `默认 Agent：${configured.defaultAgent}（当前没有交互式终端，已保留现有设置）\n`,
+      `Default Agent: ${configured.defaultAgent} (unchanged)\n`,
+      `默认 Agent：${configured.defaultAgent}（保持不变）\n`,
     ));
-    return { name: configured.defaultAgent, status: "existing" };
+    return { name: configured.defaultAgent!, status: "existing" };
   }
+
+  const choices = selectableDefaultAgents(configured.agents, inspections);
   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。",
+      "No installed supported Agent was detected. 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" };
+  let selectedAgents = choices;
+  if (process.stdin.isTTY && choices.length > 1) {
+    output.write(cliText("\nSelect Agents to configure:\n", "\n请选择要配置的 Agent：\n"));
+    for (const [index, choice] of choices.entries()) {
+      output.write(`  ${index + 1}. ${choice.name} - ${choice.title} (${choice.installedVersion})\n`);
+    }
+    const selectedIndexes = await promptForConfiguredAgents(choices);
+    selectedAgents = selectedIndexes.flatMap((index) => choices[index] ? [choices[index]!] : []);
+  }
+
+  const selectedNames = selectedAgents.map((agent) => agent.name);
+  output.write(cliText(
+    `Configured Agents: ${selectedNames.join(", ")}\n`,
+    `已配置 Agent：${selectedNames.join("、")}\n`,
+  ));
+
+  let selectedDefault = selectedAgents[0]!;
+  if (selectedAgents.length > 1) {
+    if (process.stdin.isTTY) {
+      output.write(cliText("\nSelect the default Agent:\n", "\n请选择默认 Agent：\n"));
+      for (const [index, choice] of selectedAgents.entries()) {
+        const current = choice.name === configured.defaultAgent
+          ? cliText(" [current]", " [当前]")
+          : "";
+        output.write(`  ${index + 1}. ${choice.name} - ${choice.title} (${choice.installedVersion})${current}\n`);
+      }
+      selectedDefault = selectedAgents[
+        await promptForDefaultAgent(selectedAgents, configured.defaultAgent)
+      ]!;
+    } else {
+      selectedDefault = selectedAgents.find((agent) => agent.name === configured.defaultAgent)
+        ?? selectedAgents[0]!;
+    }
+  }
+
+  const updated = writeConfiguredAgentSelection(configPath, selectedNames, selectedDefault.name);
+  output.write(cliText(
+    `Default Agent: ${selectedDefault.name}${process.stdin.isTTY ? "" : " (selected automatically)"}\n`,
+    `默认 Agent：${selectedDefault.name}${process.stdin.isTTY ? "" : "（已自动选择）"}\n`,
+  ));
+  return { name: selectedDefault.name, status: updated ? "selected" : "existing" };
 }
 
 function promptForAgentMaintenance(choiceCount: number): Promise<number[]> {
@@ -403,6 +449,40 @@ function promptForAgentMaintenance(choiceCount: number): Promise<number[]> {
   });
 }
 
+function promptForConfiguredAgents(choices: SelectableDefaultAgent[]): 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 numbers or Agent names separated by commas, type all, or press Enter for all: ",
+        "请输入 Agent 编号或标准名（多个用逗号分隔），输入 all 或直接回车选择全部：",
+      ), (answer) => {
+        const selection = resolveAgentConfigurationChoices(answer, choices);
+        if (selection) {
+          finish(selection);
+          return;
+        }
+        process.stderr.write(cliText(
+          `Select at least one Agent using numbers from 1 to ${choices.length} or standard names.\n`,
+          `请使用 1 到 ${choices.length} 之间的编号或标准名，至少选择一个 Agent。\n`,
+        ));
+        ask();
+      });
+    };
+    listenForPromptCancellation(readline, () => {
+      settled = true;
+      reject(new Error(cliText("Initialization was cancelled.", "初始化已取消。")));
+    }, () => settled);
+    ask();
+  });
+}
+
 function promptForDefaultAgent(
   choices: SelectableDefaultAgent[],
   currentAgent?: string,
@@ -1054,6 +1134,7 @@ function printInitializationResult(result: Omit<InitCommandResult, "server" | "w
     "\nAgent Bot initialization completed.\n",
     "\nAgent Bot 初始化完成。\n",
   ));
+  process.stdout.write(`${cliText("Configured Agents: ", "已配置 Agent：")}${result.configuredAgents.join(", ")}\n`);
   process.stdout.write(`${cliText("Default Agent: ", "默认 Agent：")}${result.defaultAgent.name}\n`);
   if (result.feishu.status === "created") {
     process.stdout.write(cliText(