@lmcl/ailo-mcp-feishu 0.0.1 → 0.0.3

package/README.md

@@ -1,29 +1,34 @@
 # 飞书通道
 
-飞书/Lark 感知通道，WebSocket 长连接，双向收发。
+飞书感知通道，WebSocket 长连接，双向收发。
 
 ## 安装与添加
 
 ```bash
+# 从 npm（需先 publish）
 npm install -g @lmcl/ailo-mcp-feishu
+
+# 或本地开发：在项目目录下
+npm run build && npm install -g .
 ```
 
-然后通过 mcp_manage 创建并启动：
+然后通过 mcp_manage 创建并启动。**name 只能含字母、汉字、下划线**（无标点无数字），推荐纯英文尽量短：
 
 ```
-mcp_manage(action=create, name="channel:feishu", command="ailo-mcp-feishu", env={FEISHU_APP_ID: "cli_xxx", FEISHU_APP_SECRET: "xxx"})
-mcp_manage(action=start, name="channel:feishu")
+mcp_manage(action=create, name="feishu", command="npx", args=["@lmcl/ailo-mcp-feishu"], env={FEISHU_APP_ID: "cli_xxx", FEISHU_APP_SECRET: "xxx"})
+mcp_manage(action=start, name="feishu")
 ```
 
+若已全局安装（`npm install -g @lmcl/ailo-mcp-feishu`），可用 `command="ailo-mcp-feishu"`，args 留空。
+
 ## 环境变量
 
 | 变量 | 必填 | 说明 |
 |-----|-----|-----|
 | FEISHU_APP_ID | 是 | 飞书应用 App ID |
 | FEISHU_APP_SECRET | 是 | 飞书应用 App Secret |
-| FEISHU_DOMAIN | 否 | feishu \| lark，默认 feishu |
 
-AIDO_WS_URL、AIDO_TOKEN、AIDO_MCP_NAME 由框架注入。
+AILO_WS_URL、AILO_TOKEN、AILO_MCP_NAME 由框架注入。
 
 ## 飞书开放平台
 

package/dist/feishu-handler.js

