feishu-mcp 0.2.2 → 0.2.7

package/dist/modules/task/tools/taskTools.js

@@ -0,0 +1,93 @@
+import { formatErrorMessage } from '../../../utils/error.js';
+import { Logger } from '../../../utils/logger.js';
+import { errorResponse } from '../../document/tools/toolHelpers.js';
+import { createTasks, listTasks, updateTask, deleteTasks } from '../toolApi/index.js';
+import { TaskGuidSchema, TaskSummarySchema, TaskDescriptionSchema, TaskTimestampSchema, TaskIsAllDaySchema, TaskRepeatRuleSchema, TaskCompletedAtSchema, TaskModeSchema, TaskIsMilestoneSchema, TaskCreateBatchSchema, TaskAssigneeIdsSchema, TaskFollowerIdsSchema, TaskReminderRelativeMinutesSchema, TaskReminderIdsSchema, TaskListPageTokenSchema, TaskListCompletedSchema, TaskDeleteBatchSchema, } from '../../../types/taskSchema.js';
+/**
+ * Registers Feishu task MCP tools.
+ */
+export function registerTaskTools(server, feishuService) {
+    server.tool('list_feishu_tasks', 'Lists tasks assigned to the current user ("我负责的"). Returns up to 100 items per call (2 pages of 50). Optional pageToken for next page, optional completed (true=done only, false=todo only). Response includes slimmed task fields: guid, summary, description, due, reminders, creator, members, status, task_id, url, etc. Requires user_access_token.', {
+        pageToken: TaskListPageTokenSchema,
+        completed: TaskListCompletedSchema,
+    }, async ({ pageToken, completed }) => {
+        try {
+            const result = await listTasks({ pageToken, completed }, feishuService);
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            Logger.error('列取任务失败:', error);
+            return errorResponse(`列取任务失败: ${formatErrorMessage(error)}`);
+        }
+    });
+    server.tool('create_feishu_task', 'Batch creates Feishu tasks or nested subtasks. Pass an array of task items; each item has summary (required), optional description/due/members/repeat_rule/start/mode/is_milestone, optional parentTaskGuid (create under existing task), and optional subTasks (nested subtasks, multi-level). Use open_id from get_feishu_users for assignees. Min 1, max 50 top-level items; max 50 subTasks per level. Returns nested results and path-indexed errors.', {
+        tasks: TaskCreateBatchSchema,
+    }, async ({ tasks: taskItems }) => {
+        try {
+            const result = await createTasks(taskItems, feishuService);
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            Logger.error('批量创建任务失败:', error);
+            return errorResponse(`批量创建任务失败: ${formatErrorMessage(error)}`);
+        }
+    });
+    server.tool('update_feishu_task', 'Updates an existing Feishu task. Provide task_guid and the fields to change. Supports summary, description, due, completed_at (use "0" to restore to unfinished), repeat_rule, start, mode, is_milestone. Also supports addAssigneeIds/addFollowerIds and removeAssigneeIds/removeFollowerIds for members; addReminderRelativeMinutes to add a reminder (task must have due; only one per task—remove first if needed) and removeReminderIds (from task.reminders[].id) to remove reminders. At least one update is required.', {
+        taskGuid: TaskGuidSchema,
+        summary: TaskSummarySchema.optional(),
+        description: TaskDescriptionSchema,
+        dueTimestamp: TaskTimestampSchema,
+        isDueAllDay: TaskIsAllDaySchema,
+        completedAt: TaskCompletedAtSchema,
+        repeatRule: TaskRepeatRuleSchema,
+        startTimestamp: TaskTimestampSchema,
+        isStartAllDay: TaskIsAllDaySchema,
+        mode: TaskModeSchema,
+        isMilestone: TaskIsMilestoneSchema,
+        addAssigneeIds: TaskAssigneeIdsSchema,
+        addFollowerIds: TaskFollowerIdsSchema,
+        removeAssigneeIds: TaskAssigneeIdsSchema,
+        removeFollowerIds: TaskFollowerIdsSchema,
+        addReminderRelativeMinutes: TaskReminderRelativeMinutesSchema,
+        removeReminderIds: TaskReminderIdsSchema,
+    }, async ({ taskGuid, summary, description, dueTimestamp, isDueAllDay, completedAt, repeatRule, startTimestamp, isStartAllDay, mode, isMilestone, addAssigneeIds, addFollowerIds, removeAssigneeIds, removeFollowerIds, addReminderRelativeMinutes, removeReminderIds, }) => {
+        try {
+            const result = await updateTask({
+                taskGuid,
+                summary,
+                description,
+                dueTimestamp,
+                isDueAllDay,
+                completedAt,
+                repeatRule,
+                startTimestamp,
+                isStartAllDay,
+                mode,
+                isMilestone,
+                addAssigneeIds,
+                addFollowerIds,
+                removeAssigneeIds,
+                removeFollowerIds,
+                addReminderRelativeMinutes,
+                removeReminderIds,
+            }, feishuService);
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            Logger.error('更新任务失败:', error);
+            return errorResponse(`更新任务失败: ${formatErrorMessage(error)}`);
+        }
+    });
+    server.tool('delete_feishu_task', 'Deletes one or more Feishu tasks by task_guid. Pass an array of task GUIDs (min 1, max 50). Requires edit permission on each task. Returns deleted guids and per-item errors. Deleted tasks cannot be retrieved.', {
+        taskGuids: TaskDeleteBatchSchema,
+    }, async ({ taskGuids }) => {
+        try {
+            const result = await deleteTasks(taskGuids, feishuService);
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            Logger.error('删除任务失败:', error);
+            return errorResponse(`删除任务失败: ${formatErrorMessage(error)}`);
+        }
+    });
+}

