feishu-mcp 0.2.2 → 0.2.7

package/dist/services/feishuApiService.js

@@ -1,1891 +1,377 @@
-import { BaseApiService } from './baseService.js';
-import { Logger } from '../utils/logger.js';
-import { Config } from '../utils/config.js';
-import { ParamUtils } from '../utils/paramUtils.js';
-import { BlockFactory, BlockType } from './blockFactory.js';
-import { AuthUtils, TokenCacheManager } from '../utils/auth/index.js';
 import { AuthService } from './feishuAuthService.js';
-import { ScopeInsufficientError } from '../utils/error.js';
-import axios from 'axios';
-import FormData from 'form-data';
-import fs from 'fs';
-import path from 'path';
+import { FeishuDocumentService } from '../modules/document/services/FeishuDocumentService.js';
+import { FeishuBlockService } from '../modules/document/services/FeishuBlockService.js';
+import { FeishuFoldService } from '../modules/document/services/FeishuFoldService.js';
+import { FeishuSearchService } from '../modules/document/services/FeishuSearchService.js';
+import { FeishuWhiteboardService } from '../modules/document/services/FeishuWhiteboardService.js';
+import { FeishuTaskService, } from '../modules/task/services/FeishuTaskService.js';
+import { FeishuCalendarService } from '../modules/calendar/services/FeishuCalendarService.js';
+import { FeishuMemberService } from '../modules/member/services/FeishuMemberService.js';
 /**
- * 飞书API服务类
- * 提供飞书API的所有基础操作，包括认证、请求和缓存管理
+ * 飞书 API 服务门面（Facade）
+ *
+ * 统一对外入口，持有并编排各领域服务实例。
+ * 所有 public 方法均委托给对应的领域服务，本类不直接发起 HTTP 请求。
+ * 采用单例模式，通过 {@link getInstance} 获取实例。
+ *
+ * 领域服务对应关系：
+ * - 文档操作              → {@link FeishuDocumentService}
+ * - 块/图片操作           → {@link FeishuBlockService}
+ * - 文件夹/知识空间操作  → {@link FeishuFoldService}
+ * - 搜索                 → {@link FeishuSearchService}
+ * - 画板                 → {@link FeishuWhiteboardService}
+ * - 任务                 → {@link FeishuTaskService}
+ * - 日历                 → {@link FeishuCalendarService}
+ * - 成员/通讯录          → {@link FeishuMemberService}
  */
-export class FeishuApiService extends BaseApiService {
-    /**
-     * 私有构造函数，用于单例模式
-     */
-    constructor() {
-        super();
-        Object.defineProperty(this, "blockFactory", {
+export class FeishuApiService {
+    constructor(documentService, blockService, foldService, searchService, whiteboardService, taskService, calendarService, memberService) {
+        Object.defineProperty(this, "documentService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: documentService
+        });
+        Object.defineProperty(this, "blockService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: blockService
+        });
+        Object.defineProperty(this, "foldService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: foldService
+        });
+        Object.defineProperty(this, "searchService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: searchService
+        });
+        Object.defineProperty(this, "whiteboardService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: whiteboardService
+        });
+        Object.defineProperty(this, "taskService", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: taskService
         });
