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

package/dist/lib/sf-org-context.js

@@ -1,151 +1,7 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { DEFAULT_LOCAL_SF_ORG_ALIAS } from './local-gateway-config.js';
-import { preferSalesforceId } from './salesforce-id.js';
-const execFileAsync = promisify(execFile);
-let sfOrgDisplayFn = defaultSfOrgDisplay;
-let cachedContext;
-function assertNonEmpty(value, field, orgAlias) {
-    if (value === undefined || value.trim().length === 0) {
-        throw new Error(`Salesforce org "${orgAlias}" did not return ${field}. Re-authenticate with \`sf org login web --alias ${orgAlias}\`.`);
-    }
-    return value.trim();
-}
-function sanitizeSfCliError(message, orgAlias) {
-    const cleaned = message
-        .replaceAll(/"accessToken"\s*:\s*"[^"]*"/gi, '"accessToken":"<masked>"')
-        .replaceAll(/\b00D[A-Za-z0-9]{12,15}\b/g, '<org-id>')
-        .replaceAll(/\b005[A-Za-z0-9]{12,15}\b/g, '<user-id>')
-        .trim();
-    if (cleaned.length === 0) {
-        return `Failed to resolve Salesforce org "${orgAlias}" via \`sf org display\`.`;
-    }
-    return `Failed to resolve Salesforce org "${orgAlias}" via \`sf org display\`: ${cleaned}`;
-}
-function extractJsonObject(raw) {
-    const start = raw.indexOf('{');
-    if (start === -1) {
-        throw new Error('Salesforce CLI returned non-JSON output.');
-    }
-    return JSON.parse(raw.slice(start));
-}
-function isRedactedAccessToken(value) {
-    return value.startsWith('[') || /REDACTED|show-access-token/i.test(value);
-}
-export function parseSfOrgDisplayJson(raw, orgAlias) {
-    const parsed = extractJsonObject(raw);
-    if (typeof parsed.status === 'number' && parsed.status !== 0) {
-        throw new Error(sanitizeSfCliError(parsed.message ?? parsed.name ?? 'unknown error', orgAlias));
-    }
-    if (parsed.result === undefined || typeof parsed.result === 'string') {
-        throw new Error(`Salesforce CLI response for org "${orgAlias}" is missing result data.`);
-    }
-    const orgId = assertNonEmpty(parsed.result.id ?? parsed.result.orgId, 'org Id', orgAlias);
-    const userId = assertNonEmpty(parsed.result.userId, 'user Id', orgAlias);
-    const accessToken = assertNonEmpty(parsed.result.accessToken, 'access token', orgAlias);
-    const instanceUrl = assertNonEmpty(parsed.result.instanceUrl, 'instance URL', orgAlias);
-    if (isRedactedAccessToken(accessToken)) {
-        throw new Error(`Salesforce org "${orgAlias}" access token is redacted. Set SF_TEMP_SHOW_SECRETS=true or upgrade the local gateway session resolver.`);
-    }
-    return {
-        accessToken,
-        instanceUrl: instanceUrl.replace(/\/$/, ''),
-        orgId: preferSalesforceId(orgId),
-        userId: preferSalesforceId(userId),
-        username: parsed.result.username?.trim() || undefined,
-    };
-}
-async function runSfJson(args) {
-    try {
-        const { stdout } = await execFileAsync('sf', args, {
-            encoding: 'utf8',
-            env: {
-                ...process.env,
-                SF_TEMP_SHOW_SECRETS: 'true',
-            },
-            maxBuffer: 2 * 1024 * 1024,
-        });
-        return extractJsonObject(stdout);
-    }
-    catch (error) {
-        if (error instanceof Error && 'stdout' in error && typeof error.stdout === 'string') {
-            const { stdout } = error;
-            if (stdout.trim().length > 0) {
-                return extractJsonObject(stdout);
-            }
-        }
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(sanitizeSfCliError(message, args.at(-1) ?? 'unknown'));
-    }
-}
-function resultObject(parsed, orgAlias) {
-    if (parsed.result === undefined || typeof parsed.result === 'string') {
-        throw new Error(`Salesforce CLI response for org "${orgAlias}" is missing result data.`);
-    }
-    return parsed.result;
-}
-async function resolveAccessToken(orgAlias, candidate) {
-    if (candidate !== undefined && candidate.trim().length > 0 && !isRedactedAccessToken(candidate)) {
-        return candidate.trim();
-    }
-    const tokenResponse = await runSfJson([
-        'org',
-        'auth',
-        'show-access-token',
-        '--target-org',
-        orgAlias,
-        '--json',
-        '--no-prompt',
-    ]);
-    if (typeof tokenResponse.status === 'number' && tokenResponse.status !== 0) {
-        throw new Error(sanitizeSfCliError(tokenResponse.message ?? tokenResponse.name ?? 'unknown error', orgAlias));
-    }
-    if (typeof tokenResponse.result === 'string') {
-        return assertNonEmpty(tokenResponse.result, 'access token', orgAlias);
-    }
-    return assertNonEmpty(tokenResponse.result?.accessToken, 'access token', orgAlias);
-}
-async function defaultSfOrgDisplay(orgAlias) {
-    const [orgResponse, userResponse] = await Promise.all([
-        runSfJson(['org', 'display', '--target-org', orgAlias, '--json']),
-        runSfJson(['org', 'display', 'user', '--target-org', orgAlias, '--json']),
-    ]);
-    if (typeof orgResponse.status === 'number' && orgResponse.status !== 0) {
-        throw new Error(sanitizeSfCliError(orgResponse.message ?? orgResponse.name ?? 'unknown error', orgAlias));
-    }
-    if (typeof userResponse.status === 'number' && userResponse.status !== 0) {
-        throw new Error(sanitizeSfCliError(userResponse.message ?? userResponse.name ?? 'unknown error', orgAlias));
-    }
-    const org = resultObject(orgResponse, orgAlias);
-    const user = resultObject(userResponse, orgAlias);
-    const accessToken = await resolveAccessToken(orgAlias, org.accessToken ?? user.accessToken);
-    const orgId = assertNonEmpty(org.id ?? org.orgId ?? user.orgId, 'org Id', orgAlias);
-    const userId = assertNonEmpty(user.id ?? user.userId ?? org.userId, 'user Id', orgAlias);
-    const instanceUrl = assertNonEmpty(org.instanceUrl ?? user.instanceUrl, 'instance URL', orgAlias);
-    return {
-        accessToken,
-        instanceUrl: instanceUrl.replace(/\/$/, ''),
-        orgId: preferSalesforceId(orgId),
-        userId: preferSalesforceId(userId),
-        username: (user.username ?? org.username)?.trim() || undefined,
-    };
-}
-export async function getSfOrgContext(orgAlias = DEFAULT_LOCAL_SF_ORG_ALIAS) {
-    if (cachedContext?.alias === orgAlias) {
-        return cachedContext.context;
-    }
-    const context = await sfOrgDisplayFn(orgAlias);
-    cachedContext = { alias: orgAlias, context };
-    return context;
-}
-export function setSfOrgDisplayForTests(fn) {
-    sfOrgDisplayFn = fn;
-}
-export function resetSfOrgDisplayForTests() {
-    sfOrgDisplayFn = defaultSfOrgDisplay;
-    cachedContext = undefined;
-}
-export function clearSfOrgContextCacheForTests() {
-    cachedContext = undefined;
-}
-//# sourceMappingURL=sf-org-context.js.map
+import {modules} from './runtime.js';
+const clearSfOrgContextCacheForTests = modules["sf-org-context.js"]["clearSfOrgContextCacheForTests"]
+const getSfOrgContext = modules["sf-org-context.js"]["getSfOrgContext"]
+const parseSfOrgDisplayJson = modules["sf-org-context.js"]["parseSfOrgDisplayJson"]
+const resetSfOrgDisplayForTests = modules["sf-org-context.js"]["resetSfOrgDisplayForTests"]
+const setSfOrgDisplayForTests = modules["sf-org-context.js"]["setSfOrgDisplayForTests"]
+export {clearSfOrgContextCacheForTests, getSfOrgContext, parseSfOrgDisplayJson, resetSfOrgDisplayForTests, setSfOrgDisplayForTests};

