@keyou007/agent-bot 0.1.14-alpha.0 → 0.1.14-alpha.2

package/src/index.ts

@@ -19,7 +19,7 @@ import { ConsoleFeishuClient } from "./feishu/ConsoleFeishuClient.js";
 import { FeishuConnector } from "./feishu/FeishuConnector.js";
 import { FeishuMessageClient } from "./feishu/FeishuMessageClient.js";
 import { FeishuTurnPresenter } from "./feishu/FeishuTurnPresenter.js";
-import { baseChatContextKey, isThreadContextKey } from "./feishu/contextKey.js";
+import { isThreadContextKey } from "./feishu/contextKey.js";
 import type { MessageReplyTarget } from "./feishu/types.js";
 import { requireServerFeishuTransport } from "./feishu/transport.js";
 import { createLogger } from "./logging/logger.js";
@@ -34,8 +34,10 @@ import { startFeishu } from "./startup/startFeishu.js";
 import { STOP_EXIT_CODE } from "./supervision/restartPolicy.js";
 import {
   RESTART_GROUP_CONTEXTS_ENV,
+  RESTART_NOTIFICATION_TARGETS_ENV,
   replacementSupervisorEnvironment,
   restartGroupContextKeysFromEnvironment,
+  restartNotificationTargetsFromEnvironment,
 } from "./supervision/replacementSupervisor.js";
 import { SafeRestartScheduler } from "./supervision/SafeRestartScheduler.js";
 import type { RestartNotificationTarget } from "./supervision/SafeRestartScheduler.js";
@@ -46,14 +48,22 @@ import {
   resolveSupervisorDiagnosticsPaths,
 } from "./supervision/SupervisorDiagnostics.js";
 import { refreshedSystemEnvironment } from "./supervision/systemEnvironment.js";
+import {
+  assertSelfUpdatePlanPath,
+  launchSelfUpdateRunner,
+  readPendingSelfUpdate,
+  releaseSelfUpdatePlan,
+} from "./cli/SelfUpdater.js";
 
 const processStartedAt = new Date();
 const agentBotVersion = readPackageVersion();
 const supervised = process.env.AGENT_BOT_SUPERVISED === "1";
 const startupReason = process.env.AGENT_BOT_RESTART_REASON?.trim()
   || (supervised ? "Supervisor 启动" : "直接启动");
