feishu-mcp 0.0.5 → 0.0.7

package/dist/services/baseService.js

@@ -0,0 +1,204 @@
+import axios, { AxiosError } from 'axios';
+import { Logger } from '../utils/logger.js';
+import { formatErrorMessage } from '../utils/error.js';
+/**
+ * API服务基类
+ * 提供通用的HTTP请求处理和认证功能
+ */
+export class BaseApiService {
+    constructor() {
+        Object.defineProperty(this, "accessToken", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "tokenExpireTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    /**
+     * 检查访问令牌是否过期
+     * @returns 是否过期
+     */
+    isTokenExpired() {
+        if (!this.accessToken || !this.tokenExpireTime)
+            return true;
+        // 预留5分钟的缓冲时间
+        return Date.now() >= (this.tokenExpireTime - 5 * 60 * 1000);
+    }
+    /**
+     * 处理API错误
+     * @param error 错误对象
+     * @param message 错误上下文消息
+     * @throws 标准化的API错误
+     */
+    handleApiError(error, message) {
+        Logger.error(`${message}:`, error);
+        // 如果已经是格式化的API错误，直接重新抛出
+        if (error && typeof error === 'object' && 'status' in error && 'err' in error) {
+            throw error;
+        }
+        // 处理Axios错误
+        if (error instanceof AxiosError && error.response) {
+            const responseData = error.response.data;
+            const apiError = {
+                status: error.response.status,
+                err: formatErrorMessage(error, message),
+                apiError: responseData,
+                logId: responseData?.log_id
+            };
+            throw apiError;
+        }
+        // 处理其他类型的错误
+        const errorMessage = error instanceof Error
+            ? error.message
+            : (typeof error === 'string' ? error : '未知错误');
+        throw {
+            status: 500,
+            err: formatErrorMessage(error, message),
+            apiError: {
+                code: -1,
+                msg: errorMessage,
+                error
+            }
+        };
+    }
+    /**
+     * 执行API请求
+     * @param endpoint 请求端点
+     * @param method 请求方法
+     * @param data 请求数据
+     * @param needsAuth 是否需要认证
+     * @param additionalHeaders 附加请求头
+     * @returns 响应数据
+     */
+    async request(endpoint, method = 'GET', data, needsAuth = true, additionalHeaders) {
+        try {
+            // 构建请求URL
+            const url = `${this.getBaseUrl()}${endpoint}`;
+            // 准备请求头
+            const headers = {
+                'Content-Type': 'application/json',
+                ...additionalHeaders
+            };
+            // 添加认证令牌
+            if (needsAuth) {
+                const accessToken = await this.getAccessToken();
+                headers['Authorization'] = `Bearer ${accessToken}`;
+            }
+            // 记录请求信息
+            Logger.debug('准备发送请求:');
+            Logger.debug(`请求URL: ${url}`);
+            Logger.debug(`请求方法: ${method}`);
+            if (data) {
+                Logger.debug(`请求数据:`, data);
+            }
+            // 构建请求配置
+            const config = {
+                method,
+                url,
+                headers,
+                data: method !== 'GET' ? data : undefined,
+                params: method === 'GET' ? data : undefined
+            };
+            // 发送请求
+            const response = await axios(config);
+            // 记录响应信息
+            Logger.debug('收到响应:');
+            Logger.debug(`响应状态码: ${response.status}`);
+            Logger.debug(`响应头:`, response.headers);
+            Logger.debug(`响应数据:`, response.data);
+            // 检查API错误
+            if (response.data && typeof response.data.code === 'number' && response.data.code !== 0) {
+                Logger.error(`API返回错误码: ${response.data.code}, 错误消息: ${response.data.msg}`);
+                throw {
+                    status: response.status,
+                    err: response.data.msg || 'API返回错误码',
+                    apiError: response.data,
+                    logId: response.data.log_id
+                };
+            }
+            // 返回数据
+            return response.data.data;
+        }
+        catch (error) {
+            // 处理401错误，可能是令牌过期
+            if (error instanceof AxiosError && error.response?.status === 401) {
+                // 清除当前令牌，下次请求会重新获取
+                this.accessToken = '';
+                this.tokenExpireTime = null;
+                Logger.warn('访问令牌可能已过期，已清除缓存的令牌');
+                // 如果这是重试请求，避免无限循环
+                if (error.isRetry) {
+                    this.handleApiError(error, `API请求失败 (${endpoint})`);
+                }
+                // 重试请求
+                Logger.info('重试请求...');
+                try {
+                    return await this.request(endpoint, method, data, needsAuth, additionalHeaders);
+                }
+                catch (retryError) {
+                    // 标记为重试请求
+                    retryError.isRetry = true;
+                    this.handleApiError(retryError, `重试API请求失败 (${endpoint})`);
+                }
+            }
+            // 处理其他错误
+            this.handleApiError(error, `API请求失败 (${endpoint})`);
+        }
+    }
+    /**
+     * GET请求
+     * @param endpoint 请求端点
+     * @param params 请求参数
+     * @param needsAuth 是否需要认证
+     * @returns 响应数据
+     */
+    async get(endpoint, params, needsAuth = true) {
+        return this.request(endpoint, 'GET', params, needsAuth);
+    }
+    /**
+     * POST请求
+     * @param endpoint 请求端点
+     * @param data 请求数据
+     * @param needsAuth 是否需要认证
+     * @returns 响应数据
+     */
+    async post(endpoint, data, needsAuth = true) {
+        return this.request(endpoint, 'POST', data, needsAuth);
+    }
+    /**
+     * PUT请求
+     * @param endpoint 请求端点
+     * @param data 请求数据
+     * @param needsAuth 是否需要认证
+     * @returns 响应数据
+     */
+    async put(endpoint, data, needsAuth = true) {
+        return this.request(endpoint, 'PUT', data, needsAuth);
+    }
+    /**
+     * PATCH请求
+     * @param endpoint 请求端点
+     * @param data 请求数据
+     * @param needsAuth 是否需要认证
+     * @returns 响应数据
+     */
+    async patch(endpoint, data, needsAuth = true) {
+        return this.request(endpoint, 'PATCH', data, needsAuth);
+    }
+    /**
+     * DELETE请求
+     * @param endpoint 请求端点
+     * @param data 请求数据
+     * @param needsAuth 是否需要认证
+     * @returns 响应数据
+     */
+    async delete(endpoint, data, needsAuth = true) {
+        return this.request(endpoint, 'DELETE', data, needsAuth);
+    }
+}

package/dist/services/blockFactory.js

@@ -0,0 +1,184 @@
+import { Logger } from '../utils/logger.js';
+/**
+ * 块类型枚举
+ */
+export var BlockType;
+(function (BlockType) {
+    BlockType["TEXT"] = "text";
+    BlockType["CODE"] = "code";
+    BlockType["HEADING"] = "heading";
+    BlockType["LIST"] = "list";
+})(BlockType || (BlockType = {}));
+/**
+ * 对齐方式枚举
+ */
+export var AlignType;
+(function (AlignType) {
+    AlignType[AlignType["LEFT"] = 1] = "LEFT";
+    AlignType[AlignType["CENTER"] = 2] = "CENTER";
+    AlignType[AlignType["RIGHT"] = 3] = "RIGHT";
+})(AlignType || (AlignType = {}));
+/**
+ * 块工厂类
+ * 提供统一接口创建不同类型的块内容
+ */
+export class BlockFactory {
+    constructor() { }
+    /**
+     * 获取块工厂实例
+     * @returns 块工厂实例
+     */
+    static getInstance() {
+        if (!BlockFactory.instance) {
+            BlockFactory.instance = new BlockFactory();
+        }
+        return BlockFactory.instance;
+    }
+    /**
+     * 创建块内容
+     * @param type 块类型
+     * @param options 块选项
+     * @returns 块内容对象
+     */
+    createBlock(type, options) {
+        switch (type) {
+            case BlockType.TEXT:
+                return this.createTextBlock(options);
+            case BlockType.CODE:
+                return this.createCodeBlock(options);
+            case BlockType.HEADING:
+                return this.createHeadingBlock(options);
+            case BlockType.LIST:
+                return this.createListBlock(options);
+            default:
+                Logger.error(`不支持的块类型: ${type}`);
+                throw new Error(`不支持的块类型: ${type}`);
+        }
+    }
+    /**
+     * 创建文本块内容
+     * @param options 文本块选项
+     * @returns 文本块内容对象
+     */
+    createTextBlock(options) {
+        const { textContents, align = AlignType.LEFT } = options;
+        return {
+            block_type: 2, // 2表示文本块
+            text: {
+                elements: textContents.map(content => ({
+                    text_run: {
+                        content: content.text,
+                        text_element_style: content.style || {}
+                    }
+                })),
+                style: {
+                    align: align, // 1 居左，2 居中，3 居右
+                }
+            }
+        };
+    }
+    /**
+     * 创建代码块内容
+     * @param options 代码块选项
+     * @returns 代码块内容对象
+     */
+    createCodeBlock(options) {
+        const { code, language = 0, wrap = false } = options;
+        return {
+            block_type: 14, // 14表示代码块
+            code: {
+                elements: [
+                    {
+                        text_run: {
+                            content: code,
+                            text_element_style: {
+                                bold: false,
+                                inline_code: false,
+                                italic: false,
+                                strikethrough: false,
+                                underline: false
+                            }
+                        }
+                    }
+                ],
+                style: {
+                    language: language,
+                    wrap: wrap
+                }
+            }
+        };
+    }
+    /**
+     * 创建标题块内容
+     * @param options 标题块选项
+     * @returns 标题块内容对象
+     */
+    createHeadingBlock(options) {
+        const { text, level = 1, align = AlignType.LEFT } = options;
+        // 确保标题级别在有效范围内（1-9）
+        const safeLevel = Math.max(1, Math.min(9, level));
+        // 根据标题级别设置block_type和对应的属性名
+        // 飞书API中，一级标题的block_type为3，二级标题为4，以此类推
+        const blockType = 2 + safeLevel; // 一级标题为3，二级标题为4，以此类推
+        const headingKey = `heading${safeLevel}`; // heading1, heading2, ...
+        // 构建块内容
+        const blockContent = {
+            block_type: blockType
+        };
+        // 设置对应级别的标题属性
+        blockContent[headingKey] = {
+            elements: [
+                {
+                    text_run: {
+                        content: text,
+                        text_element_style: {}
+                    }
+                }
+            ],
+            style: {
+                align: align,
+                folded: false
+            }
+        };
+        return blockContent;
+    }
+    /**
+     * 创建列表块内容（有序或无序）
+     * @param options 列表块选项
+     * @returns 列表块内容对象
+     */
+    createListBlock(options) {
+        const { text, isOrdered = false, align = AlignType.LEFT } = options;
+        // 有序列表是 block_type: 13，无序列表是 block_type: 12
+        const blockType = isOrdered ? 13 : 12;
+        const propertyKey = isOrdered ? "ordered" : "bullet";
+        // 构建块内容
+        const blockContent = {
+            block_type: blockType
+        };
+        // 设置列表属性
+        blockContent[propertyKey] = {
+            elements: [
+                {
+                    text_run: {
+                        content: text,
+                        text_element_style: {}
+                    }
+                }
+            ],
+            style: {
+                align: align,
+                folded: false
+            }
+        };
+        return blockContent;
+    }
+    /**
+     * 创建批量块内容
+     * @param blocks 块配置数组
+     * @returns 块内容数组
+     */
+    createBatchBlocks(blocks) {
+        return blocks.map(block => this.createBlock(block.type, block.options));
+    }
+}

package/dist/services/feishu.js

@@ -41,36 +41,6 @@ export class FeishuService {
         this.appId = appId;
         this.appSecret = appSecret;
     }
-    // 包装和重新抛出错误的辅助方法
-    wrapAndThrowError(message, originalError) {
-        Logger.error(`${message}:`, originalError);
-        // 如果原始错误已经是FeishuError格式，直接重新抛出
-        if (originalError && typeof originalError === 'object' && 'status' in originalError && 'err' in originalError) {
-            throw originalError;
-        }
-        // 如果是AxiosError，抽取有用信息
-        if (originalError instanceof AxiosError && originalError.response) {
-            throw {
-                status: originalError.response.status,
-                err: `${message}: ${originalError.response.data?.msg || originalError.message || 'Unknown error'}`,
-                apiError: originalError.response.data
-            };
-        }
-        // 其他类型的错误，包装为一致的格式
-        if (originalError instanceof Error) {
-            throw {
-                status: 500,
-                err: `${message}: ${originalError.message}`,
-                apiError: originalError
-            };
-        }
-        // 未知错误类型
-        throw {
-            status: 500,
-            err: message,
-            apiError: originalError
-        };
-    }
     isTokenExpired() {
         if (!this.accessToken || !this.tokenExpireTime)
             return true;
@@ -92,7 +62,7 @@ export class FeishuService {
             Logger.log(`请求方法: POST`);
             Logger.log(`请求数据: ${JSON.stringify(requestData, null, 2)}`);
             const response = await axios.post(url, requestData);
-            Logger.log(`响应状态码: ${response?.status}`);
+            Logger.log(`响应状态码: ${response.status}`);
             Logger.log(`响应头: ${JSON.stringify(response.headers, null, 2)}`);
             Logger.log(`响应数据: ${JSON.stringify(response.data, null, 2)}`);
             if (response.data.code !== 0) {
@@ -100,7 +70,6 @@ export class FeishuService {
                 throw {
                     status: response.status,
                     err: response.data.msg || "Unknown error",
-                    apiError: response.data
                 };
             }
             this.accessToken = response.data.tenant_access_token;
@@ -117,7 +86,6 @@ export class FeishuService {
                 throw {
                     status: error.response.status,
                     err: error.response.data?.msg || "Unknown error",
-                    apiError: error.response.data
                 };
             }
             Logger.error('获取访问令牌时发生未知错误:', error);
@@ -160,7 +128,6 @@ export class FeishuService {
                 throw {
                     status: error.response.status,
                     err: error.response.data?.msg || "Unknown error",
-                    apiError: error.response.data
                 };
             }
             Logger.error('发送请求时发生未知错误:', error);
@@ -190,7 +157,16 @@ export class FeishuService {
             return docInfo;
         }
         catch (error) {
-            this.wrapAndThrowError('创建文档失败', error);
+            Logger.error(`创建文档失败:`, error);
+            if (error instanceof AxiosError) {
+                Logger.error(`请求URL: ${error.config?.url}`);
+                Logger.error(`请求方法: ${error.config?.method?.toUpperCase()}`);
+                Logger.error(`状态码: ${error.response?.status}`);
+                if (error.response?.data) {
+                    Logger.error(`错误详情: ${JSON.stringify(error.response.data, null, 2)}`);
+                }
+            }
+            throw error;
         }
     }
     // 获取文档信息
@@ -407,9 +383,6 @@ export class FeishuService {
     createHeadingBlockContent(text, level = 1, align = 1) {
         // 确保标题级别在有效范围内（1-9）
         const safeLevel = Math.max(1, Math.min(9, level));
-        // 确保align值在合法范围内（1-3）
-        // 1表示居左，2表示居中，3表示居右
-        const safeAlign = (align === 1 || align === 2 || align === 3) ? align : 1;
         // 根据标题级别设置block_type和对应的属性名
         // 飞书API中，一级标题的block_type为3，二级标题为4，以此类推
         const blockType = 2 + safeLevel; // 一级标题为3，二级标题为4，以此类推
@@ -429,7 +402,7 @@ export class FeishuService {
                 }
             ],
             style: {
-                align: safeAlign,
+                align: align,
                 folded: false
             }
         };
@@ -469,10 +442,7 @@ export class FeishuService {
             if (!docId) {
                 throw new Error(`无效的文档ID: ${documentId}`);
             }
-            // 确保align值在合法范围内（1-3）
-            // 1表示居左，2表示居中，3表示居右
-            const safeAlign = (align === 1 || align === 2 || align === 3) ? align : 1;
-            Logger.log(`开始创建标题块，文档ID: ${docId}，父块ID: ${parentBlockId}，标题级别: ${level}，对齐方式: ${safeAlign}，插入位置: ${index}`);
+            Logger.log(`开始创建标题块，文档ID: ${docId}，父块ID: ${parentBlockId}，标题级别: ${level}，插入位置: ${index}`);
             // 确保标题级别在有效范围内（1-9）
             const safeLevel = Math.max(1, Math.min(9, level));
             // 根据标题级别设置block_type和对应的属性名
@@ -494,7 +464,7 @@ export class FeishuService {
                     }
                 ],
                 style: {
-                    align: safeAlign,
+                    align: align,
                     folded: false
                 }
             };
@@ -502,110 +472,8 @@ export class FeishuService {
             return await this.createDocumentBlock(documentId, parentBlockId, blockContent, index);
         }
         catch (error) {
-            this.wrapAndThrowError(`创建标题块失败`, error);
-        }
-    }
-    // 获取块内容
-    async getBlockContent(documentId, blockId) {
-        try {
-            const docId = this.extractDocIdFromUrl(documentId);
-            if (!docId) {
-                throw new Error(`无效的文档ID: ${documentId}`);
-            }
-            Logger.log(`开始获取块内容，文档ID: ${docId}，块ID: ${blockId}`);
-            const endpoint = `/docx/v1/documents/${docId}/blocks/${blockId}?document_revision_id=-1`;
-            Logger.log(`准备请求API端点: ${endpoint}`);
-            const response = await this.request(endpoint);
-            if (response.code !== 0) {
-                throw new Error(`获取块内容失败: ${response.msg}`);
-            }
-            const blockContent = response.data?.block;
-            Logger.log(`块内容获取成功: ${JSON.stringify(blockContent, null, 2)}`);
-            return blockContent;
-        }
-        catch (error) {
-            this.wrapAndThrowError(`获取块内容失败`, error);
-        }
-    }
-    // 更新块文本内容
-    async updateBlockTextContent(documentId, blockId, textElements) {
-        try {
-            const docId = this.extractDocIdFromUrl(documentId);
-            if (!docId) {
-                throw new Error(`无效的文档ID: ${documentId}`);
-            }
-            Logger.log(`开始更新块文本内容，文档ID: ${docId}，块ID: ${blockId}`);
-            const endpoint = `/docx/v1/documents/${docId}/blocks/${blockId}?document_revision_id=-1`;
-            Logger.log(`准备请求API端点: ${endpoint}`);
-            const elements = textElements.map(item => ({
-                text_run: {
-                    content: item.text,
-                    text_element_style: item.style || {}
-                }
-            }));
-            const data = {
-                update_text_elements: {
-                    elements: elements
-                }
-            };
-            Logger.log(`请求数据: ${JSON.stringify(data, null, 2)}`);
-            const response = await this.request(endpoint, 'PATCH', data);
-            if (response.code !== 0) {
-                throw new Error(`更新块文本内容失败: ${response.msg}`);
-            }
-            Logger.log(`块文本内容更新成功: ${JSON.stringify(response.data, null, 2)}`);
-            return response.data;
-        }
-        catch (error) {
-            this.wrapAndThrowError(`更新块文本内容失败`, error);
-        }
-    }
-    // 创建列表块内容（有序或无序）
-    createListBlockContent(text, isOrdered = false, align = 1) {
-        // 确保 align 值在合法范围内（1-3）
-        const safeAlign = (align === 1 || align === 2 || align === 3) ? align : 1;
-        // 有序列表是 block_type: 13，无序列表是 block_type: 12
-        const blockType = isOrdered ? 13 : 12;
-        const propertyKey = isOrdered ? "ordered" : "bullet";
-        // 构建块内容
-        const blockContent = {
-            block_type: blockType
-        };
-        // 设置列表属性
-        blockContent[propertyKey] = {
-            elements: [
-                {
-                    text_run: {
-                        content: text,
-                        text_element_style: {}
-                    }
-                }
-            ],
-            style: {
-                align: safeAlign,
-                folded: false
-            }
-        };
-        return blockContent;
-    }
-    // 创建列表块（有序或无序）
-    async createListBlock(documentId, parentBlockId, text, isOrdered = false, index = 0, align = 1) {
-        try {
-            const docId = this.extractDocIdFromUrl(documentId);
-            if (!docId) {
-                throw new Error(`无效的文档ID: ${documentId}`);
-            }
-            // 确保align值在合法范围内（1-3）
-            const safeAlign = (align === 1 || align === 2 || align === 3) ? align : 1;
-            const listType = isOrdered ? "有序" : "无序";
-            Logger.log(`开始创建${listType}列表块，文档ID: ${docId}，父块ID: ${parentBlockId}，对齐方式: ${safeAlign}，插入位置: ${index}`);
-            // 创建列表块内容
-            const blockContent = this.createListBlockContent(text, isOrdered, safeAlign);
-            Logger.log(`列表块内容: ${JSON.stringify(blockContent, null, 2)}`);
-            return await this.createDocumentBlock(documentId, parentBlockId, blockContent, index);
-        }
-        catch (error) {
-            this.wrapAndThrowError(`创建${isOrdered ? "有序" : "无序"}列表块失败`, error);
+            Logger.error(`创建标题块失败:`, error);
+            throw error;
         }
     }
     extractDocIdFromUrl(url) {