@keyou007/agent-bot 0.1.3 → 0.1.5

package/docs/technical-reference.md

@@ -35,6 +35,8 @@ The default user-data root is `~/.agent-bot`. `AGENT_BOT_HOME` replaces that roo
 
 The CLI also supports explicit directory-based profiles. Without `--profile`, commands use the main profile and the normal environment-based path rules. `--profile <directory>` pins both `AGENT_BOT_HOME` and `AGENT_BOT_CONFIG` for the command and every spawned supervisor or worker, with the configuration fixed at `<directory>/config.yaml`. It also clears inherited Feishu credential variables before loading the selected profile's `.env`, which prevents a secondary service launched from inside the primary Agent Bot process tree from accidentally reusing the primary bot. It cannot be combined with `--config`. Alternative profiles must be selected explicitly on every command; Agent Bot does not maintain a named-profile registry.
 
+All CLI interface text is English regardless of system locale. System-generated restart reasons remain Chinese because they are rendered in Chinese Lark status cards; an explicit `--reason` is preserved verbatim. `agent-bot server status` reports the running worker's Lark App ID as `feishuAppId` in JSON; when the server is stopped or predates that health field, the CLI falls back to the selected profile's configured App ID.
+
 | Default path                         | Contents                           |
 | ------------------------------------ | ---------------------------------- |
 | `~/.agent-bot/config.yaml`           | Main YAML configuration            |
@@ -78,6 +80,8 @@ Missing app configuration is handled in two stages:
 
 The generated authorization links do not contain the app secret.
 
+`agent-bot --profile <directory> init --reset` fully resets an explicitly selected Profile. The Profile server must be stopped first. The command moves the active `config.yaml`, `.env`, `data/`, and `logs/` into a unique timestamped directory under `<profile>/.reset-backups/`, creates clean replacements from the packaged templates, and proceeds through normal initialization. Existing reset backups and unrelated files are retained. Because backups can contain old app secrets and conversation data, protect the Profile directory accordingly. The remote Feishu app is not deleted. `--reset --skip-feishu` creates a clean Console-only Profile, while `--reset` and `--reconfigure-feishu` cannot be combined.
+
 After Feishu initialization succeeds, the CLI releases the initialization lock and starts the detached supervisor through the same readiness path as `agent-bot 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. `--skip-feishu` skips automatic server startup, and `--json` includes the resulting `server.status` without adding non-JSON output.
 
 ## Feishu App Requirements
@@ -138,7 +142,7 @@ logging:
   path: "./logs/agent-bot.log"
 ```
 
-`agent-bot server start` requires both Feishu credentials. The worker starts the SDK's persistent connection without inspecting SDK logs or private connection state, then sends startup status cards as an outbound readiness check. It normally targets known private chats and recently active groups. If the database has no known chat yet, it sends the card to `feishu.userOpenId` using an `open_id` private message. When notification targets exist, at least one card must be delivered before the server reports ready; individual target failures remain isolated. If neither a known chat nor `feishu.userOpenId` is available, startup continues without the outbound check. Missing credentials still fail startup with an initialization hint. `agent-bot console` is the explicit local-only path and does not require Feishu credentials.
+`agent-bot server start` requires both Feishu credentials. The worker starts the SDK's persistent connection without inspecting SDK logs or private connection state, then sends startup status cards as an outbound readiness check. Each startup card includes the Agent Bot version read from the installed package metadata. It normally targets known private chats and recently active groups. If the database has no known chat yet, it sends the card to `feishu.userOpenId` using an `open_id` private message. When notification targets exist, at least one card must be delivered before the server reports ready; individual target failures remain isolated. If neither a known chat nor `feishu.userOpenId` is available, startup continues without the outbound check. Missing credentials still fail startup with an initialization hint. `agent-bot console` is the explicit local-only path and does not require Feishu credentials.
 
 At least one agent must be configured. `defaults.agent` must name a configured agent.
 

package/docs/technical-reference.zh.md

@@ -35,6 +35,8 @@ Agent Bot 是基于 Node.js 22+、ESM 和 TypeScript 的应用，主要组件如
 
 CLI 还支持显式指定目录的 Profile。不使用 `--profile` 时，命令使用主 Profile 以及原有的环境变量路径规则。`--profile <目录>` 会为当前命令及其启动的 Supervisor、Worker 固定 `AGENT_BOT_HOME` 和 `AGENT_BOT_CONFIG`，配置文件固定为 `<目录>/config.yaml`。它还会先清除继承的飞书凭据环境变量，再加载所选 Profile 的 `.env`，避免从主 Agent Bot 进程树中启动辅助实例时误用主机器人的凭据。`--profile` 不能和 `--config` 同时使用。其他 Profile 必须在每次命令中显式选择；Agent Bot 不维护按名称注册的 Profile。
 
