@copado/agentia-cli 1.0.0-beta.8 → 1.0.0-rc.0

package/dist/lib/mcp/adv-tools.js

@@ -10,6 +10,20 @@ const componentReferenceSchema = z.union([
     }),
 ]);
 const componentInputSchema = z.array(componentReferenceSchema).min(1).describe('Components as Type/Name strings or {type, fullName, excluded} objects.');
+const deploymentIdSchema = z.number().int().positive().describe('Deployment ID.');
+const deploymentIdInputSchema = {
+    deploymentId: deploymentIdSchema.optional().describe('Canonical deployment ID.'),
+    flow: deploymentIdSchema.optional().describe('Deprecated alias for deploymentId.'),
+    id: deploymentIdSchema.optional().describe('Deprecated alias for deploymentId.'),
+};
+function resolveDeploymentId(input) {
+    const supplied = [input.deploymentId, input.id, input.flow].filter((value) => value !== undefined);
+    if (supplied.length === 0)
+        throw new Error('Provide deploymentId.');
+    if (new Set(supplied).size !== 1)
+        throw new Error('Deployment ID aliases must have the same value.');
+    return supplied[0];
+}
 function componentList(components) {
     return components.map((component) => {
         if (typeof component === 'string')
@@ -30,7 +44,7 @@ async function deploymentAction(args) {
     return {
         result: await runAdvDeploymentAction({
             backup: args.backup,
-            id: args.id,
+            id: resolveDeploymentId(args),
             kind: args.kind,
             wait: args.wait,
             waitIntervalSeconds: args.interval,
@@ -66,9 +80,9 @@ export function registerAgentiaMcpAdvTools(server) {
     }, (args) => safelyHandleTool(async () => ({ result: await listAdvDeployments({ includeArchived: args.includeArchived }) })));
     server.registerTool('agentia_adv_deployment_get', {
         description: 'Get one Copado Pipelines Advanced deployment.',
-        inputSchema: { id: z.number().int().positive().describe('Deployment ID.') },
+        inputSchema: deploymentIdInputSchema,
         title: 'Agentia ADV Deployment Get',
-    }, (args) => safelyHandleTool(async () => ({ result: await getAdvDeployment(args.id) })));
+    }, (args) => safelyHandleTool(async () => ({ result: await getAdvDeployment(resolveDeploymentId(args)) })));
     server.registerTool('agentia_adv_deployment_create', {
         description: 'Create a Copado Pipelines Advanced deployment.',
         inputSchema: {
@@ -81,15 +95,15 @@ export function registerAgentiaMcpAdvTools(server) {
     server.registerTool('agentia_adv_deployment_options', {
         description: 'Update Copado Pipelines Advanced deployment options.',
         inputSchema: {
-            id: z.number().int().positive().describe('Deployment ID.'),
+            ...deploymentIdInputSchema,
             set: z.array(z.string()).optional().describe('Options as name=value entries; booleans, null, and finite JavaScript Number values are converted.'),
         },
         title: 'Agentia ADV Deployment Options',
-    }, (args) => safelyHandleTool(async () => ({ result: await updateAdvDeploymentOptions({ id: args.id, set: args.set }) })));
+    }, (args) => safelyHandleTool(async () => ({ result: await updateAdvDeploymentOptions({ id: resolveDeploymentId(args), set: args.set }) })));
     server.registerTool('agentia_adv_deployment_validate', {
         description: 'Start a check-only Copado Pipelines Advanced validation run.',
         inputSchema: {
-            id: z.number().int().positive().describe('Deployment ID.'),
+            ...deploymentIdInputSchema,
             interval: z.number().positive().optional().describe('Seconds between polls when wait is true.'),
             timeout: z.number().positive().optional().describe('Maximum seconds to wait.'),
             wait: z.boolean().optional().describe('Wait for the run to finish.'),
@@ -100,7 +114,7 @@ export function registerAgentiaMcpAdvTools(server) {
         description: 'Start a real Copado Pipelines Advanced deployment run.',
         inputSchema: {
             confirm: z.boolean().optional().describe('Required true to start a deployment.'),
-            id: z.number().int().positive().describe('Deployment ID.'),
+            ...deploymentIdInputSchema,
             interval: z.number().positive().optional().describe('Seconds between polls when wait is true.'),
             timeout: z.number().positive().optional().describe('Maximum seconds to wait.'),
             wait: z.boolean().optional().describe('Wait for the run to finish.'),
@@ -112,7 +126,7 @@ export function registerAgentiaMcpAdvTools(server) {
         inputSchema: {
             backup: z.boolean().optional().describe('Run backupThenDeploy instead of a quick deploy.'),
             confirm: z.boolean().optional().describe('Required true to start a quick deploy.'),
-            id: z.number().int().positive().describe('Deployment ID.'),
+            ...deploymentIdInputSchema,
             interval: z.number().positive().optional().describe('Seconds between polls when wait is true.'),
             timeout: z.number().positive().optional().describe('Maximum seconds to wait.'),
             wait: z.boolean().optional().describe('Wait for the run to finish.'),
@@ -123,7 +137,7 @@ export function registerAgentiaMcpAdvTools(server) {
         description: 'Cancel the current Copado Pipelines Advanced run.',
         inputSchema: {
             confirm: z.boolean().optional().describe('Required true to request cancellation.'),
-            id: z.number().int().positive().describe('Deployment ID.'),
+            ...deploymentIdInputSchema,
             interval: z.number().positive().optional().describe('Seconds between polls when wait is true.'),
             timeout: z.number().positive().optional().describe('Maximum seconds to wait.'),
             wait: z.boolean().optional().describe('Wait for the run to finish.'),
@@ -133,7 +147,7 @@ export function registerAgentiaMcpAdvTools(server) {
         requireConfirm(args.confirm, 'Pipelines Advanced deployment cancellation');
         return {
             result: await cancelAdvDeployment({
-                id: args.id,
+                id: resolveDeploymentId(args),
                 wait: args.wait,
                 waitIntervalSeconds: args.interval,
                 waitTimeoutSeconds: args.timeout,
@@ -148,37 +162,37 @@ export function registerAgentiaMcpAdvTools(server) {
     server.registerTool('agentia_adv_component_list', {
         description: 'List source components for a Copado Pipelines Advanced deployment.',
         inputSchema: {
-            flow: z.number().int().positive().describe('Deployment ID.'),
+            ...deploymentIdInputSchema,
             includeManagedPackage: z.boolean().optional().describe('Include managed package components.'),
             type: z.string().describe('Comma-separated component type names.'),
         },
         title: 'Agentia ADV Component List',
-    }, (args) => safelyHandleTool(async () => ({ result: await listAdvComponents(args) })));
+    }, (args) => safelyHandleTool(async () => ({ result: await listAdvComponents({ ...args, flow: resolveDeploymentId(args) }) })));
     server.registerTool('agentia_adv_component_refresh', {
         description: 'Refresh Copado Pipelines Advanced component comparison cache.',
         inputSchema: {
-            flow: z.number().int().positive().describe('Deployment ID.'),
+            ...deploymentIdInputSchema,
             full: z.boolean().optional().describe('Delete cached comparison data before refreshing.'),
             type: z.string().describe('Comma-separated component type names.'),
         },
         title: 'Agentia ADV Component Refresh',
-    }, (args) => safelyHandleTool(async () => ({ result: await refreshAdvComponents(args) })));
+    }, (args) => safelyHandleTool(async () => ({ result: await refreshAdvComponents({ ...args, flow: resolveDeploymentId(args) }) })));
     server.registerTool('agentia_adv_component_selected', {
         description: 'List selected components for a Copado Pipelines Advanced deployment.',
-        inputSchema: { deploymentId: z.number().int().positive().describe('Deployment ID.') },
+        inputSchema: deploymentIdInputSchema,
         title: 'Agentia ADV Component Selected',
-    }, (args) => safelyHandleTool(async () => ({ result: await selectedAdvComponents(args.deploymentId) })));
+    }, (args) => safelyHandleTool(async () => ({ result: await selectedAdvComponents(resolveDeploymentId(args)) })));
     server.registerTool('agentia_adv_component_add', {
         description: 'Add components to a Copado Pipelines Advanced deployment selection.',
         inputSchema: {
             components: componentInputSchema,
-            deploymentId: z.number().int().positive().describe('Deployment ID.'),
+            ...deploymentIdInputSchema,
         },
         title: 'Agentia ADV Component Add',
     }, (args) => safelyHandleTool(async () => ({
         result: await addAdvComponents({
             components: componentList(args.components),
-            deploymentId: args.deploymentId,
+            deploymentId: resolveDeploymentId(args),
             mode: componentAddMode(args.components),
         }),
     })));
@@ -186,37 +200,37 @@ export function registerAgentiaMcpAdvTools(server) {
         description: 'Remove components from a Copado Pipelines Advanced deployment selection.',
         inputSchema: {
             components: componentInputSchema,
-            deploymentId: z.number().int().positive().describe('Deployment ID.'),
+            ...deploymentIdInputSchema,
         },
         title: 'Agentia ADV Component Remove',
     }, (args) => safelyHandleTool(async () => ({
-        result: await removeAdvComponents({ components: componentList(args.components), deploymentId: args.deploymentId }),
+        result: await removeAdvComponents({ components: componentList(args.components), deploymentId: resolveDeploymentId(args) }),
     })));
     server.registerTool('agentia_adv_job_get', {
         description: 'Get the latest Copado Pipelines Advanced run for a deployment.',
-        inputSchema: { deploymentId: z.number().int().positive().describe('Deployment ID.') },
+        inputSchema: deploymentIdInputSchema,
         title: 'Agentia ADV Job Get',
-    }, (args) => safelyHandleTool(async () => ({ result: await getAdvJob(args.deploymentId) })));
+    }, (args) => safelyHandleTool(async () => ({ result: await getAdvJob(resolveDeploymentId(args)) })));
     server.registerTool('agentia_adv_job_list', {
         description: 'List Copado Pipelines Advanced run history for a deployment.',
         inputSchema: {
-            deploymentId: z.number().int().positive().describe('Deployment ID.'),
+            ...deploymentIdInputSchema,
             page: z.number().int().min(0).optional().describe('Page number starting at 0.'),
             pageSize: z.number().int().positive().optional().describe('Rows per page.'),
         },
         title: 'Agentia ADV Job List',
-    }, (args) => safelyHandleTool(async () => ({ result: await listAdvJobs(args) })));
+    }, (args) => safelyHandleTool(async () => ({ result: await listAdvJobs({ ...args, deploymentId: resolveDeploymentId(args) }) })));
     server.registerTool('agentia_adv_job_wait', {
         description: 'Wait for the latest Copado Pipelines Advanced run to finish.',
         inputSchema: {
-            deploymentId: z.number().int().positive().describe('Deployment ID.'),
+            ...deploymentIdInputSchema,
             interval: z.number().positive().optional().describe('Seconds between polls.'),
             timeout: z.number().positive().optional().describe('Maximum seconds to wait.'),
         },
         title: 'Agentia ADV Job Wait',
     }, (args) => safelyHandleTool(async () => {
         const result = await waitForAdvJob({
-            deploymentId: args.deploymentId,
+            deploymentId: resolveDeploymentId(args),
             intervalSeconds: args.interval,
             timeoutSeconds: args.timeout,
         });

package/dist/lib/mcp/tool-annotations.js

@@ -93,6 +93,7 @@ const DELETE_TOOLS = [
     'agentia_data_filter_delete',
     'agentia_data_template_delete',
     'agentia_function_delete',
+    'agentia_template_delete',
     'agentia_pipeline_connection_delete',
     'agentia_pipeline_stage_connection_delete',
     'agentia_project_delete',
@@ -146,6 +147,9 @@ const READ_TOOLS = [
     'agentia_function_list',
     'agentia_function_result_get',
     'agentia_function_result_log_get',
+    'agentia_template_defaults',
+    'agentia_template_get',
+    'agentia_template_list',
     'agentia_health_check',
     'agentia_job_get',
     'agentia_job_list',
@@ -226,6 +230,7 @@ const UPDATE_TOOLS = [
     'agentia_data_template_save_detail',
     'agentia_environment_update',
     'agentia_function_upsert',
+    'agentia_template_upsert',
     'agentia_pipeline_connection_update',
     'agentia_pipeline_stage_connection_update',
     'agentia_pipeline_update',

package/dist/lib/mcp/tools.js

@@ -46,6 +46,8 @@ import { normalizeRepositoriesListPage, normalizeRepository, normalizeRepository
 import { buildStageMutationPayload, validateStagePayload } from '../stage-flags.js';
 import { fetchStages } from '../stage-list.js';
 import { normalizePipelineStageConnection, normalizeStage, pipelineStageConnectionEndpoint, pipelineStageConnectionsEndpoint, STAGE_META_STAGE_SUGGESTIONS, stageEndpoint, stagesEndpoint, } from '../stage-types.js';
+import { buildTemplateDefaultsQuery } from '../template-flags.js';
+import { normalizeTemplate, normalizeTemplatesListPage, normalizeTemplateUpsertPayload, TEMPLATE_LIST_TYPES, templateDefaultsEndpoint, templateEndpoint, templatesEndpoint, } from '../template-types.js';
 import { getUserContext } from '../user-context.js';
 import { fetchUser } from '../user-get.js';
 import { DEFAULT_USER_ID } from '../user-types.js';
@@ -637,6 +639,52 @@ async function functionDelete(args) {
     });
     return { apiName };
 }
+async function templateList(args = {}) {
+    const response = await CicdGateway.call({
+        endpoint: templatesEndpoint({ ...args, type: args.type ?? 'custom' }),
+        method: 'GET',
+    });
+    return mcpPaginatedListPayload('templates', normalizeTemplatesListPage(response));
+}
+async function templateGet(args) {
+    const response = await CicdGateway.call({
+        endpoint: templateEndpoint(assertRequired(args.apiName, 'apiName')),
+        method: 'GET',
+    });
+    return { template: normalizeTemplate(response) };
+}
+async function templateDefaults(args) {
+    const query = buildTemplateDefaultsQuery({
+        name: assertRequired(args.name, 'name'),
+        ...(args.apiName === undefined ? {} : { 'api-name': args.apiName }),
+    });
+    const response = await CicdGateway.call({
+        endpoint: templateDefaultsEndpoint(query),
+        method: 'GET',
+    });
+    return { template: normalizeTemplate(response) };
+}
+async function templateUpsert(args) {
+    const apiName = assertRequired(args.apiName, 'apiName');
+    const payload = normalizeTemplateUpsertPayload(apiName, args);
+    const response = await CicdGateway.call({
+        body: payload,
+        endpoint: templateEndpoint(apiName),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'PUT',
+    });
+    return { template: normalizeTemplate(response) };
+}
+async function templateDelete(args) {
+    const apiName = assertRequired(args.apiName, 'apiName');
+    await CicdGateway.call({
+        endpoint: templateEndpoint(apiName),
+        method: 'DELETE',
+    });
+    return { apiName };
+}
 async function functionRun(args) {
     const apiName = assertRequired(args.apiName, 'apiName');
     const response = await CicdGateway.call({
@@ -1280,6 +1328,11 @@ export const agentiaMcpToolHandlers = wrapMcpToolHandlers({
     stageGet,
     stageList,
     stageUpdate,
+    templateDefaults,
+    templateDelete,
+    templateGet,
+    templateList,
+    templateUpsert,
     userGet,
     workStatus,
     ...agentiaMcpTestingToolHandlers,
@@ -2117,6 +2170,71 @@ export function registerAgentiaMcpTools(server) {
         },
         title: 'Agentia Function Result Log Get',
     }, (args) => safelyHandleTool(() => functionResultLogGet(args)));
+    server.registerTool('agentia_template_list', {
+        description: 'List Copado Job Templates via the CICD gateway.',
+        inputSchema: {
+            fetchAll: z.boolean().optional().describe('Fetch all matching templates.'),
+            name: z.string().optional().describe('Filter by name substring.'),
+            type: z.enum(TEMPLATE_LIST_TYPES).optional().describe('List Custom templates only, or all templates.'),
+            ...listPaginationZodFields,
+        },
+        title: 'Agentia Template List',
+    }, (args) => safelyHandleTool(() => templateList(args)));
+    server.registerTool('agentia_template_get', {
+        description: 'Get a Copado Job Template by API name via the CICD gateway.',
+        inputSchema: { apiName: z.string().describe('Template API name.') },
+        title: 'Agentia Template Get',
+    }, (args) => safelyHandleTool(() => templateGet(args)));
+    server.registerTool('agentia_template_defaults', {
+        description: 'Scaffold default Copado Job Template metadata without writing to Salesforce.',
+        inputSchema: {
+            apiName: z.string().optional().describe('Optional template API name for the scaffold.'),
+            name: z.string().describe('Template display name.'),
+        },
+        title: 'Agentia Template Defaults',
+    }, (args) => safelyHandleTool(() => templateDefaults(args)));
+    server.registerTool('agentia_template_upsert', {
+        description: 'Create or update a Copado Job Template by API name via the CICD gateway.',
+        inputSchema: {
+            apiName: z.string().describe('Template API name.'),
+            description: z.string().nullable().optional().describe('Template description.'),
+            name: z.string().optional().describe('Template display name.'),
+            steps: z
+                .array(z.object({
+                apiName: z.string().describe('Step API name.'),
+                config: z.unknown().nullable().optional().describe('Step config JSON.'),
+                customType: z.string().nullable().optional().describe('Step custom type.'),
+                name: z.string().describe('Step display name.'),
+                order: z.number().nullable().optional().describe('Step order (server may reassign).'),
+                type: z.string().describe('Step type.'),
+            }))
+                .describe('Full step list (replace semantics; use [] to clear all steps).'),
+            type: z.string().optional().describe('Template type.'),
+            version: z.string().optional().describe('Template version.'),
+            volumeOptions: z.unknown().nullable().optional().describe('Volume options JSON or string.'),
+        },
+        title: 'Agentia Template Upsert',
+    }, (args) => safelyHandleTool(() => templateUpsert({
+        apiName: args.apiName,
+        description: args.description,
+        name: args.name,
+        steps: args.steps.map((step) => ({
+            apiName: step.apiName,
+            customType: step.customType,
+            name: step.name,
+            order: step.order,
+            type: step.type,
+            ...(step.config === undefined ? {} : { config: step.config }),
+        })),
+        type: args.type,
+        version: args.version,
+        volumeOptions: args.volumeOptions,
+    })));
+    server.registerTool('agentia_template_delete', {
+        description: 'Delete a Copado Job Template by API name via the CICD gateway.',
+        inputSchema: { apiName: z.string().describe('Template API name.') },
+        title: 'Agentia Template Delete',
+    }, (args) => safelyHandleTool(() => templateDelete(args)));
     server.registerTool('agentia_promotion_conflict_list', {
         description: 'List merge conflicts for a Copado promotion.',
         inputSchema: { promotionId: z.string().describe('Copado promotion ID.') },

package/dist/lib/mcp/work-tools.js

@@ -1,10 +1,10 @@
 import { z } from 'zod';
 import { assertRequired } from '../assert.js';
 import { CicdGateway } from '../cicd-gateway.js';
-import { attachCapturedOutputLogs, MCP_STDIO_CAPTURE_OPTIONS, withCapturedCommandOutput, } from '../command-output-buffer.js';
+import { MCP_STDIO_CAPTURE_OPTIONS, withCapturedCommandOutput, } from '../command-output-buffer.js';
 import { reconcileWorkSetCredential, sanitizeWorkSetUserStory } from '../credential-sync.js';
 import { readDefaults, resolveDefaults, writeLastWorkSelection, } from '../defaults-store.js';
-import { checkoutFeatureBranch, fetchOriginBranch, fetchOriginBranchIfExists, listPendingChanges, } from '../git-worktree.js';
+import { checkoutFeatureBranch, fetchOriginBranch, fetchOriginBranchIfExists, getHeadCommitId, listPendingChanges, } from '../git-worktree.js';
 import { listPaginationZodFields, mcpPaginatedListPayload } from '../list-pagination.js';
 import { LocalQualityGatesError, parseQualityGatesEnvAssignments, runLocalQualityGates, } from '../local-quality-gates.js';
 import { FULL_METADATA_SELECTION_TYPES_HELP } from '../nested-metadata-registry.js';
@@ -21,7 +21,7 @@ import { validateWorkMutationPayload, WORK_LONG_TEXT_MAX_LENGTH, WORK_SHORT_TEXT
 import { fetchWorkItem, fetchWorkItems } from '../work-get.js';
 import { performWorkLocalCommit } from '../work-local-commit.js';
 import { reportLocalQualityGatesFailure, reportLocalQualityGatesOutcome, } from '../work-local-run-tests.js';
-import { capturingWorkPushHooks, performWorkPush, resolveActiveFeatureWorkItem, resolveWorkPushContext, resolveWorkPushNeed, } from '../work-push.js';
+import { capturingWorkPushHooks, performWorkPush, resolveActiveFeatureWorkItem, resolveWorkPushContext, resolveWorkPushNeed, uploadCapturedPublishLogsBestEffort, } from '../work-push.js';
 import { performWorkSetNone } from '../work-set-none.js';
 import { isWorkSetWarning, parseWorkSetSelection, toWorkSetWarningResult, writeWorkSetWarningSelection, } from '../work-set-selection.js';
 import { reportSubmitUserStoriesAheadBehind } from '../work-submit-ahead-behind.js';
@@ -276,6 +276,7 @@ async function promoteWorkItemDone(args = {}) {
             pushResult = await performWorkPush({
                 ...pushContext,
                 hooks: capturingWorkPushHooks,
+                skipLogUpload: true,
                 skipNestedMetadataDetection: args.skipNestedMetadataDetection,
             });
         }
@@ -293,6 +294,12 @@ async function promoteWorkItemDone(args = {}) {
             },
             method: 'POST',
         }));
+        const tipCommitId = pushResult?.commits.at(-1)?.id ?? (await getHeadCommitId());
+        await uploadCapturedPublishLogsBestEffort({
+            commitId: tipCommitId,
+            hooks: capturingWorkPushHooks,
+            linkedEntityId: await resolveWorkItemId(),
+        });
         return {
             branch,
             done,
@@ -343,6 +350,7 @@ async function workSubmit(args = {}) {
             pushResult = await performWorkPush({
                 ...pushContext,
                 hooks: capturingWorkPushHooks,
+                skipLogUpload: true,
                 skipNestedMetadataDetection: args.skipNestedMetadataDetection,
             });
         }
@@ -352,13 +360,19 @@ async function workSubmit(args = {}) {
             workItem,
         });
         const submit = await capturingWorkPushHooks.withSpinner('Submitting work item', () => CicdGateway.call({
-            body: attachCapturedOutputLogs({ workItem }),
+            body: { workItem },
             endpoint: workSubmitEndpoint(),
             headers: {
                 'Content-Type': 'application/json',
             },
             method: 'POST',
         }));
+        const tipCommitId = pushResult?.commits.at(-1)?.id ?? (await getHeadCommitId());
+        await uploadCapturedPublishLogsBestEffort({
+            commitId: tipCommitId,
+            hooks: capturingWorkPushHooks,
+            linkedEntityId: await resolveWorkItemId(),
+        });
         return {
             branch,
             push: pushResult,