@lark-project/openclaw-lark-project 2026.3.131

package/dist/src/messaging/inbound/media-resolver.js

@@ -0,0 +1,70 @@
+import { LarkClient } from "../../core/lark-client";
+import { downloadMessageResourceFeishu } from "../outbound/media";
+async function downloadResources(params) {
+  const { cfg, messageId, resources, maxBytes, log, accountId } = params;
+  if (resources.length === 0) return [];
+  const out = [];
+  const core = LarkClient.runtime;
+  for (const res of resources) {
+    try {
+      const resourceType = res.type === "image" ? "image" : "file";
+      const result = await downloadMessageResourceFeishu({
+        cfg,
+        messageId,
+        fileKey: res.fileKey,
+        type: resourceType,
+        accountId
+      });
+      let contentType = result.contentType;
+      if (!contentType) {
+        contentType = await core.media.detectMime({ buffer: result.buffer });
+      }
+      const fileName = result.fileName || res.fileName;
+      const saved = await core.channel.media.saveMediaBuffer(result.buffer, contentType, "inbound", maxBytes, fileName);
+      const placeholder = inferPlaceholderFromType(res.type);
+      out.push({
+        path: saved.path,
+        contentType: saved.contentType,
+        placeholder,
+        fileKey: res.fileKey,
+        resourceType: res.type
+      });
+      log?.(`feishu: downloaded ${res.type} resource ${res.fileKey}, saved to ${saved.path}`);
+    } catch (err) {
+      log?.(`feishu: failed to download ${res.type} resource ${res.fileKey}: ${String(err)}`);
+    }
+  }
+  return out;
+}
+function inferPlaceholderFromType(type) {
+  switch (type) {
+    case "image":
+      return "<media:image>";
+    case "file":
+      return "<media:document>";
+    case "audio":
+      return "<media:audio>";
+    case "video":
+      return "<media:video>";
+    case "sticker":
+      return "<media:sticker>";
+  }
+}
+function buildFeishuMediaPayload(mediaList) {
+  const first = mediaList[0];
+  const mediaPaths = mediaList.map((m) => m.path);
+  const mediaTypes = mediaList.map((m) => m.contentType).filter(Boolean);
+  return {
+    MediaPath: first?.path,
+    MediaType: first?.contentType,
+    MediaUrl: first?.path,
+    MediaPaths: mediaPaths.length > 0 ? mediaPaths : void 0,
+    MediaUrls: mediaPaths.length > 0 ? mediaPaths : void 0,
+    MediaTypes: mediaTypes.length > 0 ? mediaTypes : void 0
+  };
+}
+export {
+  buildFeishuMediaPayload,
+  downloadResources
+};
+//# sourceMappingURL=media-resolver.js.map

package/dist/src/messaging/inbound/media-resolver.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/messaging/inbound/media-resolver.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates\n * SPDX-License-Identifier: MIT\n *\n * Media resolution and payload building for inbound Feishu messages.\n *\n * Downloads media files based on ResourceDescriptors extracted during\n * the content converter phase, and builds the payload object spread\n * into the agent envelope.\n */\n\nimport type { ClawdbotConfig } from 'openclaw/plugin-sdk';\nimport type { FeishuMediaInfo, ResourceDescriptor } from '../types';\nimport { LarkClient } from '../../core/lark-client';\nimport { downloadMessageResourceFeishu } from '../outbound/media';\n\n// ---------------------------------------------------------------------------\n// Resource-descriptor-based download\n// ---------------------------------------------------------------------------\n\n/**\n * Download media files based on pre-extracted ResourceDescriptors from\n * the converter phase.\n */\nexport async function downloadResources(params: {\n  cfg: ClawdbotConfig;\n  messageId: string;\n  resources: ResourceDescriptor[];\n  maxBytes: number;\n  log?: (msg: string) => void;\n  accountId?: string;\n}): Promise<FeishuMediaInfo[]> {\n  const { cfg, messageId, resources, maxBytes, log, accountId } = params;\n\n  if (resources.length === 0) return [];\n\n  const out: FeishuMediaInfo[] = [];\n  const core = LarkClient.runtime;\n\n  for (const res of resources) {\n    try {\n      const resourceType = res.type === 'image' ? 'image' : 'file';\n      const result = await downloadMessageResourceFeishu({\n        cfg,\n        messageId,\n        fileKey: res.fileKey,\n        type: resourceType,\n        accountId,\n      });\n\n      let contentType = result.contentType;\n      if (!contentType) {\n        contentType = await core.media.detectMime({ buffer: result.buffer });\n      }\n\n      const fileName = result.fileName || res.fileName;\n      const saved = await core.channel.media.saveMediaBuffer(result.buffer, contentType, 'inbound', maxBytes, fileName);\n\n      const placeholder = inferPlaceholderFromType(res.type);\n      out.push({\n        path: saved.path,\n        contentType: saved.contentType,\n        placeholder,\n        fileKey: res.fileKey,\n        resourceType: res.type,\n      });\n\n      log?.(`feishu: downloaded ${res.type} resource ${res.fileKey}, saved to ${saved.path}`);\n    } catch (err) {\n      log?.(`feishu: failed to download ${res.type} resource ${res.fileKey}: ${String(err)}`);\n    }\n  }\n\n  return out;\n}\n\nfunction inferPlaceholderFromType(type: ResourceDescriptor['type']): string {\n  switch (type) {\n    case 'image':\n      return '<media:image>';\n    case 'file':\n      return '<media:document>';\n    case 'audio':\n      return '<media:audio>';\n    case 'video':\n      return '<media:video>';\n    case 'sticker':\n      return '<media:sticker>';\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Media payload builder\n// ---------------------------------------------------------------------------\n\nexport function buildFeishuMediaPayload(mediaList: FeishuMediaInfo[]): {\n  MediaPath?: string;\n  MediaType?: string;\n  MediaUrl?: string;\n  MediaPaths?: string[];\n  MediaUrls?: string[];\n  MediaTypes?: string[];\n} {\n  const first = mediaList[0];\n  const mediaPaths = mediaList.map((m) => m.path);\n  const mediaTypes = mediaList.map((m) => m.contentType).filter(Boolean) as string[];\n\n  return {\n    MediaPath: first?.path,\n    MediaType: first?.contentType,\n    MediaUrl: first?.path,\n    MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,\n    MediaUrls: mediaPaths.length > 0 ? mediaPaths : undefined,\n    MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,\n  };\n}\n"],
+  "mappings": "AAaA,SAAS,kBAAkB;AAC3B,SAAS,qCAAqC;AAU9C,eAAsB,kBAAkB,QAOT;AAC7B,QAAM,EAAE,KAAK,WAAW,WAAW,UAAU,KAAK,UAAU,IAAI;AAEhE,MAAI,UAAU,WAAW,EAAG,QAAO,CAAC;AAEpC,QAAM,MAAyB,CAAC;AAChC,QAAM,OAAO,WAAW;AAExB,aAAW,OAAO,WAAW;AAC3B,QAAI;AACF,YAAM,eAAe,IAAI,SAAS,UAAU,UAAU;AACtD,YAAM,SAAS,MAAM,8BAA8B;AAAA,QACjD;AAAA,QACA;AAAA,QACA,SAAS,IAAI;AAAA,QACb,MAAM;AAAA,QACN;AAAA,MACF,CAAC;AAED,UAAI,cAAc,OAAO;AACzB,UAAI,CAAC,aAAa;AAChB,sBAAc,MAAM,KAAK,MAAM,WAAW,EAAE,QAAQ,OAAO,OAAO,CAAC;AAAA,MACrE;AAEA,YAAM,WAAW,OAAO,YAAY,IAAI;AACxC,YAAM,QAAQ,MAAM,KAAK,QAAQ,MAAM,gBAAgB,OAAO,QAAQ,aAAa,WAAW,UAAU,QAAQ;AAEhH,YAAM,cAAc,yBAAyB,IAAI,IAAI;AACrD,UAAI,KAAK;AAAA,QACP,MAAM,MAAM;AAAA,QACZ,aAAa,MAAM;AAAA,QACnB;AAAA,QACA,SAAS,IAAI;AAAA,QACb,cAAc,IAAI;AAAA,MACpB,CAAC;AAED,YAAM,sBAAsB,IAAI,IAAI,aAAa,IAAI,OAAO,cAAc,MAAM,IAAI,EAAE;AAAA,IACxF,SAAS,KAAK;AACZ,YAAM,8BAA8B,IAAI,IAAI,aAAa,IAAI,OAAO,KAAK,OAAO,GAAG,CAAC,EAAE;AAAA,IACxF;AAAA,EACF;AAEA,SAAO;AACT;AAEA,SAAS,yBAAyB,MAA0C;AAC1E,UAAQ,MAAM;AAAA,IACZ,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,EACX;AACF;AAMO,SAAS,wBAAwB,WAOtC;AACA,QAAM,QAAQ,UAAU,CAAC;AACzB,QAAM,aAAa,UAAU,IAAI,CAAC,MAAM,EAAE,IAAI;AAC9C,QAAM,aAAa,UAAU,IAAI,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,OAAO;AAErE,SAAO;AAAA,IACL,WAAW,OAAO;AAAA,IAClB,WAAW,OAAO;AAAA,IAClB,UAAU,OAAO;AAAA,IACjB,YAAY,WAAW,SAAS,IAAI,aAAa;AAAA,IACjD,WAAW,WAAW,SAAS,IAAI,aAAa;AAAA,IAChD,YAAY,WAAW,SAAS,IAAI,aAAa;AAAA,EACnD;AACF;",
+  "names": []
+}

