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

package/dist/src/monitor.account.js

@@ -0,0 +1,393 @@
+import { resolveFeishuAccount } from "./accounts.js";
+import { createEventDispatcher } from "./client.js";
+import { withTicket } from "./lark-ticket.js";
+import { raceWithTimeoutAndAbort } from "./async.js";
+import { getFeishuRuntime } from "./runtime.js";
+import { isMentionForwardRequest } from "./mention.js";
+import { getMessageFeishu } from "./send.js";
+import { hasProcessedFeishuMessage, recordProcessedFeishuMessage, releaseFeishuMessageProcessing, tryBeginFeishuMessageProcessing, warmupDedupFromDisk } from "./dedup.js";
+import { handleFeishuMessage, parseFeishuMessageEvent } from "./bot.js";
+import { handleFeishuCardAction } from "./card-action.js";
+import { fetchBotIdentityForMonitor } from "./monitor.startup.js";
+import { botNames, botOpenIds } from "./monitor.state.js";
+import { monitorWebSocket, monitorWebhook } from "./monitor.transport.js";
+import * as crypto from "crypto";
+//#region src/monitor.account.ts
+const FEISHU_REACTION_VERIFY_TIMEOUT_MS = 1500;
+async function resolveReactionSyntheticEvent(params) {
+	const { cfg, accountId, event, botOpenId, fetchMessage = getMessageFeishu, verificationTimeoutMs = FEISHU_REACTION_VERIFY_TIMEOUT_MS, logger, uuid = () => crypto.randomUUID() } = params;
+	const emoji = event.reaction_type?.emoji_type;
+	const messageId = event.message_id;
+	const senderId = event.user_id?.open_id;
+	if (!emoji || !messageId || !senderId) return null;
+	const reactionNotifications = resolveFeishuAccount({
+		cfg,
+		accountId
+	}).config.reactionNotifications ?? "own";
+	if (reactionNotifications === "off") return null;
+	if (event.operator_type === "app" || senderId === botOpenId) return null;
+	if (emoji === "Typing") return null;
+	if (reactionNotifications === "own" && !botOpenId) {
+		logger?.(`feishu[${accountId}]: bot open_id unavailable, skipping reaction ${emoji} on ${messageId}`);
+		return null;
+	}
+	const reactedMsg = await raceWithTimeoutAndAbort(fetchMessage({
+		cfg,
+		messageId,
+		accountId
+	}), { timeoutMs: verificationTimeoutMs }).then((result) => result.status === "resolved" ? result.value : null).catch(() => null);
+	const isBotMessage = reactedMsg?.senderType === "app" || reactedMsg?.senderOpenId === botOpenId;
+	if (!reactedMsg || reactionNotifications === "own" && !isBotMessage) {
+		logger?.(`feishu[${accountId}]: ignoring reaction on non-bot/unverified message ${messageId} (sender: ${reactedMsg?.senderOpenId ?? "unknown"})`);
+		return null;
+	}
+	const fallbackChatType = reactedMsg.chatType;
+	const resolvedChatType = normalizeFeishuChatType(event.chat_type) ?? fallbackChatType;
+	if (!resolvedChatType) {
+		logger?.(`feishu[${accountId}]: skipping reaction ${emoji} on ${messageId} without chat type context`);
+		return null;
+	}
+	const syntheticChatIdRaw = event.chat_id ?? reactedMsg.chatId;
+	const syntheticChatId = syntheticChatIdRaw?.trim() ? syntheticChatIdRaw : `p2p:${senderId}`;
+	const syntheticChatType = resolvedChatType;
+	return {
+		sender: {
+			sender_id: { open_id: senderId },
+			sender_type: "user"
+		},
+		message: {
+			message_id: `${messageId}:reaction:${emoji}:${uuid()}`,
+			chat_id: syntheticChatId,
+			chat_type: syntheticChatType,
+			message_type: "text",
+			content: JSON.stringify({ text: `[reacted with ${emoji} to message ${messageId}]` })
+		}
+	};
+}
+function normalizeFeishuChatType(value) {
+	return value === "group" || value === "private" || value === "p2p" ? value : void 0;
+}
+/**
+* Per-chat serial queue that ensures messages from the same chat are processed
+* in arrival order while allowing different chats to run concurrently.
+*/
+function createChatQueue() {
+	const queues = /* @__PURE__ */ new Map();
+	return (chatId, task) => {
+		const next = (queues.get(chatId) ?? Promise.resolve()).then(task, task);
+		queues.set(chatId, next);
+		next.finally(() => {
+			if (queues.get(chatId) === next) queues.delete(chatId);
+		});
+		return next;
+	};
+}
+function mergeFeishuDebounceMentions(entries) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const entry of entries) for (const mention of entry.message.mentions ?? []) {
+		const stableId = mention.id.open_id?.trim() || mention.id.user_id?.trim() || mention.id.union_id?.trim();
+		const mentionName = mention.name?.trim();
+		const mentionKey = mention.key?.trim();
+		const fallback = mentionName && mentionKey ? `${mentionName}|${mentionKey}` : mentionName || mentionKey;
+		const key = stableId || fallback;
+		if (!key || merged.has(key)) continue;
+		merged.set(key, mention);
+	}
+	if (merged.size === 0) return;
+	return Array.from(merged.values());
+}
+function dedupeFeishuDebounceEntriesByMessageId(entries) {
+	const seen = /* @__PURE__ */ new Set();
+	const deduped = [];
+	for (const entry of entries) {
+		const messageId = entry.message.message_id?.trim();
+		if (!messageId) {
+			deduped.push(entry);
+			continue;
+		}
+		if (seen.has(messageId)) continue;
+		seen.add(messageId);
+		deduped.push(entry);
+	}
+	return deduped;
+}
+function resolveFeishuDebounceMentions(params) {
+	const { entries, botOpenId } = params;
+	if (entries.length === 0) return;
+	for (let index = entries.length - 1; index >= 0; index -= 1) {
+		const entry = entries[index];
+		if (isMentionForwardRequest(entry, botOpenId)) return mergeFeishuDebounceMentions([entry]);
+	}
+	const merged = mergeFeishuDebounceMentions(entries);
+	if (!merged) return;
+	const normalizedBotOpenId = botOpenId?.trim();
+	if (!normalizedBotOpenId) return;
+	const botMentions = merged.filter((mention) => mention.id.open_id?.trim() === normalizedBotOpenId);
+	return botMentions.length > 0 ? botMentions : void 0;
+}
+function registerEventHandlers(eventDispatcher, context) {
+	const { cfg, accountId, runtime, chatHistories, fireAndForget } = context;
+	const core = getFeishuRuntime();
+	const inboundDebounceMs = core.channel.debounce.resolveInboundDebounceMs({
+		cfg,
+		channel: "feishu"
+	});
+	const log = runtime?.log ?? console.log;
+	const error = runtime?.error ?? console.error;
+	const enqueue = createChatQueue();
+	const dispatchFeishuMessage = async (event) => {
+		const chatId = event.message.chat_id?.trim() || "unknown";
+		const task = () => withTicket({
+			accountId,
+			messageId: event.message.message_id,
+			chatId: event.message.chat_id,
+			senderOpenId: event.sender.sender_id.open_id?.trim() || void 0,
+			chatType: event.message.chat_type,
+			threadId: event.message.thread_id?.trim() || event.message.root_id?.trim() || void 0,
+			startTime: Date.now()
+		}, () => handleFeishuMessage({
+			cfg,
+			event,
+			botOpenId: botOpenIds.get(accountId),
+			botName: botNames.get(accountId),
+			runtime,
+			chatHistories,
+			accountId,
+			processingClaimHeld: true
+		}));
+		await enqueue(chatId, task);
+	};
+	const resolveSenderDebounceId = (event) => {
+		return event.sender.sender_id.open_id?.trim() || event.sender.sender_id.user_id?.trim() || void 0;
+	};
+	const resolveDebounceText = (event) => {
+		return parseFeishuMessageEvent(event, botOpenIds.get(accountId), botNames.get(accountId)).content.trim();
+	};
+	const recordSuppressedMessageIds = async (entries, dispatchMessageId) => {
+		const keepMessageId = dispatchMessageId?.trim();
+		const suppressedIds = new Set(entries.map((entry) => entry.message.message_id?.trim()).filter((id) => Boolean(id) && (!keepMessageId || id !== keepMessageId)));
+		if (suppressedIds.size === 0) return;
+		for (const messageId of suppressedIds) try {
+			await recordProcessedFeishuMessage(messageId, accountId, log);
+		} catch (err) {
+			error(`feishu[${accountId}]: failed to record merged dedupe id ${messageId}: ${String(err)}`);
+		}
+	};
+	const isMessageAlreadyProcessed = async (entry) => {
+		return await hasProcessedFeishuMessage(entry.message.message_id, accountId, log);
+	};
+	const inboundDebouncer = core.channel.debounce.createInboundDebouncer({
+		debounceMs: inboundDebounceMs,
+		buildKey: (event) => {
+			const chatId = event.message.chat_id?.trim();
+			const senderId = resolveSenderDebounceId(event);
+			if (!chatId || !senderId) return null;
+			const rootId = event.message.root_id?.trim();
+			return `feishu:${accountId}:${chatId}:${rootId ? `thread:${rootId}` : "chat"}:${senderId}`;
+		},
+		shouldDebounce: (event) => {
+			if (event.message.message_type !== "text") return false;
+			const text = resolveDebounceText(event);
+			if (!text) return false;
+			return !core.channel.text.hasControlCommand(text, cfg);
+		},
+		onFlush: async (entries) => {
+			const last = entries.at(-1);
+			if (!last) return;
+			if (entries.length === 1) {
+				await dispatchFeishuMessage(last);
+				return;
+			}
+			const dedupedEntries = dedupeFeishuDebounceEntriesByMessageId(entries);
+			const freshEntries = [];
+			for (const entry of dedupedEntries) if (!await isMessageAlreadyProcessed(entry)) freshEntries.push(entry);
+			const dispatchEntry = freshEntries.at(-1);
+			if (!dispatchEntry) return;
+			await recordSuppressedMessageIds(dedupedEntries, dispatchEntry.message.message_id);
+			const combinedText = freshEntries.map((entry) => resolveDebounceText(entry)).filter(Boolean).join("\n");
+			const mergedMentions = resolveFeishuDebounceMentions({
+				entries: freshEntries,
+				botOpenId: botOpenIds.get(accountId)
+			});
+			if (!combinedText.trim()) {
+				await dispatchFeishuMessage({
+					...dispatchEntry,
+					message: {
+						...dispatchEntry.message,
+						mentions: mergedMentions ?? dispatchEntry.message.mentions
+					}
+				});
+				return;
+			}
+			await dispatchFeishuMessage({
+				...dispatchEntry,
+				message: {
+					...dispatchEntry.message,
+					message_type: "text",
+					content: JSON.stringify({ text: combinedText }),
+					mentions: mergedMentions ?? dispatchEntry.message.mentions
+				}
+			});
+		},
+		onError: (err, entries) => {
+			for (const entry of entries) releaseFeishuMessageProcessing(entry.message.message_id, accountId);
+			error(`feishu[${accountId}]: inbound debounce flush failed: ${String(err)}`);
+		}
+	});
+	eventDispatcher.register({
+		"im.message.receive_v1": async (data) => {
+			const event = data;
+			const messageId = event.message?.message_id?.trim();
+			if (!tryBeginFeishuMessageProcessing(messageId, accountId)) {
+				log(`feishu[${accountId}]: dropping duplicate event for message ${messageId}`);
+				return;
+			}
+			const processMessage = async () => {
+				await inboundDebouncer.enqueue(event);
+			};
+			if (fireAndForget) {
+				processMessage().catch((err) => {
+					releaseFeishuMessageProcessing(messageId, accountId);
+					error(`feishu[${accountId}]: error handling message: ${String(err)}`);
+				});
+				return;
+			}
+			try {
+				await processMessage();
+			} catch (err) {
+				releaseFeishuMessageProcessing(messageId, accountId);
+				error(`feishu[${accountId}]: error handling message: ${String(err)}`);
+			}
+		},
+		"im.message.message_read_v1": async () => {},
+		"im.chat.member.bot.added_v1": async (data) => {
+			try {
+				log(`feishu[${accountId}]: bot added to chat ${data.chat_id}`);
+			} catch (err) {
+				error(`feishu[${accountId}]: error handling bot added event: ${String(err)}`);
+			}
+		},
+		"im.chat.member.bot.deleted_v1": async (data) => {
+			try {
+				log(`feishu[${accountId}]: bot removed from chat ${data.chat_id}`);
+			} catch (err) {
+				error(`feishu[${accountId}]: error handling bot removed event: ${String(err)}`);
+			}
+		},
+		"im.message.reaction.created_v1": async (data) => {
+			const processReaction = async () => {
+				const event = data;
+				const myBotId = botOpenIds.get(accountId);
+				const syntheticEvent = await resolveReactionSyntheticEvent({
+					cfg,
+					accountId,
+					event,
+					botOpenId: myBotId,
+					logger: log
+				});
+				if (!syntheticEvent) return;
+				const promise = withTicket({
+					accountId,
+					messageId: syntheticEvent.message.message_id,
+					chatId: syntheticEvent.message.chat_id,
+					senderOpenId: syntheticEvent.sender.sender_id.open_id?.trim() || void 0,
+					chatType: syntheticEvent.message.chat_type,
+					threadId: syntheticEvent.message.thread_id?.trim() || syntheticEvent.message.root_id?.trim() || void 0,
+					startTime: Date.now()
+				}, () => handleFeishuMessage({
+					cfg,
+					event: syntheticEvent,
+					botOpenId: myBotId,
+					botName: botNames.get(accountId),
+					runtime,
+					chatHistories,
+					accountId
+				}));
+				if (fireAndForget) {
+					promise.catch((err) => {
+						error(`feishu[${accountId}]: error handling reaction: ${String(err)}`);
+					});
+					return;
+				}
+				await promise;
+			};
+			if (fireAndForget) {
+				processReaction().catch((err) => {
+					error(`feishu[${accountId}]: error handling reaction event: ${String(err)}`);
+				});
+				return;
+			}
+			try {
+				await processReaction();
+			} catch (err) {
+				error(`feishu[${accountId}]: error handling reaction event: ${String(err)}`);
+			}
+		},
+		"im.message.reaction.deleted_v1": async () => {},
+		"card.action.trigger": async (data) => {
+			try {
+				const promise = handleFeishuCardAction({
+					cfg,
+					event: data,
+					botOpenId: botOpenIds.get(accountId),
+					runtime,
+					accountId
+				});
+				if (fireAndForget) promise.catch((err) => {
+					error(`feishu[${accountId}]: error handling card action: ${String(err)}`);
+				});
+				else await promise;
+			} catch (err) {
+				error(`feishu[${accountId}]: error handling card action: ${String(err)}`);
+			}
+		}
+	});
+}
+async function monitorSingleAccount(params) {
+	const { cfg, account, runtime, abortSignal } = params;
+	const { accountId } = account;
+	const log = runtime?.log ?? console.log;
+	const botOpenIdSource = params.botOpenIdSource ?? { kind: "fetch" };
+	const botIdentity = botOpenIdSource.kind === "prefetched" ? {
+		botOpenId: botOpenIdSource.botOpenId,
+		botName: botOpenIdSource.botName
+	} : await fetchBotIdentityForMonitor(account, {
+		runtime,
+		abortSignal
+	});
+	const botOpenId = botIdentity.botOpenId;
+	const botName = botIdentity.botName?.trim();
+	botOpenIds.set(accountId, botOpenId ?? "");
+	if (botName) botNames.set(accountId, botName);
+	else botNames.delete(accountId);
+	log(`feishu[${accountId}]: bot open_id resolved: ${botOpenId ?? "unknown"}`);
+	const connectionMode = account.config.connectionMode ?? "websocket";
+	if (connectionMode === "webhook" && !account.verificationToken?.trim()) throw new Error(`Feishu account "${accountId}" webhook mode requires verificationToken`);
+	if (connectionMode === "webhook" && !account.encryptKey?.trim()) throw new Error(`Feishu account "${accountId}" webhook mode requires encryptKey`);
+	const warmupCount = await warmupDedupFromDisk(accountId, log);
+	if (warmupCount > 0) log(`feishu[${accountId}]: dedup warmup loaded ${warmupCount} entries from disk`);
+	const eventDispatcher = createEventDispatcher(account);
+	registerEventHandlers(eventDispatcher, {
+		cfg,
+		accountId,
+		runtime,
+		chatHistories: /* @__PURE__ */ new Map(),
+		fireAndForget: true
+	});
+	if (connectionMode === "webhook") return monitorWebhook({
+		account,
+		accountId,
+		runtime,
+		abortSignal,
+		eventDispatcher
+	});
+	return monitorWebSocket({
+		account,
+		accountId,
+		runtime,
+		abortSignal,
+		eventDispatcher
+	});
+}
+//#endregion
+export { monitorSingleAccount, resolveReactionSyntheticEvent };

