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

package/dist/src/task-subtask.js

@@ -0,0 +1,79 @@
+import { StringEnum, assertLarkOk, createToolContext, handleInvokeError, json, registerTool } from "./user-tool-helpers.js";
+import { normalizeTaskTime } from "./task-shared.js";
+import { Type } from "@sinclair/typebox";
+//#region src/task-subtask.ts
+const SubtaskSchema = Type.Union([Type.Object({
+	action: Type.Literal("create"),
+	task_guid: Type.String(),
+	summary: Type.String(),
+	description: Type.Optional(Type.String()),
+	due: Type.Optional(Type.Object({
+		timestamp: Type.String(),
+		is_all_day: Type.Optional(Type.Boolean())
+	})),
+	start: Type.Optional(Type.Object({
+		timestamp: Type.String(),
+		is_all_day: Type.Optional(Type.Boolean())
+	})),
+	members: Type.Optional(Type.Array(Type.Object({
+		id: Type.String(),
+		role: Type.Optional(StringEnum(["assignee", "follower"]))
+	})))
+}), Type.Object({
+	action: Type.Literal("list"),
+	task_guid: Type.String(),
+	page_size: Type.Optional(Type.Number()),
+	page_token: Type.Optional(Type.String())
+})]);
+function registerFeishuTaskSubtaskTool(api) {
+	const { toolClient } = createToolContext(api, "feishu_task_subtask");
+	registerTool(api, {
+		name: "feishu_task_subtask",
+		label: "Feishu Task Subtask",
+		description: "按本人身份创建、列出任务的子任务。",
+		parameters: SubtaskSchema,
+		async execute(_toolCallId, params) {
+			const payload = params;
+			try {
+				const client = toolClient();
+				if (payload.action === "create") {
+					const response = await client.invoke("feishu_task_subtask.create", (sdk, opts) => sdk.task.v2.taskSubtask.create({
+						path: { task_guid: payload.task_guid },
+						params: { user_id_type: "open_id" },
+						data: {
+							summary: payload.summary,
+							description: payload.description,
+							due: normalizeTaskTime(payload.due),
+							start: normalizeTaskTime(payload.start),
+							members: payload.members?.map((member) => ({
+								id: member.id,
+								type: "user",
+								role: member.role ?? "assignee"
+							}))
+						}
+					}, opts), { as: "user" });
+					assertLarkOk(response);
+					return json({ subtask: response.data?.subtask });
+				}
+				const response = await client.invoke("feishu_task_subtask.list", (sdk, opts) => sdk.task.v2.taskSubtask.list({
+					path: { task_guid: payload.task_guid },
+					params: {
+						page_size: payload.page_size,
+						page_token: payload.page_token,
+						user_id_type: "open_id"
+					}
+				}, opts), { as: "user" });
+				assertLarkOk(response);
+				return json({
+					subtasks: response.data?.items ?? [],
+					has_more: response.data?.has_more ?? false,
+					page_token: response.data?.page_token
+				});
+			} catch (error) {
+				return handleInvokeError(error, api);
+			}
+		}
+	}, { name: "feishu_task_subtask" });
+}
+//#endregion
+export { registerFeishuTaskSubtaskTool };

package/dist/src/task-task.js

