@catchmexz/fedin-vibe-mcp-server 0.1.0

package/dist/tool-handlers/organization.js

@@ -0,0 +1,90 @@
+import * as organization from '../operations/organization/organization.js';
+import * as members from '../operations/organization/members.js';
+import * as types from '../common/types.js';
+export const handleOrganizationTools = async (request) => {
+    switch (request.params.name) {
+        case "get_current_organization_info": {
+            const currentOrgInfo = await organization.getCurrentOrganizationInfoFunc();
+            return {
+                content: [{ type: "text", text: JSON.stringify(currentOrgInfo, null, 2) }],
+            };
+        }
+        case "get_user_organizations": {
+            const userOrgs = await organization.getUserOrganizationsFunc();
+            return {
+                content: [{ type: "text", text: JSON.stringify(userOrgs, null, 2) }],
+            };
+        }
+        case "get_current_user": {
+            const currentUserInfo = await organization.getCurrentUserFunc();
+            return {
+                content: [{ type: "text", text: JSON.stringify(currentUserInfo, null, 2) }],
+            };
+        }
+        case "list_organization_departments": {
+            const args = types.GetOrganizationDepartmentsSchema.parse(request.params.arguments);
+            const departments = await organization.getOrganizationDepartmentsFunc(args.organizationId, args.parentId ?? undefined);
+            return {
+                content: [{ type: "text", text: JSON.stringify(departments, null, 2) }],
+            };
+        }
+        case "get_organization_department_info": {
+            const args = types.GetOrganizationDepartmentInfoSchema.parse(request.params.arguments);
+            const departmentInfo = await organization.getOrganizationDepartmentInfoFunc(args.organizationId, args.id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(departmentInfo, null, 2) }],
+            };
+        }
+        case "get_organization_department_ancestors": {
+            const args = types.GetOrganizationDepartmentAncestorsSchema.parse(request.params.arguments);
+            const ancestors = await organization.getOrganizationDepartmentAncestorsFunc(args.organizationId, args.id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(ancestors, null, 2) }],
+            };
+        }
+        case "list_organization_members": {
+            const args = types.GetOrganizationMembersSchema.parse(request.params.arguments);
+            const orgMembers = await members.getOrganizationMembersFunc(args.organizationId, args.page ?? 1, args.perPage ?? 100);
+            return {
+                content: [{ type: "text", text: JSON.stringify(orgMembers, null, 2) }]
+            };
+        }
+        case "get_organization_member_info": {
+            const args = types.GetOrganizationMemberInfoSchema.parse(request.params.arguments);
+            const memberInfo = await members.getOrganizationMemberInfoFunc(args.organizationId, args.memberId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(memberInfo, null, 2) }]
+            };
+        }
+        case "get_organization_member_info_by_user_id": {
+            const args = types.GetOrganizationMemberByUserIdInfoSchema.parse(request.params.arguments);
+            const memberInfo = await members.getOrganizationMemberByUserIdInfoFunc(args.organizationId, args.userId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(memberInfo, null, 2) }]
+            };
+        }
+        case "search_organization_members": {
+            const args = types.SearchOrganizationMembersSchema.parse(request.params.arguments);
+            const membersResult = await members.searchOrganizationMembersFunc(args.organizationId, args.includeChildren ?? false, args.page ?? 1, args.perPage ?? 100, args.deptIds ?? undefined, args.nextToken ?? undefined, args.query ?? undefined, args.roleIds ?? undefined, args.statuses ?? undefined);
+            return {
+                content: [{ type: "text", text: JSON.stringify(membersResult, null, 2) }]
+            };
+        }
+        case "list_organization_roles": {
+            const args = types.ListOrganizationRolesSchema.parse(request.params.arguments);
+            const roles = await organization.listOrganizationRolesFunc(args.organizationId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(roles, null, 2) }]
+            };
+        }
+        case "get_organization_role": {
+            const args = types.GetOrganizationRoleSchema.parse(request.params.arguments);
+            const role = await organization.getOrganizationRoleFunc(args.organizationId, args.roleId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(role, null, 2) }]
+            };
+        }
+        default:
+            return null;
+    }
+};

