feishu-mcp 0.0.9 → 0.0.11

package/dist/services/blockFactory.js

@@ -34,6 +34,28 @@ export class BlockFactory {
         }
         return BlockFactory.instance;
     }
+    /**
+     * 获取默认的文本元素样式
+     * @returns 默认文本元素样式
+     */
+    static getDefaultTextElementStyle() {
+        return {
+            bold: false,
+            inline_code: false,
+            italic: false,
+            strikethrough: false,
+            underline: false
+        };
+    }
+    /**
+     * 应用默认文本样式
+     * @param style 已有样式（可选）
+     * @returns 合并后的样式
+     */
+    static applyDefaultTextStyle(style) {
+        const defaultStyle = BlockFactory.getDefaultTextElementStyle();
+        return style ? { ...defaultStyle, ...style } : defaultStyle;
+    }
     /**
      * 创建块内容
      * @param type 块类型
@@ -68,7 +90,7 @@ export class BlockFactory {
                 elements: textContents.map(content => ({
                     text_run: {
                         content: content.text,
-                        text_element_style: content.style || {}
+                        text_element_style: BlockFactory.applyDefaultTextStyle(content.style)
                     }
                 })),
                 style: {
@@ -84,6 +106,8 @@ export class BlockFactory {
      */
     createCodeBlock(options) {
         const { code, language = 0, wrap = false } = options;
+        // 校验 language 合法性，飞书API只允许1~75
+        const safeLanguage = language >= 1 && language <= 75 ? language : 1;
         return {
             block_type: 14, // 14表示代码块
             code: {
@@ -91,18 +115,12 @@ export class BlockFactory {
                     {
                         text_run: {
                             content: code,
-                            text_element_style: {
-                                bold: false,
-                                inline_code: false,
-                                italic: false,
-                                strikethrough: false,
-                                underline: false
-                            }
+                            text_element_style: BlockFactory.getDefaultTextElementStyle()
                         }
                     }
                 ],
                 style: {
-                    language: language,
+                    language: safeLanguage,
                     wrap: wrap
                 }
             }
@@ -131,7 +149,7 @@ export class BlockFactory {
                 {
                     text_run: {
                         content: text,
-                        text_element_style: {}
+                        text_element_style: BlockFactory.getDefaultTextElementStyle()
                     }
                 }
             ],
@@ -162,7 +180,7 @@ export class BlockFactory {
                 {
                     text_run: {
                         content: text,
-                        text_element_style: {}
+                        text_element_style: BlockFactory.getDefaultTextElementStyle()
                     }
                 }
             ],

package/dist/services/feishu.js

@@ -70,7 +70,6 @@ export class FeishuService {
                 throw {
                     status: response.status,
                     err: response.data.msg || "Unknown error",
-                    apiError: response.data
                 };
             }
             this.accessToken = response.data.tenant_access_token;
@@ -87,7 +86,6 @@ export class FeishuService {
                 throw {
                     status: error.response.status,
                     err: error.response.data?.msg || "Unknown error",
-                    apiError: error.response.data
                 };
             }
             Logger.error('获取访问令牌时发生未知错误:', error);
@@ -130,7 +128,6 @@ export class FeishuService {
                 throw {
                     status: error.response.status,
                     err: error.response.data?.msg || "Unknown error",
-                    apiError: error.response.data
                 };
             }
             Logger.error('发送请求时发生未知错误:', error);

package/dist/services/feishuApiService.js

@@ -229,7 +229,7 @@ export class FeishuApiService extends BaseApiService {
             const elements = textElements.map(item => ({
                 text_run: {
                     content: item.text,
-                    text_element_style: item.style || {}
+                    text_element_style: BlockFactory.applyDefaultTextStyle(item.style)
                 }
             }));
             const data = {
@@ -308,8 +308,13 @@ export class FeishuApiService extends BaseApiService {
      * @returns 创建结果
      */
     async createTextBlock(documentId, parentBlockId, textContents, align = 1, index = 0) {
+        // 处理文本内容样式
+        const processedTextContents = textContents.map(item => ({
+            text: item.text,
+            style: BlockFactory.applyDefaultTextStyle(item.style)
+        }));
         const blockContent = this.blockFactory.createTextBlock({
-            textContents,
+            textContents: processedTextContents,
             align
         });
         return this.createDocumentBlock(documentId, parentBlockId, blockContent, index);
@@ -466,6 +471,33 @@ export class FeishuApiService extends BaseApiService {
      */
     createBlockContent(blockType, options) {
         try {
+            // 处理特殊的heading标题格式，如heading1, heading2等
+            if (typeof blockType === 'string' && blockType.startsWith('heading')) {
+                // 使用正则表达式匹配"heading"后跟1-9的数字格式
+                const headingMatch = blockType.match(/^heading([1-9])$/);
+                if (headingMatch) {
+                    // 提取数字部分，例如从"heading1"中提取"1"
+                    const level = parseInt(headingMatch[1], 10);
+                    // 额外的安全检查，确保level在1-9范围内
+                    if (level >= 1 && level <= 9) {
+                        // 使用level参数创建标题块
+                        if (!options || Object.keys(options).length === 0) {
+                            // 没有提供选项时创建默认选项
+                            options = { heading: { level, content: '', align: 1 } };
+                        }
+                        else if (!('heading' in options)) {
+                            // 提供了选项但没有heading字段
+                            options = { heading: { level, content: '', align: 1 } };
+                        }
+                        else if (options.heading && !('level' in options.heading)) {
+                            // 提供了heading但没有level字段
+                            options.heading.level = level;
+                        }
+                        blockType = BlockType.HEADING; // 将blockType转为标准的heading类型
+                        Logger.info(`转换特殊标题格式: ${blockType}${level} -> standard heading with level=${level}`);
+                    }
+                }
+            }
             // 使用枚举类型来避免字符串错误
             const blockTypeEnum = blockType;
             // 构建块配置
@@ -473,12 +505,19 @@ export class FeishuApiService extends BaseApiService {
                 type: blockTypeEnum,
                 options: {}
             };
+            // 根据块类型处理不同的选项
             switch (blockTypeEnum) {
                 case BlockType.TEXT:
                     if ('text' in options && options.text) {
                         const textOptions = options.text;
+                        // 处理文本样式，应用默认样式
+                        const textStyles = textOptions.textStyles || [];
+                        const processedTextStyles = textStyles.map((item) => ({
+                            text: item.text,
+                            style: BlockFactory.applyDefaultTextStyle(item.style)
+                        }));
                         blockConfig.options = {
-                            textContents: textOptions.textStyles || [],
+                            textContents: processedTextStyles,
                             align: textOptions.align || 1
                         };
                     }
@@ -515,7 +554,55 @@ export class FeishuApiService extends BaseApiService {
                         };
                     }
                     break;
+                default:
+                    Logger.warn(`未知的块类型: ${blockType}，尝试作为标准类型处理`);
+                    if ('text' in options) {
+                        blockConfig.type = BlockType.TEXT;
+                        const textOptions = options.text;
+                        // 处理文本样式，应用默认样式
+                        const textStyles = textOptions.textStyles || [];
+                        const processedTextStyles = textStyles.map((item) => ({
+                            text: item.text,
+                            style: BlockFactory.applyDefaultTextStyle(item.style)
+                        }));
+                        blockConfig.options = {
+                            textContents: processedTextStyles,
+                            align: textOptions.align || 1
+                        };
+                    }
+                    else if ('code' in options) {
+                        blockConfig.type = BlockType.CODE;
+                        const codeOptions = options.code;
+                        blockConfig.options = {
+                            code: codeOptions.code || '',
+                            language: codeOptions.language === 0 ? 0 : (codeOptions.language || 0),
+                            wrap: codeOptions.wrap || false
+                        };
+                    }
+                    else if ('heading' in options) {
+                        blockConfig.type = BlockType.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
+                        };
+                    }
+                    else if ('list' in options) {
+                        blockConfig.type = BlockType.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;
             }
+            // 记录调试信息
+            Logger.debug(`创建块内容: 类型=${blockConfig.type}, 选项=${JSON.stringify(blockConfig.options)}`);
             // 使用BlockFactory创建块
             return this.blockFactory.createBlock(blockConfig.type, blockConfig.options);
         }

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 };
+    });
+}