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

package/dist/lib/env-file.js

@@ -1,41 +1,5 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-let loadedPath = null;
-export function parseEnvFileContents(contents) {
-    const values = {};
-    for (const rawLine of contents.split(/\r?\n/)) {
-        const line = rawLine.trim();
-        if (line.length === 0 || line.startsWith('#')) {
-            continue;
-        }
-        const separator = line.indexOf('=');
-        if (separator === -1) {
-            continue;
-        }
-        const key = line.slice(0, separator).trim();
-        const value = line.slice(separator + 1).trim().replaceAll(/^['"]|['"]$/g, '');
-        if (key.length > 0) {
-            values[key] = value;
-        }
-    }
-    return values;
-}
-export function loadEnvFile(filePath = resolve(process.cwd(), '.env'), options = {}) {
-    if (loadedPath === filePath) {
-        return;
-    }
-    loadedPath = filePath;
-    if (!existsSync(filePath)) {
-        return;
-    }
-    const values = parseEnvFileContents(readFileSync(filePath, 'utf8'));
-    for (const [key, value] of Object.entries(values)) {
-        if (options.override || process.env[key] === undefined) {
-            process.env[key] = value;
-        }
-    }
-}
-export function resetEnvFileForTests() {
-    loadedPath = null;
-}
-//# sourceMappingURL=env-file.js.map
+import {modules} from './runtime.js';
+const loadEnvFile = modules["env-file.js"]["loadEnvFile"]
+const parseEnvFileContents = modules["env-file.js"]["parseEnvFileContents"]
+const resetEnvFileForTests = modules["env-file.js"]["resetEnvFileForTests"]
+export {loadEnvFile, parseEnvFileContents, resetEnvFileForTests};

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

@@ -1,72 +1,5 @@
-import { CicdGateway } from './cicd-gateway.js';
-import { credentialSelectionNeedsUserContext, selectEnvironmentCredential, } from './environment-credential-selection.js';
-import { environmentCredentialValidateEndpoint, environmentEndpoint, } from './environment-types.js';
-import { getUserContext } from './user-context.js';
-let testDeps;
-// Test-only hook
-export function setEnvironmentAuthStatusDepsForTests(deps) {
-    testDeps = deps;
-}
-// Test-only hook
-export function resetEnvironmentAuthStatusDepsForTests() {
-    testDeps = undefined;
-}
-function resolveCredentialName(credential) {
-    const name = credential.name?.trim();
-    if (name !== undefined && name.length > 0) {
-        return name;
-    }
-    return credential.id;
-}
-function normalizeValidationMessage(message) {
-    if (typeof message !== 'string') {
-        return undefined;
-    }
-    const trimmed = message.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
-}
-async function fetchUserContext(gatewayCall) {
-    return getUserContext({ gatewayCall });
-}
-async function fetchEnvironment(gatewayCall, environmentId) {
-    return gatewayCall({
-        endpoint: environmentEndpoint(environmentId),
-        method: 'GET',
-    });
-}
-async function validateCredential(gatewayCall, environmentId, credentialId) {
-    return gatewayCall({
-        endpoint: environmentCredentialValidateEndpoint(environmentId, credentialId),
-        method: 'POST',
-    });
-}
-export async function runEnvironmentAuthStatus(options, deps = {}) {
-    const environmentId = options.environmentId.trim();
-    if (environmentId.length === 0) {
-        throw new Error('Missing required argument: environment ID');
-    }
-    const gatewayCall = deps.gatewayCall ?? testDeps?.gatewayCall ?? CicdGateway.call.bind(CicdGateway);
-    const environment = await fetchEnvironment(gatewayCall, environmentId);
-    const credentials = environment.credentials ?? [];
-    const userContext = credentialSelectionNeedsUserContext(credentials, options.credentialId)
-        ? await fetchUserContext(gatewayCall)
-        : undefined;
-    const selection = selectEnvironmentCredential({
-        credentialId: options.credentialId,
-        credentials,
-        userFullName: userContext?.fullName ?? '',
-    });
-    if (!selection.ok) {
-        throw new Error(selection.message);
-    }
-    const { credential } = selection;
-    const validation = await validateCredential(gatewayCall, environmentId, credential.id);
-    return {
-        credentialId: credential.id,
-        credentialName: resolveCredentialName(credential),
-        environmentId,
-        message: normalizeValidationMessage(validation.message),
-        validated: validation.validated === true,
-    };
-}
-//# sourceMappingURL=environment-auth-status.js.map
+import {modules} from './runtime.js';
+const resetEnvironmentAuthStatusDepsForTests = modules["environment-auth-status.js"]["resetEnvironmentAuthStatusDepsForTests"]
+const runEnvironmentAuthStatus = modules["environment-auth-status.js"]["runEnvironmentAuthStatus"]
+const setEnvironmentAuthStatusDepsForTests = modules["environment-auth-status.js"]["setEnvironmentAuthStatusDepsForTests"]
+export {resetEnvironmentAuthStatusDepsForTests, runEnvironmentAuthStatus, setEnvironmentAuthStatusDepsForTests};

package/dist/lib/environment-auth.js

@@ -1,147 +1,6 @@
-import { formatAgentiaOAuthError } from './agentia-oauth-error-codes.js';
-import { CicdGateway } from './cicd-gateway.js';
-import { credentialSelectionNeedsUserContext, selectEnvironmentCredential, } from './environment-credential-selection.js';
-import { environmentCredentialAuthUrlEndpoint, environmentEndpoint, } from './environment-types.js';
-import { createLoopbackCallbackServer, } from './loopback-callback-server.js';
-import { isHeadlessEnvironment, openUrl } from './open-browser.js';
-import { getUserContext } from './user-context.js';
-export const DEFAULT_AUTH_TIMEOUT_SECONDS = 300;
-let testDeps;
-// Test-only hook
-export function setEnvironmentWebLoginDepsForTests(deps) {
-    testDeps = deps;
-}
-// Test-only hook
-export function resetEnvironmentWebLoginDepsForTests() {
-    testDeps = undefined;
-}
-function extractAuthUrl(response) {
-    if (typeof response === 'string' && response.trim().length > 0) {
-        return response.trim();
-    }
-    if (response && typeof response === 'object' && 'data' in response) {
-        const { data } = response;
-        if (typeof data === 'string' && data.trim().length > 0) {
-            return data.trim();
-        }
-    }
-    throw new Error('Auth URL missing or empty in server response.');
-}
-async function fetchUserContext(gatewayCall) {
-    return getUserContext({ gatewayCall });
-}
-async function fetchEnvironment(gatewayCall, environmentId) {
-    return gatewayCall({
-        endpoint: environmentEndpoint(environmentId),
-        method: 'GET',
-    });
-}
-async function fetchAuthUrl(gatewayCall, environmentId, credentialId, redirectUrl) {
-    const response = await gatewayCall({
-        endpoint: environmentCredentialAuthUrlEndpoint(environmentId, credentialId, redirectUrl),
-        method: 'GET',
-    });
-    return extractAuthUrl(response);
-}
-function formatTimeoutMessage(timeoutSeconds) {
-    const minutes = Math.max(1, Math.round(timeoutSeconds / 60));
-    return `Authentication timed out after ${minutes} minute${minutes === 1 ? '' : 's'}.`;
-}
-function resolveCredentialName(credential) {
-    return credential.name?.trim() || credential.id;
-}
-async function launchBrowserForAuth(authUrl, options, resolvedDeps) {
-    const headless = resolvedDeps.isHeadless?.() ?? isHeadlessEnvironment();
-    if (headless) {
-        if (!options.quiet) {
-            process.stdout.write('Headless environment detected. Open this URL in a browser:\n');
-            process.stdout.write(`${authUrl}\n`);
-        }
-        if (resolvedDeps.promptContinue) {
-            await resolvedDeps.promptContinue();
-        }
-        return;
-    }
-    try {
-        await (resolvedDeps.openUrl ?? openUrl)(authUrl);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : 'Failed to open browser';
-        if (!options.quiet) {
-            process.stderr.write(`${message}\nOpen this URL manually:\n${authUrl}\n`);
-        }
-    }
-}
-async function waitForAuthCallback(server, timeoutMs, timeoutSeconds) {
-    let callbackResult;
-    try {
-        callbackResult = await server.waitForCallback({ timeoutMs });
-    }
-    catch (error) {
-        const code = error instanceof Error ? error.code : undefined;
-        if (code === 'ETIMEDOUT' || (error instanceof Error && error.message.includes('timed out'))) {
-            const timeoutError = new Error(formatTimeoutMessage(timeoutSeconds));
-            timeoutError.exitCode = 130;
-            throw timeoutError;
-        }
-        throw error;
-    }
-    if (!callbackResult.ok) {
-        throw new Error(formatAgentiaOAuthError(callbackResult.errorCode ?? 'UNKNOWN', callbackResult.errorDescription));
-    }
-}
-function resolveLoopbackBindingError(port) {
-    if (port !== undefined) {
-        return new Error(`Could not bind to port ${port}. Choose another port with --port.`);
-    }
-    return new Error('Could not find an available port between 8080 and 8090. Use --port to specify one.');
-}
-export async function runEnvironmentWebLogin(options, deps = {}) {
-    const environmentId = options.environmentId.trim();
-    if (environmentId.length === 0) {
-        throw new Error('Missing required argument: environment ID');
-    }
-    const gatewayCall = deps.gatewayCall ?? testDeps?.gatewayCall ?? CicdGateway.call.bind(CicdGateway);
-    const createLoopback = deps.createLoopbackServer ?? testDeps?.createLoopbackServer ?? createLoopbackCallbackServer;
-    const timeoutSeconds = options.timeoutSeconds ?? DEFAULT_AUTH_TIMEOUT_SECONDS;
-    const timeoutMs = timeoutSeconds * 1000;
-    const resolvedDeps = { ...testDeps, ...deps };
-    const environment = await fetchEnvironment(gatewayCall, environmentId);
-    const credentials = environment.credentials ?? [];
-    const userContext = credentialSelectionNeedsUserContext(credentials, options.credentialId)
-        ? await fetchUserContext(gatewayCall)
-        : undefined;
-    const selection = selectEnvironmentCredential({
-        credentialId: options.credentialId,
-        credentials,
-        userFullName: userContext?.fullName ?? '',
-    });
-    if (!selection.ok) {
-        throw new Error(selection.message);
-    }
-    const { credential } = selection;
-    let server = null;
-    try {
-        server = await createLoopback({
-            port: options.port,
-        });
-        if (server === null) {
-            throw resolveLoopbackBindingError(options.port);
-        }
-        const authUrl = await fetchAuthUrl(gatewayCall, environmentId, credential.id, server.callbackUrl);
-        await launchBrowserForAuth(authUrl, options, resolvedDeps);
-        await waitForAuthCallback(server, timeoutMs, timeoutSeconds);
-        return {
-            callbackUrl: server.callbackUrl,
-            credentialId: credential.id,
-            credentialName: resolveCredentialName(credential),
-            environmentId,
-        };
-    }
-    finally {
-        if (server) {
-            await server.close().catch(() => { });
-        }
-    }
-}
-//# sourceMappingURL=environment-auth.js.map
+import {modules} from './runtime.js';
+const DEFAULT_AUTH_TIMEOUT_SECONDS = modules["environment-auth.js"]["DEFAULT_AUTH_TIMEOUT_SECONDS"]
+const resetEnvironmentWebLoginDepsForTests = modules["environment-auth.js"]["resetEnvironmentWebLoginDepsForTests"]
+const runEnvironmentWebLogin = modules["environment-auth.js"]["runEnvironmentWebLogin"]
+const setEnvironmentWebLoginDepsForTests = modules["environment-auth.js"]["setEnvironmentWebLoginDepsForTests"]
+export {DEFAULT_AUTH_TIMEOUT_SECONDS, resetEnvironmentWebLoginDepsForTests, runEnvironmentWebLogin, setEnvironmentWebLoginDepsForTests};

package/dist/lib/environment-credential-flags.js

@@ -1,73 +1,13 @@
-import { Flags } from '@oclif/core';
-export const CUSTOM_DOMAIN_CREDENTIALS_UNSUPPORTED_MESSAGE = 'Creating or updating credentials for Custom Domain environments is not supported.';
-export const ENVIRONMENT_TYPE_REQUIRED_MESSAGE = 'Environment type is required to create or update a credential.';
-export class EnvironmentCredentialInputError extends Error {
-    exitCode = 2;
-    constructor(message) {
-        super(message);
-        this.name = 'EnvironmentCredentialInputError';
-    }
-}
-export const credentialEnvironmentIdFlag = Flags.string({
-    description: 'Copado environment ID',
-    required: true,
-});
-export const credentialCreateFlags = {
-    default: Flags.boolean({
-        allowNo: true,
-        default: false,
-        description: 'Mark this credential as the environment default',
-    }),
-    environmentid: credentialEnvironmentIdFlag,
-    name: Flags.string({
-        description: 'Credential name',
-        required: true,
-    }),
-};
-export const credentialUpdateFlags = {
-    default: Flags.boolean({
-        allowNo: true,
-        description: 'Mark this credential as the environment default',
-    }),
-    environmentid: credentialEnvironmentIdFlag,
-    name: Flags.string({
-        description: 'Credential name',
-    }),
-};
-export const credentialListFlags = {
-    environmentid: credentialEnvironmentIdFlag,
-};
-export function collectCredentialUpdateFlagKeys(flags) {
-    const selected = [];
-    if (flags.name !== undefined) {
-        selected.push('name');
-    }
-    if (flags.default !== undefined) {
-        selected.push('default');
-    }
-    return selected;
-}
-export function validateCredentialName(name) {
-    if (typeof name === 'string' && name.trim().length === 0) {
-        return 'name value cannot be empty';
-    }
-    return undefined;
-}
-export function buildCredentialCreatePayload(name, orgType, defaultCredential) {
-    return {
-        defaultCredential,
-        name,
-        orgType,
-    };
-}
-export function buildCredentialUpdatePayload(orgType, flags) {
-    const payload = { orgType };
-    if (flags.name !== undefined) {
-        payload.name = flags.name;
-    }
-    if (flags.default !== undefined) {
-        payload.defaultCredential = flags.default;
-    }
-    return payload;
-}
-//# sourceMappingURL=environment-credential-flags.js.map
+import {modules} from './runtime.js';
+const CUSTOM_DOMAIN_CREDENTIALS_UNSUPPORTED_MESSAGE = modules["environment-credential-flags.js"]["CUSTOM_DOMAIN_CREDENTIALS_UNSUPPORTED_MESSAGE"]
+const ENVIRONMENT_TYPE_REQUIRED_MESSAGE = modules["environment-credential-flags.js"]["ENVIRONMENT_TYPE_REQUIRED_MESSAGE"]
+const EnvironmentCredentialInputError = modules["environment-credential-flags.js"]["EnvironmentCredentialInputError"]
+const buildCredentialCreatePayload = modules["environment-credential-flags.js"]["buildCredentialCreatePayload"]
+const buildCredentialUpdatePayload = modules["environment-credential-flags.js"]["buildCredentialUpdatePayload"]
+const collectCredentialUpdateFlagKeys = modules["environment-credential-flags.js"]["collectCredentialUpdateFlagKeys"]
+const credentialCreateFlags = modules["environment-credential-flags.js"]["credentialCreateFlags"]
+const credentialEnvironmentIdFlag = modules["environment-credential-flags.js"]["credentialEnvironmentIdFlag"]
+const credentialListFlags = modules["environment-credential-flags.js"]["credentialListFlags"]
+const credentialUpdateFlags = modules["environment-credential-flags.js"]["credentialUpdateFlags"]
+const validateCredentialName = modules["environment-credential-flags.js"]["validateCredentialName"]
+export {CUSTOM_DOMAIN_CREDENTIALS_UNSUPPORTED_MESSAGE, ENVIRONMENT_TYPE_REQUIRED_MESSAGE, EnvironmentCredentialInputError, buildCredentialCreatePayload, buildCredentialUpdatePayload, collectCredentialUpdateFlagKeys, credentialCreateFlags, credentialEnvironmentIdFlag, credentialListFlags, credentialUpdateFlags, validateCredentialName};

package/dist/lib/environment-credential-operations.js

@@ -1,67 +1,9 @@
-import { CicdGateway } from './cicd-gateway.js';
-import { buildCredentialCreatePayload, buildCredentialUpdatePayload, CUSTOM_DOMAIN_CREDENTIALS_UNSUPPORTED_MESSAGE, ENVIRONMENT_TYPE_REQUIRED_MESSAGE, EnvironmentCredentialInputError, } from './environment-credential-flags.js';
-import { environmentCredentialEndpoint, environmentCredentialsEndpoint, environmentEndpoint, } from './environment-types.js';
-export function sanitizeCredentialListItem(credential) {
-    const { signature, ...safeCredential } = credential;
-    if (safeCredential.authenticated === undefined && typeof signature === 'string') {
-        safeCredential.authenticated = signature.trim().length > 0;
-    }
-    return safeCredential;
-}
-export function sanitizeEnvironment(environment) {
-    if (!Array.isArray(environment.credentials)) {
-        return environment;
-    }
-    return {
-        ...environment,
-        credentials: environment.credentials.map((credential) => sanitizeCredentialListItem(credential)),
-    };
-}
-export function normalizeEnvironmentCredentials(environment) {
-    return (sanitizeEnvironment(environment).credentials ?? []);
-}
-export async function resolveEnvironmentOrgType(environmentId) {
-    const environment = await CicdGateway.call({
-        endpoint: environmentEndpoint(environmentId),
-        method: 'GET',
-    });
-    const orgType = typeof environment.type === 'string' ? environment.type.trim() : '';
-    if (orgType.length === 0) {
-        throw new EnvironmentCredentialInputError(ENVIRONMENT_TYPE_REQUIRED_MESSAGE);
-    }
-    if (orgType === 'Custom Domain') {
-        throw new EnvironmentCredentialInputError(CUSTOM_DOMAIN_CREDENTIALS_UNSUPPORTED_MESSAGE);
-    }
-    return orgType;
-}
-export async function createEnvironmentCredential(input) {
-    return CicdGateway.call({
-        body: buildCredentialCreatePayload(input.name, input.orgType, input.defaultCredential),
-        endpoint: environmentCredentialsEndpoint(input.environmentId),
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        method: 'POST',
-    });
-}
-export async function listEnvironmentCredentials(environmentIdOrName) {
-    const environment = await CicdGateway.call({
-        endpoint: environmentEndpoint(environmentIdOrName),
-        method: 'GET',
-    });
-    return normalizeEnvironmentCredentials(environment);
-}
-export async function updateEnvironmentCredential(input) {
-    return CicdGateway.call({
-        body: buildCredentialUpdatePayload(input.orgType, {
-            default: input.defaultCredential,
-            name: input.name,
-        }),
-        endpoint: environmentCredentialEndpoint(input.environmentId, input.credentialId),
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        method: 'PATCH',
-    });
-}
-//# sourceMappingURL=environment-credential-operations.js.map
+import {modules} from './runtime.js';
+const createEnvironmentCredential = modules["environment-credential-operations.js"]["createEnvironmentCredential"]
+const listEnvironmentCredentials = modules["environment-credential-operations.js"]["listEnvironmentCredentials"]
+const normalizeEnvironmentCredentials = modules["environment-credential-operations.js"]["normalizeEnvironmentCredentials"]
+const resolveEnvironmentOrgType = modules["environment-credential-operations.js"]["resolveEnvironmentOrgType"]
+const sanitizeCredentialListItem = modules["environment-credential-operations.js"]["sanitizeCredentialListItem"]
+const sanitizeEnvironment = modules["environment-credential-operations.js"]["sanitizeEnvironment"]
+const updateEnvironmentCredential = modules["environment-credential-operations.js"]["updateEnvironmentCredential"]
+export {createEnvironmentCredential, listEnvironmentCredentials, normalizeEnvironmentCredentials, resolveEnvironmentOrgType, sanitizeCredentialListItem, sanitizeEnvironment, updateEnvironmentCredential};

package/dist/lib/environment-credential-selection.js

@@ -1,60 +1,4 @@
-function normalizeName(value) {
-    return value?.trim() ?? '';
-}
-function isOwnedByUser(credential, userFullName) {
-    return normalizeName(credential.createdBy) === normalizeName(userFullName);
-}
-function findCredentialById(credentials, credentialId) {
-    return credentials.find((credential) => credential.id === credentialId);
-}
-export function credentialSelectionNeedsUserContext(credentials, credentialId) {
-    return credentialId === undefined && credentials.length > 1;
-}
-export function selectEnvironmentCredential(input) {
-    const { credentialId, credentials, userFullName } = input;
-    if (credentialId !== undefined) {
-        const credential = findCredentialById(credentials, credentialId);
-        if (credential === undefined) {
-            return {
-                message: `Credential "${credentialId}" was not found on this environment.`,
-                ok: false,
-            };
-        }
-        return { credential, ok: true };
-    }
-    if (credentials.length === 0) {
-        return {
-            message: 'No credentials exist for this environment.',
-            ok: false,
-        };
-    }
-    if (credentials.length === 1) {
-        return { credential: credentials[0], ok: true };
-    }
-    const ownedCredentials = credentials.filter((credential) => isOwnedByUser(credential, userFullName));
-    if (ownedCredentials.length === 1) {
-        return { credential: ownedCredentials[0], ok: true };
-    }
-    if (ownedCredentials.length > 1) {
-        const ownedDefault = ownedCredentials.find((credential) => credential.defaultCredential === true);
-        if (ownedDefault !== undefined) {
-            return { credential: ownedDefault, ok: true };
-        }
-        return {
-            message: 'Multiple credentials are owned by the current user and none is marked as default. Specify one with --credentialid.',
-            ok: false,
-        };
-    }
-    const environmentDefault = credentials.find((credential) => credential.defaultCredential === true);
-    if (environmentDefault !== undefined) {
-        return {
-            message: 'The default credential on this environment is not owned by the current user. Specify one with --credentialid.',
-            ok: false,
-        };
-    }
-    return {
-        message: 'No credentials owned by the current user were found on this environment. Specify one with --credentialid.',
-        ok: false,
-    };
-}
-//# sourceMappingURL=environment-credential-selection.js.map
+import {modules} from './runtime.js';
+const credentialSelectionNeedsUserContext = modules["environment-credential-selection.js"]["credentialSelectionNeedsUserContext"]
+const selectEnvironmentCredential = modules["environment-credential-selection.js"]["selectEnvironmentCredential"]
+export {credentialSelectionNeedsUserContext, selectEnvironmentCredential};