@max1874/feishu 0.2.26 → 0.2.28

package/package.json

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

package/src/bot.ts

@@ -613,8 +613,16 @@ export async function handleFeishuMessage(params: {
     const feishuFrom = `feishu:${ctx.senderOpenId}`;
     const feishuTo = isGroup ? `chat:${ctx.chatId}` : `user:${ctx.senderOpenId}`;
 
+    // Default DM scope to per-channel-peer so each user gets their own session.
+    // The framework default ("main") would merge all DMs into one shared session.
+    const dmScope = feishuCfg?.dmScope ?? "per-channel-peer";
+    const routingCfg = cfg.session?.dmScope ? cfg : {
+      ...cfg,
+      session: { ...cfg.session, dmScope },
+    };
+
     const route = core.channel.routing.resolveAgentRoute({
-      cfg,
+      cfg: routingCfg,
       channel: "feishu",
       peer: {
         kind: isGroup ? "group" : "dm",

package/src/config-schema.ts

@@ -33,6 +33,10 @@ const MarkdownConfigSchema = z
 // Message render mode: auto (default) = detect markdown, raw = plain text, card = always card
 const RenderModeSchema = z.enum(["auto", "raw", "card"]).optional();
 
+// DM session scope: controls how session keys are computed for private chats.
+// Framework default is "main" (all DMs share one session), which is rarely desired.
+const DmScopeSchema = z.enum(["main", "per-peer", "per-channel-peer", "per-account-channel-peer"]).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
@@ -106,6 +110,7 @@ export const FeishuConfigSchema = z
     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
+    dmScope: DmScopeSchema, // override session.dmScope for this channel (default: per-channel-peer)
   })
   .strict()
   .superRefine((value, ctx) => {

package/src/docx.ts

@@ -868,6 +868,13 @@ const SetPermissionSchema = Type.Object({
   }),
 });
 
+const TransferOwnerSchema = Type.Object({
+  doc_token: Type.String({ description: "Document token" }),
+  new_owner_open_id: Type.Optional(
+    Type.String({ description: "Open ID of the new owner. Omit to transfer to the current conversation sender." }),
+  ),
+});
+
 // Wiki Schemas
 const WikiTokenSchema = Type.Object({
   wiki_token: Type.String({ description: "Wiki token (extract from URL /wiki/XXX)" }),
@@ -1355,5 +1362,37 @@ export function registerFeishuDocTools(api: OpenClawPluginApi) {
     { name: "feishu_chat_messages" },
   );
 
-  api.logger.info?.(`feishu_doc: Registered 15 document/wiki/messaging tools`);
+  // Tool 16: feishu_doc_transfer_owner
+  api.registerTool(
+    {
+      name: "feishu_doc_transfer_owner",
+      label: "Feishu Doc Transfer Owner",
+      description:
+        "Transfer ownership of a Feishu document to another user. " +
+        "If new_owner_open_id is omitted, transfers to the current conversation sender.",
+      parameters: TransferOwnerSchema,
+      async execute(_toolCallId, params) {
+        const { doc_token, new_owner_open_id } = params as {
+          doc_token: string;
+          new_owner_open_id?: string;
+        };
+        try {
+          const openId = new_owner_open_id || getConversationContext()?.senderOpenId;
+          if (!openId) {
+            return json({
+              error:
+                "No new_owner_open_id provided and no current conversation context available.",
+            });
+          }
+          const result = await transferOwner(getClient(), doc_token, openId);
+          return json(result);
+        } catch (err) {
+          return json({ error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    },
+    { name: "feishu_doc_transfer_owner" },
+  );
+
+  api.logger.info?.(`feishu_doc: Registered 16 document/wiki/messaging tools`);
 }

package/src/feishu-renderer.ts

@@ -111,6 +111,63 @@ export class FeishuRenderer {
     return `block_${this.blockId}`;
   }
 
+  /**
+   * marked follows CommonMark emphasis delimiter rules. One sharp edge:
+   * sequences like `总花费**$122.64**` (no whitespace before `**` and the
+   * inner text starts with punctuation like `$` or `(`) are tokenized as
+   * plain text, so `**` would be rendered literally.
+   *
+   * For Feishu doc rendering we treat `**...**` inside text tokens as bold
+   * as a permissive fallback, which makes LLM-generated Markdown more robust.
+   */
+  private renderTextTokenWithStrongFallback(text: string): TextElement | TextElement[] {
+    if (!text.includes("**")) return { text_run: { content: text } };
+
+    const elements: TextElement[] = [];
+    let cursor = 0;
+
+    while (cursor < text.length) {
+      const openIdx = text.indexOf("**", cursor);
+      if (openIdx === -1) {
+        const tail = text.slice(cursor);
+        if (tail) elements.push({ text_run: { content: tail } });
+        break;
+      }
+
+      // Plain text before `**`
+      if (openIdx > cursor) {
+        const plain = text.slice(cursor, openIdx);
+        if (plain) elements.push({ text_run: { content: plain } });
+      }
+
+      const contentStart = openIdx + 2;
+      const closeIdx = text.indexOf("**", contentStart);
+      if (closeIdx === -1) {
+        // No matching close delimiter; render the rest literally.
+        const rest = text.slice(openIdx);
+        if (rest) elements.push({ text_run: { content: rest } });
+        break;
+      }
+
+      const boldContent = text.slice(contentStart, closeIdx);
+      if (boldContent) {
+        elements.push({
+          text_run: {
+            content: boldContent,
+            text_element_style: { bold: true },
+          },
+        });
+      } else {
+        // Degenerate `****` case; keep delimiters literal.
+        elements.push({ text_run: { content: "****" } });
+      }
+
+      cursor = closeIdx + 2;
+    }
+
+    return elements.length > 0 ? elements : { text_run: { content: text } };
+  }
+
   /**
    * Render markdown tokens to Feishu blocks.
    */
@@ -244,7 +301,9 @@ export class FeishuRenderer {
         if (textToken.tokens) {
           elements.push(...this.renderInlineTokens(textToken.tokens));
         } else {
-          elements.push({ text_run: { content: textToken.raw } });
+          const fallback = this.renderTextTokenWithStrongFallback(textToken.raw);
+          if (Array.isArray(fallback)) elements.push(...fallback);
+          else elements.push(fallback);
         }
       } else if (child.type === "paragraph") {
         const paraToken = child as Tokens.Paragraph;
@@ -325,7 +384,7 @@ export class FeishuRenderer {
   private renderInline(token: Token): TextElement | TextElement[] | null {
     switch (token.type) {
       case "text":
-        return { text_run: { content: (token as Tokens.Text).text } };
+        return this.renderTextTokenWithStrongFallback((token as Tokens.Text).text);
 
       case "strong": {
         const strongToken = token as Tokens.Strong;