@openclaw-plugins/feishu-plus 0.1.7-fork.1

package/src/send.ts

@@ -0,0 +1,492 @@
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import type { FeishuSendResult, ResolvedFeishuAccount } from "./types.js";
+import type { MentionTarget } from "./mention.js";
+import { buildMentionedMessage, buildMentionedCardContent } from "./mention.js";
+import { createFeishuClient } from "./client.js";
+import { resolveReceiveIdType, normalizeFeishuTarget } from "./targets.js";
+import { getFeishuRuntime } from "./runtime.js";
+import { resolveFeishuAccount } from "./accounts.js";
+
+export type FeishuMessageInfo = {
+  messageId: string;
+  chatId: string;
+  senderId?: string;
+  senderOpenId?: string;
+  content: string;
+  contentType: string;
+  createTime?: number;
+};
+
+/**
+ * Get a message by its ID.
+ * Useful for fetching quoted/replied message content.
+ */
+export async function getMessageFeishu(params: {
+  cfg: ClawdbotConfig;
+  messageId: string;
+  accountId?: string;
+}): Promise<FeishuMessageInfo | null> {
+  const { cfg, messageId, accountId } = params;
+  const account = resolveFeishuAccount({ cfg, accountId });
+  if (!account.configured) {
+    throw new Error(`Feishu account "${account.accountId}" not configured`);
+  }
+
+  const client = createFeishuClient(account);
+
+  try {
+    const response = (await client.im.message.get({
+      path: { message_id: messageId },
+    })) as {
+      code?: number;
+      msg?: string;
+      data?: {
+        items?: Array<{
+          message_id?: string;
+          chat_id?: string;
+          msg_type?: string;
+          body?: { content?: string };
+          sender?: {
+            id?: string;
+            id_type?: string;
+            sender_type?: string;
+          };
+          create_time?: string;
+        }>;
+      };
+    };
+
+    if (response.code !== 0) {
+      return null;
+    }
+
+    const item = response.data?.items?.[0];
+    if (!item) {
+      return null;
+    }
+
+    // Parse content based on message type
+    let content = item.body?.content ?? "";
+    try {
+      const parsed = JSON.parse(content);
+      if (item.msg_type === "text" && parsed.text) {
+        content = parsed.text;
+      }
+    } catch {
+      // Keep raw content if parsing fails
+    }
+
+    return {
+      messageId: item.message_id ?? messageId,
+      chatId: item.chat_id ?? "",
+      senderId: item.sender?.id,
+      senderOpenId: item.sender?.id_type === "open_id" ? item.sender?.id : undefined,
+      content,
+      contentType: item.msg_type ?? "text",
+      createTime: item.create_time ? parseInt(item.create_time, 10) : undefined,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export type SendFeishuMessageParams = {
+  cfg: ClawdbotConfig;
+  to: string;
+  text: string;
+  replyToMessageId?: string;
+  /** Mention target users */
+  mentions?: MentionTarget[];
+  /** Account ID (optional, uses default if not specified) */
+  accountId?: string;
+};
+
+function buildFeishuPostMessagePayload(params: { messageText: string }): {
+  content: string;
+  msgType: string;
+} {
+  const { messageText } = params;
+  return {
+    content: JSON.stringify({
+      zh_cn: {
+        content: [
+          [
+            {
+              tag: "md",
+              text: messageText,
+            },
+          ],
+        ],
+      },
+    }),
+    msgType: "post",
+  };
+}
+
+export async function sendMessageFeishu(params: SendFeishuMessageParams): Promise<FeishuSendResult> {
+  const { cfg, to, text, replyToMessageId, mentions, accountId } = params;
+  const account = resolveFeishuAccount({ cfg, accountId });
+  if (!account.configured) {
+    throw new Error(`Feishu account "${account.accountId}" not configured`);
+  }
+
+  const client = createFeishuClient(account);
+  const receiveId = normalizeFeishuTarget(to);
+  if (!receiveId) {
+    throw new Error(`Invalid Feishu target: ${to}`);
+  }
+
+  const receiveIdType = resolveReceiveIdType(receiveId);
+  const tableMode = getFeishuRuntime().channel.text.resolveMarkdownTableMode({
+    cfg,
+    channel: "feishu",
+  });
+
+  // Build message content (with @mention support)
+  let rawText = text ?? "";
+  if (mentions && mentions.length > 0) {
+    rawText = buildMentionedMessage(mentions, rawText);
+  }
+  const messageText = getFeishuRuntime().channel.text.convertMarkdownTables(rawText, tableMode);
+
+  const { content, msgType } = buildFeishuPostMessagePayload({ messageText });
+
+  if (replyToMessageId) {
+    const response = await client.im.message.reply({
+      path: { message_id: replyToMessageId },
+      data: {
+        content,
+        msg_type: msgType,
+      },
+    });
+
+    if (response.code !== 0) {
+      throw new Error(`Feishu reply failed: ${response.msg || `code ${response.code}`}`);
+    }
+
+    return {
+      messageId: response.data?.message_id ?? "unknown",
+      chatId: receiveId,
+    };
+  }
+
+  const response = await client.im.message.create({
+    params: { receive_id_type: receiveIdType },
+    data: {
+      receive_id: receiveId,
+      content,
+      msg_type: msgType,
+    },
+  });
+
+  if (response.code !== 0) {
+    throw new Error(`Feishu send failed: ${response.msg || `code ${response.code}`}`);
+  }
+
+  return {
+    messageId: response.data?.message_id ?? "unknown",
+    chatId: receiveId,
+  };
+}
+
+export type SendFeishuCardParams = {
+  cfg: ClawdbotConfig;
+  to: string;
+  card: Record<string, unknown>;
+  replyToMessageId?: string;
+  accountId?: string;
+};
+
+export async function sendCardFeishu(params: SendFeishuCardParams): Promise<FeishuSendResult> {
+  const { cfg, to, card, replyToMessageId, accountId } = params;
+  const account = resolveFeishuAccount({ cfg, accountId });
+  if (!account.configured) {
+    throw new Error(`Feishu account "${account.accountId}" not configured`);
+  }
+
+  const client = createFeishuClient(account);
+  const receiveId = normalizeFeishuTarget(to);
+  if (!receiveId) {
+    throw new Error(`Invalid Feishu target: ${to}`);
+  }
+
+  const receiveIdType = resolveReceiveIdType(receiveId);
+  const content = JSON.stringify(card);
+
+  if (replyToMessageId) {
+    const response = await client.im.message.reply({
+      path: { message_id: replyToMessageId },
+      data: {
+        content,
+        msg_type: "interactive",
+      },
+    });
+
+    if (response.code !== 0) {
+      throw new Error(`Feishu card reply failed: ${response.msg || `code ${response.code}`}`);
+    }
+
+    return {
+      messageId: response.data?.message_id ?? "unknown",
+      chatId: receiveId,
+    };
+  }
+
+  const response = await client.im.message.create({
+    params: { receive_id_type: receiveIdType },
+    data: {
+      receive_id: receiveId,
+      content,
+      msg_type: "interactive",
+    },
+  });
+
+  if (response.code !== 0) {
+    throw new Error(`Feishu card send failed: ${response.msg || `code ${response.code}`}`);
+  }
+
+  return {
+    messageId: response.data?.message_id ?? "unknown",
+    chatId: receiveId,
+  };
+}
+
+export async function updateCardFeishu(params: {
+  cfg: ClawdbotConfig;
+  messageId: string;
+  card: Record<string, unknown>;
+  accountId?: string;
+}): Promise<void> {
+  const { cfg, messageId, card, accountId } = params;
+  const account = resolveFeishuAccount({ cfg, accountId });
+  if (!account.configured) {
+    throw new Error(`Feishu account "${account.accountId}" not configured`);
+  }
+
+  const client = createFeishuClient(account);
+  const content = JSON.stringify(card);
+
+  const response = await client.im.message.patch({
+    path: { message_id: messageId },
+    data: { content },
+  });
+
+  if (response.code !== 0) {
+    throw new Error(`Feishu card update failed: ${response.msg || `code ${response.code}`}`);
+  }
+}
+
+/**
+ * Build a Feishu interactive card with markdown content.
+ * Cards render markdown properly (code blocks, tables, links, etc.)
+ * Uses schema 2.0 format for proper markdown rendering.
+ */
+export function buildMarkdownCard(text: string): Record<string, unknown> {
+  return {
+    schema: "2.0",
+    config: {
+      wide_screen_mode: true,
+    },
+    body: {
+      elements: [
+        {
+          tag: "markdown",
+          content: text,
+        },
+      ],
+    },
+  };
+}
+
+/**
+ * Card template color options
+ */
+export type CardTemplate = "blue" | "wathet" | "turquoise" | "green" | "yellow" | "orange" | "red" | "carmine" | "violet" | "purple" | "indigo" | "grey" | "default";
+
+/**
+ * Button configuration for interactive cards
+ */
+export interface CardButton {
+  text: string;
+  type?: "primary" | "default" | "danger";
+  url: string;
+}
+
+/**
+ * Build a Feishu interactive card with title, content and optional buttons.
+ * This creates a rich, visually appealing card message.
+ * 
+ * @param options - Card configuration options
+ * @returns Interactive card object ready to send
+ * 
+ * @example
+ * ```typescript
+ * const card = buildInteractiveCard({
+ *   title: "📋 今日热点速报",
+ *   template: "blue",
+ *   content: "🔹 **黄金突破5500美元** 创历史新高\\n🔹 **英国首相访华** 八年来首次",
+ *   buttons: [
+ *     { text: "查看完整热搜", type: "primary", url: "https://s.weibo.com/top/summary" },
+ *   ]
+ * });
+ * ```
+ */
+export function buildInteractiveCard(options: {
+  title?: string;
+  template?: CardTemplate;
+  content: string;
+  buttons?: CardButton[];
+  streaming_mode?: boolean;
+}): Record<string, unknown> {
+  const { title, template = "default", content, buttons, streaming_mode } = options;
+
+  const elements: any[] = [];
+
+  // Add title header if provided
+  if (title) {
+    elements.push({
+      tag: "div",
+      text: {
+        tag: "plain_text",
+        content: title,
+      },
+    });
+    elements.push({ tag: "hr" });
+  }
+
+  // Add main content
+  elements.push({
+    tag: "markdown",
+    content: content,
+  });
+
+  // Add buttons if provided
+  if (buttons && buttons.length > 0) {
+    elements.push({ tag: "hr" });
+    
+    const actions = buttons.map((btn) => ({
+      tag: "button",
+      text: {
+        tag: "plain_text",
+        content: btn.text,
+      },
+      type: btn.type ?? "default",
+      url: btn.url,
+    }));
+
+    elements.push({
+      tag: "action",
+      actions,
+    });
+  }
+
+  const card: Record<string, unknown> = {
+    config: {
+      wide_screen_mode: true,
+    },
+    header: title ? {
+      title: {
+        tag: "plain_text",
+        content: title,
+      },
+      template: template === "default" ? undefined : template,
+    } : undefined,
+    elements,
+  };
+
+  // Add streaming_mode if provided
+  if (streaming_mode !== undefined) {
+    card.streaming_mode = streaming_mode;
+  }
+
+  // Remove undefined header if no title
+  if (!title) {
+    delete card.header;
+  }
+
+  return card;
+}
+
+/**
+ * Create a simple text card for streaming updates.
+ * This is a lightweight card format optimized for real-time updates.
+ * 
+ * @param text - The markdown text content
+ * @param streaming_mode - Whether to enable streaming mode
+ * @returns Simple text card object
+ */
+export function createSimpleTextCard(text: string, streaming_mode: boolean = false): Record<string, unknown> {
+  return {
+    config: {
+      wide_screen_mode: true,
+    },
+    elements: [
+      {
+        tag: "markdown",
+        content: text,
+      },
+    ],
+    streaming_mode,
+  };
+}
+
+/**
+ * Send a message as a markdown card (interactive message).
+ * This renders markdown properly in Feishu (code blocks, tables, bold/italic, etc.)
+ */
+export async function sendMarkdownCardFeishu(params: {
+  cfg: ClawdbotConfig;
+  to: string;
+  text: string;
+  replyToMessageId?: string;
+  /** Mention target users */
+  mentions?: MentionTarget[];
+  accountId?: string;
+}): Promise<FeishuSendResult> {
+  const { cfg, to, text, replyToMessageId, mentions, accountId } = params;
+  // Build message content (with @mention support)
+  let cardText = text;
+  if (mentions && mentions.length > 0) {
+    cardText = buildMentionedCardContent(mentions, text);
+  }
+  const card = buildMarkdownCard(cardText);
+  return sendCardFeishu({ cfg, to, card, replyToMessageId, accountId });
+}
+
+/**
+ * Edit an existing text message.
+ * Note: Feishu only allows editing messages within 24 hours.
+ */
+export async function editMessageFeishu(params: {
+  cfg: ClawdbotConfig;
+  messageId: string;
+  text: string;
+  accountId?: string;
+}): Promise<void> {
+  const { cfg, messageId, text, accountId } = params;
+  const account = resolveFeishuAccount({ cfg, accountId });
+  if (!account.configured) {
+    throw new Error(`Feishu account "${account.accountId}" not configured`);
+  }
+
+  const client = createFeishuClient(account);
+  const tableMode = getFeishuRuntime().channel.text.resolveMarkdownTableMode({
+    cfg,
+    channel: "feishu",
+  });
+  const messageText = getFeishuRuntime().channel.text.convertMarkdownTables(text ?? "", tableMode);
+
+  const { content, msgType } = buildFeishuPostMessagePayload({ messageText });
+
+  const response = await client.im.message.update({
+    path: { message_id: messageId },
+    data: {
+      msg_type: msgType,
+      content,
+    },
+  });
+
+  if (response.code !== 0) {
+    throw new Error(`Feishu message edit failed: ${response.msg || `code ${response.code}`}`);
+  }
+}

package/src/stream.ts

@@ -0,0 +1,160 @@
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import { createFeishuClient } from "./client.js";
+import { resolveFeishuAccount } from "./accounts.js";
+import { resolveReceiveIdType, normalizeFeishuTarget } from "./targets.js";
+import { createSimpleTextCard } from "./send.js";
+
+/**
+ * Configuration for Feishu streaming updates
+ */
+const STREAM_CONFIG = {
+  // Rate limit: ~400ms between updates to avoid API limits
+  MIN_UPDATE_INTERVAL_MS: 400,
+  // Maximum number of pending updates to queue
+  MAX_PENDING_UPDATES: 10,
+};
+
+/**
+ * FeishuStream manages streaming card updates with rate limiting.
+ * This provides a smooth streaming experience for AI responses.
+ */
+export class FeishuStream {
+  private messageId: string;
+  private cfg: ClawdbotConfig;
+  private accountId?: string;
+  private lastUpdateTime: number = 0;
+  private pendingContent: string = "";
+  private updateTimer: NodeJS.Timeout | null = null;
+  private isComplete: boolean = false;
+  private isDestroyed: boolean = false;
+
+  constructor(params: {
+    messageId: string;
+    cfg: ClawdbotConfig;
+    accountId?: string;
+  }) {
+    this.messageId = params.messageId;
+    this.cfg = params.cfg;
+    this.accountId = params.accountId;
+  }
+
+  /**
+   * Update the streaming content.
+   * The update will be throttled according to STREAM_CONFIG.MIN_UPDATE_INTERVAL_MS.
+   */
+  async update(content: string): Promise<void> {
+    if (this.isDestroyed || this.isComplete) {
+      return;
+    }
+
+    this.pendingContent = content;
+
+    const now = Date.now();
+    const timeSinceLastUpdate = now - this.lastUpdateTime;
+
+    // If enough time has passed, update immediately
+    if (timeSinceLastUpdate >= STREAM_CONFIG.MIN_UPDATE_INTERVAL_MS) {
+      await this.flush();
+    } else if (!this.updateTimer) {
+      // Schedule an update for when the interval elapses
+      const delay = STREAM_CONFIG.MIN_UPDATE_INTERVAL_MS - timeSinceLastUpdate;
+      this.updateTimer = setTimeout(() => this.flush(), delay);
+    }
+  }
+
+  /**
+   * Finalize the stream by setting streaming_mode to false.
+   * This should be called when the AI response is complete.
+   */
+  async finalize(finalContent: string): Promise<void> {
+    if (this.isDestroyed || this.isComplete) {
+      return;
+    }
+
+    // Clear any pending timer
+    if (this.updateTimer) {
+      clearTimeout(this.updateTimer);
+      this.updateTimer = null;
+    }
+
+    this.isComplete = true;
+    this.pendingContent = finalContent;
+
+    // Send final update with streaming_mode = false
+    await this.sendUpdate(finalContent, false);
+  }
+
+  /**
+   * Flush pending content to the card.
+   */
+  private async flush(): Promise<void> {
+    if (this.updateTimer) {
+      clearTimeout(this.updateTimer);
+      this.updateTimer = null;
+    }
+
+    this.lastUpdateTime = Date.now();
+    await this.sendUpdate(this.pendingContent, true);
+  }
+
+  /**
+   * Send an update to the Feishu card.
+   */
+  private async sendUpdate(content: string, streamingMode: boolean): Promise<void> {
+    try {
+      const account = resolveFeishuAccount({ cfg: this.cfg, accountId: this.accountId });
+      if (!account.configured) {
+        console.error("FeishuStream: account not configured");
+        return;
+      }
+
+      const client = createFeishuClient(account);
+      const card = createSimpleTextCard(content, streamingMode);
+      const cardContent = JSON.stringify(card);
+
+      await client.im.message.patch({
+        path: { message_id: this.messageId },
+        data: { content: cardContent },
+      });
+    } catch (err) {
+      console.error("FeishuStream: failed to update card:", err);
+    }
+  }
+
+  /**
+   * Destroy the stream and clean up resources.
+   */
+  destroy(): void {
+    this.isDestroyed = true;
+    if (this.updateTimer) {
+      clearTimeout(this.updateTimer);
+      this.updateTimer = null;
+    }
+  }
+}
+
+/**
+ * Type for partial reply callback
+ */
+export type OnPartialReply = (text: string) => void | Promise<void>;
+
+/**
+ * Create a streaming handler for Feishu replies.
+ * Returns the stream instance and an onPartialReply callback.
+ */
+export function createFeishuStreamingHandler(params: {
+  cfg: ClawdbotConfig;
+  messageId: string;
+  accountId?: string;
+}): {
+  stream: FeishuStream;
+  onPartialReply: OnPartialReply;
+} {
+  const stream = new FeishuStream(params);
+
+  const onPartialReply: OnPartialReply = async (text) => {
+    await stream.update(text);
+  };
+
+  return { stream, onPartialReply };
+}

package/src/targets.ts

@@ -0,0 +1,58 @@
+import type { FeishuIdType } from "./types.js";
+
+const CHAT_ID_PREFIX = "oc_";
+const OPEN_ID_PREFIX = "ou_";
+const USER_ID_REGEX = /^[a-zA-Z0-9_-]+$/;
+
+export function detectIdType(id: string): FeishuIdType | null {
+  const trimmed = id.trim();
+  if (trimmed.startsWith(CHAT_ID_PREFIX)) return "chat_id";
+  if (trimmed.startsWith(OPEN_ID_PREFIX)) return "open_id";
+  if (USER_ID_REGEX.test(trimmed)) return "user_id";
+  return null;
+}
+
+export function normalizeFeishuTarget(raw: string): string | null {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+
+  const lowered = trimmed.toLowerCase();
+  if (lowered.startsWith("chat:")) {
+    return trimmed.slice("chat:".length).trim() || null;
+  }
+  if (lowered.startsWith("user:")) {
+    return trimmed.slice("user:".length).trim() || null;
+  }
+  if (lowered.startsWith("open_id:")) {
+    return trimmed.slice("open_id:".length).trim() || null;
+  }
+
+  return trimmed;
+}
+
+export function formatFeishuTarget(id: string, type?: FeishuIdType): string {
+  const trimmed = id.trim();
+  if (type === "chat_id" || trimmed.startsWith(CHAT_ID_PREFIX)) {
+    return `chat:${trimmed}`;
+  }
+  if (type === "open_id" || trimmed.startsWith(OPEN_ID_PREFIX)) {
+    return `user:${trimmed}`;
+  }
+  return trimmed;
+}
+
+export function resolveReceiveIdType(id: string): "chat_id" | "open_id" | "user_id" {
+  const trimmed = id.trim();
+  if (trimmed.startsWith(CHAT_ID_PREFIX)) return "chat_id";
+  if (trimmed.startsWith(OPEN_ID_PREFIX)) return "open_id";
+  return "open_id";
+}
+
+export function looksLikeFeishuId(raw: string): boolean {
+  const trimmed = raw.trim();
+  if (!trimmed) return false;
+  if (/^(chat|user|open_id):/i.test(trimmed)) return true;
+  if (trimmed.startsWith(CHAT_ID_PREFIX)) return true;
+  if (trimmed.startsWith(OPEN_ID_PREFIX)) return true;
+  return false;
+}