@copado/agentia-cli 1.0.0-beta.5 → 1.0.0-beta.7

package/dist/hooks/init/version-warning.js

@@ -1,4 +1,5 @@
-import { ux } from '@oclif/core';
+import { Errors, ux } from '@oclif/core';
+import { colorizeCliSeverityText } from '../../lib/cli-severity-color.js';
 import { checkVersionWarning, isJsonOutputRequested } from '../../lib/version-warning.js';
 const hook = async function ({ argv, config, id }) {
     if (id === 'mcp:start') {
@@ -13,7 +14,9 @@ const hook = async function ({ argv, config, id }) {
             skip: config.scopedEnvVarTrue('SKIP_NEW_VERSION_CHECK'),
         });
         if (result.warning !== undefined && !isJsonOutputRequested(argv, config.scopedEnvVar('CONTENT_TYPE'))) {
-            this.warn(result.warning);
+            const warning = new Errors.CLIError.Warn(colorizeCliSeverityText(result.warning, 'warning'));
+            warning.name = colorizeCliSeverityText('Warning', 'warning');
+            Errors.warn(warning);
         }
     }
     catch {

package/dist/lib/adv-config.js

@@ -0,0 +1,9 @@
+import {modules} from './runtime.js';
+const ADV_REGIONAL_BASE_URLS = modules["adv-config.js"]["ADV_REGIONAL_BASE_URLS"]
+const AdvConfigurationError = modules["adv-config.js"]["AdvConfigurationError"]
+const advBaseUrlForRegion = modules["adv-config.js"]["advBaseUrlForRegion"]
+const advRegionEntries = modules["adv-config.js"]["advRegionEntries"]
+const normalizeAdvBaseUrl = modules["adv-config.js"]["normalizeAdvBaseUrl"]
+const readAdvAuthMetadata = modules["adv-config.js"]["readAdvAuthMetadata"]
+const resolveAdvCredentials = modules["adv-config.js"]["resolveAdvCredentials"]
+export {ADV_REGIONAL_BASE_URLS, AdvConfigurationError, advBaseUrlForRegion, advRegionEntries, normalizeAdvBaseUrl, readAdvAuthMetadata, resolveAdvCredentials};

package/dist/lib/adv-flags.js

@@ -0,0 +1,8 @@
+import {modules} from './runtime.js';
+const advWaitFlags = modules["adv-flags.js"]["advWaitFlags"]
+const advYesFlag = modules["adv-flags.js"]["advYesFlag"]
+const confirmAdvAction = modules["adv-flags.js"]["confirmAdvAction"]
+const hasAdvActionTestConfirm = modules["adv-flags.js"]["hasAdvActionTestConfirm"]
+const requiresAdvExplicitYes = modules["adv-flags.js"]["requiresAdvExplicitYes"]
+const setAdvActionConfirmForTests = modules["adv-flags.js"]["setAdvActionConfirmForTests"]
+export {advWaitFlags, advYesFlag, confirmAdvAction, hasAdvActionTestConfirm, requiresAdvExplicitYes, setAdvActionConfirmForTests};

package/dist/lib/adv-gateway.js

@@ -0,0 +1,8 @@
+import {modules} from './runtime.js';
+const ADV_DEFAULT_TIMEOUT_MS = modules["adv-gateway.js"]["ADV_DEFAULT_TIMEOUT_MS"]
+const ADV_MAX_RESPONSE_BYTES = modules["adv-gateway.js"]["ADV_MAX_RESPONSE_BYTES"]
+const AdvGateway = modules["adv-gateway.js"]["AdvGateway"]
+const AdvGatewayError = modules["adv-gateway.js"]["AdvGatewayError"]
+const resetAdvHttpRequestForTests = modules["adv-gateway.js"]["resetAdvHttpRequestForTests"]
+const setAdvHttpRequestForTests = modules["adv-gateway.js"]["setAdvHttpRequestForTests"]
+export {ADV_DEFAULT_TIMEOUT_MS, ADV_MAX_RESPONSE_BYTES, AdvGateway, AdvGatewayError, resetAdvHttpRequestForTests, setAdvHttpRequestForTests};

package/dist/lib/adv-operations.js

@@ -0,0 +1,29 @@
+import {modules} from './runtime.js';
+const AdvRunFailedError = modules["adv-operations.js"]["AdvRunFailedError"]
+const addAdvComponents = modules["adv-operations.js"]["addAdvComponents"]
+const advRunErrorJson = modules["adv-operations.js"]["advRunErrorJson"]
+const assertAdvJobSucceeded = modules["adv-operations.js"]["assertAdvJobSucceeded"]
+const cancelAdvDeployment = modules["adv-operations.js"]["cancelAdvDeployment"]
+const createAdvDeployment = modules["adv-operations.js"]["createAdvDeployment"]
+const deriveAdvJobResult = modules["adv-operations.js"]["deriveAdvJobResult"]
+const getAdvAuthStatus = modules["adv-operations.js"]["getAdvAuthStatus"]
+const getAdvDeployment = modules["adv-operations.js"]["getAdvDeployment"]
+const getAdvJob = modules["adv-operations.js"]["getAdvJob"]
+const getAdvOrganization = modules["adv-operations.js"]["getAdvOrganization"]
+const getStoredAdvAuthSummary = modules["adv-operations.js"]["getStoredAdvAuthSummary"]
+const listAdvComponentTypes = modules["adv-operations.js"]["listAdvComponentTypes"]
+const listAdvComponents = modules["adv-operations.js"]["listAdvComponents"]
+const listAdvDeployments = modules["adv-operations.js"]["listAdvDeployments"]
+const listAdvJobs = modules["adv-operations.js"]["listAdvJobs"]
+const listAdvOrganizations = modules["adv-operations.js"]["listAdvOrganizations"]
+const parseAdvComponentSpec = modules["adv-operations.js"]["parseAdvComponentSpec"]
+const readAdvComponentsFromJsonFile = modules["adv-operations.js"]["readAdvComponentsFromJsonFile"]
+const readAdvComponentsFromTextFile = modules["adv-operations.js"]["readAdvComponentsFromTextFile"]
+const refreshAdvComponents = modules["adv-operations.js"]["refreshAdvComponents"]
+const removeAdvComponents = modules["adv-operations.js"]["removeAdvComponents"]
+const runAdvDeploymentAction = modules["adv-operations.js"]["runAdvDeploymentAction"]
+const selectedAdvComponents = modules["adv-operations.js"]["selectedAdvComponents"]
+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};

