@keyou007/agent-bot 0.1.0

package/src/feishu/CardUpdateScheduler.ts

@@ -0,0 +1,165 @@
+export type CardUpdatePriority = "normal" | "critical";
+
+export interface CardUpdateSchedulerOptions<T> {
+  render(state: T): Record<string, unknown>;
+  write(card: Record<string, unknown>): Promise<void>;
+  normalIntervalMs?: number;
+  criticalGapMs?: number;
+  retryBackoffMs?: number[];
+  isRateLimit?: (error: unknown) => boolean;
+  isRetryable?: (error: unknown) => boolean;
+  onError?: (error: unknown) => void;
+}
+
+interface FlushWaiter {
+  version: number;
+  resolve(): void;
+  reject(error: unknown): void;
+}
+
+export class CardUpdateScheduler<T> {
+  private latestState?: T;
+  private version = 0;
+  private dirty = false;
+  private priority: CardUpdatePriority = "normal";
+  private lastWriteAt = Date.now();
+  private lastHash?: string;
+  private retryIndex = 0;
+  private retryAt = 0;
+  private timer?: ReturnType<typeof setTimeout>;
+  private writing = false;
+  private disposed = false;
+  private readonly waiters: FlushWaiter[] = [];
+  private readonly normalIntervalMs: number;
+  private readonly criticalGapMs: number;
+  private readonly retryBackoffMs: number[];
+
+  constructor(private readonly options: CardUpdateSchedulerOptions<T>) {
+    this.normalIntervalMs = options.normalIntervalMs ?? 2_000;
+    this.criticalGapMs = options.criticalGapMs ?? 500;
+    this.retryBackoffMs = options.retryBackoffMs ?? [2_000, 4_000, 8_000, 16_000, 30_000];
+  }
+
+  seed(state: T): void {
+    this.latestState = state;
+    this.lastHash = hashCard(this.options.render(state));
+    this.lastWriteAt = Date.now();
+  }
+
+  invalidateRenderedCard(): void {
+    this.lastHash = undefined;
+  }
+
+  update(state: T, priority: CardUpdatePriority = "normal"): void {
+    if (this.disposed) return;
+    this.latestState = state;
+    this.version += 1;
+    this.dirty = true;
+    if (priority === "critical") this.priority = "critical";
+    this.schedule();
+  }
+
+  flush(state?: T): Promise<void> {
+    if (state !== undefined) this.update(state, "critical");
+    else if (this.latestState !== undefined) this.update(this.latestState, "critical");
+    if (!this.dirty) return Promise.resolve();
+
+    const version = this.version;
+    return new Promise<void>((resolve, reject) => {
+      this.waiters.push({ version, resolve, reject });
+      this.schedule();
+    });
+  }
+
+  dispose(): void {
+    this.disposed = true;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = undefined;
+    const error = new Error("Card update scheduler was disposed.");
+    this.rejectWaiters(Number.POSITIVE_INFINITY, error);
+  }
+
+  private schedule(): void {
+    if (this.disposed || this.writing || !this.dirty || this.timer) return;
+    const gap = this.priority === "critical" ? this.criticalGapMs : this.normalIntervalMs;
+    const dueAt = Math.max(this.lastWriteAt + gap, this.retryAt);
+    const delay = Math.max(0, dueAt - Date.now());
+    this.timer = setTimeout(() => {
+      this.timer = undefined;
+      void this.drain();
+    }, delay);
+  }
+
+  private async drain(): Promise<void> {
+    if (this.disposed || this.writing || !this.dirty || this.latestState === undefined) return;
+    this.writing = true;
+    const state = this.latestState;
+    const version = this.version;
+    const card = this.options.render(state);
+    const hash = hashCard(card);
+
+    if (hash === this.lastHash) {
+      this.markHandled(version);
+      this.writing = false;
+      this.schedule();
+      return;
+    }
+
+    try {
+      await this.options.write(card);
+      this.lastHash = hash;
+      this.lastWriteAt = Date.now();
+      this.retryAt = 0;
+      this.retryIndex = 0;
+      this.markHandled(version);
+    } catch (error) {
+      if (this.isRetryable(error)) {
+        const index = Math.min(this.retryIndex, this.retryBackoffMs.length - 1);
+        this.retryAt = Date.now() + (this.retryBackoffMs[index] ?? 30_000);
+        this.retryIndex += 1;
+      } else {
+        this.dirty = this.version > version;
+        this.rejectWaiters(version, error);
+        this.options.onError?.(error);
+      }
+    } finally {
+      this.writing = false;
+      this.schedule();
+    }
+  }
+
+  private markHandled(version: number): void {
+    this.dirty = this.version > version;
+    if (!this.dirty) this.priority = "normal";
+    const ready = this.waiters.filter((waiter) => waiter.version <= version);
+    for (const waiter of ready) waiter.resolve();
+    this.removeWaiters(ready);
+  }
+
+  private rejectWaiters(version: number, error: unknown): void {
+    const rejected = this.waiters.filter((waiter) => waiter.version <= version);
+    for (const waiter of rejected) waiter.reject(error);
+    this.removeWaiters(rejected);
+  }
+
+  private removeWaiters(waiters: FlushWaiter[]): void {
+    for (const waiter of waiters) {
+      const index = this.waiters.indexOf(waiter);
+      if (index >= 0) this.waiters.splice(index, 1);
+    }
+  }
+
+  private isRetryable(error: unknown): boolean {
+    if (this.options.isRetryable) return this.options.isRetryable(error);
+    if (this.options.isRateLimit?.(error)) return true;
+    return (
+      typeof error === "object" &&
+      error !== null &&
+      (("isRetryable" in error && error.isRetryable === true) || ("isRateLimit" in error && error.isRateLimit === true))
+    );
+  }
+}
+
+function hashCard(card: Record<string, unknown>): string {
+  return JSON.stringify(card);
+}

