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

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

@@ -1,94 +1,3 @@
-import { AgentiaCommand } from './agentia-command.js';
-import { testingRunOptions } from './testing-flags.js';
-import { getTestingBuildForArtifacts, isSuccessfulTestingBuild, runTestingBuild, saveTestingBuildArtifacts, waitForTestingBuildResult, } from './testing-operations.js';
-import { sanitizeTestingOutput } from './testing-sanitization.js';
-import { formatTestingRecord, normalizeTestingId, } from './testing-types.js';
-import { validateTestingWatchDirectory, watchTestingDirectory } from './testing-watch.js';
-export class TestingRunCommand extends AgentiaCommand {
-    async executeTestingRun(flags, ids, label) {
-        if (flags['stream-logs'] === true && this.jsonEnabled()) {
-            this.error('--stream-logs is available only in human output mode. Remove --json.', { exit: 2 });
-        }
-        if (flags.watch !== undefined) {
-            if (this.jsonEnabled())
-                this.error('--watch cannot be used with --json.', { exit: 2 });
-            const directory = validateTestingWatchDirectory(flags.watch);
-            this.log(`Watching ${directory} for testing changes.`);
-            await watchTestingDirectory(directory, async () => {
-                this.log('Testing change detected; starting run.');
-                await this.executeTestingRunOnce({ ...flags, watch: undefined }, ids, label, true);
-            });
-        }
-        if ((flags.datatable?.length ?? 0) > 0 &&
-            (flags['wait-for-result'] === true ||
-                flags['stream-logs'] === true ||
-                flags['save-artifacts'] !== undefined ||
-                flags.xunit !== undefined)) {
-            this.error('Data-driven runs start a batch and cannot use wait, log streaming, or artifact flags.', { exit: 2 });
-        }
-        return this.executeTestingRunOnce(flags, ids, label, false);
-    }
-    async executeTestingRunOnce(flags, ids, label, watched) {
-        const runOptions = testingRunOptions(flags, ids);
-        const runResult = await this.withSpinner(`Running testing ${label}`, () => runTestingBuild(runOptions));
-        const shouldWait = flags['wait-for-result'] === true ||
-            flags['stream-logs'] === true ||
-            flags['save-artifacts'] !== undefined ||
-            flags.xunit !== undefined;
-        if (!shouldWait) {
-            this.display(() => {
-                this.log(`Testing ${label} started`);
-                this.log(formatTestingRecord({ build: runResult.build, jobId: runResult.jobId, projectId: runResult.projectId }));
-            });
-            return runResult;
-        }
-        const buildId = normalizeTestingId(runResult.build);
-        if (buildId === undefined)
-            throw new Error('CRT did not return a build ID for the started run.');
-        const wait = await this.withSpinner('Waiting for testing result', () => waitForTestingBuildResult({
-            ...runOptions,
-            buildId,
-            onLog: flags['stream-logs'] === true ? (chunk) => process.stdout.write(chunk) : undefined,
-            sensitiveValues: runOptions.parameters?.filter((parameter) => parameter.sensitive === true).map((parameter) => parameter.value ?? ''),
-            streamLogs: flags['stream-logs'],
-            timeoutMs: testingWaitTimeoutMs(flags.timeout),
-        }));
-        let finalBuild = wait.build;
-        let artifacts;
-        if (flags['save-artifacts'] !== undefined || flags.xunit !== undefined) {
-            finalBuild = await getTestingBuildForArtifacts({ ...runOptions, buildId, full: true });
-            artifacts = await saveTestingBuildArtifacts({
-                ...runOptions,
-                build: finalBuild,
-                saveArtifacts: flags['save-artifacts'],
-                xunit: flags.xunit,
-            });
-            finalBuild = sanitizeTestingOutput(finalBuild);
-        }
-        const result = { ...runResult, artifacts, finalBuild, wait };
-        this.display(() => {
-            this.log(`Testing ${label} finished`);
-            this.log(formatTestingRecord(formatWaitResult(result)));
-        });
-        if (!isSuccessfulTestingBuild(finalBuild) && flags['no-exit-code'] !== true && !watched) {
-            this.error(`Testing ${label} finished with status ${finalBuild.status ?? 'failed'}.`, { exit: 1 });
-        }
-        return result;
-    }
-}
-function testingWaitTimeoutMs(minutes = 60) {
-    if (!Number.isSafeInteger(minutes) || minutes <= 0) {
-        throw new Error('--timeout must be a positive integer number of minutes.');
-    }
-    return minutes * 60_000;
-}
-function formatWaitResult(result) {
-    return {
-        artifacts: result.artifacts,
-        buildId: result.wait?.buildId ?? normalizeTestingId(result.build),
-        finalBuild: result.finalBuild,
-        jobId: result.jobId,
-        projectId: result.projectId,
-    };
-}
-//# sourceMappingURL=testing-run-command.js.map
+import {modules} from './runtime.js';
+const TestingRunCommand = modules["testing-run-command.js"]["TestingRunCommand"]
+export {TestingRunCommand};

