@copado/agentia-cli 0.122.0-alpha.1 → 1.0.0-beta.1

package/dist/lib/loopback-callback-server.js

@@ -1,169 +1,9 @@
-import { createServer } from 'node:http';
-import { createConnection } from 'node:net';
-export const DEFAULT_CALLBACK_PATH = '/callback';
-export const DEFAULT_PORT_START = 8080;
-export const DEFAULT_PORT_END = 8090;
-function parseCallbackResult(req, callbackPath) {
-    const url = new URL(req.url ?? '/', 'http://127.0.0.1');
-    if (url.pathname !== callbackPath) {
-        return null;
-    }
-    const errorCode = url.searchParams.get('errorCode');
-    if (errorCode) {
-        return {
-            errorCode,
-            errorDescription: url.searchParams.get('errorDescription') ?? '',
-            ok: false,
-        };
-    }
-    const status = url.searchParams.get('status');
-    if (status === 'error') {
-        const reason = url.searchParams.get('reason') ?? 'Authentication failed';
-        return {
-            errorCode: reason,
-            errorDescription: reason,
-            ok: false,
-        };
-    }
-    return { ok: true };
-}
-function successHtml() {
-    return `<!DOCTYPE html>
-<html><body style="font-family:sans-serif;text-align:center;padding:50px;">
-  <h2 style="color:#2e7d32;">&#10004; Authentication Successful</h2>
-  <p>You can safely close this browser window and return to your terminal.</p>
-</body></html>`;
-}
-function errorHtml(errorCode, errorDescription) {
-    const safeCode = escapeHtml(errorCode);
-    const safeDescription = escapeHtml(errorDescription || errorCode);
-    return `<!DOCTYPE html>
-<html><body style="font-family:sans-serif;text-align:center;padding:50px;">
-  <h2 style="color:#c62828;">Authentication Failed</h2>
-  <p><strong>${safeCode}</strong></p>
-  <p>${safeDescription}</p>
-  <p>You can close this window and check your terminal for details.</p>
-</body></html>`;
-}
-const HTML_TEXT_ESCAPES = {
-    '"': '&quot;',
-    '&': '&amp;',
-    "'": '&#39;',
-    '<': '&lt;',
-    '>': '&gt;',
-};
-export function escapeHtml(text) {
-    let encoded = '';
-    for (const character of text) {
-        encoded += HTML_TEXT_ESCAPES[character] ?? character;
-    }
-    return encoded;
-}
-function respondNotFound(res) {
-    res.writeHead(404, { 'Content-Type': 'text/plain' });
-    res.end('Not Found');
-}
-function respondHtml(res, status, body) {
-    res.writeHead(status, { 'Content-Type': 'text/html; charset=utf-8' });
-    res.end(body);
-}
-export function defaultCheckPortAvailable(port, host) {
-    return new Promise((resolve) => {
-        const socket = createConnection({ host, port });
-        socket.once('connect', () => {
-            socket.destroy();
-            resolve(false);
-        });
-        socket.once('error', () => {
-            socket.destroy();
-            resolve(true);
-        });
-    });
-}
-export async function findAvailablePort(options) {
-    const { host } = options;
-    const check = options.checkPortAvailable ?? defaultCheckPortAvailable;
-    if (options.port !== undefined) {
-        return (await check(options.port, host)) ? options.port : null;
-    }
-    const start = options.portStart ?? DEFAULT_PORT_START;
-    const end = options.portEnd ?? DEFAULT_PORT_END;
-    for (let port = start; port <= end; port++) {
-        // Sequential probing is intentional: stop at the first available port.
-        // eslint-disable-next-line no-await-in-loop
-        if (await check(port, host)) {
-            return port;
-        }
-    }
-    return null;
-}
-export async function createLoopbackCallbackServer(options) {
-    const host = options?.host ?? '127.0.0.1';
-    const callbackPath = options?.callbackPath ?? DEFAULT_CALLBACK_PATH;
-    const createSrv = options?.createServerImpl ?? createServer;
-    const port = await findAvailablePort({
-        checkPortAvailable: options?.checkPortAvailable,
-        host,
-        port: options?.port,
-        portEnd: options?.portEnd,
-        portStart: options?.portStart,
-    });
-    if (port === null) {
-        return null;
-    }
-    const callbackUrl = `http://localhost:${port}${callbackPath}`;
-    let resolveWait = null;
-    let settled = false;
-    const server = createSrv((req, res) => {
-        const parsed = parseCallbackResult(req, callbackPath);
-        if (!parsed) {
-            respondNotFound(res);
-            return;
-        }
-        if (parsed.ok) {
-            respondHtml(res, 200, successHtml());
-        }
-        else {
-            respondHtml(res, 200, errorHtml(parsed.errorCode ?? '', parsed.errorDescription ?? ''));
-        }
-        if (!settled && resolveWait) {
-            settled = true;
-            resolveWait(parsed);
-        }
-    });
-    await new Promise((resolve, reject) => {
-        server.once('error', reject);
-        server.listen(port, host, () => resolve());
-    });
-    return {
-        callbackUrl,
-        close() {
-            return new Promise((resolve, reject) => {
-                server.close((error) => (error ? reject(error) : resolve()));
-            });
-        },
-        port,
-        waitForCallback({ timeoutMs }) {
-            return new Promise((resolve, reject) => {
-                if (settled) {
-                    reject(new Error('Callback already received'));
-                    return;
-                }
-                const timer = setTimeout(() => {
-                    if (!settled) {
-                        settled = true;
-                        resolveWait = null;
-                        const error = new Error('Authentication timed out');
-                        error.code = 'ETIMEDOUT';
-                        reject(error);
-                    }
-                }, timeoutMs);
-                resolveWait = (result) => {
-                    clearTimeout(timer);
-                    resolve(result);
-                };
-            });
-        },
-    };
-}
-//# sourceMappingURL=loopback-callback-server.js.map
+import {modules} from './runtime.js';
+const DEFAULT_CALLBACK_PATH = modules["loopback-callback-server.js"]["DEFAULT_CALLBACK_PATH"]
+const DEFAULT_PORT_END = modules["loopback-callback-server.js"]["DEFAULT_PORT_END"]
+const DEFAULT_PORT_START = modules["loopback-callback-server.js"]["DEFAULT_PORT_START"]
+const createLoopbackCallbackServer = modules["loopback-callback-server.js"]["createLoopbackCallbackServer"]
+const defaultCheckPortAvailable = modules["loopback-callback-server.js"]["defaultCheckPortAvailable"]
+const escapeHtml = modules["loopback-callback-server.js"]["escapeHtml"]
+const findAvailablePort = modules["loopback-callback-server.js"]["findAvailablePort"]
+export {DEFAULT_CALLBACK_PATH, DEFAULT_PORT_END, DEFAULT_PORT_START, createLoopbackCallbackServer, defaultCheckPortAvailable, escapeHtml, findAvailablePort};