package/dist/src/messaging/inbound/mention.js

@@ -0,0 +1,50 @@
+import { escapeRegExp } from "../converters/utils";
+function mentionedBot(ctx) {
+  return ctx.mentions.some((m) => m.isBot);
+}
+function nonBotMentions(ctx) {
+  return ctx.mentions.filter((m) => !m.isBot);
+}
+function extractMessageBody(text, allMentionKeys) {
+  let result = text;
+  for (const key of allMentionKeys) {
+    result = result.replace(new RegExp(escapeRegExp(key) + "\\s*", "g"), "");
+  }
+  return result.trim();
+}
+function formatMentionForText(target) {
+  return `<at user_id="${target.openId}">${target.name}</at>`;
+}
+function formatMentionAllForText() {
+  return `<at user_id="all">Everyone</at>`;
+}
+function formatMentionForCard(target) {
+  return `<at id=${target.openId}></at>`;
+}
+function formatMentionAllForCard() {
+  return `<at id=all></at>`;
+}
+function buildMentionedMessage(targets, message) {
+  if (targets.length === 0) return message;
+  const mentionTags = targets.map(formatMentionForText).join(" ");
+  return `${mentionTags}
+${message}`;
+}
+function buildMentionedCardContent(targets, message) {
+  if (targets.length === 0) return message;
+  const mentionTags = targets.map(formatMentionForCard).join(" ");
+  return `${mentionTags}
+${message}`;
+}
+export {
+  buildMentionedCardContent,
+  buildMentionedMessage,
+  extractMessageBody,
+  formatMentionAllForCard,
+  formatMentionAllForText,
+  formatMentionForCard,
+  formatMentionForText,
+  mentionedBot,
+  nonBotMentions
+};
+//# sourceMappingURL=mention.js.map

package/dist/src/messaging/inbound/mention.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/messaging/inbound/mention.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates\n * SPDX-License-Identifier: MIT\n *\n * @mention utilities for the Lark/Feishu channel plugin.\n *\n * All logic is based on `MentionInfo[]` from `MessageContext.mentions`.\n * Provides:\n * - Derive helpers: `mentionedBot()`, `nonBotMentions()`\n * - Format helpers for outbound text and card messages.\n */\n\nimport type { MentionInfo, MessageContext } from '../types';\nimport { escapeRegExp } from '../converters/utils';\n\nexport type { MentionInfo } from '../types';\n\n// ---------------------------------------------------------------------------\n// Derive helpers (work on MentionInfo[])\n// ---------------------------------------------------------------------------\n\n/** Whether the bot was @-mentioned. */\nexport function mentionedBot(ctx: MessageContext): boolean {\n  return ctx.mentions.some((m) => m.isBot);\n}\n\n/** All non-bot mentions. */\nexport function nonBotMentions(ctx: MessageContext): MentionInfo[] {\n  return ctx.mentions.filter((m) => !m.isBot);\n}\n\n// ---------------------------------------------------------------------------\n// extractMessageBody\n// ---------------------------------------------------------------------------\n\n/**\n * Remove all @mention placeholder keys from the message text.\n */\nexport function extractMessageBody(text: string, allMentionKeys: string[]): string {\n  let result = text;\n  for (const key of allMentionKeys) {\n    result = result.replace(new RegExp(escapeRegExp(key) + '\\\\s*', 'g'), '');\n  }\n  return result.trim();\n}\n\n// ---------------------------------------------------------------------------\n// Format helpers -- text messages\n// ---------------------------------------------------------------------------\n\n/**\n * Format a mention for a Feishu text / post message.\n * @returns e.g. `<at user_id=\"ou_xxx\">Alice</at>`\n */\nexport function formatMentionForText(target: MentionInfo): string {\n  return `<at user_id=\"${target.openId}\">${target.name}</at>`;\n}\n\n/** Format an @everyone mention for text / post. */\nexport function formatMentionAllForText(): string {\n  return `<at user_id=\"all\">Everyone</at>`;\n}\n\n// ---------------------------------------------------------------------------\n// Format helpers -- interactive card messages\n// ---------------------------------------------------------------------------\n\n/**\n * Format a mention for a Feishu Interactive Card.\n * @returns e.g. `<at id=ou_xxx></at>`\n */\nexport function formatMentionForCard(target: MentionInfo): string {\n  return `<at id=${target.openId}></at>`;\n}\n\n/** Format an @everyone mention for card. */\nexport function formatMentionAllForCard(): string {\n  return `<at id=all></at>`;\n}\n\n// ---------------------------------------------------------------------------\n// Build helpers (prepend mentions to message body)\n// ---------------------------------------------------------------------------\n\n/** Prepend @mention tags (text format) to a message body. */\nexport function buildMentionedMessage(targets: MentionInfo[], message: string): string {\n  if (targets.length === 0) return message;\n  const mentionTags = targets.map(formatMentionForText).join(' ');\n  return `${mentionTags}\\n${message}`;\n}\n\n/** Prepend @mention tags (card format) to card markdown content. */\nexport function buildMentionedCardContent(targets: MentionInfo[], message: string): string {\n  if (targets.length === 0) return message;\n  const mentionTags = targets.map(formatMentionForCard).join(' ');\n  return `${mentionTags}\\n${message}`;\n}\n"],
+  "mappings": "AAaA,SAAS,oBAAoB;AAStB,SAAS,aAAa,KAA8B;AACzD,SAAO,IAAI,SAAS,KAAK,CAAC,MAAM,EAAE,KAAK;AACzC;AAGO,SAAS,eAAe,KAAoC;AACjE,SAAO,IAAI,SAAS,OAAO,CAAC,MAAM,CAAC,EAAE,KAAK;AAC5C;AASO,SAAS,mBAAmB,MAAc,gBAAkC;AACjF,MAAI,SAAS;AACb,aAAW,OAAO,gBAAgB;AAChC,aAAS,OAAO,QAAQ,IAAI,OAAO,aAAa,GAAG,IAAI,QAAQ,GAAG,GAAG,EAAE;AAAA,EACzE;AACA,SAAO,OAAO,KAAK;AACrB;AAUO,SAAS,qBAAqB,QAA6B;AAChE,SAAO,gBAAgB,OAAO,MAAM,KAAK,OAAO,IAAI;AACtD;AAGO,SAAS,0BAAkC;AAChD,SAAO;AACT;AAUO,SAAS,qBAAqB,QAA6B;AAChE,SAAO,UAAU,OAAO,MAAM;AAChC;AAGO,SAAS,0BAAkC;AAChD,SAAO;AACT;AAOO,SAAS,sBAAsB,SAAwB,SAAyB;AACrF,MAAI,QAAQ,WAAW,EAAG,QAAO;AACjC,QAAM,cAAc,QAAQ,IAAI,oBAAoB,EAAE,KAAK,GAAG;AAC9D,SAAO,GAAG,WAAW;AAAA,EAAK,OAAO;AACnC;AAGO,SAAS,0BAA0B,SAAwB,SAAyB;AACzF,MAAI,QAAQ,WAAW,EAAG,QAAO;AACjC,QAAM,cAAc,QAAQ,IAAI,oBAAoB,EAAE,KAAK,GAAG;AAC9D,SAAO,GAAG,WAAW;AAAA,EAAK,OAAO;AACnC;",
+  "names": []
+}

