@max1874/feishu 0.2.27 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@max1874/feishu",
-  "version": "0.2.27",
+  "version": "0.3.0",
   "type": "module",
   "description": "OpenClaw Feishu/Lark channel plugin",
   "license": "MIT",

package/src/accounts.ts

@@ -21,16 +21,34 @@ export function resolveFeishuCredentials(cfg?: FeishuConfig): {
   };
 }
 
+/**
+ * Merge per-account overrides with the base (top-level) feishu config.
+ * Account-specific fields (credentials, domain, connectionMode, etc.) override the base.
+ */
+export function mergeFeishuAccountConfig(
+  baseCfg: FeishuConfig,
+  accountId: string,
+): FeishuConfig {
+  if (accountId === DEFAULT_ACCOUNT_ID) return baseCfg;
+  const overrides = baseCfg.accounts?.[accountId];
+  if (!overrides) return baseCfg;
+  // Strip `accounts` from merged result to prevent downstream confusion
+  const { accounts: _, ...base } = baseCfg;
+  return { ...base, ...overrides };
+}
+
 export function resolveFeishuAccount(params: {
   cfg: ClawdbotConfig;
   accountId?: string | null;
 }): ResolvedFeishuAccount {
   const feishuCfg = params.cfg.channels?.feishu as FeishuConfig | undefined;
-  const enabled = feishuCfg?.enabled !== false;
-  const creds = resolveFeishuCredentials(feishuCfg);
+  const accountId = params.accountId?.trim() || DEFAULT_ACCOUNT_ID;
+  const merged = feishuCfg ? mergeFeishuAccountConfig(feishuCfg, accountId) : undefined;
+  const enabled = merged?.enabled !== false;
+  const creds = resolveFeishuCredentials(merged);
 
   return {
-    accountId: params.accountId?.trim() || DEFAULT_ACCOUNT_ID,
+    accountId,
     enabled,
     configured: Boolean(creds),
     appId: creds?.appId,
@@ -38,12 +56,17 @@ export function resolveFeishuAccount(params: {
   };
 }
 
-export function listFeishuAccountIds(_cfg: ClawdbotConfig): string[] {
-  return [DEFAULT_ACCOUNT_ID];
+export function listFeishuAccountIds(cfg: ClawdbotConfig): string[] {
+  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+  const accounts = feishuCfg?.accounts;
+  if (!accounts) return [DEFAULT_ACCOUNT_ID];
+  const ids = Object.keys(accounts);
+  return ids.length === 0 ? [DEFAULT_ACCOUNT_ID] : ids;
 }
 
-export function resolveDefaultFeishuAccountId(_cfg: ClawdbotConfig): string {
-  return DEFAULT_ACCOUNT_ID;
+export function resolveDefaultFeishuAccountId(cfg: ClawdbotConfig): string {
+  const ids = listFeishuAccountIds(cfg);
+  return ids[0] ?? DEFAULT_ACCOUNT_ID;
 }
 
 export function listEnabledFeishuAccounts(cfg: ClawdbotConfig): ResolvedFeishuAccount[] {

package/src/bot.ts

@@ -490,8 +490,9 @@ export async function handleFeishuMessage(params: {
   botOpenId?: string;
   runtime?: RuntimeEnv;
   chatHistories?: Map<string, HistoryEntry[]>;
+  accountId?: string;
 }): Promise<void> {
-  const { cfg, event, botOpenId, runtime, chatHistories } = params;
+  const { cfg, event, botOpenId, runtime, chatHistories, accountId } = params;
   const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
   const log = runtime?.log ?? console.log;
   const error = runtime?.error ?? console.error;
@@ -613,9 +614,18 @@ export async function handleFeishuMessage(params: {
     const feishuFrom = `feishu:${ctx.senderOpenId}`;
     const feishuTo = isGroup ? `chat:${ctx.chatId}` : `user:${ctx.senderOpenId}`;
 
+    // Default DM scope to per-channel-peer so each user gets their own session.
+    // The framework default ("main") would merge all DMs into one shared session.
+    const dmScope = feishuCfg?.dmScope ?? "per-channel-peer";
+    const routingCfg = cfg.session?.dmScope ? cfg : {
+      ...cfg,
+      session: { ...cfg.session, dmScope },
+    };
+
     const route = core.channel.routing.resolveAgentRoute({
-      cfg,
+      cfg: routingCfg,
       channel: "feishu",
+      accountId,
       peer: {
         kind: isGroup ? "group" : "dm",
         id: isGroup ? ctx.chatId : ctx.senderOpenId,

package/src/channel.ts

@@ -1,7 +1,7 @@
 import type { ChannelPlugin, ClawdbotConfig } from "openclaw/plugin-sdk";
 import { DEFAULT_ACCOUNT_ID, PAIRING_APPROVED_MESSAGE } from "openclaw/plugin-sdk";
 import type { ResolvedFeishuAccount, FeishuConfig } from "./types.js";
-import { resolveFeishuAccount, resolveFeishuCredentials } from "./accounts.js";
+import { resolveFeishuAccount, resolveFeishuCredentials, listFeishuAccountIds, mergeFeishuAccountConfig } from "./accounts.js";
 import { feishuOutbound } from "./outbound.js";
 import { probeFeishu } from "./probe.js";
 import { resolveFeishuGroupToolPolicy } from "./policy.js";
@@ -87,24 +87,78 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
         chunkMode: { type: "string", enum: ["length", "newline"] },
         mediaMaxMb: { type: "number", minimum: 0 },
         renderMode: { type: "string", enum: ["auto", "raw", "card"] },
+        accounts: {
+          type: "object",
+          additionalProperties: {
+            type: "object",
+            properties: {
+              enabled: { type: "boolean" },
+              name: { type: "string" },
+              appId: { type: "string" },
+              appSecret: { type: "string" },
+              encryptKey: { type: "string" },
+              verificationToken: { type: "string" },
+              domain: { type: "string", enum: ["feishu", "lark"] },
+              connectionMode: { type: "string", enum: ["websocket", "webhook"] },
+              webhookPath: { type: "string" },
+              webhookPort: { type: "integer", minimum: 1 },
+            },
+          },
+        },
       },
     },
   },
   config: {
-    listAccountIds: () => [DEFAULT_ACCOUNT_ID],
-    resolveAccount: (cfg) => resolveFeishuAccount({ cfg }),
-    defaultAccountId: () => DEFAULT_ACCOUNT_ID,
-    setAccountEnabled: ({ cfg, enabled }) => ({
-      ...cfg,
-      channels: {
-        ...cfg.channels,
-        feishu: {
-          ...cfg.channels?.feishu,
-          enabled,
+    listAccountIds: (cfg) => listFeishuAccountIds(cfg),
+    resolveAccount: (cfg, accountId) => resolveFeishuAccount({ cfg, accountId }),
+    defaultAccountId: (cfg) => listFeishuAccountIds(cfg)[0] ?? DEFAULT_ACCOUNT_ID,
+    setAccountEnabled: ({ cfg, accountId, enabled }) => {
+      const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+      // Per-account enable/disable when using named accounts
+      if (accountId && accountId !== DEFAULT_ACCOUNT_ID && feishuCfg?.accounts?.[accountId]) {
+        return {
+          ...cfg,
+          channels: {
+            ...cfg.channels,
+            feishu: {
+              ...feishuCfg,
+              accounts: {
+                ...feishuCfg.accounts,
+                [accountId]: { ...feishuCfg.accounts[accountId], enabled },
+              },
+            },
+          },
+        };
+      }
+      return {
+        ...cfg,
+        channels: {
+          ...cfg.channels,
+          feishu: {
+            ...cfg.channels?.feishu,
+            enabled,
+          },
         },
-      },
-    }),
-    deleteAccount: ({ cfg }) => {
+      };
+    },
+    deleteAccount: ({ cfg, accountId }) => {
+      const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+      // Delete a named account
+      if (accountId && accountId !== DEFAULT_ACCOUNT_ID && feishuCfg?.accounts) {
+        const nextAccounts = { ...feishuCfg.accounts };
+        delete nextAccounts[accountId];
+        return {
+          ...cfg,
+          channels: {
+            ...cfg.channels,
+            feishu: {
+              ...feishuCfg,
+              accounts: Object.keys(nextAccounts).length > 0 ? nextAccounts : undefined,
+            },
+          },
+        };
+      }
+      // Delete the whole channel (default account)
       const next = { ...cfg } as ClawdbotConfig;
       const nextChannels = { ...cfg.channels };
       delete (nextChannels as Record<string, unknown>).feishu;
@@ -115,8 +169,7 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
       }
       return next;
     },
-    isConfigured: (_account, cfg) =>
-      Boolean(resolveFeishuCredentials(cfg.channels?.feishu as FeishuConfig | undefined)),
+    isConfigured: (account) => account.configured,
     describeAccount: (account) => ({
       accountId: account.accountId,
       enabled: account.enabled,
@@ -142,7 +195,7 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
     },
   },
   setup: {
-    resolveAccountId: () => DEFAULT_ACCOUNT_ID,
+    resolveAccountId: (cfg) => listFeishuAccountIds(cfg)[0] ?? DEFAULT_ACCOUNT_ID,
     applyAccountConfig: ({ cfg }) => ({
       ...cfg,
       channels: {
@@ -193,8 +246,11 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
       probe: snapshot.probe,
       lastProbeAt: snapshot.lastProbeAt ?? null,
     }),
-    probeAccount: async ({ cfg }) =>
-      await probeFeishu(cfg.channels?.feishu as FeishuConfig | undefined),
+    probeAccount: async ({ cfg, accountId }) => {
+      const baseCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+      const merged = baseCfg ? mergeFeishuAccountConfig(baseCfg, accountId ?? DEFAULT_ACCOUNT_ID) : baseCfg;
+      return probeFeishu(merged);
+    },
     buildAccountSnapshot: ({ account, runtime, probe }) => ({
       accountId: account.accountId,
       enabled: account.enabled,
@@ -210,12 +266,23 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
   gateway: {
     startAccount: async (ctx) => {
       const { monitorFeishuProvider } = await import("./monitor.js");
-      const feishuCfg = ctx.cfg.channels?.feishu as FeishuConfig | undefined;
-      const port = feishuCfg?.webhookPort ?? null;
+      const baseCfg = ctx.cfg.channels?.feishu as FeishuConfig | undefined;
+      const merged = baseCfg ? mergeFeishuAccountConfig(baseCfg, ctx.accountId) : baseCfg;
+      const port = merged?.webhookPort ?? null;
+
+      // Inject merged account config so all downstream reads of cfg.channels.feishu get the right values
+      const accountCfg: ClawdbotConfig = {
+        ...ctx.cfg,
+        channels: {
+          ...ctx.cfg.channels,
+          feishu: merged,
+        },
+      };
+
       ctx.setStatus({ accountId: ctx.accountId, port });
-      ctx.log?.info(`starting feishu provider (mode: ${feishuCfg?.connectionMode ?? "websocket"})`);
+      ctx.log?.info(`starting feishu provider (account: ${ctx.accountId}, mode: ${merged?.connectionMode ?? "websocket"})`);
       return monitorFeishuProvider({
-        config: ctx.cfg,
+        config: accountCfg,
         runtime: ctx.runtime,
         abortSignal: ctx.abortSignal,
         accountId: ctx.accountId,

package/src/client.ts

@@ -2,8 +2,8 @@ import * as Lark from "@larksuiteoapi/node-sdk";
 import type { FeishuConfig, FeishuDomain } from "./types.js";
 import { resolveFeishuCredentials } from "./accounts.js";
 
-let cachedClient: Lark.Client | null = null;
-let cachedConfig: { appId: string; appSecret: string; domain: FeishuDomain } | null = null;
+type CachedEntry = { client: Lark.Client; appId: string; appSecret: string; domain: FeishuDomain };
+const clientCache = new Map<string, CachedEntry>();
 
 function resolveDomain(domain: FeishuDomain) {
   return domain === "lark" ? Lark.Domain.Lark : Lark.Domain.Feishu;
@@ -15,14 +15,10 @@ export function createFeishuClient(cfg: FeishuConfig): Lark.Client {
     throw new Error("Feishu credentials not configured (appId, appSecret required)");
   }
 
-  if (
-    cachedClient &&
-    cachedConfig &&
-    cachedConfig.appId === creds.appId &&
-    cachedConfig.appSecret === creds.appSecret &&
-    cachedConfig.domain === creds.domain
-  ) {
-    return cachedClient;
+  const cacheKey = `${creds.appId}:${creds.domain}`;
+  const cached = clientCache.get(cacheKey);
+  if (cached && cached.appSecret === creds.appSecret) {
+    return cached.client;
   }
 
   const client = new Lark.Client({
@@ -32,8 +28,7 @@ export function createFeishuClient(cfg: FeishuConfig): Lark.Client {
     domain: resolveDomain(creds.domain),
   });
 
-  cachedClient = client;
-  cachedConfig = { appId: creds.appId, appSecret: creds.appSecret, domain: creds.domain };
+  clientCache.set(cacheKey, { client, appId: creds.appId, appSecret: creds.appSecret, domain: creds.domain });
 
   return client;
 }
@@ -60,7 +55,10 @@ export function createEventDispatcher(cfg: FeishuConfig): Lark.EventDispatcher {
   });
 }
 
-export function clearClientCache() {
-  cachedClient = null;
-  cachedConfig = null;
+export function clearClientCache(accountKey?: string) {
+  if (accountKey) {
+    clientCache.delete(accountKey);
+  } else {
+    clientCache.clear();
+  }
 }

package/src/config-schema.ts

@@ -33,6 +33,10 @@ const MarkdownConfigSchema = z
 // Message render mode: auto (default) = detect markdown, raw = plain text, card = always card
 const RenderModeSchema = z.enum(["auto", "raw", "card"]).optional();
 
+// DM session scope: controls how session keys are computed for private chats.
+// Framework default is "main" (all DMs share one session), which is rarely desired.
+const DmScopeSchema = z.enum(["main", "per-peer", "per-channel-peer", "per-account-channel-peer"]).optional();
+
 // Reply-to (threading) mode: controls whether bot replies are sent as threaded replies.
 // - "all" (default): always reply in thread (current behavior)
 // - "off": reply in main chat; only thread if the triggering message was already in a thread
@@ -75,6 +79,21 @@ export const FeishuGroupSchema = z
   })
   .strict();
 
+export const FeishuAccountOverrideSchema = z
+  .object({
+    enabled: z.boolean().optional(),
+    name: z.string().optional(),
+    appId: z.string().optional(),
+    appSecret: z.string().optional(),
+    encryptKey: z.string().optional(),
+    verificationToken: z.string().optional(),
+    domain: FeishuDomainSchema.optional(),
+    connectionMode: FeishuConnectionModeSchema.optional(),
+    webhookPath: z.string().optional(),
+    webhookPort: z.number().int().positive().optional(),
+  })
+  .strict();
+
 export const FeishuConfigSchema = z
   .object({
     enabled: z.boolean().optional(),
@@ -106,6 +125,8 @@ export const FeishuConfigSchema = z
     renderMode: RenderModeSchema, // raw = plain text (default), card = interactive card with markdown
     replyToMode: ReplyToModeSchema, // "all" = always thread (default), "off" = main chat unless already in thread
     replyToModeByChatType: ReplyToModeByChatTypeSchema, // per-chat-type overrides for replyToMode
+    dmScope: DmScopeSchema, // override session.dmScope for this channel (default: per-channel-peer)
+    accounts: z.record(z.string(), FeishuAccountOverrideSchema.optional()).optional(),
   })
   .strict()
   .superRefine((value, ctx) => {

package/src/feishu-renderer.ts

@@ -111,6 +111,63 @@ export class FeishuRenderer {
     return `block_${this.blockId}`;
   }
 
+  /**
+   * marked follows CommonMark emphasis delimiter rules. One sharp edge:
+   * sequences like `总花费**$122.64**` (no whitespace before `**` and the
+   * inner text starts with punctuation like `$` or `(`) are tokenized as
+   * plain text, so `**` would be rendered literally.
+   *
+   * For Feishu doc rendering we treat `**...**` inside text tokens as bold
+   * as a permissive fallback, which makes LLM-generated Markdown more robust.
+   */
+  private renderTextTokenWithStrongFallback(text: string): TextElement | TextElement[] {
+    if (!text.includes("**")) return { text_run: { content: text } };
+
+    const elements: TextElement[] = [];
+    let cursor = 0;
+
+    while (cursor < text.length) {
+      const openIdx = text.indexOf("**", cursor);
+      if (openIdx === -1) {
+        const tail = text.slice(cursor);
+        if (tail) elements.push({ text_run: { content: tail } });
+        break;
+      }
+
+      // Plain text before `**`
+      if (openIdx > cursor) {
+        const plain = text.slice(cursor, openIdx);
+        if (plain) elements.push({ text_run: { content: plain } });
+      }
+
+      const contentStart = openIdx + 2;
+      const closeIdx = text.indexOf("**", contentStart);
+      if (closeIdx === -1) {
+        // No matching close delimiter; render the rest literally.
+        const rest = text.slice(openIdx);
+        if (rest) elements.push({ text_run: { content: rest } });
+        break;
+      }
+
+      const boldContent = text.slice(contentStart, closeIdx);
+      if (boldContent) {
+        elements.push({
+          text_run: {
+            content: boldContent,
+            text_element_style: { bold: true },
+          },
+        });
+      } else {
+        // Degenerate `****` case; keep delimiters literal.
+        elements.push({ text_run: { content: "****" } });
+      }
+
+      cursor = closeIdx + 2;
+    }
+
+    return elements.length > 0 ? elements : { text_run: { content: text } };
+  }
+
   /**
    * Render markdown tokens to Feishu blocks.
    */
@@ -244,7 +301,9 @@ export class FeishuRenderer {
         if (textToken.tokens) {
           elements.push(...this.renderInlineTokens(textToken.tokens));
         } else {
-          elements.push({ text_run: { content: textToken.raw } });
+          const fallback = this.renderTextTokenWithStrongFallback(textToken.raw);
+          if (Array.isArray(fallback)) elements.push(...fallback);
+          else elements.push(fallback);
         }
       } else if (child.type === "paragraph") {
         const paraToken = child as Tokens.Paragraph;
@@ -325,7 +384,7 @@ export class FeishuRenderer {
   private renderInline(token: Token): TextElement | TextElement[] | null {
     switch (token.type) {
       case "text":
-        return { text_run: { content: (token as Tokens.Text).text } };
+        return this.renderTextTokenWithStrongFallback((token as Tokens.Text).text);
 
       case "strong": {
         const strongToken = token as Tokens.Strong;

package/src/monitor.ts

@@ -1,6 +1,7 @@
 import http from "node:http";
 import * as Lark from "@larksuiteoapi/node-sdk";
 import type { ClawdbotConfig, RuntimeEnv, HistoryEntry } from "openclaw/plugin-sdk";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk";
 import type { FeishuConfig } from "./types.js";
 import { createFeishuWSClient, createEventDispatcher } from "./client.js";
 import { resolveFeishuCredentials } from "./accounts.js";
@@ -14,9 +15,9 @@ export type MonitorFeishuOpts = {
   accountId?: string;
 };
 
-let currentWsClient: Lark.WSClient | null = null;
-let currentHttpServer: http.Server | null = null;
-let botOpenId: string | undefined;
+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> {
   try {
@@ -33,6 +34,7 @@ export async function monitorFeishuProvider(opts: MonitorFeishuOpts = {}): Promi
     throw new Error("Config is required for Feishu monitor");
   }
 
+  const accountId = opts.accountId ?? DEFAULT_ACCOUNT_ID;
   const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
   const creds = resolveFeishuCredentials(feishuCfg);
   if (!creds) {
@@ -43,17 +45,22 @@ export async function monitorFeishuProvider(opts: MonitorFeishuOpts = {}): Promi
   const error = opts.runtime?.error ?? console.error;
 
   if (feishuCfg) {
-    botOpenId = await fetchBotOpenId(feishuCfg);
-    log(`feishu: bot open_id resolved: ${botOpenId ?? "unknown"}`);
+    const openId = await fetchBotOpenId(feishuCfg);
+    if (openId) {
+      botOpenIds.set(accountId, openId);
+    } else {
+      botOpenIds.delete(accountId);
+    }
+    log(`feishu[${accountId}]: bot open_id resolved: ${openId ?? "unknown"}`);
   }
 
   const connectionMode = feishuCfg?.connectionMode ?? "websocket";
 
   if (connectionMode === "websocket") {
-    return monitorWebSocket({ cfg, feishuCfg: feishuCfg!, runtime: opts.runtime, abortSignal: opts.abortSignal });
+    return monitorWebSocket({ cfg, feishuCfg: feishuCfg!, runtime: opts.runtime, abortSignal: opts.abortSignal, accountId });
   }
 
-  return monitorWebhook({ cfg, feishuCfg: feishuCfg!, runtime: opts.runtime, abortSignal: opts.abortSignal });
+  return monitorWebhook({ cfg, feishuCfg: feishuCfg!, runtime: opts.runtime, abortSignal: opts.abortSignal, accountId });
 }
 
 async function monitorWebSocket(params: {
@@ -61,17 +68,19 @@ async function monitorWebSocket(params: {
   feishuCfg: FeishuConfig;
   runtime?: RuntimeEnv;
   abortSignal?: AbortSignal;
+  accountId: string;
 }): Promise<void> {
-  const { cfg, feishuCfg, runtime, abortSignal } = params;
+  const { cfg, feishuCfg, runtime, abortSignal, accountId } = params;
   const log = runtime?.log ?? console.log;
   const error = runtime?.error ?? console.error;
 
-  log("feishu: starting WebSocket connection...");
+  log(`feishu[${accountId}]: starting WebSocket connection...`);
 
   const wsClient = createFeishuWSClient(feishuCfg);
-  currentWsClient = wsClient;
+  wsClients.set(accountId, wsClient);
 
   const chatHistories = new Map<string, HistoryEntry[]>();
+  const botOpenId = botOpenIds.get(accountId);
 
   const eventDispatcher = createEventDispatcher(feishuCfg);
 
@@ -85,9 +94,10 @@ async function monitorWebSocket(params: {
           botOpenId,
           runtime,
           chatHistories,
+          accountId,
         });
       } catch (err) {
-        error(`feishu: error handling message event: ${String(err)}`);
+        error(`feishu[${accountId}]: error handling message event: ${String(err)}`);
       }
     },
     "im.message.message_read_v1": async () => {
@@ -96,30 +106,30 @@ 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)}`);
       }
     },
   });
 
   return new Promise((resolve, reject) => {
     const cleanup = () => {
-      if (currentWsClient === wsClient) {
-        currentWsClient = null;
+      if (wsClients.get(accountId) === wsClient) {
+        wsClients.delete(accountId);
       }
     };
 
     const handleAbort = () => {
-      log("feishu: abort signal received, stopping WebSocket client");
+      log(`feishu[${accountId}]: abort signal received, stopping WebSocket client`);
       cleanup();
       resolve();
     };
@@ -137,7 +147,7 @@ async function monitorWebSocket(params: {
         eventDispatcher,
       });
 
-      log("feishu: WebSocket client started");
+      log(`feishu[${accountId}]: WebSocket client started`);
     } catch (err) {
       cleanup();
       abortSignal?.removeEventListener("abort", handleAbort);
@@ -146,13 +156,22 @@ async function monitorWebSocket(params: {
   });
 }
 
-export function stopFeishuMonitor(): void {
-  if (currentWsClient) {
-    currentWsClient = null;
-  }
-  if (currentHttpServer) {
-    currentHttpServer.close();
-    currentHttpServer = null;
+export function stopFeishuMonitor(accountId?: string): void {
+  if (accountId) {
+    wsClients.delete(accountId);
+    botOpenIds.delete(accountId);
+    const server = httpServers.get(accountId);
+    if (server) {
+      server.close();
+      httpServers.delete(accountId);
+    }
+  } else {
+    wsClients.clear();
+    botOpenIds.clear();
+    for (const server of httpServers.values()) {
+      server.close();
+    }
+    httpServers.clear();
   }
 }
 
@@ -161,17 +180,19 @@ async function monitorWebhook(params: {
   feishuCfg: FeishuConfig;
   runtime?: RuntimeEnv;
   abortSignal?: AbortSignal;
+  accountId: string;
 }): Promise<void> {
-  const { cfg, feishuCfg, runtime, abortSignal } = params;
+  const { cfg, feishuCfg, runtime, abortSignal, accountId } = params;
   const log = runtime?.log ?? console.log;
   const error = runtime?.error ?? console.error;
 
   const webhookPath = feishuCfg.webhookPath ?? "/feishu/events";
   const webhookPort = feishuCfg.webhookPort ?? 3000;
 
-  log(`feishu: starting webhook server on port ${webhookPort}, path ${webhookPath}...`);
+  log(`feishu[${accountId}]: starting webhook server on port ${webhookPort}, path ${webhookPath}...`);
 
   const chatHistories = new Map<string, HistoryEntry[]>();
+  const botOpenId = botOpenIds.get(accountId);
   const eventDispatcher = createEventDispatcher(feishuCfg);
 
   eventDispatcher.register({
@@ -184,9 +205,10 @@ async function monitorWebhook(params: {
           botOpenId,
           runtime,
           chatHistories,
+          accountId,
         });
       } catch (err) {
-        error(`feishu: error handling message event: ${String(err)}`);
+        error(`feishu[${accountId}]: error handling message event: ${String(err)}`);
       }
     },
     "im.message.message_read_v1": async () => {
@@ -195,33 +217,33 @@ async function monitorWebhook(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)}`);
       }
     },
   });
 
   return new Promise((resolve, reject) => {
     const server = http.createServer();
-    currentHttpServer = server;
+    httpServers.set(accountId, server);
 
     const cleanup = () => {
-      if (currentHttpServer === server) {
-        currentHttpServer = null;
+      if (httpServers.get(accountId) === server) {
+        httpServers.delete(accountId);
       }
     };
 
     const handleAbort = () => {
-      log("feishu: abort signal received, stopping webhook server");
+      log(`feishu[${accountId}]: abort signal received, stopping webhook server`);
       server.close(() => {
         cleanup();
         resolve();
@@ -239,7 +261,7 @@ async function monitorWebhook(params: {
     server.on("error", (err) => {
       cleanup();
       abortSignal?.removeEventListener("abort", handleAbort);
-      error(`feishu: webhook server error: ${String(err)}`);
+      error(`feishu[${accountId}]: webhook server error: ${String(err)}`);
       reject(err);
     });
 
@@ -249,7 +271,7 @@ async function monitorWebhook(params: {
     }));
 
     server.listen(webhookPort, () => {
-      log(`feishu: webhook server started on port ${webhookPort}`);
+      log(`feishu[${accountId}]: webhook server started on port ${webhookPort}`);
     });
   });
 }

package/src/types.ts

@@ -1,8 +1,9 @@
-import type { FeishuConfigSchema, FeishuGroupSchema, z } from "./config-schema.js";
+import type { FeishuConfigSchema, FeishuGroupSchema, FeishuAccountOverrideSchema, z } from "./config-schema.js";
 import type { MentionTarget } from "./mention.js";
 
 export type FeishuConfig = z.infer<typeof FeishuConfigSchema>;
 export type FeishuGroupConfig = z.infer<typeof FeishuGroupSchema>;
+export type FeishuAccountOverride = z.infer<typeof FeishuAccountOverrideSchema>;
 
 export type FeishuDomain = "feishu" | "lark";
 export type FeishuConnectionMode = "websocket" | "webhook";