package/dist/lib/stage-flags.js

@@ -1,29 +1,7 @@
-import { Flags } from '@oclif/core';
-import { STAGE_META_STAGE_SUGGESTIONS } from './stage-types.js';
-export const stageMutationFlags = {
-    'meta-stage': Flags.string({
-        description: `Meta stage (common values: ${STAGE_META_STAGE_SUGGESTIONS.join(', ')}; custom values are allowed)`,
-    }),
-    name: Flags.string({ description: 'Stage name' }),
-};
-export const stageCreateFlags = stageMutationFlags;
-export const stageUpdateFlags = stageMutationFlags;
-export function buildStageMutationPayload(flags) {
-    const payload = {};
-    if (flags.name !== undefined)
-        payload.name = flags.name;
-    if (flags['meta-stage'] !== undefined)
-        payload.metaStage = flags['meta-stage'];
-    return payload;
-}
-export function validateStagePayload(payload, requireName = false) {
-    if (requireName && (payload.name === undefined || payload.name.trim().length === 0)) {
-        return 'name is required.';
-    }
-    for (const [key, value] of Object.entries(payload)) {
-        if (value.trim().length === 0)
-            return `${key} value cannot be empty`;
-    }
-    return undefined;
-}
-//# sourceMappingURL=stage-flags.js.map
+import {modules} from './runtime.js';
+const buildStageMutationPayload = modules["stage-flags.js"]["buildStageMutationPayload"]
+const stageCreateFlags = modules["stage-flags.js"]["stageCreateFlags"]
+const stageMutationFlags = modules["stage-flags.js"]["stageMutationFlags"]
+const stageUpdateFlags = modules["stage-flags.js"]["stageUpdateFlags"]
+const validateStagePayload = modules["stage-flags.js"]["validateStagePayload"]
+export {buildStageMutationPayload, stageCreateFlags, stageMutationFlags, stageUpdateFlags, validateStagePayload};

