@keyou007/agent-bot 0.1.17-alpha.1 → 0.1.17

package/src/feishu/FeishuTurnPresenter.ts

@@ -8,7 +8,7 @@ import { splitMarkdown } from "../presentation/splitMarkdown.js";
 import type { TurnViewState } from "../presentation/turnViewTypes.js";
 import { CardRenderer } from "./CardRenderer.js";
 import { CardUpdateScheduler } from "./CardUpdateScheduler.js";
-import { normalizeFeishuMarkdown } from "./FeishuMarkdown.js";
+import { normalizeFeishuMarkdown, type LocalFileUrlResolver } from "./FeishuMarkdown.js";
 import type { FeishuOutbound, MessageReplyTarget } from "./types.js";
 import {
   FINAL_RESPONSE_BRANDING_BLOCK,
@@ -50,6 +50,7 @@ export interface FeishuTurnPresenterOptions {
   finalChunkLength?: number;
   onError?: (error: unknown) => void;
   finalRetryBackoffMs?: number[];
+  localFileUrl?: LocalFileUrlResolver;
 }
 
 const MAX_FINAL_TABLES_PER_CARD = 5;
@@ -215,7 +216,7 @@ export class FeishuTurnPresenter {
     }
     const delivery = this.store.getTurnDelivery(turnId);
     if (delivery?.progressMessageId) {
-      await this.outbound.updateInteractiveCard(delivery.progressMessageId, this.renderer.renderTurn(state));
+      await this.outbound.updateInteractiveCard(delivery.progressMessageId, this.renderTurn(state));
     }
   }
 
@@ -332,7 +333,7 @@ export class FeishuTurnPresenter {
       await this.outbound.sendText(contextKey, "未找到这次执行的详情。可能已被清理。");
       return;
     }
-    await this.outbound.sendInteractiveCard(contextKey, this.renderer.renderTurnDetails(snapshot));
+    await this.outbound.sendInteractiveCard(contextKey, this.renderTurnDetails(snapshot));
   }
 
   async showActivityPage(
@@ -355,9 +356,9 @@ export class FeishuTurnPresenter {
           entry.scheduler.invalidateRenderedCard();
           await entry.scheduler.flush(entry.state);
         } else if (targetMessageId) {
-          await this.outbound.updateInteractiveCard(targetMessageId, this.renderer.renderTurn(entry.state));
+          await this.outbound.updateInteractiveCard(targetMessageId, this.renderTurn(entry.state));
         } else {
-          await this.outbound.sendInteractiveCard(contextKey, this.renderer.renderTurn(entry.state));
+          await this.outbound.sendInteractiveCard(contextKey, this.renderTurn(entry.state));
         }
         return;
       }
@@ -366,7 +367,7 @@ export class FeishuTurnPresenter {
         entry.historySnapshot = entry.state;
         await entry.scheduler?.flush();
       }
-      const card = this.renderer.renderActivityHistory(entry.historySnapshot, page);
+      const card = this.renderActivityHistory(entry.historySnapshot, page);
       if (targetMessageId) await this.outbound.updateInteractiveCard(targetMessageId, card);
       else await this.outbound.sendInteractiveCard(contextKey, card);
       return;
@@ -375,8 +376,8 @@ export class FeishuTurnPresenter {
     const snapshot = this.store.getTurnSnapshot(turnId);
     if (!isTurnViewState(snapshot)) throw new Error("未找到这次执行的活动历史。");
     const card = page === "latest"
-      ? this.renderer.renderTurn(snapshot)
-      : this.renderer.renderActivityHistory(snapshot, page);
+      ? this.renderTurn(snapshot)
+      : this.renderActivityHistory(snapshot, page);
     if (messageId) await this.outbound.updateInteractiveCard(messageId, card);
     else await this.outbound.sendInteractiveCard(contextKey, card);
   }
