openclaw-lark-multi-agent 1.0.0 → 1.0.2

package/dist/feishu-bot.d.ts

@@ -31,6 +31,8 @@ export declare class FeishuBot {
     private sendQueue;
     /** Per-chat delayed runtime failure notifications, canceled if a real reply arrives. */
     private delayedFailureTimers;
+    /** Last time a real assistant-visible reply was successfully handed to the delivery pipeline. */
+    private lastRealDeliveryAt;
     private adminOpenId;
     private static allBots;
     constructor(config: BotConfig, openclawClient: OpenClawClient, store: MessageStore, adminOpenId?: string);
@@ -96,8 +98,10 @@ export declare class FeishuBot {
     private validateBridgeAttachmentPath;
     private inferFeishuFileType;
     private isImagePath;
+    private errorSummary;
     private createFeishuDocFromMarkdown;
     private sendBridgeAttachment;
+    private sendBridgeFileAttachment;
     /**
      * Send a proactive message to a chat (not a reply).
      */

package/dist/feishu-bot.js

@@ -1,11 +1,12 @@
 import * as lark from "@larksuiteoapi/node-sdk";
 import { existsSync, readFileSync, statSync } from "fs";
 import { basename, extname, resolve } from "path";
-import { getBridgeAttachmentsDir } from "./paths.js";
+import { getBridgeAttachmentAllowedRoots, getBridgeAttachmentsDir } from "./paths.js";
 import { buildFeishuCardElements } from "./markdown.js";
 import { discussionManager } from "./discussion-manager.js";
 const MAX_BOT_STREAK = 10;
 const BRIDGE_ATTACHMENTS_DIR = getBridgeAttachmentsDir();
+const BRIDGE_ATTACHMENT_ALLOWED_ROOTS = getBridgeAttachmentAllowedRoots();
 /**
  * Manages a single Feishu bot instance.
  *
@@ -36,6 +37,8 @@ export class FeishuBot {
     sendQueue = new Map();
     /** Per-chat delayed runtime failure notifications, canceled if a real reply arrives. */
     delayedFailureTimers = new Map();
+    /** Last time a real assistant-visible reply was successfully handed to the delivery pipeline. */
+    lastRealDeliveryAt = new Map();
     adminOpenId;
     static allBots = new Map();
     constructor(config, openclawClient, store, adminOpenId) {
@@ -213,22 +216,26 @@ export class FeishuBot {
     async drainOnStartup() {
         try {
             const chats = this.store.getAllChatInfo();
+            const drainTasks = [];
             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);
+                    // Do not let one slow/stuck chat block startup drain for all other chats.
+                    drainTasks.push(this.processQueue(chat.chatId).catch((err) => {
+                        console.warn(`[${this.config.name}] Startup drain failed for ${chat.chatId.slice(-8)}:`, err.message);
+                    }));
                 }
             }
+            await Promise.allSettled(drainTasks);
         }
         catch (err) {
             console.warn(`[${this.config.name}] Startup drain failed:`, err.message);
@@ -272,8 +279,11 @@ export class FeishuBot {
             }
             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))
+            // --- Dedup: atomically claim this message for this bot before any await.
+            // Feishu/WebSocket can deliver the same event more than once; a separate
+            // has-then-mark sequence races and can send the same user message into
+            // OpenClaw twice.
+            if (!this.store.tryMarkBotProcessed(this.config.name, messageId))
                 return;
             // --- Cache chat info (lazy, at most once per hour) ---
             await this.fetchAndCacheChatInfo(chatId, chatType);
@@ -378,8 +388,6 @@ export class FeishuBot {
             });
             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.
