@keyou007/agent-bot 0.1.14 → 0.1.15-alpha.1

package/src/feishu/types.ts

@@ -1,3 +1,7 @@
+import type { MergedForwardContent, ReferencedMessageContent } from "./MergedForwardMessage.js";
+
+export type { MergedForwardContent, ReferencedMessageContent } from "./MergedForwardMessage.js";
+
 export interface IncomingMessage {
   messageId: string;
   contextKey: string;
@@ -12,12 +16,20 @@ export interface IncomingMessage {
   mentionedBot?: true;
   text: string;
   images?: IncomingImageReference[];
+  files?: IncomingFileReference[];
+  mergedForwardMessageId?: string;
+  displayText?: string;
 }
 
 export interface IncomingImageReference {
   imageKey: string;
 }
 
+export interface IncomingFileReference {
+  fileKey: string;
+  fileName: string;
+}
+
 export interface MessageReplyTarget {
   messageId: string;
   replyInThread: true;
@@ -54,6 +66,9 @@ export interface FeishuOutbound {
   addReaction?(messageId: string, emojiType: string): Promise<string | undefined>;
   deleteReaction?(messageId: string, reactionId: string): Promise<void>;
   downloadImage?(messageId: string, imageKey: string): Promise<string>;
+  downloadFile?(messageId: string, fileKey: string, fileName: string): Promise<string>;
+  readMergedForward?(messageId: string): Promise<MergedForwardContent>;
+  readReferencedMessage?(messageId: string): Promise<ReferencedMessageContent>;
   sendText(contextKey: string, text: string): Promise<string | undefined>;
   sendFile?(contextKey: string, filePath: string): Promise<string | undefined>;
   sendMarkdown(contextKey: string, markdown: string, idempotencyKey?: string): Promise<string | undefined>;

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}`);
+}

package/src/logging/logger.ts

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import pino, { type Logger } from "pino";
 import type { AppConfig } from "../config/schema.js";
+import { DailyLogStream } from "./DailyLogStream.js";
 
 export function createLogger(config: AppConfig): Logger {
   const streams: pino.StreamEntry[] = [
@@ -13,7 +14,7 @@ export function createLogger(config: AppConfig): Logger {
   if (config.logging.path) {
     fs.mkdirSync(path.dirname(config.logging.path), { recursive: true });
     streams.push({
-      stream: fs.createWriteStream(config.logging.path, { flags: "a" }),
+      stream: new DailyLogStream(config.logging.path),
     });
   }
 

package/src/presentation/OutboundRouter.ts

@@ -4,7 +4,9 @@ import type {
   CreatedGroup,
   CreateGroupInput,
   FeishuOutbound,
+  MergedForwardContent,
   MessageReplyTarget,
+  ReferencedMessageContent,
 } from "../feishu/types.js";
 
 export interface TurnPresenter {
@@ -165,6 +167,32 @@ export class OutboundRouter {
     return download.call(outbound, messageId, imageKey);
   }
 
+  async downloadFile(
+    contextKey: string,
+    messageId: string,
+    fileKey: string,
+    fileName: string,
+  ): Promise<string> {
+    const outbound = this.route(contextKey).outbound;
+    const download = outbound.downloadFile;
+    if (!download) throw new Error("当前消息通道不支持下载文件。");
+    return download.call(outbound, messageId, fileKey, fileName);
+  }
+
+  async readMergedForward(contextKey: string, messageId: string): Promise<MergedForwardContent> {
+    const outbound = this.route(contextKey).outbound;
+    const read = outbound.readMergedForward;
+    if (!read) throw new Error("当前消息通道不支持读取合并转发消息。");
+    return read.call(outbound, messageId);
+  }
+
+  async readReferencedMessage(contextKey: string, messageId: string): Promise<ReferencedMessageContent> {
+    const outbound = this.route(contextKey).outbound;
+    const read = outbound.readReferencedMessage;
+    if (!read) throw new Error("当前消息通道不支持读取引用消息。");
+    return read.call(outbound, messageId);
+  }
+
   async createGroup(contextKey: string, input: CreateGroupInput): Promise<CreatedGroup> {
     const outbound = this.route(contextKey).outbound;
     const createGroup = outbound.createGroup;