feishu-mcp 0.0.6 → 0.0.7

package/dist/utils/cache.js

@@ -0,0 +1,221 @@
+import { Config } from './config.js';
+import { Logger } from './logger.js';
+/**
+ * 缓存管理器类
+ * 提供内存缓存功能，支持TTL和最大容量限制
+ * 只用于缓存用户token和wiki转docid结果
+ */
+export class CacheManager {
+    /**
+     * 私有构造函数，用于单例模式
+     */
+    constructor() {
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.cache = new Map();
+        this.config = Config.getInstance();
+        // 定期清理过期缓存
+        setInterval(() => {
+            this.cleanExpiredCache();
+        }, 60000); // 每分钟清理一次过期缓存
+    }
+    /**
+     * 获取缓存管理器实例
+     * @returns 缓存管理器实例
+     */
+    static getInstance() {
+        if (!CacheManager.instance) {
+            CacheManager.instance = new CacheManager();
+        }
+        return CacheManager.instance;
+    }
+    /**
+     * 设置缓存
+     * @param key 缓存键
+     * @param data 缓存数据
+     * @param ttl 缓存生存时间（秒），默认使用配置中的TTL
+     * @returns 是否成功设置缓存
+     */
+    set(key, data, ttl) {
+        if (!this.config.cache.enabled) {
+            return false;
+        }
+        // 如果缓存已达到最大容量，清理最早的条目
+        if (this.cache.size >= this.config.cache.maxSize) {
+            this.cleanOldestCache();
+        }
+        const now = Date.now();
+        const actualTtl = ttl || this.config.cache.ttl;
+        this.cache.set(key, {
+            data,
+            timestamp: now,
+            expiresAt: now + (actualTtl * 1000)
+        });
+        Logger.debug(`缓存设置: ${key} (TTL: ${actualTtl}秒)`);
+        return true;
+    }
+    /**
+     * 获取缓存
+     * @param key 缓存键
+     * @returns 缓存数据，如果未找到或已过期则返回null
+     */
+    get(key) {
+        if (!this.config.cache.enabled) {
+            return null;
+        }
+        const cacheItem = this.cache.get(key);
+        if (!cacheItem) {
+            Logger.debug(`缓存未命中: ${key}`);
+            return null;
+        }
+        // 检查是否过期
+        if (Date.now() > cacheItem.expiresAt) {
+            Logger.debug(`缓存已过期: ${key}`);
+            this.cache.delete(key);
+            return null;
+        }
+        Logger.debug(`缓存命中: ${key}`);
+        return cacheItem.data;
+    }
+    /**
+     * 删除缓存
+     * @param key 缓存键
+     * @returns 是否成功删除
+     */
+    delete(key) {
+        if (!this.config.cache.enabled) {
+            return false;
+        }
+        const result = this.cache.delete(key);
+        if (result) {
+            Logger.debug(`缓存删除: ${key}`);
+        }
+        return result;
+    }
+    /**
+     * 清空所有缓存
+     */
+    clear() {
+        if (!this.config.cache.enabled) {
+            return;
+        }
+        const size = this.cache.size;
+        this.cache.clear();
+        Logger.debug(`清空全部缓存，删除了 ${size} 条记录`);
+    }
+    /**
+     * 根据前缀清除缓存
+     * @param prefix 缓存键前缀
+     * @returns 清除的缓存数量
+     */
+    clearByPrefix(prefix) {
+        if (!this.config.cache.enabled) {
+            return 0;
+        }
+        let count = 0;
+        for (const key of this.cache.keys()) {
+            if (key.startsWith(prefix)) {
+                this.cache.delete(key);
+                count++;
+            }
+        }
+        if (count > 0) {
+            Logger.debug(`按前缀清除缓存: ${prefix}, 删除了 ${count} 条记录`);
+        }
+        return count;
+    }
+    /**
+     * 清理过期缓存
+     * @returns 清理的缓存数量
+     */
+    cleanExpiredCache() {
+        if (!this.config.cache.enabled) {
+            return 0;
+        }
+        const now = Date.now();
+        let count = 0;
+        for (const [key, item] of this.cache.entries()) {
+            if (now > item.expiresAt) {
+                this.cache.delete(key);
+                count++;
+            }
+        }
+        if (count > 0) {
+            Logger.debug(`清理过期缓存，删除了 ${count} 条记录`);
+        }
+        return count;
+    }
+    /**
+     * 清理最旧的缓存
+     * @param count 要清理的条目数，默认为1
+     */
+    cleanOldestCache(count = 1) {
+        if (!this.config.cache.enabled || this.cache.size === 0) {
+            return;
+        }
+        // 按时间戳排序
+        const entries = Array.from(this.cache.entries())
+            .sort((a, b) => a[1].timestamp - b[1].timestamp);
+        // 删除最早的几条记录
+        const toDelete = Math.min(count, entries.length);
+        for (let i = 0; i < toDelete; i++) {
+            this.cache.delete(entries[i][0]);
+        }
+        Logger.debug(`清理最旧缓存，删除了 ${toDelete} 条记录`);
+    }
+    /**
+     * 获取缓存统计信息
+     * @returns 缓存统计信息对象
+     */
+    getStats() {
+        return {
+            size: this.cache.size,
+            enabled: this.config.cache.enabled,
+            maxSize: this.config.cache.maxSize,
+            ttl: this.config.cache.ttl
+        };
+    }
+    /**
+     * 缓存访问令牌
+     * @param token 访问令牌
+     * @param expiresInSeconds 过期时间（秒）
+     * @returns 是否成功设置缓存
+     */
+    cacheToken(token, expiresInSeconds) {
+        return this.set('access_token', token, expiresInSeconds);
+    }
+    /**
+     * 获取缓存的访问令牌
+     * @returns 访问令牌，如果未找到或已过期则返回null
+     */
+    getToken() {
+        return this.get('access_token');
+    }
+    /**
+     * 缓存Wiki到文档ID的转换结果
+     * @param wikiToken Wiki Token
+     * @param documentId 文档ID
+     * @returns 是否成功设置缓存
+     */
+    cacheWikiToDocId(wikiToken, documentId) {
+        return this.set(`wiki:${wikiToken}`, documentId);
+    }
+    /**
+     * 获取缓存的Wiki转换结果
+     * @param wikiToken Wiki Token
+     * @returns 文档ID，如果未找到或已过期则返回null
+     */
+    getWikiToDocId(wikiToken) {
+        return this.get(`wiki:${wikiToken}`);
+    }
+}

