@taole/deploy-helper 1.0.2 → 1.0.4

package/modules/alibabacloud-devops-mcp-server/dist/operations/flow/pipeline.js

@@ -1,514 +0,0 @@
-import * as utils from "../../common/utils.js";
-import { PipelineDetailSchema, PipelineListItemSchema, PipelineRunSchema, PipelineRunListItemSchema } from "../../common/types.js";
-import { generateModularPipeline } from "../../common/modularTemplates.js";
-import { listServiceConnectionsFunc } from "./serviceConnection.js";
-/**
- * 获取流水线详情
- * @param organizationId 组织ID
- * @param pipelineId 流水线ID
- * @returns 流水线详情
- */
-export async function getPipelineFunc(organizationId, pipelineId) {
-    const url = `/oapi/v1/flow/organizations/${organizationId}/pipelines/${pipelineId}`;
-    const response = await utils.yunxiaoRequest(url, {
-        method: "GET",
-    });
-    return PipelineDetailSchema.parse(response);
-}
-/**
- * 获取流水线列表
- * @param organizationId 组织ID
- * @param options 查询选项
- * @returns 流水线列表
- */
-export async function listPipelinesFunc(organizationId, options) {
-    const baseUrl = `/oapi/v1/flow/organizations/${organizationId}/pipelines`;
-    // 构建查询参数
-    const queryParams = {};
-    // 处理时间戳参数
-    // 如果传入的是日期字符串或Date对象，自动转换为毫秒时间戳
-    if (options?.createStartTime !== undefined) {
-        queryParams.createStartTime = utils.convertToTimestamp(options.createStartTime);
-    }
-    if (options?.createEndTime !== undefined) {
-        queryParams.createEndTime = utils.convertToTimestamp(options.createEndTime);
-    }
-    if (options?.executeStartTime !== undefined) {
-        queryParams.executeStartTime = utils.convertToTimestamp(options.executeStartTime);
-    }
-    if (options?.executeEndTime !== undefined) {
-        queryParams.executeEndTime = utils.convertToTimestamp(options.executeEndTime);
-    }
-    if (options?.pipelineName !== undefined) {
-        queryParams.pipelineName = options.pipelineName;
-    }
-    if (options?.statusList !== undefined) {
-        queryParams.statusList = options.statusList;
-    }
-    if (options?.perPage !== undefined) {
-        queryParams.perPage = options.perPage;
-    }
-    if (options?.page !== undefined) {
-        queryParams.page = options.page;
-    }
-    const url = utils.buildUrl(baseUrl, queryParams);
-    let response = await utils.yunxiaoRequest(url, {
-        method: "GET",
-    });
-    const pagination = {
-        nextPage: null,
-        page: 1,
-        perPage: 10,
-        prevPage: null,
-        total: 0,
-        totalPages: 0
-    };
-    let items = [];
-    if (Array.isArray(response)) {
-        response = response.map((item) => ({
-            ...item,
-            id: item.id || item.pipelineId,
-            name: item.name || item.pipelineName,
-            creatorAccountId: item.creatorAccountId || item.createAccountId,
-            createTime: item.createTime || item.createTime,
-        }))
-        items = response.map(item => PipelineListItemSchema.parse(item));
-    }
-    return {
-        items,
-        pagination
-    };
-}
-/**
- * 智能查询流水线列表，能够解析自然语言中的时间表达
- * @param organizationId 组织ID
- * @param timeReference 自然语言时间引用，如"今天"、"本周"、"上个月"
- * @param options 其他查询选项
- * @returns 流水线列表
- */
-export async function smartListPipelinesFunc(organizationId, timeReference, options) {
-    // 解析时间引用获取开始和结束时间戳
-    const { startTime, endTime } = utils.parseDateReference(timeReference);
-    // 合并选项
-    const fullOptions = {
-        ...options,
-        executeStartTime: startTime,
-        executeEndTime: endTime
-    };
-    return listPipelinesFunc(organizationId, fullOptions);
-}
-/**
- * 运行流水线
- * @param organizationId 组织ID
- * @param pipelineId 流水线ID
- * @param options 运行选项，可以是直接的JSON字符串或者自然语言描述的选项
- * @returns 流水线运行ID
- */
-export async function createPipelineRunFunc(organizationId, pipelineId, options) {
-    const url = `/oapi/v1/flow/organizations/${organizationId}/pipelines/${pipelineId}/runs`;
-    // 如果用户已经提供了格式化的params，直接使用
-    if (options?.params) {
-        const body = {
-            params: options.params
-        };
-        const response = await utils.yunxiaoRequest(url, {
-            method: "POST",
-            body: body,
-        });
-        return Number(response);
-    }
-    // 否则，基于用户提供的自然语言参数构建params
-    const paramsObject = {};
-    // 处理分支模式相关参数
-    if (options?.branchMode && options?.branches && options.branches.length > 0) {
-        paramsObject.branchModeBranchs = options.branches;
-    }
-    // 处理Release分支相关参数
-    if (options?.createReleaseBranch !== undefined) {
-        paramsObject.needCreateBranch = options.createReleaseBranch;
-    }
-    if (options?.releaseBranch) {
-        paramsObject.releaseBranch = options.releaseBranch;
-    }
-    // 处理环境变量
-    if (options?.environmentVariables && Object.keys(options.environmentVariables).length > 0) {
-        paramsObject.envs = options.environmentVariables;
-    }
-    // 处理特定仓库配置
-    if (options?.repositories && options.repositories.length > 0) {
-        // 初始化runningBranchs和runningTags对象
-        const runningBranchs = {};
-        const runningTags = {};
-        // 填充分支和标签信息
-        options.repositories.forEach(repo => {
-            if (repo.branch) {
-                runningBranchs[repo.url] = repo.branch;
-            }
-            if (repo.tag) {
-                runningTags[repo.url] = repo.tag;
-            }
-        });
-        // 只有在有内容时才添加到params对象
-        if (Object.keys(runningBranchs).length > 0) {
-            paramsObject.runningBranchs = runningBranchs;
-        }
-        if (Object.keys(runningTags).length > 0) {
-            paramsObject.runningTags = runningTags;
-        }
-    }
-    // 如果有自然语言描述，尝试解析它
-    if (options?.description) {
-        // 此处可以添加更复杂的自然语言处理逻辑
-        // 当前实现是简单的关键词匹配
-        const description = options.description.toLowerCase();
-        // 检测分支模式
-        if ((description.includes('branch mode') || description.includes('分支模式')) &&
-            !paramsObject.branchModeBranchs &&
-            options?.branches?.length) {
-            paramsObject.branchModeBranchs = options.branches;
-        }
-        // 检测是否需要创建release分支
-        if ((description.includes('create release') || description.includes('创建release')) &&
-            paramsObject.needCreateBranch === undefined) {
-            paramsObject.needCreateBranch = true;
-        }
-        // 如果提到特定release分支但没有指定
-        if ((description.includes('release branch') || description.includes('release分支')) &&
-            !paramsObject.releaseBranch &&
-            options?.branches?.length) {
-            // 假设第一个分支就是release分支
-            paramsObject.releaseBranch = options.branches[0];
-        }
-    }
-    const body = {};
-    if (Object.keys(paramsObject).length > 0) {
-        body.params = JSON.stringify(paramsObject);
-    }
-    const response = await utils.yunxiaoRequest(url, {
-        method: "POST",
-        body: body,
-    });
-    return Number(response);
-}
-/**
- * 获取最近一次流水线运行信息
- * @param organizationId 组织ID
- * @param pipelineId 流水线ID
- * @returns 最近一次流水线运行信息
- */
-export async function getLatestPipelineRunFunc(organizationId, pipelineId) {
-    const url = `/oapi/v1/flow/organizations/${organizationId}/pipelines/${pipelineId}/runs/latestPipelineRun`;
-    const response = await utils.yunxiaoRequest(url, {
-        method: "GET",
-    });
-    return PipelineRunSchema.parse(response);
-}
-/**
- * 获取特定流水线运行实例
- * @param organizationId 组织ID
- * @param pipelineId 流水线ID
- * @param pipelineRunId 流水线运行ID
- * @returns 流水线运行实例信息
- */
-export async function getPipelineRunFunc(organizationId, pipelineId, pipelineRunId) {
-    const url = `/oapi/v1/flow/organizations/${organizationId}/pipelines/${pipelineId}/runs/${pipelineRunId}`;
-    const response = await utils.yunxiaoRequest(url, {
-        method: "GET",
-    });
-    return PipelineRunSchema.parse(response);
-}
-/**
- * 获取流水线运行实例列表
- * @param organizationId 组织ID
- * @param pipelineId 流水线ID
- * @param options 查询选项
- * @returns 流水线运行实例列表和分页信息
- */
-export async function listPipelineRunsFunc(organizationId, pipelineId, options) {
-    const baseUrl = `/oapi/v1/flow/organizations/${organizationId}/pipelines/${pipelineId}/runs`;
-    // 构建查询参数
-    const queryParams = {};
-    if (options?.perPage !== undefined) {
-        queryParams.perPage = options.perPage;
-    }
-    if (options?.page !== undefined) {
-        queryParams.page = options.page;
-    }
-    if (options?.startTime !== undefined) {
-        queryParams.startTime = utils.convertToTimestamp(options.startTime);
-    }
-    if (options?.endTime !== undefined) {
-        queryParams.endTme = utils.convertToTimestamp(options.endTime);
-    }
-    if (options?.status !== undefined) {
-        queryParams.status = options.status;
-    }
-    if (options?.triggerMode !== undefined) {
-        queryParams.triggerMode = options.triggerMode;
-    }
-    const url = utils.buildUrl(baseUrl, queryParams);
-    const response = await utils.yunxiaoRequest(url, {
-        method: "GET",
-    });
-    const pagination = {
-        nextPage: null,
-        page: options?.page ?? 1,
-        perPage: options?.perPage ?? 10,
-        prevPage: null,
-        total: 0,
-        totalPages: 0
-    };
-    let items = [];
-    if (Array.isArray(response)) {
-        items = response.map(item => PipelineRunListItemSchema.parse(item));
-    }
-    return {
-        items,
-        pagination
-    };
-}
-/**
- * 创建流水线
- * @param organizationId 组织ID
- * @param name 流水线名称
- * @param content 流水线YAML描述
- * @returns 流水线ID
- */
-export async function createPipelineFunc(organizationId, name, content) {
-    const url = `/oapi/v1/flow/organizations/${organizationId}/pipelines`;
-    const body = {
-        name: name,
-        content: content
-    };
-    const response = await utils.yunxiaoRequest(url, {
-        method: "POST",
-        body: body,
-    });
-    return Number(response);
-}
-/**
- * 基于结构化参数生成流水线YAML（不创建流水线）
- * @param options 结构化的流水线配置选项
- * @returns 生成的YAML字符串
- */
-export async function generatePipelineYamlFunc(options) {
-    // 自动从repoUrl解析serviceName（如果用户没有明确指定）
-    let derivedServiceName = options.serviceName;
-    if (!derivedServiceName && options.repoUrl) {
-        // 从Git URL中提取项目名称
-        // 支持格式: git@codeup.aliyun.com:org/repo.git 或 https://codeup.aliyun.com/org/repo.git
-        const repoUrlMatch = options.repoUrl.match(/[\/:]([^\/]+)\.git$/);
-        if (repoUrlMatch) {
-            derivedServiceName = repoUrlMatch[1];
-        }
-    }
-    // 准备变量，确保版本号有双引号
-    const variables = {
-        // 基础配置
-        ...(options.repoUrl && { repoUrl: options.repoUrl }),
-        ...(options.branch && { branch: options.branch }),
-        ...(derivedServiceName && { serviceName: derivedServiceName }),
-        ...(options.serviceConnectionId && { serviceConnectionId: options.serviceConnectionId }),
-        ...(options.packagesServiceConnection && { packagesServiceConnection: options.packagesServiceConnection }),
-        ...(options.machineGroupId && { machineGroupId: options.machineGroupId }),
-        ...(options.namespace && { namespace: options.namespace }),
-        ...(options.dockerImage && { dockerImage: options.dockerImage }),
-        // 版本相关（确保双引号）
-        ...(options.jdkVersion && { jdkVersion: `"${options.jdkVersion}"` }),
-        ...(options.mavenVersion && { mavenVersion: `"${options.mavenVersion}"` }),
-        ...(options.nodeVersion && { nodeVersion: `"${options.nodeVersion}"` }),
-        ...(options.pythonVersion && { pythonVersion: `"${options.pythonVersion}"` }),
-        ...(options.goVersion && { goVersion: `"${options.goVersion}"` }),
-        ...(options.kubectlVersion && { kubectlVersion: `"${options.kubectlVersion}"` }),
-        // 构建物上传相关
-        ...(options.uploadType && { uploadType: options.uploadType }),
-        ...(options.artifactName && { artifactName: options.artifactName }),
-        ...(options.artifactVersion && { artifactVersion: options.artifactVersion }),
-        ...(options.packagesRepoId && { packagesRepoId: options.packagesRepoId }),
-        ...(options.includePathInArtifact !== undefined && { includePathInArtifact: options.includePathInArtifact }),
-        // 部署相关
-        ...(options.executeUser && { executeUser: options.executeUser }),
-        ...(options.artifactDownloadPath && { artifactDownloadPath: options.artifactDownloadPath }),
-        ...(options.kubernetesClusterId && { kubernetesClusterId: options.kubernetesClusterId }),
-        ...(options.yamlPath && { yamlPath: options.yamlPath }),
-        // 命令
-        ...(options.buildCommand && { buildCommand: options.buildCommand }),
-        ...(options.testCommand && { testCommand: options.testCommand }),
-        ...(options.deployCommand && { deployCommand: options.deployCommand }),
-    };
-    // 转换为模块化流水线选项
-    const deployTargets = options.deployTarget ? [options.deployTarget] : [];
-    // 使用模块化架构生成YAML
-    return generateModularPipeline({
-        keywords: [options.buildLanguage, options.buildTool],
-        buildLanguages: [options.buildLanguage],
-        buildTools: [options.buildTool],
-        deployTargets: deployTargets,
-        uploadType: options.uploadType || 'packages',
-        variables: variables
-    });
-}
-/**
- * 基于结构化参数创建流水线
- * @param organizationId 组织ID
- * @param options 结构化的流水线配置选项
- * @returns 创建结果，包含流水线ID和生成的YAML
- */
-export async function createPipelineWithOptionsFunc(organizationId, options) {
-    // 获取默认服务连接ID（如果用户没有明确指定）
-    let defaultServiceConnectionId = null;
-    const hasServiceConnectionId = options.serviceConnectionId;
-    if (!hasServiceConnectionId) {
-        defaultServiceConnectionId = await getDefaultServiceConnectionId(organizationId);
-    }
-    // 获取默认Packages服务连接ID（如果用户没有明确指定且需要packages上传）
-    let defaultPackagesServiceConnectionId = null;
-    const hasPackagesServiceConnectionId = options.packagesServiceConnection;
-    const needsPackagesUpload = !options.uploadType || options.uploadType === 'packages';
-    if (!hasPackagesServiceConnectionId && needsPackagesUpload) {
-        defaultPackagesServiceConnectionId = await getDefaultPackagesServiceConnectionId(organizationId);
-    }
-    // 获取默认主机组ID（如果用户没有明确指定且需要VM部署）
-    let defaultMachineGroupId = null;
-    const hasMachineGroupId = options.machineGroupId;
-    const needsVMDeploy = options.deployTarget === 'vm';
-    if (!hasMachineGroupId && needsVMDeploy) {
-        defaultMachineGroupId = await getDefaultHostGroupId(organizationId);
-    }
-    // 自动从repoUrl解析serviceName（如果用户没有明确指定）
-    let derivedServiceName = options.serviceName;
-    if (!derivedServiceName && options.repoUrl) {
-        // 从Git URL中提取项目名称
-        // 支持格式: git@codeup.aliyun.com:org/repo.git 或 https://codeup.aliyun.com/org/repo.git
-        const repoUrlMatch = options.repoUrl.match(/[\/:]([^\/]+)\.git$/);
-        if (repoUrlMatch) {
-            derivedServiceName = repoUrlMatch[1];
-        }
-    }
-    // 准备模块化流水线生成的变量
-    const finalVariables = {
-        // 基础配置（直接使用用户提供的值）
-        ...(options.repoUrl && { repoUrl: options.repoUrl }),
-        ...(options.branch && { branch: options.branch }),
-        ...(derivedServiceName && { serviceName: derivedServiceName }),
-        // 使用获取到的默认服务连接ID
-        ...(defaultServiceConnectionId && !hasServiceConnectionId && { serviceConnectionId: defaultServiceConnectionId }),
-        // 使用获取到的默认Packages服务连接ID
-        ...(defaultPackagesServiceConnectionId && !hasPackagesServiceConnectionId && { packagesServiceConnection: defaultPackagesServiceConnectionId }),
-        // 使用获取到的默认主机组ID
-        ...(defaultMachineGroupId && !hasMachineGroupId && { machineGroupId: defaultMachineGroupId }),
-        // 用户明确指定的值优先级最高
-        ...(options.serviceConnectionId && { serviceConnectionId: options.serviceConnectionId }),
-        ...(options.packagesServiceConnection && { packagesServiceConnection: options.packagesServiceConnection }),
-        ...(options.machineGroupId && { machineGroupId: options.machineGroupId }),
-        ...(options.namespace && { namespace: options.namespace }),
-        ...(options.dockerImage && { dockerImage: options.dockerImage }),
-        // 版本相关（确保双引号）
-        ...(options.jdkVersion && { jdkVersion: `"${options.jdkVersion}"` }),
-        ...(options.mavenVersion && { mavenVersion: `"${options.mavenVersion}"` }),
-        ...(options.nodeVersion && { nodeVersion: `"${options.nodeVersion}"` }),
-        ...(options.pythonVersion && { pythonVersion: `"${options.pythonVersion}"` }),
-        ...(options.goVersion && { goVersion: `"${options.goVersion}"` }),
-        ...(options.kubectlVersion && { kubectlVersion: `"${options.kubectlVersion}"` }),
-        // 构建物上传相关
-        ...(options.uploadType && { uploadType: options.uploadType }),
-        ...(options.artifactName && { artifactName: options.artifactName }),
-        ...(options.artifactVersion && { artifactVersion: options.artifactVersion }),
-        ...(options.packagesRepoId && { packagesRepoId: options.packagesRepoId }),
-        ...(options.includePathInArtifact !== undefined && { includePathInArtifact: options.includePathInArtifact }),
-        // 部署相关
-        ...(options.executeUser && { executeUser: options.executeUser }),
-        ...(options.artifactDownloadPath && { artifactDownloadPath: options.artifactDownloadPath }),
-        ...(options.kubernetesClusterId && { kubernetesClusterId: options.kubernetesClusterId }),
-        ...(options.yamlPath && { yamlPath: options.yamlPath }),
-        // 命令
-        ...(options.buildCommand && { buildCommand: options.buildCommand }),
-        ...(options.testCommand && { testCommand: options.testCommand }),
-        ...(options.deployCommand && { deployCommand: options.deployCommand }),
-    };
-    // 转换为模块化流水线选项
-    const deployTargets = options.deployTarget ? [options.deployTarget] : [];
-    // 使用模块化架构生成YAML
-    const generatedYaml = generateModularPipeline({
-        keywords: [options.buildLanguage, options.buildTool],
-        buildLanguages: [options.buildLanguage],
-        buildTools: [options.buildTool],
-        deployTargets: deployTargets,
-        uploadType: options.uploadType || 'packages',
-        variables: finalVariables
-    });
-    // 创建流水线
-    try {
-        const pipelineId = await createPipelineFunc(organizationId, options.name, generatedYaml);
-        return {
-            pipelineId,
-            generatedYaml
-        };
-    }
-    catch (error) {
-        // 如果是YAML校验失败或其他流水线创建错误，将详细信息透出给用户
-        console.error('Create pipeline failed:', error);
-        // 构造包含生成YAML的错误信息，方便用户排查
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const enhancedError = new Error(`Create pipeline failed: ${errorMessage}\n\n` +
-            `YAML content:\n${generatedYaml}\n\n` +
-            `Suggestions:\n` +
-            `1. Check whether the YAML format is correct.\n` +
-            `2. Verify whether the serviceConnectionID、machineGroupID、kubernetesClusterID and other parameters are existed and valid.`);
-        // 保持原始错误的堆栈信息
-        if (error instanceof Error && error.stack) {
-            enhancedError.stack = error.stack;
-        }
-        throw enhancedError;
-    }
-}
-/**
- * 获取默认的服务连接ID（用于代码源配置）
- * @param organizationId 组织ID
- * @returns 服务连接ID
- */
-async function getDefaultServiceConnectionId(organizationId) {
-    try {
-        // 获取Codeup类型的服务连接（代码源最常用）
-        const serviceConnections = await listServiceConnectionsFunc(organizationId, 'codeup');
-        if (serviceConnections && serviceConnections.length > 0) {
-            return serviceConnections[0].uuid || null;
-        }
-        return null;
-    }
-    catch (error) {
-        console.error('获取Codeup服务连接失败:', error);
-        return null;
-    }
-}
-/**
- * 获取默认的Packages服务连接ID（用于制品上传配置）
- * @param organizationId 组织ID
- * @returns Packages服务连接ID
- */
-async function getDefaultPackagesServiceConnectionId(organizationId) {
-    try {
-        // 获取packages类型的服务连接
-        const serviceConnections = await listServiceConnectionsFunc(organizationId, 'packages');
-        if (serviceConnections && serviceConnections.length > 0) {
-            return serviceConnections[0].uuid || null;
-        }
-        return null;
-    }
-    catch (error) {
-        console.error('获取Packages服务连接失败:', error);
-        return null;
-    }
-}
-/**
- * 获取默认的主机组ID（用于VM部署配置）
- * 注意：由于主机组API只返回数字ID而不是UUID，这个函数暂时不使用
- * 用户需要在描述中明确指定主机组UUID
- * @param organizationId 组织ID
- * @returns null（暂不自动获取）
- */
-async function getDefaultHostGroupId(organizationId) {
-    // 暂时不自动获取主机组，因为API只返回数字ID，无法在流水线中使用
-    // 用户需要在options中明确提供machineGroupId（UUID格式）
-    return null;
-}

