feishu-mcp 0.0.3 → 0.0.5

package/dist/services/feishu.js

@@ -41,6 +41,36 @@ 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;
@@ -62,7 +92,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) {
@@ -70,6 +100,7 @@ export class FeishuService {
                 throw {
                     status: response.status,
                     err: response.data.msg || "Unknown error",
+                    apiError: response.data
                 };
             }
             this.accessToken = response.data.tenant_access_token;
@@ -86,6 +117,7 @@ export class FeishuService {
                 throw {
                     status: error.response.status,
                     err: error.response.data?.msg || "Unknown error",
+                    apiError: error.response.data
                 };
             }
             Logger.error('获取访问令牌时发生未知错误:', error);
@@ -128,6 +160,7 @@ export class FeishuService {
                 throw {
                     status: error.response.status,
                     err: error.response.data?.msg || "Unknown error",
+                    apiError: error.response.data
                 };
             }
             Logger.error('发送请求时发生未知错误:', error);
@@ -157,16 +190,7 @@ export class FeishuService {
             return docInfo;
         }
         catch (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;
+            this.wrapAndThrowError('创建文档失败', error);
         }
     }
     // 获取文档信息
@@ -336,14 +360,119 @@ export class FeishuService {
             throw error;
         }
     }
+    // 创建文本块内容
+    createTextBlockContent(textContents, align = 1) {
+        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 居右
+                }
+            }
+        };
+    }
+    // 创建代码块内容
+    createCodeBlockContent(code, language = 0, wrap = false) {
+        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
+                }
+            }
+        };
+    }
+    // 创建标题块内容
+    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，以此类推
+        const headingKey = `heading${safeLevel}`; // heading1, heading2, ...
+        // 构建块内容
+        const blockContent = {
+            block_type: blockType
+        };
+        // 设置对应级别的标题属性
+        blockContent[headingKey] = {
+            elements: [
+                {
+                    text_run: {
+                        content: text,
+                        text_element_style: {}
+                    }
+                }
+            ],
+            style: {
+                align: safeAlign,
+                folded: false
+            }
+        };
+        return blockContent;
+    }
+    // 批量创建文档块
+    async createDocumentBlocks(documentId, parentBlockId, blockContents, index = 0) {
+        try {
+            const docId = this.extractDocIdFromUrl(documentId);
+            if (!docId) {
+                throw new Error(`无效的文档ID: ${documentId}`);
+            }
+            Logger.log(`开始批量创建文档块，文档ID: ${docId}，父块ID: ${parentBlockId}，块数量: ${blockContents.length}，插入位置: ${index}`);
+            const endpoint = `/docx/v1/documents/${docId}/blocks/${parentBlockId}/children?document_revision_id=-1`;
+            Logger.log(`准备请求API端点: ${endpoint}`);
+            const data = {
+                children: blockContents,
+                index: index
+            };
+            Logger.log(`请求数据: ${JSON.stringify(data, null, 2)}`);
+            const response = await this.request(endpoint, 'POST', data);
+            if (response.code !== 0) {
+                throw new Error(`批量创建文档块失败: ${response.msg}`);
+            }
+            Logger.log(`批量文档块创建成功: ${JSON.stringify(response.data, null, 2)}`);
+            return response.data;
+        }
+        catch (error) {
+            Logger.error(`批量创建文档块失败:`, error);
+            throw error;
+        }
+    }
     // 创建标题块
-    async createHeadingBlock(documentId, parentBlockId, text, level = 1, index = 0) {
+    async createHeadingBlock(documentId, parentBlockId, text, level = 1, index = 0, align = 1) {
         try {
             const docId = this.extractDocIdFromUrl(documentId);
             if (!docId) {
                 throw new Error(`无效的文档ID: ${documentId}`);
             }
-            Logger.log(`开始创建标题块，文档ID: ${docId}，父块ID: ${parentBlockId}，标题级别: ${level}，插入位置: ${index}`);
+            // 确保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}`);
             // 确保标题级别在有效范围内（1-9）
             const safeLevel = Math.max(1, Math.min(9, level));
             // 根据标题级别设置block_type和对应的属性名
@@ -365,7 +494,7 @@ export class FeishuService {
                     }
                 ],
                 style: {
-                    align: 1,
+                    align: safeAlign,
                     folded: false
                 }
             };
@@ -373,8 +502,110 @@ export class FeishuService {
             return await this.createDocumentBlock(documentId, parentBlockId, blockContent, index);
         }
         catch (error) {
-            Logger.error(`创建标题块失败:`, error);
-            throw 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);
         }
     }
     extractDocIdFromUrl(url) {

package/dist/services/feishuBlocks.js

@@ -0,0 +1,135 @@
+/**
+ * 构建批量创建块的请求数据
+ * @param blocks 块内容数组
+ * @param index 插入位置索引
+ * @returns 请求数据对象
+ */
+export function buildCreateBlocksRequest(blocks, index = 0) {
+    return {
+        children: blocks,
+        index
+    };
+}
+/**
+ * 创建文本块内容
+ * @param text 文本内容
+ * @param style 文本样式
+ * @param align 对齐方式：1左对齐，2居中，3右对齐
+ * @returns 文本块内容对象
+ */
+export function createTextBlockContent(textContents, align = 1) {
+    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 code 代码内容
+ * @param language 语言类型代码
+ * @param wrap 是否自动换行
+ * @returns 代码块内容对象
+ */
+export function createCodeBlockContent(code, language = 0, wrap = false) {
+    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 text 标题文本
+ * @param level 标题级别（1-9）
+ * @param align 对齐方式：1左对齐，2居中，3右对齐
+ * @returns 标题块内容对象
+ */
+export function createHeadingBlockContent(text, level = 1, align = 1) {
+    // 确保标题级别在有效范围内（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;
+}
+/**
+ * 处理Markdown语法转换
+ * @param textContents 文本内容数组
+ * @returns 处理后的文本内容数组
+ */
+export function processMarkdownSyntax(textContents) {
+    return textContents.map(content => {
+        let { text, style = {} } = content;
+        // 创建一个新的style对象，避免修改原始对象
+        const newStyle = { ...style };
+        // 处理粗体 **text**
+        if (text.match(/\*\*([^*]+)\*\*/g)) {
+            text = text.replace(/\*\*([^*]+)\*\*/g, "$1");
+            newStyle.bold = true;
+        }
+        // 处理斜体 *text*
+        if (text.match(/(?<!\*)\*([^*]+)\*(?!\*)/g)) {
+            text = text.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, "$1");
+            newStyle.italic = true;
+        }
+        // 处理删除线 ~~text~~
+        if (text.match(/~~([^~]+)~~/g)) {
+            text = text.replace(/~~([^~]+)~~/g, "$1");
+            newStyle.strikethrough = true;
+        }
+        // 处理行内代码 `code`
+        if (text.match(/`([^`]+)`/g)) {
+            text = text.replace(/`([^`]+)`/g, "$1");
+            newStyle.inline_code = true;
+        }
+        return { text, style: newStyle };
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "feishu-mcp",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Model Context Protocol server for Feishu integration",
   "type": "module",
   "main": "dist/index.js",