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

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({
@@ -140,7 +145,14 @@ if (feishuOutbound) {
     workspaceKind: defaultAgent?.kind === "app-server" ? "projectless" : "project",
     defaultUserOpenId: config.feishu.userOpenId,
   }, metadataHydrator);
-  safeRestartNotifier = new SafeRestartNotifier(store, feishuOutbound, renderer, logger);
+  safeRestartNotifier = new SafeRestartNotifier(store, feishuOutbound, renderer, logger, {
+    ownerId: () => config.feishu.userOpenId,
+    isCurrentSchedule: (scheduleId) => !shuttingDown && !restartRequested && safeRestart.isCurrentSchedule(scheduleId),
+    stopTerminal: (terminalId, userId) => {
+      if (!terminalServer) throw new Error("网页终端未启用。");
+      return terminalServer.stopActiveTerminal(terminalId, userId);
+    },
+  });
 }
 
 const consoleEnabled = consoleOnly || config.console.enabled || transport === "console";
@@ -160,7 +172,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 +238,43 @@ 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 terminalBlockers = terminalServer?.listActiveTerminals() ?? [];
+  return { ...activity, activeTerminals: terminalBlockers.length, terminalBlockers };
+}
+
 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);
+  },
+  stopSafeRestartTerminal: (action) => {
+    if (!safeRestartNotifier) throw new Error("安全重启通知未启用。");
+    return safeRestartNotifier.stopTerminal(action);
+  },
   showUpdates: (contextKey, userId) => manualUpdates.show(contextKey, userId),
   selectUpdate: (action, replyTarget) => manualUpdates.select(action, replyTarget),
   restart: requestRestart,
@@ -264,7 +311,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 +374,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 +515,7 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
           }),
           safeRestartScheduled: safeRestart.scheduled,
           safeRestartReason: safeRestart.pendingReason,
-          activity: store.getServerActivityState(),
+          activity: serverActivity(),
         },
       };
     case "server_restart": {
@@ -497,7 +544,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 +683,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 +756,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(

package/src/local-files/LocalFileViewerServer.ts

@@ -3,6 +3,7 @@ import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
 import fs from "node:fs";
 import { createRequire } from "node:module";
 import http, { type IncomingMessage, type ServerResponse } from "node:http";
+import type { Duplex } from "node:stream";
 import path from "node:path";
 import hljs from "highlight.js/lib/common";
 import dos from "highlight.js/lib/languages/dos";
@@ -283,11 +284,18 @@ export interface LocalFileViewerAddress {
   publicConnectionKind?: NetworkConnectionKind;
 }
 
+export interface LocalFileViewerService {
+  handleRequest(request: IncomingMessage, response: ServerResponse): void;
+  handleUpgrade(request: IncomingMessage, socket: Duplex, head: Buffer): void;
+  close(): Promise<void>;
+}
+
 export class LocalFileViewerServer {
   private server?: http.Server;
   private secret?: Buffer;
   private address?: LocalFileViewerAddress;
   private basePath = "";
+  private readonly services = new Map<string, LocalFileViewerService>();
 
   constructor(private readonly options: LocalFileViewerServerOptions) {}
 
@@ -315,6 +323,11 @@ export class LocalFileViewerServer {
       });
     });
     server.on("clientError", (_error, socket) => socket.end("HTTP/1.1 400 Bad Request\r\n\r\n"));