package/src/feishu/ConsoleFeishuClient.ts

@@ -0,0 +1,22 @@
+import type { FeishuOutbound } from "./types.js";
+
+export class ConsoleFeishuClient implements FeishuOutbound {
+  async sendText(contextKey: string, text: string): Promise<string> {
+    console.log(`\n[${contextKey}] ${text}\n`);
+    return `console-text-${Date.now()}`;
+  }
+
+  async sendMarkdown(contextKey: string, markdown: string): Promise<string> {
+    console.log(`\n[${contextKey}] ${markdown}\n`);
+    return `console-markdown-${Date.now()}`;
+  }
+
+  async sendInteractiveCard(contextKey: string, card: Record<string, unknown>): Promise<string> {
+    console.log(`\n[${contextKey}] CARD ${JSON.stringify(card, null, 2)}\n`);
+    return `console-card-${Date.now()}`;
+  }
+
+  async updateInteractiveCard(messageId: string, card: Record<string, unknown>): Promise<void> {
+    console.log(`\n[${messageId}] UPDATE CARD ${JSON.stringify(card, null, 2)}\n`);
+  }
+}

package/src/feishu/FeishuConnector.ts

@@ -0,0 +1,277 @@
+import type { Logger } from "pino";
+import type { AppConfig } from "../config/schema.js";
+import { threadContextKey } from "./contextKey.js";
+import type { ChatUpdatedEvent, FeishuEventHandler, IncomingMessage } from "./types.js";
+
+export class FeishuConnector {
+  constructor(
+    private readonly config: AppConfig,
+    private readonly handler: FeishuEventHandler,
+    private readonly logger: Logger,
+  ) {}
+
+  async start(): Promise<void> {
+    const { appId, appSecret } = this.config.feishu;
+    if (!appId || !appSecret) {
+      throw new Error("Feishu appId/appSecret are required.");
+    }
+
+    await this.startFeishuWs(appId, appSecret);
+  }
+
+  stop(): void {
+    // SDK connector currently relies on process lifetime.
+  }
+
+  private async startFeishuWs(appId: string, appSecret: string): Promise<void> {
+    const lark = (await import("@larksuiteoapi/node-sdk")) as Record<string, any>;
+    const wsClient = new lark.WSClient({ appId, appSecret });
+    const eventDispatcher = new lark.EventDispatcher({}).register({
+      "im.message.receive_v1": async (data: unknown) => {
+        const message = toIncomingMessage(data);
+        if (!message) {
+          this.logger.debug({ data }, "Ignored unsupported Feishu message event.");
+          return;
+        }
+
+        void Promise.resolve()
+          .then(() => this.handler.onMessage(message))
+          .catch((error: unknown) => {
+            this.logger.error({ error, messageId: message.messageId }, "Failed to handle Feishu message event.");
+          });
+      },
+      "im.chat.updated_v1": async (data: unknown) => {
+        const update = toChatUpdatedEvent(data);
+        if (!update) {
+          this.logger.debug({ data }, "Ignored Feishu chat update without a name change.");
+          return;
+        }
+        if (!this.handler.onChatUpdated) return;
+
+        void Promise.resolve()
+          .then(() => this.handler.onChatUpdated!(update))
+          .catch((error: unknown) => {
+            this.logger.error(
+              { error, chatId: update.chatId, afterName: update.afterName },
+              "Failed to handle Feishu chat name update.",
+            );
+          });
+      },
+      "card.action.trigger": async (data: unknown) => {
+        const action = toCardAction(data);
+        if (!action) {
+          this.logger.debug({ data }, "Ignored unsupported Feishu card action.");
+          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.");
+          });
+        return {
+          toast: {
+            type: "success",
+            content: "已处理",
+          },
+        };
+      },
+    });
+
+    wsClient.start({ eventDispatcher });
+    this.logger.info("Feishu WebSocket connector started.");
+  }
+}
+
+function toChatUpdatedEvent(data: unknown): ChatUpdatedEvent | undefined {
+  const event = getFeishuEvent(data);
+  const chatId = typeof event?.chat_id === "string" ? event.chat_id : undefined;
+  const beforeName = typeof event?.before_change?.name === "string"
+    ? event.before_change.name
+    : undefined;
+  const afterName = typeof event?.after_change?.name === "string"
+    ? event.after_change.name
+    : undefined;
+  if (!chatId || !afterName || beforeName === afterName) return undefined;
+  return {
+    chatId,
+    ...(beforeName !== undefined ? { beforeName } : {}),
+    afterName,
+  };
+}
+
+function toIncomingMessage(data: unknown): IncomingMessage | undefined {
+  const event = getFeishuEvent(data);
+  const message = event?.message;
+  if (!message) {
+    return undefined;
+  }
+
+  const messageType = message.message_type;
+  const content = parseJsonObject(message.content);
+  const parsed = parseMessageContent(messageType, content, message.mentions);
+  if (!parsed) return undefined;
+  const chatId = message.chat_id;
+  const chatType = message.chat_type === "group" ? "group" : "p2p";
+  const threadId = typeof message.thread_id === "string" && message.thread_id ? message.thread_id : undefined;
+  const rootMessageId = typeof message.root_id === "string" && message.root_id ? message.root_id : undefined;
+  const parentMessageId = typeof message.parent_id === "string" && message.parent_id ? message.parent_id : undefined;
+  const threadContext = Boolean(chatId && threadId);
+  const senderId =
+    event.sender?.sender_id?.open_id ??
+    event.sender?.sender_id?.user_id ??
+    event.sender?.sender_id?.union_id;
+
+  if (!chatId && !senderId) {
+    return undefined;
+  }
+
+  return {
+    messageId: message.message_id ?? `${Date.now()}`,
+    contextKey: chatId
+      ? threadContext
+        ? threadContextKey(chatId, threadId!)
+        : `chat_id:${chatId}`
+      : `open_id:${senderId}`,
+    chatId,
+    chatType,
+    userId: senderId,
+    ...(threadId ? { replyInThread: true as const } : {}),
+    ...(threadContext ? { threadContext: true as const } : {}),
+    ...(threadId ? { threadId } : {}),
+    ...(rootMessageId ? { rootMessageId } : {}),
+    ...(parentMessageId ? { parentMessageId } : {}),
+    text: parsed.text,
+    ...(parsed.images.length > 0 ? { images: parsed.images.map((imageKey) => ({ imageKey })) } : {}),
+  };
+}
+
+function parseMessageContent(
+  messageType: unknown,
+  content: Record<string, unknown>,
+  mentions: unknown,
+): { text: string; images: string[] } | undefined {
+  if (messageType === "text") {
+    const rawText = typeof content.text === "string" ? content.text : "";
+    return { text: stripLeadingMentions(rawText, mentions), images: [] };
+  }
+  if (messageType === "image") {
+    const imageKey = typeof content.image_key === "string" ? content.image_key : undefined;
+    return imageKey ? { text: "", images: [imageKey] } : undefined;
+  }
+  if (messageType !== "post") return undefined;
+
+  const locale = selectPostLocale(content);
+  if (!locale) return undefined;
+  const paragraphs: string[] = [];
+  const title = typeof locale.title === "string" ? locale.title.trim() : "";
+  if (title) paragraphs.push(title);
+  const images: string[] = [];
+  if (Array.isArray(locale.content)) {
+    for (const row of locale.content) {
+      if (!Array.isArray(row)) continue;
+      let rowText = "";
+      for (const element of row) {
+        if (!isRecord(element)) continue;
+        if ((element.tag === "text" || element.tag === "a") && typeof element.text === "string") {
+          rowText += element.text;
+        } else if (element.tag === "img" && typeof element.image_key === "string") {
+          images.push(element.image_key);
+        }
+      }
+      if (rowText.trim()) paragraphs.push(rowText.trim());
+    }
+  }
+  return { text: paragraphs.join("\n"), images: [...new Set(images)] };
+}
+
+function selectPostLocale(content: Record<string, unknown>): Record<string, unknown> | undefined {
+  if (Array.isArray(content.content)) return content;
+  for (const locale of ["zh_cn", "en_us", "ja_jp"]) {
+    if (isRecord(content[locale])) return content[locale];
+  }
+  return Object.values(content).find(isRecord);
+}
+
+function stripLeadingMentions(text: string, value: unknown): string {
+  if (!Array.isArray(value)) return text;
+  const mentionKeys = value.flatMap((mention): string[] => {
+    if (!isRecord(mention) || typeof mention.key !== "string" || !mention.key) return [];
+    return [mention.key];
+  });
+  let remaining = text.trimStart();
+  while (remaining) {
+    const key = mentionKeys.find((candidate) => {
+      if (!remaining.startsWith(candidate)) return false;
+      const next = remaining[candidate.length];
+      return next === undefined || /\s/u.test(next);
+    });
+    if (!key) break;
+    remaining = remaining.slice(key.length).trimStart();
+  }
+  return remaining;
+}
+
+function toCardAction(data: unknown) {
+  const event = getFeishuEvent(data);
+  if (!event?.action) {
+    return undefined;
+  }
+
+  const openId = event.operator?.open_id ?? event.operator?.user_id;
+  const chatId = event.context?.open_chat_id ?? event.chat_id;
+  return {
+    actionId: getEventId(data) ?? event.action.action_id ?? event.action.name ?? `${Date.now()}`,
+    contextKey: chatId ? `chat_id:${chatId}` : `open_id:${openId}`,
+    userId: openId,
+    ...(typeof event.context?.open_message_id === "string" ? { messageId: event.context.open_message_id } : {}),
+    value: isRecord(event.action.value) ? event.action.value : {},
+  };
+}
+
+function getEventId(data: unknown): string | undefined {
+  const value = getNested<unknown>(data, ["header", "event_id"]) ?? getNested(data, ["data", "header", "event_id"]);
+  return typeof value === "string" ? value : undefined;
+}
+
+function getFeishuEvent(data: unknown): Record<string, any> | undefined {
+  return getNested<Record<string, any>>(data, ["event"]) ?? getNested(data, ["data", "event"]) ?? asRecord(data);
+}
+
+function parseJsonObject(value: unknown): Record<string, unknown> {
+  if (isRecord(value)) {
+    return value;
+  }
+
+  if (typeof value !== "string") {
+    return {};
+  }
+
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    return isRecord(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function getNested<T>(value: unknown, path: string[]): T | undefined {
+  let current: unknown = value;
+  for (const key of path) {
+    if (!isRecord(current)) {
+      return undefined;
+    }
+
+    current = current[key];
+  }
+
+  return current as T;
+}
+
+function isRecord(value: unknown): value is Record<string, any> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function asRecord(value: unknown): Record<string, any> | undefined {
+  return isRecord(value) ? value : undefined;
+}

package/src/feishu/FeishuMarkdown.ts

@@ -0,0 +1,47 @@
+interface FenceState {
+  indent: string;
+  marker: "`" | "~";
+  length: number;
+  normalizeIndent: boolean;
+}
+
+const FENCE_OPENER = /^([ \t]*)((?:`{3,})|(?:~{3,}))(.*)$/;
+
+export function normalizeFeishuMarkdown(markdown: string): string {
+  const lines = markdown.match(/[^\r\n]*(?:\r\n|\n)|[^\r\n]+$/g) ?? [];
+  let fence: FenceState | undefined;
+
+  return lines.map((line) => {
+    const ending = line.endsWith("\r\n") ? "\r\n" : line.endsWith("\n") ? "\n" : "";
+    const body = ending ? line.slice(0, -ending.length) : line;
+
+    if (!fence) {
+      const opener = FENCE_OPENER.exec(body);
+      if (!opener?.[2]) return line;
+
+      const indent = opener[1] ?? "";
+      const delimiter = opener[2];
+      fence = {
+        indent,
+        marker: delimiter[0] as "`" | "~",
+        length: delimiter.length,
+        normalizeIndent: indent.length > 0,
+      };
+      return `${fence.normalizeIndent ? body.slice(indent.length) : body}${ending}`;
+    }
+
+    const normalizedBody = fence.normalizeIndent && body.startsWith(fence.indent)
+      ? body.slice(fence.indent.length)
+      : body;
+    if (isFenceCloser(normalizedBody, fence)) fence = undefined;
+    return `${normalizedBody}${ending}`;
+  }).join("");
+}
+
+function isFenceCloser(line: string, fence: FenceState): boolean {
+  const match = /^[ \t]*(`+|~+)[ \t]*$/.exec(line);
+  const delimiter = match?.[1];
+  return delimiter !== undefined
+    && delimiter[0] === fence.marker
+    && delimiter.length >= fence.length;
+}