feishu-mcp 0.1.2 → 0.1.4

package/dist/services/feishuApiService.js

@@ -4,6 +4,8 @@ import { Config } from '../utils/config.js';
 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 axios from 'axios';
 import FormData from 'form-data';
 import fs from 'fs';
@@ -66,35 +68,154 @@ export class FeishuApiService extends BaseApiService {
     }
     /**
      * 获取访问令牌
+     * @param userKey 用户标识（可选）
      * @returns 访问令牌
      * @throws 如果获取令牌失败则抛出错误
      */
-    async getAccessToken() {
-        // 尝试从缓存获取
-        const cachedToken = this.cacheManager.getToken();
+    async getAccessToken(userKey) {
+        const { appId, appSecret, authType } = this.config.feishu;
+        // 生成客户端缓存键
+        const clientKey = AuthUtils.generateClientKey(userKey);
+        Logger.debug(`[FeishuApiService] 获取访问令牌，userKey: ${userKey}, clientKey: ${clientKey}, authType: ${authType}`);
+        if (authType === 'tenant') {
+            // 租户模式：获取租户访问令牌
+            return this.getTenantAccessToken(appId, appSecret, clientKey);
+        }
+        else {
+            // 用户模式：获取用户访问令牌
+            return this.getUserAccessToken(appId, appSecret, clientKey, userKey);
+        }
+    }
+    /**
+     * 获取租户访问令牌
+     * @param appId 应用ID
+     * @param appSecret 应用密钥
+     * @param clientKey 客户端缓存键
+     * @returns 租户访问令牌
+     */
+    async getTenantAccessToken(appId, appSecret, clientKey) {
+        const tokenCacheManager = TokenCacheManager.getInstance();
+        // 尝试从缓存获取租户token
+        const cachedToken = tokenCacheManager.getTenantToken(clientKey);
         if (cachedToken) {
-            Logger.debug('使用缓存的访问令牌');
+            Logger.debug('使用缓存的租户访问令牌');
             return cachedToken;
         }
-        // 通过HTTP请求调用配置的tokenEndpoint接口
-        const { appId, appSecret, authType, tokenEndpoint } = this.config.feishu;
-        const params = new URLSearchParams({
+        // 缓存中没有token，请求新的租户token
+        Logger.info('缓存中没有租户token，请求新的租户访问令牌');
+        try {
+            const requestData = {
+                app_id: appId,
+                app_secret: appSecret,
+            };
+            const url = 'https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal';
+            const headers = { 'Content-Type': 'application/json' };
+            Logger.debug('请求租户访问令牌:', url, requestData);
+            const response = await axios.post(url, requestData, { headers });
+            const data = response.data;
+            if (data.code !== 0) {
+                throw new Error(`获取租户访问令牌失败：${data.msg || '未知错误'} (错误码: ${data.code})`);
+            }
+            if (!data.tenant_access_token) {
+                throw new Error('获取租户访问令牌失败：响应中没有token');
+            }
+            // 计算绝对过期时间戳
+            const expire_at = Math.floor(Date.now() / 1000) + (data.expire || 0);
+            const tokenInfo = {
+                app_access_token: data.tenant_access_token,
+                expires_at: expire_at
+            };
+            // 缓存租户token
+            tokenCacheManager.cacheTenantToken(clientKey, tokenInfo, data.expire);
+            Logger.info('租户访问令牌获取并缓存成功');
+            return data.tenant_access_token;
+        }
+        catch (error) {
+            Logger.error('获取租户访问令牌失败:', error);
+            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,
-            token_type: authType
+            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 url = `${tokenEndpoint}?${params.toString()}`;
-        const response = await axios.get(url);
-        const tokenResult = response.data?.data;
-        if (tokenResult && tokenResult.access_token) {
-            Logger.debug('使用Http的访问令牌');
-            CacheManager.getInstance().cacheToken(tokenResult.access_token, tokenResult.expires_in);
-            return tokenResult.access_token;
+        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;
         }
-        if (tokenResult && tokenResult.needAuth && tokenResult.url) {
-            throw new Error(`请在浏览器打开以下链接进行授权：\n\n[点击授权](${tokenResult.url})`);
+        else {
+            Logger.warn('刷新用户访问令牌失败:', data);
+            throw new Error('刷新用户访问令牌失败');
         }
-        throw new Error('无法获取有效的access_token');
     }
     /**
      * 创建飞书文档
@@ -878,7 +999,7 @@ export class FeishuApiService extends BaseApiService {
     async searchDocuments(searchKey, count = 50) {
         try {
             Logger.info(`开始搜索文档，关键字: ${searchKey}`);
-            const endpoint = `//suite/docs-api/search/object`;
+            const endpoint = `/suite/docs-api/search/object`;
             let offset = 0;
             let allResults = [];
             let hasMore = true;

package/dist/services/feishuAuthService.js

@@ -1,6 +1,5 @@
 import axios from 'axios';
 import { Config } from '../utils/config.js';
-import { CacheManager } from '../utils/cache.js';
 import { Logger } from '../utils/logger.js';
 export class AuthService {
     constructor() {
@@ -10,129 +9,6 @@ export class AuthService {
             writable: true,
             value: Config.getInstance()
         });
-        Object.defineProperty(this, "cache", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: CacheManager.getInstance()
-        });
-    }
-    // 获取token主入口
-    async getToken(options) {
-        Logger.warn('[AuthService] getToken called', options);
-        const config = this.config.feishu;
-        const client_id = options?.client_id || config.appId;
-        const client_secret = options?.client_secret || config.appSecret;
-        const authType = options?.authType || config.authType;
-        const clientKey = await CacheManager.getClientKey(client_id, client_secret);
-        Logger.warn('[AuthService] getToken resolved clientKey', clientKey, 'authType', authType);
-        if (authType === 'tenant') {
-            return this.getTenantToken(client_id, client_secret, clientKey);
-        }
-        else {
-            let tokenObj = this.cache.getUserToken(clientKey);
-            const now = Date.now() / 1000;
-            if (!tokenObj || tokenObj.refresh_token_expires_at < now) {
-                Logger.warn('[AuthService] No user token in cache, need user auth', clientKey);
-                // 返回授权链接
-                const redirect_uri = encodeURIComponent(`http://localhost:${this.config.server.port}/callback`);
-                const scope = encodeURIComponent('base:app:read bitable:app bitable:app:readonly board:whiteboard:node:read 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 = clientKey;
-                const url = `https://accounts.feishu.cn/open-apis/authen/v1/authorize?client_id=${client_id}&redirect_uri=${redirect_uri}&scope=${scope}&state=${state}`;
-                return { needAuth: true, url };
-            }
-            Logger.debug('[AuthService] User token found in cache', tokenObj);
-            if (tokenObj.expires_at && tokenObj.expires_at < now) {
-                Logger.warn('[AuthService] User token expired, try refresh', tokenObj);
-                if (tokenObj.refresh_token) {
-                    tokenObj = await this.refreshUserToken(tokenObj.refresh_token, clientKey, client_id, client_secret);
-                }
-                else {
-                    Logger.warn('[AuthService] No refresh_token, clear cache and require re-auth', clientKey);
-                    this.cache.cacheUserToken(clientKey, null, 0);
-                    return { needAuth: true, url: '请重新授权' };
-                }
-            }
-            Logger.warn('[AuthService] Return user access_token', tokenObj.access_token);
-            // 计算剩余有效期（秒）
-            const expires_in = tokenObj.expires_at ? Math.max(tokenObj.expires_at - now, 0) : undefined;
-            return { access_token: tokenObj.access_token, expires_in, ...tokenObj };
-        }
-    }
-    // 获取tenant_access_token
-    async getTenantToken(client_id, client_secret, clientKey) {
-        Logger.warn('[AuthService] getTenantToken called', { client_id, clientKey });
-        // 尝试从缓存获取
-        const cacheKey = clientKey;
-        const cachedTokenObj = this.cache.getTenantToken(cacheKey);
-        if (cachedTokenObj) {
-            Logger.warn('[AuthService] Tenant token cache hit', cacheKey);
-            const { tenant_access_token, expire_at } = cachedTokenObj;
-            const now = Math.floor(Date.now() / 1000);
-            const expires_in = expire_at ? Math.max(expire_at - now, 0) : undefined;
-            return { access_token: tenant_access_token, expires_in };
-        }
-        try {
-            const requestData = {
-                app_id: client_id,
-                app_secret: client_secret,
-            };
-            const url = 'https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal';
-            const headers = { 'Content-Type': 'application/json' };
-            Logger.debug('[AuthService] Requesting tenant_access_token', url, requestData);
-            const response = await axios.post(url, requestData, { headers });
-            const data = response.data;
-            Logger.debug('[AuthService] tenant_access_token response', data);
-            if (!data || typeof data !== 'object') {
-                Logger.error('[AuthService] tenant_access_token invalid response', data);
-                throw new Error('获取飞书访问令牌失败：响应格式无效');
-            }
-            if (data.code !== 0) {
-                Logger.error('[AuthService] tenant_access_token error', data);
-                throw new Error(`获取飞书访问令牌失败：${data.msg || '未知错误'} (错误码: ${data.code})`);
-            }
-            if (!data.tenant_access_token) {
-                Logger.error('[AuthService] tenant_access_token missing in response', data);
-                throw new Error('获取飞书访问令牌失败：响应中没有token');
-            }
-            // 计算绝对过期时间戳
-            const expire_at = Math.floor(Date.now() / 1000) + (data.expire || 0);
-            const tokenObj = {
-                tenant_access_token: data.tenant_access_token,
-                expire_at
-            };
-            this.cache.cacheTenantToken(cacheKey, tokenObj, data.expire);
-            Logger.warn('[AuthService] tenant_access_token cached', cacheKey);
-            // 返回token对象和expires_in
-            return { access_token: data.tenant_access_token, expires_in: data.expire, expire_at };
-        }
-        catch (error) {
-            Logger.error('[AuthService] getTenantToken error', error);
-            throw new Error('获取飞书访问令牌失败: ' + (error instanceof Error ? error.message : String(error)));
-        }
-    }
-    // 刷新user_access_token
-    async refreshUserToken(refresh_token, clientKey, client_id, client_secret) {
-        Logger.warn('[AuthService] refreshUserToken called', { clientKey });
-        const body = {
-            grant_type: 'refresh_token',
-            client_id,
-            client_secret,
-            refresh_token
-        };
-        Logger.debug('[AuthService] refreshUserToken request', 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;
-        Logger.debug('[AuthService] refreshUserToken response', data);
-        if (data && data.access_token && data.expires_in) {
-            data.expires_in = Math.floor(Date.now() / 1000) + data.expires_in;
-            this.cache.cacheUserToken(clientKey, data, data.expires_in);
-            Logger.warn('[AuthService] Refreshed user_access_token cached', clientKey);
-        }
-        else {
-            Logger.warn('[AuthService] refreshUserToken failed', data);
-        }
-        return data;
     }
     // 获取用户信息
     async getUserInfo(access_token) {
@@ -150,7 +26,6 @@ export class AuthService {
     // 通过授权码换取user_access_token
     async getUserTokenByCode({ client_id, client_secret, code, redirect_uri, code_verifier }) {
         Logger.warn('[AuthService] getUserTokenByCode called', { client_id, code, redirect_uri });
-        const clientKey = await CacheManager.getClientKey(client_id, client_secret);
         const body = {
             grant_type: 'authorization_code',
             client_id,
@@ -168,18 +43,6 @@ export class AuthService {
         });
         const data = await response.json();
         Logger.debug('[AuthService] getUserTokenByCode response', data);
-        // 缓存user_access_token
-        if (data && data.access_token && data.expires_in) {
-            data.expires_at = Math.floor(Date.now() / 1000) + data.expires_in;
-            data.refresh_token_expires_at = Math.floor(Date.now() / 1000) + data.refresh_token_expires_in;
-            // 缓存时间应为 refresh_token 的有效期，防止缓存被提前清理
-            const refreshTtl = data.refresh_expires_in || 3600 * 24 * 365; // 默认1年
-            this.cache.cacheUserToken(clientKey, data, refreshTtl);
-            Logger.warn('[AuthService] user_access_token cached', clientKey, 'refreshTtl', refreshTtl);
-        }
-        else {
-            Logger.warn('[AuthService] getUserTokenByCode failed', data);
-        }
         return data;
     }
 }

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';