-const restartGroupContextKeys = restartGroupContextKeysFromEnvironment(
-  process.env[RESTART_GROUP_CONTEXTS_ENV],
+const restartNotificationTargets = mergeRestartNotificationTargets(
+  restartNotificationTargetsFromEnvironment(process.env[RESTART_NOTIFICATION_TARGETS_ENV]),
+  restartGroupContextKeysFromEnvironment(process.env[RESTART_GROUP_CONTEXTS_ENV])
+    .map((contextKey) => ({ contextKey })),
 );
 const consoleOnly = process.env.AGENT_BOT_CONSOLE_ONLY === "1";
 const config = loadConfig();
@@ -80,7 +90,7 @@ let serverReady = false;
 
 const feishuOutbound = transport === "sdk" ? new FeishuMessageClient(config, logger) : undefined;
 if (feishuOutbound) {
-  const renderer = new CardRenderer();
+  const renderer = new CardRenderer({ thinkingCardLayout: config.feishu.thinkingCardLayout });
   const presenter = new FeishuTurnPresenter(feishuOutbound, store, renderer, {
     normalIntervalMs: 2_000,
     criticalGapMs: 500,
@@ -115,16 +125,26 @@ if (routes.length === 0) throw new Error("Neither Feishu nor console input is en
 const outbound = new OutboundRouter(routes);
 let shuttingDown = false;
 let restartRequested = false;
+let pendingSelfUpdatePlanPath: string | undefined;
 const safeRestart = new SafeRestartScheduler({
   readActivity: () => store.getServerActivityState(),
-  onReady: (reason, notificationTargets) => initiateRestart(reason, notificationTargets),
+  onReady: (reason, notificationTargets) => pendingSelfUpdatePlanPath
+    ? initiateSelfUpdate(reason, notificationTargets)
+    : initiateRestart(reason, notificationTargets),
   onStatus: (status) => safeRestartNotifier?.update(status),
   onStatusError: (error) => logger.warn({ error }, "Failed to publish safe restart status."),
 });
 const controller = new ProxySessionController(config, store, runtimes, outbound, logger, {
   supervised,
   restart: requestRestart,
-  cancelSafeRestart: (scheduleId) => safeRestart.cancelScheduled(scheduleId),
+  cancelSafeRestart: async (scheduleId) => {
+    const cancelled = await safeRestart.cancelScheduled(scheduleId);
+    if (cancelled && pendingSelfUpdatePlanPath) {
+      releaseSelfUpdatePlan(pendingSelfUpdatePlanPath);
+      pendingSelfUpdatePlanPath = undefined;
+    }
+    return cancelled;
+  },
   rememberFeishuUserOpenId: (userOpenId) => {
     if (config.feishu.userOpenId?.startsWith("ou_")) return;
     const persisted = persistFeishuUserOpenIdIfMissing(defaultDotEnvPath(), userOpenId);
@@ -170,14 +190,38 @@ if (feishuConnector && startupNotifier) {
     startupReason,
     startControlServer,
     () => { serverReady = true; },
-    restartGroupContextKeys,
+    restartNotificationTargets,
   );
 } else {
   await startControlServer();
   await feishuConnector?.start();
   serverReady = true;
 }
+await controller.recoverInterruptedTasks().catch((error: unknown) => {
+  logger.error({ error }, "Startup task recovery failed; the server will remain available.");
+});
 consoleConnector?.start();
+recoverPendingSelfUpdate();
+
+function recoverPendingSelfUpdate(): void {
+  const pending = readPendingSelfUpdate(agentBotHome());
+  if (!pending || pendingSelfUpdatePlanPath || restartRequested || safeRestart.scheduled) return;
+  let notificationTarget: RestartNotificationTarget | undefined;
+  try {
+    notificationTarget = inferControlRestartTarget(pending.plan.notificationSessionId);
+  } catch (error) {
+    logger.warn({ error }, "Could not restore the self-update notification target; update recovery will continue.");
+  }
+  pendingSelfUpdatePlanPath = pending.planPath;
+  safeRestart.schedule(
+    pending.plan.reason ?? `Resume Agent Bot update to ${pending.plan.toVersion}`,
+    notificationTarget,
+  );
+  logger.warn(
+    { planPath: pending.planPath, toVersion: pending.plan.toVersion },
+    "Recovered a prepared Agent Bot self-update after Worker restart.",
+  );
+}
 
 async function requestRestart(
   contextKey: string,
@@ -192,6 +236,10 @@ async function requestRestart(
     await outbound.sendText(contextKey, "Agent Bot 已在重启中，请稍候。").catch(() => undefined);
     return;
   }
+  if (pendingSelfUpdatePlanPath) {
+    await outbound.sendText(contextKey, "Agent Bot 更新已在等待中；更新完成后服务会自动恢复。").catch(() => undefined);
+    return;
+  }
   if (force) {
     await initiateRestart("用户执行 /restart --force 命令", [notificationTarget]);
     return;
@@ -216,13 +264,13 @@ async function initiateRestart(
     return;
   }
   restartRequested = true;
+  pendingSelfUpdatePlanPath = undefined;
   await safeRestart.cancelCurrent();
   await safeRestartNotifier?.flush();
   const allNotificationTargets = mergeRestartNotificationTargets(
     notificationTargets,
     safeRestartNotifier?.getNotificationTargets() ?? [],
   );
-  const restartGroupContextKeys = groupContextKeysForRestartTargets(allNotificationTargets);
   await sendRestartTexts(
     allNotificationTargets,
     "Agent Bot 正在重启，恢复在线后会发送启动状态通知。",
@@ -230,10 +278,59 @@ async function initiateRestart(
   setTimeout(() => void shutdown(
     supervised ? STOP_EXIT_CODE : 0,
     reason,
-    restartGroupContextKeys,
+    allNotificationTargets,
   ), 100);
 }
 
+async function initiateSelfUpdate(
+  reason: string,
+  notificationTargets: RestartNotificationTarget[] = [],
+): Promise<void> {
+  if (restartRequested) {
+    await sendRestartTexts(notificationTargets, "Agent Bot 已在重启或更新中，请稍候。");
+    return;
+  }
+  const planPath = pendingSelfUpdatePlanPath;
+  if (!planPath) return;
+  restartRequested = true;
+  await safeRestartNotifier?.flush();
+  const allNotificationTargets = mergeRestartNotificationTargets(
+    notificationTargets,
+    safeRestartNotifier?.getNotificationTargets() ?? [],
+  );
+  await sendRestartTexts(
+    allNotificationTargets,
+    "Agent Bot 正在更新，完成或回滚后会自动恢复服务并发送启动状态通知。",
+  );
+  const environmentRefresh = refreshedSystemEnvironment();
+  if (environmentRefresh.error) {
+    logger.warn({ error: environmentRefresh.error }, "Failed to refresh the environment for Agent Bot update.");
+  }
+  try {
+    assertSelfUpdatePlanPath(planPath, agentBotHome());
+    launchSelfUpdateRunner(planPath, {
+      waitPids: [process.pid, ...(supervised ? [process.ppid] : [])],
+      environment: replacementSupervisorEnvironment(
+        reason,
+        environmentRefresh.environment,
+        allNotificationTargets,
+      ),
+    });
+  } catch (error) {
+    restartRequested = false;
+    releaseSelfUpdatePlan(planPath);
+    pendingSelfUpdatePlanPath = undefined;
+    logger.error({ error, planPath }, "Failed to launch Agent Bot self-update; keeping the current service online.");
+    await sendRestartTexts(
+      allNotificationTargets,
+      `Agent Bot 更新未启动，当前服务保持在线：${error instanceof Error ? error.message : String(error)}`,
+    );
+    return;
+  }
+  pendingSelfUpdatePlanPath = undefined;
+  setTimeout(() => void shutdown(STOP_EXIT_CODE), 100);
+}
+
 async function handleControlRequest(request: ControlRequest): Promise<ControlResponse> {
   switch (request.action) {
     case "health":
@@ -262,6 +359,9 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
         },
       };
     case "server_restart": {
+      if (pendingSelfUpdatePlanPath) {
+        return { ok: false, message: "An Agent Bot update is already pending." };
+      }
       const notificationTarget = inferControlRestartTarget(request.notificationSessionId);
       if (request.mode === "safe") {
         const newlyScheduled = safeRestart.schedule(request.reason, notificationTarget);
@@ -278,18 +378,90 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
       ), 25);
       return { ok: true, message: "Immediate restart requested." };
     }
+    case "server_update": {
+      if (restartRequested || pendingSelfUpdatePlanPath || safeRestart.scheduled) {
+        return { ok: false, message: "A restart or update is already pending." };
+      }
+      assertSelfUpdatePlanPath(request.planPath, agentBotHome());
+      const notificationTarget = inferControlRestartTarget(request.notificationSessionId);
+      pendingSelfUpdatePlanPath = request.planPath;
+      safeRestart.schedule(request.reason, notificationTarget);
+      return {
+        ok: true,
+        message: "Agent Bot update scheduled after active tasks finish and the server becomes idle.",
+      };
+    }
     case "server_stop":
       safeRestart.cancel();
+      if (pendingSelfUpdatePlanPath) releaseSelfUpdatePlan(pendingSelfUpdatePlanPath);
+      pendingSelfUpdatePlanPath = undefined;
       setTimeout(() => void shutdown(STOP_EXIT_CODE), 25);
       return { ok: true, message: "Agent Bot server stop requested." };
     case "task_status":
       return { ok: true, data: await controller.controlGetTaskStatus(request.localSessionId) };
     case "task_stop":
       return { ok: true, message: await controller.controlStopTask(request.localSessionId) };
+    case "task_archive":
+      return { ok: true, data: await controller.controlArchiveTask(request.localSessionId) };
     case "task_title":
       return { ok: true, message: await controller.controlSetTaskTitle(request.localSessionId, request.title) };
     case "task_prompt":
       return { ok: true, message: await controller.controlSendTaskPrompt(request.localSessionId, request.text) };
+    case "task_new":
+      return {
+        ok: true,
+        data: await controller.controlCreateTask(
+          request.localSessionId,
+          request.title,
+          request.cwd,
+          request.projectless === true,
+          request.agentName,
+        ),
+      };
+    case "task_fork":
+      return { ok: true, data: await controller.controlForkTask(request.localSessionId) };
+    case "task_switch":
+      return {
+        ok: true,
+        data: await controller.controlSwitchTask(
+          request.localSessionId,
+          request.targetLocalSessionId,
+          request.previous === true,
+        ),
+      };
+    case "task_queue":
+      return { ok: true, data: await controller.controlQueueTaskPrompt(request.localSessionId, request.text) };
+    case "task_agent":
+      return { ok: true, data: controller.controlTaskAgent(request.localSessionId, request.agentName) };
+    case "task_settings":
+      return {
+        ok: true,
+        data: await controller.controlTaskSettings(request.localSessionId, request.setting, request.value),
+      };
+    case "task_goal":
+      return {
+        ok: true,
+        data: await controller.controlTaskGoal(
+          request.localSessionId,
+          request.goalAction,
+          request.objective,
+        ),
+      };
+    case "task_turns":
+      return { ok: true, data: controller.controlListTaskTurns(request.localSessionId) };
+    case "task_reset":
+      return { ok: true, data: await controller.controlResetTaskToTurn(request.localSessionId, request.turnId) };
+    case "task_mute":
+      return { ok: true, data: controller.controlTaskMute(request.localSessionId, request.enabled) };
+    case "task_shell":
+      return { ok: true, data: await controller.controlRunTaskShell(request.localSessionId, request.command) };
+    case "task_directory":
+      return {
+        ok: true,
+        data: await controller.controlListTaskDirectory(request.localSessionId, request.directory, request.page),
+      };
+    case "task_send_file":
+      return { ok: true, data: { messageId: await controller.controlSendTaskFile(request.localSessionId, request.filePath) } };
     case "task_new_group":
       return {
         ok: true,
@@ -317,10 +489,14 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
 async function shutdown(
   exitCode: number,
   restartReason?: string,
-  restartGroupContextKeys: string[] = [],
+  restartNotificationTargets: RestartNotificationTarget[] = [],
 ): Promise<void> {
   if (shuttingDown) return;
   shuttingDown = true;
+  if (pendingSelfUpdatePlanPath) {
+    releaseSelfUpdatePlan(pendingSelfUpdatePlanPath);
+    pendingSelfUpdatePlanPath = undefined;
+  }
   logger.info({ exitCode }, "Shutting down Agent Bot.");
   safeRestart.cancel();
   feishuConnector?.stop();
@@ -333,11 +509,14 @@ async function shutdown(
   runtimes.close();
   await controlServer?.close().catch((error: unknown) => logger.warn({ error }, "Failed to close local control endpoint."));
   store.close();
-  if (restartReason) startReplacementSupervisor(restartReason, restartGroupContextKeys);
+  if (restartReason) startReplacementSupervisor(restartReason, restartNotificationTargets);
   process.exit(exitCode);
 }
 
-function startReplacementSupervisor(restartReason: string, restartGroupContextKeys: string[]): void {
+function startReplacementSupervisor(
+  restartReason: string,
+  restartNotificationTargets: RestartNotificationTarget[],
+): void {
   const supervisorEntry = fileURLToPath(new URL("./supervisor.js", import.meta.url));
   const reportDirectory = resolveSupervisorDiagnosticsPaths(config).crashReportDirectory;
   prepareCrashReportDirectory(reportDirectory);
@@ -361,7 +540,7 @@ function startReplacementSupervisor(restartReason: string, restartGroupContextKe
     env: replacementSupervisorEnvironment(
       restartReason,
       environmentRefresh.environment,
-      restartGroupContextKeys,
+      restartNotificationTargets,
     ),
   });
   supervisor.unref();
@@ -430,15 +609,6 @@ async function sendRestartTexts(targets: RestartNotificationTarget[], text: stri
   }));
 }
 
-function groupContextKeysForRestartTargets(targets: RestartNotificationTarget[]): string[] {
-  const knownGroupContextKeys = new Set(
-    store.listChatContexts("group").map((chat) => chat.contextKey),
-  );
-  return [...new Set(targets
-    .map((target) => baseChatContextKey(target.contextKey))
-    .filter((contextKey) => knownGroupContextKeys.has(contextKey)))];
-}
-
 function mergeRestartNotificationTargets(
   ...targetGroups: RestartNotificationTarget[][]
 ): RestartNotificationTarget[] {

package/src/presentation/OutboundRouter.ts

@@ -23,8 +23,9 @@ export interface TurnPresenter {
     taskTitle?: string,
     replyTarget?: MessageReplyTarget,
     prompt?: string,
-  ): Promise<void>;
+  ): Promise<string | undefined>;
   failPendingTurn(sessionId: string, message: string): Promise<void>;
+  interruptTurnForRecovery(sessionId: string, contextKey: string, turnId: string, message: string): Promise<void>;
   appendSteerMessage(sessionId: string, turnId: string, text: string, messageId?: string): Promise<void>;
   onEvent(event: AgentEvent): Promise<void>;
   showDetails(contextKey: string, turnId: string): Promise<void>;
@@ -75,6 +76,10 @@ export class OutboundRouter {
     return this.sessionReplyTargets.get(sessionId);
   }
 
+  canRoute(contextKey: string): boolean {
+    return this.routes.some((route) => route.matches(contextKey));
+  }
+
   updateSessionTitle(sessionId: string, taskTitle: string): void {
     this.sessionRoutes.get(sessionId)?.presenter.updateSessionTitle(sessionId, taskTitle);
   }
@@ -93,19 +98,28 @@ export class OutboundRouter {
     taskTitle?: string,
     replyTarget?: MessageReplyTarget,
     prompt?: string,
-  ): Promise<void> {
+  ): Promise<string | undefined> {
     const route = this.route(contextKey);
     this.sessionRoutes.set(sessionId, route);
     this.sessionContextKeys.set(sessionId, contextKey);
     if (replyTarget) this.sessionReplyTargets.set(sessionId, replyTarget);
     else this.sessionReplyTargets.delete(sessionId);
-    await route.presenter.startPendingTurn(sessionId, contextKey, taskTitle, replyTarget, prompt);
+    return route.presenter.startPendingTurn(sessionId, contextKey, taskTitle, replyTarget, prompt);
   }
 
   async failPendingTurn(sessionId: string, message: string): Promise<void> {
     await this.sessionRoutes.get(sessionId)?.presenter.failPendingTurn(sessionId, message);
   }
 
+  async interruptTurnForRecovery(
+    sessionId: string,
+    contextKey: string,
+    turnId: string,
+    message: string,
+  ): Promise<void> {
+    await this.route(contextKey).presenter.interruptTurnForRecovery(sessionId, contextKey, turnId, message);
+  }
+
   async appendSteerMessage(
     sessionId: string,
     turnId: string,
@@ -175,6 +189,17 @@ export class OutboundRouter {
       : outbound.sendText(contextKey, text);
   }
 
+  sendFile(contextKey: string, filePath: string): Promise<string | undefined> {
+    const outbound = this.route(contextKey).outbound;
+    const target = this.currentReplyTarget(contextKey);
+    if (target) {
+      if (!outbound.replyFile) throw new Error("当前消息通道不支持在话题中发送文件。");
+      return outbound.replyFile(contextKey, target, filePath);
+    }
+    if (!outbound.sendFile) throw new Error("当前消息通道不支持发送文件。");
+    return outbound.sendFile(contextKey, filePath);
+  }
+
   sendMarkdown(contextKey: string, markdown: string): Promise<string | undefined> {
     const outbound = this.route(contextKey).outbound;
     const target = this.currentReplyTarget(contextKey);