@@ -0,0 +1,144 @@
+import { StringEnum, assertLarkOk, createToolContext, handleInvokeError, json, parseTimeToTimestampMs, registerTool } from "./user-tool-helpers.js";
+import { normalizeTaskTime } from "./task-shared.js";
+import { Type } from "@sinclair/typebox";
+//#region src/task-task.ts
+const TaskSchema = Type.Union([
+	Type.Object({
+		action: Type.Literal("create"),
+		summary: Type.String(),
+		current_user_id: Type.Optional(Type.String()),
+		description: Type.Optional(Type.String()),
+		due: Type.Optional(Type.Object({
+			timestamp: Type.String(),
+			is_all_day: Type.Optional(Type.Boolean())
+		})),
+		start: Type.Optional(Type.Object({
+			timestamp: Type.String(),
+			is_all_day: Type.Optional(Type.Boolean())
+		})),
+		members: Type.Optional(Type.Array(Type.Object({
+			id: Type.String(),
+			role: Type.Optional(StringEnum(["assignee", "follower"]))
+		}))),
+		tasklists: Type.Optional(Type.Array(Type.Object({
+			tasklist_guid: Type.String(),
+			section_guid: Type.Optional(Type.String())
+		}))),
+		repeat_rule: Type.Optional(Type.String())
+	}),
+	Type.Object({
+		action: Type.Literal("get"),
+		task_guid: Type.String()
+	}),
+	Type.Object({
+		action: Type.Literal("list"),
+		page_size: Type.Optional(Type.Number()),
+		page_token: Type.Optional(Type.String()),
+		completed: Type.Optional(Type.Boolean())
+	}),
+	Type.Object({
+		action: Type.Literal("patch"),
+		task_guid: Type.String(),
+		summary: Type.Optional(Type.String()),
+		description: Type.Optional(Type.String()),
+		due: Type.Optional(Type.Object({
+			timestamp: Type.String(),
+			is_all_day: Type.Optional(Type.Boolean())
+		})),
+		start: Type.Optional(Type.Object({
+			timestamp: Type.String(),
+			is_all_day: Type.Optional(Type.Boolean())
+		})),
+		completed_at: Type.Optional(Type.String()),
+		members: Type.Optional(Type.Array(Type.Object({
+			id: Type.String(),
+			role: Type.Optional(StringEnum(["assignee", "follower"]))
+		}))),
+		repeat_rule: Type.Optional(Type.String())
+	})
+]);
+function registerFeishuTaskTaskTool(api) {
+	const { toolClient } = createToolContext(api, "feishu_task_task");
+	registerTool(api, {
+		name: "feishu_task_task",
+		label: "Feishu Task",
+		description: "按本人身份创建、查询、列出、更新飞书任务。",
+		parameters: TaskSchema,
+		async execute(_toolCallId, params) {
+			const payload = params;
+			try {
+				const client = toolClient();
+				if (payload.action === "create") {
+					const members = [...payload.members ?? []];
+					if (payload.current_user_id && !members.some((member) => member.id === payload.current_user_id)) members.push({
+						id: payload.current_user_id,
+						role: "follower"
+					});
+					const response = await client.invoke("feishu_task_task.create", (sdk, opts) => sdk.task.v2.task.create({
+						params: { user_id_type: "open_id" },
+						data: {
+							summary: payload.summary,
+							description: payload.description,
+							due: normalizeTaskTime(payload.due),
+							start: normalizeTaskTime(payload.start),
+							repeat_rule: payload.repeat_rule,
+							members: members.length ? members.map((member) => ({
+								id: member.id,
+								type: "user",
+								role: member.role ?? "assignee"
+							})) : void 0,
+							tasklists: payload.tasklists
+						}
+					}, opts), { as: "user" });
+					assertLarkOk(response);
+					return json({ task: response.data?.task });
+				}
+				if (payload.action === "get") {
+					const response = await client.invoke("feishu_task_task.get", (sdk, opts) => sdk.task.v2.task.get({
+						path: { task_guid: payload.task_guid },
+						params: { user_id_type: "open_id" }
+					}, opts), { as: "user" });
+					assertLarkOk(response);
+					return json({ task: response.data?.task });
+				}
+				if (payload.action === "list") {
+					const response = await client.invoke("feishu_task_task.list", (sdk, opts) => sdk.task.v2.task.list({ params: {
+						page_size: payload.page_size,
+						page_token: payload.page_token,
+						completed: payload.completed,
+						user_id_type: "open_id"
+					} }, opts), { as: "user" });
+					assertLarkOk(response);
+					return json({
+						tasks: response.data?.items ?? [],
+						has_more: response.data?.has_more ?? false,
+						page_token: response.data?.page_token
+					});
+				}
+				const patchData = {};
+				if (payload.summary) patchData.summary = payload.summary;
+				if (payload.description) patchData.description = payload.description;
+				if (payload.due) patchData.due = normalizeTaskTime(payload.due);
+				if (payload.start) patchData.start = normalizeTaskTime(payload.start);
+				if (payload.repeat_rule) patchData.repeat_rule = payload.repeat_rule;
+				if (payload.completed_at !== void 0) patchData.completed_at = payload.completed_at === "0" ? "0" : /^\d+$/.test(payload.completed_at) ? payload.completed_at : parseTimeToTimestampMs(payload.completed_at);
+				if (payload.members) patchData.members = payload.members.map((member) => ({
+					id: member.id,
+					type: "user",
+					role: member.role ?? "assignee"
+				}));
+				const response = await client.invoke("feishu_task_task.patch", (sdk, opts) => sdk.task.v2.task.patch({
+					path: { task_guid: payload.task_guid },
+					params: { user_id_type: "open_id" },
+					data: patchData
+				}, opts), { as: "user" });
+				assertLarkOk(response);
+				return json({ task: response.data?.task });
+			} catch (error) {
+				return handleInvokeError(error, api);
+			}
+		}
+	}, { name: "feishu_task_task" });
+}
+//#endregion
+export { registerFeishuTaskTaskTool };

