@zzp123/mcp-zentao 1.18.2 → 1.18.4

package/dist/api/zentaoApi.js

@@ -18,13 +18,10 @@ export class ZentaoAPI {
             .update(this.config.password)
             .digest('hex');
         try {
-            console.log('正在请求token...');
-            console.log('请求URL:', `${this.config.url}/api.php/${this.config.apiVersion}/tokens`);
             const response = await this.client.post('/tokens', {
                 account: this.config.username,
                 password,
             });
-            console.log('服务器响应:', response.data);
             if (response.status === 200 || response.status === 201) {
                 if (typeof response.data === 'object' && response.data.token) {
                     this.token = response.data.token;
@@ -47,7 +44,6 @@ export class ZentaoAPI {
     async request(method, url, params, data) {
         const token = await this.getToken();
         try {
-            console.log(`正在请求 ${method} ${url}`, { params, data });
             const response = await this.client.request({
                 method,
                 url,
@@ -55,17 +51,10 @@ export class ZentaoAPI {
                 data,
                 headers: { Token: token },
             });
-            console.log(`响应状态码: ${response.status}`);
-            console.log('响应数据:', response.data);
             return response.data;
         }
         catch (error) {
             if (axios.isAxiosError(error)) {
-                console.error('请求失败:', {
-                    status: error.response?.status,
-                    data: error.response?.data,
-                    message: error.message
-                });
                 throw new Error(`请求失败: ${error.response?.data?.message || error.message}`);
             }
             throw error;
@@ -81,13 +70,10 @@ export class ZentaoAPI {
     }
     async getTaskDetail(taskId) {
         try {
-            console.log(`正在获取任务 ${taskId} 的详情...`);
             const response = await this.request('GET', `/tasks/${taskId}`);
-            console.log('任务详情响应:', response);
             return response;
         }
         catch (error) {
-            console.error('获取任务详情失败:', error);
             throw error;
         }
     }
@@ -164,9 +150,7 @@ export class ZentaoAPI {
     async getProducts(fields) {
         try {
             const finalFields = fields || 'default';
-            console.log(`正在获取产品列表 (fields=${finalFields})...`);
             const response = await this.request('GET', '/products');
-            console.log('产品列表响应:', response);
             let products = [];
             if (Array.isArray(response)) {
                 products = response;
@@ -182,7 +166,6 @@ export class ZentaoAPI {
             return filteredProducts;
         }
         catch (error) {
-            console.error('获取产品列表失败:', error);
             throw error;
         }
     }
@@ -253,7 +236,6 @@ export class ZentaoAPI {
             }
             // 使用第二个产品（如果存在），否则使用第一个
             productId = products.length > 1 ? products[1].id : products[0].id;
-            console.log(`使用产品ID: ${productId} (${products.length > 1 ? '第二个' : '第一个'})`);
         }
         // 固定每页20条
         const finalLimit = 20;
@@ -272,9 +254,7 @@ export class ZentaoAPI {
         // 固定添加状态筛选：只查询指派给我的 Bug
         queryParams.append('status', finalStatus);
         try {
-            console.log(`正在获取产品 ${productId} 的Bug列表，参数: status=${finalStatus}, branch=${finalBranch}, page=${finalPage}, limit=${finalLimit}, order=${finalOrder}, fields=${finalFields}`);
             const response = await this.request('GET', `/products/${productId}/bugs?${queryParams.toString()}`);
-            console.log(`Bug列表响应: 获取到 ${response.bugs?.length || 0} 条数据`);
             let bugs = [];
             if (Array.isArray(response)) {
                 bugs = response;
@@ -305,7 +285,6 @@ export class ZentaoAPI {
             }
         }
         catch (error) {
-            console.error('获取Bug列表失败:', error);
             throw error;
         }
     }
@@ -329,7 +308,6 @@ export class ZentaoAPI {
             const finalBranch = branch || 'all';
             const finalOrder = order || 'id_desc';
             const finalFields = fields || 'basic';
-            console.log(`正在获取产品 ${productId} 的Bug列表 (status=${status || 'all'}, branch=${finalBranch}, page=${finalPage}, limit=${finalLimit}, order=${finalOrder}, fields=${finalFields})...`);
             // 构建查询参数
             const queryParams = new URLSearchParams();
             queryParams.append('branch', finalBranch);
@@ -341,7 +319,6 @@ export class ZentaoAPI {
                 queryParams.append('status', status);
             }
             const response = await this.request('GET', `/products/${productId}/bugs?${queryParams.toString()}`);
-            console.log(`产品Bug列表响应: 获取到 ${response.bugs?.length || 0} 条数据`);
             let bugs = [];
             if (Array.isArray(response)) {
                 bugs = response;
@@ -372,15 +349,12 @@ export class ZentaoAPI {
             }
         }
         catch (error) {
-            console.error('获取产品Bug列表失败:', error);
             throw error;
         }
     }
     async getBugDetail(bugId, fields) {
         try {
-            console.log(`正在获取Bug ${bugId} 的详情 (fields=${fields || 'full'})...`);
             const response = await this.request('GET', `/bugs/${bugId}`);
-            console.log('Bug详情响应:', response);
             // 根据 fields 参数过滤返回的字段
             const fieldLevel = fields || 'full';
             if (fieldLevel === 'basic') {
@@ -411,48 +385,39 @@ export class ZentaoAPI {
             }
         }
         catch (error) {
-            console.error('获取Bug详情失败:', error);
             throw error;
         }
     }
     async resolveBug(bugId, resolution) {
         try {
-            console.log(`正在解决Bug ${bugId}...`);
             // 验证必填字段并设置默认值
             if (resolution.resolution === 'fixed' && !resolution.resolvedBuild) {
-                console.log('解决方案为"fixed"时未提供resolvedBuild，自动设置为"trunk"');
                 resolution.resolvedBuild = 'trunk';
             }
             if (resolution.resolution === 'duplicate' && !resolution.duplicateBug) {
                 throw new Error('当解决方案为"重复Bug(duplicate)"时，必须提供重复Bug的ID(duplicateBug)');
             }
             const response = await this.request('POST', `/bugs/${bugId}/resolve`, undefined, resolution);
-            console.log('Bug解决响应:', response);
             return response;
         }
         catch (error) {
-            console.error('解决Bug失败:', error);
             throw error;
         }
     }
     async updateTask(taskId, update) {
         try {
-            console.log(`正在更新任务 ${taskId}...`);
             const response = await this.request('PUT', `/tasks/${taskId}`, undefined, {
                 ...update,
                 assignedTo: this.config.username,
             });
-            console.log('任务更新响应:', response);
             return response;
         }
         catch (error) {
-            console.error('更新任务失败:', error);
             throw error;
         }
     }
     async finishTask(taskId, update = {}) {
         try {
-            console.log(`正在完成任务 ${taskId}...`);
             const finalUpdate = {
                 status: 'done',
                 finishedDate: new Date().toISOString(),
@@ -461,13 +426,11 @@ export class ZentaoAPI {
             return await this.updateTask(taskId, finalUpdate);
         }
         catch (error) {
-            console.error('完成任务失败:', error);
             throw error;
         }
     }
     async createTask(task) {
         try {
-            console.log('正在创建新任务...');
             if (!task.execution) {
                 throw new Error('创建任务需要指定执行ID');
             }
@@ -488,20 +451,16 @@ export class ZentaoAPI {
             });
             // 在URL中添加执行ID
             const response = await this.request('POST', `/executions/${task.execution}/tasks`, undefined, formData);
-            console.log('创建任务响应:', response);
             return response;
         }
         catch (error) {
-            console.error('创建任务失败:', error);
             throw error;
         }
     }
     async getPrograms(order) {
         try {
-            console.log('正在获取项目集列表...');
             const params = order ? { order } : undefined;
             const response = await this.request('GET', '/programs', params);
-            console.log('项目集列表响应:', response);
             if (Array.isArray(response)) {
                 return response;
             }
@@ -513,13 +472,11 @@ export class ZentaoAPI {
             throw new Error(`获取项目集列表失败: 响应格式不正确 ${JSON.stringify(response)}`);
         }
         catch (error) {
-            console.error('获取项目集列表失败:', error);
             throw error;
         }
     }
     async getProductPlans(productId, branch, begin, end, status, parent) {
         try {
-            console.log(`正在获取产品 ${productId} 的计划列表...`);
             const data = {};
             if (branch !== undefined)
                 data.branch = branch;
@@ -532,7 +489,6 @@ export class ZentaoAPI {
             if (parent !== undefined)
                 data.parent = parent;
             const response = await this.request('POST', `/products/${productId}/plans`, undefined, data);
-            console.log('产品计划列表响应:', response);
             if (Array.isArray(response)) {
                 return response;
             }
@@ -544,119 +500,92 @@ export class ZentaoAPI {
             throw new Error(`获取产品计划列表失败: 响应格式不正确 ${JSON.stringify(response)}`);
         }
         catch (error) {
-            console.error('获取产品计划列表失败:', error);
             throw error;
         }
     }
     async createStory(story) {
         try {
-            console.log('正在创建新需求...');
             const response = await this.request('POST', '/stories', undefined, story);
-            console.log('创建需求响应:', response);
             return response;
         }
         catch (error) {
-            console.error('创建需求失败:', error);
             throw error;
         }
     }
     async getPlanDetail(planId) {
         try {
-            console.log(`正在获取计划 ${planId} 的详情...`);
             const response = await this.request('GET', `/productplans/${planId}`);
-            console.log('计划详情响应:', response);
             return response;
         }
         catch (error) {
-            console.error('获取计划详情失败:', error);
             throw error;
         }
     }
     async updatePlan(planId, update) {
         try {
-            console.log(`正在更新计划 ${planId}...`);
             const response = await this.request('PUT', `/products/plans/${planId}`, undefined, update);
-            console.log('更新计划响应:', response);
             return response;
         }
         catch (error) {
-            console.error('更新计划失败:', error);
             throw error;
         }
     }
     async deletePlan(planId) {
         try {
-            console.log(`正在删除计划 ${planId}...`);
             const response = await this.request('DELETE', `/products/plans/${planId}`);
-            console.log('删除计划响应:', response);
             return response;
         }
         catch (error) {
-            console.error('删除计划失败:', error);
             throw error;
         }
     }
     async linkStoriesToPlan(planId, storyIds) {
         try {
-            console.log(`正在为计划 ${planId} 关联需求...`);
             const response = await this.request('POST', `/productplans/${planId}/linkstories`, undefined, {
                 stories: storyIds
             });
-            console.log('关联需求响应:', response);
             return response;
         }
         catch (error) {
-            console.error('关联需求失败:', error);
             throw error;
         }
     }
     async unlinkStoriesFromPlan(planId, storyIds) {
         try {
-            console.log(`正在为计划 ${planId} 取消关联需求...`);
             const response = await this.request('POST', `/productplans/${planId}/unlinkstories`, undefined, {
                 stories: storyIds
             });
-            console.log('取消关联需求响应:', response);
             return response;
         }
         catch (error) {
-            console.error('取消关联需求失败:', error);
             throw error;
         }
     }
     async linkBugsToPlan(planId, bugIds) {
         try {
-            console.log(`正在为计划 ${planId} 关联Bug...`);
             const response = await this.request('POST', `/products/${planId}/linkBugs`, undefined, {
                 bugs: bugIds
             });
-            console.log('关联Bug响应:', response);
             return response;
         }
         catch (error) {
-            console.error('关联Bug失败:', error);
             throw error;
         }
     }
     async unlinkBugsFromPlan(planId, bugIds) {
         try {
-            console.log(`正在为计划 ${planId} 取消关联Bug...`);
             const response = await this.request('POST', `/productplans/${planId}/unlinkbugs`, undefined, {
                 bugs: bugIds
             });
-            console.log('取消关联Bug响应:', response);
             return response;
         }
         catch (error) {
-            console.error('取消关联Bug失败:', error);
             throw error;
         }
     }
     async getProjectReleases(projectId) {
         try {
-            console.log(`正在获取项目 ${projectId} 的发布列表...`);
             const response = await this.request('GET', `/projects/${projectId}/releases`);
-            console.log('发布列表响应:', response);
             if (Array.isArray(response)) {
                 return response;
             }
@@ -668,15 +597,12 @@ export class ZentaoAPI {
             throw new Error(`获取发布列表失败: 响应格式不正确 ${JSON.stringify(response)}`);
         }
         catch (error) {
-            console.error('获取发布列表失败:', error);
             throw error;
         }
     }
     async getStoryDetail(storyId, fields) {
         try {
-            console.log(`正在获取需求 ${storyId} 的详情 (fields=${fields || 'full'})...`);
             const response = await this.request('GET', `/stories/${storyId}`);
-            console.log('需求详情响应:', response);
             // 根据 fields 参数过滤返回的字段
             const fieldLevel = fields || 'full';
             if (fieldLevel === 'basic') {
@@ -707,27 +633,21 @@ export class ZentaoAPI {
             }
         }
         catch (error) {
-            console.error('获取需求详情失败:', error);
             throw error;
         }
     }
     async createBug(productId, bug) {
         try {
-            console.log(`正在为产品 ${productId} 创建Bug...`);
             const response = await this.request('POST', `/products/${productId}/bugs`, undefined, bug);
-            console.log('创建Bug响应:', response);
             return response;
         }
         catch (error) {
-            console.error('创建Bug失败:', error);
             throw error;
         }
     }
     async getProjectExecutions(projectId) {
         try {
-            console.log(`正在获取项目 ${projectId} 的执行列表...`);
             const response = await this.request('GET', `/projects/${projectId}/executions`);
-            console.log('执行列表响应:', response);
             if (Array.isArray(response)) {
                 return response;
             }
@@ -739,32 +659,26 @@ export class ZentaoAPI {
             throw new Error(`获取执行列表失败: 响应格式不正确 ${JSON.stringify(response)}`);
         }
         catch (error) {
-            console.error('获取执行列表失败:', error);
             throw error;
         }
     }
     async createPlan(productId, plan) {
         try {
-            console.log(`正在为产品 ${productId} 创建计划...`);
             const response = await this.request('POST', `/products/${productId}/plans`, undefined, plan);
-            console.log('创建计划响应:', response);
             return response;
         }
         catch (error) {
-            console.error('创建计划失败:', error);
             throw error;
         }
     }
     async getProjects(page, limit) {
         try {
-            console.log('正在获取项目列表...');
             const params = {};
             if (page)
                 params.page = page;
             if (limit)
                 params.limit = limit;
             const response = await this.request('GET', '/projects', params);
-            console.log('项目列表响应:', response);
             if (Array.isArray(response)) {
                 return response;
             }
@@ -776,7 +690,6 @@ export class ZentaoAPI {
             throw new Error(`获取项目列表失败: 响应格式不正确 ${JSON.stringify(response)}`);
         }
         catch (error) {
-            console.error('获取项目列表失败:', error);
             throw error;
         }
     }
@@ -792,33 +705,26 @@ export class ZentaoAPI {
      */
     async changeStory(storyId, update) {
         try {
-            console.log(`正在更新需求 ${storyId}...`);
             // 自动处理评审人问题
             const updateData = { ...update };
             // 如果用户没有设置评审人，也没有指定无需评审，则自动跳过评审
             if (!updateData.reviewer && updateData.needNotReview !== true) {
                 updateData.needNotReview = true;
-                console.log('自动设置needNotReview=true以跳过评审要求');
             }
             // 使用 PUT /stories/:id 接口
             const response = await this.request('PUT', `/stories/${storyId}`, undefined, updateData);
-            console.log('更新需求响应:', response);
             return response;
         }
         catch (error) {
-            console.error('更新需求失败:', error);
             throw error;
         }
     }
     async deleteTask(taskId) {
         try {
-            console.log(`正在删除任务 ${taskId}...`);
             const response = await this.request('DELETE', `/tasks/${taskId}`);
-            console.log('删除任务响应:', response);
             return response;
         }
         catch (error) {
-            console.error('删除任务失败:', error);
             throw error;
         }
     }
@@ -835,14 +741,12 @@ export class ZentaoAPI {
             // 默认每页20条，最多100条
             const finalLimit = limit ? Math.min(limit, 100) : 20;
             const finalPage = page || 1;
-            const finalFields = fields || 'basic'; // 默认只返回基本字段
-            console.log(`正在获取产品 ${productId} 的需求列表 (page=${finalPage}, limit=${finalLimit}, fields=${finalFields})...`);
+            const finalFields = fields || 'basic';
             // 构建查询参数
             const queryParams = new URLSearchParams();
             queryParams.append('page', finalPage.toString());
             queryParams.append('limit', finalLimit.toString());
             const response = await this.request('GET', `/products/${productId}/stories?${queryParams.toString()}`);
-            console.log(`产品需求列表响应: 获取到 ${response.stories?.length || 0} 条数据`);
             let stories = [];
             if (Array.isArray(response)) {
                 stories = response;
@@ -873,594 +777,449 @@ export class ZentaoAPI {
             }
         }
         catch (error) {
-            console.error('获取产品需求列表失败:', error);
             throw error;
         }
     }
     // 项目集相关接口
     async getProgramDetail(programId) {
         try {
-            console.log(`正在获取项目集 ${programId} 的详情...`);
             const response = await this.request('GET', `/programs/${programId}`);
-            console.log('项目集详情响应:', response);
             return response;
         }
         catch (error) {
-            console.error('获取项目集详情失败:', error);
             throw error;
         }
     }
     async createProgram(program) {
         try {
-            console.log('正在创建项目集...');
             const response = await this.request('POST', '/programs', undefined, program);
-            console.log('创建项目集响应:', response);
             return response;
         }
         catch (error) {
-            console.error('创建项目集失败:', error);
             throw error;
         }
     }
     async updateProgram(programId, update) {
         try {
-            console.log(`正在更新项目集 ${programId}...`);
             const response = await this.request('PUT', `/programs/${programId}`, undefined, update);
-            console.log('更新项目集响应:', response);
             return response;
         }
         catch (error) {
-            console.error('更新项目集失败:', error);
             throw error;
         }
     }
     async deleteProgram(programId) {
         try {
-            console.log(`正在删除项目集 ${programId}...`);
             const response = await this.request('DELETE', `/programs/${programId}`);
-            console.log('删除项目集响应:', response);
             return response;
         }
         catch (error) {
-            console.error('删除项目集失败:', error);
             throw error;
         }
     }
     // 产品相关接口
     async getProductDetail(productId) {
         try {
-            console.log(`正在获取产品 ${productId} 的详情...`);
             const response = await this.request('GET', `/products/${productId}`);
-            console.log('产品详情响应:', response);
             return response;
         }
         catch (error) {
-            console.error('获取产品详情失败:', error);
             throw error;
         }
     }
     async createProduct(product) {
         try {
-            console.log('正在创建产品...');
             const response = await this.request('POST', '/products', undefined, product);
-            console.log('创建产品响应:', response);
             return response;
         }
         catch (error) {
-            console.error('创建产品失败:', error);
             throw error;
         }
     }
     async updateProduct(productId, update) {
         try {
-            console.log(`正在更新产品 ${productId}...`);
             const response = await this.request('PUT', `/product/${productId}`, undefined, update);
-            console.log('更新产品响应:', response);
             return response;
         }
         catch (error) {
-            console.error('更新产品失败:', error);
             throw error;
         }
     }
     async deleteProduct(productId) {
         try {
-            console.log(`正在删除产品 ${productId}...`);
             const response = await this.request('DELETE', `/product/${productId}`);
-            console.log('删除产品响应:', response);
             return response;
         }
         catch (error) {
-            console.error('删除产品失败:', error);
             throw error;
         }
     }
     // 项目相关接口
     async getProjectDetail(projectId) {
         try {
-            console.log(`正在获取项目 ${projectId} 的详情...`);
             const response = await this.request('GET', `/projects/${projectId}`);
-            console.log('项目详情响应:', response);
             return response;
         }
         catch (error) {
-            console.error('获取项目详情失败:', error);
             throw error;
         }
     }
     async createProject(project) {
         try {
-            console.log('正在创建项目...');
             const response = await this.request('POST', '/projects', undefined, project);
-            console.log('创建项目响应:', response);
             return response;
         }
         catch (error) {
-            console.error('创建项目失败:', error);
             throw error;
         }
     }
     async updateProject(projectId, update) {
         try {
-            console.log(`正在更新项目 ${projectId}...`);
             const response = await this.request('PUT', `/projects/${projectId}`, undefined, update);
-            console.log('更新项目响应:', response);
             return response;
         }
         catch (error) {
-            console.error('更新项目失败:', error);
             throw error;
         }
     }
     async deleteProject(projectId) {
         try {
-            console.log(`正在删除项目 ${projectId}...`);
             const response = await this.request('DELETE', `/projects/${projectId}`);
-            console.log('删除项目响应:', response);
             return response;
         }
         catch (error) {
-            console.error('删除项目失败:', error);
             throw error;
         }
     }
     // 执行相关接口
     async createExecution(projectId, execution) {
         try {
-            console.log(`正在为项目 ${projectId} 创建执行...`);
             const response = await this.request('POST', `/projects/${projectId}/executions`, undefined, execution);
-            console.log('创建执行响应:', response);
             return response;
         }
         catch (error) {
-            console.error('创建执行失败:', error);
             throw error;
         }
     }
     async getExecutionDetail(executionId) {
         try {
-            console.log(`正在获取执行 ${executionId} 的详情...`);
             const response = await this.request('GET', `/executions/${executionId}`);
-            console.log('执行详情响应:', response);
             return response;
         }
         catch (error) {
-            console.error('获取执行详情失败:', error);
             throw error;
         }
     }
     async updateExecution(executionId, update) {
         try {
-            console.log(`正在更新执行 ${executionId}...`);
             const response = await this.request('PUT', `/executions/${executionId}`, undefined, update);
-            console.log('更新执行响应:', response);
             return response;
         }
         catch (error) {
-            console.error('更新执行失败:', error);
             throw error;
         }
     }
     async deleteExecution(executionId) {
         try {
-            console.log(`正在删除执行 ${executionId}...`);
             const response = await this.request('DELETE', `/executions/${executionId}`);
-            console.log('删除执行响应:', response);
             return response;
         }
         catch (error) {
-            console.error('删除执行失败:', error);
             throw error;
         }
     }
     // 需求相关接口
     async deleteStory(storyId) {
         try {
-            console.log(`正在删除需求 ${storyId}...`);
             const response = await this.request('DELETE', `/stories/${storyId}`);
-            console.log('删除需求响应:', response);
             return response;
         }
         catch (error) {
-            console.error('删除需求失败:', error);
             throw error;
         }
     }
     // Bug相关接口
     async updateBug(bugId, update) {
         try {
-            console.log(`正在更新Bug ${bugId}...`);
             const response = await this.request('PUT', `/bugs/${bugId}`, undefined, update);
-            console.log('更新Bug响应:', response);
             return response;
         }
         catch (error) {
-            console.error('更新Bug失败:', error);
             throw error;
         }
     }
     async deleteBug(bugId) {
         try {
-            console.log(`正在删除Bug ${bugId}...`);
             const response = await this.request('DELETE', `/bugs/${bugId}`);
-            console.log('删除Bug响应:', response);
             return response;
         }
         catch (error) {
-            console.error('删除Bug失败:', error);
             throw error;
         }
     }
     // 反馈模块接口
     async getFeedbacks(params) {
         try {
-            console.log('正在获取反馈列表...');
             const response = await this.request('GET', '/feedbacks', params);
-            console.log('获取反馈列表响应:', response);
             return response;
         }
         catch (error) {
-            console.error('获取反馈列表失败:', error);
             throw error;
         }
     }
     async getFeedbackDetail(feedbackId) {
         try {
-            console.log(`正在获取反馈 ${feedbackId} 的详情...`);
             const response = await this.request('GET', `/feedbacks/${feedbackId}`);
-            console.log('获取反馈详情响应:', response);
             return response;
         }
         catch (error) {
-            console.error('获取反馈详情失败:', error);
             throw error;
         }
     }
     async createFeedback(feedback) {
         try {
-            console.log('正在创建反馈...');
             const response = await this.request('POST', '/feedbacks', undefined, feedback);
-            console.log('创建反馈响应:', response);
             return response;
         }
         catch (error) {
-            console.error('创建反馈失败:', error);
             throw error;
         }
     }
     async updateFeedback(feedbackId, update) {
         try {
-            console.log(`正在更新反馈 ${feedbackId}...`);
             const response = await this.request('PUT', `/feedbacks/${feedbackId}`, undefined, update);
-            console.log('更新反馈响应:', response);
             return response;
         }
         catch (error) {
-            console.error('更新反馈失败:', error);
             throw error;
         }
     }
     async deleteFeedback(feedbackId) {
         try {
-            console.log(`正在删除反馈 ${feedbackId}...`);
             const response = await this.request('DELETE', `/feedbacks/${feedbackId}`);
-            console.log('删除反馈响应:', response);
             return response;
         }
         catch (error) {
-            console.error('删除反馈失败:', error);
             throw error;
         }
     }
     async assignFeedback(feedbackId, assign) {
         try {
-            console.log(`正在指派反馈 ${feedbackId}...`);
             const response = await this.request('POST', `/feedbacks/${feedbackId}/assign`, undefined, assign);
-            console.log('指派反馈响应:', response);
             return response;
         }
         catch (error) {
-            console.error('指派反馈失败:', error);
             throw error;
         }
     }
     async closeFeedback(feedbackId, close) {
         try {
-            console.log(`正在关闭反馈 ${feedbackId}...`);
             const response = await this.request('POST', `/feedbacks/${feedbackId}/close`, undefined, close);
-            console.log('关闭反馈响应:', response);
             return response;
         }
         catch (error) {
-            console.error('关闭反馈失败:', error);
             throw error;
         }
     }
     // 测试用例模块接口
     async getProductTestCases(productId) {
         try {
-            console.log(`正在获取产品 ${productId} 的测试用例列表...`);
             const response = await this.request('GET', `/products/${productId}/testcases`);
-            console.log('获取测试用例列表响应:', response);
             return response;
         }
         catch (error) {
-            console.error('获取测试用例列表失败:', error);
             throw error;
         }
     }
     async createTestCase(productId, testCase) {
         try {
-            console.log(`正在为产品 ${productId} 创建测试用例...`);
             const response = await this.request('POST', `/products/${productId}/testcases`, undefined, testCase);
-            console.log('创建测试用例响应:', response);
             return response;
         }
         catch (error) {
-            console.error('创建测试用例失败:', error);
             throw error;
         }
     }
     async getTestCaseDetail(testCaseId) {
         try {
-            console.log(`正在获取测试用例 ${testCaseId} 的详情...`);
             const response = await this.request('GET', `/testcases/${testCaseId}`);
-            console.log('获取测试用例详情响应:', response);
             return response;
         }
         catch (error) {
-            console.error('获取测试用例详情失败:', error);
             throw error;
         }
     }
     async updateTestCase(testCaseId, update) {
         try {
-            console.log(`正在更新测试用例 ${testCaseId}...`);
             const response = await this.request('PUT', `/testcases/${testCaseId}`, undefined, update);
-            console.log('更新测试用例响应:', response);
             return response;
         }
         catch (error) {
-            console.error('更新测试用例失败:', error);
             throw error;
         }
     }
     async deleteTestCase(testCaseId) {
         try {
-            console.log(`正在删除测试用例 ${testCaseId}...`);
             const response = await this.request('DELETE', `/testcases/${testCaseId}`);
-            console.log('删除测试用例响应:', response);
             return response;
         }
         catch (error) {
-            console.error('删除测试用例失败:', error);
             throw error;
         }
     }
     // 版本/构建模块接口
     async getProjectBuilds(projectId) {
         try {
-            console.log(`正在获取项目 ${projectId} 的版本列表...`);
             const response = await this.request('GET', `/projects/${projectId}/builds`);
-            console.log('获取版本列表响应:', response);
             return response;
         }
         catch (error) {
-            console.error('获取版本列表失败:', error);
             throw error;
         }
     }
     async getExecutionBuilds(executionId) {
         try {
-            console.log(`正在获取执行 ${executionId} 的版本列表...`);
             const response = await this.request('GET', `/executions/${executionId}/builds`);
-            console.log('获取版本列表响应:', response);
             return response;
         }
         catch (error) {
-            console.error('获取版本列表失败:', error);
             throw error;
         }
     }
     async createBuild(projectId, build) {
         try {
-            console.log(`正在为项目 ${projectId} 创建版本...`);
             const response = await this.request('POST', `/projects/${projectId}/builds`, undefined, build);
-            console.log('创建版本响应:', response);
             return response;
         }
         catch (error) {
-            console.error('创建版本失败:', error);
             throw error;
         }
     }
     async getBuildDetail(buildId) {
         try {
-            console.log(`正在获取版本 ${buildId} 的详情...`);
             const response = await this.request('GET', `/builds/${buildId}`);
-            console.log('获取版本详情响应:', response);
             return response;
         }
         catch (error) {
-            console.error('获取版本详情失败:', error);
             throw error;
         }
     }
     async updateBuild(buildId, update) {
         try {
-            console.log(`正在更新版本 ${buildId}...`);
             const response = await this.request('PUT', `/builds/${buildId}`, undefined, update);
-            console.log('更新版本响应:', response);
             return response;
         }
         catch (error) {
-            console.error('更新版本失败:', error);
             throw error;
         }
     }
     async deleteBuild(buildId) {
         try {
-            console.log(`正在删除版本 ${buildId}...`);
             const response = await this.request('DELETE', `/builds/${buildId}`);
-            console.log('删除版本响应:', response);
             return response;
         }
         catch (error) {
-            console.error('删除版本失败:', error);
             throw error;
         }
     }
     // 用户模块接口
     async getUserDetail(userId) {
         try {
-            console.log(`正在获取用户 ${userId} 的详情...`);
             const response = await this.request('GET', `/users/${userId}`);
-            console.log('获取用户详情响应:', response);
             return response;
         }
         catch (error) {
-            console.error('获取用户详情失败:', error);
             throw error;
         }
     }
     async getMyProfile() {
         try {
-            console.log('正在获取我的个人信息...');
             const response = await this.request('GET', '/user');
-            console.log('获取个人信息响应:', response);
             return response;
         }
         catch (error) {
-            console.error('获取个人信息失败:', error);
             throw error;
         }
     }
     async getUsers(params) {
         try {
-            console.log('正在获取用户列表...');
             const response = await this.request('GET', '/users', params);
-            console.log('获取用户列表响应:', response);
             return response;
         }
         catch (error) {
-            console.error('获取用户列表失败:', error);
             throw error;
         }
     }
     async createUser(user) {
         try {
-            console.log('正在创建用户...');
             const response = await this.request('POST', '/users', undefined, user);
-            console.log('创建用户响应:', response);
             return response;
         }
         catch (error) {
-            console.error('创建用户失败:', error);
             throw error;
         }
     }
     async updateUser(userId, update) {
         try {
-            console.log(`正在更新用户 ${userId}...`);
             const response = await this.request('PUT', `/users/${userId}`, undefined, update);
-            console.log('更新用户响应:', response);
             return response;
         }
         catch (error) {
-            console.error('更新用户失败:', error);
             throw error;
         }
     }
     async deleteUser(userId) {
         try {
-            console.log(`正在删除用户 ${userId}...`);
             const response = await this.request('DELETE', `/users/${userId}`);
-            console.log('删除用户响应:', response);
             return response;
         }
         catch (error) {
-            console.error('删除用户失败:', error);
             throw error;
         }
     }
     // 工单模块接口
     async getTickets(params) {
         try {
-            console.log('正在获取工单列表...');
             const response = await this.request('GET', '/tickets', params);
-            console.log('获取工单列表响应:', response);
             return response;
         }
         catch (error) {
-            console.error('获取工单列表失败:', error);
             throw error;
         }
     }
     async getTicketDetail(ticketId) {
         try {
-            console.log(`正在获取工单 ${ticketId} 的详情...`);
             const response = await this.request('GET', `/tickets/${ticketId}`);
-            console.log('获取工单详情响应:', response);
             return response;
         }
         catch (error) {
-            console.error('获取工单详情失败:', error);
             throw error;
         }
     }
     async createTicket(ticket) {
         try {
-            console.log('正在创建工单...');
             const response = await this.request('POST', '/tickets', undefined, ticket);
-            console.log('创建工单响应:', response);
             return response;
         }
         catch (error) {
-            console.error('创建工单失败:', error);
             throw error;
         }
     }
     async updateTicket(ticketId, update) {
         try {
-            console.log(`正在更新工单 ${ticketId}...`);
             const response = await this.request('PUT', `/tickets/${ticketId}`, undefined, update);
-            console.log('更新工单响应:', response);
             return response;
         }
         catch (error) {
-            console.error('更新工单失败:', error);
             throw error;
         }
     }
     async deleteTicket(ticketId) {
         try {
-            console.log(`正在删除工单 ${ticketId}...`);
             const response = await this.request('DELETE', `/tickets/${ticketId}`);
-            console.log('删除工单响应:', response);
             return response;
         }
         catch (error) {
-            console.error('删除工单失败:', error);
             throw error;
         }
     }
@@ -1474,25 +1233,21 @@ export class ZentaoAPI {
      */
     async getModules(type, id, fields) {
         try {
-            console.log(`正在获取模块列表，类型: ${type}, ID: ${id}, 字段: ${fields || '默认'}...`);
             const params = { type, id };
             if (fields) {
                 params.fields = fields;
             }
             // 使用新的自定义接口路径
             const response = await this.request('GET', '/custom/modules', params);
-            console.log(`获取模块列表成功，共 ${response.total} 个模块`);
             return response;
         }
         catch (error) {
-            console.error('获取模块列表失败:', error);
             throw error;
         }
     }
     // 文件相关API
     async uploadFile(uploadRequest) {
         try {
-            console.log(`正在上传文件: ${uploadRequest.filename}...`);
             const token = await this.getToken();
             // 创建FormData
             const FormData = (await import('form-data')).default;
@@ -1509,17 +1264,14 @@ export class ZentaoAPI {
                     ...formData.getHeaders()
                 },
             });
-            console.log('上传文件响应:', response.data);
             return response.data;
         }
         catch (error) {
-            console.error('上传文件失败:', error);
             throw error;
         }
     }
     async downloadFile(fileId) {
         try {
-            console.log(`正在下载文件 ${fileId}...`);
             const token = await this.getToken();
             const response = await this.client.request({
                 method: 'GET',
@@ -1527,11 +1279,9 @@ export class ZentaoAPI {
                 headers: { Token: token },
                 responseType: 'arraybuffer'
             });
-            console.log('下载文件成功');
             return Buffer.from(response.data);
         }
         catch (error) {
-            console.error('下载文件失败:', error);
             throw error;
         }
     }
@@ -1542,13 +1292,10 @@ export class ZentaoAPI {
      */
     async getComments(objectType, objectID) {
         try {
-            console.log(`正在获取 ${objectType} ${objectID} 的评论列表...`);
             const response = await this.request('GET', `/comments/${objectType}/${objectID}`);
-            console.log('获取评论列表响应:', response);
             return response;
         }
         catch (error) {
-            console.error('获取评论列表失败:', error);
             throw error;
         }
     }
@@ -1558,13 +1305,10 @@ export class ZentaoAPI {
      */
     async getCommentDetail(commentId) {
         try {
-            console.log(`正在获取评论 ${commentId} 的详情...`);
             const response = await this.request('GET', `/comment/${commentId}`);
-            console.log('获取评论详情响应:', response);
             return response;
         }
         catch (error) {
-            console.error('获取评论详情失败:', error);
             throw error;
         }
     }
@@ -1574,13 +1318,10 @@ export class ZentaoAPI {
      */
     async addComment(request) {
         try {
-            console.log(`正在为 ${request.objectType} ${request.objectID} 添加评论...`);
             const response = await this.request('POST', '/comment', undefined, request);
-            console.log('添加评论响应:', response);
             return response;
         }
         catch (error) {
-            console.error('添加评论失败:', error);
             throw error;
         }
     }
@@ -1590,13 +1331,10 @@ export class ZentaoAPI {
      */
     async updateComment(commentId, update) {
         try {
-            console.log(`正在更新评论 ${commentId}...`);
             const response = await this.request('PUT', `/comment/${commentId}`, undefined, update);
-            console.log('更新评论响应:', response);
             return response;
         }
         catch (error) {
-            console.error('更新评论失败:', error);
             throw error;
         }
     }
@@ -1606,13 +1344,10 @@ export class ZentaoAPI {
      */
     async deleteComment(commentId) {
         try {
-            console.log(`正在删除评论 ${commentId}...`);
             const response = await this.request('DELETE', `/comment/${commentId}`);
-            console.log('删除评论响应:', response);
             return response;
         }
         catch (error) {
-            console.error('删除评论失败:', error);
             throw error;
         }
     }