package/dist/lib/adv-sanitization.js

@@ -0,0 +1,8 @@
+import {modules} from './runtime.js';
+const ADV_MAX_ERROR_MESSAGE_LENGTH = modules["adv-sanitization.js"]["ADV_MAX_ERROR_MESSAGE_LENGTH"]
+const ADV_REDACTED = modules["adv-sanitization.js"]["ADV_REDACTED"]
+const advProviderErrorMessage = modules["adv-sanitization.js"]["advProviderErrorMessage"]
+const sanitizeAdvOutput = modules["adv-sanitization.js"]["sanitizeAdvOutput"]
+const sanitizeAdvUrl = modules["adv-sanitization.js"]["sanitizeAdvUrl"]
+const summarizeAdvDebugBody = modules["adv-sanitization.js"]["summarizeAdvDebugBody"]
+export {ADV_MAX_ERROR_MESSAGE_LENGTH, ADV_REDACTED, advProviderErrorMessage, sanitizeAdvOutput, sanitizeAdvUrl, summarizeAdvDebugBody};

package/dist/lib/adv-types.js

@@ -0,0 +1,9 @@
+import {modules} from './runtime.js';
+const asAdvRecord = modules["adv-types.js"]["asAdvRecord"]
+const formatAdvComponents = modules["adv-types.js"]["formatAdvComponents"]
+const formatAdvDeployments = modules["adv-types.js"]["formatAdvDeployments"]
+const formatAdvJobs = modules["adv-types.js"]["formatAdvJobs"]
+const formatAdvOrganizations = modules["adv-types.js"]["formatAdvOrganizations"]
+const formatAdvRecord = modules["adv-types.js"]["formatAdvRecord"]
+const normalizeAdvId = modules["adv-types.js"]["normalizeAdvId"]
+export {asAdvRecord, formatAdvComponents, formatAdvDeployments, formatAdvJobs, formatAdvOrganizations, formatAdvRecord, normalizeAdvId};

package/dist/lib/agentia-command.js

@@ -1,9 +1,11 @@
-import { Command, ux } from '@oclif/core';
+import { Command, Errors, ux } from '@oclif/core';
 import { format } from 'node:util';
 import { createTransactionId, runWithGatewayTransactionContext } from './cicd-gateway.js';
+import { colorizeCliSeverityError, colorizeCliSeverityText } from './cli-severity-color.js';
 import { isCommandOutputCaptureActive } from './command-output-buffer.js';
 import { rememberIdeCommandError } from './ide-command-events.js';
 const TRANSACTION_ID_REPORTED = Symbol('agentiaTransactionIdReported');
+const EXPERIMENTAL_COMMAND_WARNING = 'This command is experimental and may change without notice.';
 export function elapsedSecondsSince(startedAtMs, nowMs = Date.now()) {
     return Math.max(0, Math.floor((nowMs - startedAtMs) / 1000));
 }
