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

package/dist/src/domains.js

@@ -0,0 +1,14 @@
+//#region src/domains.ts
+function openPlatformDomain(domain) {
+	return domain === "lark" ? "https://open.larksuite.com" : "https://open.feishu.cn";
+}
+function wwwDomain(domain) {
+	return domain === "lark" ? "https://www.larksuite.com" : "https://www.feishu.cn";
+}
+function resolveDomainUrl(domain) {
+	if (domain === "feishu") return "https://open.feishu.cn";
+	if (domain === "lark") return "https://open.larksuite.com";
+	return domain.replace(/\/+$/, "");
+}
+//#endregion
+export { openPlatformDomain, resolveDomainUrl, wwwDomain };

package/dist/src/drive-schema.js

@@ -0,0 +1,41 @@
+import { Type } from "@sinclair/typebox";
+//#region src/drive-schema.ts
+const FileType = Type.Union([
+	Type.Literal("doc"),
+	Type.Literal("docx"),
+	Type.Literal("sheet"),
+	Type.Literal("bitable"),
+	Type.Literal("folder"),
+	Type.Literal("file"),
+	Type.Literal("mindnote"),
+	Type.Literal("shortcut")
+]);
+const FeishuDriveSchema = Type.Union([
+	Type.Object({
+		action: Type.Literal("list"),
+		folder_token: Type.Optional(Type.String({ description: "Folder token (optional, omit for root directory)" }))
+	}),
+	Type.Object({
+		action: Type.Literal("info"),
+		file_token: Type.String({ description: "File or folder token" }),
+		type: FileType
+	}),
+	Type.Object({
+		action: Type.Literal("create_folder"),
+		name: Type.String({ description: "Folder name" }),
+		folder_token: Type.Optional(Type.String({ description: "Parent folder token (optional, omit for root)" }))
+	}),
+	Type.Object({
+		action: Type.Literal("move"),
+		file_token: Type.String({ description: "File token to move" }),
+		type: FileType,
+		folder_token: Type.String({ description: "Target folder token" })
+	}),
+	Type.Object({
+		action: Type.Literal("delete"),
+		file_token: Type.String({ description: "File token to delete" }),
+		type: FileType
+	})
+]);
+//#endregion
+export { FeishuDriveSchema };

package/dist/src/drive.js

@@ -0,0 +1,126 @@
+import { jsonToolResult, toolExecutionErrorResult, unknownToolActionResult } from "./tool-result.js";
+import { createFeishuToolClient, resolveRegisteredFeishuToolsConfig } from "./tool-account.js";
+import { FeishuDriveSchema } from "./drive-schema.js";
+//#region src/drive.ts
+async function getRootFolderToken(client) {
+	const domain = client.domain ?? "https://open.feishu.cn";
+	const res = await client.httpInstance.get(`${domain}/open-apis/drive/explorer/v2/root_folder/meta`);
+	if (res.code !== 0) throw new Error(res.msg ?? "Failed to get root folder");
+	const token = res.data?.token;
+	if (!token) throw new Error("Root folder token not found");
+	return token;
+}
+async function listFolder(client, folderToken) {
+	const validFolderToken = folderToken && folderToken !== "0" ? folderToken : void 0;
+	const res = await client.drive.file.list({ params: validFolderToken ? { folder_token: validFolderToken } : {} });
+	if (res.code !== 0) throw new Error(res.msg);
+	return {
+		files: res.data?.files?.map((f) => ({
+			token: f.token,
+			name: f.name,
+			type: f.type,
+			url: f.url,
+			created_time: f.created_time,
+			modified_time: f.modified_time,
+			owner_id: f.owner_id
+		})) ?? [],
+		next_page_token: res.data?.next_page_token
+	};
+}
+async function getFileInfo(client, fileToken, folderToken) {
+	const res = await client.drive.file.list({ params: folderToken ? { folder_token: folderToken } : {} });
+	if (res.code !== 0) throw new Error(res.msg);
+	const file = res.data?.files?.find((f) => f.token === fileToken);
+	if (!file) throw new Error(`File not found: ${fileToken}`);
+	return {
+		token: file.token,
+		name: file.name,
+		type: file.type,
+		url: file.url,
+		created_time: file.created_time,
+		modified_time: file.modified_time,
+		owner_id: file.owner_id
+	};
+}
+async function createFolder(client, name, folderToken) {
+	let effectiveToken = folderToken && folderToken !== "0" ? folderToken : "0";
+	if (effectiveToken === "0") try {
+		effectiveToken = await getRootFolderToken(client);
+	} catch {}
+	const res = await client.drive.file.createFolder({ data: {
+		name,
+		folder_token: effectiveToken
+	} });
+	if (res.code !== 0) throw new Error(res.msg);
+	return {
+		token: res.data?.token,
+		url: res.data?.url
+	};
+}
+async function moveFile(client, fileToken, type, folderToken) {
+	const res = await client.drive.file.move({
+		path: { file_token: fileToken },
+		data: {
+			type,
+			folder_token: folderToken
+		}
+	});
+	if (res.code !== 0) throw new Error(res.msg);
+	return {
+		success: true,
+		task_id: res.data?.task_id
+	};
+}
+async function deleteFile(client, fileToken, type) {
+	const res = await client.drive.file.delete({
+		path: { file_token: fileToken },
+		params: { type }
+	});
+	if (res.code !== 0) throw new Error(res.msg);
+	return {
+		success: true,
+		task_id: res.data?.task_id
+	};
+}
+function registerFeishuDriveTools(api) {
+	if (!api.config) {
+		api.logger.debug?.("feishu_drive: No config available, skipping drive tools");
+		return;
+	}
+	if (!resolveRegisteredFeishuToolsConfig(api.config).drive) {
+		api.logger.debug?.("feishu_drive: drive tool disabled in config");
+		return;
+	}
+	api.registerTool((ctx) => {
+		const defaultAccountId = ctx.agentAccountId;
+		return {
+			name: "feishu_drive",
+			label: "Feishu Drive",
+			description: "Feishu cloud storage operations. Actions: list, info, create_folder, move, delete",
+			parameters: FeishuDriveSchema,
+			async execute(_toolCallId, params) {
+				const p = params;
+				try {
+					const client = createFeishuToolClient({
+						api,
+						executeParams: p,
+						defaultAccountId
+					});
+					switch (p.action) {
+						case "list": return jsonToolResult(await listFolder(client, p.folder_token));
+						case "info": return jsonToolResult(await getFileInfo(client, p.file_token));
+						case "create_folder": return jsonToolResult(await createFolder(client, p.name, p.folder_token));
+						case "move": return jsonToolResult(await moveFile(client, p.file_token, p.type, p.folder_token));
+						case "delete": return jsonToolResult(await deleteFile(client, p.file_token, p.type));
+						default: return unknownToolActionResult(p.action);
+					}
+				} catch (err) {
+					return toolExecutionErrorResult(err);
+				}
+			}
+		};
+	}, { name: "feishu_drive" });
+	api.logger.info?.(`feishu_drive: Registered feishu_drive tool`);
+}
+//#endregion
+export { registerFeishuDriveTools };