package/dist/tool-handlers/packages.js

@@ -0,0 +1,32 @@
+import * as packageRepositories from '../operations/packages/repositories.js';
+import * as artifacts from '../operations/packages/artifacts.js';
+import * as types from '../common/types.js';
+export const handlePackageManagementTools = async (request) => {
+    switch (request.params.name) {
+        // Package Repository Operations
+        case "list_package_repositories": {
+            const args = types.ListPackageRepositoriesSchema.parse(request.params.arguments);
+            const packageRepoList = await packageRepositories.listPackageRepositoriesFunc(args.organizationId, args.repoTypes ?? undefined, args.repoCategories ?? undefined, args.perPage, args.page);
+            return {
+                content: [{ type: "text", text: JSON.stringify(packageRepoList, null, 2) }],
+            };
+        }
+        // Package Artifact Operations
+        case "list_artifacts": {
+            const args = types.ListArtifactsSchema.parse(request.params.arguments);
+            const artifactsList = await artifacts.listArtifactsFunc(args.organizationId, args.repoId, args.repoType, args.page, args.perPage, args.search ?? undefined, args.orderBy, args.sort);
+            return {
+                content: [{ type: "text", text: JSON.stringify(artifactsList, null, 2) }],
+            };
+        }
+        case "get_artifact": {
+            const args = types.GetArtifactSchema.parse(request.params.arguments);
+            const artifact = await artifacts.getArtifactFunc(args.organizationId, args.repoId, args.id, args.repoType);
+            return {
+                content: [{ type: "text", text: JSON.stringify(artifact, null, 2) }],
+            };
+        }
+        default:
+            return null;
+    }
+};

package/dist/tool-handlers/pipeline.js