+CLI 界面文本不受系统语言影响，统一使用英文。系统生成的重启原因仍使用中文，因为它会显示在中文 Lark 状态卡中；显式传入的 `--reason` 保持原样。`agent-bot server status` 会报告运行中 Worker 的 Lark App ID，JSON 字段名为 `feishuAppId`；服务停止或旧版健康协议尚未提供该字段时，CLI 会回退到当前 Profile 配置的 App ID。
+
 | 默认路径                             | 内容                 |
 | ------------------------------------ | -------------------- |
 | `~/.agent-bot/config.yaml`           | YAML 主配置          |
@@ -78,6 +80,8 @@ CLI 还支持显式指定目录的 Profile。不使用 `--profile` 时，命令
 
 生成的授权链接不包含 App Secret。
 
+`agent-bot --profile <目录> init --reset` 会完整重置显式指定的 Profile。执行前必须先停止该 Profile 的 Server。命令会把当前 `config.yaml`、`.env`、`data/` 和 `logs/` 移入 `<profile>/.reset-backups/` 下唯一的时间戳目录，从随包模板创建干净的新文件和目录，再继续正常初始化。已有重置备份及其他无关文件会保留。备份中可能含有旧 App Secret 和会话数据，应妥善保护 Profile 目录。远端旧飞书应用不会被删除。`--reset --skip-feishu` 可创建干净的 Console-only Profile，`--reset` 不能与 `--reconfigure-feishu` 同时使用。
+
 飞书初始化成功后，CLI 会先释放初始化锁，再通过与 `agent-bot server start` 相同的就绪检查流程启动后台 Supervisor，并等待最多 45 秒，直到 Worker 连接飞书并进入就绪状态。如果当前 Profile 的服务已经运行，不会创建第二个 Supervisor。`--skip-feishu` 会跳过自动启动；`--json` 会把结果写入 `server.status`，不会混入非 JSON 文本。
 
 ## 飞书应用要求
@@ -138,7 +142,7 @@ logging:
   path: "./logs/agent-bot.log"
 ```
 
-`agent-bot server start` 要求同时配置飞书 `appId` 和 `appSecret`。Worker 启动 SDK 长连接时不读取 SDK 日志或私有连接状态，随后通过发送启动状态卡片检查出站能力。通知通常发往已知私聊和最近活跃的群聊；数据库里尚无已知会话时，改用 `feishu.userOpenId`，按 `open_id` 私聊发送。存在通知目标时，至少一张卡片发送成功后 Server 才报告就绪，单个目标发送失败仍相互隔离。如果既没有已知会话，也没有 `feishu.userOpenId`，启动会跳过出站检查并继续。缺少凭据时仍会启动失败并提示先初始化。`agent-bot console` 是明确的纯本地入口，不需要飞书凭据。
+`agent-bot server start` 要求同时配置飞书 `appId` 和 `appSecret`。Worker 启动 SDK 长连接时不读取 SDK 日志或私有连接状态，随后通过发送启动状态卡片检查出站能力。每张启动卡片都会显示从已安装包元数据读取的 Agent Bot 版本。通知通常发往已知私聊和最近活跃的群聊；数据库里尚无已知会话时，改用 `feishu.userOpenId`，按 `open_id` 私聊发送。存在通知目标时，至少一张卡片发送成功后 Server 才报告就绪，单个目标发送失败仍相互隔离。如果既没有已知会话，也没有 `feishu.userOpenId`，启动会跳过出站检查并继续。缺少凭据时仍会启动失败并提示先初始化。`agent-bot console` 是明确的纯本地入口，不需要飞书凭据。
 
 必须至少配置一个 Agent，`defaults.agent` 必须指向已配置的 Agent。
 

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@keyou007/agent-bot",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@keyou007/agent-bot",
-      "version": "0.1.3",
+      "version": "0.1.5",
       "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.3",
+  "version": "0.1.5",
   "type": "module",
   "description": "Using Codex in Lark/Feishu feels just like using native Codex.",
   "license": "GPL-3.0-only",

package/skills/agent-bot/SKILL.md

@@ -54,6 +54,8 @@ When running `init` on the user's behalf, relay every exact authorization or inc
 
 Existing complete Feishu credentials are preserved but still audited and repaired when needed. Missing or incomplete credentials mean app creation did not complete, so a later `init` starts a new registration instead of resuming the previous device code. Once both credentials are durably saved, an interrupted permission audit resumes against the same remote app. `init` also holds a local lock to prevent concurrent registrations. Use `agent-bot init --skip-feishu` only for console-only initialization because it skips both registration and configuration auditing. Use `agent-bot init --reconfigure-feishu` only when the user explicitly wants to replace existing complete credentials. The command respects `AGENT_BOT_HOME`, `AGENT_BOT_CONFIG`, and `--config <path>`. Use `agent-bot init --json` when structured final output helps.
 
+Use `agent-bot --profile <directory> init --reset` only when the user explicitly requests a full Profile reset. `--profile` is mandatory even for the primary Profile, and its server must be stopped first. The command moves the active `config.yaml`, `.env`, `data/`, and `logs/` into a new timestamped `.reset-backups` directory, retains all older backups and unrelated files, then initializes a clean Profile. Relay the reported backup path. Do not delete `.reset-backups`; it may contain old credentials and task data. `--reset --skip-feishu` is valid for a clean Console-only Profile, but `--reset` cannot be combined with `--reconfigure-feishu`.
+
 For an isolated secondary bot, pass its profile directory explicitly on every command:
 
 ```powershell