package/dist/src/dynamic-agent.js

@@ -0,0 +1,93 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+//#region src/dynamic-agent.ts
+/**
+* Check if a dynamic agent should be created for a DM user and create it if needed.
+* This creates a unique agent instance with its own workspace for each DM user.
+*/
+async function maybeCreateDynamicAgent(params) {
+	const { cfg, runtime, senderOpenId, dynamicCfg, log } = params;
+	const existingBindings = cfg.bindings ?? [];
+	if (existingBindings.some((b) => b.match?.channel === "feishu" && b.match?.peer?.kind === "direct" && b.match?.peer?.id === senderOpenId)) return {
+		created: false,
+		updatedCfg: cfg
+	};
+	if (dynamicCfg.maxAgents !== void 0) {
+		if ((cfg.agents?.list ?? []).filter((a) => a.id.startsWith("feishu-")).length >= dynamicCfg.maxAgents) {
+			log(`feishu: maxAgents limit (${dynamicCfg.maxAgents}) reached, not creating agent for ${senderOpenId}`);
+			return {
+				created: false,
+				updatedCfg: cfg
+			};
+		}
+	}
+	const agentId = `feishu-${senderOpenId}`;
+	if ((cfg.agents?.list ?? []).find((a) => a.id === agentId)) {
+		log(`feishu: agent "${agentId}" exists, adding missing binding for ${senderOpenId}`);
+		const updatedCfg = {
+			...cfg,
+			bindings: [...existingBindings, {
+				agentId,
+				match: {
+					channel: "feishu",
+					peer: {
+						kind: "direct",
+						id: senderOpenId
+					}
+				}
+			}]
+		};
+		await runtime.config.writeConfigFile(updatedCfg);
+		return {
+			created: true,
+			updatedCfg,
+			agentId
+		};
+	}
+	const workspaceTemplate = dynamicCfg.workspaceTemplate ?? "~/.openclaw/workspace-{agentId}";
+	const agentDirTemplate = dynamicCfg.agentDirTemplate ?? "~/.openclaw/agents/{agentId}/agent";
+	const workspace = resolveUserPath(workspaceTemplate.replace("{userId}", senderOpenId).replace("{agentId}", agentId));
+	const agentDir = resolveUserPath(agentDirTemplate.replace("{userId}", senderOpenId).replace("{agentId}", agentId));
+	log(`feishu: creating dynamic agent "${agentId}" for user ${senderOpenId}`);
+	log(`  workspace: ${workspace}`);
+	log(`  agentDir: ${agentDir}`);
+	await fs.promises.mkdir(workspace, { recursive: true });
+	await fs.promises.mkdir(agentDir, { recursive: true });
+	const updatedCfg = {
+		...cfg,
+		agents: {
+			...cfg.agents,
+			list: [...cfg.agents?.list ?? [], {
+				id: agentId,
+				workspace,
+				agentDir
+			}]
+		},
+		bindings: [...existingBindings, {
+			agentId,
+			match: {
+				channel: "feishu",
+				peer: {
+					kind: "direct",
+					id: senderOpenId
+				}
+			}
+		}]
+	};
+	await runtime.config.writeConfigFile(updatedCfg);
+	return {
+		created: true,
+		updatedCfg,
+		agentId
+	};
+}
+/**
+* Resolve a path that may start with ~ to the user's home directory.
+*/
+function resolveUserPath(p) {
+	if (p.startsWith("~/")) return path.join(os.homedir(), p.slice(2));
+	return p;
+}
+//#endregion
+export { maybeCreateDynamicAgent };

