@max1874/feishu 0.2.3 → 0.2.5

package/package.json

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

package/src/docx.ts

@@ -65,11 +65,9 @@ const BLOCK_TYPE_NAMES: Record<number, string> = {
 };
 
 // Block types that cannot be created via documentBlockChildren.create API
-// Note: Table (31) and TableCell (32) were previously excluded, but the convert API
-// returns them with proper structure, so we attempt to create them directly.
-// If creation fails, the error will be reported to the user.
-const UNSUPPORTED_CREATE_TYPES = new Set<number>([
-  // Empty for now - let's try creating tables directly
+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) */
@@ -85,7 +83,7 @@ function cleanBlocksForInsert(blocks: any[]): { cleaned: any[]; skipped: string[
       return true;
     })
     .map((block) => {
-      // Remove read-only fields from table blocks that might cause API errors
+      // 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 };
@@ -97,6 +95,70 @@ function cleanBlocksForInsert(blocks: any[]): { cleaned: any[]; skipped: string[
 
 // ============ Core Functions ============
 
+/**
+ * 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("|");
+  };
+
+  const isSeparatorLine = (line: string): boolean => {
+    const trimmed = line.trim();
+    // Separator line contains only |, -, :, and spaces
+    return /^\|[\s\-:|]+\|$/.test(trimmed);
+  };
+
+  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);
+      }
+    } 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);
+    }
+  }
+
+  // Flush remaining table if any
+  if (inTable) {
+    flushTable();
+  }
+
+  return result.join("\n");
+}
+
 /** Convert markdown to Feishu blocks using the Convert API */
 async function convertMarkdown(client: Lark.Client, markdown: string) {
   const res = await client.docx.document.convert({
@@ -123,34 +185,12 @@ async function insertBlocks(
     return { children: [], skipped };
   }
 
-  // Log table blocks for debugging
-  const tableBlocks = cleaned.filter((b) => b.block_type === 31);
-  if (tableBlocks.length > 0) {
-    console.log(`[feishu_doc] Attempting to insert ${tableBlocks.length} table block(s)`);
-  }
-
-  try {
-    const res = await client.docx.documentBlockChildren.create({
-      path: { document_id: docToken, block_id: blockId },
-      data: { children: cleaned },
-    });
-    if (res.code !== 0) {
-      throw new Error(`API error ${res.code}: ${res.msg}`);
-    }
-    return { children: res.data?.children ?? [], skipped };
-  } catch (err: any) {
-    // Enhanced error logging
-    const errMsg = err?.response?.data?.msg || err?.message || String(err);
-    const errCode = err?.response?.data?.code || err?.code;
-    console.error(`[feishu_doc] insertBlocks failed: code=${errCode}, msg=${errMsg}`);
-
-    // If table blocks exist, report them as problematic
-    if (tableBlocks.length > 0) {
-      console.error(`[feishu_doc] Table block structure sample:`, JSON.stringify(tableBlocks[0], null, 2).slice(0, 500));
-      throw new Error(`Table insertion failed (code=${errCode}): ${errMsg}. Tables may not be supported via this API.`);
-    }
-    throw err;
-  }
+  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 };
 }
 
 /** Delete all child blocks from a parent */
@@ -440,43 +480,65 @@ async function createDoc(
 }
 
 async function writeDoc(client: Lark.Client, docToken: string, markdown: string) {
-  // 1. Clear existing content
-  const deleted = await clearDocumentContent(client, docToken);
+  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 ?? [];
 
-  // 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 };
-  }
+    if (blocks.length === 0) {
+      return { success: true, blocks_deleted: deleted, blocks_added: 0, images_processed: 0 };
+    }
 
-  // 3. Insert new blocks (unsupported types like Table are filtered)
-  const { children: inserted, skipped } = await insertBlocks(client, docToken, blocks);
+    // 4. Insert new blocks (unsupported types like Table are filtered)
+    step = "insert_blocks";
+    const { children: inserted, skipped } = await insertBlocks(client, docToken, blocks);
 
-  // 4. Process images
-  const imagesProcessed = await processImages(client, docToken, markdown, inserted);
+    // 5. Process images
+    step = "process_images";
+    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.`,
-    }),
-  };
+    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}`);
+  }
 }
 
 async function appendDoc(client: Lark.Client, docToken: string, markdown: string) {
-  // 1. Convert markdown to blocks
-  const { blocks } = await convertMarkdown(client, markdown);
+  // 1. Pre-process markdown (convert tables to code blocks)
+  const processedMarkdown = convertTablesToCodeBlocks(markdown);
+
+  // 2. Convert markdown to blocks
+  const { blocks } = await convertMarkdown(client, processedMarkdown);
   if (blocks.length === 0) {
     throw new Error("Content is empty");
   }
 
-  // 2. Insert blocks (unsupported types like Table are filtered)
+  // 3. Insert blocks (unsupported types like Table are filtered)
   const { children: inserted, skipped } = await insertBlocks(client, docToken, blocks);
 
-  // 3. Process images
+  // 4. Process images
   const imagesProcessed = await processImages(client, docToken, markdown, inserted);
 
   return {
@@ -594,32 +656,6 @@ async function listAppScopes(client: Lark.Client) {
   };
 }
 
-/** Debug: convert markdown and show resulting block structure */
-async function debugConvertMarkdown(client: Lark.Client, markdown: string) {
-  const { blocks } = await convertMarkdown(client, markdown);
-
-  const blockTypeCounts: Record<string, number> = {};
-  for (const block of blocks) {
-    const typeName = BLOCK_TYPE_NAMES[block.block_type] || `type_${block.block_type}`;
-    blockTypeCounts[typeName] = (blockTypeCounts[typeName] || 0) + 1;
-  }
-
-  // Find table blocks and show their structure
-  const tableBlocks = blocks.filter((b) => b.block_type === 31);
-  let tableSample: any = null;
-  if (tableBlocks.length > 0) {
-    tableSample = tableBlocks[0];
-  }
-
-  return {
-    total_blocks: blocks.length,
-    block_types: blockTypeCounts,
-    has_tables: tableBlocks.length > 0,
-    table_count: tableBlocks.length,
-    table_sample: tableSample ? JSON.stringify(tableSample, null, 2) : null,
-  };
-}
-
 // ============ Schemas ============
 
 const DocTokenSchema = Type.Object({
@@ -676,10 +712,6 @@ const SetPermissionSchema = Type.Object({
   }),
 });
 
-const DebugConvertSchema = Type.Object({
-  content: Type.String({ description: "Markdown content to convert (for debugging block structure)" }),
-});
-
 // Wiki Schemas
 const WikiTokenSchema = Type.Object({
   wiki_token: Type.String({ description: "Wiki token (extract from URL /wiki/XXX)" }),
@@ -1015,26 +1047,5 @@ export function registerFeishuDocTools(api: OpenClawPluginApi) {
     { name: "feishu_app_scopes" },
   );
 
-  // Tool 15: feishu_debug_convert (for diagnosing markdown conversion issues)
-  api.registerTool(
-    {
-      name: "feishu_debug_convert",
-      label: "Feishu Debug Convert",
-      description:
-        "Debug tool: convert markdown to blocks and show the resulting structure. Use to diagnose why certain markdown (like tables) may fail to write.",
-      parameters: DebugConvertSchema,
-      async execute(_toolCallId, params) {
-        const { content } = params as { content: string };
-        try {
-          const result = await debugConvertMarkdown(getClient(), content);
-          return json(result);
-        } catch (err) {
-          return json({ error: err instanceof Error ? err.message : String(err) });
-        }
-      },
-    },
-    { name: "feishu_debug_convert" },
-  );
-
-  api.logger.info?.(`feishu_doc: Registered 15 document/wiki tools`);
+  api.logger.info?.(`feishu_doc: Registered 14 document/wiki tools`);
 }