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

package/dist/src/onboarding.js

@@ -0,0 +1,381 @@
+import { DEFAULT_ACCOUNT_ID } from "./nextclaw-sdk/account-id.js";
+import { formatDocsLink } from "./nextclaw-sdk/core-pairing.js";
+import { hasConfiguredSecretInput } from "./nextclaw-sdk/secrets-core.js";
+import { buildSingleChannelSecretPromptState, mergeAllowFromEntries, setTopLevelChannelAllowFrom, setTopLevelChannelDmPolicyWithAllowFrom, setTopLevelChannelGroupPolicy, splitOnboardingEntries } from "./nextclaw-sdk/secrets-config.js";
+import { promptSingleChannelSecretInput } from "./nextclaw-sdk/secrets-prompt.js";
+import "./nextclaw-sdk/feishu.js";
+import { resolveFeishuCredentials } from "./accounts.js";
+import { probeFeishu } from "./probe.js";
+//#region src/onboarding.ts
+const channel = "feishu";
+function normalizeString(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function setFeishuDmPolicy(cfg, dmPolicy) {
+	return setTopLevelChannelDmPolicyWithAllowFrom({
+		cfg,
+		channel: "feishu",
+		dmPolicy
+	});
+}
+function setFeishuAllowFrom(cfg, allowFrom) {
+	return setTopLevelChannelAllowFrom({
+		cfg,
+		channel: "feishu",
+		allowFrom
+	});
+}
+async function promptFeishuAllowFrom(params) {
+	const existing = params.cfg.channels?.feishu?.allowFrom ?? [];
+	await params.prompter.note([
+		"Allowlist Feishu DMs by open_id or user_id.",
+		"You can find user open_id in Feishu admin console or via API.",
+		"Examples:",
+		"- ou_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+		"- on_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+	].join("\n"), "Feishu allowlist");
+	while (true) {
+		const entry = await params.prompter.text({
+			message: "Feishu allowFrom (user open_ids)",
+			placeholder: "ou_xxxxx, ou_yyyyy",
+			initialValue: existing[0] ? String(existing[0]) : void 0,
+			validate: (value) => String(value ?? "").trim() ? void 0 : "Required"
+		});
+		const parts = splitOnboardingEntries(String(entry));
+		if (parts.length === 0) {
+			await params.prompter.note("Enter at least one user.", "Feishu allowlist");
+			continue;
+		}
+		const unique = mergeAllowFromEntries(existing, parts);
+		return setFeishuAllowFrom(params.cfg, unique);
+	}
+}
+async function noteFeishuCredentialHelp(prompter) {
+	await prompter.note([
+		"1) Go to Feishu Open Platform (open.feishu.cn)",
+		"2) Create a self-built app",
+		"3) Get App ID and App Secret from Credentials page",
+		"4) Enable required permissions: im:message, im:chat, contact:user.base:readonly",
+		"5) Publish the app or add it to a test group",
+		"Tip: you can also set FEISHU_APP_ID / FEISHU_APP_SECRET env vars.",
+		`Docs: ${formatDocsLink("/channels/feishu", "feishu")}`
+	].join("\n"), "Feishu credentials");
+}
+async function promptFeishuAppId(params) {
+	return String(await params.prompter.text({
+		message: "Enter Feishu App ID",
+		initialValue: params.initialValue,
+		validate: (value) => value?.trim() ? void 0 : "Required"
+	})).trim();
+}
+function setFeishuGroupPolicy(cfg, groupPolicy) {
+	return setTopLevelChannelGroupPolicy({
+		cfg,
+		channel: "feishu",
+		groupPolicy,
+		enabled: true
+	});
+}
+function setFeishuGroupAllowFrom(cfg, groupAllowFrom) {
+	return {
+		...cfg,
+		channels: {
+			...cfg.channels,
+			feishu: {
+				...cfg.channels?.feishu,
+				groupAllowFrom
+			}
+		}
+	};
+}
+const feishuOnboardingAdapter = {
+	channel,
+	getStatus: async ({ cfg }) => {
+		const feishuCfg = cfg.channels?.feishu;
+		const isAppIdConfigured = (value) => {
+			if (normalizeString(value)) return true;
+			if (!value || typeof value !== "object") return false;
+			const rec = value;
+			const source = normalizeString(rec.source)?.toLowerCase();
+			const id = normalizeString(rec.id);
+			if (source === "env" && id) return Boolean(normalizeString(process.env[id]));
+			return hasConfiguredSecretInput(value);
+		};
+		const topLevelConfigured = Boolean(isAppIdConfigured(feishuCfg?.appId) && hasConfiguredSecretInput(feishuCfg?.appSecret));
+		const accountConfigured = Object.values(feishuCfg?.accounts ?? {}).some((account) => {
+			if (!account || typeof account !== "object") return false;
+			const hasOwnAppId = Object.prototype.hasOwnProperty.call(account, "appId");
+			const hasOwnAppSecret = Object.prototype.hasOwnProperty.call(account, "appSecret");
+			const accountAppIdConfigured = hasOwnAppId ? isAppIdConfigured(account.appId) : isAppIdConfigured(feishuCfg?.appId);
+			const accountSecretConfigured = hasOwnAppSecret ? hasConfiguredSecretInput(account.appSecret) : hasConfiguredSecretInput(feishuCfg?.appSecret);
+			return Boolean(accountAppIdConfigured && accountSecretConfigured);
+		});
+		const configured = topLevelConfigured || accountConfigured;
+		const resolvedCredentials = resolveFeishuCredentials(feishuCfg, { allowUnresolvedSecretRef: true });
+		let probeResult = null;
+		if (configured && resolvedCredentials) try {
+			probeResult = await probeFeishu(resolvedCredentials);
+		} catch {}
+		const statusLines = [];
+		if (!configured) statusLines.push("Feishu: needs app credentials");
+		else if (probeResult?.ok) statusLines.push(`Feishu: connected as ${probeResult.botName ?? probeResult.botOpenId ?? "bot"}`);
+		else statusLines.push("Feishu: configured (connection not verified)");
+		return {
+			channel,
+			configured,
+			statusLines,
+			selectionHint: configured ? "configured" : "needs app creds",
+			quickstartScore: configured ? 2 : 0
+		};
+	},
+	configure: async ({ cfg, prompter }) => {
+		const feishuCfg = cfg.channels?.feishu;
+		const resolved = resolveFeishuCredentials(feishuCfg, { allowUnresolvedSecretRef: true });
+		const hasConfigSecret = hasConfiguredSecretInput(feishuCfg?.appSecret);
+		const hasConfigCreds = Boolean(typeof feishuCfg?.appId === "string" && feishuCfg.appId.trim() && hasConfigSecret);
+		const appSecretPromptState = buildSingleChannelSecretPromptState({
+			accountConfigured: Boolean(resolved),
+			hasConfigToken: hasConfigSecret,
+			allowEnv: !hasConfigCreds && Boolean(process.env.FEISHU_APP_ID?.trim()),
+			envValue: process.env.FEISHU_APP_SECRET
+		});
+		let next = cfg;
+		let appId = null;
+		let appSecret = null;
+		let appSecretProbeValue = null;
+		if (!resolved) await noteFeishuCredentialHelp(prompter);
+		const appSecretResult = await promptSingleChannelSecretInput({
+			cfg: next,
+			prompter,
+			providerHint: "feishu",
+			credentialLabel: "App Secret",
+			accountConfigured: appSecretPromptState.accountConfigured,
+			canUseEnv: appSecretPromptState.canUseEnv,
+			hasConfigToken: appSecretPromptState.hasConfigToken,
+			envPrompt: "FEISHU_APP_ID + FEISHU_APP_SECRET detected. Use env vars?",
+			keepPrompt: "Feishu App Secret already configured. Keep it?",
+			inputPrompt: "Enter Feishu App Secret",
+			preferredEnvVar: "FEISHU_APP_SECRET"
+		});
+		if (appSecretResult.action === "use-env") next = {
+			...next,
+			channels: {
+				...next.channels,
+				feishu: {
+					...next.channels?.feishu,
+					enabled: true
+				}
+			}
+		};
+		else if (appSecretResult.action === "set") {
+			appSecret = appSecretResult.value;
+			appSecretProbeValue = appSecretResult.resolvedValue;
+			appId = await promptFeishuAppId({
+				prompter,
+				initialValue: normalizeString(feishuCfg?.appId) ?? normalizeString(process.env.FEISHU_APP_ID)
+			});
+		}
+		if (appId && appSecret) {
+			next = {
+				...next,
+				channels: {
+					...next.channels,
+					feishu: {
+						...next.channels?.feishu,
+						enabled: true,
+						appId,
+						appSecret
+					}
+				}
+			};
+			try {
+				const probe = await probeFeishu({
+					appId,
+					appSecret: appSecretProbeValue ?? void 0,
+					domain: (next.channels?.feishu)?.domain
+				});
+				if (probe.ok) await prompter.note(`Connected as ${probe.botName ?? probe.botOpenId ?? "bot"}`, "Feishu connection test");
+				else await prompter.note(`Connection failed: ${probe.error ?? "unknown error"}`, "Feishu connection test");
+			} catch (err) {
+				await prompter.note(`Connection test failed: ${String(err)}`, "Feishu connection test");
+			}
+		}
+		const currentMode = (next.channels?.feishu)?.connectionMode ?? "websocket";
+		const connectionMode = await prompter.select({
+			message: "Feishu connection mode",
+			options: [{
+				value: "websocket",
+				label: "WebSocket (default)"
+			}, {
+				value: "webhook",
+				label: "Webhook"
+			}],
+			initialValue: currentMode
+		});
+		next = {
+			...next,
+			channels: {
+				...next.channels,
+				feishu: {
+					...next.channels?.feishu,
+					connectionMode
+				}
+			}
+		};
+		if (connectionMode === "webhook") {
+			const currentVerificationToken = (next.channels?.feishu)?.verificationToken;
+			const verificationTokenPromptState = buildSingleChannelSecretPromptState({
+				accountConfigured: hasConfiguredSecretInput(currentVerificationToken),
+				hasConfigToken: hasConfiguredSecretInput(currentVerificationToken),
+				allowEnv: false
+			});
+			const verificationTokenResult = await promptSingleChannelSecretInput({
+				cfg: next,
+				prompter,
+				providerHint: "feishu-webhook",
+				credentialLabel: "verification token",
+				accountConfigured: verificationTokenPromptState.accountConfigured,
+				canUseEnv: verificationTokenPromptState.canUseEnv,
+				hasConfigToken: verificationTokenPromptState.hasConfigToken,
+				envPrompt: "",
+				keepPrompt: "Feishu verification token already configured. Keep it?",
+				inputPrompt: "Enter Feishu verification token",
+				preferredEnvVar: "FEISHU_VERIFICATION_TOKEN"
+			});
+			if (verificationTokenResult.action === "set") next = {
+				...next,
+				channels: {
+					...next.channels,
+					feishu: {
+						...next.channels?.feishu,
+						verificationToken: verificationTokenResult.value
+					}
+				}
+			};
+			const currentEncryptKey = (next.channels?.feishu)?.encryptKey;
+			const encryptKeyPromptState = buildSingleChannelSecretPromptState({
+				accountConfigured: hasConfiguredSecretInput(currentEncryptKey),
+				hasConfigToken: hasConfiguredSecretInput(currentEncryptKey),
+				allowEnv: false
+			});
+			const encryptKeyResult = await promptSingleChannelSecretInput({
+				cfg: next,
+				prompter,
+				providerHint: "feishu-webhook",
+				credentialLabel: "encrypt key",
+				accountConfigured: encryptKeyPromptState.accountConfigured,
+				canUseEnv: encryptKeyPromptState.canUseEnv,
+				hasConfigToken: encryptKeyPromptState.hasConfigToken,
+				envPrompt: "",
+				keepPrompt: "Feishu encrypt key already configured. Keep it?",
+				inputPrompt: "Enter Feishu encrypt key",
+				preferredEnvVar: "FEISHU_ENCRYPT_KEY"
+			});
+			if (encryptKeyResult.action === "set") next = {
+				...next,
+				channels: {
+					...next.channels,
+					feishu: {
+						...next.channels?.feishu,
+						encryptKey: encryptKeyResult.value
+					}
+				}
+			};
+			const currentWebhookPath = (next.channels?.feishu)?.webhookPath;
+			const webhookPath = String(await prompter.text({
+				message: "Feishu webhook path",
+				initialValue: currentWebhookPath ?? "/feishu/events",
+				validate: (value) => String(value ?? "").trim() ? void 0 : "Required"
+			})).trim();
+			next = {
+				...next,
+				channels: {
+					...next.channels,
+					feishu: {
+						...next.channels?.feishu,
+						webhookPath
+					}
+				}
+			};
+		}
+		const currentDomain = (next.channels?.feishu)?.domain ?? "feishu";
+		const domain = await prompter.select({
+			message: "Which Feishu domain?",
+			options: [{
+				value: "feishu",
+				label: "Feishu (feishu.cn) - China"
+			}, {
+				value: "lark",
+				label: "Lark (larksuite.com) - International"
+			}],
+			initialValue: currentDomain
+		});
+		if (domain) next = {
+			...next,
+			channels: {
+				...next.channels,
+				feishu: {
+					...next.channels?.feishu,
+					domain
+				}
+			}
+		};
+		const groupPolicy = await prompter.select({
+			message: "Group chat policy",
+			options: [
+				{
+					value: "allowlist",
+					label: "Allowlist - only respond in specific groups"
+				},
+				{
+					value: "open",
+					label: "Open - respond in all groups (requires mention)"
+				},
+				{
+					value: "disabled",
+					label: "Disabled - don't respond in groups"
+				}
+			],
+			initialValue: (next.channels?.feishu)?.groupPolicy ?? "allowlist"
+		});
+		if (groupPolicy) next = setFeishuGroupPolicy(next, groupPolicy);
+		if (groupPolicy === "allowlist") {
+			const existing = (next.channels?.feishu)?.groupAllowFrom ?? [];
+			const entry = await prompter.text({
+				message: "Group chat allowlist (chat_ids)",
+				placeholder: "oc_xxxxx, oc_yyyyy",
+				initialValue: existing.length > 0 ? existing.map(String).join(", ") : void 0
+			});
+			if (entry) {
+				const parts = splitOnboardingEntries(String(entry));
+				if (parts.length > 0) next = setFeishuGroupAllowFrom(next, parts);
+			}
+		}
+		return {
+			cfg: next,
+			accountId: DEFAULT_ACCOUNT_ID
+		};
+	},
+	dmPolicy: {
+		label: "Feishu",
+		channel,
+		policyKey: "channels.feishu.dmPolicy",
+		allowFromKey: "channels.feishu.allowFrom",
+		getCurrent: (cfg) => (cfg.channels?.feishu)?.dmPolicy ?? "pairing",
+		setPolicy: (cfg, policy) => setFeishuDmPolicy(cfg, policy),
+		promptAllowFrom: promptFeishuAllowFrom
+	},
+	disable: (cfg) => ({
+		...cfg,
+		channels: {
+			...cfg.channels,
+			feishu: {
+				...cfg.channels?.feishu,
+				enabled: false
+			}
+		}
+	})
+};
+//#endregion
+export { feishuOnboardingAdapter };

package/dist/src/outbound.js

@@ -0,0 +1,150 @@
+import { resolveFeishuAccount } from "./accounts.js";
+import { getFeishuRuntime } from "./runtime.js";
+import { sendMediaFeishu } from "./media.js";
+import { sendMarkdownCardFeishu, sendMessageFeishu } from "./send.js";
+import fs from "fs";
+import path from "path";
+//#region src/outbound.ts
+function normalizePossibleLocalImagePath(text) {
+	const raw = text?.trim();
+	if (!raw) return null;
+	if (/\s/.test(raw)) return null;
+	if (/^(https?:\/\/|data:|file:\/\/)/i.test(raw)) return null;
+	const ext = path.extname(raw).toLowerCase();
+	if (![
+		".jpg",
+		".jpeg",
+		".png",
+		".gif",
+		".webp",
+		".bmp",
+		".ico",
+		".tiff"
+	].includes(ext)) return null;
+	if (!path.isAbsolute(raw)) return null;
+	if (!fs.existsSync(raw)) return null;
+	try {
+		if (!fs.statSync(raw).isFile()) return null;
+	} catch {
+		return null;
+	}
+	return raw;
+}
+function shouldUseCard(text) {
+	return /```[\s\S]*?```/.test(text) || /\|.+\|[\r\n]+\|[-:| ]+\|/.test(text);
+}
+function resolveReplyToMessageId(params) {
+	const replyToId = params.replyToId?.trim();
+	if (replyToId) return replyToId;
+	if (params.threadId == null) return;
+	return String(params.threadId).trim() || void 0;
+}
+async function sendOutboundText(params) {
+	const { cfg, to, text, accountId, replyToMessageId } = params;
+	const renderMode = resolveFeishuAccount({
+		cfg,
+		accountId
+	}).config?.renderMode ?? "auto";
+	if (renderMode === "card" || renderMode === "auto" && shouldUseCard(text)) return sendMarkdownCardFeishu({
+		cfg,
+		to,
+		text,
+		accountId,
+		replyToMessageId
+	});
+	return sendMessageFeishu({
+		cfg,
+		to,
+		text,
+		accountId,
+		replyToMessageId
+	});
+}
+const feishuOutbound = {
+	deliveryMode: "direct",
+	chunker: (text, limit) => getFeishuRuntime().channel.text.chunkMarkdownText(text, limit),
+	chunkerMode: "markdown",
+	textChunkLimit: 4e3,
+	sendText: async ({ cfg, to, text, accountId, replyToId, threadId, mediaLocalRoots }) => {
+		const replyToMessageId = resolveReplyToMessageId({
+			replyToId,
+			threadId
+		});
+		const localImagePath = normalizePossibleLocalImagePath(text);
+		if (localImagePath) try {
+			return {
+				channel: "feishu",
+				...await sendMediaFeishu({
+					cfg,
+					to,
+					mediaUrl: localImagePath,
+					accountId: accountId ?? void 0,
+					replyToMessageId,
+					mediaLocalRoots
+				})
+			};
+		} catch (err) {
+			console.error(`[feishu] local image path auto-send failed:`, err);
+		}
+		return {
+			channel: "feishu",
+			...await sendOutboundText({
+				cfg,
+				to,
+				text,
+				accountId: accountId ?? void 0,
+				replyToMessageId
+			})
+		};
+	},
+	sendMedia: async ({ cfg, to, text, mediaUrl, accountId, mediaLocalRoots, replyToId, threadId }) => {
+		const replyToMessageId = resolveReplyToMessageId({
+			replyToId,
+			threadId
+		});
+		if (text?.trim()) await sendOutboundText({
+			cfg,
+			to,
+			text,
+			accountId: accountId ?? void 0,
+			replyToMessageId
+		});
+		if (mediaUrl) try {
+			return {
+				channel: "feishu",
+				...await sendMediaFeishu({
+					cfg,
+					to,
+					mediaUrl,
+					accountId: accountId ?? void 0,
+					mediaLocalRoots,
+					replyToMessageId
+				})
+			};
+		} catch (err) {
+			console.error(`[feishu] sendMediaFeishu failed:`, err);
+			return {
+				channel: "feishu",
+				...await sendOutboundText({
+					cfg,
+					to,
+					text: `📎 ${mediaUrl}`,
+					accountId: accountId ?? void 0,
+					replyToMessageId
+				})
+			};
+		}
+		return {
+			channel: "feishu",
+			...await sendOutboundText({
+				cfg,
+				to,
+				text: text ?? "",
+				accountId: accountId ?? void 0,
+				replyToMessageId
+			})
+		};
+	}
+};
+//#endregion
+export { feishuOutbound };

package/dist/src/perm-schema.js

@@ -0,0 +1,49 @@
+import { Type } from "@sinclair/typebox";
+//#region src/perm-schema.ts
+const TokenType = Type.Union([
+	Type.Literal("doc"),
+	Type.Literal("docx"),
+	Type.Literal("sheet"),
+	Type.Literal("bitable"),
+	Type.Literal("folder"),
+	Type.Literal("file"),
+	Type.Literal("wiki"),
+	Type.Literal("mindnote")
+]);
+const MemberType = Type.Union([
+	Type.Literal("email"),
+	Type.Literal("openid"),
+	Type.Literal("userid"),
+	Type.Literal("unionid"),
+	Type.Literal("openchat"),
+	Type.Literal("opendepartmentid")
+]);
+const Permission = Type.Union([
+	Type.Literal("view"),
+	Type.Literal("edit"),
+	Type.Literal("full_access")
+]);
+const FeishuPermSchema = Type.Union([
+	Type.Object({
+		action: Type.Literal("list"),
+		token: Type.String({ description: "File token" }),
+		type: TokenType
+	}),
+	Type.Object({
+		action: Type.Literal("add"),
+		token: Type.String({ description: "File token" }),
+		type: TokenType,
+		member_type: MemberType,
+		member_id: Type.String({ description: "Member ID (email, open_id, user_id, etc.)" }),
+		perm: Permission
+	}),
+	Type.Object({
+		action: Type.Literal("remove"),
+		token: Type.String({ description: "File token" }),
+		type: TokenType,
+		member_type: MemberType,
+		member_id: Type.String({ description: "Member ID to remove" })
+	})
+]);
+//#endregion
+export { FeishuPermSchema };

package/dist/src/perm.js

@@ -0,0 +1,90 @@
+import { jsonToolResult, toolExecutionErrorResult, unknownToolActionResult } from "./tool-result.js";
+import { createFeishuToolClient, resolveRegisteredFeishuToolsConfig } from "./tool-account.js";
+import { FeishuPermSchema } from "./perm-schema.js";
+//#region src/perm.ts
+async function listMembers(client, token, type) {
+	const res = await client.drive.permissionMember.list({
+		path: { token },
+		params: { type }
+	});
+	if (res.code !== 0) throw new Error(res.msg);
+	return { members: res.data?.items?.map((m) => ({
+		member_type: m.member_type,
+		member_id: m.member_id,
+		perm: m.perm,
+		name: m.name
+	})) ?? [] };
+}
+async function addMember(client, token, type, memberType, memberId, perm) {
+	const res = await client.drive.permissionMember.create({
+		path: { token },
+		params: {
+			type,
+			need_notification: false
+		},
+		data: {
+			member_type: memberType,
+			member_id: memberId,
+			perm
+		}
+	});
+	if (res.code !== 0) throw new Error(res.msg);
+	return {
+		success: true,
+		member: res.data?.member
+	};
+}
+async function removeMember(client, token, type, memberType, memberId) {
+	const res = await client.drive.permissionMember.delete({
+		path: {
+			token,
+			member_id: memberId
+		},
+		params: {
+			type,
+			member_type: memberType
+		}
+	});
+	if (res.code !== 0) throw new Error(res.msg);
+	return { success: true };
+}
+function registerFeishuPermTools(api) {
+	if (!api.config) {
+		api.logger.debug?.("feishu_perm: No config available, skipping perm tools");
+		return;
+	}
+	if (!resolveRegisteredFeishuToolsConfig(api.config).perm) {
+		api.logger.debug?.("feishu_perm: perm tool disabled in config (default: false)");
+		return;
+	}
+	api.registerTool((ctx) => {
+		const defaultAccountId = ctx.agentAccountId;
+		return {
+			name: "feishu_perm",
+			label: "Feishu Perm",
+			description: "Feishu permission management. Actions: list, add, remove",
+			parameters: FeishuPermSchema,
+			async execute(_toolCallId, params) {
+				const p = params;
+				try {
+					const client = createFeishuToolClient({
+						api,
+						executeParams: p,
+						defaultAccountId
+					});
+					switch (p.action) {
+						case "list": return jsonToolResult(await listMembers(client, p.token, p.type));
+						case "add": return jsonToolResult(await addMember(client, p.token, p.type, p.member_type, p.member_id, p.perm));
+						case "remove": return jsonToolResult(await removeMember(client, p.token, p.type, p.member_type, p.member_id));
+						default: return unknownToolActionResult(p.action);
+					}
+				} catch (err) {
+					return toolExecutionErrorResult(err);
+				}
+			}
+		};
+	}, { name: "feishu_perm" });
+	api.logger.info?.(`feishu_perm: Registered feishu_perm tool`);
+}
+//#endregion
+export { registerFeishuPermTools };