package/dist/utils/config.js

@@ -0,0 +1,363 @@
+import { config as loadDotEnv } from 'dotenv';
+import { hideBin } from 'yargs/helpers';
+import yargs from 'yargs';
+import { Logger, LogLevel } from './logger.js';
+/**
+ * 配置来源枚举
+ */
+export var ConfigSource;
+(function (ConfigSource) {
+    ConfigSource["DEFAULT"] = "default";
+    ConfigSource["ENV"] = "env";
+    ConfigSource["CLI"] = "cli";
+    ConfigSource["FILE"] = "file";
+})(ConfigSource || (ConfigSource = {}));
+/**
+ * 应用配置管理类
+ * 统一管理所有配置，支持环境变量、命令行参数和默认值
+ */
+export class Config {
+    /**
+     * 私有构造函数，用于单例模式
+     */
+    constructor() {
+        Object.defineProperty(this, "server", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "feishu", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "log", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "configSources", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // 确保在任何配置读取前加载.env文件
+        loadDotEnv();
+        // 解析命令行参数
+        const argv = this.parseCommandLineArgs();
+        // 初始化配置来源记录
+        this.configSources = {};
+        // 配置服务器
+        this.server = this.initServerConfig(argv);
+        // 配置飞书
+        this.feishu = this.initFeishuConfig(argv);
+        // 配置日志
+        this.log = this.initLogConfig(argv);
+        // 配置缓存
+        this.cache = this.initCacheConfig(argv);
+    }
+    /**
+     * 获取配置单例
+     * @returns 配置实例
+     */
+    static getInstance() {
+        if (!Config.instance) {
+            Config.instance = new Config();
+        }
+        return Config.instance;
+    }
+    /**
+     * 解析命令行参数
+     * @returns 解析后的参数对象
+     */
+    parseCommandLineArgs() {
+        return yargs(hideBin(process.argv))
+            .options({
+            port: {
+                type: 'number',
+                description: '服务器监听端口'
+            },
+            'log-level': {
+                type: 'string',
+                description: '日志级别 (debug, info, log, warn, error, none)'
+            },
+            'feishu-app-id': {
+                type: 'string',
+                description: '飞书应用ID'
+            },
+            'feishu-app-secret': {
+                type: 'string',
+                description: '飞书应用密钥'
+            },
+            'feishu-base-url': {
+                type: 'string',
+                description: '飞书API基础URL'
+            },
+            'cache-enabled': {
+                type: 'boolean',
+                description: '是否启用缓存'
+            },
+            'cache-ttl': {
+                type: 'number',
+                description: '缓存生存时间（秒）'
+            }
+        })
+            .help()
+            .parseSync();
+    }
+    /**
+     * 初始化服务器配置
+     * @param argv 命令行参数
+     * @returns 服务器配置
+     */
+    initServerConfig(argv) {
+        const serverConfig = {
+            port: 3333,
+        };
+        // 处理PORT
+        if (argv.port) {
+            serverConfig.port = argv.port;
+            this.configSources['server.port'] = ConfigSource.CLI;
+        }
+        else if (process.env.PORT) {
+            serverConfig.port = parseInt(process.env.PORT, 10);
+            this.configSources['server.port'] = ConfigSource.ENV;
+        }
+        else {
+            this.configSources['server.port'] = ConfigSource.DEFAULT;
+        }
+        return serverConfig;
+    }
+    /**
+     * 初始化飞书配置
+     * @param argv 命令行参数
+     * @returns 飞书配置
+     */
+    initFeishuConfig(argv) {
+        const feishuConfig = {
+            appId: '',
+            appSecret: '',
+            baseUrl: 'https://open.feishu.cn/open-apis',
+            tokenLifetime: 7200000 // 2小时，单位：毫秒
+        };
+        // 处理App ID
+        if (argv['feishu-app-id']) {
+            feishuConfig.appId = argv['feishu-app-id'];
+            this.configSources['feishu.appId'] = ConfigSource.CLI;
+        }
+        else if (process.env.FEISHU_APP_ID) {
+            feishuConfig.appId = process.env.FEISHU_APP_ID;
+            this.configSources['feishu.appId'] = ConfigSource.ENV;
+        }
+        // 处理App Secret
+        if (argv['feishu-app-secret']) {
+            feishuConfig.appSecret = argv['feishu-app-secret'];
+            this.configSources['feishu.appSecret'] = ConfigSource.CLI;
+        }
+        else if (process.env.FEISHU_APP_SECRET) {
+            feishuConfig.appSecret = process.env.FEISHU_APP_SECRET;
+            this.configSources['feishu.appSecret'] = ConfigSource.ENV;
+        }
+        // 处理Base URL
+        if (argv['feishu-base-url']) {
+            feishuConfig.baseUrl = argv['feishu-base-url'];
+            this.configSources['feishu.baseUrl'] = ConfigSource.CLI;
+        }
+        else if (process.env.FEISHU_BASE_URL) {
+            feishuConfig.baseUrl = process.env.FEISHU_BASE_URL;
+            this.configSources['feishu.baseUrl'] = ConfigSource.ENV;
+        }
+        else {
+            this.configSources['feishu.baseUrl'] = ConfigSource.DEFAULT;
+        }
+        // 处理token生命周期
+        if (process.env.FEISHU_TOKEN_LIFETIME) {
+            feishuConfig.tokenLifetime = parseInt(process.env.FEISHU_TOKEN_LIFETIME, 10) * 1000;
+            this.configSources['feishu.tokenLifetime'] = ConfigSource.ENV;
+        }
+        else {
+            this.configSources['feishu.tokenLifetime'] = ConfigSource.DEFAULT;
+        }
+        return feishuConfig;
+    }
+    /**
+     * 初始化日志配置
+     * @param argv 命令行参数
+     * @returns 日志配置
+     */
+    initLogConfig(argv) {
+        const logConfig = {
+            level: LogLevel.INFO,
+            showTimestamp: true,
+            showLevel: true,
+            timestampFormat: 'yyyy-MM-dd HH:mm:ss.SSS'
+        };
+        // 处理日志级别
+        if (argv['log-level']) {
+            logConfig.level = this.getLogLevelFromString(argv['log-level']);
+            this.configSources['log.level'] = ConfigSource.CLI;
+        }
+        else if (process.env.LOG_LEVEL) {
+            logConfig.level = this.getLogLevelFromString(process.env.LOG_LEVEL);
+            this.configSources['log.level'] = ConfigSource.ENV;
+        }
+        else {
+            this.configSources['log.level'] = ConfigSource.DEFAULT;
+        }
+        // 处理时间戳显示
+        if (process.env.LOG_SHOW_TIMESTAMP) {
+            logConfig.showTimestamp = process.env.LOG_SHOW_TIMESTAMP.toLowerCase() === 'true';
+            this.configSources['log.showTimestamp'] = ConfigSource.ENV;
+        }
+        else {
+            this.configSources['log.showTimestamp'] = ConfigSource.DEFAULT;
+        }
+        // 处理级别显示
+        if (process.env.LOG_SHOW_LEVEL) {
+            logConfig.showLevel = process.env.LOG_SHOW_LEVEL.toLowerCase() === 'true';
+            this.configSources['log.showLevel'] = ConfigSource.ENV;
+        }
+        else {
+            this.configSources['log.showLevel'] = ConfigSource.DEFAULT;
+        }
+        // 处理时间戳格式
+        if (process.env.LOG_TIMESTAMP_FORMAT) {
+            logConfig.timestampFormat = process.env.LOG_TIMESTAMP_FORMAT;
+            this.configSources['log.timestampFormat'] = ConfigSource.ENV;
+        }
+        else {
+            this.configSources['log.timestampFormat'] = ConfigSource.DEFAULT;
+        }
+        return logConfig;
+    }
+    /**
+     * 初始化缓存配置
+     * @param argv 命令行参数
+     * @returns 缓存配置
+     */
+    initCacheConfig(argv) {
+        const cacheConfig = {
+            enabled: true,
+            ttl: 300, // 5分钟，单位：秒
+            maxSize: 100
+        };
+        // 处理缓存启用
+        if (argv['cache-enabled'] !== undefined) {
+            cacheConfig.enabled = argv['cache-enabled'];
+            this.configSources['cache.enabled'] = ConfigSource.CLI;
+        }
+        else if (process.env.CACHE_ENABLED) {
+            cacheConfig.enabled = process.env.CACHE_ENABLED.toLowerCase() === 'true';
+            this.configSources['cache.enabled'] = ConfigSource.ENV;
+        }
+        else {
+            this.configSources['cache.enabled'] = ConfigSource.DEFAULT;
+        }
+        // 处理TTL
+        if (argv['cache-ttl']) {
+            cacheConfig.ttl = argv['cache-ttl'];
+            this.configSources['cache.ttl'] = ConfigSource.CLI;
+        }
+        else if (process.env.CACHE_TTL) {
+            cacheConfig.ttl = parseInt(process.env.CACHE_TTL, 10);
+            this.configSources['cache.ttl'] = ConfigSource.ENV;
+        }
+        else {
+            this.configSources['cache.ttl'] = ConfigSource.DEFAULT;
+        }
+        // 处理最大缓存大小
+        if (process.env.CACHE_MAX_SIZE) {
+            cacheConfig.maxSize = parseInt(process.env.CACHE_MAX_SIZE, 10);
+            this.configSources['cache.maxSize'] = ConfigSource.ENV;
+        }
+        else {
+            this.configSources['cache.maxSize'] = ConfigSource.DEFAULT;
+        }
+        return cacheConfig;
+    }
+    /**
+     * 从字符串获取日志级别
+     * @param levelStr 日志级别字符串
+     * @returns 日志级别枚举值
+     */
+    getLogLevelFromString(levelStr) {
+        switch (levelStr.toLowerCase()) {
+            case 'debug': return LogLevel.DEBUG;
+            case 'info': return LogLevel.INFO;
+            case 'log': return LogLevel.LOG;
+            case 'warn': return LogLevel.WARN;
+            case 'error': return LogLevel.ERROR;
+            case 'none': return LogLevel.NONE;
+            default: return LogLevel.INFO;
+        }
+    }
+    /**
+     * 打印当前配置信息
+     * @param isStdioMode 是否在stdio模式下
+     */
+    printConfig(isStdioMode = false) {
+        if (isStdioMode)
+            return;
+        Logger.info('当前配置:');
+        Logger.info('服务器配置:');
+        Logger.info(`- 端口: ${this.server.port} (来源: ${this.configSources['server.port']})`);
+        Logger.info('飞书配置:');
+        if (this.feishu.appId) {
+            Logger.info(`- App ID: ${this.maskApiKey(this.feishu.appId)} (来源: ${this.configSources['feishu.appId']})`);
+        }
+        if (this.feishu.appSecret) {
+            Logger.info(`- App Secret: ${this.maskApiKey(this.feishu.appSecret)} (来源: ${this.configSources['feishu.appSecret']})`);
+        }
+        Logger.info(`- API URL: ${this.feishu.baseUrl} (来源: ${this.configSources['feishu.baseUrl']})`);
+        Logger.info(`- Token生命周期: ${this.feishu.tokenLifetime / 1000}秒 (来源: ${this.configSources['feishu.tokenLifetime']})`);
+        Logger.info('日志配置:');
+        Logger.info(`- 日志级别: ${LogLevel[this.log.level]} (来源: ${this.configSources['log.level']})`);
+        Logger.info(`- 显示时间戳: ${this.log.showTimestamp} (来源: ${this.configSources['log.showTimestamp']})`);
+        Logger.info(`- 显示日志级别: ${this.log.showLevel} (来源: ${this.configSources['log.showLevel']})`);
+        Logger.info('缓存配置:');
+        Logger.info(`- 启用缓存: ${this.cache.enabled} (来源: ${this.configSources['cache.enabled']})`);
+        Logger.info(`- 缓存TTL: ${this.cache.ttl}秒 (来源: ${this.configSources['cache.ttl']})`);
+        Logger.info(`- 最大缓存条目: ${this.cache.maxSize} (来源: ${this.configSources['cache.maxSize']})`);
+    }
+    /**
+     * 掩盖API密钥
+     * @param key API密钥
+     * @returns 掩盖后的密钥字符串
+     */
+    maskApiKey(key) {
+        if (!key || key.length <= 4)
+            return '****';
+        return `${key.substring(0, 2)}****${key.substring(key.length - 2)}`;
+    }
+    /**
+     * 验证配置是否完整有效
+     * @returns 是否验证成功
+     */
+    validate() {
+        // 验证服务器配置
+        if (!this.server.port || this.server.port <= 0) {
+            Logger.error('无效的服务器端口配置');
+            return false;
+        }
+        // 验证飞书配置
+        if (!this.feishu.appId) {
+            Logger.error('缺少飞书应用ID，请通过环境变量FEISHU_APP_ID或命令行参数--feishu-app-id提供');
+            return false;
+        }
+        if (!this.feishu.appSecret) {
+            Logger.error('缺少飞书应用Secret，请通过环境变量FEISHU_APP_SECRET或命令行参数--feishu-app-secret提供');
+            return false;
+        }
+        return true;
+    }
+}

package/dist/utils/document.js

@@ -0,0 +1,74 @@
+/**
+ * 从URL或ID中提取飞书文档ID
+ * 支持多种格式:
+ * 1. 标准文档URL: https://xxx.feishu.cn/docs/xxx 或 https://xxx.feishu.cn/docx/xxx
+ * 2. API URL: https://open.feishu.cn/open-apis/docx/v1/documents/xxx
+ * 3. 直接ID: JcKbdlokYoPIe0xDzJ1cduRXnRf
+ *
+ * @param input 文档URL或ID
+ * @returns 提取的文档ID或null
+ */
+export function extractDocumentId(input) {
+    // 移除首尾空白
+    input = input.trim();
+    // 处理各种URL格式
+    const docxMatch = input.match(/\/docx\/([a-zA-Z0-9_-]+)/i);
+    const docsMatch = input.match(/\/docs\/([a-zA-Z0-9_-]+)/i);
+    const apiMatch = input.match(/\/documents\/([a-zA-Z0-9_-]+)/i);
+    const directIdMatch = input.match(/^([a-zA-Z0-9_-]{10,})$/); // 假设ID至少10个字符
+    // 按优先级返回匹配结果
+    const match = docxMatch || docsMatch || apiMatch || directIdMatch;
+    return match ? match[1] : null;
+}
+/**
+ * 从URL或Token中提取Wiki节点ID
+ * 支持多种格式:
+ * 1. Wiki URL: https://xxx.feishu.cn/wiki/xxx
+ * 2. 直接Token: xxx
+ *
+ * @param input Wiki URL或Token
+ * @returns 提取的Wiki Token或null
+ */
+export function extractWikiToken(input) {
+    // 移除首尾空白
+    input = input.trim();
+    // 处理Wiki URL格式
+    const wikiMatch = input.match(/\/wiki\/([a-zA-Z0-9_-]+)/i);
+    const directMatch = input.match(/^([a-zA-Z0-9_-]{10,})$/); // 假设Token至少10个字符
+    // 提取Token，如果存在查询参数，去掉它们
+    let token = wikiMatch ? wikiMatch[1] : (directMatch ? directMatch[1] : null);
+    if (token && token.includes('?')) {
+        token = token.split('?')[0];
+    }
+    return token;
+}
+/**
+ * 规范化文档ID
+ * 提取输入中的文档ID，如果提取失败则返回原输入
+ *
+ * @param input 文档URL或ID
+ * @returns 规范化的文档ID
+ * @throws 如果无法提取有效ID则抛出错误
+ */
+export function normalizeDocumentId(input) {
+    const id = extractDocumentId(input);
+    if (!id) {
+        throw new Error(`无法从 "${input}" 提取有效的文档ID`);
+    }
+    return id;
+}
+/**
+ * 规范化Wiki Token
+ * 提取输入中的Wiki Token，如果提取失败则返回原输入
+ *
+ * @param input Wiki URL或Token
+ * @returns 规范化的Wiki Token
+ * @throws 如果无法提取有效Token则抛出错误
+ */
+export function normalizeWikiToken(input) {
+    const token = extractWikiToken(input);
+    if (!token) {
+        throw new Error(`无法从 "${input}" 提取有效的Wiki Token`);
+    }
+    return token;
+}