openclaw-lark-multi-agent 0.1.0

package/dist/feishu-bot.js

@@ -0,0 +1,985 @@
+import * as lark from "@larksuiteoapi/node-sdk";
+const MAX_BOT_STREAK = 10;
+/**
+ * Manages a single Feishu bot instance.
+ *
+ * Each bot owns an OpenClaw session (full agent pipeline).
+ * All messages are recorded locally in SQLite.
+ * When this bot needs to respond, unsynced messages are batched into
+ * a single context catch-up + the actual message → one agent run.
+ */
+export class FeishuBot {
+    config;
+    client;
+    wsClient;
+    eventDispatcher;
+    openclawClient;
+    store;
+    botOpenId = null;
+    /** Tracks which chatId sessions have been initialized */
+    initializedSessions = new Set();
+    /** Per-chat busy lock: timestamp when became busy (0 = not busy) */
+    busyChats = new Map();
+    /** Per-chat pending reply message IDs (to ack with DONE when reply arrives) */
+    pendingAckMessages = new Map();
+    /** Per-chat pending tool message sends (to await before final reply) */
+    pendingToolSends = new Map();
+    /** Per-chat processQueue lock to avoid duplicate concurrent chat.send runs */
+    queueRuns = new Map();
+    /** Per-chat serial send queue to guarantee message order */
+    sendQueue = new Map();
+    adminOpenId;
+    static allBots = new Map();
+    constructor(config, openclawClient, store, adminOpenId) {
+        this.config = config;
+        this.openclawClient = openclawClient;
+        this.store = store;
+        this.adminOpenId = adminOpenId || null;
+        // Session keys are now per-chat: lma-<botname>-<chatId>
+        this.client = new lark.Client({
+            appId: config.appId,
+            appSecret: config.appSecret,
+            appType: lark.AppType.SelfBuild,
+        });
+        this.wsClient = new lark.WSClient({
+            appId: config.appId,
+            appSecret: config.appSecret,
+            loggerLevel: lark.LoggerLevel.info,
+        });
+        this.eventDispatcher = new lark.EventDispatcher({}).register({
+            "im.message.receive_v1": this.handleMessage.bind(this),
+        });
+    }
+    register() {
+        FeishuBot.allBots.set(this.config.appId, this);
+    }
+    /**
+     * Get the session key for a specific chat.
+     * Format: lma-<botname>-<chatId>
+     */
+    getSessionKey(chatId) {
+        return `lma-${this.config.name.toLowerCase()}-${chatId}`;
+    }
+    /**
+     * Ensure the session for a given chatId exists with the correct model.
+     * Lazy: only creates on first message in that chat.
+     */
+    async ensureSession(chatId) {
+        const sessionKey = this.getSessionKey(chatId);
+        if (this.initializedSessions.has(sessionKey)) {
+            // Already initialized this process lifetime, just ensure model
+            const corrected = await this.openclawClient.ensureModel(sessionKey, this.config.model);
+            if (corrected) {
+                console.log(`[${this.config.name}] Model auto-corrected to ${this.config.model}`);
+                await this.notifyModelDrift(chatId, sessionKey);
+            }
+            return sessionKey;
+        }
+        try {
+            // Check if session already exists in OpenClaw
+            const existing = await this.openclawClient.getSessionInfo(sessionKey).catch(() => null);
+            if (existing?.session) {
+                // Session exists — preserve it, only ensure model is correct
+                console.log(`[${this.config.name}] Session exists: ${sessionKey} (tokens: ${existing.session.totalTokens || 0})`);
+                const corrected = await this.openclawClient.ensureModel(sessionKey, this.config.model);
+                if (corrected) {
+                    console.log(`[${this.config.name}] Model auto-corrected to ${this.config.model}`);
+                    await this.notifyModelDrift(chatId, sessionKey);
+                }
+            }
+            else {
+                // Session doesn't exist — create new
+                await this.openclawClient.createSession({
+                    key: sessionKey,
+                    model: this.config.model,
+                    label: `LMA: ${this.config.name} [${chatId.slice(-8)}]`,
+                });
+                // Always patch model after create to ensure it takes effect
+                await this.openclawClient.patchSession({ key: sessionKey, model: this.config.model });
+                console.log(`[${this.config.name}] Session created: ${sessionKey} (model: ${this.config.model})`);
+            }
+        }
+        catch (err) {
+            console.warn(`[${this.config.name}] ensureSession error:`, err.message);
+        }
+        this.initializedSessions.add(sessionKey);
+        // Subscribe to session events (proactive messages + tool calls)
+        await this.openclawClient.subscribeSession(sessionKey, async (text) => {
+            try {
+                console.log(`[${this.config.name}] Proactive message for ${chatId.slice(-8)}`);
+                await this.sendMessage(chatId, text);
+            }
+            catch (err) {
+                console.error(`[${this.config.name}] Failed to deliver proactive msg:`, err.message);
+            }
+        });
+        // Subscribe to tool events for verbose mode
+        this.openclawClient.onToolEvent(sessionKey, async (toolName, toolInput, toolOutput) => {
+            if (!this.store.getBotVerbose(this.config.name, chatId))
+                return;
+            console.log(`[${this.config.name}] [${new Date().toISOString()}] Tool event received: ${toolName}`);
+            const sendPromise = this.sendOrdered(chatId, async () => {
+                try {
+                    const inputPreview = toolInput.length > 200 ? toolInput.substring(0, 200) + "..." : toolInput;
+                    const outputPreview = toolOutput.length > 300 ? toolOutput.substring(0, 300) + "..." : toolOutput;
+                    const msg = `🔧 Tool: ${toolName}\n📥 ${inputPreview}${toolOutput ? `\n📤 ${outputPreview}` : ""}`;
+                    console.log(`[${this.config.name}] [${new Date().toISOString()}] Sending tool msg to Feishu...`);
+                    await this.sendMessage(chatId, msg);
+                    console.log(`[${this.config.name}] [${new Date().toISOString()}] Tool msg sent OK`);
+                }
+                catch (err) {
+                    console.warn(`[${this.config.name}] Failed to send tool event:`, err.message);
+                }
+            });
+            // Track the send promise so processQueue can await it before final reply
+            const pending = this.pendingToolSends.get(chatId) || [];
+            pending.push(sendPromise);
+            this.pendingToolSends.set(chatId, pending);
+        });
+        return sessionKey;
+    }
+    /**
+     * Start the Feishu WS connection. Sessions are created lazily per chat.
+     */
+    async start() {
+        await this.probeBotIdentity();
+        await this.wsClient.start({ eventDispatcher: this.eventDispatcher });
+        console.log(`[${this.config.name}] Bot started (model: ${this.config.model}, open_id: ${this.botOpenId || "unknown"})`);
+        // Drain any unsynced messages left from previous run
+        this.drainOnStartup();
+    }
+    /** Resolve this bot's open_id at startup so direct @bot mentions work even
+     * when Feishu mention payloads omit app_id and only contain open_id/name. */
+    async probeBotIdentity() {
+        try {
+            const res = await this.client.request({
+                method: "POST",
+                url: "/open-apis/bot/v1/openclaw_bot/ping",
+                data: { needBotInfo: true },
+            });
+            const botInfo = res?.data?.pingBotInfo;
+            if (botInfo?.botID) {
+                this.botOpenId = botInfo.botID;
+                console.log(`[${this.config.name}] Bot identity resolved: ${botInfo.botName || this.config.name} (${this.botOpenId})`);
+            }
+            else {
+                console.warn(`[${this.config.name}] Bot identity probe returned no botID`);
+            }
+        }
+        catch (err) {
+            console.warn(`[${this.config.name}] Bot identity probe failed:`, err.message);
+        }
+    }
+    /**
+     * On startup, check all known chats for unsynced messages and process them.
+     * Also re-subscribe to known sessions for tool events.
+     */
+    async drainOnStartup() {
+        try {
+            const chats = this.store.getAllChatInfo();
+            for (const chat of chats) {
+                // Skip p2p chats that belong to other bots
+                if (chat.chatType === "p2p" && chat.ownerBot && chat.ownerBot !== this.config.name) {
+                    continue;
+                }
+                // Re-subscribe to existing sessions
+                const sessionKey = this.getSessionKey(chat.chatId);
+                await this.ensureSession(chat.chatId);
+                // Drain only messages that were explicitly marked as reply triggers.
+                // Context-only messages should not start an OpenClaw run after restart.
+                const pendingTriggerIds = this.store.getPendingTriggerIds(this.config.name, chat.chatId);
+                if (pendingTriggerIds.size > 0) {
+                    console.log(`[${this.config.name}] Startup drain: ${pendingTriggerIds.size} pending trigger(s) in ${chat.chatName || chat.chatId.slice(-8)}`);
+                    await this.processQueue(chat.chatId);
+                }
+            }
+        }
+        catch (err) {
+            console.warn(`[${this.config.name}] Startup drain failed:`, err.message);
+        }
+    }
+    static getAllBots() {
+        return FeishuBot.allBots;
+    }
+    static findByOpenId(openId) {
+        for (const bot of FeishuBot.allBots.values()) {
+            if (bot.botOpenId === openId)
+                return bot;
+        }
+        return undefined;
+    }
+    async handleMessage(data) {
+        try {
+            const event = data;
+            const message = event.message;
+            const sender = event.sender;
+            const chatId = message.chat_id;
+            const chatType = message.chat_type;
+            const messageType = message.message_type;
+            const messageId = message.message_id;
+            const isBot = sender?.sender_type === "app";
+            // Extract bot open_id from mentions
+            if (message.mentions) {
+                for (const m of message.mentions) {
+                    const bot = FeishuBot.allBots.get(m.id?.app_id || "");
+                    if (bot && m.id?.open_id) {
+                        bot.botOpenId = m.id.open_id;
+                    }
+                }
+            }
+            if (messageType !== "text" && messageType !== "image" && messageType !== "file" && messageType !== "audio" && messageType !== "sticker" && messageType !== "post")
+                return;
+            // --- Dedup: skip if this bot already processed this message ---
+            if (this.store.hasBotProcessed(this.config.name, messageId))
+                return;
+            // --- Cache chat info (lazy, at most once per hour) ---
+            await this.fetchAndCacheChatInfo(chatId, chatType);
+            // --- P2P isolation: only the owning bot processes p2p messages ---
+            if (chatType === "p2p") {
+                const chatInfo = this.store.getChatInfo(chatId);
+                if (chatInfo?.ownerBot && chatInfo.ownerBot !== this.config.name) {
+                    return; // This p2p chat belongs to another bot
+                }
+            }
+            let content;
+            try {
+                content = JSON.parse(message.content);
+            }
+            catch {
+                console.warn(`[${this.config.name}] Failed to parse message content, skipping`);
+                return;
+            }
+            // --- Extract text content based on message type ---
+            let cleanText = "";
+            if (messageType === "text") {
+                const rawText = content.text || "";
+                cleanText = this.cleanMentions(rawText);
+            }
+            else if (messageType === "image") {
+                // Download image and pass local path
+                const imageKey = content.image_key;
+                if (imageKey) {
+                    try {
+                        const imgPath = await this.downloadResource(messageId, imageKey, "image");
+                        cleanText = `[Image: ${imgPath}]`;
+                    }
+                    catch (err) {
+                        cleanText = `[Image: download failed - ${err.message}]`;
+                    }
+                }
+            }
+            else if (messageType === "file") {
+                const fileKey = content.file_key;
+                const fileName = content.file_name || "unknown";
+                if (fileKey) {
+                    try {
+                        const filePath = await this.downloadResource(messageId, fileKey, "file");
+                        cleanText = `[File: ${fileName} -> ${filePath}]`;
+                    }
+                    catch (err) {
+                        cleanText = `[File: ${fileName} - download failed]`;
+                    }
+                }
+            }
+            else if (messageType === "audio") {
+                const fileKey = content.file_key;
+                if (fileKey) {
+                    try {
+                        const audioPath = await this.downloadResource(messageId, fileKey, "file");
+                        cleanText = `[Audio: ${audioPath}]`;
+                    }
+                    catch (err) {
+                        cleanText = `[Audio: download failed]`;
+                    }
+                }
+            }
+            else if (messageType === "post") {
+                // Rich text post - extract all text content
+                cleanText = this.extractPostText(content);
+            }
+            else if (messageType === "sticker") {
+                cleanText = `[Sticker: ${content.file_key || "unknown"}]`;
+            }
+            if (!cleanText.trim())
+                return;
+            // Escape hatch: //command means send /command through to OpenClaw,
+            // while /command remains a bridge-level openclaw-lark-multi-agent command.
+            const trimmedCleanText = cleanText.trim();
+            if (trimmedCleanText.startsWith("//")) {
+                cleanText = "/" + trimmedCleanText.slice(2);
+            }
+            // --- Record to local store (ALL messages, before command/response checks) ---
+            const senderName = isBot
+                ? this.resolveBotName(sender) || "Bot"
+                : this.resolveHumanName(sender) || "User";
+            let insertedId = this.store.insert({
+                chatId,
+                messageId,
+                senderType: isBot ? "bot" : "human",
+                senderName,
+                content: cleanText,
+                timestamp: Date.now(),
+            });
+            if (insertedId < 0)
+                insertedId = this.store.getMessageId(messageId) || -1;
+            // Mark as processed only after successful parse + insert
+            this.store.markBotProcessed(this.config.name, messageId);
+            // --- Commands: in p2p always respond; in group, check shouldRespond first ---
+            // Single slash commands are handled by the bridge. Double slash commands were
+            // already unescaped above and should pass through to OpenClaw instead.
+            const isBridgeCommand = !trimmedCleanText.startsWith("//");
+            const isCommand = isBridgeCommand && /^\/(help|status|compact|reset|verbose|free)/.test(cleanText.trim());
+            if (isCommand) {
+                // In group chats, commands also require mention/shouldRespond
+                if (chatType !== "p2p" && !this.shouldRespond(chatType, message, isBot, chatId, message.content))
+                    return;
+                const markCommandSynced = () => {
+                    if (insertedId > 0) {
+                        this.store.markSynced(this.config.name, chatId, insertedId);
+                        this.store.clearPendingTriggers(this.config.name, chatId, insertedId);
+                    }
+                };
+                if (cleanText.trim().startsWith("/help")) {
+                    const helpText = [
+                        `📚 ${this.config.name} Bot 命令列表`,
+                        `━━━━━━━━━━━━━━━━━━`,
+                        `📊 /status  — 查看当前模型、Token 用量、Session 状态`,
+                        `🧹 /compact — 压缩上下文（保留摘要，释放 token）`,
+                        `🔄 /reset   — 重置会话（清空历史，从头开始）`,
+                        `🔊 /verbose — 开关 Tool Call 显示（查看 AI 调用了哪些工具）`,
+                        `🔓 /free    — 开关 Free Discussion（群聊中无需 @ 即可回复）`,
+                        `❓ /help    — 显示此帮助信息`,
+                    ].join("\n");
+                    await this.replyMessage(messageId, helpText);
+                    markCommandSynced();
+                    return;
+                }
+                if (cleanText.trim().startsWith("/status")) {
+                    await this.ensureSession(chatId);
+                    await this.handleStatusCommand(chatId, chatType, messageId);
+                    markCommandSynced();
+                    return;
+                }
+                if (cleanText.trim().startsWith("/compact")) {
+                    await this.ensureSession(chatId);
+                    await this.handleCompactCommand(chatId, messageId);
+                    markCommandSynced();
+                    return;
+                }
+                if (cleanText.trim().startsWith("/reset")) {
+                    await this.ensureSession(chatId);
+                    await this.handleResetCommand(chatId, messageId);
+                    markCommandSynced();
+                    return;
+                }
+                if (cleanText.trim().startsWith("/verbose")) {
+                    const isOn = this.store.getBotVerbose(this.config.name, chatId);
+                    this.store.setBotVerbose(this.config.name, chatId, !isOn);
+                    if (isOn) {
+                        await this.replyMessage(messageId, `🔇 ${this.config.name} Verbose 已关闭\n只影响当前 Bot 在当前会话的 Tool call 显示`);
+                    }
+                    else {
+                        await this.replyMessage(messageId, `🔊 ${this.config.name} Verbose 已开启\n只影响当前 Bot 在当前会话的 Tool call 显示`);
+                    }
+                    markCommandSynced();
+                    return;
+                }
+                if (cleanText.trim().startsWith("/free")) {
+                    if (chatType === "p2p") {
+                        await this.replyMessage(messageId, "❌ Free Discussion 只在群聊中可用");
+                        markCommandSynced();
+                        return;
+                    }
+                    const chatInfo = this.store.getChatInfo(chatId);
+                    const isOn = chatInfo?.freeDiscussion || false;
+                    this.store.setFreeDiscussion(chatId, !isOn);
+                    if (isOn) {
+                        await this.replyMessage(messageId, "🔒 Free Discussion 已关闭\n群聊中需要 @ 指定 Bot 才会回复");
+                    }
+                    else {
+                        await this.replyMessage(messageId, "🔓 Free Discussion 已开启\n所有 Bot 可以自由参与讨论（连续 Bot 回复超过 " + MAX_BOT_STREAK + " 轮将暂停，等待人类发言）");
+                    }
+                    markCommandSynced();
+                    return;
+                }
+            }
+            // --- Should this bot respond? ---
+            if (!this.shouldRespond(chatType, message, isBot, chatId, message.content))
+                return;
+            if (!isBot && insertedId > 0) {
+                this.store.markPendingTrigger(this.config.name, chatId, insertedId);
+            }
+            // Track this message for reaction status updates
+            const pending = this.pendingAckMessages.get(chatId) || [];
+            // Anti-loop
+            const streak = this.store.getBotStreak(chatId);
+            if (streak >= MAX_BOT_STREAK) {
+                console.log(`[${this.config.name}] Anti-loop: ${streak} consecutive bot msgs`);
+                return;
+            }
+            // --- Queue-based sending: if agent is busy, just accumulate ---
+            const busySince = this.busyChats.get(chatId) || 0;
+            const BUSY_TIMEOUT_MS = 1_800_000; // 30 minutes, matches collectReply safety timeout
+            const isBusy = busySince > 0 && (Date.now() - busySince) < BUSY_TIMEOUT_MS;
+            if (isBusy) {
+                // Queued: show waiting reaction
+                await this.addReaction(messageId, "Typing").catch(() => { });
+                pending.push({ messageId, emoji: "Typing" });
+                this.pendingAckMessages.set(chatId, pending);
+                console.log(`[${this.config.name}] Agent busy for ${chatId.slice(-8)}, queuing: "${cleanText.substring(0, 50)}..."`);
+                return; // Message is in DB, will be picked up when agent finishes
+            }
+            if (busySince > 0) {
+                // Busy timeout expired — unlock but don't processQueue here;
+                // let the next new message trigger it naturally to avoid concurrent runs
+                console.warn(`[${this.config.name}] Busy timeout expired for ${chatId.slice(-8)} (${Math.round((Date.now() - busySince) / 1000)}s), unlocking (will process on next message)`);
+                this.busyChats.set(chatId, 0);
+                return;
+            }
+            // --- Not busy, send now (with any accumulated messages) ---
+            // Acknowledge receipt: sent to OpenClaw (GET/了解)
+            await this.addReaction(messageId, "Get").catch(() => { });
+            pending.push({ messageId, emoji: "Get" });
+            this.pendingAckMessages.set(chatId, pending);
+            await this.processQueue(chatId);
+        }
+        catch (err) {
+            console.error(`[${this.config.name}] Error:`, err);
+        }
+    }
+    /**
+     * Process queued messages for a chat: batch all unsynced messages and send to OpenClaw.
+     * Loops until no more unsynced human messages remain.
+     */
+    async processQueue(chatId) {
+        const existing = this.queueRuns.get(chatId);
+        if (existing) {
+            console.log(`[${this.config.name}] processQueue already running for ${chatId.slice(-8)}, joining existing run`);
+            return existing;
+        }
+        const run = this.processQueueInner(chatId).finally(() => {
+            this.queueRuns.delete(chatId);
+        });
+        this.queueRuns.set(chatId, run);
+        return run;
+    }
+    async processQueueInner(chatId) {
+        while (true) {
+            const allUnsynced = this.store.getUnsyncedMessages(this.config.name, chatId);
+            const pendingTriggerIds = this.store.getPendingTriggerIds(this.config.name, chatId);
+            // Only proceed if there are unsynced human messages that should actively trigger this bot.
+            // Other unsynced messages remain as context for the next trigger.
+            const humanUnsynced = allUnsynced.filter((m) => m.senderType === "human" && m.id && pendingTriggerIds.has(m.id));
+            if (humanUnsynced.length === 0) {
+                break;
+            }
+            this.busyChats.set(chatId, Date.now());
+            // The last trigger message is the "current" one, everything else is context
+            const lastHuman = humanUnsynced[humanUnsynced.length - 1];
+            const triggerId = lastHuman.id || 0;
+            if (triggerId && this.store.hasDeliveredReply(this.config.name, chatId, triggerId)) {
+                console.warn(`[${this.config.name}] Duplicate trigger skipped for ${chatId.slice(-8)} msgId=${triggerId}`);
+                this.store.clearPendingTriggers(this.config.name, chatId, triggerId);
+                continue;
+            }
+            const contextMsgs = allUnsynced.filter((m) => m.id !== lastHuman.id);
+            const queueStartedAt = Date.now();
+            const sessionKey = await this.ensureSession(chatId);
+            console.log(`[${this.config.name}] Sending ${humanUnsynced.length} trigger(s) to OpenClaw for ${chatId.slice(-8)} (context=${contextMsgs.length})`);
+            // Update reactions: queued messages → sent (GET/了解)
+            const pendingAcks = this.pendingAckMessages.get(chatId) || [];
+            for (const ack of pendingAcks) {
+                if (ack.emoji !== "Get") {
+                    await this.removeReaction(ack.messageId, ack.emoji).catch(() => { });
+                    await this.addReaction(ack.messageId, "Get").catch(() => { });
+                    ack.emoji = "Get";
+                }
+            }
+            try {
+                const reply = await this.openclawClient.chatSendWithContext({
+                    sessionKey,
+                    unsyncedMessages: contextMsgs,
+                    currentMessage: lastHuman.content,
+                    currentSenderName: lastHuman.senderName,
+                    deliver: false,
+                    // Keep bridge UX responsive; long agent/tool loops should surface a clear failure
+                    // instead of leaving reactions stuck forever.
+                    timeoutMs: 600000,
+                });
+                console.log(`[${this.config.name}] OpenClaw reply collected for ${chatId.slice(-8)} in ${Date.now() - queueStartedAt}ms`);
+                // Mark everything up to now as synced
+                const maxId = Math.max(...allUnsynced.map((m) => m.id || 0));
+                this.store.markSynced(this.config.name, chatId, maxId);
+                this.store.clearPendingTriggers(this.config.name, chatId, maxId);
+                const trimmedReply = reply.trim();
+                const shouldReply = trimmedReply.length > 0 && trimmedReply.toUpperCase() !== "NO_REPLY";
+                // Record bot reply only if it is user-visible/context-worthy.
+                if (shouldReply) {
+                    const replyId = this.store.insert({
+                        chatId,
+                        messageId: `self-${this.config.name}-${Date.now()}`,
+                        senderType: "bot",
+                        senderName: this.config.name,
+                        content: reply,
+                        timestamp: Date.now(),
+                    });
+                    if (replyId > 0)
+                        this.store.markSynced(this.config.name, chatId, replyId);
+                }
+                // Wait for all pending tool event messages to be delivered first
+                const toolSends = this.pendingToolSends.get(chatId) || [];
+                if (toolSends.length > 0) {
+                    await Promise.allSettled(toolSends);
+                    this.pendingToolSends.set(chatId, []);
+                }
+                // Reply to the last human message on Feishu (ordered after tool msgs)
+                // Skip empty replies and explicit NO_REPLY responses
+                if (shouldReply && lastHuman.messageId) {
+                    if (triggerId && this.store.hasDeliveredReply(this.config.name, chatId, triggerId)) {
+                        console.warn(`[${this.config.name}] Reply already delivered, skip duplicate for ${chatId.slice(-8)} msgId=${triggerId}`);
+                    }
+                    else {
+                        await this.sendOrdered(chatId, async () => {
+                            try {
+                                await this.replyMessage(lastHuman.messageId, reply);
+                            }
+                            catch (err) {
+                                // Reply can fail for historical messages sent before this bot joined the chat
+                                // (Feishu 230002: Bot/User can NOT be out of the chat). Fall back to a normal
+                                // chat message so queue processing still completes.
+                                console.warn(`[${this.config.name}] replyMessage failed, fallback to sendMessage:`, err.message);
+                                await this.sendMessage(chatId, reply);
+                            }
+                            if (triggerId)
+                                this.store.markDeliveredReply(this.config.name, chatId, triggerId, lastHuman.messageId);
+                        });
+                    }
+                }
+                console.log(`[${this.config.name}] [${new Date().toISOString()}] ${shouldReply ? 'Replied' : 'Skipped (empty/NO_REPLY)'} (${reply.length} chars)`);
+                // Replace ack reactions with DONE for all pending messages in this chat
+                const pendingAcks = this.pendingAckMessages.get(chatId) || [];
+                for (const ack of pendingAcks) {
+                    await this.removeReaction(ack.messageId, ack.emoji).catch(() => { });
+                    await this.addReaction(ack.messageId, "DONE").catch(() => { });
+                }
+                this.pendingAckMessages.set(chatId, []);
+            }
+            catch (err) {
+                console.error(`[${this.config.name}] processQueue error:`, err);
+                break;
+            }
+            finally {
+                this.busyChats.set(chatId, 0);
+            }
+            // Check if more messages arrived while we were busy
+            // Small delay to let any in-flight messages settle
+            await new Promise((r) => setTimeout(r, 200));
+        }
+    }
+    shouldRespond(chatType, message, isBot, chatId, rawText) {
+        if (chatType === "p2p")
+            return !isBot;
+        const mentions = message.mentions || [];
+        // Bot messages: only respond if this bot is mentioned
+        if (isBot) {
+            return this.isMentioned(mentions);
+        }
+        // @all in text: all bots respond
+        if (rawText && (rawText.includes("@_all") || rawText.includes("@all")))
+            return true;
+        // Check if this bot is explicitly mentioned
+        if (this.isMentioned(mentions))
+            return true;
+        // Check if any other bot is mentioned (not us) — don't respond
+        const anyBotMentioned = mentions.some((m) => {
+            for (const bot of FeishuBot.allBots.values()) {
+                if (m.id?.app_id === bot.config.appId)
+                    return true;
+                if (bot.botOpenId && m.id?.open_id === bot.botOpenId)
+                    return true;
+            }
+            return false;
+        });
+        if (anyBotMentioned && !this.isMentioned(mentions))
+            return false;
+        // No bot mentioned: check free discussion mode
+        if (chatId) {
+            const chatInfo = this.store.getChatInfo(chatId);
+            if (chatInfo?.freeDiscussion)
+                return true;
+        }
+        // Default: don't respond without @
+        return false;
+    }
+    isMentioned(mentions) {
+        return mentions.some((m) => {
+            // @ this specific bot
+            if (m.id?.app_id === this.config.appId)
+                return true;
+            if (this.botOpenId && m.id?.open_id === this.botOpenId)
+                return true;
+            // Feishu may provide only a display name in some mention payloads.
+            // Use this only as a fallback; open_id/app_id checks above remain primary.
+            if (typeof m.name === "string") {
+                const normalizedName = m.name.toLowerCase();
+                const normalizedConfigName = this.config.name.toLowerCase();
+                if (normalizedName === normalizedConfigName || normalizedName.includes(`（${normalizedConfigName}）`) || normalizedName.includes(`(${normalizedConfigName})`))
+                    return true;
+            }
+            // @all / @ 所有人 is handled by raw text gating, not by direct-bot mention matching.
+            if (m.key === "all" || m.key === "@_all" || m.id?.user_id === "all" || m.id?.open_id === "all" || m.name === "所有人")
+                return false;
+            return false;
+        });
+    }
+    resolveBotName(sender) {
+        const openId = sender?.sender_id?.open_id;
+        if (openId) {
+            const bot = FeishuBot.findByOpenId(openId);
+            if (bot)
+                return bot.config.name;
+        }
+        return null;
+    }
+    resolveHumanName(sender) {
+        return sender?.sender_id?.open_id || null;
+    }
+    cleanMentions(text) {
+        return text.replace(/@_user_\d+/g, "").trim();
+    }
+    async replyMessage(messageId, text) {
+        // Use interactive card for markdown rendering
+        const card = {
+            elements: [
+                {
+                    tag: "markdown",
+                    content: text,
+                },
+            ],
+        };
+        try {
+            await this.client.im.message.reply({
+                path: { message_id: messageId },
+                data: {
+                    content: JSON.stringify(card),
+                    msg_type: "interactive",
+                },
+            });
+        }
+        catch {
+            // Fallback to plain text if card fails
+            await this.client.im.message.reply({
+                path: { message_id: messageId },
+                data: {
+                    content: JSON.stringify({ text }),
+                    msg_type: "text",
+                },
+            });
+        }
+    }
+    /**
+     * Send a proactive message to a chat (not a reply).
+     */
+    async sendMessage(chatId, text) {
+        const card = {
+            elements: [
+                {
+                    tag: "markdown",
+                    content: text,
+                },
+            ],
+        };
+        try {
+            await this.client.im.message.create({
+                params: { receive_id_type: "chat_id" },
+                data: {
+                    receive_id: chatId,
+                    content: JSON.stringify(card),
+                    msg_type: "interactive",
+                },
+            });
+        }
+        catch {
+            // Fallback to plain text
+            await this.client.im.message.create({
+                params: { receive_id_type: "chat_id" },
+                data: {
+                    receive_id: chatId,
+                    content: JSON.stringify({ text }),
+                    msg_type: "text",
+                },
+            });
+        }
+    }
+    /**
+     * Enqueue a message send to guarantee ordering per chat.
+     * All sends for a chat are serialized through this.
+     */
+    sendOrdered(chatId, fn) {
+        const prev = this.sendQueue.get(chatId) || Promise.resolve();
+        const next = prev.then(fn, fn); // run even if previous failed
+        this.sendQueue.set(chatId, next);
+        return next;
+    }
+    /**
+     * Add a reaction (emoji) to a message.
+     */
+    async addReaction(messageId, emojiType) {
+        const resp = await this.client.im.messageReaction.create({
+            path: { message_id: messageId },
+            data: {
+                reaction_type: { emoji_type: emojiType },
+            },
+        });
+        return resp.data?.reaction_id;
+    }
+    /**
+     * Remove a reaction by emoji type from a message.
+     * Finds the bot's own reaction of that type and deletes it.
+     */
+    async removeReaction(messageId, emojiType) {
+        try {
+            const resp = await this.client.im.messageReaction.list({
+                path: { message_id: messageId },
+                params: { reaction_type: emojiType },
+            });
+            const items = resp.data?.items || [];
+            for (const item of items) {
+                if (item.reaction_id) {
+                    await this.client.im.messageReaction.delete({
+                        path: { message_id: messageId, reaction_id: item.reaction_id },
+                    });
+                    break;
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    /**
+     * Handle /status command: show current session info.
+     */
+    async handleStatusCommand(chatId, chatType, messageId) {
+        const sessionKey = this.getSessionKey(chatId);
+        const chatInfo = this.store.getChatInfo(chatId);
+        const msgCount = this.store.getMessageCount(chatId);
+        let session = null;
+        try {
+            const resp = await this.openclawClient.getSessionInfo(sessionKey);
+            session = resp?.session;
+        }
+        catch {
+            // session may not exist yet
+        }
+        // Always show the configured model — session.model may show gateway-injected internal name
+        const model = this.config.model;
+        const totalTokens = session?.totalTokens || 0;
+        const contextTokens = session?.contextTokens || 0;
+        const inputTokens = session?.inputTokens || 0;
+        const outputTokens = session?.outputTokens || 0;
+        const usedPct = contextTokens > 0 ? Math.round((totalTokens / contextTokens) * 100) : 0;
+        const tokenNote = !session?.totalTokensFresh ? " (待首次对话后更新)" : "";
+        const fmtK = (n) => n >= 1000 ? `${(n / 1000).toFixed(1)}K` : `${n}`;
+        const chatLabel = chatInfo?.chatName || (chatType === "p2p" ? "私聊" : chatId.slice(-8));
+        const sessionExists = session ? "✅ 活跃" : "⏳ 未初始化";
+        const status = session?.status || "unknown";
+        const verboseStatus = this.store.getBotVerbose(this.config.name, chatId) ? "🔊 开启" : "🔇 关闭";
+        const freeStatus = chatInfo?.freeDiscussion ? "🔓 开启" : "🔒 关闭";
+        const statusText = [
+            `📊 ${this.config.name} Bot Status`,
+            `━━━━━━━━━━━━━━━━━━`,
+            `🤖 Bot: ${this.config.name}`,
+            `🧠 模型: ${model}`,
+            `💬 会话: ${chatLabel} (${chatType === "p2p" ? "私聊" : "群聊"})`,
+            `📋 Session: ${sessionExists} | ${status}`,
+            `━━━━━━━━━━━━━━━━━━`,
+            `📝 本地消息: ${msgCount} 条`,
+            `🧮 上下文: ${fmtK(totalTokens)} / ${fmtK(contextTokens)} (${usedPct}%)${tokenNote}`,
+            `📥 输入: ${fmtK(inputTokens)} | 📤 输出: ${fmtK(outputTokens)}`,
+            `🔧 Verbose: ${verboseStatus}`,
+            `💬 Free Discussion: ${freeStatus}`,
+        ].join("\n");
+        await this.replyMessage(messageId, statusText);
+    }
+    /**
+     * Handle /compact command: compress session context.
+     */
+    async handleCompactCommand(chatId, messageId) {
+        const sessionKey = this.getSessionKey(chatId);
+        try {
+            await this.openclawClient.compactSession(sessionKey);
+            await this.replyMessage(messageId, `✅ Session 已压缩`);
+        }
+        catch (err) {
+            await this.replyMessage(messageId, `❌ 压缩失败: ${err.message}`);
+        }
+    }
+    /**
+     * Handle /reset command: fire sessions.reset and confirm.
+     * sessions.reset doesn't return a WS response, so we fire-and-forget
+     * then verify via describe.
+     */
+    async handleResetCommand(chatId, messageId) {
+        const sessionKey = this.getSessionKey(chatId);
+        try {
+            // Fire reset (no response expected)
+            this.openclawClient.resetSession(sessionKey).catch(() => { });
+            // Wait a moment for it to take effect
+            await new Promise((r) => setTimeout(r, 2000));
+            // Re-init session
+            this.initializedSessions.delete(sessionKey);
+            await this.ensureSession(chatId);
+            await this.replyMessage(messageId, `✅ Session 已重置\n模型: ${this.config.model}`);
+        }
+        catch (err) {
+            await this.replyMessage(messageId, `❌ 重置失败: ${err.message}`);
+        }
+    }
+    /**
+     * Fetch chat info (name, type, members) via Feishu API and cache in SQLite.
+     * Called once per chat on first message.
+     */
+    async fetchAndCacheChatInfo(chatId, chatType) {
+        const existing = this.store.getChatInfo(chatId);
+        // Refresh at most once per hour
+        if (existing && Date.now() - existing.updatedAt < 3600_000)
+            return;
+        try {
+            if (chatType === "p2p") {
+                // For p2p, we don't have a group name or member list from chat API
+                this.store.upsertChatInfo({
+                    chatId,
+                    chatType: "p2p",
+                    chatName: "私聊",
+                    members: "",
+                    memberNames: "",
+                    ownerBot: this.config.name,
+                    freeDiscussion: this.store.getChatInfo(chatId)?.freeDiscussion || false,
+                    verbose: this.store.getChatInfo(chatId)?.verbose || false,
+                    updatedAt: Date.now(),
+                });
+                return;
+            }
+            // Fetch group info
+            const chatResp = await this.client.im.chat.get({
+                path: { chat_id: chatId },
+            });
+            const chatName = chatResp.data?.name || "";
+            // Fetch members
+            let members = [];
+            let memberNames = [];
+            try {
+                const membersResp = await this.client.im.chatMembers.get({
+                    path: { chat_id: chatId },
+                    params: { member_id_type: "open_id", page_size: 100 },
+                });
+                const items = membersResp.data?.items || [];
+                for (const item of items) {
+                    if (item.member_id)
+                        members.push(item.member_id);
+                    if (item.name)
+                        memberNames.push(item.name);
+                }
+            }
+            catch {
+                // Some bots may lack permission to list members
+            }
+            this.store.upsertChatInfo({
+                chatId,
+                chatType: "group",
+                chatName,
+                members: members.join(","),
+                memberNames: memberNames.join(","),
+                ownerBot: "", // group chats are shared, no owner
+                freeDiscussion: this.store.getChatInfo(chatId)?.freeDiscussion || false,
+                verbose: this.store.getChatInfo(chatId)?.verbose || false,
+                updatedAt: Date.now(),
+            });
+            console.log(`[${this.config.name}] Cached chat info: ${chatName} (${chatId.slice(-8)})`);
+        }
+        catch (err) {
+            console.warn(`[${this.config.name}] Failed to fetch chat info:`, err.message);
+        }
+    }
+    /**
+     * Send a model-drift notification to the affected chat.
+     */
+    /**
+     * Download a resource (image/file/audio) from a Feishu message.
+     * Returns the local file path.
+     */
+    async downloadResource(messageId, fileKey, type) {
+        const { mkdirSync, writeFileSync } = await import("fs");
+        const { resolve } = await import("path");
+        const dir = resolve(process.cwd(), "data", "media");
+        mkdirSync(dir, { recursive: true });
+        const resp = await this.client.im.messageResource.get({
+            path: { message_id: messageId, file_key: fileKey },
+            params: { type },
+        });
+        const result = resp;
+        const ext = type === "image" ? ".png" : "";
+        const filePath = resolve(dir, `${fileKey}${ext}`);
+        // SDK v1.62+ returns { writeFile, getReadableStream, headers }
+        if (result.writeFile) {
+            await result.writeFile(filePath);
+        }
+        else if (result.data && Buffer.isBuffer(result.data)) {
+            writeFileSync(filePath, result.data);
+        }
+        else {
+            throw new Error("Unsupported response format");
+        }
+        return filePath;
+    }
+    /**
+     * Extract text content from a rich text (post) message.
+     */
+    extractPostText(content) {
+        const parts = [];
+        const title = content.title;
+        if (title)
+            parts.push(title);
+        const body = content.content || [];
+        for (const paragraph of body) {
+            if (!Array.isArray(paragraph))
+                continue;
+            for (const element of paragraph) {
+                if (element.tag === "text" && element.text) {
+                    parts.push(element.text);
+                }
+                else if (element.tag === "a" && element.text) {
+                    parts.push(`${element.text}(${element.href || ''})`);
+                }
+                else if (element.tag === "at" && element.user_name) {
+                    parts.push(`@${element.user_name}`);
+                }
+                else if (element.tag === "img" && element.image_key) {
+                    parts.push(`[Image: ${element.image_key}]`);
+                }
+            }
+        }
+        return this.cleanMentions(parts.join(" "));
+    }
+    async notifyModelDrift(chatId, _sessionKey) {
+        try {
+            const chatInfo = this.store.getChatInfo(chatId);
+            const chatLabel = chatInfo?.chatName || chatId.slice(-8);
+            await this.client.im.message.create({
+                params: { receive_id_type: "chat_id" },
+                data: {
+                    receive_id: chatId,
+                    content: JSON.stringify({
+                        text: `⚠️ 模型漂移已自动纠正\n期望: ${this.config.model}\n已恢复`,
+                    }),
+                    msg_type: "text",
+                },
+            });
+            console.log(`[${this.config.name}] Drift notification sent to ${chatLabel}`);
+        }
+        catch (err) {
+            console.warn(`[${this.config.name}] Failed to notify drift:`, err.message);
+        }
+    }
+}