@tobeyoureyes/feishu 1.0.0 → 1.1.1

package/README.md

@@ -1,4 +1,4 @@
-# @openclaw/feishu
+# @tobeyoureyes/feishu
 
 飞书/Lark 企业消息平台的 OpenClaw 插件。支持私聊、群聊、消息回复、媒体处理和卡片消息渲染。
 
@@ -15,7 +15,7 @@
 ## 安装
 
 ```bash
-openclaw plugins install @openclaw/feishu
+openclaw plugins install @tobeyoureyes/feishu
 ```
 
 ## 快速开始
@@ -141,7 +141,6 @@ openclaw start
 │         │                      渲染模式判断                    │
 │         │                    (auto/raw/card)                 │
 │         │                             │                      │
-│         │                             ▼                      │
 │         └─────────────────────► 发送回复                      │
 │                                                             │
 └─────────────────────────────────────────────────────────────┘
@@ -159,7 +158,7 @@ openclaw start
 
 自动检测以下内容并使用卡片渲染：
 
-- 代码块 (\`\`\`code\`\`\`)
+- 代码块 (```code```)
 - 表格 (|header|)
 - Markdown 链接 [text](url)
 - 长文本 (>500 字符)
@@ -238,7 +237,7 @@ import {
   createTableCard,
   createCardWithButtons,
   createMultiSectionCard,
-} from "@openclaw/feishu/api";
+} from "@tobeyoureyes/feishu/api";
 
 // 简单卡片
 const card1 = createSimpleCard("标题", "Markdown 内容", "blue");
@@ -267,7 +266,7 @@ const card4 = createCardWithButtons(
 ## 文件结构
 
 ```
-extensions/feishu/
+chat_feishu/
 ├── src/
 │   ├── api.ts        # Feishu API 封装
 │   ├── auth.ts       # Token 认证管理

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tobeyoureyes/feishu",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "OpenClaw Feishu (Lark) channel plugin",
   "type": "module",
   "files": [
@@ -8,17 +8,11 @@
     "src",
     "openclaw.plugin.json"
   ],
-  "devDependencies": {
-    "@larksuiteoapi/node-sdk": "^1.58.0",
-    "openclaw": "workspace:*"
-  },
-  "peerDependencies": {
+  "dependencies": {
     "@larksuiteoapi/node-sdk": "^1.58.0"
   },
-  "peerDependenciesMeta": {
-    "@larksuiteoapi/node-sdk": {
-      "optional": true
-    }
+  "devDependencies": {
+    "openclaw": "workspace:*"
   },
   "openclaw": {
     "extensions": [
@@ -35,7 +29,7 @@
     },
     "install": {
       "npmSpec": "@tobeyoureyes/feishu",
-      "localPath": "extensions/feishu",
+      "localPath": ".",
       "defaultChoice": "npm"
     }
   }

package/src/api.ts

@@ -341,7 +341,7 @@ export async function getUserInfo(
 export async function probeFeishu(
   account: ResolvedFeishuAccount,
   timeoutMs = 10000,
-): Promise<{ ok: boolean; error?: string }> {
+): Promise<{ ok: boolean; error?: string; bot?: { open_id: string; app_name?: string } }> {
   try {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
@@ -374,6 +374,24 @@ export async function probeFeishu(
       return { ok: false, error: data.msg };
     }
 
+    // Get bot info for mention detection
+    const botInfoResponse = await fetch(`${apiBase}/bot/v3/info`, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${await getTenantAccessToken(account)}`,
+      },
+    });
+
+    if (botInfoResponse.ok) {
+      const botData = (await botInfoResponse.json()) as FeishuApiResponse<{
+        app_name?: string;
+        open_id?: string;
+      }>;
+      if (botData.code === 0 && botData.data?.open_id) {
+        return { ok: true, bot: { open_id: botData.data.open_id, app_name: botData.data.app_name } };
+      }
+    }
+
     return { ok: true };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);

package/src/channel.ts

@@ -715,8 +715,12 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
         return;
       }
 
-      // Get bot's open_id for mention detection
+      // Get bot's open_id/name for mention detection
       const botOpenId = (probe as { bot?: { open_id?: string } }).bot?.open_id;
+      const botName = (probe as { bot?: { app_name?: string } }).bot?.app_name;
+      if (!botOpenId && !botName) {
+        ctx.log?.warn(`${logPrefix} bot identity unavailable; mention detection may be limited`);
+      }
 
       // Initialize message deduplication cache
       const dedupe = createFeishuDedupeCache();
@@ -724,9 +728,8 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
       // Initialize group history manager
       const history = createGroupHistoryManager();
 
-      // Create reply senders
-      const sendReply = createDefaultReplySender(account);
-      const sendMedia = createDefaultMediaSender(account);
+      // Note: Reply senders are created inside handleInboundMessage
+      // because they need chatId which is only available at message time
 
       /**
        * Handle inbound message - build context, dispatch to agent, send reply
@@ -766,6 +769,7 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
             account,
             cfg: ctx.cfg,
             botOpenId,
+            botName,
             pendingHistory,
           });
 
@@ -778,6 +782,10 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
             return;
           }
 
+          // Create reply senders with chatId for this message
+          const sendReply = createDefaultReplySender(account, inbound.chatId, isGroup);
+          const sendMedia = createDefaultMediaSender(account, inbound.chatId, isGroup);
+
           // Dispatch to agent using local module
           await dispatchFeishuMessage({
             context,

package/src/context.ts

@@ -34,6 +34,7 @@ export interface BuildFeishuMessageContextParams {
   account: ResolvedFeishuAccount;
   cfg: OpenClawConfig;
   botOpenId?: string;
+  botName?: string;
   sendTyping?: () => Promise<void>;
   /** Pending group history entries for context */
   pendingHistory?: HistoryEntry[];
@@ -42,11 +43,39 @@ export interface BuildFeishuMessageContextParams {
 /**
  * Check if bot was mentioned in the message
  */
-function isBotMentioned(message: FeishuInboundMessage, botOpenId?: string): boolean {
-  if (!botOpenId || !message.mentions) {
+function normalizeMentionName(name: string): string {
+  return name.trim().toLowerCase();
+}
+
+function isBotMentioned(
+  message: FeishuInboundMessage,
+  botOpenId?: string,
+  botName?: string,
+): boolean {
+  if (!message.mentions || message.mentions.length === 0) {
     return false;
   }
-  return message.mentions.some((m) => m.id === botOpenId);
+
+  if (botOpenId && message.mentions.some((m) => m.id === botOpenId)) {
+    return true;
+  }
+
+  if (botName) {
+    const normalized = normalizeMentionName(botName);
+    if (
+      message.mentions.some(
+        (m) => m.name && normalizeMentionName(m.name) === normalized,
+      )
+    ) {
+      return true;
+    }
+    const displayText = message.displayText ?? message.text ?? "";
+    if (displayText.toLowerCase().includes(`@${normalized}`)) {
+      return true;
+    }
+  }
+
+  return false;
 }
 
 /**
@@ -117,7 +146,7 @@ function buildHistoryContext(entries: HistoryEntry[], currentMessage: string): s
 export async function buildFeishuMessageContext(
   params: BuildFeishuMessageContextParams,
 ): Promise<FeishuMessageContext | null> {
-  const { message, account, cfg, botOpenId, sendTyping, pendingHistory } = params;
+  const { message, account, cfg, botOpenId, botName, sendTyping, pendingHistory } = params;
   const core = getFeishuRuntime();
 
   const isGroup = message.chatType === "group";
@@ -171,14 +200,24 @@ export async function buildFeishuMessageContext(
     }
 
     const requireMention = account.requireMention;
-    const wasMentioned = isBotMentioned(message, botOpenId);
+    const wasMentioned = isBotMentioned(message, botOpenId, botName);
+    const canIdentifyBot = Boolean(botOpenId || botName);
 
     // Simple mention gating: if requireMention is true and bot was not mentioned, skip
     if (requireMention && !wasMentioned) {
-      if (core.logging.shouldLogVerbose()) {
-        core.logging.getChildLogger({ module: "feishu" }).debug("skipping group message (no mention)");
+      if (!canIdentifyBot) {
+        // Bot identity not resolved; allow to avoid blocking all group messages
+        core.logging.getChildLogger({ module: "feishu" }).warn(
+          "bot open_id/name unavailable; allowing group message without mention check",
+        );
+      } else {
+        if (core.logging.shouldLogVerbose()) {
+          core.logging
+            .getChildLogger({ module: "feishu" })
+            .debug("skipping group message (no mention)");
+        }
+        return null;
       }
-      return null;
     }
   }
 

package/src/dispatch.ts

@@ -96,21 +96,25 @@ export async function dispatchFeishuMessage(
 
         logger.info(`deliver called: text=${text.slice(0, 100)} mediaUrl=${mediaUrl}`);
 
+        // Only use reply quote in group chats, not in DM/private chats
+        const replyToId = context.isGroup ? context.message.messageId : undefined;
+        logger.info(`dispatch deliver: isGroup=${context.isGroup} chatType=${context.message?.chatType} replyToId=${replyToId}`);
+
         if (mediaUrl && onSendMedia) {
-          logger.info(`sending media to ${context.message.messageId}`);
+          logger.info(`sending media to ${context.message.messageId} (isGroup=${context.isGroup})`);
           const result = await onSendMedia({
             text,
             mediaUrl,
-            replyToId: context.message.messageId,
+            replyToId,
           });
           logger.info(`media send result: ${JSON.stringify(result)}`);
         } else if (text && onSendReply) {
           // Determine render mode based on content
           const renderMode = api.shouldUseCardRendering(text) ? "card" : account.renderMode;
-          logger.info(`sending reply to ${context.message.messageId} renderMode=${renderMode}`);
+          logger.info(`sending reply to ${context.message.messageId} renderMode=${renderMode} (isGroup=${context.isGroup})`);
           const result = await onSendReply({
             text,
-            replyToId: context.message.messageId,
+            replyToId,
             renderMode,
           });
           logger.info(`reply send result: ${JSON.stringify(result)}`);
@@ -150,36 +154,79 @@ export async function dispatchFeishuMessage(
 
 /**
  * Create default reply sender using Feishu API
+ * @param account - Feishu account
+ * @param chatId - Chat ID for sending new messages (when not replying)
  */
-export function createDefaultReplySender(account: ResolvedFeishuAccount) {
+export function createDefaultReplySender(
+  account: ResolvedFeishuAccount,
+  chatId: string,
+  isGroup: boolean,
+) {
+  const core = getFeishuRuntime();
+  const logger = core.logging.getChildLogger({ module: "feishu" });
+
   return async (params: {
     text: string;
     replyToId?: string;
     renderMode?: FeishuRenderMode;
   }) => {
-    if (!params.replyToId) {
-      return { ok: false, error: "Missing replyToId" };
+    logger.info(
+      `createDefaultReplySender: replyToId=${params.replyToId} chatId=${chatId} isGroup=${isGroup}`,
+    );
+    
+    // If replyToId is provided, use reply API (quote reply)
+    // Otherwise, send as new message without quote
+    if (params.replyToId && isGroup) {
+      logger.info(`Using replyMessage API (quote reply)`);
+      return api.replyMessage(account, params.replyToId, params.text, {
+        renderMode: params.renderMode,
+      });
     }
-    return api.replyMessage(account, params.replyToId, params.text, {
+    // Send as new message without quote (for DM/private chats)
+    // Determine receiveIdType based on chatId format
+    const receiveIdType = chatId.startsWith("ou_") ? "open_id" : "chat_id";
+    logger.info(`Using sendSmart API (no quote) receiveIdType=${receiveIdType}`);
+    return api.sendSmart(account, chatId, params.text, {
       renderMode: params.renderMode,
+      receiveIdType,
     });
   };
 }
 
 /**
  * Create default media sender using Feishu API
+ * @param account - Feishu account
+ * @param chatId - Chat ID for sending new messages (when not replying)
  */
-export function createDefaultMediaSender(account: ResolvedFeishuAccount) {
+export function createDefaultMediaSender(
+  account: ResolvedFeishuAccount,
+  chatId: string,
+  isGroup: boolean,
+) {
+  const core = getFeishuRuntime();
+  const logger = core.logging.getChildLogger({ module: "feishu" });
+
   return async (params: {
     text?: string;
     mediaUrl: string;
     replyToId?: string;
   }) => {
-    if (!params.replyToId) {
-      return { ok: false, error: "Missing replyToId" };
-    }
     // For now, send media URL as text
     const text = params.text ? `${params.text}\n\n${params.mediaUrl}` : params.mediaUrl;
-    return api.replyMessage(account, params.replyToId, text);
+    
+    logger.info(
+      `createDefaultMediaSender: replyToId=${params.replyToId} chatId=${chatId} isGroup=${isGroup}`,
+    );
+    
+    // If replyToId is provided, use reply API (quote reply)
+    // Otherwise, send as new message without quote
+    if (params.replyToId && isGroup) {
+      logger.info(`Using replyMessage API (quote reply)`);
+      return api.replyMessage(account, params.replyToId, text);
+    }
+    // Send as new message without quote (for DM/private chats)
+    const receiveIdType = chatId.startsWith("ou_") ? "open_id" : "chat_id";
+    logger.info(`Using sendSmart API (no quote) receiveIdType=${receiveIdType}`);
+    return api.sendSmart(account, chatId, text, { receiveIdType });
   };
 }