package/dist/src/messaging/inbound/parse-io.js

@@ -0,0 +1,41 @@
+import { larkLogger } from "../../core/lark-logger";
+import { createBatchResolveNames } from "./user-name-cache";
+const log = larkLogger("inbound/parse-io");
+async function fetchCardContent(messageId, larkClient) {
+  try {
+    const response = await larkClient.sdk.request({
+      method: "GET",
+      url: `/open-apis/im/v1/messages/${messageId}`,
+      params: {
+        user_id_type: "open_id",
+        card_msg_content_type: "raw_card_content"
+      }
+    });
+    return response?.data?.items?.[0]?.body?.content ?? void 0;
+  } catch (err) {
+    log.warn(`fetchCardContent failed for ${messageId}: ${err instanceof Error ? err.message : String(err)}`);
+    return void 0;
+  }
+}
+function createFetchSubMessages(larkClient) {
+  return async (msgId) => {
+    const response = await larkClient.sdk.request({
+      method: "GET",
+      url: `/open-apis/im/v1/messages/${msgId}`,
+      params: { user_id_type: "open_id", card_msg_content_type: "raw_card_content" }
+    });
+    if (response?.code !== 0) {
+      throw new Error(`API error: code=${response?.code} msg=${response?.msg}`);
+    }
+    return response?.data?.items ?? [];
+  };
+}
+function createParseResolveNames(account) {
+  return createBatchResolveNames(account, (...args) => log.info(args.map(String).join(" ")));
+}
+export {
+  createFetchSubMessages,
+  createParseResolveNames,
+  fetchCardContent
+};
+//# sourceMappingURL=parse-io.js.map

package/dist/src/messaging/inbound/parse-io.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/messaging/inbound/parse-io.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates\n * SPDX-License-Identifier: MIT\n *\n * I/O adapters for inbound message parsing.\n *\n * Contains API-calling functions that are used during the parse phase\n * but separated from the pure parsing logic in parse.ts.\n */\n\nimport type { LarkClient as LarkClientType } from '../../core/lark-client';\nimport type { LarkAccount } from '../../core/types';\nimport { larkLogger } from '../../core/lark-logger';\nimport { createBatchResolveNames } from './user-name-cache';\n\nconst log = larkLogger('inbound/parse-io');\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\n/** Shape of a single message item returned by the im/v1/messages API. */\nexport interface ApiMessageItem {\n  message_id?: string;\n  msg_type?: string;\n  body?: { content?: string };\n  sender?: { id?: string; sender_type?: string };\n  [key: string]: unknown;\n}\n\n// ---------------------------------------------------------------------------\n// Card content fetcher\n// ---------------------------------------------------------------------------\n\n/**\n * \u5BF9 interactive \u6D88\u606F\uFF0C\u901A\u8FC7 TAT \u8C03\u7528 API \u83B7\u53D6\u5B8C\u6574 v2 \u5361\u7247\u5185\u5BB9\u3002\n * \u4E8B\u4EF6\u63A8\u9001\u7684 content \u53EF\u80FD\u4E0D\u5305\u542B json_card\uFF0CAPI \u8C03\u7528\u53EF\u8FD4\u56DE\u5B8C\u6574\u7684 raw_card_content\u3002\n * \u5931\u8D25\u65F6\u8FD4\u56DE undefined\uFF0C\u8C03\u7528\u65B9 fallback \u5230\u539F\u59CB content\u3002\n *\n * Note: `larkClient.sdk` \u7684\u7C7B\u578B\u5B9A\u4E49\u4E0D\u66B4\u9732 raw `request` \u65B9\u6CD5\uFF0C\n * \u56E0\u6B64\u8FD9\u91CC\u4F7F\u7528 `as any` \u65AD\u8A00\u8C03\u7528\u3002\n */\nexport async function fetchCardContent(messageId: string, larkClient: LarkClientType): Promise<string | undefined> {\n  try {\n    // SDK \u7C7B\u578B\u4E0D\u66B4\u9732 raw request \u65B9\u6CD5\uFF0C\u9700\u8981 as any\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const response = await (larkClient.sdk as any).request({\n      method: 'GET',\n      url: `/open-apis/im/v1/messages/${messageId}`,\n      params: {\n        user_id_type: 'open_id',\n        card_msg_content_type: 'raw_card_content',\n      },\n    });\n    return response?.data?.items?.[0]?.body?.content ?? undefined;\n  } catch (err) {\n    log.warn(`fetchCardContent failed for ${messageId}: ${err instanceof Error ? err.message : String(err)}`);\n    return undefined;\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Sub-message fetcher (for merge_forward)\n// ---------------------------------------------------------------------------\n\n/**\n * Create a `fetchSubMessages` callback for use in `ConvertContext`.\n *\n * The returned function calls the im/v1/messages API to fetch\n * sub-messages of a merge_forward message.\n *\n * Note: `larkClient.sdk` \u7684\u7C7B\u578B\u5B9A\u4E49\u4E0D\u66B4\u9732 raw `request` \u65B9\u6CD5\uFF0C\n * \u56E0\u6B64\u8FD9\u91CC\u4F7F\u7528 `as any` \u65AD\u8A00\u8C03\u7528\u3002\n */\nexport function createFetchSubMessages(larkClient: LarkClientType): (msgId: string) => Promise<ApiMessageItem[]> {\n  return async (msgId) => {\n    // SDK \u7C7B\u578B\u4E0D\u66B4\u9732 raw request \u65B9\u6CD5\uFF0C\u9700\u8981 as any\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const response = await (larkClient.sdk as any).request({\n      method: 'GET',\n      url: `/open-apis/im/v1/messages/${msgId}`,\n      params: { user_id_type: 'open_id', card_msg_content_type: 'raw_card_content' },\n    });\n    if (response?.code !== 0) {\n      throw new Error(`API error: code=${response?.code} msg=${response?.msg}`);\n    }\n    return response?.data?.items ?? [];\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Batch resolve names callback factory\n// ---------------------------------------------------------------------------\n\n/**\n * Create a `batchResolveNames` callback for use in `ConvertContext`.\n *\n * Wraps `createBatchResolveNames` from user-name-cache.ts, providing\n * the account and log function.\n */\nexport function createParseResolveNames(account: LarkAccount): (openIds: string[]) => Promise<void> {\n  return createBatchResolveNames(account, (...args: unknown[]) => log.info(args.map(String).join(' ')));\n}\n"],
+  "mappings": "AAYA,SAAS,kBAAkB;AAC3B,SAAS,+BAA+B;AAExC,MAAM,MAAM,WAAW,kBAAkB;AA2BzC,eAAsB,iBAAiB,WAAmB,YAAyD;AACjH,MAAI;AAGF,UAAM,WAAW,MAAO,WAAW,IAAY,QAAQ;AAAA,MACrD,QAAQ;AAAA,MACR,KAAK,6BAA6B,SAAS;AAAA,MAC3C,QAAQ;AAAA,QACN,cAAc;AAAA,QACd,uBAAuB;AAAA,MACzB;AAAA,IACF,CAAC;AACD,WAAO,UAAU,MAAM,QAAQ,CAAC,GAAG,MAAM,WAAW;AAAA,EACtD,SAAS,KAAK;AACZ,QAAI,KAAK,+BAA+B,SAAS,KAAK,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,CAAC,EAAE;AACxG,WAAO;AAAA,EACT;AACF;AAeO,SAAS,uBAAuB,YAA0E;AAC/G,SAAO,OAAO,UAAU;AAGtB,UAAM,WAAW,MAAO,WAAW,IAAY,QAAQ;AAAA,MACrD,QAAQ;AAAA,MACR,KAAK,6BAA6B,KAAK;AAAA,MACvC,QAAQ,EAAE,cAAc,WAAW,uBAAuB,mBAAmB;AAAA,IAC/E,CAAC;AACD,QAAI,UAAU,SAAS,GAAG;AACxB,YAAM,IAAI,MAAM,mBAAmB,UAAU,IAAI,QAAQ,UAAU,GAAG,EAAE;AAAA,IAC1E;AACA,WAAO,UAAU,MAAM,SAAS,CAAC;AAAA,EACnC;AACF;AAYO,SAAS,wBAAwB,SAA4D;AAClG,SAAO,wBAAwB,SAAS,IAAI,SAAoB,IAAI,KAAK,KAAK,IAAI,MAAM,EAAE,KAAK,GAAG,CAAC,CAAC;AACtG;",
+  "names": []
+}

