@max1874/feishu 0.2.11 → 0.2.13

package/package.json

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

package/src/docx.ts

@@ -129,12 +129,63 @@ interface TableData {
   cells: string[][]; // 2D array of cell text content
 }
 
-/** 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[] = [];
+/** A content item that can be either a regular block or a table */
+type ContentItem =
+  | { type: "block"; block: any }
+  | { type: "table"; table: TableData };
+
+/** Extract table data from a table block */
+function extractTableData(tableBlock: any, blockMap: Map<string, any>): { tableData: TableData; relatedIds: Set<string> } {
+  const relatedIds = new Set<string>();
+  relatedIds.add(tableBlock.block_id);
+
+  const tableInfo = tableBlock.table;
+  const rowSize = tableInfo?.property?.row_size ?? 0;
+  const colSize = tableInfo?.property?.column_size ?? 0;
+
+  const cells: string[][] = Array.from({ length: rowSize }, () =>
+    Array.from({ length: colSize }, () => ""),
+  );
 
-  // Build a map of block_id -> block for quick lookup
+  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];
+      relatedIds.add(cellId);
+
+      const cellBlock = blockMap.get(cellId);
+      if (cellBlock?.block_type === TABLE_CELL_BLOCK_TYPE) {
+        const childIds: string[] = cellBlock.children ?? [];
+        const textParts: string[] = [];
+
+        for (const childId of childIds) {
+          relatedIds.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++;
+    }
+  }
+
+  return { tableData: { rowSize, colSize, cells }, relatedIds };
+}
+
+/** Convert blocks to content items, preserving order with tables in correct positions */
+function convertBlocksToContentItems(blocks: any[]): ContentItem[] {
   const blockMap = new Map<string, any>();
   for (const block of blocks) {
     if (block.block_id) {
@@ -142,69 +193,52 @@ function extractTableFromBlocks(blocks: any[]): { tables: TableData[]; otherBloc
     }
   }
 
-  // Track which blocks are part of tables (to exclude from otherBlocks)
+  // Track which blocks are part of tables
   const tableRelatedIds = new Set<string>();
+  const tableDataMap = new Map<string, TableData>();
 
+  // First pass: extract all table data and mark related IDs
   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++;
-          }
-        }
-
-        tables.push({ rowSize, colSize, cells });
+      const { tableData, relatedIds } = extractTableData(block, blockMap);
+      tableDataMap.set(block.block_id, tableData);
+      for (const id of relatedIds) {
+        tableRelatedIds.add(id);
       }
     }
   }
 