@@ -74,7 +76,7 @@ agent-bot server status
 agent-bot task list
 ```
 
-`agent-bot --help` uses Chinese when the system locale is Chinese and English otherwise.
+All Agent Bot CLI interface text is English regardless of system locale. `agent-bot server status` also reports the running profile's Lark App ID; with `--json`, read it from `feishuAppId`.
 
 Add `--json` to status and list commands when machine-readable output helps. If `agent-bot` is unavailable, report that the CLI is not installed or linked instead of guessing process state.
 

package/src/cli/FeishuAppConfiguration.ts

@@ -178,8 +178,8 @@ export async function ensureFeishuAppConfiguration(
     }
   }
 
-  const detail = lastError instanceof Error ? ` 最后一次检查失败：${lastError.message}` : "";
-  throw new Error(`等待飞书核心权限和消息事件配置生效超时，请重新运行 agent-bot init。${detail}`);
+  const detail = lastError instanceof Error ? ` Last check failed: ${lastError.message}` : "";
+  throw new Error(`Timed out waiting for the core Lark scopes and message event. Run agent-bot init again.${detail}`);
 }
 
 async function requestMissingFeishuConfiguration(
@@ -248,14 +248,14 @@ async function readFeishuAppConfiguration(
       `${FEISHU_OPEN_BASE_URL}${APPLICATION_PATH_PREFIX}/${appId}?lang=zh_cn`,
       { headers },
       signal,
-      "查询飞书应用配置",
+      "Read Lark app configuration",
     ),
     fetchJson(
       fetchImpl,
       `${FEISHU_OPEN_BASE_URL}${APPLICATION_PATH_PREFIX}/${appId}/app_versions?lang=zh_cn&page_size=2`,
       { headers },
       signal,
-      "查询飞书应用版本",
+      "Read Lark app versions",
     ),
   ]);
 
@@ -303,10 +303,10 @@ async function getTenantAccessToken(
       }),
     },
     signal,
-    "获取飞书 tenant_access_token",
+    "Get the Lark tenant_access_token",
   );
   const token = readString(payload, "tenant_access_token");
-  if (!token) throw new Error("飞书 tenant_access_token 响应缺少访问凭证。");
+  if (!token) throw new Error("The Lark tenant_access_token response is missing the access token.");
   return token;
 }
 
@@ -327,12 +327,12 @@ async function fetchJson(
     const response = await fetchImpl(url, { ...init, signal: controller.signal });
     const payload = (await response.json().catch(() => undefined)) as unknown;
     if (!isJsonObject(payload)) {
-      throw new Error(`${operation}返回了无法解析的响应（HTTP ${response.status}）。`);
+      throw new Error(`${operation} returned an invalid response (HTTP ${response.status}).`);
     }
     const code = readNumber(payload, "code");
     if (!response.ok || code !== 0) {
       throw new FeishuConfigurationApiError(
-        `${operation}失败：${readString(payload, "msg") || response.statusText || `HTTP ${response.status}`}`,
+        `${operation} failed: ${readString(payload, "msg") || response.statusText || `HTTP ${response.status}`}`,
         code,
         response.status,
       );
@@ -340,7 +340,7 @@ async function fetchJson(
     return payload;
   } catch (error) {
     if (parentSignal?.aborted) throw abortError(parentSignal);
-    if (controller.signal.aborted) throw new Error(`${operation}请求超时。`);
+    if (controller.signal.aborted) throw new Error(`${operation} timed out.`);
     throw error;
   } finally {
     clearTimeout(timeout);
@@ -442,7 +442,7 @@ function positiveInteger(value: number | undefined): number | undefined {
 }
 
 function abortError(signal: AbortSignal): Error {
-  return signal.reason instanceof Error ? signal.reason : new Error("飞书应用配置已取消。");
+  return signal.reason instanceof Error ? signal.reason : new Error("Lark app configuration was cancelled.");
 }
 
 function delay(milliseconds: number): Promise<void> {

package/src/cli/FeishuAppRegistration.ts

@@ -41,12 +41,12 @@ export async function registerFeishuApp(options: FeishuAppRegistrationOptions =
     },
     options.signal,
   );
-  throwRegistrationError(begin, "无法发起飞书应用创建");
+  throwRegistrationError(begin, "Could not start Lark app creation");
 
   const deviceCode = readString(begin, "device_code");
   const userCode = readString(begin, "user_code");
   if (!deviceCode || !userCode) {
-    throw new Error("飞书应用创建响应缺少 device_code 或 user_code。");
+    throw new Error("The Lark app creation response is missing device_code or user_code.");
   }
 
   const expiresIn =
@@ -113,16 +113,16 @@ export async function registerFeishuApp(options: FeishuAppRegistrationOptions =
         intervalSeconds = Math.min(intervalSeconds + 5, MAX_POLL_INTERVAL_SECONDS);
         continue;
       case "access_denied":
-        throw new Error("你已取消飞书应用创建。");
+        throw new Error("Lark app creation was cancelled.");
       case "expired_token":
       case "invalid_grant":
-        throw new Error("飞书应用创建链接已过期，请重新运行 agent-bot init。");
+        throw new Error("The Lark app creation link expired. Run agent-bot init again.");
       default:
-        throwRegistrationError(payload, "飞书应用创建失败");
+        throwRegistrationError(payload, "Lark app creation failed");
     }
   }
 
-  throw new Error("等待飞书应用创建超时，请重新运行 agent-bot init。");
+  throw new Error("Timed out waiting for Lark app creation. Run agent-bot init again.");
 }
 
 function buildVerificationUrl(userCode: string): string {
@@ -152,7 +152,7 @@ async function postRegistration(
     });
     const payload = (await response.json().catch(() => undefined)) as unknown;
     if (!isRecord(payload)) {
-      throw new Error(`飞书应用注册接口返回了无法解析的响应（HTTP ${response.status}）。`);
+      throw new Error(`The Lark app registration endpoint returned an invalid response (HTTP ${response.status}).`);
     }
     return payload;
   } finally {
@@ -165,7 +165,7 @@ function throwRegistrationError(payload: RegistrationPayload, prefix: string): v
   const code = readString(payload, "error");
   if (!code) return;
   const description = readString(payload, "error_description") || code;
-  throw new Error(`${prefix}：${description}`);
+  throw new Error(`${prefix}: ${description}`);
 }
 
 function readString(value: RegistrationPayload, key: string): string {
@@ -189,7 +189,7 @@ function isRecord(value: unknown): value is RegistrationPayload {
 }
 
 function abortError(signal: AbortSignal): Error {
-  return signal.reason instanceof Error ? signal.reason : new Error("飞书应用创建已取消。");
+  return signal.reason instanceof Error ? signal.reason : new Error("Lark app creation was cancelled.");
 }
 
 function delay(milliseconds: number): Promise<void> {

package/src/cli/Initializer.ts

@@ -11,7 +11,7 @@ import {
   resolveUserPath,
 } from "../config/paths.js";
 
-export type InitializationStatus = "created" | "existing";
+export type InitializationStatus = "created" | "existing" | "reset";
 
 export interface InitializedPath {
   path: string;
@@ -24,6 +24,9 @@ export interface InitializationResult {
   env: InitializedPath;
   data: InitializedPath;
   logs: InitializedPath;
+  reset?: {
+    backupPath: string;
+  };
 }
 
 export interface InitializationOptions {
@@ -31,6 +34,7 @@ export interface InitializationOptions {
   configPath?: string;
   configTemplatePath?: string;
   envTemplatePath?: string;
+  reset?: boolean;
 }
 
 export type FeishuCredentialStatus = "configured" | "missing" | "incomplete";
@@ -73,6 +77,9 @@ export function initializeAgentBot(options: InitializationOptions = {}): Initial
 
   const home = ensureDirectory(homePath);
   fs.mkdirSync(configDirectory, { recursive: true });
+  const reset = options.reset
+    ? resetProfileContents(homePath, configPath, envPath, configDirectory)
+    : undefined;
 
   const config = copyIfMissing(configTemplatePath, configPath);
   const envFile = copyIfMissing(envTemplatePath, envPath);
@@ -80,7 +87,14 @@ export function initializeAgentBot(options: InitializationOptions = {}): Initial
   const data = ensureDirectory(path.join(configDirectory, "data"));
   const logs = ensureDirectory(path.join(configDirectory, "logs"));
 
-  return { home, config, env: envFile, data, logs };
+  return {
+    home,
+    config: withResetStatus(config, reset?.movedNames.has("config.yaml") ?? false),
+    env: withResetStatus(envFile, reset?.movedNames.has(".env") ?? false),
+    data: withResetStatus(data, reset?.movedNames.has("data") ?? false),
+    logs: withResetStatus(logs, reset?.movedNames.has("logs") ?? false),
+    ...(reset ? { reset: { backupPath: reset.backupPath } } : {}),
+  };
 }
 
 export function readFeishuCredentials(envPath: string, env: NodeJS.ProcessEnv = process.env): FeishuCredentialState {
@@ -122,7 +136,7 @@ export function writeFeishuCredentials(envPath: string, credentials: FeishuCrede
       || persisted.appSecret !== credentials.appSecret
       || persisted.userOpenId !== credentials.userOpenId
     ) {
-      throw new Error("飞书凭据写入后校验失败。");
+      throw new Error("Lark credential verification failed after writing the environment file.");
     }
   } finally {
     if (temporaryFile !== undefined) fs.closeSync(temporaryFile);
@@ -169,13 +183,13 @@ export function acquireInitializationLock(lockDirectory: string): Initialization
       if (created) fs.rmSync(lockPath, { force: true });
       if (!isFileExistsError(error)) throw error;
       if (!isStaleInitializationLock(lockPath)) {
-        throw new Error(`另一个 agent-bot init 正在运行（锁文件：${lockPath}）。`);
+        throw new Error(`Another agent-bot init process is running (lock file: ${lockPath}).`);
       }
       fs.rmSync(lockPath, { force: true });
     }
   }
 
-  throw new Error(`无法获取初始化锁：${lockPath}`);
+  throw new Error(`Could not acquire the initialization lock: ${lockPath}`);
 }
 
 export function cleanupFeishuCredentialTemporaryFiles(envPath: string): number {
@@ -217,6 +231,62 @@ function copyIfMissing(sourcePath: string, targetPath: string): InitializedPath
   }
 }
 
+function resetProfileContents(
+  homePath: string,
+  configPath: string,
+  envPath: string,
+  configDirectory: string,
+): { backupPath: string; movedNames: Set<string> } | undefined {
+  const resolvedHome = path.resolve(homePath);
+  if (
+    path.resolve(configDirectory) !== resolvedHome
+    || path.dirname(path.resolve(configPath)) !== resolvedHome
+    || path.dirname(path.resolve(envPath)) !== resolvedHome
+  ) {
+    throw new Error("--reset only supports a profile-owned config.yaml and .env.");
+  }
+  const targets = [
+    { name: "config.yaml", sourcePath: configPath },
+    { name: ".env", sourcePath: envPath },
+    { name: "data", sourcePath: path.join(configDirectory, "data") },
+    { name: "logs", sourcePath: path.join(configDirectory, "logs") },
+  ].filter((target) => fs.existsSync(target.sourcePath));
+  if (targets.length === 0) return undefined;
+
+  const timestamp = new Date().toISOString().replaceAll(":", "-").replaceAll(".", "-");
+  const backupPath = path.join(homePath, ".reset-backups", `${timestamp}-${randomUUID()}`);
+  fs.mkdirSync(backupPath, { recursive: true, mode: 0o700 });
+  const moved: Array<{ sourcePath: string; backupPath: string }> = [];
+  try {
+    for (const target of targets) {
+      const targetBackupPath = path.join(backupPath, target.name);
+      fs.renameSync(target.sourcePath, targetBackupPath);
+      moved.push({ sourcePath: target.sourcePath, backupPath: targetBackupPath });
+    }
+  } catch (error) {
+    for (const entry of moved.reverse()) {
+      if (!fs.existsSync(entry.sourcePath) && fs.existsSync(entry.backupPath)) {
+        fs.renameSync(entry.backupPath, entry.sourcePath);
+      }
+    }
+    try {
+      fs.rmdirSync(backupPath);
+      fs.rmdirSync(path.dirname(backupPath));
+    } catch {
+      // Keep a non-empty backup directory when rollback itself cannot fully restore it.
+    }
+    throw error;
+  }
+  return {
+    backupPath,
+    movedNames: new Set(targets.map((target) => target.name)),
+  };
+}
+
+function withResetStatus(value: InitializedPath, reset: boolean): InitializedPath {
+  return reset ? { ...value, status: "reset" } : value;
+}
+
 function upsertDotEnvValue(contents: string, key: string, value: string): string {
   const newline = contents.includes("\r\n") ? "\r\n" : "\n";
   const lines = contents.length > 0 ? contents.split(/\r?\n/) : [];
@@ -234,7 +304,7 @@ function upsertDotEnvValue(contents: string, key: string, value: string): string
 
 function assertDotEnvValue(key: string, value: string): void {
   if (!value.trim() || /[\r\n]/.test(value)) {
-    throw new Error(`${key} 不是有效的单行环境变量值。`);
+    throw new Error(`${key} is not a valid single-line environment variable value.`);
   }
 }
 

package/src/cli/LocalControlClient.ts

@@ -17,7 +17,7 @@ export async function sendControlRequest(
       socket.destroy();
       operation();
     };
-    const timer = setTimeout(() => finish(() => reject(new Error("连接 Agent Bot 控制端点超时。"))), timeoutMs);
+    const timer = setTimeout(() => finish(() => reject(new Error("Timed out connecting to the Agent Bot control endpoint."))), timeoutMs);
     socket.setEncoding("utf8");
     socket.once("connect", () => socket.write(`${JSON.stringify(request)}\n`));
     socket.on("data", (chunk: string) => {
@@ -33,7 +33,7 @@ export async function sendControlRequest(
     });
     socket.once("error", (error) => finish(() => reject(error)));
     socket.once("end", () => {
-      if (!settled) finish(() => reject(new Error("Agent Bot 控制端点未返回结果。")));
+      if (!settled) finish(() => reject(new Error("The Agent Bot control endpoint returned no response.")));
     });
   });
 }

package/src/cli/LocalControlServer.ts

@@ -61,7 +61,7 @@ export class LocalControlServer {
 function parseRequest(line: string): ControlRequest {
   const value = JSON.parse(line) as unknown;
   if (!value || typeof value !== "object" || !("action" in value) || typeof value.action !== "string") {
-    throw new Error("无效的本地控制请求。");
+    throw new Error("Invalid local control request.");
   }
   return value as ControlRequest;
 }

package/src/cli/ServerStarter.ts

@@ -56,7 +56,7 @@ export async function startServer(
   if (await dependencies.isReachable(endpoint)) {
     const running = await dependencies.waitUntilRunning(endpoint, SERVER_START_TIMEOUT_MS);
     if (!running) {
-      throw new Error("agent-bot server 已启动，但未能连接飞书机器人。请检查日志。");
+      throw new Error("The Agent Bot server started but could not connect to Lark. Check the logs.");
     }
     return { status: "started" };
   }
@@ -64,7 +64,7 @@ export async function startServer(
   dependencies.spawnSupervisor(config);
   const running = await dependencies.waitUntilRunning(endpoint, SERVER_START_TIMEOUT_MS);
   if (!running) {
-    throw new Error("已启动 Supervisor，但 server 未在 45 秒内连接飞书机器人。请检查日志。");
+    throw new Error("The Supervisor started, but the server did not connect to Lark within 45 seconds. Check the logs.");
   }
   return { status: "started" };
 }
@@ -85,7 +85,7 @@ const defaultDependencies: ServerStarterDependencies = {
       detached: true,
       windowsHide: true,
       stdio: "ignore",
-      env: { ...process.env, AGENT_BOT_RESTART_REASON: "通过 agent-bot CLI 启动" },
+      env: { ...process.env, AGENT_BOT_RESTART_REASON: "通过 Agent Bot CLI 启动" },
     });
     child.unref();
   },

package/src/cli/SkillRegistry.ts

@@ -65,7 +65,7 @@ export class SkillRegistry {
     this.assertValidSource();
     const existing = fs.existsSync(this.targetPath);
     if (existing && this.readMarker()?.managedBy !== "agent-bot") {
-      throw new Error(`目标目录已存在且不由 Agent Bot 管理：${this.targetPath}`);
+      throw new Error(`The target directory exists and is not managed by Agent Bot: ${this.targetPath}`);
     }
 
     const before = existing ? this.status() : undefined;
@@ -93,7 +93,7 @@ export class SkillRegistry {
   uninstall(): boolean {
     if (!fs.existsSync(this.targetPath)) return false;
     if (this.readMarker()?.managedBy !== "agent-bot") {
-      throw new Error(`拒绝删除不由 Agent Bot 管理的目录：${this.targetPath}`);
+      throw new Error(`Refusing to remove a directory that is not managed by Agent Bot: ${this.targetPath}`);
     }
     this.removeManagedTarget();
     return true;
@@ -101,13 +101,13 @@ export class SkillRegistry {
 
   private assertValidSource(): void {
     if (!fs.existsSync(path.join(this.sourcePath, "SKILL.md"))) {
-      throw new Error(`找不到内置 Agent Bot Skill：${this.sourcePath}`);
+      throw new Error(`The built-in Agent Bot Skill was not found: ${this.sourcePath}`);
     }
   }
 
   private assertSafeTarget(): void {
     if (path.dirname(this.targetPath) !== this.skillsRoot || path.basename(this.targetPath) !== SKILL_NAME) {
-      throw new Error(`不安全的 Skill 目标路径：${this.targetPath}`);
+      throw new Error(`Unsafe Skill target path: ${this.targetPath}`);
     }
   }
 

package/src/cli/help.ts

@@ -1,63 +1,4 @@
-export type CliLanguage = "en" | "zh";
-
-export function resolveCliLanguage(
-  env: NodeJS.ProcessEnv = process.env,
-  systemLocale = Intl.DateTimeFormat().resolvedOptions().locale,
-): CliLanguage {
-  const configuredLocale = [
-    env.LC_ALL,
-    env.LC_MESSAGES,
-    env.LANGUAGE,
-    env.LANG,
-  ].find((value) => value?.trim());
-  return isChineseLocale(configuredLocale ?? systemLocale) ? "zh" : "en";
-}
-
-export function renderCliHelp(version: string, language = resolveCliLanguage()): string {
-  return language === "zh" ? renderChineseHelp(version) : renderEnglishHelp(version);
-}
-
-function renderChineseHelp(version: string): string {
-  return `Agent Bot ${version}
-通过飞书/Lark 使用本机 Codex 与 ACP Agent。
-
-用法：
-  agent-bot [选项] <命令>
-
-常用命令：
-  init                              初始化配置和飞书应用，并启动服务
-  console                           打开本地 Console
-  server start                      在后台启动 Agent Bot
-  server status                     查看服务和安全重启状态
-  server restart                    安排安全重启
-  server stop                       停止 Agent Bot
-  task list                         列出任务
-  task status <task>                查看任务状态
-  task chat <task>                  查看任务绑定的飞书会话
-  task prompt <task> <prompt>       向指定任务发送 Prompt
-  task stop <task>                  停止指定任务
-  task title <task> <title>         修改任务标题
-  skills status                     查看内置 Skill 状态
-  skills install                    安装内置 Skill
-
-选项：
-  --profile <directory>             使用指定目录中的独立 Profile
-  --config <path>                   使用指定配置文件
-  --json                            在支持的命令中输出 JSON
-  -h, --help                        显示帮助
-  -v, --version                     显示版本
-
-示例：
-  agent-bot init
-  agent-bot --profile ~/.agent-bot-rescue init
-  agent-bot server start
-  agent-bot server status
-  agent-bot task list
-  agent-bot server restart --reason "升级 Agent Bot"
-`;
-}
-
-function renderEnglishHelp(version: string): string {
+export function renderCliHelp(version: string): string {
   return `Agent Bot ${version}
 Use local Codex and ACP agents from Lark/Feishu.
 