package/dist/src/messaging/inbound/parse.js

@@ -0,0 +1,79 @@
+import { convertMessageContent } from "../converters/content-converter";
+import { getUserNameCache } from "./user-name-cache";
+import { getLarkAccount } from "../../core/accounts";
+import { LarkClient } from "../../core/lark-client";
+import { larkLogger } from "../../core/lark-logger";
+import { fetchCardContent, createFetchSubMessages, createParseResolveNames } from "./parse-io";
+const log = larkLogger("inbound/parse");
+async function parseMessageEvent(event, botOpenId, expandCtx) {
+  const mentionMap = /* @__PURE__ */ new Map();
+  const mentionList = [];
+  for (const m of event.message.mentions ?? []) {
+    const openId = m.id?.open_id ?? "";
+    if (!openId) continue;
+    const info = {
+      key: m.key,
+      openId,
+      name: m.name,
+      isBot: Boolean(botOpenId && openId === botOpenId)
+    };
+    mentionMap.set(m.key, info);
+    mentionList.push(info);
+  }
+  const mentionsByOpenId = /* @__PURE__ */ new Map();
+  for (const info of mentionList) {
+    mentionsByOpenId.set(info.openId, info);
+  }
+  const acctId = expandCtx?.accountId;
+  const larkClient = expandCtx ? LarkClient.fromCfg(expandCtx.cfg, acctId) : void 0;
+  let fetchSubMessages;
+  let batchResolveNames;
+  if (expandCtx) {
+    const account = getLarkAccount(expandCtx.cfg, acctId);
+    fetchSubMessages = createFetchSubMessages(larkClient);
+    batchResolveNames = createParseResolveNames(account);
+  }
+  let effectiveContent = event.message.content;
+  if (event.message.message_type === "interactive" && expandCtx) {
+    const fullContent = await fetchCardContent(event.message.message_id, larkClient);
+    if (fullContent) {
+      effectiveContent = fullContent;
+      log.info("replaced interactive content with full v2 card data");
+    }
+  }
+  const convertCtx = {
+    mentions: mentionMap,
+    mentionsByOpenId,
+    messageId: event.message.message_id,
+    botOpenId,
+    cfg: expandCtx?.cfg,
+    accountId: acctId,
+    resolveUserName: acctId ? (openId) => getUserNameCache(acctId).get(openId) : void 0,
+    fetchSubMessages,
+    batchResolveNames,
+    stripBotMentions: true
+  };
+  const { content, resources } = await convertMessageContent(effectiveContent, event.message.message_type, convertCtx);
+  const createTimeStr = event.message.create_time;
+  const createTime = createTimeStr ? parseInt(createTimeStr, 10) : void 0;
+  return {
+    chatId: event.message.chat_id,
+    messageId: event.message.message_id,
+    senderId: event.sender.sender_id.open_id || "",
+    chatType: event.message.chat_type,
+    rootId: event.message.root_id || void 0,
+    parentId: event.message.parent_id || void 0,
+    threadId: event.message.thread_id || void 0,
+    content,
+    contentType: event.message.message_type,
+    resources,
+    mentions: mentionList,
+    createTime: Number.isNaN(createTime) ? void 0 : createTime,
+    rawMessage: effectiveContent !== event.message.content ? { ...event.message, content: effectiveContent } : event.message,
+    rawSender: event.sender
+  };
+}
+export {
+  parseMessageEvent
+};
+//# sourceMappingURL=parse.js.map

