@lmcl/ailo-mcp-feishu 0.1.0 → 0.2.0

package/dist/feishu-handler.js

@@ -40,6 +40,16 @@ export class FeishuHandler {
     get storage() {
         return this.ctx?.storage ?? null;
     }
+    /** 通过 WS 发给 Aido 代打，ctx 未就绪时回退到 console */
+    _log(level, message, data) {
+        if (this.ctx?.log) {
+            this.ctx.log(level, message, data);
+        }
+        else {
+            const fn = level === "error" ? console.error : level === "warn" ? console.warn : level === "debug" ? console.debug : console.log;
+            fn(`[feishu] ${message}`, data ?? "");
+        }
+    }
     /** 外部用户数据单 key：{ _counter, [userId]: label } */
     static EXTERNAL_USERS_KEY = "external_users";
     /**
@@ -61,14 +71,14 @@ export class FeishuHandler {
                     if (k !== "_counter" && typeof v === "string")
                         this.externalUserLabels.set(k, v);
                 }
-                console.error(`[feishu] 已加载外部用户映射: ${this.externalUserLabels.size} 条, counter=${this.externalUserCounter}`);
+                this._log("info", `已加载外部用户映射: ${this.externalUserLabels.size} 条, counter=${this.externalUserCounter}`);
             }
             catch {
-                console.warn("[feishu] 解析外部用户数据失败，将从零开始");
+                this._log("warn", "解析外部用户数据失败，将从零开始");
             }
         })
             .catch((err) => {
-            console.warn("[feishu] 加载外部用户映射失败，将从零开始:", err);
+            this._log("warn", "加载外部用户映射失败，将从零开始", { err: String(err) });
         });
     }
     /**
@@ -87,7 +97,7 @@ export class FeishuHandler {
             return this.storage.setData(FeishuHandler.EXTERNAL_USERS_KEY, JSON.stringify(obj));
         })
             .catch((err) => {
-            console.warn("[feishu] 保存外部用户映射失败:", err);
+            this._log("warn", "保存外部用户映射失败", { err: String(err) });
         });
     }
     /**
@@ -107,13 +117,13 @@ export class FeishuHandler {
             const parsed = new URL(url);
             const pathParts = parsed.pathname.split("/").filter(Boolean);
             if (pathParts.length < 2) {
-                console.warn("[feishu] fetchDocWithImageRefs: invalid URL path", url);
+                this._log("warn", "fetchDocWithImageRefs: invalid URL path", { url });
                 return null;
             }
             const type = pathParts[0];
             const id = pathParts[1];
             if (!id) {
-                console.warn("[feishu] fetchDocWithImageRefs: missing doc id", url);
+                this._log("warn", "fetchDocWithImageRefs: missing doc id", { url });
                 return null;
             }
             if (type === "docx") {
@@ -132,14 +142,14 @@ export class FeishuHandler {
                 const docContent = await this.fetchDocRawContentLegacy(id);
                 if (docContent !== null)
                     return docContent;
-                console.warn("[feishu] fetchDocWithImageRefs docs failed for both APIs");
+                this._log("warn", "fetchDocWithImageRefs docs failed for both APIs");
                 return null;
             }
-            console.warn("[feishu] fetchDocWithImageRefs: unsupported doc type", type);
+            this._log("warn", "fetchDocWithImageRefs: unsupported doc type", { type });
             return null;
         }
         catch (err) {
-            console.warn("[feishu] fetchDocWithImageRefs error:", err);
+            this._log("warn", "fetchDocWithImageRefs error", { err: String(err) });
             return null;
         }
     }
@@ -150,7 +160,7 @@ export class FeishuHandler {
             data: {},
         }));
         if (res?.code !== 0) {
-            console.warn("[feishu] fetchDocxRawContent failed:", res);
+            this._log("warn", "fetchDocxRawContent failed", { code: res?.code });
             return null;
         }
         return res.data?.content ?? null;
@@ -162,7 +172,7 @@ export class FeishuHandler {
             data: {},
         }));
         if (res?.code !== 0) {
-            console.warn("[feishu] fetchDocRawContentLegacy failed:", res);
+            this._log("warn", "fetchDocRawContentLegacy failed", { code: res?.code });
             return null;
         }
         return res.data?.content ?? null;
@@ -181,7 +191,7 @@ export class FeishuHandler {
                 }));
                 if (res?.code !== 0 || !res.data?.items) {
                     if (res?.code !== 0)
-                        console.warn("[feishu] docx blocks failed:", res);
+                        this._log("warn", "docx blocks failed", { code: res?.code });
                     return false;
                 }
                 for (const block of res.data.items) {
@@ -228,7 +238,7 @@ export class FeishuHandler {
             data: { file_tokens: fileTokens },
         }));
         if (urlRes?.code !== 0 || !urlRes.data?.tmp_download_urls) {
-            console.warn("[feishu] batch_get_tmp_download_url failed:", urlRes);
+            this._log("warn", "batch_get_tmp_download_url failed", { code: urlRes?.code });
             return parts.join("").replace(/\[图片 \d+\]\(view_image_url_placeholder_[^)]+\)/g, "[图片]") || null;
         }
         const urlMap = new Map();
@@ -253,12 +263,12 @@ export class FeishuHandler {
             const bot = res.data?.bot;
             this.botOpenId = bot?.open_id ?? bot?.user_id ?? "";
             if (this.botOpenId) {
-                console.error(`[feishu] bot open_id: ${this.botOpenId}`);
+                this._log("info", `bot open_id: ${this.botOpenId}`);
             }
             // 获取失败时仅 debug 级别，不影响核心功能（仅群聊 @检测 会失效）
         }
         catch (err) {
-            console.warn("[feishu] failed to fetch bot info:", err);
+            this._log("warn", "failed to fetch bot info", { err: String(err) });
         }
     }
     resolveMentions(text, mentions) {
@@ -287,7 +297,7 @@ export class FeishuHandler {
     acceptMessage(msg) {
         if (!this.ctx)
             return;
-        this.ctx.accept(msg).catch((err) => console.error("[feishu] accept failed:", err));
+        this.ctx.accept(msg).catch((err) => this._log("error", "accept failed", { err: String(err) }));
     }
     setOnP2PChatEntered(handler) {
         this.onP2PChatEntered = handler;
@@ -375,7 +385,7 @@ export class FeishuHandler {
             const user = res.data?.user;
             const resolvedName = user?.name || user?.en_name || user?.nickname || "";
             if (!resolvedName) {
-                console.warn(`[feishu] getUserInfo(${userId}): 所有名称字段为空，应用可能缺少 contact:user.base:readonly 权限`);
+                this._log("warn", `getUserInfo(${userId}): 所有名称字段为空，应用可能缺少 contact:user.base:readonly 权限`);
             }
             const info = {
                 name: resolvedName,
@@ -390,11 +400,11 @@ export class FeishuHandler {
             const errCode = this.extractFeishuErrorCode(err);
             if (errCode === 41050) {
                 // 41050 = no user authority：外部用户（非本租户成员），无权访问通讯录信息，属预期情况
-                console.error(`[feishu] getUserInfo(${userId}): 外部用户，无权限获取通讯录信息 (41050)`);
+                this._log("info", `getUserInfo(${userId}): 外部用户，无权限获取通讯录信息 (41050)`);
             }
             else {
                 const detail = err?.response?.data ?? err.message;
-                console.warn(`[feishu] failed to get user ${userId}:`, detail);
+                this._log("warn", `failed to get user ${userId}`, { detail });
             }
             // 缓存失败结果（短 TTL），避免对同一用户重复调用失败的 API
             // 为每个外部用户分配稳定的顺序编号（如「外部用户1」「外部用户2」），帮助 LLM 区分
@@ -438,12 +448,11 @@ export class FeishuHandler {
         catch (err) {
             const errCode = this.extractFeishuErrorCode(err);
             if (errCode === 41050) {
-                // 41050 = no user authority：外部群可能无权获取群信息
-                console.error(`[feishu] getChatInfo(${chatId}): 无权限获取群信息 (41050)`);
+                this._log("info", `getChatInfo(${chatId}): 无权限获取群信息 (41050)`);
             }
             else {
                 const detail = err?.response?.data ?? err.message;
-                console.warn(`[feishu] failed to get chat ${chatId}:`, detail);
+                this._log("warn", `failed to get chat ${chatId}`, { detail });
             }
             // 缓存失败结果（短 TTL），避免对同一群聊重复调用失败的 API
             const fallback = { name: chatId };
@@ -469,7 +478,7 @@ export class FeishuHandler {
                 this.chatCache.delete(key);
             }
         }
-        console.error(`[feishu] cache cleaned: users=${this.userCache.size}, chats=${this.chatCache.size}`);
+        this._log("debug", `cache cleaned: users=${this.userCache.size}, chats=${this.chatCache.size}`);
     }
     /**
      * 推断 chatId 对应的聊天类型（撤回/Reaction 等事件不返回 chat_type 时使用）
@@ -525,18 +534,23 @@ export class FeishuHandler {
     /**
      * 使用飞书 WebSocket 长连接接收事件，无需配置回调地址。
      * 需在飞书开放平台「事件与回调」中选择「使用长连接接收事件」并保存（本客户端需在线）。
+     * 必须 await 飞书连接就绪后返回，避免 Aido 在飞书未连接时就认为通道就绪导致消息丢失。
      */
-    start(ctx) {
+    async start(ctx) {
         this.ctx = ctx;
         this.loadExternalUserLabels();
         this.fetchBotOpenId();
-        // MCP stdio 占用 stdout，Lark SDK 的 logger 必须写到 stderr
+        // MCP stdio 占用 stdout，Lark SDK 日志通过 WS 发给 Aido 代打
+        const sink = (level) => (...args) => {
+            const msg = args.map((a) => (typeof a === "object" ? JSON.stringify(a) : String(a))).join(" ");
+            this._log(level, msg);
+        };
         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),
+            error: sink("error"),
+            warn: sink("warn"),
+            info: sink("info"),
+            debug: sink("debug"),
+            trace: sink("debug"),
         };
         const wsClient = new Lark.WSClient({
             appId: this.config.appId,
@@ -552,12 +566,23 @@ export class FeishuHandler {
         });
         // 启动定时清理过期缓存（每小时）
         const cacheCleanupInterval = setInterval(() => this.cleanExpiredCache(), 60 * 60 * 1000);
+        // 必须 await 飞书连接就绪后再返回，否则 SDK 会在飞书未连接时就连到 Aido，导致启动窗口期消息丢失
+        const wsClientAny = wsClient;
+        wsClientAny.eventDispatcher = eventDispatcher;
         eventDispatcher.register({
             "im.message.receive_v1": async (data) => {
                 const event = data;
                 if (!event.message || !this.ctx)
                     return;
                 const msg = event.message;
+                const rawContent = msg.content ?? "";
+                const preview = rawContent.length > 100 ? String(rawContent).slice(0, 100) + "..." : rawContent;
+                this._log("debug", "im.message.receive_v1 ENTRY", {
+                    message_id: msg.message_id ?? "?",
+                    chat_id: msg.chat_id ?? "?",
+                    create_time: msg.create_time ?? "?",
+                    content_preview: preview,
+                });
                 const chatId = msg.chat_id ?? "";
                 const messageId = msg.message_id ?? "";
                 const chatType = msg.chat_type === "group" ? "group" : "p2p";
@@ -565,28 +590,27 @@ export class FeishuHandler {
                 const senderId = event.sender?.sender_id?.open_id ??
                     event.sender?.sender_id?.user_id ??
                     "";
-                const rawContent = msg.content ?? "";
                 const messageType = msg.message_type ?? "";
                 const timestamp = msg.create_time ? parseInt(msg.create_time, 10) : Date.now();
                 // 历史消息过滤：发送时间超过 5 分钟视为重发，直接丢弃
                 const createTimeMs = msg.create_time ? parseInt(msg.create_time, 10) : NaN;
                 if (!isNaN(createTimeMs) && Date.now() - createTimeMs > STALE_MESSAGE_THRESHOLD_MS) {
-                    console.error(`[feishu] dropped stale message ${messageId} (create_time ${createTimeMs}, age ${Math.round((Date.now() - createTimeMs) / 60000)}min)`);
+                    this._log("info", `dropped stale message ${messageId}`, {
+                        create_time: createTimeMs,
+                        age_min: Math.round((Date.now() - createTimeMs) / 60000),
+                    });
                     return;
                 }
-                console.error(`[feishu] received ${messageType} ${chatType} ${chatId} from ${senderId} (content length ${rawContent.length})`);
-                if (rawContent.length > 0 && rawContent.length <= 500) {
-                    console.error("[feishu] content preview:", rawContent);
-                }
-                else if (rawContent.length > 500) {
-                    console.error("[feishu] content preview:", rawContent.slice(0, 500) + "...");
-                }
+                this._log("debug", `received ${messageType} ${chatType} ${chatId} from ${senderId}`, {
+                    content_len: rawContent.length,
+                    preview: rawContent.length > 0 ? rawContent.slice(0, 200) : "",
+                });
                 // 并行获取用户信息和群聊信息
                 const [userInfo, chatInfo] = await Promise.all([
                     senderId ? this.getUserInfo(senderId) : Promise.resolve(null),
                     chatType === "group" ? this.getChatInfo(chatId) : Promise.resolve(null),
                 ]);
-                console.error(`[feishu] sender=${senderId} name=${userInfo?.name ?? "(empty)"} chatType=${chatType} chatName=${chatInfo?.name ?? "(none)"}`);
+                this._log("debug", `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);
@@ -649,6 +673,16 @@ export class FeishuHandler {
                         }
                     }
                 }
+                // 忽略机器人自己发送的消息，避免自循环
+                if (senderId && this.botOpenId && senderId === this.botOpenId) {
+                    this._log("debug", `skipped own message ${messageId}`);
+                    return;
+                }
+                // chat_id 必须有值才能回复；message_id 不能作为 chat_id 的替代
+                if (!chatId) {
+                    this._log("warn", `dropped message ${messageId}: chat_id 为空，无法路由回复（飞书事件可能异常）`);
+                    return;
+                }
                 // 解析 @mention 占位符（@_user_1 -> @显示名(open_id)）
                 const mentions = msg.mentions;
                 const { text: resolvedText, mentionsSelf } = this.resolveMentions(text, mentions);
@@ -657,20 +691,22 @@ export class FeishuHandler {
                 if (msg.parent_id) {
                     text = `[回复消息 ${msg.parent_id}] ${text}`;
                 }
-                if (chatId || messageId) {
-                    const isP2p = chatType === "p2p";
-                    this.acceptMessage(this.buildBridgeMessage({
-                        chatId: chatId ?? messageId ?? "",
-                        text,
-                        chatType: isP2p ? "私聊" : "群聊",
-                        senderId,
-                        senderName: userInfo?.name || "获取昵称失败",
-                        chatName: chatInfo?.name,
-                        mentionsSelf,
-                        attachments,
-                        timestamp,
-                    }));
+                // 未知消息类型（卡片等）时若文本和附件均空，Aido 会拒绝；提供占位说明
+                if (!text.trim() && attachments.length === 0) {
+                    text = messageType ? `[${messageType} 类型消息，暂不支持解析]` : "[未知类型消息]";
                 }
+                const isP2p = chatType === "p2p";
+                this.acceptMessage(this.buildBridgeMessage({
+                    chatId,
+                    text,
+                    chatType: isP2p ? "私聊" : "群聊",
+                    senderId,
+                    senderName: userInfo?.name || "获取昵称失败",
+                    chatName: chatInfo?.name,
+                    mentionsSelf,
+                    attachments,
+                    timestamp,
+                }));
             },
             "im.chat.access_event.bot_p2p_chat_entered_v1": async (data) => {
                 const event = data;
@@ -687,8 +723,11 @@ export class FeishuHandler {
             "im.chat.member.bot.deleted_v1": async (data) => {
                 const event = data;
                 const chatId = event.chat_id ?? event.event?.chat_id ?? "";
-                if (chatId && this.onBotRemovedFromGroup)
-                    this.onBotRemovedFromGroup(chatId);
+                if (chatId) {
+                    this._log("info", `bot removed from group ${chatId}`);
+                    if (this.onBotRemovedFromGroup)
+                        this.onBotRemovedFromGroup(chatId);
+                }
             },
             "im.message.message_read_v1": async (data) => {
                 if (this.onMessageRead)
@@ -704,7 +743,7 @@ export class FeishuHandler {
                 const meta = this.msgMetaMap.get(messageId);
                 const chatId = meta?.chatId ?? event.chat_id ?? "";
                 if (!chatId) {
-                    console.error(`[feishu] recalled unknown message ${messageId}, skipping`);
+                    this._log("warn", `recalled unknown message ${messageId}, skipping`);
                     return;
                 }
                 // 尝试获取被撤回消息的发送者信息
@@ -761,7 +800,7 @@ export class FeishuHandler {
                     const actor = recallLabel[recallType] ?? "某人";
                     text = `[${actor}撤回了一条消息]`;
                 }
-                console.error(`[feishu] message recalled: ${messageId} by ${msgSenderName || "(unknown)"}(${msgSenderId}) recall_type=${recallType} in ${chatId}`);
+                this._log("info", `message recalled: ${messageId} by ${msgSenderName || "(unknown)"}(${msgSenderId}) recall_type=${recallType} in ${chatId}`);
                 const isP2pRecall = chatType === "p2p";
                 this.acceptMessage(this.buildBridgeMessage({
                     chatId,
@@ -782,13 +821,13 @@ export class FeishuHandler {
                 const meta = this.msgMetaMap.get(messageId);
                 const chatId = meta?.chatId ?? "";
                 if (!chatId) {
-                    console.error(`[feishu] reaction on unknown message ${messageId}, skipping`);
+                    this._log("warn", `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.error(`[feishu] reaction ${emoji} on ${messageId} by ${reactorName}(${reactorId})`);
+                this._log("info", `reaction ${emoji} on ${messageId} by ${reactorName}(${reactorId})`);
                 const isP2pReaction = chatType === "p2p";
                 this.acceptMessage(this.buildBridgeMessage({
                     chatId,
@@ -809,13 +848,13 @@ export class FeishuHandler {
                 const meta2 = this.msgMetaMap.get(messageId);
                 const chatId = meta2?.chatId ?? "";
                 if (!chatId) {
-                    console.error(`[feishu] reaction-delete on unknown message ${messageId}, skipping`);
+                    this._log("warn", `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.error(`[feishu] reaction removed ${emoji} on ${messageId} by ${reactorName}(${reactorId})`);
+                this._log("info", `reaction removed ${emoji} on ${messageId} by ${reactorName}(${reactorId})`);
                 const isP2pDel = chatType === "p2p";
                 this.acceptMessage(this.buildBridgeMessage({
                     chatId,
@@ -827,7 +866,7 @@ export class FeishuHandler {
                 }));
             },
         });
-        wsClient.start({ eventDispatcher });
+        await wsClientAny.reConnect(true);
     }
     /**
      * 根据文件名/扩展名推断飞书 im.file.create 的 file_type。

package/dist/index.js

@@ -10,7 +10,7 @@ if (!FEISHU_APP_ID || !FEISHU_APP_SECRET) {
     process.exit(1);
 }
 const handler = new FeishuHandler({ appId: FEISHU_APP_ID, appSecret: FEISHU_APP_SECRET });
-handler.setOnBotRemovedFromGroup((chatId) => console.error("[feishu] bot removed from group", chatId));
+handler.setOnBotRemovedFromGroup(() => { });
 function feishuBuildChannelPrompt() {
     return `ID 格式：ou_xxx 是飞书用户 ID，oc_xxx 是群组 ID。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lmcl/ailo-mcp-feishu",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Ailo 飞书/Lark 通道 MCP",
   "type": "module",
   "main": "dist/index.js",
@@ -10,14 +10,20 @@
   "scripts": {
     "build": "tsc",
     "start": "node dist/index.js",
-    "dev": "tsx src/index.ts"
+    "dev": "tsx src/index.ts",
+    "postinstall": "patch-package"
   },
+  "files": [
+    "dist",
+    "patches"
+  ],
   "dependencies": {
     "@larksuiteoapi/node-sdk": "^1.56.1",
-    "@lmcl/ailo-mcp-sdk": "^0.1.0",
+    "@lmcl/ailo-mcp-sdk": "^0.2.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "dotenv": "^16.4.5",
     "form-data": "^4.0.0",
+    "patch-package": "^8.0.1",
     "zod": "^4.3.6"
   },
   "devDependencies": {

package/patches/@larksuiteoapi+node-sdk+1.59.0.patch

@@ -0,0 +1,42 @@
+diff --git a/node_modules/@larksuiteoapi/node-sdk/lib/index.js b/node_modules/@larksuiteoapi/node-sdk/lib/index.js
+index e0a1198..efbd5a0 100644
+--- a/node_modules/@larksuiteoapi/node-sdk/lib/index.js
++++ b/node_modules/@larksuiteoapi/node-sdk/lib/index.js
+@@ -85550,25 +85550,22 @@ class WSClient {
+                 data: payload
+             });
+             if (!mergedData) {
++                // 分片未收齐：必须立即 ACK 该帧，否则飞书认为未收到会暂停推送，后续消息延后重试才到
++                const partialRespPayload = { code: HttpStatusCode.ok };
++                this.sendMessage(Object.assign(Object.assign({}, data), { headers: [...data.headers, { key: HeaderKey.biz_rt, value: "0" }], payload: new TextEncoder().encode(JSON.stringify(partialRespPayload)) }));
+                 return;
+             }
+             this.logger.debug('[ws]', `receive message, message_type: ${type}; message_id: ${message_id}; trace_id: ${trace_id}; data: ${mergedData.data}`);
+-            const respPayload = {
+-                code: HttpStatusCode.ok,
+-            };
+-            const startTime = Date.now();
+-            try {
+-                const result = yield ((_a = this.eventDispatcher) === null || _a === void 0 ? void 0 : _a.invoke(mergedData, { needCheck: false }));
+-                if (result) {
+-                    respPayload.data = Buffer.from(JSON.stringify(result)).toString("base64");
+-                }
+-            }
+-            catch (error) {
+-                respPayload.code = HttpStatusCode.internal_server_error;
+-                this.logger.error('[ws]', `invoke event failed, message_type: ${type}; message_id: ${message_id}; trace_id: ${trace_id}; error: ${error}`);
++            // [patch] 立即 ACK，不等 handler 完成。飞书要求 3 秒内 ACK，handler 可能耗时远超此限。
++            const immediateAckPayload = { code: HttpStatusCode.ok };
++            this.sendMessage(Object.assign(Object.assign({}, data), { headers: [...data.headers, { key: HeaderKey.biz_rt, value: "0" }], payload: new TextEncoder().encode(JSON.stringify(immediateAckPayload)) }));
++            // [patch] handler 异步执行，不阻塞后续消息的 ACK
++            const dispatcher = this.eventDispatcher;
++            if (dispatcher) {
++                dispatcher.invoke(mergedData, { needCheck: false }).catch((error) => {
++                    this.logger.error('[ws]', `invoke event failed, message_type: ${type}; message_id: ${message_id}; trace_id: ${trace_id}; error: ${error}`);
++                });
+             }
+-            const endTime = Date.now();
+-            this.sendMessage(Object.assign(Object.assign({}, data), { headers: [...data.headers, { key: HeaderKey.biz_rt, value: String(startTime - endTime) }], payload: new TextEncoder().encode(JSON.stringify(respPayload)) }));
+         });
+     }
+     sendMessage(data) {