@openclaw/feishu 2026.6.8 → 2026.6.9-beta.1

package/dist/{send-B3kteMF8.js → send-BozRcrbz.js}

@@ -182,7 +182,7 @@ async function saveMessageResourceWithType(params) {
 			errorPrefix: "Feishu message resource download failed",
 			maxBytes: params.maxBytes,
 			contentType: meta.contentType,
-			fileName: meta.fileName ?? params.originalFilename
+			fileName: meta.fileName ?? (params.originalFilename ? recoverUtf8FileNameFromLatin1Header(params.originalFilename) : void 0)
 		}),
 		...meta
 	};
@@ -606,25 +606,12 @@ function isMentionForwardRequest(event, botOpenId) {
 	return userMentions.some((m) => m.id.open_id === botOpenId) && hasOtherMention;
 }
 /**
-* Format @mention for text message
-*/
-function formatMentionForText(target) {
-	return `<at user_id="${target.openId}">${target.name}</at>`;
-}
-/**
 * Format @mention for card message (lark_md)
 */
 function formatMentionForCard(target) {
 	return `<at id=${target.openId}></at>`;
 }
 /**
-* Build complete message with @mentions (text format)
-*/
-function buildMentionedMessage(targets, message) {
-	if (targets.length === 0) return message;
-	return `${targets.map((t) => formatMentionForText(t)).join(" ")} ${message}`;
-}
-/**
 * Build card content with @mentions (Markdown format)
 */
 function buildMentionedCardContent(targets, message) {
@@ -973,7 +960,10 @@ async function getMessageFeishu(params) {
 	if (!account.configured) throw new Error(`Feishu account "${account.accountId}" not configured`);
 	const client = createFeishuClient(account);
 	try {
-		const response = await client.im.message.get({ path: { message_id: messageId } });
+		const response = await client.im.message.get({
+			params: { card_msg_content_type: "user_card_content" },
+			path: { message_id: messageId }
+		});
 		if (response.code !== 0) return null;
 		const rawItem = response.data?.items?.[0] ?? response.data;
 		const item = rawItem && (rawItem.body !== void 0 || rawItem.message_id !== void 0) ? rawItem : null;
@@ -999,7 +989,8 @@ async function listFeishuThreadMessages(params) {
 		container_id_type: "thread",
 		container_id: threadId,
 		sort_type: "ByCreateTimeDesc",
-		page_size: Math.min(limit + 1, 50)
+		page_size: Math.min(limit + 1, 50),
+		card_msg_content_type: "user_card_content"
 	} });
 	if (response.code !== 0) throw new Error(`Feishu thread list failed: code=${response.code} msg=${response.msg ?? "unknown"}`);
 	const items = response.data?.items ?? [];
@@ -1021,13 +1012,29 @@ async function listFeishuThreadMessages(params) {
 	results.reverse();
 	return results;
 }
+function buildFeishuPostMentionElements(mentions) {
+	if (!mentions?.length) return [];
+	const elements = [];
+	for (const mention of mentions) {
+		const userId = mention.openId.trim();
+		if (!userId) continue;
+		const userName = mention.name.trim();
+		elements.push({
+			tag: "at",
+			user_id: userId,
+			...userName ? { user_name: userName } : {}
+		});
+	}
+	return elements;
+}
 function buildFeishuPostMessagePayload(params) {
-	const { messageText } = params;
+	const { messageText, mentions } = params;
+	const content = [...buildFeishuPostMentionElements(mentions), {
+		tag: "md",
+		text: messageText
+	}];
 	return {
-		content: JSON.stringify({ zh_cn: { content: [[{
-			tag: "md",
-			text: messageText
-		}]] } }),
+		content: JSON.stringify({ zh_cn: { content: [content] } }),
 		msgType: "post"
 	};
 }
@@ -1042,9 +1049,10 @@ async function sendMessageFeishu(params) {
 		cfg,
 		channel: "feishu"
 	});
