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

package/dist/commands/adv/auth/status.js

@@ -8,6 +8,7 @@ export default class AdvAuthStatus extends AgentiaCommand {
         '<%= config.bin %> <%= command.id %> --json',
     ];
     async run() {
+        await this.parse(AdvAuthStatus);
         const result = await this.withSpinner('Checking Pipelines Advanced authentication', () => getAdvAuthStatus());
         this.display(() => {
             this.log(formatAdvRecord(result));

package/dist/commands/adv/component/add.js

@@ -29,6 +29,9 @@ export default class AdvComponentAdd extends AgentiaCommand {
     };
     async run() {
         const { args, flags } = await this.parse(AdvComponentAdd);
+        if (flags.component === undefined && flags.file === undefined && flags['json-file'] === undefined) {
+            this.error('Provide one component input: --component, --file, or --json-file.', { exit: 2 });
+        }
         const components = flags.file === undefined
             ? flags['json-file'] === undefined
                 ? (flags.component ?? []).map((component) => parseAdvComponentSpec(component))

package/dist/commands/adv/component/remove.js

@@ -24,6 +24,9 @@ export default class AdvComponentRemove extends AgentiaCommand {
     };
     async run() {
         const { args, flags } = await this.parse(AdvComponentRemove);
+        if (flags.component === undefined && flags['json-file'] === undefined) {
+            this.error('Provide one component input: --component or --json-file.', { exit: 2 });
+        }
         const components = flags['json-file'] === undefined
             ? (flags.component ?? []).map((component) => parseAdvComponentSpec(component))
             : readAdvComponentsFromJsonFile(flags['json-file']);

package/dist/commands/adv/component/types.js

@@ -8,6 +8,7 @@ export default class AdvComponentTypes extends AgentiaCommand {
         '<%= config.bin %> <%= command.id %> --json',
     ];
     async run() {
+        await this.parse(AdvComponentTypes);
         const result = await this.withSpinner('Fetching Pipelines Advanced component types', () => listAdvComponentTypes());
         this.display(() => this.log(formatAdvRecord({ views: result.views.length })));
         return result;

package/dist/commands/adv/job/wait.js

@@ -13,7 +13,7 @@ export default class AdvJobWait extends AgentiaCommand {
     ];
     static flags = {
         interval: Flags.integer({ description: 'Seconds between job status polls (default: 3).' }),
-        timeout: Flags.integer({ description: 'Maximum seconds to wait (default: 3600).' }),
+        timeout: Flags.integer({ description: 'Maximum seconds to wait; the remote run continues after timeout (default: 3600).' }),
     };
     async run() {
         const { args, flags } = await this.parse(AdvJobWait);

package/dist/commands/adv/organization/list.js

@@ -8,6 +8,7 @@ export default class AdvOrganizationList extends AgentiaCommand {
         '<%= config.bin %> <%= command.id %> --json',
     ];
     async run() {
+        await this.parse(AdvOrganizationList);
         const result = await this.withSpinner('Fetching Pipelines Advanced organizations', () => listAdvOrganizations());
         this.display(() => {
             if (result.organizations.length === 0)

package/dist/commands/cicd/template/defaults.js

@@ -0,0 +1,42 @@
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { CicdGateway } from '../../../lib/cicd-gateway.js';
+import { buildTemplateDefaultsQuery, resolveTemplateWritePath, templateDefaultsFlags } from '../../../lib/template-flags.js';
+import { formatTemplateDetail, normalizeTemplate, templateDefaultsEndpoint, writeTemplateDiskFile, } from '../../../lib/template-types.js';
+export default class TemplateDefaults extends AgentiaCommand {
+    static description = 'Scaffold default Copado Job Template metadata without writing to Salesforce (legacy create ≈ defaults --write)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --name MyTemplate',
+        '<%= config.bin %> <%= command.id %> --name MyTemplate --api-name MyTemplate_1 --write',
+        '<%= config.bin %> <%= command.id %> --name MyTemplate --output ./copado/templates/MyTemplate_1.metadata.json --json',
+    ];
+    static flags = templateDefaultsFlags;
+    async run() {
+        const { flags } = await this.parse(TemplateDefaults);
+        let query;
+        try {
+            query = buildTemplateDefaultsQuery(flags);
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error), { exit: 2 });
+        }
+        const response = await this.withSpinner('Scaffolding template defaults', () => CicdGateway.call({
+            endpoint: templateDefaultsEndpoint(query),
+            method: 'GET',
+        }));
+        const template = normalizeTemplate(response);
+        let filePath;
+        const writePath = resolveTemplateWritePath(template.apiName, flags);
+        if (writePath !== undefined) {
+            filePath = await writeTemplateDiskFile(template, writePath);
+        }
+        this.display(() => {
+            this.log('Scaffolded template defaults (not persisted).');
+            this.log(formatTemplateDetail(template));
+            if (filePath !== undefined) {
+                this.log(`Wrote ${filePath}`);
+            }
+        });
+        return filePath === undefined ? template : { ...template, filePath };
+    }
+}
+//# sourceMappingURL=defaults.js.map

package/dist/commands/cicd/template/delete.js

@@ -0,0 +1,36 @@
+import { Args } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { CicdGateway } from '../../../lib/cicd-gateway.js';
+import { assertValidTemplateApiName, templateEndpoint } from '../../../lib/template-types.js';
+export default class TemplateDelete extends AgentiaCommand {
+    static args = {
+        'api-name': Args.string({
+            description: 'Template API name',
+            required: true,
+        }),
+    };
+    static description = 'Delete a Copado Job Template by API name';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> MyTemplate_1',
+        '<%= config.bin %> <%= command.id %> MyTemplate_1 --json',
+    ];
+    async run() {
+        const { args } = await this.parse(TemplateDelete);
+        let apiName;
+        try {
+            apiName = assertValidTemplateApiName(args['api-name']);
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error), { exit: 2 });
+        }
+        await this.withSpinner('Deleting template', () => CicdGateway.call({
+            endpoint: templateEndpoint(apiName),
+            method: 'DELETE',
+        }));
+        this.display(() => {
+            this.log(`Deleted template ${apiName}.`);
+        });
+        return { apiName };
+    }
+}
+//# sourceMappingURL=delete.js.map

package/dist/commands/cicd/template/get.js

@@ -0,0 +1,48 @@
+import { Args } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { CicdGateway } from '../../../lib/cicd-gateway.js';
+import { resolveTemplateWritePath, templateGetFlags } from '../../../lib/template-flags.js';
+import { formatTemplateDetail, normalizeTemplate, templateEndpoint, writeTemplateDiskFile, } from '../../../lib/template-types.js';
+export default class TemplateGet extends AgentiaCommand {
+    static args = {
+        'api-name': Args.string({
+            description: 'Template API name',
+            required: true,
+        }),
+    };
+    static description = 'Get a Copado Job Template by API name (legacy retrieve ≈ get --write)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> MyTemplate_1',
+        '<%= config.bin %> <%= command.id %> MyTemplate_1 --write',
+        '<%= config.bin %> <%= command.id %> MyTemplate_1 --json',
+    ];
+    static flags = templateGetFlags;
+    async run() {
+        const { args, flags } = await this.parse(TemplateGet);
+        let endpoint;
+        try {
+            endpoint = templateEndpoint(args['api-name']);
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error), { exit: 2 });
+        }
+        const response = await this.withSpinner('Fetching template', () => CicdGateway.call({
+            endpoint,
+            method: 'GET',
+        }));
+        const template = normalizeTemplate(response);
+        let filePath;
+        const writePath = resolveTemplateWritePath(template.apiName, flags);
+        if (writePath !== undefined) {
+            filePath = await writeTemplateDiskFile(template, writePath);
+        }
+        this.display(() => {
+            this.log(formatTemplateDetail(template));
+            if (filePath !== undefined) {
+                this.log(`Wrote ${filePath}`);
+            }
+        });
+        return filePath === undefined ? template : { ...template, filePath };
+    }
+}
+//# sourceMappingURL=get.js.map

package/dist/commands/cicd/template/list.js

@@ -0,0 +1,53 @@
+import { Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { CicdGateway } from '../../../lib/cicd-gateway.js';
+import { buildListPaginationQuery, displayListPagination, listPaginationFlags, } from '../../../lib/list-pagination.js';
+import { formatTemplateTable, normalizeTemplatesListPage, TEMPLATE_LIST_TYPES, templatesEndpoint, } from '../../../lib/template-types.js';
+export default class TemplateList extends AgentiaCommand {
+    static description = 'List Copado Job Templates';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --type all',
+        '<%= config.bin %> <%= command.id %> --name Demo --page-size 50',
+        '<%= config.bin %> <%= command.id %> --fetch-all --json',
+    ];
+    static flags = {
+        ...listPaginationFlags,
+        'fetch-all': Flags.boolean({
+            default: false,
+            description: 'Fetch all matching templates (incompatible with --cursor on the gateway)',
+        }),
+        name: Flags.string({
+            description: 'Filter by name substring',
+        }),
+        type: Flags.string({
+            default: 'custom',
+            description: 'List Custom templates only, or all templates',
+            options: [...TEMPLATE_LIST_TYPES],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(TemplateList);
+        const pagination = buildListPaginationQuery(flags);
+        const response = await this.withSpinner('Fetching templates', () => CicdGateway.call({
+            endpoint: templatesEndpoint({
+                ...pagination,
+                fetchAll: flags['fetch-all'] === true ? true : undefined,
+                name: flags.name,
+                type: flags.type,
+            }),
+            method: 'GET',
+        }));
+        const page = normalizeTemplatesListPage(response);
+        this.display(() => {
+            if (page.data.length === 0) {
+                this.log('No templates found.');
+                return;
+            }
+            this.log(formatTemplateTable(page.data));
+            displayListPagination(this.log.bind(this), page);
+        });
+        return page;
+    }
+}
+//# sourceMappingURL=list.js.map

package/dist/commands/cicd/template/upsert.js

@@ -0,0 +1,45 @@
+import { Args } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { CicdGateway } from '../../../lib/cicd-gateway.js';
+import { buildTemplateUpsertPayload, templateUpsertFlags } from '../../../lib/template-flags.js';
+import { formatTemplateDetail, normalizeTemplate, templateEndpoint, } from '../../../lib/template-types.js';
+export default class TemplateUpsert extends AgentiaCommand {
+    static args = {
+        'api-name': Args.string({
+            description: 'Template API name',
+            required: true,
+        }),
+    };
+    static description = 'Create or update a Copado Job Template by API name (legacy deploy ≈ upsert reading disk or --file)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> MyTemplate_1',
+        '<%= config.bin %> <%= command.id %> MyTemplate_1 --file ./copado/templates/MyTemplate_1.metadata.json',
+        '<%= config.bin %> <%= command.id %> MyTemplate_1 --name "My Template" --steps-file ./steps.json --json',
+    ];
+    static flags = templateUpsertFlags;
+    async run() {
+        const { args, flags } = await this.parse(TemplateUpsert);
+        let payload;
+        try {
+            payload = await buildTemplateUpsertPayload(args['api-name'], flags);
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error), { exit: 2 });
+        }
+        const response = await this.withSpinner('Upserting template', () => CicdGateway.call({
+            body: payload,
+            endpoint: templateEndpoint(args['api-name']),
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            method: 'PUT',
+        }));
+        const template = normalizeTemplate(response);
+        this.display(() => {
+            this.log(`Upserted template ${template.apiName ?? args['api-name']} (ID: ${template.id ?? 'unknown id'}).`);
+            this.log(formatTemplateDetail(template));
+        });
+        return template;
+    }
+}
+//# sourceMappingURL=upsert.js.map

package/dist/commands/cicd/work/ahead-behind.js

@@ -0,0 +1,51 @@
+import { Args, Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { formatWorkAheadBehindResult, performWorkAheadBehind, WorkAheadBehindValidationError, } from '../../../lib/work-ahead-behind.js';
+export default class WorkAheadBehind extends AgentiaCommand {
+    static args = {
+        environment: Args.string({
+            description: 'Copado environment Id or name (defaults to the configured project default environment)',
+            required: false,
+        }),
+    };
+    static description = [
+        'Compare user stories ahead of and behind the next pipeline environment.',
+        'Resolves the project (and its pipeline) from the project default or --project,',
+        'finds the unique next environment from pipeline connections for the given or default environment,',
+        'then GET /agentia/headless/work/user-stories-ahead-behind.',
+    ].join(' ');
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> dev1',
+        '<%= config.bin %> <%= command.id %> a0E... --project a0w...',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        project: Flags.string({
+            description: 'Copado project Id (defaults to the configured project default)',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkAheadBehind);
+        try {
+            const result = await this.withSpinner('Comparing user stories ahead and behind', () => performWorkAheadBehind({
+                ...(args.environment === undefined ? {} : { environment: args.environment }),
+                ...(flags.project === undefined ? {} : { project: flags.project }),
+            }));
+            this.display(() => {
+                this.log(formatWorkAheadBehindResult(result));
+            });
+            return result;
+        }
+        catch (error) {
+            if (error instanceof WorkAheadBehindValidationError) {
+                this.error(error.message, {
+                    exit: 1,
+                    ...(error.suggestions === undefined ? {} : { suggestions: error.suggestions }),
+                });
+            }
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=ahead-behind.js.map

package/dist/commands/cicd/work/environment-sync.js

@@ -13,6 +13,7 @@ export default class WorkEnvironmentSync extends AgentiaCommand {
         'If guessed pathspecs still conflict, PATCH the back-promotion status to Merge Conflict, resolve the files, and re-run with --promotion and --continue. The promotion destination environment supplies the dest org branch and the next-env branch.',
         'To discard a conflicted merge, re-run with --promotion and --abort (runs git merge --abort and sets the back-promotion status to Draft).',
         'After a successful sync, PATCH the back-promotion status to Completed.',
+        'On git/merge failure (including conflicts) and after a successful --continue, uploads the captured command transcript as a Salesforce File on the back-promotion (`Environment Sync Logs <name-or-id> <datetime>.txt`) via `/agentia/headless/file/upload`. HTTP 404 is ignored until that endpoint is rolled out; other upload failures are warned and do not change the environment-sync outcome.',
     ].join(' ');
     static examples = [
         '<%= config.bin %> <%= command.id %> --destination-environment=dev1',

package/dist/commands/cicd/work/submit.js

@@ -2,14 +2,15 @@ import { Flags } from '@oclif/core';
 import path from 'node:path';
 import { AgentiaCommand } from '../../../lib/agentia-command.js';
 import { CicdGateway } from '../../../lib/cicd-gateway.js';
-import { attachCapturedOutputLogs, commandStdioCaptureOptions, withCapturedCommandOutput } from '../../../lib/command-output-buffer.js';
+import { commandStdioCaptureOptions, withCapturedCommandOutput } from '../../../lib/command-output-buffer.js';
 import { readLastBaseBranch, readLastPullRequestBaseUrl, readSkipPullRequest, } from '../../../lib/defaults-store.js';
-import { listPendingChanges } from '../../../lib/git-worktree.js';
+import { getHeadCommitId, listPendingChanges } from '../../../lib/git-worktree.js';
 import { LocalQualityGatesError, resolveLocalQualityGatesScript, runLocalQualityGates, } from '../../../lib/local-quality-gates.js';
 import { openUrl } from '../../../lib/open-browser.js';
+import { resolveWorkItemId } from '../../../lib/work-active.js';
 import { pickWorkDoneFlags, runWorkDone, workDoneFlags } from '../../../lib/work-done.js';
 import { reportLocalQualityGatesFailure, reportLocalQualityGatesOutcome, } from '../../../lib/work-local-run-tests.js';
-import { performWorkPush, resolveActiveFeatureWorkItem, resolveWorkPushContext, resolveWorkPushNeed, WorkPushValidationError, } from '../../../lib/work-push.js';
+import { performWorkPush, resolveActiveFeatureWorkItem, resolveWorkPushContext, resolveWorkPushNeed, uploadCapturedPublishLogsBestEffort, WorkPushValidationError, } from '../../../lib/work-push.js';
 import { reportSubmitUserStoriesAheadBehind } from '../../../lib/work-submit-ahead-behind.js';
 import { waitForPendingCommitJobBeforeSubmit } from '../../../lib/work-submit-wait.js';
 import { buildPullRequestCompareUrl, formatWorkCommandMessage, workSubmitEndpoint, } from '../../../lib/work-types.js';
@@ -21,6 +22,7 @@ export default class WorkSubmit extends AgentiaCommand {
         '(Promote Action with validate=true).',
         'When the last pending related job template name contains Commit, waits up to 5 minutes for that job before submitting.',
         'Before submit or promote, counts user stories ahead and behind between the source environment and the next pipeline environment, and warns when stories behind might cause promotion conflicts (advising `agentia cicd work environment-sync`).',
+        'After a successful submit or promote, uploads the captured command output as a Salesforce File on the user story (`Local Commit Logs <commitId> <datetime>.txt`) via `/agentia/headless/file/upload`. HTTP 404 is ignored until that endpoint is rolled out; other upload failures are warned and do not fail the command.',
         'With --done or --deploy, matches Copado UI Submit when promoting (validate=false / headless work/done).',
         'cicd work done is a compatibility alias of this command with --done.',
     ].join(' ');
@@ -185,6 +187,7 @@ export default class WorkSubmit extends AgentiaCommand {
                             log: (message) => this.log(message),
                             withSpinner: (message, action) => this.withSpinner(message, action),
                         },
+                        skipLogUpload: true,
                         skipNestedMetadataDetection: flags['skip-nested-metadata-detection'],
                     });
                 }
@@ -209,7 +212,7 @@ export default class WorkSubmit extends AgentiaCommand {
             });
             await waitForPendingCommitJobBeforeSubmit(this, workItem);
             const submit = await this.withSpinner('Submitting work item', () => CicdGateway.call({
-                body: attachCapturedOutputLogs({ workItem }),
+                body: { workItem },
                 endpoint: workSubmitEndpoint(),
                 headers: {
                     'Content-Type': 'application/json',
@@ -219,6 +222,16 @@ export default class WorkSubmit extends AgentiaCommand {
             this.display(() => {
                 this.log(formatWorkCommandMessage(submit.message));
             });
+            const tipCommitId = pushResult?.commits.at(-1)?.id ?? (await getHeadCommitId());
+            await uploadCapturedPublishLogsBestEffort({
+                commitId: tipCommitId,
+                hooks: {
+                    display: (render) => this.display(render),
+                    log: (message) => this.log(message),
+                    withSpinner: (message, action) => this.withSpinner(message, action),
+                },
+                linkedEntityId: await resolveWorkItemId(),
+            });
             await this.openPullRequestCompareUrl(branch, flags['skip-pull-request']);
             this.logElapsed(startedAt);
             return {

package/dist/commands/update.js

@@ -2,20 +2,28 @@ import { Flags } from '@oclif/core';
 import { AgentiaCommand } from '../lib/agentia-command.js';
 import { runCliUpdate } from '../lib/cli-update.js';
 export default class Update extends AgentiaCommand {
-    static description = 'Update the globally installed Agentia CLI to the newest beta release';
+    static description = 'Update the globally installed Agentia CLI to the newest release for the selected channel';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --check',
+        '<%= config.bin %> <%= command.id %> --channel latest --check',
+        '<%= config.bin %> <%= command.id %> --channel rc',
         '<%= config.bin %> <%= command.id %> --check --json',
     ];
     static flags = {
+        channel: Flags.option({
+            description: 'npm dist-tag to check (rc or latest). Omit to auto-select: prerelease installs compare rc and latest; stable installs use latest only.',
+            options: ['rc', 'latest'],
+        })(),
         check: Flags.boolean({
             description: 'Check for an update without installing it',
         }),
     };
     async run() {
         const { flags } = await this.parse(Update);
+        const requestedChannel = flags.channel ?? 'auto';
         const result = await this.withSpinner(flags.check ? 'Checking for Agentia CLI updates' : 'Updating Agentia CLI', () => runCliUpdate({
+            channel: requestedChannel,
             checkOnly: flags.check,
             currentVersion: this.config.version,
         }));
@@ -24,7 +32,7 @@ export default class Update extends AgentiaCommand {
                 this.log(`Updated Agentia CLI from ${result.currentVersion} to ${result.latestVersion}. Re-run \`agentia --version\` to verify the new installation.`);
             }
             else if (result.updateAvailable) {
-                this.log(`Agentia CLI ${result.latestVersion} is available (current: ${result.currentVersion}). Run \`agentia update\` to install it.`);
+                this.log(`Agentia CLI ${result.latestVersion} is available on the ${result.channel} channel (current: ${result.currentVersion}). Run \`agentia update\` to install it.`);
             }
             else if (result.versionState === 'ahead') {
                 this.log(`Installed Agentia CLI ${result.currentVersion} is newer than the ${result.channel} channel release ${result.latestVersion}.`);

package/dist/lib/adv-operations.js

@@ -1,5 +1,7 @@
 import {modules} from './runtime.js';
+const AdvQuickDeployUnavailableError = modules["adv-operations.js"]["AdvQuickDeployUnavailableError"]
 const AdvRunFailedError = modules["adv-operations.js"]["AdvRunFailedError"]
+const AdvWaitTimeoutError = modules["adv-operations.js"]["AdvWaitTimeoutError"]
 const addAdvComponents = modules["adv-operations.js"]["addAdvComponents"]
 const advRunErrorJson = modules["adv-operations.js"]["advRunErrorJson"]
 const assertAdvJobSucceeded = modules["adv-operations.js"]["assertAdvJobSucceeded"]
@@ -26,4 +28,4 @@ const selectedAdvComponents = modules["adv-operations.js"]["selectedAdvComponent
 const updateAdvDeploymentOptions = modules["adv-operations.js"]["updateAdvDeploymentOptions"]
 const validateAdvOrganization = modules["adv-operations.js"]["validateAdvOrganization"]
 const waitForAdvJob = modules["adv-operations.js"]["waitForAdvJob"]
-export {AdvRunFailedError, addAdvComponents, advRunErrorJson, assertAdvJobSucceeded, cancelAdvDeployment, createAdvDeployment, deriveAdvJobResult, getAdvAuthStatus, getAdvDeployment, getAdvJob, getAdvOrganization, getStoredAdvAuthSummary, listAdvComponentTypes, listAdvComponents, listAdvDeployments, listAdvJobs, listAdvOrganizations, parseAdvComponentSpec, readAdvComponentsFromJsonFile, readAdvComponentsFromTextFile, refreshAdvComponents, removeAdvComponents, runAdvDeploymentAction, selectedAdvComponents, updateAdvDeploymentOptions, validateAdvOrganization, waitForAdvJob};
+export {AdvQuickDeployUnavailableError, AdvRunFailedError, AdvWaitTimeoutError, addAdvComponents, advRunErrorJson, assertAdvJobSucceeded, cancelAdvDeployment, createAdvDeployment, deriveAdvJobResult, getAdvAuthStatus, getAdvDeployment, getAdvJob, getAdvOrganization, getStoredAdvAuthSummary, listAdvComponentTypes, listAdvComponents, listAdvDeployments, listAdvJobs, listAdvOrganizations, parseAdvComponentSpec, readAdvComponentsFromJsonFile, readAdvComponentsFromTextFile, refreshAdvComponents, removeAdvComponents, runAdvDeploymentAction, selectedAdvComponents, updateAdvDeploymentOptions, validateAdvOrganization, waitForAdvJob};

package/dist/lib/agentia-command.js

@@ -4,8 +4,42 @@ import { createTransactionId, runWithGatewayTransactionContext } from './cicd-ga
 import { colorizeCliSeverityError, colorizeCliSeverityText } from './cli-severity-color.js';
 import { isCommandOutputCaptureActive } from './command-output-buffer.js';
 import { rememberIdeCommandError } from './ide-command-events.js';
+import { redactErrorMessage, redactSecrets } from './secret-redaction.js';
 const TRANSACTION_ID_REPORTED = Symbol('agentiaTransactionIdReported');
 const EXPERIMENTAL_COMMAND_WARNING = 'This command is experimental and may change without notice.';
+const SAFE_ERROR_FIELDS = [
+    'categories',
+    'code',
+    'requestMethod',
+    'requestUrl',
+    'retryAfterSeconds',
+    'statusCode',
+    'suggestions',
+];
+function recordValue(value) {
+    return typeof value === 'object' && value !== null ? value : {};
+}
+function safeErrorJson(err, base) {
+    const baseError = recordValue(base.error);
+    const source = recordValue(err);
+    const error = {
+        message: redactErrorMessage(err),
+        name: typeof baseError.name === 'string'
+            ? baseError.name
+            : err instanceof Error && err.name.length > 0
+                ? err.name
+                : 'Error',
+    };
+    for (const field of SAFE_ERROR_FIELDS) {
+        const value = source[field] ?? baseError[field];
+        if (value !== undefined)
+            error[field] = redactSecrets(value);
+    }
+    const oclif = recordValue(baseError.oclif);
+    if (typeof oclif.exit === 'number')
+        error.oclif = { exit: oclif.exit };
+    return error;
+}
 export function elapsedSecondsSince(startedAtMs, nowMs = Date.now()) {
     return Math.max(0, Math.floor((nowMs - startedAtMs) / 1000));
 }
@@ -76,6 +110,7 @@ export class AgentiaCommand extends Command {
         const warnings = this.jsonWarnings();
         return {
             ...base,
+            error: safeErrorJson(err, base),
             ...(warnings.length > 0 ? { warnings } : {}),
             transactionId: this.commandTransactionId,
         };

package/dist/lib/cli-version.js

@@ -2,16 +2,20 @@ import {modules} from './runtime.js';
 const AGENTIA_NPM_REGISTRY = modules["cli-version.js"]["AGENTIA_NPM_REGISTRY"]
 const AGENTIA_PACKAGE_NAME = modules["cli-version.js"]["AGENTIA_PACKAGE_NAME"]
 const AGENTIA_RELEASE_CHANNEL = modules["cli-version.js"]["AGENTIA_RELEASE_CHANNEL"]
+const AGENTIA_STABLE_CHANNEL = modules["cli-version.js"]["AGENTIA_STABLE_CHANNEL"]
 const CliVersionError = modules["cli-version.js"]["CliVersionError"]
 const VERSION_CACHE_FILENAME = modules["cli-version.js"]["VERSION_CACHE_FILENAME"]
+const VERSION_CACHE_SCHEMA_VERSION = modules["cli-version.js"]["VERSION_CACHE_SCHEMA_VERSION"]
 const VERSION_CHECK_INTERVAL_MS = modules["cli-version.js"]["VERSION_CHECK_INTERVAL_MS"]
 const defaultVersionRegistryClient = modules["cli-version.js"]["defaultVersionRegistryClient"]
-const fetchChannelVersion = modules["cli-version.js"]["fetchChannelVersion"]
+const fetchDistTags = modules["cli-version.js"]["fetchDistTags"]
 const isNewerVersion = modules["cli-version.js"]["isNewerVersion"]
+const isPrereleaseVersion = modules["cli-version.js"]["isPrereleaseVersion"]
 const isVersionCacheStale = modules["cli-version.js"]["isVersionCacheStale"]
 const readVersionCache = modules["cli-version.js"]["readVersionCache"]
 const refreshVersionCache = modules["cli-version.js"]["refreshVersionCache"]
+const resolveUpdateCandidate = modules["cli-version.js"]["resolveUpdateCandidate"]
 const setCliVersionRegistryClientForTests = modules["cli-version.js"]["setCliVersionRegistryClientForTests"]
 const versionCachePath = modules["cli-version.js"]["versionCachePath"]
 const writeVersionCache = modules["cli-version.js"]["writeVersionCache"]
-export {AGENTIA_NPM_REGISTRY, AGENTIA_PACKAGE_NAME, AGENTIA_RELEASE_CHANNEL, CliVersionError, VERSION_CACHE_FILENAME, VERSION_CHECK_INTERVAL_MS, defaultVersionRegistryClient, fetchChannelVersion, isNewerVersion, isVersionCacheStale, readVersionCache, refreshVersionCache, setCliVersionRegistryClientForTests, versionCachePath, writeVersionCache};
+export {AGENTIA_NPM_REGISTRY, AGENTIA_PACKAGE_NAME, AGENTIA_RELEASE_CHANNEL, AGENTIA_STABLE_CHANNEL, CliVersionError, VERSION_CACHE_FILENAME, VERSION_CACHE_SCHEMA_VERSION, VERSION_CHECK_INTERVAL_MS, defaultVersionRegistryClient, fetchDistTags, isNewerVersion, isPrereleaseVersion, isVersionCacheStale, readVersionCache, refreshVersionCache, resolveUpdateCandidate, setCliVersionRegistryClientForTests, versionCachePath, writeVersionCache};

package/dist/lib/headless-file-upload.js

@@ -0,0 +1,10 @@
+import {modules} from './runtime.js';
+const buildEnvironmentSyncLogsFileName = modules["headless-file-upload.js"]["buildEnvironmentSyncLogsFileName"]
+const buildLocalCommitLogsFileName = modules["headless-file-upload.js"]["buildLocalCommitLogsFileName"]
+const buildMultipartFileBody = modules["headless-file-upload.js"]["buildMultipartFileBody"]
+const formatFileNameDateTime = modules["headless-file-upload.js"]["formatFileNameDateTime"]
+const isMissingHeadlessFileUploadEndpoint = modules["headless-file-upload.js"]["isMissingHeadlessFileUploadEndpoint"]
+const uploadCapturedCommandLogs = modules["headless-file-upload.js"]["uploadCapturedCommandLogs"]
+const uploadCapturedPublishLogs = modules["headless-file-upload.js"]["uploadCapturedPublishLogs"]
+const uploadHeadlessFile = modules["headless-file-upload.js"]["uploadHeadlessFile"]
+export {buildEnvironmentSyncLogsFileName, buildLocalCommitLogsFileName, buildMultipartFileBody, formatFileNameDateTime, isMissingHeadlessFileUploadEndpoint, uploadCapturedCommandLogs, uploadCapturedPublishLogs, uploadHeadlessFile};

package/dist/lib/java-runtime.js

@@ -0,0 +1,6 @@
+import {modules} from './runtime.js';
+const MISSING_JAVA_MESSAGE = modules["java-runtime.js"]["MISSING_JAVA_MESSAGE"]
+const isMissingExecutableError = modules["java-runtime.js"]["isMissingExecutableError"]
+const resolveJavaCommand = modules["java-runtime.js"]["resolveJavaCommand"]
+const throwIfMissingJava = modules["java-runtime.js"]["throwIfMissingJava"]
+export {MISSING_JAVA_MESSAGE, isMissingExecutableError, resolveJavaCommand, throwIfMissingJava};