@keyou007/agent-bot 0.1.20 → 0.1.22

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/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!;

package/src/local-files/LocalFileViewerServer.ts

@@ -12,6 +12,13 @@ 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";
@@ -22,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);
@@ -172,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 {
@@ -214,7 +222,7 @@ interface DirectoryViewerEntry {
 interface RenderedFileSnapshot {
   content: string;
   metadata: string[];
-  viewMode?: "markdown";
+  viewMode?: "markdown" | "html";
 }
 
 export interface LocalFileViewerServerOptions {
@@ -222,6 +230,8 @@ export interface LocalFileViewerServerOptions {
   port: number;
   publicBaseUrl?: string;
   stateDirectory: string;
+  getTurnSnapshot?: (turnId: string) => unknown;
+  turnPreviewPollIntervalMs?: number;
 }
 
 export interface LocalFileViewerAddress {
@@ -333,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");
@@ -350,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]
@@ -387,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;
     }
 
@@ -430,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");
   }
@@ -499,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, (target) => this.createPreviewUrl(target))
-        : 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") {
@@ -519,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 } : {}),
     };
   }
 
@@ -541,10 +622,12 @@ export class LocalFileViewerServer {
 
     let closed = false;
     let pendingUpdate: NodeJS.Timeout | undefined;
+    let previousStat: fs.Stats | undefined;
     const sendSnapshot = () => {
       if (closed || response.destroyed) return;
       try {
         const stat = fs.statSync(filePath);
+        previousStat = stat;
         if (!stat.isFile()) throw new Error("Path is no longer a file");
         const snapshot = this.renderFileSnapshot(filePath, stat);
         writeServerSentEvent(response, "update", JSON.stringify({
@@ -563,17 +646,27 @@ export class LocalFileViewerServer {
       pendingUpdate = setTimeout(sendSnapshot, 100);
       pendingUpdate.unref();
     };
-    const watcher = (current: fs.Stats, previous: fs.Stats) => {
-      if (
-        current.mtimeMs === previous.mtimeMs
-        && current.ctimeMs === previous.ctimeMs
-        && current.size === previous.size
-        && current.nlink === previous.nlink
-      ) return;
-      scheduleSnapshot();
-    };
-    fs.watchFile(filePath, { interval: 1_000, persistent: false }, watcher);
     sendSnapshot();
+    // Compare against the sent snapshot so edits during watcher startup cannot be missed.
+    let checking = false;
+    const poller = setInterval(() => {
+      if (closed || checking) return;
+      checking = true;
+      fs.stat(filePath, (error, stat) => {
+        checking = false;
+        if (closed) return;
+        const current = error ? undefined : stat;
+        if (
+          current?.mtimeMs === previousStat?.mtimeMs
+          && current?.ctimeMs === previousStat?.ctimeMs
+          && current?.size === previousStat?.size
+          && current?.nlink === previousStat?.nlink
+        ) return;
+        previousStat = current;
+        scheduleSnapshot();
+      });
+    }, 1_000);
+    poller.unref();
     const keepAlive = setInterval(() => {
       if (!closed && !response.destroyed) response.write(": keep-alive\n\n");
     }, 15_000);
@@ -584,7 +677,58 @@ export class LocalFileViewerServer {
       closed = true;
       if (pendingUpdate) clearTimeout(pendingUpdate);
       clearInterval(keepAlive);
-      fs.unwatchFile(filePath, watcher);
+      clearInterval(poller);
+    };
+    request.once("aborted", cleanup);
+    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);
@@ -638,9 +782,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);
@@ -648,6 +797,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);
@@ -686,8 +839,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");
@@ -703,14 +856,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
@@ -787,6 +940,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; }
@@ -834,7 +988,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>
@@ -1221,7 +1375,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");
@@ -1236,6 +1390,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

@@ -8,8 +8,8 @@ export function isFileUrl(value: string): boolean {
 
 export function rewriteMarkdownFileLinks(
   tokens: Token[],
-  markdownPath: string,
-  createPreviewUrl: (filePath: string) => URL,
+  markdownPath: string | undefined,
+  createPreviewUrl: (filePath: string) => URL | undefined,
 ): void {
   for (const token of tokens) {
     const attribute = token.type === "link_open" ? "href" : token.type === "image" ? "src" : undefined;
@@ -18,9 +18,13 @@ export function rewriteMarkdownFileLinks(
       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());
+        if (url) {
+          url.hash = local.hash;
+          if (token.type === "image") url.searchParams.set("raw", "1");
+          token.attrSet(attribute, url.toString());
+        } else {
+          token.attrs = token.attrs?.filter(([name]) => name !== attribute) ?? null;
+        }
       } 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;
@@ -30,7 +34,7 @@ export function rewriteMarkdownFileLinks(
   }
 }
 
-function resolveLocalTarget(target: string, markdownPath: string): { filePath: string; hash: string } | undefined {
+function resolveLocalTarget(target: string, markdownPath: string | undefined): { 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;
@@ -44,11 +48,12 @@ function resolveLocalTarget(target: string, markdownPath: string): { filePath: s
     ? normalized.slice(0, reference.index) + normalized.slice(reference.index + reference[0].length)
     : normalized;
   if (drivePath && !windows) return undefined;
+  if (!markdownPath && !drivePath && !isFileUrl(normalized) && !path.isAbsolute(normalized)) return undefined;
 
   try {
     const url = drivePath
       ? new URL(`file:///${withoutReference.replace(/^\//u, "")}`)
-      : new URL(withoutReference, pathToFileURL(markdownPath));
+      : new URL(withoutReference, markdownPath ? pathToFileURL(markdownPath) : "file:///");
     if (url.protocol !== "file:") return undefined;
     const filePath = fileURLToPath(url);
     if (!path.isAbsolute(filePath) || /[\x00-\x1f\x7f]/u.test(filePath)) return undefined;