@zzp123/mcp-zentao 1.0.1 → 1.1.0

package/dist/index.js

@@ -160,6 +160,764 @@ server.tool("resolveBug", {
         content: [{ type: "text", text: JSON.stringify(bug, null, 2) }]
     };
 });
+// Add getPrograms tool
+server.tool("getPrograms", {
+    order: z.string().optional()
+}, async ({ order }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const programs = await zentaoApi.getPrograms(order);
+    return {
+        content: [{ type: "text", text: JSON.stringify(programs, null, 2) }]
+    };
+});
+// Add getProductPlans tool
+server.tool("getProductPlans", {
+    productId: z.number(),
+    branch: z.number().optional(),
+    begin: z.string().optional(),
+    end: z.string().optional(),
+    status: z.string().optional(),
+    parent: z.number().optional()
+}, async ({ productId, branch, begin, end, status, parent }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const plans = await zentaoApi.getProductPlans(productId, branch, begin, end, status, parent);
+    return {
+        content: [{ type: "text", text: JSON.stringify(plans, null, 2) }]
+    };
+});
+// Add createTask tool
+server.tool("createTask", {
+    name: z.string(),
+    execution: z.number(),
+    desc: z.string().optional(),
+    pri: z.number().min(1).max(4).optional(),
+    estimate: z.number().optional(),
+    project: z.number().optional(),
+    module: z.number().optional(),
+    story: z.number().optional(),
+    type: z.string().optional(),
+    assignedTo: z.string().optional(),
+    estStarted: z.string().optional(),
+    deadline: z.string().optional()
+}, async ({ name, execution, desc, pri, estimate, project, module, story, type, assignedTo, estStarted, deadline }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const task = await zentaoApi.createTask({
+        name,
+        execution,
+        desc,
+        pri,
+        estimate,
+        project,
+        module,
+        story,
+        type,
+        assignedTo,
+        estStarted,
+        deadline
+    });
+    return {
+        content: [{ type: "text", text: JSON.stringify(task, null, 2) }]
+    };
+});
+// Add createStory tool
+server.tool("createStory", {
+    title: z.string(),
+    product: z.number(),
+    pri: z.number(),
+    category: z.string().optional(),
+    spec: z.string().optional(),
+    verify: z.string().optional(),
+    source: z.string().optional(),
+    sourceNote: z.string().optional(),
+    estimate: z.number().optional(),
+    keywords: z.string().optional()
+}, async ({ title, product, pri, category, spec, verify, source, sourceNote, estimate, keywords }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const story = await zentaoApi.createStory({
+        title,
+        product,
+        pri,
+        category,
+        spec,
+        verify,
+        source,
+        sourceNote,
+        estimate,
+        keywords
+    });
+    return {
+        content: [{ type: "text", text: JSON.stringify(story, null, 2) }]
+    };
+});
+// Add getPlanDetail tool
+server.tool("getPlanDetail", {
+    planId: z.number()
+}, async ({ planId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const plan = await zentaoApi.getPlanDetail(planId);
+    return {
+        content: [{ type: "text", text: JSON.stringify(plan, null, 2) }]
+    };
+});
+// Add updatePlan tool
+server.tool("updatePlan", {
+    planId: z.number(),
+    update: z.object({
+        branch: z.number().optional(),
+        title: z.string().optional(),
+        begin: z.string().optional(),
+        end: z.string().optional(),
+        desc: z.string().optional()
+    })
+}, async ({ planId, update }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const plan = await zentaoApi.updatePlan(planId, update);
+    return {
+        content: [{ type: "text", text: JSON.stringify(plan, null, 2) }]
+    };
+});
+// Add deletePlan tool
+server.tool("deletePlan", {
+    planId: z.number()
+}, async ({ planId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const result = await zentaoApi.deletePlan(planId);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+    };
+});
+// Add linkStoriesToPlan tool
+server.tool("linkStoriesToPlan", {
+    planId: z.number(),
+    storyIds: z.array(z.number())
+}, async ({ planId, storyIds }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const plan = await zentaoApi.linkStoriesToPlan(planId, storyIds);
+    return {
+        content: [{ type: "text", text: JSON.stringify(plan, null, 2) }]
+    };
+});
+// Add unlinkStoriesFromPlan tool
+server.tool("unlinkStoriesFromPlan", {
+    planId: z.number(),
+    storyIds: z.array(z.number())
+}, async ({ planId, storyIds }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const plan = await zentaoApi.unlinkStoriesFromPlan(planId, storyIds);
+    return {
+        content: [{ type: "text", text: JSON.stringify(plan, null, 2) }]
+    };
+});
+// Add linkBugsToPlan tool
+server.tool("linkBugsToPlan", {
+    planId: z.number(),
+    bugIds: z.array(z.number())
+}, async ({ planId, bugIds }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const plan = await zentaoApi.linkBugsToPlan(planId, bugIds);
+    return {
+        content: [{ type: "text", text: JSON.stringify(plan, null, 2) }]
+    };
+});
+// Add unlinkBugsFromPlan tool
+server.tool("unlinkBugsFromPlan", {
+    planId: z.number(),
+    bugIds: z.array(z.number())
+}, async ({ planId, bugIds }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const plan = await zentaoApi.unlinkBugsFromPlan(planId, bugIds);
+    return {
+        content: [{ type: "text", text: JSON.stringify(plan, null, 2) }]
+    };
+});
+// Add getProjectReleases tool
+server.tool("getProjectReleases", {
+    projectId: z.number()
+}, async ({ projectId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const releases = await zentaoApi.getProjectReleases(projectId);
+    return {
+        content: [{ type: "text", text: JSON.stringify(releases, null, 2) }]
+    };
+});
+// Add getStoryDetail tool
+server.tool("getStoryDetail", {
+    storyId: z.number()
+}, async ({ storyId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const story = await zentaoApi.getStoryDetail(storyId);
+    return {
+        content: [{ type: "text", text: JSON.stringify(story, null, 2) }]
+    };
+});
+// Add createBug tool
+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()
+}, 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");
+    const bug = await zentaoApi.createBug(productId, {
+        title,
+        severity,
+        pri,
+        type,
+        branch,
+        module,
+        execution,
+        keywords,
+        os,
+        browser,
+        steps,
+        task,
+        story,
+        deadline,
+        openedBuild
+    });
+    return {
+        content: [{ type: "text", text: JSON.stringify(bug, null, 2) }]
+    };
+});
+// Add getProjectExecutions tool
+server.tool("getProjectExecutions", {
+    projectId: z.number()
+}, async ({ projectId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const executions = await zentaoApi.getProjectExecutions(projectId);
+    return {
+        content: [{ type: "text", text: JSON.stringify(executions, null, 2) }]
+    };
+});
+// Add createPlan tool
+server.tool("createPlan", {
+    productId: z.number(),
+    title: z.string(),
+    branch: z.number().optional(),
+    begin: z.string().optional(),
+    end: z.string().optional(),
+    desc: z.string().optional(),
+    parent: z.number().optional()
+}, async ({ productId, title, branch, begin, end, desc, parent }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const plan = await zentaoApi.createPlan(productId, {
+        title,
+        branch,
+        begin,
+        end,
+        desc,
+        parent
+    });
+    return {
+        content: [{ type: "text", text: JSON.stringify(plan, null, 2) }]
+    };
+});
+// Add getProjects tool
+server.tool("getProjects", {
+    page: z.number().optional(),
+    limit: z.number().optional()
+}, async ({ page, limit }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const projects = await zentaoApi.getProjects(page, limit);
+    return {
+        content: [{ type: "text", text: JSON.stringify(projects, null, 2) }]
+    };
+});
+// Add updateStory tool
+server.tool("updateStory", {
+    storyId: z.number(),
+    update: z.object({
+        module: z.number().optional(),
+        source: z.string().optional(),
+        sourceNote: z.string().optional(),
+        pri: z.number().optional(),
+        category: z.string().optional(),
+        estimate: z.number().optional(),
+        keywords: z.string().optional()
+    })
+}, async ({ storyId, update }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const story = await zentaoApi.updateStory(storyId, update);
+    return {
+        content: [{ type: "text", text: JSON.stringify(story, null, 2) }]
+    };
+});
+// Add deleteTask tool
+server.tool("deleteTask", {
+    taskId: z.number()
+}, async ({ taskId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const result = await zentaoApi.deleteTask(taskId);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+    };
+});
+// Add getProductStories tool
+server.tool("getProductStories", {
+    productId: z.number()
+}, async ({ productId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const stories = await zentaoApi.getProductStories(productId);
+    return {
+        content: [{ type: "text", text: JSON.stringify(stories, null, 2) }]
+    };
+});
+// Program tools
+server.tool("getProgramDetail", { programId: z.number() }, async ({ programId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.getProgramDetail(programId), null, 2) }] };
+});
+server.tool("createProgram", {
+    name: z.string().optional(), parent: z.string().optional(), PM: z.string().optional(),
+    budget: z.number().optional(), budgetUnit: z.string().optional(), desc: z.string().optional(),
+    begin: z.string().optional(), end: z.string().optional(), acl: z.string().optional(),
+    whitelist: z.array(z.string()).optional()
+}, async (params) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.createProgram(params), null, 2) }] };
+});
+server.tool("updateProgram", {
+    programId: z.number(),
+    update: z.object({
+        name: z.string().optional(), parent: z.string().optional(), PM: z.string().optional(),
+        budget: z.number().optional(), budgetUnit: z.string().optional(), desc: z.string().optional(),
+        begin: z.string().optional(), end: z.string().optional(), acl: z.string().optional(),
+        whitelist: z.array(z.string()).optional()
+    })
+}, async ({ programId, update }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.updateProgram(programId, update), null, 2) }] };
+});
+server.tool("deleteProgram", { programId: z.number() }, async ({ programId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.deleteProgram(programId), null, 2) }] };
+});
+// Product tools
+server.tool("getProductDetail", { productId: z.number() }, async ({ productId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.getProductDetail(productId), null, 2) }] };
+});
+server.tool("createProduct", {
+    name: z.string(), code: z.string(), program: z.number().optional(), line: z.number().optional(),
+    PO: z.string().optional(), QD: z.string().optional(), RD: z.string().optional(),
+    type: z.string().optional(), desc: z.string().optional(), acl: z.string().optional(),
+    whitelist: z.array(z.string()).optional()
+}, async (params) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.createProduct(params), null, 2) }] };
+});
+server.tool("updateProduct", {
+    productId: z.number(),
+    update: z.object({
+        name: z.string().optional(), code: z.string().optional(), type: z.string().optional(),
+        line: z.number().optional(), program: z.number().optional(), status: z.string().optional(),
+        desc: z.string().optional()
+    })
+}, async ({ productId, update }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.updateProduct(productId, update), null, 2) }] };
+});
+server.tool("deleteProduct", { productId: z.number() }, async ({ productId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.deleteProduct(productId), null, 2) }] };
+});
+// Project tools
+server.tool("getProjectDetail", { projectId: z.number() }, async ({ projectId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.getProjectDetail(projectId), null, 2) }] };
+});
+server.tool("createProject", {
+    name: z.string(), begin: z.string(), end: z.string(), products: z.array(z.number()),
+    code: z.string(), model: z.string().optional(), parent: z.number().optional()
+}, async (params) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.createProject(params), null, 2) }] };
+});
+server.tool("updateProject", {
+    projectId: z.number(),
+    update: z.object({
+        name: z.string().optional(), code: z.string().optional(), parent: z.number().optional(),
+        PM: z.string().optional(), budget: z.number().optional(), budgetUnit: z.string().optional(),
+        days: z.number().optional(), desc: z.string().optional(), acl: z.string().optional(),
+        whitelist: z.array(z.string()).optional(), auth: z.string().optional()
+    })
+}, async ({ projectId, update }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.updateProject(projectId, update), null, 2) }] };
+});
+server.tool("deleteProject", { projectId: z.number() }, async ({ projectId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.deleteProject(projectId), null, 2) }] };
+});
+// Execution tools
+server.tool("createExecution", {
+    projectId: z.number(), project: z.number(), name: z.string(), code: z.string(),
+    begin: z.string(), end: z.string(), days: z.number().optional(), lifetime: z.string().optional(),
+    PO: z.string().optional(), PM: z.string().optional(), QD: z.string().optional(),
+    RD: z.string().optional(), teamMembers: z.array(z.string()).optional(),
+    desc: z.string().optional(), acl: z.string().optional(), whitelist: z.array(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.createExecution(projectId, params), null, 2) }] };
+});
+server.tool("getExecutionDetail", { executionId: z.number() }, async ({ executionId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.getExecutionDetail(executionId), null, 2) }] };
+});
+server.tool("updateExecution", {
+    executionId: z.number(),
+    update: z.object({
+        project: z.number().optional(), name: z.string().optional(), code: z.string().optional(),
+        begin: z.string().optional(), end: z.string().optional(), days: z.number().optional(),
+        lifetime: z.string().optional(), PO: z.string().optional(), PM: z.string().optional(),
+        QD: z.string().optional(), RD: z.string().optional(), teamMembers: z.array(z.string()).optional(),
+        desc: z.string().optional(), acl: z.string().optional(), whitelist: z.array(z.string()).optional()
+    })
+}, async ({ executionId, update }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.updateExecution(executionId, update), null, 2) }] };
+});
+server.tool("deleteExecution", { executionId: z.number() }, async ({ executionId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.deleteExecution(executionId), null, 2) }] };
+});
+// Story tools
+server.tool("deleteStory", { storyId: z.number() }, async ({ storyId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.deleteStory(storyId), null, 2) }] };
+});
+// Bug tools
+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("getFeedbacks", {
+    solution: 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.getFeedbacks(params), null, 2) }] };
+});
+server.tool("getFeedbackDetail", { feedbackId: z.number() }, async ({ feedbackId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.getFeedbackDetail(feedbackId), null, 2) }] };
+});
+server.tool("createFeedback", {
+    product: z.number(),
+    module: z.number().optional(),
+    title: z.string(),
+    type: z.string().optional(),
+    desc: z.string().optional(),
+    public: z.number().optional(),
+    notify: z.number().optional(),
+    notifyEmail: z.string().optional(),
+    feedbackBy: z.string().optional()
+}, async (params) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.createFeedback(params), null, 2) }] };
+});
+server.tool("updateFeedback", {
+    feedbackId: z.number(),
+    product: z.number().optional(),
+    module: z.number().optional(),
+    title: z.string().optional(),
+    type: z.string().optional(),
+    desc: z.string().optional(),
+    public: z.number().optional(),
+    notify: z.number().optional(),
+    notifyEmail: z.string().optional(),
+    feedbackBy: z.string().optional()
+}, async ({ feedbackId, ...params }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.updateFeedback(feedbackId, params), null, 2) }] };
+});
+server.tool("deleteFeedback", { feedbackId: z.number() }, async ({ feedbackId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.deleteFeedback(feedbackId), null, 2) }] };
+});
+server.tool("assignFeedback", {
+    feedbackId: z.number(),
+    assignedTo: z.string().optional(),
+    comment: z.string().optional(),
+    mailto: z.string().optional()
+}, async ({ feedbackId, ...params }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.assignFeedback(feedbackId, params), null, 2) }] };
+});
+server.tool("closeFeedback", {
+    feedbackId: z.number(),
+    closedReason: z.string().optional(),
+    comment: z.string().optional()
+}, async ({ feedbackId, ...params }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.closeFeedback(feedbackId, params), 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("getProjectBuilds", { projectId: z.number() }, async ({ projectId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.getProjectBuilds(projectId), null, 2) }] };
+});
+server.tool("getExecutionBuilds", { executionId: z.number() }, async ({ executionId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.getExecutionBuilds(executionId), 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("getUserDetail", { userId: z.number() }, async ({ userId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.getUserDetail(userId), null, 2) }] };
+});
+server.tool("getMyProfile", {}, async () => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.getMyProfile(), null, 2) }] };
+});
+server.tool("getUsers", {
+    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.getUsers(params), null, 2) }] };
+});
+server.tool("createUser", {
+    account: z.string(),
+    password: z.string(),
+    realname: z.string().optional(),
+    visions: z.array(z.string()).optional()
+}, async (params) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.createUser(params), null, 2) }] };
+});
+server.tool("updateUser", {
+    userId: z.number(),
+    dept: z.number().optional(),
+    role: z.string().optional(),
+    mobile: z.string().optional(),
+    realname: z.string().optional(),
+    email: z.string().optional(),
+    phone: z.string().optional()
+}, async ({ userId, ...params }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.updateUser(userId, params), null, 2) }] };
+});
+server.tool("deleteUser", { userId: z.number() }, async ({ userId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    return { content: [{ type: "text", text: JSON.stringify(await zentaoApi.deleteUser(userId), 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) }] };
+});
 // Start receiving messages on stdin and sending messages on stdout
 const transport = new StdioServerTransport();
 await server.connect(transport).catch(console.error);