openclaw-lark-multi-agent 0.1.0

package/dist/cli.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execFileSync } from "node:child_process";
+import { homedir } from "node:os";
+import { startApp } from "./index.js";
+const APP_NAME = "openclaw-lark-multi-agent";
+const HOME_DIR = homedir() || process.env.HOME || process.cwd();
+const DEFAULT_STATE_DIR = resolve(HOME_DIR, ".openclaw", APP_NAME);
+const DEFAULT_CONFIG_PATH = resolve(DEFAULT_STATE_DIR, "config.json");
+function usage(exitCode = 0) {
+    console.log(`OpenClaw Lark Multi-Agent
+
+Usage:
+  ${APP_NAME} start [config]
+  ${APP_NAME} init [--state-dir DIR] [--force]
+  ${APP_NAME} install-systemd [--user|--system] [--state-dir DIR] [--no-restart]
+  ${APP_NAME} install-windows-service [--state-dir DIR] [--no-start]
+  ${APP_NAME} doctor [--state-dir DIR]
+  ${APP_NAME} --help
+
+Examples:
+  ${APP_NAME} init
+  ${APP_NAME} start ~/.openclaw/${APP_NAME}/config.json
+  ${APP_NAME} install-systemd --user
+  ${APP_NAME} install-windows-service
+`);
+    process.exit(exitCode);
+}
+function takeOption(args, name) {
+    const idx = args.indexOf(name);
+    if (idx < 0)
+        return undefined;
+    const value = args[idx + 1];
+    if (!value || value.startsWith("--"))
+        throw new Error(`${name} requires a value`);
+    args.splice(idx, 2);
+    return value;
+}
+function hasFlag(args, name) {
+    const idx = args.indexOf(name);
+    if (idx < 0)
+        return false;
+    args.splice(idx, 1);
+    return true;
+}
+function sampleConfig() {
+    return JSON.stringify({
+        openclaw: {
+            baseUrl: "http://127.0.0.1:18789",
+            token: "YOUR_OPENCLAW_GATEWAY_TOKEN",
+        },
+        bots: [
+            {
+                name: "GPT",
+                appId: "cli_xxx",
+                appSecret: "YOUR_LARK_APP_SECRET",
+                model: "github-copilot/gpt-5.5",
+            },
+            {
+                name: "Gemini",
+                appId: "cli_yyy",
+                appSecret: "YOUR_LARK_APP_SECRET",
+                model: "github-copilot/gemini-3.1-pro-preview",
+            },
+        ],
+    }, null, 2) + "\n";
+}
+function ensureState(stateDir, force = false) {
+    const configPath = resolve(stateDir, "config.json");
+    const dataDir = resolve(stateDir, "data");
+    mkdirSync(dataDir, { recursive: true });
+    if (existsSync(configPath) && !force) {
+        console.log(`Config already exists: ${configPath}`);
+    }
+    else {
+        writeFileSync(configPath, sampleConfig(), { mode: 0o600 });
+        console.log(`Created config: ${configPath}`);
+    }
+    console.log(`Data dir: ${dataDir}`);
+    return { configPath, dataDir };
+}
+function cmdInit(args) {
+    const stateDir = resolve(takeOption(args, "--state-dir") || DEFAULT_STATE_DIR);
+    const force = hasFlag(args, "--force");
+    if (args.length > 0)
+        throw new Error(`Unknown init arguments: ${args.join(" ")}`);
+    ensureState(stateDir, force);
+    console.log("Next: edit config.json and fill in your OpenClaw token and Lark app credentials.");
+}
+function buildUnit(params) {
+    const nodeBin = process.execPath;
+    const cliPath = fileURLToPath(import.meta.url);
+    const userLine = params.mode === "system" ? `User=${process.env.USER || "YOUR_USERNAME"}\n` : "";
+    return `[Unit]
+Description=OpenClaw Lark Multi-Agent - Multi-bot bridge for OpenClaw
+After=network.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+${userLine}ExecStart=${nodeBin} ${cliPath} start ${params.configPath}
+Restart=always
+RestartSec=5
+Environment=NODE_ENV=production
+Environment=LMA_DATA_DIR=${resolve(params.stateDir, "data")}
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=${APP_NAME}
+
+[Install]
+WantedBy=${params.mode === "system" ? "multi-user.target" : "default.target"}
+`;
+}
+function run(cmd, args) {
+    execFileSync(cmd, args, { stdio: "inherit" });
+}
+function runSudo(args) {
+    run("sudo", args);
+}
+function cmdInstallSystemd(args) {
+    const mode = hasFlag(args, "--system") ? "system" : "user";
+    hasFlag(args, "--user");
+    const noRestart = hasFlag(args, "--no-restart");
+    const stateDir = resolve(takeOption(args, "--state-dir") || DEFAULT_STATE_DIR);
+    if (args.length > 0)
+        throw new Error(`Unknown install-systemd arguments: ${args.join(" ")}`);
+    const { configPath } = ensureState(stateDir, false);
+    const unit = buildUnit({ mode, configPath, stateDir });
+    if (mode === "system") {
+        const tmp = `/tmp/${APP_NAME}.service`;
+        writeFileSync(tmp, unit);
+        runSudo(["install", "-m", "0644", tmp, `/etc/systemd/system/${APP_NAME}.service`]);
+        runSudo(["systemctl", "daemon-reload"]);
+        runSudo(["systemctl", "enable", `${APP_NAME}.service`]);
+        if (!noRestart)
+            runSudo(["systemctl", "restart", `${APP_NAME}.service`]);
+        console.log(`Installed system service: ${APP_NAME}.service`);
+    }
+    else {
+        const unitDir = resolve(HOME_DIR, ".config", "systemd", "user");
+        mkdirSync(unitDir, { recursive: true });
+        const unitPath = resolve(unitDir, `${APP_NAME}.service`);
+        writeFileSync(unitPath, unit);
+        run("systemctl", ["--user", "daemon-reload"]);
+        run("systemctl", ["--user", "enable", `${APP_NAME}.service`]);
+        if (!noRestart)
+            run("systemctl", ["--user", "restart", `${APP_NAME}.service`]);
+        console.log(`Installed user service: ${unitPath}`);
+    }
+}
+function cmdInstallWindowsService(args) {
+    const noStart = hasFlag(args, "--no-start");
+    const stateDir = resolve(takeOption(args, "--state-dir") || DEFAULT_STATE_DIR);
+    if (args.length > 0)
+        throw new Error(`Unknown install-windows-service arguments: ${args.join(" ")}`);
+    if (process.platform !== "win32") {
+        console.log("install-windows-service is intended for Windows. On Linux, use install-systemd.");
+    }
+    const { configPath, dataDir } = ensureState(stateDir, false);
+    const cliPath = fileURLToPath(import.meta.url);
+    run("nssm", ["install", APP_NAME, process.execPath, cliPath, "start", configPath]);
+    run("nssm", ["set", APP_NAME, "AppDirectory", dirname(cliPath)]);
+    run("nssm", ["set", APP_NAME, "AppEnvironmentExtra", `NODE_ENV=production`, `LMA_DATA_DIR=${dataDir}`]);
+    run("nssm", ["set", APP_NAME, "AppStdout", resolve(stateDir, "stdout.log")]);
+    run("nssm", ["set", APP_NAME, "AppStderr", resolve(stateDir, "stderr.log")]);
+    run("nssm", ["set", APP_NAME, "AppRotateFiles", "1"]);
+    run("nssm", ["set", APP_NAME, "AppRotateBytes", "10485760"]);
+    run("nssm", ["set", APP_NAME, "Start", "SERVICE_AUTO_START"]);
+    if (!noStart)
+        run("nssm", ["start", APP_NAME]);
+    console.log(`Installed Windows service: ${APP_NAME}`);
+}
+function cmdDoctor(args) {
+    const stateDir = resolve(takeOption(args, "--state-dir") || DEFAULT_STATE_DIR);
+    if (args.length > 0)
+        throw new Error(`Unknown doctor arguments: ${args.join(" ")}`);
+    const configPath = resolve(stateDir, "config.json");
+    console.log(`State dir:  ${stateDir}`);
+    console.log(`Config:     ${configPath} ${existsSync(configPath) ? "OK" : "MISSING"}`);
+    console.log(`Data dir:   ${resolve(stateDir, "data")} ${existsSync(resolve(stateDir, "data")) ? "OK" : "MISSING"}`);
+    console.log(`Node:       ${process.version}`);
+    console.log(`Platform:   ${process.platform}`);
+    console.log(`CLI:        ${fileURLToPath(import.meta.url)}`);
+}
+async function main() {
+    const [cmd = "--help", ...args] = process.argv.slice(2);
+    if (cmd === "--help" || cmd === "-h")
+        usage(0);
+    if (cmd === "init")
+        return cmdInit(args);
+    if (cmd === "install-systemd")
+        return cmdInstallSystemd(args);
+    if (cmd === "install-windows-service")
+        return cmdInstallWindowsService(args);
+    if (cmd === "doctor")
+        return cmdDoctor(args);
+    if (cmd === "start") {
+        const configPath = args[0] ? resolve(args[0]) : DEFAULT_CONFIG_PATH;
+        return startApp(configPath);
+    }
+    usage(1);
+}
+main().catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/dist/config.d.ts

