@m1heng-clawd/feishu 0.1.7 → 0.1.9

package/src/media.ts

@@ -1,6 +1,6 @@
 import type { ClawdbotConfig } from "openclaw/plugin-sdk";
-import type { FeishuConfig } from "./types.js";
 import { createFeishuClient } from "./client.js";
+import { resolveFeishuAccount } from "./accounts.js";
 import { resolveReceiveIdType, normalizeFeishuTarget } from "./targets.js";
 import fs from "fs";
 import path from "path";
@@ -25,14 +25,15 @@ export type DownloadMessageResourceResult = {
 export async function downloadImageFeishu(params: {
   cfg: ClawdbotConfig;
   imageKey: string;
+  accountId?: string;
 }): Promise<DownloadImageResult> {
-  const { cfg, imageKey } = params;
-  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg) {
-    throw new Error("Feishu channel not configured");
+  const { cfg, imageKey, accountId } = params;
+  const account = resolveFeishuAccount({ cfg, accountId });
+  if (!account.configured) {
+    throw new Error(`Feishu account "${account.accountId}" not configured`);
   }
 
-  const client = createFeishuClient(feishuCfg);
+  const client = createFeishuClient(account);
 
   const response = await client.im.image.get({
     path: { image_key: imageKey },
@@ -103,14 +104,15 @@ export async function downloadMessageResourceFeishu(params: {
   messageId: string;
   fileKey: string;
   type: "image" | "file";
+  accountId?: string;
 }): Promise<DownloadMessageResourceResult> {
-  const { cfg, messageId, fileKey, type } = params;
-  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg) {
-    throw new Error("Feishu channel not configured");
+  const { cfg, messageId, fileKey, type, accountId } = params;
+  const account = resolveFeishuAccount({ cfg, accountId });
+  if (!account.configured) {
+    throw new Error(`Feishu account "${account.accountId}" not configured`);
   }
 
-  const client = createFeishuClient(feishuCfg);
+  const client = createFeishuClient(account);
 
   const response = await client.im.messageResource.get({
     path: { message_id: messageId, file_key: fileKey },
@@ -196,14 +198,15 @@ export async function uploadImageFeishu(params: {
   cfg: ClawdbotConfig;
   image: Buffer | string; // Buffer or file path
   imageType?: "message" | "avatar";
+  accountId?: string;
 }): Promise<UploadImageResult> {
-  const { cfg, image, imageType = "message" } = params;
-  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg) {
-    throw new Error("Feishu channel not configured");
+  const { cfg, image, imageType = "message", accountId } = params;
+  const account = resolveFeishuAccount({ cfg, accountId });
+  if (!account.configured) {
+    throw new Error(`Feishu account "${account.accountId}" not configured`);
   }
 
-  const client = createFeishuClient(feishuCfg);
+  const client = createFeishuClient(account);
 
   // SDK expects a Readable stream, not a Buffer
   // Use type assertion since SDK actually accepts any Readable at runtime
@@ -242,14 +245,15 @@ export async function uploadFileFeishu(params: {
   fileName: string;
   fileType: "opus" | "mp4" | "pdf" | "doc" | "xls" | "ppt" | "stream";
   duration?: number; // Required for audio/video files, in milliseconds
+  accountId?: string;
 }): Promise<UploadFileResult> {
-  const { cfg, file, fileName, fileType, duration } = params;
-  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg) {
-    throw new Error("Feishu channel not configured");
+  const { cfg, file, fileName, fileType, duration, accountId } = params;
+  const account = resolveFeishuAccount({ cfg, accountId });
+  if (!account.configured) {
+    throw new Error(`Feishu account "${account.accountId}" not configured`);
   }
 
-  const client = createFeishuClient(feishuCfg);
+  const client = createFeishuClient(account);
 
   // SDK expects a Readable stream, not a Buffer
   // Use type assertion since SDK actually accepts any Readable at runtime
@@ -287,14 +291,15 @@ export async function sendImageFeishu(params: {
   to: string;
   imageKey: string;
   replyToMessageId?: string;
+  accountId?: string;
 }): Promise<SendMediaResult> {
-  const { cfg, to, imageKey, replyToMessageId } = params;
-  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg) {
-    throw new Error("Feishu channel not configured");
+  const { cfg, to, imageKey, replyToMessageId, accountId } = params;
+  const account = resolveFeishuAccount({ cfg, accountId });
+  if (!account.configured) {
+    throw new Error(`Feishu account "${account.accountId}" not configured`);
   }
 
-  const client = createFeishuClient(feishuCfg);
+  const client = createFeishuClient(account);
   const receiveId = normalizeFeishuTarget(to);
   if (!receiveId) {
     throw new Error(`Invalid Feishu target: ${to}`);
@@ -349,14 +354,15 @@ export async function sendFileFeishu(params: {
   to: string;
   fileKey: string;
   replyToMessageId?: string;
+  accountId?: string;
 }): Promise<SendMediaResult> {
-  const { cfg, to, fileKey, replyToMessageId } = params;
-  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg) {
-    throw new Error("Feishu channel not configured");
+  const { cfg, to, fileKey, replyToMessageId, accountId } = params;
+  const account = resolveFeishuAccount({ cfg, accountId });
+  if (!account.configured) {
+    throw new Error(`Feishu account "${account.accountId}" not configured`);
   }
 
-  const client = createFeishuClient(feishuCfg);
+  const client = createFeishuClient(account);
   const receiveId = normalizeFeishuTarget(to);
   if (!receiveId) {
     throw new Error(`Invalid Feishu target: ${to}`);
@@ -461,8 +467,9 @@ export async function sendMediaFeishu(params: {
   mediaBuffer?: Buffer;
   fileName?: string;
   replyToMessageId?: string;
+  accountId?: string;
 }): Promise<SendMediaResult> {
-  const { cfg, to, mediaUrl, mediaBuffer, fileName, replyToMessageId } = params;
+  const { cfg, to, mediaUrl, mediaBuffer, fileName, replyToMessageId, accountId } = params;
 
   let buffer: Buffer;
   let name: string;
@@ -500,8 +507,8 @@ export async function sendMediaFeishu(params: {
   const isImage = [".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".ico", ".tiff"].includes(ext);
 
   if (isImage) {
-    const { imageKey } = await uploadImageFeishu({ cfg, image: buffer });
-    return sendImageFeishu({ cfg, to, imageKey, replyToMessageId });
+    const { imageKey } = await uploadImageFeishu({ cfg, image: buffer, accountId });
+    return sendImageFeishu({ cfg, to, imageKey, replyToMessageId, accountId });
   } else {
     const fileType = detectFileType(name);
     const { fileKey } = await uploadFileFeishu({
@@ -509,7 +516,8 @@ export async function sendMediaFeishu(params: {
       file: buffer,
       fileName: name,
       fileType,
+      accountId,
     });
-    return sendFileFeishu({ cfg, to, fileKey, replyToMessageId });
+    return sendFileFeishu({ cfg, to, fileKey, replyToMessageId, accountId });
   }
 }

package/src/monitor.ts

@@ -1,8 +1,9 @@
 import * as Lark from "@larksuiteoapi/node-sdk";
+import * as http from "http";
 import type { ClawdbotConfig, RuntimeEnv, HistoryEntry } from "openclaw/plugin-sdk";
-import type { FeishuConfig } from "./types.js";
+import type { ResolvedFeishuAccount } from "./types.js";
 import { createFeishuWSClient, createEventDispatcher } from "./client.js";
-import { resolveFeishuCredentials } from "./accounts.js";
+import { resolveFeishuAccount, listEnabledFeishuAccounts } from "./accounts.js";
 import { handleFeishuMessage, type FeishuMessageEvent, type FeishuBotAddedEvent } from "./bot.js";
 import { probeFeishu } from "./probe.js";
 
@@ -13,79 +14,62 @@ export type MonitorFeishuOpts = {
   accountId?: string;
 };
 
-let currentWsClient: Lark.WSClient | null = null;
-let botOpenId: string | undefined;
+// Per-account WebSocket clients, HTTP servers, and bot info
+const wsClients = new Map<string, Lark.WSClient>();
+const httpServers = new Map<string, http.Server>();
+const botOpenIds = new Map<string, string>();
 
-async function fetchBotOpenId(cfg: FeishuConfig): Promise<string | undefined> {
+async function fetchBotOpenId(
+  account: ResolvedFeishuAccount,
+): Promise<string | undefined> {
   try {
-    const result = await probeFeishu(cfg);
+    const result = await probeFeishu(account);
     return result.ok ? result.botOpenId : undefined;
   } catch {
     return undefined;
   }
 }
 
-export async function monitorFeishuProvider(opts: MonitorFeishuOpts = {}): Promise<void> {
-  const cfg = opts.config;
-  if (!cfg) {
-    throw new Error("Config is required for Feishu monitor");
-  }
-
-  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-  const creds = resolveFeishuCredentials(feishuCfg);
-  if (!creds) {
-    throw new Error("Feishu credentials not configured (appId, appSecret required)");
-  }
-
-  const log = opts.runtime?.log ?? console.log;
-  const error = opts.runtime?.error ?? console.error;
-
-  if (feishuCfg) {
-    botOpenId = await fetchBotOpenId(feishuCfg);
-    log(`feishu: bot open_id resolved: ${botOpenId ?? "unknown"}`);
-  }
-
-  const connectionMode = feishuCfg?.connectionMode ?? "websocket";
-
-  if (connectionMode === "websocket") {
-    return monitorWebSocket({ cfg, feishuCfg: feishuCfg!, runtime: opts.runtime, abortSignal: opts.abortSignal });
-  }
-
-  log("feishu: webhook mode not implemented in monitor, use HTTP server directly");
-}
-
-async function monitorWebSocket(params: {
-  cfg: ClawdbotConfig;
-  feishuCfg: FeishuConfig;
-  runtime?: RuntimeEnv;
-  abortSignal?: AbortSignal;
-}): Promise<void> {
-  const { cfg, feishuCfg, runtime, abortSignal } = params;
+/**
+ * Register common event handlers on an EventDispatcher.
+ * When fireAndForget is true (webhook mode), message handling is not awaited
+ * to avoid blocking the HTTP response (Lark requires <3s response).
+ */
+function registerEventHandlers(
+  eventDispatcher: Lark.EventDispatcher,
+  context: {
+    cfg: ClawdbotConfig;
+    accountId: string;
+    runtime?: RuntimeEnv;
+    chatHistories: Map<string, HistoryEntry[]>;
+    fireAndForget?: boolean;
+  },
+) {
+  const { cfg, accountId, runtime, chatHistories, fireAndForget } = context;
   const log = runtime?.log ?? console.log;
   const error = runtime?.error ?? console.error;
 
-  log("feishu: starting WebSocket connection...");
-
-  const wsClient = createFeishuWSClient(feishuCfg);
-  currentWsClient = wsClient;
-
-  const chatHistories = new Map<string, HistoryEntry[]>();
-
-  const eventDispatcher = createEventDispatcher(feishuCfg);
-
   eventDispatcher.register({
     "im.message.receive_v1": async (data) => {
       try {
         const event = data as unknown as FeishuMessageEvent;
-        await handleFeishuMessage({
+        const promise = handleFeishuMessage({
           cfg,
           event,
-          botOpenId,
+          botOpenId: botOpenIds.get(accountId),
           runtime,
           chatHistories,
+          accountId,
         });
+        if (fireAndForget) {
+          promise.catch((err) => {
+            error(`feishu[${accountId}]: error handling message: ${String(err)}`);
+          });
+        } else {
+          await promise;
+        }
       } catch (err) {
-        error(`feishu: error handling message event: ${String(err)}`);
+        error(`feishu[${accountId}]: error handling message: ${String(err)}`);
       }
     },
     "im.message.message_read_v1": async () => {
@@ -94,30 +78,85 @@ async function monitorWebSocket(params: {
     "im.chat.member.bot.added_v1": async (data) => {
       try {
         const event = data as unknown as FeishuBotAddedEvent;
-        log(`feishu: bot added to chat ${event.chat_id}`);
+        log(`feishu[${accountId}]: bot added to chat ${event.chat_id}`);
       } catch (err) {
-        error(`feishu: error handling bot added event: ${String(err)}`);
+        error(`feishu[${accountId}]: error handling bot added event: ${String(err)}`);
       }
     },
     "im.chat.member.bot.deleted_v1": async (data) => {
       try {
         const event = data as unknown as { chat_id: string };
-        log(`feishu: bot removed from chat ${event.chat_id}`);
+        log(`feishu[${accountId}]: bot removed from chat ${event.chat_id}`);
       } catch (err) {
-        error(`feishu: error handling bot removed event: ${String(err)}`);
+        error(`feishu[${accountId}]: error handling bot removed event: ${String(err)}`);
       }
     },
   });
+}
+
+type MonitorAccountParams = {
+  cfg: ClawdbotConfig;
+  account: ResolvedFeishuAccount;
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+};
+
+/**
+ * Monitor a single Feishu account.
+ */
+async function monitorSingleAccount(params: MonitorAccountParams): Promise<void> {
+  const { cfg, account, runtime, abortSignal } = params;
+  const { accountId } = account;
+  const log = runtime?.log ?? console.log;
+
+  // Fetch bot open_id
+  const botOpenId = await fetchBotOpenId(account);
+  botOpenIds.set(accountId, botOpenId ?? "");
+  log(`feishu[${accountId}]: bot open_id resolved: ${botOpenId ?? "unknown"}`);
+
+  const connectionMode = account.config.connectionMode ?? "websocket";
+  const eventDispatcher = createEventDispatcher(account);
+  const chatHistories = new Map<string, HistoryEntry[]>();
+
+  registerEventHandlers(eventDispatcher, {
+    cfg,
+    accountId,
+    runtime,
+    chatHistories,
+    fireAndForget: connectionMode === "webhook",
+  });
+
+  if (connectionMode === "webhook") {
+    return monitorWebhook({ params, accountId, eventDispatcher });
+  }
+
+  return monitorWebSocket({ params, accountId, eventDispatcher });
+}
+
+type ConnectionParams = {
+  params: MonitorAccountParams;
+  accountId: string;
+  eventDispatcher: Lark.EventDispatcher;
+};
+
+async function monitorWebSocket({ params, accountId, eventDispatcher }: ConnectionParams): Promise<void> {
+  const { account, runtime, abortSignal } = params;
+  const log = runtime?.log ?? console.log;
+  const error = runtime?.error ?? console.error;
+
+  log(`feishu[${accountId}]: starting WebSocket connection...`);
+
+  const wsClient = createFeishuWSClient(account);
+  wsClients.set(accountId, wsClient);
 
   return new Promise((resolve, reject) => {
     const cleanup = () => {
-      if (currentWsClient === wsClient) {
-        currentWsClient = null;
-      }
+      wsClients.delete(accountId);
+      botOpenIds.delete(accountId);
     };
 
     const handleAbort = () => {
-      log("feishu: abort signal received, stopping WebSocket client");
+      log(`feishu[${accountId}]: abort signal received, stopping`);
       cleanup();
       resolve();
     };
@@ -131,11 +170,8 @@ async function monitorWebSocket(params: {
     abortSignal?.addEventListener("abort", handleAbort, { once: true });
 
     try {
-      wsClient.start({
-        eventDispatcher,
-      });
-
-      log("feishu: WebSocket client started");
+      wsClient.start({ eventDispatcher });
+      log(`feishu[${accountId}]: WebSocket client started`);
     } catch (err) {
       cleanup();
       abortSignal?.removeEventListener("abort", handleAbort);
@@ -144,8 +180,117 @@ async function monitorWebSocket(params: {
   });
 }
 
-export function stopFeishuMonitor(): void {
-  if (currentWsClient) {
-    currentWsClient = null;
+async function monitorWebhook({ params, accountId, eventDispatcher }: ConnectionParams): Promise<void> {
+  const { account, runtime, abortSignal } = params;
+  const log = runtime?.log ?? console.log;
+  const error = runtime?.error ?? console.error;
+
+  const port = account.config.webhookPort ?? 3000;
+  const path = account.config.webhookPath ?? "/feishu/events";
+
+  log(`feishu[${accountId}]: starting Webhook server on port ${port}, path ${path}...`);
+
+  const server = http.createServer();
+  server.on("request", Lark.adaptDefault(path, eventDispatcher, { autoChallenge: true }));
+  httpServers.set(accountId, server);
+
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      server.close();
+      httpServers.delete(accountId);
+      botOpenIds.delete(accountId);
+    };
+
+    const handleAbort = () => {
+      log(`feishu[${accountId}]: abort signal received, stopping Webhook server`);
+      cleanup();
+      resolve();
+    };
+
+    if (abortSignal?.aborted) {
+      cleanup();
+      resolve();
+      return;
+    }
+
+    abortSignal?.addEventListener("abort", handleAbort, { once: true });
+
+    server.listen(port, () => {
+      log(`feishu[${accountId}]: Webhook server listening on port ${port}`);
+    });
+
+    server.on("error", (err) => {
+      error(`feishu[${accountId}]: Webhook server error: ${err}`);
+      abortSignal?.removeEventListener("abort", handleAbort);
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Main entry: start monitoring for all enabled accounts.
+ */
+export async function monitorFeishuProvider(opts: MonitorFeishuOpts = {}): Promise<void> {
+  const cfg = opts.config;
+  if (!cfg) {
+    throw new Error("Config is required for Feishu monitor");
+  }
+
+  const log = opts.runtime?.log ?? console.log;
+
+  // If accountId is specified, only monitor that account
+  if (opts.accountId) {
+    const account = resolveFeishuAccount({ cfg, accountId: opts.accountId });
+    if (!account.enabled || !account.configured) {
+      throw new Error(`Feishu account "${opts.accountId}" not configured or disabled`);
+    }
+    return monitorSingleAccount({
+      cfg,
+      account,
+      runtime: opts.runtime,
+      abortSignal: opts.abortSignal,
+    });
+  }
+
+  // Otherwise, start all enabled accounts
+  const accounts = listEnabledFeishuAccounts(cfg);
+  if (accounts.length === 0) {
+    throw new Error("No enabled Feishu accounts configured");
+  }
+
+  log(`feishu: starting ${accounts.length} account(s): ${accounts.map((a) => a.accountId).join(", ")}`);
+
+  // Start all accounts in parallel
+  await Promise.all(
+    accounts.map((account) =>
+      monitorSingleAccount({
+        cfg,
+        account,
+        runtime: opts.runtime,
+        abortSignal: opts.abortSignal,
+      }),
+    ),
+  );
+}
+
+/**
+ * Stop monitoring for a specific account or all accounts.
+ */
+export function stopFeishuMonitor(accountId?: string): void {
+  if (accountId) {
+    wsClients.delete(accountId);
+    const server = httpServers.get(accountId);
+    if (server) {
+      server.close();
+      httpServers.delete(accountId);
+    }
+    botOpenIds.delete(accountId);
+  } else {
+    wsClients.clear();
+    for (const server of httpServers.values()) {
+      server.close();
+    }
+    httpServers.clear();
+    botOpenIds.clear();
   }
 }

package/src/outbound.ts

@@ -8,33 +8,33 @@ export const feishuOutbound: ChannelOutboundAdapter = {
   chunker: (text, limit) => getFeishuRuntime().channel.text.chunkMarkdownText(text, limit),
   chunkerMode: "markdown",
   textChunkLimit: 4000,
-  sendText: async ({ cfg, to, text }) => {
-    const result = await sendMessageFeishu({ cfg, to, text });
+  sendText: async ({ cfg, to, text, accountId }) => {
+    const result = await sendMessageFeishu({ cfg, to, text, accountId });
     return { channel: "feishu", ...result };
   },
-  sendMedia: async ({ cfg, to, text, mediaUrl }) => {
+  sendMedia: async ({ cfg, to, text, mediaUrl, accountId }) => {
     // Send text first if provided
     if (text?.trim()) {
-      await sendMessageFeishu({ cfg, to, text });
+      await sendMessageFeishu({ cfg, to, text, accountId });
     }
 
     // Upload and send media if URL provided
     if (mediaUrl) {
       try {
-        const result = await sendMediaFeishu({ cfg, to, mediaUrl });
+        const result = await sendMediaFeishu({ cfg, to, mediaUrl, accountId });
         return { channel: "feishu", ...result };
       } catch (err) {
         // Log the error for debugging
         console.error(`[feishu] sendMediaFeishu failed:`, err);
         // Fallback to URL link if upload fails
         const fallbackText = `📎 ${mediaUrl}`;
-        const result = await sendMessageFeishu({ cfg, to, text: fallbackText });
+        const result = await sendMessageFeishu({ cfg, to, text: fallbackText, accountId });
         return { channel: "feishu", ...result };
       }
     }
 
     // No media URL, just return text result
-    const result = await sendMessageFeishu({ cfg, to, text: text ?? "" });
+    const result = await sendMessageFeishu({ cfg, to, text: text ?? "", accountId });
     return { channel: "feishu", ...result };
   },
 };

package/src/perm.ts

@@ -1,6 +1,6 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { createFeishuClient } from "./client.js";
-import type { FeishuConfig } from "./types.js";
+import { listEnabledFeishuAccounts } from "./accounts.js";
 import type * as Lark from "@larksuiteoapi/node-sdk";
 import { FeishuPermSchema, type FeishuPermParams } from "./perm-schema.js";
 import { resolveToolsConfig } from "./tools-config.js";
@@ -112,19 +112,25 @@ async function removeMember(
 // ============ Tool Registration ============
 
 export function registerFeishuPermTools(api: OpenClawPluginApi) {
-  const feishuCfg = api.config?.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg?.appId || !feishuCfg?.appSecret) {
-    api.logger.debug?.("feishu_perm: Feishu credentials not configured, skipping perm tools");
+  if (!api.config) {
+    api.logger.debug?.("feishu_perm: No config available, skipping perm tools");
     return;
   }
 
-  const toolsCfg = resolveToolsConfig(feishuCfg.tools);
+  const accounts = listEnabledFeishuAccounts(api.config);
+  if (accounts.length === 0) {
+    api.logger.debug?.("feishu_perm: No Feishu accounts configured, skipping perm tools");
+    return;
+  }
+
+  const firstAccount = accounts[0];
+  const toolsCfg = resolveToolsConfig(firstAccount.config.tools);
   if (!toolsCfg.perm) {
     api.logger.debug?.("feishu_perm: perm tool disabled in config (default: false)");
     return;
   }
 
-  const getClient = () => createFeishuClient(feishuCfg);
+  const getClient = () => createFeishuClient(firstAccount);
 
   api.registerTool(
     {

package/src/probe.ts

@@ -1,10 +1,8 @@
-import type { FeishuConfig, FeishuProbeResult } from "./types.js";
-import { createFeishuClient } from "./client.js";
-import { resolveFeishuCredentials } from "./accounts.js";
+import type { FeishuProbeResult } from "./types.js";
+import { createFeishuClient, type FeishuClientCredentials } from "./client.js";
 
-export async function probeFeishu(cfg?: FeishuConfig): Promise<FeishuProbeResult> {
-  const creds = resolveFeishuCredentials(cfg);
-  if (!creds) {
+export async function probeFeishu(creds?: FeishuClientCredentials): Promise<FeishuProbeResult> {
+  if (!creds?.appId || !creds?.appSecret) {
     return {
       ok: false,
       error: "missing credentials (appId, appSecret)",
@@ -12,9 +10,8 @@ export async function probeFeishu(cfg?: FeishuConfig): Promise<FeishuProbeResult
   }
 
   try {
-    const client = createFeishuClient(cfg!);
-    // Use im.chat.list as a simple connectivity test
-    // The bot info API path varies by SDK version
+    const client = createFeishuClient(creds);
+    // Use bot/v3/info API to get bot information
     const response = await (client as any).request({
       method: "GET",
       url: "/open-apis/bot/v3/info",