@@ -0,0 +1,272 @@
+import * as pipeline from '../operations/flow/pipeline.js';
+import * as pipelineJob from '../operations/flow/pipelineJob.js';
+import * as types from '../common/types.js';
+import { z } from 'zod';
+export const handlePipelineTools = async (request) => {
+    switch (request.params.name) {
+        case "get_pipeline": {
+            const args = types.GetPipelineSchema.parse(request.params.arguments);
+            const pipelineInfo = await pipeline.getPipelineFunc(args.organizationId, args.pipelineId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(pipelineInfo, null, 2) }],
+            };
+        }
+        case "list_pipelines": {
+            const args = types.ListPipelinesSchema.parse(request.params.arguments);
+            const pipelines = await pipeline.listPipelinesFunc(args.organizationId, {
+                createStartTime: args.createStartTime,
+                createEndTime: args.createEndTime,
+                executeStartTime: args.executeStartTime,
+                executeEndTime: args.executeEndTime,
+                pipelineName: args.pipelineName,
+                statusList: args.statusList,
+                perPage: args.perPage,
+                page: args.page
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(pipelines, null, 2) }],
+            };
+        }
+        case "generate_pipeline_yaml": {
+            try {
+                const args = types.CreatePipelineFromDescriptionSchema.parse(request.params.arguments);
+                // 检查必需的参数
+                if (!args.buildLanguage) {
+                    throw new Error("The build language parameter is missing.");
+                }
+                if (!args.buildTool) {
+                    throw new Error("The build tool parameter is missing.");
+                }
+                const yamlContent = await pipeline.generatePipelineYamlFunc({
+                    buildLanguage: args.buildLanguage,
+                    buildTool: args.buildTool,
+                    deployTarget: args.deployTarget,
+                    // Repository configuration  
+                    repoUrl: args.repoUrl,
+                    branch: args.branch,
+                    serviceName: args.serviceName,
+                    serviceConnectionId: args.serviceConnectionId,
+                    // Version configuration
+                    jdkVersion: args.jdkVersion,
+                    mavenVersion: args.mavenVersion,
+                    nodeVersion: args.nodeVersion,
+                    pythonVersion: args.pythonVersion,
+                    goVersion: args.goVersion,
+                    // Build configuration
+                    buildCommand: args.buildCommand,
+                    testCommand: args.testCommand,
+                    // Artifact upload configuration
+                    uploadType: args.uploadType,
+                    packagesServiceConnection: args.packagesServiceConnection,
+                    artifactName: args.artifactName,
+                    artifactVersion: args.artifactVersion,
+                    packagesRepoId: args.packagesRepoId,
+                    includePathInArtifact: args.includePathInArtifact,
+                    // VM deployment configuration
+                    machineGroupId: args.machineGroupId,
+                    executeUser: args.executeUser,
+                    artifactDownloadPath: args.artifactDownloadPath,
+                    deployCommand: args.deployCommand,
+                    pauseStrategy: args.pauseStrategy,
+                    batchNumber: args.batchNumber,
+                    // Kubernetes deployment configuration
+                    kubernetesClusterId: args.kubernetesClusterId,
+                    kubectlVersion: args.kubectlVersion,
+                    namespace: args.namespace,
+                    yamlPath: args.yamlPath,
+                    dockerImage: args.dockerImage,
+                });
+                return {
+                    content: [{ type: "text", text: yamlContent }],
+                };
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes("build language parameter is missing")) {
+                    throw error; // 重新抛出我们自定义的错误
+                }
+                if (error instanceof Error && error.message.includes("build tool parameter is missing")) {
+                    throw error; // 重新抛出我们自定义的错误
+                }
+                // 处理YAML生成过程中的错误
+                if (error instanceof Error) {
+                    throw new Error(`YAML generation failed: ${error.message}`);
+                }
+                throw error;
+            }
+        }
+        case "create_pipeline_from_description": {
+            try {
+                const args = types.CreatePipelineFromDescriptionSchema.parse(request.params.arguments);
+                // 检查必需的参数
+                if (!args.name) {
+                    throw new Error("The Pipeline name cannot be empty.");
+                }
+                if (!args.buildLanguage) {
+                    throw new Error("The build language parameter is missing.");
+                }
+                if (!args.buildTool) {
+                    throw new Error("The build tool parameter is missing.");
+                }
+                const result = await pipeline.createPipelineWithOptionsFunc(args.organizationId, {
+                    name: args.name,
+                    repoUrl: args.repoUrl,
+                    branch: args.branch,
+                    serviceConnectionId: args.serviceConnectionId,
+                    // 技术栈参数
+                    buildLanguage: args.buildLanguage,
+                    buildTool: args.buildTool,
+                    deployTarget: args.deployTarget,
+                    // 版本相关参数
+                    jdkVersion: args.jdkVersion,
+                    mavenVersion: args.mavenVersion,
+                    nodeVersion: args.nodeVersion,
+                    pythonVersion: args.pythonVersion,
+                    goVersion: args.goVersion,
+                    kubectlVersion: args.kubectlVersion,
+                    // 构建物上传相关参数
+                    uploadType: args.uploadType,
+                    artifactName: args.artifactName,
+                    artifactVersion: args.artifactVersion,
+                    packagesServiceConnection: args.packagesServiceConnection,
+                    packagesRepoId: args.packagesRepoId,
+                    includePathInArtifact: args.includePathInArtifact,
+                    // 部署相关参数
+                    executeUser: args.executeUser,
+                    artifactDownloadPath: args.artifactDownloadPath,
+                    machineGroupId: args.machineGroupId,
+                    pauseStrategy: args.pauseStrategy,
+                    batchNumber: args.batchNumber,
+                    kubernetesClusterId: args.kubernetesClusterId,
+                    yamlPath: args.yamlPath,
+                    namespace: args.namespace,
+                    dockerImage: args.dockerImage,
+                    // 自定义命令
+                    buildCommand: args.buildCommand,
+                    testCommand: args.testCommand,
+                    deployCommand: args.deployCommand,
+                });
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes("Pipeline name cannot be empty")) {
+                    throw error;
+                }
+                if (error instanceof Error && error.message.includes("build language parameter is missing")) {
+                    throw error;
+                }
+                if (error instanceof Error && error.message.includes("build language tool is missing")) {
+                    throw error;
+                }
+                // 处理流水线创建过程中的其他错误
+                if (error instanceof Error) {
+                    throw new Error(`Create pipeline failed: ${error.message}\n Suggestion: Please check whether the organization ID, repository configuration, or other parameters are correct, and if generated YAML to check whether YAML content is invalid.`);
+                }
+                throw error;
+            }
+        }
+        case "smart_list_pipelines": {
+            // Parse arguments using the schema defined in the tool registration
+            const args = z.object({
+                organizationId: z.string(),
+                timeReference: z.string().optional(),
+                pipelineName: z.string().optional(),
+                statusList: z.string().optional(),
+                perPage: z.number().int().optional(),
+                page: z.number().int().optional()
+            }).parse(request.params.arguments);
+            // Call the smart list function
+            const pipelines = await pipeline.smartListPipelinesFunc(args.organizationId, args.timeReference, {
+                pipelineName: args.pipelineName,
+                statusList: args.statusList,
+                perPage: args.perPage,
+                page: args.page
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(pipelines, null, 2) }],
+            };
+        }
+        case "create_pipeline_run": {
+            const args = types.CreatePipelineRunSchema.parse(request.params.arguments);
+            const runId = await pipeline.createPipelineRunFunc(args.organizationId, args.pipelineId, {
+                params: args.params,
+                description: args.description,
+                branches: args.branches,
+                branchMode: args.branchMode,
+                releaseBranch: args.releaseBranch,
+                createReleaseBranch: args.createReleaseBranch,
+                environmentVariables: args.environmentVariables,
+                repositories: args.repositories
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(runId, null, 2) }],
+            };
+        }
+        case "get_latest_pipeline_run": {
+            const args = types.GetLatestPipelineRunSchema.parse(request.params.arguments);
+            const pipelineRun = await pipeline.getLatestPipelineRunFunc(args.organizationId, args.pipelineId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(pipelineRun, null, 2) }],
+            };
+        }
+        case "get_pipeline_run": {
+            const args = types.GetPipelineRunSchema.parse(request.params.arguments);
+            const pipelineRun = await pipeline.getPipelineRunFunc(args.organizationId, args.pipelineId, args.pipelineRunId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(pipelineRun, null, 2) }],
+            };
+        }
+        case "list_pipeline_runs": {
+            const args = types.ListPipelineRunsSchema.parse(request.params.arguments);
+            const pipelineRuns = await pipeline.listPipelineRunsFunc(args.organizationId, args.pipelineId, {
+                perPage: args.perPage,
+                page: args.page,
+                startTime: args.startTime,
+                endTime: args.endTime,
+                status: args.status,
+                triggerMode: args.triggerMode
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(pipelineRuns, null, 2) }],
+            };
+        }
+        case "list_pipeline_jobs_by_category": {
+            const args = types.ListPipelineJobsByCategorySchema.parse(request.params.arguments);
+            const jobs = await pipelineJob.listPipelineJobsByCategoryFunc(args.organizationId, args.pipelineId, args.category);
+            return {
+                content: [{ type: "text", text: JSON.stringify(jobs, null, 2) }],
+            };
+        }
+        case "list_pipeline_job_historys": {
+            const args = types.ListPipelineJobHistorysSchema.parse(request.params.arguments);
+            const jobHistorys = await pipelineJob.listPipelineJobHistorysFunc(args.organizationId, args.pipelineId, args.category, args.identifier, args.page, args.perPage);
+            return {
+                content: [{ type: "text", text: JSON.stringify(jobHistorys, null, 2) }],
+            };
+        }
+        case "execute_pipeline_job_run": {
+            const args = types.ExecutePipelineJobRunSchema.parse(request.params.arguments);
+            const result = await pipelineJob.executePipelineJobRunFunc(args.organizationId, args.pipelineId, args.pipelineRunId, args.jobId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        case "get_pipeline_job_run_log": {
+            const args = types.GetPipelineJobRunLogSchema.parse(request.params.arguments);
+            const log = await pipelineJob.getPipelineJobRunLogFunc(args.organizationId, args.pipelineId, args.pipelineRunId, args.jobId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(log, null, 2) }],
+            };
+        }
+        case "update_pipeline": {
+            const args = types.UpdatePipelineSchema.parse(request.params.arguments);
+            const result = await pipeline.updatePipelineFunc(args.organizationId, args.pipelineId, args.name, args.content);
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: result }) }]
+            };
+        }
+        default:
+            return null;
+    }
+};

