feishu-mcp 0.1.5 → 0.1.6

package/README.md

@@ -79,7 +79,7 @@
 - ~~**支持mermaid图表**：流程图、时序图等等，丰富文档内容~~ 0.1.11 ✅
 - ~~**支持表格创建**：创建包含各种块类型的复杂表格，支持样式控制~~ 0.1.2 ✅
 - ~~**支持飞书多用户user认证**：一人部署，可以多人使用~~ 0.1.3 ✅
-- **支持user_access_token自动刷新**：无需频繁授权，提高使用体验
+- ~~**支持user_access_token自动刷新**：无需频繁授权，提高使用体验~~ 0.1.6 ✅
 
 ---
 

package/dist/mcp/feishuMcp.js

@@ -6,7 +6,7 @@ import { registerFeishuBlockTools } from './tools/feishuBlockTools.js';
 import { registerFeishuFolderTools } from './tools/feishuFolderTools.js';
 const serverInfo = {
     name: "Feishu MCP Server",
-    version: "0.1.5",
+    version: "0.1.6",
 };
 const serverOptions = {
     capabilities: { logging: {}, tools: {} },

package/dist/server.js

@@ -7,7 +7,7 @@ import { Logger } from './utils/logger.js';
 import { SSEConnectionManager } from './manager/sseConnectionManager.js';
 import { FeishuMcp } from './mcp/feishuMcp.js';
 import { callback } from './services/callbackService.js';
-import { UserAuthManager, UserContextManager, getBaseUrl, TokenCacheManager } from './utils/auth/index.js';
+import { UserAuthManager, UserContextManager, getBaseUrl, TokenCacheManager, TokenRefreshManager } from './utils/auth/index.js';
 export class FeishuMcpServer {
     constructor() {
         Object.defineProperty(this, "connectionManager", {
@@ -33,6 +33,10 @@ export class FeishuMcpServer {
         this.userContextManager = UserContextManager.getInstance();
         // 初始化TokenCacheManager，确保在启动时从文件加载缓存
         TokenCacheManager.getInstance();
+        // 启动Token自动刷新管理器
+        const tokenRefreshManager = TokenRefreshManager.getInstance();
+        tokenRefreshManager.start();
+        Logger.info('Token自动刷新管理器已在服务器启动时初始化');
     }
     async connect(transport) {
         const server = new FeishuMcp();

package/dist/services/callbackService.js

@@ -74,6 +74,9 @@ export async function callback(req, res) {
             if (data.refresh_token_expires_in) {
                 data.refresh_token_expires_at = Math.floor(Date.now() / 1000) + data.refresh_token_expires_in;
             }
+            // 添加client_id和client_secret，用于后续刷新token
+            data.client_id = appId;
+            data.client_secret = appSecret;
             // 缓存token信息
             const refreshTtl = data.refresh_token_expires_in || 3600 * 24 * 365; // 默认1年
             tokenCacheManager.cacheUserToken(clientKey, data, refreshTtl);

package/dist/services/feishuApiService.js

@@ -5,7 +5,7 @@ import { CacheManager } from '../utils/cache.js';
 import { ParamUtils } from '../utils/paramUtils.js';
 import { BlockFactory, BlockType } from './blockFactory.js';
 import { AuthUtils, TokenCacheManager } from '../utils/auth/index.js';
-import { AuthRequiredError } from '../utils/error.js';
+import { AuthService } from './feishuAuthService.js';
 import axios from 'axios';
 import FormData from 'form-data';
 import fs from 'fs';
@@ -38,9 +38,16 @@ export class FeishuApiService extends BaseApiService {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "authService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.cacheManager = CacheManager.getInstance();
         this.blockFactory = BlockFactory.getInstance();
         this.config = Config.getInstance();
+        this.authService = new AuthService();
     }
     /**
      * 获取飞书API服务实例
@@ -83,7 +90,7 @@ export class FeishuApiService extends BaseApiService {
         }
         else {
             // 用户模式：获取用户访问令牌
-            return this.getUserAccessToken(appId, appSecret, clientKey, userKey);
+            return this.authService.getUserAccessToken(clientKey, appId, appSecret);
         }
     }
     /**
@@ -135,88 +142,6 @@ export class FeishuApiService extends BaseApiService {
             throw new Error('获取租户访问令牌失败: ' + (error instanceof Error ? error.message : String(error)));
         }
     }
-    /**
-     * 获取用户访问令牌
-     * @param appId 应用ID
-     * @param appSecret 应用密钥
-     * @param clientKey 客户端缓存键
-     * @param userKey 用户标识
-     * @returns 用户访问令牌
-     */
-    async getUserAccessToken(appId, appSecret, clientKey, _userKey) {
-        const tokenCacheManager = TokenCacheManager.getInstance();
-        // 检查用户token状态
-        const tokenStatus = tokenCacheManager.checkUserTokenStatus(clientKey);
-        Logger.debug(`用户token状态:`, tokenStatus);
-        if (tokenStatus.isValid && !tokenStatus.shouldRefresh) {
-            // token有效且不需要刷新，直接返回
-            const cachedToken = tokenCacheManager.getUserToken(clientKey);
-            if (cachedToken) {
-                Logger.debug('使用缓存的用户访问令牌');
-                return cachedToken;
-            }
-        }
-        if (tokenStatus.canRefresh && (tokenStatus.isExpired || tokenStatus.shouldRefresh)) {
-            // 可以刷新token
-            Logger.info('尝试刷新用户访问令牌');
-            try {
-                const tokenInfo = tokenCacheManager.getUserTokenInfo(clientKey);
-                if (tokenInfo && tokenInfo.refresh_token) {
-                    const refreshedToken = await this.refreshUserToken(tokenInfo.refresh_token, clientKey, appId, appSecret);
-                    if (refreshedToken && refreshedToken.access_token) {
-                        Logger.info('用户访问令牌刷新成功');
-                        return refreshedToken.access_token;
-                    }
-                }
-            }
-            catch (error) {
-                Logger.warn('刷新用户访问令牌失败:', error);
-                // 刷新失败，清除缓存，需要重新授权
-                tokenCacheManager.removeUserToken(clientKey);
-            }
-        }
-        // 没有有效的token或刷新失败，需要用户授权
-        Logger.warn('没有有效的用户token，需要用户授权');
-        throw new AuthRequiredError('user', '需要用户授权');
-    }
-    /**
-     * 刷新用户访问令牌
-     * @param refreshToken 刷新令牌
-     * @param clientKey 客户端缓存键
-     * @param appId 应用ID
-     * @param appSecret 应用密钥
-     * @returns 刷新后的token信息
-     */
-    async refreshUserToken(refreshToken, clientKey, appId, appSecret) {
-        const tokenCacheManager = TokenCacheManager.getInstance();
-        const body = {
-            grant_type: 'refresh_token',
-            client_id: appId,
-            client_secret: appSecret,
-            refresh_token: refreshToken
-        };
-        Logger.debug('刷新用户访问令牌请求:', body);
-        const response = await axios.post('https://open.feishu.cn/open-apis/authen/v2/oauth/token', body, {
-            headers: { 'Content-Type': 'application/json' }
-        });
-        const data = response.data;
-        if (data && data.access_token && data.expires_in) {
-            // 计算过期时间戳
-            data.expires_at = Math.floor(Date.now() / 1000) + data.expires_in;
-            if (data.refresh_token_expires_in) {
-                data.refresh_token_expires_at = Math.floor(Date.now() / 1000) + data.refresh_token_expires_in;
-            }
-            // 缓存新的token信息
-            const refreshTtl = data.refresh_token_expires_in || 3600 * 24 * 365; // 默认1年
-            tokenCacheManager.cacheUserToken(clientKey, data, refreshTtl);
-            Logger.info('用户访问令牌刷新并缓存成功');
-            return data;
-        }
-        else {
-            Logger.warn('刷新用户访问令牌失败:', data);
-            throw new Error('刷新用户访问令牌失败');
-        }
-    }
     /**
      * 创建飞书文档
      * @param title 文档标题

package/dist/services/feishuAuthService.js

@@ -1,6 +1,8 @@
 import axios from 'axios';
 import { Config } from '../utils/config.js';
 import { Logger } from '../utils/logger.js';
+import { TokenCacheManager } from '../utils/auth/tokenCacheManager.js';
+import { AuthRequiredError } from '../utils/error.js';
 export class AuthService {
     constructor() {
         Object.defineProperty(this, "config", {
@@ -45,4 +47,109 @@ export class AuthService {
         Logger.debug('[AuthService] getUserTokenByCode response', data);
         return data;
     }
+    /**
+     * 刷新用户访问令牌
+     * 从缓存中获取token信息并刷新，如果缓存中没有必要信息则使用传入的备用参数
+     * @param clientKey 客户端缓存键
+     * @param appId 应用ID（可选，如果tokenInfo中没有则使用此参数）
+     * @param appSecret 应用密钥（可选，如果tokenInfo中没有则使用此参数）
+     * @returns 刷新后的token信息
+     * @throws 如果无法获取必要的刷新信息则抛出错误
+     */
+    async refreshUserToken(clientKey, appId, appSecret) {
+        const tokenCacheManager = TokenCacheManager.getInstance();
+        // 从缓存中获取token信息
+        const tokenInfo = tokenCacheManager.getUserTokenInfo(clientKey);
+        if (!tokenInfo) {
+            throw new Error(`无法获取token信息: ${clientKey}`);
+        }
+        // 获取刷新所需的必要信息
+        const actualRefreshToken = tokenInfo.refresh_token;
+        const actualAppId = tokenInfo.client_id || appId;
+        const actualAppSecret = tokenInfo.client_secret || appSecret;
+        // 验证必要参数
+        if (!actualRefreshToken) {
+            throw new Error('无法获取refresh_token，无法刷新用户访问令牌');
+        }
+        if (!actualAppId || !actualAppSecret) {
+            throw new Error('无法获取client_id或client_secret，无法刷新用户访问令牌');
+        }
+        const body = {
+            grant_type: 'refresh_token',
+            client_id: actualAppId,
+            client_secret: actualAppSecret,
+            refresh_token: actualRefreshToken
+        };
+        Logger.debug('[AuthService] 刷新用户访问令牌请求:', {
+            clientKey,
+            client_id: actualAppId,
+            has_refresh_token: !!actualRefreshToken
+        });
+        const response = await axios.post('https://open.feishu.cn/open-apis/authen/v2/oauth/token', body, {
+            headers: { 'Content-Type': 'application/json' }
+        });
+        const data = response.data;
+        if (data && data.access_token && data.expires_in) {
+            // 计算过期时间戳
+            data.expires_at = Math.floor(Date.now() / 1000) + data.expires_in;
+            if (data.refresh_token_expires_in) {
+                data.refresh_token_expires_at = Math.floor(Date.now() / 1000) + data.refresh_token_expires_in;
+            }
+            // 保留client_id和client_secret（优先使用tokenInfo中的，如果没有则使用实际使用的参数）
+            data.client_id = actualAppId;
+            data.client_secret = actualAppSecret;
+            // 缓存新的token信息
+            const refreshTtl = data.refresh_token_expires_in || 3600 * 24 * 365; // 默认1年
+            tokenCacheManager.cacheUserToken(clientKey, data, refreshTtl);
+            Logger.info(`[AuthService] 用户访问令牌刷新并缓存成功: ${clientKey}`);
+            return data;
+        }
+        else {
+            Logger.warn('[AuthService] 刷新用户访问令牌失败:', data);
+            throw new Error('刷新用户访问令牌失败');
+        }
+    }
+    /**
+     * 获取用户访问令牌
+     * 检查token状态，如果有效则返回缓存的token，如果过期则尝试刷新
+     * @param clientKey 客户端缓存键
+     * @param appId 应用ID（可选，如果tokenInfo中没有则使用此参数）
+     * @param appSecret 应用密钥（可选，如果tokenInfo中没有则使用此参数）
+     * @returns 用户访问令牌
+     * @throws 如果无法获取有效的token则抛出AuthRequiredError
+     */
+    async getUserAccessToken(clientKey, appId, appSecret) {
+        const tokenCacheManager = TokenCacheManager.getInstance();
+        // 检查用户token状态
+        const tokenStatus = tokenCacheManager.checkUserTokenStatus(clientKey);
+        Logger.debug(`[AuthService] 用户token状态:`, tokenStatus);
+        if (tokenStatus.isValid && !tokenStatus.shouldRefresh) {
+            // token有效且不需要刷新，直接返回
+            const cachedToken = tokenCacheManager.getUserToken(clientKey);
+            if (cachedToken) {
+                Logger.debug('[AuthService] 使用缓存的用户访问令牌');
+                return cachedToken;
+            }
+        }
+        if (tokenStatus.canRefresh && (tokenStatus.isExpired || tokenStatus.shouldRefresh)) {
+            // 可以刷新token
+            Logger.info('[AuthService] 尝试刷新用户访问令牌');
+            try {
+                // 使用统一的刷新方法，它会自动从缓存中获取必要信息
+                const refreshedToken = await this.refreshUserToken(clientKey, appId, appSecret);
+                if (refreshedToken && refreshedToken.access_token) {
+                    Logger.info('[AuthService] 用户访问令牌刷新成功');
+                    return refreshedToken.access_token;
+                }
+            }
+            catch (error) {
+                Logger.warn('[AuthService] 刷新用户访问令牌失败:', error);
+                // 刷新失败，清除缓存，需要重新授权
+                tokenCacheManager.removeUserToken(clientKey);
+            }
+        }
+        // 没有有效的token或刷新失败，需要用户授权
+        Logger.warn('[AuthService] 没有有效的用户token，需要用户授权');
+        throw new AuthRequiredError('user', '需要用户授权');
+    }
 }

package/dist/utils/auth/index.js

@@ -2,3 +2,4 @@ export { UserContextManager, getBaseUrl } from './userContextManager.js';
 export { UserAuthManager } from './userAuthManager.js';
 export { TokenCacheManager } from './tokenCacheManager.js';
 export { AuthUtils } from './authUtils.js';
+export { TokenRefreshManager } from './tokenRefreshManager.js';

package/dist/utils/auth/tokenCacheManager.js

@@ -417,4 +417,20 @@ export class TokenCacheManager {
         }, 5 * 60 * 1000);
         Logger.info('Token缓存清理定时器已启动，每5分钟执行一次');
     }
+    /**
+     * 获取所有用户token的key列表（不包含前缀）
+     * @returns 用户token的key数组
+     */
+    getAllUserTokenKeys() {
+        const keys = [];
+        for (const [key] of this.cache.entries()) {
+            if (key.startsWith('user_access_token:')) {
+                // 提取clientKey（去掉前缀）
+                const clientKey = key.substring('user_access_token:'.length);
+                keys.push(clientKey);
+            }
+        }
+        Logger.debug(`获取到 ${keys.length} 个用户token keys`);
+        return keys;
+    }
 }

package/dist/utils/auth/tokenRefreshManager.js

@@ -0,0 +1,172 @@
+import { Logger } from '../logger.js';
+import { TokenCacheManager } from './tokenCacheManager.js';
+import { AuthService } from '../../services/feishuAuthService.js';
+/**
+ * Token自动刷新管理器
+ * 定期检查并自动刷新即将过期的用户token
+ */
+export class TokenRefreshManager {
+    /**
+     * 私有构造函数，用于单例模式
+     */
+    constructor() {
+        Object.defineProperty(this, "intervalId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "checkInterval", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 5 * 60 * 1000
+        }); // 5分钟
+        Object.defineProperty(this, "isRunning", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Logger.info('Token刷新管理器已初始化');
+    }
+    /**
+     * 获取TokenRefreshManager实例
+     */
+    static getInstance() {
+        if (!TokenRefreshManager.instance) {
+            TokenRefreshManager.instance = new TokenRefreshManager();
+        }
+        return TokenRefreshManager.instance;
+    }
+    /**
+     * 启动自动刷新检查
+     */
+    start() {
+        if (this.isRunning) {
+            Logger.warn('Token刷新管理器已在运行中');
+            return;
+        }
+        Logger.info(`启动Token自动刷新管理器，检查间隔: ${this.checkInterval / 1000}秒`);
+        // 立即执行一次检查
+        this.checkAndRefreshTokens();
+        // 设置定时器
+        this.intervalId = setInterval(() => {
+            this.checkAndRefreshTokens();
+        }, this.checkInterval);
+        this.isRunning = true;
+        Logger.info('Token自动刷新管理器已启动');
+    }
+    /**
+     * 停止自动刷新检查
+     */
+    stop() {
+        if (!this.isRunning) {
+            Logger.warn('Token刷新管理器未在运行');
+            return;
+        }
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+        this.isRunning = false;
+        Logger.info('Token自动刷新管理器已停止');
+    }
+    /**
+     * 检查并刷新即将过期的token
+     */
+    async checkAndRefreshTokens() {
+        try {
+            Logger.debug('开始检查需要刷新的token');
+            const tokenCacheManager = TokenCacheManager.getInstance();
+            // 获取所有用户token
+            const allCacheKeys = this.getAllUserTokenKeys();
+            let checkedCount = 0;
+            let refreshedCount = 0;
+            let failedCount = 0;
+            for (const clientKey of allCacheKeys) {
+                checkedCount++;
+                try {
+                    const tokenStatus = tokenCacheManager.checkUserTokenStatus(clientKey);
+                    // 检查是否需要刷新：token即将过期（5分钟内）且可以刷新
+                    if (tokenStatus.shouldRefresh || (tokenStatus.canRefresh && tokenStatus.isExpired)) {
+                        Logger.info(`检测到需要刷新的token: ${clientKey}`);
+                        const tokenInfo = tokenCacheManager.getUserTokenInfo(clientKey);
+                        if (!tokenInfo) {
+                            Logger.warn(`无法获取token信息: ${clientKey}`);
+                            failedCount++;
+                            continue;
+                        }
+                        // 验证是否有刷新所需的必要信息
+                        if (!tokenInfo.refresh_token) {
+                            Logger.warn(`token没有refresh_token，无法刷新: ${clientKey}`);
+                            failedCount++;
+                            continue;
+                        }
+                        if (!tokenInfo.client_id || !tokenInfo.client_secret) {
+                            Logger.warn(`token缺少client_id或client_secret，无法刷新: ${clientKey}`);
+                            failedCount++;
+                            continue;
+                        }
+                        // 执行刷新，使用AuthService的统一刷新方法
+                        try {
+                            const authService = new AuthService();
+                            await authService.refreshUserToken(clientKey);
+                            refreshedCount++;
+                            Logger.info(`token刷新成功: ${clientKey}`);
+                        }
+                        catch (error) {
+                            failedCount++;
+                            Logger.warn(`token刷新失败: ${clientKey}`, error);
+                            // 如果刷新失败是因为refresh_token无效，清除缓存
+                            if (error?.response?.data?.code === 99991669 || error?.message?.includes('refresh_token')) {
+                                Logger.warn(`refresh_token无效，清除缓存: ${clientKey}`);
+                                tokenCacheManager.removeUserToken(clientKey);
+                            }
+                        }
+                    }
+                    else {
+                        Logger.debug(`token状态正常，无需刷新: ${clientKey}`, {
+                            isValid: tokenStatus.isValid,
+                            isExpired: tokenStatus.isExpired,
+                            canRefresh: tokenStatus.canRefresh,
+                            shouldRefresh: tokenStatus.shouldRefresh
+                        });
+                    }
+                }
+                catch (error) {
+                    Logger.error(`检查token时发生错误: ${clientKey}`, error);
+                    failedCount++;
+                }
+            }
+            if (refreshedCount > 0 || failedCount > 0) {
+                Logger.info(`Token刷新检查完成: 检查${checkedCount}个，刷新${refreshedCount}个，失败${failedCount}个`);
+            }
+            else {
+                Logger.debug(`Token刷新检查完成: 检查${checkedCount}个，无需刷新`);
+            }
+        }
+        catch (error) {
+            Logger.error('检查并刷新token时发生错误:', error);
+        }
+    }
+    /**
+     * 获取所有用户token的key列表
+     */
+    getAllUserTokenKeys() {
+        try {
+            const tokenCacheManager = TokenCacheManager.getInstance();
+            return tokenCacheManager.getAllUserTokenKeys();
+        }
+        catch (error) {
+            Logger.error('获取所有用户token key时发生错误:', error);
+            return [];
+        }
+    }
+    /**
+     * 获取运行状态
+     */
+    isRunningStatus() {
+        return this.isRunning;
+    }
+}

package/package.json

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