@@ -66,9 +7,10 @@ Usage:
 
 Common commands:
   init                              Initialize the Lark app and start the 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 server and safe-restart status
+  server status                     Show the server, Lark App ID, and safe-restart status
   server restart                    Schedule a safe restart
   server stop                       Stop Agent Bot
   task list                         List tasks
@@ -87,8 +29,14 @@ Options:
   -h, --help                        Show help
   -v, --version                     Show version
 
+Init options:
+  --reset                           Back up and reset the selected explicit profile
+  --skip-feishu                     Initialize for Console only
+  --reconfigure-feishu              Replace only the existing Lark credentials
+
 Examples:
   agent-bot init
+  agent-bot --profile ~/.agent-bot init --reset
   agent-bot --profile ~/.agent-bot-rescue init
   agent-bot server start
   agent-bot server status
@@ -96,8 +44,3 @@ Examples:
   agent-bot server restart --reason "Update Agent Bot"
 `;
 }
-
-function isChineseLocale(value: string): boolean {
-  const locale = value.trim().split(":")[0]?.split(/[.@]/)[0]?.replaceAll("_", "-").toLowerCase();
-  return locale === "zh" || Boolean(locale?.startsWith("zh-"));
-}

package/src/cli/initOptions.ts

@@ -0,0 +1,33 @@
+export interface InitCommandOptions {
+  json: boolean;
+  skipFeishu: boolean;
+  reconfigureFeishu: boolean;
+  reset: boolean;
+}
+
+export function parseInitCommandOptions(
+  input: string[],
+  explicitProfile: boolean,
+): InitCommandOptions {
+  const supported = new Set(["--json", "--skip-feishu", "--reconfigure-feishu", "--reset"]);
+  const unsupported = input.filter((value) => !supported.has(value));
+  if (unsupported.length > 0) {
+    throw new Error(`Unsupported init options: ${unsupported.join(" ")}`);
+  }
+  const options = {
+    json: input.includes("--json"),
+    skipFeishu: input.includes("--skip-feishu"),
+    reconfigureFeishu: input.includes("--reconfigure-feishu"),
+    reset: input.includes("--reset"),
+  };
+  if (options.skipFeishu && options.reconfigureFeishu) {
+    throw new Error("--skip-feishu and --reconfigure-feishu cannot be used together.");
+  }
+  if (options.reset && !explicitProfile) {
+    throw new Error("--reset requires an explicit --profile <directory>.");
+  }
+  if (options.reset && options.reconfigureFeishu) {
+    throw new Error("--reset cannot be combined with --reconfigure-feishu because reset already replaces Lark credentials.");
+  }
+  return options;
+}

package/src/cli/packageVersion.ts

@@ -8,7 +8,7 @@ export function readPackageVersion(
     fs.readFileSync(fileURLToPath(packageJsonUrl), "utf8"),
   ) as { version?: unknown };
   if (typeof metadata.version !== "string" || !metadata.version.trim()) {
-    throw new Error("package.json 中缺少有效的 version。");
+    throw new Error("package.json does not contain a valid version.");
   }
   return metadata.version;
 }

package/src/cli/profile.ts

@@ -22,7 +22,7 @@ export function parseGlobalOptions(input: string[]): ParsedGlobalOptions {
   const configPath = removeOption(args, "--config");
   const profilePath = removeOption(args, "--profile");
   if (configPath && profilePath) {
-    throw new Error("--profile 和 --config 不能同时使用。Profile 固定使用其目录下的 config.yaml。");
+    throw new Error("--profile and --config cannot be used together. A profile always uses config.yaml in its directory.");
   }
   return {
     args,
@@ -49,11 +49,11 @@ export function applyExplicitProfile(
 
 function removeOption(args: string[], option: string): string | undefined {
   const indexes = args.flatMap((value, index) => value === option ? [index] : []);
-  if (indexes.length > 1) throw new Error(`${option} 只能指定一次。`);
+  if (indexes.length > 1) throw new Error(`${option} can only be specified once.`);
   const index = indexes[0];
   if (index === undefined) return undefined;
   const value = args[index + 1];
-  if (!value || value.startsWith("--")) throw new Error(`${option} 需要目录或文件路径。`);
+  if (!value || value.startsWith("--")) throw new Error(`${option} requires a directory or file path.`);
   args.splice(index, 2);
   return value;
 }