@keyou007/agent-bot 0.1.24-alpha.5 → 0.1.24-alpha.6

package/src/config/schema.ts

@@ -57,6 +57,9 @@ export const agentConfigSchema = z.object({
 });
 
 export const appConfigSchema = z.object({
+  terminal: z.object({
+    enabled: z.boolean().default(true),
+  }).default({ enabled: true }),
   updates: z.object({ enabled: z.boolean().default(true) }).default({ enabled: true }),
   console: z
     .object({
@@ -108,6 +111,7 @@ export type AgentConfig = Omit<ParsedAgentConfig, "defaults"> & {
   defaults?: AgentExecutionDefaults;
 };
 export type GroupNameFormatConfig = z.infer<typeof groupNameFormatSchema>;
-export type AppConfig = Omit<z.infer<typeof appConfigSchema>, "updates"> & {
+export type AppConfig = Omit<z.infer<typeof appConfigSchema>, "updates" | "terminal"> & {
   updates?: { enabled: boolean };
+  terminal?: z.infer<typeof appConfigSchema>["terminal"];
 };

package/src/feishu/CardRenderer.ts

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { approvalActivityId } from "../presentation/TurnStateReducer.js";
 import path from "node:path";
 import type { JsonValue } from "../acp/acpTypes.js";
 import type { RuntimeSession } from "../acp/AcpSessionManager.js";
@@ -14,6 +15,7 @@ import type {
 import type { TurnActivity, TurnViewState, TurnViewStatus } from "../presentation/turnViewTypes.js";
 import { truncateMiddle, truncateText } from "../utils/markdown.js";
 import type { UpdateNotice } from "../updates/types.js";
+import type { TerminalCardView } from "../terminal/TerminalServer.js";
 import { localCardImage } from "./LocalCardImage.js";
 
 export interface StartupStatusView {
@@ -58,6 +60,7 @@ export interface InitializationWelcomeView {
 }
 
 export interface SafeRestartStatusView {
+  activeTerminals?: number;
   scheduleId: number;
   reason: string;
   phase: "waiting_tasks" | "waiting_delivery" | "countdown" | "restarting" | "cancelled" | "superseded";
@@ -85,6 +88,7 @@ export interface ModelSelectorCardView {
   sessionId: string;
   contextKey: string;
   currentModel?: string;
+  modelPage?: number;
   reasoningEffort?: string;
   models: ModelOption[];
   modelProvider?: string;
@@ -131,7 +135,7 @@ export type ExecutionSettingsTab = "agent" | "provider" | "model" | "thinking" |
 
 const EXECUTION_SETTING_EFFECTS: Record<ExecutionSettingsTab, string> = {
   agent: "只影响新建任务，不切换当前任务。",
-  provider: "只影响当前任务，需空闲时切换。",
+  provider: "只影响当前任务；运行中选择将在本轮结束后生效。",
   model: "只影响当前任务，下一轮生效。",
   thinking: "只影响当前任务，下一轮生效。",
   permission: "只影响当前任务，下一轮生效。",
@@ -143,6 +147,8 @@ export interface ExecutionSettingsAgentOption {
 }
 
 export interface ExecutionSettingsCardView {
+  pendingNotice?: string;
+  pendingFailed?: boolean;
   sessionId?: string;
   contextKey: string;
   activeTab: ExecutionSettingsTab;
@@ -152,6 +158,7 @@ export interface ExecutionSettingsCardView {
   runtimeSettingsAvailable: boolean;
   currentProvider?: string;
   currentModel?: string;
+  modelPage?: number;
   currentEffort?: string;
   currentPermissionMode: PermissionMode;
   providers: ModelProviderOption[];
@@ -263,6 +270,7 @@ export interface DismissGroupCardView {
 }
 
 export interface ShellCommandCardView {
+  terminalUrl?: string;
   jobId?: string;
   contextKey?: string;
   command: string;
@@ -508,6 +516,9 @@ export class CardRenderer {
         ...(outputWasTruncated ? ["输出过长，已保留开头和结尾并截断中间内容。"] : []),
       ].join("\n")),
     ];
+    if (view.terminalUrl) {
+      elements.push(markdown(`[Open Terminal](${view.terminalUrl}) · 独立终端，需在本会话由所有者授权`));
+    }
     if (view.status === "running" && view.jobId && view.contextKey) {
       elements.push({
         tag: "button",
@@ -553,6 +564,7 @@ export class CardRenderer {
               `**思考强度 / 权限**：${inlineCode(view.currentEffort ?? "自动")} / ${inlineCode(permissionModeLabel(view.currentPermissionMode))}`,
             ]
           : []),
+        ...(view.pendingNotice ? [view.pendingNotice] : []),
         ...(view.notice ? [view.notice] : []),
         ...(view.warning ? [`**提示**：${escapeCardHtml(view.warning)}`] : []),
       ].join("\n")),
@@ -584,7 +596,8 @@ export class CardRenderer {
             inlineCode(provider.id),
             provider.isDefault ? " · 默认" : "",
           ].join(""),
-          current: provider.id === view.currentProvider,
+          current: provider.id === view.currentProvider && !view.pendingFailed,
+          currentLabel: view.pendingNotice ? "待生效" : undefined,
           action: {
             text: "Switch",
             value: {
@@ -599,18 +612,24 @@ export class CardRenderer {
       if (view.models.length === 0) {
         elements.push(markdown("当前运行时未返回可用模型。"));
       } else {
-        elements.push(...view.models.map((model) => settingsOptionRow({
+        const page = paginateModels(view.models, view.currentModel, view.modelPage, {
+          action: "settings_tab_open", ...baseAction, tab: "model", provider: view.currentProvider ?? "",
+        });
+        elements.push(...page.models.map((model) => settingsOptionRow({
           label: `${inlineCode(model.id)}${model.isDefault ? " · 默认" : ""}`,
-          current: model.id === view.currentModel,
+          current: model.id === view.currentModel && !view.pendingFailed,
+          currentLabel: view.pendingNotice ? "待生效" : undefined,
           action: {
             text: "Switch",
             value: {
               action: "settings_model_select",
               ...baseAction,
+              provider: view.currentProvider ?? "",
               model: model.id,
             },
           },
         })));
+        elements.push(...page.navigation);
       }
     } else if (view.activeTab === "thinking") {
       if (!view.currentModel) {
@@ -622,11 +641,13 @@ export class CardRenderer {
         elements.push(...view.reasoningOptions.map((option) => settingsOptionRow({
           label: inlineCode(option.value),
           current: option.value === view.currentEffort,
+          currentLabel: view.pendingNotice ? "待生效" : undefined,
           action: {
             text: "Switch",
             value: {
               action: "settings_thinking_select",
               ...baseAction,
+              provider: view.currentProvider ?? "",
               model: currentModel,
               effort: option.value,
             },
@@ -637,6 +658,7 @@ export class CardRenderer {
       elements.push(...(["auto", "confirm"] as PermissionMode[]).map((mode) => settingsOptionRow({
         label: `${inlineCode(mode)} · ${permissionModeLabel(mode)}`,
         current: mode === view.currentPermissionMode,
+        currentLabel: view.pendingNotice ? "待生效" : undefined,
         action: {
           text: "Switch",
           value: {
@@ -649,7 +671,7 @@ export class CardRenderer {
     }
 
     elements.push(markdown(`> ${EXECUTION_SETTING_EFFECTS[view.activeTab]}`));
-    return sectionCard("运行设置", elements, view.warning ? "orange" : view.notice ? "green" : "blue");
+    return sectionCard("运行设置", elements, view.warning || view.pendingFailed ? "orange" : view.notice ? "green" : "blue");
   }
 
   renderProviderSelector(view: ProviderSelectorCardView): Record<string, unknown> {
@@ -785,7 +807,14 @@ export class CardRenderer {
     if (view.models.length === 0) {
       elements.push(markdown("当前运行时未返回可用模型。"));
     } else {
-      elements.push(...view.models.map((model) => {
+      const page = paginateModels(view.models, view.currentModel, view.modelPage, {
+        action: view.unifiedSettings ? "provider_model_open" : "model_open",
+        sessionId: view.sessionId,
+        contextKey: view.contextKey,
+        ...(view.modelProvider ? { provider: view.modelProvider } : {}),
+        ...(view.permissionMode ? { permissionMode: view.permissionMode } : {}),
+      });
+      elements.push(...page.models.map((model) => {
         const isCurrent = model.id === view.currentModel;
         return {
           tag: "column_set",
@@ -823,6 +852,7 @@ export class CardRenderer {
           ],
         };
       }));
+      elements.push(...page.navigation);
     }
     if (view.unifiedSettings) {
       elements.push(
@@ -994,6 +1024,24 @@ export class CardRenderer {
       view.status === "completed" ? "green" : view.status === "cancelled" ? "grey" : "blue");
   }
 
+  renderTerminalAuthorization(view: TerminalCardView): Record<string, unknown> {
+    const action = (decision: string) => ({ action: "terminal_authorize", contextKey: view.contextKey, requestId: view.requestId, token: view.approvalToken, decision });
+    const elements: Record<string, unknown>[] = [markdown(`**目录**：${inlineCode(view.cwd)}\n**终端**：${inlineCode(view.reopenToken)}`)];
+    if (view.state === "pending") {
+      elements.push(markdown(`**验证码**：${inlineCode(view.code)}\n仅 AgentBot 所有者可授权。授权后，该浏览器可在本机执行任意命令，拥有 AgentBot 的系统用户权限。请核对网页验证码，仅批准本人发起的请求。5 分钟内有效。${view.recovery ? (view.shellStarted ? "恢复原 Shell，不创建新终端；授权后旧网页失去访问权限。拒绝不影响原终端。" : "继续打开同一个终端；授权后旧网页失去访问权限，Shell 在连接成功后启动。拒绝不影响原授权。") : "不执行原卡片命令。"}`),
+        taskActionRow([{ text: "Allow", value: action("allow") }, { text: "Deny", type: "danger", value: action("deny") }, { text: "刷新", value: action("refresh") }]));
+    } else if (view.state === "closed") {
+      elements.push(markdown(`**状态**：${view.message ? escapeCardHtml(view.message) : "已关闭"}\n原终端已结束时，请从命令卡片创建新终端。`));
+    } else {
+      const waiting = view.state === "approved";
+      const label = waiting ? "打开终端" : "重新打开终端";
+      elements.push(markdown(`**状态**：${waiting ? "已授权，等待网页连接" : view.connected ? "已连接" : "网页已断开，Shell 仍在运行"}\n${waiting ? "请返回原网页连接；原网页已关闭时，点击下方“打开终端”。Shell 尚未启动。" : "点击下方“重新打开终端”恢复原 Shell。前台连接时不因空闲关闭；后台空闲 30 分钟或网页断开 3 分钟后会自动关闭 Shell，成功重连取消断开计时并重置空闲计时；“关闭终端”会中断其中的命令。"}`));
+      elements.push(markdown(`[${label}](${view.reopenUrl}) · 新网页需核对验证码重新授权${waiting ? "，连接成功后启动 Shell" : "，恢复原 Shell"}`));
+      elements.push(taskActionRow([{ text: "关闭终端", type: "danger", value: action("close") }, { text: "刷新", value: action("refresh") }]));
+    }
+    return sectionCard(view.state === "pending" ? "网页终端授权" : "网页终端管理", elements, view.state === "closed" ? "grey" : view.state === "pending" ? "orange" : "blue");
+  }
+
   renderSafeRestartStatus(view: SafeRestartStatusView): Record<string, unknown> {
     const actionable = view.phase !== "restarting" && view.phase !== "cancelled" && view.phase !== "superseded";
     const countdown = view.phase === "countdown"
@@ -1021,6 +1069,7 @@ export class CardRenderer {
       `**重启原因**：${inlineCode(view.reason)}`,
       `**重启倒计时**：${countdown}`,
       `**待投递结果**：${view.pendingFinalDeliveries} 条`,
+      ...(view.activeTerminals ? [`**活动终端**：${view.activeTerminals} 个，请在网页或原会话的终端管理卡中关闭。ForceRestart 会中断终端。`] : []),
     ];
     const elements: Record<string, unknown>[] = [markdown(lines.join("\n"))];
     if (view.waitingTasks.length > 0) {
@@ -1782,6 +1831,10 @@ function renderApprovalElements(state: TurnViewState, request: ApprovalRequest):
       request.reason,
     ].filter(Boolean).join("\n")));
   }
+  if (request.automatic) {
+    elements.push(markdown("自动执行模式：正在自动同意。"));
+    return elements;
+  }
   elements.push({
     tag: "column_set",
     flex_mode: "flow",
@@ -2246,7 +2299,8 @@ function removeMarkdownBold(value: string): string {
 }
 
 function turnActivities(state: TurnViewState): TurnActivity[] {
-  if (state.activities?.length) return state.activities;
+  if (state.activities?.length) return state.approval
+    ? state.activities.filter((a) => a.id !== approvalActivityId(state.turnId, state.approval!.id)) : state.activities;
 
   const activities: TurnActivity[] = [];
   if (state.progressText) {
@@ -2845,6 +2899,24 @@ function acpPermissionOptionLabel(option: { name: string; kind: string }): strin
   return labels[option.kind] ?? (/^[\x20-\x7E]+$/.test(option.name) ? option.name : "Select");
 }
 
+const MODEL_PAGE_SIZE = 20;
+
+function paginateModels(
+  models: ModelOption[],
+  currentModel: string | undefined,
+  requestedPage: number | undefined,
+  action: Record<string, string>,
+): { models: ModelOption[]; navigation: Record<string, unknown>[] } {
+  const totalPages = Math.max(1, Math.ceil(models.length / MODEL_PAGE_SIZE));
+  const currentPage = Math.floor(models.findIndex((model) => model.id === currentModel) / MODEL_PAGE_SIZE);
+  const page = Math.max(0, Math.min(requestedPage ?? currentPage, totalPages - 1));
+  const navigation = totalPages > 1 ? [taskActionRow([
+    ...(page > 0 ? [{ text: "上一页", value: { ...action, page: String(page - 1) } }] : []),
+    ...(page < totalPages - 1 ? [{ text: "下一页", value: { ...action, page: String(page + 1) } }] : []),
+  ], `第 ${page + 1}/${totalPages} 页 · 共 ${models.length} 个模型`)] : [];
+  return { models: models.slice(page * MODEL_PAGE_SIZE, (page + 1) * MODEL_PAGE_SIZE), navigation };
+}
+
 function settingsTabRow(
   activeTab: ExecutionSettingsTab,
   baseAction: Record<string, string>,
@@ -2918,6 +2990,7 @@ function settingsTabElement(
 function settingsOptionRow(input: {
   label: string;
   current: boolean;
+  currentLabel?: string;
   action: TaskListCardAction;
 }): Record<string, unknown> {
   return {
@@ -2937,7 +3010,7 @@ function settingsOptionRow(input: {
         tag: "column",
         width: "auto",
         vertical_align: "center",
-        elements: input.current ? [markdown("✅ 当前")] : [taskActionElement(input.action)],
+        elements: input.current ? [markdown(`✅ ${input.currentLabel ?? "当前"}`)] : [taskActionElement(input.action)],
       },
     ],
   };

package/src/feishu/FeishuConnector.ts

@@ -262,6 +262,7 @@ function toIncomingMessage(
   const messageId = message.message_id ?? `${Date.now()}`;
   return {
     messageId,
+    ...(typeof messageType === "string" ? { messageType } : {}),
     ...(Number.isFinite(Number(message.create_time)) && Number(message.create_time) > 0
       ? { createdAt: Number(message.create_time) } : {}),
     contextKey: chatId

package/src/feishu/FeishuTurnPresenter.ts

@@ -4,6 +4,7 @@ import {
   appendSteerMessage as appendSteerMessageToState,
   createTurnViewState,
   compactTurnView,
+  continueTurnView,
   reduceTurnEvent,
 } from "../presentation/TurnStateReducer.js";
 import { splitMarkdown } from "../presentation/splitMarkdown.js";
@@ -74,6 +75,7 @@ interface TurnEntry {
   elapsedTimer?: ReturnType<typeof setInterval>;
   finalizing?: Promise<void>;
   lastFinalizedStatus?: TurnViewState["status"];
+  continuing?: boolean;
 }
 
 export class FeishuTurnPresenter {
@@ -158,6 +160,13 @@ export class FeishuTurnPresenter {
     const existing = this.pendingEntries.get(sessionId);
     if (existing) {
       await existing.initializing;
+      if (existing.continuing) {
+        existing.state = { ...existing.state, status: "running", error: undefined, completedAt: undefined, durationMs: undefined };
+        this.persist(existing.state.turnId, sessionId, existing.state, existing.contextKey);
+        existing.scheduler?.update(existing.state, "critical");
+        this.startElapsedUpdates(existing);
+        return existing.state.turnId;
+      }
       const images = localImagePaths === undefined ? existing.state.promptImagePaths : [...new Set(localImagePaths)];
       if ((prompt && existing.state.prompt !== prompt) || JSON.stringify(images) !== JSON.stringify(existing.state.promptImagePaths)) {
         existing.state = { ...existing.state, ...(prompt ? { prompt } : {}), ...(images ? { promptImagePaths: images } : {}) };
@@ -204,15 +213,15 @@ export class FeishuTurnPresenter {
   ): Promise<boolean> {
     const entry = this.pendingEntries.get(sessionId);
     if (!entry) return false;
-    this.pendingEntries.delete(sessionId);
-    this.stopElapsedUpdates(entry);
+    if (!entry.continuing) this.pendingEntries.delete(sessionId);
+    if (!entry.continuing) this.stopElapsedUpdates(entry);
     const completedAt = Date.now();
     entry.state = {
       ...entry.state,
-      status: "failed",
+      status: entry.continuing ? "running" : "failed",
       error: message,
-      completedAt,
-      durationMs: Math.max(0, completedAt - entry.state.startedAt),
+      completedAt: entry.continuing ? undefined : completedAt,
+      durationMs: entry.continuing ? undefined : Math.max(0, completedAt - entry.state.startedAt),
     };
     this.persist(entry.state.turnId, sessionId, entry.state, entry.contextKey);
     await entry.initializing;
@@ -298,7 +307,7 @@ export class FeishuTurnPresenter {
             status: "running" as const,
           };
       this.store.previews?.seed(initial);
-      this.store.previews?.user(turnId, activityId, text, localImagePaths);
+      this.store.previews?.user(initial.previewTurnId ?? turnId, activityId, text, localImagePaths);
       const state = this.cardState(appendSteerMessageToState(initial, activityId, text, localImagePaths));
       entry = { contextKey, state, initializing: Promise.resolve() } as TurnEntry;
       this.entries.set(turnId, entry);
@@ -309,7 +318,7 @@ export class FeishuTurnPresenter {
     }
 
     await entry.initializing;
-    this.store.previews?.user(turnId, activityId, text, localImagePaths);
+    this.store.previews?.user(entry.state.previewTurnId ?? turnId, activityId, text, localImagePaths);
     entry.state = this.cardState(appendSteerMessageToState(entry.state, activityId, text, localImagePaths));
     this.persist(turnId, sessionId, entry.state, entry.contextKey);
     if (!entry.historySnapshot) entry.scheduler?.update(entry.state, "critical");
@@ -317,10 +326,50 @@ export class FeishuTurnPresenter {
 
   async onEvent(event: AgentEvent): Promise<void> {
     let existing = this.entries.get(event.turnId);
+    if (!existing) {
+      const saved = this.store.getTurnSnapshot(event.turnId);
+      if (isTurnViewState(saved) && saved.continuedToTurnId) return;
+    }
     let eventApplied = false;
+    if (event.type === "turn_completed" && event.approvedPlan) {
+      const entry = existing ?? this.createEntry({ type: "progress", sessionId: event.sessionId,
+        turnId: event.turnId, activityId: "plan-handoff", text: "方案已确认，继续执行" });
+      if (!entry || entry.continuing) return;
+      entry.continuing = true;
+      entry.historySnapshot = undefined;
+      this.store.previews?.seed(entry.state);
+      entry.state = { ...entry.state, status: "running", approval: undefined };
+      this.pendingEntries.set(event.sessionId, entry);
+      this.persist(event.turnId, event.sessionId, entry.state, entry.contextKey);
+      await entry.initializing;
+      await entry.scheduler?.flush(entry.state);
+      return;
+    }
     if (!existing && event.type === "turn_started") {
       const pending = this.pendingEntries.get(event.sessionId);
-      if (pending) {
+      if (pending?.continuing) {
+        const previous = pending.state;
+        const previewTurnId = previous.previewTurnId ?? previous.turnId;
+        this.flushPersistence();
+        const state = continueTurnView(previous, event.turnId, event.startedAt);
+        this.store.previews?.handoff(previewTurnId, event.turnId, event.startedAt);
+        this.store.saveTurnSnapshot(previous.turnId, event.sessionId, {
+          ...previous, status: "completed", completedAt: event.startedAt,
+          durationMs: Math.max(0, event.startedAt - previous.startedAt),
+          finalResponse: "", continuedToTurnId: event.turnId, previewTurnId,
+        }, pending.contextKey);
+        if (pending.messageId) this.store.saveTurnDelivery(event.turnId, { progressMessageId: pending.messageId });
+        this.entries.delete(previous.turnId);
+        this.pendingEntries.delete(event.sessionId);
+        pending.state = state;
+        pending.continuing = false;
+        pending.lastFinalizedStatus = undefined;
+        pending.historySnapshot = undefined;
+        this.entries.set(event.turnId, pending);
+        this.persist(event.turnId, event.sessionId, state, pending.contextKey);
+        existing = pending;
+        eventApplied = true;
+      } else if (pending) {
         const pendingTurnId = pending.state.turnId;
         const state = reduceTurnEvent(
           createTurnViewState(
@@ -362,8 +411,9 @@ export class FeishuTurnPresenter {
     if (!entry) return;
 
     if (existing && !eventApplied) {
+      event = presentationEvent(event, entry.state);
       this.store.previews?.seed(entry.state);
-      this.store.previews?.event(event);
+      this.store.previews?.event(event, entry.state.previewTurnId);
       const previousStatus = entry.state.status;
       entry.state = this.cardState(reduceTurnEvent(entry.state, event));
       if (isTerminalViewStatus(previousStatus) && !event.type.startsWith("turn_")) entry.state.status = previousStatus;
@@ -374,6 +424,8 @@ export class FeishuTurnPresenter {
     if (!entry.scheduler) return;
 
     if (isTerminalEvent(event)) {
+      if (this.pendingEntries.get(event.sessionId) === entry) this.pendingEntries.delete(event.sessionId);
+      entry.continuing = false;
       this.stopElapsedUpdates(entry);
       if (entry.finalizing) await entry.finalizing;
       const terminalState = entry.state;
@@ -394,7 +446,8 @@ export class FeishuTurnPresenter {
   }
 
   async showDetails(contextKey: string, turnId: string): Promise<void> {
-    const snapshot = this.store.previews?.load(turnId) ?? this.store.getTurnSnapshot(turnId);
+    const saved = this.store.getTurnSnapshot(turnId);
+    const snapshot = this.store.previews?.load(isTurnViewState(saved) ? saved.previewTurnId ?? turnId : turnId) ?? saved;
     if (!isTurnViewState(snapshot)) {
       await this.outbound.sendText(contextKey, "未找到这次执行的详情。可能已被清理。");
       return;
@@ -408,6 +461,7 @@ export class FeishuTurnPresenter {
     page: number | "latest",
     messageId?: string,
   ): Promise<void> {
+    turnId = this.latestPresentationTurn(turnId, contextKey, messageId);
     const entry = this.entries.get(turnId);
     if (entry) await entry.initializing;
     const ownsProgressCard = entry
@@ -430,7 +484,7 @@ export class FeishuTurnPresenter {
       }
 
       if (!entry.historySnapshot) {
-        entry.historySnapshot = this.store.previews?.load(turnId) ?? entry.state;
+        entry.historySnapshot = this.store.previews?.load(entry.state.previewTurnId ?? turnId) ?? entry.state;
         await entry.scheduler?.flush();
       }
       const card = this.renderActivityHistory(entry.historySnapshot, page);
@@ -439,7 +493,8 @@ export class FeishuTurnPresenter {
       return;
     }
 
-    const snapshot = this.store.previews?.load(turnId) ?? this.store.getTurnSnapshot(turnId);
+    const saved = this.store.getTurnSnapshot(turnId);
+    const snapshot = this.store.previews?.load(isTurnViewState(saved) ? saved.previewTurnId ?? turnId : turnId) ?? saved;
     if (!isTurnViewState(snapshot)) throw new Error("未找到这次执行的活动历史。");
     const card = page === "latest"
       ? this.renderTurn(snapshot)
@@ -477,9 +532,9 @@ export class FeishuTurnPresenter {
     const compact = compactTurnView(state);
     this.dirty.set(turnId, { state: compact, contextKey });
     if (!event || isTerminalViewStatus(state.status) || state.status === "waiting_for_approval") {
-      this.store.previews.flush(turnId, true);
+      this.store.previews.flush(state.previewTurnId ?? turnId, true);
       this.flushPersistence();
-      if (isTerminalViewStatus(state.status)) this.store.previews.release(turnId);
+      if (isTerminalViewStatus(state.status)) this.store.previews.release(state.previewTurnId ?? turnId);
     } else if (!this.persistTimer) {
       this.persistTimer = setTimeout(() => {
         try { this.flushPersistence(); } catch (error) { this.options.onError?.(error); }
@@ -519,7 +574,8 @@ export class FeishuTurnPresenter {
           this.sessionModelProviders.get(event.sessionId),
         );
     this.store.previews?.seed(initial);
-    this.store.previews?.event(event);
+    event = presentationEvent(event, initial);
+    this.store.previews?.event(event, initial.previewTurnId);
     const state = this.cardState(reduceTurnEvent(initial, event));
     const entry = { contextKey, state, initializing: Promise.resolve() } as TurnEntry;
     this.entries.set(event.turnId, entry);
@@ -596,7 +652,21 @@ export class FeishuTurnPresenter {
   private turnPreviewUrl(state: TurnViewState): string | undefined {
     return state.turnId.startsWith("pending_")
       ? undefined
-      : this.options.turnPreviewUrl?.(state.turnId);
+      : this.options.turnPreviewUrl?.(state.previewTurnId ?? state.turnId);
+  }
+
+  private latestPresentationTurn(turnId: string, contextKey: string, messageId?: string): string {
+    const seen = new Set<string>();
+    while (!seen.has(turnId)) {
+      seen.add(turnId);
+      const saved = this.store.getTurnSnapshot(turnId);
+      if (!isTurnViewState(saved) || !saved.continuedToTurnId) break;
+      const next = saved.continuedToTurnId;
+      if (this.store.getTurnContextKey?.(next) !== contextKey
+        || (messageId && this.store.getTurnDelivery(next)?.progressMessageId !== messageId)) break;
+      turnId = next;
+    }
+    return turnId;
   }
 
   private startElapsedUpdates(entry: TurnEntry): void {
@@ -717,6 +787,28 @@ export class FeishuTurnPresenter {
   }
 }
 
+function presentationEvent(event: AgentEvent, state: TurnViewState): AgentEvent {
+  if (event.type === "turn_started" && state.segmentStartedAt !== undefined) return { ...event, startedAt: state.startedAt };
+  if (event.type === "turn_completed" && event.durationMs !== undefined && state.segmentStartedAt !== undefined) {
+    return { ...event, durationMs: Math.max(0, state.segmentStartedAt - state.startedAt) + event.durationMs };
+  }
+  if (state.continuedFromTurnId) {
+    // Tool/item IDs are only required to be unique within one runtime Turn.
+    const scoped = (id: string) => event.turnId + ":" + id;
+    if (event.type === "tool_started" || event.type === "tool_updated") return { ...event, tool: { ...event.tool, id: scoped(event.tool.id) } };
+    if (event.type === "tool_output_delta") return { ...event, toolId: scoped(event.toolId) };
+    if (event.type === "reasoning_delta" || event.type === "reasoning_completed") return { ...event, itemId: scoped(event.itemId) };
+    if (event.type === "progress") return { ...event,
+      activityId: (event.activityId?.startsWith("commentary:") ? "commentary:" : "") + scoped(event.activityId ?? "progress"),
+      ...(event.reasoning ? { reasoning: { ...event.reasoning, itemId: scoped(event.reasoning.itemId) } } : {}) };
+    if (event.type === "agent_text_delta" && event.replacesActivityId) return {
+      ...event, replacesActivityId: "commentary:" + scoped(event.replacesActivityId),
+    };
+    if (event.type === "context_compaction" && event.compactionId) return { ...event, compactionId: scoped(event.compactionId) };
+  }
+  return event;
+}
+
 function normalizeTurnCardMarkdown(
   state: TurnViewState,
   localFileUrl: LocalFileUrlResolver | undefined,

package/src/feishu/types.ts

@@ -7,6 +7,7 @@ export type { MergedForwardContent, ReferencedMessageContent } from "./MergedFor
 
 export interface IncomingMessage {
   messageId: string;
+  messageType?: string;
   createdAt?: number;
   contextKey: string;
   chatId?: string;

package/src/index.ts

@@ -1,6 +1,9 @@
 import path from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
+import { TerminalServer } from "./terminal/TerminalServer.js";
+import { sendTerminalAuthorization } from "./terminal/TerminalCards.js";
+import { ShellCommandJobManager } from "./shell/ShellCommandJobManager.js";
 import { LocalControlServer } from "./cli/LocalControlServer.js";
 import { controlEndpoint, type ControlRequest, type ControlResponse } from "./cli/controlProtocol.js";
 import { readPackageVersion } from "./cli/packageVersion.js";
@@ -79,6 +82,8 @@ const transport = consoleOnly ? "console" : requireServerFeishuTransport(config.
 const logger = createLogger(config);
 const store = new StateStore(config.storage.sqlitePath, (error) => logger.error({ error }, "Failed to persist Turn preview journal."));
 let localFileViewer: LocalFileViewerServer | undefined;
+let terminalServer: TerminalServer | undefined;
+const shellCommandJobs = new ShellCommandJobManager(path.join(path.dirname(config.storage.sqlitePath), "command-jobs"));
 let loadTurnDetails: ((turnId: string) => Promise<unknown>) | undefined;
 if (config.fileViewer.enabled) {
   const viewer = new LocalFileViewerServer({
@@ -160,7 +165,7 @@ let restartRequested = false;
 let pendingSelfUpdatePlanPath: string | undefined;
 let preparingSelfUpdate = false;
 const safeRestart = new SafeRestartScheduler({
-  readActivity: () => store.getServerActivityState(),
+  readActivity: () => serverActivity(),
   onReady: (reason, notificationTargets) => pendingSelfUpdatePlanPath
     ? initiateSelfUpdate(reason, notificationTargets)
     : initiateRestart(reason, notificationTargets),
@@ -226,8 +231,39 @@ async function prepareAndScheduleUpdate(version: string, target: RestartNotifica
   }
 }
 
+if (feishuOutbound && localFileViewer && config.terminal?.enabled !== false) {
+  const server = new TerminalServer({
+    stateDirectory: path.join(path.dirname(config.storage.sqlitePath), "terminal"),
+    ownerId: () => config.feishu.userOpenId,
+    canStart: () => !shuttingDown && !restartRequested && !safeRestart.scheduled && !safeRestart.restarting,
+    readJob: (jobId) => shellCommandJobs.readJob(jobId),
+    requestApproval: (authorization) => sendTerminalAuthorization(feishuOutbound, authorization),
+    updateCard: (messageId, view) => feishuOutbound.updateInteractiveCard(messageId, new CardRenderer().renderTerminalAuthorization(view)),
+    logger,
+  });
+  try {
+    const publicBaseUrl = await server.start(localFileViewer);
+    terminalServer = server;
+    logger.info({ publicBaseUrl }, "Interactive terminal service started (owner authorization required).");
+  } catch (error) {
+    await server.close();
+    logger.warn({ error }, "Terminal service unavailable; command cards remain usable.");
+  }
+}
+
+function serverActivity() {
+  const activity = store.getServerActivityState();
+  const activeTerminals = terminalServer?.activeCount ?? 0;
+  return { ...activity, activeTerminals };
+}
+
 const controller = new ProxySessionController(config, store, runtimes, outbound, logger, {
   supervised,
+  terminalUrl: (jobId) => terminalServer?.createUrl(jobId),
+  authorizeTerminal: (action) => {
+    if (!terminalServer) throw new Error("网页终端未启用。");
+    return terminalServer.resolveApproval(action);
+  },
   showUpdates: (contextKey, userId) => manualUpdates.show(contextKey, userId),
   selectUpdate: (action, replyTarget) => manualUpdates.select(action, replyTarget),
   restart: requestRestart,
@@ -264,7 +300,7 @@ const controller = new ProxySessionController(config, store, runtimes, outbound,
     const changed = writeAgentExecutionDefaults(activeConfigPath, agentName, defaults);
     logger.info({ agentName, changed }, "Stored Agent execution defaults.");
   },
-});
+}, undefined, undefined, shellCommandJobs);
 loadTurnDetails = (turnId) => controller.loadTurnDetails(turnId);
 
 if (feishuOutbound) {
@@ -327,7 +363,7 @@ function recoverPendingSelfUpdate(): void {
     pending.plan.reason ?? `Resume Agent Bot update to ${pending.plan.toVersion}`,
     notificationTarget,
     {
-      restartImmediatelyIfIdle: isServerIdle(store.getServerActivityState()),
+      restartImmediatelyIfIdle: isServerIdle(serverActivity()),
     },
   );
   logger.warn(
@@ -468,7 +504,7 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
           }),
           safeRestartScheduled: safeRestart.scheduled,
           safeRestartReason: safeRestart.pendingReason,
-          activity: store.getServerActivityState(),
+          activity: serverActivity(),
         },
       };
     case "server_restart": {
@@ -497,7 +533,7 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
       }
       assertSelfUpdatePlanPath(request.planPath, agentBotHome());
       const notificationTarget = inferServerRestartTarget(request.notificationSessionId);
-      const restartImmediatelyIfIdle = isServerIdle(store.getServerActivityState());
+      const restartImmediatelyIfIdle = isServerIdle(serverActivity());
       pendingSelfUpdatePlanPath = request.planPath;
       safeRestart.schedule(request.reason, notificationTarget, { restartImmediatelyIfIdle });
       return {
@@ -636,6 +672,7 @@ async function shutdown(
     outbound.flushAll().catch((error: unknown) => logger.warn({ error }, "Failed to flush presenters.")),
     delay(5_000),
   ]);
+  await terminalServer?.close().catch((error: unknown) => logger.warn({ error }, "Failed to close terminals."));
   runtimes.close();
   await controlServer?.close().catch((error: unknown) => logger.warn({ error }, "Failed to close local control endpoint."));
   await localFileViewer?.close().catch((error: unknown) => logger.warn({ error }, "Failed to close local file viewer."));
@@ -708,8 +745,8 @@ function inferServerRestartTarget(notificationSessionId?: string): RestartNotifi
   return privateRestartNotificationTarget(config.feishu.userOpenId);
 }
 
-function isServerIdle(activity: { runningSessions: number; pendingFinalDeliveries: number }): boolean {
-  return activity.runningSessions === 0 && activity.pendingFinalDeliveries === 0;
+function isServerIdle(activity: { runningSessions: number; pendingFinalDeliveries: number; activeTerminals?: number }): boolean {
+  return activity.runningSessions === 0 && activity.pendingFinalDeliveries === 0 && !activity.activeTerminals;
 }
 
 function restartNotificationTargetForSession(