feishu-mcp 0.2.0 → 0.2.2

package/README.md

@@ -89,6 +89,7 @@
 - **版本更新通知**：在发布新版本时，及时向用户提供相关提示与说明。 
 - ~~**stdio模式user认证问题**：修复stdio模式下飞书user认证失败问题~~ 0.1.9 ✅
 - ~~**权限检查功能可配置化**：将权限检查功能作为可配置选项，支持通过环境变量 `FEISHU_SCOPE_VALIDATION` 或命令行参数 `--feishu-scope-validation` 控制，默认启用，满足不同用户的使用场景~~ 0.2.0 ✅
+- ~~**优化缓存目录:把token等缓存保存到系统级的配置目录~~ 0.2.2 ✅ 感谢 [Molunerfinn](https://github.com/Molunerfinn)、[leeeezx](https://github.com/leeeezx)、[Master-cai](https://github.com/Master-cai) 三位朋友的建议及代码贡献
 ---
 
 ## 🔧 飞书配置教程
@@ -160,6 +161,7 @@ npx feishu-mcp@latest --feishu-app-id=<你的飞书应用ID> --feishu-app-secret
 | `PORT` | ❌ | 服务器端口                                                              | `3333` |
 | `FEISHU_AUTH_TYPE` | ❌ | 认证凭证类型，使用 `user`（用户级,使用时是用户的身份操作飞书文档，需OAuth授权），使用 `tenant`（应用级，默认） | `tenant` |
 | `FEISHU_SCOPE_VALIDATION` | ❌ | 是否启用权限检查，设置为 `false` 可关闭权限检查（适用于仅使用部分功能的场景） | `true` |
+| `FEISHU_USER_KEY` | ❌ | `stdio` 模式的用户标识，可通过命令行参数 `--user-key` 覆盖 | `stdio` |
 
 ### 配置文件方式（适用于 Cursor、Cline 等）
 
@@ -168,11 +170,12 @@ npx feishu-mcp@latest --feishu-app-id=<你的飞书应用ID> --feishu-app-secret
   "mcpServers": {
     "feishu-mcp": {
       "command": "npx",
-      "args": ["-y", "feishu@latest", "--stdio"],
+      "args": ["-y", "feishu-mcp@latest", "--stdio"],
       "env": {
         "FEISHU_APP_ID": "<你的飞书应用ID>",
         "FEISHU_APP_SECRET": "<你的飞书应用密钥>",
-        "FEISHU_AUTH_TYPE": "<tenant/user>"
+        "FEISHU_AUTH_TYPE": "<tenant/user>",
+        "FEISHU_USER_KEY": "<你的用户标识>"
       }
     },
     "feishu_local": {

package/dist/mcp/feishuMcp.js

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

package/dist/services/baseService.js

@@ -70,8 +70,8 @@ export class BaseApiService {
         let baseUrl;
         if (this.isStdioMode()) {
             // stdio 模式下直接使用默认值
-            userKey = 'stdio';
             const config = Config.getInstance();
+            userKey = config.feishu.userKey || 'stdio';
             baseUrl = `http://localhost:${config.server.port}`;
         }
         else {
@@ -316,7 +316,7 @@ export class BaseApiService {
             // refresh_token已过期或不存在，直接清除缓存
             Logger.warn('用户模式：refresh_token已过期，清除用户token缓存');
             tokenCacheManager.removeUserToken(clientKey);
-            return this.handleAuthFailure(true, clientKey, baseUrl, userKey);
+            return this.handleAuthFailure(false, clientKey, baseUrl, userKey);
         }
     }
     /**

package/dist/utils/auth/legacyCacheMigration.js

@@ -0,0 +1,56 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { Logger } from '../logger.js';
+/** 旧版缓存文件名（de29caca 之前位于 process.cwd()） */
+const LEGACY_FILES = [
+    'user_token_cache.json',
+    'tenant_token_cache.json',
+    'scope_version_cache.json',
+];
+const MIGRATION_MARKER = '.legacy_cache_migrated';
+/**
+ * 将旧路径（process.cwd()）下的 token 缓存迁移到新目录：复制内容到新文件后删除原文件。
+ * 通过标记文件保证只执行一次；若新目录与 cwd 相同则跳过。
+ */
+export function migrateLegacyTokenCacheIfNeeded(newCacheDir, newPaths) {
+    const markerPath = path.join(newCacheDir, MIGRATION_MARKER);
+    if (fs.existsSync(markerPath)) {
+        Logger.debug('Token 缓存已迁移过，跳过本次迁移');
+        return;
+    }
+    const legacyDir = process.cwd();
+    if (path.resolve(legacyDir) === path.resolve(newCacheDir)) {
+        Logger.debug('缓存目录与工作目录相同，无需迁移');
+        return;
+    }
+    Logger.info(`检查旧路径缓存并迁移: ${legacyDir} -> ${newCacheDir}`);
+    let migratedCount = 0;
+    for (let i = 0; i < LEGACY_FILES.length; i++) {
+        const oldPath = path.join(legacyDir, LEGACY_FILES[i]);
+        const newPath = newPaths[i];
+        if (!fs.existsSync(oldPath)) {
+            Logger.debug(`旧缓存不存在，跳过: ${LEGACY_FILES[i]}`);
+            continue;
+        }
+        try {
+            const content = fs.readFileSync(oldPath, 'utf-8');
+            fs.writeFileSync(newPath, content, 'utf-8');
+            fs.unlinkSync(oldPath);
+            migratedCount++;
+            Logger.info(`已迁移旧缓存并删除原文件: ${LEGACY_FILES[i]} -> ${newPath}`);
+        }
+        catch (error) {
+            Logger.warn(`迁移旧缓存失败，跳过 ${LEGACY_FILES[i]}`, error);
+        }
+    }
+    if (migratedCount > 0) {
+        Logger.info(`Token 缓存迁移完成，共 ${migratedCount} 个文件`);
+    }
+    try {
+        fs.writeFileSync(markerPath, new Date().toISOString(), 'utf-8');
+        Logger.debug(`迁移标记已写入: ${markerPath}`);
+    }
+    catch (error) {
+        Logger.warn('写入迁移标记失败', error);
+    }
+}

package/dist/utils/auth/tokenCacheManager.js

@@ -1,6 +1,8 @@
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 import { Logger } from '../logger.js';
+import { migrateLegacyTokenCacheIfNeeded } from './legacyCacheMigration.js';
 /**
  * Token缓存管理器
  * 专门处理用户token和租户token的缓存管理
@@ -34,13 +36,46 @@ export class TokenCacheManager {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "cacheDir", {
+            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.scopeVersionCacheFile = path.resolve(process.cwd(), 'scope_version_cache.json');
+        this.cacheDir = this.resolveCacheDir();
+        this.userTokenCacheFile = path.join(this.cacheDir, 'user_token_cache.json');
+        this.tenantTokenCacheFile = path.join(this.cacheDir, 'tenant_token_cache.json');
+        this.scopeVersionCacheFile = path.join(this.cacheDir, 'scope_version_cache.json');
+        Logger.info(`Token缓存目录: ${this.cacheDir}`);
+        migrateLegacyTokenCacheIfNeeded(this.cacheDir, [
+            this.userTokenCacheFile,
+            this.tenantTokenCacheFile,
+            this.scopeVersionCacheFile,
+        ]);
         this.loadTokenCaches();
         this.startCacheCleanupTimer();
     }
+    /**
+     * 解析并确保可写的缓存目录
+     */
+    resolveCacheDir() {
+        const candidates = [
+            path.join(os.homedir(), '.cache', 'feishu-mcp'),
+            path.join(os.homedir(), '.feishu-mcp'),
+        ];
+        for (const dir of candidates) {
+            try {
+                fs.mkdirSync(dir, { recursive: true });
+                fs.accessSync(dir, fs.constants.R_OK | fs.constants.W_OK);
+                return dir;
+            }
+            catch (error) {
+                Logger.warn(`缓存目录不可用，尝试下一个: ${dir}`, error);
+            }
+        }
+        throw new Error('无法找到可读写的缓存目录');
+    }
     /**
      * 获取TokenCacheManager实例
      */

package/dist/utils/config.js

@@ -123,6 +123,10 @@ export class Config {
             'feishu-scope-validation': {
                 type: 'boolean',
                 description: '是否启用权限检查，默认 true'
+            },
+            'user-key': {
+                type: 'string',
+                description: 'stdio 模式下的用户标识，默认 stdio'
             }
         })
             .help()
@@ -166,6 +170,7 @@ export class Config {
             authType: 'tenant', // 默认
             tokenEndpoint: `http://127.0.0.1:${serverConfig.port}/getToken`, // 默认动态端口
             enableScopeValidation: true, // 默认启用权限检查
+            userKey: 'stdio',
         };
         // 处理App ID
         if (argv['feishu-app-id']) {
@@ -233,6 +238,18 @@ export class Config {
         else {
             this.configSources['feishu.enableScopeValidation'] = ConfigSource.DEFAULT;
         }
+        // 处理 userKey（stdio 模式使用）
+        if (argv['user-key']) {
+            feishuConfig.userKey = argv['user-key'];
+            this.configSources['feishu.userKey'] = ConfigSource.CLI;
+        }
+        else if (process.env.FEISHU_USER_KEY) {
+            feishuConfig.userKey = process.env.FEISHU_USER_KEY;
+            this.configSources['feishu.userKey'] = ConfigSource.ENV;
+        }
+        else {
+            this.configSources['feishu.userKey'] = ConfigSource.DEFAULT;
+        }
         return feishuConfig;
     }
     /**
@@ -367,6 +384,7 @@ export class Config {
         Logger.info(`- API URL: ${this.feishu.baseUrl} (来源: ${this.configSources['feishu.baseUrl']})`);
         Logger.info(`- 认证类型: ${this.feishu.authType} (来源: ${this.configSources['feishu.authType']})`);
         Logger.info(`- 启用权限检查: ${this.feishu.enableScopeValidation} (来源: ${this.configSources['feishu.enableScopeValidation']})`);
+        Logger.info(`- User Key: ${this.feishu.userKey} (来源: ${this.configSources['feishu.userKey']})`);
         Logger.info('日志配置:');
         Logger.info(`- 日志级别: ${LogLevel[this.log.level]} (来源: ${this.configSources['log.level']})`);
         Logger.info(`- 显示时间戳: ${this.log.showTimestamp} (来源: ${this.configSources['log.showTimestamp']})`);

package/package.json

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