@copado/agentia-cli 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/commands/auth/get.js

@@ -1,14 +1,13 @@
-import { Flags } from '@oclif/core';
+import { Flags, ux } from '@oclif/core';
 import { existsSync } from 'node:fs';
 import { AgentiaCommand } from '../../lib/agentia-command.js';
-import { getCrtAuthStatus } from '../../lib/auth-config.js';
+import { getAiAuthStatus, getCicdAuthStatus, getCrtAuthStatus } from '../../lib/auth-config.js';
 import { readAuthProfile } from '../../lib/auth-profile.js';
-import { ALL_CREDENTIAL_TYPES, credentialLabel, getAiDomain, getAiGatewayUrl, getAiOrgId, getAiWorkspaceId, getCicdBaseUrl, getCredential, getCredentialForKey, maskSecret, } from '../../lib/credential-store.js';
+import { formatAiStatusLine, formatCicdStatusLine, formatCrtStatusLine } from '../../lib/auth-status-format.js';
+import { ALL_CREDENTIAL_TYPES, credentialLabel, } from '../../lib/credential-store.js';
 import { getDefaultsStorePaths } from '../../lib/defaults-store.js';
-import { normalizeLocalGatewayBaseUrl, readLocalGatewayConfig } from '../../lib/local-gateway-config.js';
-import { formatTestingConfigurationFieldList, } from '../../lib/testing-config.js';
 export default class AuthGet extends AgentiaCommand {
-    static description = 'Show stored authentication credentials from the system keychain and the local config file locations';
+    static description = 'Show stored authentication credentials and their configured endpoints and scopes';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --ai',
@@ -42,55 +41,32 @@ export default class AuthGet extends AgentiaCommand {
         }
         const selectedTypes = types.length > 0 ? types : ALL_CREDENTIAL_TYPES;
         const credentials = selectedTypes.map((type) => this.buildCredentialResult(type));
+        this.display(() => {
+            for (const type of ['cicd', 'ai', 'crt']) {
+                if (!selectedTypes.includes(type))
+                    continue;
+                const scopes = this.hasLocalAuthentication(type) ? ['global', 'local'] : [undefined];
+                this.log('');
+                this.log(ux.colorize('cyan', `${type.toUpperCase()} authentication`));
+                for (const [index, scope] of scopes.entries()) {
+                    if (index > 0)
+                        this.log('');
+                    this.log(this.formatCredentialLine(this.buildCredentialResult(type, scope)));
+                }
+            }
+        });
         const configFiles = this.buildConfigFileResults();
-        for (const credential of credentials) {
-            this.log(this.formatCredentialLine(credential));
-        }
-        for (const configFile of configFiles) {
-            this.log(this.formatConfigFileLine(configFile));
-        }
         return { configFiles, credentials };
     }
-    buildCicdCredentialResult() {
-        const localConfig = readLocalGatewayConfig();
-        const label = credentialLabel('cicd');
-        const localProfile = readAuthProfile('local');
-        const profile = localProfile?.cicd ?? readAuthProfile('global')?.cicd;
-        if (localConfig.enabled) {
-            const apiKey = localConfig.apiKey || (localProfile?.cicd === undefined ? getCredential('cicd') : getCredentialForKey('cicd', localProfile.keychainId));
-            if (apiKey === null || apiKey.trim().length === 0) {
-                return {
-                    baseUrl: normalizeLocalGatewayBaseUrl(localConfig.url),
-                    label,
-                    local: true,
-                    set: false,
-                    type: 'cicd',
-                };
-            }
-            return {
-                baseUrl: normalizeLocalGatewayBaseUrl(localConfig.url),
-                label,
-                local: true,
-                masked: maskSecret(apiKey),
-                set: true,
-                source: 'local',
-                type: 'cicd',
-            };
-        }
-        const credential = localProfile?.cicd === undefined ? getCredential('cicd') : getCredentialForKey('cicd', localProfile.keychainId);
-        if (credential === null) {
-            return {
-                label,
-                set: false,
-                type: 'cicd',
-            };
-        }
+    buildCicdCredentialResult(scope) {
+        const status = getCicdAuthStatus(scope);
         return {
-            baseUrl: profile?.baseUrl ?? getCicdBaseUrl(),
-            label,
-            masked: maskSecret(credential),
-            set: true,
-            source: localProfile?.cicd === undefined ? 'global' : 'local',
+            baseUrl: status.baseUrl,
+            label: credentialLabel('cicd'),
+            local: status.local,
+            masked: status.masked,
+            set: status.set,
+            source: status.source,
             type: 'cicd',
         };
     }
@@ -101,38 +77,25 @@ export default class AuthGet extends AgentiaCommand {
             { exists: existsSync(userPath), label: 'User config', path: userPath, scope: 'user' },
         ];
     }