package/dist/lib/mcp/command-id.js

@@ -14,6 +14,7 @@ const HANDLER_TOOL_NAME_OVERRIDES = {
 };
 const HYPHENATED_TOKEN_REPLACEMENTS = [
     ['deployment_step', 'deployment-step'],
+    ['job_step', 'job-step'],
     ['data_table', 'data-table'],
     ['user_parameter', 'user-parameter'],
     ['dataset_file', 'dataset-file'],

package/dist/lib/mcp/tools.js

@@ -28,9 +28,12 @@ import { validatePipelineMutationPayload, } from '../pipeline-flags.js';
 import { buildPipelineStageConnectionCreatePayload, buildPipelineStageConnectionUpdatePayload, } from '../pipeline-stage-connection-flags.js';
 import { normalizePipeline, normalizePipelineConnections, normalizePipelineDescribe, normalizePipelines, normalizePipelinesListPage, PIPELINE_CALCULATE_BASED_ON_VALUES, PIPELINE_CONNECTION_SYNC_STATE_NEEDS_RECALCULATING, PIPELINE_PLATFORMS, pipelineConnectionsEndpoint, pipelineConnectionsFromPipelines, pipelineDescribeEndpoint, pipelineEndpoint, pipelineListEndpoint, } from '../pipeline-types.js';
 import { buildSetValues, collectSelectedKeys } from '../project-default-flags.js';
+import { validateProjectDefaultIdentifiers } from '../project-default-validation.js';
 import { PROJECT_DEFAULT_KEYS } from '../project-defaults.js';
+import { validateProjectListFilters, validateProjectMutationPayload } from '../project-flags.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 { buildPromotionManualTaskUpdatePayload, PROMOTION_MANUAL_TASK_STATUSES, promotionManualTaskEndpoint, } from '../promotion-job-steps.js';
 import { performPromotionResume, performPromotionRun, PROMOTION_OPERATIONS, PROMOTION_RUN_DEFAULT_TIMEOUT_SECONDS, } from '../promotion-run.js';
 import { normalizePromotionDetail, normalizePromotionsListPage, promotionEndpoint, promotionListEndpoint, } from '../promotion-types.js';
 import { REPOSITORY_STRING_VALIDATION_KEYS, validateNonEmptyStringFields as validateRepositoryNonEmptyStringFields, } from '../repository-flags.js';
@@ -512,6 +515,9 @@ async function pipelineStageConnectionDelete(args) {
     return { connectionId, pipelineId };
 }
 async function projectList(args = {}) {
+    const validationError = validateProjectListFilters(args);
+    if (validationError !== undefined)
+        throw new Error(validationError);
     const response = await CicdGateway.call({
         endpoint: projectsListEndpoint(args),
         method: 'GET',
@@ -705,6 +711,14 @@ function buildRepositoryMcpPayload(args) {
     }
     return payload;
 }
+function buildProjectMcpPayload(args) {
+    const payload = {};
+    for (const key of ['description', 'endDate', 'name', 'pipeline', 'shouldIndexMetadata', 'startDate', 'status']) {
+        if (args[key] !== undefined)
+            Object.assign(payload, { [key]: args[key] });
+    }
+    return payload;
+}
 function buildPipelineMcpPayload(args) {
     const payload = {};
     for (const [key, value] of Object.entries(args)) {
@@ -794,6 +808,7 @@ async function projectDefaultSet(args) {
         }
     }
     const scope = args.global ? 'global' : 'local';
+    await validateProjectDefaultIdentifiers(values, selectedKeys, scope);
     const stored = await writeDefaults(scope, values);
     return {
         defaults: selectedKeys.map((key) => ({
@@ -1039,6 +1054,45 @@ async function projectGet(args) {
     });
     return { project: normalizeProject(response) };
 }
+async function projectCreate(args) {
+    const payload = {
+        ...buildProjectMcpPayload(args),
+        name: assertRequired(args.name, 'name'),
+    };
+    const validationError = validateProjectMutationPayload(payload, true);
+    if (validationError !== undefined)
+        throw new Error(validationError);
+    const response = await CicdGateway.call({
+        body: payload,
+        endpoint: projectsListEndpoint(),
+        headers: { 'Content-Type': 'application/json' },
+        method: 'POST',
+    });
+    return { project: normalizeProject(response) };
+}
+async function projectUpdate(args) {
+    const id = assertRequired(args.id, 'id');
+    const payload = buildProjectMcpPayload(args);
+    if (Object.keys(payload).length === 0)
+        throw new Error('Must provide at least one field to update.');
+    const validationError = validateProjectMutationPayload(payload);
+    if (validationError !== undefined)
+        throw new Error(validationError);
+    const response = await CicdGateway.call({
+        body: payload,
+        endpoint: projectEndpoint(id),
+        headers: { 'Content-Type': 'application/json' },
+        method: 'PATCH',
+    });
+    return { project: normalizeProject(response) };
+}
+async function projectDelete(args) {
+    const id = assertRequired(args.id, 'id');
+    if (args.confirm !== true)
+        throw new Error('Project deletion requires confirm: true.');
+    await CicdGateway.call({ endpoint: projectEndpoint(id), method: 'DELETE' });
+    return { id };
+}
 async function promotionConflictList(args) {
     const conflicts = await withPromotionConflictErrorTranslation(() => CicdGateway.call({
         endpoint: promotionConflictsEndpoint(args.promotionId),
@@ -1071,6 +1125,21 @@ async function promotionConflictUnresolve(args) {
         method: 'POST',
     }));
 }
+async function promotionJobStepUpdate(args) {
+    const manualTask = await CicdGateway.call({
+        body: buildPromotionManualTaskUpdatePayload({
+            assigneeId: args.assigneeId,
+            assigneeName: args.assigneeName,
+            status: args.status,
+            taskComments: args.taskComments,
+            taskDescription: args.taskDescription,
+        }),
+        endpoint: promotionManualTaskEndpoint(args.promotionIdOrName, args.jobStepId),
+        headers: { 'Content-Type': 'application/json' },
+        method: 'PATCH',
+    });
+    return { manualTask };
+}
 async function metadataRefreshRun(args) {
     const sourceContext = await resolveRefreshSourceFromEnv(args.env, {
         sourceCredentialId: args.sourceCredentialId,
@@ -1186,16 +1255,20 @@ export const agentiaMcpToolHandlers = wrapMcpToolHandlers({
     pipelineStageConnectionList,
     pipelineStageConnectionUpdate,
     pipelineUpdate,
+    projectCreate,
     projectDefaultGet,
     projectDefaultSet,
     projectDefaultUnset,
+    projectDelete,
     projectGet,
     projectList,
+    projectUpdate,
     promotionConflictGet,
     promotionConflictList,
     promotionConflictResolve,
     promotionConflictUnresolve,
     promotionGet,
+    promotionJobStepUpdate,
     promotionList,
     promotionRun,
     repositoryCreate,
@@ -1401,6 +1474,19 @@ export function registerAgentiaMcpTools(server) {
         },
         title: 'Agentia Promotion Run',
     }, (args) => safelyHandleTool(() => promotionRun(args)));
+    server.registerTool('agentia_promotion_job_step_update', {
+        description: 'Update a manual task for a Copado promotion job step via the CICD gateway.',
+        inputSchema: {
+            assigneeId: z.string().optional().describe('Salesforce user ID assigned to the manual task.'),
+            assigneeName: z.string().optional().describe('Name of the user assigned to the manual task.'),
+            jobStepId: z.string().describe('Promotion job step ID.'),
+            promotionIdOrName: z.string().describe('Copado promotion ID or name.'),
+            status: z.enum(PROMOTION_MANUAL_TASK_STATUSES).optional().describe('Manual task status.'),
+            taskComments: z.string().optional().describe('Manual task comments.'),
+            taskDescription: z.string().optional().describe('Manual task description.'),
+        },
+        title: 'Agentia Promotion Job Step Update',
+    }, (args) => safelyHandleTool(() => promotionJobStepUpdate(args)));
     server.registerTool('agentia_job_list', {
         description: 'List Copado job executions via the CICD gateway.',
         inputSchema: {
@@ -1589,8 +1675,13 @@ export function registerAgentiaMcpTools(server) {
     server.registerTool('agentia_project_list', {
         description: 'List Copado projects via the CICD gateway.',
         inputSchema: {
+            endDateFrom: z.string().optional().describe('Filter by end date (inclusive, YYYY-MM-DD).'),
+            endDateTo: z.string().optional().describe('Filter by end date (inclusive, YYYY-MM-DD).'),
             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).'),
+            startDateFrom: z.string().optional().describe('Filter by start date (inclusive, YYYY-MM-DD).'),
+            startDateTo: z.string().optional().describe('Filter by start date (inclusive, YYYY-MM-DD).'),
+            status: z.string().optional().describe('Filter by project status.'),
             ...listPaginationZodFields,
         },
         title: 'Agentia Project List',
@@ -1792,6 +1883,41 @@ export function registerAgentiaMcpTools(server) {
         inputSchema: { id: z.string().describe('Copado project ID.') },
         title: 'Agentia Project Get',
     }, (args) => safelyHandleTool(() => projectGet(args)));
+    server.registerTool('agentia_project_create', {
+        description: 'Create a Copado project via the CICD gateway.',
+        inputSchema: {
+            description: z.string().optional(),
+            endDate: z.string().optional(),
+            name: z.string(),
+            pipeline: z.string().optional(),
+            shouldIndexMetadata: z.boolean().optional(),
+            startDate: z.string().optional(),
+            status: z.string().optional(),
+        },
+        title: 'Agentia Project Create',
+    }, (args) => safelyHandleTool(() => projectCreate(args)));
+    server.registerTool('agentia_project_update', {
+        description: 'Update a Copado project by ID via the CICD gateway.',
+        inputSchema: {
+            description: z.string().optional(),
+            endDate: z.string().optional(),
+            id: z.string(),
+            name: z.string().optional(),
+            pipeline: z.string().optional(),
+            shouldIndexMetadata: z.boolean().optional(),
+            startDate: z.string().optional(),
+            status: z.string().optional(),
+        },
+        title: 'Agentia Project Update',
+    }, (args) => safelyHandleTool(() => projectUpdate(args)));
+    server.registerTool('agentia_project_delete', {
+        description: 'Delete a Copado project by ID via the CICD gateway. Requires confirm: true.',
+        inputSchema: {
+            confirm: z.literal(true).describe('Explicitly confirm project deletion.'),
+            id: z.string().describe('Copado project ID.'),
+        },
+        title: 'Agentia Project Delete',
+    }, (args) => safelyHandleTool(() => projectDelete(args)));
     server.registerTool('agentia_repository_list', {
         description: 'List Copado Git repositories via the CICD gateway.',
         inputSchema: {

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

@@ -7,6 +7,7 @@ import { readDefaults, resolveDefaults, writeLastWorkSelection, } from '../defau
 import { checkoutFeatureBranch, fetchOriginBranch, fetchOriginBranchIfExists, listPendingChanges, } from '../git-worktree.js';
 import { listPaginationZodFields, mcpPaginatedListPayload } from '../list-pagination.js';
 import { LocalQualityGatesError, runLocalQualityGates } from '../local-quality-gates.js';
+import { FULL_METADATA_SELECTION_TYPES_HELP } from '../nested-metadata-registry.js';
 import { PROJECT_DEFAULT_KEYS } from '../project-defaults.js';
 import { performPromotionRun, PROMOTION_RUN_DEFAULT_TIMEOUT_SECONDS, resolvePromotionIdForWorkItem, } from '../promotion-run.js';
 import { runWorkTestLocalQualityGates } from '../stock-quality-gates.js';
@@ -21,6 +22,7 @@ import { reportLocalQualityGatesFailure, reportLocalQualityGatesOutcome, } from
 import { capturingWorkPushHooks, performWorkPush, resolveActiveFeatureWorkItem, resolveWorkPushContext, resolveWorkPushNeed, } from '../work-push.js';
 import { performWorkSetNone } from '../work-set-none.js';
 import { isWorkSetWarning, parseWorkSetSelection, toWorkSetWarningResult } from '../work-set-selection.js';
+import { waitForPendingCommitJobIfNeeded } from '../work-submit-wait.js';
 import { applySourceCredentialEnvironmentRule, featureBranchName, normalizeUserStoriesListPage, workCreateEndpoint, workDoneEndpoint, workEndpoint, workListEndpoint, workSetEndpoint, workSubmitEndpoint, } from '../work-types.js';
 import { safelyHandleTool } from './result.js';
 const CLOUD_ONLY_COMMIT_ARGS = [
@@ -274,6 +276,10 @@ async function promoteWorkItemDone(args = {}) {
                 skipNestedMetadataDetection: args.skipNestedMetadataDetection,
             });
         }
+        await waitForPendingCommitJobIfNeeded({
+            hooks: capturingWorkPushHooks,
+            workItem,
+        });
         const doneBody = { workItem };
         const done = await capturingWorkPushHooks.withSpinner('Marking work item done', () => CicdGateway.call({
             body: doneBody,
@@ -335,6 +341,10 @@ async function workSubmit(args = {}) {
                 skipNestedMetadataDetection: args.skipNestedMetadataDetection,
             });
         }
+        await waitForPendingCommitJobIfNeeded({
+            hooks: capturingWorkPushHooks,
+            workItem,
+        });
         const submit = await capturingWorkPushHooks.withSpinner('Submitting work item', () => CicdGateway.call({
             body: attachCapturedOutputLogs({ workItem }),
             endpoint: workSubmitEndpoint(),
@@ -653,7 +663,7 @@ export function registerAgentiaMcpWorkTools(server) {
         fullMetadata: z
             .string()
             .optional()
-            .describe('Comma-separated type-prefixed metadata such as Profile:Sales_User,PermissionSet:Sales_Onboarding, added to lastFullMetadataSelected for this publish and sent as headless push fullMetadata corrections. The named metadata is committed as a complete file and is never decomposed into nested metadata. Not stored.'),
+            .describe(`Comma-separated Type:Name metadata such as Profile:Sales_User,PermissionSet:Sales_Onboarding. Allowed types: ${FULL_METADATA_SELECTION_TYPES_HELP}. Added for this publish and sent as headless push fullMetadata corrections. The named metadata is committed as a complete file and is never decomposed into nested metadata. Not stored.`),
         permissions: z
             .string()
             .optional()
@@ -742,7 +752,7 @@ export function registerAgentiaMcpWorkTools(server) {
         title: 'Agentia Work Promote',
     }, (args) => safelyHandleTool(() => workPromote(args || {})));
     server.registerTool('agentia_work_submit', {
-        description: 'Submit the current feature/US-XXXX work item for pipeline quality gates and validation. Runs project-root .agentia_quality_gates.sh (macOS/Linux) or .agentia_quality_gates.cmd (Windows) when present, then fetches origin/<lastBaseBranch> and counts origin/<lastBaseBranch>..HEAD before checking origin. Pushes and registers commits when that feature-only range is non-empty and the branch is ahead of origin. With done=true or deploy=true, matches Copado UI Submit when promoting (headless work/done). Prefer this over agentia_work_done.',
+        description: 'Submit the current feature/US-XXXX work item for pipeline quality gates and validation. Runs project-root .agentia_quality_gates.sh (macOS/Linux) or .agentia_quality_gates.cmd (Windows) when present, then fetches origin/<lastBaseBranch> and counts origin/<lastBaseBranch>..HEAD before checking origin. Pushes and registers commits when that feature-only range is non-empty and the branch is ahead of origin. When the last pending related job template name contains Commit, waits up to 5 minutes for that job before calling headless work/submit. With done=true or deploy=true, matches Copado UI Submit when promoting (headless work/done) and uses the same commit wait. Prefer this over agentia_work_done.',
         inputSchema: {
             apexTestClasses: z
                 .string()