feishu-mcp 0.0.11 → 0.0.12

package/dist/config.js

@@ -1,26 +1,104 @@
-import { Config, ConfigSource } from './utils/config.js';
-/**
- * 为了向后兼容，保留getServerConfig函数
- * 但内部使用Config类
- * @param isStdioMode 是否在stdio模式下
- * @returns 服务器配置
- */
+import { config } from "dotenv";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+// 确保在任何配置读取前加载.env文件
+config();
+function maskApiKey(key) {
+    if (key.length <= 4)
+        return "****";
+    return `****${key.slice(-4)}`;
+}
 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,
+    // Parse command line arguments
+    const argv = yargs(hideBin(process.argv))
+        .options({
+        port: {
+            type: "number",
+            description: "Port to run the server on",
+        },
+        "feishu-app-id": {
+            type: "string",
+            description: "Feishu App ID",
+        },
+        "feishu-app-secret": {
+            type: "string",
+            description: "Feishu App Secret",
+        },
+    })
+        .help()
+        .parseSync();
+    const config = {
+        port: 3333,
         configSources: {
-            port: config.configSources['server.port'].toLowerCase(),
-            feishuAppId: config.configSources['feishu.appId']?.toLowerCase(),
-            feishuAppSecret: config.configSources['feishu.appSecret']?.toLowerCase()
-        }
+            port: "default",
+        },
     };
+    // Handle PORT
+    if (argv.port) {
+        config.port = argv.port;
+        config.configSources.port = "cli";
+    }
+    else if (process.env.PORT) {
+        config.port = parseInt(process.env.PORT, 10);
+        config.configSources.port = "env";
+    }
+    // 在加载环境变量之前添加日志
+    console.log('开始加载环境变量配置...');
+    console.log('当前环境变量 FEISHU_APP_ID:', process.env.FEISHU_APP_ID);
+    console.log('当前环境变量 FEISHU_APP_SECRET:', process.env.FEISHU_APP_SECRET);
+    // Handle Feishu configuration
+    if (argv["feishu-app-id"]) {
+        config.feishuAppId = argv["feishu-app-id"];
+        config.configSources.feishuAppId = "cli";
+        console.log(`飞书应用 ID 来自命令行参数: ${maskApiKey(config.feishuAppId)}`);
+    }
+    else if (process.env.FEISHU_APP_ID) {
+        config.feishuAppId = process.env.FEISHU_APP_ID;
+        config.configSources.feishuAppId = "env";
+        console.log(`飞书应用 ID 来自环境变量: ${maskApiKey(config.feishuAppId)}`);
+    }
+    else {
+        console.log('未提供飞书应用 ID');
+    }
+    if (argv["feishu-app-secret"]) {
+        config.feishuAppSecret = argv["feishu-app-secret"];
+        config.configSources.feishuAppSecret = "cli";
+        console.log(`飞书应用密钥来自命令行参数: ${maskApiKey(config.feishuAppSecret)}`);
+    }
+    else if (process.env.FEISHU_APP_SECRET) {
+        config.feishuAppSecret = process.env.FEISHU_APP_SECRET;
+        config.configSources.feishuAppSecret = "env";
+        console.log(`飞书应用密钥来自环境变量: ${maskApiKey(config.feishuAppSecret)}`);
+    }
+    else {
+        console.log('未提供飞书应用密钥');
+    }
+    // 输出飞书配置状态总结
+    if (config.feishuAppId && config.feishuAppSecret) {
+        console.log('飞书配置已完整提供，服务将被初始化');
+    }
+    else if (config.feishuAppId || config.feishuAppSecret) {
+        console.log('飞书配置不完整，服务将不会初始化');
+    }
+    else {
+        console.log('未提供飞书配置，服务将不会初始化');
+    }
+    // 验证配置
+    if (!config.feishuAppId || !config.feishuAppSecret) {
+        console.error("FEISHU_APP_ID 和 FEISHU_APP_SECRET 是必需的（通过命令行参数 --feishu-app-id 和 --feishu-app-secret 或 .env 文件）");
+        process.exit(1);
+    }
+    // Log configuration sources
+    if (!isStdioMode) {
+        console.log("\n配置信息:");
+        console.log(`- PORT: ${config.port} (来源: ${config.configSources.port})`);
+        if (config.feishuAppId) {
+            console.log(`- FEISHU_APP_ID: ${maskApiKey(config.feishuAppId)} (来源: ${config.configSources.feishuAppId})`);
+        }
+        if (config.feishuAppSecret) {
+            console.log(`- FEISHU_APP_SECRET: ${maskApiKey(config.feishuAppSecret)} (来源: ${config.configSources.feishuAppSecret})`);
+        }
+        console.log(); // 空行，提高可读性
+    }
+    return config;
 }
