@zzp123/mcp-zentao 1.15.0 → 1.17.0

package/dist/index-qa.js

@@ -0,0 +1,916 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { ZentaoAPI } from './api/zentaoApi.js';
+import { loadConfig, saveConfig } from './config.js';
+// 解析命令行参数
+const args = process.argv.slice(2);
+let configData = null;
+// 查找 --config 参数
+const configIndex = args.indexOf('--config');
+if (configIndex !== -1 && configIndex + 1 < args.length) {
+    try {
+        // 获取 --config 后面的 JSON 字符串并解析
+        const jsonStr = args[configIndex + 1];
+        configData = JSON.parse(jsonStr);
+        console.log('成功解析配置数据:', configData);
+        // 如果配置数据中包含 config 对象，则保存配置
+        if (configData.config) {
+            console.log('正在保存配置...');
+            saveConfig(configData.config);
+        }
+    }
+    catch (error) {
+        console.error('配置解析失败:', error);
+        process.exit(1);
+    }
+}
+// Create an MCP server
+const server = new McpServer({
+    name: "Zentao API (测试工程师)",
+    version: "1.17.0"
+});
+// Initialize ZentaoAPI instance
+let zentaoApi = null;
+export default async function main(params) {
+    console.log('接收到的参数:', params);
+    // 如果传入了配置信息，就保存它
+    if (params.config) {
+        console.log('保存新的配置信息...');
+        saveConfig(params.config);
+    }
+}
+// Add Zentao configuration tool
+server.tool("initZentao", {}, async ({}) => {
+    let config;
+    // 尝试从配置文件加载配置
+    const savedConfig = loadConfig();
+    if (!savedConfig) {
+        throw new Error("No configuration found. Please provide complete Zentao configuration.");
+    }
+    config = savedConfig;
+    zentaoApi = new ZentaoAPI(config);
+    return {
+        content: [{ type: "text", text: JSON.stringify(config, null, 2) }]
+    };
+});
+server.tool("getMyTasks", {
+    status: z.enum(['wait', 'doing', 'done', 'all']).optional()
+}, async ({ status }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const tasks = await zentaoApi.getMyTasks(status);
+    return {
+        content: [{ type: "text", text: JSON.stringify(tasks, null, 2) }]
+    };
+});
+server.tool("getTaskDetail", {
+    taskId: z.number()
+}, async ({ taskId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const task = await zentaoApi.getTaskDetail(taskId);
+    return {
+        content: [{ type: "text", text: JSON.stringify(task, null, 2) }]
+    };
+});
+server.tool("getMyBugs", "获取Bug列表 - 支持多种状态筛选（指派给我、由我创建、未关闭等）和分支筛选", {
+    status: z.enum([
+        'active', // 激活状态
+        'resolved', // 已解决
+        'closed', // 已关闭
+        'all', // 所有状态
+        'assigntome', // 指派给我的
+        'openedbyme', // 由我创建
+        'resolvedbyme', // 由我解决
+        'assignedbyme', // 由我指派
+        'assigntonull', // 未指派
+        'unconfirmed', // 未确认
+        'unclosed', // 未关闭
+        'unresolved', // 未解决(激活状态)
+        'toclosed', // 待关闭(已解决)
+        'postponedbugs', // 延期的Bug
+        'longlifebugs', // 长期未处理的Bug
+        'overduebugs', // 已过期的Bug
+        'review', // 待我审核
+        'feedback', // 用户反馈
+        'needconfirm', // 需求变更需确认
+        'bysearch' // 自定义搜索
+    ]).optional().describe("Bug状态筛选，默认返回所有状态"),
+    productId: z.number().optional().describe("产品ID，默认使用第二个产品"),
+    page: z.number().optional().describe("页码，从1开始，默认为1"),
+    limit: z.number().optional().describe("每页数量，默认20，最大100"),
+    branch: z.string().optional().describe("分支筛选：'all'(所有分支,默认)、'0'(主干分支)、分支ID"),
+    order: z.string().optional().describe("排序方式，如 id_desc(ID降序), pri_desc(优先级降序), openedDate_desc(创建时间降序)等，默认id_desc"),
+    fields: z.enum(['basic', 'default', 'full']).optional().describe("返回字段级别：'basic'(基本字段)、'default'(默认字段,推荐)、'full'(完整字段)，默认'default'")
+}, async ({ status, productId, page, limit, branch, order, fields }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const result = await zentaoApi.getMyBugs(status, productId, page, limit, branch, order, fields);
+    // 返回分页信息和数据
+    const summary = {
+        summary: `当前第 ${result.page} 页，共 ${result.total} 个Bug，本页显示 ${result.bugs.length} 个`,
+        pagination: {
+            page: result.page,
+            limit: result.limit,
+            total: result.total,
+            totalPages: Math.ceil(result.total / result.limit)
+        },
+        bugs: result.bugs
+    };
+    return {
+        content: [{ type: "text", text: JSON.stringify(summary, null, 2) }]
+    };
+});
+server.tool("getProductBugs", "获取指定产品的Bug列表 - 支持多种状态筛选和分支筛选", {
+    productId: z.number().describe("产品ID（必填）"),
+    page: z.number().optional().describe("页码，从1开始，默认为1"),
+    limit: z.number().optional().describe("每页数量，默认20，最大100"),
+    status: z.enum([
+        'active', // 激活状态
+        'resolved', // 已解决
+        'closed', // 已关闭
+        'all', // 所有状态
+        'assigntome', // 指派给我的
+        'openedbyme', // 由我创建
+        'resolvedbyme', // 由我解决
+        'assignedbyme', // 由我指派
+        'assigntonull', // 未指派
+        'unconfirmed', // 未确认
+        'unclosed', // 未关闭
+        'unresolved', // 未解决(激活状态)
+        'toclosed', // 待关闭(已解决)
+        'postponedbugs', // 延期的Bug
+        'longlifebugs', // 长期未处理的Bug
+        'overduebugs', // 已过期的Bug
+        'review', // 待我审核
+        'feedback', // 用户反馈
+        'needconfirm', // 需求变更需确认
+        'bysearch' // 自定义搜索
+    ]).optional().describe("Bug状态筛选，默认返回所有状态"),
+    branch: z.string().optional().describe("分支筛选：'all'(所有分支,默认)、'0'(主干分支)、分支ID"),
+    order: z.string().optional().describe("排序方式，如 id_desc(ID降序), pri_desc(优先级降序), openedDate_desc(创建时间降序)等，默认id_desc"),
+    fields: z.enum(['basic', 'default', 'full']).optional().describe("返回字段级别：'basic'(基本字段)、'default'(默认字段,推荐)、'full'(完整字段)，默认'default'")
+}, async ({ productId, page, limit, status, branch, order, fields }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const result = await zentaoApi.getProductBugs(productId, page, limit, status, branch, order, fields);
+    // 返回分页信息和数据
+    const summary = {
+        summary: `当前第 ${result.page} 页，共 ${result.total} 个Bug，本页显示 ${result.bugs.length} 个`,
+        pagination: {
+            page: result.page,
+            limit: result.limit,
+            total: result.total,
+            totalPages: Math.ceil(result.total / result.limit)
+        },
+        bugs: result.bugs
+    };
+    return {
+        content: [{ type: "text", text: JSON.stringify(summary, null, 2) }]
+    };
+});
+server.tool("getBugDetail", {
+    bugId: z.number(),
+    fields: z.enum(['basic', 'detail', 'full']).optional().describe(`
+字段级别：
+- basic: 基本信息（id, title, status, severity, pri等核心字段）
+- detail: 详细信息（包含steps步骤，但不包含files/cases/linkBugs等关联数据）
+- full: 完整信息（包含所有字段，默认值）
+        `.trim())
+}, async ({ bugId, fields }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const bug = await zentaoApi.getBugDetail(bugId, fields);
+    // 添加说明信息
+    const result = {
+        fieldLevel: fields || 'full',
+        bug: bug
+    };
+    // 根据字段级别添加提示
+    if (fields === 'basic') {
+        result.note = '仅显示基本信息，如需完整内容请使用 fields=detail 或 fields=full';
+    }
+    else if (fields === 'detail') {
+        result.note = '显示详细信息但不包含关联数据（files/cases/linkBugs），如需完整内容请使用 fields=full';
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+    };
+});
+server.tool("resolveBug", {
+    bugId: z.number(),
+    resolution: z.enum(['fixed', 'bydesign', 'duplicate', 'external', 'notrepro', 'postponed', 'willnotfix']),
+    resolvedBuild: z.string().optional(),
+    assignedTo: z.string().optional(),
+    comment: z.string().optional(),
+    duplicateBug: z.number().optional()
+}, async ({ bugId, resolution, resolvedBuild, assignedTo, comment, duplicateBug }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const resolveBugRequest = {
+        resolution,
+        resolvedBuild,
+        assignedTo,
+        comment,
+        duplicateBug
+    };
+    const bug = await zentaoApi.resolveBug(bugId, resolveBugRequest);
+    return {
+        content: [{ type: "text", text: JSON.stringify(bug, null, 2) }]
+    };
+});
+server.tool("getStoryDetail", "获取需求详情 - 支持软件需求(story)和用户需求(requirement)，自动识别类型", {
+    storyId: z.number().describe("需求ID（可以是story或requirement类型）"),
+    fields: z.enum(['basic', 'detail', 'full']).optional().describe(`
+字段级别：
+- basic: 基本信息（id, title, status, stage, pri等核心字段）
+- detail: 详细信息（包含spec和verify，但不包含executions/tasks/stages/children等关联数据）
+- full: 完整信息（包含所有字段，默认值）
+        `.trim())
+}, async ({ storyId, fields }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const story = await zentaoApi.getStoryDetail(storyId, fields);
+    // 添加说明信息
+    const result = {
+        fieldLevel: fields || 'full',
+        story: story
+    };
+    // 根据字段级别添加提示
+    if (fields === 'basic') {
+        result.note = '仅显示基本信息，如需完整内容请使用 fields=detail 或 fields=full';
+    }
+    else if (fields === 'detail') {
+        result.note = '显示详细信息但不包含关联数据（executions/tasks/stages/children），如需完整内容请使用 fields=full';
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+    };
+});
+server.tool("createBug", {
+    productId: z.number(),
+    title: z.string(),
+    severity: z.number(),
+    pri: z.number(),
+    type: z.string(),
+    branch: z.number().optional(),
+    module: z.number().optional(),
+    execution: z.number().optional(),
+    keywords: z.string().optional(),
+    os: z.string().optional(),
+    browser: z.string().optional(),
+    steps: z.string().optional(),
+    task: z.number().optional(),
+    story: z.number().optional(),
+    deadline: z.string().optional(),
+    openedBuild: z.array(z.string()).optional().default(["trunk"])
+}, async ({ productId, title, severity, pri, type, branch, module, execution, keywords, os, browser, steps, task, story, deadline, openedBuild }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    // 如果未提供 openedBuild，使用默认值 ["trunk"] 表示主干版本
+    const bugData = {
+        title,
+        severity,
+        pri,
+        type,
+        branch,
+        module,
+        execution,
+        keywords,
+        os,
+        browser,
+        steps,
+        task,
+        story,
+        deadline,
+        openedBuild: openedBuild || ["trunk"]
+    };
+    const bug = await zentaoApi.createBug(productId, bugData);
+    return {
+        content: [{ type: "text", text: JSON.stringify(bug, null, 2) }]
+    };
+});
+server.tool("getProductStories", "获取产品需求列表 - 包含软件需求(story)和用户需求(requirement)，默认只返回核心字段（id, 标题, 指派人, 创建人）", {
+    productId: z.number(),
+    page: z.number().optional().describe("页码，从1开始，默认为1"),
+    limit: z.number().optional().describe("每页数量，默认20，最大100"),
+    fields: z.enum(['basic', 'default', 'full']).optional().describe("字段级别:\n- basic: 基本信息(id, title, assignedTo, openedBy)\n- default: 常用信息(包含basic + status, stage, pri等)\n- full: 完整信息(所有字段)")
+}, async ({ productId, page, limit, fields }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const result = await zentaoApi.getProductStories(productId, page, limit, fields);
+    // 返回分页信息和数据
+    const summary = {
+        summary: `当前第 ${result.page} 页，共 ${result.total} 条需求，本页显示 ${result.stories.length} 条`,
+        pagination: {
+            page: result.page,
+            limit: result.limit,
+            total: result.total,
+            totalPages: Math.ceil(result.total / result.limit)
+        },
+        stories: result.stories
+    };
+    return {
+        content: [{ type: "text", text: JSON.stringify(summary, null, 2) }]
+    };
+});
+server.tool("updateBug", {
+    bugId: z.number(),
+    update: z.object({
+        branch: z.number().optional(), module: z.number().optional(), execution: z.number().optional(),
+        title: z.string().optional(), keywords: z.string().optional(), severity: z.number().optional(),
+        pri: z.number().optional(), type: z.string().optional(), os: z.string().optional(),
+        browser: z.string().optional(), steps: z.string().optional(), assignedTo: z.string().optional(),
+        deadline: z.string().optional()
+    })
+}, async ({ bugId, update }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.updateBug(bugId, update), null, 2) }] };
+});
+server.tool("deleteBug", { bugId: z.number() }, async ({ bugId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.deleteBug(bugId), null, 2) }] };
+});
+server.tool("getProductTestCases", { productId: z.number() }, async ({ productId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.getProductTestCases(productId), null, 2) }] };
+});
+server.tool("createTestCase", {
+    productId: z.number(),
+    branch: z.number().optional(),
+    module: z.number().optional(),
+    story: z.number().optional(),
+    title: z.string(),
+    type: z.string(),
+    stage: z.string().optional(),
+    precondition: z.string().optional(),
+    pri: z.number().optional(),
+    steps: z.array(z.object({ desc: z.string(), expect: z.string() })),
+    keywords: z.string().optional()
+}, async ({ productId, ...params }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.createTestCase(productId, params), null, 2) }] };
+});
+server.tool("getTestCaseDetail", { testCaseId: z.number() }, async ({ testCaseId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.getTestCaseDetail(testCaseId), null, 2) }] };
+});
+server.tool("updateTestCase", {
+    testCaseId: z.number(),
+    branch: z.number().optional(),
+    module: z.number().optional(),
+    story: z.number().optional(),
+    title: z.string().optional(),
+    type: z.string().optional(),
+    stage: z.string().optional(),
+    precondition: z.string().optional(),
+    pri: z.number().optional(),
+    steps: z.array(z.object({ desc: z.string(), expect: z.string() })).optional(),
+    keywords: z.string().optional()
+}, async ({ testCaseId, ...params }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.updateTestCase(testCaseId, params), null, 2) }] };
+});
+server.tool("deleteTestCase", { testCaseId: z.number() }, async ({ testCaseId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.deleteTestCase(testCaseId), null, 2) }] };
+});
+server.tool("createBuild", {
+    projectId: z.number(),
+    execution: z.number(),
+    product: z.number(),
+    branch: z.number().optional(),
+    name: z.string(),
+    builder: z.string(),
+    date: z.string().optional(),
+    scmPath: z.string().optional(),
+    filePath: z.string().optional(),
+    desc: z.string().optional()
+}, async ({ projectId, ...params }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.createBuild(projectId, params), null, 2) }] };
+});
+server.tool("getBuildDetail", { buildId: z.number() }, async ({ buildId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.getBuildDetail(buildId), null, 2) }] };
+});
+server.tool("updateBuild", {
+    buildId: z.number(),
+    name: z.string().optional(),
+    builder: z.string().optional(),
+    date: z.string().optional(),
+    scmPath: z.string().optional(),
+    filePath: z.string().optional(),
+    desc: z.string().optional()
+}, async ({ buildId, ...params }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.updateBuild(buildId, params), null, 2) }] };
+});
+server.tool("deleteBuild", { buildId: z.number() }, async ({ buildId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.deleteBuild(buildId), null, 2) }] };
+});
+server.tool("getTickets", {
+    browseType: z.string().optional(),
+    param: z.string().optional(),
+    orderBy: z.string().optional(),
+    page: z.number().optional(),
+    limit: z.number().optional()
+}, async (params) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.getTickets(params), null, 2) }] };
+});
+server.tool("getTicketDetail", { ticketId: z.number() }, async ({ ticketId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.getTicketDetail(ticketId), null, 2) }] };
+});
+server.tool("createTicket", {
+    product: z.number(),
+    module: z.number(),
+    title: z.string(),
+    type: z.string().optional(),
+    desc: z.string().optional()
+}, async (params) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.createTicket(params), null, 2) }] };
+});
+server.tool("updateTicket", {
+    ticketId: z.number(),
+    product: z.number().optional(),
+    module: z.number().optional(),
+    title: z.string().optional(),
+    type: z.string().optional(),
+    desc: z.string().optional()
+}, async ({ ticketId, ...params }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.updateTicket(ticketId, params), null, 2) }] };
+});
+server.tool("deleteTicket", { ticketId: z.number() }, async ({ ticketId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.deleteTicket(ticketId), null, 2) }] };
+});
+server.tool("getModules", {
+    type: z.enum(['story', 'task', 'bug', 'case', 'feedback', 'product']),
+    id: z.number(),
+    fields: z.string().optional()
+}, async ({ type, id, fields }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const response = await zentaoApi.getModules(type, id, fields);
+    return { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] };
+});
+server.tool("uploadFile", {
+    filePath: z.string().optional(),
+    base64Data: z.string().optional(),
+    filename: z.string().optional(),
+    uid: z.string().optional()
+}, async ({ filePath, base64Data, filename, uid }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const fs = await import('fs');
+    const path = await import('path');
+    let fileBuffer;
+    let finalFilename;
+    let savedPath;
+    // 如果提供了 base64 数据（复制的图片）
+    if (base64Data) {
+        // 创建 img 文件夹（如果不存在）
+        const imgDir = path.join(process.cwd(), 'img');
+        if (!fs.existsSync(imgDir)) {
+            fs.mkdirSync(imgDir, { recursive: true });
+        }
+        // 处理 base64 数据
+        const matches = base64Data.match(/^data:image\/(\w+);base64,(.+)$/);
+        if (matches) {
+            const ext = matches[1];
+            const data = matches[2];
+            fileBuffer = Buffer.from(data, 'base64');
+            finalFilename = filename || `image_${Date.now()}.${ext}`;
+        }
+        else {
+            // 直接的 base64 数据，没有 data URL 前缀
+            fileBuffer = Buffer.from(base64Data, 'base64');
+            finalFilename = filename || `image_${Date.now()}.png`;
+        }
+        // 保存到 img 文件夹
+        savedPath = path.join(imgDir, finalFilename);
+        fs.writeFileSync(savedPath, fileBuffer);
+    }
+    // 如果提供了文件路径
+    else if (filePath) {
+        fileBuffer = fs.readFileSync(filePath);
+        finalFilename = path.basename(filePath);
+    }
+    else {
+        throw new Error("必须提供 filePath 或 base64Data 参数");
+    }
+    const result = await zentaoApi.uploadFile({
+        file: fileBuffer,
+        filename: finalFilename,
+        uid
+    });
+    // 生成禅道需要的 HTML 格式
+    const fileId = result.id;
+    const baseUrl = zentaoApi.getConfig().url;
+    const imageUrl = `${baseUrl}/zentao/entao/api.php?m=file&f=read&t=png&fileID=${fileId}`;
+    const imageHtml = `<p><img onload="setImageSize(this,0)" src="${imageUrl}" alt="${finalFilename}" /></p>`;
+    const response = {
+        upload: result,
+        fileId: fileId,
+        imageUrl: imageUrl,
+        imageHtml: imageHtml,
+        tip: `更新 Bug 描述时，请使用 imageHtml 字段中的 HTML 代码。图片会被包裹在 <p> 标签中以确保正确显示。`
+    };
+    if (savedPath) {
+        response.savedPath = savedPath;
+    }
+    return { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] };
+});
+server.tool("uploadImageFromClipboard", "上传剪贴板图片到禅道 - 自动获取剪贴板中的图片并上传", {
+    filename: z.string().optional().describe("自定义文件名，默认为 clipboard_时间戳.png"),
+    uid: z.string().optional().describe("禅道文件UID，用于关联需求或Bug")
+}, async ({ filename, uid }) => {
+    if (!zentaoApi) {
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({ error: "请先初始化禅道API配置" }, null, 2)
+                }],
+            isError: true
+        };
+    }
+    const fs = await import('fs');
+    const path = await import('path');
+    const { execSync } = await import('child_process');
+    try {
+        console.log('[uploadImageFromClipboard] 开始执行...');
+        // 读取系统剪贴板图片
+        let fileBuffer;
+        let finalFilename;
+        // Windows: 使用 PowerShell 脚本读取剪贴板
+        if (process.platform === 'win32') {
+            console.log('[uploadImageFromClipboard] Windows平台，使用PowerShell脚本读取剪贴板...');
+            // 内嵌 PowerShell 脚本，避免依赖外部文件
+            const psScript = `Add-Type -AssemblyName System.Windows.Forms; Add-Type -AssemblyName System.Drawing; $img = [System.Windows.Forms.Clipboard]::GetImage(); if ($img) { $ms = New-Object System.IO.MemoryStream; $img.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png); $bytes = $ms.ToArray(); $ms.Close(); $base64 = [Convert]::ToBase64String($bytes); Write-Output $base64 } else { Write-Output 'NoImage' }`;
+            try {
+                // 使用 Base64 编码 PowerShell 脚本以避免转义问题
+                const psScriptBase64 = Buffer.from(psScript, 'utf16le').toString('base64');
+                const result = execSync(`powershell -ExecutionPolicy Bypass -EncodedCommand ${psScriptBase64}`, {
+                    encoding: 'utf8',
+                    maxBuffer: 10 * 1024 * 1024,
+                    stdio: ['pipe', 'pipe', 'pipe']
+                }).trim();
+                if (!result || result.includes('NoImage') || result.includes('Error')) {
+                    console.error('[uploadImageFromClipboard] 剪贴板中没有图片');
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    error: "剪贴板中没有图片",
+                                    tip: "请先复制图片，不要粘贴到输入框，直接告诉我'上传'"
+                                }, null, 2)
+                            }],
+                        isError: true
+                    };
+                }
+                fileBuffer = Buffer.from(result, 'base64');
+                finalFilename = filename || `clipboard_${Date.now()}.png`;
+                console.log(`[uploadImageFromClipboard] 已读取剪贴板图片，大小: ${fileBuffer.length} bytes`);
+            }
+            catch (err) {
+                console.error('[uploadImageFromClipboard] Windows读取剪贴板失败:', err);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                error: "读取剪贴板失败",
+                                details: err.message,
+                                tip: "请确保已复制图片到剪贴板"
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+        // macOS: 使用 pngpaste
+        else if (process.platform === 'darwin') {
+            console.log('[uploadImageFromClipboard] macOS平台，使用pngpaste读取剪贴板...');
+            const tempFile = path.join(process.cwd(), '.temp_clipboard.png');
+            try {
+                execSync(`pngpaste "${tempFile}"`);
+                fileBuffer = fs.readFileSync(tempFile);
+                fs.unlinkSync(tempFile);
+                finalFilename = filename || `clipboard_${Date.now()}.png`;
+                console.log(`[uploadImageFromClipboard] 已读取剪贴板图片，大小: ${fileBuffer.length} bytes`);
+            }
+            catch (err) {
+                console.error('[uploadImageFromClipboard] macOS读取剪贴板失败:', err);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                error: "剪贴板中没有图片或pngpaste未安装",
+                                tip: "请先安装 pngpaste: brew install pngpaste"
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+        // Linux: 使用 xclip
+        else {
+            console.log('[uploadImageFromClipboard] Linux平台，使用xclip读取剪贴板...');
+            try {
+                const buffer = execSync('xclip -selection clipboard -t image/png -o', {
+                    maxBuffer: 10 * 1024 * 1024
+                });
+                fileBuffer = buffer;
+                finalFilename = filename || `clipboard_${Date.now()}.png`;
+                console.log(`[uploadImageFromClipboard] 已读取剪贴板图片，大小: ${fileBuffer.length} bytes`);
+            }
+            catch (err) {
+                console.error('[uploadImageFromClipboard] Linux读取剪贴板失败:', err);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                error: "剪贴板中没有图片或xclip未安装",
+                                tip: "请先安装 xclip: sudo apt-get install xclip"
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+        // 创建 img 文件夹
+        const imgDir = path.join(process.cwd(), 'img');
+        if (!fs.existsSync(imgDir)) {
+            console.log(`[uploadImageFromClipboard] 创建目录: ${imgDir}`);
+            fs.mkdirSync(imgDir, { recursive: true });
+        }
+        // 保存到 img 文件夹
+        const savedPath = path.join(imgDir, finalFilename);
+        fs.writeFileSync(savedPath, fileBuffer);
+        console.log(`[uploadImageFromClipboard] 图片已保存到: ${savedPath}`);
+        // 上传到禅道
+        console.log('[uploadImageFromClipboard] 开始上传到禅道...');
+        const uploadResult = await zentaoApi.uploadFile({
+            file: fileBuffer,
+            filename: finalFilename,
+            uid
+        });
+        console.log('[uploadImageFromClipboard] 上传成功，结果:', uploadResult);
+        // 生成禅道需要的 HTML 格式
+        const fileId = uploadResult.id;
+        const baseUrl = zentaoApi.getConfig().url;
+        const imageUrl = `${baseUrl}/zentao/file-read-${fileId}.png`;
+        const imageHtml = `<p><img onload="setImageSize(this,0)" src="${imageUrl}" alt="${finalFilename}" /></p>`;
+        const response = {
+            success: true,
+            upload: uploadResult,
+            savedPath: savedPath,
+            filename: finalFilename,
+            fileSize: fileBuffer.length,
+            fileId: fileId,
+            imageUrl: imageUrl,
+            imageHtml: imageHtml,
+            message: `图片已保存到本地并上传到禅道`,
+            tip: `更新 Bug 描述时，请使用 imageHtml 字段中的 HTML 代码。图片会被包裹在 <p> 标签中以确保正确显示。`
+        };
+        console.log('[uploadImageFromClipboard] 返回结果:', response);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify(response, null, 2)
+                }]
+        };
+    }
+    catch (error) {
+        console.error('[uploadImageFromClipboard] 发生错误:', error);
+        const errorResponse = {
+            success: false,
+            error: error.message || String(error),
+            stack: error.stack,
+            tip: "请检查：\n1. 确保已复制图片到剪贴板\n2. 不要粘贴到输入框，直接说'上传剪贴板图片'\n3. 或使用命令行: upload.bat"
+        };
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify(errorResponse, null, 2)
+                }],
+            isError: true
+        };
+    }
+});
+server.tool("downloadFile", {
+    fileId: z.number(),
+    savePath: z.string()
+}, async ({ fileId, savePath }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const fs = await import('fs');
+    const fileBuffer = await zentaoApi.downloadFile(fileId);
+    fs.writeFileSync(savePath, fileBuffer);
+    return { content: [{ type: "text", text: `文件已下载到: ${savePath}` }] };
+});
+server.tool("getComments", "获取评论列表 - 获取指定对象的所有评论", {
+    objectType: z.enum([
+        'story', // 软件需求
+        'requirement', // 用户需求
+        'task', // 任务
+        'bug', // Bug
+        'testcase', // 测试用例
+        'testtask', // 测试单
+        'todo', // 待办
+        'doc', // 文档
+        'execution', // 执行/迭代
+        'project', // 项目
+        'doctemplate' // 文档模板
+    ]).describe("对象类型"),
+    objectID: z.number().describe("对象ID")
+}, async ({ objectType, objectID }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const comments = await zentaoApi.getComments(objectType, objectID);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    total: comments.length,
+                    objectType,
+                    objectID,
+                    comments
+                }, null, 2)
+            }]
+    };
+});
+server.tool("getCommentDetail", "获取单条评论详情", {
+    commentId: z.number().describe("评论ID")
+}, async ({ commentId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const comment = await zentaoApi.getCommentDetail(commentId);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify(comment, null, 2)
+            }]
+    };
+});
+server.tool("addComment", "添加评论 - 为需求、任务、Bug等对象添加评论", {
+    objectType: z.enum([
+        'story', // 软件需求
+        'requirement', // 用户需求
+        'task', // 任务
+        'bug', // Bug
+        'testcase', // 测试用例
+        'testtask', // 测试单
+        'todo', // 待办
+        'doc', // 文档
+        'execution', // 执行/迭代
+        'project', // 项目
+        'doctemplate' // 文档模板
+    ]).describe("对象类型"),
+    objectID: z.number().describe("对象ID"),
+    comment: z.string().describe("评论内容，支持HTML格式"),
+    uid: z.string().optional().describe("唯一标识符（可选）")
+}, async ({ objectType, objectID, comment, uid }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const result = await zentaoApi.addComment({
+        objectType,
+        objectID,
+        comment,
+        uid
+    });
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    message: '评论添加成功',
+                    comment: result
+                }, null, 2)
+            }]
+    };
+});
+server.tool("updateComment", "更新评论 - 只能更新自己的评论", {
+    commentId: z.number().describe("评论ID"),
+    comment: z.string().describe("更新后的评论内容，支持HTML格式"),
+    uid: z.string().optional().describe("唯一标识符（可选）")
+}, async ({ commentId, comment, uid }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const result = await zentaoApi.updateComment(commentId, {
+        comment,
+        uid
+    });
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    message: '评论更新成功',
+                    comment: result
+                }, null, 2)
+            }]
+    };
+});
+server.tool("deleteComment", "删除评论 - 只能删除自己的评论，管理员可以删除所有评论", {
+    commentId: z.number().describe("评论ID")
+}, async ({ commentId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const result = await zentaoApi.deleteComment(commentId);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    status: 'success',
+                    message: result.message || '评论删除成功'
+                }, null, 2)
+            }]
+    };
+});
+server.tool("addStoryComment", "为需求添加评论 - 专用工具，支持软件需求(story)和用户需求(requirement)", {
+    storyId: z.number().describe("需求ID"),
+    comment: z.string().describe("评论内容，支持HTML格式")
+}, async ({ storyId, comment }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const result = await zentaoApi.addComment({
+        objectType: 'story',
+        objectID: storyId,
+        comment
+    });
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    message: `已为需求 #${storyId} 添加评论`,
+                    comment: result
+                }, null, 2)
+            }]
+    };
+});
+server.tool("addTaskComment", "为任务添加评论", {
+    taskId: z.number().describe("任务ID"),
+    comment: z.string().describe("评论内容，支持HTML格式")
+}, async ({ taskId, comment }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const result = await zentaoApi.addComment({
+        objectType: 'task',
+        objectID: taskId,
+        comment
+    });
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    message: `已为任务 #${taskId} 添加评论`,
+                    comment: result
+                }, null, 2)
+            }]
+    };
+});
+server.tool("addBugComment", "为Bug添加评论", {
+    bugId: z.number().describe("Bug ID"),
+    comment: z.string().describe("评论内容，支持HTML格式")
+}, async ({ bugId, comment }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const result = await zentaoApi.addComment({
+        objectType: 'bug',
+        objectID: bugId,
+        comment
+    });
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    message: `已为Bug #${bugId} 添加评论`,
+                    comment: result
+                }, null, 2)
+            }]
+    };
+});
+// Start receiving messages on stdin and sending messages on stdout
+const transport = new StdioServerTransport();
+await server.connect(transport).catch(console.error);