@m1heng-clawd/feishu 0.1.15 → 0.1.16

package/src/drive-tools/actions.ts

@@ -5,6 +5,13 @@ import type { FeishuDriveParams } from "./schemas.js";
 type DriveMoveType = "doc" | "docx" | "sheet" | "bitable" | "folder" | "file" | "mindnote" | "slides";
 type DriveDeleteType = DriveMoveType | "shortcut";
 
+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 getFileType(client: DriveClient, fileToken: string): Promise<string> {
   let pageToken: string | undefined;
   
@@ -196,18 +203,23 @@ export async function runDriveAction(
     case "list":
       return listFolder(client, params.folder_token);
     case "info":
-      return getFileInfo(client, params.file_token);
+      return getFileInfo(client, requireString(params.file_token, "file_token"));
     case "create_folder":
-      return createFolder(client, params.name, params.folder_token);
+      return createFolder(client, requireString(params.name, "name"), params.folder_token);
     case "move":
-      return moveFile(client, params.file_token, params.type, params.folder_token);
+      return moveFile(
+        client,
+        requireString(params.file_token, "file_token"),
+        requireString(params.type, "type"),
+        requireString(params.folder_token, "folder_token"),
+      );
     case "delete":
-      return deleteFile(client, params.file_token, params.type);
+      return deleteFile(client, requireString(params.file_token, "file_token"), params.type);
     case "import_document":
       return importDocument(
         client,
-        params.title,
-        params.content,
+        requireString(params.title, "title"),
+        requireString(params.content, "content"),
         mediaMaxBytes,
         params.folder_token,
         params.doc_type || "docx",

package/src/drive-tools/schemas.ts

@@ -1,67 +1,54 @@
 import { Type, type Static } from "@sinclair/typebox";
 
-const FileType = Type.Union([
-  Type.Literal("doc"),
-  Type.Literal("docx"),
-  Type.Literal("sheet"),
-  Type.Literal("bitable"),
-  Type.Literal("folder"),
-  Type.Literal("file"),
-  Type.Literal("mindnote"),
-  Type.Literal("shortcut"),
-]);
+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 DocType = Type.Union([
-  Type.Literal("docx", { description: "New generation document (default)" }),
-  Type.Literal("doc", { description: "Legacy document" }),
-]);
+const FILE_TYPE_VALUES = [
+  "doc",
+  "docx",
+  "sheet",
+  "bitable",
+  "folder",
+  "file",
+  "mindnote",
+  "shortcut",
+] as const;
 
-export const FeishuDriveSchema = Type.Union([
-  Type.Object({
-    action: Type.Literal("list"),
-    folder_token: Type.Optional(
-      Type.String({ description: "Folder token (optional, omit for root directory)" }),
-    ),
-  }),
-  Type.Object({
-    action: Type.Literal("info"),
-    file_token: Type.String({ description: "File or folder token" }),
-    type: Type.Optional(FileType),
-  }),
-  Type.Object({
-    action: Type.Literal("create_folder"),
-    name: Type.String({ description: "Folder name" }),
-    folder_token: Type.Optional(
-      Type.String({ description: "Parent folder token (optional, omit for root)" }),
-    ),
-  }),
-  Type.Object({
-    action: Type.Literal("move"),
-    file_token: Type.String({ description: "File token to move" }),
-    type: FileType,
-    folder_token: Type.String({ description: "Target folder token" }),
-  }),
-  Type.Object({
-    action: Type.Literal("delete"),
-    file_token: Type.String({ description: "File token to delete" }),
-    type: Type.Optional(FileType),
-  }),
-  Type.Object({
-    action: Type.Literal("import_document"),
-    title: Type.String({
-      description: "Document title",
-    }),
-    content: Type.String({
+const DOC_TYPE_VALUES = ["docx", "doc"] as const;
+
+const DRIVE_ACTION_VALUES = [
+  "list",
+  "info",
+  "create_folder",
+  "move",
+  "delete",
+  "import_document",
+] as const;
+
+export const FeishuDriveSchema = Type.Object({
+  action: stringEnum(DRIVE_ACTION_VALUES, { description: "Drive action" }),
+  folder_token: Type.Optional(
+    Type.String({ description: "Folder token (optional, omit for root directory)" }),
+  ),
+  file_token: Type.Optional(Type.String({ description: "File or folder token" })),
+  type: Type.Optional(stringEnum(FILE_TYPE_VALUES, { description: "File type" })),
+  name: Type.Optional(Type.String({ description: "Folder name (for create_folder)" })),
+  title: Type.Optional(Type.String({ description: "Document title (for import_document)" })),
+  content: Type.Optional(
+    Type.String({
       description:
         "Markdown content to import. Supports full Markdown syntax including tables, lists, code blocks, etc.",
     }),
-    folder_token: Type.Optional(
-      Type.String({
-        description: "Target folder token (optional, defaults to root). Use 'list' to find folder tokens.",
-      }),
-    ),
-    doc_type: Type.Optional(DocType),
-  }),
-]);
+  ),
+  doc_type: Type.Optional(
+    stringEnum(DOC_TYPE_VALUES, {
+      description: "Document type for import_document (docx default, doc legacy)",
+    }),
+  ),
+});
 
 export type FeishuDriveParams = Static<typeof FeishuDriveSchema>;

package/src/media.ts

@@ -237,23 +237,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.
@@ -280,12 +263,10 @@ export async function uploadFileFeishu(params: {
   const fileStream =
     typeof file === "string" ? fs.createReadStream(file) : Readable.from(file);
 
-  const safeFileName = sanitizeFileNameForUpload(fileName);
-
   const response = await client.im.file.create({
     data: {
       file_type: fileType,
-      file_name: safeFileName,
+      file_name: fileName,
       file: fileStream as any,
       ...(duration !== undefined && { duration }),
     },
@@ -496,9 +477,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 +495,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;

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>;

package/src/task-tools/actions.ts

@@ -3,26 +3,33 @@ import os from "node:os";
 import path from "node:path";
 import type { TaskClient } from "./common.js";
 import {
+  TASK_COMMENT_UPDATE_FIELD_VALUES,
   TASKLIST_UPDATE_FIELD_VALUES,
   TASK_UPDATE_FIELD_VALUES,
   type AddTaskToTasklistParams,
   type AddTasklistMembersParams,
+  type CreateTaskCommentParams,
   type CreateTasklistParams,
-  CreateSubtaskParams,
-  CreateTaskParams,
-  DeleteTaskAttachmentParams,
-  GetTaskAttachmentParams,
-  GetTaskParams,
+  type CreateSubtaskParams,
+  type CreateTaskParams,
+  type DeleteTaskAttachmentParams,
+  type DeleteTaskCommentParams,
+  type GetTaskAttachmentParams,
+  type GetTaskCommentParams,
+  type GetTaskParams,
   type GetTasklistParams,
-  ListTaskAttachmentsParams,
+  type ListTaskAttachmentsParams,
+  type ListTaskCommentsParams,
   type ListTasklistsParams,
   type RemoveTaskFromTasklistParams,
   type RemoveTasklistMembersParams,
-  TaskUpdateTask,
+  type TaskCommentPatchComment,
+  type TaskUpdateTask,
   type TasklistPatchTasklist,
-  UploadTaskAttachmentParams,
+  type UploadTaskAttachmentParams,
+  type UpdateTaskCommentParams,
   type UpdateTasklistParams,
-  UpdateTaskParams,
+  type UpdateTaskParams,
 } from "./schemas.js";
 import {
   DEFAULT_TASK_ATTACHMENT_FILENAME,
@@ -36,6 +43,7 @@ import { getFeishuRuntime } from "../runtime.js";
 import { runTaskApiCall } from "./common.js";
 
 const SUPPORTED_PATCH_FIELDS = new Set<string>(TASK_UPDATE_FIELD_VALUES);
+const SUPPORTED_COMMENT_PATCH_FIELDS = new Set<string>(TASK_COMMENT_UPDATE_FIELD_VALUES);
 const SUPPORTED_TASKLIST_PATCH_FIELDS = new Set<string>(TASKLIST_UPDATE_FIELD_VALUES);
 
 function omitUndefined<T extends Record<string, unknown>>(obj: T): T {
@@ -50,10 +58,16 @@ function inferUpdateFields(task: TaskUpdateTask): string[] {
   );
 }
 
+function inferCommentUpdateFields(comment: TaskCommentPatchComment): string[] {
+  return Object.keys(comment).filter((field) =>
+    SUPPORTED_COMMENT_PATCH_FIELDS.has(field),
+  );
+}
+
 function ensureSupportedUpdateFields(
   updateFields: string[],
   supported: Set<string>,
-  resource: "task" | "tasklist",
+  resource: "task" | "comment" | "tasklist",
 ) {
   const invalid = updateFields.filter((field) => !supported.has(field));
   if (invalid.length > 0) {
@@ -102,6 +116,20 @@ function formatTasklist(tasklist: Record<string, unknown> | undefined) {
   };
 }
 
+function formatComment(comment: Record<string, unknown> | undefined) {
+  if (!comment) return undefined;
+  return {
+    id: comment.id,
+    content: comment.content,
+    creator: comment.creator,
+    reply_to_comment_id: comment.reply_to_comment_id,
+    created_at: comment.created_at,
+    updated_at: comment.updated_at,
+    resource_type: comment.resource_type,
+    resource_id: comment.resource_id,
+  };
+}
+
 function formatAttachment(attachment: Record<string, unknown> | undefined) {
   if (!attachment) return undefined;
   return {
@@ -307,6 +335,113 @@ export async function getTask(client: TaskClient, params: GetTaskParams) {
   };
 }
 
+export async function createTaskComment(client: TaskClient, params: CreateTaskCommentParams) {
+  const res = await runTaskApiCall("task.v2.comment.create", () =>
+    client.task.v2.comment.create({
+      data: omitUndefined({
+        content: params.content,
+        reply_to_comment_id: params.reply_to_comment_id,
+        resource_type: "task",
+        resource_id: params.task_guid,
+      }),
+      params: omitUndefined({
+        user_id_type: params.user_id_type,
+      }),
+    }),
+  );
+
+  return {
+    comment: formatComment((res.data?.comment ?? undefined) as Record<string, unknown> | undefined),
+  };
+}
+
+export async function listTaskComments(client: TaskClient, params: ListTaskCommentsParams) {
+  const res = await runTaskApiCall("task.v2.comment.list", () =>
+    client.task.v2.comment.list({
+      params: omitUndefined({
+        resource_type: "task",
+        resource_id: params.task_guid,
+        page_size: params.page_size,
+        page_token: params.page_token,
+        direction: params.direction,
+        user_id_type: params.user_id_type,
+      }),
+    }),
+  );
+
+  const items = (res.data?.items ?? []) as Record<string, unknown>[];
+
+  return {
+    items: items.map((item) => formatComment(item)),
+    page_token: res.data?.page_token,
+    has_more: res.data?.has_more,
+  };
+}
+
+export async function getTaskComment(client: TaskClient, params: GetTaskCommentParams) {
+  const res = await runTaskApiCall("task.v2.comment.get", () =>
+    client.task.v2.comment.get({
+      path: { comment_id: params.comment_id },
+      params: omitUndefined({
+        user_id_type: params.user_id_type,
+      }),
+    }),
+  );
+
+  return {
+    comment: formatComment((res.data?.comment ?? undefined) as Record<string, unknown> | undefined),
+  };
+}
+
+export async function updateTaskComment(client: TaskClient, params: UpdateTaskCommentParams) {
+  const comment = omitUndefined(params.comment as Record<string, unknown>) as TaskCommentPatchComment;
+  const updateFields = params.update_fields?.length
+    ? params.update_fields
+    : inferCommentUpdateFields(comment);
+
+  if (params.update_fields?.length) {
+    ensureSupportedUpdateFields(updateFields, SUPPORTED_COMMENT_PATCH_FIELDS, "comment");
+  }
+
+  if (Object.keys(comment).length === 0) {
+    throw new Error("comment update payload is empty");
+  }
+  if (updateFields.length === 0) {
+    throw new Error("no valid update_fields provided or inferred from comment payload");
+  }
+
+  const res = await runTaskApiCall("task.v2.comment.patch", () =>
+    client.task.v2.comment.patch({
+      path: { comment_id: params.comment_id },
+      data: {
+        comment,
+        update_fields: updateFields,
+      },
+      params: omitUndefined({
+        user_id_type: params.user_id_type,
+      }),
+    }),
+  );
+
+  return {
+    comment: formatComment((res.data?.comment ?? undefined) as Record<string, unknown> | undefined),
+    update_fields: updateFields,
+  };
+}
+
+export async function deleteTaskComment(client: TaskClient, params: DeleteTaskCommentParams) {
+  await runTaskApiCall("task.v2.comment.delete", () =>
+    client.task.v2.comment.delete({
+      path: { comment_id: params.comment_id },
+    }),
+  );
+
+  return {
+    success: true,
+    comment_id: params.comment_id,
+  };
+}
+
 export async function getTasklist(client: TaskClient, params: GetTasklistParams) {
   const res = await runTaskApiCall("task.v2.tasklist.get", () =>
     client.task.v2.tasklist.get({