@m1heng-clawd/feishu 0.1.14 → 0.1.16

package/src/config-schema.ts

@@ -4,6 +4,7 @@ export { z };
 const DmPolicySchema = z.enum(["open", "pairing", "allowlist"]);
 const GroupPolicySchema = z.enum(["open", "allowlist", "disabled"]);
 const GroupCommandMentionBypassSchema = z.enum(["never", "single_bot", "always"]).optional();
+const AllowMentionlessInMultiBotGroupSchema = z.boolean().optional();
 const FeishuDomainSchema = z.union([
   z.enum(["feishu", "lark"]),
   z.string().url().startsWith("https://"),
@@ -88,6 +89,8 @@ const FeishuToolsConfigSchema = z
     perm: z.boolean().optional(), // Permission management (default: false, sensitive)
     scopes: z.boolean().optional(), // App scopes diagnostic (default: true)
     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)
   })
   .strict()
   .optional();
@@ -106,6 +109,7 @@ export const FeishuGroupSchema = z
   .object({
     requireMention: z.boolean().optional(),
     groupCommandMentionBypass: GroupCommandMentionBypassSchema,
+    allowMentionlessInMultiBotGroup: AllowMentionlessInMultiBotGroupSchema,
     tools: ToolPolicySchema,
     skills: z.array(z.string()).optional(),
     enabled: z.boolean().optional(),
@@ -140,6 +144,7 @@ export const FeishuAccountConfigSchema = z
     groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
     requireMention: z.boolean().optional(),
     groupCommandMentionBypass: GroupCommandMentionBypassSchema,
+    allowMentionlessInMultiBotGroup: AllowMentionlessInMultiBotGroupSchema,
     groups: z.record(z.string(), FeishuGroupSchema.optional()).optional(),
     historyLimit: z.number().int().min(0).optional(),
     dmHistoryLimit: z.number().int().min(0).optional(),
@@ -177,6 +182,7 @@ export const FeishuConfigSchema = z
     groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
     requireMention: z.boolean().optional().default(true),
     groupCommandMentionBypass: GroupCommandMentionBypassSchema.default("single_bot"),
+    allowMentionlessInMultiBotGroup: AllowMentionlessInMultiBotGroupSchema.default(false),
     groups: z.record(z.string(), FeishuGroupSchema.optional()).optional(),
     topicSessionMode: TopicSessionModeSchema,
     historyLimit: z.number().int().min(0).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,37 @@ 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;
+  
+  do {
+    const listRes = await runDriveApiCall("drive.file.list", () =>
+      client.drive.file.list({
+        params: pageToken ? { page_token: pageToken } : {},
+      }),
+    );
+
+    const file = listRes.data?.files?.find((f: any) => f.token === fileToken);
+    if (file) {
+      if (!file.type) {
+        throw new Error(`File found but no type for ${fileToken}. Please provide the 'type' parameter explicitly.`);
+      }
+      return file.type;
+    }
+    
+    pageToken = listRes.data?.next_page_token;
+  } while (pageToken);
+
+  throw new Error(`File not found: ${fileToken}. Please provide the 'type' parameter explicitly.`);
+}
+
 async function getRootFolderToken(client: DriveClient): Promise<string> {
   // Use generic HTTP client to call the root folder meta API
   // as it's not directly exposed in the SDK.
@@ -46,27 +77,32 @@ async function listFolder(client: DriveClient, folderToken?: string) {
 }
 
 async function getFileInfo(client: DriveClient, fileToken: string, folderToken?: string) {
-  // Use list with folder_token to find file info.
-  const res = await runDriveApiCall("drive.file.list", () =>
-    client.drive.file.list({
-      params: folderToken ? { folder_token: folderToken } : {},
-    }),
-  );
+  let pageToken: string | undefined;
+
+  do {
+    const res = await runDriveApiCall("drive.file.list", () =>
+      client.drive.file.list({
+        params: folderToken ? { folder_token: folderToken, page_token: pageToken } : { page_token: pageToken },
+      }),
+    );
+
+    const file = res.data?.files?.find((f: any) => f.token === fileToken);
+    if (file) {
+      return {
+        token: file.token,
+        name: file.name,
+        type: file.type,
+        url: file.url,
+        created_time: file.created_time,
+        modified_time: file.modified_time,
+        owner_id: file.owner_id,
+      };
+    }
 
-  const file = res.data?.files?.find((f) => f.token === fileToken);
-  if (!file) {
-    throw new Error(`File not found: ${fileToken}`);
-  }
+    pageToken = res.data?.next_page_token;
+  } while (pageToken);
 
-  return {
-    token: file.token,
-    name: file.name,
-    type: file.type,
-    url: file.url,
-    created_time: file.created_time,
-    modified_time: file.modified_time,
-    owner_id: file.owner_id,
-  };
+  throw new Error(`File not found: ${fileToken}`);
 }
 
 async function createFolder(client: DriveClient, name: string, folderToken?: string) {
@@ -119,12 +155,18 @@ async function moveFile(
   };
 }
 
-async function deleteFile(client: DriveClient, fileToken: string, type: string) {
+async function deleteFile(client: DriveClient, fileToken: string, type?: string) {
+  let effectiveType = type;
+
+  if (!effectiveType) {
+    effectiveType = await getFileType(client, fileToken);
+  }
+
   const res = await runDriveApiCall("drive.file.delete", () =>
     client.drive.file.delete({
       path: { file_token: fileToken },
       params: {
-        type: type as DriveDeleteType,
+        type: effectiveType as DriveDeleteType,
       },
     }),
   );
@@ -132,6 +174,7 @@ async function deleteFile(client: DriveClient, fileToken: string, type: string)
   return {
     success: true,
     task_id: res.data?.task_id,
+    type_used: effectiveType,
   };
 }
 
@@ -160,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: 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: 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>;