package/dist/server.js

@@ -47,25 +47,20 @@ export class FeishuMcpServer {
     async connect(transport) {
         const server = new FeishuMcp();
         await server.connect(transport);
+        const shutdown = () => {
+            TokenRefreshManager.getInstance().stop();
+            this.stopCallbackServer();
+            process.exit(0);
+        };
         // 监听 transport 关闭事件，清理 callback 服务器
         // 对于 stdio 模式，监听 stdin 关闭事件
         if (process.stdin && typeof process.stdin.on === 'function') {
-            process.stdin.on('close', () => {
-                this.stopCallbackServer();
-            });
-            process.stdin.on('end', () => {
-                this.stopCallbackServer();
-            });
+            process.stdin.on('close', shutdown);
+            process.stdin.on('end', shutdown);
         }
         // 监听进程退出事件，确保清理资源
-        process.on('SIGINT', () => {
-            this.stopCallbackServer();
-            process.exit(0);
-        });
-        process.on('SIGTERM', () => {
-            this.stopCallbackServer();
-            process.exit(0);
-        });
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
         // 注意：在 stdio 模式下，Logger 会自动禁用输出，避免污染 MCP 协议
         // 如果需要日志，可以通过 MCP 协议的 logging 消息传递
         Logger.info('Server connected and ready to process requests');
@@ -98,32 +93,41 @@ export class FeishuMcpServer {
                 });
                 // Check for existing session ID
                 const sessionId = req.headers['mcp-session-id'];
+                // 优先使用客户端显式传入的 ?userKey=，若不传则在 session 初始化时 fallback 到 sessionId
+                const queryUserKey = req.query.userKey;
                 let transport;
+                let userKey;
                 if (sessionId && transports[sessionId]) {
-                    // Reuse existing transport
+                    // Reuse existing transport，从 userAuthManager 取回持久化的 userKey
                     Logger.log("Reusing existing StreamableHTTP transport for sessionId", sessionId);
                     transport = transports[sessionId];
+                    userKey = this.userAuthManager.getUserKeyBySessionId(sessionId) || sessionId;
                 }
                 else if (!sessionId && isInitializeRequest(req.body)) {
                     // New initialization request
                     transport = new StreamableHTTPServerTransport({
                         sessionIdGenerator: () => randomUUID(),
-                        onsessioninitialized: (sessionId) => {
-                            // Store the transport by session ID
-                            Logger.log(`[StreamableHTTP connection] ${sessionId}`);
-                            transports[sessionId] = transport;
+                        onsessioninitialized: (newSessionId) => {
+                            // 建立 sessionId → userKey 持久映射：优先用客户端传入的，否则用 sessionId 兜底
+                            const resolvedUserKey = queryUserKey || newSessionId;
+                            this.userAuthManager.createSession(newSessionId, resolvedUserKey);
+                            Logger.log(`[StreamableHTTP connection] ${newSessionId}, userKey: ${resolvedUserKey}`);
+                            transports[newSessionId] = transport;
                         }
                     });
                     // Clean up transport and server when closed
                     transport.onclose = () => {
                         if (transport.sessionId) {
-                            Logger.log(`[StreamableHTTP delete] ${transports[transport.sessionId]}`);
+                            Logger.log(`[StreamableHTTP delete] ${transport.sessionId}`);
+                            this.userAuthManager.removeSession(transport.sessionId);
                             delete transports[transport.sessionId];
                         }
                     };
                     // Create and connect server instance
                     const server = new FeishuMcp();
                     await server.connect(transport);
+                    // 初始化握手阶段 sessionId 尚未分配，使用 queryUserKey（若有）或临时占位符
+                    userKey = queryUserKey || 'http-client';
                 }
                 else {
                     // Invalid request
@@ -137,8 +141,12 @@ export class FeishuMcpServer {
                     });
                     return;
                 }
-                // Handle the request
-                await transport.handleRequest(req, res, req.body);
+                // 获取 baseUrl 并在用户上下文中处理请求
+                const baseUrl = getBaseUrl(req);
+                // Handle the request with user context
+                await this.userContextManager.run({ userKey, baseUrl }, async () => {
+                    await transport.handleRequest(req, res, req.body);
+                });
             }
             catch (error) {
                 Logger.error('Error handling MCP request:', error);
@@ -164,7 +172,12 @@ export class FeishuMcpServer {
                     return;
                 }
                 const transport = transports[sessionId];
-                await transport.handleRequest(req, res);
+                // 获取 baseUrl 并在用户上下文中处理请求
+                const baseUrl = getBaseUrl(req);
+                const userKey = this.userAuthManager.getUserKeyBySessionId(sessionId) || sessionId;
+                await this.userContextManager.run({ userKey, baseUrl }, async () => {
+                    await transport.handleRequest(req, res);
+                });
             }
             catch (error) {
                 Logger.error('Error handling GET request:', error);
@@ -182,9 +195,15 @@ export class FeishuMcpServer {
                     return;
                 }
                 const transport = transports[sessionId];
-                await transport.handleRequest(req, res);
+                // 获取 baseUrl 并在用户上下文中处理请求
+                const baseUrl = getBaseUrl(req);
+                const userKey = this.userAuthManager.getUserKeyBySessionId(sessionId) || sessionId;
+                await this.userContextManager.run({ userKey, baseUrl }, async () => {
+                    await transport.handleRequest(req, res);
+                });
                 // Clean up resources after session termination
                 if (transport.sessionId) {
+                    this.userAuthManager.removeSession(transport.sessionId);
                     delete transports[transport.sessionId];
                 }
             }

