@openclaw/feishu 2026.5.2-beta.2 → 2026.5.3-beta.1

package/dist/client-DBVoQL5w.js

@@ -0,0 +1,157 @@
+import { t as __exportAll } from "./rolldown-runtime-DUslC3ob.js";
+import { createRequire } from "node:module";
+import * as Lark from "@larksuiteoapi/node-sdk";
+import { readPluginPackageVersion, resolveAmbientNodeProxyAgent } from "openclaw/plugin-sdk/extension-shared";
+//#region extensions/feishu/src/client-timeout.ts
+/** Default HTTP timeout for Feishu API requests (30 seconds). */
+const FEISHU_HTTP_TIMEOUT_MS = 3e4;
+const FEISHU_HTTP_TIMEOUT_MAX_MS = 3e5;
+const FEISHU_HTTP_TIMEOUT_ENV_VAR = "OPENCLAW_FEISHU_HTTP_TIMEOUT_MS";
+function resolveConfiguredHttpTimeoutMs(creds) {
+	const clampTimeout = (value) => {
+		return Math.min(Math.max(Math.floor(value), 1), FEISHU_HTTP_TIMEOUT_MAX_MS);
+	};
+	const fromDirectField = creds.httpTimeoutMs;
+	if (typeof fromDirectField === "number" && Number.isFinite(fromDirectField) && fromDirectField > 0) return clampTimeout(fromDirectField);
+	const envRaw = process.env[FEISHU_HTTP_TIMEOUT_ENV_VAR];
+	if (envRaw) {
+		const envValue = Number(envRaw);
+		if (Number.isFinite(envValue) && envValue > 0) return clampTimeout(envValue);
+	}
+	const timeout = creds.config?.httpTimeoutMs;
+	if (typeof timeout !== "number" || !Number.isFinite(timeout) || timeout <= 0) return FEISHU_HTTP_TIMEOUT_MS;
+	return clampTimeout(timeout);
+}
+//#endregion
+//#region extensions/feishu/src/client.ts
+var client_exports = /* @__PURE__ */ __exportAll({
+	FEISHU_HTTP_TIMEOUT_ENV_VAR: () => FEISHU_HTTP_TIMEOUT_ENV_VAR,
+	FEISHU_HTTP_TIMEOUT_MAX_MS: () => FEISHU_HTTP_TIMEOUT_MAX_MS,
+	FEISHU_HTTP_TIMEOUT_MS: () => FEISHU_HTTP_TIMEOUT_MS,
+	FEISHU_USER_AGENT: () => FEISHU_USER_AGENT,
+	createEventDispatcher: () => createEventDispatcher,
+	createFeishuClient: () => createFeishuClient,
+	createFeishuWSClient: () => createFeishuWSClient,
+	getFeishuUserAgent: () => getFeishuUserAgent,
+	pluginVersion: () => pluginVersion
+});
+const pluginVersion = readPluginPackageVersion({ require: createRequire(import.meta.url) });
+const FEISHU_USER_AGENT = `openclaw-feishu-builtin/${pluginVersion}/${process.platform}`;
+const FEISHU_WS_CONFIG = {
+	PingInterval: 30,
+	PingTimeout: 3
+};
+/** User-Agent header value for all Feishu API requests. */
+function getFeishuUserAgent() {
+	return FEISHU_USER_AGENT;
+}
+let feishuClientSdk = {
+	AppType: Lark.AppType,
+	Client: Lark.Client,
+	defaultHttpInstance: Lark.defaultHttpInstance,
+	Domain: Lark.Domain,
+	EventDispatcher: Lark.EventDispatcher,
+	LoggerLevel: Lark.LoggerLevel,
+	WSClient: Lark.WSClient
+};
+{
+	const inst = Lark.defaultHttpInstance;
+	if (inst.interceptors?.request) {
+		inst.interceptors.request.handlers = [];
+		inst.interceptors.request.use((req) => {
+			const r = req;
+			if (r.headers) r.headers["User-Agent"] = getFeishuUserAgent();
+			return req;
+		});
+	}
+}
+async function getWsProxyAgent() {
+	return resolveAmbientNodeProxyAgent();
+}
+const clientCache = /* @__PURE__ */ new Map();
+function resolveDomain(domain) {
+	if (domain === "lark") return feishuClientSdk.Domain.Lark;
+	if (domain === "feishu" || !domain) return feishuClientSdk.Domain.Feishu;
+	return domain.replace(/\/+$/, "");
+}
+/**
+* Create an HTTP instance that delegates to the Lark SDK's default instance
+* but injects a default request timeout and User-Agent header to prevent
+* indefinite hangs and set a standardized User-Agent per OAPI best practices.
+*/
+function createTimeoutHttpInstance(defaultTimeoutMs) {
+	const base = feishuClientSdk.defaultHttpInstance;
+	function injectTimeout(opts) {
+		return {
+			timeout: defaultTimeoutMs,
+			...opts
+		};
+	}
+	return {
+		request: (opts) => base.request(injectTimeout(opts)),
+		get: (url, opts) => base.get(url, injectTimeout(opts)),
+		post: (url, data, opts) => base.post(url, data, injectTimeout(opts)),
+		put: (url, data, opts) => base.put(url, data, injectTimeout(opts)),
+		patch: (url, data, opts) => base.patch(url, data, injectTimeout(opts)),
+		delete: (url, opts) => base.delete(url, injectTimeout(opts)),
+		head: (url, opts) => base.head(url, injectTimeout(opts)),
+		options: (url, opts) => base.options(url, injectTimeout(opts))
+	};
+}
+/**
+* Create or get a cached Feishu client for an account.
+* Accepts any object with appId, appSecret, and optional domain/accountId.
+*/
+function createFeishuClient(creds) {
+	const { accountId = "default", appId, appSecret, domain } = creds;
+	const defaultHttpTimeoutMs = resolveConfiguredHttpTimeoutMs(creds);
+	if (!appId || !appSecret) throw new Error(`Feishu credentials not configured for account "${accountId}"`);
+	const cached = clientCache.get(accountId);
+	if (cached && cached.config.appId === appId && cached.config.appSecret === appSecret && cached.config.domain === domain && cached.config.httpTimeoutMs === defaultHttpTimeoutMs) return cached.client;
+	const client = new feishuClientSdk.Client({
+		appId,
+		appSecret,
+		appType: feishuClientSdk.AppType.SelfBuild,
+		domain: resolveDomain(domain),
+		httpInstance: createTimeoutHttpInstance(defaultHttpTimeoutMs)
+	});
+	clientCache.set(accountId, {
+		client,
+		config: {
+			appId,
+			appSecret,
+			domain,
+			httpTimeoutMs: defaultHttpTimeoutMs
+		}
+	});
+	return client;
+}
+/**
+* Create a Feishu WebSocket client for an account.
+* Note: WSClient is not cached since each call creates a new connection.
+*/
+async function createFeishuWSClient(account, callbacks = {}) {
+	const { accountId, appId, appSecret, domain } = account;
+	if (!appId || !appSecret) throw new Error(`Feishu credentials not configured for account "${accountId}"`);
+	const agent = await getWsProxyAgent();
+	return new feishuClientSdk.WSClient({
+		appId,
+		appSecret,
+		domain: resolveDomain(domain),
+		...callbacks,
+		loggerLevel: feishuClientSdk.LoggerLevel.info,
+		wsConfig: FEISHU_WS_CONFIG,
+		...agent ? { agent } : {}
+	});
+}
+/**
+* Create an event dispatcher for an account.
+*/
+function createEventDispatcher(account) {
+	return new feishuClientSdk.EventDispatcher({
+		encryptKey: account.encryptKey,
+		verificationToken: account.verificationToken
+	});
+}
+//#endregion
+export { getFeishuUserAgent as a, createFeishuWSClient as i, createEventDispatcher as n, createFeishuClient as r, client_exports as t };

