@openclaw/feishu 2026.2.24 → 2026.3.1

package/src/outbound.ts

@@ -1,7 +1,64 @@
+import fs from "fs";
+import path from "path";
 import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk";
+import { resolveFeishuAccount } from "./accounts.js";
 import { sendMediaFeishu } from "./media.js";
 import { getFeishuRuntime } from "./runtime.js";
-import { sendMessageFeishu } from "./send.js";
+import { sendMarkdownCardFeishu, sendMessageFeishu } from "./send.js";
+
+function normalizePossibleLocalImagePath(text: string | undefined): string | null {
+  const raw = text?.trim();
+  if (!raw) return null;
+
+  // Only auto-convert when the message is a pure path-like payload.
+  // Avoid converting regular sentences that merely contain a path.
+  const hasWhitespace = /\s/.test(raw);
+  if (hasWhitespace) return null;
+
+  // Ignore links/data URLs; those should stay in normal mediaUrl/text paths.
+  if (/^(https?:\/\/|data:|file:\/\/)/i.test(raw)) return null;
+
+  const ext = path.extname(raw).toLowerCase();
+  const isImageExt = [".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".ico", ".tiff"].includes(
+    ext,
+  );
+  if (!isImageExt) return null;
+
+  if (!path.isAbsolute(raw)) return null;
+  if (!fs.existsSync(raw)) return null;
+
+  // Fix race condition: wrap statSync in try-catch to handle file deletion
+  // between existsSync and statSync
+  try {
+    if (!fs.statSync(raw).isFile()) return null;
+  } catch {
+    // File may have been deleted or became inaccessible between checks
+    return null;
+  }
+
+  return raw;
+}
+
+function shouldUseCard(text: string): boolean {
+  return /```[\s\S]*?```/.test(text) || /\|.+\|[\r\n]+\|[-:| ]+\|/.test(text);
+}
+
+async function sendOutboundText(params: {
+  cfg: Parameters<typeof sendMessageFeishu>[0]["cfg"];
+  to: string;
+  text: string;
+  accountId?: string;
+}) {
+  const { cfg, to, text, accountId } = params;
+  const account = resolveFeishuAccount({ cfg, accountId });
+  const renderMode = account.config?.renderMode ?? "auto";
+
+  if (renderMode === "card" || (renderMode === "auto" && shouldUseCard(text))) {
+    return sendMarkdownCardFeishu({ cfg, to, text, accountId });
+  }
+
+  return sendMessageFeishu({ cfg, to, text, accountId });
+}
 
 export const feishuOutbound: ChannelOutboundAdapter = {
   deliveryMode: "direct",
@@ -9,16 +66,45 @@ export const feishuOutbound: ChannelOutboundAdapter = {
   chunkerMode: "markdown",
   textChunkLimit: 4000,
   sendText: async ({ cfg, to, text, accountId }) => {
-    const result = await sendMessageFeishu({ cfg, to, text, accountId: accountId ?? undefined });
+    // Scheme A compatibility shim:
+    // when upstream accidentally returns a local image path as plain text,
+    // auto-upload and send as Feishu image message instead of leaking path text.
+    const localImagePath = normalizePossibleLocalImagePath(text);
+    if (localImagePath) {
+      try {
+        const result = await sendMediaFeishu({
+          cfg,
+          to,
+          mediaUrl: localImagePath,
+          accountId: accountId ?? undefined,
+        });
+        return { channel: "feishu", ...result };
+      } catch (err) {
+        console.error(`[feishu] local image path auto-send failed:`, err);
+        // fall through to plain text as last resort
+      }
+    }
+
+    const result = await sendOutboundText({
+      cfg,
+      to,
+      text,
+      accountId: accountId ?? undefined,
+    });
     return { channel: "feishu", ...result };
   },
-  sendMedia: async ({ cfg, to, text, mediaUrl, accountId }) => {
+  sendMedia: async ({ cfg, to, text, mediaUrl, accountId, mediaLocalRoots }) => {
     // Send text first if provided
     if (text?.trim()) {
-      await sendMessageFeishu({ cfg, to, text, accountId: accountId ?? undefined });
+      await sendOutboundText({
+        cfg,
+        to,
+        text,
+        accountId: accountId ?? undefined,
+      });
     }
 
-    // Upload and send media if URL provided
+    // Upload and send media if URL or local path provided
     if (mediaUrl) {
       try {
         const result = await sendMediaFeishu({
@@ -26,6 +112,7 @@ export const feishuOutbound: ChannelOutboundAdapter = {
           to,
           mediaUrl,
           accountId: accountId ?? undefined,
+          mediaLocalRoots,
         });
         return { channel: "feishu", ...result };
       } catch (err) {
@@ -33,7 +120,7 @@ export const feishuOutbound: ChannelOutboundAdapter = {
         console.error(`[feishu] sendMediaFeishu failed:`, err);
         // Fallback to URL link if upload fails
         const fallbackText = `📎 ${mediaUrl}`;
-        const result = await sendMessageFeishu({
+        const result = await sendOutboundText({
           cfg,
           to,
           text: fallbackText,
@@ -44,7 +131,7 @@ export const feishuOutbound: ChannelOutboundAdapter = {
     }
 
     // No media URL, just return text result
-    const result = await sendMessageFeishu({
+    const result = await sendOutboundText({
       cfg,
       to,
       text: text ?? "",

package/src/perm.ts

@@ -1,9 +1,8 @@
 import type * as Lark from "@larksuiteoapi/node-sdk";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { listEnabledFeishuAccounts } from "./accounts.js";
-import { createFeishuClient } from "./client.js";
 import { FeishuPermSchema, type FeishuPermParams } from "./perm-schema.js";
-import { resolveToolsConfig } from "./tools-config.js";
+import { createFeishuToolClient, resolveAnyEnabledFeishuToolsConfig } from "./tool-account.js";
 
 // ============ Helpers ============
 
@@ -129,42 +128,50 @@ export function registerFeishuPermTools(api: OpenClawPluginApi) {
     return;
   }
 
-  const firstAccount = accounts[0];
-  const toolsCfg = resolveToolsConfig(firstAccount.config.tools);
+  const toolsCfg = resolveAnyEnabledFeishuToolsConfig(accounts);
   if (!toolsCfg.perm) {
     api.logger.debug?.("feishu_perm: perm tool disabled in config (default: false)");
     return;
   }
 
-  const getClient = () => createFeishuClient(firstAccount);
+  type FeishuPermExecuteParams = FeishuPermParams & { accountId?: string };
 
   api.registerTool(
-    {
-      name: "feishu_perm",
-      label: "Feishu Perm",
-      description: "Feishu permission management. Actions: list, add, remove",
-      parameters: FeishuPermSchema,
-      async execute(_toolCallId, params) {
-        const p = params as FeishuPermParams;
-        try {
-          const client = getClient();
-          switch (p.action) {
-            case "list":
-              return json(await listMembers(client, p.token, p.type));
-            case "add":
-              return json(
-                await addMember(client, p.token, p.type, p.member_type, p.member_id, p.perm),
-              );
-            case "remove":
-              return json(await removeMember(client, p.token, p.type, p.member_type, p.member_id));
-            default:
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any -- exhaustive check fallback
-              return json({ error: `Unknown action: ${(p as any).action}` });
+    (ctx) => {
+      const defaultAccountId = ctx.agentAccountId;
+      return {
+        name: "feishu_perm",
+        label: "Feishu Perm",
+        description: "Feishu permission management. Actions: list, add, remove",
+        parameters: FeishuPermSchema,
+        async execute(_toolCallId, params) {
+          const p = params as FeishuPermExecuteParams;
+          try {
+            const client = createFeishuToolClient({
+              api,
+              executeParams: p,
+              defaultAccountId,
+            });
+            switch (p.action) {
+              case "list":
+                return json(await listMembers(client, p.token, p.type));
+              case "add":
+                return json(
+                  await addMember(client, p.token, p.type, p.member_type, p.member_id, p.perm),
+                );
+              case "remove":
+                return json(
+                  await removeMember(client, p.token, p.type, p.member_type, p.member_id),
+                );
+              default:
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any -- exhaustive check fallback
+                return json({ error: `Unknown action: ${(p as any).action}` });
+            }
+          } catch (err) {
+            return json({ error: err instanceof Error ? err.message : String(err) });
           }
-        } catch (err) {
-          return json({ error: err instanceof Error ? err.message : String(err) });
-        }
-      },
+        },
+      };
     },
     { name: "feishu_perm" },
   );

package/src/policy.test.ts

@@ -1,7 +1,62 @@
 import { describe, expect, it } from "vitest";
-import { isFeishuGroupAllowed, resolveFeishuAllowlistMatch } from "./policy.js";
+import {
+  isFeishuGroupAllowed,
+  resolveFeishuAllowlistMatch,
+  resolveFeishuGroupConfig,
+} from "./policy.js";
+import type { FeishuConfig } from "./types.js";
 
 describe("feishu policy", () => {
+  describe("resolveFeishuGroupConfig", () => {
+    it("falls back to wildcard group config when direct match is missing", () => {
+      const cfg = {
+        groups: {
+          "*": { requireMention: false },
+          "oc-explicit": { requireMention: true },
+        },
+      } as unknown as FeishuConfig;
+
+      const resolved = resolveFeishuGroupConfig({
+        cfg,
+        groupId: "oc-missing",
+      });
+
+      expect(resolved).toEqual({ requireMention: false });
+    });
+
+    it("prefers exact group config over wildcard", () => {
+      const cfg = {
+        groups: {
+          "*": { requireMention: false },
+          "oc-explicit": { requireMention: true },
+        },
+      } as unknown as FeishuConfig;
+
+      const resolved = resolveFeishuGroupConfig({
+        cfg,
+        groupId: "oc-explicit",
+      });
+
+      expect(resolved).toEqual({ requireMention: true });
+    });
+
+    it("keeps case-insensitive matching for explicit group ids", () => {
+      const cfg = {
+        groups: {
+          "*": { requireMention: false },
+          OC_UPPER: { requireMention: true },
+        },
+      } as unknown as FeishuConfig;
+
+      const resolved = resolveFeishuGroupConfig({
+        cfg,
+        groupId: "oc_upper",
+      });
+
+      expect(resolved).toEqual({ requireMention: true });
+    });
+  });
+
   describe("resolveFeishuAllowlistMatch", () => {
     it("allows wildcard", () => {
       expect(

package/src/policy.ts

@@ -56,6 +56,7 @@ export function resolveFeishuGroupConfig(params: {
   groupId?: string | null;
 }): FeishuGroupConfig | undefined {
   const groups = params.cfg?.groups ?? {};
+  const wildcard = groups["*"];
   const groupId = params.groupId?.trim();
   if (!groupId) {
     return undefined;
@@ -68,7 +69,10 @@ export function resolveFeishuGroupConfig(params: {
 
   const lowered = groupId.toLowerCase();
   const matchKey = Object.keys(groups).find((key) => key.toLowerCase() === lowered);
-  return matchKey ? groups[matchKey] : undefined;
+  if (matchKey) {
+    return groups[matchKey];
+  }
+  return wildcard;
 }
 
 export function resolveFeishuGroupToolPolicy(

package/src/post.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it } from "vitest";
+import { parsePostContent } from "./post.js";
+
+describe("parsePostContent", () => {
+  it("renders title and styled text as markdown", () => {
+    const content = JSON.stringify({
+      title: "Daily *Plan*",
+      content: [
+        [
+          { tag: "text", text: "Bold", style: { bold: true } },
+          { tag: "text", text: " " },
+          { tag: "text", text: "Italic", style: { italic: true } },
+          { tag: "text", text: " " },
+          { tag: "text", text: "Underline", style: { underline: true } },
+          { tag: "text", text: " " },
+          { tag: "text", text: "Strike", style: { strikethrough: true } },
+          { tag: "text", text: " " },
+          { tag: "text", text: "Code", style: { code: true, bold: true } },
+        ],
+      ],
+    });
+
+    const result = parsePostContent(content);
+
+    expect(result.textContent).toBe(
+      "Daily \\*Plan\\*\n\n**Bold** *Italic* <u>Underline</u> ~~Strike~~ `Code`",
+    );
+    expect(result.imageKeys).toEqual([]);
+    expect(result.mentionedOpenIds).toEqual([]);
+  });
+
+  it("renders links and mentions", () => {
+    const content = JSON.stringify({
+      title: "",
+      content: [
+        [
+          { tag: "a", text: "Docs [v2]", href: "https://example.com/guide(a)" },
+          { tag: "text", text: " " },
+          { tag: "at", user_name: "alice_bob" },
+          { tag: "text", text: " " },
+          { tag: "at", open_id: "ou_123" },
+          { tag: "text", text: " " },
+          { tag: "a", href: "https://example.com/no-text" },
+        ],
+      ],
+    });
+
+    const result = parsePostContent(content);
+
+    expect(result.textContent).toBe(
+      "[Docs \\[v2\\]](https://example.com/guide(a)) @alice\\_bob @ou\\_123 [https://example.com/no\\-text](https://example.com/no-text)",
+    );
+    expect(result.mentionedOpenIds).toEqual(["ou_123"]);
+  });
+
+  it("inserts image placeholders and collects image keys", () => {
+    const content = JSON.stringify({
+      title: "",
+      content: [
+        [
+          { tag: "text", text: "Before " },
+          { tag: "img", image_key: "img_1" },
+          { tag: "text", text: " after" },
+        ],
+        [{ tag: "img", image_key: "img_2" }],
+      ],
+    });
+
+    const result = parsePostContent(content);
+
+    expect(result.textContent).toBe("Before ![image] after\n![image]");
+    expect(result.imageKeys).toEqual(["img_1", "img_2"]);
+    expect(result.mentionedOpenIds).toEqual([]);
+  });
+
+  it("supports locale wrappers", () => {
+    const wrappedByPost = JSON.stringify({
+      post: {
+        zh_cn: {
+          title: "标题",
+          content: [[{ tag: "text", text: "内容A" }]],
+        },
+      },
+    });
+    const wrappedByLocale = JSON.stringify({
+      zh_cn: {
+        title: "标题",
+        content: [[{ tag: "text", text: "内容B" }]],
+      },
+    });
+
+    expect(parsePostContent(wrappedByPost)).toEqual({
+      textContent: "标题\n\n内容A",
+      imageKeys: [],
+      mediaKeys: [],
+      mentionedOpenIds: [],
+    });
+    expect(parsePostContent(wrappedByLocale)).toEqual({
+      textContent: "标题\n\n内容B",
+      imageKeys: [],
+      mediaKeys: [],
+      mentionedOpenIds: [],
+    });
+  });
+});

package/src/post.ts

@@ -0,0 +1,274 @@
+import { normalizeFeishuExternalKey } from "./external-keys.js";
+
+const FALLBACK_POST_TEXT = "[Rich text message]";
+const MARKDOWN_SPECIAL_CHARS = /([\\`*_{}\[\]()#+\-!|>~])/g;
+
+type PostParseResult = {
+  textContent: string;
+  imageKeys: string[];
+  mediaKeys: Array<{ fileKey: string; fileName?: string }>;
+  mentionedOpenIds: string[];
+};
+
+type PostPayload = {
+  title: string;
+  content: unknown[];
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function toStringOrEmpty(value: unknown): string {
+  return typeof value === "string" ? value : "";
+}
+
+function escapeMarkdownText(text: string): string {
+  return text.replace(MARKDOWN_SPECIAL_CHARS, "\\$1");
+}
+
+function toBoolean(value: unknown): boolean {
+  return value === true || value === 1 || value === "true";
+}
+
+function isStyleEnabled(style: Record<string, unknown> | undefined, key: string): boolean {
+  if (!style) {
+    return false;
+  }
+  return toBoolean(style[key]);
+}
+
+function wrapInlineCode(text: string): string {
+  const maxRun = Math.max(0, ...(text.match(/`+/g) ?? []).map((run) => run.length));
+  const fence = "`".repeat(maxRun + 1);
+  const needsPadding = text.startsWith("`") || text.endsWith("`");
+  const body = needsPadding ? ` ${text} ` : text;
+  return `${fence}${body}${fence}`;
+}
+
+function sanitizeFenceLanguage(language: string): string {
+  return language.trim().replace(/[^A-Za-z0-9_+#.-]/g, "");
+}
+
+function renderTextElement(element: Record<string, unknown>): string {
+  const text = toStringOrEmpty(element.text);
+  const style = isRecord(element.style) ? element.style : undefined;
+
+  if (isStyleEnabled(style, "code")) {
+    return wrapInlineCode(text);
+  }
+
+  let rendered = escapeMarkdownText(text);
+  if (!rendered) {
+    return "";
+  }
+
+  if (isStyleEnabled(style, "bold")) {
+    rendered = `**${rendered}**`;
+  }
+  if (isStyleEnabled(style, "italic")) {
+    rendered = `*${rendered}*`;
+  }
+  if (isStyleEnabled(style, "underline")) {
+    rendered = `<u>${rendered}</u>`;
+  }
+  if (
+    isStyleEnabled(style, "strikethrough") ||
+    isStyleEnabled(style, "line_through") ||
+    isStyleEnabled(style, "lineThrough")
+  ) {
+    rendered = `~~${rendered}~~`;
+  }
+  return rendered;
+}
+
+function renderLinkElement(element: Record<string, unknown>): string {
+  const href = toStringOrEmpty(element.href).trim();
+  const rawText = toStringOrEmpty(element.text);
+  const text = rawText || href;
+  if (!text) {
+    return "";
+  }
+  if (!href) {
+    return escapeMarkdownText(text);
+  }
+  return `[${escapeMarkdownText(text)}](${href})`;
+}
+
+function renderMentionElement(element: Record<string, unknown>): string {
+  const mention =
+    toStringOrEmpty(element.user_name) ||
+    toStringOrEmpty(element.user_id) ||
+    toStringOrEmpty(element.open_id);
+  if (!mention) {
+    return "";
+  }
+  return `@${escapeMarkdownText(mention)}`;
+}
+
+function renderEmotionElement(element: Record<string, unknown>): string {
+  const text =
+    toStringOrEmpty(element.emoji) ||
+    toStringOrEmpty(element.text) ||
+    toStringOrEmpty(element.emoji_type);
+  return escapeMarkdownText(text);
+}
+
+function renderCodeBlockElement(element: Record<string, unknown>): string {
+  const language = sanitizeFenceLanguage(
+    toStringOrEmpty(element.language) || toStringOrEmpty(element.lang),
+  );
+  const code = (toStringOrEmpty(element.text) || toStringOrEmpty(element.content)).replace(
+    /\r\n/g,
+    "\n",
+  );
+  const trailingNewline = code.endsWith("\n") ? "" : "\n";
+  return `\`\`\`${language}\n${code}${trailingNewline}\`\`\``;
+}
+
+function renderElement(
+  element: unknown,
+  imageKeys: string[],
+  mediaKeys: Array<{ fileKey: string; fileName?: string }>,
+  mentionedOpenIds: string[],
+): string {
+  if (!isRecord(element)) {
+    return escapeMarkdownText(toStringOrEmpty(element));
+  }
+
+  const tag = toStringOrEmpty(element.tag).toLowerCase();
+  switch (tag) {
+    case "text":
+      return renderTextElement(element);
+    case "a":
+      return renderLinkElement(element);
+    case "at":
+      {
+        const mentioned = toStringOrEmpty(element.open_id) || toStringOrEmpty(element.user_id);
+        const normalizedMention = normalizeFeishuExternalKey(mentioned);
+        if (normalizedMention) {
+          mentionedOpenIds.push(normalizedMention);
+        }
+      }
+      return renderMentionElement(element);
+    case "img": {
+      const imageKey = normalizeFeishuExternalKey(toStringOrEmpty(element.image_key));
+      if (imageKey) {
+        imageKeys.push(imageKey);
+      }
+      return "![image]";
+    }
+    case "media": {
+      const fileKey = normalizeFeishuExternalKey(toStringOrEmpty(element.file_key));
+      if (fileKey) {
+        const fileName = toStringOrEmpty(element.file_name) || undefined;
+        mediaKeys.push({ fileKey, fileName });
+      }
+      return "[media]";
+    }
+    case "emotion":
+      return renderEmotionElement(element);
+    case "br":
+      return "\n";
+    case "hr":
+      return "\n\n---\n\n";
+    case "code": {
+      const code = toStringOrEmpty(element.text) || toStringOrEmpty(element.content);
+      return code ? wrapInlineCode(code) : "";
+    }
+    case "code_block":
+    case "pre":
+      return renderCodeBlockElement(element);
+    default:
+      return escapeMarkdownText(toStringOrEmpty(element.text));
+  }
+}
+
+function toPostPayload(candidate: unknown): PostPayload | null {
+  if (!isRecord(candidate) || !Array.isArray(candidate.content)) {
+    return null;
+  }
+  return {
+    title: toStringOrEmpty(candidate.title),
+    content: candidate.content,
+  };
+}
+
+function resolveLocalePayload(candidate: unknown): PostPayload | null {
+  const direct = toPostPayload(candidate);
+  if (direct) {
+    return direct;
+  }
+  if (!isRecord(candidate)) {
+    return null;
+  }
+  for (const value of Object.values(candidate)) {
+    const localePayload = toPostPayload(value);
+    if (localePayload) {
+      return localePayload;
+    }
+  }
+  return null;
+}
+
+function resolvePostPayload(parsed: unknown): PostPayload | null {
+  const direct = toPostPayload(parsed);
+  if (direct) {
+    return direct;
+  }
+
+  if (!isRecord(parsed)) {
+    return null;
+  }
+
+  const wrappedPost = resolveLocalePayload(parsed.post);
+  if (wrappedPost) {
+    return wrappedPost;
+  }
+
+  return resolveLocalePayload(parsed);
+}
+
+export function parsePostContent(content: string): PostParseResult {
+  try {
+    const parsed = JSON.parse(content);
+    const payload = resolvePostPayload(parsed);
+    if (!payload) {
+      return {
+        textContent: FALLBACK_POST_TEXT,
+        imageKeys: [],
+        mediaKeys: [],
+        mentionedOpenIds: [],
+      };
+    }
+
+    const imageKeys: string[] = [];
+    const mediaKeys: Array<{ fileKey: string; fileName?: string }> = [];
+    const mentionedOpenIds: string[] = [];
+    const paragraphs: string[] = [];
+
+    for (const paragraph of payload.content) {
+      if (!Array.isArray(paragraph)) {
+        continue;
+      }
+      let renderedParagraph = "";
+      for (const element of paragraph) {
+        renderedParagraph += renderElement(element, imageKeys, mediaKeys, mentionedOpenIds);
+      }
+      paragraphs.push(renderedParagraph);
+    }
+
+    const title = escapeMarkdownText(payload.title.trim());
+    const body = paragraphs.join("\n").trim();
+    const textContent = [title, body].filter(Boolean).join("\n\n").trim();
+
+    return {
+      textContent: textContent || FALLBACK_POST_TEXT,
+      imageKeys,
+      mediaKeys,
+      mentionedOpenIds,
+    };
+  } catch {
+    return { textContent: FALLBACK_POST_TEXT, imageKeys: [], mediaKeys: [], mentionedOpenIds: [] };
+  }
+}