@maxenlin/mcp-zentao-11-3 1.0.1 → 1.0.3

package/README.md

@@ -15,27 +15,7 @@
 
 ## 📦 安装
 
-### 方法 1：使用 npx（推荐）
-
-在支持 MCP 的 IDE/工具配置文件中添加（以 Cursor IDE 为例）：
-
-```json
-{
-  "mcpServers": {
-    "zentao-11-3": {
-      "command": "npx",
-      "args": ["-y", "@maxenlin/mcp-zentao-11-3"],
-      "env": {
-        "ZENTAO_URL": "http://your-zentao-url/zentao",
-        "ZENTAO_USERNAME": "your-username",
-        "ZENTAO_PASSWORD": "your-password"
-      }
-    }
-  }
-}
-```
-
-### 方法 2：本地安装
+### 方法 1：本地安装
 
 ```bash
 npm install -g @maxenlin/mcp-zentao-11-3
@@ -59,18 +39,21 @@ npm install -g @maxenlin/mcp-zentao-11-3
 }
 ```
 
-## ⚙️ 配置
+**配置说明：**
+- `ZENTAO_URL`: 禅道服务器地址（必须包含 `/zentao` 路径）
+- `ZENTAO_USERNAME`: 禅道用户名
+- `ZENTAO_PASSWORD`: 禅道密码
 
-### 方法 1：在 Cursor 配置中直接设置（推荐）
+### 方法 2：使用 npx
 