package/dist/src/task-tasklist.js

@@ -0,0 +1,136 @@
+import { StringEnum, assertLarkOk, createToolContext, handleInvokeError, json, registerTool } from "./user-tool-helpers.js";
+import { Type } from "@sinclair/typebox";
+//#region src/task-tasklist.ts
+const TasklistSchema = Type.Union([
+	Type.Object({
+		action: Type.Literal("create"),
+		name: Type.String(),
+		members: Type.Optional(Type.Array(Type.Object({
+			id: Type.String(),
+			role: Type.Optional(StringEnum(["editor", "viewer"]))
+		})))
+	}),
+	Type.Object({
+		action: Type.Literal("get"),
+		tasklist_guid: Type.String()
+	}),
+	Type.Object({
+		action: Type.Literal("list"),
+		page_size: Type.Optional(Type.Number()),
+		page_token: Type.Optional(Type.String())
+	}),
+	Type.Object({
+		action: Type.Literal("tasks"),
+		tasklist_guid: Type.String(),
+		page_size: Type.Optional(Type.Number()),
+		page_token: Type.Optional(Type.String()),
+		completed: Type.Optional(Type.Boolean())
+	}),
+	Type.Object({
+		action: Type.Literal("patch"),
+		tasklist_guid: Type.String(),
+		name: Type.Optional(Type.String())
+	}),
+	Type.Object({
+		action: Type.Literal("add_members"),
+		tasklist_guid: Type.String(),
+		members: Type.Array(Type.Object({
+			id: Type.String(),
+			role: Type.Optional(StringEnum(["editor", "viewer"]))
+		}))
+	})
+]);
+function registerFeishuTaskTasklistTool(api) {
+	const { toolClient } = createToolContext(api, "feishu_task_tasklist");
+	registerTool(api, {
+		name: "feishu_task_tasklist",
+		label: "Feishu Tasklist",
+		description: "按本人身份创建、查询和管理飞书任务清单。",
+		parameters: TasklistSchema,
+		async execute(_toolCallId, params) {
+			const payload = params;
+			try {
+				const client = toolClient();
+				if (payload.action === "create") {
+					const response = await client.invoke("feishu_task_tasklist.create", (sdk, opts) => sdk.task.v2.tasklist.create({
+						params: { user_id_type: "open_id" },
+						data: {
+							name: payload.name,
+							members: payload.members?.map((member) => ({
+								id: member.id,
+								type: "user",
+								role: member.role ?? "editor"
+							}))
+						}
+					}, opts), { as: "user" });
+					assertLarkOk(response);
+					return json({ tasklist: response.data?.tasklist });
+				}
+				if (payload.action === "get") {
+					const response = await client.invoke("feishu_task_tasklist.get", (sdk, opts) => sdk.task.v2.tasklist.get({
+						path: { tasklist_guid: payload.tasklist_guid },
+						params: { user_id_type: "open_id" }
+					}, opts), { as: "user" });
+					assertLarkOk(response);
+					return json({ tasklist: response.data?.tasklist });
+				}
+				if (payload.action === "list") {
+					const response = await client.invoke("feishu_task_tasklist.list", (sdk, opts) => sdk.task.v2.tasklist.list({ params: {
+						page_size: payload.page_size,
+						page_token: payload.page_token,
+						user_id_type: "open_id"
+					} }, opts), { as: "user" });
+					assertLarkOk(response);
+					return json({
+						tasklists: response.data?.items ?? [],
+						has_more: response.data?.has_more ?? false,
+						page_token: response.data?.page_token
+					});
+				}
+				if (payload.action === "tasks") {
+					const response = await client.invoke("feishu_task_tasklist.tasks", (sdk, opts) => sdk.task.v2.tasklist.tasks({
+						path: { tasklist_guid: payload.tasklist_guid },
+						params: {
+							page_size: payload.page_size,
+							page_token: payload.page_token,
+							completed: payload.completed,
+							user_id_type: "open_id"
+						}
+					}, opts), { as: "user" });
+					assertLarkOk(response);
+					return json({
+						tasks: response.data?.items ?? [],
+						has_more: response.data?.has_more ?? false,
+						page_token: response.data?.page_token
+					});
+				}
+				if (payload.action === "patch") {
+					const response = await client.invoke("feishu_task_tasklist.patch", (sdk, opts) => sdk.task.v2.tasklist.patch({
+						path: { tasklist_guid: payload.tasklist_guid },
+						params: { user_id_type: "open_id" },
+						data: { name: payload.name }
+					}, opts), { as: "user" });
+					assertLarkOk(response);
+					return json({ tasklist: response.data?.tasklist });
+				}
+				assertLarkOk(await client.invoke("feishu_task_tasklist.add_members", (sdk, opts) => sdk.task.v2.tasklist.addMembers({
+					path: { tasklist_guid: payload.tasklist_guid },
+					params: { user_id_type: "open_id" },
+					data: { members: (payload.members ?? []).map((member) => ({
+						id: member.id,
+						type: "user",
+						role: member.role ?? "editor"
+					})) }
+				}, opts), { as: "user" }));
+				return json({
+					success: true,
+					tasklist_guid: payload.tasklist_guid
+				});
+			} catch (error) {
+				return handleInvokeError(error, api);
+			}
+		}
+	}, { name: "feishu_task_tasklist" });
+}
+//#endregion
+export { registerFeishuTaskTasklistTool };