-// 导出Config类
-export { Config, ConfigSource };

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/feishu.js

@@ -70,6 +70,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 +87,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 +130,7 @@ export class FeishuService {
                 throw {
                     status: error.response.status,
                     err: error.response.data?.msg || "Unknown error",
+                    apiError: error.response.data
                 };
             }
             Logger.error('发送请求时发生未知错误:', error);

package/dist/services/feishuApiService.js

@@ -714,4 +714,50 @@ 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, '搜索文档失败');
+        }
+    }
 }

package/dist/types/feishuSchema.js

@@ -118,3 +118,5 @@ export const OrderBySchema = z.string().optional().default('EditedTime').describ
 // 排序方向参数定义
 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.');

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,74 +1,74 @@
-{
-  "name": "feishu-mcp",
-  "version": "0.0.11",
-  "description": "Model Context Protocol server for Feishu integration",
-  "type": "module",
-  "main": "dist/index.js",
-  "bin": {
-    "feishu-mcp": "./dist/cli.js"
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsc && tsc-alias",
-    "type-check": "tsc --noEmit",
-    "start": "node dist/index.js",
-    "start:cli": "cross-env NODE_ENV=cli node dist/index.js",
-    "start:http": "node dist/index.js",
-    "dev": "cross-env NODE_ENV=development tsx watch src/index.ts",
-    "dev:cli": "cross-env NODE_ENV=development tsx watch src/index.ts --stdio",
-    "lint": "eslint . --ext .ts",
-    "format": "prettier --write \"src/**/*.ts\"",
-    "inspect": "pnpx @modelcontextprotocol/inspector",
-    "prepare": "pnpm run build",
-    "pub:release": "pnpm build && npm publish"
-  },
-  "engines": {
-    "node": "^20.17.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/cso1z/Feishu-MCP.git"
-  },
-  "keywords": [
-    "feishu",
-    "lark",
-    "mcp",
-    "typescript"
-  ],
-  "author": "cso1z",
-  "license": "MIT",
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.6.1",
-    "@types/yargs": "^17.0.33",
-    "axios": "^1.7.9",
-    "cross-env": "^7.0.3",
-    "dotenv": "^16.4.7",
-    "express": "^4.21.2",
-    "remeda": "^2.20.1",
-    "yargs": "^17.7.2",
-    "zod": "^3.24.2"
-  },
-  "devDependencies": {
-    "@types/express": "^5.0.0",
-    "@types/jest": "^29.5.11",
-    "@types/node": "^20.17.0",
-    "@typescript-eslint/eslint-plugin": "^8.24.0",
-    "@typescript-eslint/parser": "^8.24.0",
-    "eslint": "^9.20.1",
-    "eslint-config-prettier": "^10.0.1",
-    "jest": "^29.7.0",
-    "prettier": "^3.5.0",
-    "ts-jest": "^29.2.5",
-    "tsc-alias": "^1.8.10",
-    "tsx": "^4.19.2",
-    "typescript": "^5.7.3"
-  },
-  "pnpm": {
-    "overrides": {
-      "feishu-mcp": "link:"
-    }
-  }
-}
+{
+  "name": "feishu-mcp",
+  "version": "0.0.12",
+  "description": "Model Context Protocol server for Feishu integration",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "feishu-mcp": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc && tsc-alias",
+    "type-check": "tsc --noEmit",
+    "start": "node dist/index.js",
+    "start:cli": "cross-env NODE_ENV=cli node dist/index.js",
+    "start:http": "node dist/index.js",
+    "dev": "cross-env NODE_ENV=development tsx watch src/index.ts",
+    "dev:cli": "cross-env NODE_ENV=development tsx watch src/index.ts --stdio",
+    "lint": "eslint . --ext .ts",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "inspect": "pnpx @modelcontextprotocol/inspector",
+    "prepare": "pnpm run build",
+    "pub:release": "pnpm build && npm publish"
+  },
+  "engines": {
+    "node": "^20.17.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cso1z/Feishu-MCP.git"
+  },
+  "keywords": [
+    "feishu",
+    "lark",
+    "mcp",
+    "typescript"
+  ],
+  "author": "cso1z",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.6.1",
+    "@types/yargs": "^17.0.33",
+    "axios": "^1.7.9",
+    "cross-env": "^7.0.3",
+    "dotenv": "^16.4.7",
+    "express": "^4.21.2",
+    "remeda": "^2.20.1",
+    "yargs": "^17.7.2",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.0",
+    "@types/jest": "^29.5.11",
+    "@types/node": "^20.17.0",
+    "@typescript-eslint/eslint-plugin": "^8.24.0",
+    "@typescript-eslint/parser": "^8.24.0",
+    "eslint": "^9.20.1",
+    "eslint-config-prettier": "^10.0.1",
+    "jest": "^29.7.0",
+    "prettier": "^3.5.0",
+    "ts-jest": "^29.2.5",
+    "tsc-alias": "^1.8.10",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3"
+  },
+  "pnpm": {
+    "overrides": {
+      "feishu-mcp": "link:"
+    }
+  }
+}