-    buildCredentialResult(type) {
+    buildCredentialResult(type, scope) {
         if (type === 'cicd') {
-            return this.buildCicdCredentialResult();
+            return this.buildCicdCredentialResult(scope);
         }
         if (type === 'ai') {
-            const local = readAuthProfile('local');
-            const metadata = local?.ai ?? readAuthProfile('global')?.ai;
-            const credential = local?.ai === undefined ? getCredential(type) : getCredentialForKey(type, local.keychainId);
-            if (credential === null) {
-                return {
-                    domain: metadata?.domain ?? getAiDomain(),
-                    gatewayUrl: metadata?.gatewayUrl ?? getAiGatewayUrl(),
-                    label: credentialLabel(type),
-                    orgId: metadata?.orgId ?? getAiOrgId(),
-                    set: false,
-                    type,
-                    workspaceId: metadata?.workspaceId ?? getAiWorkspaceId(),
-                };
-            }
+            const status = getAiAuthStatus(scope);
             return {
-                domain: metadata?.domain ?? getAiDomain(),
-                gatewayUrl: metadata?.gatewayUrl ?? getAiGatewayUrl(),
+                domain: status.domain,
+                gatewayUrl: status.gatewayUrl,
                 label: credentialLabel(type),
-                masked: maskSecret(credential),
-                orgId: metadata?.orgId ?? getAiOrgId(),
-                set: true,
-                source: local?.ai === undefined ? 'global' : 'local',
+                masked: status.masked,
+                orgId: status.orgId,
+                set: status.set,
+                source: status.source,
                 type,
-                workspaceId: metadata?.workspaceId ?? getAiWorkspaceId(),
+                workspaceId: status.workspaceId,
             };
         }
-        const status = getCrtAuthStatus();
+        const status = getCrtAuthStatus(scope);
         return {
             domain: status.domain,
             issues: status.issues,
@@ -146,74 +109,20 @@ export default class AuthGet extends AgentiaCommand {
             type,
         };
     }
-    formatConfigFileLine(configFile) {
-        return `${configFile.label}: ${configFile.path} (${configFile.exists ? 'found' : 'not found'})`;
-    }
     formatCredentialLine(credential) {
-        if (credential.type === 'crt') {
-            return this.formatCrtCredentialLine(credential);
-        }
-        if (!credential.set) {
-            if (credential.type === 'cicd' && credential.local && credential.baseUrl) {
-                return `${credential.label}: not set (endpoint: ${credential.baseUrl}, local)`;
-            }
-            if (credential.type === 'ai') {
-                const domain = credential.domain === null || credential.domain === undefined ? 'not set' : credential.domain;
-                const orgId = credential.orgId === null || credential.orgId === undefined ? 'not set' : credential.orgId;
-                const workspaceId = credential.workspaceId === null || credential.workspaceId === undefined ? 'not set' : credential.workspaceId;
-                const gatewayUrl = credential.gatewayUrl === null || credential.gatewayUrl === undefined ? 'derived' : credential.gatewayUrl;
-                return `${credential.label}: not set (domain: ${domain}, org: ${orgId}, workspace: ${workspaceId}, gateway: ${gatewayUrl})`;
-            }
-            return `${credential.label}: not set`;
-        }
         if (credential.type === 'cicd') {
-            const endpointLabel = credential.baseUrl === null || credential.baseUrl === undefined ? 'not set' : credential.baseUrl;
-            const localSuffix = credential.local ? ', local' : '';
-            const sourceSuffix = credential.source === undefined ? '' : `, source: ${credential.source}`;
-            return `${credential.label}: ${credential.masked} (endpoint: ${endpointLabel}${localSuffix}${sourceSuffix})`;
+            return formatCicdStatusLine(credential);
         }
         if (credential.type === 'ai') {
-            const domain = credential.domain === null || credential.domain === undefined ? 'not set' : credential.domain;
-            const orgId = credential.orgId === null || credential.orgId === undefined ? 'not set' : credential.orgId;
-            const workspaceId = credential.workspaceId === null || credential.workspaceId === undefined ? 'not set' : credential.workspaceId;
-            const gatewayUrl = credential.gatewayUrl === null || credential.gatewayUrl === undefined ? 'derived' : credential.gatewayUrl;
-            const sourceSuffix = credential.source === undefined ? '' : `, source: ${credential.source}`;
-            return `${credential.label}: ${credential.masked} (domain: ${domain}, org: ${orgId}, workspace: ${workspaceId}, gateway: ${gatewayUrl}${sourceSuffix})`;
+            return formatAiStatusLine(credential);
         }
-        return `${credential.label}: ${credential.masked}`;
-    }
-    formatCrtCredentialLine(credential) {
-        const domain = credential.domain === null || credential.domain === undefined ? 'not set' : credential.domain;
-        const orgId = credential.orgId === null || credential.orgId === undefined ? 'not set' : credential.orgId;
-        const ready = credential.ready ?? credential.set;
-        if (!ready) {
-            const pak = credential.masked ?? 'not set';
-            const details = this.formatCrtIssueDetails(credential);
-            return `${credential.label}: incomplete (PAK: ${pak}, domain: ${domain}, org: ${orgId}${details})`;
+        if (credential.type === 'crt') {
+            return formatCrtStatusLine(credential);
         }
-        const sourceSuffix = credential.source === undefined ? '' : `, source: ${credential.source}`;
-        return `${credential.label}: ${credential.masked} (domain: ${domain}, org: ${orgId}${sourceSuffix})`;
+        return '';
     }
-    formatCrtIssueDetails(credential) {
-        const issues = credential.issues ?? [];
-        const missing = issues.filter((issue) => issue.kind === 'missing').map((issue) => issue.field);
-        const invalid = issues.filter((issue) => issue.kind === 'invalid');
-        const details = [];
-        if (missing.length > 0) {
-            details.push(`missing: ${formatTestingConfigurationFieldList(missing)}`);
-        }
-        if (invalid.length > 0) {
-            details.push(`invalid: ${invalid
-                .map((issue) => {
-                const label = formatTestingConfigurationFieldList([issue.field]);
-                return issue.message === undefined ? label : `${label} (${issue.message})`;
-            })
-                .join(', ')}`);
-        }
-        if (details.length === 0 && credential.missing !== undefined && credential.missing.length > 0) {
-            details.push(`missing: ${formatTestingConfigurationFieldList(credential.missing)}`);
-        }
-        return details.length === 0 ? '' : `; ${details.join('; ')}`;
+    hasLocalAuthentication(type) {
+        return readAuthProfile('local')?.[type] !== undefined;
     }
 }
 //# sourceMappingURL=get.js.map

package/dist/commands/auth/set.js

@@ -6,13 +6,13 @@ export default class AuthSet extends AgentiaCommand {
     static description = 'Store authentication credentials securely in the system keychain';
     static examples = [
         '<%= config.bin %> <%= command.id %> --ai <pak> --ai-domain robotic.copado.com --ai-org 42888',
+        '<%= config.bin %> <%= command.id %> --ai <pak> --ai-org 42888',
         '<%= config.bin %> <%= command.id %> --ai <pak> --ai-domain robotic.copado.com --ai-org 42888 --ai-workspace 42d0b908-37b7-4565-9ec9-86eda40c9782',
         '<%= config.bin %> <%= command.id %> --ai <pak> --ai-gateway-url http://localhost:8080/organizations/42888',
         '<%= config.bin %> <%= command.id %> --ai-workspace 42d0b908-37b7-4565-9ec9-86eda40c9782',
         '<%= config.bin %> <%= command.id %> --cicd <copado-api-key> --region na',
         '<%= config.bin %> <%= command.id %> --cicd <copado-api-key> --custom-url https://dev.api.copado.com',
         '<%= config.bin %> <%= command.id %> --cicd <copado-api-key>',
-        '<%= config.bin %> <%= command.id %> --crt <pak>',
         '<%= config.bin %> <%= command.id %> --crt <pak> --crt-org <crt-org-id>',
         '<%= config.bin %> <%= command.id %> --crt <pak> --crt-domain robotic.copado.com --crt-org <crt-org-id>',
         '<%= config.bin %> <%= command.id %> --cicd <copado-api-key> --region na --crt <pak>',
@@ -21,7 +21,7 @@ export default class AuthSet extends AgentiaCommand {
     static flags = {
         ai: Flags.string({ description: 'PAK for Copado AI authentication' }),
         'ai-domain': Flags.string({
-            description: 'Copado AI domain hostname used to derive the gateway URL, for example robotic.copado.com',
+            description: 'Optional Copado AI domain hostname; omit to auto-discover from the PAK and organization ID',
         }),
         'ai-gateway-url': Flags.string({
             description: 'Full Copado AI gateway base URL used instead of deriving from domain and organization; HTTP is allowed for local testing',
@@ -35,7 +35,7 @@ export default class AuthSet extends AgentiaCommand {
         cicd: Flags.string({
             description: 'Copado API key for CICD authentication',
         }),
-        crt: Flags.string({ description: 'PAK for CRT authentication' }),
+        crt: Flags.string({ description: 'PAK for CRT authentication (requires --crt-org)' }),
         'crt-domain': Flags.string({
             description: 'CRT domain hostname for robotic testing commands',
         }),

package/dist/commands/cicd/cloud/commit.js

@@ -0,0 +1,252 @@
+import { Args, Flags } from '@oclif/core';
+import { readFileSync } from 'node:fs';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { resolveWorkItemId, WorkActiveResolutionError } from '../../../lib/work-active.js';
+import { buildWorkCommitRequest, formatWorkCommitResult, normalizeWorkCommitInput, performWorkCommit, resolveWorkCommitPlatformExperience, WORK_COMMIT_ACTIONS, WORK_COMMIT_DEFAULT_TIMEOUT_SECONDS, WORK_COMMIT_METADATA_CATEGORY_HELP, WorkCommitJobFailedError, WorkCommitTimeoutError, WorkCommitValidationError, } from '../../../lib/work-commit.js';
+function readStdin() {
+    if (process.stdin.isTTY) {
+        throw new WorkCommitValidationError('Cannot read --stdin from an interactive terminal. Pipe JSON input or use --file <path>.');
+    }
+    return new Promise((resolve, reject) => {
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on('end', () => resolve(data));
+        process.stdin.on('error', reject);
+    });
+}
+function readJsonFile(path) {
+    try {
+        return readFileSync(path, 'utf8');
+    }
+    catch (error) {
+        throw new WorkCommitValidationError(`Cannot read JSON request file ${path}: ${error.message}`);
+    }
+}
+function parseJsonValue(raw, label) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        throw new WorkCommitValidationError(`${label} must contain valid JSON: ${error.message}`);
+    }
+}
+function hasSimpleChangeFlags(flags) {
+    return (flags.action !== undefined ||
+        flags['metadata-category'] !== undefined ||
+        flags['metadata-message'] !== undefined ||
+        flags['metadata-name'] !== undefined ||
+        flags['metadata-raw-json'] !== undefined ||
+        flags['metadata-type'] !== undefined ||
+        flags.selection !== undefined);
+}
+function simpleInputFromFlags(flags) {
+    const rawJson = flags['metadata-raw-json'] === undefined
+        ? undefined
+        : parseJsonValue(flags['metadata-raw-json'], '--metadata-raw-json');
+    return {
+        baseBranch: flags['base-branch'] ?? null,
+        changes: [
+            {
+                ...(flags.action === undefined ? {} : { a: flags.action }),
+                ...(flags['metadata-category'] === undefined ? {} : { c: flags['metadata-category'] }),
+                ...(rawJson === undefined ? {} : { j: rawJson }),
+                ...(flags['metadata-message'] === undefined ? {} : { m: flags['metadata-message'] }),
+                n: flags['metadata-name'],
+                ...(flags.selection === undefined ? {} : { selections: flags.selection }),
+                t: flags['metadata-type'],
+            },
+        ],
+        commitId: flags['commit-id'],
+        executeCommit: flags['execute-commit'],
+        message: flags.message,
+        recreateFeatureBranch: flags['recreate-feature-branch'],
+    };
+}
+async function jsonInputFromFlags(flags) {
+    const raw = flags.file === undefined ? await readStdin() : readJsonFile(flags.file);
+    const input = normalizeWorkCommitInput(parseJsonValue(raw, flags.file === undefined ? 'stdin' : flags.file));
+    return {
+        ...input,
+        ...(flags['base-branch'] === undefined ? {} : { baseBranch: flags['base-branch'] }),
+        ...(flags['commit-id'] === undefined ? {} : { commitId: flags['commit-id'] }),
+        ...(flags['execute-commit'] ? {} : { executeCommit: false }),
+        ...(flags.message === undefined ? {} : { message: flags.message }),
+        ...(flags['recreate-feature-branch'] ? { recreateFeatureBranch: true } : {}),
+    };
+}
+async function commitInputFromFlags(flags) {
+    const jsonModes = [flags.file !== undefined, flags.stdin].filter(Boolean).length;
+    const simpleMode = hasSimpleChangeFlags(flags);
+    if (jsonModes > 1) {
+        throw new WorkCommitValidationError('Use only one JSON input mode: --file or --stdin.');
+    }
+    if (jsonModes > 0 && simpleMode) {
+        throw new WorkCommitValidationError('Use JSON input or simple metadata flags, not both.');
+    }
+    if (jsonModes > 0) {
+        return jsonInputFromFlags(flags);
+    }
+    if (!simpleMode) {
+        throw new WorkCommitValidationError('Requires simple metadata flags such as --metadata-name and --metadata-type, or JSON input with --file/--stdin.');
+    }
+    return simpleInputFromFlags(flags);
+}
+export default class CloudCommit extends AgentiaCommand {
+    static args = {
+        id: Args.string({
+            description: 'User story ID (defaults to the active work item from `work set`)',
+            required: false,
+        }),
+    };
+    static description = [
+        'Create a Copado cloud metadata commit for a user story.',
+        'Preflights the story, submits POST /release/commit, and polls the job monitor by default.',
+        'For local Git work, use git add/commit then `cicd work publish`. Permission and full-metadata selections belong on `cicd work publish`.',
+    ].join(' ');
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --message "Commit AccountService" --metadata-name AccountService --metadata-type ApexClass --metadata-category SFDX --action Add',
+        '<%= config.bin %> <%= command.id %> a07XXXXXXXXXXXXXXX --message "Update Aura files" --metadata-name accountEditor --metadata-type AuraDefinitionBundle --metadata-category SFDX --action SelectiveCommit --selection accountEditor/accountEditor.cmp --selection accountEditor/accountEditorController.js',
+        '<%= config.bin %> <%= command.id %> --file commit-request.json  # {"message":"Commit AccountService","changes":[{"a":"Add","c":"SFDX","n":"AccountService","t":"ApexClass"}]}',
+        'cat commit-request.json | <%= config.bin %> <%= command.id %> --stdin --json',
+    ];
+    static flags = {
+        action: Flags.string({
+            description: 'Metadata action for simple flag input. Defaults to Add.',
+            options: [...WORK_COMMIT_ACTIONS],
+        }),
+        'base-branch': Flags.string({
+            description: 'Optional base branch to include in the commit request.',
+        }),
+        cloud: Flags.boolean({
+            default: false,
+            description: 'Ignored. Cloud is implied by cicd cloud commit.',
+            hidden: true,
+        }),
+        'commit-id': Flags.string({
+            description: 'Existing local Git commit identifier to register when --no-execute-commit is used.',
+        }),
+        'execute-commit': Flags.boolean({
+            allowNo: true,
+            default: true,
+            description: 'Execute the Copado commit job. Use --no-execute-commit only with --commit-id.',
+        }),
+        file: Flags.string({
+            char: 'f',
+            description: 'Path to a JSON commit request body.',
+        }),
+        message: Flags.string({
+            char: 'm',
+            description: 'Commit message. Required unless provided by JSON input.',
+        }),
+        'metadata-category': Flags.string({
+            description: WORK_COMMIT_METADATA_CATEGORY_HELP,
+        }),
+        'metadata-message': Flags.string({
+            description: 'Optional per-change message for simple flag input.',
+        }),
+        'metadata-name': Flags.string({
+            description: 'Metadata full name for simple flag input.',
+        }),
+        'metadata-raw-json': Flags.string({
+            description: 'Optional raw metadata JSON value for simple flag input.',
+        }),
+        'metadata-type': Flags.string({
+            description: 'Metadata type for simple flag input, for example ApexClass.',
+        }),
+        'recreate-feature-branch': Flags.boolean({
+            default: false,
+            description: 'Ask Copado to recreate the feature branch before committing.',
+        }),
+        selection: Flags.string({
+            description: 'Selected file inside a bundle for SelectiveCommit. Can be provided multiple times.',
+            multiple: true,
+        }),
+        stdin: Flags.boolean({
+            default: false,
+            description: 'Read a JSON commit request body from stdin.',
+        }),
+        wait: Flags.boolean({
+            allowNo: true,
+            default: true,
+            description: 'Poll the commit job to a terminal status when a jobExecution Id is returned.',
+        }),
+        'wait-timeout': Flags.integer({
+            default: WORK_COMMIT_DEFAULT_TIMEOUT_SECONDS,
+            description: 'Maximum seconds to wait for the commit job.',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(CloudCommit);
+        const commitFlags = flags;
+        if (!Number.isInteger(commitFlags['wait-timeout']) || commitFlags['wait-timeout'] <= 0) {
+            this.error('--wait-timeout must be a positive integer.', { exit: 2 });
+        }
+        let workItemId;
+        try {
+            workItemId = await resolveWorkItemId(args.id);
+        }
+        catch (error) {
+            if (error instanceof WorkActiveResolutionError) {
+                this.error(error.message, {
+                    exit: 1,
+                    suggestions: [`${this.config.bin} cicd work set <id>`],
+                });
+            }
+            throw error;
+        }
+        try {
+            const input = await commitInputFromFlags(commitFlags);
+            const request = buildWorkCommitRequest(input, { message: commitFlags.message, userStoryId: workItemId });
+            const initialPlatformExperience = await resolveWorkCommitPlatformExperience({
+                userStoryId: workItemId,
+            });
+            const result = await performWorkCommit({
+                hooks: {
+                    log: (message) => this.display(() => this.log(message)),
+                    withSpinner: (message, action) => this.withSpinner(message, action),
+                },
+                initialPlatformExperience,
+                request,
+                timeoutSeconds: commitFlags['wait-timeout'],
+                wait: commitFlags.wait,
+            });
+            this.display(() => {
+                this.log(formatWorkCommitResult(result));
+            });
+            return result;
+        }
+        catch (error) {
+            if (error instanceof WorkCommitValidationError) {
+                this.error(error.message, { exit: 2 });
+            }
+            if (error instanceof WorkCommitJobFailedError || error instanceof WorkCommitTimeoutError) {
+                this.display(() => {
+                    if (error.result !== undefined) {
+                        this.log(formatWorkCommitResult(error.result));
+                    }
+                });
+                error.oclif = { exit: 1 };
+                throw error;
+            }
+            throw error;
+        }
+    }
+    toErrorJson(err) {
+        const base = super.toErrorJson(err);
+        if (err instanceof WorkCommitJobFailedError || err instanceof WorkCommitTimeoutError) {
+            return {
+                ...base,
+                error: {
+                    ...(base.error && typeof base.error === 'object' ? base.error : {}),
+                    ...(err.jobMonitor === undefined ? {} : { jobMonitor: err.jobMonitor }),
+                    ...(err.result === undefined ? {} : { result: err.result }),
+                },
+            };
+        }
+        return base;
+    }
+}
+//# sourceMappingURL=commit.js.map

package/dist/commands/cicd/cloud/promote.js

@@ -0,0 +1,139 @@
+import { confirm } from '@inquirer/prompts';
+import { Args, Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { formatPromotionRunResult, isPromotionRunExecutionError, parseIgnoredMetadataJson, performPromotionRun, PROMOTION_RUN_DEFAULT_TIMEOUT_SECONDS, promotionRunErrorJson, PromotionRunValidationError, resolvePromotionIdForWorkItem, } from '../../../lib/promotion-run.js';
+import { resolveWorkItemId, WorkActiveResolutionError } from '../../../lib/work-active.js';
+export default class CloudPromote extends AgentiaCommand {
+    static args = {
+        id: Args.string({
+            description: 'User Story ID (defaults to the active work item from `work set`)',
+            required: false,
+        }),
+    };
+    static description = [
+        'Promote the explicit or active User Story through its Copado Promotion.',
+        'Selects promote-only unless --deploy is passed.',
+    ].join(' ');
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> a07XXXXXXXXXXXXXXX --promotion-id a0BXXXXXXXXXXXXXXX',
+        '<%= config.bin %> <%= command.id %> --deploy --json',
+    ];
+    static flags = {
+        cloud: Flags.boolean({
+            default: false,
+            description: 'Ignored. Cloud is implied by cicd cloud promote.',
+            hidden: true,
+        }),
+        deploy: Flags.boolean({
+            default: false,
+            description: 'Use merge_and_deploy instead of promote-only merge.',
+        }),
+        'deployment-step-id': Flags.string({
+            description: 'Ordered deployment-step Salesforce ID. Can be provided multiple times with --deploy.',
+            multiple: true,
+        }),
+        'ignored-metadata-json': Flags.string({
+            description: 'JSON array to persist through ignored-metadata before starting the promotion.',
+        }),
+        'promotion-id': Flags.string({
+            description: 'Explicit 18-character Promotion ID when the User Story belongs to multiple promotions.',
+        }),
+        'recreate-promotion-branch': Flags.boolean({
+            description: 'Recreate the promotion branch before execution. Requires confirmation or --yes.',
+        }),
+        wait: Flags.boolean({
+            allowNo: true,
+            default: true,
+            description: 'Poll promotion and deployment executions to terminal status.',
+        }),
+        'wait-timeout': Flags.integer({
+            default: PROMOTION_RUN_DEFAULT_TIMEOUT_SECONDS,
+            description: 'Maximum total seconds to wait for promotion and deployment executions.',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            default: false,
+            description: 'Confirm promotion branch recreation without prompting.',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(CloudPromote);
+        const promoteFlags = flags;
+        if (!Number.isInteger(promoteFlags['wait-timeout']) || promoteFlags['wait-timeout'] <= 0) {
+            this.error('--wait-timeout must be a positive integer.', { exit: 2 });
+        }
+        if (!promoteFlags.deploy && promoteFlags['deployment-step-id'] !== undefined) {
+            this.error('--deployment-step-id requires --deploy.', { exit: 2 });
+        }
+        let workItemId;
+        try {
+            workItemId = await resolveWorkItemId(args.id);
+        }
+        catch (error) {
+            if (error instanceof WorkActiveResolutionError) {
+                this.error(error.message, {
+                    exit: 1,
+                    suggestions: [`${this.config.bin} cicd work set <id>`],
+                });
+            }
+            throw error;
+        }
+        try {
+            const promotionId = await this.withSpinner('Resolving User Story promotion', () => resolvePromotionIdForWorkItem(workItemId, promoteFlags['promotion-id']));
+            if (promoteFlags['recreate-promotion-branch'] === true && !promoteFlags.yes) {
+                if (this.jsonEnabled() || !process.stdin.isTTY) {
+                    this.error('Promotion branch recreation requires confirmation. Pass --yes for headless or JSON execution.', {
+                        exit: 2,
+                    });
+                }
+                const confirmed = await confirm({
+                    default: false,
+                    message: `Recreate the promotion branch for ${promotionId}? Existing promotion branch changes may be replaced.`,
+                });
+                if (!confirmed) {
+                    this.error('Promotion canceled.', { exit: 1 });
+                }
+            }
+            const result = await performPromotionRun({
+                deploymentStepIds: promoteFlags['deployment-step-id'],
+                hooks: {
+                    log: (message) => this.display(() => this.log(message)),
+                    withSpinner: (message, action) => this.withSpinner(message, action),
+                },
+                ignoredMetadata: parseIgnoredMetadataJson(promoteFlags['ignored-metadata-json']),
+                operation: promoteFlags.deploy ? 'merge_and_deploy' : 'merge',
+                promotionId,
+                recreatePromotionBranch: promoteFlags['recreate-promotion-branch'],
+                timeoutSeconds: promoteFlags['wait-timeout'],
+                wait: promoteFlags.wait,
+            });
+            const workResult = { ...result, workItemId };
+            this.display(() => {
+                this.log(`User Story: ${workItemId}`);
+                this.log(formatPromotionRunResult(result));
+            });
+            return workResult;
+        }
+        catch (error) {
+            if (error instanceof PromotionRunValidationError) {
+                this.error(error.message, { exit: 2 });
+            }
+            if (isPromotionRunExecutionError(error)) {
+                this.display(() => {
+                    if (error.result !== undefined) {
+                        this.log(`User Story: ${workItemId}`);
+                        this.log(formatPromotionRunResult(error.result));
+                    }
+                });
+                error.oclif = { exit: 1 };
+            }
+            throw error;
+        }
+    }
+    toErrorJson(err) {
+        const base = super.toErrorJson(err);
+        return promotionRunErrorJson(base, err);
+    }
+}
+//# sourceMappingURL=promote.js.map