@keyou007/agent-bot 0.1.0

package/src/feishu/FeishuTurnPresenter.ts

@@ -0,0 +1,539 @@
+import type { AgentEvent } from "../runtime/types.js";
+import {
+  appendSteerMessage as appendSteerMessageToState,
+  createTurnViewState,
+  reduceTurnEvent,
+} from "../presentation/TurnStateReducer.js";
+import { splitMarkdown } from "../presentation/splitMarkdown.js";
+import type { TurnViewState } from "../presentation/turnViewTypes.js";
+import { CardRenderer } from "./CardRenderer.js";
+import { CardUpdateScheduler } from "./CardUpdateScheduler.js";
+import type { FeishuOutbound, MessageReplyTarget } from "./types.js";
+import { createId } from "../utils/id.js";
+import { createHash } from "node:crypto";
+
+const THINKING_CARD_RUNNING_REACTION = "OnIt";
+const THINKING_CARD_FAILED_REACTION = "ERROR";
+const THINKING_CARD_CANCELLED_REACTION = "CrossMark";
+
+interface TurnDeliveryRecord {
+  progressMessageId?: string;
+  finalDelivered: boolean;
+  finalMessageIds: string[];
+}
+
+export interface TurnPresentationStore {
+  saveTurnSnapshot(turnId: string, localSessionId: string, snapshot: unknown, contextKey?: string): void;
+  promotePendingTurn(
+    pendingTurnId: string,
+    turnId: string,
+    localSessionId: string,
+    snapshot: unknown,
+    contextKey?: string,
+  ): void;
+  getTurnSnapshot(turnId: string): unknown;
+  getTurnContextKey?(turnId: string): string | undefined;
+  saveTurnDelivery(turnId: string, patch: { progressMessageId?: string; lastCardHash?: string }): void;
+  saveFinalDeliveryProgress(turnId: string, messageIds: string[]): void;
+  markFinalDelivered(turnId: string, messageIds: string[]): void;
+  getTurnDelivery(turnId: string): TurnDeliveryRecord | undefined;
+}
+
+export interface FeishuTurnPresenterOptions {
+  normalIntervalMs?: number;
+  criticalGapMs?: number;
+  finalChunkLength?: number;
+  onError?: (error: unknown) => void;
+  finalRetryBackoffMs?: number[];
+}
+
+interface TurnEntry {
+  contextKey: string;
+  state: TurnViewState;
+  historySnapshot?: TurnViewState;
+  initializing: Promise<void>;
+  messageId?: string;
+  reactionId?: string;
+  reactionEmoji?: string;
+  scheduler?: CardUpdateScheduler<TurnViewState>;
+  finalizing?: Promise<void>;
+  lastFinalizedStatus?: TurnViewState["status"];
+}
+
+export class FeishuTurnPresenter {
+  private readonly sessionContexts = new Map<string, string>();
+  private readonly sessionTitles = new Map<string, string>();
+  private readonly sessionCwds = new Map<string, string>();
+  private readonly entries = new Map<string, TurnEntry>();
+  private readonly pendingEntries = new Map<string, TurnEntry>();
+  private readonly renderer: CardRenderer;
+
+  constructor(
+    private readonly outbound: FeishuOutbound,
+    private readonly store: TurnPresentationStore,
+    renderer?: CardRenderer,
+    private readonly options: FeishuTurnPresenterOptions = {},
+  ) {
+    this.renderer = renderer ?? new CardRenderer();
+  }
+
+  registerSession(sessionId: string, contextKey: string, taskTitle?: string, projectCwd?: string): void {
+    this.sessionContexts.set(sessionId, contextKey);
+    if (taskTitle) this.sessionTitles.set(sessionId, taskTitle);
+    if (projectCwd) this.sessionCwds.set(sessionId, projectCwd);
+  }
+
+  updateSessionTitle(sessionId: string, taskTitle: string): void {
+    this.sessionTitles.set(sessionId, taskTitle);
+    for (const entry of this.entries.values()) {
+      if (entry.state.sessionId !== sessionId || entry.state.taskTitle === taskTitle) continue;
+      entry.state = { ...entry.state, taskTitle };
+      this.store.saveTurnSnapshot(entry.state.turnId, sessionId, entry.state, entry.contextKey);
+      if (!entry.historySnapshot) entry.scheduler?.update(entry.state, "critical");
+    }
+  }
+
+  unregisterSession(sessionId: string): void {
+    this.sessionContexts.delete(sessionId);
+    this.sessionTitles.delete(sessionId);
+    this.sessionCwds.delete(sessionId);
+  }
+
+  async startPendingTurn(
+    sessionId: string,
+    contextKey: string,
+    taskTitle?: string,
+    replyTarget?: MessageReplyTarget,
+    prompt?: string,
+  ): Promise<void> {
+    const existing = this.pendingEntries.get(sessionId);
+    if (existing) {
+      await existing.initializing;
+      if (prompt && existing.state.prompt !== prompt) {
+        existing.state = { ...existing.state, prompt };
+        this.store.saveTurnSnapshot(existing.state.turnId, sessionId, existing.state, existing.contextKey);
+        if (!existing.historySnapshot) existing.scheduler?.update(existing.state, "critical");
+      }
+      return;
+    }
+    this.sessionContexts.set(sessionId, contextKey);
+    if (taskTitle) this.sessionTitles.set(sessionId, taskTitle);
+    const state = createTurnViewState(
+      sessionId,
+      createId("pending"),
+      Date.now(),
+      taskTitle ?? this.sessionTitles.get(sessionId),
+      replyTarget,
+      this.sessionCwds.get(sessionId),
+      prompt,
+    );
+    const entry = { contextKey, state, initializing: Promise.resolve() } as TurnEntry;
+    this.entries.set(state.turnId, entry);
+    this.pendingEntries.set(sessionId, entry);
+    this.store.saveTurnSnapshot(state.turnId, sessionId, state, contextKey);
+    entry.initializing = this.initializeEntry(entry);
+    try {
+      await entry.initializing;
+    } catch (error) {
+      if (this.pendingEntries.get(sessionId) === entry) this.pendingEntries.delete(sessionId);
+      this.entries.delete(state.turnId);
+      throw error;
+    }
+  }
+
+  async failPendingTurn(sessionId: string, message: string): Promise<void> {
+    const entry = this.pendingEntries.get(sessionId);
+    if (!entry) return;
+    this.pendingEntries.delete(sessionId);
+    entry.state = { ...entry.state, status: "failed", error: message, completedAt: Date.now() };
+    this.store.saveTurnSnapshot(entry.state.turnId, sessionId, entry.state, entry.contextKey);
+    await entry.initializing;
+    try {
+      await entry.scheduler?.flush(entry.state);
+    } catch (error) {
+      this.options.onError?.(error);
+    }
+    await this.syncThinkingCardReaction(entry);
+  }
+
+  async appendSteerMessage(
+    sessionId: string,
+    turnId: string,
+    text: string,
+    messageId?: string,
+  ): Promise<void> {
+    const activityId = `steer:${messageId ?? createId("message")}`;
+    let entry = this.entries.get(turnId);
+    if (!entry) {
+      const saved = this.store.getTurnSnapshot(turnId);
+      const contextKey = this.store.getTurnContextKey?.(turnId) ?? this.sessionContexts.get(sessionId);
+      if (!contextKey) return;
+      const initial = isTurnViewState(saved) && saved.sessionId === sessionId
+        ? saved
+        : {
+            ...createTurnViewState(
+              sessionId,
+              turnId,
+              Date.now(),
+              this.sessionTitles.get(sessionId),
+              undefined,
+              this.sessionCwds.get(sessionId),
+            ),
+            status: "running" as const,
+          };
+      const state = appendSteerMessageToState(initial, activityId, text);
+      entry = { contextKey, state, initializing: Promise.resolve() } as TurnEntry;
+      this.entries.set(turnId, entry);
+      this.store.saveTurnSnapshot(turnId, sessionId, state, contextKey);
+      entry.initializing = this.initializeEntry(entry);
+      await entry.initializing;
+      return;
+    }
+
+    await entry.initializing;
+    entry.state = appendSteerMessageToState(entry.state, activityId, text);
+    this.store.saveTurnSnapshot(turnId, sessionId, entry.state, entry.contextKey);
+    if (!entry.historySnapshot) entry.scheduler?.update(entry.state, "critical");
+  }
+
+  async onEvent(event: AgentEvent): Promise<void> {
+    let existing = this.entries.get(event.turnId);
+    let eventApplied = false;
+    if (!existing && event.type === "turn_started") {
+      const pending = this.pendingEntries.get(event.sessionId);
+      if (pending) {
+        const pendingTurnId = pending.state.turnId;
+        const state = reduceTurnEvent(
+          createTurnViewState(
+            event.sessionId,
+            event.turnId,
+            event.startedAt,
+            pending.state.taskTitle,
+            pending.state.replyTarget,
+            pending.state.projectCwd,
+            pending.state.prompt,
+          ),
+          event,
+        );
+        this.store.promotePendingTurn(
+          pendingTurnId,
+          event.turnId,
+          event.sessionId,
+          state,
+          pending.contextKey,
+        );
+        this.pendingEntries.delete(event.sessionId);
+        this.entries.delete(pendingTurnId);
+        pending.state = state;
+        this.entries.set(event.turnId, pending);
+        existing = pending;
+        eventApplied = true;
+      }
+    }
+    const entry = existing ?? this.createEntry(event);
+    if (!entry) return;
+
+    if (existing && !eventApplied) {
+      entry.state = reduceTurnEvent(entry.state, event);
+      this.store.saveTurnSnapshot(event.turnId, event.sessionId, entry.state, entry.contextKey);
+    }
+
+    await entry.initializing;
+    if (!entry.scheduler) return;
+
+    if (isTerminalEvent(event)) {
+      if (entry.finalizing) await entry.finalizing;
+      const terminalState = entry.state;
+      if (entry.lastFinalizedStatus === terminalState.status) return;
+      const finalizing = this.finalize(entry, terminalState);
+      entry.finalizing = finalizing;
+      try {
+        await finalizing;
+        entry.lastFinalizedStatus = terminalState.status;
+      } finally {
+        if (entry.finalizing === finalizing) entry.finalizing = undefined;
+      }
+      return;
+    }
+
+    if (!entry.historySnapshot) entry.scheduler.update(entry.state, eventPriority(event));
+  }
+
+  async showDetails(contextKey: string, turnId: string): Promise<void> {
+    const snapshot = this.store.getTurnSnapshot(turnId);
+    if (!isTurnViewState(snapshot)) {
+      await this.outbound.sendText(contextKey, "未找到这次执行的详情。可能已被清理。");
+      return;
+    }
+    await this.outbound.sendInteractiveCard(contextKey, this.renderer.renderTurnDetails(snapshot));
+  }
+
+  async showActivityPage(
+    contextKey: string,
+    turnId: string,
+    page: number | "latest",
+    messageId?: string,
+  ): Promise<void> {
+    const entry = this.entries.get(turnId);
+    if (entry) await entry.initializing;
+    const ownsProgressCard = entry
+      && entry.contextKey === contextKey
+      && (!messageId || !entry.messageId || messageId === entry.messageId);
+
+    if (ownsProgressCard) {
+      const targetMessageId = messageId ?? entry.messageId;
+      if (page === "latest") {
+        entry.historySnapshot = undefined;
+        if (entry.scheduler) {
+          entry.scheduler.invalidateRenderedCard();
+          await entry.scheduler.flush(entry.state);
+        } else if (targetMessageId) {
+          await this.outbound.updateInteractiveCard(targetMessageId, this.renderer.renderTurn(entry.state));
+        } else {
+          await this.outbound.sendInteractiveCard(contextKey, this.renderer.renderTurn(entry.state));
+        }
+        return;
+      }
+
+      if (!entry.historySnapshot) {
+        entry.historySnapshot = entry.state;
+        await entry.scheduler?.flush();
+      }
+      const card = this.renderer.renderActivityHistory(entry.historySnapshot, page);
+      if (targetMessageId) await this.outbound.updateInteractiveCard(targetMessageId, card);
+      else await this.outbound.sendInteractiveCard(contextKey, card);
+      return;
+    }
+
+    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);
+    if (messageId) await this.outbound.updateInteractiveCard(messageId, card);
+    else await this.outbound.sendInteractiveCard(contextKey, card);
+  }
+
+  async resumeDelivery(_sessionId: string, contextKey: string, turnId: string): Promise<void> {
+    const delivery = this.store.getTurnDelivery(turnId);
+    if (delivery?.finalDelivered) return;
+    const snapshot = this.store.getTurnSnapshot(turnId);
+    if (!isTurnViewState(snapshot) || snapshot.status !== "completed" || !snapshot.finalResponse) return;
+    await this.deliverFinal(contextKey, snapshot);
+  }
+
+  async flushAll(): Promise<void> {
+    await Promise.all(
+      [...this.entries.values()].map(async (entry) => {
+        await entry.initializing;
+        if (!entry.historySnapshot) await entry.scheduler?.flush();
+      }),
+    );
+  }
+
+  private createEntry(event: AgentEvent): TurnEntry | undefined {
+    const saved = this.store.getTurnSnapshot(event.turnId);
+    const contextKey = this.store.getTurnContextKey?.(event.turnId) ?? this.sessionContexts.get(event.sessionId);
+    if (!contextKey) return undefined;
+    const startedAt = event.type === "turn_started" ? event.startedAt : Date.now();
+    const initial = isTurnViewState(saved) && saved.sessionId === event.sessionId
+      ? saved
+      : createTurnViewState(
+          event.sessionId,
+          event.turnId,
+          startedAt,
+          this.sessionTitles.get(event.sessionId),
+          undefined,
+          this.sessionCwds.get(event.sessionId),
+          undefined,
+        );
+    const state = reduceTurnEvent(
+      initial,
+      event,
+    );
+    const entry = { contextKey, state, initializing: Promise.resolve() } as TurnEntry;
+    this.entries.set(event.turnId, entry);
+    this.store.saveTurnSnapshot(event.turnId, event.sessionId, state, contextKey);
+    entry.initializing = this.initializeEntry(entry);
+    return entry;
+  }
+
+  private async initializeEntry(entry: TurnEntry): Promise<void> {
+    const sentState = entry.state;
+    const card = this.renderer.renderTurn(sentState);
+    const delivery = this.store.getTurnDelivery(sentState.turnId);
+    const persistedMessageId = delivery?.progressMessageId;
+    if (delivery?.finalDelivered && !persistedMessageId) return;
+    let messageId = persistedMessageId;
+    if (messageId) {
+      await this.outbound.updateInteractiveCard(messageId, card);
+    } else {
+      messageId = sentState.replyTarget && this.outbound.replyInteractiveCard
+        ? await this.outbound.replyInteractiveCard(
+            entry.contextKey,
+            sentState.replyTarget,
+            card,
+            progressMessageKey(sentState.turnId),
+          )
+        : await this.outbound.sendInteractiveCard(entry.contextKey, card);
+    }
+    entry.messageId = messageId;
+    if (!messageId) return;
+    this.store.saveTurnDelivery(entry.state.turnId, { progressMessageId: messageId });
+    entry.scheduler = new CardUpdateScheduler<TurnViewState>({
+      render: (state) => this.renderer.renderTurn(state),
+      write: (card) => this.outbound.updateInteractiveCard(messageId, card),
+      normalIntervalMs: this.options.normalIntervalMs,
+      criticalGapMs: this.options.criticalGapMs,
+      onError: this.options.onError,
+    });
+    entry.scheduler.seed(sentState);
+    if (entry.state !== sentState) entry.scheduler.update(entry.state, "critical");
+    await this.syncThinkingCardReaction(entry);
+  }
+
+  private async finalize(entry: TurnEntry, state: TurnViewState): Promise<void> {
+    if (!entry.historySnapshot) {
+      try {
+        await entry.scheduler?.flush(state);
+      } catch (error) {
+        this.options.onError?.(error);
+      }
+    }
+    await this.syncThinkingCardReaction(entry);
+    if (state.status !== "completed" || !state.finalResponse) return;
+    await this.deliverFinal(entry.contextKey, state);
+  }
+
+  private async syncThinkingCardReaction(entry: TurnEntry): Promise<void> {
+    const messageId = entry.messageId;
+    if (!messageId) return;
+    const desiredEmoji = thinkingCardReactionForStatus(entry.state.status);
+    if (desiredEmoji === entry.reactionEmoji) return;
+
+    if (!desiredEmoji) {
+      if (!entry.reactionId || !this.outbound.deleteReaction) return;
+      try {
+        await this.outbound.deleteReaction(messageId, entry.reactionId);
+        entry.reactionId = undefined;
+        entry.reactionEmoji = undefined;
+      } catch (error) {
+        this.options.onError?.(error);
+      }
+      return;
+    }
+
+    if (!this.outbound.addReaction) return;
+    try {
+      const replacementId = await this.outbound.addReaction(messageId, desiredEmoji);
+      if (!replacementId) return;
+      const previousId = entry.reactionId;
+      entry.reactionId = replacementId;
+      entry.reactionEmoji = desiredEmoji;
+      if (previousId && this.outbound.deleteReaction) {
+        try {
+          await this.outbound.deleteReaction(messageId, previousId);
+        } catch (error) {
+          this.options.onError?.(error);
+        }
+      }
+    } catch (error) {
+      this.options.onError?.(error);
+    }
+  }
+
+  private async deliverFinal(contextKey: string, state: TurnViewState): Promise<void> {
+    const delivery = this.store.getTurnDelivery(state.turnId);
+    if (delivery?.finalDelivered || !state.finalResponse) return;
+    const chunks = splitMarkdown(state.finalResponse, this.options.finalChunkLength ?? 4_000);
+    const messageIds = [...(delivery?.finalMessageIds ?? [])];
+    for (let index = messageIds.length; index < chunks.length; index += 1) {
+      const chunk = chunks[index];
+      if (chunk === undefined) continue;
+      const messageId = await this.sendFinalChunk(
+        contextKey,
+        state.replyTarget,
+        chunk,
+        finalMessageKey(state.turnId, index),
+      );
+      messageIds.push(messageId ?? `delivered-chunk-${index}`);
+      this.store.saveFinalDeliveryProgress(state.turnId, messageIds);
+    }
+    this.store.markFinalDelivered(state.turnId, messageIds);
+  }
+
+  private async sendFinalChunk(
+    contextKey: string,
+    replyTarget: MessageReplyTarget | undefined,
+    chunk: string,
+    idempotencyKey: string,
+  ): Promise<string | undefined> {
+    const backoffs = this.options.finalRetryBackoffMs ?? [2_000, 4_000, 8_000];
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        if (replyTarget && this.outbound.replyMarkdown) {
+          return await this.outbound.replyMarkdown(contextKey, replyTarget, chunk, idempotencyKey);
+        }
+        return await this.outbound.sendMarkdown(contextKey, chunk, idempotencyKey);
+      } catch (error) {
+        if (!isRetryableError(error) || attempt >= backoffs.length) throw error;
+        await delay(backoffs[attempt] ?? 8_000);
+      }
+    }
+  }
+}
+
+function eventPriority(event: AgentEvent): "normal" | "critical" {
+  if (event.type === "turn_started" || event.type === "approval_requested" || event.type === "approval_resolved" || event.type === "tool_started") {
+    return "critical";
+  }
+  return "normal";
+}
+
+function isTerminalEvent(event: AgentEvent): boolean {
+  return event.type === "turn_completed" || event.type === "turn_cancelled" || event.type === "turn_failed";
+}
+
+function thinkingCardReactionForStatus(status: TurnViewState["status"]): string | undefined {
+  if (status === "completed") return undefined;
+  if (status === "failed") return THINKING_CARD_FAILED_REACTION;
+  if (status === "cancelled") return THINKING_CARD_CANCELLED_REACTION;
+  return THINKING_CARD_RUNNING_REACTION;
+}
+
+function isTurnViewState(value: unknown): value is TurnViewState {
+  if (typeof value !== "object" || value === null) return false;
+  const state = value as Partial<TurnViewState>;
+  return (
+    typeof state.sessionId === "string" &&
+    typeof state.turnId === "string" &&
+    typeof state.status === "string" &&
+    typeof state.startedAt === "number" &&
+    Array.isArray(state.plan) &&
+    Array.isArray(state.completedTools) &&
+    Array.isArray(state.failedTools) &&
+    Array.isArray(state.fileSummary)
+  );
+}
+
+function isRetryableError(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    (("isRetryable" in error && error.isRetryable === true) || ("isRateLimit" in error && error.isRateLimit === true))
+  );
+}
+
+function delay(milliseconds: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+function finalMessageKey(turnId: string, index: number): string {
+  const digest = createHash("sha256").update(`${turnId}:${index}`).digest("hex").slice(0, 32);
+  return `codex-final-${digest}`;
+}
+
+function progressMessageKey(turnId: string): string {
+  const digest = createHash("sha256").update(`progress:${turnId}`).digest("hex").slice(0, 32);
+  return `codex-progress-${digest}`;
+}

package/src/feishu/GroupAvatarGenerator.ts

@@ -0,0 +1,102 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { Resvg } from "@resvg/resvg-js";
+
+const AVATAR_SIZE = 512;
+
+interface AvatarPalette {
+  primary: string;
+  accent: string;
+  light: string;
+  dark: string;
+}
+
+export function resolveGroupAvatarProjectName(projectCwd: string | undefined, fallbackTitle: string): string {
+  if (!projectCwd) return fallbackTitle;
+  try {
+    const manifest = JSON.parse(readFileSync(path.join(projectCwd, "package.json"), "utf8")) as { name?: unknown };
+    if (typeof manifest.name === "string" && manifest.name.trim()) {
+      return manifest.name.trim().split("/").at(-1) ?? manifest.name.trim();
+    }
+  } catch {
+    // Non-Node projects and unreadable manifests fall back to the directory name.
+  }
+  return path.basename(path.resolve(projectCwd)) || fallbackTitle;
+}
+
+export function groupAvatarLabel(projectName: string): string {
+  const normalized = projectName.trim();
+  const characters = Array.from(normalized);
+  const firstCharacter = characters[0];
+  if (firstCharacter && isCjk(firstCharacter.codePointAt(0) ?? 0)) return characters.slice(0, 4).join("");
+  return normalized.match(/[\p{L}\p{N}]+/u)?.[0] || "?";
+}
+
+export function generateGroupAvatarPng(projectName: string, projectCwd?: string): Uint8Array {
+  const seed = projectCwd ? path.resolve(projectCwd) : projectName;
+  const hash = createHash("sha256").update(seed).digest();
+  const svg = identiconAvatarSvg(groupAvatarLabel(projectName), choosePalette(hash[0] ?? 0), hash);
+  return new Resvg(svg, {
+    fitTo: { mode: "width", value: AVATAR_SIZE },
+    font: { loadSystemFonts: true },
+  }).render().asPng();
+}
+
+function identiconAvatarSvg(label: string, colors: AvatarPalette, bytes: Buffer): string {
+  const dots: string[] = [];
+  const cell = 62;
+  const start = 101;
+  for (let row = 0; row < 5; row += 1) {
+    for (let column = 0; column < 3; column += 1) {
+      if (((bytes[1 + row * 3 + column] ?? 0) & 1) === 0) continue;
+      for (const mirrored of new Set([column, 4 - column])) {
+        const color = (row + column) % 3 === 0 ? colors.accent : colors.primary;
+        dots.push(`<circle cx="${start + mirrored * cell + cell / 2}" cy="${start + row * cell + cell / 2}" r="25" fill="${color}"/>`);
+      }
+    }
+  }
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="${AVATAR_SIZE}" height="${AVATAR_SIZE}" viewBox="0 0 ${AVATAR_SIZE} ${AVATAR_SIZE}">
+  <circle cx="256" cy="256" r="240" fill="${colors.dark}"/>
+  ${dots.join("\n  ")}
+  <rect x="54" y="184" width="404" height="144" rx="52" fill="${colors.dark}"/>
+  ${centeredText(label, colors.light)}
+</svg>`;
+}
+
+function centeredText(text: string, color: string): string {
+  const visualWidth = Math.max(1, Array.from(text).reduce(
+    (width, character) => width + (isCjk(character.codePointAt(0) ?? 0) ? 1 : 0.62),
+    0,
+  ));
+  const fontSize = Math.max(34, Math.min(144, 400 / visualWidth));
+  return `<text x="256" y="274" text-anchor="middle" dominant-baseline="middle" fill="${color}" font-family="Inter, Segoe UI, PingFang SC, Noto Sans CJK SC, sans-serif" font-size="${fontSize.toFixed(1)}" font-weight="700">${escapeXml(text)}</text>`;
+}
+
+function choosePalette(seed: number): AvatarPalette {
+  const palettes: AvatarPalette[] = [
+    { primary: "#246BFD", accent: "#20D5E8", light: "#FFFFFF", dark: "#10223C" },
+    { primary: "#7657FF", accent: "#E75BFF", light: "#FFFFFF", dark: "#24153F" },
+    { primary: "#00A884", accent: "#5CE1B9", light: "#FFFFFF", dark: "#123B36" },
+    { primary: "#F26B38", accent: "#FFB14A", light: "#FFFFFF", dark: "#432418" },
+  ];
+  return palettes[seed % palettes.length]!;
+}
+
+function isCjk(codePoint: number): boolean {
+  return (
+    (codePoint >= 0x3400 && codePoint <= 0x4dbf)
+    || (codePoint >= 0x4e00 && codePoint <= 0x9fff)
+    || (codePoint >= 0xf900 && codePoint <= 0xfaff)
+  );
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&apos;");
+}

package/src/feishu/LocalCardImage.ts

@@ -0,0 +1,13 @@
+export const LOCAL_CARD_IMAGE_PATH = "__acp_local_image_path";
+
+export function localCardImage(filePath: string, label: string): Record<string, unknown> {
+  return {
+    tag: "img",
+    img_key: "",
+    [LOCAL_CARD_IMAGE_PATH]: filePath,
+    alt: { tag: "plain_text", content: label },
+    title: { tag: "plain_text", content: label },
+    mode: "fit_horizontal",
+    preview: true,
+  };
+}