@max1874/feishu 0.2.16 → 0.2.18

package/src/feishu-renderer.ts

@@ -0,0 +1,441 @@
+/**
+ * Feishu Document Renderer using marked.
+ *
+ * Converts Markdown AST to Feishu Block structure.
+ */
+
+import { Lexer, type Token, type Tokens } from "marked";
+
+// Code language mapping for Feishu
+export const CODE_LANG_MAP: Record<string, number> = {
+  python: 49,
+  py: 49,
+  javascript: 30,
+  js: 30,
+  typescript: 63,
+  ts: 63,
+  go: 22,
+  golang: 22,
+  rust: 53,
+  java: 29,
+  kotlin: 32,
+  kt: 32,
+  c: 10,
+  cpp: 9,
+  "c++": 9,
+  sql: 56,
+  bash: 7,
+  shell: 7,
+  sh: 7,
+  json: 28,
+  yaml: 67,
+  yml: 67,
+  markdown: 39,
+  md: 39,
+  html: 24,
+  css: 12,
+  swift: 61,
+  ruby: 52,
+  php: 43,
+};
+
+/**
+ * Placeholder for table content.
+ *
+ * Tables in Feishu require special handling via nested blocks API.
+ */
+export class TablePlaceholder {
+  rows: string[][];
+  rowSize: number;
+  colSize: number;
+
+  constructor(rows: string[][]) {
+    this.rows = rows;
+    this.rowSize = rows.length;
+    this.colSize = rows.length > 0 ? Math.max(...rows.map((r) => r.length)) : 0;
+  }
+
+  toString(): string {
+    return `TablePlaceholder(${this.rowSize}x${this.colSize})`;
+  }
+}
+
+/** Feishu text element */
+export interface TextElement {
+  text_run: {
+    content: string;
+    text_element_style?: {
+      bold?: boolean;
+      italic?: boolean;
+      strikethrough?: boolean;
+      inline_code?: boolean;
+      link?: { url: string };
+    };
+  };
+}
+
+/** Feishu block structure */
+export interface FeishuBlock {
+  block_id: string;
+  block_type: number;
+  children: string[];
+  text?: { elements: TextElement[] };
+  heading1?: { elements: TextElement[] };
+  heading2?: { elements: TextElement[] };
+  heading3?: { elements: TextElement[] };
+  heading4?: { elements: TextElement[] };
+  heading5?: { elements: TextElement[] };
+  heading6?: { elements: TextElement[] };
+  heading7?: { elements: TextElement[] };
+  heading8?: { elements: TextElement[] };
+  heading9?: { elements: TextElement[] };
+  bullet?: { elements: TextElement[] };
+  ordered?: { elements: TextElement[] };
+  code?: { elements: TextElement[]; style: { language: number } };
+  quote_container?: Record<string, never>;
+  divider?: Record<string, never>;
+  _nested_blocks?: FeishuBlock[];
+}
+
+/** Content item: either a block or a table placeholder */
+export type ContentItem = FeishuBlock | TablePlaceholder;
+
+/**
+ * Render Markdown to Feishu Block structure.
+ */
+export class FeishuRenderer {
+  private blockId = 0;
+
+  private nextId(): string {
+    this.blockId++;
+    return `block_${this.blockId}`;
+  }
+
+  /**
+   * Render markdown tokens to Feishu blocks.
+   */
+  render(tokens: Token[]): ContentItem[] {
+    const result: ContentItem[] = [];
+    for (const token of tokens) {
+      const block = this.renderToken(token);
+      if (block !== null) {
+        if (Array.isArray(block)) {
+          result.push(...block);
+        } else {
+          result.push(block);
+        }
+      }
+    }
+    return result;
+  }
+
+  private renderToken(token: Token): ContentItem | ContentItem[] | null {
+    switch (token.type) {
+      case "paragraph":
+        return this.paragraph(token as Tokens.Paragraph);
+      case "heading":
+        return this.heading(token as Tokens.Heading);
+      case "code":
+        return this.blockCode(token as Tokens.Code);
+      case "blockquote":
+        return this.blockQuote(token as Tokens.Blockquote);
+      case "list":
+        return this.list(token as Tokens.List);
+      case "hr":
+        return this.thematicBreak();
+      case "table":
+        return this.table(token as Tokens.Table);
+      case "space":
+        return null;
+      default:
+        return null;
+    }
+  }
+
+  // === Block-level rendering ===
+
+  private paragraph(token: Tokens.Paragraph): FeishuBlock {
+    const elements = this.renderInlineTokens(token.tokens ?? []);
+    return {
+      block_id: this.nextId(),
+      block_type: 2,
+      text: { elements },
+      children: [],
+    };
+  }
+
+  private heading(token: Tokens.Heading): FeishuBlock {
+    const level = token.depth;
+    const elements = this.renderInlineTokens(token.tokens ?? []);
+    const key = `heading${level}` as keyof FeishuBlock;
+    return {
+      block_id: this.nextId(),
+      block_type: 2 + level, // heading1=3, heading2=4, etc.
+      [key]: { elements },
+      children: [],
+    };
+  }
+
+  private blockCode(token: Tokens.Code): FeishuBlock {
+    const lang = token.lang ?? "";
+    const langCode = CODE_LANG_MAP[lang.toLowerCase()] ?? 1;
+    return {
+      block_id: this.nextId(),
+      block_type: 14,
+      code: {
+        elements: [{ text_run: { content: token.text } }],
+        style: { language: langCode },
+      },
+      children: [],
+    };
+  }
+
+  private blockQuote(token: Tokens.Blockquote): FeishuBlock {
+    const containerId = this.nextId();
+    const nestedBlocks: FeishuBlock[] = [];
+
+    for (const child of token.tokens ?? []) {
+      const block = this.renderToken(child);
+      if (block !== null) {
+        if (Array.isArray(block)) {
+          for (const b of block) {
+            if (!(b instanceof TablePlaceholder)) {
+              nestedBlocks.push(b);
+            }
+          }
+        } else if (!(block instanceof TablePlaceholder)) {
+          nestedBlocks.push(block);
+        }
+      }
+    }
+
+    return {
+      block_id: containerId,
+      block_type: 34, // quote_container
+      quote_container: {},
+      children: nestedBlocks.map((b) => b.block_id),
+      _nested_blocks: nestedBlocks,
+    };
+  }
+
+  private list(token: Tokens.List): FeishuBlock[] {
+    const ordered = token.ordered;
+    const blockType = ordered ? 13 : 12;
+    const key = ordered ? "ordered" : "bullet";
+
+    const result: FeishuBlock[] = [];
+    for (const item of token.items) {
+      const elements = this.renderListItemContent(item);
+      result.push({
+        block_id: this.nextId(),
+        block_type: blockType,
+        [key]: { elements: elements.length > 0 ? elements : [{ text_run: { content: "" } }] },
+        children: [],
+      });
+    }
+    return result;
+  }
+
+  private renderListItemContent(item: Tokens.ListItem): TextElement[] {
+    const elements: TextElement[] = [];
+    for (const child of item.tokens ?? []) {
+      if (child.type === "text") {
+        const textToken = child as Tokens.Text;
+        if (textToken.tokens) {
+          elements.push(...this.renderInlineTokens(textToken.tokens));
+        } else {
+          elements.push({ text_run: { content: textToken.raw } });
+        }
+      } else if (child.type === "paragraph") {
+        const paraToken = child as Tokens.Paragraph;
+        elements.push(...this.renderInlineTokens(paraToken.tokens ?? []));
+      }
+    }
+    return elements;
+  }
+
+  private thematicBreak(): FeishuBlock {
+    return {
+      block_id: this.nextId(),
+      block_type: 22,
+      divider: {},
+      children: [],
+    };
+  }
+
+  // === Table rendering ===
+
+  private table(token: Tokens.Table): TablePlaceholder {
+    const rows: string[][] = [];
+
+    // Header row
+    const headerRow: string[] = [];
+    for (const cell of token.header) {
+      headerRow.push(this.extractTextContent(cell.tokens));
+    }
+    rows.push(headerRow);
+
+    // Body rows
+    for (const row of token.rows) {
+      const rowData: string[] = [];
+      for (const cell of row) {
+        rowData.push(this.extractTextContent(cell.tokens));
+      }
+      rows.push(rowData);
+    }
+
+    return new TablePlaceholder(rows);
+  }
+
+  private extractTextContent(tokens: Token[]): string {
+    const parts: string[] = [];
+    for (const token of tokens) {
+      if (token.type === "text") {
+        parts.push((token as Tokens.Text).text);
+      } else if (token.type === "codespan") {
+        parts.push((token as Tokens.Codespan).text);
+      } else if (token.type === "strong" || token.type === "em" || token.type === "del") {
+        const t = token as Tokens.Strong | Tokens.Em | Tokens.Del;
+        parts.push(this.extractTextContent(t.tokens ?? []));
+      } else if (token.type === "link") {
+        const linkToken = token as Tokens.Link;
+        parts.push(this.extractTextContent(linkToken.tokens ?? []));
+      }
+    }
+    return parts.join("");
+  }
+
+  // === Inline-level rendering ===
+
+  private renderInlineTokens(tokens: Token[]): TextElement[] {
+    const elements: TextElement[] = [];
+    for (const token of tokens) {
+      const result = this.renderInline(token);
+      if (result) {
+        if (Array.isArray(result)) {
+          elements.push(...result);
+        } else {
+          elements.push(result);
+        }
+      }
+    }
+    return elements.length > 0 ? elements : [{ text_run: { content: "" } }];
+  }
+
+  private renderInline(token: Token): TextElement | TextElement[] | null {
+    switch (token.type) {
+      case "text":
+        return { text_run: { content: (token as Tokens.Text).text } };
+
+      case "strong": {
+        const strongToken = token as Tokens.Strong;
+        const elements = this.renderInlineTokens(strongToken.tokens ?? []);
+        for (const el of elements) {
+          el.text_run.text_element_style = el.text_run.text_element_style ?? {};
+          el.text_run.text_element_style.bold = true;
+        }
+        return elements;
+      }
+
+      case "em": {
+        const emToken = token as Tokens.Em;
+        const elements = this.renderInlineTokens(emToken.tokens ?? []);
+        for (const el of elements) {
+          el.text_run.text_element_style = el.text_run.text_element_style ?? {};
+          el.text_run.text_element_style.italic = true;
+        }
+        return elements;
+      }
+
+      case "del": {
+        const delToken = token as Tokens.Del;
+        const elements = this.renderInlineTokens(delToken.tokens ?? []);
+        for (const el of elements) {
+          el.text_run.text_element_style = el.text_run.text_element_style ?? {};
+          el.text_run.text_element_style.strikethrough = true;
+        }
+        return elements;
+      }
+
+      case "codespan":
+        return {
+          text_run: {
+            content: (token as Tokens.Codespan).text,
+            text_element_style: { inline_code: true },
+          },
+        };
+
+      case "link": {
+        const linkToken = token as Tokens.Link;
+        const elements = this.renderInlineTokens(linkToken.tokens ?? []);
+        const encodedUrl = encodeURIComponent(linkToken.href);
+        for (const el of elements) {
+          el.text_run.text_element_style = el.text_run.text_element_style ?? {};
+          el.text_run.text_element_style.link = { url: encodedUrl };
+        }
+        return elements;
+      }
+
+      case "br":
+        return { text_run: { content: "\n" } };
+
+      case "html":
+        return { text_run: { content: (token as Tokens.HTML).raw } };
+
+      default:
+        return null;
+    }
+  }
+}
+
+/**
+ * Convert Markdown to Feishu Block structure.
+ *
+ * @param mdContent Markdown content string
+ * @returns Object with blocks array and tables array
+ */
+export function markdownToFeishuBlocks(mdContent: string): {
+  blocks: FeishuBlock[];
+  tables: TablePlaceholder[];
+  allItems: ContentItem[];
+} {
+  const lexer = new Lexer();
+  const tokens = lexer.lex(mdContent);
+
+  const renderer = new FeishuRenderer();
+  const items = renderer.render(tokens);
+
+  const blocks: FeishuBlock[] = [];
+  const tables: TablePlaceholder[] = [];
+
+  function collectBlocks(item: ContentItem) {
+    if (item instanceof TablePlaceholder) {
+      tables.push(item);
+    } else {
+      blocks.push(item);
+      // Collect nested blocks (e.g., from blockquote)
+      if (item._nested_blocks) {
+        for (const nested of item._nested_blocks) {
+          blocks.push(nested);
+        }
+      }
+    }
+  }
+
+  for (const item of items) {
+    collectBlocks(item);
+  }
+
+  return { blocks, tables, allItems: items };
+}
+
+/**
+ * Prepare blocks for Feishu API.
+ * Removes helper fields before sending to API.
+ */
+export function prepareBlocksForApi(blocks: FeishuBlock[]): any[] {
+  return blocks.map((block) => {
+    const { block_id, children, _nested_blocks, ...rest } = block;
+    return rest;
+  });
+}

package/src/runtime.ts

@@ -1,4 +1,5 @@
 import type { PluginRuntime } from "openclaw/plugin-sdk";
+import { AsyncLocalStorage } from "node:async_hooks";
 
 let runtime: PluginRuntime | null = null;
 
@@ -12,3 +13,21 @@ export function getFeishuRuntime(): PluginRuntime {
   }
   return runtime;
 }
+
+// --- Conversation context (tracked via AsyncLocalStorage for concurrency safety) ---
+
+export interface FeishuConversationContext {
+  senderOpenId: string;
+  chatId: string;
+  chatType: "group" | "p2p";
+}
+
+const conversationStore = new AsyncLocalStorage<FeishuConversationContext>();
+
+export function runWithConversationContext<T>(ctx: FeishuConversationContext, fn: () => T): T {
+  return conversationStore.run(ctx, fn);
+}
+
+export function getConversationContext(): FeishuConversationContext | undefined {
+  return conversationStore.getStore();
+}