package/dist/lib/testing-sanitization.js

@@ -1,135 +1,9 @@
-export const TESTING_REDACTED = '[REDACTED]';
-const SENSITIVE_KEY_PATTERN = /^(?:dom|fl|html|screenshot|sessionExpiresAt)$|(?:access.?key|api.?key|authorization|cookie|credential|csrf|encryption.?key|guacamole|password|rdp|refresh.?token|secret|session.?token|signature|token|viewer.?key|xsrf)/iu;
-const CONFIGURATION_KEY_PATTERN = /^(config|configuration)$/iu;
-const LOG_KEY_PATTERN = /^(log|logs|stderr|stdout)$/iu;
-const PARAMETER_CONTAINER_PATTERN = /(input.?parameters?|parameters?|variables?)/iu;
-const BEARER_VALUE_PATTERN = /Bearer\s+[\w.~+/=-]+/giu;
-const SESSION_COOKIE_VALUE_PATTERN = /\b(?:FL|XSRF-TOKEN|sessionsToken)=[^;\s]*/giu;
-const LIVE_SECRET_VALUE_PATTERN = /\b(?:rdpAccessKey|guacamoleToken|encryptionKey|viewerKey)=([^&\s]+)/giu;
-const PROVIDER_INTERNAL_ID_PATTERN = /\b(?:(?=[a-z\d]{15,18}\b)(?=[a-z\d]*[a-z])(?=[a-z\d]*\d)[a-z\d]{15,18}|[a-f\d]{8}-[a-f\d]{4}-[1-5][a-f\d]{3}-[89ab][a-f\d]{3}-[a-f\d]{12}|\d{6,})\b/giu;
-const PROVIDER_SECRET_LIKE_VALUE_PATTERN = /\b[\w.-]*(?:authorization|cookie|encryption|guacamole|password|rdp|secret|token|xsrf)[\w.-]*\b/giu;
-const TESTING_PROVIDER_ERROR_MAX_CHARS = 2000;
-export function sanitizeTestingOutput(value, context = {}) {
-    if (Array.isArray(value)) {
-        return value.map((item) => sanitizeTestingOutput(item, context));
-    }
-    if (isRecord(value)) {
-        const result = {};
-        const sensitiveRecord = value.sensitive === true || value.type === 'secret';
-        for (const [key, nested] of Object.entries(value)) {
-            if (SENSITIVE_KEY_PATTERN.test(key) ||
-                CONFIGURATION_KEY_PATTERN.test(key) ||
-                LOG_KEY_PATTERN.test(key) ||
-                (key === 'value' && nested !== '' && (context.redactValues === true || sensitiveRecord))) {
-                result[key] = TESTING_REDACTED;
-                continue;
-            }
-            result[key] = sanitizeTestingOutput(nested, {
-                redactValues: PARAMETER_CONTAINER_PATTERN.test(key),
-            });
-        }
-        return result;
-    }
-    if (typeof value === 'string') {
-        if (context.redactValues === true)
-            return TESTING_REDACTED;
-        return sanitizeTestingString(value);
-    }
-    return value;
-}
-export function summarizeTestingDebugRequest(body, context = {}) {
-    if (body === undefined || body === null)
-        return null;
-    if (typeof body === 'string')
-        return { bytes: Buffer.byteLength(body), content: TESTING_REDACTED };
-    if (Buffer.isBuffer(body))
-        return { bytes: body.length, content: TESTING_REDACTED };
-    return sanitizeTestingOutput(body, context);
-}
-export function summarizeTestingDebugResponse(raw, responseType = 'json') {
-    if (raw.length === 0)
-        return null;
-    if (responseType === 'buffer' || responseType === 'text') {
-        return { bytes: Buffer.byteLength(raw), content: TESTING_REDACTED };
-    }
-    try {
-        return sanitizeTestingOutput(JSON.parse(raw));
-    }
-    catch {
-        return { bytes: Buffer.byteLength(raw), content: TESTING_REDACTED };
-    }
-}
-export function sanitizeTestingUrl(url) {
-    const sanitized = new URL(url);
-    if (sanitized.username.length > 0)
-        sanitized.username = TESTING_REDACTED;
-    if (sanitized.password.length > 0)
-        sanitized.password = TESTING_REDACTED;
-    for (const key of sanitized.searchParams.keys()) {
-        sanitized.searchParams.set(key, TESTING_REDACTED);
-    }
-    return sanitized.toString();
-}
-export function sanitizeTestingText(value, knownSecrets = []) {
-    let sanitized = value;
-    for (const secret of knownSecrets) {
-        if (secret.length > 0)
-            sanitized = sanitized.replaceAll(secret, TESTING_REDACTED);
-    }
-    return sanitizeTestingString(sanitized);
-}
-export function testingProviderErrorMessage(raw, statusCode) {
-    let selected;
-    try {
-        const parsed = JSON.parse(raw);
-        if (isRecord(parsed)) {
-            selected = nonBlankString(parsed.details) ?? nonBlankString(parsed.message);
-        }
-    }
-    catch {
-        // Arbitrary non-JSON response bodies are intentionally ignored.
-    }
-    const generic = `CRT request failed (${statusCode}).`;
-    if (selected === undefined)
-        return generic;
-    const sanitized = [
-        ...sanitizeTestingString(selected)
-            .replaceAll(PROVIDER_SECRET_LIKE_VALUE_PATTERN, TESTING_REDACTED)
-            .replaceAll(PROVIDER_INTERNAL_ID_PATTERN, TESTING_REDACTED),
-    ]
-        .filter((character) => {
-        const code = character.codePointAt(0) ?? 0;
-        return code === 9 || code === 10 || code === 13 || (code >= 32 && code !== 127);
-    })
-        .join('')
-        .trim();
-    if (sanitized.length === 0)
-        return generic;
-    const message = sanitized.startsWith(generic) ? sanitized : `${generic} ${sanitized}`;
-    return message.slice(0, TESTING_PROVIDER_ERROR_MAX_CHARS);
-}
-function sanitizeTestingString(value) {
-    const secretsRedacted = value
-        .replaceAll(BEARER_VALUE_PATTERN, `Bearer ${TESTING_REDACTED}`)
-        .replaceAll(SESSION_COOKIE_VALUE_PATTERN, (match) => `${match.slice(0, match.indexOf('=') + 1)}${TESTING_REDACTED}`)
-        .replaceAll(LIVE_SECRET_VALUE_PATTERN, (match) => `${match.slice(0, match.indexOf('=') + 1)}${TESTING_REDACTED}`);
-    if (!looksLikeUrl(secretsRedacted))
-        return secretsRedacted;
-    try {
-        return sanitizeTestingUrl(new URL(secretsRedacted, 'https://crt.invalid/'))
-            .replace(/^https:\/\/crt\.invalid/iu, '');
-    }
-    catch {
-        return TESTING_REDACTED;
-    }
-}
-function looksLikeUrl(value) {
-    return /^https?:\/\//iu.test(value) || (/^\//u.test(value) && value.includes('?'));
-}
-function isRecord(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-function nonBlankString(value) {
-    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
-}
-//# sourceMappingURL=testing-sanitization.js.map
+import {modules} from './runtime.js';
+const TESTING_REDACTED = modules["testing-sanitization.js"]["TESTING_REDACTED"]
+const sanitizeTestingOutput = modules["testing-sanitization.js"]["sanitizeTestingOutput"]
+const sanitizeTestingText = modules["testing-sanitization.js"]["sanitizeTestingText"]
+const sanitizeTestingUrl = modules["testing-sanitization.js"]["sanitizeTestingUrl"]
+const summarizeTestingDebugRequest = modules["testing-sanitization.js"]["summarizeTestingDebugRequest"]
+const summarizeTestingDebugResponse = modules["testing-sanitization.js"]["summarizeTestingDebugResponse"]
+const testingProviderErrorMessage = modules["testing-sanitization.js"]["testingProviderErrorMessage"]
+export {TESTING_REDACTED, sanitizeTestingOutput, sanitizeTestingText, sanitizeTestingUrl, summarizeTestingDebugRequest, summarizeTestingDebugResponse, testingProviderErrorMessage};

package/dist/lib/testing-schedule.js

@@ -1,48 +1,5 @@
-import { TestingGateway, TestingGatewayError, } from './testing-gateway.js';
-import { sanitizeTestingOutput } from './testing-sanitization.js';
-import { normalizeTestingRecord, testingJobScheduleEndpoint, } from './testing-types.js';
-export async function getTestingJobSchedule(options) {
-    try {
-        const response = await TestingGateway.call({
-            endpoint: testingJobScheduleEndpoint(options.projectId, options.jobId),
-            method: 'GET',
-            service: 'pace',
-        }, options);
-        const schedule = normalizeTestingRecord(response);
-        return schedule.schedule?.trim().length > 0 ? sanitizeTestingOutput(schedule) : undefined;
-    }
-    catch (error) {
-        if (error instanceof TestingGatewayError && error.statusCode === 404)
-            return undefined;
-        throw error;
-    }
-}
-export async function setTestingJobSchedule(options) {
-    const body = {
-        schedule: options.cron,
-        ...(options.timezone === undefined ? {} : { timezone: options.timezone }),
-        ...(options.record === undefined ? {} : { record: options.record }),
-    };
-    const existing = await getTestingJobSchedule(options);
-    const response = await TestingGateway.call({
-        body,
-        endpoint: testingJobScheduleEndpoint(options.projectId, options.jobId),
-        method: existing === undefined ? 'POST' : 'PUT',
-        service: 'pace',
-    }, options);
-    return {
-        created: existing === undefined,
-        jobId: options.jobId,
-        projectId: options.projectId,
-        schedule: sanitizeTestingOutput(normalizeTestingRecord(response)),
-    };
-}
-export async function removeTestingJobSchedule(options) {
-    await TestingGateway.call({
-        endpoint: testingJobScheduleEndpoint(options.projectId, options.jobId),
-        method: 'DELETE',
-        service: 'pace',
-    }, options);
-    return { jobId: options.jobId, projectId: options.projectId, removed: true };
-}
-//# sourceMappingURL=testing-schedule.js.map
+import {modules} from './runtime.js';
+const getTestingJobSchedule = modules["testing-schedule.js"]["getTestingJobSchedule"]
+const removeTestingJobSchedule = modules["testing-schedule.js"]["removeTestingJobSchedule"]
+const setTestingJobSchedule = modules["testing-schedule.js"]["setTestingJobSchedule"]
+export {getTestingJobSchedule, removeTestingJobSchedule, setTestingJobSchedule};

package/dist/lib/testing-secret-input.js

@@ -1,56 +1,4 @@
-import { createReadStream, lstatSync, realpathSync, statSync } from 'node:fs';
-import { resolve } from 'node:path';
-export const TESTING_SECRET_INPUT_MAX_BYTES = 1024 * 1024;
-export async function resolveTestingSecretInput(input, options) {
-    if (input.trim === true && input.noTrim === true) {
-        throw new Error('Use either --trim or --no-trim, not both.');
-    }
-    const sourceCount = [input.value !== undefined, input.valueFile !== undefined, input.valueStdin === true].filter(Boolean).length;
-    if (sourceCount > 1) {
-        throw new Error('Use exactly one of --value, --value-file, or --value-stdin.');
-    }
-    if (sourceCount === 0) {
-        if (options.required)
-            throw new Error(`Provide --value, --value-file, or --value-stdin for ${options.label}.`);
-        return undefined;
-    }
-    const raw = input.value ??
-        (input.valueFile === undefined
-            ? await readBoundedStream(process.stdin, options.label)
-            : await readBoundedSecretFile(input.valueFile, options.label));
-    const value = input.noTrim === true ? raw : raw.trim();
-    if (Buffer.byteLength(value) > TESTING_SECRET_INPUT_MAX_BYTES) {
-        throw new Error(`${options.label} exceeds the ${TESTING_SECRET_INPUT_MAX_BYTES} byte safety limit.`);
-    }
-    return value;
-}
-async function readBoundedSecretFile(path, label) {
-    if (path.trim().length === 0 || path.includes('\0'))
-        throw new Error(`${label} file path is invalid.`);
-    const target = resolve(path);
-    const linkStat = lstatSync(target);
-    if (linkStat.isSymbolicLink())
-        throw new Error(`${label} file must not be a symbolic link.`);
-    const canonical = realpathSync(target);
-    const stat = statSync(canonical);
-    if (!stat.isFile())
-        throw new Error(`${label} file must be a regular file.`);
-    if (stat.size > TESTING_SECRET_INPUT_MAX_BYTES) {
-        throw new Error(`${label} exceeds the ${TESTING_SECRET_INPUT_MAX_BYTES} byte safety limit.`);
-    }
-    return readBoundedStream(createReadStream(canonical), label);
-}
-async function readBoundedStream(stream, label) {
-    const chunks = [];
-    let size = 0;
-    for await (const chunk of stream) {
-        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-        size += bytes.length;
-        if (size > TESTING_SECRET_INPUT_MAX_BYTES) {
-            throw new Error(`${label} exceeds the ${TESTING_SECRET_INPUT_MAX_BYTES} byte safety limit.`);
-        }
-        chunks.push(bytes);
-    }
-    return Buffer.concat(chunks).toString('utf8');
-}
-//# sourceMappingURL=testing-secret-input.js.map
+import {modules} from './runtime.js';
+const TESTING_SECRET_INPUT_MAX_BYTES = modules["testing-secret-input.js"]["TESTING_SECRET_INPUT_MAX_BYTES"]
+const resolveTestingSecretInput = modules["testing-secret-input.js"]["resolveTestingSecretInput"]
+export {TESTING_SECRET_INPUT_MAX_BYTES, resolveTestingSecretInput};

package/dist/lib/testing-session.js

@@ -1,82 +1,5 @@
-import { TestingGateway } from './testing-gateway.js';
-export async function exchangeTestingSession(options = {}) {
-    const response = await TestingGateway.call({
-        endpoint: '/user/access-keys/tokens?toSign=all',
-        method: 'GET',
-        service: 'pace',
-    }, options);
-    return parseTestingSession(response);
-}
-export function parseTestingSession(response) {
-    const record = asRecord(response);
-    const fl = stringValue(record.FL, record.fl);
-    const sessionsToken = stringValue(record.sessionsToken, record.sessionToken);
-    const xsrf = parseXsrf(record.XSRF ?? record.xsrf);
-    if (fl === undefined || sessionsToken === undefined || xsrf.jwt === undefined) {
-        throw new Error('CRT session exchange returned incomplete credentials. Sign in to CRT again.');
-    }
-    assertHeaderPart(fl, 'FL');
-    assertHeaderPart(xsrf.jwt, 'XSRF');
-    assertHeaderPart(sessionsToken, 'sessions token');
-    if (xsrf.token !== undefined)
-        assertHeaderValue(xsrf.token, 'XSRF token');
-    return {
-        cookie: `FL=${fl}; XSRF-TOKEN=${xsrf.jwt}; sessionsToken=${sessionsToken}`,
-        xsrfToken: xsrf.token,
-    };
-}
-export function testingSessionAuth(session) {
-    return {
-        cookie: session.cookie,
-        mode: 'session',
-        xsrfToken: session.xsrfToken,
-    };
-}
-function parseXsrf(value) {
-    if (typeof value === 'string') {
-        return { jwt: nonBlank(value), token: extractXsrfTokenClaim(value) };
-    }
-    const record = asRecord(value);
-    const jwt = stringValue(record.jwt, record.JWT, record.value, record.cookie);
-    const token = stringValue(record.token, record.xsrfToken, record['X-XSRF-TOKEN']) ?? extractXsrfTokenClaim(jwt);
-    return { jwt, token };
-}
-function extractXsrfTokenClaim(jwt) {
-    if (jwt === undefined)
-        return undefined;
-    const encoded = jwt.split('.')[1];
-    if (encoded === undefined)
-        return undefined;
-    try {
-        const payload = JSON.parse(Buffer.from(encoded, 'base64url').toString('utf8'));
-        return nonBlank(asRecord(payload).token);
-    }
-    catch {
-        return undefined;
-    }
-}
-function stringValue(...values) {
-    for (const value of values) {
-        const normalized = nonBlank(value);
-        if (normalized !== undefined)
-            return normalized;
-    }
-    return undefined;
-}
-function nonBlank(value) {
-    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
-}
-function asRecord(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : {};
-}
-function assertHeaderPart(value, label) {
-    assertHeaderValue(value, label);
-    if (value.includes(';'))
-        throw new Error(`CRT ${label} contains an invalid cookie delimiter.`);
-}
-function assertHeaderValue(value, label) {
-    if ([...value].some((character) => character.codePointAt(0) <= 31 || character.codePointAt(0) === 127)) {
-        throw new Error(`CRT ${label} contains invalid header characters.`);
-    }
-}
-//# sourceMappingURL=testing-session.js.map
+import {modules} from './runtime.js';
+const exchangeTestingSession = modules["testing-session.js"]["exchangeTestingSession"]
+const parseTestingSession = modules["testing-session.js"]["parseTestingSession"]
+const testingSessionAuth = modules["testing-session.js"]["testingSessionAuth"]
+export {exchangeTestingSession, parseTestingSession, testingSessionAuth};