@@ -12,6 +14,7 @@ export function formatElapsedSecondsMessage(seconds) {
 }
 export class AgentiaCommand extends Command {
     static enableJsonFlag = true;
+    static experimental = false;
     commandTransactionId;
     async _run() {
         const transactionId = createTransactionId();
@@ -20,6 +23,9 @@ export class AgentiaCommand extends Command {
     }
     async catch(error) {
         this.reportHumanErrorTransactionId(error);
+        if (!this.jsonEnabled()) {
+            colorizeCliSeverityError(error, 'error');
+        }
         return super.catch(error);
     }
     display(render) {
@@ -27,10 +33,31 @@ export class AgentiaCommand extends Command {
             render();
         }
     }
+    error(input, options = {}) {
+        // exit:false prints immediately (no catch); colorize here. Throwing errors are colorized in catch.
+        if (!this.jsonEnabled() && options.exit === false) {
+            if (typeof input === 'string') {
+                const error = new Errors.CLIError(input, options);
+                colorizeCliSeverityError(error, 'error');
+                Errors.error(error, { exit: false });
+                return;
+            }
+            colorizeCliSeverityError(input, 'error');
+            Errors.error(input, { exit: false });
+            return;
+        }
+        return Errors.error(input, options);
+    }
     async finally(error) {
         rememberIdeCommandError(error);
         return super.finally(error);
     }
+    async init() {
+        await super.init();
+        if (this.isExperimentalCommand() && !this.jsonEnabled()) {
+            this.warn(EXPERIMENTAL_COMMAND_WARNING);
+        }
+    }
     log(message, ...args) {
         if (this.jsonEnabled() && isCommandOutputCaptureActive()) {
             const formatted = format(message ?? '', ...args);
@@ -46,10 +73,31 @@ export class AgentiaCommand extends Command {
     }
     toErrorJson(err) {
         const base = super.toErrorJson(err);
-        return { ...base, transactionId: this.commandTransactionId };
+        const warnings = this.jsonWarnings();
+        return {
+            ...base,
+            ...(warnings.length > 0 ? { warnings } : {}),
+            transactionId: this.commandTransactionId,
+        };
     }
     toSuccessJson(result) {
-        return { result, status: 0, transactionId: this.commandTransactionId };
+        const warnings = this.jsonWarnings(result);
+        return {
+            result,
+            status: 0,
+            ...(warnings.length > 0 ? { warnings } : {}),
+            transactionId: this.commandTransactionId,
+        };
+    }
+    warn(input) {
+        if (this.jsonEnabled()) {
+            return super.warn(input);
+        }
+        const text = typeof input === 'string' ? input : input.message;
+        const warning = new Errors.CLIError.Warn(colorizeCliSeverityText(text, 'warning'));
+        warning.name = colorizeCliSeverityText('Warning', 'warning');
+        Errors.warn(warning);
+        return input;
     }
     async withSpinner(message, action) {
         if (this.jsonEnabled()) {
@@ -69,6 +117,16 @@ export class AgentiaCommand extends Command {
             throw error;
         }
     }
+    isExperimentalCommand() {
+        return this.constructor.experimental === true;
+    }
+    jsonWarnings(result) {
+        const warnings = [
+            ...(this.isExperimentalCommand() ? [EXPERIMENTAL_COMMAND_WARNING] : []),
+            ...this.resultWarnings(result),
+        ];
+        return [...new Set(warnings)];
+    }
     reportHumanErrorTransactionId(error) {
         if (this.jsonEnabled() || this.commandTransactionId === undefined) {
             return;
@@ -80,5 +138,12 @@ export class AgentiaCommand extends Command {
         reportedError[TRANSACTION_ID_REPORTED] = true;
         this.logToStderr(`Transaction ID: ${this.commandTransactionId}`);
     }
+    resultWarnings(result) {
+        if (typeof result !== 'object' || result === null || Array.isArray(result)) {
+            return [];
+        }
+        const { warnings } = result;
+        return Array.isArray(warnings) ? warnings.filter((warning) => typeof warning === 'string') : [];
+    }
 }
 //# sourceMappingURL=agentia-command.js.map

package/dist/lib/ai-config.js

@@ -4,6 +4,8 @@ const AI_DEFAULT_WORKSPACE_NAME = modules["ai-config.js"]["AI_DEFAULT_WORKSPACE_
 const AI_DISCOVERY_DOMAINS = modules["ai-config.js"]["AI_DISCOVERY_DOMAINS"]
 const AI_GATEWAY_HOST_PREFIX = modules["ai-config.js"]["AI_GATEWAY_HOST_PREFIX"]
 const aiBaseUrl = modules["ai-config.js"]["aiBaseUrl"]
+const evaluateAiReady = modules["ai-config.js"]["evaluateAiReady"]
+const isAiReady = modules["ai-config.js"]["isAiReady"]
 const normalizeAiDialogueId = modules["ai-config.js"]["normalizeAiDialogueId"]
 const normalizeAiDomain = modules["ai-config.js"]["normalizeAiDomain"]
 const normalizeAiGatewayUrl = modules["ai-config.js"]["normalizeAiGatewayUrl"]
@@ -11,4 +13,4 @@ const normalizeAiOrgId = modules["ai-config.js"]["normalizeAiOrgId"]
 const normalizeAiUuid = modules["ai-config.js"]["normalizeAiUuid"]
 const normalizeAiWorkspaceId = modules["ai-config.js"]["normalizeAiWorkspaceId"]
 const resolveAiCredentials = modules["ai-config.js"]["resolveAiCredentials"]
-export {AI_DEFAULT_TIMEOUT_MS, AI_DEFAULT_WORKSPACE_NAME, AI_DISCOVERY_DOMAINS, AI_GATEWAY_HOST_PREFIX, aiBaseUrl, normalizeAiDialogueId, normalizeAiDomain, normalizeAiGatewayUrl, normalizeAiOrgId, normalizeAiUuid, normalizeAiWorkspaceId, resolveAiCredentials};
+export {AI_DEFAULT_TIMEOUT_MS, AI_DEFAULT_WORKSPACE_NAME, AI_DISCOVERY_DOMAINS, AI_GATEWAY_HOST_PREFIX, aiBaseUrl, evaluateAiReady, isAiReady, normalizeAiDialogueId, normalizeAiDomain, normalizeAiGatewayUrl, normalizeAiOrgId, normalizeAiUuid, normalizeAiWorkspaceId, resolveAiCredentials};

package/dist/lib/auth-config.js

@@ -9,6 +9,7 @@ const formatAuthUnsetConfirmation = modules["auth-config.js"]["formatAuthUnsetCo
 const formatCicdApiKeyHelp = modules["auth-config.js"]["formatCicdApiKeyHelp"]
 const formatPersonalAccessKeyHelp = modules["auth-config.js"]["formatPersonalAccessKeyHelp"]
 const formatTerminalHyperlink = modules["auth-config.js"]["formatTerminalHyperlink"]
+const getAdvAuthStatus = modules["auth-config.js"]["getAdvAuthStatus"]
 const getAiAuthStatus = modules["auth-config.js"]["getAiAuthStatus"]
 const getCicdAuthStatus = modules["auth-config.js"]["getCicdAuthStatus"]
 const getCrtAuthStatus = modules["auth-config.js"]["getCrtAuthStatus"]
@@ -17,4 +18,4 @@ const isCicdConfigured = modules["auth-config.js"]["isCicdConfigured"]
 const resetAuthUnsetConfirmForTests = modules["auth-config.js"]["resetAuthUnsetConfirmForTests"]
 const resolveAuthUnsetTypes = modules["auth-config.js"]["resolveAuthUnsetTypes"]
 const setAuthUnsetConfirmForTests = modules["auth-config.js"]["setAuthUnsetConfirmForTests"]
-export {AuthSetError, COPADO_ACCOUNT_SUMMARY_LOGIN_URL, COPADO_ROBOTIC_PERSONAL_ACCESS_KEY_URL, applyAuthSet, applyAuthUnset, confirmAuthUnset, formatAuthUnsetConfirmation, formatCicdApiKeyHelp, formatPersonalAccessKeyHelp, formatTerminalHyperlink, getAiAuthStatus, getCicdAuthStatus, getCrtAuthStatus, hasAuthUnsetTestConfirm, isCicdConfigured, resetAuthUnsetConfirmForTests, resolveAuthUnsetTypes, setAuthUnsetConfirmForTests};
+export {AuthSetError, COPADO_ACCOUNT_SUMMARY_LOGIN_URL, COPADO_ROBOTIC_PERSONAL_ACCESS_KEY_URL, applyAuthSet, applyAuthUnset, confirmAuthUnset, formatAuthUnsetConfirmation, formatCicdApiKeyHelp, formatPersonalAccessKeyHelp, formatTerminalHyperlink, getAdvAuthStatus, getAiAuthStatus, getCicdAuthStatus, getCrtAuthStatus, hasAuthUnsetTestConfirm, isCicdConfigured, resetAuthUnsetConfirmForTests, resolveAuthUnsetTypes, setAuthUnsetConfirmForTests};

package/dist/lib/auth-profile.js

@@ -1,8 +1,9 @@
 import {modules} from './runtime.js';
 const deleteAuthProfile = modules["auth-profile.js"]["deleteAuthProfile"]
+const deleteAuthProfileUserId = modules["auth-profile.js"]["deleteAuthProfileUserId"]
 const ensureLocalKeychainId = modules["auth-profile.js"]["ensureLocalKeychainId"]
 const localProfileKeychainId = modules["auth-profile.js"]["localProfileKeychainId"]
 const readAuthProfile = modules["auth-profile.js"]["readAuthProfile"]
 const updateAuthProfile = modules["auth-profile.js"]["updateAuthProfile"]
 const writeAuthProfile = modules["auth-profile.js"]["writeAuthProfile"]
-export {deleteAuthProfile, ensureLocalKeychainId, localProfileKeychainId, readAuthProfile, updateAuthProfile, writeAuthProfile};
+export {deleteAuthProfile, deleteAuthProfileUserId, ensureLocalKeychainId, localProfileKeychainId, readAuthProfile, updateAuthProfile, writeAuthProfile};

package/dist/lib/auth-status-format.js

@@ -1,6 +1,7 @@
 import {modules} from './runtime.js';
+const formatAdvStatusLine = modules["auth-status-format.js"]["formatAdvStatusLine"]
 const formatAiStatusLine = modules["auth-status-format.js"]["formatAiStatusLine"]
 const formatAuthScope = modules["auth-status-format.js"]["formatAuthScope"]
 const formatCicdStatusLine = modules["auth-status-format.js"]["formatCicdStatusLine"]
 const formatCrtStatusLine = modules["auth-status-format.js"]["formatCrtStatusLine"]
-export {formatAiStatusLine, formatAuthScope, formatCicdStatusLine, formatCrtStatusLine};
+export {formatAdvStatusLine, formatAiStatusLine, formatAuthScope, formatCicdStatusLine, formatCrtStatusLine};

package/dist/lib/cicd-gateway.js

@@ -1,4 +1,5 @@
 import {modules} from './runtime.js';
+const ADV_GATEWAY_EVENT_SERVICE = modules["cicd-gateway.js"]["ADV_GATEWAY_EVENT_SERVICE"]
 const AGENTIA_CLIENT_ORIGIN_ENV = modules["cicd-gateway.js"]["AGENTIA_CLIENT_ORIGIN_ENV"]
 const AGENTIA_IDE_VERSION_ENV = modules["cicd-gateway.js"]["AGENTIA_IDE_VERSION_ENV"]
 const AI_GATEWAY_EVENT_SERVICE = modules["cicd-gateway.js"]["AI_GATEWAY_EVENT_SERVICE"]
@@ -41,4 +42,4 @@ const scheduleGatewayEventLog = modules["cicd-gateway.js"]["scheduleGatewayEvent
 const setGatewayEventLogSenderForTests = modules["cicd-gateway.js"]["setGatewayEventLogSenderForTests"]
 const setHttpRequestForTests = modules["cicd-gateway.js"]["setHttpRequestForTests"]
 const tryResolveCicdCredentials = modules["cicd-gateway.js"]["tryResolveCicdCredentials"]
-export {AGENTIA_CLIENT_ORIGIN_ENV, AGENTIA_IDE_VERSION_ENV, AI_GATEWAY_EVENT_SERVICE, CICD_ENV, CRT_GATEWAY_EVENT_SERVICE, CicdGateway, CicdGatewayError, GATEWAY_EVENT_API_CALL, GATEWAY_EVENT_UNKNOWN, MCP_CICD_DEFAULT_REQUEST_TIMEOUT_MS, PLUGIN_GATEWAY_EVENT_SERVICE, buildGatewayEventLogPayload, cicdApiUrl, createTransactionId, discoverCicdBaseUrl, flushGatewayEventLogsForTests, formatCicdGatewayError, formatGatewayEventTimestamp, gatewayEventSource, gatewayRefererHeaders, gatewayUserAgent, getActiveHttpRequestOptionsForTests, getGatewayClientOrigin, getGatewayReferer, getGatewayTransactionId, isCicdWarningResponseBody, isCicdWarningStatus, maskUrlSecrets, maskedCicdApiUrl, normalizeCicdBaseUrl, parseRetryAfterHeader, resetGatewayEventLogSenderForTests, resetHttpRequestForTests, resolveAndValidateCicdEndpoint, resolveCicdCredentials, resolveCicdRequestTimeoutMs, resolveConfiguredCicdBaseUrl, runWithGatewayTransactionContext, scheduleGatewayEventLog, setGatewayEventLogSenderForTests, setHttpRequestForTests, tryResolveCicdCredentials};
+export {ADV_GATEWAY_EVENT_SERVICE, AGENTIA_CLIENT_ORIGIN_ENV, AGENTIA_IDE_VERSION_ENV, AI_GATEWAY_EVENT_SERVICE, CICD_ENV, CRT_GATEWAY_EVENT_SERVICE, CicdGateway, CicdGatewayError, GATEWAY_EVENT_API_CALL, GATEWAY_EVENT_UNKNOWN, MCP_CICD_DEFAULT_REQUEST_TIMEOUT_MS, PLUGIN_GATEWAY_EVENT_SERVICE, buildGatewayEventLogPayload, cicdApiUrl, createTransactionId, discoverCicdBaseUrl, flushGatewayEventLogsForTests, formatCicdGatewayError, formatGatewayEventTimestamp, gatewayEventSource, gatewayRefererHeaders, gatewayUserAgent, getActiveHttpRequestOptionsForTests, getGatewayClientOrigin, getGatewayReferer, getGatewayTransactionId, isCicdWarningResponseBody, isCicdWarningStatus, maskUrlSecrets, maskedCicdApiUrl, normalizeCicdBaseUrl, parseRetryAfterHeader, resetGatewayEventLogSenderForTests, resetHttpRequestForTests, resolveAndValidateCicdEndpoint, resolveCicdCredentials, resolveCicdRequestTimeoutMs, resolveConfiguredCicdBaseUrl, runWithGatewayTransactionContext, scheduleGatewayEventLog, setGatewayEventLogSenderForTests, setHttpRequestForTests, tryResolveCicdCredentials};

package/dist/lib/cli-severity-color.js

@@ -0,0 +1,4 @@
+import {modules} from './runtime.js';
+const colorizeCliSeverityError = modules["cli-severity-color.js"]["colorizeCliSeverityError"]
+const colorizeCliSeverityText = modules["cli-severity-color.js"]["colorizeCliSeverityText"]
+export {colorizeCliSeverityError, colorizeCliSeverityText};

package/dist/lib/environment-get.js

@@ -0,0 +1,4 @@
+import {modules} from './runtime.js';
+const fetchEnvironment = modules["environment-get.js"]["fetchEnvironment"]
+const fetchEnvironments = modules["environment-get.js"]["fetchEnvironments"]
+export {fetchEnvironment, fetchEnvironments};

package/dist/lib/job-get.js

@@ -0,0 +1,4 @@
+import {modules} from './runtime.js';
+const fetchJob = modules["job-get.js"]["fetchJob"]
+const fetchJobs = modules["job-get.js"]["fetchJobs"]
+export {fetchJob, fetchJobs};

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

@@ -0,0 +1,227 @@
+import { z } from 'zod';
+import { addAdvComponents, assertAdvJobSucceeded, cancelAdvDeployment, createAdvDeployment, getAdvAuthStatus, getAdvDeployment, getAdvJob, getAdvOrganization, listAdvComponents, listAdvComponentTypes, listAdvDeployments, listAdvJobs, listAdvOrganizations, parseAdvComponentSpec, refreshAdvComponents, removeAdvComponents, runAdvDeploymentAction, selectedAdvComponents, updateAdvDeploymentOptions, validateAdvOrganization, waitForAdvJob, } from '../adv-operations.js';
+import { safelyHandleTool } from './result.js';
+const componentReferenceSchema = z.union([
+    z.string().min(1).describe('Component in Type/Name format.'),
+    z.object({
+        excluded: z.boolean().optional().describe('Whether the component is excluded from deployment.'),
+        fullName: z.string().min(1).describe('Component full name.'),
+        type: z.string().min(1).describe('Metadata type name.'),
+    }),
+]);
+const componentInputSchema = z.array(componentReferenceSchema).min(1).describe('Components as Type/Name strings or {type, fullName, excluded} objects.');
+function componentList(components) {
+    return components.map((component) => {
+        if (typeof component === 'string')
+            return parseAdvComponentSpec(component);
+        return component;
+    });
+}
+function componentAddMode(components) {
+    return components.some((component) => typeof component !== 'string') ? 'json' : 'import';
+}
+function requireConfirm(confirm, action) {
+    if (confirm !== true)
+        throw new Error(`${action} requires confirm: true.`);
+}
+async function deploymentAction(args) {
+    if (args.kind !== 'validate')
+        requireConfirm(args.confirm, 'Pipelines Advanced deployment action');
+    return {
+        result: await runAdvDeploymentAction({
+            backup: args.backup,
+            id: args.id,
+            kind: args.kind,
+            wait: args.wait,
+            waitIntervalSeconds: args.interval,
+            waitTimeoutSeconds: args.timeout,
+        }),
+    };
+}
+export function registerAgentiaMcpAdvTools(server) {
+    server.registerTool('agentia_adv_auth_status', {
+        description: 'Check the configured Copado Pipelines Advanced PAT.',
+        inputSchema: {},
+        title: 'Agentia ADV Auth Status',
+    }, () => safelyHandleTool(async () => ({ result: await getAdvAuthStatus() })));
+    server.registerTool('agentia_adv_organization_list', {
+        description: 'List Copado Pipelines Advanced organizations visible to the PAT user.',
+        inputSchema: {},
+        title: 'Agentia ADV Organization List',
+    }, () => safelyHandleTool(async () => ({ result: await listAdvOrganizations() })));
+    server.registerTool('agentia_adv_organization_get', {
+        description: 'Get one Copado Pipelines Advanced organization.',
+        inputSchema: { id: z.number().int().positive().describe('Organization ID.') },
+        title: 'Agentia ADV Organization Get',
+    }, (args) => safelyHandleTool(async () => ({ result: await getAdvOrganization(args.id) })));
+    server.registerTool('agentia_adv_organization_validate', {
+        description: 'Validate Copado Pipelines Advanced connectivity to an organization.',
+        inputSchema: { id: z.number().int().positive().describe('Organization ID.') },
+        title: 'Agentia ADV Organization Validate',
+    }, (args) => safelyHandleTool(async () => ({ result: await validateAdvOrganization(args.id) })));
+    server.registerTool('agentia_adv_deployment_list', {
+        description: 'List Copado Pipelines Advanced deployments.',
+        inputSchema: { includeArchived: z.boolean().optional().describe('Include archived deployments.') },
+        title: 'Agentia ADV Deployment List',
+    }, (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.') },
+        title: 'Agentia ADV Deployment Get',
+    }, (args) => safelyHandleTool(async () => ({ result: await getAdvDeployment(args.id) })));
+    server.registerTool('agentia_adv_deployment_create', {
+        description: 'Create a Copado Pipelines Advanced deployment.',
+        inputSchema: {
+            name: z.string().min(1).describe('Deployment name.'),
+            sourceOrg: z.number().int().positive().describe('Source organization ID.'),
+            targetOrg: z.number().int().positive().describe('Target organization ID.'),
+        },
+        title: 'Agentia ADV Deployment Create',
+    }, (args) => safelyHandleTool(async () => ({ result: await createAdvDeployment(args) })));
+    server.registerTool('agentia_adv_deployment_options', {
+        description: 'Update Copado Pipelines Advanced deployment options.',
+        inputSchema: {
+            id: z.number().int().positive().describe('Deployment ID.'),
+            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 }) })));
+    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.'),
+            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.'),
+        },
+        title: 'Agentia ADV Deployment Validate',
+    }, (args) => safelyHandleTool(() => deploymentAction({ ...args, kind: 'validate' })));
+    server.registerTool('agentia_adv_deployment_deploy', {
+        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.'),
+            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.'),
+        },
+        title: 'Agentia ADV Deployment Deploy',
+    }, (args) => safelyHandleTool(() => deploymentAction({ ...args, kind: 'deploy' })));
+    server.registerTool('agentia_adv_deployment_quick_deploy', {
+        description: 'Start a Copado Pipelines Advanced quick deploy run.',
+        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.'),
+            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.'),
+        },
+        title: 'Agentia ADV Deployment Quick Deploy',
+    }, (args) => safelyHandleTool(() => deploymentAction({ ...args, kind: 'quick-deploy' })));
+    server.registerTool('agentia_adv_deployment_cancel', {
+        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.'),
+            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.'),
+        },
+        title: 'Agentia ADV Deployment Cancel',
+    }, (args) => safelyHandleTool(async () => {
+        requireConfirm(args.confirm, 'Pipelines Advanced deployment cancellation');
+        return {
+            result: await cancelAdvDeployment({
+                id: args.id,
+                wait: args.wait,
+                waitIntervalSeconds: args.interval,
+                waitTimeoutSeconds: args.timeout,
+            }),
+        };
+    }));
+    server.registerTool('agentia_adv_component_types', {
+        description: 'List Copado Pipelines Advanced component type views.',
+        inputSchema: {},
+        title: 'Agentia ADV Component Types',
+    }, () => safelyHandleTool(async () => ({ result: await listAdvComponentTypes() })));
+    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.'),
+            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) })));
+    server.registerTool('agentia_adv_component_refresh', {
+        description: 'Refresh Copado Pipelines Advanced component comparison cache.',
+        inputSchema: {
+            flow: z.number().int().positive().describe('Deployment ID.'),
+            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) })));
+    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.') },
+        title: 'Agentia ADV Component Selected',
+    }, (args) => safelyHandleTool(async () => ({ result: await selectedAdvComponents(args.deploymentId) })));
+    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.'),
+        },
+        title: 'Agentia ADV Component Add',
+    }, (args) => safelyHandleTool(async () => ({
+        result: await addAdvComponents({
+            components: componentList(args.components),
+            deploymentId: args.deploymentId,
+            mode: componentAddMode(args.components),
+        }),
+    })));
+    server.registerTool('agentia_adv_component_remove', {
+        description: 'Remove components from a Copado Pipelines Advanced deployment selection.',
+        inputSchema: {
+            components: componentInputSchema,
+            deploymentId: z.number().int().positive().describe('Deployment ID.'),
+        },
+        title: 'Agentia ADV Component Remove',
+    }, (args) => safelyHandleTool(async () => ({
+        result: await removeAdvComponents({ components: componentList(args.components), deploymentId: args.deploymentId }),
+    })));
+    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.') },
+        title: 'Agentia ADV Job Get',
+    }, (args) => safelyHandleTool(async () => ({ result: await getAdvJob(args.deploymentId) })));
+    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.'),
+            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) })));
+    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.'),
+            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,
+            intervalSeconds: args.interval,
+            timeoutSeconds: args.timeout,
+        });
+        assertAdvJobSucceeded(result);
+        return { result };
+    }));
+}
+//# sourceMappingURL=adv-tools.js.map

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

