@m1heng-clawd/feishu 0.1.9 → 0.1.11

package/src/docx.ts

@@ -1,11 +1,9 @@
 import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-import { createFeishuClient } from "./client.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";
-import { resolveToolsConfig } from "./tools-config.js";
+import { appendDoc, createAndWriteDoc, createDoc, writeDoc } from "./doc-write-service.js";
+import { hasFeishuToolEnabledForAnyAccount, withFeishuToolClient } from "./tools-common/tool-exec.js";
 
 // ============ Helpers ============
 
@@ -16,20 +14,6 @@ function json(data: unknown) {
   };
 }
 
-/** Extract image URLs from markdown content */
-function extractImageUrls(markdown: string): string[] {
-  const regex = /!\[[^\]]*\]\(([^)]+)\)/g;
-  const urls: string[] = [];
-  let match;
-  while ((match = regex.exec(markdown)) !== null) {
-    const url = match[1].trim();
-    if (url.startsWith("http://") || url.startsWith("https://")) {
-      urls.push(url);
-    }
-  }
-  return urls;
-}
-
 const BLOCK_TYPE_NAMES: Record<number, string> = {
   1: "Page",
   2: "Text",
@@ -51,160 +35,10 @@ const BLOCK_TYPE_NAMES: Record<number, string> = {
   32: "TableCell",
 };
 
-// Block types that cannot be created via documentBlockChildren.create API
-const UNSUPPORTED_CREATE_TYPES = new Set([31, 32]);
-
-/** Clean blocks for insertion (remove unsupported types and read-only fields) */
-function cleanBlocksForInsert(blocks: any[]): { cleaned: any[]; skipped: string[] } {
-  const skipped: string[] = [];
-  const cleaned = blocks
-    .filter((block) => {
-      if (UNSUPPORTED_CREATE_TYPES.has(block.block_type)) {
-        const typeName = BLOCK_TYPE_NAMES[block.block_type] || `type_${block.block_type}`;
-        skipped.push(typeName);
-        return false;
-      }
-      return true;
-    })
-    .map((block) => {
-      if (block.block_type === 31 && block.table?.merge_info) {
-        const { merge_info, ...tableRest } = block.table;
-        return { ...block, table: tableRest };
-      }
-      return block;
-    });
-  return { cleaned, skipped };
-}
-
-// ============ Core Functions ============
-
-async function convertMarkdown(client: Lark.Client, markdown: string) {
-  const res = await client.docx.document.convert({
-    data: { content_type: "markdown", content: markdown },
-  });
-  if (res.code !== 0) throw new Error(res.msg);
-  return {
-    blocks: res.data?.blocks ?? [],
-    firstLevelBlockIds: res.data?.first_level_block_ids ?? [],
-  };
-}
-
-async function insertBlocks(
-  client: Lark.Client,
-  docToken: string,
-  blocks: any[],
-  parentBlockId?: string,
-): Promise<{ children: any[]; skipped: string[] }> {
-  const { cleaned, skipped } = cleanBlocksForInsert(blocks);
-  const blockId = parentBlockId ?? docToken;
-
-  if (cleaned.length === 0) {
-    return { children: [], skipped };
-  }
-
-  const res = await client.docx.documentBlockChildren.create({
-    path: { document_id: docToken, block_id: blockId },
-    data: { children: cleaned },
-  });
-  if (res.code !== 0) throw new Error(res.msg);
-  return { children: res.data?.children ?? [], skipped };
-}
-
-async function clearDocumentContent(client: Lark.Client, docToken: string) {
-  const existing = await client.docx.documentBlock.list({
-    path: { document_id: docToken },
-  });
-  if (existing.code !== 0) throw new Error(existing.msg);
-
-  const childIds =
-    existing.data?.items
-      ?.filter((b) => b.parent_id === docToken && b.block_type !== 1)
-      .map((b) => b.block_id) ?? [];
-
-  if (childIds.length > 0) {
-    const res = await client.docx.documentBlockChildren.batchDelete({
-      path: { document_id: docToken, block_id: docToken },
-      data: { start_index: 0, end_index: childIds.length },
-    });
-    if (res.code !== 0) throw new Error(res.msg);
-  }
-
-  return childIds.length;
-}
-
-async function uploadImageToDocx(
-  client: Lark.Client,
-  blockId: string,
-  imageBuffer: Buffer,
-  fileName: string,
-): Promise<string> {
-  const res = await client.drive.media.uploadAll({
-    data: {
-      file_name: fileName,
-      parent_type: "docx_image",
-      parent_node: blockId,
-      size: imageBuffer.length,
-      file: Readable.from(imageBuffer) as any,
-    },
-  });
-
-  const fileToken = res?.file_token;
-  if (!fileToken) {
-    throw new Error("Image upload failed: no file_token returned");
-  }
-  return fileToken;
-}
-
-async function downloadImage(url: string): Promise<Buffer> {
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Failed to download image: ${response.status} ${response.statusText}`);
-  }
-  return Buffer.from(await response.arrayBuffer());
-}
-
-async function processImages(
-  client: Lark.Client,
-  docToken: string,
-  markdown: string,
-  insertedBlocks: any[],
-): Promise<number> {
-  const imageUrls = extractImageUrls(markdown);
-  if (imageUrls.length === 0) return 0;
-
-  const imageBlocks = insertedBlocks.filter((b) => b.block_type === 27);
-
-  let processed = 0;
-  for (let i = 0; i < Math.min(imageUrls.length, imageBlocks.length); i++) {
-    const url = imageUrls[i];
-    const blockId = imageBlocks[i].block_id;
-
-    try {
-      const buffer = await downloadImage(url);
-      const urlPath = new URL(url).pathname;
-      const fileName = urlPath.split("/").pop() || `image_${i}.png`;
-      const fileToken = await uploadImageToDocx(client, blockId, buffer, fileName);
-
-      await client.docx.documentBlock.patch({
-        path: { document_id: docToken, block_id: blockId },
-        data: {
-          replace_image: { token: fileToken },
-        },
-      });
-
-      processed++;
-    } catch (err) {
-      console.error(`Failed to process image ${url}:`, err);
-    }
-  }
-
-  return processed;
-}
+const STRUCTURED_BLOCK_TYPES = new Set([14, 18, 21, 23, 27, 30, 31, 32]);
 
 // ============ Actions ============
 
-const STRUCTURED_BLOCK_TYPES = new Set([14, 18, 21, 23, 27, 30, 31, 32]);
-
 async function readDoc(client: Lark.Client, docToken: string) {
   const [contentRes, infoRes, blocksRes] = await Promise.all([
     client.docx.document.rawContent({ path: { document_id: docToken } }),
@@ -243,61 +77,6 @@ async function readDoc(client: Lark.Client, docToken: string) {
   };
 }
 
-async function createDoc(client: Lark.Client, title: string, folderToken?: string) {
-  const res = await client.docx.document.create({
-    data: { title, folder_token: folderToken },
-  });
-  if (res.code !== 0) throw new Error(res.msg);
-  const doc = res.data?.document;
-  return {
-    document_id: doc?.document_id,
-    title: doc?.title,
-    url: `https://feishu.cn/docx/${doc?.document_id}`,
-  };
-}
-
-async function writeDoc(client: Lark.Client, docToken: string, markdown: string) {
-  const deleted = await clearDocumentContent(client, docToken);
-
-  const { blocks } = await convertMarkdown(client, markdown);
-  if (blocks.length === 0) {
-    return { success: true, blocks_deleted: deleted, blocks_added: 0, images_processed: 0 };
-  }
-
-  const { children: inserted, skipped } = await insertBlocks(client, docToken, blocks);
-  const imagesProcessed = await processImages(client, docToken, markdown, inserted);
-
-  return {
-    success: true,
-    blocks_deleted: deleted,
-    blocks_added: inserted.length,
-    images_processed: imagesProcessed,
-    ...(skipped.length > 0 && {
-      warning: `Skipped unsupported block types: ${skipped.join(", ")}. Tables are not supported via this API.`,
-    }),
-  };
-}
-
-async function appendDoc(client: Lark.Client, docToken: string, markdown: string) {
-  const { blocks } = await convertMarkdown(client, markdown);
-  if (blocks.length === 0) {
-    throw new Error("Content is empty");
-  }
-
-  const { children: inserted, skipped } = await insertBlocks(client, docToken, blocks);
-  const imagesProcessed = await processImages(client, docToken, markdown, inserted);
-
-  return {
-    success: true,
-    blocks_added: inserted.length,
-    images_processed: imagesProcessed,
-    block_ids: inserted.map((b: any) => b.block_id),
-    ...(skipped.length > 0 && {
-      warning: `Skipped unsupported block types: ${skipped.join(", ")}. Tables are not supported via this API.`,
-    }),
-  };
-}
-
 async function updateBlock(
   client: Lark.Client,
   docToken: string,
@@ -393,88 +172,105 @@ export function registerFeishuDocTools(api: OpenClawPluginApi) {
     return;
   }
 
-  // Check if any account is configured
-  const accounts = listEnabledFeishuAccounts(api.config);
-  if (accounts.length === 0) {
+  if (!hasFeishuToolEnabledForAnyAccount(api.config)) {
     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);
+  // Registration happens once; account selection happens per execute() call.
+  const docEnabled = hasFeishuToolEnabledForAnyAccount(api.config, "doc");
+  const scopesEnabled = hasFeishuToolEnabledForAnyAccount(api.config, "scopes");
   const registered: string[] = [];
 
   // Main document tool with action-based dispatch
-  if (toolsCfg.doc) {
+  if (docEnabled) {
     api.registerTool(
-    {
-      name: "feishu_doc",
-      label: "Feishu Doc",
-      description:
-        "Feishu document operations. Actions: read, write, append, create, list_blocks, get_block, update_block, delete_block",
-      parameters: FeishuDocSchema,
-      async execute(_toolCallId, params) {
-        const p = params as FeishuDocParams;
-        try {
-          const client = getClient();
-          switch (p.action) {
-            case "read":
-              return json(await readDoc(client, p.doc_token));
-            case "write":
-              return json(await writeDoc(client, p.doc_token, p.content));
-            case "append":
-              return json(await appendDoc(client, p.doc_token, p.content));
-            case "create":
-              return json(await createDoc(client, p.title, p.folder_token));
-            case "list_blocks":
-              return json(await listBlocks(client, p.doc_token));
-            case "get_block":
-              return json(await getBlock(client, p.doc_token, p.block_id));
-            case "update_block":
-              return json(await updateBlock(client, p.doc_token, p.block_id, p.content));
-            case "delete_block":
-              return json(await deleteBlock(client, p.doc_token, p.block_id));
-            default:
-              return json({ error: `Unknown action: ${(p as any).action}` });
+      {
+        name: "feishu_doc",
+        label: "Feishu Doc",
+        description:
+          'Feishu document operations. Actions: read, write, append, create, create_and_write, list_blocks, get_block, update_block, delete_block. Use "create_and_write" for atomic create + content write.',
+        parameters: FeishuDocSchema,
+        async execute(_toolCallId, params) {
+          const p = params as FeishuDocParams;
+          try {
+            return await withFeishuToolClient({
+              api,
+              toolName: "feishu_doc",
+              requiredTool: "doc",
+              run: async ({ client, account }) => {
+                const mediaMaxBytes = (account.config?.mediaMaxMb ?? 30) * 1024 * 1024;
+                switch (p.action) {
+                  case "read":
+                    return json(await readDoc(client, p.doc_token));
+                  case "write":
+                    return json(await writeDoc(client, p.doc_token, p.content, mediaMaxBytes));
+                  case "append":
+                    return json(await appendDoc(client, p.doc_token, p.content, mediaMaxBytes));
+                  case "create":
+                    return json(await createDoc(client, p.title, p.folder_token));
+                  case "create_and_write":
+                    return json(
+                      await createAndWriteDoc(
+                        client,
+                        p.title,
+                        p.content,
+                        mediaMaxBytes,
+                        p.folder_token,
+                      ),
+                    );
+                  case "list_blocks":
+                    return json(await listBlocks(client, p.doc_token));
+                  case "get_block":
+                    return json(await getBlock(client, p.doc_token, p.block_id));
+                  case "update_block":
+                    return json(await updateBlock(client, p.doc_token, p.block_id, p.content));
+                  case "delete_block":
+                    return json(await deleteBlock(client, p.doc_token, p.block_id));
+                  default:
+                    return json({ error: `Unknown action: ${(p as any).action}` });
+                }
+              },
+            });
+          } catch (err) {
+            return json({ error: err instanceof Error ? err.message : String(err) });
           }
-        } catch (err) {
-          return json({ error: err instanceof Error ? err.message : String(err) });
-        }
+        },
       },
-    },
-    { name: "feishu_doc" },
-  );
+      { name: "feishu_doc" },
+    );
     registered.push("feishu_doc");
   }
 
   // Keep feishu_app_scopes as independent tool
-  if (toolsCfg.scopes) {
+  if (scopesEnabled) {
     api.registerTool(
-    {
-      name: "feishu_app_scopes",
-      label: "Feishu App Scopes",
-      description:
-        "List current app permissions (scopes). Use to debug permission issues or check available capabilities.",
-      parameters: Type.Object({}),
-      async execute() {
-        try {
-          const result = await listAppScopes(getClient());
-          return json(result);
-        } catch (err) {
-          return json({ error: err instanceof Error ? err.message : String(err) });
-        }
+      {
+        name: "feishu_app_scopes",
+        label: "Feishu App Scopes",
+        description:
+          "List current app permissions (scopes). Use to debug permission issues or check available capabilities.",
+        parameters: Type.Object({}),
+        async execute() {
+          try {
+            const result = await withFeishuToolClient({
+              api,
+              toolName: "feishu_app_scopes",
+              requiredTool: "scopes",
+              run: async ({ client }) => listAppScopes(client),
+            });
+            return json(result);
+          } catch (err) {
+            return json({ error: err instanceof Error ? err.message : String(err) });
+          }
+        },
       },
-    },
-    { name: "feishu_app_scopes" },
-  );
+      { name: "feishu_app_scopes" },
+    );
     registered.push("feishu_app_scopes");
   }
 
   if (registered.length > 0) {
-    api.logger.info?.(`feishu_doc: Registered ${registered.join(", ")}`);
+    api.logger.debug?.(`feishu_doc: Registered ${registered.join(", ")}`);
   }
 }

package/src/drive-schema.ts

@@ -11,6 +11,11 @@ const FileType = Type.Union([
   Type.Literal("shortcut"),
 ]);
 
+const DocType = Type.Union([
+  Type.Literal("docx", { description: "New generation document (default)" }),
+  Type.Literal("doc", { description: "Legacy document" }),
+]);
+
 export const FeishuDriveSchema = Type.Union([
   Type.Object({
     action: Type.Literal("list"),
@@ -41,6 +46,21 @@ export const FeishuDriveSchema = Type.Union([
     file_token: Type.String({ description: "File token to delete" }),
     type: FileType,
   }),
+  Type.Object({
+    action: Type.Literal("import_document"),
+    title: Type.String({
+      description: "Document title",
+    }),
+    content: Type.String({
+      description: "Markdown content to import. Supports full Markdown syntax including tables, lists, code blocks, etc.",
+    }),
+    folder_token: Type.Optional(
+      Type.String({
+        description: "Target folder token (optional, defaults to root). Use 'list' to find folder tokens.",
+      }),
+    ),
+    doc_type: Type.Optional(DocType),
+  }),
 ]);
 
 export type FeishuDriveParams = Static<typeof FeishuDriveSchema>;

package/src/drive.ts

@@ -1,9 +1,8 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-import { createFeishuClient } from "./client.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";
+import { hasFeishuToolEnabledForAnyAccount, withFeishuToolClient } from "./tools-common/tool-exec.js";
+import { createAndWriteDoc } from "./doc-write-service.js";
 
 // ============ Helpers ============
 
@@ -147,6 +146,24 @@ async function deleteFile(client: Lark.Client, fileToken: string, type: string)
   };
 }
 
+// ============ Import Document Functions ============
+
+/**
+ * Import markdown content as a new Feishu document
+ * Uses create + write approach for reliable content import.
+ * Note: docType parameter is accepted for API compatibility but docx is always used.
+ */
+async function importDocument(
+  client: Lark.Client,
+  title: string,
+  content: string,
+  mediaMaxBytes: number,
+  folderToken?: string,
+  _docType?: "docx" | "doc",
+) {
+  return createAndWriteDoc(client, title, content, mediaMaxBytes, folderToken);
+}
+
 // ============ Tool Registration ============
 
 export function registerFeishuDriveTools(api: OpenClawPluginApi) {
@@ -155,46 +172,59 @@ export function registerFeishuDriveTools(api: OpenClawPluginApi) {
     return;
   }
 
-  const accounts = listEnabledFeishuAccounts(api.config);
-  if (accounts.length === 0) {
+  if (!hasFeishuToolEnabledForAnyAccount(api.config)) {
     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) {
+  if (!hasFeishuToolEnabledForAnyAccount(api.config, "drive")) {
     api.logger.debug?.("feishu_drive: drive tool disabled in config");
     return;
   }
 
-  const getClient = () => createFeishuClient(firstAccount);
-
   api.registerTool(
     {
       name: "feishu_drive",
       label: "Feishu Drive",
       description:
-        "Feishu cloud storage operations. Actions: list, info, create_folder, move, delete",
+        "Feishu cloud storage operations. Actions: list, info, create_folder, move, delete, import_document. Use 'import_document' to create documents from Markdown with better structure preservation than block-by-block writing.",
       parameters: FeishuDriveSchema,
       async execute(_toolCallId, params) {
         const p = params as FeishuDriveParams;
         try {
-          const client = getClient();
-          switch (p.action) {
-            case "list":
-              return json(await listFolder(client, p.folder_token));
-            case "info":
-              return json(await getFileInfo(client, p.file_token));
-            case "create_folder":
-              return json(await createFolder(client, p.name, p.folder_token));
-            case "move":
-              return json(await moveFile(client, p.file_token, p.type, p.folder_token));
-            case "delete":
-              return json(await deleteFile(client, p.file_token, p.type));
-            default:
-              return json({ error: `Unknown action: ${(p as any).action}` });
-          }
+          return await withFeishuToolClient({
+            api,
+            toolName: "feishu_drive",
+            requiredTool: "drive",
+            run: async ({ client, account }) => {
+              const mediaMaxBytes = (account.config?.mediaMaxMb ?? 30) * 1024 * 1024;
+              switch (p.action) {
+                case "list":
+                  return json(await listFolder(client, p.folder_token));
+                case "info":
+                  return json(await getFileInfo(client, p.file_token));
+                case "create_folder":
+                  return json(await createFolder(client, p.name, p.folder_token));
+                case "move":
+                  return json(await moveFile(client, p.file_token, p.type, p.folder_token));
+                case "delete":
+                  return json(await deleteFile(client, p.file_token, p.type));
+                case "import_document":
+                  return json(
+                    await importDocument(
+                      client,
+                      p.title,
+                      p.content,
+                      mediaMaxBytes,
+                      p.folder_token,
+                      (p as any).doc_type || "docx",
+                    ),
+                  );
+                default:
+                  return json({ error: `Unknown action: ${(p as any).action}` });
+              }
+            },
+          });
         } catch (err) {
           return json({ error: err instanceof Error ? err.message : String(err) });
         }
@@ -203,5 +233,5 @@ export function registerFeishuDriveTools(api: OpenClawPluginApi) {
     { name: "feishu_drive" },
   );
 
-  api.logger.info?.(`feishu_drive: Registered feishu_drive tool`);
+  api.logger.debug?.("feishu_drive: Registered feishu_drive tool");
 }

package/src/dynamic-agent.ts

@@ -19,16 +19,18 @@ export async function maybeCreateDynamicAgent(params: {
   runtime: PluginRuntime;
   senderOpenId: string;
   dynamicCfg: DynamicAgentCreationConfig;
+  accountId?: string;
   log: (msg: string) => void;
 }): Promise<MaybeCreateDynamicAgentResult> {
-  const { cfg, runtime, senderOpenId, dynamicCfg, log } = params;
+  const { cfg, runtime, senderOpenId, dynamicCfg, accountId, 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" &&
+      (!accountId || b.match?.accountId === accountId) &&
+      b.match?.peer?.kind === "direct" &&
       b.match?.peer?.id === senderOpenId,
   );
 
@@ -66,7 +68,8 @@ export async function maybeCreateDynamicAgent(params: {
           agentId,
           match: {
             channel: "feishu",
-            peer: { kind: "dm", id: senderOpenId },
+            ...(accountId ? { accountId } : {}),
+            peer: { kind: "direct", id: senderOpenId },
           },
         },
       ],
@@ -108,7 +111,8 @@ export async function maybeCreateDynamicAgent(params: {
         agentId,
         match: {
           channel: "feishu",
-          peer: { kind: "dm", id: senderOpenId },
+          ...(accountId ? { accountId } : {}),
+          peer: { kind: "direct", id: senderOpenId },
         },
       },
     ],