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

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

@@ -403,6 +403,8 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
       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":

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),
       };
+    }
   }
 }
 

package/src/proxy/ProxySessionController.ts

@@ -146,6 +146,7 @@ const HELP_COMMAND_SECTIONS: Array<{
         usage: "[序号或任务 ID]",
         description: "归档当前或指定任务",
       },
+      { command: "/dismiss", description: "归档当前任务并解散当前群" },
       {
         command: "/switch",
         usage: "[序号或任务 ID]",
@@ -498,7 +499,7 @@ export class ProxySessionController {
     if (isQueueIndependentCommand(command)) {
       await this.outbound.withReplyTarget(message.contextKey, replyTarget, async () => {
         try {
-          if (command.type !== "forkgroup") await this.ensureThreadFork(message);
+          if (command.type !== "forkgroup" && command.type !== "dismiss") await this.ensureThreadFork(message);
           await this.execute(
             message.contextKey,
             command,
@@ -667,6 +668,20 @@ export class ProxySessionController {
             source: "sessions_card",
           });
           await this.refreshSessionsCardFromAction(scopedAction);
+        } else if (kind === "group_dismiss_keep") {
+          this.assertDismissGroupRequester(scopedAction);
+          await this.outbound.updateInteractiveCard(
+            contextKey,
+            requiredCardMessageId(scopedAction.messageId),
+            this.cardRenderer.renderDismissGroupKept(),
+          );
+        } else if (kind === "group_dismiss_confirm") {
+          this.assertDismissGroupRequester(scopedAction);
+          await this.dismissGroupAndArchiveTask(
+            contextKey,
+            String(scopedAction.value.sessionId ?? ""),
+            "command",
+          );
         } else if (kind === "session_stop") {
           const sessionId = String(scopedAction.value.sessionId ?? "");
           await this.stopSessionReference(contextKey, sessionId);
@@ -827,6 +842,21 @@ export class ProxySessionController {
     });
   }
 
+  async controlDismissTask(localSessionId: string): Promise<{
+    localSessionId: string;
+    remoteSessionId: string;
+    title: string;
+    chatId: string;
+  }> {
+    const record = this.store.getSession(localSessionId);
+    if (!record) throw new Error(`Task not found: ${localSessionId}`);
+    return this.dismissGroupAndArchiveTask(
+      this.controlSessionContextKey(record),
+      localSessionId,
+      "cli",
+    );
+  }
+
   async controlGetTaskStatus(localSessionId: string): Promise<{
     session: SessionRecord;
     snapshot?: TurnViewState;
@@ -1493,6 +1523,9 @@ export class ProxySessionController {
         });
         return;
       }
+      case "dismiss":
+        await this.openDismissGroupCard(contextKey, userId);
+        return;
       case "status":
         await this.status(contextKey, command.sessionId);
         return;
@@ -4780,7 +4813,7 @@ export class ProxySessionController {
   private async archiveSessionReference(
     contextKey: string,
     reference: string,
-    options: { announce: boolean; source: "cli" | "command" | "sessions_card" },
+    options: { announce: boolean; source: "cli" | "command" | "dismiss" | "sessions_card" },
   ): Promise<{ localSessionId: string; remoteSessionId: string; title: string }> {
     const taskId = this.resolveSessionReference(contextKey, reference);
     const direct = this.store.getSession(taskId);
@@ -4838,6 +4871,101 @@ export class ProxySessionController {
     };
   }
 
+  private async openDismissGroupCard(contextKey: string, userId?: string): Promise<void> {
+    const groupContextKey = this.dismissibleGroupContextKey(contextKey);
+    if (!userId) throw new Error("无法识别当前用户，不能发起解散群操作。");
+    const session = this.requireCurrentSession(groupContextKey);
+    await this.outbound.sendInteractiveCard(groupContextKey, this.cardRenderer.renderDismissGroupConfirmation({
+      contextKey: groupContextKey,
+      sessionId: session.localSessionId,
+      taskTitle: session.title ?? session.remoteSessionId ?? session.localSessionId,
+      requestedBy: userId,
+    }));
+  }
+
+  private assertDismissGroupRequester(action: CardAction): void {
+    const requestedBy = String(action.value.requestedBy ?? "");
+    if (!requestedBy || !action.userId || action.userId !== requestedBy) {
+      throw new Error("只有发起解散操作的用户可以点击这张卡片。");
+    }
+  }
+
+  private async dismissGroupAndArchiveTask(
+    contextKey: string,
+    localSessionId: string,
+    source: "cli" | "command",
+  ): Promise<{ localSessionId: string; remoteSessionId: string; title: string; chatId: string }> {
+    const groupContextKey = this.dismissibleGroupContextKey(contextKey);
+    const session = this.store.getSessionForContext(localSessionId, groupContextKey);
+    if (!session) throw new Error("解散群卡片已失效，请重新发送 /dismiss。");
+
+    const currentSessionId = this.store.getUserContext(groupContextKey)?.currentSessionId;
+    if (session.status !== "closed" && currentSessionId !== localSessionId) {
+      throw new Error("当前任务已经切换，解散群卡片已失效，请重新发送 /dismiss。");
+    }
+    this.assertNoOtherActiveGroupTasks(groupContextKey, localSessionId);
+
+    const archived = session.status === "closed"
+      ? {
+          localSessionId: session.localSessionId,
+          remoteSessionId: session.remoteSessionId ?? session.acpSessionId ?? "",
+          title: session.title ?? session.remoteSessionId ?? session.localSessionId,
+        }
+      : await this.archiveSessionReference(groupContextKey, localSessionId, {
+          announce: false,
+          source: "dismiss",
+        });
+    const chatId = groupContextKey.slice("chat_id:".length);
+    try {
+      await this.outbound.deleteGroup(groupContextKey, chatId);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`当前任务已归档，但解散群失败：${message}`);
+    }
+
+    const detachedSessionIds = this.store.removeChatContext(groupContextKey);
+    for (const detachedSessionId of detachedSessionIds) {
+      const linked = this.store.getSession(detachedSessionId);
+      const routedContextKey = this.outbound.getSessionContextKey(detachedSessionId) ?? linked?.contextKey;
+      if (routedContextKey && baseChatContextKey(routedContextKey) === groupContextKey) {
+        this.outbound.unregisterSession(detachedSessionId);
+      }
+    }
+    this.store.audit(groupContextKey, "group_dismissed", {
+      chatId,
+      localSessionId,
+      remoteSessionId: archived.remoteSessionId,
+      source,
+    });
+    return { ...archived, chatId };
+  }
+
+  private assertNoOtherActiveGroupTasks(contextKey: string, dismissedSessionId: string): void {
+    const active = this.store.listSessionsForChat(contextKey).find((session) => (
+      session.localSessionId !== dismissedSessionId
+      && session.status !== "closed"
+      && (
+        session.status === "running"
+        || Boolean(this.runtimes.forAgent(session.agentName).getSession(session.localSessionId)?.activeTurnId)
+        || this.store.countQueuedPrompts(session.localSessionId) > 0
+      )
+    ));
+    if (active) {
+      throw new Error(`群内任务仍在执行或有排队消息，暂时不能解散：${active.title ?? active.localSessionId}`);
+    }
+  }
+
+  private dismissibleGroupContextKey(contextKey: string): string {
+    if (isThreadContextKey(contextKey)) {
+      throw new Error("/dismiss 不能在话题中使用，请回到群聊正文后重试。");
+    }
+    const groupContextKey = baseChatContextKey(contextKey);
+    if (!groupContextKey.startsWith("chat_id:") || this.store.getChatContext(groupContextKey)?.chatType !== "group") {
+      throw new Error("/dismiss 仅适用于普通群聊。");
+    }
+    return groupContextKey;
+  }
+
   private resolveSessionReference(contextKey: string, reference?: string): string {
     if (reference === undefined) {
       const previous = this.store.getOrCreateUserContext(contextKey, this.config.defaults.agent!).previousSessionId;
@@ -5763,7 +5891,7 @@ function isBotOwnedActiveTurn(record: SessionRecord, remote: RemoteSessionSummar
 }
 
 function isQueueIndependentCommand(command: Command): boolean {
-  if (["archive", "stop", "status", "restart", "mute", "help", "sessions", "dir", "goal", "nosteer"].includes(command.type)) return true;
+  if (["archive", "dismiss", "stop", "status", "restart", "mute", "help", "sessions", "dir", "goal", "nosteer"].includes(command.type)) return true;
   if (command.type === "agent") return command.agent === undefined;
   if (["model", "provider", "thinking", "permissions"].includes(command.type)) return true;
   return false;

package/src/state/StateStore.ts

@@ -344,6 +344,31 @@ export class StateStore {
     return rows.map(mapChatContext);
   }
 
+  removeChatContext(contextKey: string): string[] {
+    const threadPrefix = `${contextKey}:thread_id:`;
+    const linked = this.db.prepare(`
+      SELECT DISTINCT local_session_id
+      FROM context_sessions
+      WHERE context_key = ? OR instr(context_key, ?) = 1
+    `).all(contextKey, threadPrefix) as Array<{ local_session_id: string }>;
+    const remove = this.db.transaction(() => {
+      this.db.prepare(`
+        DELETE FROM context_sessions
+        WHERE context_key = ? OR instr(context_key, ?) = 1
+      `).run(contextKey, threadPrefix);
+      this.db.prepare(`
+        DELETE FROM user_contexts
+        WHERE context_key = ? OR instr(context_key, ?) = 1
+      `).run(contextKey, threadPrefix);
+      this.db.prepare(`
+        DELETE FROM chat_contexts
+        WHERE context_key = ? OR instr(context_key, ?) = 1
+      `).run(contextKey, threadPrefix);
+    });
+    remove();
+    return linked.map((row) => row.local_session_id);
+  }
+
   enqueuePrompt(input: {
     promptId: string;
     localSessionId: string;
@@ -1233,6 +1258,18 @@ export class StateStore {
     return rows.map((row) => ({ ...mapSession(row), contextKey }));
   }
 
+  listSessionsForChat(contextKey: string): SessionRecord[] {
+    const threadPrefix = `${contextKey}:thread_id:`;
+    const rows = this.db.prepare(`
+      SELECT DISTINCT sessions.*
+      FROM context_sessions
+      JOIN sessions ON sessions.local_session_id = context_sessions.local_session_id
+      WHERE context_sessions.context_key = ? OR instr(context_sessions.context_key, ?) = 1
+      ORDER BY sessions.updated_at DESC
+    `).all(contextKey, threadPrefix) as SessionRow[];
+    return rows.map(mapSession);
+  }
+
   listAllSessions(): SessionRecord[] {
     const rows = this.db
       .prepare("SELECT * FROM sessions ORDER BY updated_at DESC, created_at DESC")