feishu-mcp 0.1.9-test.1 → 0.1.9-test.3

package/dist/cli.js

@@ -2,14 +2,15 @@
 import { resolve } from "path";
 import { config } from "dotenv";
 import { startServer } from "./index.js";
+import { Logger } from "./utils/logger.js";
 // Load .env from the current working directory
 config({ path: resolve(process.cwd(), ".env") });
 startServer().catch((error) => {
     if (error instanceof Error) {
-        console.error("Failed to start server:", error.message);
+        Logger.error("Failed to start server:", error.message);
     }
     else {
-        console.error("Failed to start server with unknown error:", error);
+        Logger.error("Failed to start server with unknown error:", error);
     }
     process.exit(1);
 });

package/dist/index.js

@@ -1,6 +1,7 @@
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { FeishuMcpServer } from "./server.js";
 import { Config } from "./utils/config.js";
+import { Logger } from "./utils/logger.js";
 import { fileURLToPath } from 'url';
 import { resolve } from 'path';
 export async function startServer() {
@@ -12,12 +13,11 @@ export async function startServer() {
     config.printConfig(isStdioMode);
     // 验证配置
     if (!config.validate()) {
-        console.error("配置验证失败，无法启动服务器");
+        Logger.error("配置验证失败，无法启动服务器");
         process.exit(1);
     }
     // 创建MCP服务器
     const server = new FeishuMcpServer();
-    console.log(`isStdioMode:${isStdioMode}`);
     if (isStdioMode) {
         const transport = new StdioServerTransport();
         // 在stdio模式下也需要启动HTTP服务器以提供callback接口
@@ -26,21 +26,16 @@ export async function startServer() {
         await server.connect(transport);
     }
     else {
-        console.log(`Initializing Feishu MCP Server in HTTP mode on port ${config.server.port}...`);
+        Logger.info(`Initializing Feishu MCP Server in HTTP mode on port ${config.server.port}...`);
         await server.startHttpServer(config.server.port);
     }
 }
 // 跨平台兼容的方式检查是否直接运行
 const currentFilePath = fileURLToPath(import.meta.url);
 const executedFilePath = resolve(process.argv[1]);
-console.log(`meta.url:${currentFilePath}  argv:${executedFilePath}`);
 if (currentFilePath === executedFilePath) {
-    console.log(`startServer`);
     startServer().catch((error) => {
-        console.error('Failed to start server:', error);
+        Logger.error('Failed to start server:', error);
         process.exit(1);
     });
 }
-else {
-    console.log(`not startServer`);
-}

package/dist/manager/sseConnectionManager.js

@@ -55,7 +55,7 @@ export class SSEConnectionManager {
     addConnection(sessionId, transport, req, res) {
         this.transports[sessionId] = transport;
         this.connections.set(sessionId, { res });
-        console.info(`[SSE Connection] Client connected: ${sessionId}`);
+        Logger.info(`[SSE Connection] Client connected: ${sessionId}`);
         req.on('close', () => {
             this.removeConnection(sessionId);
         });
@@ -76,13 +76,13 @@ export class SSEConnectionManager {
         }
         delete this.transports[sessionId];
         this.connections.delete(sessionId);
-        console.info(`[SSE Connection] Client disconnected: ${sessionId}`);
+        Logger.info(`[SSE Connection] Client disconnected: ${sessionId}`);
     }
     /**
      * 获取指定sessionId的传输实例
      */
     getTransport(sessionId) {
-        console.info(`[SSE Connection] Getting transport for sessionId: ${sessionId}`);
+        Logger.debug(`[SSE Connection] Getting transport for sessionId: ${sessionId}`);
         return this.transports[sessionId];
     }
     /**

package/dist/server.js

@@ -29,6 +29,12 @@ export class FeishuMcpServer {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "callbackServer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        }); // stdio 模式下的 callback 服务器实例
         this.connectionManager = new SSEConnectionManager();
         this.userAuthManager = UserAuthManager.getInstance();
         this.userContextManager = UserContextManager.getInstance();
@@ -50,14 +56,40 @@ export class FeishuMcpServer {
         }, async () => {
             await server.connect(transport);
         });
-        Logger.info = (...args) => {
-            server.server.sendLoggingMessage({ level: 'info', data: args });
-        };
-        Logger.error = (...args) => {
-            server.server.sendLoggingMessage({ level: 'error', data: args });
-        };
+        // 监听 transport 关闭事件，清理 callback 服务器
+        // 对于 stdio 模式，监听 stdin 关闭事件
+        if (process.stdin && typeof process.stdin.on === 'function') {
+            process.stdin.on('close', () => {
+                this.stopCallbackServer();
+            });
+            process.stdin.on('end', () => {
+                this.stopCallbackServer();
+            });
+        }
+        // 监听进程退出事件，确保清理资源
+        process.on('SIGINT', () => {
+            this.stopCallbackServer();
+            process.exit(0);
+        });
+        process.on('SIGTERM', () => {
+            this.stopCallbackServer();
+            process.exit(0);
+        });
+        // 注意：在 stdio 模式下，Logger 会自动禁用输出，避免污染 MCP 协议
+        // 如果需要日志，可以通过 MCP 协议的 logging 消息传递
         Logger.info('Server connected and ready to process requests');
     }
+    /**
+     * 停止 callback 服务器
+     */
+    stopCallbackServer() {
+        if (this.callbackServer) {
+            this.callbackServer.close(() => {
+                Logger.info('Callback server stopped');
+            });
+            this.callbackServer = null;
+        }
+    }
     async startHttpServer(port) {
         const app = express();
         const transports = {};
@@ -118,7 +150,7 @@ export class FeishuMcpServer {
                 await transport.handleRequest(req, res, req.body);
             }
             catch (error) {
-                console.error('Error handling MCP request:', error);
+                Logger.error('Error handling MCP request:', error);
                 if (!res.headersSent) {
                     res.status(500).json({
                         jsonrpc: '2.0',
@@ -144,7 +176,7 @@ export class FeishuMcpServer {
                 await transport.handleRequest(req, res);
             }
             catch (error) {
-                console.error('Error handling GET request:', error);
+                Logger.error('Error handling GET request:', error);
                 if (!res.headersSent) {
                     res.status(500).send('Internal server error');
                 }
@@ -166,7 +198,7 @@ export class FeishuMcpServer {
                 }
             }
             catch (error) {
-                console.error('Error handling DELETE request:', error);
+                Logger.error('Error handling DELETE request:', error);
                 if (!res.headersSent) {
                     res.status(500).send('Internal server error');
                 }
@@ -244,13 +276,26 @@ export class FeishuMcpServer {
      */
     async startCallbackServer(port) {
         const app = express();
-        console.log(`[Callback Server] startCallbackServer`);
         // 只注册callback接口
         app.get('/callback', callback);
-        app.listen(port, '0.0.0.0', () => {
-            // 使用console.log确保在stdio模式下也能看到日志
-            Logger.info(`Callback server listening on port ${port}`);
-            Logger.info(`Callback endpoint available at http://localhost:${port}/callback`);
+        return new Promise((resolve, reject) => {
+            const server = app.listen(port, '0.0.0.0', () => {
+                this.callbackServer = server;
+                Logger.info(`Callback server listening on port ${port}`);
+                Logger.info(`Callback endpoint available at http://localhost:${port}/callback`);
+                resolve();
+            });
+            server.on('error', (err) => {
+                if (err.code === 'EADDRINUSE') {
+                    // 端口被占用，说明其他进程已经启动了 callback 服务器
+                    // 这是正常的，静默处理即可（多个 stdio 进程共享同一个 callback 服务器）
+                    Logger.debug(`Port ${port} is already in use, callback server may already be running`);
+                    resolve(); // 不抛出错误，因为 callback 服务器已经存在
+                }
+                else {
+                    reject(err);
+                }
+            });
         });
     }
 }

package/dist/services/baseService.js

@@ -309,8 +309,11 @@ export class BaseApiService {
      */
     generateUserAuthUrl(baseUrl, userKey) {
         const { appId, appSecret } = Config.getInstance().feishu;
+        const config = Config.getInstance();
         const clientKey = AuthUtils.generateClientKey(userKey);
-        const redirect_uri = `${baseUrl}/callback`;
+        // 如果 baseUrl 为空，使用默认值（stdio 模式）
+        const finalBaseUrl = baseUrl || `http://localhost:${config.server.port}`;
+        const redirect_uri = `${finalBaseUrl}/callback`;
         const scope = encodeURIComponent('base:app:read bitable:app bitable:app:readonly board:whiteboard:node:read board:whiteboard:node:create contact:user.employee_id:readonly docs:document.content:read docx:document docx:document.block:convert docx:document:create docx:document:readonly drive:drive drive:drive:readonly drive:file drive:file:upload sheets:spreadsheet sheets:spreadsheet:readonly space:document:retrieve space:folder:create wiki:space:read wiki:space:retrieve wiki:wiki wiki:wiki:readonly offline_access');
         const state = AuthUtils.encodeState(appId, appSecret, clientKey, redirect_uri);
         return `https://accounts.feishu.cn/open-apis/authen/v1/authorize?client_id=${appId}&redirect_uri=${encodeURIComponent(redirect_uri)}&scope=${scope}&state=${state}`;

package/dist/services/callbackService.js

@@ -2,6 +2,7 @@ import { AuthService } from './feishuAuthService.js';
 import { Config } from '../utils/config.js';
 import { renderFeishuAuthResultHtml } from '../utils/document.js';
 import { AuthUtils, TokenCacheManager } from '../utils/auth/index.js';
+import { Logger } from '../utils/logger.js';
 // 通用响应码
 const CODE = {
     SUCCESS: 0,
@@ -24,28 +25,28 @@ const config = Config.getInstance();
 export async function callback(req, res) {
     const code = req.query.code;
     const state = req.query.state;
-    console.log(`[callback] query:`, req.query);
+    Logger.debug(`[callback] query:`, req.query);
     if (!code) {
-        console.log('[callback] 缺少code参数');
+        Logger.warn('[callback] 缺少code参数');
         return sendFail(res, '缺少code参数', CODE.PARAM_ERROR);
     }
     if (!state) {
-        console.log('[callback] 缺少state参数');
+        Logger.warn('[callback] 缺少state参数');
         return sendFail(res, '缺少state参数', CODE.PARAM_ERROR);
     }
     // 解析state参数
     const stateData = AuthUtils.decodeState(state);
     if (!stateData) {
-        console.log('[callback] state参数解析失败');
+        Logger.warn('[callback] state参数解析失败');
         return sendFail(res, 'state参数格式错误', CODE.PARAM_ERROR);
     }
     const { appId, appSecret, clientKey, redirectUri } = stateData;
-    console.log(`[callback] 解析state成功:`, { appId, clientKey, redirectUri });
+    Logger.debug(`[callback] 解析state成功:`, { appId, clientKey, redirectUri });
     // 验证state中的appId和appSecret是否与配置匹配
     const configAppId = config.feishu.appId;
     const configAppSecret = config.feishu.appSecret;
     if (appId !== configAppId || appSecret !== configAppSecret) {
-        console.log('[callback] state中的appId或appSecret与配置不匹配');
+        Logger.warn('[callback] state中的appId或appSecret与配置不匹配');
         return sendFail(res, 'state参数验证失败', CODE.PARAM_ERROR);
     }
     // 使用从state中解析的redirect_uri，如果没有则使用默认值
@@ -62,7 +63,7 @@ export async function callback(req, res) {
             code_verifier
         });
         const data = (tokenResp && typeof tokenResp === 'object') ? tokenResp : undefined;
-        console.log('[callback] feishu response:', data);
+        Logger.debug('[callback] feishu response:', data);
         if (!data || data.code !== 0 || !data.access_token) {
             return sendFail(res, `获取 access_token 失败，飞书返回: ${JSON.stringify(tokenResp)}`, CODE.CUSTOM);
         }
@@ -80,19 +81,19 @@ export async function callback(req, res) {
             // 缓存token信息
             const refreshTtl = data.refresh_token_expires_in || 3600 * 24 * 365; // 默认1年
             tokenCacheManager.cacheUserToken(clientKey, data, refreshTtl);
-            console.log(`[callback] token已缓存到clientKey: ${clientKey}`);
+            Logger.info(`[callback] token已缓存到clientKey: ${clientKey}`);
         }
         // 获取用户信息
         const access_token = data.access_token;
         let userInfo = null;
         if (access_token) {
             userInfo = await authService.getUserInfo(access_token);
-            console.log('[callback] feishu userInfo:', userInfo);
+            Logger.debug('[callback] feishu userInfo:', userInfo);
         }
         return sendSuccess(res, { ...data, userInfo, clientKey });
     }
     catch (e) {
-        console.error('[callback] 请求飞书token或用户信息失败:', e);
+        Logger.error('[callback] 请求飞书token或用户信息失败:', e);
         return sendFail(res, `请求飞书token或用户信息失败: ${e}`, CODE.CUSTOM);
     }
 }

package/dist/utils/logger.js

@@ -18,6 +18,13 @@ import * as path from 'path';
  * 提供可配置的日志记录功能，支持不同日志级别和格式化
  */
 export class Logger {
+    /**
+     * 检查是否处于 stdio 模式
+     * @returns 是否处于 stdio 模式
+     */
+    static isStdioMode() {
+        return process.env.NODE_ENV === "cli" || process.argv.includes("--stdio");
+    }
     /**
      * 配置日志管理器
      * @param config 日志配置项
@@ -45,6 +52,10 @@ export class Logger {
      * @returns 是否可输出
      */
     static canLog(level) {
+        // 在 stdio 模式下，禁用所有日志输出（避免污染 MCP 协议）
+        if (this.isStdioMode()) {
+            return false;
+        }
         return this.config.enabled && level >= this.config.minLevel;
     }
     /**
@@ -99,7 +110,10 @@ export class Logger {
             fs.appendFileSync(this.config.logFilePath, logString);
         }
         catch (error) {
-            console.error('写入日志文件失败:', error);
+            // 在 stdio 模式下不输出错误，避免污染 MCP 协议
+            if (!this.isStdioMode()) {
+                console.error('写入日志文件失败:', error);
+            }
         }
     }
     /**

package/package.json

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