package/dist/src/task.js

@@ -0,0 +1,16 @@
+import { resolveRegisteredFeishuToolsConfig } from "./tool-account.js";
+import { registerFeishuTaskCommentTool } from "./task-comment.js";
+import { registerFeishuTaskSubtaskTool } from "./task-subtask.js";
+import { registerFeishuTaskTaskTool } from "./task-task.js";
+import { registerFeishuTaskTasklistTool } from "./task-tasklist.js";
+//#region src/task.ts
+function registerFeishuTaskTools(api) {
+	if (!api.config) return;
+	if (!resolveRegisteredFeishuToolsConfig(api.config).task) return;
+	registerFeishuTaskTaskTool(api);
+	registerFeishuTaskTasklistTool(api);
+	registerFeishuTaskCommentTool(api);
+	registerFeishuTaskSubtaskTool(api);
+}
+//#endregion
+export { registerFeishuTaskTools };

package/dist/src/token-store.js

@@ -0,0 +1,154 @@
+import { join } from "node:path";
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+import { homedir } from "node:os";
+import { chmod, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region src/token-store.ts
+const execFile$1 = promisify(execFile);
+const KEYCHAIN_SERVICE = "nextclaw-feishu-uat";
+const REFRESH_AHEAD_MS = 300 * 1e3;
+function accountKey(appId, userOpenId) {
+	return `${appId}:${userOpenId}`;
+}
+const darwinBackend = {
+	async get(service, account) {
+		try {
+			const { stdout } = await execFile$1("security", [
+				"find-generic-password",
+				"-s",
+				service,
+				"-a",
+				account,
+				"-w"
+			]);
+			return stdout.trim() || null;
+		} catch {
+			return null;
+		}
+	},
+	async set(service, account, data) {
+		try {
+			await execFile$1("security", [
+				"delete-generic-password",
+				"-s",
+				service,
+				"-a",
+				account
+			]);
+		} catch {}
+		await execFile$1("security", [
+			"add-generic-password",
+			"-s",
+			service,
+			"-a",
+			account,
+			"-w",
+			data
+		]);
+	},
+	async remove(service, account) {
+		try {
+			await execFile$1("security", [
+				"delete-generic-password",
+				"-s",
+				service,
+				"-a",
+				account
+			]);
+		} catch {}
+	}
+};
+const STORAGE_DIR = join(process.platform === "win32" ? process.env.LOCALAPPDATA ?? join(process.env.USERPROFILE ?? homedir(), "AppData", "Local") : process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share"), KEYCHAIN_SERVICE);
+const MASTER_KEY_PATH = join(STORAGE_DIR, "master.key");
+const MASTER_KEY_BYTES = 32;
+const IV_BYTES = 12;
+const TAG_BYTES = 16;
+function safeFileName(account) {
+	return account.replace(/[^a-zA-Z0-9._-]/g, "_") + ".enc";
+}
+async function ensureStorageDir() {
+	await mkdir(STORAGE_DIR, {
+		recursive: true,
+		mode: 448
+	});
+}
+async function getMasterKey() {
+	try {
+		const key = await readFile(MASTER_KEY_PATH);
+		if (key.length === MASTER_KEY_BYTES) return key;
+	} catch {}
+	await ensureStorageDir();
+	const key = randomBytes(MASTER_KEY_BYTES);
+	await writeFile(MASTER_KEY_PATH, key, { mode: 384 });
+	if (process.platform !== "win32") await chmod(MASTER_KEY_PATH, 384);
+	return key;
+}
+function encryptData(plaintext, key) {
+	const iv = randomBytes(IV_BYTES);
+	const cipher = createCipheriv("aes-256-gcm", key, iv);
+	const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+	return Buffer.concat([
+		iv,
+		cipher.getAuthTag(),
+		encrypted
+	]);
+}
+function decryptData(data, key) {
+	if (data.length < IV_BYTES + TAG_BYTES) return null;
+	try {
+		const iv = data.subarray(0, IV_BYTES);
+		const tag = data.subarray(IV_BYTES, IV_BYTES + TAG_BYTES);
+		const encrypted = data.subarray(IV_BYTES + TAG_BYTES);
+		const decipher = createDecipheriv("aes-256-gcm", key, iv);
+		decipher.setAuthTag(tag);
+		return Buffer.concat([decipher.update(encrypted), decipher.final()]).toString("utf8");
+	} catch {
+		return null;
+	}
+}
+const backend = process.platform === "darwin" ? darwinBackend : {
+	async get(_service, account) {
+		try {
+			const key = await getMasterKey();
+			return decryptData(await readFile(join(STORAGE_DIR, safeFileName(account))), key);
+		} catch {
+			return null;
+		}
+	},
+	async set(_service, account, data) {
+		const key = await getMasterKey();
+		await ensureStorageDir();
+		const filePath = join(STORAGE_DIR, safeFileName(account));
+		await writeFile(filePath, encryptData(data, key), { mode: 384 });
+		if (process.platform !== "win32") await chmod(filePath, 384);
+	},
+	async remove(_service, account) {
+		try {
+			await unlink(join(STORAGE_DIR, safeFileName(account)));
+		} catch {}
+	}
+};
+async function getStoredToken(appId, userOpenId) {
+	try {
+		const json = await backend.get(KEYCHAIN_SERVICE, accountKey(appId, userOpenId));
+		return json ? JSON.parse(json) : null;
+	} catch {
+		return null;
+	}
+}
+async function setStoredToken(token) {
+	const payload = JSON.stringify(token);
+	await backend.set(KEYCHAIN_SERVICE, accountKey(token.appId, token.userOpenId), payload);
+}
+async function removeStoredToken(appId, userOpenId) {
+	await backend.remove(KEYCHAIN_SERVICE, accountKey(appId, userOpenId));
+}
+function tokenStatus(token) {
+	const now = Date.now();
+	if (now < token.expiresAt - REFRESH_AHEAD_MS) return "valid";
+	if (now < token.refreshExpiresAt) return "needs_refresh";
+	return "expired";
+}
+//#endregion
+export { getStoredToken, removeStoredToken, setStoredToken, tokenStatus };

package/dist/src/tool-account.js

@@ -0,0 +1,65 @@
+import { listFeishuAccountIds, resolveFeishuAccount } from "./accounts.js";
+import { createFeishuClient } from "./client.js";
+import { getTicket } from "./lark-ticket.js";
+import { resolveToolsConfig } from "./tools-config.js";
+//#region src/tool-account.ts
+function normalizeOptionalAccountId(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+}
+function readConfiguredDefaultAccountId(config) {
+	const value = (config?.channels?.feishu)?.defaultAccount;
+	if (typeof value !== "string") return;
+	return normalizeOptionalAccountId(value);
+}
+function readTicketAccountId() {
+	return normalizeOptionalAccountId(getTicket()?.accountId);
+}
+function resolveFeishuToolAccount(params) {
+	if (!params.api.config) throw new Error("Feishu config unavailable");
+	return resolveFeishuAccount({
+		cfg: params.api.config,
+		accountId: normalizeOptionalAccountId(params.executeParams?.accountId) ?? readTicketAccountId() ?? readConfiguredDefaultAccountId(params.api.config) ?? normalizeOptionalAccountId(params.defaultAccountId)
+	});
+}
+function createFeishuToolClient(params) {
+	return createFeishuClient(resolveFeishuToolAccount(params));
+}
+function resolveAnyEnabledFeishuToolsConfig(accounts) {
+	const merged = {
+		doc: false,
+		chat: false,
+		wiki: false,
+		drive: false,
+		perm: false,
+		scopes: false,
+		calendar: false,
+		task: false,
+		sheets: false,
+		oauth: false,
+		identity: false
+	};
+	for (const account of accounts) {
+		const cfg = resolveToolsConfig(account.config.tools);
+		merged.doc = merged.doc || cfg.doc;
+		merged.chat = merged.chat || cfg.chat;
+		merged.wiki = merged.wiki || cfg.wiki;
+		merged.drive = merged.drive || cfg.drive;
+		merged.perm = merged.perm || cfg.perm;
+		merged.scopes = merged.scopes || cfg.scopes;
+		merged.calendar = merged.calendar || cfg.calendar;
+		merged.task = merged.task || cfg.task;
+		merged.sheets = merged.sheets || cfg.sheets;
+		merged.oauth = merged.oauth || cfg.oauth;
+		merged.identity = merged.identity || cfg.identity;
+	}
+	return merged;
+}
+function resolveRegisteredFeishuToolsConfig(config) {
+	return resolveAnyEnabledFeishuToolsConfig(listFeishuAccountIds(config).map((accountId) => resolveFeishuAccount({
+		cfg: config,
+		accountId
+	})));
+}
+//#endregion
+export { createFeishuToolClient, resolveFeishuToolAccount, resolveRegisteredFeishuToolsConfig };

package/dist/src/tool-result.js

@@ -0,0 +1,18 @@
+//#region src/tool-result.ts
+function jsonToolResult(data) {
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify(data, null, 2)
+		}],
+		details: data
+	};
+}
+function unknownToolActionResult(action) {
+	return jsonToolResult({ error: `Unknown action: ${String(action)}` });
+}
+function toolExecutionErrorResult(error) {
+	return jsonToolResult({ error: error instanceof Error ? error.message : String(error) });
+}
+//#endregion
+export { jsonToolResult, toolExecutionErrorResult, unknownToolActionResult };

