@keyou007/agent-bot 0.1.9 → 0.1.11

package/src/cli/FeishuAppConfiguration.ts

@@ -1,5 +1,6 @@
 import { gzipSync } from "node:zlib";
 import type { FeishuAppCredentials } from "./FeishuAppRegistration.js";
+import { cliText } from "./i18n.js";
 
 const FEISHU_OPEN_BASE_URL = "https://open.feishu.cn";
 const TENANT_TOKEN_PATH = "/open-apis/auth/v3/tenant_access_token/internal";
@@ -71,6 +72,7 @@ const CORE_FEISHU_SCOPES = new Set([
   "im:message:send_as_bot",
 ]);
 const CORE_FEISHU_EVENTS = new Set<string>(["im.message.receive_v1"]);
+const MANUAL_FEISHU_SCOPES = new Set(["im:message.group_msg"]);
 
 export interface FeishuAppConfiguration {
   scopes: string[];
@@ -85,6 +87,7 @@ export interface MissingFeishuAppConfiguration {
 }
 
 export interface FeishuConfigurationChallenge {
+  kind: "launcher" | "manual_scope";
   verificationUrl: string;
   missing: MissingFeishuAppConfiguration;
   blocking: boolean;
@@ -94,6 +97,7 @@ export interface EnsureFeishuAppConfigurationOptions {
   fetch?: typeof globalThis.fetch;
   sleep?: (milliseconds: number) => Promise<void>;
   signal?: AbortSignal;
+  manualPermissionSkipSignal?: AbortSignal;
   optionalSkipSignal?: AbortSignal;
   pollIntervalMs?: number;
   timeoutMs?: number;
@@ -157,15 +161,27 @@ export async function ensureFeishuAppConfiguration(
 
   let remainingMs = timeoutMs;
   let lastError: unknown;
+  let refreshImmediately = options.manualPermissionSkipSignal?.aborted === true;
   while (remainingMs > 0) {
     const waitMs = Math.min(pollIntervalMs, remainingMs);
-    await sleepWithAbort(sleep, waitMs, options.signal);
-    remainingMs -= waitMs;
+    if (!refreshImmediately) {
+      const waitResult = options.manualPermissionSkipSignal?.aborted
+        ? await sleepWithAbort(sleep, waitMs, options.signal).then(() => "elapsed" as const)
+        : await sleepWithOptionalSkip(
+            sleep,
+            waitMs,
+            options.signal,
+            options.manualPermissionSkipSignal,
+          );
+      if (waitResult === "elapsed") remainingMs -= waitMs;
+    }
+    refreshImmediately = false;
 
     try {
       configuration = await readFeishuAppConfiguration(credentials, fetchImpl, options.signal);
       const remaining = missingFeishuAppConfiguration(configuration);
-      if (!hasMissingConfiguration(coreMissingFeishuAppConfiguration(remaining))) {
+      const unresolvedCore = coreMissingFeishuAppConfiguration(remaining);
+      if (!hasBlockingCoreConfiguration(unresolvedCore, options.manualPermissionSkipSignal)) {
         return completeOptionalFeishuConfiguration(
           credentials,
           configuration,
@@ -175,17 +191,40 @@ export async function ensureFeishuAppConfiguration(
           pollIntervalMs,
           optionalTimeoutMs,
           options,
+          skippedManualScopes(coreMissing, options.manualPermissionSkipSignal),
         );
       }
       lastError = undefined;
     } catch (error) {
       if (options.signal?.aborted) throw abortError(options.signal);
+      const knownRemaining = missingFeishuAppConfiguration(configuration);
+      if (!hasBlockingCoreConfiguration(
+        coreMissingFeishuAppConfiguration(knownRemaining),
+        options.manualPermissionSkipSignal,
+      )) {
+        return completeOptionalFeishuConfiguration(
+          credentials,
+          configuration,
+          missing,
+          fetchImpl,
+          sleep,
+          pollIntervalMs,
+          optionalTimeoutMs,
+          options,
+          skippedManualScopes(coreMissing, options.manualPermissionSkipSignal),
+        );
+      }
       lastError = error;
     }
   }
 
-  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}`);
+  const detail = lastError instanceof Error
+    ? cliText(` Last check failed: ${lastError.message}`, ` 上次检查失败：${lastError.message}`)
+    : "";
+  throw new Error(cliText(
+    `Timed out waiting for the core Lark scopes and message event. Run agent-bot init again.${detail}`,
+    `等待飞书核心权限和消息事件超时。请重新运行 agent-bot init。${detail}`,
+  ));
 }
 
 async function requestMissingFeishuConfiguration(
@@ -194,8 +233,28 @@ async function requestMissingFeishuConfiguration(
   blocking: boolean,
   onVerification: EnsureFeishuAppConfigurationOptions["onVerification"],
 ): Promise<void> {
-  const verificationUrl = buildFeishuConfigurationUrl(appId, missing);
-  await onVerification?.({ verificationUrl, missing, blocking });
+  const launcherMissing: MissingFeishuAppConfiguration = {
+    scopes: missing.scopes.filter((scope) => !MANUAL_FEISHU_SCOPES.has(scope)),
+    events: missing.events,
+    callbacks: missing.callbacks,
+  };
+  if (hasMissingConfiguration(launcherMissing)) {
+    await onVerification?.({
+      kind: "launcher",
+      verificationUrl: buildFeishuConfigurationUrl(appId, launcherMissing),
+      missing: launcherMissing,
+      blocking,
+    });
+  }
+
+  for (const scope of missing.scopes.filter((value) => MANUAL_FEISHU_SCOPES.has(value))) {
+    await onVerification?.({
+      kind: "manual_scope",
+      verificationUrl: buildFeishuPermissionManagementUrl(appId, scope),
+      missing: { scopes: [scope], events: [], callbacks: [] },
+      blocking,
+    });
+  }
 }
 
 async function completeOptionalFeishuConfiguration(
@@ -207,13 +266,15 @@ async function completeOptionalFeishuConfiguration(
   pollIntervalMs: number,
   timeoutMs: number,
   options: EnsureFeishuAppConfigurationOptions,
+  ignoredScopes: ReadonlySet<string> = new Set(),
 ): Promise<EnsureFeishuAppConfigurationResult> {
   let configuration = initialConfiguration;
   let remaining = missingFeishuAppConfiguration(configuration);
-  if (hasMissingConfiguration(remaining)) {
+  const requested = withoutIgnoredScopes(remaining, ignoredScopes);
+  if (hasMissingConfiguration(requested)) {
     await requestMissingFeishuConfiguration(
       credentials.appId,
-      remaining,
+      requested,
       false,
       options.onVerification,
     );
@@ -227,6 +288,7 @@ async function completeOptionalFeishuConfiguration(
         timeoutMs,
         options.signal,
         options.optionalSkipSignal,
+        ignoredScopes,
       );
       configuration = completed.configuration;
       remaining = completed.remaining;
@@ -249,6 +311,7 @@ async function waitForOptionalFeishuConfiguration(
   timeoutMs: number,
   signal?: AbortSignal,
   optionalSkipSignal?: AbortSignal,
+  ignoredScopes: ReadonlySet<string> = new Set(),
 ): Promise<{
   configuration: FeishuAppConfiguration;
   remaining: MissingFeishuAppConfiguration;
@@ -256,7 +319,7 @@ async function waitForOptionalFeishuConfiguration(
   let configuration = initialConfiguration;
   let remaining = missingFeishuAppConfiguration(configuration);
   let remainingMs = timeoutMs;
-  while (remainingMs > 0 && hasMissingConfiguration(remaining)) {
+  while (remainingMs > 0 && hasMissingConfiguration(withoutIgnoredScopes(remaining, ignoredScopes))) {
     if (optionalSkipSignal?.aborted) break;
     const waitMs = Math.min(pollIntervalMs, remainingMs);
     const waitResult = await sleepWithOptionalSkip(
@@ -346,6 +409,14 @@ export function buildFeishuConfigurationUrl(appId: string, missing: MissingFeish
   return url.toString();
 }
 
+export function buildFeishuPermissionManagementUrl(appId: string, scope: string): string {
+  const url = new URL(`/app/${encodeURIComponent(appId)}/auth`, FEISHU_OPEN_BASE_URL);
+  url.searchParams.set("q", scope);
+  url.searchParams.set("op_from", "openapi");
+  url.searchParams.set("token_type", "tenant");
+  return url.toString();
+}
+
 async function readFeishuAppConfiguration(
   credentials: FeishuAppCredentials,
   fetchImpl: typeof globalThis.fetch,
@@ -360,14 +431,14 @@ async function readFeishuAppConfiguration(
       `${FEISHU_OPEN_BASE_URL}${APPLICATION_PATH_PREFIX}/${appId}?lang=zh_cn`,
       { headers },
       signal,
-      "Read Lark app configuration",
+      cliText("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",
+      cliText("Read Lark app versions", "读取飞书应用版本"),
     ),
   ]);
 
@@ -415,10 +486,13 @@ async function getTenantAccessToken(
       }),
     },
     signal,
-    "Get the Lark tenant_access_token",
+    cliText("Get the Lark tenant_access_token", "获取飞书 tenant_access_token"),
   );
   const token = readString(payload, "tenant_access_token");
-  if (!token) throw new Error("The Lark tenant_access_token response is missing the access token.");
+  if (!token) throw new Error(cliText(
+    "The Lark tenant_access_token response is missing the access token.",
+    "飞书 tenant_access_token 响应中缺少访问令牌。",
+  ));
   return token;
 }
 
@@ -439,12 +513,18 @@ 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} returned an invalid response (HTTP ${response.status}).`);
+      throw new Error(cliText(
+        `${operation} returned an invalid response (HTTP ${response.status}).`,
+        `${operation}返回了无效响应（HTTP ${response.status}）。`,
+      ));
     }
     const code = readNumber(payload, "code");
     if (!response.ok || code !== 0) {
       throw new FeishuConfigurationApiError(
-        `${operation} failed: ${readString(payload, "msg") || response.statusText || `HTTP ${response.status}`}`,
+        cliText(
+          `${operation} failed: ${readString(payload, "msg") || response.statusText || `HTTP ${response.status}`}`,
+          `${operation}失败：${readString(payload, "msg") || response.statusText || `HTTP ${response.status}`}`,
+        ),
         code,
         response.status,
       );
@@ -452,7 +532,10 @@ async function fetchJson(
     return payload;
   } catch (error) {
     if (parentSignal?.aborted) throw abortError(parentSignal);
-    if (controller.signal.aborted) throw new Error(`${operation} timed out.`);
+    if (controller.signal.aborted) throw new Error(cliText(
+      `${operation} timed out.`,
+      `${operation}超时。`,
+    ));
     throw error;
   } finally {
     clearTimeout(timeout);
@@ -484,6 +567,33 @@ function hasMissingConfiguration(missing: MissingFeishuAppConfiguration): boolea
   return missing.scopes.length > 0 || missing.events.length > 0 || missing.callbacks.length > 0;
 }
 
+function hasBlockingCoreConfiguration(
+  missing: MissingFeishuAppConfiguration,
+  manualPermissionSkipSignal?: AbortSignal,
+): boolean {
+  if (!manualPermissionSkipSignal?.aborted) return hasMissingConfiguration(missing);
+  return hasMissingConfiguration(withoutIgnoredScopes(missing, MANUAL_FEISHU_SCOPES));
+}
+
+function skippedManualScopes(
+  initialCoreMissing: MissingFeishuAppConfiguration,
+  manualPermissionSkipSignal?: AbortSignal,
+): ReadonlySet<string> {
+  if (!manualPermissionSkipSignal?.aborted) return new Set();
+  return new Set(initialCoreMissing.scopes.filter((scope) => MANUAL_FEISHU_SCOPES.has(scope)));
+}
+
+function withoutIgnoredScopes(
+  missing: MissingFeishuAppConfiguration,
+  ignoredScopes: ReadonlySet<string>,
+): MissingFeishuAppConfiguration {
+  return {
+    scopes: missing.scopes.filter((scope) => !ignoredScopes.has(scope)),
+    events: missing.events,
+    callbacks: missing.callbacks,
+  };
+}
+
 function coreMissingFeishuAppConfiguration(missing: MissingFeishuAppConfiguration): MissingFeishuAppConfiguration {
   return {
     scopes: missing.scopes.filter((scope) => CORE_FEISHU_SCOPES.has(scope)),
@@ -554,7 +664,9 @@ function positiveInteger(value: number | undefined): number | undefined {
 }
 
 function abortError(signal: AbortSignal): Error {
-  return signal.reason instanceof Error ? signal.reason : new Error("Lark app configuration was cancelled.");
+  return signal.reason instanceof Error
+    ? signal.reason
+    : new Error(cliText("Lark app configuration was cancelled.", "飞书应用配置已取消。"));
 }
 
 function delay(milliseconds: number): Promise<void> {

package/src/cli/FeishuAppRegistration.ts

@@ -41,12 +41,15 @@ export async function registerFeishuApp(options: FeishuAppRegistrationOptions =
     },
     options.signal,
   );
-  throwRegistrationError(begin, "Could not start Lark app creation");
+  throwRegistrationError(begin, cliText("Could not start Lark app creation", "无法开始创建飞书应用"));
 
   const deviceCode = readString(begin, "device_code");
   const userCode = readString(begin, "user_code");
   if (!deviceCode || !userCode) {
-    throw new Error("The Lark app creation response is missing device_code or user_code.");
+    throw new Error(cliText(
+      "The Lark app creation response is missing device_code or user_code.",
+      "飞书应用创建响应中缺少 device_code 或 user_code。",
+    ));
   }
 
   const expiresIn =
@@ -113,16 +116,22 @@ export async function registerFeishuApp(options: FeishuAppRegistrationOptions =
         intervalSeconds = Math.min(intervalSeconds + 5, MAX_POLL_INTERVAL_SECONDS);
         continue;
       case "access_denied":
-        throw new Error("Lark app creation was cancelled.");
+        throw new Error(cliText("Lark app creation was cancelled.", "飞书应用创建已取消。"));
       case "expired_token":
       case "invalid_grant":
-        throw new Error("The Lark app creation link expired. Run agent-bot init again.");
+        throw new Error(cliText(
+          "The Lark app creation link expired. Run agent-bot init again.",
+          "飞书应用创建链接已过期，请重新运行 agent-bot init。",
+        ));
       default:
-        throwRegistrationError(payload, "Lark app creation failed");
+        throwRegistrationError(payload, cliText("Lark app creation failed", "飞书应用创建失败"));
     }
   }
 
-  throw new Error("Timed out waiting for Lark app creation. Run agent-bot init again.");
+  throw new Error(cliText(
+    "Timed out waiting for Lark app creation. Run agent-bot init again.",
+    "等待飞书应用创建超时，请重新运行 agent-bot init。",
+  ));
 }
 
 function buildVerificationUrl(userCode: string): string {
@@ -152,7 +161,10 @@ async function postRegistration(
     });
     const payload = (await response.json().catch(() => undefined)) as unknown;
     if (!isRecord(payload)) {
-      throw new Error(`The Lark app registration endpoint returned an invalid response (HTTP ${response.status}).`);
+      throw new Error(cliText(
+        `The Lark app registration endpoint returned an invalid response (HTTP ${response.status}).`,
+        `飞书应用注册接口返回了无效响应（HTTP ${response.status}）。`,
+      ));
     }
     return payload;
   } finally {
@@ -165,7 +177,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}${cliText(": ", "：")}${description}`);
 }
 
 function readString(value: RegistrationPayload, key: string): string {
@@ -189,7 +201,9 @@ function isRecord(value: unknown): value is RegistrationPayload {
 }
 
 function abortError(signal: AbortSignal): Error {
-  return signal.reason instanceof Error ? signal.reason : new Error("Lark app creation was cancelled.");
+  return signal.reason instanceof Error
+    ? signal.reason
+    : new Error(cliText("Lark app creation was cancelled.", "飞书应用创建已取消。"));
 }
 
 function delay(milliseconds: number): Promise<void> {
@@ -218,3 +232,4 @@ async function sleepWithAbort(
     if (onAbort) signal.removeEventListener("abort", onAbort);
   }
 }
+import { cliText } from "./i18n.js";

package/src/cli/Initializer.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { cliText } from "./i18n.js";
 import { fileURLToPath } from "node:url";
 import { parse as parseDotEnv } from "dotenv";
 import {
@@ -136,7 +137,10 @@ export function writeFeishuCredentials(envPath: string, credentials: FeishuCrede
       || persisted.appSecret !== credentials.appSecret
       || persisted.userOpenId !== credentials.userOpenId
     ) {
-      throw new Error("Lark credential verification failed after writing the environment file.");
+      throw new Error(cliText(
+        "Lark credential verification failed after writing the environment file.",
+        "写入环境文件后，飞书凭据校验失败。",
+      ));
     }
   } finally {
     if (temporaryFile !== undefined) fs.closeSync(temporaryFile);
@@ -183,13 +187,19 @@ export function acquireInitializationLock(lockDirectory: string): Initialization
       if (created) fs.rmSync(lockPath, { force: true });
       if (!isFileExistsError(error)) throw error;
       if (!isStaleInitializationLock(lockPath)) {
-        throw new Error(`Another agent-bot init process is running (lock file: ${lockPath}).`);
+        throw new Error(cliText(
+          `Another agent-bot init process is running (lock file: ${lockPath}).`,
+          `另一个 agent-bot init 进程正在运行（锁文件：${lockPath}）。`,
+        ));
       }
       fs.rmSync(lockPath, { force: true });
     }
   }
 
-  throw new Error(`Could not acquire the initialization lock: ${lockPath}`);
+  throw new Error(cliText(
+    `Could not acquire the initialization lock: ${lockPath}`,
+    `无法获取初始化锁：${lockPath}`,
+  ));
 }
 
 export function cleanupFeishuCredentialTemporaryFiles(envPath: string): number {
@@ -209,7 +219,10 @@ export function cleanupFeishuCredentialTemporaryFiles(envPath: string): number {
 
 function assertTemplate(templatePath: string): void {
   if (!fs.statSync(templatePath, { throwIfNoEntry: false })?.isFile()) {
-    throw new Error(`Initialization template does not exist: ${templatePath}`);
+    throw new Error(cliText(
+      `Initialization template does not exist: ${templatePath}`,
+      `初始化模板不存在：${templatePath}`,
+    ));
   }
 }
 
@@ -243,7 +256,10 @@ function resetProfileContents(
     || 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.");
+    throw new Error(cliText(
+      "--reset only supports a profile-owned config.yaml and .env.",
+      "--reset 仅支持由 Profile 管理的 config.yaml 和 .env。",
+    ));
   }
   const targets = [
     { name: "config.yaml", sourcePath: configPath },
@@ -304,7 +320,10 @@ 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} is not a valid single-line environment variable value.`);
+    throw new Error(cliText(
+      `${key} is not a valid single-line environment variable value.`,
+      `${key} 不是有效的单行环境变量值。`,
+    ));
   }
 }
 

