@max1874/feishu 0.2.0 → 0.2.2

package/src/media.ts

@@ -1,4 +1,4 @@
-import type { ClawdbotConfig } from "clawdbot/plugin-sdk";
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
 import type { FeishuConfig } from "./types.js";
 import { createFeishuClient } from "./client.js";
 import { resolveReceiveIdType, normalizeFeishuTarget } from "./targets.js";

package/src/mention.ts

@@ -0,0 +1,121 @@
+import type { FeishuMessageEvent } from "./bot.js";
+
+/**
+ * Mention target user info
+ */
+export type MentionTarget = {
+  openId: string;
+  name: string;
+  key: string; // Placeholder in original message, e.g. @_user_1
+};
+
+/**
+ * Extract mention targets from message event (excluding the bot itself)
+ */
+export function extractMentionTargets(
+  event: FeishuMessageEvent,
+  botOpenId?: string,
+): MentionTarget[] {
+  const mentions = event.message.mentions ?? [];
+
+  return mentions
+    .filter((m) => {
+      // Exclude the bot itself
+      if (botOpenId && m.id.open_id === botOpenId) return false;
+      // Must have open_id
+      return !!m.id.open_id;
+    })
+    .map((m) => ({
+      openId: m.id.open_id!,
+      name: m.name,
+      key: m.key,
+    }));
+}
+
+/**
+ * Check if message is a mention forward request
+ * Rules:
+ * - Group: message mentions bot + at least one other user
+ * - DM: message mentions any user (no need to mention bot)
+ */
+export function isMentionForwardRequest(
+  event: FeishuMessageEvent,
+  botOpenId?: string,
+): boolean {
+  const mentions = event.message.mentions ?? [];
+  if (mentions.length === 0) return false;
+
+  const isDirectMessage = event.message.chat_type === "p2p";
+  const hasOtherMention = mentions.some((m) => m.id.open_id !== botOpenId);
+
+  if (isDirectMessage) {
+    // DM: trigger if any non-bot user is mentioned
+    return hasOtherMention;
+  } else {
+    // Group: need to mention both bot and other users
+    const hasBotMention = mentions.some((m) => m.id.open_id === botOpenId);
+    return hasBotMention && hasOtherMention;
+  }
+}
+
+/**
+ * Extract message body from text (remove @ placeholders)
+ */
+export function extractMessageBody(text: string, allMentionKeys: string[]): string {
+  let result = text;
+
+  // Remove all @ placeholders
+  for (const key of allMentionKeys) {
+    result = result.replace(new RegExp(key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), "");
+  }
+
+  return result.replace(/\s+/g, " ").trim();
+}
+
+/**
+ * Format @mention for text message
+ */
+export function formatMentionForText(target: MentionTarget): string {
+  return `<at user_id="${target.openId}">${target.name}</at>`;
+}
+
+/**
+ * Format @everyone for text message
+ */
+export function formatMentionAllForText(): string {
+  return `<at user_id="all">Everyone</at>`;
+}
+
+/**
+ * Format @mention for card message (lark_md)
+ */
+export function formatMentionForCard(target: MentionTarget): string {
+  return `<at id=${target.openId}></at>`;
+}
+
+/**
+ * Format @everyone for card message
+ */
+export function formatMentionAllForCard(): string {
+  return `<at id=all></at>`;
+}
+
+/**
+ * Build complete message with @mentions (text format)
+ */
+export function buildMentionedMessage(targets: MentionTarget[], message: string): string {
+  if (targets.length === 0) return message;
+
+  const mentionParts = targets.map((t) => formatMentionForText(t));
+  return `${mentionParts.join(" ")} ${message}`;
+}
+
+/**
+ * Build card content with @mentions (Markdown format)
+ */
+export function buildMentionedCardContent(targets: MentionTarget[], message: string): string {
+  if (targets.length === 0) return message;
+
+  const mentionParts = targets.map((t) => formatMentionForCard(t));
+  return `${mentionParts.join(" ")} ${message}`;
+}

package/src/monitor.ts

@@ -1,6 +1,6 @@
 import http from "node:http";
 import * as Lark from "@larksuiteoapi/node-sdk";
-import type { ClawdbotConfig, RuntimeEnv, HistoryEntry } from "clawdbot/plugin-sdk";
+import type { ClawdbotConfig, RuntimeEnv, HistoryEntry } from "openclaw/plugin-sdk";
 import type { FeishuConfig } from "./types.js";
 import { createFeishuWSClient, createEventDispatcher } from "./client.js";
 import { resolveFeishuCredentials } from "./accounts.js";

package/src/onboarding.ts

