@max1874/feishu 0.2.7 → 0.2.9

package/package.json

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

package/src/docx.ts

@@ -64,101 +64,119 @@ 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, // Table - must use different API or workaround
-  32, // TableCell - child of Table
-]);
-
-/** 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) => {
-      // Remove any read-only fields that might slip through
-      if (block.block_type === 31 && block.table?.merge_info) {
-        const { merge_info, ...tableRest } = block.table;
-        return { ...block, table: tableRest };
-      }
-      return block;
-    });
-  return { cleaned, skipped };
+// Block types that need special handling (not via standard documentBlockChildren.create)
+const TABLE_BLOCK_TYPE = 31;
+const TABLE_CELL_BLOCK_TYPE = 32;
+
+/** Extracted table data from convert API result */
+interface TableData {
+  rowSize: number;
+  colSize: number;
+  cells: string[][]; // 2D array of cell text content
 }
 
-// ============ Core Functions ============
+/** Extract table data from converted blocks (flat list with ID references) */
+function extractTableFromBlocks(blocks: any[]): { tables: TableData[]; otherBlocks: any[] } {
+  const tables: TableData[] = [];
+  const otherBlocks: any[] = [];
 
-/**
- * Convert Markdown tables to code blocks.
- * Feishu API doesn't support creating Table blocks directly, so we preserve
- * table formatting by wrapping them in code blocks.
- */
-function convertTablesToCodeBlocks(markdown: string): string {
-  const lines = markdown.split("\n");
-  const result: string[] = [];
-  let tableLines: string[] = [];
-  let inTable = false;
-
-  const isTableLine = (line: string): boolean => {
-    const trimmed = line.trim();
-    // Table line starts with | or is a separator line like |---|---|
-    return trimmed.startsWith("|") && trimmed.endsWith("|");
-  };
+  // Build a map of block_id -> block for quick lookup
+  const blockMap = new Map<string, any>();
+  for (const block of blocks) {
+    if (block.block_id) {
+      blockMap.set(block.block_id, block);
+    }
+  }
 
-  const isSeparatorLine = (line: string): boolean => {
-    const trimmed = line.trim();
-    // Separator line contains only |, -, :, and spaces
-    return /^\|[\s\-:|]+\|$/.test(trimmed);
-  };
+  // Track which blocks are part of tables (to exclude from otherBlocks)
+  const tableRelatedIds = new Set<string>();
+
+  for (const block of blocks) {
+    if (block.block_type === TABLE_BLOCK_TYPE) {
+      tableRelatedIds.add(block.block_id);
+
+      const tableInfo = block.table;
+      if (tableInfo) {
+        const rowSize = tableInfo.property?.row_size ?? 0;
+        const colSize = tableInfo.property?.column_size ?? 0;
+
+        // Initialize cells array
+        const cells: string[][] = Array.from({ length: rowSize }, () =>
+          Array.from({ length: colSize }, () => ""),
+        );
+
+        // table.cells is a flat array of cell block IDs in row-major order
+        const cellIds: string[] = tableInfo.cells ?? [];
+
+        let cellIndex = 0;
+        for (let row = 0; row < rowSize; row++) {
+          for (let col = 0; col < colSize; col++) {
+            if (cellIndex >= cellIds.length) break;
+
+            const cellId = cellIds[cellIndex];
+            tableRelatedIds.add(cellId);
+
+            // Find the TableCell block
+            const cellBlock = blockMap.get(cellId);
+            if (cellBlock?.block_type === TABLE_CELL_BLOCK_TYPE) {
+              // Get text content from cell's children (Text blocks)
+              const childIds: string[] = cellBlock.children ?? [];
+              const textParts: string[] = [];
+
+              for (const childId of childIds) {
+                tableRelatedIds.add(childId);
+                const textBlock = blockMap.get(childId);
+                if (textBlock?.block_type === 2 && textBlock.text?.elements) {
+                  const text = textBlock.text.elements
+                    .filter((e: any) => e.text_run)
+                    .map((e: any) => e.text_run.content)
+                    .join("");
+                  textParts.push(text);
+                }
+              }
+
+              cells[row][col] = textParts.join("\n");
+            }
+
+            cellIndex++;
+          }
+        }
 
-  const flushTable = () => {
-    if (tableLines.length >= 2) {
-      // Check if we have a valid table (at least header + separator)
-      const hasSeparator = tableLines.some(isSeparatorLine);
-      if (hasSeparator) {
-        // Wrap table in code block to preserve formatting
-        result.push("```");
-        result.push(...tableLines);
-        result.push("```");
-      } else {
-        // Not a valid table, keep as-is
-        result.push(...tableLines);
+        tables.push({ rowSize, colSize, cells });
       }
-    } else {
-      // Single line with |, keep as-is
-      result.push(...tableLines);
     }
-    tableLines = [];
-  };
+  }
 
-  for (const line of lines) {
-    if (isTableLine(line)) {
-      inTable = true;
-      tableLines.push(line);
-    } else {
-      if (inTable) {
-        flushTable();
-        inTable = false;
-      }
-      result.push(line);
+  // Collect non-table blocks
+  for (const block of blocks) {
+    if (!tableRelatedIds.has(block.block_id)) {
+      otherBlocks.push(block);
     }
   }
 
-  // Flush remaining table if any
-  if (inTable) {
-    flushTable();
-  }
+  return { tables, otherBlocks };
+}
+
+/** Clean blocks for insertion (remove read-only fields and unsupported nested structures) */
+function cleanBlocksForInsert(blocks: any[]): { cleaned: any[]; skipped: string[] } {
+  const skipped: string[] = [];
+  const cleaned = blocks.map((block) => {
+    const { children, parent_id, block_id, ...rest } = block;
+
+    // Remove children from non-table blocks (nested lists not supported in create API)
+    // Table children are handled separately via table.cells
+    if (block.block_type === TABLE_BLOCK_TYPE && block.table?.merge_info) {
+      const { merge_info, ...tableRest } = block.table;
+      return { ...rest, table: tableRest };
+    }
 
-  return result.join("\n");
+    return rest;
+  });
+  return { cleaned, skipped };
 }
 
+// ============ Core Functions ============
+
 /** Convert markdown to Feishu blocks using the Convert API */
 async function convertMarkdown(client: Lark.Client, markdown: string) {
   const res = await client.docx.document.convert({
@@ -171,10 +189,7 @@ async function convertMarkdown(client: Lark.Client, markdown: string) {
   };
 }
 
-/** Insert blocks as children of a parent block */
-// Batch size for inserting blocks (API may have limits)
-const INSERT_BATCH_SIZE = 50;
-
+/** Insert blocks as children of a parent block (with batching for >50 blocks) */
 async function insertBlocks(
   client: Lark.Client,
   docToken: string,
@@ -188,23 +203,18 @@ async function insertBlocks(
     return { children: [], skipped };
   }
 
+  // Feishu API limits to 50 blocks per request
+  const BATCH_SIZE = 50;
   const allChildren: any[] = [];
 
-  // Insert in batches to avoid API limits
-  for (let i = 0; i < cleaned.length; i += INSERT_BATCH_SIZE) {
-    const batch = cleaned.slice(i, i + INSERT_BATCH_SIZE);
-    try {
-      const res = await client.docx.documentBlockChildren.create({
-        path: { document_id: docToken, block_id: blockId },
-        data: { children: batch },
-      });
-      if (res.code !== 0) throw new Error(res.msg);
-      allChildren.push(...(res.data?.children ?? []));
-    } catch (err) {
-      const blockTypes = batch.map((b) => BLOCK_TYPE_NAMES[b.block_type] || `type_${b.block_type}`);
-      const errMsg = err instanceof Error ? err.message : String(err);
-      throw new Error(`insertBlocks failed at batch ${Math.floor(i / INSERT_BATCH_SIZE) + 1}: ${errMsg}. Batch types: [${blockTypes.join(", ")}]. Batch size: ${batch.length}`);
-    }
+  for (let i = 0; i < cleaned.length; i += BATCH_SIZE) {
+    const batch = cleaned.slice(i, i + BATCH_SIZE);
+    const res = await client.docx.documentBlockChildren.create({
+      path: { document_id: docToken, block_id: blockId },
+      data: { children: batch },
+    });
+    if (res.code !== 0) throw new Error(res.msg);
+    allChildren.push(...(res.data?.children ?? []));
   }
 
   return { children: allChildren, skipped };
@@ -266,6 +276,140 @@ async function downloadImage(url: string): Promise<Buffer> {
   return Buffer.from(await response.arrayBuffer());
 }
 
+/** Create an empty table and return its block ID */
+async function createEmptyTable(
+  client: Lark.Client,
+  docToken: string,
+  parentBlockId: string,
+  rowSize: number,
+  colSize: number,
+): Promise<string | null> {
+  const tableBlock = {
+    block_type: TABLE_BLOCK_TYPE,
+    table: {
+      property: {
+        row_size: rowSize,
+        column_size: colSize,
+        header_row: true,
+      },
+      cells: [], // Empty cells, will be filled later
+    },
+  };
+
+  const res = await client.docx.documentBlockChildren.create({
+    path: { document_id: docToken, block_id: parentBlockId },
+    data: { children: [tableBlock] },
+  });
+
+  if (res.code !== 0) {
+    console.error(`Failed to create table: ${res.msg}`);
+    return null;
+  }
+
+  const created = res.data?.children ?? [];
+  return created[0]?.block_id ?? null;
+}
+
+/** Get children blocks of a parent block */
+async function getBlockChildren(
+  client: Lark.Client,
+  docToken: string,
+  blockId: string,
+): Promise<any[]> {
+  const res = await client.docx.documentBlockChildren.get({
+    path: { document_id: docToken, block_id: blockId },
+  });
+  if (res.code !== 0) {
+    throw new Error(`Failed to get block children: ${res.msg}`);
+  }
+  return res.data?.items ?? [];
+}
+
+/** Update a text block's content */
+async function updateTextBlock(
+  client: Lark.Client,
+  docToken: string,
+  blockId: string,
+  content: string,
+): Promise<void> {
+  const res = await client.docx.documentBlock.patch({
+    path: { document_id: docToken, block_id: blockId },
+    data: {
+      update_text_elements: {
+        elements: [{ text_run: { content } }],
+      },
+    },
+  });
+  if (res.code !== 0) {
+    console.error(`Failed to update text block ${blockId}: ${res.msg}`);
+  }
+}
+
+/** Fill table cells with content */
+async function fillTableContent(
+  client: Lark.Client,
+  docToken: string,
+  tableBlockId: string,
+  cells: string[][],
+): Promise<void> {
+  // Get table's cell blocks (they are direct children of the table)
+  const cellBlocks = await getBlockChildren(client, docToken, tableBlockId);
+
+  // Cells are in row-major order
+  const colSize = cells[0]?.length ?? 0;
+  let cellIndex = 0;
+
+  for (let row = 0; row < cells.length; row++) {
+    for (let col = 0; col < colSize; col++) {
+      if (cellIndex >= cellBlocks.length) break;
+
+      const cellBlock = cellBlocks[cellIndex];
+      const cellBlockId = cellBlock?.block_id;
+      const cellText = cells[row]?.[col] ?? "";
+
+      if (cellBlockId && cellText) {
+        // Each cell block contains text blocks as children
+        const cellChildren = await getBlockChildren(client, docToken, cellBlockId);
+        if (cellChildren.length > 0) {
+          // Update the first text block in the cell
+          const textBlockId = cellChildren[0]?.block_id;
+          if (textBlockId) {
+            await updateTextBlock(client, docToken, textBlockId, cellText);
+          }
+        }
+      }
+
+      cellIndex++;
+    }
+  }
+}
+
+/** Create and fill a table */
+async function createAndFillTable(
+  client: Lark.Client,
+  docToken: string,
+  parentBlockId: string,
+  tableData: TableData,
+): Promise<boolean> {
+  // 1. Create empty table
+  const tableBlockId = await createEmptyTable(
+    client,
+    docToken,
+    parentBlockId,
+    tableData.rowSize,
+    tableData.colSize,
+  );
+
+  if (!tableBlockId) {
+    return false;
+  }
+
+  // 2. Fill table content
+  await fillTableContent(client, docToken, tableBlockId, tableData.cells);
+
+  return true;
+}
+
 /** Process images in markdown: download from URL, upload to Feishu, update blocks */
 async function processImages(
   client: Lark.Client,
@@ -497,74 +641,74 @@ async function createDoc(
 }
 
 async function writeDoc(client: Lark.Client, docToken: string, markdown: string) {
-  let step = "init";
-  try {
-    // 1. Clear existing content
-    step = "clear_content";
-    const deleted = await clearDocumentContent(client, docToken);
-
-    // 2. Pre-process markdown (convert tables to code blocks)
-    step = "preprocess_markdown";
-    const processedMarkdown = convertTablesToCodeBlocks(markdown);
-
-    // 3. Convert markdown to blocks
-    step = "convert_markdown";
-    const res = await client.docx.document.convert({
-      data: { content_type: "markdown", content: processedMarkdown },
-    });
-    if (res.code !== 0) throw new Error(`convert failed: ${res.msg}`);
-    const blocks = res.data?.blocks ?? [];
+  // 1. Clear existing content
+  const deleted = await clearDocumentContent(client, docToken);
 
-    if (blocks.length === 0) {
-      return { success: true, blocks_deleted: deleted, blocks_added: 0, images_processed: 0 };
-    }
+  // 2. Convert markdown to blocks
+  const { blocks } = await convertMarkdown(client, markdown);
+  if (blocks.length === 0) {
+    return { success: true, blocks_deleted: deleted, blocks_added: 0, images_processed: 0, tables_created: 0 };
+  }
 
-    // 4. Insert new blocks (unsupported types like Table are filtered)
-    step = "insert_blocks";
-    const { children: inserted, skipped } = await insertBlocks(client, docToken, blocks);
+  // 3. Separate tables from other blocks
+  const { tables, otherBlocks } = extractTableFromBlocks(blocks);
 
-    // 5. Process images
-    step = "process_images";
-    const imagesProcessed = await processImages(client, docToken, markdown, inserted);
+  // 4. Insert non-table blocks
+  const { children: inserted, skipped } = await insertBlocks(client, docToken, otherBlocks);
 
-    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.`,
-      }),
-    };
-  } catch (err) {
-    const errMsg = err instanceof Error ? err.message : String(err);
-    throw new Error(`writeDoc failed at step '${step}': ${errMsg}`);
+  // 5. Create and fill tables
+  let tablesCreated = 0;
+  for (const tableData of tables) {
+    const success = await createAndFillTable(client, docToken, docToken, tableData);
+    if (success) tablesCreated++;
   }
+
+  // 6. Process images
+  const imagesProcessed = await processImages(client, docToken, markdown, inserted);
+
+  return {
+    success: true,
+    blocks_deleted: deleted,
+    blocks_added: inserted.length,
+    tables_created: tablesCreated,
+    images_processed: imagesProcessed,
+    ...(skipped.length > 0 && {
+      warning: `Skipped unsupported block types: ${skipped.join(", ")}.`,
+    }),
+  };
 }
 
 async function appendDoc(client: Lark.Client, docToken: string, markdown: string) {
-  // 1. Pre-process markdown (convert tables to code blocks)
-  const processedMarkdown = convertTablesToCodeBlocks(markdown);
-
-  // 2. Convert markdown to blocks
-  const { blocks } = await convertMarkdown(client, processedMarkdown);
+  // 1. Convert markdown to blocks
+  const { blocks } = await convertMarkdown(client, markdown);
   if (blocks.length === 0) {
     throw new Error("Content is empty");
   }
 
-  // 3. Insert blocks (unsupported types like Table are filtered)
-  const { children: inserted, skipped } = await insertBlocks(client, docToken, blocks);
+  // 2. Separate tables from other blocks
+  const { tables, otherBlocks } = extractTableFromBlocks(blocks);
+
+  // 3. Insert non-table blocks
+  const { children: inserted, skipped } = await insertBlocks(client, docToken, otherBlocks);
+
+  // 4. Create and fill tables
+  let tablesCreated = 0;
+  for (const tableData of tables) {
+    const success = await createAndFillTable(client, docToken, docToken, tableData);
+    if (success) tablesCreated++;
+  }
 
-  // 4. Process images
+  // 5. Process images
   const imagesProcessed = await processImages(client, docToken, markdown, inserted);
 
   return {
     success: true,
     blocks_added: inserted.length,
+    tables_created: tablesCreated,
     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.`,
+      warning: `Skipped unsupported block types: ${skipped.join(", ")}.`,
     }),
   };
 }
@@ -803,7 +947,7 @@ export function registerFeishuDocTools(api: OpenClawPluginApi) {
       name: "feishu_doc_write",
       label: "Feishu Doc Write",
       description:
-        "Write markdown content to a Feishu document (replaces all content). Supports headings, lists, code blocks, quotes, links, images, and text styling. Note: tables are not supported.",
+        "Write markdown content to a Feishu document (replaces all content). Supports headings, lists, code blocks, quotes, links, images, tables, and text styling.",
       parameters: WriteDocSchema,
       async execute(_toolCallId, params) {
         const { doc_token, content } = params as { doc_token: string; content: string };