@nextclaw/channel-plugin-feishu 0.2.29-beta.0 → 0.2.29-beta.1

package/dist/src/media.js

@@ -0,0 +1,304 @@
+import { withTempDownloadPath } from "./nextclaw-sdk/network-fetch.js";
+import "./nextclaw-sdk/feishu.js";
+import { resolveFeishuAccount } from "./accounts.js";
+import { createFeishuClient } from "./client.js";
+import { normalizeFeishuExternalKey } from "./external-keys.js";
+import { getFeishuRuntime } from "./runtime.js";
+import { assertFeishuMessageApiSuccess, toFeishuSendResult } from "./send-result.js";
+import { resolveFeishuSendTarget } from "./send-target.js";
+import fs from "fs";
+import path from "path";
+//#region src/media.ts
+const FEISHU_MEDIA_HTTP_TIMEOUT_MS = 12e4;
+function createConfiguredFeishuMediaClient(params) {
+	const account = resolveFeishuAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	if (!account.configured) throw new Error(`Feishu account "${account.accountId}" not configured`);
+	return {
+		account,
+		client: createFeishuClient({
+			...account,
+			httpTimeoutMs: FEISHU_MEDIA_HTTP_TIMEOUT_MS
+		})
+	};
+}
+function extractFeishuUploadKey(response, params) {
+	const responseAny = response;
+	if (responseAny.code !== void 0 && responseAny.code !== 0) throw new Error(`${params.errorPrefix}: ${responseAny.msg || `code ${responseAny.code}`}`);
+	const key = responseAny[params.key] ?? responseAny.data?.[params.key];
+	if (!key) throw new Error(`${params.errorPrefix}: no ${params.key} returned`);
+	return key;
+}
+async function readFeishuResponseBuffer(params) {
+	const { response } = params;
+	const responseAny = response;
+	if (responseAny.code !== void 0 && responseAny.code !== 0) throw new Error(`${params.errorPrefix}: ${responseAny.msg || `code ${responseAny.code}`}`);
+	if (Buffer.isBuffer(response)) return response;
+	if (response instanceof ArrayBuffer) return Buffer.from(response);
+	if (responseAny.data && Buffer.isBuffer(responseAny.data)) return responseAny.data;
+	if (responseAny.data instanceof ArrayBuffer) return Buffer.from(responseAny.data);
+	if (typeof responseAny.getReadableStream === "function") {
+		const stream = responseAny.getReadableStream();
+		const chunks = [];
+		for await (const chunk of stream) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+		return Buffer.concat(chunks);
+	}
+	if (typeof responseAny.writeFile === "function") return await withTempDownloadPath({ prefix: params.tmpDirPrefix }, async (tmpPath) => {
+		await responseAny.writeFile(tmpPath);
+		return await fs.promises.readFile(tmpPath);
+	});
+	if (typeof responseAny[Symbol.asyncIterator] === "function") {
+		const chunks = [];
+		for await (const chunk of responseAny) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+		return Buffer.concat(chunks);
+	}
+	if (typeof responseAny.read === "function") {
+		const chunks = [];
+		for await (const chunk of responseAny) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+		return Buffer.concat(chunks);
+	}
+	const types = Object.keys(responseAny).map((k) => `${k}: ${typeof responseAny[k]}`).join(", ");
+	throw new Error(`${params.errorPrefix}: unexpected response format. Keys: [${types}]`);
+}
+/**
+* Download a message resource (file/image/audio/video) from Feishu.
+* Used for downloading files, audio, and video from messages.
+*/
+async function downloadMessageResourceFeishu(params) {
+	const { cfg, messageId, fileKey, type, accountId } = params;
+	const normalizedFileKey = normalizeFeishuExternalKey(fileKey);
+	if (!normalizedFileKey) throw new Error("Feishu message resource download failed: invalid file_key");
+	const { client } = createConfiguredFeishuMediaClient({
+		cfg,
+		accountId
+	});
+	return { buffer: await readFeishuResponseBuffer({
+		response: await client.im.messageResource.get({
+			path: {
+				message_id: messageId,
+				file_key: normalizedFileKey
+			},
+			params: { type }
+		}),
+		tmpDirPrefix: "openclaw-feishu-resource-",
+		errorPrefix: "Feishu message resource download failed"
+	}) };
+}
+/**
+* Upload an image to Feishu and get an image_key for sending.
+* Supports: JPEG, PNG, WEBP, GIF, TIFF, BMP, ICO
+*/
+async function uploadImageFeishu(params) {
+	const { cfg, image, imageType = "message", accountId } = params;
+	const { client } = createConfiguredFeishuMediaClient({
+		cfg,
+		accountId
+	});
+	const imageData = typeof image === "string" ? fs.createReadStream(image) : image;
+	return { imageKey: extractFeishuUploadKey(await client.im.image.create({ data: {
+		image_type: imageType,
+		image: imageData
+	} }), {
+		key: "image_key",
+		errorPrefix: "Feishu image upload failed"
+	}) };
+}
+/**
+* Sanitize a filename for safe use in Feishu multipart/form-data uploads.
+* Strips control characters and multipart-injection vectors (CWE-93) while
+* preserving the original UTF-8 display name (Chinese, emoji, etc.).
+*
+* Previous versions percent-encoded non-ASCII characters, but the Feishu
+* `im.file.create` API uses `file_name` as a literal display name — it does
+* NOT decode percent-encoding — so encoded filenames appeared as garbled text
+* in chat (regression in v2026.3.2).
+*/
+function sanitizeFileNameForUpload(fileName) {
+	return fileName.replace(/[\x00-\x1F\x7F\r\n"\\]/g, "_");
+}
+/**
+* Upload a file to Feishu and get a file_key for sending.
+* Max file size: 30MB
+*/
+async function uploadFileFeishu(params) {
+	const { cfg, file, fileName, fileType, duration, accountId } = params;
+	const { client } = createConfiguredFeishuMediaClient({
+		cfg,
+		accountId
+	});
+	const fileData = typeof file === "string" ? fs.createReadStream(file) : file;
+	const safeFileName = sanitizeFileNameForUpload(fileName);
+	return { fileKey: extractFeishuUploadKey(await client.im.file.create({ data: {
+		file_type: fileType,
+		file_name: safeFileName,
+		file: fileData,
+		...duration !== void 0 && { duration }
+	} }), {
+		key: "file_key",
+		errorPrefix: "Feishu file upload failed"
+	}) };
+}
+/**
+* Send an image message using an image_key
+*/
+async function sendImageFeishu(params) {
+	const { cfg, to, imageKey, replyToMessageId, replyInThread, accountId } = params;
+	const { client, receiveId, receiveIdType } = resolveFeishuSendTarget({
+		cfg,
+		to,
+		accountId
+	});
+	const content = JSON.stringify({ image_key: imageKey });
+	if (replyToMessageId) {
+		const response = await client.im.message.reply({
+			path: { message_id: replyToMessageId },
+			data: {
+				content,
+				msg_type: "image",
+				...replyInThread ? { reply_in_thread: true } : {}
+			}
+		});
+		assertFeishuMessageApiSuccess(response, "Feishu image reply failed");
+		return toFeishuSendResult(response, receiveId);
+	}
+	const response = await client.im.message.create({
+		params: { receive_id_type: receiveIdType },
+		data: {
+			receive_id: receiveId,
+			content,
+			msg_type: "image"
+		}
+	});
+	assertFeishuMessageApiSuccess(response, "Feishu image send failed");
+	return toFeishuSendResult(response, receiveId);
+}
+/**
+* Send a file message using a file_key
+*/
+async function sendFileFeishu(params) {
+	const { cfg, to, fileKey, replyToMessageId, replyInThread, accountId } = params;
+	const msgType = params.msgType ?? "file";
+	const { client, receiveId, receiveIdType } = resolveFeishuSendTarget({
+		cfg,
+		to,
+		accountId
+	});
+	const content = JSON.stringify({ file_key: fileKey });
+	if (replyToMessageId) {
+		const response = await client.im.message.reply({
+			path: { message_id: replyToMessageId },
+			data: {
+				content,
+				msg_type: msgType,
+				...replyInThread ? { reply_in_thread: true } : {}
+			}
+		});
+		assertFeishuMessageApiSuccess(response, "Feishu file reply failed");
+		return toFeishuSendResult(response, receiveId);
+	}
+	const response = await client.im.message.create({
+		params: { receive_id_type: receiveIdType },
+		data: {
+			receive_id: receiveId,
+			content,
+			msg_type: msgType
+		}
+	});
+	assertFeishuMessageApiSuccess(response, "Feishu file send failed");
+	return toFeishuSendResult(response, receiveId);
+}
+/**
+* Helper to detect file type from extension
+*/
+function detectFileType(fileName) {
+	switch (path.extname(fileName).toLowerCase()) {
+		case ".opus":
+		case ".ogg": return "opus";
+		case ".mp4":
+		case ".mov":
+		case ".avi": return "mp4";
+		case ".pdf": return "pdf";
+		case ".doc":
+		case ".docx": return "doc";
+		case ".xls":
+		case ".xlsx": return "xls";
+		case ".ppt":
+		case ".pptx": return "ppt";
+		default: return "stream";
+	}
+}
+/**
+* Upload and send media (image or file) from URL, local path, or buffer.
+* When mediaUrl is a local path, mediaLocalRoots (from core outbound context)
+* must be passed so loadWebMedia allows the path (post CVE-2026-26321).
+*/
+async function sendMediaFeishu(params) {
+	const { cfg, to, mediaUrl, mediaBuffer, fileName, replyToMessageId, replyInThread, accountId, mediaLocalRoots } = params;
+	const account = resolveFeishuAccount({
+		cfg,
+		accountId
+	});
+	if (!account.configured) throw new Error(`Feishu account "${account.accountId}" not configured`);
+	const mediaMaxBytes = (account.config?.mediaMaxMb ?? 30) * 1024 * 1024;
+	let buffer;
+	let name;
+	if (mediaBuffer) {
+		buffer = mediaBuffer;
+		name = fileName ?? "file";
+	} else if (mediaUrl) {
+		const loaded = await getFeishuRuntime().media.loadWebMedia(mediaUrl, {
+			maxBytes: mediaMaxBytes,
+			optimizeImages: false,
+			localRoots: mediaLocalRoots?.length ? mediaLocalRoots : void 0
+		});
+		buffer = loaded.buffer;
+		name = fileName ?? loaded.fileName ?? "file";
+	} else throw new Error("Either mediaUrl or mediaBuffer must be provided");
+	const ext = path.extname(name).toLowerCase();
+	if ([
+		".jpg",
+		".jpeg",
+		".png",
+		".gif",
+		".webp",
+		".bmp",
+		".ico",
+		".tiff"
+	].includes(ext)) {
+		const { imageKey } = await uploadImageFeishu({
+			cfg,
+			image: buffer,
+			accountId
+		});
+		return sendImageFeishu({
+			cfg,
+			to,
+			imageKey,
+			replyToMessageId,
+			replyInThread,
+			accountId
+		});
+	} else {
+		const fileType = detectFileType(name);
+		const { fileKey } = await uploadFileFeishu({
+			cfg,
+			file: buffer,
+			fileName: name,
+			fileType,
+			accountId
+		});
+		return sendFileFeishu({
+			cfg,
+			to,
+			fileKey,
+			msgType: fileType === "opus" ? "audio" : fileType === "mp4" ? "media" : "file",
+			replyToMessageId,
+			replyInThread,
+			accountId
+		});
+	}
+}
+//#endregion
+export { downloadMessageResourceFeishu, sendFileFeishu, sendImageFeishu, sendMediaFeishu, uploadFileFeishu, uploadImageFeishu };

package/dist/src/mention.d.ts

@@ -0,0 +1,52 @@
+import { FeishuMessageEvent } from "./bot.js";
+
+//#region src/mention.d.ts
+/**
+ * Mention target user info
+ */
+type MentionTarget = {
+  openId: string;
+  name: string;
+  key: string;
+};
+/**
+ * Extract mention targets from message event (excluding the bot itself)
+ */
+declare function extractMentionTargets(event: FeishuMessageEvent, botOpenId?: string): MentionTarget[];
+/**
+ * Check if message is a mention forward request
+ * Rules:
+ * - Group: message mentions bot + at least one other user
+ * - DM: message mentions any user (no need to mention bot)
+ */
+declare function isMentionForwardRequest(event: FeishuMessageEvent, botOpenId?: string): boolean;
+/**
+ * Extract message body from text (remove @ placeholders)
+ */
+declare function extractMessageBody(text: string, allMentionKeys: string[]): string;
+/**
+ * Format @mention for text message
+ */
+declare function formatMentionForText(target: MentionTarget): string;
+/**
+ * Format @everyone for text message
+ */
+declare function formatMentionAllForText(): string;
+/**
+ * Format @mention for card message (lark_md)
+ */
+declare function formatMentionForCard(target: MentionTarget): string;
+/**
+ * Format @everyone for card message
+ */
+declare function formatMentionAllForCard(): string;
+/**
+ * Build complete message with @mentions (text format)
+ */
+declare function buildMentionedMessage(targets: MentionTarget[], message: string): string;
+/**
+ * Build card content with @mentions (Markdown format)
+ */
+declare function buildMentionedCardContent(targets: MentionTarget[], message: string): string;
+//#endregion
+export { MentionTarget, buildMentionedCardContent, buildMentionedMessage, extractMentionTargets, extractMessageBody, formatMentionAllForCard, formatMentionAllForText, formatMentionForCard, formatMentionForText, isMentionForwardRequest };

package/dist/src/mention.js

@@ -0,0 +1,82 @@
+//#region src/mention.ts
+/**
+* Escape regex metacharacters so user-controlled mention fields are treated literally.
+*/
+function escapeRegExp(input) {
+	return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+* Extract mention targets from message event (excluding the bot itself)
+*/
+function extractMentionTargets(event, botOpenId) {
+	return (event.message.mentions ?? []).filter((m) => {
+		if (botOpenId && m.id.open_id === botOpenId) return false;
+		return !!m.id.open_id;
+	}).map((m) => ({
+		openId: m.id.open_id,
+		name: m.name,
+		key: m.key
+	}));
+}
+/**
+* Check if message is a mention forward request
+* Rules:
+* - Group: message mentions bot + at least one other user
+* - DM: message mentions any user (no need to mention bot)
+*/
+function isMentionForwardRequest(event, botOpenId) {
+	const mentions = event.message.mentions ?? [];
+	if (mentions.length === 0) return false;
+	const isDirectMessage = event.message.chat_type !== "group";
+	const hasOtherMention = mentions.some((m) => m.id.open_id !== botOpenId);
+	if (isDirectMessage) return hasOtherMention;
+	else return mentions.some((m) => m.id.open_id === botOpenId) && hasOtherMention;
+}
+/**
+* Extract message body from text (remove @ placeholders)
+*/
+function extractMessageBody(text, allMentionKeys) {
+	let result = text;
+	for (const key of allMentionKeys) result = result.replace(new RegExp(escapeRegExp(key), "g"), "");
+	return result.replace(/\s+/g, " ").trim();
+}
+/**
+* Format @mention for text message
+*/
+function formatMentionForText(target) {
+	return `<at user_id="${target.openId}">${target.name}</at>`;
+}
+/**
+* Format @everyone for text message
+*/
+function formatMentionAllForText() {
+	return `<at user_id="all">Everyone</at>`;
+}
+/**
+* Format @mention for card message (lark_md)
+*/
+function formatMentionForCard(target) {
+	return `<at id=${target.openId}></at>`;
+}
+/**
+* Format @everyone for card message
+*/
+function formatMentionAllForCard() {
+	return `<at id=all></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) {
+	if (targets.length === 0) return message;
+	return `${targets.map((t) => formatMentionForCard(t)).join(" ")} ${message}`;
+}
+//#endregion
+export { buildMentionedCardContent, buildMentionedMessage, extractMentionTargets, extractMessageBody, formatMentionAllForCard, formatMentionAllForText, formatMentionForCard, formatMentionForText, isMentionForwardRequest };

package/dist/src/monitor.account.d.ts

@@ -0,0 +1 @@
+export { };