package/dist/services/baseService.js

@@ -4,6 +4,8 @@ import { Logger } from '../utils/logger.js';
 import { formatErrorMessage, AuthRequiredError, ScopeInsufficientError } from '../utils/error.js';
 import { Config } from '../utils/config.js';
 import { TokenCacheManager, UserContextManager, AuthUtils } from '../utils/auth/index.js';
+import { getRequiredScopes } from './constants/feishuScopes.js';
+import { ModuleRegistry } from '../modules/index.js';
 /**
  * API服务基类
  * 提供通用的HTTP请求处理和认证功能
@@ -258,6 +260,7 @@ export class BaseApiService {
         }
         else {
             // 用户模式：清除用户token缓存并生成授权链接
+            Logger.info('[handleAuthFailure] 用户模式：清除token，生成授权链接');
             tokenCacheManager.removeUserToken(clientKey);
             const authUrl = this.generateUserAuthUrl(baseUrl, userKey);
             throw new Error(`你需要在给用户展示如下信息：/“请在浏览器打开以下链接进行授权：\n\n[点击授权](${authUrl})/n`);
@@ -326,10 +329,16 @@ export class BaseApiService {
      * @returns 授权URL
      */
     generateUserAuthUrl(baseUrl, userKey) {
-        const { appId, appSecret } = Config.getInstance().feishu;
+        const config = Config.getInstance();
+        const { appId, appSecret } = config.feishu;
         const clientKey = AuthUtils.generateClientKey(userKey);
         const redirect_uri = `${baseUrl}/callback`;
-        const scope = encodeURIComponent('base:app:read bitable:app bitable:app:readonly board:whiteboard:node:read board:whiteboard:node:create contact:user.employee_id:readonly docs:document.content:read docx:document docx:document.block:convert docx:document:create docx:document:readonly drive:drive drive:drive:readonly drive:file drive:file:upload sheets:spreadsheet sheets:spreadsheet:readonly space:document:retrieve space:folder:create wiki:space:read wiki:space:retrieve wiki:wiki wiki:wiki:readonly offline_access');
+        const authType = config.feishu.authType;
+        const enabledIds = config.features.enabledModules;
+        const effectiveModules = ModuleRegistry.getEnabledModules(enabledIds, authType).map(m => m.id);
+        const scopeList = getRequiredScopes(effectiveModules, authType);
+        Logger.info(`[generateUserAuthUrl] enabledModules=${effectiveModules.join(',')} authType=${authType} scopes=${scopeList.join(',')}`);
+        const scope = encodeURIComponent(scopeList.join(' '));
         const state = AuthUtils.encodeState(appId, appSecret, clientKey, redirect_uri);
         return `https://accounts.feishu.cn/open-apis/authen/v1/authorize?client_id=${appId}&redirect_uri=${encodeURIComponent(redirect_uri)}&scope=${scope}&state=${state}`;
     }

