feishu-mcp 0.1.1 → 0.1.3

package/dist/utils/auth/authUtils.js

@@ -0,0 +1,71 @@
+import * as crypto from 'crypto';
+import { Config } from '../config.js';
+/**
+ * 认证工具类
+ * 提供认证相关的加密和哈希工具方法
+ */
+export class AuthUtils {
+    /**
+     * 生成客户端缓存键
+     * @param userKey 用户标识（可选）
+     * @returns 生成的客户端键
+     */
+    static generateClientKey(userKey) {
+        const feishuConfig = Config.getInstance().feishu;
+        const userPart = userKey ? `:${userKey}` : '';
+        let source = '';
+        if (feishuConfig.authType === "tenant") {
+            source = `${feishuConfig.appId}:${feishuConfig.appSecret}`;
+        }
+        else {
+            source = `${feishuConfig.appId}:${feishuConfig.appSecret}${userPart}`;
+        }
+        return crypto.createHash('sha256').update(source).digest('hex');
+    }
+    /**
+     * 生成时间戳
+     * @returns 当前时间戳（秒）
+     */
+    static timestamp() {
+        return Math.floor(Date.now() / 1000);
+    }
+    /**
+     * 生成时间戳（毫秒）
+     * @returns 当前时间戳（毫秒）
+     */
+    static timestampMs() {
+        return Date.now();
+    }
+    /**
+     * 编码state参数
+     * @param appId 应用ID
+     * @param appSecret 应用密钥
+     * @param clientKey 客户端缓存键
+     * @param redirectUri 重定向URI（可选）
+     * @returns Base64编码的state字符串
+     */
+    static encodeState(appId, appSecret, clientKey, redirectUri) {
+        const stateData = {
+            appId,
+            appSecret,
+            clientKey,
+            redirectUri,
+            timestamp: this.timestamp()
+        };
+        return Buffer.from(JSON.stringify(stateData)).toString('base64');
+    }
+    /**
+     * 解码state参数
+     * @param encodedState Base64编码的state字符串
+     * @returns 解码后的state数据
+     */
+    static decodeState(encodedState) {
+        try {
+            const decoded = Buffer.from(encodedState, 'base64').toString('utf-8');
+            return JSON.parse(decoded);
+        }
+        catch (error) {
+            return null;
+        }
+    }
+}

package/dist/utils/auth/index.js

@@ -0,0 +1,4 @@
+export { UserContextManager, getBaseUrl } from './userContextManager.js';
+export { UserAuthManager } from './userAuthManager.js';
+export { TokenCacheManager } from './tokenCacheManager.js';
+export { AuthUtils } from './authUtils.js';

package/dist/utils/auth/tokenCacheManager.js