package/dist/tool-handlers/project-management.js

@@ -0,0 +1,152 @@
+import * as project from '../operations/projex/project.js';
+import * as workitem from '../operations/projex/workitem.js';
+import * as sprint from '../operations/projex/sprint.js';
+import * as types from '../common/types.js';
+import { z } from 'zod';
+export const handleProjectManagementTools = async (request) => {
+    switch (request.params.name) {
+        // Project Operations
+        case "get_project": {
+            const args = types.GetProjectSchema.parse(request.params.arguments);
+            const projectInfo = await project.getProjectFunc(args.organizationId, args.id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(projectInfo, null, 2) }],
+            };
+        }
+        case "search_projects": {
+            const args = types.SearchProjectsSchema.parse(request.params.arguments);
+            const projects = await project.searchProjectsFunc(args.organizationId, args.name ?? undefined, args.status ?? undefined, args.createdAfter ?? undefined, args.createdBefore ?? undefined, args.creator ?? undefined, args.adminUserId ?? undefined, args.logicalStatus ?? undefined, args.advancedConditions ?? undefined, args.extraConditions ?? undefined, args.orderBy, args.page, args.perPage, args.sort, args.scenarioFilter ?? undefined, args.userId ?? undefined);
+            return {
+                content: [{ type: "text", text: JSON.stringify(projects, null, 2) }],
+            };
+        }
+        // Sprint Operations
+        case "get_sprint": {
+            const args = types.GetSprintSchema.parse(request.params.arguments);
+            const sprintInfo = await sprint.getSprintFunc(args.organizationId, args.projectId, args.id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(sprintInfo, null, 2) }],
+            };
+        }
+        case "list_sprints": {
+            const args = types.ListSprintsSchema.parse(request.params.arguments);
+            const sprints = await sprint.listSprintsFunc(args.organizationId, args.id, args.status, args.page, args.perPage);
+            return {
+                content: [{ type: "text", text: JSON.stringify(sprints, null, 2) }],
+            };
+        }
+        case "create_sprint": {
+            const args = types.CreateSprintSchema.parse(request.params.arguments);
+            const sprintResult = await sprint.createSprintFunc(args.organizationId, args.projectId, args.name, args.owners, args.startDate, args.endDate, args.description, args.capacityHours);
+            return {
+                content: [{ type: "text", text: JSON.stringify(sprintResult, null, 2) }],
+            };
+        }
+        case "update_sprint": {
+            const args = types.UpdateSprintSchema.parse(request.params.arguments);
+            await sprint.updateSprintFunc(args.organizationId, args.projectId, args.id, args.name, args.owners, args.startDate, args.endDate, args.description, args.capacityHours);
+            return {
+                content: [{ type: "text", text: "Sprint updated successfully" }],
+            };
+        }
+        // Work Item Operations
+        case "get_work_item": {
+            const args = types.GetWorkItemSchema.parse(request.params.arguments);
+            const workItemInfo = await workitem.getWorkItemFunc(args.organizationId, args.workItemId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(workItemInfo, null, 2) }],
+            };
+        }
+        case "create_work_item": {
+            const args = types.CreateWorkItemSchema.parse(request.params.arguments);
+            const workItemInfo = await workitem.createWorkItemFunc(args.organizationId, args.assignedTo, args.spaceId, args.subject, args.workitemTypeId, args.customFieldValues, args.description, args.labels, args.parentId, args.participants, args.sprint, args.trackers, args.verifier, args.versions);
+            return {
+                content: [{ type: "text", text: JSON.stringify(workItemInfo, null, 2) }],
+            };
+        }
+        case "search_workitems": {
+            const args = types.SearchWorkitemsSchema.parse(request.params.arguments);
+            const workItems = await workitem.searchWorkitemsFunc(args.organizationId, args.category, args.spaceId, args.subject ?? undefined, args.status ?? undefined, args.createdAfter ?? undefined, args.createdBefore ?? undefined, args.updatedAfter ?? undefined, args.updatedBefore ?? undefined, args.creator ?? undefined, args.assignedTo ?? undefined, args.advancedConditions ?? undefined, args.orderBy ?? "gmtCreate", args.includeDetails ?? false);
+            return {
+                content: [{ type: "text", text: JSON.stringify(workItems, null, 2) }],
+            };
+        }
+        case "get_work_item_types": {
+            const args = z.object({
+                organizationId: z.string().describe("organization id"),
+                id: z.string().describe("project id or space id"),
+                category: z.string().describe("Req、Task、Bug etc.")
+            }).parse(request.params.arguments);
+            const workItemTypes = await workitem.getWorkItemTypesFunc(args.organizationId, args.id, args.category);
+            return {
+                content: [{ type: "text", text: JSON.stringify(workItemTypes, null, 2) }],
+            };
+        }
+        case "update_work_item": {
+            const args = types.UpdateWorkItemSchema.parse(request.params.arguments);
+            await workitem.updateWorkItemFunc(args.organizationId, args.workItemId, args.updateWorkItemFields);
+            return {
+                content: [{ type: "text", text: "" }],
+            };
+        }
+        // Work Item Type Operations
+        case "list_all_work_item_types": {
+            const args = types.ListAllWorkItemTypesSchema.parse(request.params.arguments);
+            const workItemTypes = await workitem.listAllWorkItemTypesFunc(args.organizationId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(workItemTypes, null, 2) }],
+            };
+        }
+        case "list_work_item_types": {
+            const args = types.ListWorkItemTypesSchema.parse(request.params.arguments);
+            const workItemTypes = await workitem.listWorkItemTypesFunc(args.organizationId, args.projectId, args.category);
+            return {
+                content: [{ type: "text", text: JSON.stringify(workItemTypes, null, 2) }],
+            };
+        }
+        case "get_work_item_type": {
+            const args = types.GetWorkItemTypeSchema.parse(request.params.arguments);
+            const workItemType = await workitem.getWorkItemTypeFunc(args.organizationId, args.id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(workItemType, null, 2) }],
+            };
+        }
+        case "list_work_item_relation_work_item_types": {
+            const args = types.ListWorkItemRelationWorkItemTypesSchema.parse(request.params.arguments);
+            const workItemTypes = await workitem.listWorkItemRelationWorkItemTypesFunc(args.organizationId, args.workItemTypeId, args.relationType);
+            return {
+                content: [{ type: "text", text: JSON.stringify(workItemTypes, null, 2) }],
+            };
+        }
+        case "get_work_item_type_field_config": {
+            const args = types.GetWorkItemTypeFieldConfigSchema.parse(request.params.arguments);
+            const fieldConfig = await workitem.getWorkItemTypeFieldConfigFunc(args.organizationId, args.projectId, args.workItemTypeId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(fieldConfig, null, 2) }],
+            };
+        }
+        case "get_work_item_workflow": {
+            const args = types.GetWorkItemWorkflowSchema.parse(request.params.arguments);
+            const workflow = await workitem.getWorkItemWorkflowFunc(args.organizationId, args.projectId, args.workItemTypeId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(workflow, null, 2) }],
+            };
+        }
+        case "list_work_item_comments": {
+            const args = types.ListWorkItemCommentsSchema.parse(request.params.arguments);
+            const comments = await workitem.listWorkItemCommentsFunc(args.organizationId, args.workItemId, args.page, args.perPage);
+            return {
+                content: [{ type: "text", text: JSON.stringify(comments, null, 2) }],
+            };
+        }
+        case "create_work_item_comment": {
+            const args = types.CreateWorkItemCommentSchema.parse(request.params.arguments);
+            const comment = await workitem.createWorkItemCommentFunc(args.organizationId, args.workItemId, args.content);
+            return {
+                content: [{ type: "text", text: JSON.stringify(comment, null, 2) }],
+            };
+        }
+        default:
+            return null;
+    }
+};

