feishu-mcp 0.0.5 → 0.0.7

package/dist/services/feishuApiService.js

@@ -0,0 +1,488 @@
+import { BaseApiService } from './baseService.js';
+import { Logger } from '../utils/logger.js';
+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 axios from 'axios';
+/**
+ * 飞书API服务类
+ * 提供飞书API的所有基础操作，包括认证、请求和缓存管理
+ */
+export class FeishuApiService extends BaseApiService {
+    /**
+     * 私有构造函数，用于单例模式
+     */
+    constructor() {
+        super();
+        Object.defineProperty(this, "cacheManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "blockFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.cacheManager = CacheManager.getInstance();
+        this.blockFactory = BlockFactory.getInstance();
+        this.config = Config.getInstance();
+    }
+    /**
+     * 获取飞书API服务实例
+     * @returns 飞书API服务实例
+     */
+    static getInstance() {
+        if (!FeishuApiService.instance) {
+            FeishuApiService.instance = new FeishuApiService();
+        }
+        return FeishuApiService.instance;
+    }
+    /**
+     * 获取API基础URL
+     * @returns API基础URL
+     */
+    getBaseUrl() {
+        return this.config.feishu.baseUrl;
+    }
+    /**
+     * 获取API认证端点
+     * @returns 认证端点URL
+     */
+    getAuthEndpoint() {
+        return '/auth/v3/tenant_access_token/internal';
+    }
+    /**
+     * 获取访问令牌
+     * @returns 访问令牌
+     * @throws 如果获取令牌失败则抛出错误
+     */
+    async getAccessToken() {
+        // 尝试从缓存获取
+        const cachedToken = this.cacheManager.getToken();
+        if (cachedToken) {
+            Logger.debug('使用缓存的访问令牌');
+            return cachedToken;
+        }
+        try {
+            const requestData = {
+                app_id: this.config.feishu.appId,
+                app_secret: this.config.feishu.appSecret,
+            };
+            Logger.info('开始获取新的飞书访问令牌...');
+            Logger.debug('认证请求参数:', requestData);
+            // 不使用通用的request方法，因为这个请求不需要认证
+            // 为了确保正确处理响应，我们直接使用axios
+            const url = `${this.getBaseUrl()}${this.getAuthEndpoint()}`;
+            const headers = { 'Content-Type': 'application/json' };
+            Logger.debug(`发送认证请求到: ${url}`);
+            const response = await axios.post(url, requestData, { headers });
+            Logger.debug('认证响应:', response.data);
+            if (!response.data || typeof response.data !== 'object') {
+                throw new Error('获取飞书访问令牌失败：响应格式无效');
+            }
+            // 检查错误码
+            if (response.data.code !== 0) {
+                throw new Error(`获取飞书访问令牌失败：${response.data.msg || '未知错误'} (错误码: ${response.data.code})`);
+            }
+            if (!response.data.tenant_access_token) {
+                throw new Error('获取飞书访问令牌失败：响应中没有token');
+            }
+            this.accessToken = response.data.tenant_access_token;
+            this.tokenExpireTime = Date.now() + Math.min(response.data.expire * 1000, this.config.feishu.tokenLifetime);
+            // 缓存令牌
+            this.cacheManager.cacheToken(this.accessToken, response.data.expire);
+            Logger.info(`成功获取新的飞书访问令牌，有效期: ${response.data.expire} 秒`);
+            return this.accessToken;
+        }
+        catch (error) {
+            Logger.error('获取访问令牌失败:', error);
+            this.handleApiError(error, '获取飞书访问令牌失败');
+        }
+    }
+    /**
+     * 创建飞书文档
+     * @param title 文档标题
+     * @param folderToken 文件夹Token
+     * @returns 创建的文档信息
+     */
+    async createDocument(title, folderToken) {
+        try {
+            const endpoint = '/docx/v1/documents';
+            const payload = {
+                title,
+                folder_token: folderToken
+            };
+            const response = await this.post(endpoint, payload);
+            return response;
+        }
+        catch (error) {
+            this.handleApiError(error, '创建飞书文档失败');
+        }
+    }
+    /**
+     * 获取文档信息
+     * @param documentId 文档ID或URL
+     * @returns 文档信息
+     */
+    async getDocumentInfo(documentId) {
+        try {
+            const normalizedDocId = ParamUtils.processDocumentId(documentId);
+            const endpoint = `/docx/v1/documents/${normalizedDocId}`;
+            const response = await this.get(endpoint);
+            return response;
+        }
+        catch (error) {
+            this.handleApiError(error, '获取文档信息失败');
+        }
+    }
+    /**
+     * 获取文档内容
+     * @param documentId 文档ID或URL
+     * @param lang 语言代码，0为中文，1为英文
+     * @returns 文档内容
+     */
+    async getDocumentContent(documentId, lang = 0) {
+        try {
+            const normalizedDocId = ParamUtils.processDocumentId(documentId);
+            const endpoint = `/docx/v1/documents/${normalizedDocId}/raw_content`;
+            const params = { lang };
+            const response = await this.get(endpoint, params);
+            return response.content;
+        }
+        catch (error) {
+            this.handleApiError(error, '获取文档内容失败');
+        }
+    }
+    /**
+     * 获取文档块结构
+     * @param documentId 文档ID或URL
+     * @param pageSize 每页块数量
+     * @returns 文档块数组
+     */
+    async getDocumentBlocks(documentId, pageSize = 500) {
+        try {
+            const normalizedDocId = ParamUtils.processDocumentId(documentId);
+            const endpoint = `/docx/v1/documents/${normalizedDocId}/blocks`;
+            let pageToken = '';
+            let allBlocks = [];
+            // 分页获取所有块
+            do {
+                const params = {
+                    page_size: pageSize,
+                    document_revision_id: -1
+                };
+                if (pageToken) {
+                    params.page_token = pageToken;
+                }
+                const response = await this.get(endpoint, params);
+                const blocks = response.items || [];
+                allBlocks = [...allBlocks, ...blocks];
+                pageToken = response.page_token;
+            } while (pageToken);
+            return allBlocks;
+        }
+        catch (error) {
+            this.handleApiError(error, '获取文档块结构失败');
+        }
+    }
+    /**
+     * 获取块内容
+     * @param documentId 文档ID或URL
+     * @param blockId 块ID
+     * @returns 块内容
+     */
+    async getBlockContent(documentId, blockId) {
+        try {
+            const normalizedDocId = ParamUtils.processDocumentId(documentId);
+            const safeBlockId = ParamUtils.processBlockId(blockId);
+            const endpoint = `/docx/v1/documents/${normalizedDocId}/blocks/${safeBlockId}`;
+            const params = { document_revision_id: -1 };
+            const response = await this.get(endpoint, params);
+            return response;
+        }
+        catch (error) {
+            this.handleApiError(error, '获取块内容失败');
+        }
+    }
+    /**
+     * 更新块文本内容
+     * @param documentId 文档ID或URL
+     * @param blockId 块ID
+     * @param textElements 文本元素数组
+     * @returns 更新结果
+     */
+    async updateBlockTextContent(documentId, blockId, textElements) {
+        try {
+            const docId = ParamUtils.processDocumentId(documentId);
+            const endpoint = `/docx/v1/documents/${docId}/blocks/${blockId}?document_revision_id=-1`;
+            Logger.debug(`准备请求API端点: ${endpoint}`);
+            const elements = textElements.map(item => ({
+                text_run: {
+                    content: item.text,
+                    text_element_style: item.style || {}
+                }
+            }));
+            const data = {
+                update_text_elements: {
+                    elements: elements
+                }
+            };
+            Logger.debug(`请求数据: ${JSON.stringify(data, null, 2)}`);
+            const response = await this.patch(endpoint, data);
+            return response;
+        }
+        catch (error) {
+            this.handleApiError(error, '更新块文本内容失败');
+            return null; // 永远不会执行到这里
+        }
+    }
+    /**
+     * 创建文档块
+     * @param documentId 文档ID或URL
+     * @param parentBlockId 父块ID
+     * @param blockContent 块内容
+     * @param index 插入位置索引
+     * @returns 创建结果
+     */
+    async createDocumentBlock(documentId, parentBlockId, blockContent, index = 0) {
+        try {
+            const normalizedDocId = ParamUtils.processDocumentId(documentId);
+            const endpoint = `/docx/v1/documents/${normalizedDocId}/blocks/${parentBlockId}/children?document_revision_id=-1`;
+            Logger.debug(`准备请求API端点: ${endpoint}`);
+            const payload = {
+                children: [blockContent],
+                index
+            };
+            Logger.debug(`请求数据: ${JSON.stringify(payload, null, 2)}`);
+            const response = await this.post(endpoint, payload);
+            return response;
+        }
+        catch (error) {
+            this.handleApiError(error, '创建文档块失败');
+            return null; // 永远不会执行到这里
+        }
+    }
+    /**
+     * 批量创建文档块
+     * @param documentId 文档ID或URL
+     * @param parentBlockId 父块ID
+     * @param blockContents 块内容数组
+     * @param index 起始插入位置索引
+     * @returns 创建结果
+     */
+    async createDocumentBlocks(documentId, parentBlockId, blockContents, index = 0) {
+        try {
+            const normalizedDocId = ParamUtils.processDocumentId(documentId);
+            const endpoint = `/docx/v1/documents/${normalizedDocId}/blocks/${parentBlockId}/children?document_revision_id=-1`;
+            Logger.debug(`准备请求API端点: ${endpoint}`);
+            const payload = {
+                children: blockContents,
+                index
+            };
+            Logger.debug(`请求数据: ${JSON.stringify(payload, null, 2)}`);
+            const response = await this.post(endpoint, payload);
+            return response;
+        }
+        catch (error) {
+            this.handleApiError(error, '批量创建文档块失败');
+            return null; // 永远不会执行到这里
+        }
+    }
+    /**
+     * 创建文本块
+     * @param documentId 文档ID或URL
+     * @param parentBlockId 父块ID
+     * @param textContents 文本内容数组
+     * @param align 对齐方式，1为左对齐，2为居中，3为右对齐
+     * @param index 插入位置索引
+     * @returns 创建结果
+     */
+    async createTextBlock(documentId, parentBlockId, textContents, align = 1, index = 0) {
+        const blockContent = this.blockFactory.createTextBlock({
+            textContents,
+            align
+        });
+        return this.createDocumentBlock(documentId, parentBlockId, blockContent, index);
+    }
+    /**
+     * 创建代码块
+     * @param documentId 文档ID或URL
+     * @param parentBlockId 父块ID
+     * @param code 代码内容
+     * @param language 语言代码
+     * @param wrap 是否自动换行
+     * @param index 插入位置索引
+     * @returns 创建结果
+     */
+    async createCodeBlock(documentId, parentBlockId, code, language = 0, wrap = false, index = 0) {
+        const blockContent = this.blockFactory.createCodeBlock({
+            code,
+            language,
+            wrap
+        });
+        return this.createDocumentBlock(documentId, parentBlockId, blockContent, index);
+    }
+    /**
+     * 创建标题块
+     * @param documentId 文档ID或URL
+     * @param parentBlockId 父块ID
+     * @param text 标题文本
+     * @param level 标题级别，1-9
+     * @param index 插入位置索引
+     * @param align 对齐方式，1为左对齐，2为居中，3为右对齐
+     * @returns 创建结果
+     */
+    async createHeadingBlock(documentId, parentBlockId, text, level = 1, index = 0, align = 1) {
+        const blockContent = this.blockFactory.createHeadingBlock({
+            text,
+            level,
+            align
+        });
+        return this.createDocumentBlock(documentId, parentBlockId, blockContent, index);
+    }
+    /**
+     * 创建列表块
+     * @param documentId 文档ID或URL
+     * @param parentBlockId 父块ID
+     * @param text 列表项文本
+     * @param isOrdered 是否是有序列表
+     * @param index 插入位置索引
+     * @param align 对齐方式，1为左对齐，2为居中，3为右对齐
+     * @returns 创建结果
+     */
+    async createListBlock(documentId, parentBlockId, text, isOrdered = false, index = 0, align = 1) {
+        const blockContent = this.blockFactory.createListBlock({
+            text,
+            isOrdered,
+            align
+        });
+        return this.createDocumentBlock(documentId, parentBlockId, blockContent, index);
+    }
+    /**
+     * 创建混合块
+     * @param documentId 文档ID或URL
+     * @param parentBlockId 父块ID
+     * @param blocks 块配置数组
+     * @param index 插入位置索引
+     * @returns 创建结果
+     */
+    async createMixedBlocks(documentId, parentBlockId, blocks, index = 0) {
+        const blockContents = this.blockFactory.createBatchBlocks(blocks);
+        return this.createDocumentBlocks(documentId, parentBlockId, blockContents, index);
+    }
+    /**
+     * 将飞书Wiki链接转换为文档ID
+     * @param wikiUrl Wiki链接或Token
+     * @returns 文档ID
+     */
+    async convertWikiToDocumentId(wikiUrl) {
+        try {
+            const wikiToken = ParamUtils.processWikiToken(wikiUrl);
+            // 尝试从缓存获取
+            const cachedDocId = this.cacheManager.getWikiToDocId(wikiToken);
+            if (cachedDocId) {
+                Logger.debug(`使用缓存的Wiki转换结果: ${wikiToken} -> ${cachedDocId}`);
+                return cachedDocId;
+            }
+            // 获取Wiki节点信息
+            const endpoint = `/wiki/v2/spaces/get_node`;
+            const params = { token: wikiToken, obj_type: 'wiki' };
+            const response = await this.get(endpoint, params);
+            if (!response.node || !response.node.obj_token) {
+                throw new Error(`无法从Wiki节点获取文档ID: ${wikiToken}`);
+            }
+            const documentId = response.node.obj_token;
+            // 缓存结果
+            this.cacheManager.cacheWikiToDocId(wikiToken, documentId);
+            Logger.debug(`Wiki转换为文档ID: ${wikiToken} -> ${documentId}`);
+            return documentId;
+        }
+        catch (error) {
+            this.handleApiError(error, 'Wiki转换为文档ID失败');
+            return ''; // 永远不会执行到这里
+        }
+    }
+    /**
+     * 获取BlockFactory实例
+     * @returns BlockFactory实例
+     */
+    getBlockFactory() {
+        return this.blockFactory;
+    }
+    /**
+     * 创建块内容对象
+     * @param blockType 块类型
+     * @param options 块选项
+     * @returns 块内容对象
+     */
+    createBlockContent(blockType, options) {
+        try {
+            // 使用枚举类型来避免字符串错误
+            const blockTypeEnum = blockType;
+            // 构建块配置
+            let blockConfig = {
+                type: blockTypeEnum,
+                options: {}
+            };
+            switch (blockTypeEnum) {
+                case BlockType.TEXT:
+                    if ('text' in options && options.text) {
+                        const textOptions = options.text;
+                        blockConfig.options = {
+                            textContents: textOptions.textStyles || [],
+                            align: textOptions.align || 1
+                        };
+                    }
+                    break;
+                case BlockType.CODE:
+                    if ('code' in options && options.code) {
+                        const codeOptions = options.code;
+                        blockConfig.options = {
+                            code: codeOptions.code || '',
+                            language: codeOptions.language === 0 ? 0 : (codeOptions.language || 0),
+                            wrap: codeOptions.wrap || false
+                        };
+                    }
+                    break;
+                case BlockType.HEADING:
+                    if ('heading' in options && options.heading) {
+                        const headingOptions = options.heading;
+                        blockConfig.options = {
+                            text: headingOptions.content || '',
+                            level: headingOptions.level || 1,
+                            align: (headingOptions.align === 1 || headingOptions.align === 2 || headingOptions.align === 3)
+                                ? headingOptions.align : 1
+                        };
+                    }
+                    break;
+                case BlockType.LIST:
+                    if ('list' in options && options.list) {
+                        const listOptions = options.list;
+                        blockConfig.options = {
+                            text: listOptions.content || '',
+                            isOrdered: listOptions.isOrdered || false,
+                            align: (listOptions.align === 1 || listOptions.align === 2 || listOptions.align === 3)
+                                ? listOptions.align : 1
+                        };
+                    }
+                    break;
+            }
+            // 使用BlockFactory创建块
+            return this.blockFactory.createBlock(blockConfig.type, blockConfig.options);
+        }
+        catch (error) {
+            Logger.error(`创建块内容对象失败: ${error}`);
+            return null;
+        }
+    }
+}

package/dist/services/feishuBlockService.js

@@ -0,0 +1,179 @@
+/**
+ * @deprecated 这个文件已被弃用，所有功能已迁移到BlockFactory类。
+ * 请使用BlockFactory创建各种块内容。
+ * 所有接口定义已迁移到blockFactory.ts文件。
+ * 此文件仅保留为历史兼容性目的，将在后续版本中移除。
+ */
+/**
+ * 构建批量创建块的请求数据
+ * @param blocks 块内容数组
+ * @param index 插入位置索引
+ * @returns 请求数据对象
+ * @deprecated 请使用BlockFactory.buildCreateBlocksRequest
+ */
+export function buildCreateBlocksRequest(blocks, index = 0) {
+    return {
+        children: blocks,
+        index
+    };
+}
+/**
+ * 创建文本块内容
+ * @param align 对齐方式：1左对齐，2居中，3右对齐
+ * @returns 文本块内容对象
+ * @deprecated 请使用BlockFactory.createTextBlock
+ */
+export function createTextBlockContent(textContents, align = 1) {
+    return {
+        block_type: 2, // 2表示文本块
+        text: {
+            elements: textContents.map(content => ({
+                text_run: {
+                    content: content.text,
+                    text_element_style: content.style || {}
+                }
+            })),
+            style: {
+                align: align // 1 居左，2 居中，3 居右
+            }
+        }
+    };
+}
+/**
+ * 创建代码块内容
+ * @param code 代码内容
+ * @param language 语言类型代码
+ * @param wrap 是否自动换行
+ * @returns 代码块内容对象
+ * @deprecated 请使用BlockFactory.createCodeBlock
+ */
+export function createCodeBlockContent(code, language = 0, wrap = false) {
+    return {
+        block_type: 14, // 14表示代码块
+        code: {
+            elements: [
+                {
+                    text_run: {
+                        content: code,
+                        text_element_style: {
+                            bold: false,
+                            inline_code: false,
+                            italic: false,
+                            strikethrough: false,
+                            underline: false
+                        }
+                    }
+                }
+            ],
+            style: {
+                language: language,
+                wrap: wrap
+            }
+        }
+    };
+}
+/**
+ * 创建标题块内容
+ * @param text 标题文本
+ * @param level 标题级别（1-9）
+ * @param align 对齐方式：1左对齐，2居中，3右对齐
+ * @returns 标题块内容对象
+ * @deprecated 请使用BlockFactory.createHeadingBlock
+ */
+export function createHeadingBlockContent(text, level = 1, align = 1) {
+    // 确保标题级别在有效范围内（1-9）
+    const safeLevel = Math.max(1, Math.min(9, level));
+    // 根据标题级别设置block_type和对应的属性名
+    // 飞书API中，一级标题的block_type为3，二级标题为4，以此类推
+    const blockType = 2 + safeLevel; // 一级标题为3，二级标题为4，以此类推
+    const headingKey = `heading${safeLevel}`; // heading1, heading2, ...
+    // 构建块内容
+    const blockContent = {
+        block_type: blockType
+    };
+    // 设置对应级别的标题属性
+    blockContent[headingKey] = {
+        elements: [
+            {
+                text_run: {
+                    content: text,
+                    text_element_style: {}
+                }
+            }
+        ],
+        style: {
+            align: align,
+            folded: false
+        }
+    };
+    return blockContent;
+}
+/**
+ * 创建列表块内容（有序或无序）
+ * @param text 列表项文本
+ * @param isOrdered 是否为有序列表
+ * @param align 对齐方式：1左对齐，2居中，3右对齐
+ * @returns 列表块内容对象
+ * @deprecated 请使用BlockFactory.createListBlock
+ */
+export function createListBlockContent(text, isOrdered = false, align = 1) {
+    // 确保 align 值在合法范围内（1-3）
+    const safeAlign = (align === 1 || align === 2 || align === 3) ? align : 1;
+    // 有序列表是 block_type: 13，无序列表是 block_type: 12
+    const blockType = isOrdered ? 13 : 12;
+    const propertyKey = isOrdered ? "ordered" : "bullet";
+    // 构建块内容
+    const blockContent = {
+        block_type: blockType
+    };
+    // 设置列表属性
+    blockContent[propertyKey] = {
+        elements: [
+            {
+                text_run: {
+                    content: text,
+                    text_element_style: {}
+                }
+            }
+        ],
+        style: {
+            align: safeAlign,
+            folded: false
+        }
+    };
+    return blockContent;
+}
+/**
+ * 处理Markdown语法转换
+ * @param textContents 文本内容数组
+ * @returns 处理后的文本内容数组
+ * @deprecated 应当避免使用Markdown语法，请直接使用TextElementStyle设置样式
+ */
+export function processMarkdownSyntax(textContents) {
+    return textContents.map(content => {
+        let { text, style = {} } = content;
+        // 创建一个新的style对象，避免修改原始对象
+        const newStyle = { ...style };
+        // 处理粗体 **text**
+        if (text.match(/\*\*([^*]+)\*\*/g)) {
+            text = text.replace(/\*\*([^*]+)\*\*/g, "$1");
+            newStyle.bold = true;
+        }
+        // 处理斜体 *text*
+        if (text.match(/(?<!\*)\*([^*]+)\*(?!\*)/g)) {
+            text = text.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, "$1");
+            newStyle.italic = true;
+        }
+        // 处理删除线 ~~text~~
+        if (text.match(/~~([^~]+)~~/g)) {
+            text = text.replace(/~~([^~]+)~~/g, "$1");
+            newStyle.strikethrough = true;
+        }
+        // 处理行内代码 `code`
+        if (text.match(/`([^`]+)`/g)) {
+            text = text.replace(/`([^`]+)`/g, "$1");
+            newStyle.inline_code = true;
+        }
+        return { text, style: newStyle };
+    });
+}