feishu-mcp 0.1.1 → 0.1.3

package/dist/services/blockFactory.js

@@ -246,4 +246,92 @@ export class BlockFactory {
             },
         };
     }
+    /**
+     * 创建表格块
+     * @param options 表格块选项
+     * @returns 表格块内容对象
+     */
+    createTableBlock(options) {
+        const { columnSize, rowSize, cells = [] } = options;
+        // 生成表格ID
+        const tableId = `table_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const imageBlocks = Array();
+        // 创建表格单元格
+        const tableCells = [];
+        const descendants = [];
+        for (let row = 0; row < rowSize; row++) {
+            for (let col = 0; col < columnSize; col++) {
+                const cellId = `table_cell${row}_${col}`;
+                // 查找是否有配置的单元格内容
+                const cellConfigs = cells.filter(cell => cell.coordinate.row === row && cell.coordinate.column === col);
+                // 创建单元格内容
+                const cellContentBlocks = [];
+                const cellContentIds = [];
+                if (cellConfigs.length > 0) {
+                    // 处理多个内容块
+                    cellConfigs.forEach((cellConfig, index) => {
+                        const cellContentId = `${cellId}_child_${index}`;
+                        const cellContentBlock = {
+                            block_id: cellContentId,
+                            ...cellConfig.content,
+                            children: []
+                        };
+                        cellContentBlocks.push(cellContentBlock);
+                        cellContentIds.push(cellContentId);
+                        Logger.info(`处理块：${JSON.stringify(cellConfig)}  ${index}`);
+                        if (cellConfig.content.block_type === 27) {
+                            //把图片块保存起来，用于后续获取该图片块的token
+                            imageBlocks.push({
+                                coordinate: cellConfig.coordinate,
+                                localBlockId: cellContentId,
+                            });
+                        }
+                    });
+                }
+                else {
+                    // 创建空的文本块
+                    const cellContentId = `${cellId}_child`;
+                    const cellContentBlock = {
+                        block_id: cellContentId,
+                        ...this.createTextBlock({
+                            textContents: [{ text: "" }]
+                        }),
+                        children: []
+                    };
+                    cellContentBlocks.push(cellContentBlock);
+                    cellContentIds.push(cellContentId);
+                }
+                // 创建表格单元格块
+                const tableCell = {
+                    block_id: cellId,
+                    block_type: 32, // 表格单元格类型
+                    table_cell: {},
+                    children: cellContentIds
+                };
+                tableCells.push(cellId);
+                descendants.push(tableCell);
+                descendants.push(...cellContentBlocks);
+            }
+        }
+        // 创建表格主体
+        const tableBlock = {
+            block_id: tableId,
+            block_type: 31, // 表格块类型
+            table: {
+                property: {
+                    row_size: rowSize,
+                    column_size: columnSize
+                }
+            },
+            children: tableCells
+        };
+        descendants.unshift(tableBlock);
+        // 过滤并记录 block_type 为 27 的元素
+        Logger.info(`发现 ${imageBlocks.length} 个图片块 (block_type: 27):  ${JSON.stringify(imageBlocks)}`);
+        return {
+            children_id: [tableId],
+            descendants: descendants,
+            imageBlocks: imageBlocks
+        };
+    }
 }

package/dist/services/callbackService.js

@@ -1,7 +1,7 @@
 import { AuthService } from './feishuAuthService.js';
 import { Config } from '../utils/config.js';
-import { CacheManager } from '../utils/cache.js';
 import { renderFeishuAuthResultHtml } from '../utils/document.js';
+import { AuthUtils, TokenCacheManager } from '../utils/auth';
 // 通用响应码
 const CODE = {
     SUCCESS: 0,
@@ -29,22 +29,34 @@ export async function callback(req, res) {
         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);
+    if (!state) {
+        console.log('[callback] 缺少state参数');
+        return sendFail(res, '缺少state参数', CODE.PARAM_ERROR);
     }
-    const redirect_uri = `http://localhost:${config.server.port}/callback`;
+    // 解析state参数
+    const stateData = AuthUtils.decodeState(state);
+    if (!stateData) {
+        console.log('[callback] state参数解析失败');
+        return sendFail(res, 'state参数格式错误', CODE.PARAM_ERROR);
+    }
+    const { appId, appSecret, clientKey, redirectUri } = stateData;
+    console.log(`[callback] 解析state成功:`, { appId, clientKey, redirectUri });
+    // 验证state中的appId和appSecret是否与配置匹配
+    const configAppId = config.feishu.appId;
+    const configAppSecret = config.feishu.appSecret;
+    if (appId !== configAppId || appSecret !== configAppSecret) {
+        console.log('[callback] state中的appId或appSecret与配置不匹配');
+        return sendFail(res, 'state参数验证失败', CODE.PARAM_ERROR);
+    }
+    // 使用从state中解析的redirect_uri，如果没有则使用默认值
+    const redirect_uri = redirectUri || `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,
+            client_id: appId,
+            client_secret: appSecret,
             code,
             redirect_uri,
             code_verifier
@@ -54,6 +66,19 @@ export async function callback(req, res) {
         if (!data || data.code !== 0 || !data.access_token) {
             return sendFail(res, `获取 access_token 失败，飞书返回: ${JSON.stringify(tokenResp)}`, CODE.CUSTOM);
         }
+        // 使用TokenCacheManager缓存token信息
+        const tokenCacheManager = TokenCacheManager.getInstance();
+        if (data.access_token && data.expires_in) {
+            // 计算过期时间戳
+            data.expires_at = Math.floor(Date.now() / 1000) + data.expires_in;
+            if (data.refresh_token_expires_in) {
+                data.refresh_token_expires_at = Math.floor(Date.now() / 1000) + data.refresh_token_expires_in;
+            }
+            // 缓存token信息
+            const refreshTtl = data.refresh_token_expires_in || 3600 * 24 * 365; // 默认1年
+            tokenCacheManager.cacheUserToken(clientKey, data, refreshTtl);
+            console.log(`[callback] token已缓存到clientKey: ${clientKey}`);
+        }
         // 获取用户信息
         const access_token = data.access_token;
         let userInfo = null;
@@ -61,20 +86,10 @@ export async function callback(req, res) {
             userInfo = await authService.getUserInfo(access_token);
             console.log('[callback] feishu userInfo:', userInfo);
         }
-        return sendSuccess(res, { ...data, userInfo });
+        return sendSuccess(res, { ...data, userInfo, clientKey });
     }
     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

@@ -4,6 +4,8 @@ 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 { AuthUtils, TokenCacheManager } from '../utils/auth';
+import { AuthRequiredError } from '../utils/error.js';
 import axios from 'axios';
 import FormData from 'form-data';
 import fs from 'fs';
@@ -66,35 +68,154 @@ export class FeishuApiService extends BaseApiService {
     }
     /**
      * 获取访问令牌
+     * @param userKey 用户标识（可选）
      * @returns 访问令牌
      * @throws 如果获取令牌失败则抛出错误
      */
-    async getAccessToken() {
-        // 尝试从缓存获取
-        const cachedToken = this.cacheManager.getToken();
+    async getAccessToken(userKey) {
+        const { appId, appSecret, authType } = this.config.feishu;
+        // 生成客户端缓存键
+        const clientKey = AuthUtils.generateClientKey(userKey);
+        Logger.debug(`[FeishuApiService] 获取访问令牌，userKey: ${userKey}, clientKey: ${clientKey}, authType: ${authType}`);
+        if (authType === 'tenant') {
+            // 租户模式：获取租户访问令牌
+            return this.getTenantAccessToken(appId, appSecret, clientKey);
+        }
+        else {
+            // 用户模式：获取用户访问令牌
+            return this.getUserAccessToken(appId, appSecret, clientKey, userKey);
+        }
+    }
+    /**
+     * 获取租户访问令牌
+     * @param appId 应用ID
+     * @param appSecret 应用密钥
+     * @param clientKey 客户端缓存键
+     * @returns 租户访问令牌
+     */
+    async getTenantAccessToken(appId, appSecret, clientKey) {
+        const tokenCacheManager = TokenCacheManager.getInstance();
+        // 尝试从缓存获取租户token
+        const cachedToken = tokenCacheManager.getTenantToken(clientKey);
         if (cachedToken) {
-            Logger.debug('使用缓存的访问令牌');
+            Logger.debug('使用缓存的租户访问令牌');
             return cachedToken;
         }
-        // 通过HTTP请求调用配置的tokenEndpoint接口
-        const { appId, appSecret, authType, tokenEndpoint } = this.config.feishu;
-        const params = new URLSearchParams({
+        // 缓存中没有token，请求新的租户token
+        Logger.info('缓存中没有租户token，请求新的租户访问令牌');
+        try {
+            const requestData = {
+                app_id: appId,
+                app_secret: appSecret,
+            };
+            const url = 'https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal';
+            const headers = { 'Content-Type': 'application/json' };
+            Logger.debug('请求租户访问令牌:', url, requestData);
+            const response = await axios.post(url, requestData, { headers });
+            const data = response.data;
+            if (data.code !== 0) {
+                throw new Error(`获取租户访问令牌失败：${data.msg || '未知错误'} (错误码: ${data.code})`);
+            }
+            if (!data.tenant_access_token) {
+                throw new Error('获取租户访问令牌失败：响应中没有token');
+            }
+            // 计算绝对过期时间戳
+            const expire_at = Math.floor(Date.now() / 1000) + (data.expire || 0);
+            const tokenInfo = {
+                app_access_token: data.tenant_access_token,
+                expires_at: expire_at
+            };
+            // 缓存租户token
+            tokenCacheManager.cacheTenantToken(clientKey, tokenInfo, data.expire);
+            Logger.info('租户访问令牌获取并缓存成功');
+            return data.tenant_access_token;
+        }
+        catch (error) {
+            Logger.error('获取租户访问令牌失败:', error);
+            throw new Error('获取租户访问令牌失败: ' + (error instanceof Error ? error.message : String(error)));
+        }
+    }
+    /**
+     * 获取用户访问令牌
+     * @param appId 应用ID
+     * @param appSecret 应用密钥
+     * @param clientKey 客户端缓存键
+     * @param userKey 用户标识
+     * @returns 用户访问令牌
+     */
+    async getUserAccessToken(appId, appSecret, clientKey, _userKey) {
+        const tokenCacheManager = TokenCacheManager.getInstance();
+        // 检查用户token状态
+        const tokenStatus = tokenCacheManager.checkUserTokenStatus(clientKey);
+        Logger.debug(`用户token状态:`, tokenStatus);
+        if (tokenStatus.isValid && !tokenStatus.shouldRefresh) {
+            // token有效且不需要刷新，直接返回
+            const cachedToken = tokenCacheManager.getUserToken(clientKey);
+            if (cachedToken) {
+                Logger.debug('使用缓存的用户访问令牌');
+                return cachedToken;
+            }
+        }
+        if (tokenStatus.canRefresh && (tokenStatus.isExpired || tokenStatus.shouldRefresh)) {
+            // 可以刷新token
+            Logger.info('尝试刷新用户访问令牌');
+            try {
+                const tokenInfo = tokenCacheManager.getUserTokenInfo(clientKey);
+                if (tokenInfo && tokenInfo.refresh_token) {
+                    const refreshedToken = await this.refreshUserToken(tokenInfo.refresh_token, clientKey, appId, appSecret);
+                    if (refreshedToken && refreshedToken.access_token) {
+                        Logger.info('用户访问令牌刷新成功');
+                        return refreshedToken.access_token;
+                    }
+                }
+            }
+            catch (error) {
+                Logger.warn('刷新用户访问令牌失败:', error);
+                // 刷新失败，清除缓存，需要重新授权
+                tokenCacheManager.removeUserToken(clientKey);
+            }
+        }
+        // 没有有效的token或刷新失败，需要用户授权
+        Logger.warn('没有有效的用户token，需要用户授权');
+        throw new AuthRequiredError('user', '需要用户授权');
+    }
+    /**
+     * 刷新用户访问令牌
+     * @param refreshToken 刷新令牌
+     * @param clientKey 客户端缓存键
+     * @param appId 应用ID
+     * @param appSecret 应用密钥
+     * @returns 刷新后的token信息
+     */
+    async refreshUserToken(refreshToken, clientKey, appId, appSecret) {
+        const tokenCacheManager = TokenCacheManager.getInstance();
+        const body = {
+            grant_type: 'refresh_token',
             client_id: appId,
             client_secret: appSecret,
-            token_type: authType
+            refresh_token: refreshToken
+        };
+        Logger.debug('刷新用户访问令牌请求:', body);
+        const response = await axios.post('https://open.feishu.cn/open-apis/authen/v2/oauth/token', body, {
+            headers: { 'Content-Type': 'application/json' }
         });
-        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;
+        const data = response.data;
+        if (data && data.access_token && data.expires_in) {
+            // 计算过期时间戳
+            data.expires_at = Math.floor(Date.now() / 1000) + data.expires_in;
+            if (data.refresh_token_expires_in) {
+                data.refresh_token_expires_at = Math.floor(Date.now() / 1000) + data.refresh_token_expires_in;
+            }
+            // 缓存新的token信息
+            const refreshTtl = data.refresh_token_expires_in || 3600 * 24 * 365; // 默认1年
+            tokenCacheManager.cacheUserToken(clientKey, data, refreshTtl);
+            Logger.info('用户访问令牌刷新并缓存成功');
+            return data;
         }
-        if (tokenResult && tokenResult.needAuth && tokenResult.url) {
-            throw new Error(`请在浏览器打开以下链接进行授权：\n\n[点击授权](${tokenResult.url})`);
+        else {
+            Logger.warn('刷新用户访问令牌失败:', data);
+            throw new Error('刷新用户访问令牌失败');
         }
-        throw new Error('无法获取有效的access_token');
     }
     /**
      * 创建飞书文档
@@ -411,6 +532,91 @@ export class FeishuApiService extends BaseApiService {
         const response = await this.post(endpoint, payload);
         return response;
     }
+    /**
+     * 创建表格块
+     * @param documentId 文档ID或URL
+     * @param parentBlockId 父块ID
+     * @param tableConfig 表格配置
+     * @param index 插入位置索引
+     * @returns 创建结果
+     */
+    async createTableBlock(documentId, parentBlockId, tableConfig, index = 0) {
+        const normalizedDocId = ParamUtils.processDocumentId(documentId);
+        const endpoint = `/docx/v1/documents/${normalizedDocId}/blocks/${parentBlockId}/descendant?document_revision_id=-1`;
+        // 处理表格配置，为每个单元格创建正确的内容块
+        const processedTableConfig = {
+            ...tableConfig,
+            cells: tableConfig.cells?.map(cell => ({
+                ...cell,
+                content: this.createBlockContent(cell.content.blockType, cell.content.options)
+            }))
+        };
+        // 使用 BlockFactory 创建表格块内容
+        const tableStructure = this.blockFactory.createTableBlock(processedTableConfig);
+        const payload = {
+            children_id: tableStructure.children_id,
+            descendants: tableStructure.descendants,
+            index
+        };
+        Logger.info(`请求创建表格块: ${tableConfig.rowSize}x${tableConfig.columnSize}，单元格数量: ${tableConfig.cells?.length || 0}`);
+        const response = await this.post(endpoint, payload);
+        // 创建表格成功后，获取单元格中的图片token
+        const imageTokens = await this.extractImageTokensFromTable(response, tableStructure.imageBlocks);
+        return {
+            ...response,
+            imageTokens: imageTokens
+        };
+    }
+    /**
+     * 从表格中提取图片块信息（优化版本）
+     * @param tableResponse 创建表格的响应数据
+     * @param cells 表格配置，包含原始cells信息
+     * @returns 图片块信息数组，包含坐标和块ID信息
+     */
+    async extractImageTokensFromTable(tableResponse, cells) {
+        try {
+            const imageTokens = [];
+            Logger.info(`tableResponse: ${JSON.stringify(tableResponse)}`);
+            // 判断 cells 是否为空
+            if (!cells || cells.length === 0) {
+                Logger.info('表格中没有图片单元格，跳过图片块信息提取');
+                return imageTokens;
+            }
+            // 创建 localBlockId 到 block_id 的映射
+            const blockIdMap = new Map();
+            if (tableResponse && tableResponse.block_id_relations) {
+                for (const relation of tableResponse.block_id_relations) {
+                    blockIdMap.set(relation.temporary_block_id, relation.block_id);
+                }
+                Logger.debug(`创建了 ${blockIdMap.size} 个块ID映射关系`);
+            }
+            // 遍历所有图片单元格
+            for (const cell of cells) {
+                const { coordinate, localBlockId } = cell;
+                const { row, column } = coordinate;
+                // 根据 localBlockId 在创建表格的返回数据中找到 block_id
+                const blockId = blockIdMap.get(localBlockId);
+                if (!blockId) {
+                    Logger.warn(`未找到 localBlockId ${localBlockId} 对应的 block_id`);
+                    continue;
+                }
+                Logger.debug(`处理单元格 (${row}, ${column})，localBlockId: ${localBlockId}，blockId: ${blockId}`);
+                // 直接添加块信息
+                imageTokens.push({
+                    row,
+                    column,
+                    blockId
+                });
+                Logger.info(`提取到图片块信息: 位置(${row}, ${column})，blockId: ${blockId}`);
+            }
+            Logger.info(`成功提取 ${imageTokens.length} 个图片块信息`);
+            return imageTokens;
+        }
+        catch (error) {
+            Logger.error(`提取表格图片块信息失败: ${error}`);
+            return [];
+        }
+    }
     /**
      * 删除文档中的块，支持批量删除
      * @param documentId 文档ID或URL
@@ -793,7 +999,7 @@ export class FeishuApiService extends BaseApiService {
     async searchDocuments(searchKey, count = 50) {
         try {
             Logger.info(`开始搜索文档，关键字: ${searchKey}`);
-            const endpoint = `//suite/docs-api/search/object`;
+            const endpoint = `/suite/docs-api/search/object`;
             let offset = 0;
             let allResults = [];
             let hasMore = true;

package/dist/services/feishuAuthService.js

@@ -1,6 +1,5 @@
 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() {
@@ -10,129 +9,6 @@ export class AuthService {
             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) {
@@ -150,7 +26,6 @@ export class AuthService {
     // 通过授权码换取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,
@@ -168,18 +43,6 @@ export class AuthService {
         });
         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

@@ -137,6 +137,33 @@ export const BlockConfigSchema = z.object({
         z.record(z.any()).describe("Fallback for any other block options")
     ]).describe('Options for the specific block type. Provide the corresponding options object based on blockType.'),
 });
+// 表格列数参数定义
+export const TableColumnSizeSchema = z.number().min(1).describe('Table column size (required). The number of columns in the table. Must be at least 1.');
+// 表格行数参数定义
+export const TableRowSizeSchema = z.number().min(1).describe('Table row size (required). The number of rows in the table. Must be at least 1.');
+// 表格单元格坐标参数定义
+export const TableCellCoordinateSchema = z.object({
+    row: z.number().min(0).describe('Row coordinate (0-based). The row position of the cell in the table.'),
+    column: z.number().min(0).describe('Column coordinate (0-based). The column position of the cell in the table.')
+});
+// 表格单元格内容配置定义
+export const TableCellContentSchema = z.object({
+    coordinate: TableCellCoordinateSchema,
+    content: BlockConfigSchema
+});
+// 表格创建参数定义 - 专门用于创建表格块工具
+export const TableCreateSchema = z.object({
+    columnSize: TableColumnSizeSchema,
+    rowSize: TableRowSizeSchema,
+    cells: z.array(TableCellContentSchema).optional().describe('Array of cell configurations (optional). Each cell specifies its position (row, column) and content block configuration. ' +
+        'If not provided, empty text blocks will be created for all cells. ' +
+        'IMPORTANT: Multiple cells can have the same coordinates (row, column) - when this happens, ' +
+        'the content blocks will be added sequentially to the same cell, allowing you to create rich content ' +
+        'with multiple blocks (text, code, images, etc.) within a single cell. ' +
+        'Example: [{coordinate:{row:0,column:0}, content:{blockType:"text", options:{text:{textStyles:[{text:"Header"}]}}}, ' +
+        '{coordinate:{row:0,column:0}, content:{blockType:"code", options:{code:{code:"console.log(\'hello\')", language:30}}}}] ' +
+        'will add both a text block and a code block to cell (0,0).')
+});
 // 媒体ID参数定义
 export const MediaIdSchema = z.string().describe('Media ID (required). The unique identifier for a media resource (image, file, etc.) in Feishu. ' +
     'Usually obtained from image blocks or file references in documents. ' +