package/dist/tool-handlers/service-connections.js

@@ -0,0 +1,16 @@
+import * as serviceConnection from '../operations/flow/serviceConnection.js';
+import * as types from '../common/types.js';
+export const handleServiceConnectionTools = async (request) => {
+    switch (request.params.name) {
+        // Service Connection Operations
+        case "list_service_connections": {
+            const args = types.ListServiceConnectionsSchema.parse(request.params.arguments);
+            const serviceConnections = await serviceConnection.listServiceConnectionsFunc(args.organizationId, args.serviceConnectionType);
+            return {
+                content: [{ type: "text", text: JSON.stringify(serviceConnections, null, 2) }],
+            };
+        }
+        default:
+            return null;
+    }
+};

package/dist/tool-registry/appstack-change-orders.js

@@ -0,0 +1,40 @@
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { CreateChangeOrderRequestSchema, ListChangeOrderVersionsRequestSchema, GetChangeOrderRequestSchema, ListChangeOrderJobLogsRequestSchema, FindTaskOperationLogRequestSchema, ExecuteJobActionRequestSchema, ListChangeOrdersByOriginRequestSchema } from '../operations/appstack/changeOrders.js';
+// Export all appstack change order tools
+export const getAppStackChangeOrderTools = () => [
+    {
+        name: 'create_change_order',
+        description: '[application delivery] 创建部署单',
+        inputSchema: zodToJsonSchema(CreateChangeOrderRequestSchema),
+    },
+    {
+        name: 'list_change_order_versions',
+        description: '[application delivery] 查看部署单版本列表',
+        inputSchema: zodToJsonSchema(ListChangeOrderVersionsRequestSchema),
+    },
+    {
+        name: 'get_change_order',
+        description: '[application delivery] 读取部署单使用的物料和工单状态',
+        inputSchema: zodToJsonSchema(GetChangeOrderRequestSchema),
+    },
+    {
+        name: 'list_change_order_job_logs',
+        description: '[application delivery] 查询环境部署单日志',
+        inputSchema: zodToJsonSchema(ListChangeOrderJobLogsRequestSchema),
+    },
+    {
+        name: 'find_task_operation_log',
+        description: '[application delivery] 查询部署任务执行日志，其中通常包含下游部署引擎的调度细节信息',
+        inputSchema: zodToJsonSchema(FindTaskOperationLogRequestSchema),
+    },
+    {
+        name: 'execute_job_action',
+        description: '[application delivery] 操作环境部署单',
+        inputSchema: zodToJsonSchema(ExecuteJobActionRequestSchema),
+    },
+    {
+        name: 'list_change_orders_by_origin',
+        description: '[application delivery] 根据创建来源查询部署单',
+        inputSchema: zodToJsonSchema(ListChangeOrdersByOriginRequestSchema),
+    }
+];

