openclaw-lark-multi-agent 0.1.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+export declare function startApp(configPath?: string): Promise<void>;

package/dist/index.js

@@ -0,0 +1,52 @@
+import { loadConfig } from "./config.js";
+import { OpenClawClient } from "./openclaw-client.js";
+import { MessageStore } from "./message-store.js";
+import { FeishuBot } from "./feishu-bot.js";
+import { mkdirSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+export async function startApp(configPath) {
+    const config = loadConfig(configPath);
+    console.log("=== OpenClaw Lark Multi-Agent ===");
+    console.log(`OpenClaw: ${config.openclaw.baseUrl}`);
+    console.log(`Bots: ${config.bots.map((b) => `${b.name}(${b.model})`).join(", ")}`);
+    console.log("");
+    // Init data dir & store. Runtime state should live next to config by default,
+    // not next to deployable program files. Override with LMA_DATA_DIR if needed.
+    const resolvedConfigPath = configPath ? resolve(configPath) : resolve(process.cwd(), "config.json");
+    const dataDir = process.env.LMA_DATA_DIR
+        ? resolve(process.env.LMA_DATA_DIR)
+        : resolve(dirname(resolvedConfigPath), "data");
+    mkdirSync(dataDir, { recursive: true });
+    console.log(`Data dir: ${dataDir}`);
+    const store = new MessageStore(resolve(dataDir, "messages.db"));
+    // Connect to OpenClaw Gateway via WebSocket
+    const openclawClient = new OpenClawClient(config.openclaw);
+    await openclawClient.connect();
+    // Two-phase startup: register all bots first, then start WS connections
+    const bots = [];
+    for (const botConfig of config.bots) {
+        const bot = new FeishuBot(botConfig, openclawClient, store, config.adminOpenId);
+        bots.push(bot);
+        bot.register(); // Phase 1: register to allBots map
+    }
+    for (const bot of bots) {
+        await bot.start(); // Phase 2: start WS connections
+    }
+    console.log(`\nAll ${bots.length} bots started. Waiting for messages...`);
+    // Graceful shutdown
+    const shutdown = () => {
+        console.log("\nShutting down...");
+        openclawClient.disconnect();
+        store.close();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}
+if (process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1])) {
+    startApp(process.argv[2]).catch((err) => {
+        console.error("Fatal error:", err);
+        process.exit(1);
+    });
+}

package/dist/message-store.d.ts

@@ -0,0 +1,80 @@
+export interface ChatInfo {
+    chatId: string;
+    chatType: "p2p" | "group";
+    chatName: string;
+    /** Comma-separated member open_ids */
+    members: string;
+    /** Comma-separated member names */
+    memberNames: string;
+    /** Which bot owns this chat (for p2p isolation) */
+    ownerBot: string;
+    /** Free discussion mode (group chat: all bots respond without @) */
+    freeDiscussion: boolean;
+    verbose: boolean;
+    updatedAt: number;
+}
+export interface ChatMessage {
+    id?: number;
+    chatId: string;
+    messageId: string;
+    senderType: "human" | "bot";
+    senderName: string;
+    content: string;
+    timestamp: number;
+}
+export declare class MessageStore {
+    private db;
+    constructor(dbPath?: string);
+    private init;
+    /**
+     * Insert a message. Returns the auto-increment id, or -1 if duplicate.
+     */
+    insert(msg: ChatMessage): number;
+    getMessageId(messageId: string): number | null;
+    markPendingTrigger(botName: string, chatId: string, messageRowId: number): void;
+    getPendingTriggerIds(botName: string, chatId: string): Set<number>;
+    clearPendingTriggers(botName: string, chatId: string, upToId: number): void;
+    hasDeliveredReply(botName: string, chatId: string, triggerMessageRowId: number): boolean;
+    markDeliveredReply(botName: string, chatId: string, triggerMessageRowId: number, replyMessageId?: string): void;
+    /**
+     * Get messages that haven't been synced to a bot's session yet.
+     * Returns messages ordered by timestamp ascending.
+     */
+    getUnsyncedMessages(botName: string, chatId: string, maxCount?: number): ChatMessage[];
+    /**
+     * Mark all messages up to (and including) the given id as synced for a bot.
+     */
+    markSynced(botName: string, chatId: string, upToId: number): void;
+    /**
+     * Get recent messages for a chat, ordered by timestamp ascending.
+     */
+    getRecent(chatId: string, maxCount?: number): ChatMessage[];
+    /**
+     * Count consecutive bot messages at the tail of a chat.
+     */
+    getBotStreak(chatId: string): number;
+    upsertChatInfo(info: ChatInfo): void;
+    setFreeDiscussion(chatId: string, on: boolean): void;
+    setVerbose(chatId: string, verbose: boolean): void;
+    setBotVerbose(botName: string, chatId: string, verbose: boolean): void;
+    getBotVerbose(botName: string, chatId: string): boolean;
+    getChatInfo(chatId: string): ChatInfo | null;
+    getAllChatInfo(): ChatInfo[];
+    /**
+     * Check if a message already exists in the store.
+     */
+    hasMessage(messageId: string): boolean;
+    /**
+     * Get total message count for a chat.
+     */
+    getMessageCount(chatId: string): number;
+    /**
+     * Check if a specific bot has already processed a message.
+     */
+    hasBotProcessed(botName: string, messageId: string): boolean;
+    /**
+     * Mark a message as processed by a specific bot.
+     */
+    markBotProcessed(botName: string, messageId: string): void;
+    close(): void;
+}