@@ -1,7 +1,9 @@
 export const MCP_ONLY_TOOL_NAMES = new Set(['agentia_navigation_resolve']);
-const TOP_LEVEL_COMMAND_TOPICS = new Set(['auth', 'testing']);
+const TOP_LEVEL_COMMAND_TOPICS = new Set(['adv', 'auth', 'testing']);
 const TOOL_COMMAND_ID_OVERRIDES = Object.fromEntries([
     ['agentia_ai_ask', 'ai:agent:ask'],
+    ['agentia_repository_auth_https', 'cicd:repository:auth:https:configure'],
+    ['agentia_repository_auth_ssh', 'cicd:repository:auth:ssh:configure'],
 ]);
 const HANDLER_TOOL_NAME_OVERRIDES = {
     deploymentStepCreate: 'agentia_work_deployment_step_create',
@@ -29,6 +31,7 @@ const HYPHENATED_TOKEN_REPLACEMENTS = [
     ['stage_connection', 'stage-connection'],
     ['run_local', 'run-local'],
     ['set_options', 'set-options'],
+    ['quick_deploy', 'quick-deploy'],
 ].sort((left, right) => right[0].length - left[0].length);
 export function mcpCommandIdFromToolName(toolName) {
     const trimmed = toolName.trim();

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

@@ -23,6 +23,11 @@ const CLASS_ANNOTATIONS = {
 };
 /** Triggers side effects (commit, promote, run, kill, ...). */
 const ACTION_TOOLS = [
+    'agentia_adv_component_refresh',
+    'agentia_adv_deployment_cancel',
+    'agentia_adv_deployment_deploy',
+    'agentia_adv_deployment_quick_deploy',
+    'agentia_adv_deployment_validate',
     'agentia_cloud_commit',
     'agentia_cloud_promote',
     'agentia_data_sync_apply',
@@ -57,6 +62,7 @@ const ASK_TOOLS = [
 ];
 /** Additive writes. */
 const CREATE_TOOLS = [
+    'agentia_adv_deployment_create',
     'agentia_credential_create',
     'agentia_data_commit_create',
     'agentia_data_filter_add',
@@ -106,6 +112,18 @@ const DELETE_TOOLS = [
 /** Read-only lookups. */
 const READ_TOOLS = [
     'agentia_auth_get',
+    'agentia_adv_auth_status',
+    'agentia_adv_component_list',
+    'agentia_adv_component_selected',
+    'agentia_adv_component_types',
+    'agentia_adv_job_get',
+    'agentia_adv_job_list',
+    'agentia_adv_job_wait',
+    'agentia_adv_organization_get',
+    'agentia_adv_organization_list',
+    'agentia_adv_organization_validate',
+    'agentia_adv_deployment_get',
+    'agentia_adv_deployment_list',
     'agentia_credential_list',
     'agentia_data_commit_list',
     'agentia_data_dataset_file_content',
@@ -141,6 +159,7 @@ const READ_TOOLS = [
     'agentia_metadata_list',
     'agentia_metadata_refresh_status',
     'agentia_navigation_resolve',
+    'agentia_notification_get',
     'agentia_pipeline_connection_list',
     'agentia_pipeline_get',
     'agentia_pipeline_list',
@@ -197,6 +216,10 @@ const READ_TOOLS = [
 /** Overwrites existing state. */
 const UPDATE_TOOLS = [
     'agentia_auth_set',
+    'agentia_notification_configure',
+    'agentia_adv_component_add',
+    'agentia_adv_component_remove',
+    'agentia_adv_deployment_options',
     'agentia_credential_update',
     'agentia_data_filter_update',
     'agentia_data_formula_update',