@max1874/feishu 0.2.22 → 0.2.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@max1874/feishu",
-  "version": "0.2.22",
+  "version": "0.2.24",
   "type": "module",
   "description": "OpenClaw Feishu/Lark channel plugin",
   "license": "MIT",

package/src/bot.ts

@@ -752,12 +752,29 @@ export async function handleFeishuMessage(params: {
       ...mediaPayload,
     });
 
+    // Resolve replyToMode: per-chat-type override > global > default ("all")
+    const chatTypeKey = isGroup ? "group" : "direct";
+    const replyToMode =
+      feishuCfg?.replyToModeByChatType?.[chatTypeKey] ??
+      feishuCfg?.replyToMode ??
+      "all";
+
+    // Compute effective replyToMessageId based on mode
+    let effectiveReplyToMessageId: string | undefined;
+    if (replyToMode === "all") {
+      // Always thread: reply to the triggering message
+      effectiveReplyToMessageId = ctx.messageId;
+    } else {
+      // "off": only thread if the triggering message is already in a thread
+      effectiveReplyToMessageId = ctx.rootId;
+    }
+
     const { dispatcher, replyOptions, markDispatchIdle } = createFeishuReplyDispatcher({
       cfg,
       agentId: route.agentId,
       runtime: runtime as RuntimeEnv,
       chatId: ctx.chatId,
-      replyToMessageId: ctx.messageId,
+      replyToMessageId: effectiveReplyToMessageId,
       mentionTargets: ctx.mentionTargets,
     });
 

package/src/config-schema.ts

@@ -33,6 +33,20 @@ const MarkdownConfigSchema = z
 // Message render mode: auto (default) = detect markdown, raw = plain text, card = always card
 const RenderModeSchema = z.enum(["auto", "raw", "card"]).optional();
 
+// Reply-to (threading) mode: controls whether bot replies are sent as threaded replies.
+// - "all" (default): always reply in thread (current behavior)
+// - "off": reply in main chat; only thread if the triggering message was already in a thread
+const ReplyToModeSchema = z.enum(["off", "all"]).optional();
+
+// Per-chat-type overrides for replyToMode
+const ReplyToModeByChatTypeSchema = z
+  .object({
+    direct: ReplyToModeSchema,
+    group: ReplyToModeSchema,
+  })
+  .strict()
+  .optional();
+
 const BlockStreamingCoalesceSchema = z
   .object({
     enabled: z.boolean().optional(),
@@ -90,6 +104,8 @@ export const FeishuConfigSchema = z
     mediaMaxMb: z.number().positive().optional(),
     heartbeat: ChannelHeartbeatVisibilitySchema,
     renderMode: RenderModeSchema, // raw = plain text (default), card = interactive card with markdown
+    replyToMode: ReplyToModeSchema, // "all" = always thread (default), "off" = main chat unless already in thread
+    replyToModeByChatType: ReplyToModeByChatTypeSchema, // per-chat-type overrides for replyToMode
   })
   .strict()
   .superRefine((value, ctx) => {

package/src/docx.ts

@@ -508,6 +508,20 @@ async function grantFullAccess(client: Lark.Client, docToken: string, memberId:
   return res.data;
 }
 
+/** Transfer document ownership to a user (open_id) */
+async function transferOwner(client: Lark.Client, docToken: string, newOwnerOpenId: string) {
+  const res = await client.drive.permissionMember.transferOwner({
+    path: { token: docToken },
+    params: { type: "docx", need_notification: false, remove_old_owner: false },
+    data: {
+      member_type: "openid",
+      member_id: newOwnerOpenId,
+    },
+  });
+  if (res.code !== 0) throw new Error(res.msg);
+  return res.data;
+}
+
 async function createDoc(
   client: Lark.Client,
   title: string,
@@ -526,16 +540,32 @@ async function createDoc(
     await setDocPermissionTenantEditable(client, docId);
   }
 
-  // Auto-grant full_access to conversation participant (user in DM, chat group in group)
+  // Auto-transfer ownership to the sender, and grant group access if in group chat
+  let ownerTransferredTo: string | undefined;
   let grantedTo: string | undefined;
   const convCtx = getConversationContext();
   if (docId && convCtx) {
-    const memberId = convCtx.chatType === "group" ? convCtx.chatId : convCtx.senderOpenId;
+    // Transfer ownership to the user who triggered this request
     try {
-      await grantFullAccess(client, docId, memberId);
-      grantedTo = memberId;
+      await transferOwner(client, docId, convCtx.senderOpenId);
+      ownerTransferredTo = convCtx.senderOpenId;
     } catch {
-      // Non-fatal: doc is created, permission grant failed
+      // Fallback: grant full_access if transfer fails
+      try {
+        await grantFullAccess(client, docId, convCtx.senderOpenId);
+        grantedTo = convCtx.senderOpenId;
+      } catch {
+        // Non-fatal: doc is created, permission grant failed
+      }
+    }
+
+    // In group chats, also grant full_access to the chat group
+    if (convCtx.chatType === "group") {
+      try {
+        await grantFullAccess(client, docId, convCtx.chatId);
+      } catch {
+        // Non-fatal
+      }
     }
   }
 
@@ -544,6 +574,7 @@ async function createDoc(
     title: doc?.title,
     url: `https://feishu.cn/docx/${docId}`,
     permission: permission ?? "private",
+    ...(ownerTransferredTo && { owner_transferred_to: ownerTransferredTo }),
     ...(grantedTo && { granted_full_access_to: grantedTo }),
   };
 }