-	let rawText = text ?? "";
-	if (mentions && mentions.length > 0) rawText = buildMentionedMessage(mentions, rawText);
-	const { content, msgType } = buildFeishuPostMessagePayload({ messageText: convertMarkdownTables(rawText, tableMode) });
+	const { content, msgType } = buildFeishuPostMessagePayload({
+		messageText: convertMarkdownTables(text ?? "", tableMode),
+		mentions
+	});
 	return sendReplyOrFallbackDirect(client, {
 		replyToMessageId,
 		replyInThread,

package/dist/setup-api.js

@@ -1,2 +1,2 @@
-import { i as feishuSetupAdapter, n as feishuSetupWizard, t as feishuPlugin } from "./channel-DwygSth-.js";
+import { i as feishuSetupAdapter, n as feishuSetupWizard, t as feishuPlugin } from "./channel-C9mW5kaS.js";
 export { feishuPlugin, feishuSetupAdapter, feishuSetupWizard };

package/node_modules/@protobufjs/aspromise/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2016, Daniel Wirtz  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of its author, nor the names of its contributors
+  may be used to endorse or promote products derived from this software
+  without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/node_modules/@protobufjs/aspromise/README.md

@@ -0,0 +1,13 @@
+@protobufjs/aspromise
+=====================
+[![npm](https://img.shields.io/npm/v/@protobufjs/aspromise.svg)](https://www.npmjs.com/package/@protobufjs/aspromise)
+
+Returns a promise from a node-style callback function.
+
+API
+---
+
+* **asPromise(fn: `function`, ctx: `Object`, ...params: `*`): `Promise<*>`**<br />
+  Returns a promise from a node-style callback function.
+
+**License:** [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)

package/node_modules/{protobufjs/src/util/aspromise.d.ts → @protobufjs/aspromise/index.d.ts}

@@ -1,13 +1,13 @@
-export = asPromise;
-
-type asPromiseCallback = (error: Error | null, ...params: any[]) => {};
-
-/**
- * Returns a promise from a node-style callback function.
- * @memberof util
- * @param {asPromiseCallback} fn Function to call
- * @param {*} ctx Function context
- * @param {...*} params Function arguments
- * @returns {Promise<*>} Promisified function
- */
-declare function asPromise(fn: asPromiseCallback, ctx: any, ...params: any[]): Promise<any>;
+export = asPromise;
+
+type asPromiseCallback = (error: Error | null, ...params: any[]) => {};
+
+/**
+ * Returns a promise from a node-style callback function.
+ * @memberof util
+ * @param {asPromiseCallback} fn Function to call
+ * @param {*} ctx Function context
+ * @param {...*} params Function arguments
+ * @returns {Promise<*>} Promisified function
+ */
+declare function asPromise(fn: asPromiseCallback, ctx: any, ...params: any[]): Promise<any>;

package/node_modules/{protobufjs/src/util/aspromise.js → @protobufjs/aspromise/index.js}

@@ -1,52 +1,52 @@
-"use strict";
-module.exports = asPromise;
-
-/**
- * Callback as used by {@link util.asPromise}.
- * @typedef asPromiseCallback
- * @type {function}
- * @param {Error|null} error Error, if any
- * @param {...*} params Additional arguments
- * @returns {undefined}
- */
-
-/**
- * Returns a promise from a node-style callback function.
- * @memberof util
- * @param {asPromiseCallback} fn Function to call
- * @param {*} ctx Function context
- * @param {...*} params Function arguments
- * @returns {Promise<*>} Promisified function
- */
-function asPromise(fn, ctx/*, varargs */) {
-    var params  = new Array(arguments.length - 1),
-        offset  = 0,
-        index   = 2,
-        pending = true;
-    while (index < arguments.length)
-        params[offset++] = arguments[index++];
-    return new Promise(function executor(resolve, reject) {
-        params[offset] = function callback(err/*, varargs */) {
-            if (pending) {
-                pending = false;
-                if (err)
-                    reject(err);
-                else {
-                    var params = new Array(arguments.length - 1),
-                        offset = 0;
-                    while (offset < params.length)
-                        params[offset++] = arguments[offset];
-                    resolve.apply(null, params);
-                }
-            }
-        };
-        try {
-            fn.apply(ctx || null, params);
-        } catch (err) {
-            if (pending) {
-                pending = false;
-                reject(err);
-            }
-        }
-    });
-}
+"use strict";
+module.exports = asPromise;
+
+/**
+ * Callback as used by {@link util.asPromise}.
+ * @typedef asPromiseCallback
+ * @type {function}
+ * @param {Error|null} error Error, if any
+ * @param {...*} params Additional arguments
+ * @returns {undefined}
+ */
+
+/**
+ * Returns a promise from a node-style callback function.
+ * @memberof util
+ * @param {asPromiseCallback} fn Function to call
+ * @param {*} ctx Function context
+ * @param {...*} params Function arguments
+ * @returns {Promise<*>} Promisified function
+ */
+function asPromise(fn, ctx/*, varargs */) {
+    var params  = new Array(arguments.length - 1),
+        offset  = 0,
+        index   = 2,
+        pending = true;
+    while (index < arguments.length)
+        params[offset++] = arguments[index++];
+    return new Promise(function executor(resolve, reject) {
+        params[offset] = function callback(err/*, varargs */) {
+            if (pending) {
+                pending = false;
+                if (err)
+                    reject(err);
+                else {
+                    var params = new Array(arguments.length - 1),
+                        offset = 0;
+                    while (offset < params.length)
+                        params[offset++] = arguments[offset];
+                    resolve.apply(null, params);
+                }
+            }
+        };
+        try {
+            fn.apply(ctx || null, params);
+        } catch (err) {
+            if (pending) {
+                pending = false;
+                reject(err);
+            }
+        }
+    });
+}

package/node_modules/@protobufjs/aspromise/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@protobufjs/aspromise",
+  "description": "Returns a promise from a node-style callback function.",
+  "version": "1.1.2",
+  "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dcodeIO/protobuf.js.git"
+  },
+  "license": "BSD-3-Clause",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "devDependencies": {
+    "istanbul": "^0.4.5",
+    "tape": "^4.6.3"
+  },
+  "scripts": {
+    "test": "tape tests/*.js",
+    "coverage": "istanbul cover node_modules/tape/bin/tape tests/*.js"
+  }
+}

package/node_modules/@protobufjs/aspromise/tests/index.js

@@ -0,0 +1,130 @@
+var tape = require("tape");
+
+var asPromise = require("..");
+
+tape.test("aspromise", function(test) {
+
+    test.test(this.name + " - resolve", function(test) {
+
+        function fn(arg1, arg2, callback) {
+            test.equal(this, ctx, "function should be called with this = ctx");
+            test.equal(arg1, 1, "function should be called with arg1 = 1");
+            test.equal(arg2, 2, "function should be called with arg2 = 2");
+            callback(null, arg2);
+        }
+
+        var ctx = {};
+
+        var promise = asPromise(fn, ctx, 1, 2);
+        promise.then(function(arg2) {
+            test.equal(arg2, 2, "promise should be resolved with arg2 = 2");
+            test.end();
+        }).catch(function(err) {
+            test.fail("promise should not be rejected (" + err + ")");
+        });
+    });
+
+    test.test(this.name + " - reject", function(test) {
+
+        function fn(arg1, arg2, callback) {
+            test.equal(this, ctx, "function should be called with this = ctx");
+            test.equal(arg1, 1, "function should be called with arg1 = 1");
+            test.equal(arg2, 2, "function should be called with arg2 = 2");
+            callback(arg1);
+        }
+
+        var ctx = {};
+
+        var promise = asPromise(fn, ctx, 1, 2);
+        promise.then(function() {
+            test.fail("promise should not be resolved");
+        }).catch(function(err) {
+            test.equal(err, 1, "promise should be rejected with err = 1");
+            test.end();
+        });
+    });
+
+    test.test(this.name + " - resolve twice", function(test) {
+
+        function fn(arg1, arg2, callback) {
+            test.equal(this, ctx, "function should be called with this = ctx");
+            test.equal(arg1, 1, "function should be called with arg1 = 1");
+            test.equal(arg2, 2, "function should be called with arg2 = 2");
+            callback(null, arg2);
+            callback(null, arg1);
+        }
+
+        var ctx = {};
+        var count = 0;
+
+        var promise = asPromise(fn, ctx, 1, 2);
+        promise.then(function(arg2) {
+            test.equal(arg2, 2, "promise should be resolved with arg2 = 2");
+            if (++count > 1)
+                test.fail("promise should not be resolved twice");
+            test.end();
+        }).catch(function(err) {
+            test.fail("promise should not be rejected (" + err + ")");
+        });
+    });
+
+    test.test(this.name + " - reject twice", function(test) {
+
+        function fn(arg1, arg2, callback) {
+            test.equal(this, ctx, "function should be called with this = ctx");
+            test.equal(arg1, 1, "function should be called with arg1 = 1");
+            test.equal(arg2, 2, "function should be called with arg2 = 2");
+            callback(arg1);
+            callback(arg2);
+        }
+
+        var ctx = {};
+        var count = 0;
+
+        var promise = asPromise(fn, ctx, 1, 2);
+        promise.then(function() {
+            test.fail("promise should not be resolved");
+        }).catch(function(err) {
+            test.equal(err, 1, "promise should be rejected with err = 1");
+            if (++count > 1)
+                test.fail("promise should not be rejected twice");
+            test.end();
+        });
+    });
+
+    test.test(this.name + " - reject error", function(test) {
+
+        function fn(callback) {
+            test.ok(arguments.length === 1 && typeof callback === "function", "function should be called with just a callback");
+            throw 3;
+        }
+
+        var promise = asPromise(fn, null);
+        promise.then(function() {
+            test.fail("promise should not be resolved");
+        }).catch(function(err) {
+            test.equal(err, 3, "promise should be rejected with err = 3");
+            test.end();
+        });
+    });
+
+    test.test(this.name + " - reject and error", function(test) {
+
+        function fn(callback) {
+            callback(3);
+            throw 4;
+        }
+
+        var count = 0;
+
+        var promise = asPromise(fn, null);
+        promise.then(function() {
+            test.fail("promise should not be resolved");
+        }).catch(function(err) {
+            test.equal(err, 3, "promise should be rejected with err = 3");
+            if (++count > 1)
+                test.fail("promise should not be rejected twice");
+            test.end();
+        });
+    });
+});

package/node_modules/@protobufjs/base64/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2016, Daniel Wirtz  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of its author, nor the names of its contributors
+  may be used to endorse or promote products derived from this software
+  without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/node_modules/@protobufjs/base64/README.md

@@ -0,0 +1,19 @@
+@protobufjs/base64
+==================
+[![npm](https://img.shields.io/npm/v/@protobufjs/base64.svg)](https://www.npmjs.com/package/@protobufjs/base64)
+
+A minimal base64 implementation for number arrays.
+
+API
+---
+
+* **base64.length(string: `string`): `number`**<br />
+  Calculates the byte length of a base64 encoded string.
+
+* **base64.encode(buffer: `Uint8Array`, start: `number`, end: `number`): `string`**<br />
+  Encodes a buffer to a base64 encoded string.
+
+* **base64.decode(string: `string`, buffer: `Uint8Array`, offset: `number`): `number`**<br />
+  Decodes a base64 encoded string to a buffer.
+
+**License:** [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)

package/node_modules/{protobufjs/src/util/base64.d.ts → @protobufjs/base64/index.d.ts}

@@ -1,32 +1,32 @@
-/**
- * Calculates the byte length of a base64 encoded string.
- * @param {string} string Base64 encoded string
- * @returns {number} Byte length
- */
-export function length(string: string): number;
-
-/**
- * Encodes a buffer to a base64 encoded string.
- * @param {Uint8Array} buffer Source buffer
- * @param {number} start Source start
- * @param {number} end Source end
- * @returns {string} Base64 encoded string
- */
-export function encode(buffer: Uint8Array, start: number, end: number): string;
-
-/**
- * Decodes a base64 encoded string to a buffer.
- * @param {string} string Source string
- * @param {Uint8Array} buffer Destination buffer
- * @param {number} offset Destination offset
- * @returns {number} Number of bytes written
- * @throws {Error} If encoding is invalid
- */
-export function decode(string: string, buffer: Uint8Array, offset: number): number;
-
-/**
- * Tests if the specified string appears to be base64 encoded.
- * @param {string} string String to test
- * @returns {boolean} `true` if it appears to be base64 encoded, otherwise false
- */
-export function test(string: string): boolean;
+/**
+ * Calculates the byte length of a base64 encoded string.
+ * @param {string} string Base64 encoded string
+ * @returns {number} Byte length
+ */
+export function length(string: string): number;
+
+/**
+ * Encodes a buffer to a base64 encoded string.
+ * @param {Uint8Array} buffer Source buffer
+ * @param {number} start Source start
+ * @param {number} end Source end
+ * @returns {string} Base64 encoded string
+ */
+export function encode(buffer: Uint8Array, start: number, end: number): string;
+
+/**
+ * Decodes a base64 encoded string to a buffer.
+ * @param {string} string Source string
+ * @param {Uint8Array} buffer Destination buffer
+ * @param {number} offset Destination offset
+ * @returns {number} Number of bytes written
+ * @throws {Error} If encoding is invalid
+ */
+export function decode(string: string, buffer: Uint8Array, offset: number): number;
+
+/**
+ * Tests if the specified string appears to be base64 encoded.
+ * @param {string} string String to test
+ * @returns {boolean} `true` if it appears to be base64 encoded, otherwise false
+ */
+export function test(string: string): boolean;