-在支持 MCP 的 IDE/工具的配置文件中，直接在 `env` 字段中填入配置（以 Cursor IDE 为例）：
+在支持 MCP 的 IDE/工具配置文件中添加（以 Cursor IDE 为例）：
 
 ```json
 {
   "mcpServers": {
     "zentao-11-3": {
-      "command": "mcp-zentao-11-3",
-      "args": [],
+      "command": "npx",
+      "args": ["-y", "@maxenlin/mcp-zentao-11-3"],
       "env": {
         "ZENTAO_URL": "http://your-zentao-url/zentao",
         "ZENTAO_USERNAME": "your-username",
@@ -86,33 +69,6 @@ npm install -g @maxenlin/mcp-zentao-11-3
 - `ZENTAO_USERNAME`: 禅道用户名
 - `ZENTAO_PASSWORD`: 禅道密码
 
-### 方法 2：使用配置文件（备选）
-
-如果不想在 Cursor 配置中直接填写密码，可以创建配置文件：
-
-**Windows:**
-```
-C:\Users\你的用户名\.zentao\config.json
-```
-
-**macOS/Linux:**
-```
-~/.zentao/config.json
-```
-
-配置文件内容：
-
-```json
-{
-  "url": "http://your-zentao-url/zentao",
-  "username": "your-username",
-  "password": "your-password",
-  "apiVersion": "legacy"
-}
-```
-
-**注意：** 环境变量配置优先于配置文件。如果同时设置了环境变量和配置文件，将使用环境变量中的配置。
-
 ## 🚀 使用
 
 配置完成后，重启您的 IDE/工具即可使用。
@@ -176,70 +132,84 @@ C:\Users\你的用户名\.zentao\config.json
 ## 📋 可用工具
 
 ### 配置管理
+
 - `initZentao` - 初始化禅道连接
 - `getConfig` - 查看配置信息
 
 ### 任务管理
+
 - `getMyTasks` - 获取我的任务列表
 - `getTaskDetail` - 获取任务详情
 - `updateTask` - 更新任务
 - `finishTask` - 完成任务
 
 ### Bug 管理
+
 - `getMyBugs` - 获取我的Bug列表
 - `getBugDetail` - 获取Bug详情
 - `resolveBug` - 解决Bug
 
 ### 产品管理
+
 - `getProducts` - 获取产品列表
 
 ### 需求管理
+
 - `getProductStories` - 获取产品的需求列表
 - `getStoryDetail` - 获取需求详情
 - `searchStories` - 搜索需求
 - `searchStoriesByProductName` - 按产品名称搜索需求
 
 ### 测试用例管理
+
 - `getProductTestCases` - 获取产品的测试用例
 - `getTestCaseDetail` - 获取测试用例详情
 - `createTestCase` - 创建测试用例
 - `getStoryTestCases` - 获取需求的测试用例
 
 ### 测试单管理
+
 - `getTestTasks` - 获取测试单列表
 - `getTestTaskDetail` - 获取测试单详情
 - `getTestTaskResults` - 获取测试单的测试结果
 - `runTestCase` - 执行测试用例
 
 ### 关联关系查询
+
 - `getStoryRelatedBugs` - 获取需求关联的 Bug 列表
 - `getBugRelatedStory` - 获取 Bug 关联的需求
 
 ### 批量操作
+
 - `batchUpdateTasks` - 批量更新任务
 - `batchResolveBugs` - 批量解决 Bug
 
 ### 数据统计
+
 - `getMyTaskStatistics` - 获取我的任务统计信息
 - `getMyBugStatistics` - 获取我的 Bug 统计信息
 
 ### AI 编程辅助功能
+
 - `getDevelopmentContext` - 获取需求/Bug 的完整开发上下文（包含关联信息）
 - `generateStorySummary` - 生成需求摘要（支持 JSON/Markdown/文本格式）
 - `generateBugSummary` - 生成 Bug 摘要（支持 JSON/Markdown/文本格式）
 - `formatTaskAsMarkdown` - 将任务格式化为 Markdown
 
 ### 智能分析功能
+
 - `analyzeStoryComplexity` - 分析需求复杂度（评分、工时估算、优先级建议）
 - `analyzeBugPriority` - 分析 Bug 优先级（评分、优先级建议）
 - `analyzeTaskWorkload` - 分析任务工作量（工时估算、难度评估）
 
 ### 代码生成提示
+
 - `generateCodePromptFromStory` - 根据需求生成代码框架提示
 - `generateTestPromptFromBug` - 根据 Bug 生成测试用例提示
 - `generateCodeReviewChecklist` - 生成代码审查检查清单
 
 ### 根据需求/Bug创建任务
+
 - `createTaskFromStory` - 根据需求创建任务（提供手动操作指南）
 - `createTaskFromBug` - 根据Bug创建修复任务（提供手动操作指南）
 
@@ -251,4 +221,3 @@ MIT
 
 - [禅道开源版 GitHub](https://github.com/easysoft/zentaopms) - 禅道官方 GitHub 仓库
 - [禅道官网](https://www.zentao.net/)
-

package/dist/index.js

@@ -9,6 +9,59 @@ import { ZentaoError, ErrorCode, createError } from './errors.js';
 import { formatStoryAsMarkdown, formatBugAsMarkdown, formatTaskAsMarkdown, generateStorySummary, generateBugSummary } from './utils/formatter.js';
 import { analyzeStoryComplexity, analyzeBugPriority, analyzeTaskWorkload } from './utils/analyzer.js';
 import { suggestNextActionsForStory, suggestNextActionsForBug, suggestNextActionsForTask, formatSuggestionsAsMarkdown } from './utils/suggestions.js';
+/**
+ * 解析模块链接，提取产品ID和模块ID
+ * 支持的链接格式：
+ * - product-browse-{productId}--byModule-{moduleId}.html - 产品模块（需求）
+ * - testtask-cases-{taskId}-byModule-{moduleId}.html - 测试任务用例模块
+ * - testcase-browse-{productId}-byModule-{moduleId}.html - 产品用例模块
+ * - bug-browse-{productId}--byModule-{moduleId}.html - Bug模块
+ *
+ * @param url 链接URL
+ * @returns 解析结果 { type: 'story' | 'testcase' | 'bug', productId: number, moduleId: number, taskId?: number }
+ */
+function parseModuleUrl(url) {
+    // 移除协议和域名，只保留路径部分
+    const path = url.replace(/^https?:\/\/[^\/]+/, '');
+    // 匹配 product-browse-{productId}--byModule-{moduleId}
+    const productModuleMatch = path.match(/product-browse-(\d+)--byModule-(\d+)/);
+    if (productModuleMatch) {
+        return {
+            type: 'story',
+            productId: parseInt(productModuleMatch[1]),
+            moduleId: parseInt(productModuleMatch[2])
+        };
+    }
+    // 匹配 testtask-cases-{taskId}-byModule-{moduleId}
+    const testtaskModuleMatch = path.match(/testtask-cases-(\d+)-byModule-(\d+)/);
+    if (testtaskModuleMatch) {
+        return {
+            type: 'testcase',
+            productId: 0, // 测试任务用例需要从任务详情获取产品ID
+            moduleId: parseInt(testtaskModuleMatch[2]),
+            taskId: parseInt(testtaskModuleMatch[1])
+        };
+    }
+    // 匹配 testcase-browse-{productId}-byModule-{moduleId}
+    const testcaseModuleMatch = path.match(/testcase-browse-(\d+)-byModule-(\d+)/);
+    if (testcaseModuleMatch) {
+        return {
+            type: 'testcase',
+            productId: parseInt(testcaseModuleMatch[1]),
+            moduleId: parseInt(testcaseModuleMatch[2])
+        };
+    }
+    // 匹配 bug-browse-{productId}--byModule-{moduleId}
+    const bugModuleMatch = path.match(/bug-browse-(\d+)--byModule-(\d+)/);
+    if (bugModuleMatch) {
+        return {
+            type: 'bug',
+            productId: parseInt(bugModuleMatch[1]),
+            moduleId: parseInt(bugModuleMatch[2])
+        };
+    }
+    return null;
+}
 /**
  * 解析自然语言时间表达式
  * 支持：今年、今年1月、最近3个月、今天、昨天、上个月等
@@ -240,17 +293,49 @@ server.tool("getBugDetail", {
             result.hasImages = result.images.length > 0;
             result.hasFiles = result.fileIds.length > 0;
         }
-        // 下载图片（并行）
+        // 下载图片（并行，带超时控制）
+        let downloadedImages = [];
+        let imageDownloadStats = { total: 0, success: 0, failed: 0 };
         if (shouldDownloadImages && result.images.length > 0) {
-            result.downloadedImages = await downloadImages(zentaoApi, result.images, true);
+            // 去重图片 URL，避免重复下载
+            const uniqueImageUrls = Array.from(new Set(result.images));
+            imageDownloadStats.total = uniqueImageUrls.length;
+            try {
+                // 使用超时控制，即使部分图片超时/失败也能继续
+                downloadedImages = await downloadImages(zentaoApi, uniqueImageUrls, true, 15000);
+                imageDownloadStats.success = downloadedImages.filter(img => img.success).length;
+                imageDownloadStats.failed = downloadedImages.filter(img => !img.success).length;
+            }
+            catch (error) {
+                // 即使下载过程出错，也继续返回结果（可能部分图片已下载成功）
+                imageDownloadStats.failed = imageDownloadStats.total;
+                console.warn(`图片下载过程中出现错误，但继续返回已成功下载的图片:`, error);
+            }
         }
+        // 构建返回的 JSON（移除原始图片 URL，避免 Cursor 循环读取）
+        const imageInfo = result.images.length > 0
+            ? `已找到 ${result.images.length} 张图片，成功下载 ${imageDownloadStats.success} 张${imageDownloadStats.failed > 0 ? `，${imageDownloadStats.failed} 张下载失败或超时` : ''}`
+            : [];
+        const jsonResult = {
+            ...result,
+            images: imageInfo,
+            downloadedImages: downloadedImages.map((img, idx) => ({
+                success: img.success,
+                size: img.size,
+                mimeType: img.mimeType,
+                // 不包含 base64 和 URL，避免 JSON 过大和循环读取
+                index: idx + 1,
+                error: img.success ? undefined : img.error
+            }))
+        };
         // 构建返回内容，包含文本和图片
         const content = [
-            { type: "text", text: JSON.stringify(result, null, 2) }
+            { type: "text", text: JSON.stringify(jsonResult, null, 2) }
         ];
         // 添加图片内容（使用MCP协议的image类型）
-        if (result.downloadedImages && result.downloadedImages.length > 0) {
-            const imageContent = buildImageContent(result.downloadedImages, 'bug', bugId);
+        // 只添加成功下载的图片，失败的图片不会阻塞流程
+        if (downloadedImages && downloadedImages.length > 0) {
+            const imageContent = buildImageContent(downloadedImages, 'bug', bugId);
             content.push(...imageContent);
         }
         return {
@@ -364,11 +449,12 @@ server.tool("resolveBug", {
 // Add getProductStories tool
 server.tool("getProductStories", {
     productId: z.number(),
-    status: z.enum(['draft', 'active', 'closed', 'changed', 'all']).optional()
-}, async ({ productId, status }) => {
+    status: z.enum(['draft', 'active', 'closed', 'changed', 'all']).optional(),
+    moduleId: z.number().optional()
+}, async ({ productId, status, moduleId }) => {
     await ensureInitialized();
     try {
-        const stories = await zentaoApi.getProductStories(productId, status);
+        const stories = await zentaoApi.getProductStories(productId, status, moduleId);
         return {
             content: [{ type: "text", text: JSON.stringify(stories, null, 2) }]
         };
@@ -402,20 +488,52 @@ server.tool("getStoryDetail", {
             result.hasImages = result.images.length > 0;
             result.hasFiles = result.fileIds.length > 0;
         }
-        // 下载图片（并行）
+        // 下载图片（并行，带超时控制）
+        let downloadedImages = [];
+        let imageDownloadStats = { total: 0, success: 0, failed: 0 };
         if (shouldDownloadImages && result.images.length > 0) {
-            result.downloadedImages = await downloadImages(zentaoApi, result.images, true);
+            // 去重图片 URL，避免重复下载
+            const uniqueImageUrls = Array.from(new Set(result.images));
+            imageDownloadStats.total = uniqueImageUrls.length;
+            try {
+                // 使用超时控制，即使部分图片超时/失败也能继续
+                downloadedImages = await downloadImages(zentaoApi, uniqueImageUrls, true, 15000);
+                imageDownloadStats.success = downloadedImages.filter(img => img.success).length;
+                imageDownloadStats.failed = downloadedImages.filter(img => !img.success).length;
+            }
+            catch (error) {
+                // 即使下载过程出错，也继续返回结果（可能部分图片已下载成功）
+                imageDownloadStats.failed = imageDownloadStats.total;
+                console.warn(`图片下载过程中出现错误，但继续返回已成功下载的图片:`, error);
+            }
         }
+        // 构建返回的 JSON（移除原始图片 URL，避免 Cursor 循环读取）
+        const imageInfo = result.images.length > 0
+            ? `已找到 ${result.images.length} 张图片，成功下载 ${imageDownloadStats.success} 张${imageDownloadStats.failed > 0 ? `，${imageDownloadStats.failed} 张下载失败或超时` : ''}`
+            : [];
+        const jsonResult = {
+            ...result,
+            images: imageInfo,
+            downloadedImages: downloadedImages.map((img, idx) => ({
+                success: img.success,
+                size: img.size,
+                mimeType: img.mimeType,
+                // 不包含 base64 和 URL，避免 JSON 过大和循环读取
+                index: idx + 1,
+                error: img.success ? undefined : img.error
+            }))
+        };
         // 构建返回内容，包含文本和图片
         const content = [
-            { type: "text", text: JSON.stringify(result, null, 2) }
+            { type: "text", text: JSON.stringify(jsonResult, null, 2) }
         ];
         // 添加图片内容（使用MCP协议的image类型）
-        if (result.downloadedImages && result.downloadedImages.length > 0) {
-            const imageContent = buildImageContent(result.downloadedImages, 'story', storyId);
+        // 只添加成功下载的图片，失败的图片不会阻塞流程
+        if (downloadedImages && downloadedImages.length > 0) {
+            const imageContent = buildImageContent(downloadedImages, 'story', storyId);
             content.push(...imageContent);
         }
-        // 添加下一步建议
+        // 添加下一步建议（即使图片下载失败，也继续提供建议）
         const relatedBugs = await zentaoApi.getStoryRelatedBugs(storyId).catch(() => []);
         const testCases = await zentaoApi.getStoryTestCases(storyId).catch(() => []);
         const suggestions = suggestNextActionsForStory(story, relatedBugs.length > 0, testCases.length > 0);
@@ -496,6 +614,105 @@ server.tool("searchStoriesByProductName", {
     }
 });
 // ==================== 测试用例相关接口 ====================
+// Add getProductBugs tool
+server.tool("getProductBugs", {
+    productId: z.number(),
+    status: z.enum(['active', 'resolved', 'closed', 'all']).optional(),
+    moduleId: z.number().optional()
+}, async ({ productId, status, moduleId }) => {
+    await ensureInitialized();
+    try {
+        const bugs = await zentaoApi.getProductBugs(productId, status, moduleId);
+        return {
+            content: [{ type: "text", text: JSON.stringify(bugs, null, 2) }]
+        };
+    }
+    catch (error) {
+        if (error instanceof ZentaoError) {
+            throw error;
+        }
+        throw createError(ErrorCode.API_ERROR, `获取产品 ${productId} 的 Bug 列表失败: ${error instanceof Error ? error.message : String(error)}`, undefined, error);
+    }
+});
+// Add getModuleItems tool - 根据模块链接获取对应的需求、用例或Bug
+server.tool("getModuleItems", {
+    url: z.string().describe("模块链接URL，例如：product-browse-245--byModule-1377.html")
+}, async ({ url }) => {
+    await ensureInitialized();
+    try {
+        const parsed = parseModuleUrl(url);
+        if (!parsed) {
+            throw createError(ErrorCode.API_ERROR, `无法解析模块链接: ${url}。支持的格式：product-browse-{productId}--byModule-{moduleId}.html, bug-browse-{productId}--byModule-{moduleId}.html, testcase-browse-{productId}-byModule-{moduleId}.html`);
+        }
+        let result;
+        if (parsed.type === 'story') {
+            // 获取模块下的需求
+            const stories = await zentaoApi.getProductStories(parsed.productId, undefined, parsed.moduleId);
+            result = {
+                type: 'story',
+                productId: parsed.productId,
+                moduleId: parsed.moduleId,
+                items: stories,
+                count: stories.length
+            };
+        }
+        else if (parsed.type === 'testcase') {
+            // 获取模块下的用例
+            if (parsed.taskId) {
+                // 测试任务的用例模块，需要先获取任务详情获取产品ID
+                const task = await zentaoApi.getTaskDetail(parsed.taskId);
+                if (task.product) {
+                    const productId = typeof task.product === 'string' ? parseInt(task.product) : task.product;
+                    const testCases = await zentaoApi.getProductTestCases(productId, undefined, parsed.moduleId);
+                    result = {
+                        type: 'testcase',
+                        productId: productId,
+                        moduleId: parsed.moduleId,
+                        taskId: parsed.taskId,
+                        items: testCases,
+                        count: testCases.length
+                    };
+                }
+                else {
+                    throw createError(ErrorCode.API_ERROR, `无法从任务 ${parsed.taskId} 获取产品ID`);
+                }
+            }
+            else if (parsed.productId > 0) {
+                const testCases = await zentaoApi.getProductTestCases(parsed.productId, undefined, parsed.moduleId);
+                result = {
+                    type: 'testcase',
+                    productId: parsed.productId,
+                    moduleId: parsed.moduleId,
+                    items: testCases,
+                    count: testCases.length
+                };
+            }
+            else {
+                throw createError(ErrorCode.API_ERROR, `无法确定产品ID`);
+            }
+        }
+        else if (parsed.type === 'bug') {
+            // 获取模块下的Bug
+            const bugs = await zentaoApi.getProductBugs(parsed.productId, undefined, parsed.moduleId);
+            result = {
+                type: 'bug',
+                productId: parsed.productId,
+                moduleId: parsed.moduleId,
+                items: bugs,
+                count: bugs.length
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+    }
+    catch (error) {
+        if (error instanceof ZentaoError) {
+            throw error;
+        }
+        throw createError(ErrorCode.API_ERROR, `获取模块数据失败: ${error instanceof Error ? error.message : String(error)}`, undefined, error);
+    }
+});
 // Add getProductTestCases tool
 server.tool("getProductTestCases", {
     productId: z.number(),

package/dist/utils/imageDownloader.d.ts

@@ -16,10 +16,12 @@ export interface DownloadedImage {
  * @param zentaoApi Zentao API 实例
  * @param imageUrls 图片 URL 列表
  * @param parallel 是否并行下载（默认 true）
+ * @param timeoutMs 单张图片超时时间（毫秒），默认 15 秒
  * @returns 下载结果数组
  */
-export declare function downloadImages(zentaoApi: ZentaoLegacyAPI, imageUrls: string[], parallel?: boolean): Promise<DownloadedImage[]>;
+export declare function downloadImages(zentaoApi: ZentaoLegacyAPI, imageUrls: string[], parallel?: boolean, timeoutMs?: number): Promise<DownloadedImage[]>;
 /**
  * 构建 MCP image 内容数组
+ * 注意：不包含原始 URL，避免 Cursor 循环读取
  */
 export declare function buildImageContent(downloadedImages: DownloadedImage[], entityType: 'bug' | 'story', entityId: number): any[];

package/dist/utils/imageDownloader.js

@@ -17,71 +17,91 @@ function detectMimeType(buffer) {
     }
     return 'image/png'; // 默认
 }
+/**
+ * 带超时的图片下载
+ * @param zentaoApi Zentao API 实例
+ * @param url 图片 URL
+ * @param timeoutMs 超时时间（毫秒），默认 15 秒
+ * @returns 下载结果
+ */
+async function downloadImageWithTimeout(zentaoApi, url, timeoutMs = 15000) {
+    const timeoutPromise = new Promise((resolve) => {
+        setTimeout(() => {
+            resolve({
+                url,
+                success: false,
+                error: `下载超时（${timeoutMs}ms）`
+            });
+        }, timeoutMs);
+    });
+    const downloadPromise = (async () => {
+        try {
+            const imageBuffer = await zentaoApi.downloadStoryImage(url);
+            const base64Image = imageBuffer.toString('base64');
+            const mimeType = detectMimeType(imageBuffer);
+            return {
+                url,
+                base64: base64Image,
+                mimeType,
+                size: imageBuffer.length,
+                success: true
+            };
+        }
+        catch (error) {
+            return {
+                url,
+                success: false,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    })();
+    // 使用 Promise.race 实现超时控制
+    return Promise.race([downloadPromise, timeoutPromise]);
+}
 /**
  * 下载图片列表
  * @param zentaoApi Zentao API 实例
  * @param imageUrls 图片 URL 列表
  * @param parallel 是否并行下载（默认 true）
+ * @param timeoutMs 单张图片超时时间（毫秒），默认 15 秒
  * @returns 下载结果数组
  */
-export async function downloadImages(zentaoApi, imageUrls, parallel = true) {
+export async function downloadImages(zentaoApi, imageUrls, parallel = true, timeoutMs = 15000) {
     if (imageUrls.length === 0) {
         return [];
     }
     if (parallel) {
-        // 并行下载
-        const downloadPromises = imageUrls.map(async (url) => {
-            try {
-                const imageBuffer = await zentaoApi.downloadStoryImage(url);
-                const base64Image = imageBuffer.toString('base64');
-                const mimeType = detectMimeType(imageBuffer);
-                return {
-                    url,
-                    base64: base64Image,
-                    mimeType,
-                    size: imageBuffer.length,
-                    success: true
-                };
+        // 并行下载，使用 Promise.allSettled 确保即使部分失败也能继续
+        const downloadPromises = imageUrls.map(url => downloadImageWithTimeout(zentaoApi, url, timeoutMs));
+        // 使用 allSettled 而不是 all，这样即使部分图片超时/失败，也能返回已成功的图片
+        const results = await Promise.allSettled(downloadPromises);
+        return results.map((result, index) => {
+            if (result.status === 'fulfilled') {
+                return result.value;
             }
-            catch (error) {
+            else {
                 return {
-                    url,
+                    url: imageUrls[index],
                     success: false,
-                    error: error instanceof Error ? error.message : String(error)
+                    error: result.reason instanceof Error ? result.reason.message : String(result.reason)
                 };
             }
         });
-        return Promise.all(downloadPromises);
     }
     else {
-        // 串行下载（兼容旧逻辑）
+        // 串行下载（兼容旧逻辑），但添加超时控制
         const results = [];
         for (const url of imageUrls) {
-            try {
-                const imageBuffer = await zentaoApi.downloadStoryImage(url);
-                const base64Image = imageBuffer.toString('base64');
-                const mimeType = detectMimeType(imageBuffer);
-                results.push({
-                    url,
-                    base64: base64Image,
-                    mimeType,
-                    size: imageBuffer.length,
-                    success: true
-                });
-            }
-            catch (error) {
-                results.push({
-                    url,
-                    success: false,
-                    error: error instanceof Error ? error.message : String(error)
-                });
-            }
+            const result = await downloadImageWithTimeout(zentaoApi, url, timeoutMs);
+            results.push(result);
+            // 即使失败也继续下载下一张
         }
         return results;
     }
 }
 /**
  * 构建 MCP image 内容数组
+ * 注意：不包含原始 URL，避免 Cursor 循环读取
  */
 export function buildImageContent(downloadedImages, entityType, entityId) {
     const content = [];
@@ -91,12 +111,8 @@ export function buildImageContent(downloadedImages, entityType, entityId) {
                 type: "image",
                 data: img.base64,
                 mimeType: img.mimeType || 'image/png',
-                annotations: {
-                    audience: ["user"],
-                    priority: 0.8,
-                    title: `${entityType === 'bug' ? 'Bug' : '需求'} ${entityId} 的图片 ${index + 1}`,
-                    description: `来源: ${img.url}`
-                }
+                // 不包含 URL 信息，避免 Cursor 尝试读取原始 URL 导致循环
+                // 图片已通过 base64 内嵌，无需额外 URL
             });
         }
     });

package/dist/zentaoLegacyApi.d.ts

@@ -2,7 +2,7 @@
  * 禅道旧版API (11.x版本)
  * 使用Session认证方式
  */
-import { Bug, Task, Story, StoryStatus, TestCase, TestCaseStatus, TestResult, TestTask, CreateTestCaseRequest, TestRunRequest, Product, TaskUpdate, BugResolution } from './types.js';
+import { Bug, BugStatus, Task, Story, StoryStatus, TestCase, TestCaseStatus, TestResult, TestTask, CreateTestCaseRequest, TestRunRequest, Product, TaskUpdate, BugResolution } from './types.js';
 import { ZentaoConfig } from './config.js';
 export declare class ZentaoLegacyAPI {
     private config;
@@ -51,6 +51,13 @@ export declare class ZentaoLegacyAPI {
      * 获取我的Bug列表
      */
     getMyBugs(): Promise<Bug[]>;
+    /**
+     * 获取产品的Bug列表（支持分页和模块过滤）
+     * @param productId 产品ID
+     * @param status Bug状态（可选）
+     * @param moduleId 模块ID（可选），当提供时，只获取该模块下的Bug
+     */
+    getProductBugs(productId: number, status?: BugStatus, moduleId?: number): Promise<Bug[]>;
     /**
      * 获取Bug详情
      */
@@ -69,8 +76,11 @@ export declare class ZentaoLegacyAPI {
     resolveBug(bugId: number, resolution: BugResolution): Promise<void>;
     /**
      * 获取产品的需求列表（支持分页，自动获取所有需求）
+     * @param productId 产品ID
+     * @param status 需求状态（可选）
+     * @param moduleId 模块ID（可选），当提供时，只获取该模块下的需求
      */
-    getProductStories(productId: number, status?: StoryStatus): Promise<Story[]>;
+    getProductStories(productId: number, status?: StoryStatus, moduleId?: number): Promise<Story[]>;
     /**
      * 获取需求详情
      */

package/dist/zentaoLegacyApi.js

@@ -227,6 +227,75 @@ export class ZentaoLegacyAPI {
             openedDate: bug.openedDate,
         }));
     }
+    /**
+     * 获取产品的Bug列表（支持分页和模块过滤）
+     * @param productId 产品ID
+     * @param status Bug状态（可选）
+     * @param moduleId 模块ID（可选），当提供时，只获取该模块下的Bug
+     */
+    async getProductBugs(productId, status, moduleId) {
+        try {
+            // 禅道11.x API路径：/bug-browse-{productId}-{branch}-{browseType}-{param}-{orderBy}-{recTotal}-{recPerPage}-{pageID}.json
+            // 当 browseType = 'byModule' 时，param 是模块ID
+            // 当 browseType 是状态时，param 是 0
+            let browseType;
+            let param = 0;
+            if (moduleId) {
+                // 按模块浏览
+                browseType = 'byModule';
+                param = moduleId;
+            }
+            else if (status && status !== 'all') {
+                // 按状态浏览
+                browseType = status;
+                param = 0;
+            }
+            else {
+                // 浏览全部
+                browseType = 'all';
+                param = 0;
+            }
+            const allBugs = [];
+            let currentPage = 1;
+            const pageSize = 100;
+            let hasMore = true;
+            while (hasMore) {
+                const url = `/bug-browse-${productId}-0-${browseType}-${param}-id_desc-0-${pageSize}-${currentPage}.json`;
+                const data = await this.request(url);
+                const bugs = data.bugs || {};
+                const bugsArray = Object.values(bugs);
+                allBugs.push(...bugsArray);
+                // 检查分页信息
+                if (data.pager) {
+                    const { recTotal, recPerPage, pageID } = data.pager;
+                    const totalPages = Math.ceil(recTotal / recPerPage);
+                    hasMore = currentPage < totalPages && bugsArray.length > 0;
+                }
+                else {
+                    hasMore = false;
+                }
+                currentPage++;
+                // 安全限制：最多获取100页
+                if (currentPage > 100) {
+                    break;
+                }
+            }
+            return allBugs.map((bug) => ({
+                id: parseInt(bug.id),
+                title: bug.title,
+                status: bug.status,
+                severity: parseInt(bug.severity),
+                steps: bug.steps || '',
+                openedDate: bug.openedDate,
+                product: bug.product ? parseInt(bug.product) : undefined,
+                module: bug.module ? parseInt(bug.module) : undefined,
+            }));
+        }
+        catch (error) {
+            console.error('获取产品Bug列表失败:', error);
+            throw error;
+        }
+    }
     /**
      * 获取Bug详情
      */
@@ -281,15 +350,18 @@ export class ZentaoLegacyAPI {
     }
     /**
      * 获取产品的需求列表（支持分页，自动获取所有需求）
+     * @param productId 产品ID
+     * @param status 需求状态（可选）
+     * @param moduleId 模块ID（可选），当提供时，只获取该模块下的需求
      */
-    async getProductStories(productId, status) {
+    async getProductStories(productId, status, moduleId) {
         // 禅道11.x API分页支持：
         // URL格式：/product-browse-{productId}-{branch}-{browseType}-{param}-{orderBy}-{recTotal}-{recPerPage}-{pageID}.json
         // 参数说明：
         // - productId: 产品ID
         // - branch: 分支（默认0）
-        // - browseType: unclosed(未关闭) | all(全部) | active(激活) | draft(草稿) | closed(已关闭) | changed(已变更)
-        // - param: 模块ID或查询ID（默认0）
+        // - browseType: unclosed(未关闭) | all(全部) | active(激活) | draft(草稿) | closed(已关闭) | changed(已变更) | byModule(按模块)
+        // - param: 模块ID或查询ID（默认0），当browseType=byModule时，param是模块ID
         // - orderBy: 排序字段（默认id_desc）
         // - recTotal: 总记录数（可以为0，系统会自动计算）
         // - recPerPage: 每页记录数（默认20，可以设置更大值如100、500）
@@ -300,31 +372,40 @@ export class ZentaoLegacyAPI {
         let hasMore = true;
         // 映射status参数到browseType
         // 注意：禅道11.x的browseType只支持简单的值，不像RESTful API那样复杂
-        let browseType = 'unclosed'; // 默认获取未关闭的需求
-        if (status) {
-            switch (status) {
-                case 'all':
-                    browseType = 'unclosed'; // 11.x中all返回0条，所以用unclosed代替
-                    break;
-                case 'active':
-                    browseType = 'unclosed'; // active也映射到unclosed
-                    break;
-                case 'draft':
-                    browseType = 'unclosed'; // draft也映射到unclosed
-                    break;
-                case 'closed':
-                    browseType = 'unclosed'; // closed也映射到unclosed
-                    break;
-                case 'changed':
-                    browseType = 'unclosed'; // changed也映射到unclosed
-                    break;
-                default:
-                    browseType = 'unclosed';
+        let browseType;
+        let param = 0;
+        if (moduleId) {
+            // 按模块浏览
+            browseType = 'byModule';
+            param = moduleId;
+        }
+        else {
+            browseType = 'unclosed'; // 默认获取未关闭的需求
+            if (status) {
+                switch (status) {
+                    case 'all':
+                        browseType = 'unclosed'; // 11.x中all返回0条，所以用unclosed代替
+                        break;
+                    case 'active':
+                        browseType = 'unclosed'; // active也映射到unclosed
+                        break;
+                    case 'draft':
+                        browseType = 'unclosed'; // draft也映射到unclosed
+                        break;
+                    case 'closed':
+                        browseType = 'unclosed'; // closed也映射到unclosed
+                        break;
+                    case 'changed':
+                        browseType = 'unclosed'; // changed也映射到unclosed
+                        break;
+                    default:
+                        browseType = 'unclosed';
+                }
             }
         }
         while (hasMore) {
             // 构建URL：/product-browse-{productId}-{branch}-{browseType}-{param}-{orderBy}-{recTotal}-{recPerPage}-{pageID}.json
-            const url = `/product-browse-${productId}-0-${browseType}-0-id_desc-0-${pageSize}-${currentPage}.json`;
+            const url = `/product-browse-${productId}-0-${browseType}-${param}-id_desc-0-${pageSize}-${currentPage}.json`;
             const data = await this.request(url);
             const stories = data.stories || {};
             const storiesArray = Object.values(stories);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maxenlin/mcp-zentao-11-3",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Zentao 11.3 legacy 版 MCP 服务器，只支持旧版 Session API，纯净无 REST v1",
   "main": "dist/index.js",
   "type": "module",
@@ -50,4 +50,3 @@
     "access": "public"
   }
 }
-