@keyou007/agent-bot 0.1.20-alpha.1 → 0.1.21

package/src/feishu/FeishuTurnPresenter.ts

@@ -51,6 +51,7 @@ export interface FeishuTurnPresenterOptions {
   onError?: (error: unknown) => void;
   finalRetryBackoffMs?: number[];
   localFileUrl?: LocalFileUrlResolver;
+  turnPreviewUrl?: (turnId: string) => string | undefined;
 }
 
 const MAX_FINAL_TABLES_PER_CARD = 5;
@@ -76,6 +77,7 @@ export class FeishuTurnPresenter {
   private readonly sessionTitles = new Map<string, string>();
   private readonly sessionCwds = new Map<string, string>();
   private readonly sessionAgentLabels = new Map<string, string>();
+  private readonly sessionModels = new Map<string, string>();
   private readonly entries = new Map<string, TurnEntry>();
   private readonly pendingEntries = new Map<string, TurnEntry>();
   private readonly renderer: CardRenderer;
@@ -95,11 +97,25 @@ export class FeishuTurnPresenter {
     taskTitle?: string,
     projectCwd?: string,
     agentLabel?: string,
+    model?: string,
   ): void {
     this.sessionContexts.set(sessionId, contextKey);
     if (taskTitle) this.sessionTitles.set(sessionId, taskTitle);
     if (projectCwd) this.sessionCwds.set(sessionId, projectCwd);
     if (agentLabel) this.sessionAgentLabels.set(sessionId, agentLabel);
+    if (model) {
+      this.updateSessionModel(sessionId, model);
+    }
+  }
+
+  updateSessionModel(sessionId: string, model?: string): void {
+    if (!model) return;
+    this.sessionModels.set(sessionId, model);
+    const pending = this.pendingEntries.get(sessionId);
+    if (!pending || pending.state.model === model) return;
+    pending.state = { ...pending.state, model };
+    this.store.saveTurnSnapshot(pending.state.turnId, sessionId, pending.state, pending.contextKey);
+    if (!pending.historySnapshot) pending.scheduler?.update(pending.state, "critical");
   }
 
   updateSessionTitle(sessionId: string, taskTitle: string): void {
@@ -117,6 +133,7 @@ export class FeishuTurnPresenter {
     this.sessionTitles.delete(sessionId);
     this.sessionCwds.delete(sessionId);
     this.sessionAgentLabels.delete(sessionId);
+    this.sessionModels.delete(sessionId);
   }
 
   async startPendingTurn(
@@ -147,6 +164,7 @@ export class FeishuTurnPresenter {
       this.sessionCwds.get(sessionId),
       prompt,
       this.sessionAgentLabels.get(sessionId),
+      this.sessionModels.get(sessionId),
     );
     const entry = { contextKey, state, initializing: Promise.resolve() } as TurnEntry;
     this.entries.set(state.turnId, entry);
@@ -257,6 +275,7 @@ export class FeishuTurnPresenter {
               this.sessionCwds.get(sessionId),
               undefined,
               this.sessionAgentLabels.get(sessionId),
+              this.sessionModels.get(sessionId),
             ),
             status: "running" as const,
           };
@@ -292,6 +311,7 @@ export class FeishuTurnPresenter {
             pending.state.projectCwd,
             pending.state.prompt,
             pending.state.agentLabel,
+            pending.state.model,
           ),
           event,
         );
@@ -428,6 +448,7 @@ export class FeishuTurnPresenter {
           this.sessionCwds.get(event.sessionId),
           undefined,
           this.sessionAgentLabels.get(event.sessionId),
+          this.sessionModels.get(event.sessionId),
         );
     const state = reduceTurnEvent(
       initial,
@@ -476,15 +497,30 @@ export class FeishuTurnPresenter {
   }
 
   private renderTurn(state: TurnViewState): Record<string, unknown> {
-    return this.renderer.renderTurn(normalizeTurnCardMarkdown(state, this.options.localFileUrl));
+    return this.renderer.renderTurn(
+      normalizeTurnCardMarkdown(state, this.options.localFileUrl),
+      this.turnPreviewUrl(state),
+    );
   }
 
   private renderTurnDetails(state: TurnViewState): Record<string, unknown> {
-    return this.renderer.renderTurnDetails(normalizeTurnCardMarkdown(state, this.options.localFileUrl));
+    return this.renderer.renderTurnDetails(
+      normalizeTurnCardMarkdown(state, this.options.localFileUrl),
+      this.turnPreviewUrl(state),
+    );
   }
 
   private renderActivityHistory(state: TurnViewState, page: number): Record<string, unknown> {
-    return this.renderer.renderActivityHistory(normalizeTurnCardMarkdown(state, this.options.localFileUrl), page);
+    return this.renderer.renderActivityHistory(
+      normalizeTurnCardMarkdown(state, this.options.localFileUrl),
+      page,
+    );
+  }
+
+  private turnPreviewUrl(state: TurnViewState): string | undefined {
+    return state.turnId.startsWith("pending_")
+      ? undefined
+      : this.options.turnPreviewUrl?.(state.turnId);
   }
 
   private startElapsedUpdates(entry: TurnEntry): void {
@@ -642,7 +678,13 @@ function brandedFinalChunks(response: string, maxLength: number): string[] {
 }
 
 function eventPriority(event: AgentEvent): "normal" | "critical" {
-  if (event.type === "turn_started" || event.type === "approval_requested" || event.type === "approval_resolved" || event.type === "tool_started") {
+  if (
+    event.type === "turn_started"
+    || event.type === "approval_requested"
+    || event.type === "approval_resolved"
+    || event.type === "tool_started"
+    || event.type === "context_compaction"
+  ) {
     return "critical";
   }
   return "normal";

package/src/feishu/InboundText.ts

@@ -10,3 +10,14 @@ export function normalizeFeishuPostText(value: string): string {
     .replace(/\n{3,}/gu, "\n\n")
     .trim();
 }
+
+export function renderFeishuCodeBlock(text: string, language: unknown): string {
+  const code = text.replace(/\r\n?/gu, "\n").replace(/\n+$/gu, "");
+  if (!code) return "";
+  const longestBacktickRun = Math.max(0, ...[...code.matchAll(/`+/gu)].map((match) => match[0].length));
+  const fence = "`".repeat(Math.max(3, longestBacktickRun + 1));
+  const languageHint = typeof language === "string" && /^[A-Za-z0-9_+#.-]+$/u.test(language.trim())
+    ? language.trim().toLowerCase()
+    : "";
+  return `${fence}${languageHint}\n${code}\n${fence}`;
+}

package/src/feishu/MergedForwardMessage.ts

@@ -1,4 +1,4 @@
-import { normalizeFeishuPostText } from "./InboundText.js";
+import { normalizeFeishuPostText, renderFeishuCodeBlock } from "./InboundText.js";
 
 export const MAX_MERGED_FORWARD_PROMPT_CHARS = 48_000;
 
@@ -266,10 +266,12 @@ function renderPost(
   const paragraphs: string[] = [];
   const title = normalizeFeishuPostText(textValue(locale.title));
   if (title) paragraphs.push(title);
-  if (!Array.isArray(locale.content)) return paragraphs.join("\n");
-  for (const row of locale.content) {
+  const rows = Array.isArray(locale.content) ? locale.content : locale.content_v2;
+  if (!Array.isArray(rows)) return paragraphs.join("\n");
+  for (const row of rows) {
     if (!Array.isArray(row)) continue;
     let rowText = "";
+    let preserveFormatting = false;
     for (const rawElement of row) {
       if (!isRecord(rawElement)) continue;
       const tag = textValue(rawElement.tag);
@@ -279,6 +281,12 @@ function renderPost(
         const text = textValue(rawElement.text);
         const href = textValue(rawElement.href);
         rowText += href && href !== text ? `${text || href} (${href})` : text || href;
+      } else if (tag === "md") {
+        rowText += textValue(rawElement.text);
+        preserveFormatting = true;
+      } else if (tag === "code_block") {
+        rowText += renderFeishuCodeBlock(textValue(rawElement.text), rawElement.language);
+        preserveFormatting = true;
       } else if (tag === "at") {
         rowText += renderMention(rawElement, mentions);
       } else if (tag === "img") {
@@ -287,7 +295,9 @@ function renderPost(
         rowText += "[媒体]";
       }
     }
-    const normalized = normalizeFeishuPostText(rowText);
+    const normalized = preserveFormatting
+      ? rowText.replace(/\r\n?/gu, "\n").trim()
+      : normalizeFeishuPostText(rowText);
     if (normalized) paragraphs.push(normalized);
   }
   return paragraphs.join("\n");
@@ -314,7 +324,7 @@ function replaceMentions(text: string, mentions: MergedForwardMessageItem["menti
 }
 
 function selectPostLocale(content: Record<string, unknown>): Record<string, unknown> | undefined {
-  if (Array.isArray(content.content)) return content;
+  if (Array.isArray(content.content) || Array.isArray(content.content_v2)) return content;
   for (const locale of ["zh_cn", "en_us", "ja_jp"]) {
     if (isRecord(content[locale])) return content[locale];
   }

package/src/index.ts

@@ -80,6 +80,7 @@ if (config.fileViewer.enabled) {
     port: config.fileViewer.port,
     publicBaseUrl: config.fileViewer.publicBaseUrl,
     stateDirectory: path.join(path.dirname(config.storage.sqlitePath), "file-viewer"),
+    getTurnSnapshot: (turnId) => store.getTurnSnapshot(turnId),
   });
   try {
     const address = await viewer.start();
@@ -116,6 +117,7 @@ if (feishuOutbound) {
     criticalGapMs: 500,
     onError: (error) => logger.warn({ error }, "Failed to update Agent progress card."),
     localFileUrl: (filePath, reference) => localFileViewer?.createFileUrl(filePath, reference),
+    turnPreviewUrl: (turnId) => localFileViewer?.createTurnPreviewUrl(turnId),
   });
   routes.push({ matches: (contextKey) => !contextKey.startsWith("console:"), outbound: feishuOutbound, presenter });
   const defaultAgentName = config.defaults.agent!;
@@ -483,7 +485,7 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
         ),
       };
     case "task_turns":
-      return { ok: true, data: controller.controlListTaskTurns(request.localSessionId) };
+      return { ok: true, data: await controller.controlListTaskTurns(request.localSessionId) };
     case "task_reset":
       return { ok: true, data: await controller.controlResetTaskToTurn(request.localSessionId, request.turnId) };
     case "task_mute":

package/src/local-files/LocalFileViewerServer.ts

@@ -7,10 +7,18 @@ import dos from "highlight.js/lib/languages/dos";
 import dockerfile from "highlight.js/lib/languages/dockerfile";
 import powershell from "highlight.js/lib/languages/powershell";
 import MarkdownIt from "markdown-it";
+import { isFileUrl, rewriteMarkdownFileLinks } from "./MarkdownFileLinks.js";
 import {
   selectPreferredNetworkAddress,
   type NetworkConnectionKind,
 } from "./NetworkAddressSelector.js";
+import {
+  isTurnPreviewState,
+  detectTurnPreviewLanguage,
+  renderTurnPreviewPage,
+  renderTurnPreviewSnapshot,
+  TURN_PREVIEW_CLIENT_SCRIPT,
+} from "./TurnPreviewPage.js";
 
 const SECRET_FILE = "secret";
 const PORT_FILE = "port";
@@ -21,6 +29,7 @@ const MAX_CONTENT_SAMPLE_BYTES = 64 * 1024;
 const MAX_SYNTAX_HIGHLIGHT_BYTES = 512 * 1024;
 const DIRECTORY_PAGE_SIZE = 100;
 const MARKDOWN_EXTENSIONS = new Set([".markdown", ".md", ".mdown", ".mkd", ".mkdn"]);
+const HTML_EXTENSIONS = new Set([".html", ".htm"]);
 hljs.registerLanguage("dos", dos);
 hljs.registerLanguage("dockerfile", dockerfile);
 hljs.registerLanguage("powershell", powershell);
@@ -43,6 +52,8 @@ const MARKDOWN_RENDERER = new MarkdownIt({
 MARKDOWN_RENDERER.renderer.rules.table_open = () =>
   '<div class="markdown-table-scroll" role="region" aria-label="Markdown 表格" tabindex="0"><table>\n';
 MARKDOWN_RENDERER.renderer.rules.table_close = () => '</table></div>\n';
+const validateMarkdownLink = MARKDOWN_RENDERER.validateLink.bind(MARKDOWN_RENDERER);
+MARKDOWN_RENDERER.validateLink = (url) => isFileUrl(url) || validateMarkdownLink(url);
 
 const HIGHLIGHT_LANGUAGE_BY_EXTENSION: Readonly<Record<string, string>> = {
   ".bash": "bash", ".bat": "dos", ".c": "c", ".cc": "cpp", ".cmd": "dos", ".cpp": "cpp",
@@ -132,7 +143,10 @@ const VIEWER_CLIENT_SCRIPT = `(() => {
   if (typeof ResizeObserver === "function") {
     new ResizeObserver(updateHeaderOffset).observe(header);
   }
-  window.addEventListener("hashchange", () => requestAnimationFrame(positionHashTarget));
+  window.addEventListener("hashchange", () => {
+    if (/^#L\\d+$/u.test(window.location.hash)) setViewMode("code");
+    else requestAnimationFrame(positionHashTarget);
+  });
   requestAnimationFrame(positionHashTarget);
   if (!eventsUrl || typeof EventSource !== "function") return;
 
@@ -166,7 +180,7 @@ const VIEWER_CLIENT_SCRIPT = `(() => {
     try {
       const update = JSON.parse(event.data);
       if (typeof update.content === "string" && typeof update.metadata === "string") {
-        if (viewSwitch) viewSwitch.hidden = update.viewMode !== "markdown";
+        if (viewSwitch) viewSwitch.hidden = update.viewMode !== "markdown" && update.viewMode !== "html";
         replaceContent(update.content, update.metadata);
       }
     } catch {
@@ -208,7 +222,7 @@ interface DirectoryViewerEntry {
 interface RenderedFileSnapshot {
   content: string;
   metadata: string[];
-  viewMode?: "markdown";
+  viewMode?: "markdown" | "html";
 }
 
 export interface LocalFileViewerServerOptions {
@@ -216,6 +230,8 @@ export interface LocalFileViewerServerOptions {
   port: number;
   publicBaseUrl?: string;
   stateDirectory: string;
+  getTurnSnapshot?: (turnId: string) => unknown;
+  turnPreviewPollIntervalMs?: number;
 }
 
 export interface LocalFileViewerAddress {
@@ -327,6 +343,18 @@ export class LocalFileViewerServer {
     return url.toString();
   }
 
+  createTurnPreviewUrl(turnId: string): string | undefined {
+    const normalizedTurnId = normalizeTurnId(turnId);
+    if (!this.address || !this.secret || !this.options.getTurnSnapshot || !normalizedTurnId) return undefined;
+    const url = new URL(this.address.publicBaseUrl);
+    url.pathname = `${this.basePath}/turn-preview/${this.createShortToken(`turn:${normalizedTurnId}`)}`
+      .replace(/\/{2,}/gu, "/");
+    url.search = "";
+    url.hash = "";
+    url.searchParams.set("turn", normalizedTurnId);
+    return url.toString();
+  }
+
   private async handleRequest(request: IncomingMessage, response: ServerResponse): Promise<void> {
     if (request.method !== "GET" && request.method !== "HEAD") {
       response.setHeader("Allow", "GET, HEAD");
@@ -344,6 +372,42 @@ export class LocalFileViewerServer {
       this.sendJavascript(response, request.method === "HEAD");
       return;
     }
+    if (route === "/assets/turn-preview.js") {
+      this.sendJavascript(response, request.method === "HEAD", TURN_PREVIEW_CLIENT_SCRIPT);
+      return;
+    }
+    const turnPreviewMatch = new RegExp(`^/turn-preview/([A-Za-z0-9_-]{${SHORT_TOKEN_LENGTH}})$`, "u").exec(route);
+    if (turnPreviewMatch) {
+      const turnId = this.verifyTurnPreviewToken(
+        turnPreviewMatch[1] ?? "",
+        requestUrl.searchParams.get("turn") ?? "",
+      );
+      if (!turnId) {
+        this.sendHtml(response, 403, errorPage("Turn 链接无效", "签名校验失败，Agent Bot 已拒绝该请求。"), request.method === "HEAD");
+        return;
+      }
+      const snapshot = this.options.getTurnSnapshot?.(turnId);
+      if (!isTurnPreviewState(snapshot)) {
+        this.sendHtml(response, 404, errorPage("Turn 不存在", "这次执行可能尚未保存或已被清理。"), request.method === "HEAD");
+        return;
+      }
+      if (requestUrl.searchParams.get("events") === "1") {
+        this.serveTurnEvents(request, response, turnId);
+        return;
+      }
+      const eventsUrl = new URL(this.createTurnPreviewUrl(turnId)!);
+      eventsUrl.searchParams.set("events", "1");
+      const language = detectTurnPreviewLanguage(request.headers["accept-language"]);
+      const html = renderTurnPreviewPage({
+        state: snapshot,
+        eventsUrl: eventsUrl.toString(),
+        scriptPath: `${this.basePath}/assets/turn-preview.js`.replace(/\/{2,}/gu, "/"),
+        localFileUrl: (filePath) => this.createFileUrl(filePath),
+        language,
+      });
+      this.sendHtml(response, 200, html, request.method === "HEAD");
+      return;
+    }
     const previewMatch = new RegExp(`^/preview/([A-Za-z0-9_-]{${SHORT_TOKEN_LENGTH}})$`, "u").exec(route);
     const legacyMatch = /^\/(view|raw)\/([A-Za-z0-9_-]+)$/u.exec(route);
     const previewPath = previewMatch?.[1]
@@ -381,12 +445,13 @@ export class LocalFileViewerServer {
     }
 
     const raw = legacyMatch?.[1] === "raw" || requestUrl.searchParams.get("raw") === "1";
-    if (raw) {
+    const renderHtml = !raw && requestUrl.searchParams.get("render") === "html";
+    if (raw || renderHtml) {
       if (stat.isDirectory()) {
         this.sendHtml(response, 400, errorPage("无法打开目录", "目录只能通过文件列表页面浏览。"), request.method === "HEAD");
         return;
       }
-      this.serveRawFile(request, response, filePath, stat, requestUrl.searchParams.get("download") === "1");
+      this.serveRawFile(request, response, filePath, stat, requestUrl.searchParams.get("download") === "1", renderHtml);
       return;
     }
 
@@ -424,6 +489,17 @@ export class LocalFileViewerServer {
       : undefined;
   }
 
+  private verifyTurnPreviewToken(token: string, rawTurnId: string): string | undefined {
+    const turnId = normalizeTurnId(rawTurnId);
+    if (!turnId || !this.secret) return undefined;
+    const expected = this.createShortToken(`turn:${turnId}`);
+    const actualBuffer = Buffer.from(token, "utf8");
+    const expectedBuffer = Buffer.from(expected, "utf8");
+    return actualBuffer.length === expectedBuffer.length && timingSafeEqual(actualBuffer, expectedBuffer)
+      ? turnId
+      : undefined;
+  }
+
   private sign(token: string): string {
     return createHmac("sha256", this.secret!).update(token).digest("hex");
   }
@@ -493,12 +569,25 @@ export class LocalFileViewerServer {
     appendUrlQueryParameter(rawUrl, "raw", "1");
 
     let content: string;
+    let viewMode: RenderedFileSnapshot["viewMode"];
     if (classification.kind === "text") {
       const preview = readTextPreview(filePath, stat.size, classification.encoding);
-      const previewContent = isMarkdownFile(filePath)
-        ? renderMarkdownDocument(preview.text, filePath)
-        : renderText(preview.text, filePath);
-      content = `${preview.truncated ? '<div class="notice">文件较大，仅显示开头 2 MiB。可使用下方按钮查看或下载完整文件。</div>' : ""}${previewContent}`;
+      const notice = preview.truncated
+        ? '<div class="notice">文件较大，源码仅显示开头 2 MiB。可打开原始文件或下载完整文件。</div>'
+        : "";
+      if (HTML_EXTENSIONS.has(extension)) {
+        viewMode = "html";
+        const renderUrl = this.createPreviewUrl(filePath);
+        appendUrlQueryParameter(renderUrl, "render", "html");
+        appendUrlQueryParameter(renderUrl, "version", `${stat.mtimeMs}-${stat.ctimeMs}-${stat.size}`);
+        content = `<iframe class="html-preview" data-view-panel="rendered" title="HTML 预览" sandbox="allow-scripts" referrerpolicy="no-referrer" src="${escapeAttribute(renderUrl.toString())}"></iframe><section data-view-panel="code">${notice}${renderText(preview.text, filePath)}</section>`;
+      } else {
+        viewMode = isMarkdownFile(filePath) ? "markdown" : undefined;
+        const previewContent = viewMode === "markdown"
+          ? renderMarkdownDocument(preview.text, filePath, (target) => this.createPreviewUrl(target))
+          : renderText(preview.text, filePath);
+        content = `${notice}${previewContent}`;
+      }
     } else if (contentType.startsWith("image/")) {
       content = `<div class="media"><img src="${escapeAttribute(rawUrl.toString())}" alt="${escapeAttribute(fileName)}"></div>`;
     } else if (contentType === "application/pdf") {
@@ -513,9 +602,7 @@ export class LocalFileViewerServer {
     return {
       content,
       metadata: [formatFileSize(stat.size), stat.mtime.toLocaleString()],
-      ...(classification.kind === "text" && isMarkdownFile(filePath)
-        ? { viewMode: "markdown" as const }
-        : {}),
+      ...(viewMode ? { viewMode } : {}),
     };
   }
 
@@ -584,6 +671,57 @@ export class LocalFileViewerServer {
     response.once("close", cleanup);
   }
 
+  private serveTurnEvents(request: IncomingMessage, response: ServerResponse, turnId: string): void {
+    setSecurityHeaders(response);
+    response.statusCode = 200;
+    response.setHeader("Cache-Control", "no-cache, no-store");
+    response.setHeader("Connection", "keep-alive");
+    response.setHeader("Content-Type", "text/event-stream; charset=utf-8");
+    response.setHeader("X-Accel-Buffering", "no");
+    if (request.method === "HEAD") {
+      response.end();
+      return;
+    }
+    response.flushHeaders();
+    response.write("retry: 2000\n\n");
+    const language = detectTurnPreviewLanguage(request.headers["accept-language"]);
+
+    let closed = false;
+    let previousSnapshot = "";
+    const sendSnapshot = () => {
+      if (closed || response.destroyed) return;
+      const state = this.options.getTurnSnapshot?.(turnId);
+      if (!isTurnPreviewState(state)) {
+        writeServerSentEvent(response, "unavailable", JSON.stringify({ message: "Turn 暂时无法读取。" }));
+        return;
+      }
+      const serialized = JSON.stringify(state);
+      if (serialized === previousSnapshot) return;
+      previousSnapshot = serialized;
+      const snapshot = renderTurnPreviewSnapshot(state, (filePath) => this.createFileUrl(filePath), language);
+      writeServerSentEvent(response, "update", JSON.stringify(snapshot));
+    };
+    sendSnapshot();
+    const poller = setInterval(
+      sendSnapshot,
+      Math.max(50, this.options.turnPreviewPollIntervalMs ?? 1_000),
+    );
+    poller.unref();
+    const keepAlive = setInterval(() => {
+      if (!closed && !response.destroyed) response.write(": keep-alive\n\n");
+    }, 15_000);
+    keepAlive.unref();
+
+    const cleanup = () => {
+      if (closed) return;
+      closed = true;
+      clearInterval(poller);
+      clearInterval(keepAlive);
+    };
+    request.once("aborted", cleanup);
+    response.once("close", cleanup);
+  }
+
   private renderDirectoryViewer(directory: string, stat: fs.Stats, requestedPage: number): string {
     const entries = fs.readdirSync(directory, { withFileTypes: true })
       .flatMap((entry): DirectoryViewerEntry[] => {
@@ -632,9 +770,14 @@ export class LocalFileViewerServer {
     filePath: string,
     stat: fs.Stats,
     download: boolean,
+    renderHtml = false,
   ): void {
     const extension = path.extname(filePath).toLowerCase();
     const classification = classifyFileContent(filePath, stat.size);
+    if (renderHtml && (!HTML_EXTENSIONS.has(extension) || classification.kind !== "text")) {
+      this.sendHtml(response, 400, errorPage("无法预览 HTML", "只有 HTML 文本文件支持此预览模式。"), request.method === "HEAD");
+      return;
+    }
     const contentType = classification.kind === "text"
       ? textContentTypeFor(extension, classification.encoding)
       : binaryContentTypeFor(extension);
@@ -642,6 +785,10 @@ export class LocalFileViewerServer {
     const fileName = path.basename(filePath);
     const disposition = download ? "attachment" : "inline";
     setSecurityHeaders(response);
+    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'");
+    }
     response.setHeader("Accept-Ranges", "bytes");
     response.setHeader("Cache-Control", "no-store");
     response.setHeader("Content-Type", contentType);
@@ -680,8 +827,8 @@ export class LocalFileViewerServer {
     response.end(headOnly ? undefined : body);
   }
 
-  private sendJavascript(response: ServerResponse, headOnly: boolean): void {
-    const body = Buffer.from(VIEWER_CLIENT_SCRIPT, "utf8");
+  private sendJavascript(response: ServerResponse, headOnly: boolean, source = VIEWER_CLIENT_SCRIPT): void {
+    const body = Buffer.from(source, "utf8");
     setSecurityHeaders(response);
     response.statusCode = 200;
     response.setHeader("Cache-Control", "no-store");
@@ -697,14 +844,14 @@ function renderViewerPage(input: {
   metadata: string[];
   actions: Array<{ href: string; label: string }>;
   content: string;
-  viewMode?: "markdown";
+  viewMode?: RenderedFileSnapshot["viewMode"];
   liveUpdates?: { eventsUrl: string; scriptPath: string };
 }): string {
   const metadata = renderMetadata(input.metadata);
   const actions = input.actions.length > 0
     ? `<nav class="actions">${input.actions.map((action) => `<a href="${escapeAttribute(action.href)}">${escapeHtml(action.label)}</a>`).join("")}</nav>`
     : "";
-  const viewSwitch = input.viewMode === "markdown"
+  const viewSwitch = input.viewMode
     ? '<div class="view-switch" id="viewer-view-switch" role="tablist" aria-label="预览模式"><button class="is-active" type="button" role="tab" aria-selected="true" data-view-mode-button="rendered">预览</button><button type="button" role="tab" aria-selected="false" data-view-mode-button="code">代码</button></div>'
     : "";
   const toolbar = viewSwitch || actions
@@ -781,6 +928,7 @@ function renderViewerPage(input: {
     .media img, .media video { max-width: 100%; max-height: calc(100vh - 70px); }
     .media audio { width: min(720px, 100%); }
     .document { width: 100%; height: calc(100vh - 70px); border: 0; border-radius: 0; background: #fff; }
+    .html-preview { display: block; width: 100%; height: calc(100dvh - var(--viewer-header-offset)); min-height: 240px; border: 0; background: #fff; color-scheme: normal; }
     .directory-list { overflow: hidden; border: 0; border-radius: 0; background: #fff; }
     .directory-entry { display: grid; grid-template-columns: minmax(0, 1fr) auto auto; gap: 18px; align-items: center; min-height: 44px; padding: 8px 14px; color: inherit; text-decoration: none; border-bottom: 1px solid #eceff3; }
     .directory-entry:last-child { border-bottom: 0; }
@@ -828,7 +976,7 @@ function renderViewerPage(input: {
     }
   </style>
 </head>
-<body${input.viewMode === "markdown" ? ' data-view-mode="rendered"' : ""}${liveAttributes}>
+<body${input.viewMode ? ' data-view-mode="rendered"' : ""}${liveAttributes}>
   <header id="viewer-header">
     <h1 id="viewer-title" data-file-path="${escapeAttribute(input.filePath)}">${escapeHtml(input.filePath)}</h1>
     <div class="meta"><span class="metadata-values" id="viewer-metadata">${metadata}</span>${toolbar}</div>
@@ -1084,8 +1232,12 @@ function renderText(value: string, filePath: string): string {
   }).join("")}</code></pre>`;
 }
 
-function renderMarkdownDocument(value: string, filePath: string): string {
-  return `<article class="markdown-body" data-view-panel="rendered">${MARKDOWN_RENDERER.render(value)}</article><section data-view-panel="code">${renderText(value, filePath)}</section>`;
+function renderMarkdownDocument(value: string, filePath: string, createPreviewUrl: (filePath: string) => URL): string {
+  const environment = {};
+  const tokens = MARKDOWN_RENDERER.parse(value, environment);
+  rewriteMarkdownFileLinks(tokens, filePath, createPreviewUrl);
+  const rendered = MARKDOWN_RENDERER.renderer.render(tokens, MARKDOWN_RENDERER.options, environment);
+  return `<article class="markdown-body" data-view-panel="rendered">${rendered}</article><section data-view-panel="code">${renderText(value, filePath)}</section>`;
 }
 
 function isMarkdownFile(filePath: string): boolean {
@@ -1211,7 +1363,7 @@ function writeServerSentEvent(response: ServerResponse, event: string, data: str
 }
 
 function setSecurityHeaders(response: ServerResponse): void {
-  response.setHeader("Content-Security-Policy", "default-src 'none'; img-src 'self' data:; media-src 'self'; object-src 'self'; script-src 'self'; connect-src 'self'; style-src 'unsafe-inline'; base-uri 'none'; form-action 'none'; frame-ancestors 'self'");
+  response.setHeader("Content-Security-Policy", "default-src 'none'; img-src 'self' data:; media-src 'self'; object-src 'self'; frame-src 'self'; script-src 'self'; connect-src 'self'; style-src 'unsafe-inline'; base-uri 'none'; form-action 'none'; frame-ancestors 'self'");
   response.setHeader("Cross-Origin-Resource-Policy", "same-origin");
   response.setHeader("Referrer-Policy", "no-referrer");
   response.setHeader("X-Content-Type-Options", "nosniff");
@@ -1226,6 +1378,13 @@ function escapeAttribute(value: string): string {
   return escapeHtml(value);
 }
 
+function normalizeTurnId(value: string): string | undefined {
+  const normalized = value.trim();
+  return normalized && normalized.length <= 256 && !normalized.includes("\0")
+    ? normalized
+    : undefined;
+}
+
 function errorPage(title: string, message: string): string {
   return `<!doctype html><html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>${escapeHtml(title)} · Agent Bot</title><style>body{font-family:system-ui,sans-serif;max-width:720px;margin:12vh auto;padding:0 24px;color:#1f2329}h1{font-size:24px}p{color:#646a73}</style></head><body><h1>${escapeHtml(title)}</h1><p>${escapeHtml(message)}</p></body></html>`;
 }

package/src/local-files/MarkdownFileLinks.ts

@@ -0,0 +1,64 @@
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import type { Token } from "markdown-it";
+
+export function isFileUrl(value: string): boolean {
+  return /^file:/iu.test(value);
+}
+
+export function rewriteMarkdownFileLinks(
+  tokens: Token[],
+  markdownPath: string,
+  createPreviewUrl: (filePath: string) => URL,
+): void {
+  for (const token of tokens) {
+    const attribute = token.type === "link_open" ? "href" : token.type === "image" ? "src" : undefined;
+    const target = attribute ? token.attrGet(attribute) : null;
+    if (attribute && typeof target === "string" && target) {
+      const local = resolveLocalTarget(target, markdownPath);
+      if (local) {
+        const url = createPreviewUrl(local.filePath);
+        url.hash = local.hash;
+        if (token.type === "image") url.searchParams.set("raw", "1");
+        token.attrSet(attribute, url.toString());
+      } else if (isFileUrl(target)) {
+        // File URLs are accepted by the parser only to convert them to signed HTTP URLs.
+        token.attrs = token.attrs?.filter(([name]) => name !== attribute) ?? null;
+      }
+    }
+    if (token.children) rewriteMarkdownFileLinks(token.children, markdownPath, createPreviewUrl);
+  }
+}
+
+function resolveLocalTarget(target: string, markdownPath: string): { filePath: string; hash: string } | undefined {
+  if (/^(?:#|\?|\/\/)/u.test(target)) return undefined;
+  const windows = process.platform === "win32";
+  const normalized = windows ? target.replace(/%5c/giu, "/").replaceAll("\\", "/") : target;
+  const drivePath = /^\/?[a-z]:\//iu.test(normalized);
+  const relativeFileWithLine = /^[^:/]+\.[^:/]+:\d+(?::\d+)?(?:#.*)?$/u.test(normalized);
+  if (!drivePath && !isFileUrl(normalized) && !relativeFileWithLine && /^[a-z][a-z\d+.-]*:/iu.test(normalized)) return undefined;
+  const pathEnd = normalized.search(/[?#]/u);
+  const pathTarget = pathEnd < 0 ? normalized : normalized.slice(0, pathEnd);
+  const reference = /:(\d+)(?::\d+)?$/u.exec(pathTarget);
+  const withoutReference = reference
+    ? normalized.slice(0, reference.index) + normalized.slice(reference.index + reference[0].length)
+    : normalized;
+  if (drivePath && !windows) return undefined;
+
+  try {
+    const url = drivePath
+      ? new URL(`file:///${withoutReference.replace(/^\//u, "")}`)
+      : new URL(withoutReference, pathToFileURL(markdownPath));
+    if (url.protocol !== "file:") return undefined;
+    const filePath = fileURLToPath(url);
+    if (!path.isAbsolute(filePath) || /[\x00-\x1f\x7f]/u.test(filePath)) return undefined;
+    const line = /^#L(\d+)(?:C\d+)?(?:-L?\d+(?:C\d+)?)?$/u.exec(url.hash)?.[1]
+      ?? (url.hash ? undefined : reference?.[1]);
+    const hash = line && Number.isSafeInteger(Number(line)) && Number(line) > 0
+      ? `#L${Number(line)}`
+      : url.hash;
+    return { filePath: path.resolve(filePath), hash };
+  } catch {
+    return undefined;
+  }
+}