devops-mcp-server-extension 1.0.0

package/dist/tool-handlers/index.js

@@ -0,0 +1,119 @@
+import { handleCodeManagementTools } from './code-management.js';
+import { handleOrganizationTools } from './organization.js';
+import { handleProjectManagementTools } from './project-management.js';
+import { handlePipelineTools } from './pipeline.js';
+import { handlePackageManagementTools } from './packages.js';
+import { handleServiceConnectionTools } from './service-connections.js';
+import { handleAppStackTools } from './appstack.js';
+import { handleAppStackTagTools } from './appstack-tags.js';
+import { handleAppStackTemplateTools } from './appstack-templates.js';
+import { handleAppStackGlobalVarTools } from './appstack-global-vars.js';
+import { handleAppStackVariableGroupTools } from './appstack-variable-groups.js';
+import { handleAppStackOrchestrationTools } from './appstack-orchestrations.js';
+import { handleAppStackChangeRequestTools } from './appstack-change-requests.js';
+import { handleAppStackDeploymentResourceTools } from './appstack-deployment-resources.js';
+import { handleAppStackChangeOrderTools } from './appstack-change-orders.js';
+import { handleAppStackAppReleaseWorkflowTools } from './appstack-app-release-workflows.js';
+import { handleEffortTools } from './effort.js';
+import { handleResourceMemberTools } from './resourceMember.js';
+import { handleVMDeployOrderTools } from './vmDeployOrder.js';
+import { handleCommitTools } from './commit.js';
+import { handleBaseTools } from './base.js';
+import { handleTestManagementTools } from './test-management.js';
+import { Toolset } from '../common/toolsets.js';
+// 定义处理函数映射
+const HANDLER_MAP = {
+    [Toolset.BASE]: handleBaseTools,
+    [Toolset.CODE_MANAGEMENT]: handleCodeManagementTools,
+    [Toolset.ORGANIZATION_MANAGEMENT]: handleOrganizationTools,
+    [Toolset.PROJECT_MANAGEMENT]: handleProjectManagementTools,
+    [Toolset.PIPELINE_MANAGEMENT]: handlePipelineTools,
+    [Toolset.PACKAGES_MANAGEMENT]: handlePackageManagementTools,
+    [Toolset.APPLICATION_DELIVERY]: handleAppStackTools, // 注意：这里只使用了主处理函数，其他AppStack处理函数在内部处理
+    [Toolset.TEST_MANAGEMENT]: handleTestManagementTools,
+};
+// 保持向后兼容的接口
+export const handleToolRequest = async (request) => {
+    // Try each handler in sequence until one returns a result
+    const handlers = [
+        handleBaseTools,
+        handleCodeManagementTools,
+        handleOrganizationTools,
+        handleProjectManagementTools,
+        handlePipelineTools,
+        handlePackageManagementTools,
+        handleServiceConnectionTools,
+        handleAppStackTools,
+        handleAppStackTagTools,
+        handleAppStackTemplateTools,
+        handleAppStackGlobalVarTools,
+        handleAppStackVariableGroupTools,
+        handleAppStackOrchestrationTools,
+        handleAppStackChangeRequestTools,
+        handleAppStackDeploymentResourceTools,
+        handleAppStackChangeOrderTools,
+        handleAppStackAppReleaseWorkflowTools,
+        handleEffortTools,
+        handleResourceMemberTools,
+        handleVMDeployOrderTools,
+        handleCommitTools,
+        handleTestManagementTools
+    ];
+    for (const handler of handlers) {
+        const result = await handler(request);
+        if (result !== null) {
+            return result;
+        }
+    }
+    // If no handler matched, throw an error
+    throw new Error(`Unknown tool: ${request.params.name}`);
+};
+// 新增按工具集处理工具请求的接口
+export const handleToolRequestByToolset = async (request, toolsetName) => {
+    const handler = HANDLER_MAP[toolsetName];
+    if (!handler) {
+        throw new Error(`Unknown toolset: ${toolsetName}`);
+    }
+    return await handler(request);
+};
+// 新增处理启用工具集的接口
+export const handleEnabledToolRequest = async (request, enabledToolsets) => {
+    // 总是先尝试处理基础工具集
+    try {
+        const baseResult = await handleToolRequestByToolset(request, Toolset.BASE);
+        if (baseResult !== null) {
+            return baseResult;
+        }
+    }
+    catch (error) {
+        // 如果工具不在基础工具集中，继续尝试其他工具集
+        // 如果是其他错误，重新抛出
+        if (!(error instanceof Error && error.message.includes("Unknown tool"))) {
+            throw error;
+        }
+    }
+    // 如果没有指定启用的工具集，则处理所有工具集（除了基础工具集，因为已经处理过了）
+    const toolsets = enabledToolsets.length > 0 ? enabledToolsets : Object.values(Toolset).filter(t => t !== Toolset.BASE);
+    // 按顺序尝试每个启用的工具集
+    for (const toolset of toolsets) {
+        // 跳过基础工具集，因为我们已经处理过了
+        if (toolset === Toolset.BASE) {
+            continue;
+        }
+        try {
+            const result = await handleToolRequestByToolset(request, toolset);
+            if (result !== null) {
+                return result;
+            }
+        }
+        catch (error) {
+            // 如果工具不在当前工具集中，继续尝试下一个工具集
+            // 如果是其他错误，重新抛出
+            if (!(error instanceof Error && error.message.includes("Unknown tool"))) {
+                throw error;
+            }
+        }
+    }
+    // 如果没有处理函数匹配，抛出错误
+    throw new Error(`Unknown tool: ${request.params.name}`);
+};

package/dist/tool-handlers/organization.js

@@ -0,0 +1,72 @@
+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 "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,289 @@
+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);
+            // 调试日志：查看AI传递的原始参数
+            console.log('[DEBUG] Handler - Raw request.params.arguments:', JSON.stringify(request.params.arguments, null, 2));
+            console.log('[DEBUG] Handler - Parsed args:', JSON.stringify({
+                organizationId: args.organizationId,
+                pipelineId: args.pipelineId,
+                params: args.params,
+                branch: args.branch,
+                tag: args.tag,
+                branches: args.branches,
+                repositories: args.repositories
+            }, null, 2));
+            const runId = await pipeline.createPipelineRunFunc(args.organizationId, args.pipelineId, {
+                params: args.params,
+                branch: args.branch,
+                tag: args.tag,
+                branches: args.branches,
+                branchMode: args.branchMode,
+                repositories: args.repositories,
+                environmentVariables: args.environmentVariables,
+                pipelineArtifacts: args.pipelineArtifacts,
+                acrArtifacts: args.acrArtifacts,
+                packagesArtifacts: args.packagesArtifacts,
+                releaseBranch: args.releaseBranch,
+                createReleaseBranch: args.createReleaseBranch,
+                comment: args.comment,
+                description: args.description
+            });
+            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;
+    }
+};