@@ -623,10 +631,17 @@ export class FeishuBot {
     }
     async processQueueInner(chatId) {
         while (true) {
-            const allUnsynced = this.store.getUnsyncedMessages(this.config.name, chatId);
+            const unsyncedMessages = this.store.getUnsyncedMessages(this.config.name, chatId);
+            const pendingMessages = this.store.getPendingTriggerMessages(this.config.name, chatId);
+            const messageById = new Map();
+            for (const msg of [...unsyncedMessages, ...pendingMessages]) {
+                if (msg.id)
+                    messageById.set(msg.id, msg);
+            }
+            const allUnsynced = Array.from(messageById.values()).sort((a, b) => a.timestamp - b.timestamp);
             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.
+            // Only proceed if there are pending human messages that should actively trigger this bot.
+            // Pending triggers are included even if a later bridge command has advanced sync_state.
             const humanUnsynced = allUnsynced.filter((m) => m.senderType === "human" && m.id && pendingTriggerIds.has(m.id));
             if (humanUnsynced.length === 0) {
                 break;
@@ -920,6 +935,11 @@ export class FeishuBot {
         this.delayedFailureTimers.delete(chatId);
     }
     scheduleDelayedFailure(chatId, replyToMessageId, text, triggerId) {
+        const lastRealDelivery = this.lastRealDeliveryAt.get(chatId) || 0;
+        if (Date.now() - lastRealDelivery < 90_000) {
+            console.log(`[${this.config.name}] Suppressed delayed runtime failure for ${chatId.slice(-8)} because a real reply was delivered recently`);
+            return;
+        }
         this.cancelDelayedFailure(chatId);
         const timer = setTimeout(() => {
             this.delayedFailureTimers.delete(chatId);
@@ -976,6 +996,9 @@ export class FeishuBot {
         if (deliveryId === null)
             return;
         await this.dispatchPendingDeliveries(chatId, replyToMessageId);
+        if (sourceType === "assistant_visible" && (text.trim() || attachments.length > 0) && text.trim().toUpperCase() !== "NO_REPLY" && !this.isRuntimeFailureText(text.trim())) {
+            this.lastRealDeliveryAt.set(chatId, Date.now());
+        }
     }
     async dispatchPendingDeliveries(chatId, replyToMessageId) {
         const pending = this.store.getPendingDeliveries(chatId, this.config.name, 50);
@@ -1009,6 +1032,17 @@ export class FeishuBot {
                 catch (err) {
                     if (item.id)
                         this.store.markDeliveryFailed(item.id);
+                    const errorText = `⚠️ 附件发送失败：${this.errorSummary(err)}`;
+                    const replyTarget = item.replyToMessageId || replyToMessageId;
+                    try {
+                        if (replyTarget)
+                            await this.replyMessage(replyTarget, errorText);
+                        else
+                            await this.sendMessage(chatId, errorText);
+                    }
+                    catch (notifyErr) {
+                        console.warn(`[${this.config.name}] Failed to notify attachment delivery error:`, this.errorSummary(notifyErr));
+                    }
                     throw err;
                 }
             });
@@ -1123,9 +1157,9 @@ export class FeishuBot {
     }
     validateBridgeAttachmentPath(filePath) {
         const resolvedPath = resolve(filePath);
-        const allowedRoot = resolve(BRIDGE_ATTACHMENTS_DIR);
-        if (!(resolvedPath === allowedRoot || resolvedPath.startsWith(allowedRoot + "/"))) {
-            throw new Error(`Attachment path outside allowed directory: ${resolvedPath}`);
+        const isAllowed = BRIDGE_ATTACHMENT_ALLOWED_ROOTS.some((root) => resolvedPath === root || resolvedPath.startsWith(root + "/"));
+        if (!isAllowed) {
+            throw new Error(`Attachment path outside allowed directories (${BRIDGE_ATTACHMENT_ALLOWED_ROOTS.join(", ")}): ${resolvedPath}`);
         }
         if (!existsSync(resolvedPath))
             throw new Error(`Attachment file not found: ${resolvedPath}`);
@@ -1153,6 +1187,12 @@ export class FeishuBot {
     isImagePath(filePath) {
         return [".jpg", ".jpeg", ".png", ".webp", ".gif", ".tiff", ".bmp", ".ico"].includes(extname(filePath).toLowerCase());
     }
+    errorSummary(err) {
+        const data = err?.response?.data || err?.data;
+        const code = data?.code ? `code=${data.code} ` : "";
+        const msg = data?.msg || data?.message || err?.message || String(err);
+        return `${code}${msg}`.slice(0, 800);
+    }
     async createFeishuDocFromMarkdown(filePath) {
         const rawTitle = basename(filePath).replace(/\.[^.]+$/, "").trim() || "Markdown Document";
         const markdown = readFileSync(filePath, "utf8");
@@ -1182,11 +1222,19 @@ export class FeishuBot {
         const filePath = this.validateBridgeAttachmentPath(attachment.path);
         const type = attachment.type || (this.isImagePath(filePath) ? "image" : "file");
         if (type === "document" && extname(filePath).toLowerCase() === ".md") {
-            const doc = await this.createFeishuDocFromMarkdown(filePath);
-            const caption = attachment.caption?.trim() || `飞书文档：${doc.title}`;
-            await this.sendMessage(chatId, `${caption}
-${doc.url}`);
-            return;
+            try {
+                const doc = await this.createFeishuDocFromMarkdown(filePath);
+                const caption = attachment.caption?.trim() || `飞书文档：${doc.title}`;
+                await this.sendMessage(chatId, `${caption}\n${doc.url}`);
+                return;
+            }
+            catch (err) {
+                console.warn(`[${this.config.name}] Feishu doc conversion failed, falling back to file attachment:`, this.errorSummary(err));
+                const caption = attachment.caption?.trim();
+                await this.sendMessage(chatId, `${caption ? `${caption}\n` : ""}飞书文档创建失败，已改为 Markdown 文件附件发送。`);
+                await this.sendBridgeFileAttachment(chatId, filePath);
+                return;
+            }
         }
         if (attachment.caption?.trim())
             await this.sendMessage(chatId, attachment.caption.trim());
@@ -1209,6 +1257,9 @@ ${doc.url}`);
             });
             return;
         }
+        await this.sendBridgeFileAttachment(chatId, filePath);
+    }
+    async sendBridgeFileAttachment(chatId, filePath) {
         const uploaded = await this.client.im.file.create({
             data: {
                 file_type: this.inferFeishuFileType(filePath),

package/dist/message-store.d.ts

@@ -55,6 +55,7 @@ export declare class MessageStore {
     isMessageRecalled(messageId: string): boolean;
     markPendingTrigger(botName: string, chatId: string, messageRowId: number): void;
     getPendingTriggerIds(botName: string, chatId: string): Set<number>;
+    getPendingTriggerMessages(botName: string, chatId: string): ChatMessage[];
     clearPendingTriggers(botName: string, chatId: string, upToId: number): void;
     clearPendingTrigger(botName: string, chatId: string, messageRowId: number): void;
     hasDeliveredReply(botName: string, chatId: string, triggerMessageRowId: number): boolean;
@@ -118,5 +119,6 @@ export declare class MessageStore {
      * Mark a message as processed by a specific bot.
      */
     markBotProcessed(botName: string, messageId: string): void;
+    tryMarkBotProcessed(botName: string, messageId: string): boolean;
     close(): void;
 }

package/dist/message-store.js

@@ -260,6 +260,24 @@ export class MessageStore {
     `).all(botName, chatId);
         return new Set(rows.map((r) => Number(r.message_row_id)));
     }
+    getPendingTriggerMessages(botName, chatId) {
+        const rows = this.db.prepare(`
+      SELECT messages.* FROM pending_triggers
+      JOIN messages ON messages.id = pending_triggers.message_row_id
+      LEFT JOIN recalled_messages ON recalled_messages.message_id = messages.message_id
+      WHERE pending_triggers.bot_name = ? AND pending_triggers.chat_id = ? AND recalled_messages.message_id IS NULL
+      ORDER BY messages.timestamp ASC
+    `).all(botName, chatId);
+        return rows.map((r) => ({
+            id: r.id,
+            chatId: r.chat_id,
+            messageId: r.message_id,
+            senderType: r.sender_type,
+            senderName: r.sender_name,
+            content: r.content,
+            timestamp: r.timestamp,
+        }));
+    }
     clearPendingTriggers(botName, chatId, upToId) {
         this.db.prepare(`
       DELETE FROM pending_triggers
@@ -607,6 +625,10 @@ export class MessageStore {
     markBotProcessed(botName, messageId) {
         this.db.prepare(`INSERT OR IGNORE INTO processed_events (bot_name, message_id) VALUES (?, ?)`).run(botName, messageId);
     }
+    tryMarkBotProcessed(botName, messageId) {
+        const result = this.db.prepare(`INSERT OR IGNORE INTO processed_events (bot_name, message_id) VALUES (?, ?)`).run(botName, messageId);
+        return result.changes === 1;
+    }
     close() {
         this.db.close();
     }

package/dist/openclaw-client.js

@@ -578,7 +578,7 @@ export class OpenClawClient {
             return "";
         return `
 
-[Bridge attachment capability hint: This is an OpenClaw Lark Multi-Agent bridge session. You cannot send Feishu files/images directly from inside OpenClaw. Do NOT call message, sessions_send, Feishu tools, or proactive send tools for this request. If the user asks you to send an image/file/document to Feishu, only create the local file under ${BRIDGE_ATTACHMENTS_DIR}/ and include this exact marker at the very end of your final reply (do not explain or expose the marker as normal text): <LMA_BRIDGE_ATTACHMENTS>{"attachments":[{"type":"image|file|document","path":"/absolute/path","caption":"optional"}]}</LMA_BRIDGE_ATTACHMENTS>. The bridge layer will parse this marker and send the attachment. Use type=image for images; use type=document for Markdown documents (.md) so the bridge creates a Feishu cloud document and sends its link; use type=file for other ordinary files.]`;
+[Bridge attachment capability hint: This is an OpenClaw Lark Multi-Agent bridge session. You cannot send Feishu files/images directly from inside OpenClaw. Do NOT call message, sessions_send, Feishu tools, or proactive send tools for this request. If the user asks you to send an image/file/document to Feishu, prefer creating new files under ${BRIDGE_ATTACHMENTS_DIR}/; existing files under the OpenClaw workspace are also allowed. Include this exact marker at the very end of your final reply (do not explain or expose the marker as normal text): <LMA_BRIDGE_ATTACHMENTS>{"attachments":[{"type":"image|file|document","path":"/absolute/path","caption":"optional"}]}</LMA_BRIDGE_ATTACHMENTS>. The bridge layer will parse this marker and send the attachment. Use type=image for images; use type=document for Markdown documents (.md) so the bridge creates a Feishu cloud document and sends its link; use type=file for other ordinary files.]`;
     }
     /**
      * Build and send a context catch-up message followed by the actual message.

package/dist/paths.d.ts

@@ -4,3 +4,5 @@
  */
 export declare function getStateDir(): string;
 export declare function getBridgeAttachmentsDir(): string;
+export declare function getOpenClawWorkspaceDir(): string;
+export declare function getBridgeAttachmentAllowedRoots(): string[];

package/dist/paths.js

@@ -10,3 +10,16 @@ export function getStateDir() {
 export function getBridgeAttachmentsDir() {
     return resolve(process.env.OPENCLAW_LARK_MULTI_AGENT_ATTACHMENTS_DIR || resolve(getStateDir(), "attachments"));
 }
+export function getOpenClawWorkspaceDir() {
+    return resolve(process.env.OPENCLAW_WORKSPACE_DIR || resolve(homedir(), ".openclaw/workspace"));
+}
+export function getBridgeAttachmentAllowedRoots() {
+    const roots = [getBridgeAttachmentsDir(), getOpenClawWorkspaceDir()];
+    const extra = process.env.OPENCLAW_LARK_MULTI_AGENT_ATTACHMENT_ALLOW_ROOTS || "";
+    for (const part of extra.split(",")) {
+        const trimmed = part.trim();
+        if (trimmed)
+            roots.push(resolve(trimmed));
+    }
+    return Array.from(new Set(roots.map((root) => resolve(root))));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-lark-multi-agent",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {