@nextclaw/channel-extension-feishu 0.1.1

package/dist/services/feishu-registration.service.js

@@ -0,0 +1,214 @@
+import { FEISHU_CHANNEL_ID, buildRegisteredFeishuChannelConfig, normalizeFeishuChannelConfig } from "../utils/feishu-config.utils.js";
+import { FileFeishuAccountStore } from "../stores/feishu-account.store.js";
+import { randomUUID } from "node:crypto";
+//#region src/services/feishu-registration.service.ts
+const REGISTRATION_PATH = "/oauth/v1/app/registration";
+const FEISHU_ACCOUNTS_BASE_URLS = {
+	feishu: "https://accounts.feishu.cn",
+	lark: "https://accounts.larksuite.com"
+};
+const FEISHU_OPEN_BASE_URLS = {
+	feishu: "https://open.feishu.cn",
+	lark: "https://open.larksuite.com"
+};
+const FEISHU_AUTH_POLL_INTERVAL_MS = 5e3;
+const FEISHU_REGISTRATION_TIMEOUT_MS = 10 * 6e4;
+function readString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readDomain(value) {
+	return value === "feishu" || value === "lark" ? value : void 0;
+}
+function appendHermesQrHints(url) {
+	if (!url.trim()) return url;
+	return `${url}${url.includes("?") ? "&" : "?"}from=nextclaw&tp=nextclaw`;
+}
+var FeishuRegistrationService = class {
+	store;
+	fetchImpl;
+	sessions = /* @__PURE__ */ new Map();
+	constructor(deps = {}) {
+		this.store = deps.store ?? new FileFeishuAccountStore();
+		this.fetchImpl = deps.fetchImpl ?? fetch;
+	}
+	start = async (params) => {
+		this.cleanupExpiredSessions();
+		const currentConfig = normalizeFeishuChannelConfig(params.pluginConfig);
+		const domain = params.domain ?? currentConfig.domain ?? "feishu";
+		await this.assertRegistrationSupported(domain);
+		const begin = await this.beginRegistration(domain);
+		const sessionId = randomUUID();
+		const expiresAtMs = Date.now() + Math.min(begin.expiresInMs, FEISHU_REGISTRATION_TIMEOUT_MS);
+		this.sessions.set(sessionId, {
+			currentConfig,
+			requestedAccountId: params.requestedAccountId,
+			deviceCode: begin.deviceCode,
+			domain,
+			intervalMs: begin.intervalMs,
+			expiresAtMs
+		});
+		return {
+			channel: FEISHU_CHANNEL_ID,
+			kind: "qr_code",
+			sessionId,
+			qrCode: begin.qrUrl,
+			qrCodeUrl: begin.qrUrl,
+			expiresAt: new Date(expiresAtMs).toISOString(),
+			intervalMs: begin.intervalMs,
+			note: "请使用飞书或 Lark 扫码授权，NextClaw 会自动创建机器人应用并保存连接信息。"
+		};
+	};
+	poll = async ({ sessionId }) => {
+		this.cleanupExpiredSessions();
+		const session = this.sessions.get(sessionId);
+		if (!session) return null;
+		if (session.expiresAtMs <= Date.now()) {
+			this.sessions.delete(sessionId);
+			return {
+				channel: FEISHU_CHANNEL_ID,
+				status: "expired",
+				message: "飞书扫码授权已过期，请重新开始。"
+			};
+		}
+		try {
+			const response = await this.postRegistration(session.domain, {
+				action: "poll",
+				device_code: session.deviceCode,
+				tp: "ob_app"
+			});
+			const userInfo = this.readRecord(response.user_info) ?? {};
+			const switchedDomain = readDomain(userInfo.tenant_brand) ?? session.domain;
+			if (switchedDomain !== session.domain) session.domain = switchedDomain;
+			const clientId = readString(response.client_id);
+			const clientSecret = readString(response.client_secret);
+			if (clientId && clientSecret) {
+				const result = await this.confirmRegistration({
+					session,
+					appId: clientId,
+					appSecret: clientSecret,
+					ownerOpenId: readString(userInfo.open_id)
+				});
+				this.sessions.delete(sessionId);
+				return {
+					channel: FEISHU_CHANNEL_ID,
+					status: "authorized",
+					message: "飞书已连接。",
+					nextPollMs: 0,
+					accountId: result.accountId,
+					notes: result.notes,
+					pluginConfig: result.pluginConfig
+				};
+			}
+			const error = readString(response.error);
+			if (error === "access_denied" || error === "expired_token") {
+				this.sessions.delete(sessionId);
+				return {
+					channel: FEISHU_CHANNEL_ID,
+					status: "expired",
+					message: error === "access_denied" ? "飞书授权已取消。" : "飞书扫码授权已过期。"
+				};
+			}
+			return {
+				channel: FEISHU_CHANNEL_ID,
+				status: "pending",
+				nextPollMs: session.intervalMs
+			};
+		} catch (error) {
+			return {
+				channel: FEISHU_CHANNEL_ID,
+				status: "error",
+				message: error instanceof Error ? error.message : String(error)
+			};
+		}
+	};
+	assertRegistrationSupported = async (domain) => {
+		const response = await this.postRegistration(domain, { action: "init" });
+		const methods = Array.isArray(response.supported_auth_methods) ? response.supported_auth_methods : [];
+		if (!methods.includes("client_secret")) throw new Error(`Feishu registration does not support client_secret auth. Supported: ${methods.join(", ")}`);
+	};
+	beginRegistration = async (domain) => {
+		const response = await this.postRegistration(domain, {
+			action: "begin",
+			archetype: "PersonalAgent",
+			auth_method: "client_secret",
+			request_user_info: "open_id"
+		});
+		const deviceCode = readString(response.device_code);
+		const qrUrl = readString(response.verification_uri_complete);
+		if (!deviceCode || !qrUrl) throw new Error("Feishu registration did not return a device code and QR URL.");
+		return {
+			deviceCode,
+			qrUrl: appendHermesQrHints(qrUrl),
+			intervalMs: Math.max(1, Number(response.interval ?? 5)) * 1e3 || FEISHU_AUTH_POLL_INTERVAL_MS,
+			expiresInMs: Math.max(60, Number(response.expire_in ?? 600)) * 1e3
+		};
+	};
+	postRegistration = async (domain, body) => {
+		const response = await this.fetchImpl(`${FEISHU_ACCOUNTS_BASE_URLS[domain]}${REGISTRATION_PATH}`, {
+			method: "POST",
+			headers: { "Content-Type": "application/x-www-form-urlencoded" },
+			body: new URLSearchParams(body).toString()
+		});
+		const data = await response.json();
+		if (!response.ok && !data.error) throw new Error(`Feishu registration failed: HTTP ${response.status}`);
+		return data;
+	};
+	confirmRegistration = async ({ appId, appSecret, ownerOpenId, session }) => {
+		const botInfo = await this.probeBot({
+			appId,
+			appSecret,
+			domain: session.domain
+		});
+		const accountId = session.requestedAccountId?.trim() || appId;
+		this.store.saveAccount({
+			accountId,
+			appId,
+			appSecret,
+			domain: session.domain,
+			botName: botInfo.botName,
+			botOpenId: botInfo.botOpenId,
+			ownerOpenId,
+			savedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		return {
+			accountId,
+			notes: [...botInfo.botName ? [`Connected bot: ${botInfo.botName}`] : [], ...ownerOpenId ? [`Authorized initial user: ${ownerOpenId}`] : []],
+			pluginConfig: buildRegisteredFeishuChannelConfig({
+				config: session.currentConfig,
+				accountId,
+				domain: session.domain,
+				botName: botInfo.botName,
+				allowOpenId: ownerOpenId
+			})
+		};
+	};
+	probeBot = async ({ appId, appSecret, domain }) => {
+		const accessToken = readString((await (await this.fetchImpl(`${FEISHU_OPEN_BASE_URLS[domain]}/open-apis/auth/v3/tenant_access_token/internal`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				app_id: appId,
+				app_secret: appSecret
+			})
+		})).json()).tenant_access_token);
+		if (!accessToken) return {};
+		const botData = await (await this.fetchImpl(`${FEISHU_OPEN_BASE_URLS[domain]}/open-apis/bot/v3/info`, { headers: {
+			Authorization: `Bearer ${accessToken}`,
+			"Content-Type": "application/json"
+		} })).json();
+		const bot = this.readRecord(botData.bot) ?? this.readRecord(this.readRecord(botData.data)?.bot);
+		return {
+			botName: readString(bot?.app_name) ?? readString(bot?.bot_name),
+			botOpenId: readString(bot?.open_id)
+		};
+	};
+	readRecord = (value) => {
+		if (!value || typeof value !== "object" || Array.isArray(value)) return;
+		return value;
+	};
+	cleanupExpiredSessions = (now = Date.now()) => {
+		for (const [sessionId, session] of this.sessions.entries()) if (session.expiresAtMs <= now) this.sessions.delete(sessionId);
+	};
+};
+//#endregion
+export { FeishuRegistrationService };