package/dist/src/tool-scopes.js

@@ -0,0 +1,62 @@
+//#region src/tool-scopes.ts
+const TOOL_SCOPES = {
+	"feishu_get_user.default": ["contact:contact.base:readonly", "contact:user.base:readonly"],
+	"feishu_search_user.default": ["contact:user:search"],
+	"feishu_calendar_calendar.list": ["calendar:calendar:read"],
+	"feishu_calendar_calendar.get": ["calendar:calendar:read"],
+	"feishu_calendar_calendar.primary": ["calendar:calendar:read"],
+	"feishu_calendar_event.create": ["calendar:calendar.event:create", "calendar:calendar.event:update"],
+	"feishu_calendar_event.list": ["calendar:calendar.event:read"],
+	"feishu_calendar_event.get": ["calendar:calendar.event:read"],
+	"feishu_calendar_event.patch": ["calendar:calendar.event:update"],
+	"feishu_calendar_event.delete": ["calendar:calendar.event:delete"],
+	"feishu_calendar_event.instance_view": ["calendar:calendar.event:read"],
+	"feishu_calendar_event_attendee.create": ["calendar:calendar.event:update"],
+	"feishu_calendar_event_attendee.list": ["calendar:calendar.event:read"],
+	"feishu_calendar_freebusy.list": ["calendar:calendar.free_busy:read"],
+	"feishu_task_task.create": ["task:task:write", "task:task:writeonly"],
+	"feishu_task_task.get": ["task:task:read", "task:task:write"],
+	"feishu_task_task.list": ["task:task:read", "task:task:write"],
+	"feishu_task_task.patch": ["task:task:write", "task:task:writeonly"],
+	"feishu_task_tasklist.create": ["task:tasklist:write"],
+	"feishu_task_tasklist.get": ["task:tasklist:read", "task:tasklist:write"],
+	"feishu_task_tasklist.list": ["task:tasklist:read", "task:tasklist:write"],
+	"feishu_task_tasklist.tasks": ["task:tasklist:read", "task:tasklist:write"],
+	"feishu_task_tasklist.patch": ["task:tasklist:write"],
+	"feishu_task_tasklist.add_members": ["task:tasklist:write"],
+	"feishu_task_comment.create": ["task:comment:write"],
+	"feishu_task_comment.get": ["task:comment:read", "task:comment:write"],
+	"feishu_task_comment.list": ["task:comment:read", "task:comment:write"],
+	"feishu_task_subtask.create": ["task:task:write"],
+	"feishu_task_subtask.list": ["task:task:read", "task:task:write"],
+	"feishu_sheet.info": ["sheets:spreadsheet.meta:read", "sheets:spreadsheet:read"],
+	"feishu_sheet.read": ["sheets:spreadsheet.meta:read", "sheets:spreadsheet:read"],
+	"feishu_sheet.write": [
+		"sheets:spreadsheet.meta:read",
+		"sheets:spreadsheet:read",
+		"sheets:spreadsheet:create",
+		"sheets:spreadsheet:write_only"
+	],
+	"feishu_sheet.append": [
+		"sheets:spreadsheet.meta:read",
+		"sheets:spreadsheet:read",
+		"sheets:spreadsheet:create",
+		"sheets:spreadsheet:write_only"
+	],
+	"feishu_sheet.find": ["sheets:spreadsheet.meta:read", "sheets:spreadsheet:read"],
+	"feishu_sheet.create": [
+		"sheets:spreadsheet.meta:read",
+		"sheets:spreadsheet:read",
+		"sheets:spreadsheet:create",
+		"sheets:spreadsheet:write_only"
+	],
+	"feishu_sheet.export": ["docs:document:export"]
+};
+function getRequiredScopes(toolAction) {
+	return TOOL_SCOPES[toolAction] ?? [];
+}
+function getAllKnownScopes() {
+	return Array.from(new Set(Object.values(TOOL_SCOPES).flat())).sort();
+}
+//#endregion
+export { getAllKnownScopes, getRequiredScopes };