@keyou007/agent-bot 0.1.15-alpha.0 → 0.1.15-alpha.2

package/src/feishu/CardRenderer.ts

@@ -11,7 +11,7 @@ import type {
   ToolState,
 } from "../runtime/types.js";
 import type { TurnActivity, TurnViewState, TurnViewStatus } from "../presentation/turnViewTypes.js";
-import { truncateText } from "../utils/markdown.js";
+import { truncateMiddle, truncateText } from "../utils/markdown.js";
 import { localCardImage } from "./LocalCardImage.js";
 
 export interface StartupStatusView {
@@ -195,7 +195,6 @@ export interface DirectoryBrowserCardEntry {
   name: string;
   kind: "directory" | "drive" | "file" | "image" | "binary";
   openAction?: TaskListCardAction;
-  actions?: TaskListCardAction[];
 }
 
 export interface DirectoryBrowserCardView {
@@ -206,6 +205,13 @@ export interface DirectoryBrowserCardView {
   footerLines: string[];
 }
 
+export interface DirectoryNewFolderCardView {
+  directory: string;
+  displayDirectory?: string;
+  contextKey: string;
+  page: number;
+}
+
 const DIRECTORY_BROWSER_ROW_COUNT = 16;
 
 export type ThinkingCardLayout = "grouped" | "timeline";
@@ -233,6 +239,17 @@ export interface DismissGroupCardView {
   requestedBy: string;
 }
 
+export interface ShellCommandCardView {
+  command: string;
+  cwd: string;
+  stdout: string;
+  stderr: string;
+  status: "running" | "completed" | "failed" | "timed_out";
+  exitCode?: number | null;
+  elapsedMs: number;
+  outputTruncated: boolean;
+}
+
 export class CardRenderer {
   private readonly thinkingCardLayout: ThinkingCardLayout;
 
@@ -240,6 +257,35 @@ export class CardRenderer {
     this.thinkingCardLayout = options.thinkingCardLayout ?? "grouped";
   }
 
+  renderShellCommandCard(view: ShellCommandCardView): Record<string, unknown> {
+    const stdout = normalizeTerminalOutput(view.stdout).trimEnd();
+    const stderr = normalizeTerminalOutput(view.stderr).trimEnd();
+    const rawOutput = [
+      stdout,
+      stderr ? `[stderr]\n${stderr}` : "",
+    ].filter(Boolean).join("\n");
+    const displayOutput = truncateMiddle(
+      rawOutput,
+      6_000,
+      "\n\n... 中间输出已截断 ...\n\n",
+    );
+    const command = truncateMiddle(view.command.trim(), 600, " ... ");
+    const output = displayOutput || (view.status === "running" ? "等待输出..." : "（无输出）");
+    const status = shellCommandStatus(view);
+    const outputWasTruncated = view.outputTruncated || rawOutput.length > 6_000;
+    return sectionCard(
+      status.title,
+      [
+        markdown(codeBlock(`$  ${command}\n${output}`, 6_700)),
+        markdown([
+          `${inlineCode(view.cwd)} · ${status.label} · ${formatTurnDuration(view.elapsedMs)}`,
+          ...(outputWasTruncated ? ["输出过长，已保留开头和结尾并截断中间内容。"] : []),
+        ].join("\n")),
+      ],
+      status.template,
+    );
+  }
+
   renderExecutionSettings(view: ExecutionSettingsCardView): Record<string, unknown> {
     const baseAction: Record<string, string> = {
       contextKey: view.contextKey,
@@ -1174,7 +1220,7 @@ export class CardRenderer {
   renderDirectoryBrowserCard(view: DirectoryBrowserCardView): Record<string, unknown> {
     const elements: Record<string, unknown>[] = [
       markdown(`**当前目录**：${inlineCode(view.directory)}`),
-      taskActionRow(view.currentActions),
+      taskActionRow(view.currentActions, undefined, true),
       { tag: "hr" },
     ];
     const entryRows = view.entries.length === 0
@@ -1191,6 +1237,54 @@ export class CardRenderer {
     return sectionCard("文件浏览", elements, "blue", "2px");
   }
 
+  renderDirectoryNewFolderCard(view: DirectoryNewFolderCardView): Record<string, unknown> {
+    const actionValue = {
+      action: "directory_new_folder_submit",
+      directory: view.directory,
+      contextKey: view.contextKey,
+      page: String(view.page),
+    };
+    return compactCard("新建目录", "blue", [
+      markdown(`将在当前目录下创建一个子目录：\n${inlineCode(view.displayDirectory ?? view.directory)}`),
+      {
+        tag: "form",
+        name: "directory_new_folder_form",
+        vertical_spacing: "8px",
+        elements: [
+          {
+            tag: "input",
+            element_id: "folder_name_input",
+            name: "folderName",
+            required: true,
+            input_type: "text",
+            width: "fill",
+            max_length: 255,
+            label: { tag: "plain_text", content: "目录名" },
+            placeholder: { tag: "plain_text", content: "请输入目录名" },
+          },
+          {
+            tag: "button",
+            name: "directory_new_folder_create",
+            text: { tag: "plain_text", content: "Create" },
+            type: "primary",
+            width: "fill",
+            action_type: "form_submit",
+            value: actionValue,
+          },
+        ],
+      },
+      taskActionRow([{
+        text: "Back",
+        value: {
+          action: "directory_new_folder_cancel",
+          directory: view.directory,
+          contextKey: view.contextKey,
+          page: String(view.page),
+        },
+      }]),
+    ]);
+  }
+
   renderResetHistoryCard(view: ResetHistoryCardView): Record<string, unknown> {
     const elements: Record<string, unknown>[] = [
       {
@@ -1958,10 +2052,26 @@ function renderToolDetails(tool: ToolState, projectCwd?: string): string {
     ? unwrapShellCommand(normalizedCommand) ?? normalizedCommand
     : normalizedCommand;
   const commandText = truncateText(displayCommand, 600);
-  const resultText = result ? truncateToolResult(stripAnsi(result).trim()) : undefined;
+  const resultText = result ? truncateToolResult(normalizeTerminalOutput(result).trim()) : undefined;
   return codeBlock([`$ ${commandText}`, resultText].filter((part): part is string => part !== undefined).join("\n"), 2_003);
 }
 
+function normalizeTerminalOutput(value: string): string {
+  const clean = stripAnsi(value).replace(/\r\n/g, "\n");
+  return clean
+    .split("\n")
+    .map((line) => {
+      if (!line.includes("\r")) return line;
+      const updates = line.split("\r");
+      for (let index = updates.length - 1; index >= 0; index -= 1) {
+        const update = updates[index];
+        if (update) return update;
+      }
+      return "";
+    })
+    .join("\n");
+}
+
 function truncateToolResult(result: string): string {
   const maxLength = 900;
   const marker = "\n...\n";
@@ -2048,6 +2158,23 @@ function formatTurnDuration(durationMs: number): string {
   return `${seconds}s`;
 }
 
+function shellCommandStatus(view: ShellCommandCardView): {
+  title: string;
+  label: string;
+  template: string;
+} {
+  if (view.status === "running") {
+    return { title: "正在执行命令", label: "运行中", template: "blue" };
+  }
+  if (view.status === "timed_out") {
+    return { title: "命令执行超时", label: "已超时（120s）", template: "orange" };
+  }
+  if (view.status === "completed") {
+    return { title: "命令执行完成", label: `退出码 ${view.exitCode ?? 0}`, template: "green" };
+  }
+  return { title: "命令执行失败", label: `退出码 ${view.exitCode ?? "未知"}`, template: "red" };
+}
+
 function unwrapShellCommand(command: string): string | undefined {
   return unwrapPowerShellCommand(command) ?? unwrapPosixShellCommand(command);
 }
@@ -2409,13 +2536,25 @@ function resetHistoryEntryRow(
   };
 }
 
-function taskActionRow(actions: TaskListCardAction[], trailingText?: string): Record<string, unknown> {
-  const columns = actions.map((action) => ({
-    tag: "column",
-    width: "auto",
-    vertical_align: "center",
-    elements: [taskActionElement(action)],
-  }));
+function taskActionRow(
+  actions: TaskListCardAction[],
+  trailingText?: string,
+  dotSeparated = false,
+): Record<string, unknown> {
+  const columns = actions.flatMap((action, index) => [
+    ...(dotSeparated && index > 0 ? [{
+      tag: "column",
+      width: "auto",
+      vertical_align: "center",
+      elements: [markdown("<font color='grey'>·</font>")],
+    }] : []),
+    {
+      tag: "column",
+      width: "auto",
+      vertical_align: "center",
+      elements: [taskActionElement(action)],
+    },
+  ]);
   if (trailingText) {
     columns.push({
       tag: "column",
@@ -2453,12 +2592,6 @@ function directoryBrowserEntryRow(entry: DirectoryBrowserCardEntry): Record<stri
           ? [taskActionElement({ ...entry.openAction, text: label })]
           : [markdown(escapeCardHtml(label))],
       },
-      ...(entry.actions ?? []).map((action) => ({
-        tag: "column",
-        width: "auto",
-        vertical_align: "center",
-        elements: [taskActionElement(action)],
-      })),
     ],
   };
 }

package/src/feishu/FeishuConnector.ts

@@ -4,7 +4,7 @@ import { threadContextKey } from "./contextKey.js";
 import { resolveFeishuBotOpenId } from "./FeishuBotIdentity.js";
 import { normalizeFeishuPostText } from "./InboundText.js";
 import { allowsFeishuUser } from "./ownerAccess.js";
-import type { ChatUpdatedEvent, FeishuEventHandler, IncomingMessage } from "./types.js";
+import type { CardAction, ChatUpdatedEvent, FeishuEventHandler, IncomingMessage } from "./types.js";
 
 type BotOpenIdResolver = (appId: string, appSecret: string) => Promise<string>;
 type BotOpenIdListener = (botOpenId: string) => void;
@@ -89,6 +89,7 @@ export class FeishuConnector {
           });
       },
       "card.action.trigger": async (data: unknown) => {
+        const receivedAt = Date.now();
         const operatorOpenId = getFeishuEvent(data)?.operator?.open_id;
         if (!allowsFeishuUser(this.config, operatorOpenId)) {
           this.logger.debug(
@@ -103,11 +104,11 @@ export class FeishuConnector {
           return {};
         }
 
-        void Promise.resolve()
-          .then(() => this.handler.onCardAction(action))
-          .catch((error: unknown) => {
-            this.logger.error({ error, actionId: action.actionId }, "Failed to handle Feishu card action.");
-          });
+        this.deferCardAction(action, receivedAt);
+        this.logger.debug(
+          { actionId: action.actionId, messageId: action.messageId, responsePreparedInMs: Date.now() - receivedAt },
+          "Prepared the Feishu card action acknowledgement.",
+        );
         return {
           toast: {
             type: "success",
@@ -123,6 +124,27 @@ export class FeishuConnector {
     await wsClient.start({ eventDispatcher });
     this.logger.info("Feishu WebSocket connector started.");
   }
+
+  private deferCardAction(action: CardAction, receivedAt: number): void {
+    setImmediate(() => {
+      const startedAt = Date.now();
+      this.logger.debug(
+        { actionId: action.actionId, messageId: action.messageId, dispatchDelayMs: startedAt - receivedAt },
+        "Started deferred Feishu card action handling.",
+      );
+      void Promise.resolve()
+        .then(() => this.handler.onCardAction(action))
+        .then(() => {
+          this.logger.debug(
+            { actionId: action.actionId, messageId: action.messageId, durationMs: Date.now() - startedAt },
+            "Completed Feishu card action handling.",
+          );
+        })
+        .catch((error: unknown) => {
+          this.logger.error({ error, actionId: action.actionId }, "Failed to handle Feishu card action.");
+        });
+    });
+  }
 }
 
 function toChatUpdatedEvent(data: unknown): ChatUpdatedEvent | undefined {
@@ -305,7 +327,10 @@ function getCardActionValue(action: Record<string, unknown>): Record<string, unk
     const option = parseJsonObject(action.option);
     if (Object.keys(option).length > 0) return option;
   }
-  return isRecord(action.value) ? action.value : {};
+  const value = isRecord(action.value) ? action.value : {};
+  return isRecord(action.form_value)
+    ? { ...value, formValue: action.form_value }
+    : value;
 }
 
 function getEventId(data: unknown): string | undefined {

package/src/feishu/FeishuMarkdown.ts

@@ -1,3 +1,5 @@
+import path from "node:path";
+
 interface FenceState {
   indent: string;
   marker: "`" | "~";
@@ -9,7 +11,7 @@ const FENCE_OPENER = /^([ \t]*)((?:`{3,})|(?:~{3,}))(.*)$/;
 const MARKDOWN_LINK = /(!?)\[([^\]\r\n]*)\]\((<?[^)\r\n]+>?)\)/g;
 const LOCAL_FILE_LINE_REFERENCE = /(:\d+(?::\d+)?)$/;
 
-export function normalizeFeishuMarkdown(markdown: string): string {
+export function normalizeFeishuMarkdown(markdown: string, projectCwd?: string): string {
   const lines = markdown.match(/[^\r\n]*(?:\r\n|\n)|[^\r\n]+$/g) ?? [];
   let fence: FenceState | undefined;
 
@@ -19,7 +21,7 @@ export function normalizeFeishuMarkdown(markdown: string): string {
 
     if (!fence) {
       const opener = FENCE_OPENER.exec(body);
-      if (!opener?.[2]) return `${includeLocalFileLineReferences(body)}${ending}`;
+      if (!opener?.[2]) return `${includeLocalFileLineReferences(body, projectCwd)}${ending}`;
 
       const indent = opener[1] ?? "";
       const delimiter = opener[2];
@@ -40,7 +42,7 @@ export function normalizeFeishuMarkdown(markdown: string): string {
   }).join("");
 }
 
-function includeLocalFileLineReferences(markdown: string): string {
+function includeLocalFileLineReferences(markdown: string, projectCwd?: string): string {
   return markdown.replace(MARKDOWN_LINK, (link, imageMarker: string, label: string, rawTarget: string) => {
     if (imageMarker) return link;
 
@@ -48,11 +50,68 @@ function includeLocalFileLineReferences(markdown: string): string {
     if (!isLocalFileTarget(target)) return link;
 
     const reference = LOCAL_FILE_LINE_REFERENCE.exec(target)?.[1];
-    if (!reference || label.endsWith(reference)) return link;
-    return `[${label}${reference}](${rawTarget})`;
+    const projectPathLabel = projectCwd ? projectFilePathLabel(target, projectCwd, reference) : undefined;
+    const normalizedLabel = projectPathLabel
+      ?? (reference && !label.endsWith(reference) ? `${label}${reference}` : label);
+    return normalizedLabel === label ? link : `[${normalizedLabel}](${rawTarget})`;
   });
 }
 
+function projectFilePathLabel(
+  target: string,
+  projectCwd: string,
+  reference: string | undefined,
+): string | undefined {
+  const targetWithoutReference = reference ? target.slice(0, -reference.length) : target;
+  const filePath = localFilePath(targetWithoutReference);
+  if (!filePath) return undefined;
+  if (!isInsideProject(filePath, projectCwd)) {
+    return `${displayAbsolutePath(filePath)}${reference ?? ""}`;
+  }
+
+  const pathApi = usesWindowsPaths(filePath, projectCwd) ? path.win32 : path.posix;
+  const parsed = pathApi.parse(filePath);
+  if (Array.from(parsed.name).length > 5) return undefined;
+
+  const parentName = pathApi.basename(pathApi.dirname(filePath));
+  if (!parentName) return undefined;
+  return `${parentName}${pathApi.sep}${parsed.base}${reference ?? ""}`;
+}
+
+function localFilePath(target: string): string | undefined {
+  if (!/^file:\/\//i.test(target)) return normalizeWindowsDrivePrefix(target);
+
+  let value = target.slice("file://".length);
+  try {
+    value = decodeURIComponent(value);
+  } catch {
+    // Keep malformed percent escapes visible instead of dropping the link.
+  }
+  if (/^\/[a-z]:[\\/]/i.test(value)) return value.slice(1);
+  if (value.startsWith("/")) return value;
+  return `//${value}`;
+}
+
+function normalizeWindowsDrivePrefix(value: string): string {
+  return /^\/[a-z]:[\\/]/i.test(value) ? value.slice(1) : value;
+}
+
+function isInsideProject(filePath: string, projectCwd: string): boolean {
+  const pathApi = usesWindowsPaths(filePath, projectCwd) ? path.win32 : path.posix;
+  const relative = pathApi.relative(pathApi.resolve(projectCwd), pathApi.resolve(filePath));
+  return relative === ""
+    || (relative !== ".." && !relative.startsWith(`..${pathApi.sep}`) && !pathApi.isAbsolute(relative));
+}
+
+function displayAbsolutePath(filePath: string): string {
+  if (!usesWindowsPaths(filePath)) return path.posix.normalize(filePath);
+  return path.win32.normalize(filePath);
+}
+
+function usesWindowsPaths(...values: string[]): boolean {
+  return values.some((value) => /^\/?[a-z]:[\\/]/i.test(value) || /^\\\\/.test(value));
+}
+
 function unwrapMarkdownTarget(target: string): string {
   return target.startsWith("<") && target.endsWith(">") ? target.slice(1, -1) : target;
 }

package/src/feishu/FeishuMessageClient.ts

@@ -7,6 +7,7 @@ import type { AppConfig } from "../config/schema.js";
 import { normalizeFeishuMarkdown } from "./FeishuMarkdown.js";
 import { LOCAL_CARD_IMAGE_PATH } from "./LocalCardImage.js";
 import { renderMarkdownWithLocalImages } from "./LocalImageMarkdown.js";
+import { splitFinalResponseBranding } from "./FinalResponseBranding.js";
 import {
   renderMergedForwardPrompt,
   renderReferencedMessage,
@@ -101,6 +102,7 @@ export class FeishuMessageClient implements FeishuOutbound {
     expiresAt: number;
   };
   private readonly sendQueues = new Map<string, Promise<void>>();
+  private readonly cardUpdateQueues = new Map<string, Promise<void>>();
   private readonly lastSendAt = new Map<string, number>();
   private readonly imageUploads = new Map<string, { mtimeMs: number; upload: Promise<string> }>();
   private readonly imageDownloads = new Map<string, Promise<string>>();
@@ -288,11 +290,7 @@ export class FeishuMessageClient implements FeishuOutbound {
 
   async sendMarkdown(contextKey: string, markdown: string, idempotencyKey?: string): Promise<string | undefined> {
     const normalizedMarkdown = normalizeFeishuMarkdown(markdown);
-    const elements = await renderMarkdownWithLocalImages(
-      normalizedMarkdown,
-      (filePath) => this.uploadImageCached(filePath),
-      (error, filePath) => this.logger.warn({ error, filePath }, "Failed to upload local image to Feishu."),
-    );
+    const elements = await this.renderFinalAnswerElements(normalizedMarkdown);
     return this.sendMessage(
       contextKey,
       "interactive",
@@ -334,11 +332,7 @@ export class FeishuMessageClient implements FeishuOutbound {
     idempotencyKey?: string,
   ): Promise<string | undefined> {
     const normalizedMarkdown = normalizeFeishuMarkdown(markdown);
-    const elements = await renderMarkdownWithLocalImages(
-      normalizedMarkdown,
-      (filePath) => this.uploadImageCached(filePath),
-      (error, filePath) => this.logger.warn({ error, filePath }, "Failed to upload local image to Feishu."),
-    );
+    const elements = await this.renderFinalAnswerElements(normalizedMarkdown);
     return this.replyMessage(
       contextKey,
       target,
@@ -364,9 +358,28 @@ export class FeishuMessageClient implements FeishuOutbound {
     );
   }
 
+  private async renderFinalAnswerElements(markdown: string): Promise<Array<Record<string, unknown>>> {
+    const { content, branding } = splitFinalResponseBranding(markdown);
+    const elements = content
+      ? await renderMarkdownWithLocalImages(
+        content,
+        (filePath) => this.uploadImageCached(filePath),
+        (error, filePath) => this.logger.warn({ error, filePath }, "Failed to upload local image to Feishu."),
+      )
+      : [];
+    if (!branding) return elements;
+    return [
+      ...elements,
+      { tag: "hr" },
+      { tag: "markdown", content: branding, text_size: "notation" },
+    ];
+  }
+
   async updateInteractiveCard(messageId: string, card: Record<string, unknown>): Promise<void> {
-    const preparedCard = await this.prepareInteractiveCard(card);
-    await this.updateInteractiveCardNow(messageId, preparedCard);
+    await this.enqueueCardUpdate(messageId, async () => {
+      const preparedCard = await this.prepareInteractiveCard(card);
+      await this.updateInteractiveCardNow(messageId, preparedCard);
+    });
   }
 
   private async updateInteractiveCardNow(
@@ -626,6 +639,22 @@ export class FeishuMessageClient implements FeishuOutbound {
     return queued;
   }
 
+  private enqueueCardUpdate(messageId: string, task: () => Promise<void>): Promise<void> {
+    const previous = this.cardUpdateQueues.get(messageId) ?? Promise.resolve();
+    const queued = previous.catch(() => undefined).then(task);
+    const stored = queued.then(
+      () => undefined,
+      () => undefined,
+    );
+    this.cardUpdateQueues.set(messageId, stored);
+    stored.finally(() => {
+      if (this.cardUpdateQueues.get(messageId) === stored) {
+        this.cardUpdateQueues.delete(messageId);
+      }
+    });
+    return queued;
+  }
+
   private async getTenantAccessToken(): Promise<string> {
     const now = Date.now();
     if (this.token && this.token.expiresAt > now + 60_000) {

package/src/feishu/FeishuTurnPresenter.ts

@@ -8,7 +8,11 @@ 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 type { FeishuOutbound, MessageReplyTarget } from "./types.js";
+import {
+  FINAL_RESPONSE_BRANDING_BLOCK,
+} from "./FinalResponseBranding.js";
 import { createId } from "../utils/id.js";
 import { createHash } from "node:crypto";
 
@@ -50,7 +54,6 @@ export interface FeishuTurnPresenterOptions {
 
 const MAX_FINAL_TABLES_PER_CARD = 5;
 const DEFAULT_ELAPSED_UPDATE_INTERVAL_MS = 3_000;
-const FINAL_RESPONSE_BRANDING = "> Powered by [AgentBot](https://github.com/keyou/agent-bot)";
 const FINAL_RESPONSE_BRANDING_MIN_LENGTH = 1_000;
 
 interface TurnEntry {
@@ -536,7 +539,7 @@ export class FeishuTurnPresenter {
     if (delivery?.finalDelivered || !state.finalResponse) return;
     const finalChunkLength = this.options.finalChunkLength ?? 4_000;
     const chunks = brandedFinalChunks(
-      state.finalResponse,
+      normalizeFeishuMarkdown(state.finalResponse, state.projectCwd),
       finalChunkLength,
     );
     const messageIds = [...(delivery?.finalMessageIds ?? [])];
@@ -582,17 +585,17 @@ function brandedFinalChunks(response: string, maxLength: number): string[] {
 
   const last = chunks.pop();
   if (last === undefined) return chunks;
-  const reservedLength = FINAL_RESPONSE_BRANDING.length + 2;
+  const reservedLength = FINAL_RESPONSE_BRANDING_BLOCK.length + 2;
   const brandedContentLimit = maxLength - reservedLength;
-  if (brandedContentLimit < 32) return [...chunks, last, FINAL_RESPONSE_BRANDING];
+  if (brandedContentLimit < 32) return [...chunks, last, FINAL_RESPONSE_BRANDING_BLOCK];
 
   const lastParts = splitMarkdown(last, brandedContentLimit, MAX_FINAL_TABLES_PER_CARD);
   const lastContent = lastParts.pop();
   if (lastContent === undefined || lastContent.length > brandedContentLimit) {
-    return [...chunks, ...lastParts, lastContent ?? last, FINAL_RESPONSE_BRANDING];
+    return [...chunks, ...lastParts, lastContent ?? last, FINAL_RESPONSE_BRANDING_BLOCK];
   }
   const separator = lastContent.endsWith("\n\n") ? "" : lastContent.endsWith("\n") ? "\n" : "\n\n";
-  return [...chunks, ...lastParts, `${lastContent}${separator}${FINAL_RESPONSE_BRANDING}`];
+  return [...chunks, ...lastParts, `${lastContent}${separator}${FINAL_RESPONSE_BRANDING_BLOCK}`];
 }
 
 function eventPriority(event: AgentEvent): "normal" | "critical" {

package/src/feishu/FinalResponseBranding.ts

@@ -0,0 +1,18 @@
+export const FINAL_RESPONSE_BRANDING = "> Powered by [AgentBot](https://github.com/keyou/agent-bot)";
+export const FINAL_RESPONSE_BRANDING_BLOCK = `----\n\n${FINAL_RESPONSE_BRANDING}`;
+
+export function splitFinalResponseBranding(markdown: string): {
+  content: string;
+  branding?: string;
+} {
+  if (markdown === FINAL_RESPONSE_BRANDING_BLOCK) {
+    return { content: "", branding: FINAL_RESPONSE_BRANDING };
+  }
+
+  const suffix = `\n\n${FINAL_RESPONSE_BRANDING_BLOCK}`;
+  if (!markdown.endsWith(suffix)) return { content: markdown };
+  return {
+    content: markdown.slice(0, -suffix.length),
+    branding: FINAL_RESPONSE_BRANDING,
+  };
+}

package/src/logging/DailyLogStream.ts

@@ -0,0 +1,88 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Writable } from "node:stream";
+
+interface DailyLogStreamOptions {
+  clock?: () => Date;
+  mode?: number;
+  beforeOpen?: (filePath: string) => void;
+}
+
+export class DailyLogStream extends Writable {
+  private currentPath?: string;
+  private lastPath?: string;
+  private currentStream?: fs.WriteStream;
+  private readonly clock: () => Date;
+
+  constructor(
+    private readonly basePath: string,
+    private readonly options: DailyLogStreamOptions = {},
+  ) {
+    super();
+    this.clock = options.clock ?? (() => new Date());
+  }
+
+  get filePath(): string | undefined {
+    return this.currentPath ?? this.lastPath;
+  }
+
+  override _write(
+    chunk: string | Buffer,
+    encoding: BufferEncoding,
+    callback: (error?: Error | null) => void,
+  ): void {
+    let stream: fs.WriteStream;
+    try {
+      stream = this.streamFor(this.clock());
+    } catch (error) {
+      callback(error instanceof Error ? error : new Error(String(error)));
+      return;
+    }
+    stream.write(chunk, encoding, callback);
+  }
+
+  override _final(callback: (error?: Error | null) => void): void {
+    const stream = this.currentStream;
+    this.currentStream = undefined;
+    this.currentPath = undefined;
+    if (!stream) {
+      callback();
+      return;
+    }
+    stream.end(callback);
+  }
+
+  override _destroy(error: Error | null, callback: (error?: Error | null) => void): void {
+    this.currentStream?.destroy();
+    this.currentStream = undefined;
+    this.currentPath = undefined;
+    callback(error);
+  }
+
+  private streamFor(date: Date): fs.WriteStream {
+    const targetPath = dailyLogPath(this.basePath, date);
+    if (this.currentStream && this.currentPath === targetPath) return this.currentStream;
+
+    const previous = this.currentStream;
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    this.options.beforeOpen?.(targetPath);
+    this.currentPath = targetPath;
+    this.lastPath = targetPath;
+    this.currentStream = fs.createWriteStream(targetPath, {
+      flags: "a",
+      ...(this.options.mode === undefined ? {} : { mode: this.options.mode }),
+    });
+    previous?.end();
+    return this.currentStream;
+  }
+}
+
+export function dailyLogPath(basePath: string, date: Date): string {
+  const parsed = path.parse(basePath);
+  const dateStamp = [
+    date.getFullYear(),
+    String(date.getMonth() + 1).padStart(2, "0"),
+    String(date.getDate()).padStart(2, "0"),
+  ].join("-");
+  return path.join(parsed.dir, `${parsed.name}.${dateStamp}${parsed.ext}`);
+}