package/dist/message-store.js

@@ -0,0 +1,333 @@
+import Database from "better-sqlite3";
+import { resolve } from "path";
+import { mkdirSync } from "fs";
+export class MessageStore {
+    db;
+    constructor(dbPath) {
+        const path = dbPath || resolve(process.cwd(), "data", "messages.db");
+        const dir = resolve(path, "..");
+        mkdirSync(dir, { recursive: true });
+        this.db = new Database(path);
+        this.db.pragma("journal_mode = WAL");
+        this.init();
+    }
+    init() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS messages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        chat_id TEXT NOT NULL,
+        message_id TEXT UNIQUE NOT NULL,
+        sender_type TEXT NOT NULL,
+        sender_name TEXT NOT NULL,
+        content TEXT NOT NULL,
+        timestamp INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_messages_chat_ts ON messages(chat_id, timestamp);
+
+      CREATE TABLE IF NOT EXISTS chat_info (
+        chat_id TEXT PRIMARY KEY,
+        chat_type TEXT NOT NULL DEFAULT 'group',
+        chat_name TEXT NOT NULL DEFAULT '',
+        members TEXT NOT NULL DEFAULT '',
+        member_names TEXT NOT NULL DEFAULT '',
+        verbose INTEGER NOT NULL DEFAULT 0,
+        updated_at INTEGER NOT NULL DEFAULT 0
+      );
+
+      -- Tracks which messages have been synced to each bot's OpenClaw session.
+      CREATE TABLE IF NOT EXISTS sync_state (
+        bot_name TEXT NOT NULL,
+        chat_id TEXT NOT NULL,
+        last_synced_msg_id INTEGER NOT NULL DEFAULT 0,
+        PRIMARY KEY (bot_name, chat_id)
+      );
+
+      -- Tracks which messages have been processed by each bot (multi-bot dedup).
+      CREATE TABLE IF NOT EXISTS processed_events (
+        bot_name TEXT NOT NULL,
+        message_id TEXT NOT NULL,
+        PRIMARY KEY (bot_name, message_id)
+      );
+
+      -- Tracks messages that should actively trigger a bot reply.
+      -- Other unsynced messages remain local context and are sent only when a trigger arrives.
+      CREATE TABLE IF NOT EXISTS pending_triggers (
+        bot_name TEXT NOT NULL,
+        chat_id TEXT NOT NULL,
+        message_row_id INTEGER NOT NULL,
+        PRIMARY KEY (bot_name, chat_id, message_row_id)
+      );
+
+      -- Tracks replies already delivered for a trigger message.
+      -- Prevents duplicate user-visible replies after restarts/race conditions.
+      CREATE TABLE IF NOT EXISTS delivered_replies (
+        bot_name TEXT NOT NULL,
+        chat_id TEXT NOT NULL,
+        trigger_message_row_id INTEGER NOT NULL,
+        delivered_at INTEGER NOT NULL,
+        reply_message_id TEXT NOT NULL DEFAULT '',
+        PRIMARY KEY (bot_name, chat_id, trigger_message_row_id)
+      );
+
+      -- Per-bot, per-chat settings. A group can contain multiple bots, so settings
+      -- like verbose must not be shared globally at chat level.
+      CREATE TABLE IF NOT EXISTS bot_chat_settings (
+        bot_name TEXT NOT NULL,
+        chat_id TEXT NOT NULL,
+        verbose INTEGER NOT NULL DEFAULT 0,
+        updated_at INTEGER NOT NULL DEFAULT 0,
+        PRIMARY KEY (bot_name, chat_id)
+      );
+    `);
+        // Migration: add verbose column if missing
+        try {
+            this.db.exec(`ALTER TABLE chat_info ADD COLUMN verbose INTEGER NOT NULL DEFAULT 0`);
+        }
+        catch {
+            // Column already exists
+        }
+        // Migration: add owner_bot column if missing
+        try {
+            this.db.exec(`ALTER TABLE chat_info ADD COLUMN owner_bot TEXT NOT NULL DEFAULT ''`);
+        }
+        catch {
+            // Column already exists
+        }
+        // Migration: add free_discussion column if missing
+        try {
+            this.db.exec(`ALTER TABLE chat_info ADD COLUMN free_discussion INTEGER NOT NULL DEFAULT 0`);
+        }
+        catch {
+            // Column already exists
+        }
+    }
+    /**
+     * Insert a message. Returns the auto-increment id, or -1 if duplicate.
+     */
+    insert(msg) {
+        try {
+            const result = this.db.prepare(`
+        INSERT INTO messages (chat_id, message_id, sender_type, sender_name, content, timestamp)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `).run(msg.chatId, msg.messageId, msg.senderType, msg.senderName, msg.content, msg.timestamp);
+            return Number(result.lastInsertRowid);
+        }
+        catch (err) {
+            if (err.code === "SQLITE_CONSTRAINT_UNIQUE")
+                return -1;
+            throw err;
+        }
+    }
+    getMessageId(messageId) {
+        const row = this.db.prepare(`SELECT id FROM messages WHERE message_id = ?`).get(messageId);
+        return row?.id || null;
+    }
+    markPendingTrigger(botName, chatId, messageRowId) {
+        this.db.prepare(`
+      INSERT OR IGNORE INTO pending_triggers (bot_name, chat_id, message_row_id)
+      VALUES (?, ?, ?)
+    `).run(botName, chatId, messageRowId);
+    }
+    getPendingTriggerIds(botName, chatId) {
+        const rows = this.db.prepare(`
+      SELECT message_row_id FROM pending_triggers
+      WHERE bot_name = ? AND chat_id = ?
+      ORDER BY message_row_id ASC
+    `).all(botName, chatId);
+        return new Set(rows.map((r) => Number(r.message_row_id)));
+    }
+    clearPendingTriggers(botName, chatId, upToId) {
+        this.db.prepare(`
+      DELETE FROM pending_triggers
+      WHERE bot_name = ? AND chat_id = ? AND message_row_id <= ?
+    `).run(botName, chatId, upToId);
+    }
+    hasDeliveredReply(botName, chatId, triggerMessageRowId) {
+        const row = this.db.prepare(`
+      SELECT 1 FROM delivered_replies
+      WHERE bot_name = ? AND chat_id = ? AND trigger_message_row_id = ?
+    `).get(botName, chatId, triggerMessageRowId);
+        return !!row;
+    }
+    markDeliveredReply(botName, chatId, triggerMessageRowId, replyMessageId = '') {
+        this.db.prepare(`
+      INSERT OR IGNORE INTO delivered_replies (bot_name, chat_id, trigger_message_row_id, delivered_at, reply_message_id)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(botName, chatId, triggerMessageRowId, Date.now(), replyMessageId);
+    }
+    /**
+     * Get messages that haven't been synced to a bot's session yet.
+     * Returns messages ordered by timestamp ascending.
+     */
+    getUnsyncedMessages(botName, chatId, maxCount = 50) {
+        const row = this.db.prepare(`
+      SELECT last_synced_msg_id FROM sync_state
+      WHERE bot_name = ? AND chat_id = ?
+    `).get(botName, chatId);
+        const lastId = row?.last_synced_msg_id || 0;
+        const rows = this.db.prepare(`
+      SELECT * FROM messages
+      WHERE chat_id = ? AND id > ?
+      ORDER BY timestamp ASC
+      LIMIT ?
+    `).all(chatId, lastId, maxCount);
+        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,
+        }));
+    }
+    /**
+     * Mark all messages up to (and including) the given id as synced for a bot.
+     */
+    markSynced(botName, chatId, upToId) {
+        this.db.prepare(`
+      INSERT INTO sync_state (bot_name, chat_id, last_synced_msg_id)
+      VALUES (?, ?, ?)
+      ON CONFLICT (bot_name, chat_id) DO UPDATE SET last_synced_msg_id = MAX(sync_state.last_synced_msg_id, excluded.last_synced_msg_id)
+    `).run(botName, chatId, upToId);
+    }
+    /**
+     * Get recent messages for a chat, ordered by timestamp ascending.
+     */
+    getRecent(chatId, maxCount = 50) {
+        const rows = this.db.prepare(`
+      SELECT * FROM messages
+      WHERE chat_id = ?
+      ORDER BY timestamp DESC
+      LIMIT ?
+    `).all(chatId, maxCount);
+        return rows.reverse().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,
+        }));
+    }
+    /**
+     * Count consecutive bot messages at the tail of a chat.
+     */
+    getBotStreak(chatId) {
+        const rows = this.db.prepare(`
+      SELECT sender_type FROM messages
+      WHERE chat_id = ?
+      ORDER BY timestamp DESC
+      LIMIT 20
+    `).all(chatId);
+        let count = 0;
+        for (const r of rows) {
+            if (r.sender_type === "bot")
+                count++;
+            else
+                break;
+        }
+        return count;
+    }
+    // --- Chat info ---
+    upsertChatInfo(info) {
+        this.db.prepare(`
+      INSERT INTO chat_info (chat_id, chat_type, chat_name, members, member_names, verbose, free_discussion, owner_bot, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT (chat_id) DO UPDATE SET
+        chat_type = excluded.chat_type,
+        chat_name = excluded.chat_name,
+        members = excluded.members,
+        member_names = excluded.member_names,
+        verbose = excluded.verbose,
+        free_discussion = excluded.free_discussion,
+        owner_bot = CASE WHEN excluded.owner_bot != '' THEN excluded.owner_bot ELSE chat_info.owner_bot END,
+        updated_at = excluded.updated_at
+    `).run(info.chatId, info.chatType, info.chatName, info.members, info.memberNames, info.verbose ? 1 : 0, info.freeDiscussion ? 1 : 0, info.ownerBot || '', info.updatedAt);
+    }
+    setFreeDiscussion(chatId, on) {
+        this.db.prepare(`UPDATE chat_info SET free_discussion = ? WHERE chat_id = ?`).run(on ? 1 : 0, chatId);
+    }
+    setVerbose(chatId, verbose) {
+        this.db.prepare(`
+      UPDATE chat_info SET verbose = ? WHERE chat_id = ?
+    `).run(verbose ? 1 : 0, chatId);
+    }
+    setBotVerbose(botName, chatId, verbose) {
+        this.db.prepare(`
+      INSERT INTO bot_chat_settings (bot_name, chat_id, verbose, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT (bot_name, chat_id) DO UPDATE SET
+        verbose = excluded.verbose,
+        updated_at = excluded.updated_at
+    `).run(botName, chatId, verbose ? 1 : 0, Date.now());
+    }
+    getBotVerbose(botName, chatId) {
+        const row = this.db.prepare(`
+      SELECT verbose FROM bot_chat_settings
+      WHERE bot_name = ? AND chat_id = ?
+    `).get(botName, chatId);
+        return !!row?.verbose;
+    }
+    getChatInfo(chatId) {
+        const row = this.db.prepare(`SELECT * FROM chat_info WHERE chat_id = ?`).get(chatId);
+        if (!row)
+            return null;
+        return {
+            chatId: row.chat_id,
+            chatType: row.chat_type,
+            chatName: row.chat_name,
+            members: row.members,
+            memberNames: row.member_names,
+            ownerBot: row.owner_bot || '',
+            freeDiscussion: !!row.free_discussion,
+            verbose: !!row.verbose,
+            updatedAt: row.updated_at,
+        };
+    }
+    getAllChatInfo() {
+        const rows = this.db.prepare(`SELECT * FROM chat_info ORDER BY updated_at DESC`).all();
+        return rows.map((r) => ({
+            chatId: r.chat_id,
+            chatType: r.chat_type,
+            chatName: r.chat_name,
+            members: r.members,
+            memberNames: r.member_names,
+            ownerBot: r.owner_bot || '',
+            freeDiscussion: !!r.free_discussion,
+            verbose: !!r.verbose,
+            updatedAt: r.updated_at,
+        }));
+    }
+    /**
+     * Check if a message already exists in the store.
+     */
+    hasMessage(messageId) {
+        const row = this.db.prepare(`SELECT 1 FROM messages WHERE message_id = ?`).get(messageId);
+        return !!row;
+    }
+    /**
+     * Get total message count for a chat.
+     */
+    getMessageCount(chatId) {
+        const row = this.db.prepare(`SELECT COUNT(*) as cnt FROM messages WHERE chat_id = ?`).get(chatId);
+        return row?.cnt || 0;
+    }
+    /**
+     * Check if a specific bot has already processed a message.
+     */
+    hasBotProcessed(botName, messageId) {
+        const row = this.db.prepare(`SELECT 1 FROM processed_events WHERE bot_name = ? AND message_id = ?`).get(botName, messageId);
+        return !!row;
+    }
+    /**
+     * Mark a message as processed by a specific bot.
+     */
+    markBotProcessed(botName, messageId) {
+        this.db.prepare(`INSERT OR IGNORE INTO processed_events (bot_name, message_id) VALUES (?, ?)`).run(botName, messageId);
+    }
+    close() {
+        this.db.close();
+    }
+}