package/dist/src/messaging/inbound/parse.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/messaging/inbound/parse.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates\n * SPDX-License-Identifier: MIT\n *\n * Event parsing for inbound Feishu messages.\n *\n * Converts a raw FeishuMessageEvent into a normalised MessageContext.\n * All mention information is captured in `mentions: MentionInfo[]`;\n * downstream logic derives `mentionedBot` and non-bot targets from it.\n *\n * When `expandCtx` is provided, `cfg` and `accountId` are passed into\n * the converter context so that async converters (e.g. merge_forward)\n * can make API calls during parsing.\n */\n\nimport type { ClawdbotConfig } from 'openclaw/plugin-sdk';\nimport type { FeishuMessageEvent, MessageContext, MentionInfo } from '../types';\nimport { convertMessageContent, type ConvertContext } from '../converters/content-converter';\nimport { getUserNameCache } from './user-name-cache';\nimport { getLarkAccount } from '../../core/accounts';\nimport { LarkClient } from '../../core/lark-client';\nimport { larkLogger } from '../../core/lark-logger';\nimport { fetchCardContent, createFetchSubMessages, createParseResolveNames } from './parse-io';\n\nconst log = larkLogger('inbound/parse');\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\n/**\n * Parse a raw Feishu message event into a normalised MessageContext.\n *\n * @param expandCtx  When provided, cfg/accountId are used to create\n *                   callbacks for async converters (e.g. merge_forward)\n *                   to fetch sub-messages and resolve sender names.\n */\nexport async function parseMessageEvent(\n  event: FeishuMessageEvent,\n  botOpenId?: string,\n  expandCtx?: {\n    /** account \u7EA7\u522B\u7684 ClawdbotConfig\uFF08channels.feishu \u5DF2\u66FF\u6362\u4E3A per-account \u5408\u5E76\u540E\u7684\u914D\u7F6E\uFF09 */\n    cfg: ClawdbotConfig;\n    accountId?: string;\n  },\n): Promise<MessageContext> {\n  // 1. Build MentionInfo list from event mentions\n  const mentionMap = new Map<string, MentionInfo>();\n  const mentionList: MentionInfo[] = [];\n\n  for (const m of event.message.mentions ?? []) {\n    const openId = m.id?.open_id ?? '';\n    if (!openId) continue;\n\n    const info: MentionInfo = {\n      key: m.key,\n      openId,\n      name: m.name,\n      isBot: Boolean(botOpenId && openId === botOpenId),\n    };\n    mentionMap.set(m.key, info);\n    mentionList.push(info);\n  }\n\n  // Build reverse map for O(1) openId lookup\n  const mentionsByOpenId = new Map<string, MentionInfo>();\n  for (const info of mentionList) {\n    mentionsByOpenId.set(info.openId, info);\n  }\n\n  // 2. Convert content via registered converter\n  const acctId = expandCtx?.accountId;\n\n  // Create larkClient once when expandCtx is available (used for merge_forward & card fetch)\n  const larkClient = expandCtx ? LarkClient.fromCfg(expandCtx.cfg, acctId) : undefined;\n\n  // Build merge_forward callbacks when expandCtx is provided\n  let fetchSubMessages: ConvertContext['fetchSubMessages'];\n  let batchResolveNames: ConvertContext['batchResolveNames'];\n  if (expandCtx) {\n    const account = getLarkAccount(expandCtx.cfg, acctId);\n    fetchSubMessages = createFetchSubMessages(larkClient!);\n    batchResolveNames = createParseResolveNames(account);\n  }\n\n  // For interactive messages, fetch full v2 card content via API\n  let effectiveContent = event.message.content;\n  if (event.message.message_type === 'interactive' && expandCtx) {\n    const fullContent = await fetchCardContent(event.message.message_id, larkClient!);\n    if (fullContent) {\n      effectiveContent = fullContent;\n      log.info('replaced interactive content with full v2 card data');\n    }\n  }\n\n  const convertCtx: ConvertContext = {\n    mentions: mentionMap,\n    mentionsByOpenId,\n    messageId: event.message.message_id,\n    botOpenId,\n    cfg: expandCtx?.cfg,\n    accountId: acctId,\n    resolveUserName: acctId ? (openId) => getUserNameCache(acctId).get(openId) : undefined,\n    fetchSubMessages,\n    batchResolveNames,\n    stripBotMentions: true,\n  };\n  const { content, resources } = await convertMessageContent(effectiveContent, event.message.message_type, convertCtx);\n\n  const createTimeStr = event.message.create_time;\n  const createTime = createTimeStr ? parseInt(createTimeStr, 10) : undefined;\n\n  return {\n    chatId: event.message.chat_id,\n    messageId: event.message.message_id,\n    senderId: event.sender.sender_id.open_id || '',\n    chatType: event.message.chat_type,\n    rootId: event.message.root_id || undefined,\n    parentId: event.message.parent_id || undefined,\n    threadId: event.message.thread_id || undefined,\n    content,\n    contentType: event.message.message_type,\n    resources,\n    mentions: mentionList,\n    createTime: Number.isNaN(createTime) ? undefined : createTime,\n    rawMessage:\n      effectiveContent !== event.message.content ? { ...event.message, content: effectiveContent } : event.message,\n    rawSender: event.sender,\n  };\n}\n"],
+  "mappings": "AAiBA,SAAS,6BAAkD;AAC3D,SAAS,wBAAwB;AACjC,SAAS,sBAAsB;AAC/B,SAAS,kBAAkB;AAC3B,SAAS,kBAAkB;AAC3B,SAAS,kBAAkB,wBAAwB,+BAA+B;AAElF,MAAM,MAAM,WAAW,eAAe;AAatC,eAAsB,kBACpB,OACA,WACA,WAKyB;AAEzB,QAAM,aAAa,oBAAI,IAAyB;AAChD,QAAM,cAA6B,CAAC;AAEpC,aAAW,KAAK,MAAM,QAAQ,YAAY,CAAC,GAAG;AAC5C,UAAM,SAAS,EAAE,IAAI,WAAW;AAChC,QAAI,CAAC,OAAQ;AAEb,UAAM,OAAoB;AAAA,MACxB,KAAK,EAAE;AAAA,MACP;AAAA,MACA,MAAM,EAAE;AAAA,MACR,OAAO,QAAQ,aAAa,WAAW,SAAS;AAAA,IAClD;AACA,eAAW,IAAI,EAAE,KAAK,IAAI;AAC1B,gBAAY,KAAK,IAAI;AAAA,EACvB;AAGA,QAAM,mBAAmB,oBAAI,IAAyB;AACtD,aAAW,QAAQ,aAAa;AAC9B,qBAAiB,IAAI,KAAK,QAAQ,IAAI;AAAA,EACxC;AAGA,QAAM,SAAS,WAAW;AAG1B,QAAM,aAAa,YAAY,WAAW,QAAQ,UAAU,KAAK,MAAM,IAAI;AAG3E,MAAI;AACJ,MAAI;AACJ,MAAI,WAAW;AACb,UAAM,UAAU,eAAe,UAAU,KAAK,MAAM;AACpD,uBAAmB,uBAAuB,UAAW;AACrD,wBAAoB,wBAAwB,OAAO;AAAA,EACrD;AAGA,MAAI,mBAAmB,MAAM,QAAQ;AACrC,MAAI,MAAM,QAAQ,iBAAiB,iBAAiB,WAAW;AAC7D,UAAM,cAAc,MAAM,iBAAiB,MAAM,QAAQ,YAAY,UAAW;AAChF,QAAI,aAAa;AACf,yBAAmB;AACnB,UAAI,KAAK,qDAAqD;AAAA,IAChE;AAAA,EACF;AAEA,QAAM,aAA6B;AAAA,IACjC,UAAU;AAAA,IACV;AAAA,IACA,WAAW,MAAM,QAAQ;AAAA,IACzB;AAAA,IACA,KAAK,WAAW;AAAA,IAChB,WAAW;AAAA,IACX,iBAAiB,SAAS,CAAC,WAAW,iBAAiB,MAAM,EAAE,IAAI,MAAM,IAAI;AAAA,IAC7E;AAAA,IACA;AAAA,IACA,kBAAkB;AAAA,EACpB;AACA,QAAM,EAAE,SAAS,UAAU,IAAI,MAAM,sBAAsB,kBAAkB,MAAM,QAAQ,cAAc,UAAU;AAEnH,QAAM,gBAAgB,MAAM,QAAQ;AACpC,QAAM,aAAa,gBAAgB,SAAS,eAAe,EAAE,IAAI;AAEjE,SAAO;AAAA,IACL,QAAQ,MAAM,QAAQ;AAAA,IACtB,WAAW,MAAM,QAAQ;AAAA,IACzB,UAAU,MAAM,OAAO,UAAU,WAAW;AAAA,IAC5C,UAAU,MAAM,QAAQ;AAAA,IACxB,QAAQ,MAAM,QAAQ,WAAW;AAAA,IACjC,UAAU,MAAM,QAAQ,aAAa;AAAA,IACrC,UAAU,MAAM,QAAQ,aAAa;AAAA,IACrC;AAAA,IACA,aAAa,MAAM,QAAQ;AAAA,IAC3B;AAAA,IACA,UAAU;AAAA,IACV,YAAY,OAAO,MAAM,UAAU,IAAI,SAAY;AAAA,IACnD,YACE,qBAAqB,MAAM,QAAQ,UAAU,EAAE,GAAG,MAAM,SAAS,SAAS,iBAAiB,IAAI,MAAM;AAAA,IACvG,WAAW,MAAM;AAAA,EACnB;AACF;",
+  "names": []
+}

package/dist/src/messaging/inbound/permission.js

@@ -0,0 +1,30 @@
+import { extractPermissionGrantUrl } from "../../core/permission-url";
+import { LARK_ERROR } from "../../core/auth-errors";
+function extractPermissionError(err) {
+  if (!err || typeof err !== "object") {
+    return null;
+  }
+  const axiosErr = err;
+  const data = axiosErr.response?.data;
+  if (!data || typeof data !== "object") {
+    return null;
+  }
+  const feishuErr = data;
+  if (feishuErr.code !== LARK_ERROR.APP_SCOPE_MISSING) {
+    return null;
+  }
+  const msg = feishuErr.msg ?? "";
+  const grantUrl = extractPermissionGrantUrl(msg);
+  if (!grantUrl) {
+    return null;
+  }
+  return { code: feishuErr.code, message: msg, grantUrl };
+}
+const PERMISSION_ERROR_COOLDOWN_MS = 5 * 60 * 1e3;
+const permissionErrorNotifiedAt = /* @__PURE__ */ new Map();
+export {
+  PERMISSION_ERROR_COOLDOWN_MS,
+  extractPermissionError,
+  permissionErrorNotifiedAt
+};
+//# sourceMappingURL=permission.js.map

package/dist/src/messaging/inbound/permission.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/messaging/inbound/permission.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates\n * SPDX-License-Identifier: MIT\n *\n * Permission error extraction and cooldown tracking for Feishu API calls.\n *\n * Extracted from bot.ts: PermissionError type, extractPermissionError,\n * PERMISSION_ERROR_COOLDOWN_MS, permissionErrorNotifiedAt.\n */\n\nimport { extractPermissionGrantUrl } from '../../core/permission-url';\nimport { LARK_ERROR } from '../../core/auth-errors';\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\nexport interface PermissionError {\n  code: number;\n  message: string;\n  grantUrl?: string;\n}\n\n// ---------------------------------------------------------------------------\n// Permission error extraction\n// ---------------------------------------------------------------------------\n\nexport function extractPermissionError(err: unknown): PermissionError | null {\n  if (!err || typeof err !== 'object') {\n    return null;\n  }\n\n  const axiosErr = err as { response?: { data?: unknown } };\n  const data = axiosErr.response?.data;\n  if (!data || typeof data !== 'object') {\n    return null;\n  }\n\n  const feishuErr = data as {\n    code?: number;\n    msg?: string;\n    error?: { permission_violations?: Array<{ uri?: string }> };\n  };\n\n  // Feishu permission error code\n  if (feishuErr.code !== LARK_ERROR.APP_SCOPE_MISSING) {\n    return null;\n  }\n\n  const msg = feishuErr.msg ?? '';\n  const grantUrl = extractPermissionGrantUrl(msg);\n\n  if (!grantUrl) {\n    return null;\n  }\n\n  return { code: feishuErr.code, message: msg, grantUrl };\n}\n\n// ---------------------------------------------------------------------------\n// Cooldown tracking\n// ---------------------------------------------------------------------------\n\nexport const PERMISSION_ERROR_COOLDOWN_MS = 5 * 60 * 1000; // 5 minutes\nexport const permissionErrorNotifiedAt = new Map<string, number>();\n"],
+  "mappings": "AAUA,SAAS,iCAAiC;AAC1C,SAAS,kBAAkB;AAgBpB,SAAS,uBAAuB,KAAsC;AAC3E,MAAI,CAAC,OAAO,OAAO,QAAQ,UAAU;AACnC,WAAO;AAAA,EACT;AAEA,QAAM,WAAW;AACjB,QAAM,OAAO,SAAS,UAAU;AAChC,MAAI,CAAC,QAAQ,OAAO,SAAS,UAAU;AACrC,WAAO;AAAA,EACT;AAEA,QAAM,YAAY;AAOlB,MAAI,UAAU,SAAS,WAAW,mBAAmB;AACnD,WAAO;AAAA,EACT;AAEA,QAAM,MAAM,UAAU,OAAO;AAC7B,QAAM,WAAW,0BAA0B,GAAG;AAE9C,MAAI,CAAC,UAAU;AACb,WAAO;AAAA,EACT;AAEA,SAAO,EAAE,MAAM,UAAU,MAAM,SAAS,KAAK,SAAS;AACxD;AAMO,MAAM,+BAA+B,IAAI,KAAK;AAC9C,MAAM,4BAA4B,oBAAI,IAAoB;",
+  "names": []
+}