+    server.on("upgrade", (request, socket, head) => {
+      const service = this.serviceFor(request);
+      if (service) service.handleUpgrade(request, socket, head);
+      else socket.end("HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n");
+    });
 
     let selectedPort = preferredPort;
     try {
@@ -361,12 +374,36 @@ export class LocalFileViewerServer {
   }
 
   async close(): Promise<void> {
+    await Promise.all([...this.services.values()].map((service) => service.close()));
+    this.services.clear();
     const server = this.server;
     this.server = undefined;
     this.address = undefined;
     if (server) await closeServer(server);
   }
 
+  mountService(name: string, service: LocalFileViewerService): { publicBaseUrl: string; unmount(): void } {
+    if (!this.address || !this.server) throw new Error("Preview server is not running.");
+    if (!/^[a-z][a-z0-9-]*$/u.test(name) || ["preview", "turn-preview", "assets", "view", "raw"].includes(name)) {
+      throw new Error("Invalid Preview service route.");
+    }
+    const basePath = `${this.basePath}/${name}`;
+    if (this.services.has(basePath)) throw new Error("Preview service route is already mounted.");
+    this.services.set(basePath, service);
+    const url = new URL(this.address.publicBaseUrl);
+    url.pathname = basePath;
+    return { publicBaseUrl: url.toString(), unmount: () => {
+      if (this.services.get(basePath) === service) this.services.delete(basePath);
+    } };
+  }
+
+  private serviceFor(request: IncomingMessage): LocalFileViewerService | undefined {
+    try {
+      const pathname = new URL(request.url ?? "/", "http://127.0.0.1").pathname;
+      return [...this.services].find(([base]) => pathname === base || pathname.startsWith(`${base}/`))?.[1];
+    } catch { return undefined; }
+  }
+
   createFileUrl(filePath: string, reference?: string): string | undefined {
     if (!this.address || !this.secret) return undefined;
     const absolutePath = normalizeAbsolutePath(filePath);
@@ -397,6 +434,8 @@ export class LocalFileViewerServer {
   }
 
   private async handleRequest(request: IncomingMessage, response: ServerResponse): Promise<void> {
+    const service = this.serviceFor(request);
+    if (service) { service.handleRequest(request, response); return; }
     if (request.method !== "GET" && request.method !== "HEAD") {
       response.setHeader("Allow", "GET, HEAD");
       this.sendHtml(response, 405, errorPage("不支持的请求", "该服务只接受只读请求。"), request.method === "HEAD");
@@ -433,14 +472,16 @@ export class LocalFileViewerServer {
         return;
       }
       const journal = this.options.previewJournal;
-      const recorded = journal?.has(turnId);
+      const stored = journal?.has(turnId) ? undefined : this.options.getTurnSnapshot?.(turnId);
+      const journalId = isTurnPreviewState(stored) ? stored.previewTurnId ?? turnId : turnId;
+      const recorded = journal?.has(journalId);
       if (recorded && requestUrl.searchParams.get("events") === "1") {
-        this.serveJournalEvents(request, response, turnId, journal!);
+        this.serveJournalEvents(request, response, journalId, journal!);
         return;
       }
       const detailKey = requestUrl.searchParams.get("detail");
       let snapshot = recorded
-        ? journal!.load(turnId, detailKey ?? false)
+        ? journal!.load(journalId, detailKey ?? false)
         : this.options.getTurnSnapshot?.(turnId);
       if (!recorded && this.options.loadTurnSnapshot && request.method !== "HEAD"
         && requestUrl.searchParams.get("events") !== "1" && !requestUrl.searchParams.has("detail")) {
@@ -467,7 +508,7 @@ export class LocalFileViewerServer {
         const after = requestUrl.searchParams.get("detailAfter");
         const outputAppend = recorded && after && tool?.kind === "tool" && tool.tool.kind === "command" && !tool.tool.error
           && !/repl/i.test(tool.tool.title) && snapshot.previewCursor !== undefined
-          ? journal!.outputAppend(turnId, tool.id, Number(after), snapshot.previewCursor) : undefined;
+          ? journal!.outputAppend(journalId, tool.id, Number(after), snapshot.previewCursor) : undefined;
         const detail = outputAppend !== undefined && tool?.kind === "tool"
           && (snapshot.fullToolOutputs?.[tool.id]?.length ?? 0) > outputAppend.length
           ? { key, revision: String(tool.tool.previewRevision), content: "", outputAppend,
@@ -965,6 +1006,9 @@ export class LocalFileViewerServer {
     if (renderHtml) {
       // A response-level sandbox also isolates this document when opened outside the viewer iframe.
       response.setHeader("Content-Security-Policy", "sandbox allow-scripts; default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src data: blob:; media-src data: blob:; font-src data:; base-uri 'none'; form-action 'none'; frame-ancestors 'self'");
+    } else {
+      // Raw HTML/SVG/XML must not gain the shared origin's storage or execution privileges.
+      response.setHeader("Content-Security-Policy", "sandbox; default-src 'none'; style-src 'unsafe-inline'; img-src data: blob:; media-src data: blob:; base-uri 'none'; form-action 'none'; frame-ancestors 'self'");
     }
     response.setHeader("Accept-Ranges", "bytes");
     response.setHeader("Cache-Control", "no-store");

package/src/local-files/TurnPreviewPage.ts

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { approvalActivityId } from "../presentation/TurnStateReducer.js";
 import path from "node:path";
 import { enableDiagramFences, DIAGRAM_PREVIEW_CLIENT_SCRIPT, DIAGRAM_PREVIEW_CSS } from "./DiagramPreview.js";
 import MarkdownIt from "markdown-it";
@@ -693,7 +694,10 @@ function renderApprovalNotice(request: ApprovalRequest, renderText: (value: stri
     : `<div class="markdown">${renderText(reason)}</div>`;
   const details = commandApproval
     ? `<details class="approval-details" data-activity-id="approval:${escapeAttribute(request.id)}"><summary>${language === "zh" ? "查看完整命令" : "View full command"}</summary><pre data-scroll-id="approval:${escapeAttribute(request.id)}:command">${escapeHtml(request.command!)}</pre></details>` : "";
-  return `<section class="notice" data-preview-key="approval"><h2>${escapeHtml(title)}</h2>${description}${details}<p>${language === "zh" ? "请在飞书任务卡片中确认或拒绝。" : "Approve or reject using the task card in Feishu."}</p></section>`;
+  const instruction = request.automatic
+    ? language === "zh" ? "自动执行模式：正在自动同意。" : "Auto mode: approving automatically."
+    : language === "zh" ? "请在飞书任务卡片中确认或拒绝。" : "Approve or reject using the task card in Feishu.";
+  return `<section class="notice" data-preview-key="approval"><h2>${escapeHtml(title)}</h2>${description}${details}<p>${instruction}</p></section>`;
 }
 
 function renderFinalAnswer(markdown: string, turnId: string, renderText: (value: string) => string, language: TurnPreviewLanguage): string {
@@ -726,7 +730,8 @@ function renderTimeline(
   projectCwd?: string,
   deferDetails = false,
 ): string {
-  const activities = state.activities ?? [];
+  const activities = state.approval
+    ? state.activities.filter((a) => a.id !== approvalActivityId(state.turnId, state.approval!.id)) : state.activities ?? [];
   const positions = new Map(activities.map((activity, index) => [activity.id, index]));
   const reasoning = new Map<number, TurnReasoningItem[]>();
   for (const item of turnReasoningItems(state)) {

package/src/presentation/TurnStateReducer.ts

@@ -1,4 +1,4 @@
-import type { AgentEvent, RemoteTurnDetails, ToolState } from "../runtime/types.js";
+import type { AgentEvent, ApprovalDecision, ApprovalRequest, RemoteTurnDetails, ToolState } from "../runtime/types.js";
 import { appendGeneratedImageMarkdown } from "../utils/generatedImageMarkdown.js";
 import type { MessageReplyTarget } from "../feishu/types.js";
 import { formatStorageSize } from "../utils/formatStorageSize.js";
@@ -113,6 +113,13 @@ export function reduceTurnEvent(state: TurnViewState, event: AgentEvent, complet
   if (event.type === "turn_completed") next.finalResponse = event.finalResponse;
   if (event.type === "agent_text_delta") next.assistantText = state.assistantText + event.text;
   if (event.type === "plan_updated") next.plan = event.steps;
+  if (event.type === "approval_requested" || event.type === "approval_resolved") {
+    const request = event.type === "approval_requested" ? event.request
+      : state.approval?.id === event.requestId ? state.approval : undefined;
+    if (request) next.activities = next.activities.map((a) => a.id === approvalActivityId(event.turnId, request.id) && a.kind === "assistant"
+      ? { ...a, text: approvalHistoryText(request, event.type === "approval_resolved" ? event.decision : undefined,
+        event.type === "approval_resolved" && event.automatic) } : a);
+  }
   if (event.type === "progress") {
     const id = event.activityId ?? "progress";
     const old = state.activities.find((a) => a.id === id);
@@ -305,7 +312,7 @@ function reduceEvent(state: TurnViewState, event: AgentEvent): TurnViewState {
       return {
         ...state,
         ...tracking,
-        status: state.approval ? "waiting_for_approval" : "tool_running",
+        status: state.approval && !state.approval.automatic ? "waiting_for_approval" : "tool_running",
         activeTool: bounded,
         activities: activityUpdate.activities,
         activitiesTruncated: state.activitiesTruncated || activityUpdate.truncated,
@@ -317,10 +324,21 @@ function reduceEvent(state: TurnViewState, event: AgentEvent): TurnViewState {
     case "tool_output_delta":
       return reduceToolOutputDelta(state, event.toolId, event.delta);
     case "approval_requested":
-      return { ...state, status: "waiting_for_approval", approval: event.request };
+      return { ...state, status: event.request.automatic ? state.activeTool ? "tool_running" : "running" : "waiting_for_approval", approval: event.request,
+        activities: [...state.activities.filter((a) => a.id !== approvalActivityId(event.turnId, event.request.id)), {
+          kind: "assistant", id: approvalActivityId(event.turnId, event.request.id), text: bound(approvalHistoryText(event.request)),
+        }],
+      };
     case "approval_resolved":
       if (state.approval?.id !== event.requestId) return state;
-      return { ...state, status: state.activeTool ? "tool_running" : "running", approval: undefined };
+      return {
+        ...state, status: state.activeTool ? "tool_running" : "running", approval: undefined,
+        activities: upsertActivity(state.activities,
+          state.activities.findIndex((a) => a.id === approvalActivityId(event.turnId, event.requestId)), {
+            kind: "assistant", id: approvalActivityId(event.turnId, event.requestId),
+            text: bound(approvalHistoryText(state.approval, event.decision, event.automatic)),
+          }).activities,
+      };
     case "turn_completed": {
       const durationMs = Math.max(0, event.durationMs ?? Date.now() - state.startedAt);
       return {
@@ -363,6 +381,27 @@ function reduceEvent(state: TurnViewState, event: AgentEvent): TurnViewState {
   }
 }
 
+export function approvalActivityId(turnId: string, requestId: string): string {
+  return "approval:" + turnId + ":" + requestId;
+}
+
+export function continueTurnView(state: TurnViewState, turnId: string, startedAt: number): TurnViewState {
+  return { ...state, turnId, previewTurnId: state.previewTurnId ?? state.turnId,
+    continuedFromTurnId: state.turnId, continuedToTurnId: undefined, segmentStartedAt: startedAt,
+    status: "running", completedAt: undefined, durationMs: undefined, finalResponse: undefined,
+    error: undefined, approval: undefined, activeTool: undefined, assistantText: "", progressText: undefined };
+}
+
+function approvalHistoryText(request: ApprovalRequest, decision?: ApprovalDecision, automatic = false): string {
+  const labels = { accept: "允许一次", acceptForSession: "本会话允许", decline: "拒绝", cancel: "取消请求" };
+  const choice = decision ? request.options.find((option) => option.id === decision)?.label ?? labels[decision] : undefined;
+  const heading = choice ? automatic ? "自动同意（auto）" : "用户选择：" + choice
+    : request.automatic ? "正在自动同意（auto）" : "等待选择";
+  return ["**审批请求 · " + heading + "**", request.title, request.reason,
+    request.command ? "~~~\n" + request.command + "\n~~~" : undefined,
+  ].filter(Boolean).join("\n\n");
+}
+
 export function appendSteerMessage(state: TurnViewState, id: string, text: string, localImagePaths?: string[]): TurnViewState {
   const normalized = text.trim();
   if (!normalized && !localImagePaths?.length) return state;
@@ -442,7 +481,7 @@ function reduceToolUpdate(state: TurnViewState, tool: ToolState, fullOutput?: st
       ...tracking,
       fullToolOutputs,
       fullToolErrors,
-      status: state.approval ? "waiting_for_approval" : "tool_running",
+      status: state.approval && !state.approval.automatic ? "waiting_for_approval" : "tool_running",
       activeTool: bounded,
       activities: activityUpdate.activities,
       activitiesTruncated: state.activitiesTruncated || activityUpdate.truncated,
@@ -458,7 +497,7 @@ function reduceToolUpdate(state: TurnViewState, tool: ToolState, fullOutput?: st
       ...tracking,
       fullToolOutputs,
       fullToolErrors,
-      status: state.approval ? "waiting_for_approval" : activeTool ? "tool_running" : "running",
+      status: state.approval && !state.approval.automatic ? "waiting_for_approval" : activeTool ? "tool_running" : "running",
       activeTool,
       activities: activityUpdate.activities,
       activitiesTruncated: state.activitiesTruncated || activityUpdate.truncated,
@@ -473,7 +512,7 @@ function reduceToolUpdate(state: TurnViewState, tool: ToolState, fullOutput?: st
     ...tracking,
     fullToolOutputs,
     fullToolErrors,
-    status: state.approval ? "waiting_for_approval" : activeTool ? "tool_running" : "running",
+    status: state.approval && !state.approval.automatic ? "waiting_for_approval" : activeTool ? "tool_running" : "running",
     activeTool,
     activities: activityUpdate.activities,
     activitiesTruncated: state.activitiesTruncated || activityUpdate.truncated,