@m1heng-clawd/feishu 0.1.15 → 0.1.17

package/src/chat-tools/schemas.ts

@@ -1,66 +1,61 @@
 import { Type, type Static } from "@sinclair/typebox";
 
-export const FeishuChatSchema = Type.Union([
-  Type.Object({
-    action: Type.Literal("get_announcement_info"),
-    chat_id: Type.String({ description: "Chat ID to get announcement from" }),
-  }),
-  Type.Object({
-    action: Type.Literal("get_announcement"),
-    chat_id: Type.String({ description: "Chat ID to get announcement from" }),
-  }),
-  Type.Object({
-    action: Type.Literal("write_announcement"),
-    chat_id: Type.String({ description: "Chat ID to write announcement to" }),
-    content: Type.String({ description: "Content to write. For doc format: replaces the entire announcement. For docx format: appends a new text block under the page root." }),
-  }),
-  Type.Object({
-    action: Type.Literal("append_announcement"),
-    chat_id: Type.String({ description: "Chat ID to append announcement to" }),
-    content: Type.String({ description: "Markdown content to append to announcement" }),
-  }),
-  Type.Object({
-    action: Type.Literal("list_announcement_blocks"),
-    chat_id: Type.String({ description: "Chat ID to list announcement blocks from" }),
-  }),
-  Type.Object({
-    action: Type.Literal("get_announcement_block"),
-    chat_id: Type.String({ description: "Chat ID to get announcement block from" }),
-    block_id: Type.String({ description: "Block ID (from list_announcement_blocks)" }),
-  }),
-  Type.Object({
-    action: Type.Literal("update_announcement_block"),
-    chat_id: Type.String({ description: "Chat ID to update announcement block in" }),
-    block_id: Type.String({ description: "Block ID (from list_announcement_blocks)" }),
-    content: Type.String({ description: "New text content" }),
-  }),
-  // ============== New Chat Management Actions ==============
-  Type.Object({
-    action: Type.Literal("create_chat"),
-    name: Type.String({ description: "Group chat name" }),
-    user_ids: Type.Optional(Type.Array(Type.String(), { description: "List of user IDs to add to the group" })),
-    description: Type.Optional(Type.String({ description: "Group chat description" })),
-  }),
-  Type.Object({
-    action: Type.Literal("add_members"),
-    chat_id: Type.String({ description: "Chat ID to add members to" }),
-    user_ids: Type.Array(Type.String(), { description: "List of user IDs to add" }),
-  }),
-  Type.Object({
-    action: Type.Literal("check_bot_in_chat"),
-    chat_id: Type.String({ description: "Chat ID to check" }),
-  }),
-  Type.Object({
-    action: Type.Literal("delete_chat"),
-    chat_id: Type.String({ description: "Chat ID to delete/dismiss" }),
-  }),
-  Type.Object({
-    action: Type.Literal("create_session_chat"),
-    name: Type.String({ description: "Session group name" }),
-    user_ids: Type.Array(Type.String(), { description: "List of user IDs to invite" }),
-    greeting: Type.Optional(Type.String({ description: "Greeting message to send (default: Hello! I've created this group chat for us to collaborate.)" })),
-    description: Type.Optional(Type.String({ description: "Group description" })),
-  }),
-]);
+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 CHAT_ACTION_VALUES = [
+  "get_announcement_info",
+  "get_announcement",
+  "write_announcement",
+  "append_announcement",
+  "list_announcement_blocks",
+  "get_announcement_block",
+  "update_announcement_block",
+  "create_chat",
+  "add_members",
+  "check_bot_in_chat",
+  "delete_chat",
+  "create_session_chat",
+] as const;
+
+const USER_ID_TYPE_VALUES = ["open_id", "user_id", "union_id"] as const;
+const MEMBER_ID_TYPE_VALUES = ["open_id", "user_id", "union_id", "app_id"] as const;
+
+export const FeishuChatSchema = Type.Object({
+  action: stringEnum(CHAT_ACTION_VALUES, { description: "Chat action" }),
+  chat_id: Type.Optional(Type.String({ description: "Chat ID" })),
+  content: Type.Optional(Type.String({ description: "Announcement content / block content" })),
+  block_id: Type.Optional(Type.String({ description: "Announcement block ID" })),
+
+  name: Type.Optional(Type.String({ description: "Group chat name" })),
+  user_ids: Type.Optional(
+    Type.Array(Type.String(), {
+      description: "User/member IDs used by create_chat/add_members/create_session_chat",
+    }),
+  ),
+  user_id_type: Type.Optional(
+    stringEnum(USER_ID_TYPE_VALUES, {
+      description: "ID type for user_ids in create_chat/create_session_chat",
+      default: "open_id",
+    }),
+  ),
+  member_id_type: Type.Optional(
+    stringEnum(MEMBER_ID_TYPE_VALUES, {
+      description: "ID type for add_members (supports app_id for bots)",
+      default: "open_id",
+    }),
+  ),
+  greeting: Type.Optional(
+    Type.String({
+      description:
+        "Greeting message for create_session_chat (default: Hello! I've created this group chat for us to collaborate.)",
+    }),
+  ),
+  description: Type.Optional(Type.String({ description: "Group chat description" })),
+});
 
 export type FeishuChatParams = Static<typeof FeishuChatSchema>;