-        Object.defineProperty(this, "config", {
+        Object.defineProperty(this, "calendarService", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: calendarService
         });
-        Object.defineProperty(this, "authService", {
+        Object.defineProperty(this, "memberService", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: memberService
         });
-        this.blockFactory = BlockFactory.getInstance();
-        this.config = Config.getInstance();
-        this.authService = new AuthService();
+    }
+    /** 组装所有领域服务并返回 FeishuApiService 新实例 */
+    static createInstance() {
+        const authService = new AuthService();
+        const documentService = new FeishuDocumentService(authService);
+        const blockService = new FeishuBlockService(authService);
+        const foldService = new FeishuFoldService(authService);
+        const searchService = new FeishuSearchService(authService);
+        const whiteboardService = new FeishuWhiteboardService(authService);
+        const taskService = new FeishuTaskService(authService);
+        const calendarService = new FeishuCalendarService(authService);
+        const memberService = new FeishuMemberService(authService);
+        return new FeishuApiService(documentService, blockService, foldService, searchService, whiteboardService, taskService, calendarService, memberService);
     }
     /**
-     * 获取飞书API服务实例
-     * @returns 飞书API服务实例
+     * 获取 FeishuApiService 单例
+     * @returns 全局唯一的 FeishuApiService 实例
      */
     static getInstance() {
         if (!FeishuApiService.instance) {
-            FeishuApiService.instance = new FeishuApiService();
+            FeishuApiService.instance = FeishuApiService.createInstance();
         }
         return FeishuApiService.instance;
     }
-    /**
-     * 获取API基础URL
-     * @returns API基础URL
-     */
-    getBaseUrl() {
-        return this.config.feishu.baseUrl;
-    }
-    /**
-     * 获取API认证端点
-     * @returns 认证端点URL
-     */
-    getAuthEndpoint() {
-        return '/auth/v3/tenant_access_token/internal';
-    }
-    /**
-     * 获取访问令牌
-     * @param userKey 用户标识（可选）
-     * @returns 访问令牌
-     * @throws 如果获取令牌失败则抛出错误
-     */
-    async getAccessToken(userKey) {
-        const { appId, appSecret, authType } = this.config.feishu;
-        // 生成客户端缓存键
-        const clientKey = AuthUtils.generateClientKey(userKey);
-        Logger.debug(`[FeishuApiService] 获取访问令牌，userKey: ${userKey}, clientKey: ${clientKey}, authType: ${authType}`);
-        // 在使用token之前先校验scope（使用appId+appSecret获取临时tenant token来调用scope接口）
-        // 根据配置决定是否执行权限检查
-        if (this.config.feishu.enableScopeValidation) {
-            await this.validateScopeWithVersion(appId, appSecret, authType);
-        }
-        else {
-            Logger.debug('权限检查已禁用，跳过scope校验');
-        }
-        // 校验通过后，获取实际的token
-        if (authType === 'tenant') {
-            // 租户模式：获取租户访问令牌
-            return await this.getTenantAccessToken(appId, appSecret, clientKey);
-        }
-        else {
-            // 用户模式：获取用户访问令牌
-            return await this.authService.getUserAccessToken(clientKey, appId, appSecret);
-        }
-    }
-    /**
-     * 获取应用权限范围
-     * @param accessToken 访问令牌
-     * @param authType 认证类型（tenant或user）
-     * @returns 应用权限范围列表
-     */
-    async getApplicationScopes(accessToken, authType) {
-        try {
-            const endpoint = '/application/v6/scopes';
-            const headers = {
-                'Authorization': `Bearer ${accessToken}`,
-                'Content-Type': 'application/json'
-            };
-            Logger.debug('请求应用权限范围:', endpoint);
-            const response = await axios.get(`${this.getBaseUrl()}${endpoint}`, { headers });
-            const data = response.data;
-            if (data.code !== 0) {
-                throw new Error(`获取应用权限范围失败：${data.msg || '未知错误'} (错误码: ${data.code})`);
-            }
-            // 提取权限列表
-            // API返回格式: { "data": { "scopes": [{ "grant_status": 1, "scope_name": "...", "scope_type": "tenant"|"user" }] } }
-            const scopes = [];
-            if (data.data && Array.isArray(data.data.scopes)) {
-                // 根据authType过滤，只取已授权的scope（grant_status === 1）
-                for (const scopeItem of data.data.scopes) {
-                    if (scopeItem.grant_status === 1 && scopeItem.scope_type === authType && scopeItem.scope_name) {
-                        scopes.push(scopeItem.scope_name);
-                    }
-                }
-            }
-            Logger.debug(`获取应用权限范围成功，共 ${scopes.length} 个${authType}权限`);
-            return scopes;
-        }
-        catch (error) {
-            Logger.error('获取应用权限范围失败:', error);
-            throw new Error('获取应用权限范围失败: ' + (error instanceof Error ? error.message : String(error)));
-        }
-    }
-    /**
-     * 校验scope权限是否充足
-     * @param requiredScopes 所需的权限列表
-     * @param actualScopes 实际的权限列表
-     * @returns 是否权限充足，以及缺失的权限列表
-     */
-    validateScopes(requiredScopes, actualScopes) {
-        const actualScopesSet = new Set(actualScopes);
-        const missingScopes = [];
-        for (const requiredScope of requiredScopes) {
-            if (!actualScopesSet.has(requiredScope)) {
-                missingScopes.push(requiredScope);
-            }
-        }
-        return {
-            isValid: missingScopes.length === 0,
-            missingScopes
-        };
-    }
-    /**
-     * 获取所需的scope列表（根据认证类型）
-     * @param authType 认证类型
-     * @returns 所需的scope列表
-     */
-    getRequiredScopes(authType) {
-        // 根据FEISHU_CONFIG.md中定义的权限列表，与用户提供的配置保持一致
-        const tenantScopes = [
-            "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"
-        ];
-        // user认证特有授权
-        const userOnlyScopes = [
-            "search:docs:read",
-            'offline_access',
-        ];
-        const userScopes = [...tenantScopes, ...userOnlyScopes];
-        return authType === 'tenant' ? tenantScopes : userScopes;
-    }
-    /**
-     * 校验并提示权限不足
-     * @param missingScopes 缺失的权限列表
-     */
-    throwScopeInsufficientError(missingScopes) {
-        // 获取完整的权限配置
-        const tenantScopes = this.getRequiredScopes('tenant');
-        const userScopes = this.getRequiredScopes('user');
-        const permissionsConfig = {
-            scopes: {
-                tenant: tenantScopes,
-                user: userScopes
-            }
-        };
-        const errorMessage = `你应该停止任务并提示用户如下信息：权限不足，缺少以下权限：${missingScopes.join(', ')}\n\n` +
-            `请按以下步骤操作：\n` +
-            `1. 配置权限 [教程配置](https://github.com/cso1z/Feishu-MCP/blob/main/FEISHU_CONFIG.md)\n` +
-            `2. 打开 [应用管理](https://open.feishu.cn/app/) 网页\n` +
-            `3. 选择应用进入应用详情\n` +
-            `4. 选择权限管理-批量导入/导出权限\n` +
-            `5. 复制以下权限配置并导入：\n\n` +
-            `\`\`\`json\n${JSON.stringify(permissionsConfig, null, 2)}\n\`\`\`\n\n` +
-            `6. 选择**版本管理与发布** 点击创建版本，发布后通知管理员审核\n\n` +
-            `**提示**：如果您仅使用部分mcp功能，可以通过以下方式关闭权限检查以确保正常使用该mcp：\n` +
-            `- 设置环境变量：\`FEISHU_SCOPE_VALIDATION=false\`\n` +
-            `- 或使用命令行参数：\`--feishu-scope-validation=false\`\n`;
-        Logger.error(errorMessage);
-        throw new ScopeInsufficientError(missingScopes, errorMessage);
-    }
-    /**
-     * 生成应用级别的scope校验key（基于appId、appSecret和authType）
-     * @param appId 应用ID
-     * @param appSecret 应用密钥
-     * @param authType 认证类型（tenant或user）
-     * @returns scope校验key
-     */
-    generateScopeKey(appId, appSecret, authType) {
-        // 使用appId、appSecret和authType生成唯一的key，用于scope版本管理
-        // 包含authType是因为tenant和user的权限列表不同，需要分开校验
-        return `app:${appId}:${appSecret.substring(0, 8)}:${authType}`;
-    }
-    /**
-     * 获取临时租户访问令牌（用于scope校验）
-     * @param appId 应用ID
-     * @param appSecret 应用密钥
-     * @returns 租户访问令牌
-     */
-    async getTempTenantTokenForScope(appId, appSecret) {
-        try {
-            const requestData = {
-                app_id: appId,
-                app_secret: appSecret,
-            };
-            const url = 'https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal';
-            const headers = { 'Content-Type': 'application/json' };
-            Logger.debug('获取临时租户token用于scope校验:', url);
-            const response = await axios.post(url, requestData, { headers });
-            const data = response.data;
-            if (data.code !== 0) {
-                throw new Error(`获取临时租户访问令牌失败：${data.msg || '未知错误'} (错误码: ${data.code})`);
-            }
-            if (!data.tenant_access_token) {
-                throw new Error('获取临时租户访问令牌失败：响应中没有token');
-            }
-            Logger.debug('临时租户token获取成功，用于scope校验');
-            return data.tenant_access_token;
-        }
-        catch (error) {
-            Logger.error('获取临时租户访问令牌失败:', error);
-            throw new Error('获取临时租户访问令牌失败: ' + (error instanceof Error ? error.message : String(error)));
-        }
-    }
-    /**
-     * 校验scope权限（带版本管理）
-     * @param appId 应用ID
-     * @param appSecret 应用密钥
-     * @param authType 认证类型
-     */
-    async validateScopeWithVersion(appId, appSecret, authType) {
-        const tokenCacheManager = TokenCacheManager.getInstance();
-        // 生成应用级别的scope校验key（包含authType，因为tenant和user权限不同）
-        const scopeKey = this.generateScopeKey(appId, appSecret, authType);
-        const scopeVersion = '2.0.0'; // 当前scope版本号，可以根据需要更新
-        // 检查是否需要校验
-        if (!tokenCacheManager.shouldValidateScope(scopeKey, scopeVersion)) {
-            Logger.debug(`Scope版本已校验过，跳过校验: ${scopeKey}`);
-            return;
-        }
-        Logger.info(`开始校验scope权限，版本: ${scopeVersion}, scopeKey: ${scopeKey}`);
-        try {
-            // 使用appId和appSecret获取临时tenant token来调用scope接口
-            const tempTenantToken = await this.getTempTenantTokenForScope(appId, appSecret);
-            // 获取实际权限范围（使用tenant token，但根据authType过滤scope_type）
-            const actualScopes = await this.getApplicationScopes(tempTenantToken, authType);
-            // 获取当前版本所需的scope列表
-            const requiredScopes = this.getRequiredScopes(authType);
-            // 校验权限
-            const validationResult = this.validateScopes(requiredScopes, actualScopes);
-            if (!validationResult.isValid) {
-                // 权限不足，抛出错误
-                this.throwScopeInsufficientError(validationResult.missingScopes);
-            }
-            // 权限充足，保存版本信息
-            const scopeVersionInfo = {
-                scopeVersion,
-                scopeList: requiredScopes,
-                validatedAt: Math.floor(Date.now() / 1000),
-                validatedVersion: scopeVersion
-            };
-            tokenCacheManager.saveScopeVersionInfo(scopeKey, scopeVersionInfo);
-            Logger.info(`Scope权限校验成功，版本: ${scopeVersion}`);
-        }
-        catch (error) {
-            // 如果是权限不足错误，需要重新抛出，中断流程
-            if (error instanceof ScopeInsufficientError) {
-                throw error;
-            }
-            // 如果获取权限范围失败（网络错误、API调用失败等），记录警告但不阻止token使用
-            Logger.warn(`Scope权限校验失败，但继续使用token: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * 获取租户访问令牌
-     * @param appId 应用ID
-     * @param appSecret 应用密钥
-     * @param clientKey 客户端缓存键
-     * @returns 租户访问令牌
-     */
-    async getTenantAccessToken(appId, appSecret, clientKey) {
-        const tokenCacheManager = TokenCacheManager.getInstance();
-        // 尝试从缓存获取租户token
-        const cachedToken = tokenCacheManager.getTenantToken(clientKey);
-        if (cachedToken) {
-            Logger.debug('使用缓存的租户访问令牌');
-            return cachedToken;
-        }
-        // 缓存中没有token，请求新的租户token
-        Logger.info('缓存中没有租户token，请求新的租户访问令牌');
-        try {
-            const requestData = {
-                app_id: appId,
-                app_secret: appSecret,
-            };
-            const url = 'https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal';
-            const headers = { 'Content-Type': 'application/json' };
-            Logger.debug('请求租户访问令牌:', url, requestData);
-            const response = await axios.post(url, requestData, { headers });
-            const data = response.data;
-            if (data.code !== 0) {
-                throw new Error(`获取租户访问令牌失败：${data.msg || '未知错误'} (错误码: ${data.code})`);
-            }
-            if (!data.tenant_access_token) {
-                throw new Error('获取租户访问令牌失败：响应中没有token');
-            }
-            // 计算绝对过期时间戳
-            const expire_at = Math.floor(Date.now() / 1000) + (data.expire || 0);
-            const tokenInfo = {
-                app_access_token: data.tenant_access_token,
-                expires_at: expire_at
-            };
-            // 缓存租户token
-            tokenCacheManager.cacheTenantToken(clientKey, tokenInfo, data.expire);
-            Logger.info('租户访问令牌获取并缓存成功');
-            return data.tenant_access_token;
-        }
-        catch (error) {
-            Logger.error('获取租户访问令牌失败:', error);
-            throw new Error('获取租户访问令牌失败: ' + (error instanceof Error ? error.message : String(error)));
-        }
-    }
+    // ─── 文档服务委托 ─────────────────────────────────────────────────
     /**
      * 创建飞书文档
-     * @param title 文档标题
-     * @param folderToken 文件夹Token
-     * @returns 创建的文档信息
+     * @see FeishuDocumentService.createDocument
      */
     async createDocument(title, folderToken) {
-        try {
-            const endpoint = '/docx/v1/documents';
-            const payload = {
-                title,
-                folder_token: folderToken
-            };
-            const response = await this.post(endpoint, payload);
-            return response;
-        }
-        catch (error) {
-            this.handleApiError(error, '创建飞书文档失败');
-        }
+        return this.documentService.createDocument(title, folderToken);
     }
     /**
-     * 获取文档信息（支持普通文档和Wiki文档）
-     * @param documentId 文档ID或URL（支持Wiki链接）
-     * @param documentType 文档类型（可选），'document' 或 'wiki'，如果不指定则自动检测
-     * @returns 文档信息或Wiki节点信息
+     * 获取文档信息，支持普通文档和 Wiki 文档
+     * @see FeishuDocumentService.getDocumentInfo
      */
     async getDocumentInfo(documentId, documentType) {
-        try {
-            let isWikiLink;
-            // 如果明确指定了类型，使用指定的类型
-            if (documentType === 'wiki') {
-                isWikiLink = true;
-            }
-            else if (documentType === 'document') {
-                isWikiLink = false;
-            }
-            else {
-                // 自动检测：检查是否是Wiki链接（包含 /wiki/ 路径）
-                isWikiLink = documentId.includes('/wiki/');
-            }
-            if (isWikiLink) {
-                // 处理Wiki文档
-                const wikiToken = ParamUtils.processWikiToken(documentId);
-                const endpoint = `/wiki/v2/spaces/get_node`;
-                const params = { token: wikiToken, obj_type: 'wiki' };
-                const response = await this.get(endpoint, params);
-                if (!response.node || !response.node.obj_token) {
-                    throw new Error(`无法从Wiki节点获取文档ID: ${wikiToken}`);
-                }
-                const node = response.node;
-                const docId = node.obj_token;
-                // 构建返回对象，包含完整节点信息和 documentId 字段
-                const result = {
-                    ...node,
-                    documentId: docId, // 添加 documentId 字段作为 obj_token 的别名
-                    _type: 'wiki', // 标识这是Wiki文档
-                };
-                Logger.debug(`获取Wiki文档信息: ${wikiToken} -> documentId: ${docId}, space_id: ${node.space_id}, node_token: ${node.node_token}`);
-                return result;
-            }
-            else {
-                // 处理普通文档
-                const normalizedDocId = ParamUtils.processDocumentId(documentId);
-                const endpoint = `/docx/v1/documents/${normalizedDocId}`;
-                const response = await this.get(endpoint);
-                const result = {
-                    ...response,
-                    _type: 'document', // 标识这是普通文档
-                };
-                Logger.debug(`获取普通文档信息: ${normalizedDocId}`);
-                return result;
-            }
-        }
-        catch (error) {
-            this.handleApiError(error, '获取文档信息失败');
-        }
+        return this.documentService.getDocumentInfo(documentId, documentType);
     }
     /**
-     * 获取文档内容
-     * @param documentId 文档ID或URL
-     * @param lang 语言代码，0为中文，1为英文
-     * @returns 文档内容
+     * 获取文档的纯文本内容
+     * @see FeishuDocumentService.getDocumentContent
      */
     async getDocumentContent(documentId, lang = 0) {
-        try {
-            const normalizedDocId = ParamUtils.processDocumentId(documentId);
-            const endpoint = `/docx/v1/documents/${normalizedDocId}/raw_content`;
-            const params = { lang };
-            const response = await this.get(endpoint, params);
-            return response.content;
-        }
-        catch (error) {
-            this.handleApiError(error, '获取文档内容失败');
-        }
+        return this.documentService.getDocumentContent(documentId, lang);
     }
     /**
-     * 获取文档块结构
-     * @param documentId 文档ID或URL
-     * @param pageSize 每页块数量
-     * @returns 文档块数组
+     * 获取文档的所有块结构（自动分页）
+     * @see FeishuDocumentService.getDocumentBlocks
      */
     async getDocumentBlocks(documentId, pageSize = 500) {
-        try {
-            const normalizedDocId = ParamUtils.processDocumentId(documentId);
-            const endpoint = `/docx/v1/documents/${normalizedDocId}/blocks`;
-            let pageToken = '';
-            let allBlocks = [];
-            // 分页获取所有块
-            do {
-                const params = {
-                    page_size: pageSize,
-                    document_revision_id: -1
-                };
-                if (pageToken) {
-                    params.page_token = pageToken;
-                }
-                const response = await this.get(endpoint, params);
-                const blocks = response.items || [];
-                allBlocks = [...allBlocks, ...blocks];
-                pageToken = response.page_token;
-            } while (pageToken);
-            return allBlocks;
-        }
-        catch (error) {
-            this.handleApiError(error, '获取文档块结构失败');
-        }
+        return this.documentService.getDocumentBlocks(documentId, pageSize);
     }
+    // ─── 块服务委托 ───────────────────────────────────────────────────
     /**
-     * 获取块内容
-     * @param documentId 文档ID或URL
-     * @param blockId 块ID
-     * @returns 块内容
-     */
-    async getBlockContent(documentId, blockId) {
-        try {
-            const normalizedDocId = ParamUtils.processDocumentId(documentId);
-            const safeBlockId = ParamUtils.processBlockId(blockId);
-            const endpoint = `/docx/v1/documents/${normalizedDocId}/blocks/${safeBlockId}`;
-            const params = { document_revision_id: -1 };
-            const response = await this.get(endpoint, params);
-            return response;
-        }
-        catch (error) {
-            this.handleApiError(error, '获取块内容失败');
-        }
-    }
-    /**
-     * 更新块文本内容
-     * @param documentId 文档ID或URL
-     * @param blockId 块ID
-     * @param textElements 文本元素数组，支持普通文本和公式元素
-     * @returns 更新结果
+     * 更新块的文本内容，支持普通文本与行内公式混排
+     * @see FeishuBlockService.updateBlockTextContent
      */
     async updateBlockTextContent(documentId, blockId, textElements) {
-        try {
-            const docId = ParamUtils.processDocumentId(documentId);
-            const endpoint = `/docx/v1/documents/${docId}/blocks/${blockId}?document_revision_id=-1`;
-            Logger.debug(`准备请求API端点: ${endpoint}`);
-            const elements = textElements.map(item => {
-                if (item.equation !== undefined) {
-                    return {
-                        equation: {
-                            content: item.equation,
-                            text_element_style: BlockFactory.applyDefaultTextStyle(item.style)
-                        }
-                    };
-                }
-                else {
-                    return {
-                        text_run: {
-                            content: item.text || '',
-                            text_element_style: BlockFactory.applyDefaultTextStyle(item.style)
-                        }
-                    };
-                }
-            });
-            const data = {
-                update_text_elements: {
-                    elements: elements
-                }
-            };
-            Logger.debug(`请求数据: ${JSON.stringify(data, null, 2)}`);
-            const response = await this.patch(endpoint, data);
-            return response;
-        }
-        catch (error) {
-            this.handleApiError(error, '更新块文本内容失败');
-            return null; // 永远不会执行到这里
-        }
+        return this.blockService.updateBlockTextContent(documentId, blockId, textElements);
     }
     /**
-     * 创建文档块
-     * @param documentId 文档ID或URL
-     * @param parentBlockId 父块ID
-     * @param blockContent 块内容
-     * @param index 插入位置索引
-     * @returns 创建结果
+     * 批量更新多个块的文本内容（一次 API 调用）
+     * @see FeishuBlockService.batchUpdateBlocksTextContent
      */
-    async createDocumentBlock(documentId, parentBlockId, blockContent, index = 0) {
-        try {
-            const normalizedDocId = ParamUtils.processDocumentId(documentId);
-            const endpoint = `/docx/v1/documents/${normalizedDocId}/blocks/${parentBlockId}/children?document_revision_id=-1`;
-            Logger.debug(`准备请求API端点: ${endpoint}`);
-            const payload = {
-                children: [blockContent],
-                index
-            };
-            Logger.debug(`请求数据: ${JSON.stringify(payload, null, 2)}`);
-            const response = await this.post(endpoint, payload);
-            return response;
-        }
-        catch (error) {
-            this.handleApiError(error, '创建文档块失败');
-            return null; // 永远不会执行到这里
-        }
+    async batchUpdateBlocksTextContent(documentId, updates) {
+        return this.blockService.batchUpdateBlocksTextContent(documentId, updates);
     }
     /**
-     * 批量创建文档块
-     * @param documentId 文档ID或URL
-     * @param parentBlockId 父块ID
-     * @param blockContents 块内容数组
-     * @param index 起始插入位置索引
-     * @returns 创建结果
+     * 在指定父块下批量创建多个子块
+     * @see FeishuBlockService.createDocumentBlocks
      */
     async createDocumentBlocks(documentId, parentBlockId, blockContents, index = 0) {
-        try {
-            const normalizedDocId = ParamUtils.processDocumentId(documentId);
-            const endpoint = `/docx/v1/documents/${normalizedDocId}/blocks/${parentBlockId}/children?document_revision_id=-1`;
-            Logger.debug(`准备请求API端点: ${endpoint}`);
-            const payload = {
-                children: blockContents,
-                index
-            };
-            Logger.debug(`请求数据: ${JSON.stringify(payload, null, 2)}`);
-            const response = await this.post(endpoint, payload);
-            return response;
-        }
-        catch (error) {
-            this.handleApiError(error, '批量创建文档块失败');
-            return null; // 永远不会执行到这里
-        }
-    }
-    /**
-     * 创建文本块
-     * @param documentId 文档ID或URL
-     * @param parentBlockId 父块ID
-     * @param textContents 文本内容数组，支持普通文本和公式元素
-     * @param align 对齐方式，1为左对齐，2为居中，3为右对齐
-     * @param index 插入位置索引
-     * @returns 创建结果
-     */
-    async createTextBlock(documentId, parentBlockId, textContents, align = 1, index = 0) {
-        // 处理文本内容样式，支持普通文本和公式元素
-        const processedTextContents = textContents.map(item => {
-            if (item.equation !== undefined) {
-                return {
-                    equation: item.equation,
-                    style: BlockFactory.applyDefaultTextStyle(item.style)
-                };
-            }
-            else {
-                return {
-                    text: item.text || '',
-                    style: BlockFactory.applyDefaultTextStyle(item.style)
-                };
-            }
-        });
-        const blockContent = this.blockFactory.createTextBlock({
-            textContents: processedTextContents,
-            align
-        });
-        return this.createDocumentBlock(documentId, parentBlockId, blockContent, index);
-    }
-    /**
-     * 创建代码块
-     * @param documentId 文档ID或URL
-     * @param parentBlockId 父块ID
-     * @param code 代码内容
-     * @param language 语言代码
-     * @param wrap 是否自动换行
-     * @param index 插入位置索引
-     * @returns 创建结果
-     */
-    async createCodeBlock(documentId, parentBlockId, code, language = 0, wrap = false, index = 0) {
-        const blockContent = this.blockFactory.createCodeBlock({
-            code,
-            language,
-            wrap
-        });
-        return this.createDocumentBlock(documentId, parentBlockId, blockContent, index);
-    }
-    /**
-     * 创建标题块
-     * @param documentId 文档ID或URL
-     * @param parentBlockId 父块ID
-     * @param text 标题文本
-     * @param level 标题级别，1-9
-     * @param index 插入位置索引
-     * @param align 对齐方式，1为左对齐，2为居中，3为右对齐
-     * @returns 创建结果
-     */
-    async createHeadingBlock(documentId, parentBlockId, text, level = 1, index = 0, align = 1) {
-        const blockContent = this.blockFactory.createHeadingBlock({
-            text,
-            level,
-            align
-        });
-        return this.createDocumentBlock(documentId, parentBlockId, blockContent, index);
-    }
-    /**
-     * 创建列表块
-     * @param documentId 文档ID或URL
-     * @param parentBlockId 父块ID
-     * @param text 列表项文本
-     * @param isOrdered 是否是有序列表
-     * @param index 插入位置索引
-     * @param align 对齐方式，1为左对齐，2为居中，3为右对齐
-     * @returns 创建结果
-     */
-    async createListBlock(documentId, parentBlockId, text, isOrdered = false, index = 0, align = 1) {
-        const blockContent = this.blockFactory.createListBlock({
-            text,
-            isOrdered,
-            align
-        });
-        return this.createDocumentBlock(documentId, parentBlockId, blockContent, index);
+        return this.blockService.createDocumentBlocks(documentId, parentBlockId, blockContents, index);
     }
     /**
-     * 创建Mermaid块
-     * @param documentId 文档ID或URL
-     * @param parentBlockId 父块ID
-     * @param mermaidCode Mermaid代码
-     * @param index 插入位置索引
-     * @returns 创建结果
-     */
-    async createMermaidBlock(documentId, parentBlockId, mermaidCode, index = 0) {
-        const normalizedDocId = ParamUtils.processDocumentId(documentId);
-        const endpoint = `/docx/v1/documents/${normalizedDocId}/blocks/${parentBlockId}/children?document_revision_id=-1`;
-        const blockContent = {
-            block_type: 40,
-            add_ons: {
-                component_id: "",
-                component_type_id: "blk_631fefbbae02400430b8f9f4",
-                record: JSON.stringify({
-                    data: mermaidCode,
-                })
-            }
-        };
-        const payload = {
-            children: [blockContent],
-            index
-        };
-        Logger.info(`请求创建Mermaid块: ${JSON.stringify(payload).slice(0, 500)}...`);
-        const response = await this.post(endpoint, payload);
-        return response;
-    }
-    /**
-     * 创建表格块
-     * @param documentId 文档ID或URL
-     * @param parentBlockId 父块ID
-     * @param tableConfig 表格配置
-     * @param index 插入位置索引
-     * @returns 创建结果
+     * 创建表格块，支持自定义单元格内容
+     * @see FeishuBlockService.createTableBlock
      */
     async createTableBlock(documentId, parentBlockId, tableConfig, index = 0) {
-        const normalizedDocId = ParamUtils.processDocumentId(documentId);
-        const endpoint = `/docx/v1/documents/${normalizedDocId}/blocks/${parentBlockId}/descendant?document_revision_id=-1`;
-        // 处理表格配置，为每个单元格创建正确的内容块
-        const processedTableConfig = {
-            ...tableConfig,
-            cells: tableConfig.cells?.map(cell => ({
-                ...cell,
-                content: this.createBlockContent(cell.content.blockType, cell.content.options)
-            }))
-        };
-        // 使用 BlockFactory 创建表格块内容
-        const tableStructure = this.blockFactory.createTableBlock(processedTableConfig);
-        const payload = {
-            children_id: tableStructure.children_id,
-            descendants: tableStructure.descendants,
-            index
-        };
-        Logger.info(`请求创建表格块: ${tableConfig.rowSize}x${tableConfig.columnSize}，单元格数量: ${tableConfig.cells?.length || 0}`);
-        const response = await this.post(endpoint, payload);
-        // 创建表格成功后，获取单元格中的图片token
-        const imageTokens = await this.extractImageTokensFromTable(response, tableStructure.imageBlocks);
-        return {
-            ...response,
-            imageTokens: imageTokens
-        };
-    }
-    /**
-     * 从表格中提取图片块信息（优化版本）
-     * @param tableResponse 创建表格的响应数据
-     * @param cells 表格配置，包含原始cells信息
-     * @returns 图片块信息数组，包含坐标和块ID信息
-     */
-    async extractImageTokensFromTable(tableResponse, cells) {
-        try {
-            const imageTokens = [];
-            Logger.info(`tableResponse: ${JSON.stringify(tableResponse)}`);
-            // 判断 cells 是否为空
-            if (!cells || cells.length === 0) {
-                Logger.info('表格中没有图片单元格，跳过图片块信息提取');
-                return imageTokens;
-            }
-            // 创建 localBlockId 到 block_id 的映射
-            const blockIdMap = new Map();
-            if (tableResponse && tableResponse.block_id_relations) {
-                for (const relation of tableResponse.block_id_relations) {
-                    blockIdMap.set(relation.temporary_block_id, relation.block_id);
-                }
-                Logger.debug(`创建了 ${blockIdMap.size} 个块ID映射关系`);
-            }
-            // 遍历所有图片单元格
-            for (const cell of cells) {
-                const { coordinate, localBlockId } = cell;
-                const { row, column } = coordinate;
-                // 根据 localBlockId 在创建表格的返回数据中找到 block_id
-                const blockId = blockIdMap.get(localBlockId);
-                if (!blockId) {
-                    Logger.warn(`未找到 localBlockId ${localBlockId} 对应的 block_id`);
-                    continue;
-                }
-                Logger.debug(`处理单元格 (${row}, ${column})，localBlockId: ${localBlockId}，blockId: ${blockId}`);
-                // 直接添加块信息
-                imageTokens.push({
-                    row,
-                    column,
-                    blockId
-                });
-                Logger.info(`提取到图片块信息: 位置(${row}, ${column})，blockId: ${blockId}`);
-            }
-            Logger.info(`成功提取 ${imageTokens.length} 个图片块信息`);
-            return imageTokens;
-        }
-        catch (error) {
-            Logger.error(`提取表格图片块信息失败: ${error}`);
-            return [];
-        }
+        return this.blockService.createTableBlock(documentId, parentBlockId, tableConfig, index);
     }
     /**
-     * 删除文档中的块，支持批量删除
-     * @param documentId 文档ID或URL
-     * @param parentBlockId 父块ID（通常是文档ID）
-     * @param startIndex 起始索引
-     * @param endIndex 结束索引
-     * @returns 操作结果
+     * 批量删除指定父块下的连续子块（按索引范围）
+     * @see FeishuBlockService.deleteDocumentBlocks
      */
     async deleteDocumentBlocks(documentId, parentBlockId, startIndex, endIndex) {
-        try {
-            const normalizedDocId = ParamUtils.processDocumentId(documentId);
-            const endpoint = `/docx/v1/documents/${normalizedDocId}/blocks/${parentBlockId}/children/batch_delete`;
-            // 确保索引有效
-            if (startIndex < 0 || endIndex < startIndex) {
-                throw new Error('无效的索引范围：起始索引必须大于等于0，结束索引必须大于等于起始索引');
-            }
-            const payload = {
-                start_index: startIndex,
-                end_index: endIndex
-            };
-            Logger.info(`开始删除文档块，文档ID: ${normalizedDocId}，父块ID: ${parentBlockId}，索引范围: ${startIndex}-${endIndex}`);
-            const response = await this.delete(endpoint, payload);
-            Logger.info('文档块删除成功');
-            return response;
-        }
-        catch (error) {
-            this.handleApiError(error, '删除文档块失败');
-        }
+        return this.blockService.deleteDocumentBlocks(documentId, parentBlockId, startIndex, endIndex);
     }
     /**
-     * 删除单个文档块（通过创建起始和结束索引相同的批量删除请求）
-     * @param documentId 文档ID或URL
-     * @param parentBlockId 父块ID
-     * @param blockIndex 块索引
-     * @returns 操作结果
+     * 根据块类型字符串和选项对象创建块内容对象
+     * @see FeishuBlockService.createBlockContent
      */
-    async deleteDocumentBlock(documentId, parentBlockId, blockIndex) {
-        return this.deleteDocumentBlocks(documentId, parentBlockId, blockIndex, blockIndex + 1);
+    createBlockContent(blockType, options) {
+        return this.blockService.createBlockContent(blockType, options);
     }
     /**
-     * 将飞书Wiki链接转换为文档ID
-     * @param wikiUrl Wiki链接或Token
-     * @returns 文档ID
-     */
-    // public async convertWikiToDocumentId(wikiUrl: string): Promise<string> {
-    //   try {
-    //     const wikiToken = ParamUtils.processWikiToken(wikiUrl);
-    //
-    //     // 获取Wiki节点信息
-    //     const endpoint = `/wiki/v2/spaces/get_node`;
-    //     const params = { token: wikiToken, obj_type: 'wiki' };
-    //     const response = await this.get(endpoint, params);
-    //
-    //     if (!response.node || !response.node.obj_token) {
-    //       throw new Error(`无法从Wiki节点获取文档ID: ${wikiToken}`);
-    //     }
-    //
-    //     const documentId = response.node.obj_token;
-    //
-    //     Logger.debug(`Wiki转换为文档ID: ${wikiToken} -> ${documentId}`);
-    //     return documentId;
-    //   } catch (error) {
-    //     this.handleApiError(error, 'Wiki转换为文档ID失败');
-    //     return ''; // 永远不会执行到这里
-    //   }
-    // }
-    /**
-     * 获取BlockFactory实例
-     * @returns BlockFactory实例
+     * 获取 BlockFactory 单例实例
+     * @see FeishuBlockService.getBlockFactory
      */
     getBlockFactory() {
-        return this.blockFactory;
+        return this.blockService.getBlockFactory();
     }
+    // ─── 文件夹 / 知识空间服务委托 ───────────────────────────────────
     /**
-     * 创建块内容对象
-     * @param blockType 块类型
-     * @param options 块选项
-     * @returns 块内容对象
+     * 获取当前用户根文件夹的元数据信息
+     * @see FeishuFoldService.getRootFolderInfo
      */
-    createBlockContent(blockType, options) {
-        try {
-            // 处理特殊的heading标题格式，如heading1, heading2等
-            if (typeof blockType === 'string' && blockType.startsWith('heading')) {
-                // 使用正则表达式匹配"heading"后跟1-9的数字格式
-                const headingMatch = blockType.match(/^heading([1-9])$/);
-                if (headingMatch) {
-                    // 提取数字部分，例如从"heading1"中提取"1"
-                    const level = parseInt(headingMatch[1], 10);
-                    // 额外的安全检查，确保level在1-9范围内
-                    if (level >= 1 && level <= 9) {
-                        // 使用level参数创建标题块
-                        if (!options || Object.keys(options).length === 0) {
-                            // 没有提供选项时创建默认选项
-                            options = { heading: { level, content: '', align: 1 } };
-                        }
-                        else if (!('heading' in options)) {
-                            // 提供了选项但没有heading字段
-                            options = { heading: { level, content: '', align: 1 } };
-                        }
-                        else if (options.heading && !('level' in options.heading)) {
-                            // 提供了heading但没有level字段
-                            options.heading.level = level;
-                        }
-                        blockType = BlockType.HEADING; // 将blockType转为标准的heading类型
-                        Logger.info(`转换特殊标题格式: ${blockType}${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)
-                                };
-                            }
-                            else {
-                                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: (headingOptions.align === 1 || headingOptions.align === 2 || headingOptions.align === 3)
-                                ? 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: (listOptions.align === 1 || listOptions.align === 2 || listOptions.align === 3)
-                                ? 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) {
-                        const mermaidOptions = options.mermaid;
-                        blockConfig.options = {
-                            code: mermaidOptions.code,
-                        };
-                    }
-                    break;
-                case BlockType.WHITEBOARD:
-                    if ('whiteboard' in options && options.whiteboard) {
-                        const whiteboardOptions = options.whiteboard;
-                        blockConfig.options = {
-                            align: (whiteboardOptions.align === 1 || whiteboardOptions.align === 2 || whiteboardOptions.align === 3)
-                                ? 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)
-                                };
-                            }
-                            else {
-                                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: (headingOptions.align === 1 || headingOptions.align === 2 || headingOptions.align === 3)
-                                ? 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: (listOptions.align === 1 || listOptions.align === 2 || listOptions.align === 3)
-                                ? 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;
-                        const mermaidConfig = options.mermaid;
-                        blockConfig.options = {
-                            code: mermaidConfig.code,
-                        };
-                    }
-                    else if ("whiteboard" in options) {
-                        blockConfig.type = BlockType.WHITEBOARD;
-                        const whiteboardConfig = options.whiteboard;
-                        blockConfig.options = {
-                            align: (whiteboardConfig.align === 1 || whiteboardConfig.align === 2 || whiteboardConfig.align === 3)
-                                ? whiteboardConfig.align : 1
-                        };
-                    }
-                    break;
-            }
-            // 记录调试信息
-            Logger.debug(`创建块内容: 类型=${blockConfig.type}, 选项=${JSON.stringify(blockConfig.options)}`);
-            // 使用BlockFactory创建块
-            return this.blockFactory.createBlock(blockConfig.type, blockConfig.options);
-        }
-        catch (error) {
-            Logger.error(`创建块内容对象失败: ${error}`);
-            return null;
-        }
+    async getRootFolderInfo() {
+        return this.foldService.getRootFolderInfo();
     }
     /**
-     * 获取飞书图片资源
-     * @param mediaId 图片媒体ID
-     * @param extra 额外参数，可选
-     * @returns 图片二进制数据
+     * 获取指定文件夹内的文件和子文件夹列表
+     * @see FeishuFoldService.getFolderFileList
      */