@@ -0,0 +1,420 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { Logger } from '../logger.js';
+/**
+ * Token缓存管理器
+ * 专门处理用户token和租户token的缓存管理
+ */
+export class TokenCacheManager {
+    /**
+     * 私有构造函数，用于单例模式
+     */
+    constructor() {
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "userTokenCacheFile", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tenantTokenCacheFile", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.cache = new Map();
+        this.userTokenCacheFile = path.resolve(process.cwd(), 'user_token_cache.json');
+        this.tenantTokenCacheFile = path.resolve(process.cwd(), 'tenant_token_cache.json');
+        this.loadTokenCaches();
+        this.startCacheCleanupTimer();
+    }
+    /**
+     * 获取TokenCacheManager实例
+     */
+    static getInstance() {
+        if (!TokenCacheManager.instance) {
+            TokenCacheManager.instance = new TokenCacheManager();
+        }
+        return TokenCacheManager.instance;
+    }
+    /**
+     * 系统启动时从本地文件缓存中读取token记录
+     */
+    loadTokenCaches() {
+        this.loadUserTokenCache();
+        this.loadTenantTokenCache();
+    }
+    /**
+     * 加载用户token缓存
+     */
+    loadUserTokenCache() {
+        if (fs.existsSync(this.userTokenCacheFile)) {
+            try {
+                const raw = fs.readFileSync(this.userTokenCacheFile, 'utf-8');
+                const cacheData = JSON.parse(raw);
+                let loadedCount = 0;
+                for (const key in cacheData) {
+                    if (key.startsWith('user_access_token:')) {
+                        this.cache.set(key, cacheData[key]);
+                        loadedCount++;
+                    }
+                }
+                Logger.info(`已加载用户token缓存，共 ${loadedCount} 条记录`);
+            }
+            catch (error) {
+                Logger.warn('加载用户token缓存失败:', error);
+            }
+        }
+        else {
+            Logger.info('用户token缓存文件不存在，将创建新的缓存');
+        }
+    }
+    /**
+     * 加载租户token缓存
+     */
+    loadTenantTokenCache() {
+        if (fs.existsSync(this.tenantTokenCacheFile)) {
+            try {
+                const raw = fs.readFileSync(this.tenantTokenCacheFile, 'utf-8');
+                const cacheData = JSON.parse(raw);
+                let loadedCount = 0;
+                for (const key in cacheData) {
+                    if (key.startsWith('tenant_access_token:')) {
+                        this.cache.set(key, cacheData[key]);
+                        loadedCount++;
+                    }
+                }
+                Logger.info(`已加载租户token缓存，共 ${loadedCount} 条记录`);
+            }
+            catch (error) {
+                Logger.warn('加载租户token缓存失败:', error);
+            }
+        }
+    }
+    /**
+     * 根据key获取完整的用户token信息
+     * @param key 缓存键
+     * @returns 完整的用户token信息对象，如果未找到或refresh_token过期则返回null
+     */
+    getUserTokenInfo(key) {
+        const cacheKey = `user_access_token:${key}`;
+        const cacheItem = this.cache.get(cacheKey);
+        if (!cacheItem) {
+            Logger.debug(`用户token信息未找到: ${key}`);
+            return null;
+        }
+        const tokenInfo = cacheItem.data;
+        const now = Math.floor(Date.now() / 1000);
+        // 检查refresh_token是否过期（如果有的话）
+        if (tokenInfo.refresh_token && tokenInfo.refresh_token_expires_at) {
+            if (tokenInfo.refresh_token_expires_at < now) {
+                Logger.debug(`用户token的refresh_token已过期，从缓存中删除: ${key}`);
+                this.cache.delete(cacheKey);
+                this.saveUserTokenCache();
+                return null;
+            }
+        }
+        else {
+            // 如果没有refresh_token信息，检查缓存本身是否过期
+            if (Date.now() > cacheItem.expiresAt) {
+                Logger.debug(`用户token缓存已过期: ${key}`);
+                this.cache.delete(cacheKey);
+                this.saveUserTokenCache();
+                return null;
+            }
+        }
+        Logger.debug(`获取用户token信息成功: ${key}`);
+        return tokenInfo;
+    }
+    /**
+     * 根据key获取用户的access_token值
+     * @param key 缓存键
+     * @returns access_token字符串，如果未找到或已过期则返回null
+     */
+    getUserToken(key) {
+        const tokenInfo = this.getUserTokenInfo(key);
+        return tokenInfo ? tokenInfo.access_token : null;
+    }
+    /**
+     * 根据key获取租户token信息
+     * @param key 缓存键
+     * @returns 租户token信息，如果未找到或已过期则返回null
+     */
+    getTenantTokenInfo(key) {
+        const cacheKey = `tenant_access_token:${key}`;
+        const cacheItem = this.cache.get(cacheKey);
+        if (!cacheItem) {
+            Logger.debug(`租户token信息未找到: ${key}`);
+            return null;
+        }
+        // 检查是否过期
+        if (Date.now() > cacheItem.expiresAt) {
+            Logger.debug(`租户token信息已过期: ${key}`);
+            this.cache.delete(cacheKey);
+            this.saveTenantTokenCache();
+            return null;
+        }
+        Logger.debug(`获取租户token信息成功: ${key}`);
+        return cacheItem.data;
+    }
+    /**
+     * 删除租户token
+     * @param key 缓存键
+     * @returns 是否成功删除
+     */
+    removeTenantToken(key) {
+        const cacheKey = `tenant_access_token:${key}`;
+        const result = this.cache.delete(cacheKey);
+        if (result) {
+            this.saveUserTokenCache();
+            Logger.debug(`租户token删除成功: ${key}`);
+        }
+        return result;
+    }
+    /**
+     * 根据key获取租户的access_token值
+     * @param key 缓存键
+     * @returns app_access_token字符串，如果未找到或已过期则返回null
+     */
+    getTenantToken(key) {
+        const tokenInfo = this.getTenantTokenInfo(key);
+        return tokenInfo ? tokenInfo.app_access_token : null;
+    }
+    /**
+     * 缓存用户token信息
+     * @param key 缓存键
+     * @param tokenInfo 用户token信息
+     * @param customTtl 自定义TTL（秒），如果不提供则使用refresh_token的过期时间
+     * @returns 是否成功缓存
+     */
+    cacheUserToken(key, tokenInfo, customTtl) {
+        try {
+            const now = Date.now();
+            const cacheKey = `user_access_token:${key}`;
+            // 计算过期时间 - 优先使用refresh_token的过期时间，确保可以刷新
+            let expiresAt;
+            if (customTtl) {
+                expiresAt = now + (customTtl * 1000);
+            }
+            else if (tokenInfo.refresh_token_expires_at) {
+                // 使用refresh_token的过期时间，确保在refresh_token有效期内缓存不会被清除
+                expiresAt = tokenInfo.refresh_token_expires_at * 1000; // 转换为毫秒
+                Logger.debug(`使用refresh_token过期时间作为缓存过期时间: ${new Date(expiresAt).toISOString()}`);
+            }
+            else if (tokenInfo.expires_at) {
+                // 如果没有refresh_token_expires_at信息，降级使用access_token的过期时间
+                expiresAt = tokenInfo.expires_at * 1000;
+                Logger.warn(`没有refresh_token过期时间戳，使用access_token过期时间: ${new Date(expiresAt).toISOString()}`);
+            }
+            else {
+                // 最后的降级方案：如果没有任何过期时间信息，设置默认的2小时过期
+                expiresAt = now + (2 * 60 * 60 * 1000); // 2小时
+                Logger.warn(`没有过期时间信息，使用默认2小时作为缓存过期时间`);
+            }
+            const cacheItem = {
+                data: tokenInfo,
+                timestamp: now,
+                expiresAt: expiresAt
+            };
+            this.cache.set(cacheKey, cacheItem);
+            this.saveUserTokenCache();
+            Logger.debug(`用户token缓存成功: ${key}, 缓存过期时间: ${new Date(expiresAt).toISOString()}`);
+            return true;
+        }
+        catch (error) {
+            Logger.error(`缓存用户token失败: ${key}`, error);
+            return false;
+        }
+    }
+    /**
+     * 缓存租户token信息
+     * @param key 缓存键
+     * @param tokenInfo 租户token信息
+     * @param customTtl 自定义TTL（秒），如果不提供则使用token本身的过期时间
+     * @returns 是否成功缓存
+     */
+    cacheTenantToken(key, tokenInfo, customTtl) {
+        try {
+            const now = Date.now();
+            const cacheKey = `tenant_access_token:${key}`;
+            // 计算过期时间
+            let expiresAt;
+            if (customTtl) {
+                expiresAt = now + (customTtl * 1000);
+            }
+            else if (tokenInfo.expires_at) {
+                expiresAt = tokenInfo.expires_at * 1000; // 转换为毫秒
+            }
+            else {
+                // 如果没有过期时间信息，设置默认的2小时过期
+                expiresAt = now + (2 * 60 * 60 * 1000);
+                Logger.warn(`租户token没有过期时间信息，使用默认2小时`);
+            }
+            const cacheItem = {
+                data: tokenInfo,
+                timestamp: now,
+                expiresAt: expiresAt
+            };
+            this.cache.set(cacheKey, cacheItem);
+            this.saveTenantTokenCache();
+            Logger.debug(`租户token缓存成功: ${key}, 过期时间: ${new Date(expiresAt).toISOString()}`);
+            return true;
+        }
+        catch (error) {
+            Logger.error(`缓存租户token失败: ${key}`, error);
+            return false;
+        }
+    }
+    /**
+     * 检查用户token状态
+     * @param key 缓存键
+     * @returns token状态信息
+     */
+    checkUserTokenStatus(key) {
+        const tokenInfo = this.getUserTokenInfo(key);
+        if (!tokenInfo) {
+            return {
+                isValid: false,
+                isExpired: true,
+                canRefresh: false,
+                shouldRefresh: false
+            };
+        }
+        const now = Math.floor(Date.now() / 1000);
+        const isExpired = tokenInfo.expires_at ? tokenInfo.expires_at < now : false;
+        const timeToExpiry = tokenInfo.expires_at ? Math.max(0, tokenInfo.expires_at - now) : 0;
+        // 判断是否可以刷新
+        const canRefresh = !!(tokenInfo.refresh_token &&
+            tokenInfo.refresh_token_expires_at &&
+            tokenInfo.refresh_token_expires_at > now);
+        // 判断是否应该提前刷新（提前5分钟）
+        const shouldRefresh = timeToExpiry > 0 && timeToExpiry < 300 && canRefresh;
+        return {
+            isValid: !isExpired,
+            isExpired,
+            canRefresh,
+            shouldRefresh
+        };
+    }
+    /**
+     * 删除用户token
+     * @param key 缓存键
+     * @returns 是否成功删除
+     */
+    removeUserToken(key) {
+        const cacheKey = `user_access_token:${key}`;
+        const result = this.cache.delete(cacheKey);
+        if (result) {
+            this.saveUserTokenCache();
+            Logger.debug(`用户token删除成功: ${key}`);
+        }
+        return result;
+    }
+    /**
+     * 保存用户token缓存到文件
+     */
+    saveUserTokenCache() {
+        const cacheData = {};
+        for (const [key, value] of this.cache.entries()) {
+            if (key.startsWith('user_access_token:')) {
+                cacheData[key] = value;
+            }
+        }
+        try {
+            fs.writeFileSync(this.userTokenCacheFile, JSON.stringify(cacheData, null, 2), 'utf-8');
+            Logger.debug('用户token缓存已保存到文件');
+        }
+        catch (error) {
+            Logger.warn('保存用户token缓存失败:', error);
+        }
+    }
+    /**
+     * 保存租户token缓存到文件
+     */
+    saveTenantTokenCache() {
+        const cacheData = {};
+        for (const [key, value] of this.cache.entries()) {
+            if (key.startsWith('tenant_access_token:')) {
+                cacheData[key] = value;
+            }
+        }
+        try {
+            fs.writeFileSync(this.tenantTokenCacheFile, JSON.stringify(cacheData, null, 2), 'utf-8');
+            Logger.debug('租户token缓存已保存到文件');
+        }
+        catch (error) {
+            Logger.warn('保存租户token缓存失败:', error);
+        }
+    }
+    /**
+     * 清理过期缓存
+     * 对于用户token，只有在refresh_token过期时才清理
+     * 对于租户token，按缓存过期时间清理
+     * @returns 清理的数量
+     */
+    cleanExpiredTokens() {
+        const now = Date.now();
+        const nowSeconds = Math.floor(now / 1000);
+        let cleanedCount = 0;
+        const keysToDelete = [];
+        for (const [key, cacheItem] of this.cache.entries()) {
+            let shouldDelete = false;
+            if (key.startsWith('user_access_token:')) {
+                // 用户token：检查refresh_token是否过期
+                const tokenInfo = cacheItem.data;
+                if (tokenInfo.refresh_token && tokenInfo.refresh_token_expires_at) {
+                    // 有refresh_token，只有refresh_token过期才删除
+                    shouldDelete = tokenInfo.refresh_token_expires_at < nowSeconds;
+                    if (shouldDelete) {
+                        Logger.debug(`清理用户token - refresh_token已过期: ${key}`);
+                    }
+                }
+                else {
+                    // 没有refresh_token，按缓存过期时间删除
+                    shouldDelete = cacheItem.expiresAt <= now;
+                    if (shouldDelete) {
+                        Logger.debug(`清理用户token - 无refresh_token且缓存过期: ${key}`);
+                    }
+                }
+            }
+            else {
+                // 租户token或其他类型：按缓存过期时间删除
+                shouldDelete = cacheItem.expiresAt <= now;
+                if (shouldDelete) {
+                    Logger.debug(`清理过期缓存: ${key}`);
+                }
+            }
+            if (shouldDelete) {
+                keysToDelete.push(key);
+            }
+        }
+        // 批量删除
+        keysToDelete.forEach(key => {
+            this.cache.delete(key);
+            cleanedCount++;
+        });
+        if (cleanedCount > 0) {
+            // 分别保存用户和租户缓存
+            this.saveUserTokenCache();
+            this.saveTenantTokenCache();
+            Logger.info(`清理过期token，删除了 ${cleanedCount} 条记录`);
+        }
+        return cleanedCount;
+    }
+    /**
+     * 启动缓存清理定时器
+     */
+    startCacheCleanupTimer() {
+        // 每5分钟清理一次过期缓存
+        setInterval(() => {
+            this.cleanExpiredTokens();
+        }, 5 * 60 * 1000);
+        Logger.info('Token缓存清理定时器已启动，每5分钟执行一次');
+    }
+}