-  // Collect non-table blocks
+  // Second pass: build content items in order
+  const items: ContentItem[] = [];
   for (const block of blocks) {
-    if (!tableRelatedIds.has(block.block_id)) {
-      otherBlocks.push(block);
+    if (tableRelatedIds.has(block.block_id)) {
+      // If this is a table block itself, add the table item
+      if (block.block_type === TABLE_BLOCK_TYPE) {
+        const tableData = tableDataMap.get(block.block_id);
+        if (tableData) {
+          items.push({ type: "table", table: tableData });
+        }
+      }
+      // Skip table-related blocks (cells, cell contents)
+    } else {
+      items.push({ type: "block", block });
+    }
+  }
+
+  return items;
+}
+
+/** Extract table data from converted blocks (flat list with ID references) - legacy function */
+function extractTableFromBlocks(blocks: any[]): { tables: TableData[]; otherBlocks: any[] } {
+  const items = convertBlocksToContentItems(blocks);
+  const tables: TableData[] = [];
+  const otherBlocks: any[] = [];
+
+  for (const item of items) {
+    if (item.type === "table") {
+      tables.push(item.table);
+    } else {
+      otherBlocks.push(item.block);
     }
   }
 
@@ -229,6 +263,231 @@ function cleanBlocksForInsert(blocks: any[]): { cleaned: any[]; skipped: string[
   return { cleaned, skipped };
 }
 
+// ============ Helpers for Recursive Insert ============
+
+/** Delay helper for rate limiting */
+const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
+
+/** API call with retry for rate limiting */
+async function createChildrenWithRetry(
+  client: Lark.Client,
+  docToken: string,
+  parentBlockId: string,
+  children: any[],
+  index?: number,
+  retries = 3
+): Promise<any> {
+  for (let i = 0; i < retries; i++) {
+    try {
+      const res = await client.docx.documentBlockChildren.create({
+        path: { document_id: docToken, block_id: parentBlockId },
+        data: {
+          children,
+          ...(index !== undefined && { index })
+        },
+      });
+      if (res.code === 0) return res;
+      // Rate limit error
+      if (res.code === 99991400 || res.msg?.includes('rate')) {
+        await delay((i + 1) * 2000);
+        continue;
+      }
+      return res;
+    } catch (e: any) {
+      if (e.message?.includes('429') || e.response?.status === 429) {
+        await delay((i + 1) * 2000);
+        continue;
+      }
+      throw e;
+    }
+  }
+  return { code: -1, msg: 'Max retries exceeded' };
+}
+
+/** Context for recursive block insertion */
+interface InsertContext {
+  client: Lark.Client;
+  docToken: string;
+  blockMap: Map<string, any>;
+  tableRelatedIds: Set<string>;
+  tableDataMap: Map<string, TableData>;
+  insertedCount: number;
+  tablesCreated: number;
+}
+
+/** Recursively insert a block and its children */
+async function insertBlockWithChildren(
+  ctx: InsertContext,
+  block: any,
+  parentBlockId: string,
+  index?: number
+): Promise<string | null> {
+  // Skip table-related blocks (handled separately)
+  if (ctx.tableRelatedIds.has(block.block_id)) {
+    if (block.block_type === TABLE_BLOCK_TYPE) {
+      const tableData = ctx.tableDataMap.get(block.block_id);
+      if (tableData) {
+        return await createTableWithRetry(ctx, parentBlockId, tableData, index);
+      }
+    }
+    return null;
+  }
+
+  // Clean block (remove read-only fields but preserve children reference)
+  const { block_id, parent_id, children, ...cleanBlock } = block;
+
+  // Add delay to avoid rate limiting
+  await delay(100);
+
+  // Insert current block
+  const insertRes = await createChildrenWithRetry(
+    ctx.client,
+    ctx.docToken,
+    parentBlockId,
+    [cleanBlock],
+    index
+  );
+
+  if (insertRes.code !== 0) {
+    console.error(`Failed to insert block: ${insertRes.msg}`);
+    return null;
+  }
+
+  const newBlockId = insertRes.data?.children?.[0]?.block_id;
+  if (!newBlockId) return null;
+
+  ctx.insertedCount++;
+
+  // Recursively insert children
+  if (children && children.length > 0) {
+    for (let i = 0; i < children.length; i++) {
+      const childId = children[i];
+      const childBlock = ctx.blockMap.get(childId);
+      if (childBlock) {
+        await insertBlockWithChildren(ctx, childBlock, newBlockId, i);
+      }
+    }
+  }
+
+  return newBlockId;
+}
+
+/** Create and fill a table with retry */
+async function createTableWithRetry(
+  ctx: InsertContext,
+  parentBlockId: string,
+  tableData: TableData,
+  index?: number
+): Promise<string | null> {
+  await delay(100);
+
+  const createRes = await createChildrenWithRetry(
+    ctx.client,
+    ctx.docToken,
+    parentBlockId,
+    [{
+      block_type: TABLE_BLOCK_TYPE,
+      table: {
+        property: { row_size: tableData.rowSize, column_size: tableData.colSize, header_row: true },
+        cells: []
+      }
+    }],
+    index
+  );
+
+  if (createRes.code !== 0) {
+    console.error(`Failed to create table: ${createRes.msg}`);
+    return null;
+  }
+
+  const tableBlockId = createRes.data?.children?.[0]?.block_id;
+  if (!tableBlockId) return null;
+
+  // Fill table content
+  const cellBlocksRes = await ctx.client.docx.documentBlockChildren.get({
+    path: { document_id: ctx.docToken, block_id: tableBlockId },
+  });
+  const cellBlocks = cellBlocksRes.data?.items ?? [];
+
+  let cellIndex = 0;
+  for (let row = 0; row < tableData.rowSize; row++) {
+    for (let col = 0; col < tableData.colSize; col++) {
+      if (cellIndex >= cellBlocks.length) break;
+      const cellBlockId = cellBlocks[cellIndex]?.block_id;
+      const cellText = tableData.cells[row]?.[col] ?? "";
+      if (cellBlockId && cellText) {
+        await delay(50);
+        const cellChildrenRes = await ctx.client.docx.documentBlockChildren.get({
+          path: { document_id: ctx.docToken, block_id: cellBlockId },
+        });
+        const textBlockId = cellChildrenRes.data?.items?.[0]?.block_id;
+        if (textBlockId) {
+          await ctx.client.docx.documentBlock.patch({
+            path: { document_id: ctx.docToken, block_id: textBlockId },
+            data: { update_text_elements: { elements: [{ text_run: { content: cellText } }] } },
+          });
+        }
+      }
+      cellIndex++;
+    }
+  }
+
+  ctx.tablesCreated++;
+  return tableBlockId;
+}
+
+/** Insert blocks recursively preserving nested structure */
+async function insertBlocksRecursively(
+  client: Lark.Client,
+  docToken: string,
+  blocks: any[],
+  firstLevelBlockIds: string[],
+  startIndex: number = 0
+): Promise<{ blocksInserted: number; tablesCreated: number }> {
+  // Build block map
+  const blockMap = new Map<string, any>();
+  for (const block of blocks) {
+    if (block.block_id) {
+      blockMap.set(block.block_id, block);
+    }
+  }
+
+  // Extract table data and related IDs
+  const tableRelatedIds = new Set<string>();
+  const tableDataMap = new Map<string, TableData>();
+
+  for (const block of blocks) {
+    if (block.block_type === TABLE_BLOCK_TYPE) {
+      const { tableData, relatedIds } = extractTableData(block, blockMap);
+      tableDataMap.set(block.block_id, tableData);
+      for (const id of relatedIds) {
+        tableRelatedIds.add(id);
+      }
+    }
+  }
+
+  const ctx: InsertContext = {
+    client,
+    docToken,
+    blockMap,
+    tableRelatedIds,
+    tableDataMap,
+    insertedCount: 0,
+    tablesCreated: 0,
+  };
+
+  // Insert blocks in order of first_level_block_ids
+  for (let i = 0; i < firstLevelBlockIds.length; i++) {
+    const blockId = firstLevelBlockIds[i];
+    const block = blockMap.get(blockId);
+    if (block) {
+      await insertBlockWithChildren(ctx, block, docToken, startIndex + i);
+    }
+  }
+
+  return { blocksInserted: ctx.insertedCount, tablesCreated: ctx.tablesCreated };
+}
+
 // ============ Core Functions ============
 
 /** Convert markdown to Feishu blocks using the Convert API */
@@ -289,6 +548,40 @@ async function insertBlocks(
   return { children: allChildren, skipped };
 }
 
+/** Insert blocks at a specific index (with batching for >50 blocks) */
+async function insertBlocksAtIndex(
+  client: Lark.Client,
+  docToken: string,
+  blocks: any[],
+  startIndex: number,
+  parentBlockId?: string,
+): Promise<{ children: any[]; skipped: string[] }> {
+  const { cleaned, skipped } = cleanBlocksForInsert(blocks);
+  const blockId = parentBlockId ?? docToken;
+
+  if (cleaned.length === 0) {
+    return { children: [], skipped };
+  }
+
+  const BATCH_SIZE = 50;
+  const allChildren: any[] = [];
+  let insertIndex = startIndex;
+
+  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, index: insertIndex },
+    });
+    if (res.code !== 0) throw new Error(res.msg);
+    const inserted = res.data?.children ?? [];
+    allChildren.push(...inserted);
+    insertIndex += inserted.length;
+  }
+
+  return { children: allChildren, skipped };
+}
+
 /** Delete all child blocks from a parent */
 async function clearDocumentContent(client: Lark.Client, docToken: string) {
   const existing = await client.docx.documentBlock.list({
@@ -352,6 +645,7 @@ async function createEmptyTable(
   parentBlockId: string,
   rowSize: number,
   colSize: number,
+  index?: number,
 ): Promise<string | null> {
   const tableBlock = {
     block_type: TABLE_BLOCK_TYPE,
@@ -367,7 +661,7 @@ async function createEmptyTable(
 
   const res = await client.docx.documentBlockChildren.create({
     path: { document_id: docToken, block_id: parentBlockId },
-    data: { children: [tableBlock] },
+    data: { children: [tableBlock], ...(index !== undefined && { index }) },
   });
 
   if (res.code !== 0) {
@@ -479,6 +773,34 @@ async function createAndFillTable(
   return true;
 }
 
+/** Create and fill a table at a specific index */
+async function createAndFillTableAtIndex(
+  client: Lark.Client,
+  docToken: string,
+  parentBlockId: string,
+  tableData: TableData,
+  index: number,
+): Promise<boolean> {
+  // 1. Create empty table at specific index
+  const tableBlockId = await createEmptyTable(
+    client,
+    docToken,
+    parentBlockId,
+    tableData.rowSize,
+    tableData.colSize,
+    index,
+  );
+
+  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,
@@ -714,71 +1036,75 @@ async function writeDoc(client: Lark.Client, docToken: string, markdown: string)
   const deleted = await clearDocumentContent(client, docToken);
 
   // 2. Convert markdown to blocks
-  const { blocks } = await convertMarkdown(client, markdown);
+  const { blocks, firstLevelBlockIds } = await convertMarkdown(client, markdown);
   if (blocks.length === 0) {
     return { success: true, blocks_deleted: deleted, blocks_added: 0, images_processed: 0, tables_created: 0 };
   }
 
-  // 3. Separate tables from other blocks
-  const { tables, otherBlocks } = extractTableFromBlocks(blocks);
-
-  // 4. Insert non-table blocks
-  const { children: inserted, skipped } = await insertBlocks(client, docToken, otherBlocks);
-
-  // 5. Create and fill tables
-  let tablesCreated = 0;
-  for (const tableData of tables) {
-    const success = await createAndFillTable(client, docToken, docToken, tableData);
-    if (success) tablesCreated++;
-  }
+  // 3. Insert blocks recursively (preserves nested structure)
+  const { blocksInserted, tablesCreated } = await insertBlocksRecursively(
+    client,
+    docToken,
+    blocks,
+    firstLevelBlockIds,
+    0
+  );
 
-  // 6. Process images
-  const imagesProcessed = await processImages(client, docToken, markdown, inserted);
+  // 4. Process images (get inserted blocks for image processing)
+  const insertedRes = await client.docx.documentBlock.list({
+    path: { document_id: docToken },
+    params: { page_size: 500 },
+  });
+  const insertedBlocks = insertedRes.data?.items ?? [];
+  const imagesProcessed = await processImages(client, docToken, markdown, insertedBlocks);
 
   return {
     success: true,
     blocks_deleted: deleted,
-    blocks_added: inserted.length,
+    blocks_added: blocksInserted,
     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. Convert markdown to blocks
-  const { blocks } = await convertMarkdown(client, markdown);
+  const { blocks, firstLevelBlockIds } = await convertMarkdown(client, markdown);
   if (blocks.length === 0) {
     throw new Error("Content is empty");
   }
 
-  // 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++;
+  // 2. Get current insert index
+  let startIndex = 0;
+  const existing = await client.docx.documentBlockChildren.get({
+    path: { document_id: docToken, block_id: docToken },
+  });
+  if (existing.code === 0) {
+    startIndex = existing.data?.items?.length ?? 0;
   }
 
-  // 5. Process images
-  const imagesProcessed = await processImages(client, docToken, markdown, inserted);
+  // 3. Insert blocks recursively (preserves nested structure)
+  const { blocksInserted, tablesCreated } = await insertBlocksRecursively(
+    client,
+    docToken,
+    blocks,
+    firstLevelBlockIds,
+    startIndex
+  );
+
+  // 4. Process images (get inserted blocks for image processing)
+  const insertedRes = await client.docx.documentBlock.list({
+    path: { document_id: docToken },
+    params: { page_size: 500 },
+  });
+  const insertedBlocks = insertedRes.data?.items ?? [];
+  const imagesProcessed = await processImages(client, docToken, markdown, insertedBlocks);
 
   return {
     success: true,
-    blocks_added: inserted.length,
+    blocks_added: blocksInserted,
     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(", ")}.`,
-    }),
   };
 }