package/dist/services/blockFactory.js

@@ -263,6 +263,173 @@ export class BlockFactory {
             }
         };
     }
+    /**
+     * 根据 blockType 字符串和 options 对象创建块内容
+     * 将 MCP 工具传入的高级选项转换为 BlockFactory.createBlock 所需格式
+     */
+    createBlockContentFromOptions(blockType, options) {
+        try {
+            // 处理特殊的 heading 格式，如 heading1, heading2 等
+            if (typeof blockType === 'string' && blockType.startsWith('heading')) {
+                const headingMatch = blockType.match(/^heading([1-9])$/);
+                if (headingMatch) {
+                    const level = parseInt(headingMatch[1], 10);
+                    if (level >= 1 && level <= 9) {
+                        if (!options || Object.keys(options).length === 0) {
+                            options = { heading: { level, content: '', align: 1 } };
+                        }
+                        else if (!('heading' in options)) {
+                            options = { heading: { level, content: '', align: 1 } };
+                        }
+                        else if (options.heading && !('level' in options.heading)) {
+                            options.heading.level = level;
+                        }
+                        blockType = BlockType.HEADING;
+                        Logger.info(`转换特殊标题格式: heading${level} -> standard heading with level=${level}`);
+                    }
+                }
+            }
+            const blockTypeEnum = blockType;
+            const blockConfig = {
+                type: blockTypeEnum,
+                options: {}
+            };
+            switch (blockTypeEnum) {
+                case BlockType.TEXT:
+                    if ('text' in options && options.text) {
+                        const textOptions = options.text;
+                        const textStyles = textOptions.textStyles || [];
+                        const processedTextStyles = textStyles.map((item) => {
+                            if (item.equation !== undefined) {
+                                return { equation: item.equation, style: BlockFactory.applyDefaultTextStyle(item.style) };
+                            }
+                            return { text: item.text || '', style: BlockFactory.applyDefaultTextStyle(item.style) };
+                        });
+                        blockConfig.options = { textContents: processedTextStyles, align: textOptions.align || 1 };
+                    }
+                    break;
+                case BlockType.CODE:
+                    if ('code' in options && options.code) {
+                        const codeOptions = options.code;
+                        blockConfig.options = {
+                            code: codeOptions.code || '',
+                            language: codeOptions.language === 0 ? 0 : (codeOptions.language || 0),
+                            wrap: codeOptions.wrap || false
+                        };
+                    }
+                    break;
+                case BlockType.HEADING:
+                    if ('heading' in options && options.heading) {
+                        const headingOptions = options.heading;
+                        blockConfig.options = {
+                            text: headingOptions.content || '',
+                            level: headingOptions.level || 1,
+                            align: [1, 2, 3].includes(headingOptions.align) ? headingOptions.align : 1
+                        };
+                    }
+                    break;
+                case BlockType.LIST:
+                    if ('list' in options && options.list) {
+                        const listOptions = options.list;
+                        blockConfig.options = {
+                            text: listOptions.content || '',
+                            isOrdered: listOptions.isOrdered || false,
+                            align: [1, 2, 3].includes(listOptions.align) ? listOptions.align : 1
+                        };
+                    }
+                    break;
+                case BlockType.IMAGE:
+                    if ('image' in options && options.image) {
+                        const imageOptions = options.image;
+                        blockConfig.options = { width: imageOptions.width || 100, height: imageOptions.height || 100 };
+                    }
+                    else {
+                        blockConfig.options = { width: 100, height: 100 };
+                    }
+                    break;
+                case BlockType.MERMAID:
+                    if ('mermaid' in options && options.mermaid) {
+                        blockConfig.options = { code: options.mermaid.code };
+                    }
+                    break;
+                case BlockType.WHITEBOARD:
+                    if ('whiteboard' in options && options.whiteboard) {
+                        const whiteboardOptions = options.whiteboard;
+                        blockConfig.options = {
+                            align: [1, 2, 3].includes(whiteboardOptions.align) ? whiteboardOptions.align : 1
+                        };
+                    }
+                    else {
+                        blockConfig.options = { align: 1 };
+                    }
+                    break;
+                default:
+                    Logger.warn(`未知的块类型: ${blockType}，尝试作为标准类型处理`);
+                    if ('text' in options) {
+                        blockConfig.type = BlockType.TEXT;
+                        const textOptions = options.text;
+                        const textStyles = textOptions.textStyles || [];
+                        const processedTextStyles = textStyles.map((item) => {
+                            if (item.equation !== undefined) {
+                                return { equation: item.equation, style: BlockFactory.applyDefaultTextStyle(item.style) };
+                            }
+                            return { text: item.text || '', style: BlockFactory.applyDefaultTextStyle(item.style) };
+                        });
+                        blockConfig.options = { textContents: processedTextStyles, align: textOptions.align || 1 };
+                    }
+                    else if ('code' in options) {
+                        blockConfig.type = BlockType.CODE;
+                        const codeOptions = options.code;
+                        blockConfig.options = {
+                            code: codeOptions.code || '',
+                            language: codeOptions.language === 0 ? 0 : (codeOptions.language || 0),
+                            wrap: codeOptions.wrap || false
+                        };
+                    }
+                    else if ('heading' in options) {
+                        blockConfig.type = BlockType.HEADING;
+                        const headingOptions = options.heading;
+                        blockConfig.options = {
+                            text: headingOptions.content || '',
+                            level: headingOptions.level || 1,
+                            align: [1, 2, 3].includes(headingOptions.align) ? headingOptions.align : 1
+                        };
+                    }
+                    else if ('list' in options) {
+                        blockConfig.type = BlockType.LIST;
+                        const listOptions = options.list;
+                        blockConfig.options = {
+                            text: listOptions.content || '',
+                            isOrdered: listOptions.isOrdered || false,
+                            align: [1, 2, 3].includes(listOptions.align) ? listOptions.align : 1
+                        };
+                    }
+                    else if ('image' in options) {
+                        blockConfig.type = BlockType.IMAGE;
+                        const imageOptions = options.image;
+                        blockConfig.options = { width: imageOptions.width || 100, height: imageOptions.height || 100 };
+                    }
+                    else if ('mermaid' in options) {
+                        blockConfig.type = BlockType.MERMAID;
+                        blockConfig.options = { code: options.mermaid.code };
+                    }
+                    else if ('whiteboard' in options) {
+                        blockConfig.type = BlockType.WHITEBOARD;
+                        const whiteboardConfig = options.whiteboard;
+                        blockConfig.options = {
+                            align: [1, 2, 3].includes(whiteboardConfig.align) ? whiteboardConfig.align : 1
+                        };
+                    }
+                    break;
+            }
+            Logger.debug(`创建块内容: 类型=${blockConfig.type}, 选项=${JSON.stringify(blockConfig.options)}`);
+            return this.createBlock(blockConfig.type, blockConfig.options);
+        }
+        catch (error) {
+            Logger.error(`创建块内容对象失败: ${error}`);
+            return null;
+        }
+    }
     /**
      * 创建表格块
      * @param options 表格块选项

package/dist/services/callbackService.js

@@ -64,7 +64,7 @@ export async function callback(req, res) {
         });
         const data = (tokenResp && typeof tokenResp === 'object') ? tokenResp : undefined;
         Logger.debug('[callback] feishu response:', data);
-        if (!data || data.code !== 0 || !data.access_token) {
+        if (!data || !data.access_token) {
             return sendFail(res, `获取 access_token 失败，飞书返回: ${JSON.stringify(tokenResp)}`, CODE.CUSTOM);
         }
         // 使用TokenCacheManager缓存token信息

package/dist/services/constants/feishuScopes.js

@@ -0,0 +1,94 @@
+/**
+ * 飞书各功能模块所需权限 Scope 定义
+ * 按模块拆分，通过 getRequiredScopes 动态计算最小权限集
+ */
+export const MODULE_SCOPES = {
+    document: {
+        tenant: [
+            "docx:document.block:convert",
+            "base:app:read",
+            "bitable:app",
+            "bitable:app:readonly",
+            "board:whiteboard:node:create",
+            "board:whiteboard:node:read",
+            "contact:user.employee_id:readonly",
+            "docs:document.content:read",
+            "docx:document",
+            "docx:document:create",
+            "docx:document:readonly",
+            "drive:drive",
+            "drive:drive:readonly",
+            "drive:file",
+            "drive:file:upload",
+            "sheets:spreadsheet",
+            "sheets:spreadsheet:readonly",
+            "space:document:retrieve",
+            "space:folder:create",
+            "wiki:space:read",
+            "wiki:space:retrieve",
+            "wiki:wiki",
+            "wiki:wiki:readonly",
+        ],
+        userOnly: [
+            "search:docs:read",
+            "offline_access",
+        ],
+    },
+    task: {
+        tenant: [
+            "task:task:write",
+        ],
+        userOnly: [],
+    },
+    calendar: {
+        tenant: [],
+        userOnly: [],
+    },
+    member: {
+        tenant: [
+            // 调用批量获取用户信息 API 所需（任选其一即可）
+            "contact:contact.base:readonly",
+            // 字段权限：返回完整用户信息
+            // "contact:user.assign_info:read",
+            "contact:user.base:readonly",
+            // "contact:user.department:readonly",
+            // "contact:user.department_path:readonly",
+            // "contact:user.dotted_line_leader_info.read",
+            // "contact:user.employee:readonly",
+            // "contact:user.employee_id:readonly",
+            // "contact:user.employee_number:read",
+            // "contact:user.gender:readonly",
+            // "contact:user.user_geo",
+            // "contact:user.phone:readonly",
+            // "contact:user.email:readonly",
+            // "contact:user.job_family:readonly",
+            // "contact:user.job_level:readonly",
+        ],
+        userOnly: [
+            "contact:user:search",
+            "contact:contact.base:readonly",
+            "contact:user.employee_id:readonly",
+        ],
+    },
+};
+/**
+ * 根据已启用模块和认证类型，计算所需的最小 Scope 集合
+ * @param enabledModules 已启用的模块 ID 列表（含 'all' 则返回全量）
+ * @param authType 认证类型
+ */
+export function getRequiredScopes(enabledModules, authType) {
+    const moduleIds = enabledModules.includes('all')
+        ? Object.keys(MODULE_SCOPES)
+        : enabledModules;
+    const scopes = new Set();
+    for (const moduleId of moduleIds) {
+        const moduleScopes = MODULE_SCOPES[moduleId];
+        if (!moduleScopes)
+            continue;
+        moduleScopes.tenant.forEach(s => scopes.add(s));
+        if (authType === 'user') {
+            moduleScopes.userOnly.forEach(s => scopes.add(s));
+        }
+    }
+    return Array.from(scopes);
+}