package/dist/src/messaging/inbound/policy.js

@@ -0,0 +1,83 @@
+import { getLarkAccount } from "../../core/accounts";
+function resolveFeishuAllowlistMatch(params) {
+  const allowFrom = params.allowFrom.map((entry) => String(entry).trim().toLowerCase()).filter(Boolean);
+  if (allowFrom.length === 0) {
+    return { allowed: false };
+  }
+  if (allowFrom.includes("*")) {
+    return { allowed: true, matchKey: "*", matchSource: "wildcard" };
+  }
+  const senderId = params.senderId.toLowerCase();
+  if (allowFrom.includes(senderId)) {
+    return { allowed: true, matchKey: senderId, matchSource: "id" };
+  }
+  return { allowed: false };
+}
+function resolveFeishuGroupConfig(params) {
+  const groups = params.cfg?.groups ?? {};
+  const groupId = params.groupId?.trim();
+  if (!groupId) {
+    return void 0;
+  }
+  const direct = groups[groupId];
+  if (direct) {
+    return direct;
+  }
+  const lowered = groupId.toLowerCase();
+  const matchKey = Object.keys(groups).find((key) => key.toLowerCase() === lowered);
+  return matchKey ? groups[matchKey] : void 0;
+}
+function resolveFeishuGroupToolPolicy(params) {
+  const account = getLarkAccount(params.cfg, params.accountId ?? void 0);
+  const accountFeishuCfg = account.config;
+  if (!accountFeishuCfg) {
+    return void 0;
+  }
+  const groupConfig = resolveFeishuGroupConfig({
+    cfg: accountFeishuCfg,
+    groupId: params.groupId
+  });
+  return groupConfig?.tools;
+}
+function isFeishuGroupAllowed(params) {
+  const { groupPolicy } = params;
+  if (groupPolicy === "disabled") {
+    return false;
+  }
+  if (groupPolicy === "open") {
+    return true;
+  }
+  return resolveFeishuAllowlistMatch(params).allowed;
+}
+function splitLegacyGroupAllowFrom(rawGroupAllowFrom) {
+  const legacyChatIds = [];
+  const senderAllowFrom = [];
+  for (const entry of rawGroupAllowFrom) {
+    const str = String(entry);
+    if (str.startsWith("oc_")) {
+      legacyChatIds.push(str);
+    } else {
+      senderAllowFrom.push(str);
+    }
+  }
+  return { legacyChatIds, senderAllowFrom };
+}
+function resolveGroupSenderPolicyContext(params) {
+  const { groupConfig, defaultConfig, accountFeishuCfg, senderGroupAllowFrom } = params;
+  const senderPolicy = groupConfig?.groupPolicy ?? defaultConfig?.groupPolicy ?? accountFeishuCfg?.groupPolicy ?? "open";
+  const senderAllowFrom = [
+    ...senderGroupAllowFrom,
+    ...groupConfig?.allowFrom ?? [],
+    ...!groupConfig && defaultConfig?.allowFrom ? defaultConfig.allowFrom : []
+  ];
+  return { senderPolicy, senderAllowFrom };
+}
+export {
+  isFeishuGroupAllowed,
+  resolveFeishuAllowlistMatch,
+  resolveFeishuGroupConfig,
+  resolveFeishuGroupToolPolicy,
+  resolveGroupSenderPolicyContext,
+  splitLegacyGroupAllowFrom
+};
+//# sourceMappingURL=policy.js.map