@@ -0,0 +1,17 @@
+export interface BotConfig {
+    name: string;
+    appId: string;
+    appSecret: string;
+    model: string;
+}
+export interface OpenClawConfig {
+    baseUrl: string;
+    token: string;
+}
+export interface AppConfig {
+    openclaw: OpenClawConfig;
+    bots: BotConfig[];
+    /** Optional Feishu/Lark open_id for model-drift notifications */
+    adminOpenId?: string;
+}
+export declare function loadConfig(path?: string): AppConfig;

package/dist/config.js

@@ -0,0 +1,28 @@
+import { readFileSync } from "fs";
+import { resolve } from "path";
+export function loadConfig(path) {
+    const configPath = path || resolve(process.cwd(), "config.json");
+    const raw = readFileSync(configPath, "utf-8");
+    const config = JSON.parse(raw);
+    if (!config.openclaw?.baseUrl || !config.openclaw?.token) {
+        throw new Error("Missing openclaw.baseUrl or openclaw.token in config");
+    }
+    if (!config.bots || config.bots.length === 0) {
+        throw new Error("No bots configured");
+    }
+    for (const bot of config.bots) {
+        if (!bot.appId || !bot.appSecret || !bot.model) {
+            throw new Error(`Bot "${bot.name}" missing appId, appSecret, or model`);
+        }
+    }
+    // Validate uniqueness
+    const names = config.bots.map((b) => b.name);
+    const appIds = config.bots.map((b) => b.appId);
+    if (new Set(names).size !== names.length) {
+        throw new Error(`Duplicate bot names detected: ${names.join(", ")}`);
+    }
+    if (new Set(appIds).size !== appIds.length) {
+        throw new Error(`Duplicate bot appIds detected`);
+    }
+    return config;
+}

