@keyou007/agent-bot 0.1.1 → 0.1.3

package/src/cli/ServerStarter.ts

@@ -0,0 +1,106 @@
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { loadConfig } from "../config/loadConfig.js";
+import type { AppConfig } from "../config/schema.js";
+import { requireServerFeishuTransport } from "../feishu/transport.js";
+import {
+  nodeDiagnosticReportArguments,
+  prepareCrashReportDirectory,
+  resolveSupervisorDiagnosticsPaths,
+} from "../supervision/SupervisorDiagnostics.js";
+import { controlEndpoint } from "./controlProtocol.js";
+import { isServerReachable, isServerRunning } from "./LocalControlClient.js";
+
+export interface ServerStartResult {
+  status: "started" | "already-running";
+}
+
+export type InitializationServerResult =
+  | ServerStartResult
+  | { status: "skipped"; reason: "feishu-skipped" };
+
+export interface ServerStarterDependencies {
+  isRunning(endpoint: string): Promise<boolean>;
+  isReachable(endpoint: string): Promise<boolean>;
+  waitUntilRunning(endpoint: string, timeoutMs: number): Promise<boolean>;
+  spawnSupervisor(config: AppConfig): void;
+}
+
+const SERVER_START_TIMEOUT_MS = 45_000;
+
+interface InitializationServerDependencies {
+  loadConfig(configPath?: string): AppConfig;
+  startServer(config: AppConfig): Promise<ServerStartResult>;
+}
+
+export async function startInitializedServer(
+  options: { skipFeishu: boolean; configPath?: string },
+  dependencies: InitializationServerDependencies = defaultInitializationDependencies,
+): Promise<InitializationServerResult> {
+  if (options.skipFeishu) {
+    return { status: "skipped", reason: "feishu-skipped" };
+  }
+  return dependencies.startServer(dependencies.loadConfig(options.configPath));
+}
+
+export async function startServer(
+  config: AppConfig,
+  dependencies: ServerStarterDependencies = defaultDependencies,
+): Promise<ServerStartResult> {
+  requireServerFeishuTransport(config.feishu);
+  const endpoint = controlEndpoint(config.storage.sqlitePath);
+
+  if (await dependencies.isRunning(endpoint)) {
+    return { status: "already-running" };
+  }
+  if (await dependencies.isReachable(endpoint)) {
+    const running = await dependencies.waitUntilRunning(endpoint, SERVER_START_TIMEOUT_MS);
+    if (!running) {
+      throw new Error("agent-bot server 已启动，但未能连接飞书机器人。请检查日志。");
+    }
+    return { status: "started" };
+  }
+
+  dependencies.spawnSupervisor(config);
+  const running = await dependencies.waitUntilRunning(endpoint, SERVER_START_TIMEOUT_MS);
+  if (!running) {
+    throw new Error("已启动 Supervisor，但 server 未在 45 秒内连接飞书机器人。请检查日志。");
+  }
+  return { status: "started" };
+}
+
+const defaultDependencies: ServerStarterDependencies = {
+  isRunning: isServerRunning,
+  isReachable: isServerReachable,
+  waitUntilRunning: waitForServer,
+  spawnSupervisor: (config) => {
+    const entry = fileURLToPath(new URL("../supervisor.js", import.meta.url));
+    const reportDirectory = resolveSupervisorDiagnosticsPaths(config).crashReportDirectory;
+    prepareCrashReportDirectory(reportDirectory);
+    const child = spawn(process.execPath, [
+      ...nodeDiagnosticReportArguments(reportDirectory),
+      entry,
+    ], {
+      cwd: process.cwd(),
+      detached: true,
+      windowsHide: true,
+      stdio: "ignore",
+      env: { ...process.env, AGENT_BOT_RESTART_REASON: "通过 agent-bot CLI 启动" },
+    });
+    child.unref();
+  },
+};
+
+const defaultInitializationDependencies: InitializationServerDependencies = {
+  loadConfig,
+  startServer: (config) => startServer(config),
+};
+
+async function waitForServer(endpoint: string, timeoutMs: number): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await isServerRunning(endpoint)) return true;
+    await new Promise((resolve) => setTimeout(resolve, 200));
+  }
+  return false;
+}