package/dist/tool-registry/appstack-change-requests.js

@@ -0,0 +1,35 @@
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { CreateChangeRequestRequestSchema, GetChangeRequestAuditItemsRequestSchema, ListChangeRequestExecutionsRequestSchema, ListChangeRequestWorkItemsRequestSchema, CancelChangeRequestRequestSchema, CloseChangeRequestRequestSchema } from '../operations/appstack/changeRequests.js';
+// Export all appstack change requests tools
+export const getAppStackChangeRequestTools = () => [
+    {
+        name: 'create_appstack_change_request',
+        description: '[application delivery] Create a change request',
+        inputSchema: zodToJsonSchema(CreateChangeRequestRequestSchema),
+    },
+    {
+        name: 'get_change_request_audit_items',
+        description: '[application delivery] Get audit items for a change request',
+        inputSchema: zodToJsonSchema(GetChangeRequestAuditItemsRequestSchema),
+    },
+    {
+        name: 'list_change_request_executions',
+        description: '[application delivery] List change request executions',
+        inputSchema: zodToJsonSchema(ListChangeRequestExecutionsRequestSchema),
+    },
+    {
+        name: 'list_change_request_work_items',
+        description: '[application delivery] List work items for a change request',
+        inputSchema: zodToJsonSchema(ListChangeRequestWorkItemsRequestSchema),
+    },
+    {
+        name: 'cancel_change_request',
+        description: '[application delivery] Cancel a change request',
+        inputSchema: zodToJsonSchema(CancelChangeRequestRequestSchema),
+    },
+    {
+        name: 'close_change_request',
+        description: '[application delivery] Close a change request',
+        inputSchema: zodToJsonSchema(CloseChangeRequestRequestSchema),
+    }
+];