@@ -4,8 +4,8 @@ import type {
   ClawdbotConfig,
   DmPolicy,
   WizardPrompter,
-} from "clawdbot/plugin-sdk";
-import { addWildcardAllowFrom, DEFAULT_ACCOUNT_ID, formatDocsLink } from "clawdbot/plugin-sdk";
+} from "openclaw/plugin-sdk";
+import { addWildcardAllowFrom, DEFAULT_ACCOUNT_ID, formatDocsLink } from "openclaw/plugin-sdk";
 
 import { resolveFeishuCredentials } from "./accounts.js";
 import { probeFeishu } from "./probe.js";

package/src/outbound.ts

@@ -1,4 +1,4 @@
-import type { ChannelOutboundAdapter } from "clawdbot/plugin-sdk";
+import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk";
 import { getFeishuRuntime } from "./runtime.js";
 import { sendMessageFeishu } from "./send.js";
 import { sendMediaFeishu } from "./media.js";

package/src/policy.ts

@@ -1,4 +1,4 @@
-import type { ChannelGroupContext, GroupToolPolicyConfig } from "clawdbot/plugin-sdk";
+import type { ChannelGroupContext, GroupToolPolicyConfig } from "openclaw/plugin-sdk";
 import type { FeishuConfig, FeishuGroupConfig } from "./types.js";
 
 export type FeishuAllowlistMatch = {

package/src/reactions.ts

@@ -1,4 +1,4 @@
-import type { ClawdbotConfig } from "clawdbot/plugin-sdk";
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
 import type { FeishuConfig } from "./types.js";
 import { createFeishuClient } from "./client.js";
 

package/src/reply-dispatcher.ts

@@ -5,10 +5,11 @@ import {
   type ClawdbotConfig,
   type RuntimeEnv,
   type ReplyPayload,
-} from "clawdbot/plugin-sdk";
+} from "openclaw/plugin-sdk";
 import { getFeishuRuntime } from "./runtime.js";
 import { sendMessageFeishu, sendMarkdownCardFeishu } from "./send.js";
 import type { FeishuConfig } from "./types.js";
+import type { MentionTarget } from "./mention.js";
 import {
   addTypingIndicator,
   removeTypingIndicator,
@@ -33,11 +34,13 @@ export type CreateFeishuReplyDispatcherParams = {
   runtime: RuntimeEnv;
   chatId: string;
   replyToMessageId?: string;
+  /** Mention targets, will be auto-included in replies */
+  mentionTargets?: MentionTarget[];
 };
 
 export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherParams) {
   const core = getFeishuRuntime();
-  const { cfg, agentId, chatId, replyToMessageId } = params;
+  const { cfg, agentId, chatId, replyToMessageId, mentionTargets } = params;
 
   const prefixContext = createReplyPrefixContext({
     cfg,
@@ -111,6 +114,9 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
         const useCard =
           renderMode === "card" || (renderMode === "auto" && shouldUseCard(text));
 
+        // Only include @mentions in the first chunk (avoid duplicate @s)
+        let isFirstChunk = true;
+
         if (useCard) {
           // Card mode: send as interactive card with markdown rendering
           const chunks = core.channel.text.chunkTextWithMode(text, textChunkLimit, chunkMode);
@@ -121,7 +127,9 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
               to: chatId,
               text: chunk,
               replyToMessageId,
+              mentions: isFirstChunk ? mentionTargets : undefined,
             });
+            isFirstChunk = false;
           }
         } else {
           // Raw mode: send as plain text with table conversion
@@ -134,7 +142,9 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
               to: chatId,
               text: chunk,
               replyToMessageId,
+              mentions: isFirstChunk ? mentionTargets : undefined,
             });
+            isFirstChunk = false;
           }
         }
       },

package/src/runtime.ts

@@ -1,4 +1,4 @@
-import type { PluginRuntime } from "clawdbot/plugin-sdk";
+import type { PluginRuntime } from "openclaw/plugin-sdk";
 
 let runtime: PluginRuntime | null = null;
 

package/src/send.ts

@@ -1,5 +1,7 @@
-import type { ClawdbotConfig } from "clawdbot/plugin-sdk";
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
 import type { FeishuConfig, FeishuSendResult } 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";
@@ -14,6 +16,14 @@ export type FeishuMessageInfo = {
   createTime?: number;
 };
 
