@m1heng-clawd/feishu 0.1.7 → 0.1.9

package/src/bot.ts

@@ -6,9 +6,10 @@ import {
   DEFAULT_GROUP_HISTORY_LIMIT,
   type HistoryEntry,
 } from "openclaw/plugin-sdk";
-import type { FeishuConfig, FeishuMessageContext, FeishuMediaInfo } from "./types.js";
+import type { FeishuConfig, FeishuMessageContext, FeishuMediaInfo, ResolvedFeishuAccount } from "./types.js";
 import { getFeishuRuntime } from "./runtime.js";
 import { createFeishuClient } from "./client.js";
+import { resolveFeishuAccount } from "./accounts.js";
 import {
   resolveFeishuGroupConfig,
   resolveFeishuReplyPolicy,
@@ -23,6 +24,39 @@ import {
   extractMessageBody,
   isMentionForwardRequest,
 } from "./mention.js";
+import { maybeCreateDynamicAgent } from "./dynamic-agent.js";
+import type { DynamicAgentCreationConfig } from "./types.js";
+
+// --- Message deduplication ---
+// Prevent duplicate processing when WebSocket reconnects or Feishu redelivers messages.
+const DEDUP_TTL_MS = 30 * 60 * 1000; // 30 minutes
+const DEDUP_MAX_SIZE = 1_000;
+const DEDUP_CLEANUP_INTERVAL_MS = 5 * 60 * 1000; // cleanup every 5 minutes
+const processedMessageIds = new Map<string, number>(); // messageId -> timestamp
+let lastCleanupTime = Date.now();
+
+function tryRecordMessage(messageId: string): boolean {
+  const now = Date.now();
+
+  // Throttled cleanup: evict expired entries at most once per interval
+  if (now - lastCleanupTime > DEDUP_CLEANUP_INTERVAL_MS) {
+    for (const [id, ts] of processedMessageIds) {
+      if (now - ts > DEDUP_TTL_MS) processedMessageIds.delete(id);
+    }
+    lastCleanupTime = now;
+  }
+
+  if (processedMessageIds.has(messageId)) return false;
+
+  // Evict oldest entries if cache is full
+  if (processedMessageIds.size >= DEDUP_MAX_SIZE) {
+    const first = processedMessageIds.keys().next().value!;
+    processedMessageIds.delete(first);
+  }
+
+  processedMessageIds.set(messageId, now);
+  return true;
+}
 
 // --- Permission error extraction ---
 // Extract permission grant URL from Feishu API error response.
@@ -51,7 +85,7 @@ function extractPermissionError(err: unknown): PermissionError | null {
 
   // Extract the grant URL from the error message (contains the direct link)
   const msg = feishuErr.msg ?? "";
-  const urlMatch = msg.match(/https:\/\/open\.feishu\.cn\/app\/[^\s,]+/);
+  const urlMatch = msg.match(/https:\/\/[^\s,]+\/app\/[^\s,]+/);
   const grantUrl = urlMatch?.[0];
 
   return {
@@ -77,12 +111,12 @@ type SenderNameResult = {
 };
 
 async function resolveFeishuSenderName(params: {
-  feishuCfg?: FeishuConfig;
+  account: ResolvedFeishuAccount;
   senderOpenId: string;
   log: (...args: any[]) => void;
 }): Promise<SenderNameResult> {
-  const { feishuCfg, senderOpenId, log } = params;
-  if (!feishuCfg) return {};
+  const { account, senderOpenId, log } = params;
+  if (!account.configured) return {};
   if (!senderOpenId) return {};
 
   const cached = senderNameCache.get(senderOpenId);
@@ -90,7 +124,7 @@ async function resolveFeishuSenderName(params: {
   if (cached && cached.expireAt > now) return { name: cached.name };
 
   try {
-    const client = createFeishuClient(feishuCfg);
+    const client = createFeishuClient(account);
 
     // contact/v3/users/:user_id?user_id_type=open_id
     const res: any = await client.contact.user.get({
@@ -308,8 +342,9 @@ async function resolveFeishuMediaList(params: {
   content: string;
   maxBytes: number;
   log?: (msg: string) => void;
+  accountId?: string;
 }): Promise<FeishuMediaInfo[]> {
-  const { cfg, messageId, messageType, content, maxBytes, log } = params;
+  const { cfg, messageId, messageType, content, maxBytes, log, accountId } = params;
 
   // Only process media message types (including post for embedded images)
   const mediaTypes = ["image", "file", "audio", "video", "sticker", "post"];
@@ -337,6 +372,7 @@ async function resolveFeishuMediaList(params: {
           messageId,
           fileKey: imageKey,
           type: "image",
+          accountId,
         });
 
         let contentType = result.contentType;
@@ -390,6 +426,7 @@ async function resolveFeishuMediaList(params: {
       messageId,
       fileKey,
       type: resourceType,
+      accountId,
     });
     buffer = result.buffer;
     contentType = result.contentType;
@@ -491,18 +528,30 @@ 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 feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+  const { cfg, event, botOpenId, runtime, chatHistories, accountId } = params;
+  
+  // Resolve account with merged config
+  const account = resolveFeishuAccount({ cfg, accountId });
+  const feishuCfg = account.config;
+  
   const log = runtime?.log ?? console.log;
   const error = runtime?.error ?? console.error;
 
+  // Dedup check: skip if this message was already processed
+  const messageId = event.message.message_id;
+  if (!tryRecordMessage(messageId)) {
+    log(`feishu: skipping duplicate message ${messageId}`);
+    return;
+  }
+
   let ctx = parseFeishuMessageEvent(event, botOpenId);
   const isGroup = ctx.chatType === "group";
 
   // Resolve sender display name (best-effort) so the agent can attribute messages correctly.
   const senderResult = await resolveFeishuSenderName({
-    feishuCfg,
+    account,
     senderOpenId: ctx.senderOpenId,
     log,
   });
@@ -511,7 +560,7 @@ export async function handleFeishuMessage(params: {
   // Track permission error to inform agent later (with cooldown to avoid repetition)
   let permissionErrorForAgent: PermissionError | undefined;
   if (senderResult.permissionError) {
-    const appKey = feishuCfg?.appId ?? "default";
+    const appKey = account.appId ?? "default";
     const now = Date.now();
     const lastNotified = permissionErrorNotifiedAt.get(appKey) ?? 0;
 
@@ -521,12 +570,12 @@ export async function handleFeishuMessage(params: {
     }
   }
 
-  log(`feishu: received message from ${ctx.senderOpenId} in ${ctx.chatId} (${ctx.chatType})`);
+  log(`feishu[${account.accountId}]: received message from ${ctx.senderOpenId} in ${ctx.chatId} (${ctx.chatType})`);
 
   // Log mention targets if detected
   if (ctx.mentionTargets && ctx.mentionTargets.length > 0) {
     const names = ctx.mentionTargets.map((t) => t.name).join(", ");
-    log(`feishu: detected @ forward request, targets: [${names}]`);
+    log(`feishu[${account.accountId}]: detected @ forward request, targets: [${names}]`);
   }
 
   const historyLimit = Math.max(
@@ -537,6 +586,7 @@ export async function handleFeishuMessage(params: {
   if (isGroup) {
     const groupPolicy = feishuCfg?.groupPolicy ?? "open";
     const groupAllowFrom = feishuCfg?.groupAllowFrom ?? [];
+    // DEBUG: log(`feishu[${account.accountId}]: groupPolicy=${groupPolicy}`);
     const groupConfig = resolveFeishuGroupConfig({ cfg: feishuCfg, groupId: ctx.chatId });
 
     // Check if this GROUP is allowed (groupAllowFrom contains group IDs like oc_xxx, not user IDs)
@@ -548,7 +598,7 @@ export async function handleFeishuMessage(params: {
     });
 
     if (!groupAllowed) {
-      log(`feishu: group ${ctx.chatId} not in allowlist`);
+      log(`feishu[${account.accountId}]: sender ${ctx.senderOpenId} not in group allowlist`);
       return;
     }
 
@@ -574,7 +624,7 @@ export async function handleFeishuMessage(params: {
     });
 
     if (requireMention && !ctx.mentionedBot) {
-      log(`feishu: message in group ${ctx.chatId} did not mention bot, recording to history`);
+      log(`feishu[${account.accountId}]: message in group ${ctx.chatId} did not mention bot, recording to history`);
       if (chatHistories) {
         recordPendingHistoryEntryIfEnabled({
           historyMap: chatHistories,
@@ -600,7 +650,7 @@ export async function handleFeishuMessage(params: {
         senderId: ctx.senderOpenId,
       });
       if (!match.allowed) {
-        log(`feishu: sender ${ctx.senderOpenId} not in DM allowlist`);
+        log(`feishu[${account.accountId}]: sender ${ctx.senderOpenId} not in DM allowlist`);
         return;
       }
     }
@@ -614,19 +664,62 @@ export async function handleFeishuMessage(params: {
     const feishuFrom = `feishu:${ctx.senderOpenId}`;
     const feishuTo = isGroup ? `chat:${ctx.chatId}` : `user:${ctx.senderOpenId}`;
 
-    const route = core.channel.routing.resolveAgentRoute({
+    // Resolve peer ID for session routing
+    // When topicSessionMode is enabled, messages within a topic (identified by root_id)
+    // get a separate session from the main group chat.
+    let peerId = isGroup ? ctx.chatId : ctx.senderOpenId;
+    if (isGroup && ctx.rootId) {
+      const groupConfig = resolveFeishuGroupConfig({ cfg: feishuCfg, groupId: ctx.chatId });
+      const topicSessionMode = groupConfig?.topicSessionMode ?? feishuCfg?.topicSessionMode ?? "disabled";
+      if (topicSessionMode === "enabled") {
+        // Use chatId:topic:rootId as peer ID for topic-scoped sessions
+        peerId = `${ctx.chatId}:topic:${ctx.rootId}`;
+        log(`feishu[${account.accountId}]: topic session isolation enabled, peer=${peerId}`);
+      }
+    }
+
+    let route = core.channel.routing.resolveAgentRoute({
       cfg,
       channel: "feishu",
+      accountId: account.accountId,
       peer: {
-        kind: isGroup ? "group" : "dm",
-        id: isGroup ? ctx.chatId : ctx.senderOpenId,
+        kind: isGroup ? "group" : "direct",
+        id: peerId,
       },
     });
 
+    // Dynamic agent creation for DM users
+    // When enabled, creates a unique agent instance with its own workspace for each DM user.
+    let effectiveCfg = cfg;
+    if (!isGroup && route.matchedBy === "default") {
+      const dynamicCfg = feishuCfg?.dynamicAgentCreation as DynamicAgentCreationConfig | undefined;
+      if (dynamicCfg?.enabled) {
+        const runtime = getFeishuRuntime();
+        const result = await maybeCreateDynamicAgent({
+          cfg,
+          runtime,
+          senderOpenId: ctx.senderOpenId,
+          dynamicCfg,
+          log: (msg) => log(msg),
+        });
+        if (result.created) {
+          effectiveCfg = result.updatedCfg;
+          // Re-resolve route with updated config
+          route = core.channel.routing.resolveAgentRoute({
+            cfg: result.updatedCfg,
+            channel: "feishu",
+            accountId: account.accountId,
+            peer: { kind: "dm", id: ctx.senderOpenId },
+          });
+          log(`feishu[${account.accountId}]: dynamic agent created, new route: ${route.sessionKey}`);
+        }
+      }
+    }
+
     const preview = ctx.content.replace(/\s+/g, " ").slice(0, 160);
     const inboundLabel = isGroup
-      ? `Feishu message in group ${ctx.chatId}`
-      : `Feishu DM from ${ctx.senderOpenId}`;
+      ? `Feishu[${account.accountId}] message in group ${ctx.chatId}`
+      : `Feishu[${account.accountId}] DM from ${ctx.senderOpenId}`;
 
     core.system.enqueueSystemEvent(`${inboundLabel}: ${preview}`, {
       sessionKey: route.sessionKey,
@@ -642,6 +735,7 @@ export async function handleFeishuMessage(params: {
       content: event.message.content,
       maxBytes: mediaMaxBytes,
       log,
+      accountId: account.accountId,
     });
     const mediaPayload = buildFeishuMediaPayload(mediaList);
 
@@ -649,13 +743,13 @@ export async function handleFeishuMessage(params: {
     let quotedContent: string | undefined;
     if (ctx.parentId) {
       try {
-        const quotedMsg = await getMessageFeishu({ cfg, messageId: ctx.parentId });
+        const quotedMsg = await getMessageFeishu({ cfg, messageId: ctx.parentId, accountId: account.accountId });
         if (quotedMsg) {
           quotedContent = quotedMsg.content;
-          log(`feishu: fetched quoted message: ${quotedContent?.slice(0, 100)}`);
+          log(`feishu[${account.accountId}]: fetched quoted message: ${quotedContent?.slice(0, 100)}`);
         }
       } catch (err) {
-        log(`feishu: failed to fetch quoted message: ${String(err)}`);
+        log(`feishu[${account.accountId}]: failed to fetch quoted message: ${String(err)}`);
       }
     }
 
@@ -722,9 +816,10 @@ export async function handleFeishuMessage(params: {
           runtime: runtime as RuntimeEnv,
           chatId: ctx.chatId,
           replyToMessageId: ctx.messageId,
+          accountId: account.accountId,
         });
 
-      log(`feishu: dispatching permission error notification to agent`);
+      log(`feishu[${account.accountId}]: dispatching permission error notification to agent`);
 
       await core.channel.reply.dispatchReplyFromConfig({
         ctx: permissionCtx,
@@ -795,9 +890,10 @@ export async function handleFeishuMessage(params: {
       chatId: ctx.chatId,
       replyToMessageId: ctx.messageId,
       mentionTargets: ctx.mentionTargets,
+      accountId: account.accountId,
     });
 
-    log(`feishu: dispatching to agent (session=${route.sessionKey})`);
+    log(`feishu[${account.accountId}]: dispatching to agent (session=${route.sessionKey})`);
 
     const { queuedFinal, counts } = await core.channel.reply.dispatchReplyFromConfig({
       ctx: ctxPayload,
@@ -816,8 +912,8 @@ export async function handleFeishuMessage(params: {
       });
     }
 
-    log(`feishu: dispatch complete (queuedFinal=${queuedFinal}, replies=${counts.final})`);
+    log(`feishu[${account.accountId}]: dispatch complete (queuedFinal=${queuedFinal}, replies=${counts.final})`);
   } catch (err) {
-    error(`feishu: failed to dispatch message: ${String(err)}`);
+    error(`feishu[${account.accountId}]: failed to dispatch message: ${String(err)}`);
   }
 }

package/src/channel.ts

@@ -1,7 +1,12 @@
 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,
+  resolveDefaultFeishuAccountId,
+} from "./accounts.js";
 import { feishuOutbound } from "./outbound.js";
 import { probeFeishu } from "./probe.js";
 import { resolveFeishuGroupToolPolicy } from "./policy.js";
@@ -34,11 +39,12 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
   pairing: {
     idLabel: "feishuUserId",
     normalizeAllowEntry: (entry) => entry.replace(/^(feishu|user|open_id):/i, ""),
-    notifyApproval: async ({ cfg, id }) => {
+    notifyApproval: async ({ cfg, id, accountId }) => {
       await sendMessageFeishu({
         cfg,
         to: id,
         text: PAIRING_APPROVED_MESSAGE,
+        accountId,
       });
     },
   },
@@ -71,7 +77,12 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
         appSecret: { type: "string" },
         encryptKey: { type: "string" },
         verificationToken: { type: "string" },
-        domain: { type: "string", enum: ["feishu", "lark"] },
+        domain: {
+          oneOf: [
+            { type: "string", enum: ["feishu", "lark"] },
+            { type: "string", format: "uri", pattern: "^https://" },
+          ],
+        },
         connectionMode: { type: "string", enum: ["websocket", "webhook"] },
         webhookPath: { type: "string" },
         webhookPort: { type: "integer", minimum: 1 },
@@ -80,49 +91,118 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
         groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
         groupAllowFrom: { type: "array", items: { oneOf: [{ type: "string" }, { type: "number" }] } },
         requireMention: { type: "boolean" },
+        topicSessionMode: { type: "string", enum: ["disabled", "enabled"] },
         historyLimit: { type: "integer", minimum: 0 },
         dmHistoryLimit: { type: "integer", minimum: 0 },
         textChunkLimit: { type: "integer", minimum: 1 },
         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"] },
+            },
+          },
+        },
       },
     },
   },
   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) => resolveDefaultFeishuAccountId(cfg),
+    setAccountEnabled: ({ cfg, accountId, enabled }) => {
+      const account = resolveFeishuAccount({ cfg, accountId });
+      const isDefault = accountId === DEFAULT_ACCOUNT_ID;
+      
+      if (isDefault) {
+        // For default account, set top-level enabled
+        return {
+          ...cfg,
+          channels: {
+            ...cfg.channels,
+            feishu: {
+              ...cfg.channels?.feishu,
+              enabled,
+            },
+          },
+        };
+      }
+      
+      // For named accounts, set enabled in accounts[accountId]
+      const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+      return {
+        ...cfg,
+        channels: {
+          ...cfg.channels,
+          feishu: {
+            ...feishuCfg,
+            accounts: {
+              ...feishuCfg?.accounts,
+              [accountId]: {
+                ...feishuCfg?.accounts?.[accountId],
+                enabled,
+              },
+            },
+          },
         },
-      },
-    }),
-    deleteAccount: ({ cfg }) => {
-      const next = { ...cfg } as ClawdbotConfig;
-      const nextChannels = { ...cfg.channels };
-      delete (nextChannels as Record<string, unknown>).feishu;
-      if (Object.keys(nextChannels).length > 0) {
-        next.channels = nextChannels;
-      } else {
-        delete next.channels;
+      };
+    },
+    deleteAccount: ({ cfg, accountId }) => {
+      const isDefault = accountId === DEFAULT_ACCOUNT_ID;
+      
+      if (isDefault) {
+        // Delete entire feishu config
+        const next = { ...cfg } as ClawdbotConfig;
+        const nextChannels = { ...cfg.channels };
+        delete (nextChannels as Record<string, unknown>).feishu;
+        if (Object.keys(nextChannels).length > 0) {
+          next.channels = nextChannels;
+        } else {
+          delete next.channels;
+        }
+        return next;
       }
-      return next;
+      
+      // Delete specific account from accounts
+      const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+      const accounts = { ...feishuCfg?.accounts };
+      delete accounts[accountId];
+      
+      return {
+        ...cfg,
+        channels: {
+          ...cfg.channels,
+          feishu: {
+            ...feishuCfg,
+            accounts: Object.keys(accounts).length > 0 ? accounts : undefined,
+          },
+        },
+      };
     },
-    isConfigured: (_account, cfg) =>
-      Boolean(resolveFeishuCredentials(cfg.channels?.feishu as FeishuConfig | undefined)),
+    isConfigured: (account) => account.configured,
     describeAccount: (account) => ({
       accountId: account.accountId,
       enabled: account.enabled,
       configured: account.configured,
+      name: account.name,
+      appId: account.appId,
+      domain: account.domain,
     }),
-    resolveAllowFrom: ({ cfg }) =>
-      (cfg.channels?.feishu as FeishuConfig | undefined)?.allowFrom ?? [],
+    resolveAllowFrom: ({ cfg, accountId }) => {
+      const account = resolveFeishuAccount({ cfg, accountId });
+      return account.config?.allowFrom ?? [];
+    },
     formatAllowFrom: ({ allowFrom }) =>
       allowFrom
         .map((entry) => String(entry).trim())
@@ -130,28 +210,53 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
         .map((entry) => entry.toLowerCase()),
   },
   security: {
-    collectWarnings: ({ cfg }) => {
-      const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+    collectWarnings: ({ cfg, accountId }) => {
+      const account = resolveFeishuAccount({ cfg, accountId });
+      const feishuCfg = account.config;
       const defaultGroupPolicy = (cfg.channels as Record<string, { groupPolicy?: string }> | undefined)?.defaults?.groupPolicy;
       const groupPolicy = feishuCfg?.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
       if (groupPolicy !== "open") return [];
       return [
-        `- Feishu groups: groupPolicy="open" allows any member to trigger (mention-gated). Set channels.feishu.groupPolicy="allowlist" + channels.feishu.groupAllowFrom to restrict senders.`,
+        `- Feishu[${account.accountId}] groups: groupPolicy="open" allows any member to trigger (mention-gated). Set channels.feishu.groupPolicy="allowlist" + channels.feishu.groupAllowFrom to restrict senders.`,
       ];
     },
   },
   setup: {
     resolveAccountId: () => DEFAULT_ACCOUNT_ID,
-    applyAccountConfig: ({ cfg }) => ({
-      ...cfg,
-      channels: {
-        ...cfg.channels,
-        feishu: {
-          ...cfg.channels?.feishu,
-          enabled: true,
+    applyAccountConfig: ({ cfg, accountId }) => {
+      const isDefault = !accountId || accountId === DEFAULT_ACCOUNT_ID;
+      
+      if (isDefault) {
+        return {
+          ...cfg,
+          channels: {
+            ...cfg.channels,
+            feishu: {
+              ...cfg.channels?.feishu,
+              enabled: true,
+            },
+          },
+        };
+      }
+      
+      const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+      return {
+        ...cfg,
+        channels: {
+          ...cfg.channels,
+          feishu: {
+            ...feishuCfg,
+            accounts: {
+              ...feishuCfg?.accounts,
+              [accountId]: {
+                ...feishuCfg?.accounts?.[accountId],
+                enabled: true,
+              },
+            },
+          },
         },
-      },
-    }),
+      };
+    },
   },
   onboarding: feishuOnboardingAdapter,
   messaging: {
@@ -163,14 +268,14 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
   },
   directory: {
     self: async () => null,
-    listPeers: async ({ cfg, query, limit }) =>
-      listFeishuDirectoryPeers({ cfg, query, limit }),
-    listGroups: async ({ cfg, query, limit }) =>
-      listFeishuDirectoryGroups({ cfg, query, limit }),
-    listPeersLive: async ({ cfg, query, limit }) =>
-      listFeishuDirectoryPeersLive({ cfg, query, limit }),
-    listGroupsLive: async ({ cfg, query, limit }) =>
-      listFeishuDirectoryGroupsLive({ cfg, query, limit }),
+    listPeers: async ({ cfg, query, limit, accountId }) =>
+      listFeishuDirectoryPeers({ cfg, query, limit, accountId }),
+    listGroups: async ({ cfg, query, limit, accountId }) =>
+      listFeishuDirectoryGroups({ cfg, query, limit, accountId }),
+    listPeersLive: async ({ cfg, query, limit, accountId }) =>
+      listFeishuDirectoryPeersLive({ cfg, query, limit, accountId }),
+    listGroupsLive: async ({ cfg, query, limit, accountId }) =>
+      listFeishuDirectoryGroupsLive({ cfg, query, limit, accountId }),
   },
   outbound: feishuOutbound,
   status: {
@@ -192,12 +297,17 @@ 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 account = resolveFeishuAccount({ cfg, accountId });
+      return await probeFeishu(account);
+    },
     buildAccountSnapshot: ({ account, runtime, probe }) => ({
       accountId: account.accountId,
       enabled: account.enabled,
       configured: account.configured,
+      name: account.name,
+      appId: account.appId,
+      domain: account.domain,
       running: runtime?.running ?? false,
       lastStartAt: runtime?.lastStartAt ?? null,
       lastStopAt: runtime?.lastStopAt ?? null,
@@ -209,10 +319,10 @@ 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 account = resolveFeishuAccount({ cfg: ctx.cfg, accountId: ctx.accountId });
+      const port = account.config?.webhookPort ?? null;
       ctx.setStatus({ accountId: ctx.accountId, port });
-      ctx.log?.info(`starting feishu provider (mode: ${feishuCfg?.connectionMode ?? "websocket"})`);
+      ctx.log?.info(`starting feishu[${ctx.accountId}] (mode: ${account.config?.connectionMode ?? "websocket"})`);
       return monitorFeishuProvider({
         config: ctx.cfg,
         runtime: ctx.runtime,