package/src/cli/LocalControlClient.ts

@@ -1,5 +1,6 @@
 import net from "node:net";
 import type { ControlRequest, ControlResponse } from "./controlProtocol.js";
+import { cliText } from "./i18n.js";
 
 export async function sendControlRequest(
   endpoint: string,
@@ -17,7 +18,10 @@ export async function sendControlRequest(
       socket.destroy();
       operation();
     };
-    const timer = setTimeout(() => finish(() => reject(new Error("Timed out connecting to the Agent Bot control endpoint."))), timeoutMs);
+    const timer = setTimeout(() => finish(() => reject(new Error(cliText(
+      "Timed out connecting to the Agent Bot control endpoint.",
+      "连接 Agent Bot 控制端点超时。",
+    )))), timeoutMs);
     socket.setEncoding("utf8");
     socket.once("connect", () => socket.write(`${JSON.stringify(request)}\n`));
     socket.on("data", (chunk: string) => {
@@ -33,7 +37,10 @@ export async function sendControlRequest(
     });
     socket.once("error", (error) => finish(() => reject(error)));
     socket.once("end", () => {
-      if (!settled) finish(() => reject(new Error("The Agent Bot control endpoint returned no response.")));
+      if (!settled) finish(() => reject(new Error(cliText(
+        "The Agent Bot control endpoint returned no response.",
+        "Agent Bot 控制端点未返回响应。",
+      ))));
     });
   });
 }