package/src/cli/help.ts

@@ -25,7 +25,7 @@ function renderChineseHelp(version: string): string {
   agent-bot [选项] <命令>
 
 常用命令：
-  init                              初始化配置、数据目录和飞书应用
+  init                              初始化配置和飞书应用，并启动服务
   console                           打开本地 Console
   server start                      在后台启动 Agent Bot
   server status                     查看服务和安全重启状态
@@ -41,6 +41,7 @@ function renderChineseHelp(version: string): string {
   skills install                    安装内置 Skill
 
 选项：
+  --profile <directory>             使用指定目录中的独立 Profile
   --config <path>                   使用指定配置文件
   --json                            在支持的命令中输出 JSON
   -h, --help                        显示帮助
@@ -48,6 +49,7 @@ function renderChineseHelp(version: string): string {
 
 示例：
   agent-bot init
+  agent-bot --profile ~/.agent-bot-rescue init
   agent-bot server start
   agent-bot server status
   agent-bot task list
@@ -63,7 +65,7 @@ Usage:
   agent-bot [options] <command>
 
 Common commands:
-  init                              Initialize config, data directories, and the Lark app
+  init                              Initialize the Lark app and start the service
   console                           Open the local console
   server start                      Start Agent Bot in the background
   server status                     Show server and safe-restart status
@@ -79,6 +81,7 @@ Common commands:
   skills install                    Install the built-in Skill
 
 Options:
+  --profile <directory>             Use an isolated profile directory
   --config <path>                   Use a specific config file
   --json                            Print JSON when supported
   -h, --help                        Show help
@@ -86,6 +89,7 @@ Options:
 
 Examples:
   agent-bot init
+  agent-bot --profile ~/.agent-bot-rescue init
   agent-bot server start
   agent-bot server status
   agent-bot task list

package/src/cli/profile.ts

@@ -0,0 +1,59 @@
+import path from "node:path";
+import {
+  AGENT_BOT_EXPLICIT_PROFILE_ENV,
+  AGENT_BOT_HOME_ENV,
+  DEFAULT_CONFIG_FILE,
+  resolveUserPath,
+} from "../config/paths.js";
+
+export interface ParsedGlobalOptions {
+  args: string[];
+  configPath?: string;
+  profilePath?: string;
+}
+
+export interface AppliedProfile {
+  homePath: string;
+  configPath: string;
+}
+
+export function parseGlobalOptions(input: string[]): ParsedGlobalOptions {
+  const args = [...input];
+  const configPath = removeOption(args, "--config");
+  const profilePath = removeOption(args, "--profile");
+  if (configPath && profilePath) {
+    throw new Error("--profile 和 --config 不能同时使用。Profile 固定使用其目录下的 config.yaml。");
+  }
+  return {
+    args,
+    ...(configPath ? { configPath } : {}),
+    ...(profilePath ? { profilePath } : {}),
+  };
+}
+
+export function applyExplicitProfile(
+  profilePath: string,
+  env: NodeJS.ProcessEnv = process.env,
+  baseDirectory = process.cwd(),
+): AppliedProfile {
+  const homePath = resolveUserPath(profilePath, baseDirectory);
+  const configPath = path.join(homePath, DEFAULT_CONFIG_FILE);
+  env[AGENT_BOT_HOME_ENV] = homePath;
+  env.AGENT_BOT_CONFIG = configPath;
+  env[AGENT_BOT_EXPLICIT_PROFILE_ENV] = "1";
+  delete env.FEISHU_APP_ID;
+  delete env.FEISHU_APP_SECRET;
+  delete env.FEISHU_USER_OPEN_ID;
+  return { homePath, configPath };
+}
+
+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} 只能指定一次。`);
+  const index = indexes[0];
+  if (index === undefined) return undefined;
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) throw new Error(`${option} 需要目录或文件路径。`);
+  args.splice(index, 2);
+  return value;
+}

package/src/cli.ts

@@ -1,17 +1,20 @@
 #!/usr/bin/env node
-import { spawn, spawnSync } from "node:child_process";
+import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import qrcode from "qrcode-terminal";
 import { loadConfig } from "./config/loadConfig.js";
-import { sendControlRequest, isServerRunning } from "./cli/LocalControlClient.js";
+import { sendControlRequest, isServerReachable } from "./cli/LocalControlClient.js";
 import {
   controlEndpoint,
   type ControlResponse,
   type TaskStatusControlData,
 } from "./cli/controlProtocol.js";
 import {
+  acquireInitializationLock,
+  cleanupFeishuCredentialTemporaryFiles,
   initializeAgentBot,
   readFeishuCredentials,
+  shouldCreateFeishuApp,
   writeFeishuCredentials,
   type InitializationResult,
   type InitializationStatus,
@@ -29,8 +32,20 @@ import {
 import { renderCliHelp } from "./cli/help.js";
 import { resolveSystemSkillsRoot, SkillRegistry, type SkillRegistrationStatus } from "./cli/SkillRegistry.js";
 import { readPackageVersion } from "./cli/packageVersion.js";
+import { applyExplicitProfile, parseGlobalOptions } from "./cli/profile.js";
+import {
+  startInitializedServer,
+  startServer,
+  type InitializationServerResult,
+  type ServerStartResult,
+} from "./cli/ServerStarter.js";
 import { taskChatRoute } from "./cli/taskChatRoute.js";
 import { StateStore, type SessionRecord } from "./state/StateStore.js";
+import {
+  nodeDiagnosticReportArguments,
+  prepareCrashReportDirectory,
+  resolveSupervisorDiagnosticsPaths,
+} from "./supervision/SupervisorDiagnostics.js";
 
 const args = process.argv.slice(2);
 
@@ -41,7 +56,8 @@ void main(args).catch((error: unknown) => {
 
 async function main(input: string[]): Promise<void> {
   const parsed = parseGlobalOptions(input);
-  if (parsed.configPath) process.env.AGENT_BOT_CONFIG = parsed.configPath;
+  if (parsed.profilePath) applyExplicitProfile(parsed.profilePath);
+  else if (parsed.configPath) process.env.AGENT_BOT_CONFIG = parsed.configPath;
   const [command, ...rest] = parsed.args;
   if (!command || command === "help" || command === "--help" || command === "-h") {
     printHelp();
@@ -82,6 +98,7 @@ interface InitCommandResult extends InitializationResult {
     appId?: string;
     configuration?: EnsureFeishuAppConfigurationResult;
   };
+  server: InitializationServerResult;
 }
 
 async function initCommand(input: string[], configPath?: string): Promise<void> {
@@ -97,57 +114,80 @@ async function initCommand(input: string[], configPath?: string): Promise<void>
 
   const paths = initializeAgentBot({ configPath });
   if (!json) printInitializationPaths(paths);
+  const initializationLock = acquireInitializationLock(paths.home.path);
+
+  let initialized: Omit<InitCommandResult, "server">;
+  try {
+    cleanupFeishuCredentialTemporaryFiles(paths.env.path);
+    const feishu = await initializeFeishu(
+      paths,
+      { json, skipFeishu, reconfigureFeishu },
+    );
+    initialized = { ...paths, feishu };
+  } finally {
+    initializationLock.release();
+  }
+
+  if (!json) printInitializationResult(initialized);
+  if (!json && !skipFeishu) process.stdout.write("\n正在启动 Agent Bot server...\n");
+  const server = await startInitializedServer({ skipFeishu, configPath });
+  const result: InitCommandResult = { ...initialized, server };
+  if (json) printJson(result);
+  else printInitializationServerResult(server);
+}
 
+async function initializeFeishu(
+  paths: InitializationResult,
+  options: { json: boolean; skipFeishu: boolean; reconfigureFeishu: boolean },
+): Promise<InitCommandResult["feishu"]> {
   const existing = readFeishuCredentials(paths.env.path);
-  let feishu: InitCommandResult["feishu"];
-  if (skipFeishu) {
-    feishu = {
+  if (options.skipFeishu) {
+    return {
       status: "skipped",
       ...(existing.appId ? { appId: existing.appId } : {}),
     };
-  } else {
-    const controller = new AbortController();
-    const onInterrupt = (): void => controller.abort(new Error("已取消初始化。"));
-    process.once("SIGINT", onInterrupt);
-    try {
-      let credentials: FeishuAppCredentials;
-      let status: Exclude<FeishuInitializationStatus, "skipped">;
-      if (existing.status === "configured" && !reconfigureFeishu) {
-        credentials = {
-          appId: existing.appId!,
-          appSecret: existing.appSecret!,
-        };
-        status = "existing";
-      } else {
-        if (existing.status === "incomplete" && !reconfigureFeishu) {
-          throw new Error(`检测到不完整的飞书凭证：请补全 ${paths.env.path}，或使用 --reconfigure-feishu 重新创建应用。`);
-        }
-        credentials = await registerFeishuApp({
-          signal: controller.signal,
-          onVerification: (challenge) => printFeishuVerification(challenge, json),
-        });
-        writeFeishuCredentials(paths.env.path, credentials);
-        status = "created";
-      }
+  }
 
-      if (!json) process.stdout.write("\n正在检查飞书应用权限、事件和回调配置...\n");
-      const configuration = await ensureFeishuAppConfiguration(credentials, {
+  const controller = new AbortController();
+  const onInterrupt = (): void => controller.abort(new Error("已取消初始化。"));
+  process.once("SIGINT", onInterrupt);
+  process.once("SIGTERM", onInterrupt);
+  try {
+    let credentials: FeishuAppCredentials;
+    let status: Exclude<FeishuInitializationStatus, "skipped">;
+    if (!shouldCreateFeishuApp(existing, options.reconfigureFeishu)) {
+      credentials = {
+        appId: existing.appId!,
+        appSecret: existing.appSecret!,
+        userOpenId: existing.userOpenId,
+      };
+      status = "existing";
+    } else {
+      if (existing.status === "incomplete" && !options.json) {
+        process.stdout.write("\n检测到未完整保存的飞书凭据，将重新创建机器人。\n");
+      }
+      credentials = await registerFeishuApp({
         signal: controller.signal,
-        onVerification: (challenge) => printFeishuConfigurationVerification(challenge, json),
+        onVerification: (challenge) => printFeishuVerification(challenge, options.json),
       });
-      feishu = {
-        status,
-        appId: credentials.appId,
-        configuration,
-      };
-    } finally {
-      process.removeListener("SIGINT", onInterrupt);
+      writeFeishuCredentials(paths.env.path, credentials);
+      status = "created";
     }
-  }
 
-  const result: InitCommandResult = { ...paths, feishu };
-  if (json) printJson(result);
-  else printInitializationResult(result);
+    if (!options.json) process.stdout.write("\n正在检查飞书应用权限、事件和回调配置...\n");
+    const configuration = await ensureFeishuAppConfiguration(credentials, {
+      signal: controller.signal,
+      onVerification: (challenge) => printFeishuConfigurationVerification(challenge, options.json),
+    });
+    return {
+      status,
+      appId: credentials.appId,
+      configuration,
+    };
+  } finally {
+    process.removeListener("SIGINT", onInterrupt);
+    process.removeListener("SIGTERM", onInterrupt);
+  }
 }
 
 function skillsCommand(input: string[]): void {
@@ -196,11 +236,16 @@ async function consoleCommand(input: string[]): Promise<void> {
   const config = loadConfig();
   const endpoint = controlEndpoint(config.storage.sqlitePath);
   const force = input.includes("--force");
-  if (!force && await isServerRunning(endpoint)) {
+  if (!force && await isServerReachable(endpoint)) {
     throw new Error("agent-bot server 正在运行。为避免争用同一任务状态，请先停止 server，或明确使用 --force。");
   }
   const entry = fileURLToPath(new URL("./index.js", import.meta.url));
-  const result = spawnSync(process.execPath, [entry], {
+  const reportDirectory = resolveSupervisorDiagnosticsPaths(config).crashReportDirectory;
+  prepareCrashReportDirectory(reportDirectory);
+  const result = spawnSync(process.execPath, [
+    ...nodeDiagnosticReportArguments(reportDirectory),
+    entry,
+  ], {
     cwd: process.cwd(),
     stdio: "inherit",
     env: { ...process.env, AGENT_BOT_CONSOLE_ONLY: "1" },
@@ -227,22 +272,7 @@ async function serverCommand(input: string[]): Promise<void> {
     return;
   }
   if (action === "start") {
-    if (await isServerRunning(endpoint)) {
-      process.stdout.write("agent-bot server 已在运行。\n");
-      return;
-    }
-    const entry = fileURLToPath(new URL("./supervisor.js", import.meta.url));
-    const child = spawn(process.execPath, [entry], {
-      cwd: process.cwd(),
-      detached: true,
-      windowsHide: true,
-      stdio: "ignore",
-      env: { ...process.env, AGENT_BOT_RESTART_REASON: "通过 agent-bot CLI 启动" },
-    });
-    child.unref();
-    const running = await waitForServer(endpoint, 30_000);
-    if (!running) throw new Error("已启动 Supervisor，但 server 未在 30 秒内就绪。请检查日志。");
-    process.stdout.write("agent-bot server 已启动。\n");
+    printServerStartResult(await startServer(config));
     return;
   }
   if (action === "stop") {
@@ -347,16 +377,6 @@ async function taskCommand(input: string[]): Promise<void> {
   }
 }
 
-function parseGlobalOptions(input: string[]): { configPath?: string; args: string[] } {
-  const args = [...input];
-  const configIndex = args.indexOf("--config");
-  if (configIndex < 0) return { args };
-  const configPath = args[configIndex + 1];
-  if (!configPath) throw new Error("--config 需要配置文件路径。");
-  args.splice(configIndex, 2);
-  return { configPath, args };
-}
-
 function filterSessions(sessions: SessionRecord[], args: string[]): SessionRecord[] {
   const context = optionValue(args, "--context");
   const status = optionValue(args, "--status");
@@ -422,7 +442,11 @@ function printServerStatus(data: unknown): void {
   const activity = value.activity && typeof value.activity === "object"
     ? value.activity as Record<string, unknown>
     : {};
-  process.stdout.write("agent-bot server：运行中\n");
+  process.stdout.write(
+    value.ready === false
+      ? "agent-bot server：启动中（正在连接飞书机器人）\n"
+      : "agent-bot server：运行中\n",
+  );
   process.stdout.write(`PID：${value.pid ?? "-"}\n`);
   process.stdout.write(`启动时间：${value.startedAt ?? "-"}\n`);
   process.stdout.write(`Supervisor：${value.supervised ? "已启用" : "未启用"}\n`);
@@ -450,7 +474,7 @@ function printInitializationPaths(result: InitializationResult): void {
   process.stdout.write(`日志目录：${result.logs.path}（${initializationStatusLabel(result.logs.status)}）\n`);
 }
 
-function printInitializationResult(result: InitCommandResult): void {
+function printInitializationResult(result: Omit<InitCommandResult, "server">): void {
   process.stdout.write("\nAgent Bot 初始化完成。\n");
   if (result.feishu.status === "created") {
     process.stdout.write(`飞书应用：已创建并保存凭证（${result.feishu.appId}）\n`);
@@ -480,7 +504,22 @@ function printInitializationResult(result: InitCommandResult): void {
     process.stdout.write("飞书配置：权限、事件和回调均已就绪\n");
   }
   process.stdout.write(`配置文件：${result.config.path}\n`);
-  process.stdout.write("下一步：运行 agent-bot server start。\n");
+}
+
+function printInitializationServerResult(result: InitCommandResult["server"]): void {
+  if (result.status === "skipped") {
+    process.stdout.write("Agent Bot server：已跳过（未配置飞书，可使用 Console 模式）\n");
+    return;
+  }
+  printServerStartResult(result);
+}
+
+function printServerStartResult(result: ServerStartResult): void {
+  process.stdout.write(
+    result.status === "already-running"
+      ? "agent-bot server 已在运行。\n"
+      : "agent-bot server 已启动。\n",
+  );
 }
 
 function printFeishuVerification(challenge: FeishuAppRegistrationChallenge, json: boolean): void {
@@ -586,15 +625,6 @@ function optionValue(args: string[], name: string): string | undefined {
   return index >= 0 ? args[index + 1] : undefined;
 }
 
-async function waitForServer(endpoint: string, timeoutMs: number): Promise<boolean> {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (await isServerRunning(endpoint)) return true;
-    await new Promise((resolve) => setTimeout(resolve, 200));
-  }
-  return false;
-}
-
 function printJson(value: unknown): void {
   process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }

package/src/config/loadConfig.ts

@@ -3,14 +3,18 @@ import path from "node:path";
 import { config as loadDotEnv } from "dotenv";
 import YAML from "yaml";
 import { appConfigSchema, type AppConfig } from "./schema.js";
-import { defaultConfigPath, defaultDotEnvPath, resolveUserPath } from "./paths.js";
+import {
+  AGENT_BOT_EXPLICIT_PROFILE_ENV,
+  defaultConfigPath,
+  defaultDotEnvPath,
+  resolveUserPath,
+} from "./paths.js";
 
 const ENV_PATTERN = /\$\{([A-Z0-9_]+)\}/gi;
 const DEFAULT_CONFIG = `feishu:
-  transport: "auto"
   appId: "\${FEISHU_APP_ID}"
   appSecret: "\${FEISHU_APP_SECRET}"
-  useConsoleWhenMissingCredentials: true
+  userOpenId: "\${FEISHU_USER_OPEN_ID}"
 
 console:
   enabled: true
@@ -67,7 +71,11 @@ logging:
 export function loadConfig(
   configPath?: string,
 ): AppConfig {
-  loadDotEnv({ path: defaultDotEnvPath(), quiet: true });
+  loadDotEnv({
+    path: defaultDotEnvPath(),
+    quiet: true,
+    override: process.env[AGENT_BOT_EXPLICIT_PROFILE_ENV] === "1",
+  });
 
   const configuredPath = firstNonBlank(configPath, process.env.AGENT_BOT_CONFIG);
   const absolutePath = resolveUserPath(configuredPath ?? defaultConfigPath());

package/src/config/paths.ts

@@ -2,6 +2,7 @@ import os from "node:os";
 import path from "node:path";
 
 export const AGENT_BOT_HOME_ENV = "AGENT_BOT_HOME";
+export const AGENT_BOT_EXPLICIT_PROFILE_ENV = "AGENT_BOT_EXPLICIT_PROFILE";
 export const DEFAULT_CONFIG_FILE = "config.yaml";
 export const DEFAULT_ENV_FILE = ".env";
 export const DEFAULT_SQLITE_PATH = "./data/agent-bot.sqlite";

package/src/config/schema.ts

@@ -21,7 +21,8 @@ export const appConfigSchema = z.object({
     transport: z.enum(["auto", "sdk", "console"]).default("auto"),
     appId: z.string().optional(),
     appSecret: z.string().optional(),
-    useConsoleWhenMissingCredentials: z.boolean().default(true),
+    userOpenId: z.string().optional(),
+    useConsoleWhenMissingCredentials: z.boolean().default(false),
   }),
   agents: z.record(z.string().min(1), agentConfigSchema).refine(
     (agents) => Object.keys(agents).length > 0,

package/src/feishu/CardRenderer.ts

@@ -33,8 +33,9 @@ export interface StartupStatusView {
 }
 
 export interface SafeRestartStatusView {
+  scheduleId: number;
   reason: string;
-  phase: "waiting_tasks" | "waiting_delivery" | "countdown" | "restarting";
+  phase: "waiting_tasks" | "waiting_delivery" | "countdown" | "restarting" | "cancelled";
   remainingMs?: number;
   pendingFinalDeliveries: number;
   waitingTasks: Array<{
@@ -270,6 +271,8 @@ export class CardRenderer {
       ? `${Math.max(0, Math.ceil((view.remainingMs ?? 0) / 1_000))}s`
       : view.phase === "restarting"
         ? "0s"
+        : view.phase === "cancelled"
+          ? "已取消"
         : "等待阻塞项清空后开始";
     const status = view.phase === "waiting_tasks"
       ? "🟠 等待任务完成"
@@ -277,7 +280,9 @@ export class CardRenderer {
         ? "🟠 等待最终结果投递"
         : view.phase === "countdown"
           ? "🟡 空闲确认中"
-          : "🔄 正在重启";
+          : view.phase === "restarting"
+            ? "🔄 正在重启"
+            : "⚪ 已取消";
     const lines = [
       `**状态**：${status}`,
       `**重启原因**：${inlineCode(view.reason)}`,
@@ -296,7 +301,24 @@ export class CardRenderer {
     } else {
       elements.push({ tag: "hr" }, markdown("**当前等待的任务**：无"));
     }
-    return sectionCard("Agent Bot 安全重启", elements, view.phase === "restarting" ? "blue" : "orange");
+    if (view.phase !== "restarting" && view.phase !== "cancelled") {
+      elements.push(
+        { tag: "hr" },
+        taskActionRow([{
+          text: "Cancel",
+          value: {
+            action: "safe_restart_cancel",
+            scheduleId: String(view.scheduleId),
+          },
+        }]),
+      );
+    }
+    const template = view.phase === "restarting"
+      ? "blue"
+      : view.phase === "cancelled"
+        ? "grey"
+        : "orange";
+    return sectionCard("Agent Bot 安全重启", elements, template);
   }
 
   renderStartupStatus(view: StartupStatusView): Record<string, unknown> {

package/src/feishu/FeishuConnector.ts

@@ -25,7 +25,6 @@ export class FeishuConnector {
 
   private async startFeishuWs(appId: string, appSecret: string): Promise<void> {
     const lark = (await import("@larksuiteoapi/node-sdk")) as Record<string, any>;
-    const wsClient = new lark.WSClient({ appId, appSecret });
     const eventDispatcher = new lark.EventDispatcher({}).register({
       "im.message.receive_v1": async (data: unknown) => {
         const message = toIncomingMessage(data);
@@ -77,8 +76,11 @@ export class FeishuConnector {
         };
       },
     });
-
-    wsClient.start({ eventDispatcher });
+    const wsClient = new lark.WSClient({
+      appId,
+      appSecret,
+    });
+    await wsClient.start({ eventDispatcher });
     this.logger.info("Feishu WebSocket connector started.");
   }
 }
@@ -86,12 +88,8 @@ export class FeishuConnector {
 function toChatUpdatedEvent(data: unknown): ChatUpdatedEvent | undefined {
   const event = getFeishuEvent(data);
   const chatId = typeof event?.chat_id === "string" ? event.chat_id : undefined;
-  const beforeName = typeof event?.before_change?.name === "string"
-    ? event.before_change.name
-    : undefined;
-  const afterName = typeof event?.after_change?.name === "string"
-    ? event.after_change.name
-    : undefined;
+  const beforeName = typeof event?.before_change?.name === "string" ? event.before_change.name : undefined;
+  const afterName = typeof event?.after_change?.name === "string" ? event.after_change.name : undefined;
   if (!chatId || !afterName || beforeName === afterName) return undefined;
   return {
     chatId,
@@ -118,9 +116,7 @@ function toIncomingMessage(data: unknown): IncomingMessage | undefined {
   const parentMessageId = typeof message.parent_id === "string" && message.parent_id ? message.parent_id : undefined;
   const threadContext = Boolean(chatId && threadId);
   const senderId =
-    event.sender?.sender_id?.open_id ??
-    event.sender?.sender_id?.user_id ??
-    event.sender?.sender_id?.union_id;
+    event.sender?.sender_id?.open_id ?? event.sender?.sender_id?.user_id ?? event.sender?.sender_id?.union_id;
 
   if (!chatId && !senderId) {
     return undefined;