@m1heng-clawd/feishu 0.1.16 → 0.1.18

package/src/media-duration.ts

@@ -1,3 +1,5 @@
+import { parseBuffer } from "music-metadata";
+
 /**
  * Media duration parsers for Feishu file upload.
  *
@@ -9,11 +11,38 @@
  *   - MP4  (ISO base media) — MP4, MOV, QuickTime, M4A, M4V, 3GP share this format
  *   - WAV  (RIFF PCM)       — uncompressed audio
  *
- * Formats intentionally skipped (complex frame-level parsing, rare in practice):
- *   - MP3 (VBR makes byte-count estimation unreliable without scanning all frames)
- *   - Raw AAC / ADTS
+ * Raw AAC / ADTS is delegated to music-metadata on the audio path.
  */
 
+async function parseAudioDurationWithMusicMetadata(params: {
+  buffer: Buffer;
+  fileName?: string;
+  contentType?: string;
+}): Promise<number | undefined> {
+  const { buffer, fileName, contentType } = params;
+  try {
+    const metadata = await parseBuffer(
+      buffer,
+      {
+        mimeType: contentType,
+        path: fileName,
+        size: buffer.length,
+      },
+      {
+        duration: true,
+        skipCovers: true,
+      },
+    );
+    const seconds = metadata.format.duration;
+    if (typeof seconds !== "number" || !Number.isFinite(seconds) || seconds <= 0) {
+      return undefined;
+    }
+    return Math.round(seconds * 1000);
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * Parse duration from an OGG container (Opus or Vorbis).
  * Reads the granule position from the last OGG page and divides by sample rate.
@@ -174,17 +203,23 @@ export function parseWavDurationMs(buffer: Buffer): number | undefined {
  *
  * Routes to the appropriate parser based on Feishu's file type:
  *   - "mp4"  → MP4/MOV/QuickTime container parser
- *   - "opus" → OGG parser, then MP4 container (covers M4A), then WAV
+ *   - "opus" → music-metadata first, then OGG parser, then MP4 container, then WAV
  *
  * Returns duration in milliseconds, or undefined if not determinable.
  */
-export function parseFeishuMediaDurationMs(
+export async function parseFeishuMediaDurationMs(
   buffer: Buffer,
   fileType: "opus" | "mp4",
-): number | undefined {
+  options?: { fileName?: string; contentType?: string },
+): Promise<number | undefined> {
   if (fileType === "mp4") {
     return parseMp4DurationMs(buffer);
   }
-  // fileType === "opus": try each container format in likelihood order
-  return parseOggDurationMs(buffer) ?? parseMp4DurationMs(buffer) ?? parseWavDurationMs(buffer);
+  return (
+    await parseAudioDurationWithMusicMetadata({
+      buffer,
+      fileName: options?.fileName,
+      contentType: options?.contentType,
+    })
+  ) ?? parseOggDurationMs(buffer) ?? parseMp4DurationMs(buffer) ?? parseWavDurationMs(buffer);
 }

package/src/media.ts

@@ -192,6 +192,12 @@ export type SendMediaResult = {
   chatId: string;
 };
 
+function assertNonEmptyMediaBuffer(buffer: Buffer, name: string): void {
+  if (buffer.length === 0) {
+    throw new Error(`Feishu media upload failed: "${name}" is empty (0 bytes)`);
+  }
+}
+
 /**
  * Upload an image to Feishu and get an image_key for sending.
  * Supports: JPEG, PNG, WEBP, GIF, TIFF, BMP, ICO
@@ -210,15 +216,16 @@ export async function uploadImageFeishu(params: {
 
   const client = createFeishuClient(account);
 
-  // SDK expects a Readable stream, not a Buffer
-  // Use type assertion since SDK actually accepts any Readable at runtime
-  const imageStream =
-    typeof image === "string" ? fs.createReadStream(image) : Readable.from(image);
+  if (Buffer.isBuffer(image)) {
+    assertNonEmptyMediaBuffer(image, "image");
+  }
+
+  const imagePayload = typeof image === "string" ? fs.createReadStream(image) : image;
 
   const response = await client.im.image.create({
     data: {
       image_type: imageType,
-      image: imageStream as any,
+      image: imagePayload as any,
     },
   });
 
@@ -258,16 +265,17 @@ export async function uploadFileFeishu(params: {
 
   const client = createFeishuClient(account);
 
-  // SDK expects a Readable stream, not a Buffer
-  // Use type assertion since SDK actually accepts any Readable at runtime
-  const fileStream =
-    typeof file === "string" ? fs.createReadStream(file) : Readable.from(file);
+  if (Buffer.isBuffer(file)) {
+    assertNonEmptyMediaBuffer(file, fileName);
+  }
+
+  const filePayload = typeof file === "string" ? fs.createReadStream(file) : file;
 
   const response = await client.im.file.create({
     data: {
       file_type: fileType,
       file_name: fileName,
-      file: fileStream as any,
+      file: filePayload as any,
       ...(duration !== undefined && { duration }),
     },
   });
@@ -506,12 +514,21 @@ export async function sendMediaFeishu(params: {
       ...(mergedLocalRoots.length > 0 ? { localRoots: mergedLocalRoots } : {}),
     });
     buffer = loaded.buffer;
-    name = fileName ?? loaded.fileName ?? "file";
+    const loadedFileName = loaded.fileName ?? "file";
+    let decoded: string;
+    try {
+      decoded = decodeURIComponent(loadedFileName);
+    } catch {
+      decoded = loadedFileName;
+    }
+    name = fileName ?? decoded;
     contentType = loaded.contentType;
   } else {
     throw new Error("Either mediaUrl or mediaBuffer must be provided");
   }
 
+  assertNonEmptyMediaBuffer(buffer, name);
+
   // Determine if it's an image based on extension
   const ext = path.extname(name).toLowerCase();
   const isImage = [".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".ico", ".tiff"].includes(ext);
@@ -530,7 +547,7 @@ export async function sendMediaFeishu(params: {
     const msgType = fileType === "opus" ? "audio" : fileType === "mp4" ? "media" : "file";
     const duration =
       fileType === "opus" || fileType === "mp4"
-        ? parseFeishuMediaDurationMs(buffer, fileType)
+        ? await parseFeishuMediaDurationMs(buffer, fileType, { fileName: name, contentType })
         : undefined;
     const { fileKey } = await uploadFileFeishu({
       cfg,

package/src/message-tools/actions.ts

@@ -0,0 +1,154 @@
+import type * as Lark from "@larksuiteoapi/node-sdk";
+import { runFeishuApiCall, type FeishuApiResponse } from "../tools-common/feishu-api.js";
+import type { FeishuMessageParams } from "./schemas.js";
+
+interface MessageGetResponse extends FeishuApiResponse {
+  data?: {
+    items?: Array<{
+      message_id?: string;
+      root_id?: string;
+      parent_id?: string;
+      msg_type?: string;
+      create_time?: string;
+      update_time?: string;
+      deleted?: boolean;
+      chat_id?: string;
+      sender?: { id: string; id_type: string; sender_type: string };
+      body?: { content: string };
+      mentions?: Array<{ key: string; id: string; id_type: string; name: string }>;
+    }>;
+  };
+}
+
+interface MessageListResponse extends FeishuApiResponse {
+  data?: {
+    has_more?: boolean;
+    page_token?: string;
+    items?: Array<{
+      message_id?: string;
+      root_id?: string;
+      parent_id?: string;
+      msg_type?: string;
+      create_time?: string;
+      deleted?: boolean;
+      chat_id?: string;
+      sender?: { id: string; id_type: string; sender_type: string };
+      body?: { content: string };
+    }>;
+  };
+}
+
+export async function runMessageAction(
+  client: Lark.Client,
+  params: FeishuMessageParams,
+): Promise<unknown> {
+  switch (params.action) {
+    case "get":
+      return getMessage(client, params);
+    case "list":
+      return listMessages(client, params);
+  }
+}
+
+function parseMessageContent(msgType: string | undefined, rawContent: string | undefined): string {
+  if (!rawContent) return "";
+  try {
+    const parsed = JSON.parse(rawContent);
+    if (msgType === "text") return (parsed.text as string) ?? rawContent;
+    if (msgType === "post") {
+      const title = (parsed.title as string) ?? "";
+      const lines: string[] = [];
+      for (const paragraph of (parsed.content as Array<Array<{ tag: string; text?: string }>>) ?? []) {
+        lines.push(paragraph.map((el) => el.text ?? "").join(""));
+      }
+      return title ? `${title}\n${lines.join("\n")}` : lines.join("\n");
+    }
+    if (msgType === "image") return "[image]";
+    if (msgType === "file") return `[file: ${(parsed.file_name as string) ?? ""}]`;
+    if (msgType === "audio") return "[audio]";
+    if (msgType === "sticker") return "[sticker]";
+    if (msgType === "share_chat") return "[share_chat]";
+    if (msgType === "share_user") return "[share_user]";
+    return `[${msgType ?? "unknown"}]`;
+  } catch {
+    return rawContent;
+  }
+}
+
+async function getMessage(client: Lark.Client, params: FeishuMessageParams) {
+  if (!params.message_id) {
+    throw new Error("message_id is required for action=get");
+  }
+
+  const response = await runFeishuApiCall<MessageGetResponse>(
+    "Feishu get message",
+    () =>
+      client.im.message.get({
+        path: { message_id: params.message_id! },
+      }) as Promise<MessageGetResponse>,
+  );
+
+  const item = response.data?.items?.[0];
+  if (!item) {
+    return { ok: true, action: "get", message_id: params.message_id, found: false };
+  }
+
+  return {
+    ok: true,
+    action: "get",
+    found: true,
+    message_id: item.message_id ?? params.message_id,
+    msg_type: item.msg_type ?? "",
+    content: parseMessageContent(item.msg_type, item.body?.content),
+    sender_id: item.sender?.id ?? "",
+    sender_type: item.sender?.sender_type ?? "",
+    chat_id: item.chat_id ?? "",
+    create_time: item.create_time ?? "",
+    update_time: item.update_time ?? "",
+    mentions: item.mentions?.map((m) => ({ id: m.id, name: m.name })) ?? [],
+  };
+}
+
+async function listMessages(client: Lark.Client, params: FeishuMessageParams) {
+  if (!params.chat_id) {
+    throw new Error("chat_id is required for action=list");
+  }
+
+  const pageSize = Math.min(Math.max(params.page_size ?? 10, 1), 50);
+  const sortType = params.sort_type ?? "ByCreateTimeDesc";
+
+  const response = await runFeishuApiCall<MessageListResponse>(
+    "Feishu list messages",
+    () =>
+      client.im.message.list({
+        params: {
+          container_id_type: "chat",
+          container_id: params.chat_id!,
+          sort_type: sortType,
+          page_size: pageSize,
+          ...(params.start_time ? { start_time: params.start_time } : {}),
+          ...(params.end_time ? { end_time: params.end_time } : {}),
+        },
+      }) as Promise<MessageListResponse>,
+  );
+
+  const messages = (response.data?.items ?? [])
+    .filter((item) => !item.deleted)
+    .map((item) => ({
+      message_id: item.message_id ?? "",
+      msg_type: item.msg_type ?? "",
+      content_preview: parseMessageContent(item.msg_type, item.body?.content),
+      sender_id: item.sender?.id ?? "",
+      sender_type: item.sender?.sender_type ?? "",
+      create_time: item.create_time ?? "",
+      chat_id: item.chat_id ?? "",
+    }));
+
+  return {
+    ok: true,
+    action: "list",
+    chat_id: params.chat_id,
+    total: messages.length,
+    messages,
+  };
+}

package/src/message-tools/index.ts

@@ -0,0 +1,2 @@
+export { registerFeishuMessageTools } from "./register.js";
+export { FeishuMessageSchema, type FeishuMessageParams } from "./schemas.js";

package/src/message-tools/register.ts

@@ -0,0 +1,58 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { hasFeishuToolEnabledForAnyAccount, withFeishuToolClient } from "../tools-common/tool-exec.js";
+import { getCurrentFeishuToolContext } from "../tools-common/tool-context.js";
+import { errorResult, json } from "../tools-common/feishu-api.js";
+import { runMessageAction } from "./actions.js";
+import { FeishuMessageSchema, type FeishuMessageParams } from "./schemas.js";
+
+export function registerFeishuMessageTools(api: OpenClawPluginApi) {
+  if (!api.config) {
+    api.logger.debug?.("feishu_message: No config available, skipping");
+    return;
+  }
+
+  if (!hasFeishuToolEnabledForAnyAccount(api.config)) {
+    api.logger.debug?.("feishu_message: No Feishu accounts configured, skipping");
+    return;
+  }
+
+  if (!hasFeishuToolEnabledForAnyAccount(api.config, "message")) {
+    api.logger.debug?.("feishu_message: message tool disabled in config");
+    return;
+  }
+
+  api.registerTool(
+    {
+      name: "feishu_message",
+      label: "Feishu Message",
+      description:
+        "Read Feishu messages. Actions: get (get a single message by message_id), list (list recent messages in a chat). " +
+        "Use list to discover message_ids for use with other tools (e.g., feishu_reaction).",
+      parameters: FeishuMessageSchema,
+      async execute(_toolCallId, params) {
+        const p = params as FeishuMessageParams;
+        if (p.action === "list") {
+          const isValidChatId = p.chat_id?.startsWith("oc_");
+          if (!isValidChatId) {
+            const ctx = getCurrentFeishuToolContext();
+            if (ctx?.chatId) p.chat_id = ctx.chatId;
+          }
+        }
+
+        try {
+          return await withFeishuToolClient({
+            api,
+            toolName: "feishu_message",
+            requiredTool: "message",
+            run: async ({ client }) => json(await runMessageAction(client, p)),
+          });
+        } catch (err) {
+          return errorResult(err);
+        }
+      },
+    },
+    { name: "feishu_message" },
+  );
+
+  api.logger.debug?.("feishu_message: Registered feishu_message tool");
+}

package/src/message-tools/schemas.ts

@@ -0,0 +1,56 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+function stringEnum<T extends readonly string[]>(
+  values: T,
+  options: { description?: string; default?: T[number] } = {},
+) {
+  return Type.Unsafe<T[number]>({ type: "string", enum: [...values], ...options });
+}
+
+const ACTION_VALUES = ["get", "list"] as const;
+const SORT_VALUES = ["ByCreateTimeAsc", "ByCreateTimeDesc"] as const;
+
+export const FeishuMessageSchema = Type.Object({
+  action: stringEnum(ACTION_VALUES, {
+    description:
+      "Action to perform: get (get a single message by message_id), list (list recent messages in a chat by chat_id).",
+  }),
+  message_id: Type.Optional(
+    Type.String({
+      description: "Feishu message ID (e.g. om_xxx). Required for action=get.",
+    }),
+  ),
+  chat_id: Type.Optional(
+    Type.String({
+      description: "Chat ID (e.g. oc_xxx). Required for action=list. Omit to use the current conversation's chat.",
+    }),
+  ),
+  page_size: Type.Optional(
+    Type.Integer({
+      description: "Number of messages to fetch for action=list (default: 10, max: 50).",
+      minimum: 1,
+      maximum: 50,
+      default: 10,
+    }),
+  ),
+  sort_type: Type.Optional(
+    stringEnum(SORT_VALUES, {
+      description: "Sort order for action=list. Default: ByCreateTimeDesc (newest first).",
+      default: "ByCreateTimeDesc",
+    }),
+  ),
+  start_time: Type.Optional(
+    Type.String({
+      description:
+        "Start of time range for action=list, as Unix timestamp in seconds (e.g. \"1710000000\"). Omit for no lower bound.",
+    }),
+  ),
+  end_time: Type.Optional(
+    Type.String({
+      description:
+        "End of time range for action=list, as Unix timestamp in seconds (e.g. \"1710086400\"). Omit for no upper bound.",
+    }),
+  ),
+});
+
+export type FeishuMessageParams = Static<typeof FeishuMessageSchema>;

package/src/onboarding.ts

@@ -15,6 +15,7 @@ import {
 
 import {
   listFeishuAccountIds,
+  resolveConfiguredFeishuAccountKey,
   resolveDefaultFeishuAccountId,
   resolveFeishuAccount,
   resolveFeishuCredentials,
@@ -58,7 +59,8 @@ function upsertFeishuAccountConfig(
     };
   }
 
-  const existingAccount = feishuCfg?.accounts?.[normalizedAccountId];
+  const accountKey = resolveConfiguredFeishuAccountKey(cfg, normalizedAccountId) ?? normalizedAccountId;
+  const existingAccount = feishuCfg?.accounts?.[accountKey];
   return {
     ...cfg,
     channels: {
@@ -68,7 +70,7 @@ function upsertFeishuAccountConfig(
         enabled: true,
         accounts: {
           ...feishuCfg?.accounts,
-          [normalizedAccountId]: {
+          [accountKey]: {
             ...existingAccount,
             enabled: existingAccount?.enabled ?? true,
             ...patch,

package/src/reaction-tools/actions.ts

@@ -0,0 +1,127 @@
+import type * as Lark from "@larksuiteoapi/node-sdk";
+import { runFeishuApiCall, type FeishuApiResponse } from "../tools-common/feishu-api.js";
+import type { FeishuReactionParams } from "./schemas.js";
+
+interface ReactionCreateResponse extends FeishuApiResponse {
+  data?: { reaction_id?: string };
+}
+
+interface ReactionListResponse extends FeishuApiResponse {
+  data?: {
+    items?: Array<{
+      reaction_id?: string;
+      reaction_type?: { emoji_type?: string };
+      operator_type?: string;
+      operator_id?: { open_id?: string; user_id?: string; union_id?: string };
+    }>;
+    has_more?: boolean;
+    page_token?: string;
+  };
+}
+
+export async function runReactionAction(
+  client: Lark.Client,
+  params: FeishuReactionParams,
+): Promise<unknown> {
+  switch (params.action) {
+    case "add":
+      return addReaction(client, params);
+    case "remove":
+      return removeReaction(client, params);
+    case "list":
+      return listReactions(client, params);
+  }
+}
+
+async function addReaction(client: Lark.Client, params: FeishuReactionParams) {
+  if (!params.emoji_type) {
+    throw new Error("emoji_type is required for action=add");
+  }
+
+  const response = await runFeishuApiCall<ReactionCreateResponse>(
+    "Feishu add reaction",
+    () =>
+      client.im.messageReaction.create({
+        path: { message_id: params.message_id },
+        data: { reaction_type: { emoji_type: params.emoji_type! } },
+      }) as Promise<ReactionCreateResponse>,
+  );
+
+  return {
+    ok: true,
+    action: "add",
+    message_id: params.message_id,
+    emoji_type: params.emoji_type,
+    reaction_id: response.data?.reaction_id ?? null,
+  };
+}
+
+async function removeReaction(client: Lark.Client, params: FeishuReactionParams) {
+  if (!params.reaction_id) {
+    throw new Error("reaction_id is required for action=remove");
+  }
+
+  await runFeishuApiCall<FeishuApiResponse>(
+    "Feishu remove reaction",
+    () =>
+      client.im.messageReaction.delete({
+        path: {
+          message_id: params.message_id,
+          reaction_id: params.reaction_id!,
+        },
+      }) as Promise<FeishuApiResponse>,
+  );
+
+  return {
+    ok: true,
+    action: "remove",
+    message_id: params.message_id,
+    reaction_id: params.reaction_id,
+  };
+}
+
+async function listReactions(client: Lark.Client, params: FeishuReactionParams) {
+  const allItems: Array<{
+    reaction_id: string;
+    emoji_type: string;
+    operator_type: string;
+    operator_id: string;
+  }> = [];
+
+  let pageToken: string | undefined;
+  do {
+    const response = await runFeishuApiCall<ReactionListResponse>(
+      "Feishu list reactions",
+      () =>
+        client.im.messageReaction.list({
+          path: { message_id: params.message_id },
+          params: {
+            ...(params.emoji_type ? { reaction_type: params.emoji_type } : {}),
+            ...(pageToken ? { page_token: pageToken } : {}),
+            page_size: 50,
+          },
+        }) as Promise<ReactionListResponse>,
+    );
+
+    for (const item of response.data?.items ?? []) {
+      allItems.push({
+        reaction_id: item.reaction_id ?? "",
+        emoji_type: item.reaction_type?.emoji_type ?? "",
+        operator_type: item.operator_type ?? "user",
+        operator_id:
+          item.operator_id?.open_id ?? item.operator_id?.user_id ?? item.operator_id?.union_id ?? "",
+      });
+    }
+
+    pageToken = response.data?.has_more ? (response.data.page_token ?? undefined) : undefined;
+  } while (pageToken);
+
+  return {
+    ok: true,
+    action: "list",
+    message_id: params.message_id,
+    emoji_type_filter: params.emoji_type ?? null,
+    total: allItems.length,
+    reactions: allItems,
+  };
+}

package/src/reaction-tools/index.ts

@@ -0,0 +1,2 @@
+export { registerFeishuReactionTools } from "./register.js";
+export { FeishuReactionSchema, type FeishuReactionParams } from "./schemas.js";

package/src/reaction-tools/register.ts

@@ -0,0 +1,51 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { hasFeishuToolEnabledForAnyAccount, withFeishuToolClient } from "../tools-common/tool-exec.js";
+import { errorResult, json } from "../tools-common/feishu-api.js";
+import { runReactionAction } from "./actions.js";
+import { FeishuReactionSchema, type FeishuReactionParams } from "./schemas.js";
+
+export function registerFeishuReactionTools(api: OpenClawPluginApi) {
+  if (!api.config) {
+    api.logger.debug?.("feishu_reaction: No config available, skipping");
+    return;
+  }
+
+  if (!hasFeishuToolEnabledForAnyAccount(api.config)) {
+    api.logger.debug?.("feishu_reaction: No Feishu accounts configured, skipping");
+    return;
+  }
+
+  if (!hasFeishuToolEnabledForAnyAccount(api.config, "reaction")) {
+    api.logger.debug?.("feishu_reaction: reaction tool disabled in config");
+    return;
+  }
+
+  api.registerTool(
+    {
+      name: "feishu_reaction",
+      label: "Feishu Reaction",
+      description:
+        "Add, remove, or list emoji reactions on Feishu messages. " +
+        "Supported actions: add (add an emoji reaction), remove (remove a reaction by ID), list (list all reactions). " +
+        "Common emoji types: THUMBSUP, THUMBSDOWN, HEART, SMILE, GRINNING, FIRE, CLAP, OK, CHECK, CROSS, PARTY, PRAY. " +
+        "To react to a previous message, first use feishu_message list to find the target message_id.",
+      parameters: FeishuReactionSchema,
+      async execute(_toolCallId, params) {
+        const p = params as FeishuReactionParams;
+        try {
+          return await withFeishuToolClient({
+            api,
+            toolName: "feishu_reaction",
+            requiredTool: "reaction",
+            run: async ({ client }) => json(await runReactionAction(client, p)),
+          });
+        } catch (err) {
+          return errorResult(err);
+        }
+      },
+    },
+    { name: "feishu_reaction" },
+  );
+
+  api.logger.debug?.("feishu_reaction: Registered feishu_reaction tool");
+}

package/src/reaction-tools/schemas.ts

@@ -0,0 +1,34 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+function stringEnum<T extends readonly string[]>(
+  values: T,
+  options: { description?: string; default?: T[number] } = {},
+) {
+  return Type.Unsafe<T[number]>({ type: "string", enum: [...values], ...options });
+}
+
+const ACTION_VALUES = ["add", "remove", "list"] as const;
+
+export const FeishuReactionSchema = Type.Object({
+  action: stringEnum(ACTION_VALUES, {
+    description:
+      "Action to perform: add (add emoji reaction to a message), remove (remove a reaction by reaction_id), list (list all reactions on a message).",
+  }),
+  message_id: Type.String({
+    description: "Feishu message ID (e.g. om_xxx). Use feishu_message list to find message_ids from chat history.",
+  }),
+  emoji_type: Type.Optional(
+    Type.String({
+      description:
+        "Emoji type to add or filter by (e.g. THUMBSUP, HEART, SMILE, GRINNING, FIRE, CLAP, OK, CHECK, CROSS). " +
+        "Required for action=add. Optional filter for action=list.",
+    }),
+  ),
+  reaction_id: Type.Optional(
+    Type.String({
+      description: "Reaction ID to remove. Required for action=remove. Obtained from add or list results.",
+    }),
+  ),
+});
+
+export type FeishuReactionParams = Static<typeof FeishuReactionSchema>;