package/src/cli/LocalControlServer.ts

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import net from "node:net";
 import type { ControlRequest, ControlResponse } from "./controlProtocol.js";
+import { cliText } from "./i18n.js";
 
 export type ControlRequestHandler = (request: ControlRequest) => Promise<ControlResponse>;
 
@@ -61,7 +62,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("Invalid local control request.");
+    throw new Error(cliText("Invalid local control request.", "无效的本地控制请求。"));
   }
   return value as ControlRequest;
 }

package/src/cli/OptionalAuthorizationSkip.ts

@@ -1,4 +1,5 @@
 import { createInterface, type Interface } from "node:readline";
+import { cliText } from "./i18n.js";
 
 export interface OptionalAuthorizationSkipListener {
   close(): void;
@@ -6,6 +7,45 @@ export interface OptionalAuthorizationSkipListener {
 
 export function listenForOptionalAuthorizationSkip(
   onSkip: () => void,
+): OptionalAuthorizationSkipListener {
+  return listenForAuthorizationSkip(onSkip, {
+    prompt: cliText(
+      "Skip optional authorization? Enter Y and press Enter to skip.\n",
+      "是否跳过可选授权？输入 Y 并按回车键跳过。\n",
+    ),
+    retry: cliText(
+      "Enter Y to skip optional authorization, or keep waiting.\n",
+      "输入 Y 跳过可选授权，或继续等待。\n",
+    ),
+    skipped: cliText(
+      "Optional authorization skipped. Initialization will continue.\n",
+      "已跳过可选授权，初始化将继续。\n",
+    ),
+  });
+}
+
+export function listenForManualPermissionSkip(
+  onSkip: () => void,
+): OptionalAuthorizationSkipListener {
+  return listenForAuthorizationSkip(onSkip, {
+    prompt: cliText(
+      "Skip waiting for this permission? Enter Y and press Enter to skip.\n",
+      "是否跳过等待此权限？输入 Y 并按回车键跳过。\n",
+    ),
+    retry: cliText(
+      "Enter Y to skip this permission, or keep waiting.\n",
+      "输入 Y 跳过此权限，或继续等待。\n",
+    ),
+    skipped: cliText(
+      "Permission wait skipped. Initialization will continue with limited group-message functionality.\n",
+      "已跳过权限等待，初始化将继续，但群消息功能受限。\n",
+    ),
+  });
+}
+
+function listenForAuthorizationSkip(
+  onSkip: () => void,
+  messages: { prompt: string; retry: string; skipped: string },
 ): OptionalAuthorizationSkipListener {
   if (!process.stdin.isTTY) return { close: () => undefined };
 
@@ -13,19 +53,24 @@ export function listenForOptionalAuthorizationSkip(
     input: process.stdin,
     output: process.stderr,
   });
+  let closed = false;
+  const close = (): void => {
+    if (closed) return;
+    closed = true;
+    closeReadline(readline, onLine);
+  };
   const onLine = (value: string): void => {
     if (!isOptionalAuthorizationSkip(value)) {
-      process.stderr.write("Enter Y to skip optional authorization, or keep waiting.\n");
+      process.stderr.write(messages.retry);
       return;
     }
-    process.stderr.write("Optional authorization skipped. Initialization will continue.\n");
+    process.stderr.write(messages.skipped);
+    close();
     onSkip();
   };
   readline.on("line", onLine);
-  process.stderr.write("Skip optional authorization? Enter Y and press Enter to skip.\n");
-  return {
-    close: () => closeReadline(readline, onLine),
-  };
+  process.stderr.write(messages.prompt);
+  return { close };
 }
 
 export function isOptionalAuthorizationSkip(value: string): boolean {

package/src/cli/ServerStarter.ts

@@ -9,6 +9,7 @@ import {
   resolveSupervisorDiagnosticsPaths,
 } from "../supervision/SupervisorDiagnostics.js";
 import { controlEndpoint } from "./controlProtocol.js";
+import { cliText } from "./i18n.js";
 import { isServerReachable, isServerRunning } from "./LocalControlClient.js";
 
 export interface ServerStartResult {
@@ -47,7 +48,17 @@ export async function startServer(
   config: AppConfig,
   dependencies: ServerStarterDependencies = defaultDependencies,
 ): Promise<ServerStartResult> {
-  requireServerFeishuTransport(config.feishu);
+  try {
+    requireServerFeishuTransport(config.feishu);
+  } catch (error) {
+    if (error instanceof Error && /Lark bot is not configured/.test(error.message)) {
+      throw new Error(cliText(
+        "The Lark bot is not configured. Run agent-bot init first, or use agent-bot console for local-only testing.",
+        "尚未配置飞书机器人。请先运行 agent-bot init，或使用 agent-bot console 进行纯本地测试。",
+      ));
+    }
+    throw error;
+  }
   const endpoint = controlEndpoint(config.storage.sqlitePath);
 
   if (await dependencies.isRunning(endpoint)) {
@@ -56,7 +67,10 @@ export async function startServer(
   if (await dependencies.isReachable(endpoint)) {
     const running = await dependencies.waitUntilRunning(endpoint, SERVER_START_TIMEOUT_MS);
     if (!running) {
-      throw new Error("The Agent Bot server started but could not connect to Lark. Check the logs.");
+      throw new Error(cliText(
+        "The Agent Bot server started but could not connect to Lark. Check the logs.",
+        "Agent Bot 服务已启动，但无法连接飞书。请检查日志。",
+      ));
     }
     return { status: "started" };
   }
@@ -64,7 +78,10 @@ export async function startServer(
   dependencies.spawnSupervisor(config);
   const running = await dependencies.waitUntilRunning(endpoint, SERVER_START_TIMEOUT_MS);
   if (!running) {
-    throw new Error("The Supervisor started, but the server did not connect to Lark within 45 seconds. Check the logs.");
+    throw new Error(cliText(
+      "The Supervisor started, but the server did not connect to Lark within 45 seconds. Check the logs.",
+      "Supervisor 已启动，但服务未能在 45 秒内连接飞书。请检查日志。",
+    ));
   }
   return { status: "started" };
 }