package/dist/openclaw-client.d.ts

@@ -0,0 +1,111 @@
+import { OpenClawConfig } from "./config.js";
+import { ChatMessage } from "./message-store.js";
+export type ChatAttachment = {
+    type?: string;
+    mimeType?: string;
+    fileName?: string;
+    content: string;
+};
+/**
+ * OpenClaw Gateway WebSocket client.
+ * Full agent pipeline — tools, memory, skills, context management by OpenClaw.
+ */
+export declare class OpenClawClient {
+    private config;
+    private ws;
+    private pending;
+    private connected;
+    private connectPromise;
+    private agentEvents;
+    private reconnectDelay;
+    private maxReconnectDelay;
+    private shouldReconnect;
+    /** Callbacks for tool events (verbose mode) */
+    private toolEventCallbacks;
+    private sessionMessageCallbacks;
+    /** Session keys that should be re-subscribed on reconnect */
+    private subscribedKeys;
+    /** Session keys with active chatSend — suppress proactive message delivery */
+    private suppressedSessions;
+    constructor(config: OpenClawConfig);
+    connect(): Promise<void>;
+    private _doConnect;
+    private scheduleReconnect;
+    private rpc;
+    /**
+     * Collect agent reply by polling accumulated events.
+     * Matches by initial runId OR sessionKey to handle multi-turn tool calling
+     * where OpenClaw creates new runIds for each tool-call round.
+     * No aggressive timeout — waits for lifecycle end as the source of truth.
+     * 30-minute safety net only for catastrophic WS disconnection.
+     */
+    private collectReply;
+    createSession(params: {
+        key: string;
+        model: string;
+        label?: string;
+    }): Promise<any>;
+    patchSession(params: {
+        key: string;
+        model?: string;
+        label?: string;
+    }): Promise<any>;
+    getSessionStatus(key: string): Promise<any>;
+    /**
+     * Get session info (model, tokens, etc.) for status display.
+     */
+    getSessionInfo(sessionKey: string): Promise<any>;
+    /**
+     * Ensure session is using the expected model. If not, patch it back.
+     * Returns true if a correction was made.
+     */
+    ensureModel(sessionKey: string, expectedModel: string): Promise<boolean>;
+    deleteSession(key: string, deleteTranscript?: boolean): Promise<any>;
+    resetSession(key: string): Promise<any>;
+    compactSession(key: string): Promise<any>;
+    /**
+     * Send a message to a session and get the agent reply.
+     * deliver=false prevents OpenClaw from auto-posting to channels.
+     */
+    abortChat(sessionKey: string, runId: string): Promise<any>;
+    chatSend(params: {
+        sessionKey: string;
+        message: string;
+        attachments?: ChatAttachment[];
+        deliver?: boolean;
+        timeoutMs?: number;
+    }): Promise<string>;
+    /**
+     * Build and send a context catch-up message followed by the actual message.
+     *
+     * Batches unsynced messages into a single context block to minimize agent runs.
+     * Format:
+     *   [Context: messages you missed]
+     *   [Alice 00:30]: blah
+     *   [GPT 00:31]: blah
+     *   ---
+     *   Now respond to: <actual message>
+     *
+     * If there are no unsynced messages, just sends the actual message directly.
+     */
+    chatSendWithContext(params: {
+        sessionKey: string;
+        unsyncedMessages: ChatMessage[];
+        currentMessage: string;
+        currentSenderName: string;
+        deliver?: boolean;
+        timeoutMs?: number;
+    }): Promise<string>;
+    private extractImageAttachments;
+    disconnect(): Promise<void>;
+    /**
+     * Subscribe to message events for a session.
+     * When the agent proactively produces a message, the callback fires.
+     */
+    subscribeSession(sessionKey: string, onMessage: (text: string) => void): Promise<void>;
+    unsubscribeSession(sessionKey: string): Promise<void>;
+    /**
+     * Register a callback for tool call events on a session.
+     */
+    onToolEvent(sessionKey: string, callback: (toolName: string, toolInput: string, toolOutput: string) => void): void;
+}