package/dist/src/monitor.d.ts

@@ -0,0 +1,11 @@
+import { ClawdbotConfig, RuntimeEnv } from "./nextclaw-sdk/types.js";
+//#region src/monitor.d.ts
+type MonitorFeishuOpts = {
+  config?: ClawdbotConfig;
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  accountId?: string;
+};
+declare function monitorFeishuProvider(opts?: MonitorFeishuOpts): Promise<void>;
+//#endregion
+export { monitorFeishuProvider };

package/dist/src/monitor.js

@@ -0,0 +1,58 @@
+import { listEnabledFeishuAccounts, resolveFeishuAccount } from "./accounts.js";
+import { fetchBotIdentityForMonitor } from "./monitor.startup.js";
+import { stopFeishuMonitorState } from "./monitor.state.js";
+import { monitorSingleAccount } from "./monitor.account.js";
+//#region src/monitor.ts
+async function monitorFeishuProvider(opts = {}) {
+	const cfg = opts.config;
+	if (!cfg) throw new Error("Config is required for Feishu monitor");
+	const log = opts.runtime?.log ?? console.log;
+	if (opts.accountId) {
+		const account = resolveFeishuAccount({
+			cfg,
+			accountId: opts.accountId
+		});
+		if (!account.enabled || !account.configured) throw new Error(`Feishu account "${opts.accountId}" not configured or disabled`);
+		return monitorSingleAccount({
+			cfg,
+			account,
+			runtime: opts.runtime,
+			abortSignal: opts.abortSignal
+		});
+	}
+	const accounts = listEnabledFeishuAccounts(cfg);
+	if (accounts.length === 0) throw new Error("No enabled Feishu accounts configured");
+	log(`feishu: starting ${accounts.length} account(s): ${accounts.map((a) => a.accountId).join(", ")}`);
+	const monitorPromises = [];
+	for (const account of accounts) {
+		if (opts.abortSignal?.aborted) {
+			log("feishu: abort signal received during startup preflight; stopping startup");
+			break;
+		}
+		const { botOpenId, botName } = await fetchBotIdentityForMonitor(account, {
+			runtime: opts.runtime,
+			abortSignal: opts.abortSignal
+		});
+		if (opts.abortSignal?.aborted) {
+			log("feishu: abort signal received during startup preflight; stopping startup");
+			break;
+		}
+		monitorPromises.push(monitorSingleAccount({
+			cfg,
+			account,
+			runtime: opts.runtime,
+			abortSignal: opts.abortSignal,
+			botOpenIdSource: {
+				kind: "prefetched",
+				botOpenId,
+				botName
+			}
+		}));
+	}
+	await Promise.all(monitorPromises);
+}
+function stopFeishuMonitor(accountId) {
+	stopFeishuMonitorState(accountId);
+}
+//#endregion
+export { monitorFeishuProvider, stopFeishuMonitor };

package/dist/src/monitor.startup.js

@@ -0,0 +1,24 @@
+import { probeFeishu } from "./probe.js";
+function isTimeoutErrorMessage(message) {
+	return message?.toLowerCase().includes("timeout") || message?.toLowerCase().includes("timed out") ? true : false;
+}
+function isAbortErrorMessage(message) {
+	return message?.toLowerCase().includes("aborted") ?? false;
+}
+async function fetchBotIdentityForMonitor(account, options = {}) {
+	if (options.abortSignal?.aborted) return {};
+	const timeoutMs = options.timeoutMs ?? 1e4;
+	const result = await probeFeishu(account, {
+		timeoutMs,
+		abortSignal: options.abortSignal
+	});
+	if (result.ok) return {
+		botOpenId: result.botOpenId,
+		botName: result.botName
+	};
+	if (options.abortSignal?.aborted || isAbortErrorMessage(result.error)) return {};
+	if (isTimeoutErrorMessage(result.error)) (options.runtime?.error ?? console.error)(`feishu[${account.accountId}]: bot info probe timed out after ${timeoutMs}ms; continuing startup`);
+	return {};
+}
+//#endregion
+export { fetchBotIdentityForMonitor };

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

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

package/dist/src/monitor.state.js

@@ -0,0 +1,80 @@
+import { WEBHOOK_ANOMALY_COUNTER_DEFAULTS, WEBHOOK_RATE_LIMIT_DEFAULTS, createFixedWindowRateLimiter, createWebhookAnomalyTracker } from "./nextclaw-sdk/network-webhook.js";
+import "./nextclaw-sdk/feishu.js";
+//#region src/monitor.state.ts
+const wsClients = /* @__PURE__ */ new Map();
+const httpServers = /* @__PURE__ */ new Map();
+const botOpenIds = /* @__PURE__ */ new Map();
+const botNames = /* @__PURE__ */ new Map();
+const FEISHU_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
+const FEISHU_WEBHOOK_BODY_TIMEOUT_MS = 3e4;
+const FEISHU_WEBHOOK_RATE_LIMIT_FALLBACK_DEFAULTS = {
+	windowMs: 6e4,
+	maxRequests: 120,
+	maxTrackedKeys: 4096
+};
+const FEISHU_WEBHOOK_ANOMALY_FALLBACK_DEFAULTS = {
+	maxTrackedKeys: 4096,
+	ttlMs: 360 * 6e4,
+	logEvery: 25
+};
+function coercePositiveInt(value, fallback) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+	const normalized = Math.floor(value);
+	return normalized > 0 ? normalized : fallback;
+}
+function resolveFeishuWebhookRateLimitDefaultsForTest(defaults) {
+	const resolved = defaults;
+	return {
+		windowMs: coercePositiveInt(resolved?.windowMs, FEISHU_WEBHOOK_RATE_LIMIT_FALLBACK_DEFAULTS.windowMs),
+		maxRequests: coercePositiveInt(resolved?.maxRequests, FEISHU_WEBHOOK_RATE_LIMIT_FALLBACK_DEFAULTS.maxRequests),
+		maxTrackedKeys: coercePositiveInt(resolved?.maxTrackedKeys, FEISHU_WEBHOOK_RATE_LIMIT_FALLBACK_DEFAULTS.maxTrackedKeys)
+	};
+}
+function resolveFeishuWebhookAnomalyDefaultsForTest(defaults) {
+	const resolved = defaults;
+	return {
+		maxTrackedKeys: coercePositiveInt(resolved?.maxTrackedKeys, FEISHU_WEBHOOK_ANOMALY_FALLBACK_DEFAULTS.maxTrackedKeys),
+		ttlMs: coercePositiveInt(resolved?.ttlMs, FEISHU_WEBHOOK_ANOMALY_FALLBACK_DEFAULTS.ttlMs),
+		logEvery: coercePositiveInt(resolved?.logEvery, FEISHU_WEBHOOK_ANOMALY_FALLBACK_DEFAULTS.logEvery)
+	};
+}
+const feishuWebhookRateLimitDefaults = resolveFeishuWebhookRateLimitDefaultsForTest(WEBHOOK_RATE_LIMIT_DEFAULTS);
+const feishuWebhookAnomalyDefaults = resolveFeishuWebhookAnomalyDefaultsForTest(WEBHOOK_ANOMALY_COUNTER_DEFAULTS);
+const feishuWebhookRateLimiter = createFixedWindowRateLimiter({
+	windowMs: feishuWebhookRateLimitDefaults.windowMs,
+	maxRequests: feishuWebhookRateLimitDefaults.maxRequests,
+	maxTrackedKeys: feishuWebhookRateLimitDefaults.maxTrackedKeys
+});
+const feishuWebhookAnomalyTracker = createWebhookAnomalyTracker({
+	maxTrackedKeys: feishuWebhookAnomalyDefaults.maxTrackedKeys,
+	ttlMs: feishuWebhookAnomalyDefaults.ttlMs,
+	logEvery: feishuWebhookAnomalyDefaults.logEvery
+});
+function recordWebhookStatus(runtime, accountId, path, statusCode) {
+	feishuWebhookAnomalyTracker.record({
+		key: `${accountId}:${path}:${statusCode}`,
+		statusCode,
+		log: runtime?.log ?? console.log,
+		message: (count) => `feishu[${accountId}]: webhook anomaly path=${path} status=${statusCode} count=${count}`
+	});
+}
+function stopFeishuMonitorState(accountId) {
+	if (accountId) {
+		wsClients.delete(accountId);
+		const server = httpServers.get(accountId);
+		if (server) {
+			server.close();
+			httpServers.delete(accountId);
+		}
+		botOpenIds.delete(accountId);
+		botNames.delete(accountId);
+		return;
+	}
+	wsClients.clear();
+	for (const server of httpServers.values()) server.close();
+	httpServers.clear();
+	botOpenIds.clear();
+	botNames.clear();
+}
+//#endregion
+export { FEISHU_WEBHOOK_BODY_TIMEOUT_MS, FEISHU_WEBHOOK_MAX_BODY_BYTES, botNames, botOpenIds, feishuWebhookRateLimiter, httpServers, recordWebhookStatus, stopFeishuMonitorState, wsClients };