@copado/agentia-cli 0.28.0-alpha.0 → 0.31.0-alpha.0

package/dist/lib/mcp/tools.d.ts

@@ -1,13 +1,13 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type CicdRegion } from '../cicd-region.js';
 import { type CredentialType } from '../credential-store.js';
-import { type Environment } from '../environment-types.js';
+import { type Environment, type EnvironmentListFilters } from '../environment-types.js';
 import { type JobListFilters } from '../job-types.js';
 import { type ComparisonMode, type ContentSource, type DependencyResult, type IndexSearchResult, type IndexSource, type MetadataContentResult, type ModuleType, type OrderDirection, type PlatformExperience, type RetrieveMode } from '../metadata-common.js';
 import { type IndexRefreshResult, type RefreshDeletedMetadataIndexResult } from '../metadata-refresh.js';
-import { type PipelineConnection, type PipelineDescribe } from '../pipeline-types.js';
+import { type PipelineConnection, type PipelineDescribe, type PipelineListFilters } from '../pipeline-types.js';
 import { type ProjectDefaultScope } from '../project-defaults.js';
-import { type Project } from '../project-types.js';
+import { type Project, type ProjectListFilters } from '../project-types.js';
 import { type PromotionConflict, type PromotionConflictMode, type PromotionConflictResolutionResult, type PromotionConflictUndoResult } from '../promotion-conflicts.js';
 import { type PromotionDetail, type PromotionListFilters } from '../promotion-types.js';
 import { type User } from '../user-types.js';
@@ -133,24 +133,14 @@ type MetadataDependencyArgs = {
     sourceOrgId: string;
     targetOrgId?: string;
 };
-declare function environmentList(args?: {
-    limit?: number;
-    name?: string;
-    orgId?: string;
-    platform?: string;
-    type?: string;
-}): Promise<{
-    environments: Environment[];
-}>;
+declare function environmentList(args?: EnvironmentListFilters): Promise<Record<string, unknown>>;
 declare function environmentGet(args: {
     id: string;
 }): Promise<{
     environment: Environment;
 }>;
 type PromotionListArgs = PromotionListFilters;