@@ -428,7 +429,7 @@ export class FeishuTurnPresenter {
 
   private async initializeEntry(entry: TurnEntry): Promise<void> {
     const sentState = entry.state;
-    const card = this.renderer.renderTurn(sentState);
+    const card = this.renderTurn(sentState);
     const delivery = this.store.getTurnDelivery(sentState.turnId);
     const persistedMessageId = delivery?.progressMessageId;
     if (delivery?.finalDelivered && !persistedMessageId) return;
@@ -449,7 +450,7 @@ export class FeishuTurnPresenter {
     if (!messageId) return;
     this.store.saveTurnDelivery(entry.state.turnId, { progressMessageId: messageId });
     entry.scheduler = new CardUpdateScheduler<TurnViewState>({
-      render: (state) => this.renderer.renderTurn(state),
+      render: (state) => this.renderTurn(state),
       write: (card) => this.outbound.updateInteractiveCard(messageId, card),
       normalIntervalMs: this.options.normalIntervalMs,
       criticalGapMs: this.options.criticalGapMs,
@@ -461,6 +462,18 @@ export class FeishuTurnPresenter {
     await this.syncThinkingCardReaction(entry);
   }
 
+  private renderTurn(state: TurnViewState): Record<string, unknown> {
+    return this.renderer.renderTurn(normalizeTurnCardMarkdown(state, this.options.localFileUrl));
+  }
+
+  private renderTurnDetails(state: TurnViewState): Record<string, unknown> {
+    return this.renderer.renderTurnDetails(normalizeTurnCardMarkdown(state, this.options.localFileUrl));
+  }
+
+  private renderActivityHistory(state: TurnViewState, page: number): Record<string, unknown> {
+    return this.renderer.renderActivityHistory(normalizeTurnCardMarkdown(state, this.options.localFileUrl), page);
+  }
+
   private startElapsedUpdates(entry: TurnEntry): void {
     if (entry.elapsedTimer || isTerminalViewStatus(entry.state.status)) return;
     const intervalMs = Math.max(1, this.options.elapsedUpdateIntervalMs ?? DEFAULT_ELAPSED_UPDATE_INTERVAL_MS);
@@ -539,7 +552,7 @@ export class FeishuTurnPresenter {
     if (delivery?.finalDelivered || !state.finalResponse) return;
     const finalChunkLength = this.options.finalChunkLength ?? 4_000;
     const chunks = brandedFinalChunks(
-      normalizeFeishuMarkdown(state.finalResponse, state.projectCwd),
+      normalizeFeishuMarkdown(state.finalResponse, state.projectCwd, this.options.localFileUrl),
       finalChunkLength,
     );
     const messageIds = [...(delivery?.finalMessageIds ?? [])];
@@ -579,6 +592,23 @@ export class FeishuTurnPresenter {
   }
 }
 
+function normalizeTurnCardMarkdown(
+  state: TurnViewState,
+  localFileUrl: LocalFileUrlResolver | undefined,
+): TurnViewState {
+  if (!localFileUrl) return state;
+  const normalize = (value: string): string => normalizeFeishuMarkdown(value, state.projectCwd, localFileUrl);
+  return {
+    ...state,
+    assistantText: normalize(state.assistantText),
+    ...(state.progressText !== undefined ? { progressText: normalize(state.progressText) } : {}),
+    plan: state.plan.map((step) => ({ ...step, text: normalize(step.text) })),
+    activities: state.activities.map((activity) => activity.kind === "tool"
+      ? activity
+      : { ...activity, text: normalize(activity.text) }),
+  };
+}
+
 function brandedFinalChunks(response: string, maxLength: number): string[] {
   const chunks = splitMarkdown(response, maxLength, MAX_FINAL_TABLES_PER_CARD);
   if (chunks.length <= 1 && response.length <= FINAL_RESPONSE_BRANDING_THRESHOLD) return chunks;

package/src/feishu/LocalImageMarkdown.ts

@@ -29,7 +29,7 @@ export async function renderMarkdownWithLocalImages(
       continue;
     }
 
-    appendMarkdown(elements, markdown.slice(cursor, matchIndex));
+    appendMarkdown(elements, markdownBeforeLocalImage(markdown, cursor, matchIndex, matchIndex + match[0].length));
     try {
       let upload = uploads.get(filePath);
       if (!upload) {
@@ -86,7 +86,28 @@ function unsupportedImageFallback(label: string, rawTarget: string): string {
     : `图片不可用：${label || "本地图片"}`;
 }
 
+function markdownBeforeLocalImage(
+  markdown: string,
+  cursor: number,
+  matchStart: number,
+  matchEnd: number,
+): string {
+  const lineStart = markdown.lastIndexOf("\n", matchStart - 1) + 1;
+  if (lineStart < cursor) return markdown.slice(cursor, matchStart);
+
+  const lineEndIndex = markdown.indexOf("\n", matchEnd);
+  const lineEnd = lineEndIndex === -1 ? markdown.length : lineEndIndex;
+  const beforeLink = markdown.slice(lineStart, matchStart);
+  const afterLink = markdown.slice(matchEnd, lineEnd);
+  const standaloneListMarker = /^[ \t]*(?:[-+*]|\d+[.)])[ \t]+$/u.test(beforeLink);
+  if (!standaloneListMarker || !/^[ \t]*\r?$/u.test(afterLink)) {
+    return markdown.slice(cursor, matchStart);
+  }
+
+  return markdown.slice(cursor, lineStart);
+}
+
 function appendMarkdown(elements: Array<Record<string, unknown>>, content: string): void {
-  if (!content) return;
+  if (!content.trim()) return;
   elements.push({ tag: "markdown", content });
 }

package/src/index.ts

@@ -44,6 +44,7 @@ import { SafeRestartScheduler } from "./supervision/SafeRestartScheduler.js";
 import type { RestartNotificationTarget } from "./supervision/SafeRestartScheduler.js";
 import { SafeRestartNotifier } from "./supervision/SafeRestartNotifier.js";
 import { privateRestartNotificationTarget } from "./supervision/restartNotificationTarget.js";
+import { LocalFileViewerServer } from "./local-files/LocalFileViewerServer.js";
 import {
   nodeDiagnosticReportArguments,
   prepareCrashReportDirectory,
@@ -72,6 +73,22 @@ const config = loadConfig();
 const transport = consoleOnly ? "console" : requireServerFeishuTransport(config.feishu);
 const logger = createLogger(config);
 const store = new StateStore(config.storage.sqlitePath);
+let localFileViewer: LocalFileViewerServer | undefined;
+if (config.fileViewer.enabled) {
+  const viewer = new LocalFileViewerServer({
+    host: config.fileViewer.host,
+    port: config.fileViewer.port,
+    publicBaseUrl: config.fileViewer.publicBaseUrl,
+    stateDirectory: path.join(path.dirname(config.storage.sqlitePath), "file-viewer"),
+  });
+  try {
+    const address = await viewer.start();
+    localFileViewer = viewer;
+    logger.info(address, "Local file viewer started.");
+  } catch (error) {
+    logger.warn({ error }, "Local file viewer failed to start; local file links will remain plain text.");
+  }
+}
 
 const configuredConfigPath = process.env.AGENT_BOT_CONFIG?.trim();
 const activeConfigPath = configuredConfigPath ? resolveUserPath(configuredConfigPath) : defaultConfigPath();
@@ -98,6 +115,7 @@ if (feishuOutbound) {
     normalIntervalMs: 2_000,
     criticalGapMs: 500,
     onError: (error) => logger.warn({ error }, "Failed to update Agent progress card."),
+    localFileUrl: (filePath, reference) => localFileViewer?.createFileUrl(filePath, reference),
   });
   routes.push({ matches: (contextKey) => !contextKey.startsWith("console:"), outbound: feishuOutbound, presenter });
   const defaultAgentName = config.defaults.agent!;
@@ -215,7 +233,7 @@ function recoverPendingSelfUpdate(): void {
   if (!pending || pendingSelfUpdatePlanPath || restartRequested || safeRestart.scheduled) return;
   let notificationTarget: RestartNotificationTarget | undefined;
   try {
-    notificationTarget = inferControlRestartTarget(pending.plan.notificationSessionId);
+    notificationTarget = inferServerRestartTarget(pending.plan.notificationSessionId);
   } catch (error) {
     logger.warn({ error }, "Could not restore the self-update notification target; update recovery will continue.");
   }
@@ -223,6 +241,9 @@ function recoverPendingSelfUpdate(): void {
   safeRestart.schedule(
     pending.plan.reason ?? `Resume Agent Bot update to ${pending.plan.toVersion}`,
     notificationTarget,
+    {
+      restartImmediatelyIfIdle: isServerIdle(store.getServerActivityState()),
+    },
   );
   logger.warn(
     { planPath: pending.planPath, toVersion: pending.plan.toVersion },
@@ -390,12 +411,15 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
         return { ok: false, message: "A restart or update is already pending." };
       }
       assertSelfUpdatePlanPath(request.planPath, agentBotHome());
-      const notificationTarget = inferControlRestartTarget(request.notificationSessionId);
+      const notificationTarget = inferServerRestartTarget(request.notificationSessionId);
+      const restartImmediatelyIfIdle = isServerIdle(store.getServerActivityState());
       pendingSelfUpdatePlanPath = request.planPath;
-      safeRestart.schedule(request.reason, notificationTarget);
+      safeRestart.schedule(request.reason, notificationTarget, { restartImmediatelyIfIdle });
       return {
         ok: true,
-        message: "Agent Bot update scheduled after active tasks finish and the server becomes idle.",
+        message: restartImmediatelyIfIdle
+          ? "Agent Bot update will start immediately because the server is idle."
+          : "Agent Bot update scheduled after active tasks finish and the server becomes idle.",
       };
     }
     case "server_stop":
@@ -517,6 +541,7 @@ async function shutdown(
   ]);
   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."));
   store.close();
   if (restartReason) startReplacementSupervisor(restartReason, restartNotificationTargets);
   process.exit(exitCode);
@@ -586,6 +611,10 @@ 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 restartNotificationTargetForSession(
   session: { localSessionId: string; contextKey: string },
 ): RestartNotificationTarget {