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

package/dist/lib/testing-gateway.js

@@ -1,363 +1,15 @@
-import * as http from 'node:http';
-import * as https from 'node:https';
-import { URL } from 'node:url';
-import { createTransactionId, CRT_GATEWAY_EVENT_SERVICE, gatewayRefererHeaders, gatewayUserAgent, getGatewayTransactionId, scheduleGatewayEventLog, } from './cicd-gateway.js';
-import { logVerboseDebug } from './debug.js';
-import { CRT_DISCOVERY_DOMAINS, metricsBaseUrl, normalizeCrtDomain, paceBaseUrl, platformBaseUrl, resolveTestingCredentials, sessionsBaseUrl, testDataBaseUrl, } from './testing-config.js';
-import { sanitizeTestingUrl, summarizeTestingDebugRequest, summarizeTestingDebugResponse, TESTING_REDACTED, testingProviderErrorMessage, } from './testing-sanitization.js';
-import { testingProjectsEndpoint } from './testing-types.js';
-export const TESTING_DEFAULT_TIMEOUT_MS = 45_000;
-export const TESTING_MAX_RESPONSE_BYTES = 10 * 1024 * 1024;
-export const TESTING_MAX_ARTIFACT_BYTES = 100 * 1024 * 1024;
-export class TestingGatewayError extends Error {
-    requestMethod;
-    requestUrl;
-    retryAfterSeconds;
-    statusCode;
-    constructor(message, options = {}) {
-        super(message);
-        this.name = 'TestingGatewayError';
-        this.requestMethod = options.request?.method;
-        this.requestUrl = options.request?.url;
-        this.retryAfterSeconds = options.retryAfterSeconds;
-        this.statusCode = options.statusCode;
-    }
-}
-function userAgent() {
-    return gatewayUserAgent();
-}
-function transactionIdForRequest() {
-    return getGatewayTransactionId() ?? createTransactionId();
-}
-function parseRetryAfterHeader(value) {
-    if (value === undefined)
-        return undefined;
-    const raw = Array.isArray(value) ? value[0] : value;
-    if (raw === undefined)
-        return undefined;
-    if (typeof raw === 'number')
-        return Number.isFinite(raw) && raw >= 0 ? Math.ceil(raw) : undefined;
-    const trimmed = raw.trim();
-    if (/^\d+$/u.test(trimmed))
-        return Number.parseInt(trimmed, 10);
-    const dateMs = Date.parse(trimmed);
-    return Number.isNaN(dateMs) ? undefined : Math.max(0, Math.ceil((dateMs - Date.now()) / 1000));
-}
-function defaultHttpsRequest(url, method, headers, body, timeoutMs, maxResponseBytes = TESTING_MAX_RESPONSE_BYTES) {
-    const hasBody = body !== undefined;
-    const payload = hasBody ? (typeof body === 'string' ? body : JSON.stringify(body)) : '';
-    const requestHeaders = {
-        Accept: 'application/json',
-        ...headers,
-    };
-    if (hasBody) {
-        requestHeaders['Content-Type'] = requestHeaders['Content-Type'] ?? 'application/json';
-        requestHeaders['Content-Length'] = Buffer.byteLength(payload).toString();
-    }
-    const transport = url.protocol === 'http:' ? http : https;
-    return new Promise((resolve, reject) => {
-        const req = transport.request({
-            headers: requestHeaders,
-            hostname: url.hostname,
-            method,
-            path: `${url.pathname}${url.search}`,
-            port: url.port.length > 0 ? Number(url.port) : undefined,
-            timeout: timeoutMs,
-        }, (res) => {
-            const chunks = [];
-            let responseBytes = 0;
-            res.on('data', (chunk) => {
-                responseBytes += chunk.length;
-                if (responseBytes > maxResponseBytes) {
-                    req.destroy(new TestingGatewayError(`CRT response exceeded the ${maxResponseBytes} byte safety limit.`));
-                    return;
-                }
-                chunks.push(chunk);
-            });
-            res.on('end', () => {
-                const raw = Buffer.concat(chunks);
-                const status = res.statusCode ?? 0;
-                if (status >= 400) {
-                    const text = raw.toString('utf8');
-                    logVerboseDebug('CRT response', {
-                        body: summarizeTestingDebugResponse(text),
-                        status,
-                    });
-                    reject(new TestingGatewayError(testingProviderErrorMessage(text, status), {
-                        retryAfterSeconds: status === 429 ? parseRetryAfterHeader(res.headers['retry-after']) : undefined,
-                        statusCode: status,
-                    }));
-                    return;
-                }
-                resolve(raw);
-            });
-        });
-        req.on('error', (error) => reject(error));
-        req.on('timeout', () => {
-            req.destroy(new Error(`CRT request timed out after ${Math.ceil(timeoutMs / 1000)} seconds.`));
-        });
-        if (hasBody)
-            req.write(payload);
-        req.end();
-    });
-}
-let httpRequestFn = defaultHttpsRequest;
-function requestUrl(request, domain) {
-    if (request.service === 'session') {
-        if (request.sessionPath === undefined) {
-            throw new TestingGatewayError('CRT session requests require a validated session path.');
-        }
-        const base = resolveTestingSessionUrl(request.sessionPath, domain);
-        if (!/^\/api\/[a-z-]+$/u.test(request.endpoint)) {
-            throw new TestingGatewayError('CRT session endpoint has an unexpected format.');
-        }
-        return new URL(`${base.pathname}${request.endpoint}`, `${base.protocol}//${base.host}`);
-    }
-    const baseUrl = request.service === 'platform'
-        ? platformBaseUrl(domain)
-        : request.service === 'metrics'
-            ? metricsBaseUrl(domain)
-            : request.service === 'test-data'
-                ? testDataBaseUrl(domain)
-                : paceBaseUrl(domain);
-    return new URL(request.endpoint, `${baseUrl}/`);
-}
-function withRequestSuffix(message, request) {
-    const suffix = request.url === undefined ? '' : ` Request: ${request.method ?? ''} ${request.url}`.trimEnd();
-    if (suffix.length === 0)
-        return message;
-    return message.endsWith('.') ? `${message} ${suffix}` : `${message}. ${suffix}`;
-}
-function maskTestingHeaders(headers) {
-    const masked = {};
-    for (const [key, value] of Object.entries(headers)) {
-        masked[key] = /authorization|cookie|csrf|xsrf/iu.test(key) ? TESTING_REDACTED : value;
-    }
-    return masked;
-}
-async function executeTestingRequest(request, options = {}) {
-    const credentials = resolveTestingCredentials(options);
-    if (request.service === 'test-data' && request.auth?.mode !== 'session') {
-        throw new TestingGatewayError('CRT test-data requests require an in-memory session.');
-    }
-    if (request.service === 'session' && request.auth?.mode !== 'session') {
-        throw new TestingGatewayError('CRT live session requests require an in-memory session.');
-    }
-    if (request.service === 'test-data' &&
-        Object.keys(request.headers ?? {}).some((key) => key.toLowerCase() === 'x-authorization')) {
-        throw new TestingGatewayError('CRT test-data requests must not send X-Authorization.');
-    }
-    if (request.service !== 'test-data' && request.service !== 'session' && request.auth !== undefined) {
-        throw new TestingGatewayError('CRT session authentication is restricted to session services.');
-    }
-    const url = requestUrl(request, credentials.domain);
-    const safeUrl = sanitizeTestingUrl(url);
-    const requestInfo = { method: request.method, url: safeUrl };
-    const transactionId = transactionIdForRequest();
-    const authenticationHeaders = {};
-    if (request.auth?.mode === 'session') {
-        authenticationHeaders.Cookie = request.auth.cookie;
-        if (request.auth.xsrfToken !== undefined)
-            authenticationHeaders['X-XSRF-TOKEN'] = request.auth.xsrfToken;
-    }
-    else {
-        authenticationHeaders['X-Authorization'] = credentials.pak;
-    }
-    const headers = {
-        ...gatewayRefererHeaders(),
-        ...request.headers,
-        'User-Agent': userAgent(),
-        ...authenticationHeaders,
-        'x-transaction-id': transactionId,
-    };
-    let raw;
-    logVerboseDebug('CRT request', {
-        body: summarizeTestingDebugRequest(request.body, {
-            redactValues: request.service === 'session' ||
-                request.endpoint.includes('/secrets') ||
-                request.endpoint.includes('/user-parameters'),
-        }),
-        headers: maskTestingHeaders(headers),
-        method: request.method,
-        url: safeUrl,
-    });
-    try {
-        scheduleGatewayEventLog({
-            eventId: transactionId,
-            method: request.method,
-            orgId: credentials.orgId.toString(),
-            service: CRT_GATEWAY_EVENT_SERVICE,
-            url: safeUrl,
-        });
-        raw = await httpRequestFn(url, request.method, headers, request.body, options.timeoutMs ?? TESTING_DEFAULT_TIMEOUT_MS, request.maxResponseBytes ?? TESTING_MAX_RESPONSE_BYTES);
-    }
-    catch (error) {
-        if (error instanceof TestingGatewayError) {
-            const message = error.statusCode === undefined
-                ? error.message.startsWith('CRT response exceeded')
-                    ? error.message
-                    : 'CRT request failed.'
-                : testingProviderErrorMessage(JSON.stringify({ message: error.message }), error.statusCode);
-            const safeMessage = request.service === 'session' ? message : withRequestSuffix(message, requestInfo);
-            throw new TestingGatewayError(safeMessage, {
-                request: requestInfo,
-                retryAfterSeconds: error.retryAfterSeconds,
-                statusCode: error.statusCode,
-            });
-        }
-        const message = request.service === 'session'
-            ? 'CRT live request failed before receiving a response.'
-            : withRequestSuffix('CRT request failed before receiving a response', requestInfo);
-        throw new TestingGatewayError(message, {
-            request: requestInfo,
-        });
-    }
-    const responseBuffer = typeof raw === 'string' ? Buffer.from(raw, 'utf8') : raw;
-    const responseText = responseBuffer.toString('utf8');
-    logVerboseDebug('CRT response', summarizeTestingDebugResponse(responseText, request.responseType));
-    if (responseBuffer.length === 0)
-        return undefined;
-    if (request.responseType === 'buffer')
-        return responseBuffer;
-    if (request.responseType === 'text')
-        return responseText;
-    try {
-        return JSON.parse(responseText);
-    }
-    catch {
-        throw new TestingGatewayError(withRequestSuffix('CRT API returned an unexpected non-JSON response', requestInfo), {
-            request: requestInfo,
-        });
-    }
-}
-export class TestingGateway {
-    static async call(request, options = {}) {
-        return executeTestingRequest(request, options);
-    }
-    static async downloadArtifact(location, options = {}) {
-        const credentials = resolveTestingCredentials(options);
-        const url = resolveTestingArtifactUrl(location, credentials.domain);
-        return executeTestingRequest({
-            endpoint: `${url.pathname}${url.search}`,
-            maxResponseBytes: TESTING_MAX_ARTIFACT_BYTES,
-            method: 'GET',
-            responseType: 'buffer',
-            service: 'pace',
-        }, options);
-    }
-    static async resolveAndValidateDomain(pat, orgId, customDomain) {
-        return resolveAndValidateCrtDomain(pat, orgId, customDomain);
-    }
-    static async validateCredentials(options) {
-        await validateCrtCredentials(options);
-    }
-}
-export function resolveTestingArtifactUrl(location, configuredDomain) {
-    const value = location.trim();
-    if (value.length === 0)
-        throw new Error('CRT artifact URL is empty.');
-    if (value.startsWith('//'))
-        throw new Error('CRT artifact URL must be relative or use HTTPS.');
-    const expectedHost = `api.${normalizeCrtDomain(configuredDomain)}`;
-    const absolute = /^[a-z][a-z\d+.-]*:/iu.test(value);
-    if (!absolute) {
-        let decodedPath;
-        try {
-            decodedPath = decodeURIComponent(value.split(/[?#]/u, 1)[0] ?? '');
-        }
-        catch {
-            throw new Error('CRT artifact URL contains invalid path encoding.');
-        }
-        if (decodedPath.split('/').includes('..')) {
-            throw new Error('CRT artifact URL must not contain path traversal.');
-        }
-    }
-    const url = new URL(value, `https://${expectedHost}/`);
-    if (url.protocol !== 'https:' || url.hostname !== expectedHost || url.port.length > 0) {
-        throw new Error(`CRT artifact URL must use HTTPS on ${expectedHost}.`);
-    }
-    if (url.username.length > 0 || url.password.length > 0) {
-        throw new Error('CRT artifact URL must not contain credentials.');
-    }
-    if (absolute && !value.toLowerCase().startsWith('https://')) {
-        throw new Error('CRT artifact URL must be relative or use HTTPS.');
-    }
-    return url;
-}
-export function resolveTestingSessionUrl(location, configuredDomain) {
-    const expectedHost = `sessions.${normalizeCrtDomain(configuredDomain)}`;
-    const value = location.trim();
-    if (value.length === 0 || value.startsWith('//'))
-        throw new Error('CRT live session URL is invalid.');
-    const url = new URL(value, `${sessionsBaseUrl(configuredDomain)}/`);
-    if (url.protocol !== 'https:' ||
-        url.hostname !== expectedHost ||
-        url.port.length > 0 ||
-        url.username.length > 0 ||
-        url.password.length > 0) {
-        throw new Error(`CRT live session URL must use HTTPS on ${expectedHost}.`);
-    }
-    if (url.search.length > 0 || url.hash.length > 0) {
-        throw new Error('CRT live session URL must not contain query parameters or fragments.');
-    }
-    let decodedPath;
-    try {
-        decodedPath = decodeURIComponent(url.pathname);
-    }
-    catch {
-        throw new Error('CRT live session URL contains invalid path encoding.');
-    }
-    if (decodedPath.split('/').includes('..') || !/^\/live-testing\/\d+\/?$/u.test(decodedPath)) {
-        throw new Error('CRT live session URL has an unexpected path.');
-    }
-    url.pathname = decodedPath.replace(/\/$/u, '');
-    return url;
-}
-export function resolveTestingSessionWebSocketUrl(sessionPath, configuredDomain) {
-    const session = resolveTestingSessionUrl(sessionPath, configuredDomain);
-    const url = new URL(session);
-    url.protocol = 'wss:';
-    url.pathname = `${url.pathname}/client/websocket`;
-    return url;
-}
-export async function validateCrtCredentials(options) {
-    const domain = normalizeCrtDomain(options.domain);
-    await executeTestingRequest({
-        endpoint: testingProjectsEndpoint(options.orgId),
-        method: 'GET',
-        service: 'platform',
-    }, {
-        domain,
-        org: options.orgId,
-        pat: options.pat,
-    });
-}
-export async function discoverCrtDomain(pat, orgId) {
-    for (const domain of CRT_DISCOVERY_DOMAINS) {
-        try {
-            // Sequential probing is intentional: stop at the first domain that validates.
-            // eslint-disable-next-line no-await-in-loop
-            await validateCrtCredentials({ domain, orgId, pat });
-            return domain;
-        }
-        catch {
-            continue;
-        }
-    }
-    throw new Error('CRT credentials could not be validated. Specify a custom domain.');
-}
-export async function resolveAndValidateCrtDomain(pat, orgId, customDomain) {
-    if (customDomain !== undefined) {
-        const domain = normalizeCrtDomain(customDomain);
-        await validateCrtCredentials({ domain, orgId, pat });
-        return domain;
-    }
-    return discoverCrtDomain(pat, orgId);
-}
-export function setTestingHttpRequestForTests(requestFn) {
-    httpRequestFn = requestFn;
-}
-export function resetTestingHttpRequestForTests() {
-    httpRequestFn = defaultHttpsRequest;
-}
-//# sourceMappingURL=testing-gateway.js.map
+import {modules} from './runtime.js';
+const TESTING_DEFAULT_TIMEOUT_MS = modules["testing-gateway.js"]["TESTING_DEFAULT_TIMEOUT_MS"]
+const TESTING_MAX_ARTIFACT_BYTES = modules["testing-gateway.js"]["TESTING_MAX_ARTIFACT_BYTES"]
+const TESTING_MAX_RESPONSE_BYTES = modules["testing-gateway.js"]["TESTING_MAX_RESPONSE_BYTES"]
+const TestingGateway = modules["testing-gateway.js"]["TestingGateway"]
+const TestingGatewayError = modules["testing-gateway.js"]["TestingGatewayError"]
+const discoverCrtDomain = modules["testing-gateway.js"]["discoverCrtDomain"]
+const resetTestingHttpRequestForTests = modules["testing-gateway.js"]["resetTestingHttpRequestForTests"]
+const resolveAndValidateCrtDomain = modules["testing-gateway.js"]["resolveAndValidateCrtDomain"]
+const resolveTestingArtifactUrl = modules["testing-gateway.js"]["resolveTestingArtifactUrl"]
+const resolveTestingSessionUrl = modules["testing-gateway.js"]["resolveTestingSessionUrl"]
+const resolveTestingSessionWebSocketUrl = modules["testing-gateway.js"]["resolveTestingSessionWebSocketUrl"]
+const setTestingHttpRequestForTests = modules["testing-gateway.js"]["setTestingHttpRequestForTests"]
+const validateCrtCredentials = modules["testing-gateway.js"]["validateCrtCredentials"]
+export {TESTING_DEFAULT_TIMEOUT_MS, TESTING_MAX_ARTIFACT_BYTES, TESTING_MAX_RESPONSE_BYTES, TestingGateway, TestingGatewayError, discoverCrtDomain, resetTestingHttpRequestForTests, resolveAndValidateCrtDomain, resolveTestingArtifactUrl, resolveTestingSessionUrl, resolveTestingSessionWebSocketUrl, setTestingHttpRequestForTests, validateCrtCredentials};

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

@@ -1,56 +1,6 @@
-import { Flags } from '@oclif/core';
-export const testingLiveCommonFlags = {
-    project: Flags.integer({
-        char: 'p',
-        description: 'CRT project ID.',
-        required: true,
-    }),
-    'session-id': Flags.integer({
-        description: 'Guard that must match the locally active CRT live session.',
-        min: 1,
-    }),
-};
-export const testingLiveRecorderOptionFlags = {
-    enable: Flags.boolean({ allowNo: true, description: 'Enable or disable interaction recording.' }),
-    'healing-context': Flags.boolean({ allowNo: true, description: 'Capture recorder healing context.' }),
-    'hover-text': Flags.boolean({ allowNo: true, description: 'Capture HoverText interactions.' }),
-    'scroll-text': Flags.boolean({ allowNo: true, description: 'Capture ScrollText interactions.' }),
-    'system-state': Flags.boolean({ allowNo: true, description: 'Capture console/network system state.' }),
-    'table-keywords': Flags.boolean({ allowNo: true, description: 'Prefer table-aware interaction keywords.' }),
-    'verify-text': Flags.boolean({ allowNo: true, description: 'Capture VerifyText interactions.' }),
-};
-export function testingLiveRecorderOptions(flags) {
-    return {
-        enabled: flags.enable ?? false,
-        enableHealingContext: flags['healing-context'] ?? false,
-        enableHoverText: flags['hover-text'] ?? false,
-        enableScrollText: flags['scroll-text'] ?? false,
-        enableSystemState: flags['system-state'] ?? false,
-        enableVerifyText: flags['verify-text'] ?? false,
-        preferTableKeywords: flags['table-keywords'] ?? false,
-    };
-}
-export function parseTestingLiveScreen(screen, viewport) {
-    if (screen !== undefined && viewport !== undefined)
-        throw new Error('Use either --screen or --viewport, not both.');
-    const spec = screen ?? (viewport === undefined ? undefined : `${viewport}x24`);
-    if (spec === undefined)
-        return undefined;
-    const match = /^(\d+)x(\d+)x(\d+)$/u.exec(spec.trim());
-    if (match === null)
-        throw new Error('CRT live screen must use WIDTHxHEIGHTxDEPTH.');
-    const [width, height, depth] = match.slice(1).map(Number);
-    if (width === undefined ||
-        height === undefined ||
-        depth === undefined ||
-        width < 320 ||
-        width > 7680 ||
-        height < 240 ||
-        height > 4320 ||
-        depth < 8 ||
-        depth > 32) {
-        throw new Error('CRT live screen dimensions are outside supported safety limits.');
-    }
-    return { depth, height, width };
-}
-//# sourceMappingURL=testing-live-command.js.map
+import {modules} from './runtime.js';
+const parseTestingLiveScreen = modules["testing-live-command.js"]["parseTestingLiveScreen"]
+const testingLiveCommonFlags = modules["testing-live-command.js"]["testingLiveCommonFlags"]
+const testingLiveRecorderOptionFlags = modules["testing-live-command.js"]["testingLiveRecorderOptionFlags"]
+const testingLiveRecorderOptions = modules["testing-live-command.js"]["testingLiveRecorderOptions"]
+export {parseTestingLiveScreen, testingLiveCommonFlags, testingLiveRecorderOptionFlags, testingLiveRecorderOptions};

package/dist/lib/testing-live-endpoints.js

@@ -1,34 +1,6 @@
-export function testingLiveJobSessionEndpoint(projectId, jobId) {
-    return `/pace/v4/projects/${positiveId(projectId, 'project')}/jobs/${positiveId(jobId, 'job')}/sessions`;
-}
-export const TESTING_LIVE_API_ENDPOINTS = {
-    continue: '/api/continue',
-    download: '/api/download',
-    interrupt: '/api/interrupt',
-    keyword: '/api/keyword',
-    setOptions: '/api/setoptions',
-    start: '/api/start',
-    status: '/api/status',
-    stop: '/api/stop',
-    systemState: '/api/system-state',
-};
-export function testingLiveSessionPath(sessionId) {
-    return `/live-testing/${positiveId(sessionId, 'session')}`;
-}
-export function validateTestingLiveSessionPath(value, sessionId) {
-    const trimmed = value.trim();
-    if (!/^\/live-testing\/\d+\/?$/u.test(trimmed)) {
-        throw new Error('CRT live session path has an unexpected format.');
-    }
-    const normalized = trimmed.replace(/\/$/u, '');
-    if (sessionId !== undefined && normalized !== testingLiveSessionPath(sessionId)) {
-        throw new Error('CRT live session path does not match the returned session ID.');
-    }
-    return normalized;
-}
-function positiveId(value, label) {
-    if (!Number.isSafeInteger(value) || value <= 0)
-        throw new Error(`CRT ${label} ID must be a positive integer.`);
-    return value;
-}
-//# sourceMappingURL=testing-live-endpoints.js.map
+import {modules} from './runtime.js';
+const TESTING_LIVE_API_ENDPOINTS = modules["testing-live-endpoints.js"]["TESTING_LIVE_API_ENDPOINTS"]
+const testingLiveJobSessionEndpoint = modules["testing-live-endpoints.js"]["testingLiveJobSessionEndpoint"]
+const testingLiveSessionPath = modules["testing-live-endpoints.js"]["testingLiveSessionPath"]
+const validateTestingLiveSessionPath = modules["testing-live-endpoints.js"]["validateTestingLiveSessionPath"]
+export {TESTING_LIVE_API_ENDPOINTS, testingLiveJobSessionEndpoint, testingLiveSessionPath, validateTestingLiveSessionPath};

package/dist/lib/testing-live-history.js

@@ -1,96 +1,7 @@
-import { randomUUID } from 'node:crypto';
-import { chmodSync, closeSync, mkdirSync, openSync, readFileSync, writeSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { getDefaultsStorePaths } from './defaults-store.js';
-import { summarizeTestingLiveKeywordLines } from './testing-live-robot.js';
-import { sanitizeTestingOutput } from './testing-sanitization.js';
-export const TESTING_LIVE_HISTORY_MAX_LINE_BYTES = 64 * 1024;
-export const TESTING_LIVE_HISTORY_MAX_READ_BYTES = 4 * 1024 * 1024;
-export const TESTING_LIVE_HISTORY_MAX_LIMIT = 500;
-export function appendTestingLiveHistory(record) {
-    const clean = sanitizeRecord(record);
-    const path = historyPath(clean.projectId, clean.jobId);
-    mkdirSync(dirname(path), { mode: 0o700, recursive: true });
-    const line = `${JSON.stringify(clean)}\n`;
-    if (Buffer.byteLength(line) > TESTING_LIVE_HISTORY_MAX_LINE_BYTES) {
-        throw new Error('CRT live history record exceeds the safety limit.');
-    }
-    const descriptor = openSync(path, 'a', 0o600);
-    try {
-        writeSync(descriptor, line, undefined, 'utf8');
-    }
-    finally {
-        closeSync(descriptor);
-    }
-    chmodSync(path, 0o600);
-}
-export function readTestingLiveHistory(options) {
-    const path = historyPath(options.projectId, options.jobId);
-    const limit = Math.min(Math.max(options.limit ?? 10, 1), TESTING_LIVE_HISTORY_MAX_LIMIT);
-    let contents;
-    try {
-        contents = readFileSync(path, 'utf8');
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return [];
-        throw error;
-    }
-    const tail = Buffer.from(contents).subarray(-TESTING_LIVE_HISTORY_MAX_READ_BYTES).toString('utf8');
-    const firstNewline = tail.indexOf('\n');
-    const bounded = Buffer.byteLength(contents) > TESTING_LIVE_HISTORY_MAX_READ_BYTES && firstNewline !== -1
-        ? tail.slice(firstNewline + 1)
-        : tail;
-    return bounded
-        .split('\n')
-        .filter(Boolean)
-        .map((line) => parseRecord(line))
-        .filter((record) => record !== undefined)
-        .filter((record) => options.status === undefined || record.status === options.status)
-        .slice(-limit)
-        .reverse();
-}
-function historyPath(projectId, jobId) {
-    return join(dirname(getDefaultsStorePaths().globalPath), 'testing-live', safeId(projectId, 'project'), `${safeId(jobId, 'job')}.jsonl`);
-}
-function safeId(value, label) {
-    if (!Number.isSafeInteger(value) || value <= 0)
-        throw new Error(`CRT ${label} ID must be a positive integer.`);
-    return value.toString();
-}
-function sanitizeRecord(value) {
-    const lines = summarizeTestingLiveKeywordLines(value.lines)
-        .slice(0, 500)
-        .map((line) => sanitizeTestingOutput(line.replaceAll('\0', '')).slice(0, 16 * 1024));
-    return {
-        ...(value.completedAt === undefined ? {} : { completedAt: safeTimestamp(value.completedAt) }),
-        id: /^[\w-]{1,128}$/u.test(value.id) ? value.id : randomUUID(),
-        jobId: Number(safeId(value.jobId, 'job')),
-        lines,
-        projectId: Number(safeId(value.projectId, 'project')),
-        startedAt: safeTimestamp(value.startedAt),
-        status: value.status,
-    };
-}
-function parseRecord(line) {
-    if (Buffer.byteLength(line) > TESTING_LIVE_HISTORY_MAX_LINE_BYTES)
-        return undefined;
-    try {
-        const value = JSON.parse(line);
-        if (!isRecord(value) || !Array.isArray(value.lines))
-            return undefined;
-        if (!['completed', 'failed', 'recorded'].includes(String(value.status)))
-            return undefined;
-        return sanitizeRecord(value);
-    }
-    catch {
-        return undefined;
-    }
-}
-function safeTimestamp(value) {
-    return Number.isNaN(Date.parse(value)) ? new Date().toISOString() : value;
-}
-function isRecord(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-//# sourceMappingURL=testing-live-history.js.map
+import {modules} from './runtime.js';
+const TESTING_LIVE_HISTORY_MAX_LIMIT = modules["testing-live-history.js"]["TESTING_LIVE_HISTORY_MAX_LIMIT"]
+const TESTING_LIVE_HISTORY_MAX_LINE_BYTES = modules["testing-live-history.js"]["TESTING_LIVE_HISTORY_MAX_LINE_BYTES"]
+const TESTING_LIVE_HISTORY_MAX_READ_BYTES = modules["testing-live-history.js"]["TESTING_LIVE_HISTORY_MAX_READ_BYTES"]
+const appendTestingLiveHistory = modules["testing-live-history.js"]["appendTestingLiveHistory"]
+const readTestingLiveHistory = modules["testing-live-history.js"]["readTestingLiveHistory"]
+export {TESTING_LIVE_HISTORY_MAX_LIMIT, TESTING_LIVE_HISTORY_MAX_LINE_BYTES, TESTING_LIVE_HISTORY_MAX_READ_BYTES, appendTestingLiveHistory, readTestingLiveHistory};