package/dist/services/feishu-reply-chat.service.js

@@ -0,0 +1,92 @@
+import { NcpEventType } from "@nextclaw/ncp";
+import "@nextclaw/ncp-toolkit";
+//#region src/services/feishu-reply-chat.service.ts
+const TERMINAL_NCP_EVENT_TYPES = new Set([
+	NcpEventType.MessageCompleted,
+	NcpEventType.MessageFailed,
+	NcpEventType.RunFinished,
+	NcpEventType.RunError
+]);
+var NcpEventQueue = class {
+	events = [];
+	waiting = null;
+	closed = false;
+	push = (event) => {
+		if (this.closed) return;
+		const waiting = this.waiting;
+		if (waiting) {
+			this.waiting = null;
+			waiting({
+				value: event,
+				done: false
+			});
+			return;
+		}
+		this.events.push(event);
+	};
+	close = () => {
+		this.closed = true;
+		const waiting = this.waiting;
+		if (waiting) {
+			this.waiting = null;
+			waiting({
+				value: void 0,
+				done: true
+			});
+		}
+	};
+	[Symbol.asyncIterator] = () => ({ next: async () => {
+		const event = this.events.shift();
+		if (event) return {
+			value: event,
+			done: false
+		};
+		if (this.closed) return {
+			value: void 0,
+			done: true
+		};
+		return await new Promise((resolve) => {
+			this.waiting = resolve;
+		});
+	} });
+};
+function renderPartText(part) {
+	switch (part.type) {
+		case "text":
+		case "rich-text": return part.text;
+		case "source": return [
+			part.title ?? "",
+			part.url ?? "",
+			part.snippet ?? ""
+		].filter(Boolean).join("\n");
+		case "card": return (typeof part.payload.title === "string" ? part.payload.title.trim() : "") || JSON.stringify(part.payload);
+		case "action": return part.label.trim();
+		case "step-start": return part.title?.trim() ?? "";
+		case "file": return part.name ? `[file] ${part.name}` : "[file]";
+		default: return "";
+	}
+}
+var FeishuReplyChat = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	startTyping = async (_target) => {};
+	stopTyping = async (_target) => {};
+	sendError = async (target, message) => {
+		if (message.trim()) await this.sendText(target, message);
+	};
+	sendPart = async (target, part) => {
+		const text = renderPartText(part);
+		if (text.trim()) await this.sendText(target, text);
+	};
+	sendText = async (target, text) => {
+		const account = this.deps.resolveAccount(target);
+		await this.deps.sendText({
+			account,
+			conversationId: target.conversationId,
+			text
+		});
+	};
+};
+//#endregion
+export { FeishuReplyChat, NcpEventQueue, TERMINAL_NCP_EVENT_TYPES };

package/dist/services/feishu-sdk.service.d.ts

@@ -0,0 +1,75 @@
+import { FeishuRuntimeAccount } from "../types/feishu-extension.types.js";
+import * as Lark from "@larksuiteoapi/node-sdk";
+
+//#region src/services/feishu-sdk.service.d.ts
+type FeishuMessageClient = {
+  im: {
+    message: {
+      create: (params: {
+        params: {
+          receive_id_type: "chat_id";
+        };
+        data: {
+          receive_id: string;
+          content: string;
+          msg_type: "text";
+        };
+      }) => Promise<{
+        code?: number;
+        msg?: string;
+        data?: {
+          message_id?: string;
+        };
+      }>;
+    };
+    messageReaction: {
+      create: (params: {
+        path: {
+          message_id: string;
+        };
+        data: {
+          reaction_type: {
+            emoji_type: string;
+          };
+        };
+      }) => Promise<{
+        code?: number;
+        msg?: string;
+        data?: {
+          reaction_id?: string;
+        };
+      }>;
+      delete: (params: {
+        path: {
+          message_id: string;
+          reaction_id: string;
+        };
+      }) => Promise<{
+        code?: number;
+        msg?: string;
+      }>;
+    };
+  };
+};
+declare class FeishuSdkService {
+  readonly createClient: (account: FeishuRuntimeAccount) => FeishuMessageClient;
+  readonly createEventDispatcher: () => Lark.EventDispatcher;
+  readonly createWsClient: (account: FeishuRuntimeAccount) => Lark.WSClient;
+  readonly sendText: (params: {
+    account: FeishuRuntimeAccount;
+    chatId: string;
+    text: string;
+  }) => Promise<void>;
+  readonly addReaction: (params: {
+    account: FeishuRuntimeAccount;
+    messageId: string;
+    emojiType: string;
+  }) => Promise<string | null>;
+  readonly deleteReaction: (params: {
+    account: FeishuRuntimeAccount;
+    messageId: string;
+    reactionId: string;
+  }) => Promise<void>;
+}
+//#endregion
+export { FeishuSdkService };

