@dyno181cm.nexsoft/zentao_mcp 1.2.9 → 1.2.10

package/build/tools.js

@@ -42,8 +42,39 @@ function formatUser(user) {
     }
     return String(user);
 }
+/**
+ * Find all <img src="..."> URLs in an HTML string, download each image
+ * to the local tmp directory using the authenticated ZenTao client,
+ * and replace the remote src with the local file path.
+ * Images already cached on disk are not re-downloaded.
+ */
+async function localizeImages(html) {
+    if (!html)
+        return html;
+    const imgRegex = /<img[^>]+src=["']([^"']+)["']/gi;
+    const matches = [...html.matchAll(imgRegex)];
+    if (matches.length === 0)
+        return html;
+    let result = html;
+    await Promise.all(matches.map(async (match) => {
+        const remoteUrl = match[1];
+        // Derive a stable local filename from the last path segment of the URL
+        const filename = `zentao_img_${path.basename(remoteUrl.split('?')[0])}`;
+        const localPath = path.join(os.tmpdir(), filename);
+        try {
+            if (!fs.existsSync(localPath)) {
+                await client.downloadImageToLocal(remoteUrl, localPath);
+            }
+            result = result.split(remoteUrl).join(localPath);
+        }
+        catch {
+            // If download fails, keep the original remote URL
+        }
+    }));
+    return result;
+}
 /** Format a file size in bytes to a human-readable string (B / KB / MB). */
