@dyno181cm.nexsoft/zentao_mcp 1.2.0 → 1.2.2

package/README.md

@@ -20,7 +20,7 @@ A Model Context Protocol (MCP) server for integrating with the Zentao API. This
 1. Clone the repository:
 
    ```bash
-   git clone <repository-url>
+   git clone https://github.com/dyno-nexsoft/zentao_mcp.git
    cd zentao_mcp
    ```
 

package/build/index.js

@@ -8,7 +8,7 @@ dotenv.config();
 // Create the MCP server instance
 const server = new McpServer({
     name: "Zentao MCP Server",
-    version: "1.2.0"
+    version: "1.2.2"
 });
 // Register all Zentao-specific tools onto the server
 registerTools(server);

package/build/tools.js

@@ -13,6 +13,87 @@ const client = new ZentaoClient();
  *
  * @param server The MCP Server instance where the tools will be registered.
  */
+function parseFiles(files) {
+    if (!files)
+        return [];
+    const mapper = (f) => ({
+        id: f.id,
+        title: f.title || f.name,
+        extension: f.extension,
+        size: f.size
+    });
+    if (Array.isArray(files)) {
+        return files.map(mapper);
+    }
+    if (typeof files === 'object') {
+        return Object.values(files).map(mapper);
+    }
+    return [];
+}
+function cleanTask(task) {
+    if (!task)
+        return null;
+    return {
+        id: task.id,
+        name: task.name,
+        status: task.status,
+        pri: task.pri,
+        desc: task.desc,
+        estimate: task.estimate,
+        consumed: task.consumed,
+        left: task.left,
+        progress: task.progress,
+        openedBy: task.openedBy ? {
+            account: task.openedBy.account,
+            realname: task.openedBy.realname
+        } : undefined,
+        assignedTo: task.assignedTo ? {
+            account: task.assignedTo.account,
+            realname: task.assignedTo.realname
+        } : undefined,
+        finishedBy: task.finishedBy ? {
+            account: task.finishedBy.account,
+            realname: task.finishedBy.realname
+        } : undefined,
+        closedBy: task.closedBy ? {
+            account: task.closedBy.account,
+            realname: task.closedBy.realname
+        } : undefined,
+        closedReason: task.closedReason,
+        files: parseFiles(task.files)
+    };
+}
+function cleanBug(bug) {
+    if (!bug)
+        return null;
+    return {
+        id: bug.id,
+        title: bug.title,
+        status: bug.status,
+        severity: bug.severity,
+        pri: bug.pri,
+        type: bug.type,
+        steps: bug.steps,
+        openedBy: bug.openedBy ? {
+            account: bug.openedBy.account,
+            realname: bug.openedBy.realname
+        } : undefined,
+        assignedTo: bug.assignedTo ? {
+            account: bug.assignedTo.account,
+            realname: bug.assignedTo.realname
+        } : undefined,
+        resolvedBy: bug.resolvedBy ? {
+            account: bug.resolvedBy.account,
+            realname: bug.resolvedBy.realname
+        } : undefined,
+        resolution: bug.resolution,
+        closedBy: bug.closedBy ? {
+            account: bug.closedBy.account,
+            realname: bug.closedBy.realname
+        } : undefined,
+        files: parseFiles(bug.files)
+    };
+}
 export function registerTools(server) {
     server.registerTool("zentao_get_task_details", {
         description: "Get detailed information of a task",
@@ -21,8 +102,9 @@ export function registerTools(server) {
         }
     }, async ({ taskId }) => {
         const data = await client.getTaskDetails(taskId);
+        const cleaned = cleanTask(data);
         return {
-            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            content: [{ type: "text", text: JSON.stringify(cleaned, null, 2) }],
         };
     });
     server.registerTool("zentao_get_bug_details", {
@@ -32,8 +114,9 @@ export function registerTools(server) {
         }
     }, async ({ bugId }) => {
         const data = await client.getBugDetails(bugId);
+        const cleaned = cleanBug(data);
         return {
-            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            content: [{ type: "text", text: JSON.stringify(cleaned, null, 2) }],
         };
     });
     server.registerTool("zentao_download_attachment", {

package/build/zentaoClient.js

@@ -13,12 +13,38 @@ export class ZentaoClient {
     account = process.env.ZENTAO_ACCOUNT || '';
     password = process.env.ZENTAO_PASSWORD || '';
     baseUrl = process.env.ZENTAO_BASE_URL || '';
+    getCache = new Map();
+    cacheTtlMs = 2 * 60 * 1000; // 2 minutes TTL
+    /**
+     * Clears the in-memory cache for GET requests. Helpful for testing.
+     */
+    clearCache() {
+        this.getCache.clear();
+    }
+    /**
+     * Helper method to perform GET requests with caching.
+     *
+     * @param url The API endpoint path.
+     * @returns The response data.
+     */
+    async get(url) {
+        const cached = this.getCache.get(url);
+        const now = Date.now();
+        if (cached && (now - cached.timestamp < this.cacheTtlMs)) {
+            return cached.data;
+        }
+        const res = await this.client.get(url);
+        this.getCache.set(url, { data: res.data, timestamp: now });
+        return res.data;
+    }
     /**
      * Initializes the Axios client with base configurations and registers interceptors
      * to automatically inject token headers and handle token expiration (401 errors).
+     *
+     * @param customClient Optional custom AxiosInstance for dependency injection/testing.
      */
-    constructor() {
-        this.client = axios.create({
+    constructor(customClient) {
+        this.client = customClient || axios.create({
             baseURL: this.baseUrl,
             headers: {
                 'Content-Type': 'application/json',
@@ -80,23 +106,23 @@ export class ZentaoClient {
     }
     /**
      * Retrieves details of a specific task.
+     * Checks the cache first, otherwise fetches from API.
      *
      * @param taskId The ID of the task.
      * @returns Resolves with the task details.
      */
     async getTaskDetails(taskId) {
-        const res = await this.client.get(`/tasks/${taskId}`);
-        return res.data;
+        return this.get(`/tasks/${taskId}`);
     }
     /**
      * Retrieves details of a specific bug.
+     * Checks the cache first, otherwise fetches from API.
      *
      * @param bugId The ID of the bug.
      * @returns Resolves with the bug details.
      */
     async getBugDetails(bugId) {
-        const res = await this.client.get(`/bugs/${bugId}`);
-        return res.data;
+        return this.get(`/bugs/${bugId}`);
     }
     /**
      * Downloads a file from Zentao API and pipes it to a local file path.

package/package.json

@@ -1,7 +1,15 @@
 {
   "name": "@dyno181cm.nexsoft/zentao_mcp",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Zentao MCP Server",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dyno-nexsoft/zentao_mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/dyno-nexsoft/zentao_mcp/issues"
+  },
+  "homepage": "https://github.com/dyno-nexsoft/zentao_mcp#readme",
   "main": "build/index.js",
   "bin": {
     "zentao_mcp": "build/index.js"
@@ -14,6 +22,7 @@
     "build": "tsc",
     "start": "node build/index.js",
     "dev": "tsc --watch",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
     "test:api": "tsx tests/testApi.ts"
   },
   "dependencies": {