-    async getImageResource(mediaId, extra = '') {
-        try {
-            Logger.info(`开始获取图片资源，媒体ID: ${mediaId}`);
-            if (!mediaId) {
-                throw new Error('媒体ID不能为空');
-            }
-            const endpoint = `/drive/v1/medias/${mediaId}/download`;
-            const params = {};
-            if (extra) {
-                params.extra = extra;
-            }
-            // 使用通用的request方法获取二进制响应
-            const response = await this.request(endpoint, 'GET', params, true, {}, 'arraybuffer');
-            const imageBuffer = Buffer.from(response);
-            Logger.info(`图片资源获取成功，大小: ${imageBuffer.length} 字节`);
-            return imageBuffer;
-        }
-        catch (error) {
-            this.handleApiError(error, '获取图片资源失败');
-            return Buffer.from([]); // 永远不会执行到这里
-        }
+    async getFolderFileList(folderToken, orderBy = 'EditedTime', direction = 'DESC') {
+        return this.foldService.getFolderFileList(folderToken, orderBy, direction);
     }
     /**
-     * 获取飞书根文件夹信息
-     * 获取用户的根文件夹的元数据信息，包括token、id和用户id
-     * @returns 根文件夹信息
+     * 在指定文件夹下创建子文件夹
+     * @see FeishuFoldService.createFolder
      */
-    async getRootFolderInfo() {
-        try {
-            const endpoint = '/drive/explorer/v2/root_folder/meta';
-            const response = await this.get(endpoint);
-            Logger.debug('获取根文件夹信息成功:', response);
-            return response;
-        }
-        catch (error) {
-            this.handleApiError(error, '获取飞书根文件夹信息失败');
-        }
+    async createFolder(folderToken, name) {
+        return this.foldService.createFolder(folderToken, name);
     }
     /**
-     * 获取所有知识空间列表（遍历所有分页）
-     * @param pageSize 每页数量，默认20
-     * @returns 所有知识空间列表（仅包含 items 数组，不包含 has_more 和 page_token）
+     * 获取所有知识空间列表（自动分页）
+     * @see FeishuFoldService.getAllWikiSpacesList
      */
     async getAllWikiSpacesList(pageSize = 20) {
-        try {
-            Logger.info(`开始获取所有知识空间列表，每页数量: ${pageSize}`);
-            const endpoint = '/wiki/v2/spaces';
-            let allItems = [];
-            let pageToken = undefined;
-            let hasMore = true;
-            // 循环获取所有页的数据
-            while (hasMore) {
-                const params = { page_size: pageSize };
-                if (pageToken) {
-                    params.page_token = pageToken;
-                }
-                Logger.debug(`请求知识空间列表，page_token: ${pageToken || 'null'}, page_size: ${pageSize}`);
-                const response = await this.get(endpoint, params);
-                if (response && response.items) {
-                    const newItems = response.items;
-                    allItems = [...allItems, ...newItems];
-                    hasMore = response.has_more || false;
-                    pageToken = response.page_token;
-                    Logger.debug(`当前页获取到 ${newItems.length} 个知识空间，累计 ${allItems.length} 个，hasMore: ${hasMore}`);
-                }
-                else {
-                    hasMore = false;
-                    Logger.warn('知识空间列表响应格式异常:', JSON.stringify(response, null, 2));
-                }
-            }
-            Logger.info(`知识空间列表获取完成，共 ${allItems.length} 个空间`);
-            return allItems; // 直接返回数组，不包装在 items 中
-        }
-        catch (error) {
-            this.handleApiError(error, '获取知识空间列表失败');
-        }
+        return this.foldService.getAllWikiSpacesList(pageSize);
     }
     /**
-     * 获取所有知识空间子节点列表（遍历所有分页）
-     * @param spaceId 知识空间ID
-     * @param parentNodeToken 父节点Token（可选，为空时获取根节点）
-     * @param pageSize 每页数量，默认20
-     * @returns 所有子节点列表（仅包含 items 数组，不包含 has_more 和 page_token）
+     * 获取指定知识空间下的所有子节点（自动分页）
+     * @see FeishuFoldService.getAllWikiSpaceNodes
      */
     async getAllWikiSpaceNodes(spaceId, parentNodeToken, pageSize = 20) {
-        try {
-            Logger.info(`开始获取知识空间子节点列表，space_id: ${spaceId}, parent_node_token: ${parentNodeToken || 'null'}, 每页数量: ${pageSize}`);
-            const endpoint = `/wiki/v2/spaces/${spaceId}/nodes`;
-            let allItems = [];
-            let pageToken = undefined;
-            let hasMore = true;
-            // 循环获取所有页的数据
-            while (hasMore) {
-                const params = { page_size: pageSize };
-                if (parentNodeToken) {
-                    params.parent_node_token = parentNodeToken;
-                }
-                if (pageToken) {
-                    params.page_token = pageToken;
-                }
-                Logger.debug(`请求知识空间子节点列表，page_token: ${pageToken || 'null'}, page_size: ${pageSize}`);
-                const response = await this.get(endpoint, params);
-                if (response && response.items) {
-                    const newItems = response.items;
-                    allItems = [...allItems, ...newItems];
-                    hasMore = response.has_more || false;
-                    pageToken = response.page_token;
-                    Logger.debug(`当前页获取到 ${newItems.length} 个子节点，累计 ${allItems.length} 个，hasMore: ${hasMore}`);
-                }
-                else {
-                    hasMore = false;
-                    Logger.warn('知识空间子节点列表响应格式异常:', JSON.stringify(response, null, 2));
-                }
-            }
-            Logger.info(`知识空间子节点列表获取完成，共 ${allItems.length} 个节点`);
-            return allItems; // 直接返回数组，不包装在 items 中
-        }
-        catch (error) {
-            this.handleApiError(error, '获取知识空间子节点列表失败');
-        }
+        return this.foldService.getAllWikiSpaceNodes(spaceId, parentNodeToken, pageSize);
     }
     /**
-     * 获取知识空间信息
-     * @param spaceId 知识空间ID，传入 'my_library' 时获取"我的知识库"
-     * @param lang 语言（仅当 spaceId 为 'my_library' 时有效），默认'en'
-     * @returns 知识空间信息
+     * 获取指定知识空间的详细信息
+     * @see FeishuFoldService.getWikiSpaceInfo
      */
     async getWikiSpaceInfo(spaceId, lang = 'en') {
-        try {
-            const endpoint = `/wiki/v2/spaces/${spaceId}`;
-            const params = {};
-            // 当 spaceId 为 'my_library' 时，添加 lang 参数
-            if (spaceId === 'my_library') {
-                params.lang = lang;
-            }
-            const response = await this.get(endpoint, params);
-            Logger.debug(`获取知识空间信息成功 (space_id: ${spaceId}):`, response);
-            // 如果响应中包含 space 字段，直接返回 space 对象；否则返回整个响应
-            if (response && response.space) {
-                return response.space;
-            }
-            return response;
-        }
-        catch (error) {
-            this.handleApiError(error, `获取知识空间信息失败 (space_id: ${spaceId})`);
-        }
+        return this.foldService.getWikiSpaceInfo(spaceId, lang);
     }
     /**
-     * 创建知识空间节点（知识库节点）
-     * @param spaceId 知识空间ID
-     * @param title 节点标题
-     * @param parentNodeToken 父节点Token（可选，为空时在根节点下创建）
-     * @returns 创建的节点信息，包含 node_token（节点ID）和 obj_token（文档ID）
+     * 在知识空间中创建文档节点
+     * @see FeishuFoldService.createWikiSpaceNode
      */
     async createWikiSpaceNode(spaceId, title, parentNodeToken) {
-        try {
-            Logger.info(`开始创建知识空间节点，space_id: ${spaceId}, title: ${title}, parent_node_token: ${parentNodeToken || 'null（根节点）'}`);
-            const endpoint = `/wiki/v2/spaces/${spaceId}/nodes`;
-            const payload = {
-                title,
-                obj_type: 'docx',
-                node_type: 'origin',
-            };
-            if (parentNodeToken) {
-                payload.parent_node_token = parentNodeToken;
-            }
-            const response = await this.post(endpoint, payload);
-            // 提取 node 对象，统一返回格式
-            if (response && response.data && response.data.node) {
-                const node = response.data.node;
-                Logger.info(`知识空间节点创建成功，node_token: ${node.node_token}, obj_token: ${node.obj_token}`);
-                return node;
-            }
-            Logger.info(`知识空间节点创建成功`);
-            return response;
-        }
-        catch (error) {
-            this.handleApiError(error, '创建知识空间节点失败');
-        }
+        return this.foldService.createWikiSpaceNode(spaceId, title, parentNodeToken);
     }
+    // ─── Search 服务委托 ──────────────────────────────────────────────
     /**
-     * 获取文件夹中的文件清单
-     * @param folderToken 文件夹Token
-     * @param orderBy 排序方式，默认按修改时间排序
-     * @param direction 排序方向，默认降序
-     * @returns 文件清单信息
-     */
-    async getFolderFileList(folderToken, orderBy = 'EditedTime', direction = 'DESC') {
-        try {
-            const endpoint = '/drive/v1/files';
-            const params = {
-                folder_token: folderToken,
-                order_by: orderBy,
-                direction: direction
-            };
-            const response = await this.get(endpoint, params);
-            Logger.debug(`获取文件夹(${folderToken})中的文件清单成功，文件数量: ${response.files?.length || 0}`);
-            return response;
-        }
-        catch (error) {
-            this.handleApiError(error, '获取文件夹中的文件清单失败');
-        }
-    }
-    /**
-     * 创建文件夹
-     * @param folderToken 父文件夹Token
-     * @param name 文件夹名称
-     * @returns 创建的文件夹信息
-     */
-    async createFolder(folderToken, name) {
-        try {
-            const endpoint = '/drive/v1/files/create_folder';
-            const payload = {
-                folder_token: folderToken,
-                name: name
-            };
-            const response = await this.post(endpoint, payload);
-            Logger.debug(`文件夹创建成功, token: ${response.token}, url: ${response.url}`);
-            return response;
-        }
-        catch (error) {
-            this.handleApiError(error, '创建文件夹失败');
-        }
-    }
-    /**
-     * 搜索飞书文档（支持分页和轮询）
-     * @param searchKey 搜索关键字
-     * @param maxSize 最大返回数量，如果未指定则只返回一页
-     * @param offset 偏移量，用于分页，默认0
-     * @returns 搜索结果，包含数据和分页信息
+     * 搜索飞书文档，支持分页
+     * @see FeishuSearchService.searchDocuments
      */
     async searchDocuments(searchKey, maxSize, offset = 0) {
-        try {
-            Logger.info(`开始搜索文档，关键字: ${searchKey}, maxSize: ${maxSize || '未指定'}, offset: ${offset}`);
-            const endpoint = `/suite/docs-api/search/object`;
-            const PAGE_SIZE = 50; // 文档API固定使用50
-            const allResults = [];
-            let currentOffset = offset;
-            let hasMore = true;
-            // 如果指定了maxSize，轮询获取直到满足maxSize或没有更多数据
-            while (hasMore && (maxSize === undefined || allResults.length < maxSize)) {
-                const payload = {
-                    search_key: searchKey,
-                    docs_types: ["doc"],
-                    count: PAGE_SIZE,
-                    offset: currentOffset
-                };
-                Logger.debug(`请求搜索文档，offset: ${currentOffset}, count: ${PAGE_SIZE}`);
-                const response = await this.post(endpoint, payload);
-                Logger.debug('搜索响应:', JSON.stringify(response, null, 2));
-                if (response && response.docs_entities) {
-                    const resultCount = response.docs_entities.length;
-                    const apiHasMore = response.has_more || false;
-                    // 更新offset
-                    currentOffset += resultCount;
-                    if (resultCount > 0) {
-                        allResults.push(...response.docs_entities);
-                        hasMore = apiHasMore; // 保持API返回的hasMore
-                        // 如果指定了maxSize，只取需要的数量
-                        if (maxSize == undefined || allResults.length >= maxSize) {
-                            // 如果已经达到maxSize，停止轮询，但保持API返回的hasMore值
-                            Logger.debug(`已达到maxSize ${maxSize}，停止获取，但API还有更多: ${hasMore}`);
-                            break; // 停止轮询
-                        }
-                    }
-                    else {
-                        hasMore = false;
-                    }
-                    Logger.debug(`文档搜索进度: 已获取 ${allResults.length} 条，hasMore: ${hasMore}`);
-                }
-                else {
-                    Logger.warn('搜索响应格式异常:', JSON.stringify(response, null, 2));
-                    hasMore = false;
-                }
-            }
-            const resultCount = allResults.length;
-            Logger.info(`文档搜索完成，找到 ${resultCount} 个结果${maxSize ? `(maxSize: ${maxSize})` : ''}`);
-            return {
-                items: allResults,
-                hasMore: hasMore,
-                nextOffset: currentOffset
-            };
-        }
-        catch (error) {
-            this.handleApiError(error, '搜索文档失败');
-            throw error;
-        }
+        return this.searchService.searchDocuments(searchKey, maxSize, offset);
     }
     /**
-     * 搜索Wiki知识库节点（支持分页和轮询）
-     * @param query 搜索关键字
-     * @param maxSize 最大返回数量，如果未指定则只返回一页
-     * @param pageToken 分页token，用于获取下一页，可选
-     * @returns 搜索结果，包含数据和分页信息
+     * 搜索飞书知识库节点，支持分页
+     * @see FeishuSearchService.searchWikiNodes
      */
     async searchWikiNodes(query, maxSize, pageToken) {
-        try {
-            Logger.info(`开始搜索知识库，关键字: ${query}, maxSize: ${maxSize || '未指定'}, pageToken: ${pageToken || '无'}`);
-            const endpoint = `/wiki/v1/nodes/search`;
-            const PAGE_SIZE = 20; // Wiki API每页固定使用20
-            const allResults = [];
-            let currentPageToken = pageToken;
-            let hasMore = true;
-            // 如果指定了maxSize，轮询获取直到满足maxSize或没有更多数据
-            while (hasMore && (maxSize === undefined || allResults.length < maxSize)) {
-                const size = Math.min(PAGE_SIZE, 100); // Wiki API最大支持100
-                let url = `${endpoint}?page_size=${size}`;
-                if (currentPageToken) {
-                    url += `&page_token=${currentPageToken}`;
-                }
-                const payload = {
-                    query: query
-                };
-                Logger.debug(`请求搜索知识库，pageSize: ${size}, pageToken: ${currentPageToken || '无'}`);
-                const response = await this.post(url, payload);
-                Logger.debug('知识库搜索响应:', JSON.stringify(response, null, 2));
-                // baseService的post方法已经提取了response.data.data，所以response直接就是data字段的内容
-                if (response && response.items) {
-                    const resultCount = response.items?.length || 0;
-                    const apiHasMore = response.has_more || false;
-                    currentPageToken = response.page_token || null;
-                    if (resultCount > 0) {
-                        allResults.push(...response.items);
-                        hasMore = apiHasMore; // 保持API返回的hasMore，以便下次调用可以继续
-                        if (maxSize !== undefined) {
-                            // 如果已经达到maxSize，停止轮询，但保持API返回的hasMore值
-                            if (allResults.length >= maxSize) {
-                                Logger.debug(`已达到maxSize ${maxSize}，停止获取，但API还有更多: ${hasMore}`);
-                                break; // 停止轮询
-                            }
-                        }
-                        else {
-                            break; // 只返回一页
-                        }
-                    }
-                    else {
-                        hasMore = false;
-                    }
-                    Logger.debug(`知识库搜索进度: 已获取 ${allResults.length} 条，hasMore: ${hasMore}`);
-                }
-                else {
-                    Logger.warn('知识库搜索响应格式异常:', JSON.stringify(response, null, 2));
-                    hasMore = false;
-                }
-            }
-            const resultCount = allResults.length;
-            Logger.info(`知识库搜索完成，找到 ${resultCount} 个结果${maxSize ? `(maxSize: ${maxSize})` : ''}`);
-            return {
-                items: allResults,
-                hasMore: hasMore,
-                pageToken: currentPageToken,
-                count: resultCount
-            };
-        }
-        catch (error) {
-            this.handleApiError(error, '搜索知识库失败');
-            throw error;
-        }
+        return this.searchService.searchWikiNodes(query, maxSize, pageToken);
     }
     /**
-     * 统一搜索方法，支持文档和知识库搜索
-     * @param searchKey 搜索关键字
-     * @param searchType 搜索类型：'document' | 'wiki' | 'both'，默认'both'
-     * @param offset 文档搜索的偏移量，可选（用于分页）
-     * @param pageToken 知识库搜索的分页token，可选（用于分页）
-     * @returns 搜索结果，包含documents、wikis和分页信息
+     * 统一搜索入口，可同时搜索文档和知识库节点
+     * @see FeishuSearchService.search
      */
     async search(searchKey, searchType = 'both', offset, pageToken) {
-        try {
-            // wiki搜索不支持tenant认证，如果是tenant模式则强制使用document搜索
-            if (this.config.feishu.authType === 'tenant' && (searchType === 'wiki' || searchType === 'both')) {
-                Logger.info(`租户认证模式下wiki搜索不支持，强制将searchType从 ${searchType} 修改为 document`);
-                searchType = 'document';
-            }
-            const MAX_TOTAL_RESULTS = 100; // 总共最多200条（文档+wiki合计）
-            const docOffset = offset ?? 0;
-            Logger.info(`开始统一搜索，关键字: ${searchKey}, 类型: ${searchType}, offset: ${docOffset}, pageToken: ${pageToken || '无'}`);
-            const documents = [];
-            const wikis = [];
-            // 用于生成分页指导的内部变量
-            let documentOffset = docOffset;
-            let wikiPageToken = null;
-            let documentHasMore = false;
-            let wikiHasMore = false;
-            // 搜索文档
-            if (searchType === 'document' || searchType === 'both') {
-                // 计算文档的最大数量（不超过总限制）
-                const maxDocCount = MAX_TOTAL_RESULTS;
-                const docResult = await this.searchDocuments(searchKey, maxDocCount, docOffset);
-                if (docResult.items && docResult.items.length > 0) {
-                    documents.push(...docResult.items);
-                    documentOffset = docResult.nextOffset;
-                    documentHasMore = docResult.hasMore;
-                    Logger.debug(`文档搜索: 获取 ${docResult.items.length} 条，新offset: ${documentOffset}, hasMore: ${documentHasMore}`);
-                }
-                else {
-                    documentHasMore = false;
-                    Logger.debug('文档搜索: 无结果');
-                }
-            }
-            // 搜索知识库（仅在文档+wiki总数未达到100条时继续）
-            if (searchType === 'wiki' || searchType === 'both') {
-                const currentDocCount = documents.length;
-                const remainingCount = MAX_TOTAL_RESULTS - currentDocCount;
-                // 如果还有剩余空间，获取知识库
-                if (remainingCount > 0) {
-                    const wikiResult = await this.searchWikiNodes(searchKey, remainingCount, pageToken);
-                    if (wikiResult.items && wikiResult.items.length > 0) {
-                        wikis.push(...wikiResult.items);
-                        wikiPageToken = wikiResult.pageToken;
-                        wikiHasMore = wikiResult.hasMore;
-                        Logger.debug(`知识库搜索: 获取 ${wikiResult.items.length} 条，pageToken: ${wikiPageToken || '无'}, hasMore: ${wikiHasMore}`);
-                    }
-                    else {
-                        wikiHasMore = false;
-                        Logger.debug('知识库搜索: 无结果');
-                    }
-                }
-                else {
-                    Logger.info(`已达到总限制 ${MAX_TOTAL_RESULTS} 条，不再获取知识库`);
-                    wikiHasMore = true;
-                }
-            }
-            // 生成分页指导信息
-            const paginationGuide = this.generatePaginationGuide(searchType, documentHasMore, wikiHasMore, documentOffset, wikiPageToken);
-            const total = documents.length + wikis.length;
-            const hasMore = documentHasMore || wikiHasMore;
-            Logger.info(`统一搜索完成，文档: ${documents.length} 条, 知识库: ${wikis.length} 条, 总计: ${total} 条, hasMore: ${hasMore}`);
-            // 只返回必要字段，根据搜索类型动态添加
-            const result = {
-                paginationGuide
-            };
-            if (searchType === 'document' || searchType === 'both') {
-                result.documents = documents;
-            }
-            if (searchType === 'wiki' || searchType === 'both') {
-                result.wikis = wikis;
-            }
-            return result;
-        }
-        catch (error) {
-            this.handleApiError(error, '统一搜索失败');
-            throw error;
-        }
+        return this.searchService.search(searchKey, searchType, offset, pageToken);
     }
+    // ─── 图片块操作委托 ───────────────────────────────────────────────
     /**
-     * 生成分页指导信息
-     * @param searchType 搜索类型
-     * @param documentHasMore 文档是否还有更多
-     * @param wikiHasMore 知识库是否还有更多
-     * @param documentOffset 文档的下一offset
-     * @param wikiPageToken 知识库的下一页token
-     * @returns 分页指导信息
+     * 将本地路径或远程 URL 的图片转换为 Base64 及文件名
+     * @see FeishuBlockService.getImageBase64FromPathOrUrl
      */
-    generatePaginationGuide(searchType, documentHasMore, wikiHasMore, documentOffset, wikiPageToken) {
-        const guide = {
-            hasMore: documentHasMore || wikiHasMore,
-            description: ''
-        };
-        if (!guide.hasMore) {
-            guide.description = '没有更多结果了';
-            return guide;
-        }
-        // 根据搜索类型和hasMore状态生成指导
-        if (searchType === 'document') {
-            if (documentHasMore) {
-                guide.nextPageParams = {
-                    searchType: 'document',
-                    offset: documentOffset
-                };
-                guide.description = `请使用 search_feishu_documents工具获取下一页,searchType = document offset=${documentOffset} 获取文档的下一页`;
-            }
-        }
-        else if (searchType === 'wiki') {
-            if (wikiHasMore && wikiPageToken) {
-                guide.nextPageParams = {
-                    searchType: 'wiki',
-                    pageToken: wikiPageToken
-                };
-                guide.description = `请使用 search_feishu_documents工具获取下一页,searchType = wiki pageToken="${wikiPageToken}" 获取知识库的下一页`;
-            }
-        }
-        else if (searchType === 'both') {
-            // both类型：优先返回文档的下一页，如果文档没有更多了，再返回知识库的下一页
-            if (documentHasMore) {
-                guide.nextPageParams = {
-                    searchType: 'both',
-                    offset: documentOffset
-                };
-                guide.description = `请使用 search_feishu_documents工具获取下一页,searchType = both offset=${documentOffset} 获取文档的下一页`;
-            }
-            else if (wikiHasMore && wikiPageToken) {
-                guide.nextPageParams = {
-                    searchType: 'wiki',
-                    pageToken: wikiPageToken
-                };
-                guide.description = `请使用 search_feishu_documents工具获取下一页,searchType = wiki pageToken="${wikiPageToken}" 获取知识库的下一页wiki结果`;
-            }
-        }
-        return guide;
+    async getImageBase64FromPathOrUrl(imagePathOrUrl) {
+        return this.blockService.getImageBase64FromPathOrUrl(imagePathOrUrl);
     }
     /**
-     * 上传图片素材到飞书
-     * @param imageBase64 图片的Base64编码
-     * @param fileName 图片文件名，如果不提供则自动生成
-     * @param parentBlockId 图片块ID
-     * @returns 上传结果，包含file_token
+     * 下载飞书图片素材，返回二进制数据
+     * @see FeishuBlockService.getImageResource
      */
-    async uploadImageMedia(imageBase64, fileName, parentBlockId) {
-        try {
-            const endpoint = '/drive/v1/medias/upload_all';
-            // 将Base64转换为Buffer
-            const imageBuffer = Buffer.from(imageBase64, 'base64');
-            const imageSize = imageBuffer.length;
-            // 如果没有提供文件名，根据Base64数据生成默认文件名
-            if (!fileName) {
-                // 简单检测图片格式
-                if (imageBase64.startsWith('/9j/')) {
-                    fileName = `image_${Date.now()}.jpg`;
-                }
-                else if (imageBase64.startsWith('iVBORw0KGgo')) {
-                    fileName = `image_${Date.now()}.png`;
-                }
-                else if (imageBase64.startsWith('R0lGODlh')) {
-                    fileName = `image_${Date.now()}.gif`;
-                }
-                else {
-                    fileName = `image_${Date.now()}.png`; // 默认PNG格式
-                }
-            }
-            Logger.info(`开始上传图片素材，文件名: ${fileName}，大小: ${imageSize} 字节，关联块ID: ${parentBlockId}`);
-            // 验证图片大小（可选的业务检查）
-            if (imageSize > 20 * 1024 * 1024) {
-                // 20MB限制
-                Logger.warn(`图片文件过大: ${imageSize} 字节，建议小于20MB`);
-            }
-            // 使用FormData构建multipart/form-data请求
-            const formData = new FormData();
-            // file字段传递图片的二进制数据流
-            // Buffer是Node.js中的二进制数据类型，form-data库会将其作为文件流处理
-            formData.append('file', imageBuffer, {
-                filename: fileName,
-                contentType: this.getMimeTypeFromFileName(fileName),
-                knownLength: imageSize, // 明确指定文件大小，避免流读取问题
-            });
-            // 飞书API要求的其他表单字段
-            formData.append('file_name', fileName);
-            formData.append('parent_type', 'docx_image'); // 固定值：文档图片类型
-            formData.append('parent_node', parentBlockId); // 关联的图片块ID
-            formData.append('size', imageSize.toString()); // 文件大小（字节，字符串格式）
-            // 使用通用的post方法发送请求
-            const response = await this.post(endpoint, formData);
-            Logger.info(`图片素材上传成功，file_token: ${response.file_token}`);
-            return response;
-        }
-        catch (error) {
-            this.handleApiError(error, '上传图片素材失败');
-        }
+    async getImageResource(mediaId, extra = '') {
+        return this.blockService.getImageResource(mediaId, extra);
     }
     /**
-     * 设置图片块的素材内容
-     * @param documentId 文档ID
-     * @param imageBlockId 图片块ID
-     * @param fileToken 图片素材的file_token
-     * @returns 设置结果
+     * 将图片素材上传到飞书云端
+     * @see FeishuBlockService.uploadImageMedia
      */
-    async setImageBlockContent(documentId, imageBlockId, fileToken) {
-        try {
-            const normalizedDocId = ParamUtils.processDocumentId(documentId);
-            const endpoint = `/docx/v1/documents/${normalizedDocId}/blocks/${imageBlockId}`;
-            const payload = {
-                replace_image: {
-                    token: fileToken,
-                },
-            };
-            Logger.info(`开始设置图片块内容，文档ID: ${normalizedDocId}，块ID: ${imageBlockId}，file_token: ${fileToken}`);
-            const response = await this.patch(endpoint, payload);
-            Logger.info('图片块内容设置成功');
-            return response;
-        }
-        catch (error) {
-            this.handleApiError(error, '设置图片块内容失败');
-        }
+    async uploadImageMedia(imageBase64, fileName, parentBlockId) {
+        return this.blockService.uploadImageMedia(imageBase64, fileName, parentBlockId);
     }
     /**
-     * 创建完整的图片块（包括创建空块、上传图片、设置内容的完整流程）
-     * @param documentId 文档ID
-     * @param parentBlockId 父块ID
-     * @param imagePathOrUrl 图片路径或URL
-     * @param options 图片选项
-     * @returns 创建结果
+     * 将已上传的图片素材绑定到指定图片块
+     * @see FeishuBlockService.setImageBlockContent
      */
-    async createImageBlock(documentId, parentBlockId, imagePathOrUrl, options = {}) {
-        try {
-            const { fileName: providedFileName, width, height, index = 0 } = options;
-            Logger.info(`开始创建图片块，文档ID: ${documentId}，父块ID: ${parentBlockId}，图片源: ${imagePathOrUrl}，插入位置: ${index}`);
-            // 从路径或URL获取图片的Base64编码
-            const { base64: imageBase64, fileName: detectedFileName } = await this.getImageBase64FromPathOrUrl(imagePathOrUrl);
-            // 使用提供的文件名或检测到的文件名
-            const finalFileName = providedFileName || detectedFileName;
-            // 第1步：创建空图片块
-            Logger.info('第1步：创建空图片块');
-            const imageBlockContent = this.blockFactory.createImageBlock({
-                width,
-                height,
-            });
-            const createBlockResult = await this.createDocumentBlock(documentId, parentBlockId, imageBlockContent, index);
-            if (!createBlockResult?.children?.[0]?.block_id) {
-                throw new Error('创建空图片块失败：无法获取块ID');
-            }
-            const imageBlockId = createBlockResult.children[0].block_id;
-            Logger.info(`空图片块创建成功，块ID: ${imageBlockId}`);
-            // 第2步：上传图片素材
-            Logger.info('第2步：上传图片素材');
-            const uploadResult = await this.uploadImageMedia(imageBase64, finalFileName, imageBlockId);
-            if (!uploadResult?.file_token) {
-                throw new Error('上传图片素材失败：无法获取file_token');
-            }
-            Logger.info(`图片素材上传成功，file_token: ${uploadResult.file_token}`);
-            // 第3步：设置图片块内容
-            Logger.info('第3步：设置图片块内容');
-            const setContentResult = await this.setImageBlockContent(documentId, imageBlockId, uploadResult.file_token);
-            Logger.info('图片块创建完成');
-            // 返回综合结果
-            return {
-                imageBlock: createBlockResult.children[0],
-                imageBlockId: imageBlockId,
-                fileToken: uploadResult.file_token,
-                uploadResult: uploadResult,
-                setContentResult: setContentResult,
-                documentRevisionId: setContentResult.document_revision_id ||
-                    createBlockResult.document_revision_id,
-            };
-        }
-        catch (error) {
-            this.handleApiError(error, '创建图片块失败');
-        }
+    async setImageBlockContent(documentId, imageBlockId, fileToken) {
+        return this.blockService.setImageBlockContent(documentId, imageBlockId, fileToken);
     }
     /**
-     * 根据文件名获取MIME类型
-     * @param fileName 文件名
-     * @returns MIME类型
+     * 完整创建图片块（创建空块 → 上传素材 → 绑定），支持本地路径和 URL
+     * @see FeishuBlockService.createImageBlock
      */
-    getMimeTypeFromFileName(fileName) {
-        const extension = fileName.toLowerCase().split('.').pop();
-        switch (extension) {
-            case 'jpg':
-            case 'jpeg':
-                return 'image/jpeg';
-            case 'png':
-                return 'image/png';
-            case 'gif':
-                return 'image/gif';
-            case 'webp':
-                return 'image/webp';
-            case 'bmp':
-                return 'image/bmp';
-            case 'svg':
-                return 'image/svg+xml';
-            default:
-                return 'image/png'; // 默认PNG
-        }
+    async createImageBlock(documentId, parentBlockId, imagePathOrUrl, options = {}) {
+        return this.blockService.createImageBlock(documentId, parentBlockId, imagePathOrUrl, options);
     }
+    // ─── Whiteboard 服务委托 ──────────────────────────────────────────
     /**
-     * 获取画板内容
-     * @param whiteboardId 画板ID或URL
-     * @returns 画板节点数据
+     * 获取画板的所有节点内容
+     * @see FeishuWhiteboardService.getWhiteboardContent
      */
     async getWhiteboardContent(whiteboardId) {
-        try {
-            const normalizedWhiteboardId = ParamUtils.processWhiteboardId(whiteboardId);
-            const endpoint = `/board/v1/whiteboards/${normalizedWhiteboardId}/nodes`;
-            Logger.info(`开始获取画板内容，画板ID: ${normalizedWhiteboardId}`);
-            const response = await this.get(endpoint);
-            Logger.info(`画板内容获取成功，节点数量: ${response.nodes?.length || 0}`);
-            return response;
-        }
-        catch (error) {
-            this.handleApiError(error, '获取画板内容失败');
-        }
+        return this.whiteboardService.getWhiteboardContent(whiteboardId);
     }
     /**
-     * 获取画板缩略图
-     * @param whiteboardId 画板ID或URL
-     * @returns 画板缩略图的二进制数据
+     * 获取画板缩略图，返回二进制数据
+     * @see FeishuWhiteboardService.getWhiteboardThumbnail
      */
     async getWhiteboardThumbnail(whiteboardId) {
-        try {
-            const normalizedWhiteboardId = ParamUtils.processWhiteboardId(whiteboardId);
-            const endpoint = `/board/v1/whiteboards/${normalizedWhiteboardId}/download_as_image`;
-            Logger.info(`开始获取画板缩略图，画板ID: ${normalizedWhiteboardId}`);
-            // 使用通用的request方法获取二进制响应
-            const response = await this.request(endpoint, 'GET', {}, true, {}, 'arraybuffer');
-            const thumbnailBuffer = Buffer.from(response);
-            Logger.info(`画板缩略图获取成功，大小: ${thumbnailBuffer.length} 字节`);
-            return thumbnailBuffer;
-        }
-        catch (error) {
-            this.handleApiError(error, '获取画板缩略图失败');
-            return Buffer.from([]); // 永远不会执行到这里
-        }
+        return this.whiteboardService.getWhiteboardThumbnail(whiteboardId);
     }
     /**
-     * 在画板中创建图表节点（支持 PlantUML 和 Mermaid）
-     * @param whiteboardId 画板ID（token）
-     * @param code 图表代码（PlantUML 或 Mermaid）
-     * @param syntaxType 语法类型：1=PlantUML, 2=Mermaid
-     * @returns 创建结果
+     * 在画板中创建图表节点（支持 PlantUML / Mermaid）
+     * @see FeishuWhiteboardService.createDiagramNode
      */
     async createDiagramNode(whiteboardId, code, syntaxType) {
-        try {
-            const normalizedWhiteboardId = ParamUtils.processWhiteboardId(whiteboardId);
-            const endpoint = `/board/v1/whiteboards/${normalizedWhiteboardId}/nodes/plantuml`;
-            const syntaxTypeName = syntaxType === 1 ? 'PlantUML' : 'Mermaid';
-            Logger.info(`开始在画板中创建 ${syntaxTypeName} 节点，画板ID: ${normalizedWhiteboardId}`);
-            Logger.debug(`${syntaxTypeName} 代码: ${code.substring(0, 200)}...`);
-            const payload = {
-                plant_uml_code: code,
-                style_type: 1, // 画板样式（默认为2 经典样式） 示例值：1 可选值有： 1：画板样式（解析之后为多个画板节点，粘贴到画板中，不可对语法进行二次编辑） 2：经典样式（解析之后为一张图片，粘贴到画板中，可对语法进行二次编辑）（只有PlantUml语法支持经典样式
-                syntax_type: syntaxType
-            };
-            Logger.debug(`请求载荷: ${JSON.stringify(payload, null, 2)}`);
-            const response = await this.post(endpoint, payload);
-            Logger.info(`${syntaxTypeName} 节点创建成功`);
-            return response;
-        }
-        catch (error) {
-            const syntaxTypeName = syntaxType === 1 ? 'PlantUML' : 'Mermaid';
-            Logger.error(`创建 ${syntaxTypeName} 节点失败，画板ID: ${whiteboardId}`, error);
-            this.handleApiError(error, `创建 ${syntaxTypeName} 节点失败`);
-        }
-    }
-    /**
-     * 从路径或URL获取图片的Base64编码
-     * @param imagePathOrUrl 图片路径或URL
-     * @returns 图片的Base64编码和文件名
-     */
-    async getImageBase64FromPathOrUrl(imagePathOrUrl) {
-        try {
-            let imageBuffer;
-            let fileName;
-            // 判断是否为HTTP/HTTPS URL
-            if (imagePathOrUrl.startsWith('http://') || imagePathOrUrl.startsWith('https://')) {
-                Logger.info(`从URL获取图片: ${imagePathOrUrl}`);
-                // 从URL下载图片
-                const response = await axios.get(imagePathOrUrl, {
-                    responseType: 'arraybuffer',
-                    timeout: 30000, // 30秒超时
-                });
-                imageBuffer = Buffer.from(response.data);
-                // 从URL中提取文件名
-                const urlPath = new URL(imagePathOrUrl).pathname;
-                fileName = path.basename(urlPath) || `image_${Date.now()}.png`;
-                Logger.info(`从URL成功获取图片，大小: ${imageBuffer.length} 字节，文件名: ${fileName}`);
-            }
-            else {
-                // 本地文件路径
-                Logger.info(`从本地路径读取图片: ${imagePathOrUrl}`);
-                // 检查文件是否存在
-                if (!fs.existsSync(imagePathOrUrl)) {
-                    throw new Error(`图片文件不存在: ${imagePathOrUrl}`);
-                }
-                // 读取文件
-                imageBuffer = fs.readFileSync(imagePathOrUrl);
-                fileName = path.basename(imagePathOrUrl);
-                Logger.info(`从本地路径成功读取图片，大小: ${imageBuffer.length} 字节，文件名: ${fileName}`);
-            }
-            // 转换为Base64
-            const base64 = imageBuffer.toString('base64');
-            return { base64, fileName };
-        }
-        catch (error) {
-            Logger.error(`获取图片失败: ${error}`);
-            throw new Error(`获取图片失败: ${error instanceof Error ? error.message : String(error)}`);
-        }
+        return this.whiteboardService.createDiagramNode(whiteboardId, code, syntaxType);
+    }
+    // ─── 任务服务委托 ─────────────────────────────────────────────────
+    /** @see FeishuTaskService.createTask */
+    async createTask(params) {
+        return this.taskService.createTask(params);
+    }
+    /** @see FeishuTaskService.createTasksNested. Supports multi-level subTasks. */
+    async createTasksNested(rootItems, options) {
+        return this.taskService.createTasksNested(rootItems, options);
+    }
+    /** @see FeishuTaskService.updateTask */
+    async updateTask(taskGuid, params) {
+        return this.taskService.updateTask(taskGuid, params);
+    }
+    /** @see FeishuTaskService.addTaskMembers */
+    async addTaskMembers(taskGuid, members) {
+        return this.taskService.addTaskMembers(taskGuid, members);
+    }
+    /** @see FeishuTaskService.removeTaskMembers */
+    async removeTaskMembers(taskGuid, members) {
+        return this.taskService.removeTaskMembers(taskGuid, members);
+    }
+    /** @see FeishuTaskService.addTaskReminder. Task must have due; only one reminder per task. */
+    async addTaskReminder(taskGuid, relativeFireMinute) {
+        return this.taskService.addTaskReminder(taskGuid, relativeFireMinute);
+    }
+    /** @see FeishuTaskService.removeTaskReminders */
+    async removeTaskReminders(taskGuid, reminderIds) {
+        return this.taskService.removeTaskReminders(taskGuid, reminderIds);
+    }
+    /** @see FeishuTaskService.listTasksTwoPages. Lists "my_tasks" (我负责的), 2 pages (up to 100 items), slimmed fields. Requires user token. */
+    async listTasks(pageToken, completed) {
+        return this.taskService.listTasksTwoPages(pageToken, completed);
+    }
+    /** @see FeishuTaskService.deleteTask */
+    async deleteTask(taskGuid) {
+        return this.taskService.deleteTask(taskGuid);
+    }
+    /** 批量删除任务。逐条调用 deleteTask，返回已删除的 guid 与每项错误。 */
+    async deleteTasks(taskGuids) {
+        const deleted = [];
+        const errors = [];
+        for (const guid of taskGuids) {
+            try {
+                await this.taskService.deleteTask(guid);
+                deleted.push(guid);
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                errors.push({ taskGuid: guid, error: msg });
+            }
+        }
+        return { deleted, errors };
+    }
+    // ─── 日历服务委托 ─────────────────────────────────────────────────
+    /** @see FeishuCalendarService - 供 calendarTools 等调用 */
+    getCalendarService() {
+        return this.calendarService;
+    }
+    // ─── 成员搜索服务委托 ──────────────────────────────────────────────
+    /** @see FeishuMemberService.searchUsers */
+    async searchUsers(query, pageToken) {
+        return this.memberService.searchUsers(query, pageToken);
+    }
+    /** @see FeishuMemberService.batchGetUsers */
+    async getUsersBatch(userIds, userIdType = 'open_id') {
+        return this.memberService.batchGetUsers(userIds, userIdType);
     }
 }