@m1heng-clawd/feishu 0.1.15 → 0.1.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m1heng-clawd/feishu",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "type": "module",
   "description": "OpenClaw Feishu/Lark channel plugin",
   "scripts": {

package/src/bot.ts

@@ -1488,6 +1488,7 @@ export async function handleFeishuMessage(params: {
           channel: "feishu",
           accountId: account.accountId,
           sessionKey: route.sessionKey,
+          senderOpenId: ctx.senderOpenId,
         },
         // Keep account context available while the agent executes plugin tools.
         () =>
@@ -1574,6 +1575,7 @@ export async function handleFeishuMessage(params: {
         channel: "feishu",
         accountId: account.accountId,
         sessionKey: route.sessionKey,
+        senderOpenId: ctx.senderOpenId,
       },
       // Tool calls produced by this turn should resolve to the same inbound account.
       () =>

package/src/chat-tools/actions.ts

@@ -2,6 +2,23 @@ import type { ChatClient } from "./common.js";
 import type { FeishuChatParams } from "./schemas.js";
 import { runChatApiCall } from "./common.js";
 
+type UserIdType = "open_id" | "user_id" | "union_id";
+type MemberIdType = UserIdType | "app_id";
+
+function requireString(value: unknown, field: string): string {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${field} is required`);
+  }
+  return value;
+}
+
+function requireStringArray(value: unknown, field: string): string[] {
+  if (!Array.isArray(value) || value.length === 0 || value.some((item) => typeof item !== "string")) {
+    throw new Error(`${field} must be a non-empty string array`);
+  }
+  return value;
+}
+
 const BLOCK_TYPE_NAMES: Record<number, string> = {
   1: "Page",
   2: "Text",
@@ -117,15 +134,35 @@ async function writeDocAnnouncement(client: ChatClient, chatId: string, content:
     }),
   );
 
-  const res = await runChatApiCall("im.chatAnnouncement.patch", () =>
-    (client as any).im.chatAnnouncement.patch({
-      path: { chat_id: chatId },
-      data: {
-        content,
-        revision: (current as any).data?.revision,
-      },
-    }),
-  );
+  const revision = (current as any).data?.revision;
+  if (!revision) {
+    throw new Error("Failed to load current announcement revision");
+  }
+
+  let res: unknown;
+  try {
+    // Prefer SDK current payload shape (revision + requests[]).
+    res = await runChatApiCall("im.chatAnnouncement.patch", () =>
+      (client as any).im.chatAnnouncement.patch({
+        path: { chat_id: chatId },
+        data: {
+          revision,
+          requests: [content],
+        },
+      }),
+    );
+  } catch {
+    // Backward compatibility for tenants still accepting legacy content payload.
+    res = await runChatApiCall("im.chatAnnouncement.patch", () =>
+      (client as any).im.chatAnnouncement.patch({
+        path: { chat_id: chatId },
+        data: {
+          content,
+          revision,
+        },
+      }),
+    );
+  }
 
   return {
     success: true,
@@ -210,7 +247,13 @@ async function batchUpdateAnnouncementBlocks(
 
 // ============== New Chat Management Functions ==============
 
-async function createChat(client: ChatClient, name: string, userIds?: string[], description?: string) {
+async function createChat(
+  client: ChatClient,
+  name: string,
+  userIds?: string[],
+  description?: string,
+  userIdType: UserIdType = "open_id",
+) {
   const data: any = { name };
   if (userIds && userIds.length > 0) {
     data.user_id_list = userIds;
@@ -222,7 +265,7 @@ async function createChat(client: ChatClient, name: string, userIds?: string[],
   const res = await runChatApiCall("im.chat.create", () =>
     (client as any).im.chat.create({
       data,
-      params: { user_id_type: "open_id" },
+      params: { user_id_type: userIdType },
     }),
   );
 
@@ -233,11 +276,16 @@ async function createChat(client: ChatClient, name: string, userIds?: string[],
   };
 }
 
-async function addMembers(client: ChatClient, chatId: string, userIds: string[]) {
+async function addMembers(
+  client: ChatClient,
+  chatId: string,
+  userIds: string[],
+  memberIdType: MemberIdType = "open_id",
+) {
   const res = await runChatApiCall("im.chatMembers.create", () =>
     (client as any).im.chatMembers.create({
       path: { chat_id: chatId },
-      params: { member_id_type: "open_id" },
+      params: { member_id_type: memberIdType },
       data: { id_list: userIds },
     }),
   );
@@ -300,9 +348,10 @@ async function createSessionChat(
   userIds: string[],
   greeting?: string,
   description?: string,
+  userIdType: UserIdType = "open_id",
 ) {
   // Step 1: Create the chat
-  const createResult = await createChat(client, name, userIds, description);
+  const createResult = await createChat(client, name, userIds, description, userIdType);
   const chatId = createResult.chat_id;
   
   if (!chatId) {
@@ -358,15 +407,21 @@ export async function runChatAction(client: ChatClient, params: FeishuChatParams
   switch (params.action) {
     case "get_announcement_info":
     case "get_announcement":
-      return getAnnouncement(client, params.chat_id);
+      return getAnnouncement(client, requireString(params.chat_id, "chat_id"));
     case "list_announcement_blocks":
-      return listAnnouncementBlocks(client, params.chat_id);
+      return listAnnouncementBlocks(client, requireString(params.chat_id, "chat_id"));
     case "get_announcement_block":
-      return getAnnouncementBlock(client, params.chat_id, params.block_id);
+      return getAnnouncementBlock(
+        client,
+        requireString(params.chat_id, "chat_id"),
+        requireString(params.block_id, "block_id"),
+      );
     case "write_announcement": {
-      const current = await getAnnouncement(client, params.chat_id);
+      const chatId = requireString(params.chat_id, "chat_id");
+      const content = requireString(params.content, "content");
+      const current = await getAnnouncement(client, chatId);
       if (current.announcement_type === "doc") {
-        return writeDocAnnouncement(client, params.chat_id, params.content);
+        return writeDocAnnouncement(client, chatId, content);
       } else {
         // For docx announcements, append a text block under the Page root block.
         // Full replacement is not supported via API; use update_announcement_block to edit existing blocks.
@@ -375,15 +430,17 @@ export async function runChatAction(client: ChatClient, params: FeishuChatParams
         if (!pageBlock?.block_id) {
           return { error: "Could not find the Page root block for docx announcement. Use list_announcement_blocks to inspect the structure." };
         }
-        return createTextBlock(client, params.chat_id, pageBlock.block_id, params.content);
+        return createTextBlock(client, chatId, pageBlock.block_id, content);
       }
     }
     case "append_announcement": {
-      const current = await getAnnouncement(client, params.chat_id);
+      const chatId = requireString(params.chat_id, "chat_id");
+      const content = requireString(params.content, "content");
+      const current = await getAnnouncement(client, chatId);
       if (current.announcement_type === "doc") {
         const existingContent = (current as any).content || "";
-        const newContent = existingContent + "\n" + params.content;
-        return writeDocAnnouncement(client, params.chat_id, newContent);
+        const newContent = existingContent + "\n" + content;
+        return writeDocAnnouncement(client, chatId, newContent);
       } else {
         // For docx format, the parent block must be the Page root block (block_type: 1)
         const blocks: any[] = (current as any).blocks ?? [];
@@ -391,40 +448,52 @@ export async function runChatAction(client: ChatClient, params: FeishuChatParams
         if (!pageBlock?.block_id) {
           return { error: "Could not find the Page root block for docx announcement. Use list_announcement_blocks to inspect the structure." };
         }
-        return createTextBlock(client, params.chat_id, pageBlock.block_id, params.content);
+        return createTextBlock(client, chatId, pageBlock.block_id, content);
       }
     }
     case "update_announcement_block": {
       const requests = [
         {
-          block_id: params.block_id,
+          block_id: requireString(params.block_id, "block_id"),
           update_text_elements: {
-            elements: [{ text_run: { content: params.content } }],
+            elements: [{ text_run: { content: requireString(params.content, "content") } }],
           },
         },
       ];
-      return batchUpdateAnnouncementBlocks(client, params.chat_id, requests);
+      return batchUpdateAnnouncementBlocks(client, requireString(params.chat_id, "chat_id"), requests);
     }
     // ============== New Chat Management Actions ==============
     case "create_chat": {
-      return createChat(client, params.name, params.user_ids, params.description);
+      return createChat(
+        client,
+        requireString(params.name, "name"),
+        params.user_ids,
+        params.description,
+        params.user_id_type,
+      );
     }
     case "add_members": {
-      return addMembers(client, params.chat_id, params.user_ids);
+      return addMembers(
+        client,
+        requireString(params.chat_id, "chat_id"),
+        requireStringArray(params.user_ids, "user_ids"),
+        params.member_id_type,
+      );
     }
     case "check_bot_in_chat": {
-      return checkBotInChat(client, params.chat_id);
+      return checkBotInChat(client, requireString(params.chat_id, "chat_id"));
     }
     case "delete_chat": {
-      return deleteChat(client, params.chat_id);
+      return deleteChat(client, requireString(params.chat_id, "chat_id"));
     }
     case "create_session_chat": {
       return createSessionChat(
         client,
-        params.name,
-        params.user_ids,
+        requireString(params.name, "name"),
+        requireStringArray(params.user_ids, "user_ids"),
         params.greeting,
         params.description,
+        params.user_id_type,
       );
     }
     default:

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/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,