@openclaw/feishu 2026.7.2-beta.5 → 2026.7.33

package/dist/.setup/client-DLqNWY5r.mjs

@@ -0,0 +1,161 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { createRequire } from "node:module";
+import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
+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 = parseStrictPositiveInteger(envRaw);
+		if (envValue !== void 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 require = createRequire(import.meta.url);
+const pluginVersion = readPluginPackageVersion({ require });
+const FEISHU_USER_AGENT = `openclaw-feishu-builtin/${pluginVersion}/${process.platform}`;
+const FEISHU_WS_CONFIG = { 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
+};
+function setRequestUserAgent(req) {
+	const request = req;
+	const headers = request.headers;
+	if (!headers) {
+		request.headers = { "User-Agent": getFeishuUserAgent() };
+		return req;
+	}
+	const maybeAxiosHeaders = headers;
+	if (typeof maybeAxiosHeaders.set === "function") {
+		maybeAxiosHeaders.set("User-Agent", getFeishuUserAgent());
+		return req;
+	}
+	headers["User-Agent"] = getFeishuUserAgent();
+	return req;
+}
+Lark.defaultHttpInstance.interceptors?.request?.use(setRequestUserAgent);
+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, FEISHU_HTTP_TIMEOUT_MS as o, createFeishuClient as r, resolveConfiguredHttpTimeoutMs as s, client_exports as t };

package/dist/.setup/conversation-id-CdLdoot3.mjs

@@ -0,0 +1,143 @@
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/feishu/src/conversation-id.ts
+function resolveConfiguredFeishuGroupSessionScope(params) {
+	const legacyTopicSessionMode = params.groupConfig?.topicSessionMode ?? params.feishuCfg?.topicSessionMode ?? "disabled";
+	return params.groupConfig?.groupSessionScope ?? params.feishuCfg?.groupSessionScope ?? (legacyTopicSessionMode === "enabled" ? "group_topic" : "group");
+}
+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, resolveConfiguredFeishuGroupSessionScope as o, parseFeishuConversationId as r, buildFeishuConversationId as t };