package/src/config-schema.ts

@@ -91,6 +91,8 @@ const FeishuToolsConfigSchema = z
     task: z.boolean().optional(), // Task operations (default: true)
     chat: z.boolean().optional(), // Chat management operations (default: true)
     urgent: z.boolean().optional(), // Buzz/urgent notifications (default: true)
+    message: z.boolean().optional(), // Message reading (default: true)
+    reaction: z.boolean().optional(), // Emoji reactions (default: true)
   })
   .strict()
   .optional();

package/src/doc-tools/actions.ts

@@ -44,6 +44,13 @@ function normalizePageSize(pageSize?: number) {
   return pageSize;
 }
 
+function requireString(value: unknown, field: string): string {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${field} is required`);
+  }
+  return value;
+}
+
 function omitUndefined<T extends Record<string, unknown>>(obj: T): T {
   return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined)) as T;
 }
@@ -304,37 +311,79 @@ export async function runDocAction(
 ) {
   switch (params.action) {
     case "read":
-      return readDoc(client, params.doc_token);
+      return readDoc(client, requireString(params.doc_token, "doc_token"));
     case "write":
-      return writeDoc(client, params.doc_token, params.content, mediaMaxBytes);
+      return writeDoc(
+        client,
+        requireString(params.doc_token, "doc_token"),
+        requireString(params.content, "content"),
+        mediaMaxBytes,
+      );
     case "append":
-      return appendDoc(client, params.doc_token, params.content, mediaMaxBytes);
+      return appendDoc(
+        client,
+        requireString(params.doc_token, "doc_token"),
+        requireString(params.content, "content"),
+        mediaMaxBytes,
+      );
     case "create":
-      return createDoc(client, params.title, params.folder_token);
+      return createDoc(client, requireString(params.title, "title"), params.folder_token);
     case "create_and_write":
       return createAndWriteDoc(
         client,
-        params.title,
-        params.content,
+        requireString(params.title, "title"),
+        requireString(params.content, "content"),
         mediaMaxBytes,
         params.folder_token,
       );
     case "list_blocks":
-      return listBlocks(client, params.doc_token);
+      return listBlocks(client, requireString(params.doc_token, "doc_token"));
     case "get_block":
-      return getBlock(client, params.doc_token, params.block_id);
+      return getBlock(
+        client,
+        requireString(params.doc_token, "doc_token"),
+        requireString(params.block_id, "block_id"),
+      );
     case "update_block":
-      return updateBlock(client, params.doc_token, params.block_id, params.content);
+      return updateBlock(
+        client,
+        requireString(params.doc_token, "doc_token"),
+        requireString(params.block_id, "block_id"),
+        requireString(params.content, "content"),
+      );
     case "delete_block":
-      return deleteBlock(client, params.doc_token, params.block_id);
+      return deleteBlock(
+        client,
+        requireString(params.doc_token, "doc_token"),
+        requireString(params.block_id, "block_id"),
+      );
     case "list_comments":
-      return listComments(client, params.doc_token, params.page_token, params.page_size);
+      return listComments(
+        client,
+        requireString(params.doc_token, "doc_token"),
+        params.page_token,
+        params.page_size,
+      );
     case "create_comment":
-      return createComment(client, params.doc_token, params.content);
+      return createComment(
+        client,
+        requireString(params.doc_token, "doc_token"),
+        requireString(params.content, "content"),
+      );
     case "get_comment":
-      return getComment(client, params.doc_token, params.comment_id);
+      return getComment(
+        client,
+        requireString(params.doc_token, "doc_token"),
+        requireString(params.comment_id, "comment_id"),
+      );
     case "list_comment_replies":
-      return listCommentReplies(client, params.doc_token, params.comment_id, params.page_token, params.page_size);
+      return listCommentReplies(
+        client,
+        requireString(params.doc_token, "doc_token"),
+        requireString(params.comment_id, "comment_id"),
+        params.page_token,
+        params.page_size,
+      );
     default:
       return { error: `Unknown action: ${(params as any).action}` };
   }

package/src/doc-tools/schemas.ts

@@ -1,85 +1,49 @@
 import { Type, type Static } from "@sinclair/typebox";
 
-export const FeishuDocSchema = Type.Union([
-  Type.Object({
-    action: Type.Literal("read"),
-    doc_token: Type.String({
+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 DOC_ACTION_VALUES = [
+  "read",
+  "write",
+  "append",
+  "create",
+  "create_and_write",
+  "list_blocks",
+  "get_block",
+  "update_block",
+  "delete_block",
+  "list_comments",
+  "create_comment",
+  "get_comment",
+  "list_comment_replies",
+] as const;
+
+export const FeishuDocSchema = Type.Object({
+  action: stringEnum(DOC_ACTION_VALUES, { description: "Document action" }),
+  doc_token: Type.Optional(
+    Type.String({
       description:
         "Document token (extract from URL /docx/XXX or /docs/XXX). Supports both new (docx) and legacy (doc) formats.",
     }),
-  }),
-  Type.Object({
-    action: Type.Literal("write"),
-    doc_token: Type.String({ description: "Document token" }),
-    content: Type.String({
-      description: "Markdown content to write (replaces entire document content)",
-    }),
-  }),
-  Type.Object({
-    action: Type.Literal("append"),
-    doc_token: Type.String({ description: "Document token" }),
-    content: Type.String({ description: "Markdown content to append to end of document" }),
-  }),
-  Type.Object({
-    action: Type.Literal("create"),
-    title: Type.String({ description: "Document title" }),
-    folder_token: Type.Optional(Type.String({ description: "Target folder token (optional)" })),
-  }),
-  Type.Object({
-    action: Type.Literal("create_and_write"),
-    title: Type.String({ description: "Document title" }),
-    content: Type.String({
-      description: "Markdown content to write immediately after document creation",
+  ),
+  content: Type.Optional(
+    Type.String({
+      description: "Markdown content for write/append/comment/update operations",
     }),
-    folder_token: Type.Optional(Type.String({ description: "Target folder token (optional)" })),
-  }),
-  Type.Object({
-    action: Type.Literal("list_blocks"),
-    doc_token: Type.String({ description: "Document token" }),
-  }),
-  Type.Object({
-    action: Type.Literal("get_block"),
-    doc_token: Type.String({ description: "Document token" }),
-    block_id: Type.String({ description: "Block ID (from list_blocks)" }),
-  }),
-  Type.Object({
-    action: Type.Literal("update_block"),
-    doc_token: Type.String({ description: "Document token" }),
-    block_id: Type.String({ description: "Block ID (from list_blocks)" }),
-    content: Type.String({ description: "New text content" }),
-  }),
-  Type.Object({
-    action: Type.Literal("delete_block"),
-    doc_token: Type.String({ description: "Document token" }),
-    block_id: Type.String({ description: "Block ID" }),
-  }),
-  Type.Object({
-    action: Type.Literal("list_comments"),
-    doc_token: Type.String({ description: "Document token" }),
-    page_token: Type.Optional(Type.String({ description: "Page token for pagination" })),
-    page_size: Type.Optional(
-      Type.Integer({ minimum: 1, description: "Page size, default 50 (positive integer)" }),
-    ),
-  }),
-  Type.Object({
-    action: Type.Literal("create_comment"),
-    doc_token: Type.String({ description: "Document token" }),
-    content: Type.String({ description: "Comment content" }),
-  }),
-  Type.Object({
-    action: Type.Literal("get_comment"),
-    doc_token: Type.String({ description: "Document token" }),
-    comment_id: Type.String({ description: "Comment ID" }),
-  }),
-  Type.Object({
-    action: Type.Literal("list_comment_replies"),
-    doc_token: Type.String({ description: "Document token" }),
-    comment_id: Type.String({ description: "Comment ID" }),
-    page_token: Type.Optional(Type.String({ description: "Page token for pagination" })),
-    page_size: Type.Optional(
-      Type.Integer({ minimum: 1, description: "Page size, default 50 (positive integer)" }),
-    ),
-  }),
-]);
+  ),
+  title: Type.Optional(Type.String({ description: "Document title (for create/create_and_write)" })),
+  folder_token: Type.Optional(Type.String({ description: "Target folder token (optional)" })),
+  block_id: Type.Optional(Type.String({ description: "Block ID (from list_blocks)" })),
+  comment_id: Type.Optional(Type.String({ description: "Comment ID" })),
+  page_token: Type.Optional(Type.String({ description: "Page token for pagination" })),
+  page_size: Type.Optional(
+    Type.Integer({ minimum: 1, description: "Page size, default 50 (positive integer)" }),
+  ),
+});
 
 export type FeishuDocParams = Static<typeof FeishuDocSchema>;

package/src/doc-write-service.ts

@@ -1,6 +1,7 @@
 import type * as Lark from "@larksuiteoapi/node-sdk";
 import { Readable } from "stream";
 import { getFeishuRuntime } from "./runtime.js";
+import { getCurrentFeishuToolContext } from "./tools-common/tool-context.js";
 
 const BLOCK_TYPE_NAMES: Record<number, string> = {
   1: "Page",
@@ -572,6 +573,24 @@ export async function createDoc(
   });
   if (res.code !== 0) throw new Error(res.msg);
   const doc = res.data?.document;
+
+  // Auto-share with the requesting user so they can edit the document.
+  const senderOpenId = getCurrentFeishuToolContext()?.senderOpenId;
+  if (doc?.document_id && senderOpenId) {
+    try {
+      const permRes = await client.drive.permissionMember.create({
+        path: { token: doc.document_id },
+        params: { type: "docx", need_notification: false },
+        data: { member_type: "openid", member_id: senderOpenId, perm: "edit" },
+      });
+      if (permRes.code !== 0) {
+        console.warn(`[feishu_doc] Failed to auto-share doc ${doc.document_id}: ${permRes.msg}`);
+      }
+    } catch (err) {
+      console.warn(`[feishu_doc] Failed to auto-share doc ${doc.document_id}:`, err);
+    }
+  }
+
   return {
     document_id: doc?.document_id,
     title: doc?.title,

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/register.ts

@@ -59,7 +59,7 @@ export function registerFeishuDriveTools(api: OpenClawPluginApi) {
     name: "feishu_drive",
     label: "Feishu Drive",
     description:
-      "Feishu cloud storage operations. Actions: list, info, create_folder, move, delete, import_document. Use 'import_document' to create documents from Markdown with better structure preservation than block-by-block writing.",
+      "Feishu cloud Drive operations. This tool works with Feishu Drive folders/files/documents, not the OpenClaw agent's local filesystem workspace. Actions: list, info, create_folder, move, delete, import_document. Use 'import_document' to create documents from Markdown with better structure preservation than block-by-block writing.",
     parameters: FeishuDriveSchema,
     run: async ({ client, account }, params) => {
       const mediaMaxBytes = (account.config?.mediaMaxMb ?? 30) * 1024 * 1024;

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