@openclaw/feishu 2026.5.2 → 2026.5.3-beta.2

package/src/policy.ts

@@ -1,236 +0,0 @@
-import {
-  normalizeAccountId,
-  resolveMergedAccountConfig,
-} from "openclaw/plugin-sdk/account-resolution";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
-import { evaluateSenderGroupAccessForPolicy } from "openclaw/plugin-sdk/group-access";
-import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/text-runtime";
-import type { AllowlistMatch, ChannelGroupContext } from "../runtime-api.js";
-import { detectIdType } from "./targets.js";
-import type { FeishuConfig } from "./types.js";
-
-type FeishuAllowlistMatch = AllowlistMatch<"wildcard" | "id">;
-
-const FEISHU_PROVIDER_PREFIX_RE = /^(feishu|lark):/i;
-
-function stripRepeatedFeishuProviderPrefixes(raw: string): string {
-  let normalized = raw.trim();
-  while (FEISHU_PROVIDER_PREFIX_RE.test(normalized)) {
-    normalized = normalized.replace(FEISHU_PROVIDER_PREFIX_RE, "").trim();
-  }
-  return normalized;
-}
-
-function canonicalizeFeishuAllowlistKey(params: { kind: "chat" | "user"; value: string }): string {
-  const value = params.value.trim();
-  if (!value) {
-    return "";
-  }
-  // A typed wildcard (`chat:*`, `user:*`, `open_id:*`, `dm:*`, `group:*`,
-  // `channel:*`) collapses to the bare wildcard so it keeps matching across
-  // both kinds, preserving the prior `normalizeFeishuTarget`-based behavior.
-  if (value === "*") {
-    return "*";
-  }
-  return `${params.kind}:${value}`;
-}
-
-function normalizeFeishuAllowEntry(raw: string): string {
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    return "";
-  }
-  if (trimmed === "*") {
-    return "*";
-  }
-
-  const withoutProviderPrefix = stripRepeatedFeishuProviderPrefixes(trimmed);
-  if (withoutProviderPrefix === "*") {
-    return "*";
-  }
-  const lowered = normalizeOptionalLowercaseString(withoutProviderPrefix) ?? "";
-  if (!lowered) {
-    return "";
-  }
-  // Lowercase for prefix detection only; preserve the original ID casing in the
-  // canonicalized key. Sender candidates pass through this same path so allowlist
-  // entries and runtime IDs stay normalized symmetrically.
-  if (
-    lowered.startsWith("chat:") ||
-    lowered.startsWith("group:") ||
-    lowered.startsWith("channel:")
-  ) {
-    return canonicalizeFeishuAllowlistKey({
-      kind: "chat",
-      value: withoutProviderPrefix.slice(withoutProviderPrefix.indexOf(":") + 1),
-    });
-  }
-  if (lowered.startsWith("user:") || lowered.startsWith("dm:")) {
-    return canonicalizeFeishuAllowlistKey({
-      kind: "user",
-      value: withoutProviderPrefix.slice(withoutProviderPrefix.indexOf(":") + 1),
-    });
-  }
-  if (lowered.startsWith("open_id:")) {
-    return canonicalizeFeishuAllowlistKey({
-      kind: "user",
-      value: withoutProviderPrefix.slice(withoutProviderPrefix.indexOf(":") + 1),
-    });
-  }
-
-  const detectedType = detectIdType(withoutProviderPrefix);
-  if (detectedType === "chat_id") {
-    return canonicalizeFeishuAllowlistKey({
-      kind: "chat",
-      value: withoutProviderPrefix,
-    });
-  }
-  if (detectedType === "open_id" || detectedType === "user_id") {
-    return canonicalizeFeishuAllowlistKey({
-      kind: "user",
-      value: withoutProviderPrefix,
-    });
-  }
-
-  return "";
-}
-
-export function resolveFeishuAllowlistMatch(params: {
-  allowFrom: Array<string | number>;
-  senderId: string;
-  senderIds?: Array<string | null | undefined>;
-  senderName?: string | null;
-}): FeishuAllowlistMatch {
-  const allowFrom = params.allowFrom
-    .map((entry) => normalizeFeishuAllowEntry(String(entry)))
-    .filter(Boolean);
-  if (allowFrom.length === 0) {
-    return { allowed: false };
-  }
-  if (allowFrom.includes("*")) {
-    return { allowed: true, matchKey: "*", matchSource: "wildcard" };
-  }
-
-  // Feishu allowlists are ID-based; mutable display names must never grant access.
-  const senderCandidates = [params.senderId, ...(params.senderIds ?? [])]
-    .map((entry) => normalizeFeishuAllowEntry(entry ?? ""))
-    .filter(Boolean);
-
-  for (const senderId of senderCandidates) {
-    if (allowFrom.includes(senderId)) {
-      return { allowed: true, matchKey: senderId, matchSource: "id" };
-    }
-  }
-
-  return { allowed: false };
-}
-
-export function resolveFeishuGroupConfig(params: { cfg?: FeishuConfig; groupId?: string | null }) {
-  const groups = params.cfg?.groups ?? {};
-  const wildcard = groups["*"];
-  const groupId = params.groupId?.trim();
-  if (!groupId) {
-    return undefined;
-  }
-
-  const direct = groups[groupId];
-  if (direct) {
-    return direct;
-  }
-
-  const lowered = normalizeOptionalLowercaseString(groupId) ?? "";
-  const matchKey = Object.keys(groups).find(
-    (key) => normalizeOptionalLowercaseString(key) === lowered,
-  );
-  if (matchKey) {
-    return groups[matchKey];
-  }
-  return wildcard;
-}
-
-export function hasExplicitFeishuGroupConfig(params: {
-  cfg?: FeishuConfig;
-  groupId?: string | null;
-}): boolean {
-  const groups = params.cfg?.groups ?? {};
-  const groupId = params.groupId?.trim();
-  if (!groupId) {
-    return false;
-  }
-  if (Object.prototype.hasOwnProperty.call(groups, groupId) && groupId !== "*") {
-    return true;
-  }
-
-  const lowered = normalizeOptionalLowercaseString(groupId) ?? "";
-  return Object.keys(groups).some(
-    (key) => key !== "*" && normalizeOptionalLowercaseString(key) === lowered,
-  );
-}
-
-export function resolveFeishuGroupToolPolicy(params: ChannelGroupContext) {
-  const cfg = params.cfg.channels?.feishu;
-  if (!cfg) {
-    return undefined;
-  }
-
-  const groupConfig = resolveFeishuGroupConfig({
-    cfg,
-    groupId: params.groupId,
-  });
-
-  return groupConfig?.tools;
-}
-
-export function isFeishuGroupAllowed(params: {
-  groupPolicy: "open" | "allowlist" | "disabled" | "allowall";
-  allowFrom: Array<string | number>;
-  senderId: string;
-  senderIds?: Array<string | null | undefined>;
-  senderName?: string | null;
-}): boolean {
-  return evaluateSenderGroupAccessForPolicy({
-    groupPolicy: params.groupPolicy === "allowall" ? "open" : params.groupPolicy,
-    groupAllowFrom: params.allowFrom.map((entry) => String(entry)),
-    senderId: params.senderId,
-    isSenderAllowed: () => resolveFeishuAllowlistMatch(params).allowed,
-  }).allowed;
-}
-
-export function resolveFeishuReplyPolicy(params: {
-  isDirectMessage: boolean;
-  cfg: OpenClawConfig;
-  accountId?: string | null;
-  groupId?: string | null;
-  /**
-   * Effective group policy resolved for this chat. When "open", requireMention
-   * defaults to false so that non-text messages (e.g. images) that cannot carry
-   * @-mentions are still delivered to the agent.
-   */
-  groupPolicy?: "open" | "allowlist" | "disabled" | "allowall";
-}): { requireMention: boolean } {
-  if (params.isDirectMessage) {
-    return { requireMention: false };
-  }
-
-  const feishuCfg = params.cfg.channels?.feishu;
-  const resolvedCfg = resolveMergedAccountConfig<FeishuConfig>({
-    channelConfig: feishuCfg,
-    accounts: feishuCfg?.accounts as Record<string, Partial<FeishuConfig>> | undefined,
-    accountId: normalizeAccountId(params.accountId),
-    normalizeAccountId,
-    omitKeys: ["defaultAccount"],
-  });
-  const groupRequireMention = resolveFeishuGroupConfig({
-    cfg: resolvedCfg,
-    groupId: params.groupId,
-  })?.requireMention;
-
-  return {
-    requireMention:
-      typeof groupRequireMention === "boolean"
-        ? groupRequireMention
-        : typeof resolvedCfg.requireMention === "boolean"
-          ? resolvedCfg.requireMention
-          : params.groupPolicy !== "open",
-  };
-}

package/src/post.test.ts

@@ -1,105 +0,0 @@
-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

@@ -1,275 +0,0 @@
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
-import { isRecord } from "./comment-shared.js";
-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 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 = normalizeLowercaseStringOrEmpty(toStringOrEmpty(element.tag));
-  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 "md":
-    case "lark_md":
-      return toStringOrEmpty(element.text) || toStringOrEmpty(element.content);
-    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: [] };
-  }
-}