package/dist/services/feishu/FeishuBaseApiService.js

@@ -0,0 +1,47 @@
+import { BaseApiService } from '../baseService.js';
+import { Config } from '../../utils/config.js';
+import { Logger } from '../../utils/logger.js';
+import { AuthUtils } from '../../utils/auth/index.js';
+import { FeishuScopeValidator } from './FeishuScopeValidator.js';
+/**
+ * 飞书 API 服务基类
+ * 封装 getBaseUrl 和 getAccessToken（委托给 AuthService），供各领域服务继承
+ */
+export class FeishuBaseApiService extends BaseApiService {
+    constructor(authService) {
+        super();
+        Object.defineProperty(this, "authService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: authService
+        });
+        Object.defineProperty(this, "scopeValidator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.scopeValidator = new FeishuScopeValidator();
+    }
+    getBaseUrl() {
+        return Config.getInstance().feishu.baseUrl;
+    }
+    async getAccessToken(userKey) {
+        const { appId, appSecret, authType, enableScopeValidation } = Config.getInstance().feishu;
+        const clientKey = AuthUtils.generateClientKey(userKey);
+        Logger.debug(`[FeishuBaseApiService] 获取访问令牌，authType: ${authType}, clientKey: ${clientKey}`);
+        if (enableScopeValidation) {
+            await this.scopeValidator.validateScopeWithVersion(appId, appSecret, authType, clientKey);
+        }
+        else {
+            Logger.debug('权限检查已禁用，跳过scope校验');
+        }
+        if (authType === 'tenant') {
+            return this.authService.getTenantAccessToken(appId, appSecret, clientKey);
+        }
+        else {
+            return this.authService.getUserAccessToken(clientKey, appId, appSecret);
+        }
+    }
+}