feishu-mcp 0.0.11 → 0.0.13

package/dist/mcp/tools/feishuTools.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { formatErrorMessage } from '../../utils/error.js';
 import { Logger } from '../../utils/logger.js';
-import { DocumentIdSchema, BlockIdSchema, } from '../../types/feishuSchema.js';
+import { DocumentIdSchema, BlockIdSchema, SearchKeySchema, } from '../../types/feishuSchema.js';
 /**
  * 注册飞书相关的MCP工具
  * @param server MCP服务器实例
@@ -134,4 +134,33 @@ export function registerFeishuTools(server, feishuService) {
             };
         }
     });
+    // 添加搜索文档工具
+    server.tool('search_feishu_documents', 'Searches for documents in Feishu. Supports keyword-based search and returns document information including title, type, and owner. Use this tool to find specific content or related documents in your document library.', {
+        searchKey: SearchKeySchema,
+    }, async ({ searchKey }) => {
+        try {
+            if (!feishuService) {
+                return {
+                    content: [{ type: 'text', text: 'Feishu service is not initialized. Please check the configuration.' }],
+                };
+            }
+            Logger.info(`开始搜索飞书文档，关键字: ${searchKey},`);
+            const searchResult = await feishuService.searchDocuments(searchKey);
+            Logger.info(`文档搜索完成，找到 ${searchResult.size} 个结果`);
+            return {
+                content: [
+                    { type: 'text', text: JSON.stringify(searchResult, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            Logger.error(`搜索飞书文档失败:`, error);
+            const errorMessage = formatErrorMessage(error);
+            return {
+                content: [
+                    { type: 'text', text: `搜索飞书文档失败: ${errorMessage}` },
+                ],
+            };
+        }
+    });
 }

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}`);
@@ -192,11 +195,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的所有基础操作，包括认证、请求和缓存管理
@@ -373,18 +376,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 +492,7 @@ export class FeishuApiService extends BaseApiService {
             // 使用枚举类型来避免字符串错误
             const blockTypeEnum = blockType;
             // 构建块配置
-            let blockConfig = {
+            const blockConfig = {
                 type: blockTypeEnum,
                 options: {}
             };
@@ -554,6 +545,22 @@ 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) {
@@ -599,6 +606,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 +643,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;
         }
@@ -714,4 +714,256 @@ export class FeishuApiService extends BaseApiService {
             this.handleApiError(error, '创建文件夹失败');
         }
     }
+    /**
+     * 搜索飞书文档
+     * @param searchKey 搜索关键字
+     * @param count 每页数量，默认50
+     * @returns 搜索结果，包含所有页的数据
+     */
+    async searchDocuments(searchKey, count = 50) {
+        try {
+            Logger.info(`开始搜索文档，关键字: ${searchKey}`);
+            const endpoint = `//suite/docs-api/search/object`;
+            let offset = 0;
+            let allResults = [];
+            let hasMore = true;
+            // 循环获取所有页的数据
+            while (hasMore && offset + count < 200) {
+                const payload = {
+                    search_key: searchKey,
+                    docs_types: ["doc"],
+                    count: count,
+                    offset: offset
+                };
+                Logger.debug(`请求搜索，offset: ${offset}, count: ${count}`);
+                const response = await this.post(endpoint, payload);
+                Logger.debug('搜索响应:', JSON.stringify(response, null, 2));
+                if (response && response.docs_entities) {
+                    const newDocs = response.docs_entities;
+                    allResults = [...allResults, ...newDocs];
+                    hasMore = response.has_more || false;
+                    offset += count;
+                    Logger.debug(`当前页获取到 ${newDocs.length} 条数据，累计 ${allResults.length} 条，总计 ${response.total} 条，hasMore: ${hasMore}`);
+                }
+                else {
+                    hasMore = false;
+                    Logger.warn('搜索响应格式异常:', JSON.stringify(response, null, 2));
+                }
+            }
+            const resultCount = allResults.length;
+            Logger.info(`文档搜索完成，找到 ${resultCount} 个结果`);
+            return {
+                data: allResults
+            };
+        }
+        catch (error) {
+            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
+        }
+    }
+    /**
+     * 从路径或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)}`);
+        }
+    }
 }

package/dist/types/feishuSchema.js

@@ -11,14 +11,26 @@ export const ParentBlockIdSchema = z.string().describe('Parent block ID (require
 // 块ID参数定义
 export const BlockIdSchema = z.string().describe('Block ID (required). The ID of the specific block to get content from. You can obtain block IDs using the get_feishu_document_blocks tool.');
 // 插入位置索引参数定义
-export const IndexSchema = z.number().describe('Insertion position index (required). Specifies where the block should be inserted. Use 0 to insert at the beginning. ' +
+export const IndexSchema = z.number().describe('Insertion position index (required). This index is relative to the children array of the specified parentBlockId block (not the whole document).\n' +
+    'If parentBlockId is the document root (i.e., the document ID), index refers to the position among the document content blocks (excluding the title block itself).\n' +
+    '0 means to insert as the first content block after the title.\n' +
+    'If children is empty or missing, use 0 to insert the first content block.\n' +
+    'For nested blocks, index is relative to the parent block\'s children.\n' +
+    'Note: The title block itself is not part of the children array and cannot be operated on with index.' +
+    'Specifies where the block should be inserted. Use 0 to insert at the beginning. ' +
     'Use get_feishu_document_blocks tool to understand document structure if unsure. ' +
     'For consecutive insertions, calculate next index as previous index + 1.');
 // 起始插入位置索引参数定义
-export const StartIndexSchema = z.number().describe('Starting insertion position index (required). Specifies where the first block should be inserted. Use 0 to insert at the beginning. ' +
+export const StartIndexSchema = z.number().describe('Starting insertion position index (required). This index is relative to the children array of the specified parentBlockId block.\n' +
+    'For the document root, this means the content blocks after the title. For other blocks, it means the sub-blocks under that block.\n' +
+    'The index does not include the title block itself.' +
+    'Specifies where the first block should be inserted or deleted. Use 0 to insert at the beginning. ' +
     'Use get_feishu_document_blocks tool to understand document structure if unsure.');
 // 结束位置索引参数定义
-export const EndIndexSchema = z.number().describe('Ending position index (required). Specifies the end of the range for deletion (exclusive). ' +
+export const EndIndexSchema = z.number().describe('Ending position index (required). This index is relative to the children array of the specified parentBlockId block.\n' +
+    'For the document root, this means the content blocks after the title. For other blocks, it means the sub-blocks under that block.\n' +
+    'The index does not include the title block itself.' +
+    'Specifies the end of the range for deletion (exclusive). ' +
     'For example, to delete blocks 2, 3, and 4, use startIndex=2, endIndex=5. ' +
     'To delete a single block at position 2, use startIndex=2, endIndex=3.');
 // 文本对齐方式参数定义
@@ -87,8 +99,14 @@ export const ListBlockSchema = z.object({
     align: AlignSchemaWithValidation,
 });
 // 块类型枚举 - 用于批量创建块工具
-export const BlockTypeEnum = z.string().describe("Block type (required). Supports: 'text', 'code', 'heading', 'list', as well as 'heading1' through 'heading9'. " +
-    "For headings, we recommend using 'heading' with level property, but 'heading1'-'heading9' are also supported.");
+export const BlockTypeEnum = z.string().describe("Block type (required). Supports: 'text', 'code', 'heading', 'list', 'image', as well as 'heading1' through 'heading9'. " +
+    "For headings, we recommend using 'heading' with level property, but 'heading1'-'heading9' are also supported. " +
+    "For images, use 'image' to create empty image blocks that can be filled later.");
+// 图片块内容定义 - 用于批量创建块工具
+export const ImageBlockSchema = z.object({
+    width: z.number().optional().describe('Image width in pixels (optional). If not provided, default width will be used.'),
+    height: z.number().optional().describe('Image height in pixels (optional). If not provided, default height will be used.'),
+});
 // 块配置定义 - 用于批量创建块工具
 export const BlockConfigSchema = z.object({
     blockType: BlockTypeEnum,
@@ -97,6 +115,7 @@ export const BlockConfigSchema = z.object({
         z.object({ code: CodeBlockSchema }).describe("Code block options. Used when blockType is 'code'."),
         z.object({ heading: HeadingBlockSchema }).describe("Heading block options. Used with both 'heading' and 'headingN' formats."),
         z.object({ list: ListBlockSchema }).describe("List block options. Used when blockType is 'list'."),
+        z.object({ image: ImageBlockSchema }).describe("Image block options. Used when blockType is 'image'. Creates empty image blocks."),
         z.record(z.any()).describe("Fallback for any other block options")
     ]).describe('Options for the specific block type. Provide the corresponding options object based on blockType.'),
 });
@@ -112,9 +131,17 @@ export const FolderTokenSchema = z.string().describe('Folder token (required). T
     'Format is an alphanumeric string like "FWK2fMleClICfodlHHWc4Mygnhb".');
 // 文件夹名称参数定义
 export const FolderNameSchema = z.string().describe('Folder name (required). The name for the new folder to be created.');
-// 排序方式参数定义
-export const OrderBySchema = z.string().optional().default('EditedTime').describe('Order by field (optional). Specifies how to sort the file list. Available values: ' +
-    '"EditedTime" (default), "CreatedTime", "Name". For user-friendly display, case insensitive.');
-// 排序方向参数定义
-export const DirectionSchema = z.string().optional().default('DESC').describe('Sort direction (optional). Specifies the sort order. Available values: ' +
-    '"DESC" (default) for descending order, "ASC" for ascending order. Case sensitive.');
+// 搜索关键字参数定义
+export const SearchKeySchema = z.string().describe('Search keyword (required). The keyword to search for in documents.');
+// 图片路径或URL参数定义
+export const ImagePathOrUrlSchema = z.string().describe('Image path or URL (required). Supports the following formats:\n' +
+    '1. Local file absolute path: e.g., "C:\\path\\to\\image.jpg"\n' +
+    '2. HTTP/HTTPS URL: e.g., "https://example.com/image.png"\n' +
+    'The tool will automatically detect the format and handle accordingly.');
+// 图片文件名参数定义
+export const ImageFileNameSchema = z.string().optional().describe('Image file name (optional). If not provided, a default name will be generated based on the source. ' +
+    'Should include the file extension, e.g., "image.png" or "photo.jpg".');
+// 图片宽度参数定义
+export const ImageWidthSchema = z.number().optional().describe('Image width in pixels (optional). If not provided, the original image width will be used.');
+// 图片高度参数定义
+export const ImageHeightSchema = z.number().optional().describe('Image height in pixels (optional). If not provided, the original image height will be used.');

package/dist/utils/logger.js

@@ -265,9 +265,9 @@ Object.defineProperty(Logger, "config", {
         showTimestamp: true,
         showLevel: true,
         timestampFormat: 'yyyy-MM-dd HH:mm:ss.SSS',
-        logToFile: true,
+        logToFile: false,
         logFilePath: 'log/log.txt',
-        maxObjectDepth: 4, // 限制对象序列化深度
+        maxObjectDepth: 2, // 限制对象序列化深度
         maxObjectStringLength: 5000000 // 限制序列化后字符串长度
     }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "feishu-mcp",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "Model Context Protocol server for Feishu integration",
   "type": "module",
   "main": "dist/index.js",
@@ -41,12 +41,13 @@
   "author": "cso1z",
   "license": "MIT",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.6.1",
+    "@modelcontextprotocol/sdk": "^1.13.1",
     "@types/yargs": "^17.0.33",
     "axios": "^1.7.9",
     "cross-env": "^7.0.3",
     "dotenv": "^16.4.7",
     "express": "^4.21.2",
+    "form-data": "^4.0.3",
     "remeda": "^2.20.1",
     "yargs": "^17.7.2",
     "zod": "^3.24.2"

package/dist/config.js

@@ -1,26 +0,0 @@
-import { Config, ConfigSource } from './utils/config.js';
-/**
- * 为了向后兼容，保留getServerConfig函数
- * 但内部使用Config类
- * @param isStdioMode 是否在stdio模式下
- * @returns 服务器配置
- */
-export function getServerConfig(isStdioMode) {
-    const config = Config.getInstance();
-    if (!isStdioMode) {
-        config.printConfig(isStdioMode);
-    }
-    // 为了向后兼容，返回旧格式的配置对象
-    return {
-        port: config.server.port,
-        feishuAppId: config.feishu.appId,
-        feishuAppSecret: config.feishu.appSecret,
-        configSources: {
-            port: config.configSources['server.port'].toLowerCase(),
-            feishuAppId: config.configSources['feishu.appId']?.toLowerCase(),
-            feishuAppSecret: config.configSources['feishu.appSecret']?.toLowerCase()
-        }
-    };
-}
-// 导出Config类
-export { Config, ConfigSource };