+export type FeishuMergeForwardMessage = {
+  messageId: string;
+  chatId?: string;
+  content: string;
+  contentType: string;
+  upperMessageId?: string;
+};
+
 /**
  * Get a message by its ID.
  * Useful for fetching quoted/replied message content.
@@ -86,15 +96,112 @@ export async function getMessageFeishu(params: {
   }
 }
 
+/**
+ * Get all messages from a merge_forward message.
+ * Returns child messages that are linked via upper_message_id.
+ */
+export async function getMergeForwardMessagesFeishu(params: {
+  cfg: ClawdbotConfig;
+  messageId: string;
+}): Promise<FeishuMergeForwardMessage[]> {
+  const { cfg, messageId } = params;
+  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+  if (!feishuCfg) {
+    throw new Error("Feishu channel not configured");
+  }
+
+  const client = createFeishuClient(feishuCfg);
+
+  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 };
+        upper_message_id?: string;
+      }>;
+    };
+  };
+
+  if (response.code !== 0) {
+    throw new Error(`Feishu get message failed: ${response.msg || `code ${response.code}`}`);
+  }
+
+  const items = response.data?.items ?? [];
+  const result: FeishuMergeForwardMessage[] = [];
+
+  for (const item of items) {
+    // Skip the merge_forward container itself
+    if (item.msg_type === "merge_forward") {
+      continue;
+    }
+
+    // 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;
+      } else if (item.msg_type === "post") {
+        // Extract text from rich text post
+        content = extractPostText(parsed);
+      }
+    } catch {
+      // Keep raw content if parsing fails
+    }
+
+    result.push({
+      messageId: item.message_id ?? "",
+      chatId: item.chat_id,
+      content,
+      contentType: item.msg_type ?? "text",
+      upperMessageId: item.upper_message_id,
+    });
+  }
+
+  return result;
+}
+
+/**
+ * Extract plain text from a Feishu post (rich text) content.
+ */
+function extractPostText(parsed: { title?: string; content?: Array<Array<{ tag: string; text?: string }>> }): string {
+  const title = parsed.title || "";
+  const contentBlocks = parsed.content || [];
+  let textContent = title ? `${title}\n\n` : "";
+
+  for (const paragraph of contentBlocks) {
+    if (Array.isArray(paragraph)) {
+      for (const element of paragraph) {
+        if (element.tag === "text" && element.text) {
+          textContent += element.text;
+        } else if (element.tag === "a") {
+          textContent += (element as { text?: string }).text || "";
+        }
+      }
+      textContent += "\n";
+    }
+  }
+
+  return textContent.trim() || "[富文本消息]";
+}
+
 export type SendFeishuMessageParams = {
   cfg: ClawdbotConfig;
   to: string;
   text: string;
   replyToMessageId?: string;
+  /** Mention target users */
+  mentions?: MentionTarget[];
 };
 
 export async function sendMessageFeishu(params: SendFeishuMessageParams): Promise<FeishuSendResult> {
-  const { cfg, to, text, replyToMessageId } = params;
+  const { cfg, to, text, replyToMessageId, mentions } = params;
   const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
   if (!feishuCfg) {
     throw new Error("Feishu channel not configured");
@@ -111,7 +218,13 @@ export async function sendMessageFeishu(params: SendFeishuMessageParams): Promis
     cfg,
     channel: "feishu",
   });
-  const messageText = getFeishuRuntime().channel.text.convertMarkdownTables(text ?? "", tableMode);
+
+  // 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 = JSON.stringify({ text: messageText });
 
@@ -265,9 +378,16 @@ export async function sendMarkdownCardFeishu(params: {
   to: string;
   text: string;
   replyToMessageId?: string;
+  /** Mention target users */
+  mentions?: MentionTarget[];
 }): Promise<FeishuSendResult> {
-  const { cfg, to, text, replyToMessageId } = params;
-  const card = buildMarkdownCard(text);
+  const { cfg, to, text, replyToMessageId, mentions } = 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 });
 }
 

package/src/types.ts

@@ -1,4 +1,5 @@
 import type { FeishuConfigSchema, FeishuGroupSchema, z } from "./config-schema.js";
+import type { MentionTarget } from "./mention.js";
 
 export type FeishuConfig = z.infer<typeof FeishuConfigSchema>;
 export type FeishuGroupConfig = z.infer<typeof FeishuGroupSchema>;
@@ -28,6 +29,10 @@ export type FeishuMessageContext = {
   parentId?: string;
   content: string;
   contentType: string;
+  /** Mention forward targets (excluding the bot itself) */
+  mentionTargets?: MentionTarget[];
+  /** Extracted message body (after removing @ placeholders) */
+  mentionMessageBody?: string;
 };
 
 export type FeishuSendResult = {

package/src/typing.ts

@@ -1,4 +1,4 @@
-import type { ClawdbotConfig } from "clawdbot/plugin-sdk";
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
 import type { FeishuConfig } from "./types.js";
 import { createFeishuClient } from "./client.js";