package/dist/utils/auth/userAuthManager.js

@@ -0,0 +1,104 @@
+import { Logger } from '../logger.js';
+/**
+ * 用户认证管理器
+ * 管理 sessionId 与 userKey 的映射关系
+ */
+export class UserAuthManager {
+    /**
+     * 私有构造函数，用于单例模式
+     */
+    constructor() {
+        Object.defineProperty(this, "sessionToUserKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // sessionId -> userKey
+        this.sessionToUserKey = new Map();
+    }
+    /**
+     * 获取用户认证管理器实例
+     * @returns 用户认证管理器实例
+     */
+    static getInstance() {
+        if (!UserAuthManager.instance) {
+            UserAuthManager.instance = new UserAuthManager();
+        }
+        return UserAuthManager.instance;
+    }
+    /**
+     * 创建用户会话
+     * @param sessionId 会话ID
+     * @param userKey 用户密钥
+     * @returns 是否创建成功
+     */
+    createSession(sessionId, userKey) {
+        if (!sessionId || !userKey) {
+            Logger.warn('创建会话失败：sessionId 或 userKey 为空');
+            return false;
+        }
+        this.sessionToUserKey.set(sessionId, userKey);
+        Logger.info(`创建用户会话：sessionId=${sessionId}, userKey=${userKey}`);
+        return true;
+    }
+    /**
+     * 根据 sessionId 获取 userKey
+     * @param sessionId 会话ID
+     * @returns 用户密钥，如果未找到则返回 null
+     */
+    getUserKeyBySessionId(sessionId) {
+        if (!sessionId) {
+            return null;
+        }
+        const userKey = this.sessionToUserKey.get(sessionId);
+        if (!userKey) {
+            Logger.debug(`未找到会话：${sessionId}`);
+            return null;
+        }
+        Logger.debug(`获取用户密钥：sessionId=${sessionId}, userKey=${userKey}`);
+        return userKey;
+    }
+    /**
+     * 删除会话
+     * @param sessionId 会话ID
+     * @returns 是否删除成功
+     */
+    removeSession(sessionId) {
+        if (!sessionId) {
+            return false;
+        }
+        const userKey = this.sessionToUserKey.get(sessionId);
+        if (!userKey) {
+            Logger.debug(`会话不存在：${sessionId}`);
+            return false;
+        }
+        this.sessionToUserKey.delete(sessionId);
+        Logger.info(`删除用户会话：sessionId=${sessionId}, userKey=${userKey}`);
+        return true;
+    }
+    /**
+     * 检查会话是否存在
+     * @param sessionId 会话ID
+     * @returns 会话是否存在
+     */
+    hasSession(sessionId) {
+        return this.sessionToUserKey.has(sessionId);
+    }
+    /**
+     * 获取所有会话统计信息
+     * @returns 会话统计信息
+     */
+    getStats() {
+        return {
+            totalSessions: this.sessionToUserKey.size
+        };
+    }
+    /**
+     * 清空所有会话
+     */
+    clearAllSessions() {
+        const count = this.sessionToUserKey.size;
+        this.sessionToUserKey.clear();
+        Logger.info(`清空所有会话，删除了 ${count} 个会话`);
+    }
+}

package/dist/utils/auth/userContextManager.js

@@ -0,0 +1,81 @@
+import { AsyncLocalStorage } from 'async_hooks';
+/**
+ * 用户上下文管理器
+ * 使用 AsyncLocalStorage 在异步调用链中传递用户信息
+ */
+export class UserContextManager {
+    constructor() {
+        Object.defineProperty(this, "asyncLocalStorage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.asyncLocalStorage = new AsyncLocalStorage();
+    }
+    /**
+     * 获取单例实例
+     */
+    static getInstance() {
+        if (!UserContextManager.instance) {
+            UserContextManager.instance = new UserContextManager();
+        }
+        return UserContextManager.instance;
+    }
+    /**
+     * 在指定上下文中运行回调函数
+     * @param context 用户上下文
+     * @param callback 回调函数
+     * @returns 回调函数的返回值
+     */
+    run(context, callback) {
+        return this.asyncLocalStorage.run(context, callback);
+    }
+    /**
+     * 获取当前上下文中的用户密钥
+     * @returns 用户密钥，如果不存在则返回空字符串
+     */
+    getUserKey() {
+        const context = this.asyncLocalStorage.getStore();
+        return context?.userKey || '';
+    }
+    /**
+     * 获取当前上下文中的基础URL
+     * @returns 基础URL，如果不存在则返回空字符串
+     */
+    getBaseUrl() {
+        const context = this.asyncLocalStorage.getStore();
+        return context?.baseUrl || '';
+    }
+    /**
+     * 获取当前完整的用户上下文
+     * @returns 用户上下文，如果不存在则返回 undefined
+     */
+    getContext() {
+        return this.asyncLocalStorage.getStore();
+    }
+    /**
+     * 检查是否存在用户上下文
+     * @returns 如果存在用户上下文则返回 true
+     */
+    hasContext() {
+        return this.asyncLocalStorage.getStore() !== undefined;
+    }
+}
+/**
+ * 获取协议
+ */
+function getProtocol(req) {
+    if (req.secure || req.get('X-Forwarded-Proto') === 'https') {
+        return 'https';
+    }
+    return 'http';
+}
+/**
+ * 获取基础URL
+ */
+export function getBaseUrl(req) {
+    const protocol = getProtocol(req);
+    const host = req.get('X-Forwarded-Host') || req.get('host');
+    return `${protocol}://${host}`;
+}