@@ -1,73 +1,9 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as Lark from "@larksuiteoapi/node-sdk";
-/** 历史消息阈值：发送时间超过此值视为重发，直接丢弃（毫秒） */
-const STALE_MESSAGE_THRESHOLD_MS = 5 * 60 * 1000;
-/** 失败缓存 TTL：getUserInfo/getChatInfo 调用失败后缓存此时长，避免重复调用（毫秒） */
-const NEGATIVE_CACHE_TTL = 5 * 60 * 1000;
-/** 飞书 message_type 与「获取消息中的资源文件」API 的 type、Aido attachment type 的映射 */
-const MEDIA_MESSAGE_CONFIG = {
-    image: { resourceType: "image", aidoType: "image", contentKey: "image_key" },
-    file: { resourceType: "file", aidoType: "file", contentKey: "file_key" },
-    audio: { resourceType: "audio", aidoType: "audio", contentKey: "file_key" },
-    media: { resourceType: "video", aidoType: "video", contentKey: "file_key" },
-    video: { resourceType: "video", aidoType: "video", contentKey: "file_key" },
-};
-function streamToBuffer(stream) {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        stream.on("data", (chunk) => chunks.push(chunk));
-        stream.on("end", () => resolve(Buffer.concat(chunks)));
-        stream.on("error", reject);
-    });
-}
-function getPostContentRows(contentJson) {
-    try {
-        const root = JSON.parse(contentJson);
-        let content = root?.content;
-        if (!Array.isArray(content) && root?.post) {
-            const lang = root.post.zh_cn ?? root.post.en;
-            content = lang?.content;
-        }
-        return Array.isArray(content) ? content : null;
-    }
-    catch {
-        return null;
-    }
-}
-function extractTextFromPostContent(contentJson) {
-    const content = getPostContentRows(contentJson);
-    if (!content)
-        return "";
-    const parts = [];
-    for (const row of content) {
-        if (!Array.isArray(row))
-            continue;
-        for (const node of row) {
-            if (node?.tag === "text" && typeof node.text === "string") {
-                parts.push(node.text);
-            }
-        }
-    }
-    return parts.join("\n");
-}
-/** 从 post 消息 content 中解析出所有 img 节点的 image_key，用于拉取图片附件 */
-function extractImageKeysFromPostContent(contentJson) {
-    const content = getPostContentRows(contentJson);
-    if (!content)
-        return [];
-    const keys = [];
-    for (const row of content) {
-        if (!Array.isArray(row))
-            continue;
-        for (const node of row) {
-            if (node?.tag === "img" && typeof node.image_key === "string") {
-                keys.push(node.image_key);
-            }
-        }
-    }
-    return keys;
-}
+import { getWorkDir } from "@lmcl/ailo-mcp-sdk";
+import { MEDIA_MESSAGE_CONFIG, NEGATIVE_CACHE_TTL, STALE_MESSAGE_THRESHOLD_MS, } from "./feishu-types.js";
+import { adaptMarkdownForFeishu, convertMarkdownTablesToCodeBlock, extractImageKeysFromPostContent, extractMentionElements, extractTextFromPostContent, streamToBuffer, } from "./feishu-utils.js";
 export class FeishuHandler {
     config;
     client;
@@ -95,12 +31,11 @@ export class FeishuHandler {
     CACHE_TTL = 24 * 60 * 60 * 1000;
     constructor(config) {
         this.config = config;
-        const domain = config.domain === "lark" ? Lark.Domain.Lark : Lark.Domain.Feishu;
         this.client = new Lark.Client({
             appId: config.appId,
             appSecret: config.appSecret,
             appType: Lark.AppType.SelfBuild,
-            domain,
+            domain: Lark.Domain.Feishu,
             // 抑制 SDK 内部的 error 日志输出（如外部用户 41050 等预期失败），
             // 应用层已在 getUserInfo/getChatInfo 等方法中自行处理错误并输出可读日志。
             loggerLevel: Lark.LoggerLevel.fatal,
@@ -134,7 +69,7 @@ export class FeishuHandler {
                     if (k !== "_counter" && typeof v === "string")
                         this.externalUserLabels.set(k, v);
                 }
-                console.log(`[feishu] 已加载外部用户映射: ${this.externalUserLabels.size} 条, counter=${this.externalUserCounter}`);
+                console.error(`[feishu] 已加载外部用户映射: ${this.externalUserLabels.size} 条, counter=${this.externalUserCounter}`);
             }
             catch {
                 console.warn("[feishu] 解析外部用户数据失败，将从零开始");
@@ -326,7 +261,7 @@ export class FeishuHandler {
             const bot = res.data?.bot;
             this.botOpenId = bot?.open_id ?? bot?.user_id ?? "";
             if (this.botOpenId) {
-                console.log(`[feishu] bot open_id: ${this.botOpenId}`);
+                console.error(`[feishu] bot open_id: ${this.botOpenId}`);
             }
             // 获取失败时仅 debug 级别，不影响核心功能（仅群聊 @检测 会失效）
         }
@@ -372,6 +307,34 @@ export class FeishuHandler {
     setOnMessageRead(handler) {
         this.onMessageRead = handler;
     }
+    buildBridgeMessage(opts) {
+        const { chatId, text, chatType, senderId = "", senderName = "", chatName, mentionsSelf, timestamp, attachments } = opts;
+        const isPrivate = chatType === "私聊";
+        const tags = [
+            { desc: "类型", value: chatType, core: true },
+            { desc: "会话", value: chatId, core: true },
+        ];
+        if (!isPrivate && chatName) {
+            tags.push({ desc: "群名", value: chatName, core: true });
+        }
+        else if (!isPrivate && chatId) {
+            tags.push({ desc: "群名", value: `群${chatId.slice(-8)}`, core: true });
+        }
+        tags.push({ desc: "昵称", value: senderName, core: isPrivate }, { desc: "用户", value: senderId, core: isPrivate });
+        if (mentionsSelf) {
+            tags.push({ desc: "@我", value: "是", core: isPrivate });
+        }
+        if (timestamp != null && timestamp > 0) {
+            const d = new Date(timestamp);
+            const pad = (n) => String(n).padStart(2, "0");
+            tags.push({
+                desc: "时间",
+                value: `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`,
+                core: false,
+            });
+        }
+        return { text, contextTags: tags, attachments };
+    }
     /**
      * 从飞书 SDK 抛出的错误中提取业务错误码。
      * SDK 的错误结构通常为 [AxiosError, { code, msg, ... }] 数组，
@@ -433,7 +396,7 @@ export class FeishuHandler {
             const errCode = this.extractFeishuErrorCode(err);
             if (errCode === 41050) {
                 // 41050 = no user authority：外部用户（非本租户成员），无权访问通讯录信息，属预期情况
-                console.log(`[feishu] getUserInfo(${userId}): 外部用户，无权限获取通讯录信息 (41050)`);
+                console.error(`[feishu] getUserInfo(${userId}): 外部用户，无权限获取通讯录信息 (41050)`);
             }
             else {
                 const detail = err?.response?.data ?? err.message;
@@ -482,7 +445,7 @@ export class FeishuHandler {
             const errCode = this.extractFeishuErrorCode(err);
             if (errCode === 41050) {
                 // 41050 = no user authority：外部群可能无权获取群信息
-                console.log(`[feishu] getChatInfo(${chatId}): 无权限获取群信息 (41050)`);
+                console.error(`[feishu] getChatInfo(${chatId}): 无权限获取群信息 (41050)`);
             }
             else {
                 const detail = err?.response?.data ?? err.message;
@@ -512,7 +475,7 @@ export class FeishuHandler {
                 this.chatCache.delete(key);
             }
         }
-        console.log(`[feishu] cache cleaned: users=${this.userCache.size}, chats=${this.chatCache.size}`);
+        console.error(`[feishu] cache cleaned: users=${this.userCache.size}, chats=${this.chatCache.size}`);
     }
     /**
      * 推断 chatId 对应的聊天类型（撤回/Reaction 等事件不返回 chat_type 时使用）
@@ -526,23 +489,14 @@ export class FeishuHandler {
             return "group";
         return "p2p";
     }
-    getBlobCacheDir() {
-        // 优先使用 AIDO_BLOB_CACHE（迁出生命目录）；否则回退 AIDO_HOME/cache/blobs
-        const blobCache = process.env.AIDO_BLOB_CACHE;
-        if (blobCache)
-            return blobCache;
-        const home = process.env.AIDO_HOME;
-        if (!home)
-            return null;
-        return path.join(home, "cache", "blobs");
-    }
     /**
      * 下载消息资源到本地缓存，返回 path。失败时返回 null（调用方传 ref）。
      */
     async downloadToCache(messageId, fileKey, resourceType, aidoType) {
-        const cacheDir = this.getBlobCacheDir();
-        if (!cacheDir)
+        const workDir = getWorkDir();
+        if (!workDir)
             return null;
+        const cacheDir = path.join(workDir, "blobs");
         try {
             await fs.promises.mkdir(cacheDir, { recursive: true });
         }
@@ -601,11 +555,19 @@ export class FeishuHandler {
     start() {
         // 获取 bot 自身的 open_id（异步，不阻塞启动）
         this.fetchBotOpenId();
-        const domain = this.config.domain === "lark" ? Lark.Domain.Lark : Lark.Domain.Feishu;
+        // MCP stdio 占用 stdout，Lark SDK 的 logger 必须写到 stderr
+        const stderrLogger = {
+            error: (...args) => console.error(...args),
+            warn: (...args) => console.error(...args),
+            info: (...args) => console.error(...args),
+            debug: (...args) => console.error(...args),
+            trace: (...args) => console.error(...args),
+        };
         const wsClient = new Lark.WSClient({
             appId: this.config.appId,
             appSecret: this.config.appSecret,
-            domain,
+            domain: Lark.Domain.Feishu,
+            logger: stderrLogger,
             loggerLevel: Lark.LoggerLevel.info,
         });
         this.wsClient = wsClient;
@@ -634,22 +596,22 @@ export class FeishuHandler {
                 // 历史消息过滤：发送时间超过 5 分钟视为重发，直接丢弃
                 const createTimeMs = msg.create_time ? parseInt(msg.create_time, 10) : NaN;
                 if (!isNaN(createTimeMs) && Date.now() - createTimeMs > STALE_MESSAGE_THRESHOLD_MS) {
-                    console.log(`[feishu] dropped stale message ${messageId} (create_time ${createTimeMs}, age ${Math.round((Date.now() - createTimeMs) / 60000)}min)`);
+                    console.error(`[feishu] dropped stale message ${messageId} (create_time ${createTimeMs}, age ${Math.round((Date.now() - createTimeMs) / 60000)}min)`);
                     return;
                 }
-                console.log(`[feishu] received ${messageType} ${chatType} ${chatId} from ${senderId} (content length ${rawContent.length})`);
+                console.error(`[feishu] received ${messageType} ${chatType} ${chatId} from ${senderId} (content length ${rawContent.length})`);
                 if (rawContent.length > 0 && rawContent.length <= 500) {
-                    console.log("[feishu] content preview:", rawContent);
+                    console.error("[feishu] content preview:", rawContent);
                 }
                 else if (rawContent.length > 500) {
-                    console.log("[feishu] content preview:", rawContent.slice(0, 500) + "...");
+                    console.error("[feishu] content preview:", rawContent.slice(0, 500) + "...");
                 }
                 // 并行获取用户信息和群聊信息
                 const [userInfo, chatInfo] = await Promise.all([
                     senderId ? this.getUserInfo(senderId) : Promise.resolve(null),
                     chatType === "group" ? this.getChatInfo(chatId) : Promise.resolve(null),
                 ]);
-                console.log(`[feishu] sender=${senderId} name=${userInfo?.name ?? "(empty)"} chatType=${chatType} chatName=${chatInfo?.name ?? "(none)"}`);
+                console.error(`[feishu] sender=${senderId} name=${userInfo?.name ?? "(empty)"} chatType=${chatType} chatName=${chatInfo?.name ?? "(none)"}`);
                 // 缓存 senderName → senderId，供出站消息 @Name 转换使用
                 if (senderId && userInfo?.name) {
                     this.mentionNameToId.set(userInfo.name, senderId);
@@ -683,12 +645,12 @@ export class FeishuHandler {
                     text = extractTextFromPostContent(rawContent);
                     const postImageKeys = [...new Set(extractImageKeysFromPostContent(rawContent))];
                     if (postImageKeys.length > 0) {
-                        console.log(`[feishu] post: fetching ${postImageKeys.length} image(s) from message ${messageId}`);
+                        console.error(`[feishu] post: fetching ${postImageKeys.length} image(s) from message ${messageId}`);
                         for (const imageKey of postImageKeys) {
                             const attach = await this.fetchMessageResourceAttachment(messageId, imageKey, "image", "image");
                             if (attach) {
                                 attachments.push(attach);
-                                console.log(`[feishu] post: fetched image ok (${attach.path ? "path" : "ref"})`);
+                                console.error(`[feishu] post: fetched image ok (${attach.path ? "path" : "ref"})`);
                             }
                             else {
                                 console.warn(`[feishu] post: failed to fetch image ${imageKey}`);
@@ -729,22 +691,19 @@ export class FeishuHandler {
                 if (msg.parent_id) {
                     text = `[回复消息 ${msg.parent_id}] ${text}`;
                 }
-                // 组装完整消息并回调（符合 BridgeMessage 接口，chatType 用中文标签，isPrivate 供 SDK 生成 coreForSenseContext）
                 if (chatId || messageId) {
                     const isP2p = chatType === "p2p";
-                    this.onMessageHandler({
-                        chatId,
-                        messageId,
+                    this.onMessageHandler(this.buildBridgeMessage({
+                        chatId: chatId ?? messageId ?? "",
+                        text,
+                        chatType: isP2p ? "私聊" : "群聊",
                         senderId,
                         senderName: userInfo?.name || "获取昵称失败",
-                        chatType: isP2p ? "私聊" : "群聊",
                         chatName: chatInfo?.name,
-                        text,
                         mentionsSelf,
                         attachments,
                         timestamp,
-                        isPrivate: isP2p,
-                    });
+                    }));
                 }
             },
             "im.chat.access_event.bot_p2p_chat_entered_v1": async (data) => {
@@ -779,7 +738,7 @@ export class FeishuHandler {
                 const meta = this.msgMetaMap.get(messageId);
                 const chatId = meta?.chatId ?? event.chat_id ?? "";
                 if (!chatId) {
-                    console.log(`[feishu] recalled unknown message ${messageId}, skipping`);
+                    console.error(`[feishu] recalled unknown message ${messageId}, skipping`);
                     return;
                 }
                 // 尝试获取被撤回消息的发送者信息
@@ -836,18 +795,16 @@ export class FeishuHandler {
                     const actor = recallLabel[recallType] ?? "某人";
                     text = `[${actor}撤回了一条消息]`;
                 }
-                console.log(`[feishu] message recalled: ${messageId} by ${msgSenderName || "(unknown)"}(${msgSenderId}) recall_type=${recallType} in ${chatId}`);
+                console.error(`[feishu] message recalled: ${messageId} by ${msgSenderName || "(unknown)"}(${msgSenderId}) recall_type=${recallType} in ${chatId}`);
                 const isP2pRecall = chatType === "p2p";
-                this.onMessageHandler({
+                this.onMessageHandler(this.buildBridgeMessage({
                     chatId,
-                    messageId,
+                    text,
+                    chatType: isP2pRecall ? "私聊" : "群聊",
                     senderId: msgSenderId,
                     senderName: msgSenderName,
-                    chatType: isP2pRecall ? "私聊" : "群聊",
-                    text,
                     timestamp: event.recall_time ? parseInt(event.recall_time, 10) : Date.now(),
-                    isPrivate: isP2pRecall,
-                });
+                }));
             },
             "im.message.reaction.created_v1": async (data) => {
                 if (!this.onMessageHandler)
@@ -859,24 +816,22 @@ export class FeishuHandler {
                 const meta = this.msgMetaMap.get(messageId);
                 const chatId = meta?.chatId ?? "";
                 if (!chatId) {
-                    console.log(`[feishu] reaction on unknown message ${messageId}, skipping`);
+                    console.error(`[feishu] reaction on unknown message ${messageId}, skipping`);
                     return;
                 }
                 const reactorInfo = reactorId ? await this.getUserInfo(reactorId) : null;
                 const reactorName = reactorInfo?.name || reactorId || "某人";
                 const chatType = this.inferChatType(chatId);
-                console.log(`[feishu] reaction ${emoji} on ${messageId} by ${reactorName}(${reactorId})`);
+                console.error(`[feishu] reaction ${emoji} on ${messageId} by ${reactorName}(${reactorId})`);
                 const isP2pReaction = chatType === "p2p";
-                this.onMessageHandler({
+                this.onMessageHandler(this.buildBridgeMessage({
                     chatId,
-                    messageId,
+                    text: `[${reactorName} 对一条消息贴了表情 ${emoji} (message_id: ${messageId})]`,
+                    chatType: isP2pReaction ? "私聊" : "群聊",
                     senderId: reactorId,
                     senderName: reactorName,
-                    chatType: isP2pReaction ? "私聊" : "群聊",
-                    text: `[${reactorName} 对一条消息贴了表情 ${emoji} (message_id: ${messageId})]`,
                     timestamp: event.action_time ? parseInt(event.action_time, 10) : Date.now(),
-                    isPrivate: isP2pReaction,
-                });
+                }));
             },
             "im.message.reaction.deleted_v1": async (data) => {
                 if (!this.onMessageHandler)
@@ -888,24 +843,22 @@ export class FeishuHandler {
                 const meta2 = this.msgMetaMap.get(messageId);
                 const chatId = meta2?.chatId ?? "";
                 if (!chatId) {
-                    console.log(`[feishu] reaction-delete on unknown message ${messageId}, skipping`);
+                    console.error(`[feishu] reaction-delete on unknown message ${messageId}, skipping`);
                     return;
                 }
                 const reactorInfo = reactorId ? await this.getUserInfo(reactorId) : null;
                 const reactorName = reactorInfo?.name || reactorId || "某人";
                 const chatType = this.inferChatType(chatId);
-                console.log(`[feishu] reaction removed ${emoji} on ${messageId} by ${reactorName}(${reactorId})`);
+                console.error(`[feishu] reaction removed ${emoji} on ${messageId} by ${reactorName}(${reactorId})`);
                 const isP2pDel = chatType === "p2p";
-                this.onMessageHandler({
+                this.onMessageHandler(this.buildBridgeMessage({
                     chatId,
-                    messageId,
+                    text: `[${reactorName} 移除了表情 ${emoji} (message_id: ${messageId})]`,
+                    chatType: isP2pDel ? "私聊" : "群聊",
                     senderId: reactorId,
                     senderName: reactorName,
-                    chatType: isP2pDel ? "私聊" : "群聊",
-                    text: `[${reactorName} 移除了表情 ${emoji} (message_id: ${messageId})]`,
                     timestamp: event.action_time ? parseInt(event.action_time, 10) : Date.now(),
-                    isPrivate: isP2pDel,
-                });
+                }));
             },
         });
         wsClient.start({ eventDispatcher });
@@ -1022,210 +975,17 @@ export class FeishuHandler {
             },
         });
     }
-    /**
-     * 处理来自 LLM 的结构化命令。
-     *
-     * 当前支持的命令：
-     * - set_nickname: 更新外部用户的昵称映射
-     *   params: { sender_id: "ou_xxx", nickname: "小红" }
-     */
+    /** 处理来自 MCP 工具 feishu action=set_nickname 的命令 */
     async onCommand(command, params) {
-        switch (command) {
-            case "set_nickname": {
-                const senderId = String(params.sender_id ?? "");
-                const nickname = String(params.nickname ?? "").trim();
-                if (!senderId) {
-                    console.warn("[feishu] set_nickname: sender_id is required");
-                    return;
-                }
-                if (!nickname) {
-                    console.warn("[feishu] set_nickname: nickname is required");
-                    return;
-                }
-                const oldLabel = this.externalUserLabels.get(senderId);
-                // 更新外部用户映射（无论之前是否存在）
-                this.externalUserLabels.set(senderId, nickname);
-                // 同步更新 userCache，使后续消息立即使用新昵称
-                this.userCache.set(senderId, { value: { name: nickname, openId: senderId }, ts: Date.now() });
-                // 同步更新 mentionNameToId，使出站消息 @新昵称 立即可用
-                this.mentionNameToId.set(nickname, senderId);
-                this.saveExternalUserLabel(senderId, nickname);
-                console.log(`[feishu] set_nickname: ${senderId} ${oldLabel ? oldLabel + " → " : "→ "}${nickname}`);
-                break;
-            }
-            case "add_reaction": {
-                const messageId = String(params.message_id ?? "");
-                const emojiType = String(params.emoji_type ?? "").trim();
-                if (!messageId) {
-                    console.warn("[feishu] add_reaction: message_id is required");
-                    return;
-                }
-                if (!emojiType) {
-                    console.warn("[feishu] add_reaction: emoji_type is required");
-                    return;
-                }
-                try {
-                    await this.client.request({
-                        method: "POST",
-                        url: `/open-apis/im/v1/messages/${messageId}/reactions`,
-                        data: { reaction_type: { emoji_type: emojiType } },
-                    });
-                    console.log(`[feishu] add_reaction: ${emojiType} on ${messageId}`);
-                }
-                catch (err) {
-                    console.warn(`[feishu] add_reaction failed:`, err);
-                }
-                break;
-            }
-            default:
-                console.log(`[feishu] unknown command: ${command}`);
-        }
-    }
-}
-/**
- * 从出站文本中提取 @提及，返回独立的 at 元素列表和清理后的文本。
- * 飞书 post 消息的 md 标签不支持内联 <at> 语法，
- * 必须将 @提及 作为独立的 { tag: "at", user_id } 元素放在 content 数组中。
- *
- * 两种匹配策略：
- * 1. @Name(open_id) 格式 —— AI 保留了完整 ID 信息
- * 2. @Name 格式 —— AI 只写了名字，通过 nameToIdCache 查找 open_id
- */
-function extractMentionElements(text, nameToIdCache) {
-    const atElements = [];
-    const seenIds = new Set();
-    // Step 1: 提取 @Name(open_id) 格式并从文本中移除
-    let cleanText = text.replace(/@([^@(]+?)\(([a-zA-Z0-9][a-zA-Z0-9_]{9,})\)/g, (_, displayName, userId) => {
-        if (!seenIds.has(userId)) {
-            atElements.push({ userId, name: displayName.trim() });
-            seenIds.add(userId);
-        }
-        return ""; // 从文本中移除
-    });
-    // Step 2: 通过名称缓存提取剩余的纯 @Name
-    if (nameToIdCache && nameToIdCache.size > 0) {
-        // 按名称长度降序排列，避免短名称部分匹配长名称
-        const names = [...nameToIdCache.keys()].sort((a, b) => b.length - a.length);
-        for (const name of names) {
-            const openId = nameToIdCache.get(name);
-            const atMention = `@${name}`;
-            if (cleanText.includes(atMention)) {
-                if (!seenIds.has(openId)) {
-                    atElements.push({ userId: openId, name });
-                    seenIds.add(openId);
-                }
-                cleanText = cleanText.replaceAll(atMention, "");
-            }
-        }
-    }
-    // 清理多余空格（仅压缩行内水平空白，保留换行结构）
-    cleanText = cleanText
-        .replace(/[^\S\n]+/g, " ") // 行内连续空白 → 单个空格
-        .replace(/\n{3,}/g, "\n\n") // 3+ 连续换行 → 双换行（段落分隔）
-        .trim();
-    return { cleanText, atElements };
-}
-// ─── Markdown 适配：飞书 md 标签受限子集 ───
-/**
- * 将标准 Markdown 适配为飞书 md 标签支持的子集。
- *
- * 飞书 md 标签的已知限制：
- *   - 标题仅支持 # 和 ##，###+ 不渲染（被当纯文本显示）
- *   - 列表不支持缩进/嵌套
- *   - 列表项仅支持文本和链接
- *   - 不支持表格（由 convertMarkdownTablesToCodeBlock 另行处理）
- */
-function adaptMarkdownForFeishu(text) {
-    return text
-        // ###+ 标题 → **加粗文本**（飞书仅支持 # 和 ##）
-        .replace(/^#{3,}\s+(.+)$/gm, "**$1**")
-        // 移除嵌套列表的前导缩进（飞书不支持缩进）
-        .replace(/^[ \t]+([-*])\s/gm, "$1 ")
-        .replace(/^[ \t]+(\d+\.)\s/gm, "$1 ");
-}
-// ─── Markdown 表格转换工具函数 ───
-/** 获取字符串显示宽度（CJK 字符算 2，其他算 1） */
-function getDisplayWidth(str) {
-    let width = 0;
-    for (const ch of str) {
-        const code = ch.codePointAt(0) ?? 0;
-        if ((code >= 0x4e00 && code <= 0x9fff) ||
-            (code >= 0x3000 && code <= 0x303f) ||
-            (code >= 0xff00 && code <= 0xffef) ||
-            (code >= 0x3400 && code <= 0x4dbf) ||
-            (code >= 0x20000 && code <= 0x2a6df)) {
-            width += 2;
-        }
-        else {
-            width += 1;
-        }
-    }
-    return width;
-}
-/** 按显示宽度右填充空格 */
-function padEnd(str, targetWidth) {
-    const padding = Math.max(0, targetWidth - getDisplayWidth(str));
-    return str + " ".repeat(padding);
-}
-/**
- * 将 Markdown 中的表格块转换为代码块（等宽对齐文本），
- * 飞书 md 标签不支持表格语法，会被静默丢弃。
- */
-function convertMarkdownTablesToCodeBlock(text) {
-    const lines = text.split("\n");
-    const result = [];
-    let tableLines = [];
-    const flushTable = () => {
-        if (tableLines.length === 0)
+        if (command !== "set_nickname")
             return;
-        // 解析表格：提取单元格，跳过分隔行（|---|---|）
-        const rows = [];
-        for (const line of tableLines) {
-            const trimmed = line.replace(/^\|/, "").replace(/\|$/, "");
-            const cells = trimmed.split("|").map((c) => c.trim());
-            if (cells.every((c) => /^[-:]+$/.test(c)))
-                continue;
-            rows.push(cells);
-        }
-        if (rows.length === 0) {
-            result.push(...tableLines);
-            tableLines = [];
+        const senderId = String(params.sender_id ?? "");
+        const nickname = String(params.nickname ?? "").trim();
+        if (!senderId || !nickname)
             return;
-        }
-        // 计算每列最大显示宽度
-        const colCount = Math.max(...rows.map((r) => r.length));
-        const colWidths = Array(colCount).fill(0);
-        for (const row of rows) {
-            for (let i = 0; i < row.length; i++) {
-                colWidths[i] = Math.max(colWidths[i], getDisplayWidth(row[i]));
-            }
-        }
-        // 格式化为对齐文本
-        const formatted = [];
-        for (let ri = 0; ri < rows.length; ri++) {
-            const row = rows[ri];
-            const cells = row.map((cell, ci) => padEnd(cell, colWidths[ci]));
-            formatted.push(cells.join(" | "));
-            if (ri === 0 && rows.length > 1) {
-                formatted.push(colWidths.map((w) => "-".repeat(w)).join("-+-"));
-            }
-        }
-        result.push("```");
-        result.push(...formatted);
-        result.push("```");
-        tableLines = [];
-    };
-    for (const line of lines) {
-        if (/^\s*\|/.test(line)) {
-            tableLines.push(line);
-        }
-        else {
-            if (tableLines.length > 0)
-                flushTable();
-            result.push(line);
-        }
+        this.externalUserLabels.set(senderId, nickname);
+        this.userCache.set(senderId, { value: { name: nickname, openId: senderId }, ts: Date.now() });
+        this.mentionNameToId.set(nickname, senderId);
+        this.saveExternalUserLabel(senderId, nickname);
     }
-    if (tableLines.length > 0)
-        flushTable();
-    return result.join("\n");
 }

package/dist/feishu-types.js

@@ -0,0 +1,9 @@
+export const STALE_MESSAGE_THRESHOLD_MS = 5 * 60 * 1000;
+export const NEGATIVE_CACHE_TTL = 5 * 60 * 1000;
+export const MEDIA_MESSAGE_CONFIG = {
+    image: { resourceType: "image", aidoType: "image", contentKey: "image_key" },
+    file: { resourceType: "file", aidoType: "file", contentKey: "file_key" },
+    audio: { resourceType: "audio", aidoType: "audio", contentKey: "file_key" },
+    media: { resourceType: "video", aidoType: "video", contentKey: "file_key" },
+    video: { resourceType: "video", aidoType: "video", contentKey: "file_key" },
+};