-export function formatSize(bytes) {
+function formatSize(bytes) {
     if (bytes === undefined || bytes === null || bytes === '')
         return 'unknown size';
     const numBytes = typeof bytes === 'string' ? parseInt(bytes, 10) : bytes;
@@ -59,74 +90,118 @@ export function formatSize(bytes) {
 function mcpText(text) {
     return { content: [{ type: "text", text }] };
 }
-/** Render a list of file attachments as a Markdown section. Returns empty string if none. */
-function renderAttachments(files) {
+/** Download all attachments to local tmp dir and render them as a Markdown section with AI hints. */
+async function renderAttachments(files) {
     if (!files || files.length === 0)
         return '';
-    const lines = files.map((f) => `- 📎 **${f.title}** (ID: ${f.id}, Extension: ${f.extension}, Size: ${formatSize(f.size)})`);
-    return `\n## Attachments\n${lines.join('\n')}\n`;
+    const IMAGE_EXTS = new Set(['png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'svg']);
+    const VIDEO_EXTS = new Set(['mp4', 'mov', 'avi', 'mkv', 'webm']);
+    const enriched = await Promise.all(files.map(async (f) => {
+        const ext = (f.extension || '').toLowerCase();
+        const targetPath = path.join(os.tmpdir(), `zentao_file_${f.id}.${ext}`);
+        let localPath = null;
+        try {
+            localPath = fs.existsSync(targetPath)
+                ? targetPath
+                : await client.downloadFile(f.id, targetPath);
+        }
+        catch { /* keep null, show download failed below */ }
+        return { title: f.title, size: f.size, localPath, ext };
+    }));
+    // Build section header hint based on media types present
+    const hasImage = enriched.some(f => f.localPath && IMAGE_EXTS.has(f.ext));
+    const hasVideo = enriched.some(f => f.localPath && VIDEO_EXTS.has(f.ext));
+    let headerHint = '';
+    if (hasImage && hasVideo)
+        headerHint = ' *(AI: Please view the images and videos below)*';
+    else if (hasImage)
+        headerHint = ' *(AI: Please view the images below)*';
+    else if (hasVideo)
+        headerHint = ' *(AI: Please view the videos below)*';
+    const lines = enriched.map((f) => {
+        if (!f.localPath)
+            return `- 📎 ${f.title} — *(download failed, Size: ${formatSize(f.size)})*`;
+        if (IMAGE_EXTS.has(f.ext))
+            return `- 📎 ![${f.title}](${f.localPath}) *(Size: ${formatSize(f.size)})*`;
+        return `- 📎 [${f.title}](${f.localPath}) *(Size: ${formatSize(f.size)})*`;
+    });
+    return `\n## Files 📎${headerHint}\n${lines.join('\n')}\n`;
 }
 // ─── Public formatters ───────────────────────────────────────────────────────
 /**
  * Format a raw ZenTao task object into a human-readable Markdown document.
  */
-export function taskToMarkdown(rawTask) {
+export async function taskToMarkdown(rawTask) {
     if (!rawTask)
         return "Task not found.";
     const est = rawTask.estimate ?? 0;
     const cons = rawTask.consumed ?? 0;
     const left = rawTask.left ?? 0;
     const prog = rawTask.progress ?? 0;
-    const lines = [
-        `# Task #${rawTask.id}: ${rawTask.name}`,
-        '',
-        `- **Status**: ${rawTask.status || 'N/A'}`,
-        `- **Priority**: ${rawTask.pri || 'N/A'}`,
-        `- **Estimate / Consumed / Left**: ${est}h / ${cons}h / ${left}h (${prog}%)`,
+    // ── Compact metadata row ──
+    const meta = [
+        `**Status:** ${rawTask.status || 'N/A'}`,
+        `**Priority:** ${rawTask.pri || 'N/A'}`,
+        `**Estimate/Consumed/Left:** ${est}h / ${cons}h / ${left}h (${prog}%)`,
     ];
     if (rawTask.openedBy)
-        lines.push(`- **Opened By**: ${formatUser(rawTask.openedBy)}`);
+        meta.push(`**Opened by:** ${formatUser(rawTask.openedBy)}`);
     if (rawTask.assignedTo)
-        lines.push(`- **Assigned To**: ${formatUser(rawTask.assignedTo)}`);
+        meta.push(`**Assigned to:** ${formatUser(rawTask.assignedTo)}`);
     if (rawTask.finishedBy)
-        lines.push(`- **Finished By**: ${formatUser(rawTask.finishedBy)}`);
+        meta.push(`**Finished by:** ${formatUser(rawTask.finishedBy)}`);
     if (rawTask.closedBy) {
-        const reason = rawTask.closedReason ? ` (Reason: ${rawTask.closedReason})` : '';
-        lines.push(`- **Closed By**: ${formatUser(rawTask.closedBy)}${reason}`);
+        const reason = rawTask.closedReason ? ` (${rawTask.closedReason})` : '';
+        meta.push(`**Closed by:** ${formatUser(rawTask.closedBy)}${reason}`);
     }
-    const desc = htmlToMarkdown(rawTask.desc);
-    lines.push(`\n## Description\n${desc || '*No description provided.*'}`);
-    lines.push(renderAttachments(parseFiles(rawTask.files)));
-    return lines.join('\n');
+    const localizedDesc = await localizeImages(rawTask.desc);
+    const desc = htmlToMarkdown(localizedDesc);
+    const attachments = await renderAttachments(parseFiles(rawTask.files));
+    return [
+        `# Task #${rawTask.id}: ${rawTask.name}`,
+        '',
+        meta.join(' | '),
+        '',
+        '## Description',
+        desc || '*No description provided.*',
+        attachments,
+    ].join('\n');
 }
 /**
  * Format a raw ZenTao bug object into a human-readable Markdown document.
  */
-export function bugToMarkdown(rawBug) {
+export async function bugToMarkdown(rawBug) {
     if (!rawBug)
         return "Bug not found.";
-    const lines = [
-        `# Bug #${rawBug.id}: ${rawBug.title}`,
-        '',
-        `- **Status**: ${rawBug.status || 'N/A'}`,
-        `- **Severity**: ${rawBug.severity || 'N/A'}`,
-        `- **Priority**: ${rawBug.pri || 'N/A'}`,
-        `- **Type**: ${rawBug.type || 'N/A'}`,
+    // ── Compact metadata row ──
+    const meta = [
+        `**Status:** ${rawBug.status || 'N/A'}`,
+        `**Severity:** ${rawBug.severity || 'N/A'}`,
+        `**Priority:** ${rawBug.pri || 'N/A'}`,
+        `**Type:** ${rawBug.type || 'N/A'}`,
     ];
     if (rawBug.openedBy)
-        lines.push(`- **Opened By**: ${formatUser(rawBug.openedBy)}`);
+        meta.push(`**Opened by:** ${formatUser(rawBug.openedBy)}`);
     if (rawBug.assignedTo)
-        lines.push(`- **Assigned To**: ${formatUser(rawBug.assignedTo)}`);
+        meta.push(`**Assigned to:** ${formatUser(rawBug.assignedTo)}`);
     if (rawBug.resolvedBy) {
-        const resolution = rawBug.resolution ? ` (Resolution: ${rawBug.resolution})` : '';
-        lines.push(`- **Resolved By**: ${formatUser(rawBug.resolvedBy)}${resolution}`);
+        const resolution = rawBug.resolution ? ` (${rawBug.resolution})` : '';
+        meta.push(`**Resolved by:** ${formatUser(rawBug.resolvedBy)}${resolution}`);
     }
     if (rawBug.closedBy)
-        lines.push(`- **Closed By**: ${formatUser(rawBug.closedBy)}`);
-    const steps = htmlToMarkdown(rawBug.steps);
-    lines.push(`\n## Steps to Reproduce\n${steps || '*No steps provided.*'}`);
-    lines.push(renderAttachments(parseFiles(rawBug.files)));
-    return lines.join('\n');
+        meta.push(`**Closed by:** ${formatUser(rawBug.closedBy)}`);
+    const localizedSteps = await localizeImages(rawBug.steps);
+    const steps = htmlToMarkdown(localizedSteps);
+    const attachments = await renderAttachments(parseFiles(rawBug.files));
+    return [
+        `# Bug #${rawBug.id}: ${rawBug.title}`,
+        '',
+        meta.join(' | '),
+        '',
+        '## Repro Steps',
+        steps || '*No steps provided.*',
+        attachments,
+    ].join('\n');
 }
 // ─── Download handler (extracted for Single Responsibility) ──────────────────
 /**
@@ -170,7 +245,7 @@ export function registerTools(server) {
         },
     }, async ({ taskId }) => {
         const data = await client.getTaskDetails(taskId);
-        return mcpText(taskToMarkdown(data));
+        return mcpText(await taskToMarkdown(data));
     });
     server.registerTool("zentao_get_bug_details", {
         description: "Get detailed information of a bug",
@@ -179,7 +254,7 @@ export function registerTools(server) {
         },
     }, async ({ bugId }) => {
         const data = await client.getBugDetails(bugId);
-        return mcpText(bugToMarkdown(data));
+        return mcpText(await bugToMarkdown(data));
     });
     server.registerTool("zentao_download_attachment", {
         description: "Download a file attachment from ZenTao and save it locally",

package/build/zentaoClient.js

@@ -145,4 +145,32 @@ export class ZentaoClient {
             });
         });
     }
+    /**
+     * Downloads an image from a full authenticated URL and saves it to a local path.
+     * Uses the same authenticated Axios client so ZenTao session token is injected automatically.
+     *
+     * @param imageUrl The full image URL to download (e.g. https://zentao.../file-read-xxx.png).
+     * @param targetPath The local file path where the image should be saved.
+     * @returns A promise that resolves to the targetPath upon success, or rejects with an error.
+     */
+    async downloadImageToLocal(imageUrl, targetPath) {
+        const writer = fs.createWriteStream(targetPath);
+        const res = await this.client.get(imageUrl, {
+            baseURL: '', // override baseURL so the full URL is used as-is
+            responseType: 'stream',
+        });
+        return new Promise((resolve, reject) => {
+            res.data.pipe(writer);
+            let error = null;
+            writer.on('error', err => {
+                error = err;
+                writer.close();
+                reject(err);
+            });
+            writer.on('close', () => {
+                if (!error)
+                    resolve(targetPath);
+            });
+        });
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dyno181cm.nexsoft/zentao_mcp",
-  "version": "1.2.9",
+  "version": "1.2.10",
   "description": "Zentao MCP Server",
   "repository": {
     "type": "git",