@m1heng-clawd/feishu 0.1.7 → 0.1.9

package/src/client.ts

@@ -1,66 +1,114 @@
 import * as Lark from "@larksuiteoapi/node-sdk";
-import type { FeishuConfig, FeishuDomain } from "./types.js";
-import { resolveFeishuCredentials } from "./accounts.js";
+import type { FeishuDomain, ResolvedFeishuAccount } from "./types.js";
 
-let cachedClient: Lark.Client | null = null;
-let cachedConfig: { appId: string; appSecret: string; domain: FeishuDomain } | null = null;
+// Multi-account client cache
+const clientCache = new Map<
+  string,
+  {
+    client: Lark.Client;
+    config: { appId: string; appSecret: string; domain?: FeishuDomain };
+  }
+>();
 
-function resolveDomain(domain: FeishuDomain) {
-  return domain === "lark" ? Lark.Domain.Lark : Lark.Domain.Feishu;
+function resolveDomain(domain: FeishuDomain | undefined): Lark.Domain | string {
+  if (domain === "lark") return Lark.Domain.Lark;
+  if (domain === "feishu" || !domain) return Lark.Domain.Feishu;
+  return domain.replace(/\/+$/, ""); // Custom URL for private deployment
 }
 
-export function createFeishuClient(cfg: FeishuConfig): Lark.Client {
-  const creds = resolveFeishuCredentials(cfg);
-  if (!creds) {
-    throw new Error("Feishu credentials not configured (appId, appSecret required)");
+/**
+ * Credentials needed to create a Feishu client.
+ * Both FeishuConfig and ResolvedFeishuAccount satisfy this interface.
+ */
+export type FeishuClientCredentials = {
+  accountId?: string;
+  appId?: string;
+  appSecret?: string;
+  domain?: FeishuDomain;
+};
+
+/**
+ * Create or get a cached Feishu client for an account.
+ * Accepts any object with appId, appSecret, and optional domain/accountId.
+ */
+export function createFeishuClient(creds: FeishuClientCredentials): Lark.Client {
+  const { accountId = "default", appId, appSecret, domain } = creds;
+
+  if (!appId || !appSecret) {
+    throw new Error(`Feishu credentials not configured for account "${accountId}"`);
   }
 
+  // Check cache
+  const cached = clientCache.get(accountId);
   if (
-    cachedClient &&
-    cachedConfig &&
-    cachedConfig.appId === creds.appId &&
-    cachedConfig.appSecret === creds.appSecret &&
-    cachedConfig.domain === creds.domain
+    cached &&
+    cached.config.appId === appId &&
+    cached.config.appSecret === appSecret &&
+    cached.config.domain === domain
   ) {
-    return cachedClient;
+    return cached.client;
   }
 
+  // Create new client
   const client = new Lark.Client({
-    appId: creds.appId,
-    appSecret: creds.appSecret,
+    appId,
+    appSecret,
     appType: Lark.AppType.SelfBuild,
-    domain: resolveDomain(creds.domain),
+    domain: resolveDomain(domain),
   });
 
-  cachedClient = client;
-  cachedConfig = { appId: creds.appId, appSecret: creds.appSecret, domain: creds.domain };
+  // Cache it
+  clientCache.set(accountId, {
+    client,
+    config: { appId, appSecret, domain },
+  });
 
   return client;
 }
 
-export function createFeishuWSClient(cfg: FeishuConfig): Lark.WSClient {
-  const creds = resolveFeishuCredentials(cfg);
-  if (!creds) {
-    throw new Error("Feishu credentials not configured (appId, appSecret required)");
+/**
+ * Create a Feishu WebSocket client for an account.
+ * Note: WSClient is not cached since each call creates a new connection.
+ */
+export function createFeishuWSClient(account: ResolvedFeishuAccount): Lark.WSClient {
+  const { accountId, appId, appSecret, domain } = account;
+
+  if (!appId || !appSecret) {
+    throw new Error(`Feishu credentials not configured for account "${accountId}"`);
   }
 
   return new Lark.WSClient({
-    appId: creds.appId,
-    appSecret: creds.appSecret,
-    domain: resolveDomain(creds.domain),
+    appId,
+    appSecret,
+    domain: resolveDomain(domain),
     loggerLevel: Lark.LoggerLevel.info,
   });
 }
 
-export function createEventDispatcher(cfg: FeishuConfig): Lark.EventDispatcher {
-  const creds = resolveFeishuCredentials(cfg);
+/**
+ * Create an event dispatcher for an account.
+ */
+export function createEventDispatcher(account: ResolvedFeishuAccount): Lark.EventDispatcher {
   return new Lark.EventDispatcher({
-    encryptKey: creds?.encryptKey,
-    verificationToken: creds?.verificationToken,
+    encryptKey: account.encryptKey,
+    verificationToken: account.verificationToken,
   });
 }
 
-export function clearClientCache() {
-  cachedClient = null;
-  cachedConfig = null;
+/**
+ * Get a cached client for an account (if exists).
+ */
+export function getFeishuClient(accountId: string): Lark.Client | null {
+  return clientCache.get(accountId)?.client ?? null;
+}
+
+/**
+ * Clear client cache for a specific account or all accounts.
+ */
+export function clearClientCache(accountId?: string): void {
+  if (accountId) {
+    clientCache.delete(accountId);
+  } else {
+    clientCache.clear();
+  }
 }

package/src/config-schema.ts

@@ -3,7 +3,10 @@ export { z };
 
 const DmPolicySchema = z.enum(["open", "pairing", "allowlist"]);
 const GroupPolicySchema = z.enum(["open", "allowlist", "disabled"]);
-const FeishuDomainSchema = z.enum(["feishu", "lark"]);
+const FeishuDomainSchema = z.union([
+  z.enum(["feishu", "lark"]),
+  z.string().url().startsWith("https://"),
+]);
 const FeishuConnectionModeSchema = z.enum(["websocket", "webhook"]);
 
 const ToolPolicySchema = z
@@ -50,6 +53,20 @@ const ChannelHeartbeatVisibilitySchema = z
   .strict()
   .optional();
 
+/**
+ * Dynamic agent creation configuration.
+ * When enabled, a new agent is created for each unique DM user.
+ */
+const DynamicAgentCreationSchema = z
+  .object({
+    enabled: z.boolean().optional(),
+    workspaceTemplate: z.string().optional(),
+    agentDirTemplate: z.string().optional(),
+    maxAgents: z.number().int().positive().optional(),
+  })
+  .strict()
+  .optional();
+
 /**
  * Feishu tools configuration.
  * Controls which tool categories are enabled.
@@ -69,6 +86,16 @@ const FeishuToolsConfigSchema = z
   .strict()
   .optional();
 
+/**
+ * Topic session isolation mode for group chats.
+ * - "disabled" (default): All messages in a group share one session
+ * - "enabled": Messages in different topics get separate sessions
+ *
+ * When enabled, the session key becomes `chat:{chatId}:topic:{rootId}`
+ * for messages within a topic thread, allowing isolated conversations.
+ */
+const TopicSessionModeSchema = z.enum(["disabled", "enabled"]).optional();
+
 export const FeishuGroupSchema = z
   .object({
     requireMention: z.boolean().optional(),
@@ -77,12 +104,52 @@ export const FeishuGroupSchema = z
     enabled: z.boolean().optional(),
     allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
     systemPrompt: z.string().optional(),
+    topicSessionMode: TopicSessionModeSchema,
+  })
+  .strict();
+
+/**
+ * Per-account configuration.
+ * All fields are optional - missing fields inherit from top-level config.
+ */
+export const FeishuAccountConfigSchema = z
+  .object({
+    enabled: z.boolean().optional(),
+    name: z.string().optional(), // Display name for this account
+    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(),
+    capabilities: z.array(z.string()).optional(),
+    markdown: MarkdownConfigSchema,
+    configWrites: z.boolean().optional(),
+    dmPolicy: DmPolicySchema.optional(),
+    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+    groupPolicy: GroupPolicySchema.optional(),
+    groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+    requireMention: z.boolean().optional(),
+    groups: z.record(z.string(), FeishuGroupSchema.optional()).optional(),
+    historyLimit: z.number().int().min(0).optional(),
+    dmHistoryLimit: z.number().int().min(0).optional(),
+    dms: z.record(z.string(), DmConfigSchema).optional(),
+    textChunkLimit: z.number().int().positive().optional(),
+    chunkMode: z.enum(["length", "newline"]).optional(),
+    blockStreamingCoalesce: BlockStreamingCoalesceSchema,
+    mediaMaxMb: z.number().positive().optional(),
+    heartbeat: ChannelHeartbeatVisibilitySchema,
+    renderMode: RenderModeSchema,
+    tools: FeishuToolsConfigSchema,
   })
   .strict();
 
 export const FeishuConfigSchema = z
   .object({
     enabled: z.boolean().optional(),
+    // Top-level credentials (backward compatible for single-account mode)
     appId: z.string().optional(),
     appSecret: z.string().optional(),
     encryptKey: z.string().optional(),
@@ -100,6 +167,7 @@ export const FeishuConfigSchema = z
     groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
     requireMention: z.boolean().optional().default(true),
     groups: z.record(z.string(), FeishuGroupSchema.optional()).optional(),
+    topicSessionMode: TopicSessionModeSchema,
     historyLimit: z.number().int().min(0).optional(),
     dmHistoryLimit: z.number().int().min(0).optional(),
     dms: z.record(z.string(), DmConfigSchema).optional(),
@@ -110,6 +178,10 @@ export const FeishuConfigSchema = z
     heartbeat: ChannelHeartbeatVisibilitySchema,
     renderMode: RenderModeSchema, // raw = plain text (default), card = interactive card with markdown
     tools: FeishuToolsConfigSchema,
+    // Dynamic agent creation for DM users
+    dynamicAgentCreation: DynamicAgentCreationSchema,
+    // Multi-account configuration
+    accounts: z.record(z.string(), FeishuAccountConfigSchema.optional()).optional(),
   })
   .strict()
   .superRefine((value, ctx) => {

package/src/directory.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 { normalizeFeishuTarget } from "./targets.js";
 
 export type FeishuDirectoryPeer = {
@@ -19,8 +19,10 @@ export async function listFeishuDirectoryPeers(params: {
   cfg: ClawdbotConfig;
   query?: string;
   limit?: number;
+  accountId?: string;
 }): Promise<FeishuDirectoryPeer[]> {
-  const feishuCfg = params.cfg.channels?.feishu as FeishuConfig | undefined;
+  const account = resolveFeishuAccount({ cfg: params.cfg, accountId: params.accountId });
+  const feishuCfg = account.config;
   const q = params.query?.trim().toLowerCase() || "";
   const ids = new Set<string>();
 
@@ -47,8 +49,10 @@ export async function listFeishuDirectoryGroups(params: {
   cfg: ClawdbotConfig;
   query?: string;
   limit?: number;
+  accountId?: string;
 }): Promise<FeishuDirectoryGroup[]> {
-  const feishuCfg = params.cfg.channels?.feishu as FeishuConfig | undefined;
+  const account = resolveFeishuAccount({ cfg: params.cfg, accountId: params.accountId });
+  const feishuCfg = account.config;
   const q = params.query?.trim().toLowerCase() || "";
   const ids = new Set<string>();
 
@@ -74,14 +78,15 @@ export async function listFeishuDirectoryPeersLive(params: {
   cfg: ClawdbotConfig;
   query?: string;
   limit?: number;
+  accountId?: string;
 }): Promise<FeishuDirectoryPeer[]> {
-  const feishuCfg = params.cfg.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg?.appId || !feishuCfg?.appSecret) {
+  const account = resolveFeishuAccount({ cfg: params.cfg, accountId: params.accountId });
+  if (!account.configured) {
     return listFeishuDirectoryPeers(params);
   }
 
   try {
-    const client = createFeishuClient(feishuCfg);
+    const client = createFeishuClient(account);
     const peers: FeishuDirectoryPeer[] = [];
     const limit = params.limit ?? 50;
 
@@ -118,14 +123,15 @@ export async function listFeishuDirectoryGroupsLive(params: {
   cfg: ClawdbotConfig;
   query?: string;
   limit?: number;
+  accountId?: string;
 }): Promise<FeishuDirectoryGroup[]> {
-  const feishuCfg = params.cfg.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg?.appId || !feishuCfg?.appSecret) {
+  const account = resolveFeishuAccount({ cfg: params.cfg, accountId: params.accountId });
+  if (!account.configured) {
     return listFeishuDirectoryGroups(params);
   }
 
   try {
-    const client = createFeishuClient(feishuCfg);
+    const client = createFeishuClient(account);
     const groups: FeishuDirectoryGroup[] = [];
     const limit = params.limit ?? 50;
 

package/src/docx.ts

@@ -1,7 +1,7 @@
 import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { createFeishuClient } from "./client.js";
-import type { FeishuConfig } from "./types.js";
+import { resolveFeishuAccount, listEnabledFeishuAccounts } from "./accounts.js";
 import type * as Lark from "@larksuiteoapi/node-sdk";
 import { Readable } from "stream";
 import { FeishuDocSchema, type FeishuDocParams } from "./doc-schema.js";
@@ -388,14 +388,24 @@ async function listAppScopes(client: Lark.Client) {
 // ============ Tool Registration ============
 
 export function registerFeishuDocTools(api: OpenClawPluginApi) {
-  const feishuCfg = api.config?.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg?.appId || !feishuCfg?.appSecret) {
-    api.logger.debug?.("feishu_doc: Feishu credentials not configured, skipping doc tools");
+  if (!api.config) {
+    api.logger.debug?.("feishu_doc: No config available, skipping doc tools");
     return;
   }
 
-  const toolsCfg = resolveToolsConfig(feishuCfg.tools);
-  const getClient = () => createFeishuClient(feishuCfg);
+  // Check if any account is configured
+  const accounts = listEnabledFeishuAccounts(api.config);
+  if (accounts.length === 0) {
+    api.logger.debug?.("feishu_doc: No Feishu accounts configured, skipping doc tools");
+    return;
+  }
+
+  // Use first account's config for tools configuration
+  const firstAccount = accounts[0];
+  const toolsCfg = resolveToolsConfig(firstAccount.config.tools);
+  
+  // Helper to get client for the default account
+  const getClient = () => createFeishuClient(firstAccount);
   const registered: string[] = [];
 
   // Main document tool with action-based dispatch

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

package/src/dynamic-agent.ts

@@ -0,0 +1,131 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
+import type { DynamicAgentCreationConfig } from "./types.js";
+
+export type MaybeCreateDynamicAgentResult = {
+  created: boolean;
+  updatedCfg: OpenClawConfig;
+  agentId?: string;
+};
+
+/**
+ * Check if a dynamic agent should be created for a DM user and create it if needed.
+ * This creates a unique agent instance with its own workspace for each DM user.
+ */
+export async function maybeCreateDynamicAgent(params: {
+  cfg: OpenClawConfig;
+  runtime: PluginRuntime;
+  senderOpenId: string;
+  dynamicCfg: DynamicAgentCreationConfig;
+  log: (msg: string) => void;
+}): Promise<MaybeCreateDynamicAgentResult> {
+  const { cfg, runtime, senderOpenId, dynamicCfg, log } = params;
+
+  // Check if there's already a binding for this user
+  const existingBindings = cfg.bindings ?? [];
+  const hasBinding = existingBindings.some(
+    (b) =>
+      b.match?.channel === "feishu" &&
+      b.match?.peer?.kind === "dm" &&
+      b.match?.peer?.id === senderOpenId,
+  );
+
+  if (hasBinding) {
+    return { created: false, updatedCfg: cfg };
+  }
+
+  // Check maxAgents limit if configured
+  if (dynamicCfg.maxAgents !== undefined) {
+    const feishuAgentCount = (cfg.agents?.list ?? []).filter((a) =>
+      a.id.startsWith("feishu-"),
+    ).length;
+    if (feishuAgentCount >= dynamicCfg.maxAgents) {
+      log(
+        `feishu: maxAgents limit (${dynamicCfg.maxAgents}) reached, not creating agent for ${senderOpenId}`,
+      );
+      return { created: false, updatedCfg: cfg };
+    }
+  }
+
+  // Use full OpenID as agent ID suffix (OpenID format: ou_xxx is already filesystem-safe)
+  const agentId = `feishu-${senderOpenId}`;
+
+  // Check if agent already exists (but binding was missing)
+  const existingAgent = (cfg.agents?.list ?? []).find((a) => a.id === agentId);
+  if (existingAgent) {
+    // Agent exists but binding doesn't - just add the binding
+    log(`feishu: agent "${agentId}" exists, adding missing binding for ${senderOpenId}`);
+
+    const updatedCfg: OpenClawConfig = {
+      ...cfg,
+      bindings: [
+        ...existingBindings,
+        {
+          agentId,
+          match: {
+            channel: "feishu",
+            peer: { kind: "dm", id: senderOpenId },
+          },
+        },
+      ],
+    };
+
+    await runtime.config.writeConfigFile(updatedCfg);
+    return { created: true, updatedCfg, agentId };
+  }
+
+  // Resolve path templates with substitutions
+  const workspaceTemplate = dynamicCfg.workspaceTemplate ?? "~/.openclaw/workspace-{agentId}";
+  const agentDirTemplate = dynamicCfg.agentDirTemplate ?? "~/.openclaw/agents/{agentId}/agent";
+
+  const workspace = resolveUserPath(
+    workspaceTemplate.replace("{userId}", senderOpenId).replace("{agentId}", agentId),
+  );
+  const agentDir = resolveUserPath(
+    agentDirTemplate.replace("{userId}", senderOpenId).replace("{agentId}", agentId),
+  );
+
+  log(`feishu: creating dynamic agent "${agentId}" for user ${senderOpenId}`);
+  log(`  workspace: ${workspace}`);
+  log(`  agentDir: ${agentDir}`);
+
+  // Create directories
+  await fs.promises.mkdir(workspace, { recursive: true });
+  await fs.promises.mkdir(agentDir, { recursive: true });
+
+  // Update configuration with new agent and binding
+  const updatedCfg: OpenClawConfig = {
+    ...cfg,
+    agents: {
+      ...cfg.agents,
+      list: [...(cfg.agents?.list ?? []), { id: agentId, workspace, agentDir }],
+    },
+    bindings: [
+      ...existingBindings,
+      {
+        agentId,
+        match: {
+          channel: "feishu",
+          peer: { kind: "dm", id: senderOpenId },
+        },
+      },
+    ],
+  };
+
+  // Write updated config using PluginRuntime API
+  await runtime.config.writeConfigFile(updatedCfg);
+
+  return { created: true, updatedCfg, agentId };
+}
+
+/**
+ * Resolve a path that may start with ~ to the user's home directory.
+ */
+function resolveUserPath(p: string): string {
+  if (p.startsWith("~/")) {
+    return path.join(os.homedir(), p.slice(2));
+  }
+  return p;
+}