@openclaw/feishu 2026.7.2-beta.7 → 2026.7.34

package/dist/.setup/send-result-COI_ANtb.mjs

@@ -0,0 +1,287 @@
+import { d as isRecord$1 } from "./accounts-CfuPSCip.mjs";
+import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
+import { isRecord, normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/feishu/src/card-interaction.ts
+const FEISHU_CARD_INTERACTION_VERSION = "ocf1";
+function isInteractionKind(value) {
+	return value === "button" || value === "quick" || value === "meta";
+}
+function isMetadataValue(value) {
+	return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function createFeishuCardInteractionEnvelope(envelope) {
+	return {
+		oc: FEISHU_CARD_INTERACTION_VERSION,
+		...envelope
+	};
+}
+function buildFeishuCardActionTextFallback(event) {
+	const actionValue = event.action.value;
+	if (isRecord$1(actionValue)) {
+		if (typeof actionValue.text === "string") return actionValue.text;
+		if (typeof actionValue.command === "string") return actionValue.command;
+		return JSON.stringify(actionValue);
+	}
+	return String(actionValue);
+}
+function decodeFeishuCardAction(params) {
+	const { event, now = Date.now() } = params;
+	const actionValue = event.action.value;
+	if (!isRecord$1(actionValue) || actionValue.oc !== "ocf1") return {
+		kind: "legacy",
+		text: buildFeishuCardActionTextFallback(event)
+	};
+	if (!isInteractionKind(actionValue.k) || typeof actionValue.a !== "string" || !actionValue.a) return {
+		kind: "invalid",
+		reason: "malformed"
+	};
+	if (actionValue.q !== void 0 && typeof actionValue.q !== "string") return {
+		kind: "invalid",
+		reason: "malformed"
+	};
+	if (actionValue.m !== void 0) {
+		if (!isRecord$1(actionValue.m)) return {
+			kind: "invalid",
+			reason: "malformed"
+		};
+		for (const value of Object.values(actionValue.m)) if (!isMetadataValue(value)) return {
+			kind: "invalid",
+			reason: "malformed"
+		};
+	}
+	if (actionValue.c !== void 0) {
+		if (!isRecord$1(actionValue.c)) return {
+			kind: "invalid",
+			reason: "malformed"
+		};
+		if (actionValue.c.u !== void 0 && typeof actionValue.c.u !== "string") return {
+			kind: "invalid",
+			reason: "malformed"
+		};
+		if (actionValue.c.h !== void 0 && typeof actionValue.c.h !== "string") return {
+			kind: "invalid",
+			reason: "malformed"
+		};
+		if (actionValue.c.s !== void 0 && typeof actionValue.c.s !== "string") return {
+			kind: "invalid",
+			reason: "malformed"
+		};
+		if (actionValue.c.e !== void 0 && !Number.isFinite(actionValue.c.e)) return {
+			kind: "invalid",
+			reason: "malformed"
+		};
+		if (actionValue.c.t !== void 0 && actionValue.c.t !== "p2p" && actionValue.c.t !== "group") return {
+			kind: "invalid",
+			reason: "malformed"
+		};
+		if (typeof actionValue.c.e === "number" && actionValue.c.e < now) return {
+			kind: "invalid",
+			reason: "stale"
+		};
+		const expectedUser = actionValue.c.u?.trim();
+		if (expectedUser && expectedUser !== (event.operator.open_id ?? "").trim()) return {
+			kind: "invalid",
+			reason: "wrong_user"
+		};
+		const expectedChat = actionValue.c.h?.trim();
+		if (expectedChat && expectedChat !== (event.context.chat_id ?? "").trim()) return {
+			kind: "invalid",
+			reason: "wrong_conversation"
+		};
+	}
+	return {
+		kind: "structured",
+		envelope: actionValue
+	};
+}
+//#endregion
+//#region extensions/feishu/src/native-card.ts
+const FEISHU_CARD_TEMPLATES = /* @__PURE__ */ new Set([
+	"blue",
+	"green",
+	"red",
+	"orange",
+	"purple",
+	"indigo",
+	"wathet",
+	"turquoise",
+	"yellow",
+	"grey",
+	"carmine",
+	"violet",
+	"lime"
+]);
+function resolveFeishuCardTemplate(template) {
+	const normalized = normalizeOptionalLowercaseString(template);
+	if (!normalized || !FEISHU_CARD_TEMPLATES.has(normalized)) return;
+	return normalized;
+}
+function escapeFeishuCardMarkdownText(text) {
+	return text.replace(/[&<>]/g, (char) => {
+		switch (char) {
+			case "&": return "&amp;";
+			case "<": return "&lt;";
+			case ">": return "&gt;";
+			default: return char;
+		}
+	});
+}
+function escapeFeishuCardPlainText(text) {
+	return escapeFeishuCardMarkdownText(text).replace(/([\\`*_{}[\]()#+\-!|>~])/g, "\\$1");
+}
+function resolveSafeFeishuButtonUrl(url) {
+	const trimmed = typeof url === "string" ? url.trim() : "";
+	if (!trimmed) return;
+	try {
+		const parsed = new URL(trimmed);
+		return parsed.protocol === "https:" || parsed.protocol === "http:" ? trimmed : void 0;
+	} catch {
+		return;
+	}
+}
+function sanitizeNativeFeishuButtonBehavior(behavior) {
+	if (!isRecord(behavior)) return;
+	if (behavior.type === "open_url") {
+		const safeUrl = resolveSafeFeishuButtonUrl(behavior.default_url) ?? resolveSafeFeishuButtonUrl(behavior.url);
+		return safeUrl ? {
+			type: "open_url",
+			default_url: safeUrl
+		} : void 0;
+	}
+	if (behavior.type === "callback" && isRecord(behavior.value) && behavior.value.oc === "ocf1") return {
+		type: "callback",
+		value: behavior.value
+	};
+}
+function sanitizeNativeFeishuCardButton(button) {
+	if (!isRecord(button)) return;
+	const text = isRecord(button.text) && typeof button.text.content === "string" ? button.text.content : void 0;
+	if (!text?.trim()) return;
+	const style = button.type === "danger" ? "danger" : button.type === "primary" || button.type === "success" ? "primary" : void 0;
+	const behaviors = Array.isArray(button.behaviors) ? button.behaviors.map((behavior) => sanitizeNativeFeishuButtonBehavior(behavior)).filter((behavior) => Boolean(behavior)) : [];
+	const rootSafeUrl = resolveSafeFeishuButtonUrl(button.url);
+	if (rootSafeUrl) behaviors.push({
+		type: "open_url",
+		default_url: rootSafeUrl
+	});
+	if (isRecord(button.value) && button.value.oc === "ocf1") behaviors.push({
+		type: "callback",
+		value: button.value
+	});
+	if (behaviors.length === 0) return;
+	return {
+		tag: "button",
+		text: {
+			tag: "plain_text",
+			content: text
+		},
+		type: style === "danger" ? "danger" : style === "primary" ? "primary" : "default",
+		behaviors
+	};
+}
+function sanitizeNativeFeishuCardElements(element) {
+	if (!isRecord(element) || typeof element.tag !== "string") return [];
+	if (element.tag === "hr") return [{ tag: "hr" }];
+	if (element.tag === "markdown" && typeof element.content === "string") return [{
+		tag: "markdown",
+		content: escapeFeishuCardMarkdownText(element.content)
+	}];
+	if (element.tag === "div" && isRecord(element.text)) {
+		const text = element.text;
+		if (text.tag === "lark_md" && typeof text.content === "string") return [{
+			tag: "markdown",
+			content: escapeFeishuCardMarkdownText(text.content)
+		}];
+		if (text.tag === "plain_text" && typeof text.content === "string") return [{
+			tag: "markdown",
+			content: escapeFeishuCardPlainText(text.content)
+		}];
+		return [];
+	}
+	if (element.tag === "button") {
+		const button = sanitizeNativeFeishuCardButton(element);
+		return button ? [button] : [];
+	}
+	if (element.tag === "action" && Array.isArray(element.actions)) return element.actions.map((action) => sanitizeNativeFeishuCardButton(action)).filter((action) => Boolean(action));
+	return [];
+}
+function sanitizeNativeFeishuCard(card) {
+	const normalizedCard = card.type === "interactive" && isRecord(card.card) ? card.card : card;
+	const body = isRecord(normalizedCard.body) ? normalizedCard.body : void 0;
+	const elements = (Array.isArray(body?.elements) ? body.elements : Array.isArray(normalizedCard.elements) ? normalizedCard.elements : []).flatMap((element) => sanitizeNativeFeishuCardElements(element)).filter((element) => Boolean(element));
+	if (elements.length === 0) return;
+	const header = isRecord(normalizedCard.header) ? normalizedCard.header : void 0;
+	const title = isRecord(header?.title) && typeof header.title.content === "string" ? header.title.content : void 0;
+	return {
+		schema: "2.0",
+		config: { width_mode: "fill" },
+		...title?.trim() ? { header: {
+			title: {
+				tag: "plain_text",
+				content: title
+			},
+			template: resolveFeishuCardTemplate(typeof header?.template === "string" ? header.template : void 0) ?? "blue"
+		} } : {},
+		body: { elements }
+	};
+}
+function readNativeFeishuCardJson(text, options) {
+	let trimmed = text?.trim();
+	const responsePrefix = options?.responsePrefix;
+	if (trimmed && responsePrefix && trimmed.startsWith(responsePrefix)) {
+		const suffix = trimmed.slice(responsePrefix.length);
+		if (/^\s+\{/.test(suffix)) trimmed = suffix.trimStart();
+	}
+	if (!trimmed?.startsWith("{") || !trimmed.endsWith("}")) return;
+	try {
+		const parsed = JSON.parse(trimmed);
+		return isRecord(parsed) ? sanitizeNativeFeishuCard(parsed) : void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region extensions/feishu/src/send-result.ts
+function resolveFeishuReceiptKind(msgType) {
+	switch (msgType) {
+		case "audio": return "voice";
+		case "image":
+		case "media":
+		case "file": return "media";
+		case "interactive": return "card";
+		case "post":
+		case "text": return "text";
+		default: return "unknown";
+	}
+}
+function createFeishuSendReceipt(params) {
+	const messageId = params.messageId?.trim();
+	const chatId = params.chatId.trim();
+	return createMessageReceiptFromOutboundResults({
+		results: messageId ? [{
+			channel: "feishu",
+			messageId,
+			chatId,
+			conversationId: chatId
+		}] : [],
+		...chatId ? { threadId: chatId } : {},
+		kind: params.kind ?? "unknown"
+	});
+}
+function assertFeishuMessageApiSuccess(response, errorPrefix) {
+	if (response.code !== 0) throw new Error(`${errorPrefix}: ${response.msg || `code ${response.code}`}`);
+}
+function toFeishuSendResult(response, chatId, kind) {
+	const messageId = response.data?.message_id ?? "unknown";
+	return {
+		messageId,
+		chatId,
+		receipt: createFeishuSendReceipt({
+			messageId,
+			chatId,
+			kind
+		})
+	};
+}
+//#endregion
+export { readNativeFeishuCardJson as a, FEISHU_CARD_INTERACTION_VERSION as c, decodeFeishuCardAction as d, toFeishuSendResult as i, buildFeishuCardActionTextFallback as l, createFeishuSendReceipt as n, resolveFeishuCardTemplate as o, resolveFeishuReceiptKind as r, sanitizeNativeFeishuCard as s, assertFeishuMessageApiSuccess as t, createFeishuCardInteractionEnvelope as u };

package/dist/.setup/session-conversation-CWBrUzmY.mjs

@@ -0,0 +1,27 @@
+import { r as parseFeishuConversationId, t as buildFeishuConversationId } from "./conversation-id-CdLdoot3.mjs";
+//#region extensions/feishu/src/session-conversation.ts
+function resolveFeishuParentConversationCandidates(rawId) {
+	const parsed = parseFeishuConversationId({ conversationId: rawId });
+	if (!parsed) return [];
+	switch (parsed.scope) {
+		case "group_topic_sender": return [buildFeishuConversationId({
+			chatId: parsed.chatId,
+			scope: "group_topic",
+			topicId: parsed.topicId
+		}), parsed.chatId];
+		case "group_topic":
+		case "group_sender": return [parsed.chatId];
+		default: return [];
+	}
+}
+function resolveFeishuSessionConversation(params) {
+	const parsed = parseFeishuConversationId({ conversationId: params.rawId });
+	if (!parsed) return null;
+	return {
+		id: parsed.canonicalConversationId,
+		baseConversationId: parsed.chatId,
+		parentConversationCandidates: resolveFeishuParentConversationCandidates(parsed.canonicalConversationId)
+	};
+}
+//#endregion
+export { resolveFeishuSessionConversation as t };

package/dist/.setup/setup-api-DY9H9ISg.mjs

@@ -0,0 +1,3 @@
+import { i as feishuSetupAdapter, n as feishuSetupWizard, t as feishuPlugin } from "./channel-CiFS4inh.mjs";
+import "../setup-api.js";
+export { feishuPlugin, feishuSetupAdapter, feishuSetupWizard };

package/dist/.setup/subagent-hooks-BQhuBlyy.mjs

@@ -0,0 +1,235 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { r as normalizeFeishuTarget } from "./targets-BUjQ1TcA.mjs";
+import { r as parseFeishuConversationId, t as buildFeishuConversationId } from "./conversation-id-CdLdoot3.mjs";
+import { n as getFeishuThreadBindingManager } from "./thread-bindings-V0bwk0A1.mjs";
+import { normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/feishu/src/subagent-hooks.ts
+var subagent_hooks_exports = /* @__PURE__ */ __exportAll({
+	handleFeishuSubagentDeliveryTarget: () => handleFeishuSubagentDeliveryTarget,
+	handleFeishuSubagentEnded: () => handleFeishuSubagentEnded,
+	handleFeishuSubagentSpawning: () => handleFeishuSubagentSpawning
+});
+function summarizeError(err) {
+	if (err instanceof Error) return err.message;
+	if (typeof err === "string") return err;
+	return "error";
+}
+function stripProviderPrefix(raw) {
+	return raw.replace(/^(feishu|lark):/i, "").trim();
+}
+function resolveFeishuRequesterConversation(params) {
+	const manager = getFeishuThreadBindingManager(params.accountId);
+	if (!manager) return null;
+	const rawTo = params.to?.trim();
+	const withoutProviderPrefix = rawTo ? stripProviderPrefix(rawTo) : "";
+	const normalizedTarget = rawTo ? normalizeFeishuTarget(rawTo) : null;
+	const threadId = params.threadId != null && params.threadId !== "" ? String(params.threadId).trim() : "";
+	const isChatTarget = /^(chat|group|channel):/i.test(withoutProviderPrefix);
+	const parsedRequesterTopic = normalizedTarget && threadId && isChatTarget ? parseFeishuConversationId({
+		conversationId: buildFeishuConversationId({
+			chatId: normalizedTarget,
+			scope: "group_topic",
+			topicId: threadId
+		}),
+		parentConversationId: normalizedTarget
+	}) : null;
+	const requesterSessionKey = params.requesterSessionKey?.trim();
+	if (requesterSessionKey) {
+		const existingBindings = manager.listBySessionKey(requesterSessionKey);
+		if (existingBindings.length === 1) {
+			const existing = existingBindings[0];
+			return {
+				accountId: existing.accountId,
+				conversationId: existing.conversationId,
+				parentConversationId: existing.parentConversationId
+			};
+		}
+		if (existingBindings.length > 1) {
+			if (rawTo && normalizedTarget && !threadId && !isChatTarget) {
+				const directMatches = existingBindings.filter((entry) => entry.accountId === manager.accountId && entry.conversationId === normalizedTarget && !entry.parentConversationId);
+				if (directMatches.length === 1) {
+					const existing = directMatches[0];
+					return {
+						accountId: existing.accountId,
+						conversationId: existing.conversationId,
+						parentConversationId: existing.parentConversationId
+					};
+				}
+				return null;
+			}
+			if (parsedRequesterTopic) {
+				const matchingTopicBindings = existingBindings.filter((entry) => {
+					const parsed = parseFeishuConversationId({
+						conversationId: entry.conversationId,
+						parentConversationId: entry.parentConversationId
+					});
+					return parsed?.chatId === parsedRequesterTopic.chatId && parsed?.topicId === parsedRequesterTopic.topicId;
+				});
+				if (matchingTopicBindings.length === 1) {
+					const existing = matchingTopicBindings[0];
+					return {
+						accountId: existing.accountId,
+						conversationId: existing.conversationId,
+						parentConversationId: existing.parentConversationId
+					};
+				}
+				const senderScopedTopicBindings = matchingTopicBindings.filter((entry) => {
+					return parseFeishuConversationId({
+						conversationId: entry.conversationId,
+						parentConversationId: entry.parentConversationId
+					})?.scope === "group_topic_sender";
+				});
+				if (senderScopedTopicBindings.length === 1 && matchingTopicBindings.length === senderScopedTopicBindings.length) {
+					const existing = senderScopedTopicBindings[0];
+					return {
+						accountId: existing.accountId,
+						conversationId: existing.conversationId,
+						parentConversationId: existing.parentConversationId
+					};
+				}
+				return null;
+			}
+		}
+	}
+	if (!rawTo) return null;
+	if (!normalizedTarget) return null;
+	if (threadId) {
+		if (!isChatTarget) return null;
+		return {
+			accountId: manager.accountId,
+			conversationId: buildFeishuConversationId({
+				chatId: normalizedTarget,
+				scope: "group_topic",
+				topicId: threadId
+			}),
+			parentConversationId: normalizedTarget
+		};
+	}
+	if (isChatTarget) return null;
+	return {
+		accountId: manager.accountId,
+		conversationId: normalizedTarget
+	};
+}
+function resolveFeishuDeliveryOrigin(params) {
+	const deliveryTo = params.deliveryTo?.trim();
+	const deliveryThreadId = params.deliveryThreadId?.trim();
+	if (deliveryTo) return {
+		channel: "feishu",
+		accountId: params.accountId,
+		to: deliveryTo,
+		...deliveryThreadId ? { threadId: deliveryThreadId } : {}
+	};
+	const parsed = parseFeishuConversationId({
+		conversationId: params.conversationId,
+		parentConversationId: params.parentConversationId
+	});
+	if (parsed?.topicId) return {
+		channel: "feishu",
+		accountId: params.accountId,
+		to: `chat:${params.parentConversationId?.trim() || parsed.chatId}`,
+		threadId: parsed.topicId
+	};
+	return {
+		channel: "feishu",
+		accountId: params.accountId,
+		to: `user:${params.conversationId}`
+	};
+}
+function resolveMatchingChildBinding(params) {
+	const manager = getFeishuThreadBindingManager(params.accountId);
+	if (!manager) return null;
+	const childBindings = manager.listBySessionKey(params.childSessionKey.trim());
+	if (childBindings.length === 0) return null;
+	const requesterConversation = resolveFeishuRequesterConversation({
+		accountId: manager.accountId,
+		to: params.requesterOrigin?.to,
+		threadId: params.requesterOrigin?.threadId,
+		requesterSessionKey: params.requesterSessionKey
+	});
+	if (requesterConversation) {
+		const matched = childBindings.find((entry) => entry.accountId === requesterConversation.accountId && entry.conversationId === requesterConversation.conversationId && normalizeOptionalString(entry.parentConversationId) === normalizeOptionalString(requesterConversation.parentConversationId));
+		if (matched) return matched;
+	}
+	return childBindings.length === 1 ? childBindings[0] : null;
+}
+async function handleFeishuSubagentSpawning(event, ctx) {
+	if (!event.threadRequested) return;
+	if (normalizeOptionalLowercaseString(event.requester?.channel) !== "feishu") return;
+	const manager = getFeishuThreadBindingManager(event.requester?.accountId);
+	if (!manager) return {
+		status: "error",
+		error: "Feishu current-conversation binding is unavailable because the Feishu account monitor is not active."
+	};
+	const conversation = resolveFeishuRequesterConversation({
+		accountId: event.requester?.accountId,
+		to: event.requester?.to,
+		threadId: event.requester?.threadId,
+		requesterSessionKey: ctx.requesterSessionKey
+	});
+	if (!conversation) return {
+		status: "error",
+		error: "Feishu current-conversation binding is only available in direct messages or topic conversations."
+	};
+	try {
+		const binding = manager.bindConversation({
+			conversationId: conversation.conversationId,
+			parentConversationId: conversation.parentConversationId,
+			targetKind: "subagent",
+			targetSessionKey: event.childSessionKey,
+			metadata: {
+				agentId: event.agentId,
+				label: event.label,
+				boundBy: "system",
+				deliveryTo: event.requester?.to,
+				deliveryThreadId: event.requester?.threadId != null && event.requester.threadId !== "" ? String(event.requester.threadId) : void 0
+			}
+		});
+		if (!binding) return {
+			status: "error",
+			error: "Unable to bind this Feishu conversation to the spawned subagent session. Session mode is unavailable for this target."
+		};
+		return {
+			status: "ok",
+			threadBindingReady: true,
+			deliveryOrigin: resolveFeishuDeliveryOrigin({
+				conversationId: binding.conversationId,
+				parentConversationId: binding.parentConversationId,
+				accountId: binding.accountId,
+				deliveryTo: binding.deliveryTo,
+				deliveryThreadId: binding.deliveryThreadId
+			})
+		};
+	} catch (err) {
+		return {
+			status: "error",
+			error: `Feishu conversation bind failed: ${summarizeError(err)}`
+		};
+	}
+}
+function handleFeishuSubagentDeliveryTarget(event) {
+	if (!event.expectsCompletionMessage) return;
+	if (normalizeOptionalLowercaseString(event.requesterOrigin?.channel) !== "feishu") return;
+	const binding = resolveMatchingChildBinding({
+		accountId: event.requesterOrigin?.accountId,
+		childSessionKey: event.childSessionKey,
+		requesterSessionKey: event.requesterSessionKey,
+		requesterOrigin: {
+			to: event.requesterOrigin?.to,
+			threadId: event.requesterOrigin?.threadId
+		}
+	});
+	if (!binding) return;
+	return { origin: resolveFeishuDeliveryOrigin({
+		conversationId: binding.conversationId,
+		parentConversationId: binding.parentConversationId,
+		accountId: binding.accountId,
+		deliveryTo: binding.deliveryTo,
+		deliveryThreadId: binding.deliveryThreadId
+	}) };
+}
+function handleFeishuSubagentEnded(event) {
+	getFeishuThreadBindingManager(event.accountId)?.unbindBySessionKey(event.targetSessionKey);
+}
+//#endregion
+export { subagent_hooks_exports as i, handleFeishuSubagentEnded as n, handleFeishuSubagentSpawning as r, handleFeishuSubagentDeliveryTarget as t };