package/dist/src/messaging/inbound/policy.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/messaging/inbound/policy.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates\n * SPDX-License-Identifier: MIT\n *\n * Access control policies for the Lark/Feishu channel plugin.\n *\n * Provides allowlist matching, group configuration lookup, tool policy\n * extraction, and group access checks.\n */\n\nimport type { ChannelGroupContext, GroupToolPolicyConfig } from 'openclaw/plugin-sdk';\nimport type { FeishuConfig, FeishuGroupConfig } from '../../core/types';\nimport { getLarkAccount } from '../../core/accounts';\n\n// ---------------------------------------------------------------------------\n// Allowlist matching\n// ---------------------------------------------------------------------------\n\nexport interface FeishuAllowlistMatch {\n  allowed: boolean;\n  matchKey?: string;\n  matchSource?: 'wildcard' | 'id' | 'name';\n}\n\n/**\n * Check whether a sender is permitted by a given allowlist.\n *\n * Entries are normalised to lowercase strings before comparison.\n * A single \"*\" entry acts as a wildcard that matches everyone.\n * When the allowlist is empty the result is `{ allowed: false }`.\n */\nexport function resolveFeishuAllowlistMatch(params: {\n  allowFrom: Array<string | number>;\n  senderId: string;\n  senderName?: string | null;\n}): FeishuAllowlistMatch {\n  const allowFrom = params.allowFrom.map((entry) => String(entry).trim().toLowerCase()).filter(Boolean);\n\n  if (allowFrom.length === 0) {\n    return { allowed: false };\n  }\n\n  // Wildcard: allow everyone\n  if (allowFrom.includes('*')) {\n    return { allowed: true, matchKey: '*', matchSource: 'wildcard' };\n  }\n\n  // Match by sender ID\n  const senderId = params.senderId.toLowerCase();\n  if (allowFrom.includes(senderId)) {\n    return { allowed: true, matchKey: senderId, matchSource: 'id' };\n  }\n\n/*  // Match by sender display name\n  const senderName = params.senderName?.toLowerCase();\n  if (senderName && allowFrom.includes(senderName)) {\n    return { allowed: true, matchKey: senderName, matchSource: 'name' };\n  }*/\n\n  return { allowed: false };\n}\n\n// ---------------------------------------------------------------------------\n// Group configuration lookup\n// ---------------------------------------------------------------------------\n\n/**\n * Look up the per-group configuration by group ID.\n *\n * Performs a case-insensitive lookup against the keys in `cfg.groups`.\n * Returns `undefined` when no matching group entry is found.\n */\nexport function resolveFeishuGroupConfig(params: {\n  cfg?: FeishuConfig;\n  groupId?: string | null;\n}): FeishuGroupConfig | undefined {\n  const groups = params.cfg?.groups ?? {};\n  const groupId = params.groupId?.trim();\n  if (!groupId) {\n    return undefined;\n  }\n\n  // Direct (exact-key) lookup first\n  const direct = groups[groupId];\n  if (direct) {\n    return direct;\n  }\n\n  // Case-insensitive fallback\n  const lowered = groupId.toLowerCase();\n  const matchKey = Object.keys(groups).find((key) => key.toLowerCase() === lowered);\n  return matchKey ? groups[matchKey] : undefined;\n}\n\n// ---------------------------------------------------------------------------\n// Group tool policy\n// ---------------------------------------------------------------------------\n\n/**\n * Extract the tool policy configuration from the group config that\n * corresponds to the given group context.\n *\n * \u2605 \u591A\u8D26\u53F7\u914D\u7F6E\u9694\u79BB\uFF1ASDK \u56DE\u8C03\u4F20\u5165\u7684 params.cfg \u662F\u9876\u5C42\u5168\u5C40\u914D\u7F6E\uFF0C\n *   cfg.channels.feishu \u4E0D\u5305\u542B per-account \u7684\u8986\u76D6\u503C\u3002\n *   \u8FD9\u91CC\u901A\u8FC7 getLarkAccount() \u83B7\u53D6\u5F53\u524D account \u5408\u5E76\u540E\u7684\u914D\u7F6E\uFF0C\n *   \u786E\u4FDD\u6BCF\u4E2A\u8D26\u53F7\u7684 groups / tool policy \u914D\u7F6E\u72EC\u7ACB\u751F\u6548\u3002\n */\nexport function resolveFeishuGroupToolPolicy(params: ChannelGroupContext): GroupToolPolicyConfig | undefined {\n  // \u4F7F\u7528 getLarkAccount \u83B7\u53D6 per-account \u5408\u5E76\u540E\u7684\u98DE\u4E66\u6E20\u9053\u914D\u7F6E\uFF0C\n  // \u800C\u975E\u76F4\u63A5\u8BFB\u53D6 cfg.channels.feishu\uFF08\u9876\u5C42\u5168\u5C40\u914D\u7F6E\uFF09\u3002\n  const account = getLarkAccount(params.cfg, params.accountId ?? undefined);\n  const accountFeishuCfg = account.config;\n  if (!accountFeishuCfg) {\n    return undefined;\n  }\n\n  const groupConfig = resolveFeishuGroupConfig({\n    cfg: accountFeishuCfg,\n    groupId: params.groupId,\n  });\n\n  return groupConfig?.tools;\n}\n\n// ---------------------------------------------------------------------------\n// Group access gate\n// ---------------------------------------------------------------------------\n\n/**\n * Determine whether an inbound group message should be processed.\n *\n * - `disabled` --> always rejected\n * - `open`     --> always allowed\n * - `allowlist` --> allowed only when the sender matches the allowlist\n */\nexport function isFeishuGroupAllowed(params: {\n  groupPolicy: 'open' | 'allowlist' | 'disabled';\n  allowFrom: Array<string | number>;\n  senderId: string;\n  senderName?: string | null;\n}): boolean {\n  const { groupPolicy } = params;\n  if (groupPolicy === 'disabled') {\n    return false;\n  }\n  if (groupPolicy === 'open') {\n    return true;\n  }\n  // allowlist\n  return resolveFeishuAllowlistMatch(params).allowed;\n}\n\n// ---------------------------------------------------------------------------\n// Legacy compat: groupAllowFrom splitting\n// ---------------------------------------------------------------------------\n\n/**\n * Split a raw `groupAllowFrom` array into legacy chat-ID entries\n * (`oc_xxx`) and sender-level entries.\n *\n * Older Feishu configs used `groupAllowFrom` with `oc_xxx` chat IDs to\n * control which groups are allowed.  The correct semantic (aligned with\n * Telegram) is sender IDs.  This function separates the two concerns so\n * both layers can work independently.\n */\nexport function splitLegacyGroupAllowFrom(rawGroupAllowFrom: Array<string | number>): {\n  legacyChatIds: string[];\n  senderAllowFrom: string[];\n} {\n  const legacyChatIds: string[] = [];\n  const senderAllowFrom: string[] = [];\n  for (const entry of rawGroupAllowFrom) {\n    const str = String(entry);\n    if (str.startsWith('oc_')) {\n      legacyChatIds.push(str);\n    } else {\n      senderAllowFrom.push(str);\n    }\n  }\n  return { legacyChatIds, senderAllowFrom };\n}\n\n// ---------------------------------------------------------------------------\n// Sender policy context resolution\n// ---------------------------------------------------------------------------\n\n/**\n * Resolve the effective sender-level group policy and the merged\n * `allowFrom` list for sender filtering within a group.\n *\n * The precedence chain for `senderPolicy` is:\n *   per-group `groupPolicy` > default (\"*\") group `groupPolicy` >\n *   global `groupPolicy` > \"open\" (default).\n *\n * The `senderAllowFrom` is the union of global (non-oc_) entries,\n * per-group entries, and default (\"*\") entries (when no per-group config).\n */\nexport function resolveGroupSenderPolicyContext(params: {\n  groupConfig?: FeishuGroupConfig;\n  defaultConfig?: FeishuGroupConfig;\n  accountFeishuCfg?: FeishuConfig;\n  senderGroupAllowFrom: Array<string | number>;\n}): {\n  senderPolicy: 'open' | 'allowlist' | 'disabled';\n  senderAllowFrom: Array<string | number>;\n} {\n  const { groupConfig, defaultConfig, accountFeishuCfg, senderGroupAllowFrom } = params;\n\n  const senderPolicy: 'open' | 'allowlist' | 'disabled' =\n    groupConfig?.groupPolicy ?? defaultConfig?.groupPolicy ?? accountFeishuCfg?.groupPolicy ?? 'open';\n\n  const senderAllowFrom: Array<string | number> = [\n    ...senderGroupAllowFrom,\n    ...(groupConfig?.allowFrom ?? []),\n    ...(!groupConfig && defaultConfig?.allowFrom ? defaultConfig.allowFrom : []),\n  ];\n\n  return { senderPolicy, senderAllowFrom };\n}\n"],
+  "mappings": "AAYA,SAAS,sBAAsB;AAmBxB,SAAS,4BAA4B,QAInB;AACvB,QAAM,YAAY,OAAO,UAAU,IAAI,CAAC,UAAU,OAAO,KAAK,EAAE,KAAK,EAAE,YAAY,CAAC,EAAE,OAAO,OAAO;AAEpG,MAAI,UAAU,WAAW,GAAG;AAC1B,WAAO,EAAE,SAAS,MAAM;AAAA,EAC1B;AAGA,MAAI,UAAU,SAAS,GAAG,GAAG;AAC3B,WAAO,EAAE,SAAS,MAAM,UAAU,KAAK,aAAa,WAAW;AAAA,EACjE;AAGA,QAAM,WAAW,OAAO,SAAS,YAAY;AAC7C,MAAI,UAAU,SAAS,QAAQ,GAAG;AAChC,WAAO,EAAE,SAAS,MAAM,UAAU,UAAU,aAAa,KAAK;AAAA,EAChE;AAQA,SAAO,EAAE,SAAS,MAAM;AAC1B;AAYO,SAAS,yBAAyB,QAGP;AAChC,QAAM,SAAS,OAAO,KAAK,UAAU,CAAC;AACtC,QAAM,UAAU,OAAO,SAAS,KAAK;AACrC,MAAI,CAAC,SAAS;AACZ,WAAO;AAAA,EACT;AAGA,QAAM,SAAS,OAAO,OAAO;AAC7B,MAAI,QAAQ;AACV,WAAO;AAAA,EACT;AAGA,QAAM,UAAU,QAAQ,YAAY;AACpC,QAAM,WAAW,OAAO,KAAK,MAAM,EAAE,KAAK,CAAC,QAAQ,IAAI,YAAY,MAAM,OAAO;AAChF,SAAO,WAAW,OAAO,QAAQ,IAAI;AACvC;AAeO,SAAS,6BAA6B,QAAgE;AAG3G,QAAM,UAAU,eAAe,OAAO,KAAK,OAAO,aAAa,MAAS;AACxE,QAAM,mBAAmB,QAAQ;AACjC,MAAI,CAAC,kBAAkB;AACrB,WAAO;AAAA,EACT;AAEA,QAAM,cAAc,yBAAyB;AAAA,IAC3C,KAAK;AAAA,IACL,SAAS,OAAO;AAAA,EAClB,CAAC;AAED,SAAO,aAAa;AACtB;AAaO,SAAS,qBAAqB,QAKzB;AACV,QAAM,EAAE,YAAY,IAAI;AACxB,MAAI,gBAAgB,YAAY;AAC9B,WAAO;AAAA,EACT;AACA,MAAI,gBAAgB,QAAQ;AAC1B,WAAO;AAAA,EACT;AAEA,SAAO,4BAA4B,MAAM,EAAE;AAC7C;AAeO,SAAS,0BAA0B,mBAGxC;AACA,QAAM,gBAA0B,CAAC;AACjC,QAAM,kBAA4B,CAAC;AACnC,aAAW,SAAS,mBAAmB;AACrC,UAAM,MAAM,OAAO,KAAK;AACxB,QAAI,IAAI,WAAW,KAAK,GAAG;AACzB,oBAAc,KAAK,GAAG;AAAA,IACxB,OAAO;AACL,sBAAgB,KAAK,GAAG;AAAA,IAC1B;AAAA,EACF;AACA,SAAO,EAAE,eAAe,gBAAgB;AAC1C;AAiBO,SAAS,gCAAgC,QAQ9C;AACA,QAAM,EAAE,aAAa,eAAe,kBAAkB,qBAAqB,IAAI;AAE/E,QAAM,eACJ,aAAa,eAAe,eAAe,eAAe,kBAAkB,eAAe;AAE7F,QAAM,kBAA0C;AAAA,IAC9C,GAAG;AAAA,IACH,GAAI,aAAa,aAAa,CAAC;AAAA,IAC/B,GAAI,CAAC,eAAe,eAAe,YAAY,cAAc,YAAY,CAAC;AAAA,EAC5E;AAEA,SAAO,EAAE,cAAc,gBAAgB;AACzC;",
+  "names": []
+}

