feishu-mcp 0.0.16 → 0.0.18

package/dist/mcp/tools/feishuTools.js

@@ -1,7 +1,9 @@
-import { z } from 'zod';
+// import { z } from 'zod';
 import { formatErrorMessage } from '../../utils/error.js';
 import { Logger } from '../../utils/logger.js';
-import { DocumentIdSchema, BlockIdSchema, SearchKeySchema, WhiteboardIdSchema, } from '../../types/feishuSchema.js';
+import { DocumentIdSchema, 
+// BlockIdSchema,
+SearchKeySchema, WhiteboardIdSchema, DocumentTitleSchema, FolderTokenSchema, } from '../../types/feishuSchema.js';
 /**
  * 注册飞书相关的MCP工具
  * @param server MCP服务器实例
@@ -10,8 +12,8 @@ import { DocumentIdSchema, BlockIdSchema, SearchKeySchema, WhiteboardIdSchema, }
 export function registerFeishuTools(server, feishuService) {
     // 添加创建飞书文档工具
     server.tool('create_feishu_document', 'Creates a new Feishu document and returns its information. Use this tool when you need to create a document from scratch with a specific title and folder location.', {
-        title: z.string().describe('Document title (required). This will be displayed in the Feishu document list and document header.'),
-        folderToken: z.string().describe('Folder token (required). Specifies where to create the document. Format is an alphanumeric string like "doxcnOu1ZKYH4RtX1Y5XwL5WGRh".'),
+        title: DocumentTitleSchema,
+        folderToken: FolderTokenSchema,
     }, async ({ title, folderToken }) => {
         try {
             Logger.info(`开始创建飞书文档，标题: ${title}${folderToken ? `，文件夹Token: ${folderToken}` : '，使用默认文件夹'}`);
@@ -58,31 +60,37 @@ export function registerFeishuTools(server, feishuService) {
         }
     });
     // 添加获取飞书文档内容工具
-    server.tool('get_feishu_document_content', 'Retrieves the plain text content of a Feishu document. Ideal for content analysis, processing, or when you need to extract text without formatting. The content maintains the document structure but without styling. Note: For Feishu wiki links (https://xxx.feishu.cn/wiki/xxx) you must first use convert_feishu_wiki_to_document_id tool to obtain a compatible document ID.', {
-        documentId: DocumentIdSchema,
-        lang: z.number().optional().default(0).describe('Language code (optional). Default is 0 (Chinese). Use 1 for English if available.'),
-    }, async ({ documentId, lang }) => {
-        try {
-            if (!feishuService) {
-                return {
-                    content: [{ type: 'text', text: 'Feishu service is not initialized. Please check the configuration' }],
-                };
-            }
-            Logger.info(`开始获取飞书文档内容，文档ID: ${documentId}，语言: ${lang}`);
-            const content = await feishuService.getDocumentContent(documentId, lang);
-            Logger.info(`飞书文档内容获取成功，内容长度: ${content.length}字符`);
-            return {
-                content: [{ type: 'text', text: content }],
-            };
-        }
-        catch (error) {
-            Logger.error(`获取飞书文档内容失败:`, error);
-            const errorMessage = formatErrorMessage(error);
-            return {
-                content: [{ type: 'text', text: `获取飞书文档内容失败: ${errorMessage}` }],
-            };
-        }
-    });
+    // server.tool(
+    //   'get_feishu_document_content',
+    //   'Retrieves the plain text content of a Feishu document. Ideal for content analysis, processing, or when you need to extract text without formatting. The content maintains the document structure but without styling. Note: For Feishu wiki links (https://xxx.feishu.cn/wiki/xxx) you must first use convert_feishu_wiki_to_document_id tool to obtain a compatible document ID.',
+    //   {
+    //     documentId: DocumentIdSchema,
+    //     lang: z.number().optional().default(0).describe('Language code (optional). Default is 0 (Chinese). Use 1 for English if available.'),
+    //   },
+    //   async ({ documentId, lang }) => {
+    //     try {
+    //       if (!feishuService) {
+    //         return {
+    //           content: [{ type: 'text', text: 'Feishu service is not initialized. Please check the configuration' }],
+    //         };
+    //       }
+    //
+    //       Logger.info(`开始获取飞书文档内容，文档ID: ${documentId}，语言: ${lang}`);
+    //       const content = await feishuService.getDocumentContent(documentId, lang);
+    //       Logger.info(`飞书文档内容获取成功，内容长度: ${content.length}字符`);
+    //
+    //       return {
+    //         content: [{ type: 'text', text: content }],
+    //       };
+    //     } catch (error) {
+    //       Logger.error(`获取飞书文档内容失败:`, error);
+    //       const errorMessage = formatErrorMessage(error);
+    //       return {
+    //         content: [{ type: 'text', text: `获取飞书文档内容失败: ${errorMessage}` }],
+    //       };
+    //     }
+    //   },
+    // );
     // 添加获取飞书文档块工具
     server.tool('get_feishu_document_blocks', 'Retrieves the block structure information of a Feishu document. Essential to use before inserting content to understand document structure and determine correct insertion positions. Returns a detailed hierarchy of blocks with their IDs, types, and content. Note: For Feishu wiki links (https://xxx.feishu.cn/wiki/xxx) you must first use convert_feishu_wiki_to_document_id tool to obtain a compatible document ID.', {
         documentId: DocumentIdSchema,
@@ -127,31 +135,37 @@ export function registerFeishuTools(server, feishuService) {
         }
     });
     // 添加获取块内容工具
-    server.tool('get_feishu_block_content', 'Retrieves the detailed content and structure of a specific block in a Feishu document. Useful for inspecting block properties, formatting, and content, especially before making updates or for debugging purposes. Note: For Feishu wiki links (https://xxx.feishu.cn/wiki/xxx) you must first use convert_feishu_wiki_to_document_id tool to obtain a compatible document ID.', {
-        documentId: DocumentIdSchema,
-        blockId: BlockIdSchema,
-    }, async ({ documentId, blockId }) => {
-        try {
-            if (!feishuService) {
-                return {
-                    content: [{ type: 'text', text: '飞书服务未初始化，请检查配置' }],
-                };
-            }
-            Logger.info(`开始获取飞书块内容，文档ID: ${documentId}，块ID: ${blockId}`);
-            const blockContent = await feishuService.getBlockContent(documentId, blockId);
-            Logger.info(`飞书块内容获取成功，块类型: ${blockContent.block_type}`);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(blockContent, null, 2) }],
-            };
-        }
-        catch (error) {
-            Logger.error(`获取飞书块内容失败:`, error);
-            const errorMessage = formatErrorMessage(error);
-            return {
-                content: [{ type: 'text', text: `获取飞书块内容失败: ${errorMessage}` }],
-            };
-        }
-    });
+    // server.tool(
+    //   'get_feishu_block_content',
+    //   'Retrieves the detailed content and structure of a specific block in a Feishu document. Useful for inspecting block properties, formatting, and content, especially before making updates or for debugging purposes. Note: For Feishu wiki links (https://xxx.feishu.cn/wiki/xxx) you must first use convert_feishu_wiki_to_document_id tool to obtain a compatible document ID.',
+    //   {
+    //     documentId: DocumentIdSchema,
+    //     blockId: BlockIdSchema,
+    //   },
+    //   async ({ documentId, blockId }) => {
+    //     try {
+    //       if (!feishuService) {
+    //         return {
+    //           content: [{ type: 'text', text: '飞书服务未初始化，请检查配置' }],
+    //         };
+    //       }
+    //
+    //       Logger.info(`开始获取飞书块内容，文档ID: ${documentId}，块ID: ${blockId}`);
+    //       const blockContent = await feishuService.getBlockContent(documentId, blockId);
+    //       Logger.info(`飞书块内容获取成功，块类型: ${blockContent.block_type}`);
+    //
+    //       return {
+    //         content: [{ type: 'text', text: JSON.stringify(blockContent, null, 2) }],
+    //       };
+    //     } catch (error) {
+    //       Logger.error(`获取飞书块内容失败:`, error);
+    //       const errorMessage = formatErrorMessage(error);
+    //       return {
+    //         content: [{ type: 'text', text: `获取飞书块内容失败: ${errorMessage}` }],
+    //       };
+    //     }
+    //   },
+    // );
     // 添加搜索文档工具
     server.tool('search_feishu_documents', 'Searches for documents in Feishu. Supports keyword-based search and returns document information including title, type, and owner. Use this tool to find specific content or related documents in your document library.', {
         searchKey: SearchKeySchema,

package/dist/server.js

@@ -3,6 +3,7 @@ import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 import { Logger } from './utils/logger.js';
 import { SSEConnectionManager } from './manager/sseConnectionManager.js';
 import { FeishuMcp } from './mcp/feishuMcp.js';
+import { callback, getTokenByParams } from './services/callbackService.js';
 export class FeishuMcpServer {
     constructor() {
         Object.defineProperty(this, "connectionManager", {
@@ -62,6 +63,25 @@ export class FeishuMcpServer {
             }
             await transport.handlePostMessage(req, res);
         });
+        app.get('/callback', callback);
+        app.get('/getToken', async (req, res) => {
+            const { client_id, client_secret, token_type } = req.query;
+            if (!client_id || !client_secret) {
+                res.status(400).json({ code: 400, msg: '缺少 client_id 或 client_secret' });
+                return;
+            }
+            try {
+                const tokenResult = await getTokenByParams({
+                    client_id: client_id,
+                    client_secret: client_secret,
+                    token_type: token_type
+                });
+                res.json({ code: 0, msg: 'success', data: tokenResult });
+            }
+            catch (e) {
+                res.status(500).json({ code: 500, msg: e.message || '获取token失败' });
+            }
+        });
         app.listen(port, () => {
             Logger.info(`HTTP server listening on port ${port}`);
             Logger.info(`SSE endpoint available at http://localhost:${port}/sse`);

package/dist/services/baseService.js

@@ -21,16 +21,6 @@ export class BaseApiService {
             value: null
         });
     }
-    /**
-     * 检查访问令牌是否过期
-     * @returns 是否过期
-     */
-    isTokenExpired() {
-        if (!this.accessToken || !this.tokenExpireTime)
-            return true;
-        // 预留5分钟的缓冲时间
-        return Date.now() >= (this.tokenExpireTime - 5 * 60 * 1000);
-    }
     /**
      * 处理API错误
      * @param error 错误对象

package/dist/services/callbackService.js

@@ -0,0 +1,80 @@
+import { AuthService } from './feishuAuthService.js';
+import { Config } from '../utils/config.js';
+import { CacheManager } from '../utils/cache.js';
+import { renderFeishuAuthResultHtml } from '../utils/document.js';
+// 通用响应码
+const CODE = {
+    SUCCESS: 0,
+    PARAM_ERROR: 400,
+    CUSTOM: 500,
+};
+// 封装响应方法
+function sendSuccess(res, data) {
+    const html = renderFeishuAuthResultHtml(data);
+    res.setHeader('Content-Type', 'text/html; charset=utf-8');
+    res.status(200).send(html);
+}
+function sendFail(res, msg, code = CODE.CUSTOM) {
+    const html = renderFeishuAuthResultHtml({ error: msg, code });
+    res.setHeader('Content-Type', 'text/html; charset=utf-8');
+    res.status(200).send(html);
+}
+const authService = new AuthService();
+const config = Config.getInstance();
+export async function callback(req, res) {
+    const code = req.query.code;
+    const state = req.query.state;
+    console.log(`[callback] query:`, req.query);
+    if (!code) {
+        console.log('[callback] 缺少code参数');
+        return sendFail(res, '缺少code参数', CODE.PARAM_ERROR);
+    }
+    // 校验state（clientKey）
+    const client_id = config.feishu.appId;
+    const client_secret = config.feishu.appSecret;
+    const expectedClientKey = await CacheManager.getClientKey(client_id, client_secret);
+    if (state !== expectedClientKey) {
+        console.log('[callback] state(clientKey)不匹配');
+        return sendFail(res, 'state(clientKey)不匹配', CODE.PARAM_ERROR);
+    }
+    const redirect_uri = `http://localhost:${config.server.port}/callback`;
+    const session = req.session;
+    const code_verifier = session?.code_verifier || undefined;
+    try {
+        // 获取 user_access_token
+        const tokenResp = await authService.getUserTokenByCode({
+            client_id,
+            client_secret,
+            code,
+            redirect_uri,
+            code_verifier
+        });
+        const data = (tokenResp && typeof tokenResp === 'object') ? tokenResp : undefined;
+        console.log('[callback] feishu response:', data);
+        if (!data || data.code !== 0 || !data.access_token) {
+            return sendFail(res, `获取 access_token 失败，飞书返回: ${JSON.stringify(tokenResp)}`, CODE.CUSTOM);
+        }
+        // 获取用户信息
+        const access_token = data.access_token;
+        let userInfo = null;
+        if (access_token) {
+            userInfo = await authService.getUserInfo(access_token);
+            console.log('[callback] feishu userInfo:', userInfo);
+        }
+        return sendSuccess(res, { ...data, userInfo });
+    }
+    catch (e) {
+        console.error('[callback] 请求飞书token或用户信息失败:', e);
+        return sendFail(res, `请求飞书token或用户信息失败: ${e}`, CODE.CUSTOM);
+    }
+}
+export async function getTokenByParams({ client_id, client_secret, token_type }) {
+    const authService = new AuthService();
+    if (client_id)
+        authService.config.feishu.appId = client_id;
+    if (client_secret)
+        authService.config.feishu.appSecret = client_secret;
+    if (token_type)
+        authService.config.feishu.authType = token_type === 'user' ? 'user' : 'tenant';
+    return await authService.getToken();
+}

package/dist/services/feishuApiService.js

@@ -76,41 +76,25 @@ export class FeishuApiService extends BaseApiService {
             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, '获取飞书访问令牌失败');
-        }
+        // 通过HTTP请求调用配置的tokenEndpoint接口
+        const { appId, appSecret, authType, tokenEndpoint } = this.config.feishu;
+        const params = new URLSearchParams({
+            client_id: appId,
+            client_secret: appSecret,
+            token_type: authType
+        });
+        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;
+        }
+        if (tokenResult && tokenResult.needAuth && tokenResult.url) {
+            throw new Error(`请在浏览器打开以下链接进行授权：\n\n[点击授权](${tokenResult.url})`);
+        }
+        throw new Error('无法获取有效的access_token');
     }
     /**
      * 创建飞书文档

package/dist/services/feishuAuthService.js

@@ -0,0 +1,185 @@
+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() {
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            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) {
+        Logger.warn('[AuthService] getUserInfo called');
+        try {
+            const response = await axios.get('https://open.feishu.cn/open-apis/authen/v1/user_info', { headers: { Authorization: `Bearer ${access_token}` } });
+            Logger.debug('[AuthService] getUserInfo response', response.data);
+            return response.data;
+        }
+        catch (error) {
+            Logger.error('[AuthService] getUserInfo error', error);
+            throw error;
+        }
+    }
+    // 通过授权码换取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,
+            client_secret,
+            code,
+            redirect_uri
+        };
+        if (code_verifier)
+            body.code_verifier = code_verifier;
+        Logger.debug('[AuthService] getUserTokenByCode request', body);
+        const response = await fetch('https://open.feishu.cn/open-apis/authen/v2/oauth/token', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body)
+        });
+        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/types/feishuSchema.js

@@ -16,6 +16,7 @@ export const IndexSchema = z.number().describe('Insertion position index (requir
     '0 means to insert as the first content block after the title.\n' +
     'If children is empty or missing, use 0 to insert the first content block.\n' +
     'For nested blocks, index is relative to the parent block\'s children.\n' +
+    '**index must satisfy 0 ≤ index ≤ parentBlock.children.length, otherwise the API will return an error.**\n' +
     'Note: The title block itself is not part of the children array and cannot be operated on with index.' +
     'Specifies where the block should be inserted. Use 0 to insert at the beginning. ' +
     'Use get_feishu_document_blocks tool to understand document structure if unsure. ' +
@@ -106,10 +107,14 @@ export const BlockTypeEnum = z.string().describe("Block type (required). Support
     "For headings, we recommend using 'heading' with level property, but 'heading1'-'heading9' are also supported. " +
     "For images, use 'image' to create empty image blocks that can be filled later. " +
     "For text blocks, you can include both regular text and equation elements in the same block.");
+// 图片宽度参数定义
+export const ImageWidthSchema = z.number().optional().describe('Image width in pixels (optional). If not provided, the original image width will be used.');
+// 图片高度参数定义
+export const ImageHeightSchema = z.number().optional().describe('Image height in pixels (optional). If not provided, the original image height will be used.');
 // 图片块内容定义 - 用于批量创建块工具
 export const ImageBlockSchema = z.object({
-    width: z.number().optional().describe('Image width in pixels (optional). If not provided, default width will be used.'),
-    height: z.number().optional().describe('Image height in pixels (optional). If not provided, default height will be used.'),
+    width: ImageWidthSchema,
+    height: ImageHeightSchema
 });
 // 块配置定义 - 用于批量创建块工具
 export const BlockConfigSchema = z.object({
@@ -145,11 +150,15 @@ export const ImagePathOrUrlSchema = z.string().describe('Image path or URL (requ
 // 图片文件名参数定义
 export const ImageFileNameSchema = z.string().optional().describe('Image file name (optional). If not provided, a default name will be generated based on the source. ' +
     'Should include the file extension, e.g., "image.png" or "photo.jpg".');
-// 图片宽度参数定义
-export const ImageWidthSchema = z.number().optional().describe('Image width in pixels (optional). If not provided, the original image width will be used.');
-// 图片高度参数定义
-export const ImageHeightSchema = z.number().optional().describe('Image height in pixels (optional). If not provided, the original image height will be used.');
+// 批量图片上传绑定参数定义
+export const ImagesArraySchema = z.array(z.object({
+    blockId: BlockIdSchema,
+    imagePathOrUrl: ImagePathOrUrlSchema,
+    fileName: ImageFileNameSchema.optional(),
+})).describe('Array of image binding objects (required). Each object must include: blockId (target image block ID), imagePathOrUrl (local path or URL of the image), and optionally fileName (image file name, e.g., "image.png").');
 // 画板ID参数定义
 export const WhiteboardIdSchema = z.string().describe('Whiteboard ID (required). This is the token value from the board.token field when getting document blocks.\n' +
     'When you find a block with block_type: 43, the whiteboard ID is located in board.token field.\n' +
     'Example: "EPJKwvY5ghe3pVbKj9RcT2msnBX"');
+// 文档标题参数定义
+export const DocumentTitleSchema = z.string().describe('Document title (required). This will be displayed in the Feishu document list and document header.');