feishu-mcp 0.0.7 → 0.0.9-alpha

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/manager/sseConnectionManager.js

@@ -0,0 +1,104 @@
+import { Logger } from '../utils/logger';
+/**
+ * SSE连接管理器 - 负责管理所有的SSE长连接和心跳机制
+ */
+export class SSEConnectionManager {
+    constructor() {
+        Object.defineProperty(this, "transports", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "connections", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "keepAliveIntervalId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "KEEP_ALIVE_INTERVAL_MS", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1000 * 25
+        }); // 25秒心跳间隔
+        this.startGlobalKeepAlive();
+    }
+    /**
+     * 启动全局心跳管理
+     */
+    startGlobalKeepAlive() {
+        if (this.keepAliveIntervalId) {
+            clearInterval(this.keepAliveIntervalId);
+        }
+        this.keepAliveIntervalId = setInterval(() => {
+            Logger.info(`[KeepAlive] Sending keepalive to ${this.connections.size} connections`);
+            for (const [sessionId, connection] of this.connections.entries()) {
+                if (!connection.res.writableEnded) {
+                    connection.res.write(': keepalive\n\n');
+                }
+                else {
+                    // 移除已关闭的连接
+                    this.removeConnection(sessionId);
+                }
+            }
+        }, this.KEEP_ALIVE_INTERVAL_MS);
+    }
+    /**
+     * 添加新的SSE连接
+     */
+    addConnection(sessionId, transport, req, res) {
+        this.transports[sessionId] = transport;
+        this.connections.set(sessionId, { res });
+        console.info(`[SSE Connection] Client connected: ${sessionId}`);
+        req.on('close', () => {
+            this.removeConnection(sessionId);
+        });
+    }
+    /**
+     * 移除SSE连接
+     */
+    removeConnection(sessionId) {
+        const transport = this.transports[sessionId];
+        if (transport) {
+            try {
+                transport.close();
+                Logger.info(`[SSE Connection] Transport closed for: ${sessionId}`);
+            }
+            catch (error) {
+                Logger.error(`[SSE Connection] Error closing transport for: ${sessionId}`, error);
+            }
+        }
+        delete this.transports[sessionId];
+        this.connections.delete(sessionId);
+        console.info(`[SSE Connection] Client disconnected: ${sessionId}`);
+    }
+    /**
+     * 获取指定sessionId的传输实例
+     */
+    getTransport(sessionId) {
+        console.info(`[SSE Connection] Getting transport for sessionId: ${sessionId}`);
+        return this.transports[sessionId];
+    }
+    /**
+     * 关闭连接管理器
+     */
+    shutdown() {
+        if (this.keepAliveIntervalId) {
+            clearInterval(this.keepAliveIntervalId);
+            this.keepAliveIntervalId = null;
+        }
+        // 关闭所有连接
+        Logger.info(`[SSE Connection] Shutting down all connections (${this.connections.size} active)`);
+        for (const sessionId of this.connections.keys()) {
+            this.removeConnection(sessionId);
+        }
+        Logger.info(`[SSE Connection] All connections closed`);
+    }
+}

package/dist/mcp/feishuMcp.js

@@ -0,0 +1,67 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { FeishuApiService } from '../services/feishuApiService.js';
+import { Logger } from '../utils/logger.js';
+import { registerFeishuTools } from './tools/feishuTools.js';
+import { registerFeishuBlockTools } from './tools/feishuBlockTools.js';
+import { registerFeishuFolderTools } from './tools/feishuFolderTools.js';
+const serverInfo = {
+    name: "Feishu MCP Server",
+    version: "0.0.9-alpha",
+};
+const serverOptions = {
+    capabilities: { logging: {}, tools: {} },
+};
+/**
+ * 飞书MCP服务类
+ * 继承自McpServer，提供飞书工具注册和初始化功能
+ */
+export class FeishuMcp extends McpServer {
+    /**
+     * 构造函数
+     */
+    constructor() {
+        super(serverInfo, serverOptions);
+        Object.defineProperty(this, "feishuService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // 初始化飞书服务
+        this.initFeishuService();
+        // 注册所有工具
+        if (this.feishuService) {
+            this.registerAllTools();
+        }
+        else {
+            Logger.error('无法注册飞书工具: 飞书服务初始化失败');
+            throw new Error('飞书服务初始化失败');
+        }
+    }
+    /**
+     * 初始化飞书API服务
+     */
+    initFeishuService() {
+        try {
+            // 使用单例模式获取飞书服务实例
+            this.feishuService = FeishuApiService.getInstance();
+            Logger.info('飞书服务初始化成功');
+        }
+        catch (error) {
+            Logger.error('飞书服务初始化失败:', error);
+            this.feishuService = null;
+        }
+    }
+    /**
+     * 注册所有飞书MCP工具
+     */
+    registerAllTools() {
+        if (!this.feishuService) {
+            return;
+        }
+        // 注册所有工具
+        registerFeishuTools(this, this.feishuService);
+        registerFeishuBlockTools(this, this.feishuService);
+        registerFeishuFolderTools(this, this.feishuService);
+    }
+}