-declare function promotionList(args?: PromotionListArgs): Promise<{
-    promotions: import("../promotion-types.js").Promotion[];
-}>;
+declare function promotionList(args?: PromotionListArgs): Promise<Record<string, unknown>>;
 declare function promotionGet(args: {
     id: string;
 }): Promise<{
@@ -162,9 +152,7 @@ declare function environmentCreate(args: EnvironmentCreateArgs): Promise<{
 declare function environmentUpdate(args: EnvironmentUpdateArgs): Promise<{
     environment: Environment;
 }>;
-declare function jobList(args: JobListArgs): Promise<{
-    jobs: import("../job-types.js").Job[];
-}>;
+declare function jobList(args: JobListArgs): Promise<Record<string, unknown>>;
 declare function jobGet(args: JobIdArgs): Promise<{
     job: import("../job-types.js").Job;
 }>;
@@ -180,9 +168,7 @@ declare function jobKill(args: JobIdArgs): Promise<{
 declare function jobPause(args: JobIdArgs): Promise<{
     result: import("../job-types.js").JobOperationResult;
 }>;
-declare function pipelineList(): Promise<{
-    pipelines: import("../pipeline-types.js").Pipeline[];
-}>;
+declare function pipelineList(args?: PipelineListFilters): Promise<Record<string, unknown>>;
 declare function pipelineGet(args: {
     id: string;
 }): Promise<{
@@ -193,12 +179,7 @@ declare function pipelineConnectionList(args: {
 }): Promise<{
     connections: PipelineConnection[];
 }>;
-declare function projectList(args?: {
-    mine?: boolean;
-    name?: string;
-}): Promise<{
-    projects: Project[];
-}>;
+declare function projectList(args?: ProjectListFilters): Promise<Record<string, unknown>>;
 declare function userGet(args?: {
     id?: string;
 }): Promise<{
@@ -383,12 +364,20 @@ export declare const agentiaMcpToolHandlers: {
     }) => Promise<{
         userStory: import("../work-types.js").UserStory;
     }>;
-    workList: (args?: import("../work-types.js").WorkListFilters & {
+    workList: (args?: import("../list-pagination.js").ListPaginationQuery & {
+        assigneeId?: string;
+        assigneeName?: string;
+        name?: string;
+        ownerId?: string;
+        ownerName?: string;
+        projectId?: string;
+        projectName?: string;
+        status?: string;
+        title?: string;
+    } & {
         assignedToMe?: boolean;
         ownedByMe?: boolean;
-    }) => Promise<{
-        userStories: import("../work-types.js").UserStory[];
-    }>;
+    }) => Promise<Record<string, unknown>>;
     workPush: () => Promise<import("../work-types.js").WorkPushResult>;
     workSet: (args: {
         baseBranch?: string;
@@ -412,6 +401,274 @@ export declare const agentiaMcpToolHandlers: {
     }) => Promise<{
         userStory: import("../work-types.js").UserStory;
     }>;
+    testingBuildList: (args: ({
+        domain?: string;
+        org?: number;
+        pat?: string;
+    } & {
+        project: number;
+    }) & {
+        job?: number;
+        resultSize?: "compact";
+        status?: import("../testing-types.js").TestingBuildStatus;
+    }) => Promise<{
+        result: import("../testing-types.js").TestingBuild[];
+    }>;
+    testingBuildLogs: (args: ({
+        domain?: string;
+        org?: number;
+        pat?: string;
+    } & {
+        project: number;
+    }) & {
+        build: number;
+        job: number;
+        output?: string;
+    }) => Promise<{
+        result: import("../testing-types.js").TestingLogResult;
+    }>;
+    testingBuildRun: (args: ({
+        domain?: string;
+        org?: number;
+        pat?: string;
+    } & {
+        project: number;
+    }) & {
+        job: number;
+    }) => Promise<{
+        result: import("../testing-types.js").TestingBuildRunResult;
+    }>;
+    testingCreate: (args: ({
+        domain?: string;
+        org?: number;
+        pat?: string;
+    } & {
+        project: number;
+    }) & {
+        description?: string;
+        dir?: string[];
+        file?: string[];
+        name: string;
+        robot: string;
+    }) => Promise<{
+        result: import("../testing-types.js").TestingJobCreateResult;
+    }>;
+    testingJobCreate: (args: ({
+        domain?: string;
+        org?: number;
+        pat?: string;
+    } & {
+        project: number;
+    }) & {
+        description?: string;
+        dir?: string[];
+        file?: string[];
+        name: string;
+        robot: string;
+    }) => Promise<{
+        result: import("../testing-types.js").TestingJobCreateResult;
+    }>;
+    testingJobDownload: (args: ({
+        domain?: string;
+        org?: number;
+        pat?: string;
+    } & {
+        project: number;
+    }) & {
+        branch?: string;
+        file: string[];
+        job: number;
+        outputDir?: string;
+    }) => Promise<{
+        result: import("../testing-types.js").TestingDownloadResult;
+    }>;
+    testingJobFiles: (args: ({
+        domain?: string;
+        org?: number;
+        pat?: string;
+    } & {
+        project: number;
+    }) & {
+        job: number;
+    }) => Promise<{
+        result: import("../testing-types.js").TestingFileEntry[];
+    }>;
+    testingJobList: (args: ({
+        domain?: string;
+        org?: number;
+        pat?: string;
+    } & {
+        project: number;
+    }) & {
+        name?: string;
+    }) => Promise<{
+        result: import("../testing-types.js").TestingJob[];
+    }>;
+    testingJobUpload: (args: ({
+        domain?: string;
+        org?: number;
+        pat?: string;
+    } & {
+        project: number;
+    }) & {
+        add?: string[];
+        authorEmail?: string;
+        authorName?: string;
+        branch?: string;
+        job: number;
+        remove?: string[];
+        replace?: string[];
+    }) => Promise<{
+        result: {
+            operations: import("../testing-types.js").TestingFileOperation[];
+            response: import("../testing-types.js").TestingRecord;
+        };
+    }>;
+    testingLogs: (args: ({
+        domain?: string;
+        org?: number;
+        pat?: string;
+    } & {
+        project: number;
+    }) & {
+        build: number;
+        job: number;
+        output?: string;
+    }) => Promise<{
+        result: import("../testing-types.js").TestingLogResult;
+    }>;
+    testingProjectCreate: (args: {
+        domain?: string;
+        org?: number;
+        pat?: string;
+    } & {
+        description?: string;
+        name: string;
+    }) => Promise<{
+        result: import("../testing-types.js").TestingProject;
+    }>;
+    testingProjectList: (args?: {
+        domain?: string;
+        org?: number;
+        pat?: string;
+    } & {
+        name?: string;
+    }) => Promise<{
+        result: import("../testing-types.js").TestingProject[];
+    }>;
+    testingRobotCreate: (args: ({
+        domain?: string;
+        org?: number;
+        pat?: string;
+    } & {
+        project: number;
+    }) & {
+        description?: string;
+        fwVersion?: string;
+        kind?: "cloud" | "QConnect";
+        name: string;
+        os?: string;
+        robotType?: string;
+    }) => Promise<{
+        result: import("../testing-types.js").TestingRobot;
+    }>;
+    testingRobotList: (args: {
+        domain?: string;
+        org?: number;
+        pat?: string;
+    } & {
+        project: number;
+    }) => Promise<{
+        result: import("../testing-types.js").TestingRobot[];
+    }>;
+    testingRun: (args: ({
+        domain?: string;
+        org?: number;
+        pat?: string;
+    } & {
+        project: number;
+    }) & {
+        job: number;
+    }) => Promise<{
+        result: import("../testing-types.js").TestingBuildRunResult;
+    }>;
+    testingStatus: (args: ({
+        domain?: string;
+        org?: number;
+        pat?: string;
+    } & {
+        project: number;
+    }) & {
+        job?: number;
+        resultSize?: "compact";
+        status?: import("../testing-types.js").TestingBuildStatus;
+    }) => Promise<{
+        result: import("../testing-types.js").TestingBuild[];
+    }>;
+    testingUpdate: (args: ({
+        domain?: string;
+        org?: number;
+        pat?: string;
+    } & {
+        project: number;
+    }) & {
+        add?: string[];
+        authorEmail?: string;
+        authorName?: string;
+        branch?: string;
+        job: number;
+        remove?: string[];
+        replace?: string[];
+    }) => Promise<{
+        result: {
+            operations: import("../testing-types.js").TestingFileOperation[];
+            response: import("../testing-types.js").TestingRecord;
+        };
+    }>;
+    testingVariableCreate: (args: ({
+        domain?: string;
+        org?: number;
+        pat?: string;
+    } & {
+        project: number;
+    }) & {
+        description?: string;
+        job?: number;
+        key: string;
+        robot?: number;
+        sensitive?: boolean;
+        type?: import("../testing-types.js").TestingVariableType;
+        userSpecific?: boolean;
+        value?: string;
+    }) => Promise<{
+        result: unknown;
+    }>;
+    testingVariableDelete: (args: ({
+        domain?: string;
+        org?: number;
+        pat?: string;
+    } & {
+        project: number;
+    }) & {
+        id: string;
+    }) => Promise<{
+        result: {
+            projectId: number;
+            variableId: string;
+        };
+    }>;
+    testingVariableList: (args: ({
+        domain?: string;
+        org?: number;
+        pat?: string;
+    } & {
+        project: number;
+    }) & {
+        job?: number;
+        robot?: number;
+    }) => Promise<{
+        result: import("../testing-types.js").TestingVariable[];
+    }>;
     authGet: typeof authGet;
     authSet: typeof authSet;
     environmentAuthStatus: typeof environmentAuthStatus;

package/dist/lib/mcp/tools.js

@@ -1,6 +1,6 @@
 /* eslint-disable max-lines -- Tool schemas and registrations are intentionally colocated. */
 import { z } from 'zod';
-import { normalizeEnvironments } from '../../commands/environment/list.js';
+import { normalizeEnvironmentsListPage } from '../../commands/environment/list.js';
 import { buildMetadataCompareFileRequests } from '../../commands/metadata/content/compare.js';
 import { buildMetadataContentRequest } from '../../commands/metadata/content/get.js';
 import { buildMetadataCompareRequest } from '../../commands/metadata/index/compare.js';
@@ -13,43 +13,30 @@ import { readDefaults, readLastWorkItem, resolveDefaults, unsetDefaults, writeDe
 import { runEnvironmentAuthStatus } from '../environment-auth-status.js';
 import { buildCreatePayload, buildMutationPayload, ENVIRONMENT_STRING_VALIDATION_KEYS, validateNonEmptyStringFields, } from '../environment-flags.js';
 import { DEFAULT_ENVIRONMENT_PLATFORM, DEFAULT_ENVIRONMENT_TYPE, ENVIRONMENT_TYPES, environmentEndpoint, environmentsListEndpoint, } from '../environment-types.js';
-import { JOB_LIST_LIMIT_MAX, JOB_LIST_LIMIT_MIN, jobEndpoint, jobKillEndpoint, jobListEndpoint, jobPauseEndpoint, jobResultLogEndpoint, jobResumeEndpoint, jobRunEndpoint, normalizeJob, normalizeJobOperation, normalizeJobs, resolveJobStepForLog, } from '../job-types.js';
+import { jobEndpoint, jobKillEndpoint, jobListEndpoint, jobPauseEndpoint, jobResultLogEndpoint, jobResumeEndpoint, jobRunEndpoint, normalizeJob, normalizeJobOperation, normalizeJobsListPage, resolveJobStepForLog, } from '../job-types.js';
+import { listPaginationZodFields, mcpPaginatedListPayload } from '../list-pagination.js';
 import { normalizeLocalGatewayBaseUrl, readLocalGatewayConfig } from '../local-gateway-config.js';
 import { COMPARISON_MODES, CONTENT_SOURCES, contentResultToCompareSide, createUnifiedDiff, INDEX_SOURCES, MODULE_TYPES, ORDER_DIRECTIONS, PLATFORM_EXPERIENCES, RETRIEVE_MODES, sourceSideLabel, } from '../metadata-common.js';
 import { buildRefreshDeletedRequest, buildRefreshIndexRequest, refreshStatusEndpoint, resolveRefreshSourceFromEnv, } from '../metadata-refresh.js';
-import { normalizePipelineDescribe, normalizePipelines, pipelineConnectionsFromPipelines, pipelineDescribeEndpoint, pipelineListEndpoint, } from '../pipeline-types.js';
+import { normalizePipelineDescribe, normalizePipelines, normalizePipelinesListPage, pipelineConnectionsFromPipelines, pipelineDescribeEndpoint, pipelineListEndpoint, } from '../pipeline-types.js';
 import { buildSetValues, collectSelectedKeys } from '../project-default-flags.js';
 import { PROJECT_DEFAULT_KEYS } from '../project-defaults.js';
-import { normalizeProject, normalizeProjects, projectEndpoint, projectsListEndpoint, } from '../project-types.js';
+import { normalizeProject, normalizeProjectsListPage, projectEndpoint, projectsListEndpoint, } from '../project-types.js';
 import { buildPromotionConflictResolutionRequest, normalizePromotionConflicts, PROMOTION_CONFLICT_MODES, promotionConflictContentEndpoint, promotionConflictResolveEndpoint, promotionConflictsEndpoint, promotionConflictUndoEndpoint, withPromotionConflictErrorTranslation, } from '../promotion-conflicts.js';
-import { normalizePromotionDetail, normalizePromotions, PROMOTION_LIST_LIMIT_MAX, PROMOTION_LIST_LIMIT_MIN, promotionEndpoint, promotionListEndpoint, } from '../promotion-types.js';
+import { normalizePromotionDetail, normalizePromotionsListPage, promotionEndpoint, promotionListEndpoint, } from '../promotion-types.js';
 import { getUserContext } from '../user-context.js';
 import { DEFAULT_USER_ID, resolveUserId, userEndpoint } from '../user-types.js';
 import { workStatusEndpoint } from '../work-types.js';
 import { safelyHandleTool } from './result.js';
+import { agentiaMcpTestingToolHandlers, registerAgentiaMcpTestingTools } from './testing-tools.js';
 import { agentiaMcpWorkToolHandlers, registerAgentiaMcpWorkTools } from './work-tools.js';
 const MAX_LIMIT = 2000;
 async function environmentList(args = {}) {
-    const filters = {};
-    if (args.name !== undefined) {
-        filters.name = args.name;
-    }
-    if (args.orgId !== undefined) {
-        filters.orgId = args.orgId;
-    }
-    if (args.platform !== undefined) {
-        filters.platform = args.platform;
-    }
-    if (args.type !== undefined) {
-        filters.type = args.type;
-    }
     const response = await CicdGateway.call({
-        endpoint: environmentsListEndpoint(filters),
+        endpoint: environmentsListEndpoint(args),
         method: 'GET',
     });
-    const environments = normalizeEnvironments(response);
-    const limit = args.limit === undefined ? environments.length : Math.min(Math.max(args.limit, 1), MAX_LIMIT);
-    return { environments: environments.slice(0, limit) };
+    return mcpPaginatedListPayload('environments', normalizeEnvironmentsListPage(response));
 }
 async function environmentGet(args) {
     const environment = await CicdGateway.call({
@@ -63,7 +50,7 @@ async function promotionList(args = {}) {
         endpoint: promotionListEndpoint(args),
         method: 'GET',
     });
-    return { promotions: normalizePromotions(response) };
+    return mcpPaginatedListPayload('promotions', normalizePromotionsListPage(response));
 }
 async function promotionGet(args) {
     const response = await CicdGateway.call({
@@ -145,9 +132,10 @@ async function environmentUpdate(args) {
 async function jobList(args) {
     const filters = {
         context: args.context,
+        cursor: args.cursor,
         id: args.id,
-        limit: args.limit,
         name: args.name,
+        pageSize: args.pageSize,
         parent: args.parent,
         status: args.status,
         type: args.type,
@@ -163,7 +151,7 @@ async function jobList(args) {
         endpoint: jobListEndpoint(filters),
         method: 'GET',
     });
-    return { jobs: normalizeJobs(response) };
+    return mcpPaginatedListPayload('jobs', normalizeJobsListPage(response));
 }
 async function jobGet(args) {
     const response = await CicdGateway.call({
@@ -200,12 +188,12 @@ async function jobPause(args) {
     });
     return { result: normalizeJobOperation(result) };
 }
-async function pipelineList() {
+async function pipelineList(args = {}) {
     const response = await CicdGateway.call({
-        endpoint: pipelineListEndpoint(),
+        endpoint: pipelineListEndpoint(args),
         method: 'GET',
     });
-    return { pipelines: normalizePipelines(response) };
+    return mcpPaginatedListPayload('pipelines', normalizePipelinesListPage(response));
 }
 async function pipelineGet(args) {
     const response = await CicdGateway.call({
@@ -234,18 +222,11 @@ async function pipelineConnectionList(args) {
     return { connections };
 }
 async function projectList(args = {}) {
-    const filters = {};
-    if (args.mine) {
-        filters.mine = true;
-    }
-    if (typeof args.name === 'string') {
-        filters.name = args.name;
-    }
     const response = await CicdGateway.call({
-        endpoint: projectsListEndpoint(filters),
+        endpoint: projectsListEndpoint(args),
         method: 'GET',
     });
-    return { projects: normalizeProjects(response) };
+    return mcpPaginatedListPayload('projects', normalizeProjectsListPage(response));
 }
 async function userGet(args = {}) {
     const user = await CicdGateway.call({
@@ -667,6 +648,7 @@ export const agentiaMcpToolHandlers = {
     promotionList,
     userGet,
     workStatus,
+    ...agentiaMcpTestingToolHandlers,
     ...agentiaMcpWorkToolHandlers,
 };
 const environmentMutationSchema = {
@@ -698,13 +680,6 @@ const promotionListSchema = {
     destinationEnvironmentId: z.string().optional().describe('Filter by destination environment ID.'),
     destinationEnvironmentName: z.string().optional().describe('Filter by destination environment name.'),
     isBackPromotion: z.boolean().optional().describe('Filter by back promotion.'),
-    limit: z
-        .number()
-        .int()
-        .min(PROMOTION_LIST_LIMIT_MIN)
-        .max(PROMOTION_LIST_LIMIT_MAX)
-        .optional()
-        .describe(`Maximum number of promotions to return (${PROMOTION_LIST_LIMIT_MIN}-${PROMOTION_LIST_LIMIT_MAX}).`),
     name: z.string().optional().describe('Filter by name.'),
     pipelineId: z.string().optional().describe('Filter by pipeline ID.'),
     pipelineName: z.string().optional().describe('Filter by pipeline name.'),
@@ -714,16 +689,18 @@ const promotionListSchema = {
     sourceEnvironmentName: z.string().optional().describe('Filter by source environment name.'),
     status: z.string().optional().describe('Filter by status.'),
     userStoryId: z.string().optional().describe('Filter by user story ID.'),
+    ...listPaginationZodFields,
 };
 export function registerAgentiaMcpTools(server) {
+    registerAgentiaMcpTestingTools(server);
     server.registerTool('agentia_environment_list', {
         description: 'List Copado environments via the CICD gateway.',
         inputSchema: {
-            limit: z.number().int().min(1).max(MAX_LIMIT).optional().describe('Maximum number of environments to return.'),
             name: z.string().optional().describe('Filter by name.'),
             orgId: z.string().optional().describe('Filter by Salesforce org ID.'),
             platform: z.string().optional().describe('Filter by platform.'),
             type: z.string().optional().describe('Filter by environment type.'),
+            ...listPaginationZodFields,
         },
         title: 'Agentia Environment List',
     }, (args) => safelyHandleTool(() => environmentList(args || {})));
@@ -768,18 +745,12 @@ export function registerAgentiaMcpTools(server) {
         inputSchema: {
             context: z.string().optional().describe('Contains match on JobExecution context.'),
             id: z.string().optional().describe('Exact JobExecution Id.'),
-            limit: z
-                .number()
-                .int()
-                .min(JOB_LIST_LIMIT_MIN)
-                .max(JOB_LIST_LIMIT_MAX)
-                .optional()
-                .describe(`Maximum number of jobs to return (${JOB_LIST_LIMIT_MIN}-${JOB_LIST_LIMIT_MAX}).`),
             mine: z.boolean().optional().describe('List only jobs owned by the current user.'),
             name: z.string().optional().describe('Contains match on JobExecution name.'),
             parent: z.string().optional().describe('Exact parent record Id.'),
             status: z.string().optional().describe('Exact Copado job status.'),
             type: z.string().optional().describe('Contains match on Job Template name.'),
+            ...listPaginationZodFields,
         },
         title: 'Agentia Job List',
     }, (args) => safelyHandleTool(() => jobList(args)));
@@ -821,9 +792,9 @@ export function registerAgentiaMcpTools(server) {
     }, (args) => safelyHandleTool(() => jobPause(args)));
     server.registerTool('agentia_pipeline_list', {
         description: 'List Copado pipelines via the CICD gateway.',
-        inputSchema: {},
+        inputSchema: listPaginationZodFields,
         title: 'Agentia Pipeline List',
-    }, () => safelyHandleTool(() => pipelineList()));
+    }, (args) => safelyHandleTool(() => pipelineList(args || {})));
     server.registerTool('agentia_pipeline_get', {
         description: 'Describe a Copado pipeline via the CICD gateway.',
         inputSchema: {
@@ -843,6 +814,7 @@ export function registerAgentiaMcpTools(server) {
         inputSchema: {
             mine: z.boolean().optional().describe('When true, list only projects owned by or related to the current user.'),
             name: z.string().optional().describe('Filter by name (partial match).'),
+            ...listPaginationZodFields,
         },
         title: 'Agentia Project List',
     }, (args) => safelyHandleTool(() => projectList(args || {})));