package/dist/services/feishu-sdk.service.js

@@ -0,0 +1,50 @@
+import * as Lark from "@larksuiteoapi/node-sdk";
+//#region src/services/feishu-sdk.service.ts
+function resolveDomain(domain) {
+	return domain === "lark" ? Lark.Domain.Lark : Lark.Domain.Feishu;
+}
+function assertFeishuSuccess(response, fallback) {
+	if (response.code === 0 || response.code === void 0) return;
+	throw new Error(`${fallback}: ${response.msg ?? `code ${response.code}`}`);
+}
+var FeishuSdkService = class {
+	createClient = (account) => new Lark.Client({
+		appId: account.appId,
+		appSecret: account.appSecret,
+		appType: Lark.AppType.SelfBuild,
+		domain: resolveDomain(account.domain)
+	});
+	createEventDispatcher = () => new Lark.EventDispatcher({});
+	createWsClient = (account) => new Lark.WSClient({
+		appId: account.appId,
+		appSecret: account.appSecret,
+		domain: resolveDomain(account.domain),
+		loggerLevel: Lark.LoggerLevel.info
+	});
+	sendText = async (params) => {
+		assertFeishuSuccess(await this.createClient(params.account).im.message.create({
+			params: { receive_id_type: "chat_id" },
+			data: {
+				receive_id: params.chatId,
+				content: JSON.stringify({ text: params.text }),
+				msg_type: "text"
+			}
+		}), "Feishu send failed");
+	};
+	addReaction = async (params) => {
+		const response = await this.createClient(params.account).im.messageReaction.create({
+			path: { message_id: params.messageId },
+			data: { reaction_type: { emoji_type: params.emojiType } }
+		});
+		assertFeishuSuccess(response, "Feishu reaction failed");
+		return response.data?.reaction_id ?? null;
+	};
+	deleteReaction = async (params) => {
+		assertFeishuSuccess(await this.createClient(params.account).im.messageReaction.delete({ path: {
+			message_id: params.messageId,
+			reaction_id: params.reactionId
+		} }), "Feishu reaction delete failed");
+	};
+};
+//#endregion
+export { FeishuSdkService };

package/dist/stores/feishu-account.store.d.ts

@@ -0,0 +1,21 @@
+import { FeishuDomain } from "../types/feishu-extension.types.js";
+
+//#region src/stores/feishu-account.store.d.ts
+type StoredFeishuAccount = {
+  accountId: string;
+  appId: string;
+  appSecret: string;
+  domain: FeishuDomain;
+  botName?: string;
+  botOpenId?: string;
+  ownerOpenId?: string;
+  savedAt?: string;
+};
+type FeishuAccountStore = {
+  listAccountIds: () => string[];
+  loadAccount: (accountId: string) => StoredFeishuAccount | null;
+  saveAccount: (account: StoredFeishuAccount) => void;
+  deleteAccount: (accountId: string) => void;
+};
+//#endregion
+export { FeishuAccountStore };

package/dist/stores/feishu-account.store.js

@@ -0,0 +1,40 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+//#region src/stores/feishu-account.store.ts
+function resolveNextclawHome() {
+	const override = process.env.NEXTCLAW_HOME?.trim();
+	return resolve(override || join(homedir(), ".nextclaw"));
+}
+function resolveAccountsDir() {
+	return join(resolveNextclawHome(), "channels", "feishu", "accounts");
+}
+function toFileName(accountId) {
+	return `${encodeURIComponent(accountId)}.json`;
+}
+function readJsonFile(filePath) {
+	if (!existsSync(filePath)) return null;
+	try {
+		return JSON.parse(readFileSync(filePath, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+var FileFeishuAccountStore = class {
+	listAccountIds = () => {
+		if (!existsSync(resolveAccountsDir())) return [];
+		return readdirSync(resolveAccountsDir()).filter((entry) => entry.endsWith(".json")).map((entry) => decodeURIComponent(entry.slice(0, -5))).filter(Boolean);
+	};
+	loadAccount = (accountId) => {
+		return readJsonFile(join(resolveAccountsDir(), toFileName(accountId)));
+	};
+	saveAccount = (account) => {
+		mkdirSync(resolveAccountsDir(), { recursive: true });
+		writeFileSync(join(resolveAccountsDir(), toFileName(account.accountId)), JSON.stringify(account, null, 2));
+	};
+	deleteAccount = (accountId) => {
+		rmSync(join(resolveAccountsDir(), toFileName(accountId)), { force: true });
+	};
+};
+//#endregion
+export { FileFeishuAccountStore };

package/dist/types/feishu-extension.types.d.ts

@@ -0,0 +1,51 @@
+import { NcpEndpointEvent } from "@nextclaw/ncp";
+
+//#region src/types/feishu-extension.types.d.ts
+type FeishuDomain = "feishu" | "lark";
+type FeishuAccountConfig = {
+  enabled?: boolean;
+  name?: string;
+  domain?: FeishuDomain;
+  allowFrom?: string[];
+  groupPolicy?: "open" | "allowlist" | "disabled";
+  requireMention?: boolean;
+};
+type FeishuChannelConfig = {
+  enabled?: boolean;
+  defaultAccountId?: string;
+  domain?: FeishuDomain;
+  allowFrom?: string[];
+  groupPolicy?: "open" | "allowlist" | "disabled";
+  requireMention?: boolean;
+  accounts?: Record<string, FeishuAccountConfig>;
+};
+type FeishuInboundMessage = {
+  conversationId: string;
+  senderId: string;
+  text: string;
+  accountId: string;
+  peerKind: "direct" | "group";
+  messageId?: string;
+  raw?: unknown;
+};
+type FeishuRuntimeAccount = {
+  accountId: string;
+  appId: string;
+  appSecret: string;
+  domain: FeishuDomain;
+  enabled: boolean;
+  name?: string;
+  botOpenId?: string;
+  allowFrom: string[];
+  groupPolicy: "open" | "allowlist" | "disabled";
+  requireMention: boolean;
+};
+type FeishuChannelAdapterContract = {
+  configure: (config: FeishuChannelConfig) => Promise<void>;
+  start: () => Promise<void>;
+  stop: () => Promise<void>;
+  onMessage: (handler: (message: FeishuInboundMessage) => void | Promise<void>) => () => void;
+  sendNcpEvent: (event: NcpEndpointEvent) => Promise<void>;
+};
+//#endregion
+export { FeishuAccountConfig, FeishuChannelAdapterContract, FeishuChannelConfig, FeishuDomain, FeishuInboundMessage, FeishuRuntimeAccount };

package/dist/utils/feishu-config.utils.js

@@ -0,0 +1,79 @@
+//#region src/utils/feishu-config.utils.ts
+const FEISHU_CHANNEL_ID = "feishu";
+const DEFAULT_FEISHU_DOMAIN = "feishu";
+function toRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function readString(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function readStringArray(value) {
+	if (!Array.isArray(value)) return;
+	const values = value.map((entry) => readString(entry)).filter((entry) => Boolean(entry));
+	return values.length > 0 ? values : void 0;
+}
+function readDomain(value) {
+	return value === "lark" || value === "feishu" ? value : void 0;
+}
+function readGroupPolicy(value) {
+	return value === "open" || value === "allowlist" || value === "disabled" ? value : void 0;
+}
+function normalizeAccountConfig(value) {
+	const record = toRecord(value);
+	if (!record) return;
+	return {
+		enabled: typeof record.enabled === "boolean" ? record.enabled : void 0,
+		name: readString(record.name),
+		domain: readDomain(record.domain),
+		allowFrom: readStringArray(record.allowFrom),
+		groupPolicy: readGroupPolicy(record.groupPolicy),
+		requireMention: typeof record.requireMention === "boolean" ? record.requireMention : void 0
+	};
+}
+function normalizeFeishuChannelConfig(value) {
+	const record = toRecord(value);
+	if (!record) return {};
+	const accounts = {};
+	for (const [accountId, rawAccountConfig] of Object.entries(toRecord(record.accounts) ?? {})) {
+		const normalized = normalizeAccountConfig(rawAccountConfig);
+		if (normalized) accounts[accountId] = normalized;
+	}
+	return {
+		enabled: typeof record.enabled === "boolean" ? record.enabled : void 0,
+		defaultAccountId: readString(record.defaultAccountId),
+		domain: readDomain(record.domain),
+		allowFrom: readStringArray(record.allowFrom),
+		groupPolicy: readGroupPolicy(record.groupPolicy),
+		requireMention: typeof record.requireMention === "boolean" ? record.requireMention : void 0,
+		accounts: Object.keys(accounts).length > 0 ? accounts : void 0
+	};
+}
+function buildRegisteredFeishuChannelConfig({ accountId, allowOpenId, botName, config, domain }) {
+	const current = normalizeFeishuChannelConfig(config);
+	const currentAccount = current.accounts?.[accountId] ?? {};
+	const allowFrom = new Set([
+		...current.allowFrom ?? [],
+		...currentAccount.allowFrom ?? [],
+		...allowOpenId ? [allowOpenId] : []
+	]);
+	return {
+		...current,
+		enabled: true,
+		defaultAccountId: accountId,
+		domain: current.domain ?? domain,
+		accounts: {
+			...current.accounts ?? {},
+			[accountId]: {
+				...currentAccount,
+				enabled: true,
+				domain,
+				name: currentAccount.name ?? botName,
+				allowFrom: allowFrom.size > 0 ? [...allowFrom] : void 0
+			}
+		}
+	};
+}
+//#endregion
+export { DEFAULT_FEISHU_DOMAIN, FEISHU_CHANNEL_ID, buildRegisteredFeishuChannelConfig, normalizeFeishuChannelConfig };

package/dist/utils/feishu-message.utils.js

@@ -0,0 +1,44 @@
+//#region src/utils/feishu-message.utils.ts
+function readRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function readString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function parseTextContent(raw) {
+	if (!raw) return "";
+	try {
+		return readString(JSON.parse(raw).text) ?? "";
+	} catch {
+		return raw;
+	}
+}
+function readMentionOpenIds(value) {
+	if (!Array.isArray(value)) return [];
+	return value.map((entry) => readString(readRecord(readRecord(entry)?.id)?.open_id)).filter((entry) => Boolean(entry));
+}
+function parseFeishuInboundMessage(value) {
+	const event = value;
+	const chatId = readString(event.message?.chat_id);
+	const senderOpenId = readString(event.sender?.sender_id?.open_id);
+	if (!chatId || !senderOpenId || event.sender?.sender_type === "app") return null;
+	const text = parseTextContent(event.message?.content);
+	if (!text.trim()) return null;
+	return {
+		chatId,
+		senderOpenId,
+		text,
+		messageId: readString(event.message?.message_id),
+		chatType: readString(event.message?.chat_type) ?? "p2p",
+		mentionedOpenIds: readMentionOpenIds(event.message?.mentions)
+	};
+}
+function isFeishuGroupChat(chatType) {
+	return chatType !== "p2p";
+}
+function isFeishuBotMentioned(params) {
+	return Boolean(params.botOpenId && params.mentionedOpenIds.includes(params.botOpenId));
+}
+//#endregion
+export { isFeishuBotMentioned, isFeishuGroupChat, parseFeishuInboundMessage };