package/dist/src/external-keys.js

@@ -0,0 +1,13 @@
+//#region src/external-keys.ts
+const CONTROL_CHARS_RE = /[\u0000-\u001f\u007f]/;
+const MAX_EXTERNAL_KEY_LENGTH = 512;
+function normalizeFeishuExternalKey(value) {
+	if (typeof value !== "string") return;
+	const normalized = value.trim();
+	if (!normalized || normalized.length > MAX_EXTERNAL_KEY_LENGTH) return;
+	if (CONTROL_CHARS_RE.test(normalized)) return;
+	if (normalized.includes("/") || normalized.includes("\\") || normalized.includes("..")) return;
+	return normalized;
+}
+//#endregion
+export { normalizeFeishuExternalKey };

package/dist/src/feishu-fetch.js

@@ -0,0 +1,12 @@
+//#region src/feishu-fetch.ts
+const FEISHU_USER_AGENT = "nextclaw-feishu-plugin/0.2";
+function feishuFetch(url, init) {
+	const headers = new Headers(init?.headers);
+	if (!headers.has("User-Agent")) headers.set("User-Agent", FEISHU_USER_AGENT);
+	return fetch(url, {
+		...init,
+		headers
+	});
+}
+//#endregion
+export { feishuFetch };

package/dist/src/identity.js

@@ -0,0 +1,92 @@
+import { StringEnum, assertLarkOk, createToolContext, handleInvokeError, json, registerTool } from "./user-tool-helpers.js";
+import { resolveRegisteredFeishuToolsConfig } from "./tool-account.js";
+import { Type } from "@sinclair/typebox";
+//#region src/identity.ts
+const GetUserSchema = Type.Object({
+	user_id: Type.Optional(Type.String({ description: "用户 ID（如 ou_xxx）。不传时获取当前消息发送者本人信息。" })),
+	user_id_type: Type.Optional(StringEnum([
+		"open_id",
+		"union_id",
+		"user_id"
+	]))
+});
+const SearchUserSchema = Type.Object({
+	query: Type.String({ description: "搜索关键词，可匹配姓名、邮箱、手机号等。" }),
+	page_size: Type.Optional(Type.Integer({
+		description: "分页大小，默认 20，最大 200。",
+		minimum: 1,
+		maximum: 200
+	})),
+	page_token: Type.Optional(Type.String({ description: "翻页 token。" }))
+});
+function registerFeishuIdentityTools(api) {
+	if (!api.config) return;
+	if (!resolveRegisteredFeishuToolsConfig(api.config).identity) return;
+	registerFeishuGetUserTool(api);
+	registerFeishuSearchUserTool(api);
+}
+function registerFeishuGetUserTool(api) {
+	const { toolClient, log } = createToolContext(api, "feishu_get_user");
+	registerTool(api, {
+		name: "feishu_get_user",
+		label: "Feishu: Get User",
+		description: "获取飞书用户信息。不传 user_id 时默认获取当前消息发送者本人信息；传 user_id 时获取指定用户信息。",
+		parameters: GetUserSchema,
+		async execute(_toolCallId, params) {
+			const payload = params;
+			try {
+				const client = toolClient();
+				if (!payload.user_id) {
+					log.info("fetching current user info");
+					const response = await client.invoke("feishu_get_user.default", (sdk, opts) => sdk.authen.userInfo.get({}, opts), { as: "user" });
+					assertLarkOk(response);
+					return json({ user: response.data });
+				}
+				log.info(`fetching user ${payload.user_id}`);
+				const response = await client.invoke("feishu_get_user.default", (sdk, opts) => sdk.contact.user.get({
+					path: { user_id: payload.user_id },
+					params: { user_id_type: payload.user_id_type ?? "open_id" }
+				}, opts), { as: "user" });
+				assertLarkOk(response);
+				return json({ user: response.data?.user });
+			} catch (error) {
+				return handleInvokeError(error, api);
+			}
+		}
+	}, { name: "feishu_get_user" });
+}
+function registerFeishuSearchUserTool(api) {
+	const { toolClient, log } = createToolContext(api, "feishu_search_user");
+	registerTool(api, {
+		name: "feishu_search_user",
+		label: "Feishu: Search User",
+		description: "搜索飞书员工信息，返回姓名、部门、open_id 等结果。",
+		parameters: SearchUserSchema,
+		async execute(_toolCallId, params) {
+			const payload = params;
+			try {
+				const client = toolClient();
+				log.info(`search query="${payload.query}"`);
+				const response = await client.invokeByPath("feishu_search_user.default", "/open-apis/search/v1/user", {
+					method: "GET",
+					query: {
+						query: payload.query,
+						page_size: String(payload.page_size ?? 20),
+						...payload.page_token ? { page_token: payload.page_token } : {}
+					},
+					as: "user"
+				});
+				assertLarkOk(response);
+				return json({
+					users: response.data?.users ?? [],
+					has_more: response.data?.has_more ?? false,
+					page_token: response.data?.page_token
+				});
+			} catch (error) {
+				return handleInvokeError(error, api);
+			}
+		}
+	}, { name: "feishu_search_user" });
+}
+//#endregion
+export { registerFeishuIdentityTools };

