feishu-mcp 0.0.12 → 0.0.14

package/dist/services/baseService.js

@@ -1,4 +1,5 @@
 import axios, { AxiosError } from 'axios';
+import FormData from 'form-data';
 import { Logger } from '../utils/logger.js';
 import { formatErrorMessage } from '../utils/error.js';
 /**
@@ -74,17 +75,25 @@ export class BaseApiService {
      * @param data 请求数据
      * @param needsAuth 是否需要认证
      * @param additionalHeaders 附加请求头
+     * @param responseType 响应类型
      * @returns 响应数据
      */
-    async request(endpoint, method = 'GET', data, needsAuth = true, additionalHeaders) {
+    async request(endpoint, method = 'GET', data, needsAuth = true, additionalHeaders, responseType) {
         try {
             // 构建请求URL
             const url = `${this.getBaseUrl()}${endpoint}`;
             // 准备请求头
             const headers = {
-                'Content-Type': 'application/json',
                 ...additionalHeaders
             };
+            // 如果数据是FormData，合并FormData的headers
+            // 否则设置为application/json
+            if (data instanceof FormData) {
+                Object.assign(headers, data.getHeaders());
+            }
+            else {
+                headers['Content-Type'] = 'application/json';
+            }
             // 添加认证令牌
             if (needsAuth) {
                 const accessToken = await this.getAccessToken();
@@ -103,7 +112,8 @@ export class BaseApiService {
                 url,
                 headers,
                 data: method !== 'GET' ? data : undefined,
-                params: method === 'GET' ? data : undefined
+                params: method === 'GET' ? data : undefined,
+                responseType: responseType || 'json'
             };
             // 发送请求
             const response = await axios(config);
@@ -112,7 +122,11 @@ export class BaseApiService {
             Logger.debug(`响应状态码: ${response.status}`);
             Logger.debug(`响应头:`, response.headers);
             Logger.debug(`响应数据:`, response.data);
-            // 检查API错误
+            // 对于非JSON响应，直接返回数据
+            if (responseType && responseType !== 'json') {
+                return response.data;
+            }
+            // 检查API错误（仅对JSON响应）
             if (response.data && typeof response.data.code === 'number' && response.data.code !== 0) {
                 Logger.error(`API返回错误码: ${response.data.code}, 错误消息: ${response.data.msg}`);
                 throw {

package/dist/services/blockFactory.js

@@ -8,6 +8,7 @@ export var BlockType;
     BlockType["CODE"] = "code";
     BlockType["HEADING"] = "heading";
     BlockType["LIST"] = "list";
+    BlockType["IMAGE"] = "image";
 })(BlockType || (BlockType = {}));
 /**
  * 对齐方式枚举
@@ -72,6 +73,8 @@ export class BlockFactory {
                 return this.createHeadingBlock(options);
             case BlockType.LIST:
                 return this.createListBlock(options);
+            case BlockType.IMAGE:
+                return this.createImageBlock(options);
             default:
                 Logger.error(`不支持的块类型: ${type}`);
                 throw new Error(`不支持的块类型: ${type}`);
@@ -87,14 +90,29 @@ export class BlockFactory {
         return {
             block_type: 2, // 2表示文本块
             text: {
-                elements: textContents.map(content => ({
-                    text_run: {
-                        content: content.text,
-                        text_element_style: BlockFactory.applyDefaultTextStyle(content.style)
+                elements: textContents.map(content => {
+                    // 检查是否是公式元素
+                    if ('equation' in content) {
+                        return {
+                            equation: {
+                                content: content.equation,
+                                text_element_style: BlockFactory.applyDefaultTextStyle(content.style)
+                            }
+                        };
+                    }
+                    else {
+                        // 普通文本元素
+                        return {
+                            text_run: {
+                                content: content.text,
+                                text_element_style: BlockFactory.applyDefaultTextStyle(content.style)
+                            }
+                        };
                     }
-                })),
+                }),
                 style: {
                     align: align, // 1 居左，2 居中，3 居右
+                    folded: false
                 }
             }
         };
@@ -192,11 +210,19 @@ export class BlockFactory {
         return blockContent;
     }
     /**
-     * 创建批量块内容
-     * @param blocks 块配置数组
-     * @returns 块内容数组
+     * 创建图片块内容（空图片块，需要后续设置图片资源）
+     * @param options 图片块选项
+     * @returns 图片块内容对象
      */
-    createBatchBlocks(blocks) {
-        return blocks.map(block => this.createBlock(block.type, block.options));
+    createImageBlock(options = {}) {
+        const { width = 100, height = 100 } = options;
+        return {
+            block_type: 27, // 27表示图片块
+            image: {
+                width: width,
+                height: height,
+                token: "" // 空token，需要后续通过API设置
+            }
+        };
     }
 }

package/dist/services/feishuApiService.js

@@ -5,6 +5,9 @@ import { CacheManager } from '../utils/cache.js';
 import { ParamUtils } from '../utils/paramUtils.js';
 import { BlockFactory, BlockType } from './blockFactory.js';
 import axios from 'axios';
+import FormData from 'form-data';
+import fs from 'fs';
+import path from 'path';
 /**
  * 飞书API服务类
  * 提供飞书API的所有基础操作，包括认证、请求和缓存管理
@@ -218,7 +221,7 @@ export class FeishuApiService extends BaseApiService {
      * 更新块文本内容
      * @param documentId 文档ID或URL
      * @param blockId 块ID
-     * @param textElements 文本元素数组
+     * @param textElements 文本元素数组，支持普通文本和公式元素
      * @returns 更新结果
      */
     async updateBlockTextContent(documentId, blockId, textElements) {
@@ -226,12 +229,24 @@ export class FeishuApiService extends BaseApiService {
             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 => ({
-                text_run: {
-                    content: item.text,
-                    text_element_style: BlockFactory.applyDefaultTextStyle(item.style)
+            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
@@ -302,17 +317,27 @@ export class FeishuApiService extends BaseApiService {
      * 创建文本块
      * @param documentId 文档ID或URL
      * @param parentBlockId 父块ID
-     * @param textContents 文本内容数组
+     * @param textContents 文本内容数组，支持普通文本和公式元素
      * @param align 对齐方式，1为左对齐，2为居中，3为右对齐
      * @param index 插入位置索引
      * @returns 创建结果
      */
     async createTextBlock(documentId, parentBlockId, textContents, align = 1, index = 0) {
-        // 处理文本内容样式
-        const processedTextContents = textContents.map(item => ({
-            text: item.text,
-            style: BlockFactory.applyDefaultTextStyle(item.style)
-        }));
+        // 处理文本内容样式，支持普通文本和公式元素
+        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
@@ -373,18 +398,6 @@ export class FeishuApiService extends BaseApiService {
         });
         return this.createDocumentBlock(documentId, parentBlockId, blockContent, index);
     }
-    /**
-     * 创建混合块
-     * @param documentId 文档ID或URL
-     * @param parentBlockId 父块ID
-     * @param blocks 块配置数组
-     * @param index 插入位置索引
-     * @returns 创建结果
-     */
-    async createMixedBlocks(documentId, parentBlockId, blocks, index = 0) {
-        const blockContents = blocks.map(block => this.blockFactory.createBlock(block.type, block.options));
-        return this.createDocumentBlocks(documentId, parentBlockId, blockContents, index);
-    }
     /**
      * 删除文档中的块，支持批量删除
      * @param documentId 文档ID或URL
@@ -501,7 +514,7 @@ export class FeishuApiService extends BaseApiService {
             // 使用枚举类型来避免字符串错误
             const blockTypeEnum = blockType;
             // 构建块配置
-            let blockConfig = {
+            const blockConfig = {
                 type: blockTypeEnum,
                 options: {}
             };
@@ -510,12 +523,22 @@ export class FeishuApiService extends BaseApiService {
                 case BlockType.TEXT:
                     if ('text' in options && options.text) {
                         const textOptions = options.text;
-                        // 处理文本样式，应用默认样式
+                        // 处理文本样式，应用默认样式，支持普通文本和公式元素
                         const textStyles = textOptions.textStyles || [];
-                        const processedTextStyles = textStyles.map((item) => ({
-                            text: item.text,
-                            style: BlockFactory.applyDefaultTextStyle(item.style)
-                        }));
+                        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
@@ -554,17 +577,43 @@ export class FeishuApiService extends BaseApiService {
                         };
                     }
                     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;
                 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) => ({
-                            text: item.text,
-                            style: BlockFactory.applyDefaultTextStyle(item.style)
-                        }));
+                        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
@@ -599,6 +648,14 @@ export class FeishuApiService extends BaseApiService {
                                 ? 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
+                        };
+                    }
                     break;
             }
             // 记录调试信息
@@ -628,24 +685,9 @@ export class FeishuApiService extends BaseApiService {
             if (extra) {
                 params.extra = extra;
             }
-            // 这里需要特殊处理，因为返回的是二进制数据，不是JSON
-            const token = await this.getAccessToken();
-            const url = `${this.getBaseUrl()}${endpoint}`;
-            const headers = {
-                'Authorization': `Bearer ${token}`
-            };
-            Logger.debug(`请求图片资源URL: ${url}`);
-            // 使用axios直接获取二进制响应
-            const response = await axios.get(url, {
-                params,
-                headers,
-                responseType: 'arraybuffer'
-            });
-            // 检查响应状态
-            if (response.status !== 200) {
-                throw new Error(`获取图片资源失败，状态码: ${response.status}`);
-            }
-            const imageBuffer = Buffer.from(response.data);
+            // 使用通用的request方法获取二进制响应
+            const response = await this.request(endpoint, 'GET', params, true, {}, 'arraybuffer');
+            const imageBuffer = Buffer.from(response);
             Logger.info(`图片资源获取成功，大小: ${imageBuffer.length} 字节`);
             return imageBuffer;
         }
@@ -760,4 +802,236 @@ export class FeishuApiService extends BaseApiService {
             this.handleApiError(error, '搜索文档失败');
         }
     }
+    /**
+     * 上传图片素材到飞书
+     * @param imageBase64 图片的Base64编码
+     * @param fileName 图片文件名，如果不提供则自动生成
+     * @param parentBlockId 图片块ID
+     * @returns 上传结果，包含file_token
+     */
+    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, '上传图片素材失败');
+        }
+    }
+    /**
+     * 设置图片块的素材内容
+     * @param documentId 文档ID
+     * @param imageBlockId 图片块ID
+     * @param fileToken 图片素材的file_token
+     * @returns 设置结果
+     */
+    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, '设置图片块内容失败');
+        }
+    }
+    /**
+     * 创建完整的图片块（包括创建空块、上传图片、设置内容的完整流程）
+     * @param documentId 文档ID
+     * @param parentBlockId 父块ID
+     * @param imagePathOrUrl 图片路径或URL
+     * @param options 图片选项
+     * @returns 创建结果
+     */
+    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, '创建图片块失败');
+        }
+    }
+    /**
+     * 根据文件名获取MIME类型
+     * @param fileName 文件名
+     * @returns MIME类型
+     */
+    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
+        }
+    }
+    /**
+     * 获取画板内容
+     * @param whiteboardId 画板ID或URL
+     * @returns 画板节点数据
+     */
+    async getWhiteboardContent(whiteboardId) {
+        try {
+            // 从URL中提取画板ID
+            let normalizedWhiteboardId = whiteboardId;
+            if (whiteboardId.includes('feishu.cn/board/')) {
+                // 从URL中提取画板ID
+                const matches = whiteboardId.match(/board\/([^\/\?]+)/);
+                if (matches) {
+                    normalizedWhiteboardId = matches[1];
+                }
+            }
+            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, '获取画板内容失败');
+        }
+    }
+    /**
+     * 从路径或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)}`);
+        }
+    }
 }