openclaw-lark-multi-agent 0.1.8 → 0.1.9

package/dist/feishu-bot.js

@@ -2,6 +2,7 @@ import * as lark from "@larksuiteoapi/node-sdk";
 import { existsSync, readFileSync, statSync } from "fs";
 import { basename, extname, resolve } from "path";
 import { getBridgeAttachmentsDir } from "./paths.js";
+import { buildFeishuCardElements } from "./markdown.js";
 const MAX_BOT_STREAK = 10;
 const BRIDGE_ATTACHMENTS_DIR = getBridgeAttachmentsDir();
 /**
@@ -763,12 +764,7 @@ export class FeishuBot {
             schema: "2.0",
             config: { wide_screen_mode: true },
             body: {
-                elements: [
-                    {
-                        tag: "markdown",
-                        content: text,
-                    },
-                ],
+                elements: buildFeishuCardElements(text),
             },
         };
     }

package/dist/markdown.d.ts

@@ -0,0 +1,31 @@
+declare function optimizeMarkdownStyle(text: string, cardVersion?: number): string;
+declare function convertMarkdownTables(markdown: string): string;
+type FeishuMarkdownElement = {
+    tag: "markdown";
+    content: string;
+};
+type FeishuTableElement = {
+    tag: "table";
+    page_size?: number;
+    row_height?: "low";
+    header_style?: Record<string, unknown>;
+    columns: Array<{
+        name: string;
+        display_name: string;
+        data_type: "lark_md";
+        width?: string;
+        vertical_align?: "top" | "center" | "bottom";
+        horizontal_align?: "left" | "center" | "right";
+    }>;
+    rows: Array<Record<string, string>>;
+};
+export type FeishuCardElement = FeishuMarkdownElement | FeishuTableElement;
+declare function buildTableElement(lines: string[], index: number): FeishuTableElement | null;
+export declare function buildFeishuCardElements(markdown: string): FeishuCardElement[];
+export declare function prepareMarkdownForFeishu(text: string): string;
+export declare const __test__: {
+    convertMarkdownTables: typeof convertMarkdownTables;
+    optimizeMarkdownStyle: typeof optimizeMarkdownStyle;
+    buildTableElement: typeof buildTableElement;
+};
+export {};

package/dist/markdown.js

@@ -0,0 +1,203 @@
+const MARKDOWN_STYLE_MARKERS = {
+    bold: { open: "**", close: "**" },
+    italic: { open: "_", close: "_" },
+    strikethrough: { open: "~~", close: "~~" },
+    code: { open: "`", close: "`" },
+    code_block: { open: "```\n", close: "```" },
+};
+const IMAGE_RE = /!\[([^\]]*)\]\(([^)\s]+)\)/g;
+function protectCodeBlocks(text) {
+    const blocks = [];
+    const protectedText = text.replace(/(^|\n)(`{3,})([^\n]*)\n[\s\S]*?\n\2(?=\n|$)/g, (match, prefix = "") => {
+        const block = match.slice(String(prefix).length);
+        const token = `___LMA_CB_${blocks.length}___`;
+        blocks.push({ token, text: block });
+        return `${prefix}${token}`;
+    });
+    return { text: protectedText, blocks };
+}
+function restoreCodeBlocks(text, blocks, cardVersion = 2) {
+    let restored = text;
+    for (const { token, text: block } of blocks) {
+        restored = restored.replace(token, cardVersion >= 2 ? `\n<br>\n${block}\n<br>\n` : block);
+    }
+    return restored;
+}
+function stripInvalidImageKeys(text) {
+    if (!text.includes("!["))
+        return text;
+    return text.replace(IMAGE_RE, (fullMatch, _alt, value) => {
+        if (String(value).startsWith("img_"))
+            return fullMatch;
+        return "";
+    });
+}
+function optimizeMarkdownStyle(text, cardVersion = 2) {
+    try {
+        const protectedResult = protectCodeBlocks(text);
+        let r = protectedResult.text;
+        const hasH1toH3 = /^#{1,3} /m.test(text);
+        if (hasH1toH3) {
+            r = r.replace(/^#{2,6} (.+)$/gm, "##### $1");
+            r = r.replace(/^# (.+)$/gm, "#### $1");
+        }
+        if (cardVersion >= 2) {
+            r = r.replace(/^(#{4,5} .+)\n{1,2}(#{4,5} )/gm, "$1\n<br>\n$2");
+            r = r.replace(/^([^|\n].*)\n(\|.+\|)/gm, "$1\n\n$2");
+            r = r.replace(/\n\n((?:\|.+\|[^\S\n]*\n?)+)/g, "\n\n<br>\n\n$1");
+            r = r.replace(/((?:^\|.+\|[^\S\n]*\n?)+)/gm, (match, _table, offset) => {
+                const after = r.slice(offset + match.length).replace(/^\n+/, "");
+                if (!after || /^(---|#{4,5} |\*\*)/.test(after))
+                    return match;
+                return `${match}\n<br>\n`;
+            });
+            r = r.replace(/^((?!#{4,5} )(?!\*\*).+)\n\n(<br>)\n\n(\|)/gm, "$1\n$2\n$3");
+            r = r.replace(/^(\*\*.+)\n\n(<br>)\n\n(\|)/gm, "$1\n$2\n\n$3");
+            r = r.replace(/(\|[^\n]*\n)\n(<br>\n)((?!#{4,5} )(?!\*\*))/gm, "$1$2$3");
+        }
+        r = restoreCodeBlocks(r, protectedResult.blocks, cardVersion);
+        r = r.replace(/\n{3,}/g, "\n\n");
+        return stripInvalidImageKeys(r);
+    }
+    catch {
+        return text;
+    }
+}
+function isMarkdownTableSeparator(line) {
+    const trimmed = line.trim();
+    if (!trimmed.includes("|"))
+        return false;
+    const cells = trimmed.replace(/^\|/, "").replace(/\|$/, "").split("|").map((cell) => cell.trim());
+    return cells.length >= 2 && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
+}
+function isMarkdownTableRow(line) {
+    const trimmed = line.trim();
+    return trimmed.includes("|") && trimmed.replace(/^\|/, "").replace(/\|$/, "").split("|").length >= 2;
+}
+function splitMarkdownTableRow(line) {
+    return line.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((cell) => cell.trim());
+}
+function formatTableAsCodeBlock(lines) {
+    const rows = lines.filter((line) => !isMarkdownTableSeparator(line)).map(splitMarkdownTableRow);
+    if (rows.length === 0)
+        return lines.join("\n");
+    const width = Math.max(...rows.map((row) => row.length));
+    const widths = Array.from({ length: width }, (_, i) => Math.max(...rows.map((row) => row[i]?.length ?? 0), 1));
+    const renderedRows = rows.map((row, rowIndex) => {
+        const rendered = widths.map((w, i) => (row[i] ?? "").padEnd(w)).join("  ").trimEnd();
+        if (rowIndex === 0 && rows.length > 1) {
+            const sep = widths.map((w) => "─".repeat(w)).join("  ");
+            return `${rendered}\n${sep}`;
+        }
+        return rendered;
+    });
+    return `\n\`\`\`\n${renderedRows.join("\n")}\n\`\`\`\n`;
+}
+function convertMarkdownTables(markdown) {
+    const { text, blocks } = protectCodeBlocks(markdown);
+    const lines = text.split("\n");
+    const out = [];
+    let i = 0;
+    while (i < lines.length) {
+        if (i + 1 < lines.length && isMarkdownTableRow(lines[i]) && isMarkdownTableSeparator(lines[i + 1])) {
+            const tableLines = [lines[i], lines[i + 1]];
+            i += 2;
+            while (i < lines.length && isMarkdownTableRow(lines[i])) {
+                tableLines.push(lines[i]);
+                i++;
+            }
+            out.push(formatTableAsCodeBlock(tableLines));
+            continue;
+        }
+        out.push(lines[i]);
+        i++;
+    }
+    return restoreCodeBlocks(out.join("\n"), blocks, 1);
+}
+function buildTableElement(lines, index) {
+    const rows = lines.filter((line) => !isMarkdownTableSeparator(line)).map(splitMarkdownTableRow);
+    if (rows.length < 2)
+        return null;
+    const headers = rows[0];
+    if (headers.length === 0)
+        return null;
+    const width = Math.min(Math.max(...rows.map((row) => row.length)), 50);
+    const columns = Array.from({ length: width }, (_, i) => ({
+        name: `c${index}_${i}`,
+        display_name: headers[i] || `列 ${i + 1}`,
+        data_type: "lark_md",
+        width: "auto",
+        vertical_align: "top",
+        horizontal_align: "left",
+    }));
+    const dataRows = rows.slice(1).map((row) => {
+        const item = {};
+        for (let i = 0; i < columns.length; i++)
+            item[columns[i].name] = row[i] || "";
+        return item;
+    });
+    return {
+        tag: "table",
+        page_size: Math.min(Math.max(dataRows.length, 1), 10),
+        header_style: {
+            text_align: "left",
+            text_size: "normal",
+            background_style: "grey",
+            text_color: "default",
+            bold: true,
+            lines: 2,
+        },
+        columns,
+        rows: dataRows,
+    };
+}
+function pushMarkdownElement(elements, text) {
+    const content = optimizeMarkdownStyle(text.trim(), 2).trim();
+    if (!content)
+        return;
+    elements.push({ tag: "markdown", content });
+}
+export function buildFeishuCardElements(markdown) {
+    const { text, blocks } = protectCodeBlocks(markdown);
+    const lines = text.split("\n");
+    const elements = [];
+    const buffer = [];
+    let tableCount = 0;
+    let i = 0;
+    while (i < lines.length) {
+        if (i + 1 < lines.length && isMarkdownTableRow(lines[i]) && isMarkdownTableSeparator(lines[i + 1])) {
+            const tableLines = [lines[i], lines[i + 1]];
+            i += 2;
+            while (i < lines.length && isMarkdownTableRow(lines[i])) {
+                tableLines.push(lines[i]);
+                i++;
+            }
+            pushMarkdownElement(elements, restoreCodeBlocks(buffer.join("\n"), blocks, 1));
+            buffer.length = 0;
+            // Feishu cards support up to 5 table components per card. Fall back to a
+            // readable code-block table after that instead of sending an invalid card.
+            if (tableCount < 5) {
+                const table = buildTableElement(tableLines, tableCount);
+                if (table) {
+                    elements.push(table);
+                    tableCount++;
+                }
+                else {
+                    buffer.push(formatTableAsCodeBlock(tableLines));
+                }
+            }
+            else {
+                buffer.push(formatTableAsCodeBlock(tableLines));
+            }
+            continue;
+        }
+        buffer.push(lines[i]);
+        i++;
+    }
+    pushMarkdownElement(elements, restoreCodeBlocks(buffer.join("\n"), blocks, 1));
+    return elements.length > 0 ? elements : [{ tag: "markdown", content: "" }];
+}
+export function prepareMarkdownForFeishu(text) {
+    return optimizeMarkdownStyle(convertMarkdownTables(text), 2);
+}
+export const __test__ = { convertMarkdownTables, optimizeMarkdownStyle, buildTableElement };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-lark-multi-agent",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {