@keyou007/agent-bot 0.1.14-alpha.1 → 0.1.14-alpha.3

package/src/feishu/FeishuMessageClient.ts

@@ -39,6 +39,13 @@ interface CreateGroupResponse {
   error?: unknown;
 }
 
+interface DeleteGroupResponse {
+  code: number;
+  msg: string;
+  data?: Record<string, never>;
+  error?: unknown;
+}
+
 interface UploadImageResponse {
   code: number;
   msg: string;
@@ -128,6 +135,31 @@ export class FeishuMessageClient implements FeishuOutbound {
     }
   }
 
+  async deleteGroup(chatId: string): Promise<void> {
+    try {
+      const token = await this.getTenantAccessToken();
+      const response = await fetch(
+        `https://open.feishu.cn/open-apis/im/v1/chats/${encodeURIComponent(chatId)}`,
+        {
+          method: "DELETE",
+          headers: { Authorization: `Bearer ${token}` },
+        },
+      );
+      const payload = (await response.json()) as DeleteGroupResponse;
+      if (!response.ok || payload.code !== 0) {
+        throw new FeishuApiError(
+          payload.msg || response.statusText,
+          payload.code,
+          payload,
+          "delete group",
+          response.status,
+        );
+      }
+    } catch (error) {
+      throw normalizeTransportError(error, "delete group");
+    }
+  }
+
   async addReaction(messageId: string, emojiType: string): Promise<string | undefined> {
     try {
       const token = await this.getTenantAccessToken();
@@ -731,6 +763,7 @@ export class FeishuApiError extends Error {
     readonly payload:
       | SendMessageResponse
       | CreateGroupResponse
+      | DeleteGroupResponse
       | UploadImageResponse
       | UploadFileResponse
       | ReactionResponse

package/src/feishu/FeishuTurnPresenter.ts

@@ -42,12 +42,14 @@ export interface TurnPresentationStore {
 export interface FeishuTurnPresenterOptions {
   normalIntervalMs?: number;
   criticalGapMs?: number;
+  elapsedUpdateIntervalMs?: number;
   finalChunkLength?: number;
   onError?: (error: unknown) => void;
   finalRetryBackoffMs?: number[];
 }
 
 const MAX_FINAL_TABLES_PER_CARD = 5;
+const DEFAULT_ELAPSED_UPDATE_INTERVAL_MS = 3_000;
 
 interface TurnEntry {
   contextKey: string;
@@ -58,6 +60,7 @@ interface TurnEntry {
   reactionId?: string;
   reactionEmoji?: string;
   scheduler?: CardUpdateScheduler<TurnViewState>;
+  elapsedTimer?: ReturnType<typeof setInterval>;
   finalizing?: Promise<void>;
   lastFinalizedStatus?: TurnViewState["status"];
 }
@@ -148,6 +151,7 @@ export class FeishuTurnPresenter {
       await entry.initializing;
       return state.turnId;
     } catch (error) {
+      this.stopElapsedUpdates(entry);
       if (this.pendingEntries.get(sessionId) === entry) this.pendingEntries.delete(sessionId);
       this.entries.delete(state.turnId);
       throw error;
@@ -158,7 +162,15 @@ export class FeishuTurnPresenter {
     const entry = this.pendingEntries.get(sessionId);
     if (!entry) return;
     this.pendingEntries.delete(sessionId);
-    entry.state = { ...entry.state, status: "failed", error: message, completedAt: Date.now() };
+    this.stopElapsedUpdates(entry);
+    const completedAt = Date.now();
+    entry.state = {
+      ...entry.state,
+      status: "failed",
+      error: message,
+      completedAt,
+      durationMs: Math.max(0, completedAt - entry.state.startedAt),
+    };
     this.store.saveTurnSnapshot(entry.state.turnId, sessionId, entry.state, entry.contextKey);
     await entry.initializing;
     try {
@@ -178,24 +190,28 @@ export class FeishuTurnPresenter {
   ): Promise<void> {
     const snapshot = this.store.getTurnSnapshot(turnId);
     if (!isTurnViewState(snapshot) || snapshot.sessionId !== sessionId || isTerminalViewStatus(snapshot.status)) return;
+    const completedAt = Date.now();
     const state: TurnViewState = {
       ...snapshot,
       status: "cancelled",
       progressText: message,
       activeTool: undefined,
       approval: undefined,
-      completedAt: Date.now(),
+      completedAt,
+      durationMs: Math.max(0, completedAt - snapshot.startedAt),
     };
     this.store.saveTurnSnapshot(turnId, sessionId, state, contextKey);
-    const delivery = this.store.getTurnDelivery(turnId);
-    if (delivery?.progressMessageId) {
-      await this.outbound.updateInteractiveCard(delivery.progressMessageId, this.renderer.renderTurn(state));
-    }
     const entry = this.entries.get(turnId);
     if (entry) {
+      entry.state = state;
+      this.stopElapsedUpdates(entry);
       this.entries.delete(turnId);
       if (this.pendingEntries.get(sessionId) === entry) this.pendingEntries.delete(sessionId);
     }
+    const delivery = this.store.getTurnDelivery(turnId);
+    if (delivery?.progressMessageId) {
+      await this.outbound.updateInteractiveCard(delivery.progressMessageId, this.renderer.renderTurn(state));
+    }
   }
 
   async appendSteerMessage(
@@ -287,6 +303,7 @@ export class FeishuTurnPresenter {
     if (!entry.scheduler) return;
 
     if (isTerminalEvent(event)) {
+      this.stopElapsedUpdates(entry);
       if (entry.finalizing) await entry.finalizing;
       const terminalState = entry.state;
       if (entry.lastFinalizedStatus === terminalState.status) return;
@@ -434,10 +451,30 @@ export class FeishuTurnPresenter {
       onError: this.options.onError,
     });
     entry.scheduler.seed(sentState);
+    this.startElapsedUpdates(entry);
     if (entry.state !== sentState) entry.scheduler.update(entry.state, "critical");
     await this.syncThinkingCardReaction(entry);
   }
 
+  private startElapsedUpdates(entry: TurnEntry): void {
+    if (entry.elapsedTimer || isTerminalViewStatus(entry.state.status)) return;
+    const intervalMs = Math.max(1, this.options.elapsedUpdateIntervalMs ?? DEFAULT_ELAPSED_UPDATE_INTERVAL_MS);
+    entry.elapsedTimer = setInterval(() => {
+      if (isTerminalViewStatus(entry.state.status)) {
+        this.stopElapsedUpdates(entry);
+        return;
+      }
+      if (!entry.historySnapshot) entry.scheduler?.update(entry.state);
+    }, intervalMs);
+    entry.elapsedTimer.unref?.();
+  }
+
+  private stopElapsedUpdates(entry: TurnEntry): void {
+    if (!entry.elapsedTimer) return;
+    clearInterval(entry.elapsedTimer);
+    entry.elapsedTimer = undefined;
+  }
+
   private async finalize(entry: TurnEntry, state: TurnViewState): Promise<void> {
     let terminalCardError: unknown;
     if (!entry.historySnapshot) {

package/src/feishu/types.ts

@@ -50,6 +50,7 @@ export interface ChatUpdatedEvent {
 
 export interface FeishuOutbound {
   createGroup?(input: CreateGroupInput): Promise<CreatedGroup>;
+  deleteGroup?(chatId: string): Promise<void>;
   addReaction?(messageId: string, emojiType: string): Promise<string | undefined>;
   deleteReaction?(messageId: string, reactionId: string): Promise<void>;
   downloadImage?(messageId: string, imageKey: string): Promise<string>;

package/src/index.ts

@@ -48,6 +48,12 @@ 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();
@@ -119,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);
@@ -185,6 +201,27 @@ 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,
@@ -199,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;
@@ -223,6 +264,7 @@ async function initiateRestart(
     return;
   }
   restartRequested = true;
+  pendingSelfUpdatePlanPath = undefined;
   await safeRestart.cancelCurrent();
   await safeRestartNotifier?.flush();
   const allNotificationTargets = mergeRestartNotificationTargets(
@@ -240,6 +282,55 @@ async function initiateRestart(
   ), 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":
@@ -268,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);
@@ -284,18 +378,92 @@ 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_dismiss":
+      return { ok: true, data: await controller.controlDismissTask(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,
@@ -327,6 +495,10 @@ async function shutdown(
 ): Promise<void> {
   if (shuttingDown) return;
   shuttingDown = true;
+  if (pendingSelfUpdatePlanPath) {
+    releaseSelfUpdatePlan(pendingSelfUpdatePlanPath);
+    pendingSelfUpdatePlanPath = undefined;
+  }
   logger.info({ exitCode }, "Shutting down Agent Bot.");
   safeRestart.cancel();
   feishuConnector?.stop();

package/src/presentation/OutboundRouter.ts

@@ -172,6 +172,13 @@ export class OutboundRouter {
     return createGroup.call(outbound, input);
   }
 
+  async deleteGroup(contextKey: string, chatId: string): Promise<void> {
+    const outbound = this.route(contextKey).outbound;
+    const deleteGroup = outbound.deleteGroup;
+    if (!deleteGroup) throw new Error("当前消息通道不支持解散飞书群。");
+    await deleteGroup.call(outbound, chatId);
+  }
+
   withReplyTarget<T>(
     contextKey: string,
     target: MessageReplyTarget | undefined,

package/src/presentation/TurnStateReducer.ts

@@ -102,31 +102,45 @@ export function reduceTurnEvent(state: TurnViewState, event: AgentEvent): TurnVi
       return { ...state, status: "waiting_for_approval", approval: event.request };
     case "approval_resolved":
       return { ...state, status: state.activeTool ? "tool_running" : "running", approval: undefined };
-    case "turn_completed":
+    case "turn_completed": {
+      const durationMs = Math.max(0, event.durationMs ?? Date.now() - state.startedAt);
       return {
         ...state,
         status: "completed",
         activeTool: undefined,
         approval: undefined,
-        completedAt: state.startedAt + (event.durationMs ?? Date.now() - state.startedAt),
-        durationMs: event.durationMs ?? Date.now() - state.startedAt,
+        completedAt: state.startedAt + durationMs,
+        durationMs,
         finalResponse: appendGeneratedImageMarkdown(
           event.finalResponse,
           state.completedTools.flatMap((tool) =>
             tool.kind === "image_generation" && tool.imagePath ? [tool.imagePath] : []),
         ),
       };
-    case "turn_cancelled":
-      return { ...state, status: "cancelled", activeTool: undefined, approval: undefined, completedAt: Date.now() };
-    case "turn_failed":
+    }
+    case "turn_cancelled": {
+      const completedAt = Date.now();
+      return {
+        ...state,
+        status: "cancelled",
+        activeTool: undefined,
+        approval: undefined,
+        completedAt,
+        durationMs: Math.max(0, completedAt - state.startedAt),
+      };
+    }
+    case "turn_failed": {
+      const completedAt = Date.now();
       return {
         ...state,
         status: "failed",
         activeTool: undefined,
         approval: undefined,
-        completedAt: Date.now(),
+        completedAt,
+        durationMs: Math.max(0, completedAt - state.startedAt),
         error: bound(event.message),
       };
+    }
   }
 }