package/dist/feishu-bot.d.ts

@@ -0,0 +1,123 @@
+import { BotConfig } from "./config.js";
+import { OpenClawClient } from "./openclaw-client.js";
+import { MessageStore } from "./message-store.js";
+/**
+ * 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 declare class FeishuBot {
+    readonly config: BotConfig;
+    private client;
+    private wsClient;
+    private eventDispatcher;
+    private openclawClient;
+    private store;
+    private botOpenId;
+    /** Tracks which chatId sessions have been initialized */
+    private initializedSessions;
+    /** Per-chat busy lock: timestamp when became busy (0 = not busy) */
+    private busyChats;
+    /** Per-chat pending reply message IDs (to ack with DONE when reply arrives) */
+    private pendingAckMessages;
+    /** Per-chat pending tool message sends (to await before final reply) */
+    private pendingToolSends;
+    /** Per-chat processQueue lock to avoid duplicate concurrent chat.send runs */
+    private queueRuns;
+    /** Per-chat serial send queue to guarantee message order */
+    private sendQueue;
+    private adminOpenId;
+    private static allBots;
+    constructor(config: BotConfig, openclawClient: OpenClawClient, store: MessageStore, adminOpenId?: string);
+    register(): void;
+    /**
+     * Get the session key for a specific chat.
+     * Format: lma-<botname>-<chatId>
+     */
+    getSessionKey(chatId: string): string;
+    /**
+     * Ensure the session for a given chatId exists with the correct model.
+     * Lazy: only creates on first message in that chat.
+     */
+    private ensureSession;
+    /**
+     * Start the Feishu WS connection. Sessions are created lazily per chat.
+     */
+    start(): Promise<void>;
+    /** 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. */
+    private probeBotIdentity;
+    /**
+     * On startup, check all known chats for unsynced messages and process them.
+     * Also re-subscribe to known sessions for tool events.
+     */
+    private drainOnStartup;
+    static getAllBots(): Map<string, FeishuBot>;
+    static findByOpenId(openId: string): FeishuBot | undefined;
+    private handleMessage;
+    /**
+     * Process queued messages for a chat: batch all unsynced messages and send to OpenClaw.
+     * Loops until no more unsynced human messages remain.
+     */
+    private processQueue;
+    private processQueueInner;
+    private shouldRespond;
+    private isMentioned;
+    private resolveBotName;
+    private resolveHumanName;
+    private cleanMentions;
+    private replyMessage;
+    /**
+     * Send a proactive message to a chat (not a reply).
+     */
+    private sendMessage;
+    /**
+     * Enqueue a message send to guarantee ordering per chat.
+     * All sends for a chat are serialized through this.
+     */
+    private sendOrdered;
+    /**
+     * Add a reaction (emoji) to a message.
+     */
+    private addReaction;
+    /**
+     * Remove a reaction by emoji type from a message.
+     * Finds the bot's own reaction of that type and deletes it.
+     */
+    private removeReaction;
+    /**
+     * Handle /status command: show current session info.
+     */
+    private handleStatusCommand;
+    /**
+     * Handle /compact command: compress session context.
+     */
+    private handleCompactCommand;
+    /**
+     * 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.
+     */
+    private handleResetCommand;
+    /**
+     * Fetch chat info (name, type, members) via Feishu API and cache in SQLite.
+     * Called once per chat on first message.
+     */
+    private fetchAndCacheChatInfo;
+    /**
+     * Send a model-drift notification to the affected chat.
+     */
+    /**
+     * Download a resource (image/file/audio) from a Feishu message.
+     * Returns the local file path.
+     */
+    private downloadResource;
+    /**
+     * Extract text content from a rich text (post) message.
+     */
+    private extractPostText;
+    private notifyModelDrift;
+}