@m1heng-clawd/feishu 0.1.7 → 0.1.9

package/src/reactions.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";
 
 export type FeishuReaction = {
   reactionId: string;
@@ -18,14 +18,15 @@ export async function addReactionFeishu(params: {
   cfg: ClawdbotConfig;
   messageId: string;
   emojiType: string;
+  accountId?: string;
 }): Promise<{ reactionId: string }> {
-  const { cfg, messageId, emojiType } = params;
-  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg) {
-    throw new Error("Feishu channel not configured");
+  const { cfg, messageId, emojiType, 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.messageReaction.create({
     path: { message_id: messageId },
@@ -59,14 +60,15 @@ export async function removeReactionFeishu(params: {
   cfg: ClawdbotConfig;
   messageId: string;
   reactionId: string;
+  accountId?: string;
 }): Promise<void> {
-  const { cfg, messageId, reactionId } = params;
-  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg) {
-    throw new Error("Feishu channel not configured");
+  const { cfg, messageId, reactionId, 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.messageReaction.delete({
     path: {
@@ -87,14 +89,15 @@ export async function listReactionsFeishu(params: {
   cfg: ClawdbotConfig;
   messageId: string;
   emojiType?: string;
+  accountId?: string;
 }): Promise<FeishuReaction[]> {
-  const { cfg, messageId, emojiType } = params;
-  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg) {
-    throw new Error("Feishu channel not configured");
+  const { cfg, messageId, emojiType, 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.messageReaction.list({
     path: { message_id: messageId },

package/src/reply-dispatcher.ts

@@ -10,6 +10,7 @@ import { getFeishuRuntime } from "./runtime.js";
 import { sendMessageFeishu, sendMarkdownCardFeishu } from "./send.js";
 import type { FeishuConfig } from "./types.js";
 import type { MentionTarget } from "./mention.js";
+import { resolveFeishuAccount } from "./accounts.js";
 import {
   addTypingIndicator,
   removeTypingIndicator,
@@ -36,11 +37,16 @@ export type CreateFeishuReplyDispatcherParams = {
   replyToMessageId?: string;
   /** Mention targets, will be auto-included in replies */
   mentionTargets?: MentionTarget[];
+  /** Account ID for multi-account support */
+  accountId?: string;
 };
 
 export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherParams) {
   const core = getFeishuRuntime();
-  const { cfg, agentId, chatId, replyToMessageId, mentionTargets } = params;
+  const { cfg, agentId, chatId, replyToMessageId, mentionTargets, accountId } = params;
+
+  // Resolve account for config access
+  const account = resolveFeishuAccount({ cfg, accountId });
 
   const prefixContext = createReplyPrefixContext({
     cfg,
@@ -54,14 +60,14 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
   const typingCallbacks = createTypingCallbacks({
     start: async () => {
       if (!replyToMessageId) return;
-      typingState = await addTypingIndicator({ cfg, messageId: replyToMessageId });
-      params.runtime.log?.(`feishu: added typing indicator reaction`);
+      typingState = await addTypingIndicator({ cfg, messageId: replyToMessageId, accountId });
+      params.runtime.log?.(`feishu[${account.accountId}]: added typing indicator reaction`);
     },
     stop: async () => {
       if (!typingState) return;
-      await removeTypingIndicator({ cfg, state: typingState });
+      await removeTypingIndicator({ cfg, state: typingState, accountId });
       typingState = null;
-      params.runtime.log?.(`feishu: removed typing indicator reaction`);
+      params.runtime.log?.(`feishu[${account.accountId}]: removed typing indicator reaction`);
     },
     onStartError: (err) => {
       logTypingFailure({
@@ -99,15 +105,15 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
       humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, agentId),
       onReplyStart: typingCallbacks.onReplyStart,
       deliver: async (payload: ReplyPayload) => {
-        params.runtime.log?.(`feishu deliver called: text=${payload.text?.slice(0, 100)}`);
+        params.runtime.log?.(`feishu[${account.accountId}] deliver called: text=${payload.text?.slice(0, 100)}`);
         const text = payload.text ?? "";
         if (!text.trim()) {
-          params.runtime.log?.(`feishu deliver: empty text, skipping`);
+          params.runtime.log?.(`feishu[${account.accountId}] deliver: empty text, skipping`);
           return;
         }
 
         // Check render mode: auto (default), raw, or card
-        const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+        const feishuCfg = account.config;
         const renderMode = feishuCfg?.renderMode ?? "auto";
 
         // Determine if we should use card for this message
@@ -120,7 +126,7 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
         if (useCard) {
           // Card mode: send as interactive card with markdown rendering
           const chunks = core.channel.text.chunkTextWithMode(text, textChunkLimit, chunkMode);
-          params.runtime.log?.(`feishu deliver: sending ${chunks.length} card chunks to ${chatId}`);
+          params.runtime.log?.(`feishu[${account.accountId}] deliver: sending ${chunks.length} card chunks to ${chatId}`);
           for (const chunk of chunks) {
             await sendMarkdownCardFeishu({
               cfg,
@@ -128,6 +134,7 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
               text: chunk,
               replyToMessageId,
               mentions: isFirstChunk ? mentionTargets : undefined,
+              accountId,
             });
             isFirstChunk = false;
           }
@@ -135,7 +142,7 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
           // Raw mode: send as plain text with table conversion
           const converted = core.channel.text.convertMarkdownTables(text, tableMode);
           const chunks = core.channel.text.chunkTextWithMode(converted, textChunkLimit, chunkMode);
-          params.runtime.log?.(`feishu deliver: sending ${chunks.length} text chunks to ${chatId}`);
+          params.runtime.log?.(`feishu[${account.accountId}] deliver: sending ${chunks.length} text chunks to ${chatId}`);
           for (const chunk of chunks) {
             await sendMessageFeishu({
               cfg,
@@ -143,13 +150,14 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
               text: chunk,
               replyToMessageId,
               mentions: isFirstChunk ? mentionTargets : undefined,
+              accountId,
             });
             isFirstChunk = false;
           }
         }
       },
       onError: (err, info) => {
-        params.runtime.error?.(`feishu ${info.kind} reply failed: ${String(err)}`);
+        params.runtime.error?.(`feishu[${account.accountId}] ${info.kind} reply failed: ${String(err)}`);
         typingCallbacks.onIdle?.();
       },
       onIdle: typingCallbacks.onIdle,

package/src/send.ts

@@ -1,10 +1,11 @@
 import type { ClawdbotConfig } from "openclaw/plugin-sdk";
-import type { FeishuConfig, FeishuSendResult } from "./types.js";
+import type { FeishuSendResult, ResolvedFeishuAccount } from "./types.js";
 import type { MentionTarget } from "./mention.js";
 import { buildMentionedMessage, buildMentionedCardContent } from "./mention.js";
 import { createFeishuClient } from "./client.js";
 import { resolveReceiveIdType, normalizeFeishuTarget } from "./targets.js";
 import { getFeishuRuntime } from "./runtime.js";
+import { resolveFeishuAccount } from "./accounts.js";
 
 export type FeishuMessageInfo = {
   messageId: string;
@@ -23,14 +24,15 @@ export type FeishuMessageInfo = {
 export async function getMessageFeishu(params: {
   cfg: ClawdbotConfig;
   messageId: string;
+  accountId?: string;
 }): Promise<FeishuMessageInfo | null> {
-  const { cfg, messageId } = params;
-  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg) {
-    throw new Error("Feishu channel not configured");
+  const { cfg, messageId, 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);
 
   try {
     const response = (await client.im.message.get({
@@ -95,9 +97,11 @@ export type SendFeishuMessageParams = {
   replyToMessageId?: string;
   /** Mention target users */
   mentions?: MentionTarget[];
+  /** Account ID (optional, uses default if not specified) */
+  accountId?: string;
 };
 
-function buildFeishuPostMessagePayload(params: { feishuCfg: FeishuConfig; messageText: string }): {
+function buildFeishuPostMessagePayload(params: { messageText: string }): {
   content: string;
   msgType: string;
 } {
@@ -120,13 +124,13 @@ function buildFeishuPostMessagePayload(params: { feishuCfg: FeishuConfig; messag
 }
 
 export async function sendMessageFeishu(params: SendFeishuMessageParams): Promise<FeishuSendResult> {
-  const { cfg, to, text, replyToMessageId, mentions } = params;
-  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg) {
-    throw new Error("Feishu channel not configured");
+  const { cfg, to, text, replyToMessageId, mentions, 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}`);
@@ -145,10 +149,7 @@ export async function sendMessageFeishu(params: SendFeishuMessageParams): Promis
   }
   const messageText = getFeishuRuntime().channel.text.convertMarkdownTables(rawText, tableMode);
 
-  const { content, msgType } = buildFeishuPostMessagePayload({
-    feishuCfg,
-    messageText,
-  });
+  const { content, msgType } = buildFeishuPostMessagePayload({ messageText });
 
   if (replyToMessageId) {
     const response = await client.im.message.reply({
@@ -193,16 +194,17 @@ export type SendFeishuCardParams = {
   to: string;
   card: Record<string, unknown>;
   replyToMessageId?: string;
+  accountId?: string;
 };
 
 export async function sendCardFeishu(params: SendFeishuCardParams): Promise<FeishuSendResult> {
-  const { cfg, to, card, replyToMessageId } = params;
-  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg) {
-    throw new Error("Feishu channel not configured");
+  const { cfg, to, card, 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}`);
@@ -253,14 +255,15 @@ export async function updateCardFeishu(params: {
   cfg: ClawdbotConfig;
   messageId: string;
   card: Record<string, unknown>;
+  accountId?: string;
 }): Promise<void> {
-  const { cfg, messageId, card } = params;
-  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg) {
-    throw new Error("Feishu channel not configured");
+  const { cfg, messageId, card, 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 content = JSON.stringify(card);
 
   const response = await client.im.message.patch({
@@ -276,18 +279,22 @@ export async function updateCardFeishu(params: {
 /**
  * Build a Feishu interactive card with markdown content.
  * Cards render markdown properly (code blocks, tables, links, etc.)
+ * Uses schema 2.0 format for proper markdown rendering.
  */
 export function buildMarkdownCard(text: string): Record<string, unknown> {
   return {
+    schema: "2.0",
     config: {
       wide_screen_mode: true,
     },
-    elements: [
-      {
-        tag: "markdown",
-        content: text,
-      },
-    ],
+    body: {
+      elements: [
+        {
+          tag: "markdown",
+          content: text,
+        },
+      ],
+    },
   };
 }
 
@@ -302,15 +309,16 @@ export async function sendMarkdownCardFeishu(params: {
   replyToMessageId?: string;
   /** Mention target users */
   mentions?: MentionTarget[];
+  accountId?: string;
 }): Promise<FeishuSendResult> {
-  const { cfg, to, text, replyToMessageId, mentions } = params;
+  const { cfg, to, text, replyToMessageId, mentions, accountId } = params;
   // Build message content (with @mention support)
   let cardText = text;
   if (mentions && mentions.length > 0) {
     cardText = buildMentionedCardContent(mentions, text);
   }
   const card = buildMarkdownCard(cardText);
-  return sendCardFeishu({ cfg, to, card, replyToMessageId });
+  return sendCardFeishu({ cfg, to, card, replyToMessageId, accountId });
 }
 
 /**
@@ -321,24 +329,22 @@ export async function editMessageFeishu(params: {
   cfg: ClawdbotConfig;
   messageId: string;
   text: string;
+  accountId?: string;
 }): Promise<void> {
-  const { cfg, messageId, text } = params;
-  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg) {
-    throw new Error("Feishu channel not configured");
+  const { cfg, messageId, text, 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 tableMode = getFeishuRuntime().channel.text.resolveMarkdownTableMode({
     cfg,
     channel: "feishu",
   });
   const messageText = getFeishuRuntime().channel.text.convertMarkdownTables(text ?? "", tableMode);
 
-  const { content, msgType } = buildFeishuPostMessagePayload({
-    feishuCfg,
-    messageText,
-  });
+  const { content, msgType } = buildFeishuPostMessagePayload({ messageText });
 
   const response = await client.im.message.update({
     path: { message_id: messageId },

package/src/types.ts

@@ -1,18 +1,25 @@
-import type { FeishuConfigSchema, FeishuGroupSchema, z } from "./config-schema.js";
+import type { FeishuConfigSchema, FeishuGroupSchema, FeishuAccountConfigSchema, 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 FeishuAccountConfig = z.infer<typeof FeishuAccountConfigSchema>;
 
-export type FeishuDomain = "feishu" | "lark";
+export type FeishuDomain = "feishu" | "lark" | (string & {});
 export type FeishuConnectionMode = "websocket" | "webhook";
 
 export type ResolvedFeishuAccount = {
   accountId: string;
   enabled: boolean;
   configured: boolean;
+  name?: string;
   appId?: string;
+  appSecret?: string;
+  encryptKey?: string;
+  verificationToken?: string;
   domain: FeishuDomain;
+  /** Merged config (top-level defaults + account-specific overrides) */
+  config: FeishuConfig;
 };
 
 export type FeishuIdType = "open_id" | "user_id" | "union_id" | "chat_id";
@@ -61,3 +68,10 @@ export type FeishuToolsConfig = {
   perm?: boolean;
   scopes?: boolean;
 };
+
+export type DynamicAgentCreationConfig = {
+  enabled?: boolean;
+  workspaceTemplate?: string;
+  agentDirTemplate?: string;
+  maxAgents?: number;
+};

package/src/typing.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";
 
 // Feishu emoji types for typing indicator
 // See: https://open.feishu.cn/document/server-docs/im-v1/message-reaction/emojis-introduce
@@ -18,14 +18,15 @@ export type TypingIndicatorState = {
 export async function addTypingIndicator(params: {
   cfg: ClawdbotConfig;
   messageId: string;
+  accountId?: string;
 }): Promise<TypingIndicatorState> {
-  const { cfg, messageId } = params;
-  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg) {
+  const { cfg, messageId, accountId } = params;
+  const account = resolveFeishuAccount({ cfg, accountId });
+  if (!account.configured) {
     return { messageId, reactionId: null };
   }
 
-  const client = createFeishuClient(feishuCfg);
+  const client = createFeishuClient(account);
 
   try {
     const response = await client.im.messageReaction.create({
@@ -50,14 +51,15 @@ export async function addTypingIndicator(params: {
 export async function removeTypingIndicator(params: {
   cfg: ClawdbotConfig;
   state: TypingIndicatorState;
+  accountId?: string;
 }): Promise<void> {
-  const { cfg, state } = params;
+  const { cfg, state, accountId } = params;
   if (!state.reactionId) return;
 
-  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg) return;
+  const account = resolveFeishuAccount({ cfg, accountId });
+  if (!account.configured) return;
 
-  const client = createFeishuClient(feishuCfg);
+  const client = createFeishuClient(account);
 
   try {
     await client.im.messageReaction.delete({

package/src/wiki.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 { FeishuWikiSchema, type FeishuWikiParams } from "./wiki-schema.js";
 import { resolveToolsConfig } from "./tools-config.js";
@@ -150,19 +150,25 @@ async function renameNode(
 // ============ Tool Registration ============
 
 export function registerFeishuWikiTools(api: OpenClawPluginApi) {
-  const feishuCfg = api.config?.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg?.appId || !feishuCfg?.appSecret) {
-    api.logger.debug?.("feishu_wiki: Feishu credentials not configured, skipping wiki tools");
+  if (!api.config) {
+    api.logger.debug?.("feishu_wiki: No config available, skipping wiki tools");
     return;
   }
 
-  const toolsCfg = resolveToolsConfig(feishuCfg.tools);
+  const accounts = listEnabledFeishuAccounts(api.config);
+  if (accounts.length === 0) {
+    api.logger.debug?.("feishu_wiki: No Feishu accounts configured, skipping wiki tools");
+    return;
+  }
+
+  const firstAccount = accounts[0];
+  const toolsCfg = resolveToolsConfig(firstAccount.config.tools);
   if (!toolsCfg.wiki) {
     api.logger.debug?.("feishu_wiki: wiki tool disabled in config");
     return;
   }
 
-  const getClient = () => createFeishuClient(feishuCfg);
+  const getClient = () => createFeishuClient(firstAccount);
 
   api.registerTool(
     {