package/modules/alibabacloud-devops-mcp-server/dist/operations/flow/pipelineJob.js

@@ -1,113 +0,0 @@
-/**
- * 流水线任务相关操作
- * 提供按照分类获取流水线执行的任务接口
- */
-import * as utils from "../../common/utils.js";
-import { PipelineJobItemSchema, PipelineJobHistoryItemSchema, PipelineJobRunLogSchema } from "../../common/types.js";
-/**
- * 按任务分类获取流水线执行的任务
- * @param organizationId Organization ID（组织ID）
- * @param pipelineId Pipeline ID（流水线ID）
- * @param category Task category, currently only supports DEPLOY（任务分类，当前仅支持DEPLOY）
- * @returns 任务列表
- */
-export async function listPipelineJobsByCategoryFunc(organizationId, pipelineId, category) {
-    const url = `/oapi/v1/flow/organizations/${organizationId}/pipelines/${pipelineId}/listTasksByCategory/${category}`;
-    const response = await utils.yunxiaoRequest(url, {
-        method: "GET",
-    });
-    if (!Array.isArray(response)) {
-        return [];
-    }
-    return response.map(job => PipelineJobItemSchema.parse(job));
-}
-/**
- * 获取流水线任务的执行历史
- * @param organizationId Organization ID（组织ID）
- * @param pipelineId Pipeline ID（流水线ID）
- * @param category Task category, currently only supports DEPLOY（任务分类，当前仅支持DEPLOY）
- * @param identifier Task identifier（任务标识）
- * @param page Page number, default 1
- * @param perPage Number of items per page, default 10, max 30
- * @returns Job history list and pagination information
- */
-export async function listPipelineJobHistorysFunc(organizationId, pipelineId, category, identifier, page = 1, perPage = 10) {
-    const baseUrl = `/oapi/v1/flow/organizations/${organizationId}/pipelines/getComponentsWithoutButtons`;
-    const queryParams = {
-        pipelineId,
-        category,
-        identifier,
-        page,
-        perPage
-    };
-    const url = utils.buildUrl(baseUrl, queryParams);
-    const response = await utils.yunxiaoRequest(url, {
-        method: "GET",
-    });
-    const pagination = {
-        nextPage: null,
-        page: page,
-        perPage: perPage,
-        prevPage: null,
-        total: 0,
-        totalPages: 0
-    };
-    if (response && 'headers' in response) {
-        const headers = response.headers;
-        if (headers['x-next-page']) {
-            pagination.nextPage = parseInt(headers['x-next-page']);
-        }
-        if (headers['x-page']) {
-            pagination.page = parseInt(headers['x-page']);
-        }
-        if (headers['x-per-page']) {
-            pagination.perPage = parseInt(headers['x-per-page']);
-        }
-        if (headers['x-prev-page']) {
-            pagination.prevPage = parseInt(headers['x-prev-page']);
-        }
-        if (headers['x-total']) {
-            pagination.total = parseInt(headers['x-total']);
-        }
-        if (headers['x-total-pages']) {
-            pagination.totalPages = parseInt(headers['x-total-pages']);
-        }
-    }
-    const items = Array.isArray(response)
-        ? response.map(item => PipelineJobHistoryItemSchema.parse(item))
-        : [];
-    return {
-        items,
-        pagination
-    };
-}
-/**
- * 手动运行流水线任务
- * @param organizationId Organization ID（组织ID）
- * @param pipelineId Pipeline ID（流水线ID）
- * @param pipelineRunId Pipeline run instance ID（流水线运行ID）
- * @param jobId Job ID for the pipeline run task（流水线运行任务ID）
- * @returns Whether the operation was successful
- */
-export async function executePipelineJobRunFunc(organizationId, pipelineId, pipelineRunId, jobId) {
-    const url = `/oapi/v1/flow/organizations/${organizationId}/pipelines/${pipelineId}/pipelineRuns/${pipelineRunId}/jobs/${jobId}/start`;
-    const response = await utils.yunxiaoRequest(url, {
-        method: "POST",
-    });
-    return Boolean(response);
-}
-/**
- * 查询任务运行日志
- * @param organizationId Organization ID（组织ID）
- * @param pipelineId Pipeline ID（流水线ID）
- * @param pipelineRunId Pipeline run instance ID（流水线运行ID）
- * @param jobId Job ID of the pipeline run task（流水线运行任务ID）
- * @returns Log content and metadata
- */
-export async function getPipelineJobRunLogFunc(organizationId, pipelineId, pipelineRunId, jobId) {
-    const url = `/oapi/v1/flow/organizations/${organizationId}/pipelines/${pipelineId}/runs/${pipelineRunId}/job/${jobId}/log`;
-    const response = await utils.yunxiaoRequest(url, {
-        method: "GET",
-    });
-    return PipelineJobRunLogSchema.parse(response);
-}

package/modules/alibabacloud-devops-mcp-server/dist/operations/flow/serviceConnection.js

@@ -1,23 +0,0 @@
-import * as utils from "../../common/utils.js";
-import { ServiceConnectionSchema } from "../../common/types.js";
-/**
- * 获取服务连接列表
- * @param organizationId 组织ID
- * @param serviceConnectionType 服务连接类型
- * @returns 服务连接列表
- */
-export async function listServiceConnectionsFunc(organizationId, serviceConnectionType) {
-    const baseUrl = `/oapi/v1/flow/organizations/${organizationId}/serviceConnections`;
-    // 构建查询参数
-    const queryParams = {
-        sericeConnectionType: serviceConnectionType // 注意：API文档中拼写为 sericeConnectionType
-    };
-    const url = utils.buildUrl(baseUrl, queryParams);
-    const response = await utils.yunxiaoRequest(url, {
-        method: "GET",
-    });
-    if (!Array.isArray(response)) {
-        return [];
-    }
-    return response.map(item => ServiceConnectionSchema.parse(item));
-}