package/dist/src/lark-ticket.js

@@ -0,0 +1,11 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/lark-ticket.ts
+const store = new AsyncLocalStorage();
+function withTicket(ticket, fn) {
+	return store.run(ticket, fn);
+}
+function getTicket() {
+	return store.getStore();
+}
+//#endregion
+export { getTicket, withTicket };

package/dist/src/media.d.ts

@@ -0,0 +1,75 @@
+import { ClawdbotConfig } from "./nextclaw-sdk/types.js";
+//#region src/media.d.ts
+type UploadImageResult = {
+  imageKey: string;
+};
+type UploadFileResult = {
+  fileKey: string;
+};
+type SendMediaResult = {
+  messageId: string;
+  chatId: string;
+};
+/**
+ * Upload an image to Feishu and get an image_key for sending.
+ * Supports: JPEG, PNG, WEBP, GIF, TIFF, BMP, ICO
+ */
+declare function uploadImageFeishu(params: {
+  cfg: ClawdbotConfig;
+  image: Buffer | string;
+  imageType?: "message" | "avatar";
+  accountId?: string;
+}): Promise<UploadImageResult>;
+/**
+ * Upload a file to Feishu and get a file_key for sending.
+ * Max file size: 30MB
+ */
+declare function uploadFileFeishu(params: {
+  cfg: ClawdbotConfig;
+  file: Buffer | string;
+  fileName: string;
+  fileType: "opus" | "mp4" | "pdf" | "doc" | "xls" | "ppt" | "stream";
+  duration?: number;
+  accountId?: string;
+}): Promise<UploadFileResult>;
+/**
+ * Send an image message using an image_key
+ */
+declare function sendImageFeishu(params: {
+  cfg: ClawdbotConfig;
+  to: string;
+  imageKey: string;
+  replyToMessageId?: string;
+  replyInThread?: boolean;
+  accountId?: string;
+}): Promise<SendMediaResult>;
+/**
+ * Send a file message using a file_key
+ */
+declare function sendFileFeishu(params: {
+  cfg: ClawdbotConfig;
+  to: string;
+  fileKey: string; /** Use "audio" for audio, "media" for video (mp4), "file" for documents */
+  msgType?: "file" | "audio" | "media";
+  replyToMessageId?: string;
+  replyInThread?: boolean;
+  accountId?: string;
+}): Promise<SendMediaResult>;
+/**
+ * Upload and send media (image or file) from URL, local path, or buffer.
+ * When mediaUrl is a local path, mediaLocalRoots (from core outbound context)
+ * must be passed so loadWebMedia allows the path (post CVE-2026-26321).
+ */
+declare function sendMediaFeishu(params: {
+  cfg: ClawdbotConfig;
+  to: string;
+  mediaUrl?: string;
+  mediaBuffer?: Buffer;
+  fileName?: string;
+  replyToMessageId?: string;
+  replyInThread?: boolean;
+  accountId?: string; /** Allowed roots for local path reads; required for local filePath to work. */
+  mediaLocalRoots?: readonly string[];
+}): Promise<SendMediaResult>;
+//#endregion
+export { sendFileFeishu, sendImageFeishu, sendMediaFeishu, uploadFileFeishu, uploadImageFeishu };