package/dist/services/feishuBlockService.js

@@ -1,179 +0,0 @@
-/**
- * @deprecated 这个文件已被弃用，所有功能已迁移到BlockFactory类。
- * 请使用BlockFactory创建各种块内容。
- * 所有接口定义已迁移到blockFactory.ts文件。
- * 此文件仅保留为历史兼容性目的，将在后续版本中移除。
- */
-/**
- * 构建批量创建块的请求数据
- * @param blocks 块内容数组
- * @param index 插入位置索引
- * @returns 请求数据对象
- * @deprecated 请使用BlockFactory.buildCreateBlocksRequest
- */
-export function buildCreateBlocksRequest(blocks, index = 0) {
-    return {
-        children: blocks,
-        index
-    };
-}
-/**
- * 创建文本块内容
- * @param align 对齐方式：1左对齐，2居中，3右对齐
- * @returns 文本块内容对象
- * @deprecated 请使用BlockFactory.createTextBlock
- */
-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 代码块内容对象
- * @deprecated 请使用BlockFactory.createCodeBlock
- */
-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 标题块内容对象
- * @deprecated 请使用BlockFactory.createHeadingBlock
- */
-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;
-}
-/**
- * 创建列表块内容（有序或无序）
- * @param text 列表项文本
- * @param isOrdered 是否为有序列表
- * @param align 对齐方式：1左对齐，2居中，3右对齐
- * @returns 列表块内容对象
- * @deprecated 请使用BlockFactory.createListBlock
- */
-export function 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;
-}
-/**
- * 处理Markdown语法转换
- * @param textContents 文本内容数组
- * @returns 处理后的文本内容数组
- * @deprecated 应当避免使用Markdown语法，请直接使用TextElementStyle设置样式
- */
-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 };
-    });
-}