package/dist/lib/stage-types.js

@@ -1,69 +1,14 @@
-import { cellValue, table } from './format.js';
-import { appendListPaginationQueryParams, paginatedResultFromNestedData, } from './list-pagination.js';
-import { preferSalesforceId } from './salesforce-id.js';
-export const STAGE_META_STAGE_SUGGESTIONS = ['Build', 'Test', 'Production'];
-export function stagesEndpoint(filters = {}) {
-    const params = new URLSearchParams();
-    appendListPaginationQueryParams(params, filters);
-    const query = params.toString();
-    return query.length > 0 ? `/corpus/stages?${query}` : '/corpus/stages';
-}
-export function stageEndpoint(id) {
-    return `/corpus/stages/${encodeURIComponent(preferSalesforceId(id))}`;
-}
-export function pipelineStageConnectionsEndpoint(pipelineId) {
-    return `/corpus/pipelines/${encodeURIComponent(preferSalesforceId(pipelineId))}/stage-connections`;
-}
-export function pipelineStageConnectionEndpoint(pipelineId, connectionId) {
-    return `${pipelineStageConnectionsEndpoint(pipelineId)}/${encodeURIComponent(preferSalesforceId(connectionId))}`;
-}
-export function normalizeStagesListPage(response) {
-    return paginatedResultFromNestedData(response);
-}
-export function normalizeStage(response) {
-    if ('data' in response && response.data !== undefined) {
-        return response.data;
-    }
-    return response;
-}
-export function normalizePipelineStageConnection(response) {
-    if ('data' in response && response.data !== undefined) {
-        return response.data;
-    }
-    return response;
-}
-export function normalizePipelineStageConnections(response) {
-    if (Array.isArray(response))
-        return response;
-    if ('data' in response && Array.isArray(response.data))
-        return response.data;
-    return [];
-}
-export function formatStageTable(stages) {
-    return table([
-        { alias: 'ID', value: 'id' },
-        { alias: 'NAME', value: 'name' },
-        { alias: 'META STAGE', value: 'metaStage' },
-    ], stages.map((stage) => ({
-        id: cellValue(stage.id),
-        metaStage: cellValue(stage.metaStage),
-        name: cellValue(stage.name),
-    })));
-}
-export function formatStageDetail(stage) {
-    return [`ID: ${cellValue(stage.id)}`, `Name: ${cellValue(stage.name)}`, `Meta Stage: ${cellValue(stage.metaStage)}`].join('\n');
-}
-export function formatPipelineStageConnectionTable(connections) {
-    return table([
-        { alias: 'ID', value: 'id' },
-        { alias: 'PIPELINE ID', value: 'pipelineId' },
-        { alias: 'STAGE ID', value: 'stageId' },
-        { alias: 'NEXT CONNECTION ID', value: 'nextPipelineStageConnectionId' },
-    ], connections.map((connection) => ({
-        id: cellValue(connection.id),
-        nextPipelineStageConnectionId: cellValue(connection.nextPipelineStageConnectionId),
-        pipelineId: cellValue(connection.pipelineId),
-        stageId: cellValue(connection.stageId ?? connection.stage?.id),
-    })));
-}
-//# sourceMappingURL=stage-types.js.map
+import {modules} from './runtime.js';
+const STAGE_META_STAGE_SUGGESTIONS = modules["stage-types.js"]["STAGE_META_STAGE_SUGGESTIONS"]
+const formatPipelineStageConnectionTable = modules["stage-types.js"]["formatPipelineStageConnectionTable"]
+const formatStageDetail = modules["stage-types.js"]["formatStageDetail"]
+const formatStageTable = modules["stage-types.js"]["formatStageTable"]
+const normalizePipelineStageConnection = modules["stage-types.js"]["normalizePipelineStageConnection"]
+const normalizePipelineStageConnections = modules["stage-types.js"]["normalizePipelineStageConnections"]
+const normalizeStage = modules["stage-types.js"]["normalizeStage"]
+const normalizeStagesListPage = modules["stage-types.js"]["normalizeStagesListPage"]
+const pipelineStageConnectionEndpoint = modules["stage-types.js"]["pipelineStageConnectionEndpoint"]
+const pipelineStageConnectionsEndpoint = modules["stage-types.js"]["pipelineStageConnectionsEndpoint"]
+const stageEndpoint = modules["stage-types.js"]["stageEndpoint"]
+const stagesEndpoint = modules["stage-types.js"]["stagesEndpoint"]
+export {STAGE_META_STAGE_SUGGESTIONS, formatPipelineStageConnectionTable, formatStageDetail, formatStageTable, normalizePipelineStageConnection, normalizePipelineStageConnections, normalizeStage, normalizeStagesListPage, pipelineStageConnectionEndpoint, pipelineStageConnectionsEndpoint, stageEndpoint, stagesEndpoint};