package/dist/contract-api.js

@@ -0,0 +1,9 @@
+import { a as parseFeishuTargetId, i as parseFeishuDirectConversationId, r as parseFeishuConversationId, t as buildFeishuConversationId } from "./conversation-id-DWS3Ep2A.js";
+import { n as createFeishuThreadBindingManager, t as __testing } from "./thread-bindings-BmS6TLes.js";
+import { t as messageActionTargetAliases } from "./security-audit-DqJdocrN.js";
+import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-Dm4Z_zQN.js";
+import { t as collectFeishuSecurityAuditFindings } from "./security-audit-shared-ByuMx9cJ.js";
+//#region extensions/feishu/contract-api.ts
+const feishuSessionBindingAdapterChannels = ["feishu"];
+//#endregion
+export { buildFeishuConversationId, collectFeishuSecurityAuditFindings, collectRuntimeConfigAssignments, createFeishuThreadBindingManager, feishuSessionBindingAdapterChannels, __testing as feishuThreadBindingTesting, messageActionTargetAliases, parseFeishuConversationId, parseFeishuDirectConversationId, parseFeishuTargetId, secretTargetRegistryEntries };

package/dist/conversation-id-DWS3Ep2A.js

@@ -0,0 +1,139 @@
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
+//#region extensions/feishu/src/conversation-id.ts
+function normalizeText(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function buildFeishuConversationId(params) {
+	const chatId = normalizeText(params.chatId) ?? "unknown";
+	const senderOpenId = normalizeText(params.senderOpenId);
+	const topicId = normalizeText(params.topicId);
+	switch (params.scope) {
+		case "group_sender": return senderOpenId ? `${chatId}:sender:${senderOpenId}` : chatId;
+		case "group_topic": return topicId ? `${chatId}:topic:${topicId}` : chatId;
+		case "group_topic_sender":
+			if (topicId && senderOpenId) return `${chatId}:topic:${topicId}:sender:${senderOpenId}`;
+			if (topicId) return `${chatId}:topic:${topicId}`;
+			return senderOpenId ? `${chatId}:sender:${senderOpenId}` : chatId;
+		default: return chatId;
+	}
+}
+function parseFeishuTargetId(raw) {
+	const target = normalizeText(raw);
+	if (!target) return;
+	const withoutProvider = target.replace(/^(feishu|lark):/i, "").trim();
+	if (!withoutProvider) return;
+	const lowered = normalizeLowercaseStringOrEmpty(withoutProvider);
+	for (const prefix of [
+		"chat:",
+		"group:",
+		"channel:",
+		"user:",
+		"dm:",
+		"open_id:"
+	]) if (lowered.startsWith(prefix)) return normalizeText(withoutProvider.slice(prefix.length));
+	return withoutProvider;
+}
+function parseFeishuDirectConversationId(raw) {
+	const target = normalizeText(raw);
+	if (!target) return;
+	const withoutProvider = target.replace(/^(feishu|lark):/i, "").trim();
+	if (!withoutProvider) return;
+	const lowered = normalizeLowercaseStringOrEmpty(withoutProvider);
+	for (const prefix of [
+		"user:",
+		"dm:",
+		"open_id:"
+	]) if (lowered.startsWith(prefix)) return normalizeText(withoutProvider.slice(prefix.length));
+	const id = parseFeishuTargetId(target);
+	if (!id) return;
+	if (id.startsWith("ou_") || id.startsWith("on_")) return id;
+}
+function parseFeishuConversationId(params) {
+	const conversationId = normalizeText(params.conversationId);
+	const parentConversationId = normalizeText(params.parentConversationId);
+	if (!conversationId) return null;
+	const topicSenderMatch = conversationId.match(/^(.+):topic:([^:]+):sender:([^:]+)$/i);
+	if (topicSenderMatch) {
+		const [, chatId, topicId, senderOpenId] = topicSenderMatch;
+		return {
+			canonicalConversationId: buildFeishuConversationId({
+				chatId,
+				scope: "group_topic_sender",
+				topicId,
+				senderOpenId
+			}),
+			chatId,
+			topicId,
+			senderOpenId,
+			scope: "group_topic_sender"
+		};
+	}
+	const topicMatch = conversationId.match(/^(.+):topic:([^:]+)$/i);
+	if (topicMatch) {
+		const [, chatId, topicId] = topicMatch;
+		return {
+			canonicalConversationId: buildFeishuConversationId({
+				chatId,
+				scope: "group_topic",
+				topicId
+			}),
+			chatId,
+			topicId,
+			scope: "group_topic"
+		};
+	}
+	const senderMatch = conversationId.match(/^(.+):sender:([^:]+)$/i);
+	if (senderMatch) {
+		const [, chatId, senderOpenId] = senderMatch;
+		return {
+			canonicalConversationId: buildFeishuConversationId({
+				chatId,
+				scope: "group_sender",
+				senderOpenId
+			}),
+			chatId,
+			senderOpenId,
+			scope: "group_sender"
+		};
+	}
+	if (parentConversationId) return {
+		canonicalConversationId: buildFeishuConversationId({
+			chatId: parentConversationId,
+			scope: "group_topic",
+			topicId: conversationId
+		}),
+		chatId: parentConversationId,
+		topicId: conversationId,
+		scope: "group_topic"
+	};
+	return {
+		canonicalConversationId: conversationId,
+		chatId: conversationId,
+		scope: "group"
+	};
+}
+function buildFeishuModelOverrideParentCandidates(parentConversationId) {
+	const rawId = normalizeText(parentConversationId);
+	if (!rawId) return [];
+	const topicSenderMatch = rawId.match(/^(.+):topic:([^:]+):sender:([^:]+)$/i);
+	if (topicSenderMatch) {
+		const chatId = normalizeLowercaseStringOrEmpty(topicSenderMatch[1]);
+		const topicId = normalizeLowercaseStringOrEmpty(topicSenderMatch[2]);
+		if (chatId && topicId) return [`${chatId}:topic:${topicId}`, chatId];
+		return [];
+	}
+	const topicMatch = rawId.match(/^(.+):topic:([^:]+)$/i);
+	if (topicMatch) {
+		const chatId = normalizeLowercaseStringOrEmpty(topicMatch[1]);
+		return chatId ? [chatId] : [];
+	}
+	const senderMatch = rawId.match(/^(.+):sender:([^:]+)$/i);
+	if (senderMatch) {
+		const chatId = normalizeLowercaseStringOrEmpty(senderMatch[1]);
+		return chatId ? [chatId] : [];
+	}
+	return [];
+}
+//#endregion
+export { parseFeishuTargetId as a, parseFeishuDirectConversationId as i, buildFeishuModelOverrideParentCandidates as n, parseFeishuConversationId as r, buildFeishuConversationId as t };

package/dist/directory.static-f3EeoRJd.js

@@ -0,0 +1,44 @@
+import { r as normalizeFeishuTarget } from "./targets-JMFJRKSe.js";
+import { o as resolveFeishuAccount } from "./accounts-Ba3-WP1z.js";
+import { listDirectoryGroupEntriesFromMapKeysAndAllowFrom, listDirectoryUserEntriesFromAllowFromAndMapKeys } from "openclaw/plugin-sdk/directory-runtime";
+//#region extensions/feishu/src/directory.static.ts
+function toFeishuDirectoryPeers(ids) {
+	return ids.map((id) => ({
+		kind: "user",
+		id
+	}));
+}
+function toFeishuDirectoryGroups(ids) {
+	return ids.map((id) => ({
+		kind: "group",
+		id
+	}));
+}
+async function listFeishuDirectoryPeers(params) {
+	const account = resolveFeishuAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	return toFeishuDirectoryPeers(listDirectoryUserEntriesFromAllowFromAndMapKeys({
+		allowFrom: account.config.allowFrom,
+		map: account.config.dms,
+		query: params.query,
+		limit: params.limit,
+		normalizeAllowFromId: (entry) => normalizeFeishuTarget(entry) ?? entry,
+		normalizeMapKeyId: (entry) => normalizeFeishuTarget(entry) ?? entry
+	}).map((entry) => entry.id));
+}
+async function listFeishuDirectoryGroups(params) {
+	const account = resolveFeishuAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	return toFeishuDirectoryGroups(listDirectoryGroupEntriesFromMapKeysAndAllowFrom({
+		groups: account.config.groups,
+		allowFrom: account.config.groupAllowFrom,
+		query: params.query,
+		limit: params.limit
+	}).map((entry) => entry.id));
+}
+//#endregion
+export { listFeishuDirectoryPeers as n, listFeishuDirectoryGroups as t };