package/dist/src/messaging/inbound/reaction-handler.js

@@ -0,0 +1,162 @@
+import * as crypto from "node:crypto";
+import { DEFAULT_GROUP_HISTORY_LIMIT } from "openclaw/plugin-sdk";
+import { getLarkAccount } from "../../core/accounts";
+import { getMessageFeishu } from "../shared/message-lookup";
+import { isThreadCapableGroup, getChatTypeFeishu } from "../../core/chat-info-cache";
+import { resolveUserName } from "./user-name-cache";
+import { dispatchToAgent } from "./dispatch";
+import { resolveFeishuGroupConfig } from "./policy";
+import { larkLogger } from "../../core/lark-logger";
+const logger = larkLogger("inbound/reaction-handler");
+const REACTION_VERIFY_TIMEOUT_MS = 3e3;
+async function resolveReactionContext(params) {
+  const { cfg, event, botOpenId, runtime, accountId } = params;
+  const log = runtime?.log ?? ((...args) => logger.info(args.map(String).join(" ")));
+  const account = getLarkAccount(cfg, accountId);
+  const reactionMode = account.config?.reactionNotifications ?? "own";
+  if (reactionMode === "off") {
+    return null;
+  }
+  const emojiType = event.reaction_type?.emoji_type;
+  const messageId = event.message_id;
+  const operatorOpenId = event.user_id?.open_id ?? "";
+  if (!emojiType || !messageId || !operatorOpenId) {
+    return null;
+  }
+  if (event.operator_type === "app" || operatorOpenId === botOpenId) {
+    log(`feishu[${accountId}]: ignoring app/self reaction on ${messageId}`);
+    return null;
+  }
+  if (emojiType === "Typing") {
+    return null;
+  }
+  if (reactionMode === "own" && !botOpenId) {
+    log(`feishu[${accountId}]: bot open_id unavailable, skipping reaction on ${messageId}`);
+    return null;
+  }
+  const msg = await Promise.race([
+    getMessageFeishu({ cfg, messageId, accountId }),
+    new Promise((resolve) => setTimeout(() => resolve(null), REACTION_VERIFY_TIMEOUT_MS))
+  ]).catch(() => null);
+  if (!msg) {
+    log(`feishu[${accountId}]: reacted message ${messageId} not found or timed out, skipping`);
+    return null;
+  }
+  const isBotMessage = msg.senderType === "app" && msg.senderId === account.appId;
+  if (reactionMode === "own" && !isBotMessage) {
+    log(
+      `feishu[${accountId}]: reaction on non-bot message ${messageId}, skipping (senderId=${msg.senderId}, senderType=${msg.senderType}, botOpenId=${botOpenId}, appId=${account.appId})`
+    );
+    return null;
+  }
+  const rawChatId = event.chat_id?.trim() || msg.chatId?.trim() || "";
+  const effectiveChatId = rawChatId || `p2p:${operatorOpenId}`;
+  let chatType = event.chat_type === "group" ? "group" : event.chat_type === "p2p" || event.chat_type === "private" ? "p2p" : msg.chatType === "group" || msg.chatType === "p2p" ? msg.chatType : "p2p";
+  if (rawChatId && chatType === "p2p" && !event.chat_type && !msg.chatType) {
+    try {
+      chatType = await getChatTypeFeishu({ cfg, chatId: rawChatId, accountId });
+    } catch {
+    }
+  }
+  let threadCapable = false;
+  const threadSessionEnabled = account.config?.threadSession === true;
+  if (rawChatId && chatType === "group") {
+    threadCapable = await isThreadCapableGroup({ cfg, chatId: rawChatId, accountId });
+    if (threadSessionEnabled && threadCapable) {
+      log(`feishu[${accountId}]: reaction on thread-capable group ${rawChatId}, skipping (threadSession enabled)`);
+      return null;
+    }
+  }
+  return {
+    chatId: effectiveChatId,
+    chatType,
+    threadId: msg.threadId,
+    threadCapable,
+    msg
+  };
+}
+async function handleFeishuReaction(params) {
+  const { cfg, event, runtime, chatHistories, accountId, preResolved } = params;
+  const log = runtime?.log ?? ((...args) => logger.info(args.map(String).join(" ")));
+  const error = runtime?.error ?? ((...args) => logger.error(args.map(String).join(" ")));
+  const emojiType = event.reaction_type?.emoji_type;
+  const messageId = event.message_id;
+  const operatorOpenId = event.user_id?.open_id ?? "";
+  const account = getLarkAccount(cfg, accountId);
+  const accountFeishuCfg = account.config;
+  const accountScopedCfg = {
+    ...cfg,
+    channels: { ...cfg.channels, feishu: accountFeishuCfg }
+  };
+  const excerpt = preResolved.msg.content.length > 200 ? preResolved.msg.content.slice(0, 200) + "\u2026" : preResolved.msg.content;
+  const syntheticText = excerpt ? `[reacted with ${emojiType} to message ${messageId}: "${excerpt}"]` : `[reacted with ${emojiType} to message ${messageId}]`;
+  const syntheticMessageId = `${messageId}:reaction:${emojiType}:${crypto.randomUUID()}`;
+  let ctx = {
+    chatId: preResolved.chatId,
+    messageId: syntheticMessageId,
+    senderId: operatorOpenId,
+    chatType: preResolved.chatType,
+    content: syntheticText,
+    contentType: "text",
+    resources: [],
+    mentions: [],
+    threadId: preResolved.threadId,
+    rawMessage: {
+      message_id: syntheticMessageId,
+      chat_id: preResolved.chatId,
+      chat_type: preResolved.chatType,
+      message_type: "text",
+      content: JSON.stringify({ text: syntheticText }),
+      create_time: event.action_time ?? String(Date.now()),
+      thread_id: preResolved.threadId
+    },
+    rawSender: {
+      sender_id: {
+        open_id: operatorOpenId,
+        user_id: event.user_id?.user_id,
+        union_id: event.user_id?.union_id
+      },
+      sender_type: "user"
+    }
+  };
+  const senderResult = await resolveUserName({ account, openId: operatorOpenId, log });
+  if (senderResult.name) {
+    ctx = { ...ctx, senderName: senderResult.name };
+  }
+  log(
+    `feishu[${accountId}]: reaction "${emojiType}" by ${operatorOpenId} on ${messageId} (chatId=${preResolved.chatId}, chatType=${preResolved.chatType}${preResolved.threadId ? `, thread=${preResolved.threadId}` : ""}), dispatching to AI`
+  );
+  logger.info(`reaction "${emojiType}" by ${operatorOpenId} on ${messageId} (chatType=${preResolved.chatType})`);
+  const isGroup = ctx.chatType === "group";
+  const groupConfig = isGroup ? resolveFeishuGroupConfig({ cfg: accountFeishuCfg, groupId: ctx.chatId }) : void 0;
+  const defaultGroupConfig = isGroup ? accountFeishuCfg?.groups?.["*"] : void 0;
+  const historyLimit = Math.max(
+    0,
+    accountFeishuCfg?.historyLimit ?? accountScopedCfg.messages?.groupChat?.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT
+  );
+  try {
+    await dispatchToAgent({
+      ctx,
+      permissionError: void 0,
+      mediaPayload: {},
+      quotedContent: void 0,
+      account,
+      accountScopedCfg,
+      runtime,
+      chatHistories,
+      historyLimit,
+      replyToMessageId: messageId,
+      commandAuthorized: false,
+      groupConfig,
+      defaultGroupConfig,
+      skipTyping: true
+    });
+  } catch (err) {
+    error(`feishu[${accountId}]: error dispatching reaction event: ${String(err)}`);
+  }
+}
+export {
+  handleFeishuReaction,
+  resolveReactionContext
+};
+//# sourceMappingURL=reaction-handler.js.map