feishu-mcp 0.1.8 → 0.1.9-test.2

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,32 +13,29 @@ 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接口
+        // 启动最小化的HTTP服务器（只提供callback接口）
+        await server.startCallbackServer(config.server.port);
         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

@@ -8,6 +8,7 @@ import { SSEConnectionManager } from './manager/sseConnectionManager.js';
 import { FeishuMcp } from './mcp/feishuMcp.js';
 import { callback } from './services/callbackService.js';
 import { UserAuthManager, UserContextManager, getBaseUrl, TokenCacheManager, TokenRefreshManager } from './utils/auth/index.js';
+import { Config } from './utils/config.js';
 export class FeishuMcpServer {
     constructor() {
         Object.defineProperty(this, "connectionManager", {
@@ -40,13 +41,17 @@ export class FeishuMcpServer {
     }
     async connect(transport) {
         const server = new FeishuMcp();
-        await server.connect(transport);
-        Logger.info = (...args) => {
-            server.server.sendLoggingMessage({ level: 'info', data: args });
-        };
-        Logger.error = (...args) => {
-            server.server.sendLoggingMessage({ level: 'error', data: args });
-        };
+        // stdio模式只能本地运行，使用localhost + 配置的端口
+        const config = Config.getInstance();
+        const baseUrl = `http://localhost:${config.server.port}`;
+        await this.userContextManager.run({
+            userKey: 'stdio',
+            baseUrl: baseUrl
+        }, async () => {
+            await server.connect(transport);
+        });
+        // 注意：在 stdio 模式下，Logger 会自动禁用输出，避免污染 MCP 协议
+        // 如果需要日志，可以通过 MCP 协议的 logging 消息传递
         Logger.info('Server connected and ready to process requests');
     }
     async startHttpServer(port) {
@@ -109,7 +114,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',
@@ -135,7 +140,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');
                 }
@@ -157,7 +162,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');
                 }
@@ -228,4 +233,18 @@ export class FeishuMcpServer {
             Logger.info(`StreamableHTTP endpoint available at http://localhost:${port}/mcp`);
         });
     }
+    /**
+     * 启动最小化的HTTP服务器（仅提供callback接口）
+     * 用于stdio模式下提供OAuth回调功能
+     * @param port 服务器端口
+     */
+    async startCallbackServer(port) {
+        const app = express();
+        // 只注册callback接口
+        app.get('/callback', callback);
+        app.listen(port, '0.0.0.0', () => {
+            Logger.info(`Callback server listening on port ${port}`);
+            Logger.info(`Callback endpoint available at http://localhost:${port}/callback`);
+        });
+    }
 }

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.8",
+  "version": "0.1.9-test.2",
   "description": "Model Context Protocol server for Feishu integration",
   "type": "module",
   "main": "dist/index.js",
@@ -23,7 +23,8 @@
     "format": "prettier --write \"src/**/*.ts\"",
     "inspect": "pnpx @modelcontextprotocol/inspector",
     "prepare": "pnpm run build",
-    "pub:release": "pnpm build && npm publish"
+    "pub:release": "pnpm build && npm publish",
+    "pub:test": "pnpm build && npm publish --tag test"
   },
   "engines": {
     "node": "^20.17.0"