package/dist/lib/stock-quality-gates.js

@@ -1,67 +1,5 @@
-import { chmod, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { qualityGatesScriptName, resolveLocalQualityGatesScript, runLocalQualityGates, } from './local-quality-gates.js';
-import { SAMPLE_QUALITY_GATES_UNIX, SAMPLE_QUALITY_GATES_WINDOWS } from './setup-templates.js';
-export function stockQualityGatesMissingWarning(platform) {
-    return [
-        `No project local quality gates found (${qualityGatesScriptName(platform)}).`,
-        'Running the stock Agentia sample gates from a temporary file.',
-        'Persist them by running `agentia setup` and accepting the local quality gates prompt.',
-    ].join(' ');
-}
-function assertInsideDirectory(parent, candidate) {
-    const resolvedParent = path.resolve(parent);
-    const resolved = path.resolve(candidate);
-    const relative = path.relative(resolvedParent, resolved);
-    if (relative.startsWith('..') || path.isAbsolute(relative)) {
-        throw new Error('Refusing to write stock quality gates outside the system temp directory.');
-    }
-    return resolved;
-}
-export async function createTemporaryStockQualityGatesScript(options = {}) {
-    const currentPlatform = options.platform ?? process.platform;
-    const tempRoot = path.resolve(tmpdir());
-    const tempDir = assertInsideDirectory(tempRoot, await mkdtemp(path.join(tempRoot, 'agentia-quality-gates-')));
-    const scriptPath = assertInsideDirectory(tempDir, path.join(tempDir, qualityGatesScriptName(currentPlatform)));
-    const contents = currentPlatform === 'win32' ? SAMPLE_QUALITY_GATES_WINDOWS : SAMPLE_QUALITY_GATES_UNIX;
-    await writeFile(scriptPath, contents, { encoding: 'utf8', mode: 0o700 });
-    if (currentPlatform !== 'win32') {
-        try {
-            await chmod(scriptPath, 0o700);
-        }
-        catch {
-            // Best-effort executable bit; bash invocation does not require it.
-        }
-    }
-    return {
-        async cleanup() {
-            await rm(tempDir, { force: true, recursive: true });
-        },
-        scriptPath,
-    };
-}
-export async function runWorkTestLocalQualityGates(options = {}) {
-    const existing = resolveLocalQualityGatesScript(options);
-    if (existing !== undefined) {
-        return runLocalQualityGates({ ...options, scriptPath: existing });
-    }
-    options.onWarning?.(stockQualityGatesMissingWarning(options.platform));
-    const temp = await createTemporaryStockQualityGatesScript({ platform: options.platform });
-    try {
-        const result = await runLocalQualityGates({
-            ...options,
-            scriptPath: temp.scriptPath,
-        });
-        return { ...result, usedStockScript: true };
-    }
-    finally {
-        try {
-            await temp.cleanup();
-        }
-        catch {
-            // Best-effort temp cleanup; leftover files are stock samples with no secrets.
-        }
-    }
-}
-//# sourceMappingURL=stock-quality-gates.js.map
+import {modules} from './runtime.js';
+const createTemporaryStockQualityGatesScript = modules["stock-quality-gates.js"]["createTemporaryStockQualityGatesScript"]
+const runWorkTestLocalQualityGates = modules["stock-quality-gates.js"]["runWorkTestLocalQualityGates"]
+const stockQualityGatesMissingWarning = modules["stock-quality-gates.js"]["stockQualityGatesMissingWarning"]
+export {createTemporaryStockQualityGatesScript, runWorkTestLocalQualityGates, stockQualityGatesMissingWarning};

package/dist/lib/testing-config.js

@@ -1,175 +1,17 @@
-import { readAuthProfile } from './auth-profile.js';
-import { getCredential, getCredentialForKey, getCrtDomain, getCrtOrgId } from './credential-store.js';
-import { loadEnvFile } from './env-file.js';
-export const CRT_ALLOWED_DOMAINS = [
-    'dev-robotic.copado.com',
-    'qa.robotic.copado.com',
-    'au-robotic.copado.com',
-    'ca-robotic.copado.com',
-    'eu-robotic.copado.com',
-    'gb-robotic.copado.com',
-    'in-robotic.copado.com',
-    'jp-robotic.copado.com',
-    'sg-robotic.copado.com',
-    'robotic.copado.com',
-];
-export const CRT_DISCOVERY_DOMAINS = [
-    'robotic.copado.com',
-    'sg-robotic.copado.com',
-    'eu-robotic.copado.com',
-    'ca-robotic.copado.com',
-    'au-robotic.copado.com',
-];
-const CRT_HOSTNAME_PATTERN = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)(?:\.(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?))+$/u;
-const TESTING_CONFIGURATION_FIELD_LABELS = {
-    domain: 'domain',
-    org: 'organization ID',
-    pak: 'PAK',
-};
-const TESTING_CONFIGURATION_REMEDIATION = 'Configure all required values with `agentia auth set --crt <pak> --crt-domain <domain> --crt-org <org-id>` or set AGENTIA_CRT_DOMAIN, AGENTIA_CRT_ORG, and AGENTIA_CRT_PAK. Verify with `agentia auth get --crt --json`.';
-export class TestingConfigurationError extends Error {
-    invalidFields;
-    issues;
-    missingFields;
-    constructor(issues) {
-        super(formatTestingConfigurationError(issues));
-        this.invalidFields = issues.filter((issue) => issue.kind === 'invalid').map((issue) => issue.field);
-        this.issues = issues;
-        this.missingFields = issues.filter((issue) => issue.kind === 'missing').map((issue) => issue.field);
-        this.name = 'TestingConfigurationError';
-    }
-}
-export function isCrtAllowedDomain(value) {
-    return CRT_ALLOWED_DOMAINS.includes(value);
-}
-export function normalizeCrtDomain(value) {
-    const trimmed = value.trim().replace(/^https?:\/\//iu, '').replace(/\/+$/u, '').toLowerCase();
-    if (trimmed.length === 0) {
-        throw new Error('CRT domain cannot be empty.');
-    }
-    if (trimmed.includes('/') || trimmed.includes(':') || trimmed.includes('@')) {
-        throw new Error('CRT domain must be a hostname without a path, port, or userinfo.');
-    }
-    if (isCrtAllowedDomain(trimmed)) {
-        return trimmed;
-    }
-    if (!CRT_HOSTNAME_PATTERN.test(trimmed)) {
-        throw new Error('CRT domain must be a valid hostname.');
-    }
-    return trimmed;
-}
-export function normalizeCrtOrgId(value) {
-    const raw = typeof value === 'number' ? value.toString() : value.trim();
-    if (!/^\d+$/u.test(raw)) {
-        throw new Error('CRT organization ID must be a positive integer.');
-    }
-    const parsed = Number.parseInt(raw, 10);
-    if (!Number.isSafeInteger(parsed) || parsed <= 0) {
-        throw new Error('CRT organization ID must be a positive integer.');
-    }
-    return parsed;
-}
-function envValue(...keys) {
-    for (const key of keys) {
-        const value = process.env[key]?.trim();
-        if (value !== undefined && value.length > 0) {
-            return value;
-        }
-    }
-    return undefined;
-}
-function formatIssueList(issues) {
-    return issues
-        .map((issue) => {
-        const label = TESTING_CONFIGURATION_FIELD_LABELS[issue.field];
-        return issue.message === undefined ? label : `${label} (${issue.message})`;
-    })
-        .join(', ');
-}
-export function formatTestingConfigurationFieldList(fields) {
-    return fields.map((field) => TESTING_CONFIGURATION_FIELD_LABELS[field]).join(', ');
-}
-export function formatTestingConfigurationError(issues) {
-    const missing = issues.filter((issue) => issue.kind === 'missing');
-    const invalid = issues.filter((issue) => issue.kind === 'invalid');
-    const details = [];
-    if (missing.length > 0) {
-        details.push(`Missing required CRT configuration: ${formatIssueList(missing)}.`);
-    }
-    if (invalid.length > 0) {
-        details.push(`Invalid CRT configuration: ${formatIssueList(invalid)}.`);
-    }
-    return `CRT authentication configuration is incomplete or invalid. ${details.join(' ')} ${TESTING_CONFIGURATION_REMEDIATION}`;
-}
-function hasText(value) {
-    return value !== null && value !== undefined && value.toString().trim().length > 0;
-}
-export function collectTestingConfigurationIssues(input) {
-    const issues = [];
-    if (hasText(input.domain)) {
-        try {
-            normalizeCrtDomain(input.domain);
-        }
-        catch (error) {
-            issues.push({ field: 'domain', kind: 'invalid', message: error.message });
-        }
-    }
-    else {
-        issues.push({ field: 'domain', kind: 'missing' });
-    }
-    if (hasText(input.org)) {
-        try {
-            normalizeCrtOrgId(input.org);
-        }
-        catch (error) {
-            issues.push({ field: 'org', kind: 'invalid', message: error.message });
-        }
-    }
-    else {
-        issues.push({ field: 'org', kind: 'missing' });
-    }
-    if (!hasText(input.pak)) {
-        issues.push({ field: 'pak', kind: 'missing' });
-    }
-    return issues;
-}
-export function resolveTestingCredentials(overrides = {}) {
-    loadEnvFile();
-    const local = readAuthProfile('local');
-    const localCrt = local?.crt;
-    const globalCrt = readAuthProfile('global')?.crt;
-    const localConfigured = localCrt !== undefined;
-    const metadata = localConfigured ? localCrt : globalCrt;
-    const domain = overrides.domain ?? envValue('AGENTIA_CRT_DOMAIN', 'COPADO_ROBOTIC_DOMAIN', 'CRT_DOMAIN') ?? metadata?.domain ?? (localConfigured ? undefined : getCrtDomain());
-    const org = overrides.org ?? envValue('AGENTIA_CRT_ORG', 'COPADO_ROBOTIC_ORG_ID', 'CRT_ORG') ?? metadata?.orgId ?? (localConfigured ? undefined : getCrtOrgId());
-    const scopedPak = localConfigured && local?.keychainId !== undefined
-        ? getCredentialForKey('crt', local.keychainId)
-        : undefined;
-    const pak = overrides.pak ?? overrides.pat ?? envValue('AGENTIA_CRT_PAK', 'AGENTIA_CRT_PAT', 'COPADO_ROBOTIC_API_KEY', 'CRT_AI_KEY') ?? (localConfigured ? scopedPak : getCredential('crt'));
-    const issues = collectTestingConfigurationIssues({ domain, org, pak });
-    if (issues.length > 0) {
-        throw new TestingConfigurationError(issues);
-    }
-    return {
-        domain: normalizeCrtDomain(domain),
-        orgId: normalizeCrtOrgId(org),
-        pak: pak,
-        pat: pak,
-    };
-}
-export function platformBaseUrl(domain) {
-    return `https://platform.${domain}`;
-}
-export function paceBaseUrl(domain) {
-    return `https://api.${domain}`;
-}
-export function metricsBaseUrl(domain) {
-    return `https://metrics.${domain}`;
-}
-export function testDataBaseUrl(domain) {
-    return `https://test-data.${normalizeCrtDomain(domain)}`;
-}
-export function sessionsBaseUrl(domain) {
-    return `https://sessions.${normalizeCrtDomain(domain)}`;
-}
-//# sourceMappingURL=testing-config.js.map
+import {modules} from './runtime.js';
+const CRT_ALLOWED_DOMAINS = modules["testing-config.js"]["CRT_ALLOWED_DOMAINS"]
+const CRT_DISCOVERY_DOMAINS = modules["testing-config.js"]["CRT_DISCOVERY_DOMAINS"]
+const TestingConfigurationError = modules["testing-config.js"]["TestingConfigurationError"]
+const collectTestingConfigurationIssues = modules["testing-config.js"]["collectTestingConfigurationIssues"]
+const formatTestingConfigurationError = modules["testing-config.js"]["formatTestingConfigurationError"]
+const formatTestingConfigurationFieldList = modules["testing-config.js"]["formatTestingConfigurationFieldList"]
+const isCrtAllowedDomain = modules["testing-config.js"]["isCrtAllowedDomain"]
+const metricsBaseUrl = modules["testing-config.js"]["metricsBaseUrl"]
+const normalizeCrtDomain = modules["testing-config.js"]["normalizeCrtDomain"]
+const normalizeCrtOrgId = modules["testing-config.js"]["normalizeCrtOrgId"]
+const paceBaseUrl = modules["testing-config.js"]["paceBaseUrl"]
+const platformBaseUrl = modules["testing-config.js"]["platformBaseUrl"]
+const resolveTestingCredentials = modules["testing-config.js"]["resolveTestingCredentials"]
+const sessionsBaseUrl = modules["testing-config.js"]["sessionsBaseUrl"]
+const testDataBaseUrl = modules["testing-config.js"]["testDataBaseUrl"]
+export {CRT_ALLOWED_DOMAINS, CRT_DISCOVERY_DOMAINS, TestingConfigurationError, collectTestingConfigurationIssues, formatTestingConfigurationError, formatTestingConfigurationFieldList, isCrtAllowedDomain, metricsBaseUrl, normalizeCrtDomain, normalizeCrtOrgId, paceBaseUrl, platformBaseUrl, resolveTestingCredentials, sessionsBaseUrl, testDataBaseUrl};

package/dist/lib/testing-confirmation.js

@@ -1,17 +1,5 @@
-import { confirm } from '@inquirer/prompts';
-let confirmPrompt = (options) => confirm(options);
-export async function confirmTestingAction(options) {
-    if (options.yes)
-        return true;
-    if (options.json || process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
-        throw new Error(`${options.action} requires explicit confirmation. Re-run with --yes.`);
-    }
-    return confirmPrompt({ default: false, message: options.message });
-}
-export function setTestingConfirmPromptForTests(prompt) {
-    confirmPrompt = prompt;
-}
-export function resetTestingConfirmPromptForTests() {
-    confirmPrompt = (options) => confirm(options);
-}
-//# sourceMappingURL=testing-confirmation.js.map
+import {modules} from './runtime.js';
+const confirmTestingAction = modules["testing-confirmation.js"]["confirmTestingAction"]
+const resetTestingConfirmPromptForTests = modules["testing-confirmation.js"]["resetTestingConfirmPromptForTests"]
+const setTestingConfirmPromptForTests = modules["testing-confirmation.js"]["setTestingConfirmPromptForTests"]
+export {confirmTestingAction, resetTestingConfirmPromptForTests, setTestingConfirmPromptForTests};

package/dist/lib/testing-data-command.js

@@ -1,49 +1,8 @@
-import { Flags } from '@oclif/core';
-import { buildTestingDataDisplayGrid, prepareTestingData, } from './testing-data-core.js';
-import { readTestingDataInput } from './testing-data-import.js';
-import { TESTING_DATA_HEADER_ORIENTATIONS, } from './testing-data-types.js';
-export const testingDataJobFlag = {
-    job: Flags.integer({ description: 'Optional CRT job/test ID filter.', min: 1 }),
-};
-export const testingDataRevisionFlag = {
-    revision: Flags.string({ char: 'r', description: 'Specific data-table revision/version.' }),
-};
-export const testingDataInputFlags = {
-    file: Flags.string({ description: 'Read data from a CSV, TSV, JSON, or XLSX file.' }),
-    header: Flags.option({
-        default: 'row',
-        description: 'Location of variable headers in imported data.',
-        options: [...TESTING_DATA_HEADER_ORIENTATIONS],
-    })(),
-    'json-data': Flags.string({ description: 'Inline JSON array of row arrays. Mutually exclusive with --file/--stdin.' }),
-    stdin: Flags.boolean({ description: 'Read CSV, TSV, or JSON data from stdin.' }),
-};
-export async function prepareTestingDataInput(flags) {
-    const matrix = await readTestingDataInput({
-        file: flags.file,
-        header: flags.header,
-        jsonData: flags['json-data'],
-        stdin: flags.stdin,
-    });
-    return prepareTestingData(matrix, flags.header);
-}
-export function parseTestingDataTopics(value) {
-    return value?.split(',').map((topic) => topic.trim()).filter(Boolean);
-}
-export function formatTestingDataTableHuman(table, previewRows = 5) {
-    const { headers, rows } = buildTestingDataDisplayGrid(table);
-    const lines = [
-        `ID: ${table.id ?? ''}`,
-        `Name: ${table.name ?? ''}`,
-        `Version: ${table.version ?? ''}`,
-        `Datasets: ${Math.max((table.data?.length ?? 1) - 1, 0)}`,
-        `Variables: ${table.data?.[0]?.length ?? 0}`,
-    ];
-    if (headers.length > 0) {
-        lines.push('', headers.join('\t'), ...rows.slice(0, previewRows).map((row) => row.join('\t')));
-        if (rows.length > previewRows)
-            lines.push(`… ${rows.length - previewRows} more variable(s)`);
-    }
-    return lines.join('\n');
-}
-//# sourceMappingURL=testing-data-command.js.map
+import {modules} from './runtime.js';
+const formatTestingDataTableHuman = modules["testing-data-command.js"]["formatTestingDataTableHuman"]
+const parseTestingDataTopics = modules["testing-data-command.js"]["parseTestingDataTopics"]
+const prepareTestingDataInput = modules["testing-data-command.js"]["prepareTestingDataInput"]
+const testingDataInputFlags = modules["testing-data-command.js"]["testingDataInputFlags"]
+const testingDataJobFlag = modules["testing-data-command.js"]["testingDataJobFlag"]
+const testingDataRevisionFlag = modules["testing-data-command.js"]["testingDataRevisionFlag"]
+export {formatTestingDataTableHuman, parseTestingDataTopics, prepareTestingDataInput, testingDataInputFlags, testingDataJobFlag, testingDataRevisionFlag};