@m1heng-clawd/feishu 0.1.15 → 0.1.17

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,
     },
   });
 
@@ -237,23 +244,6 @@ export async function uploadImageFeishu(params: {
   return { imageKey };
 }
 
-/**
- * Encode a filename for safe use in Feishu multipart/form-data uploads.
- * Non-ASCII characters (Chinese, em-dash, full-width brackets, etc.) cause
- * the upload to silently fail when passed raw through the SDK's form-data
- * serialization. RFC 5987 percent-encoding keeps headers 7-bit clean while
- * Feishu's server decodes and preserves the original display name.
- */
-export function sanitizeFileNameForUpload(fileName: string): string {
-  const ASCII_ONLY = /^[\x20-\x7E]+$/;
-  if (ASCII_ONLY.test(fileName)) {
-    return fileName;
-  }
-  return encodeURIComponent(fileName)
-    .replace(/'/g, "%27")
-    .replace(/\(/g, "%28")
-    .replace(/\)/g, "%29");
-}
 
 /**
  * Upload a file to Feishu and get a file_key for sending.
@@ -275,18 +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 safeFileName = sanitizeFileNameForUpload(fileName);
+  const filePayload = typeof file === "string" ? fs.createReadStream(file) : file;
 
   const response = await client.im.file.create({
     data: {
       file_type: fileType,
-      file_name: safeFileName,
-      file: fileStream as any,
+      file_name: fileName,
+      file: filePayload as any,
       ...(duration !== undefined && { duration }),
     },
   });
@@ -496,9 +485,10 @@ export async function sendMediaFeishu(params: {
   mediaBuffer?: Buffer;
   fileName?: string;
   replyToMessageId?: string;
+  mediaLocalRoots?: readonly string[];
   accountId?: string;
 }): Promise<SendMediaResult> {
-  const { cfg, to, mediaUrl, mediaBuffer, fileName, replyToMessageId, accountId } = params;
+  const { cfg, to, mediaUrl, mediaBuffer, fileName, replyToMessageId, mediaLocalRoots, accountId } = params;
   const account = resolveFeishuAccount({ cfg, accountId });
   if (!account.configured) {
     throw new Error(`Feishu account "${account.accountId}" not configured`);
@@ -513,30 +503,16 @@ export async function sendMediaFeishu(params: {
     buffer = mediaBuffer;
     name = fileName ?? "file";
   } else if (mediaUrl) {
-    const mediaLocalRoots = (account.config?.mediaLocalRoots ?? [])
+    const configLocalRoots = (account.config?.mediaLocalRoots ?? [])
       .map((root) => root.trim())
       .filter((root) => root.length > 0);
-    const loaded = await (async () => {
-      try {
-        return await getFeishuRuntime().media.loadWebMedia(mediaUrl, {
-          maxBytes: mediaMaxBytes,
-          optimizeImages: false,
-        });
-      } catch (err) {
-        const shouldRetryWithCustomRoots =
-          mediaLocalRoots.length > 0 &&
-          err instanceof Error &&
-          err.message.includes("Local media path is not under an allowed directory");
-        if (!shouldRetryWithCustomRoots) {
-          throw err;
-        }
-        return await getFeishuRuntime().media.loadWebMedia(mediaUrl, {
-          maxBytes: mediaMaxBytes,
-          optimizeImages: false,
-          localRoots: mediaLocalRoots,
-        });
-      }
-    })();
+    // Merge context-provided roots (includes agent workspace) with config roots.
+    const mergedLocalRoots = [...(mediaLocalRoots ?? []), ...configLocalRoots];
+    const loaded = await getFeishuRuntime().media.loadWebMedia(mediaUrl, {
+      maxBytes: mediaMaxBytes,
+      optimizeImages: false,
+      ...(mergedLocalRoots.length > 0 ? { localRoots: mergedLocalRoots } : {}),
+    });
     buffer = loaded.buffer;
     name = fileName ?? loaded.fileName ?? "file";
     contentType = loaded.contentType;
@@ -544,6 +520,8 @@ export async function sendMediaFeishu(params: {
     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);
@@ -562,7 +540,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/outbound.ts

@@ -12,7 +12,7 @@ export const feishuOutbound: ChannelOutboundAdapter = {
     const result = await sendMessageFeishu({ cfg, to, text, accountId });
     return { channel: "feishu", ...result };
   },
-  sendMedia: async ({ cfg, to, text, mediaUrl, accountId }) => {
+  sendMedia: async ({ cfg, to, text, mediaUrl, mediaLocalRoots, accountId }) => {
     // Send text first if provided
     if (text?.trim()) {
       await sendMessageFeishu({ cfg, to, text, accountId });
@@ -21,7 +21,7 @@ export const feishuOutbound: ChannelOutboundAdapter = {
     // Upload and send media if URL provided
     if (mediaUrl) {
       try {
-        const result = await sendMediaFeishu({ cfg, to, mediaUrl, accountId });
+        const result = await sendMediaFeishu({ cfg, to, mediaUrl, mediaLocalRoots, accountId });
         return { channel: "feishu", ...result };
       } catch (err) {
         // Log the error for debugging

package/src/perm-tools/actions.ts

@@ -33,6 +33,13 @@ type MemberType =
   | "wikispaceid";
 type PermType = "view" | "edit" | "full_access";
 
+function requireString(value: unknown, field: string): string {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${field} is required`);
+  }
+  return value;
+}
+
 async function listMembers(client: PermClient, token: string, type: string) {
   const res = await runPermApiCall("drive.permissionMember.list", () =>
     client.drive.permissionMember.list({
@@ -100,11 +107,28 @@ async function removeMember(
 export async function runPermAction(client: PermClient, params: FeishuPermParams) {
   switch (params.action) {
     case "list":
-      return listMembers(client, params.token, params.type);
+      return listMembers(
+        client,
+        requireString(params.token, "token"),
+        requireString(params.type, "type"),
+      );
     case "add":
-      return addMember(client, params.token, params.type, params.member_type, params.member_id, params.perm);
+      return addMember(
+        client,
+        requireString(params.token, "token"),
+        requireString(params.type, "type"),
+        requireString(params.member_type, "member_type"),
+        requireString(params.member_id, "member_id"),
+        requireString(params.perm, "perm"),
+      );
     case "remove":
-      return removeMember(client, params.token, params.type, params.member_type, params.member_id);
+      return removeMember(
+        client,
+        requireString(params.token, "token"),
+        requireString(params.type, "type"),
+        requireString(params.member_type, "member_type"),
+        requireString(params.member_id, "member_id"),
+      );
     default:
       return { error: `Unknown action: ${(params as any).action}` };
   }

package/src/perm-tools/schemas.ts

@@ -1,52 +1,46 @@
 import { Type, type Static } from "@sinclair/typebox";
 
-const TokenType = Type.Union([
-  Type.Literal("doc"),
-  Type.Literal("docx"),
-  Type.Literal("sheet"),
-  Type.Literal("bitable"),
-  Type.Literal("folder"),
-  Type.Literal("file"),
-  Type.Literal("wiki"),
-  Type.Literal("mindnote"),
-]);
+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 MemberType = Type.Union([
-  Type.Literal("email"),
-  Type.Literal("openid"),
-  Type.Literal("userid"),
-  Type.Literal("unionid"),
-  Type.Literal("openchat"),
-  Type.Literal("opendepartmentid"),
-]);
+const TOKEN_TYPE_VALUES = [
+  "doc",
+  "docx",
+  "sheet",
+  "bitable",
+  "folder",
+  "file",
+  "wiki",
+  "mindnote",
+] as const;
 
-const Permission = Type.Union([
-  Type.Literal("view"),
-  Type.Literal("edit"),
-  Type.Literal("full_access"),
-]);
+const MEMBER_TYPE_VALUES = [
+  "email",
+  "openid",
+  "userid",
+  "unionid",
+  "openchat",
+  "opendepartmentid",
+] as const;
 
-export const FeishuPermSchema = Type.Union([
-  Type.Object({
-    action: Type.Literal("list"),
-    token: Type.String({ description: "File token" }),
-    type: TokenType,
-  }),
-  Type.Object({
-    action: Type.Literal("add"),
-    token: Type.String({ description: "File token" }),
-    type: TokenType,
-    member_type: MemberType,
-    member_id: Type.String({ description: "Member ID (email, open_id, user_id, etc.)" }),
-    perm: Permission,
-  }),
-  Type.Object({
-    action: Type.Literal("remove"),
-    token: Type.String({ description: "File token" }),
-    type: TokenType,
-    member_type: MemberType,
-    member_id: Type.String({ description: "Member ID to remove" }),
-  }),
-]);
+const PERMISSION_VALUES = ["view", "edit", "full_access"] as const;
+const PERM_ACTION_VALUES = ["list", "add", "remove"] as const;
+
+export const FeishuPermSchema = Type.Object({
+  action: stringEnum(PERM_ACTION_VALUES, { description: "Permission action" }),
+  token: Type.Optional(Type.String({ description: "File token" })),
+  type: Type.Optional(stringEnum(TOKEN_TYPE_VALUES, { description: "File token type" })),
+  member_type: Type.Optional(
+    stringEnum(MEMBER_TYPE_VALUES, {
+      description: "Member ID type (email/openid/userid/unionid/openchat/opendepartmentid)",
+    }),
+  ),
+  member_id: Type.Optional(Type.String({ description: "Member ID" })),
+  perm: Type.Optional(stringEnum(PERMISSION_VALUES, { description: "Permission level" })),
+});
 
 export type FeishuPermParams = Static<typeof FeishuPermSchema>;