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

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

@@ -1,676 +1,19 @@
-/* eslint-disable no-await-in-loop -- CRT readiness polling is deliberately sequential. */
-import { randomUUID } from 'node:crypto';
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { basename, dirname, resolve, sep } from 'node:path';
-import { deleteCrtLiveViewerSecret, setCrtLiveViewerSecret, } from './credential-store.js';
-import { normalizeCrtDomain, resolveTestingCredentials } from './testing-config.js';
-import { resolveTestingSessionUrl, TestingGateway, TestingGatewayError, } from './testing-gateway.js';
-import { TESTING_LIVE_API_ENDPOINTS, testingLiveJobSessionEndpoint, testingLiveSessionPath, validateTestingLiveSessionPath, } from './testing-live-endpoints.js';
-import { appendTestingLiveHistory, readTestingLiveHistory } from './testing-live-history.js';
-import { connectTestingLiveWebSocket, feedTestingLiveDomFrame, parseTestingLiveRecorderFrame, TESTING_LIVE_MAX_DOM_BYTES, } from './testing-live-recorder.js';
-import { escapeTestingLiveXpathEquals, parseTestingRobot, summarizeTestingLiveKeywordLines, validateKeywordLines, } from './testing-live-robot.js';
-import { clearTestingLiveState, readTestingLiveState, writeTestingLiveState, } from './testing-live-state.js';
-import { sanitizeTestingOutput, sanitizeTestingUrl, testingProviderErrorMessage, } from './testing-sanitization.js';
-import { exchangeTestingSession, testingSessionAuth } from './testing-session.js';
-export const TESTING_LIVE_MAX_SCREENSHOT_BYTES = 10 * 1024 * 1024;
-export const TESTING_LIVE_MAX_REPORT_BYTES = 20 * 1024 * 1024;
-export const TESTING_LIVE_SYSTEM_STATE_MAX_WAIT_MS = 45_000;
-const TESTING_LIVE_SYSTEM_STATE_MAX_ATTEMPTS = 7;
-const TESTING_LIVE_SYSTEM_STATE_REQUEST_TIMEOUT_MS = 15_000;
-const TESTING_LIVE_SYSTEM_STATE_RETRY_BASE_MS = 500;
-const TESTING_LIVE_SYSTEM_STATE_RETRY_MAX_MS = 4000;
-const DEFAULT_POLL_INTERVAL_MS = 3000;
-const DEFAULT_START_TIMEOUT_MS = 120_000;
-const defaultGlobalEnvironment = (library, openBrowser) => {
-    const rows = [`*** Settings ***`, `Library                 ${library}`];
-    if (openBrowser) {
-        rows.push('Suite Setup             Open Browser    about:blank    chrome', 'Suite Teardown          Close All Browsers');
-    }
-    return rows.join('\n');
-};
-const DEFAULT_QWEB_CONFIG = [
-    'SetConfig    ClickToFocus    True',
-    'SetConfig    PartialMatch    True',
-    'SetConfig    HighlightColor    teal',
-];
-const OPEN_BROWSER_KEYWORD = 'Open Browser    about:blank    chrome';
-const DOM_KEYWORD = 'GetAttribute    //html    outerHTML';
-let testingLiveSystemStateDelay = delay;
-export function setTestingLiveSystemStateDelayForTests(delayFunction) {
-    testingLiveSystemStateDelay = delayFunction ?? delay;
-}
-// The bounded bootstrap state machine intentionally validates optional legacy fields in one boundary.
-// eslint-disable-next-line complexity
-export async function startTestingLive(options) {
-    if (options.file === undefined && (options.section !== undefined || options.sectionIndex !== undefined)) {
-        throw new Error('CRT live Robot section selection requires --file.');
-    }
-    const existing = await readTestingLiveState();
-    if (existing !== undefined) {
-        throw new Error(`CRT live session ${existing.sessionId} is already active. Stop it before starting another.`);
-    }
-    const response = await TestingGateway.call({
-        body: {
-            action: 'start',
-            ...(options.description === undefined ? {} : { description: boundedLabel(options.description, 500) }),
-            ...(options.japIme === true ? { japIME: true } : {}),
-            ...(options.screen === undefined ? {} : { screen: options.screen }),
-            ...(options.sessionVersion === undefined ? {} : { version: boundedLabel(options.sessionVersion, 100) }),
-            type: 'live-testing',
-            useRDP: true,
-        },
-        endpoint: testingLiveJobSessionEndpoint(options.projectId, options.jobId),
-        method: 'PUT',
-        service: 'pace',
-    }, options);
-    const data = unwrapRecord(response);
-    const sessionId = positiveNumber(data.id, 'session');
-    const sessionPath = normalizeReturnedSessionPath(data.url, sessionId, resolveTestingCredentials(gatewayOptions(options)).domain);
-    const now = new Date().toISOString();
-    const metadata = {
-        createdAt: now,
-        jobId: options.jobId,
-        projectId: options.projectId,
-        sessionId,
-        sessionPath,
-        status: 'starting',
-        updatedAt: now,
-    };
-    for (const key of ['rdpAccessKey', 'guacamoleToken', 'encryptionKey']) {
-        const secret = typeof data[key] === 'string' ? data[key].trim() : '';
-        if (secret.length > 0) {
-            try {
-                setCrtLiveViewerSecret(sessionId, secret);
-            }
-            catch (error) {
-                await teardownCreatedTestingLive(metadata, undefined, options);
-                throw error;
-            }
-            break;
-        }
-    }
-    if (options.noBootstrap === true) {
-        try {
-            return await writeTestingLiveState({ ...metadata, status: 'ready', updatedAt: new Date().toISOString() });
-        }
-        catch (error) {
-            await teardownCreatedTestingLive(metadata, undefined, options);
-            throw error;
-        }
-    }
-    let session;
-    try {
-        session = await exchangeTestingSession(gatewayOptions(options));
-        await pollTestingLiveReady({ metadata, session }, options.timeoutMs, options.pollIntervalMs, options);
-        const parsed = options.file === undefined
-            ? undefined
-            : parseTestingRobot(readBoundedRobotFile(options.file), {
-                section: options.section,
-                sectionIndex: options.sectionIndex,
-            });
-        const library = options.library ?? 'QWeb';
-        const opensBrowser = library !== 'QMobile' && options.noBrowser !== true;
-        await startSessionEnvironment(metadata, session, {
-            files: [],
-            globalEnvironment: parsed?.globalEnvironment ?? defaultGlobalEnvironment(library, opensBrowser),
-            scriptPath: '',
-            testCaseName: parsed?.sectionName ?? 'LiveTest',
-        }, options);
-        if (library === 'QWeb' || library === 'QForce')
-            await executeLines(metadata, session, DEFAULT_QWEB_CONFIG, options);
-        if (opensBrowser) {
-            await executeLines(metadata, session, [OPEN_BROWSER_KEYWORD], options);
-            await pollTestingLiveBrowserReady({ metadata, session }, Math.min(options.timeoutMs ?? DEFAULT_START_TIMEOUT_MS, 60_000), options.pollIntervalMs, options);
-        }
-        if ((parsed?.lines.length ?? 0) > 0)
-            await executeLines(metadata, session, parsed.lines, options);
-        return await writeTestingLiveState({ ...metadata, status: 'ready', updatedAt: new Date().toISOString() });
-    }
-    catch (error) {
-        await teardownCreatedTestingLive(metadata, session, options);
-        throw error;
-    }
-}
-export async function stopTestingLive(options) {
-    const metadata = await requireTestingLiveState(options);
-    try {
-        const session = await exchangeTestingSession(gatewayOptions(options));
-        await sessionCall(metadata, session, TESTING_LIVE_API_ENDPOINTS.stop, 'GET', undefined, options);
-    }
-    catch {
-        // Pace teardown is authoritative and still runs when exchange or host-side shutdown fails.
-    }
-    try {
-        await TestingGateway.call({
-            body: { action: 'stop' },
-            endpoint: testingLiveJobSessionEndpoint(metadata.projectId, metadata.jobId),
-            method: 'PUT',
-            service: 'pace',
-        }, gatewayOptions(options));
-    }
-    finally {
-        await clearTestingLive(metadata);
-    }
-    return {
-        jobId: metadata.jobId,
-        projectId: metadata.projectId,
-        sessionId: metadata.sessionId,
-        stopped: true,
-    };
-}
-export async function getTestingLiveStatus(options) {
-    const connection = await loadTestingLiveConnection(options);
-    try {
-        const response = await sessionCall(connection.metadata, connection.session, TESTING_LIVE_API_ENDPOINTS.status, 'GET', undefined, options);
-        const status = normalizeStatus(response);
-        const metadata = await writeTestingLiveState({
-            ...connection.metadata,
-            status: status.server.inShutdownState ? 'stopping' : 'ready',
-            updatedAt: new Date().toISOString(),
-        });
-        return { metadata, status };
-    }
-    catch (error) {
-        if (error instanceof TestingGatewayError && [404, 410].includes(error.statusCode ?? 0)) {
-            await clearTestingLive(connection.metadata);
-        }
-        throw error;
-    }
-}
-export async function executeTestingLive(options) {
-    const connection = await loadTestingLiveConnection(options);
-    let lines;
-    let environment;
-    if (options.file !== undefined) {
-        const parsed = parseTestingRobot(readBoundedRobotFile(options.file), options);
-        lines = parsed.lines;
-        environment = parsed.globalEnvironment;
-    }
-    else if (options.lines !== undefined && options.lines.length > 0) {
-        lines = validateKeywordLines(options.lines);
-    }
-    else if (options.keyword === undefined) {
-        throw new Error('Provide --keyword, --line, or --file for live execution.');
-    }
-    else {
-        lines = validateKeywordLines([
-            [options.keyword.trim(), ...(options.args ?? [])].filter(Boolean).join('    '),
-        ]);
-    }
-    if (environment !== undefined) {
-        await startSessionEnvironment(connection.metadata, connection.session, { files: [], globalEnvironment: environment, scriptPath: '', testCaseName: 'LiveTest' }, options);
-    }
-    const startedAt = new Date().toISOString();
-    try {
-        const response = await executeLines(connection.metadata, connection.session, lines, options);
-        const record = unwrapRecord(response);
-        const result = {
-            executionId: typeof record.executionId === 'string' && record.executionId.length > 0
-                ? record.executionId
-                : randomUUID(),
-            jobId: connection.metadata.jobId,
-            lines: summarizeTestingLiveKeywordLines(lines),
-            projectId: connection.metadata.projectId,
-            sessionId: connection.metadata.sessionId,
-            status: record.status === 200 ? 'completed' : 'failed',
-        };
-        appendTestingLiveHistory({
-            completedAt: new Date().toISOString(),
-            id: result.executionId,
-            jobId: result.jobId,
-            lines: summarizeTestingLiveKeywordLines(lines),
-            projectId: result.projectId,
-            startedAt,
-            status: result.status,
-        });
-        return result;
-    }
-    catch (error) {
-        appendTestingLiveHistory({
-            completedAt: new Date().toISOString(),
-            id: randomUUID(),
-            jobId: connection.metadata.jobId,
-            lines: summarizeTestingLiveKeywordLines(lines),
-            projectId: connection.metadata.projectId,
-            startedAt,
-            status: 'failed',
-        });
-        throw error;
-    }
-}
-export async function controlTestingLive(action, options) {
-    const connection = await loadTestingLiveConnection(options);
-    const endpoint = action === 'continue' ? TESTING_LIVE_API_ENDPOINTS.continue : TESTING_LIVE_API_ENDPOINTS.interrupt;
-    const response = unwrapRecord(await sessionCall(connection.metadata, connection.session, endpoint, 'POST', undefined, options));
-    return {
-        action,
-        message: typeof response.message === 'string' ? sanitizeTestingOutput(response.message).slice(0, 2000) : action,
-        sessionId: connection.metadata.sessionId,
-    };
-}
-export async function inspectTestingLive(options) {
-    const connection = await loadTestingLiveConnection(options);
-    if (options.dom === true) {
-        if (options.output === undefined)
-            throw new Error('Raw DOM requires an explicit --output path.');
-        const target = validateExplicitFilePath(options.output);
-        const dom = await collectTestingLiveDom(connection, options);
-        mkdirSync(dirname(target), { recursive: true });
-        writeFileSync(target, dom, { encoding: 'utf8', mode: 0o600 });
-        return { bytes: Buffer.byteLength(dom), path: target, sessionId: connection.metadata.sessionId };
-    }
-    const record = await fetchTestingLiveSystemState(connection, options, TESTING_LIVE_MAX_SCREENSHOT_BYTES * 2);
-    return {
-        changeOrigin: boundedString(record.changeOrigin, 200),
-        sessionId: connection.metadata.sessionId,
-        systemState: sanitizeSystemState(record.systemState),
-        timestamp: boundedString(record.timestamp, 100),
-        url: sanitizeUntrustedPageUrl(record.url),
-    };
-}
-export async function saveTestingLiveScreenshot(options) {
-    const connection = await loadTestingLiveConnection(options);
-    const record = await fetchTestingLiveSystemState(connection, options, TESTING_LIVE_MAX_SCREENSHOT_BYTES * 2);
-    const screenshot = typeof record.screenshot === 'string' ? record.screenshot : '';
-    const encoded = screenshot.includes(',') ? screenshot.slice(screenshot.indexOf(',') + 1) : screenshot;
-    if (encoded.length === 0 || !/^[a-z\d+/=\s]+$/iu.test(encoded))
-        throw new Error('CRT session did not return a valid screenshot.');
-    const bytes = Buffer.from(encoded, 'base64');
-    if (bytes.length === 0 || bytes.length > TESTING_LIVE_MAX_SCREENSHOT_BYTES) {
-        throw new Error('CRT screenshot exceeded the safety limit.');
-    }
-    const target = validateExplicitFilePath(options.output);
-    mkdirSync(dirname(target), { recursive: true });
-    writeFileSync(target, bytes, { mode: 0o600 });
-    return {
-        bytes: bytes.length,
-        path: target,
-        sessionId: connection.metadata.sessionId,
-        ...(typeof record.timestamp === 'string' ? { timestamp: boundedString(record.timestamp, 100) } : {}),
-        ...(typeof record.url === 'string' ? { url: sanitizeUntrustedPageUrl(record.url) } : {}),
-    };
-}
-export async function getTestingLiveReports(options) {
-    const connection = await loadTestingLiveConnection(options);
-    const response = unwrapRecord(await sessionCall(connection.metadata, connection.session, TESTING_LIVE_API_ENDPOINTS.download, 'GET', undefined, { ...options, maxResponseBytes: TESTING_LIVE_MAX_REPORT_BYTES * 3 }));
-    const files = [];
-    const root = options.outputDir === undefined ? undefined : validateExplicitDirectory(options.outputDir);
-    const mappings = [['log', 'log.html'], ['report', 'report.html'], ['output', 'output.xml']];
-    for (const [key, name] of mappings) {
-        const content = response[key];
-        if (typeof content !== 'string')
-            continue;
-        const bytes = Buffer.byteLength(content);
-        if (bytes > TESTING_LIVE_MAX_REPORT_BYTES)
-            throw new Error(`CRT report ${name} exceeded the safety limit.`);
-        if (root === undefined)
-            files.push({ bytes, name });
-        else {
-            const target = resolve(root, basename(name));
-            mkdirSync(root, { recursive: true });
-            writeFileSync(target, content, { encoding: 'utf8', mode: 0o600 });
-            files.push({ bytes, name, path: target });
-        }
-    }
-    return { files, sessionId: connection.metadata.sessionId };
-}
-export async function setTestingLiveOptions(options) {
-    const connection = await loadTestingLiveConnection(options);
-    const response = unwrapRecord(await sessionCall(connection.metadata, connection.session, TESTING_LIVE_API_ENDPOINTS.setOptions, 'POST', { recorder: options.recorder }, options));
-    return {
-        recorder: options.recorder,
-        sessionId: connection.metadata.sessionId,
-        status: typeof response.status === 'number' ? response.status : 0,
-    };
-}
-export function getTestingLiveHistory(options) {
-    const executions = readTestingLiveHistory(options);
-    return { count: executions.length, executions, jobId: options.jobId, projectId: options.projectId };
-}
-export async function testingLiveViewUrl(options) {
-    const metadata = await requireTestingLiveState(options);
-    const domain = normalizeCrtDomain(resolveTestingCredentials(gatewayOptions(options)).domain);
-    const url = new URL(`/live-testing/session/${metadata.sessionId}`, `https://${domain}`);
-    if (options.interactive === true)
-        url.searchParams.set('interactive', 'true');
-    return url.toString();
-}
-export async function loadTestingLiveConnection(options) {
-    return {
-        metadata: await requireTestingLiveState(options),
-        session: await exchangeTestingSession(gatewayOptions(options)),
-    };
-}
-export async function clearTestingLive(metadata) {
-    const active = metadata ?? await readTestingLiveState();
-    if (active !== undefined)
-        deleteCrtLiveViewerSecret(active.sessionId);
-    await clearTestingLiveState();
-}
-async function requireTestingLiveState(options) {
-    const metadata = await readTestingLiveState();
-    if (metadata === undefined)
-        throw new Error('No active CRT live session. Run `agentia testing live start` first.');
-    if (metadata.projectId !== options.projectId)
-        throw new Error('Active CRT live session belongs to another project.');
-    if (options.jobId !== undefined && metadata.jobId !== options.jobId) {
-        throw new Error('Requested CRT job does not match the active live session.');
-    }
-    if (options.sessionId !== undefined && metadata.sessionId !== options.sessionId) {
-        throw new Error('Requested CRT session does not match the active live session.');
-    }
-    return metadata;
-}
-// Keeping the explicit request tuple visible makes every live endpoint/auth call auditable.
-// eslint-disable-next-line max-params
-async function sessionCall(metadata, session, endpoint, method, body, options) {
-    return TestingGateway.call({
-        auth: testingSessionAuth(session),
-        ...(body === undefined ? {} : { body }),
-        endpoint,
-        maxResponseBytes: typeof options.maxResponseBytes === 'number' ? options.maxResponseBytes : undefined,
-        method,
-        service: 'session',
-        sessionPath: metadata.sessionPath,
-    }, gatewayOptions(options));
-}
-async function executeLines(metadata, session, lines, options) {
-    const processed = validateKeywordLines(lines).map((line) => escapeTestingLiveXpathEquals(line));
-    const response = await sessionCall(metadata, session, TESTING_LIVE_API_ENDPOINTS.keyword, 'POST', {
-        auxCode: '',
-        context: 'normal',
-        filepath: '',
-        internalKeyword: false,
-        lines: processed,
-        sequenceId: -1,
-    }, options);
-    assertTestingLiveResponseStatus(response, 'keyword execution');
-    return response;
-}
-async function startSessionEnvironment(metadata, session, body, options) {
-    const response = await sessionCall(metadata, session, TESTING_LIVE_API_ENDPOINTS.start, 'POST', body, options);
-    assertTestingLiveResponseStatus(response, 'session bootstrap');
-    return response;
-}
-async function teardownCreatedTestingLive(metadata, session, options) {
-    if (session !== undefined) {
-        await sessionCall(metadata, session, TESTING_LIVE_API_ENDPOINTS.stop, 'GET', undefined, options).catch(() => { });
-    }
-    try {
-        await TestingGateway.call({
-            body: { action: 'stop' },
-            endpoint: testingLiveJobSessionEndpoint(metadata.projectId, metadata.jobId),
-            method: 'PUT',
-            service: 'pace',
-        }, gatewayOptions(options));
-    }
-    catch {
-        // Local cleanup is mandatory even when Pace teardown fails.
-    }
-    finally {
-        await clearTestingLive(metadata);
-    }
-}
-function assertTestingLiveResponseStatus(response, action) {
-    const record = unwrapRecord(response);
-    const { status } = record;
-    if (status === 200)
-        return;
-    if (typeof status !== 'number') {
-        throw new TypeError(`CRT live ${action} failed because the response status was missing or invalid.`);
-    }
-    const detail = testingProviderErrorMessage(JSON.stringify(record), status);
-    throw new Error(`CRT live ${action} failed. ${detail}`);
-}
-async function pollTestingLiveReady(connection, timeoutMs = DEFAULT_START_TIMEOUT_MS, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS, options) {
-    const boundedTimeout = boundedInteger(timeoutMs, 1000, 10 * 60_000, 'timeout');
-    const interval = boundedInteger(pollIntervalMs, 250, 30_000, 'poll interval');
-    const deadline = Date.now() + boundedTimeout;
-    while (Date.now() < deadline) {
-        try {
-            const status = normalizeStatus(await sessionCall(connection.metadata, connection.session, TESTING_LIVE_API_ENDPOINTS.status, 'GET', undefined, { ...options, timeoutMs: Math.min(interval, 10_000) }));
-            if (!status.server.inShutdownState && status.server.ambleApiVersion.length > 0)
-                return;
-        }
-        catch {
-            // Host may not accept connections until its live environment is ready.
-        }
-        await delay(interval);
-    }
-    throw new Error(`CRT live session did not become ready within ${Math.ceil(boundedTimeout / 1000)} seconds.`);
-}
-async function pollTestingLiveBrowserReady(connection, timeoutMs, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS, options) {
-    const boundedTimeout = boundedInteger(timeoutMs, 1000, 60_000, 'browser timeout');
-    const interval = boundedInteger(pollIntervalMs, 250, 30_000, 'poll interval');
-    const deadline = Date.now() + boundedTimeout;
-    while (Date.now() < deadline) {
-        try {
-            const status = normalizeStatus(await sessionCall(connection.metadata, connection.session, TESTING_LIVE_API_ENDPOINTS.status, 'GET', undefined, { ...options, timeoutMs: Math.min(interval, 10_000) }));
-            if (status.env.isBrowserStarted || status.env.browsersRunning.length > 0)
-                return;
-        }
-        catch {
-            // The live host may briefly reject status while Chrome is starting.
-        }
-        await delay(interval);
-    }
-    throw new Error(`CRT live browser did not become ready within ${Math.ceil(boundedTimeout / 1000)} seconds.`);
-}
-async function collectTestingLiveDom(connection, options) {
-    const { domain } = resolveTestingCredentials(gatewayOptions(options));
-    const socket = connectTestingLiveWebSocket(connection.metadata.sessionPath, domain, connection.session);
-    await new Promise((resolvePromise, reject) => {
-        socket.once('open', resolvePromise);
-        socket.once('error', reject);
-    });
-    await executeLines(connection.metadata, connection.session, [DOM_KEYWORD], options);
-    return new Promise((resolvePromise, reject) => {
-        let dom;
-        let quiet;
-        const budget = setTimeout(() => finish(new Error('CRT session did not return the page DOM.')), 30_000);
-        const finish = (error) => {
-            clearTimeout(budget);
-            if (quiet !== undefined)
-                clearTimeout(quiet);
-            socket.close();
-            if (error !== undefined)
-                reject(error);
-            else if (dom === undefined)
-                reject(new Error('CRT session did not return the page DOM.'));
-            else
-                resolvePromise(dom);
-        };
-        socket.on('message', (frame) => {
-            try {
-                const event = parseTestingLiveRecorderFrame(frame);
-                if (event === undefined)
-                    return;
-                dom = feedTestingLiveDomFrame(dom, event);
-                if (dom !== undefined) {
-                    if (quiet !== undefined)
-                        clearTimeout(quiet);
-                    quiet = setTimeout(() => finish(), 1500);
-                }
-            }
-            catch (error) {
-                finish(error);
-            }
-        });
-        socket.once('error', () => finish(new Error('CRT live DOM stream failed.')));
-    });
-}
-function normalizeReturnedSessionPath(value, sessionId, domain) {
-    if (typeof value !== 'string' || value.trim().length === 0)
-        return testingLiveSessionPath(sessionId);
-    const candidate = value.trim();
-    if (/^https:\/\//iu.test(candidate)) {
-        return validateTestingLiveSessionPath(resolveTestingSessionUrl(candidate, domain).pathname, sessionId);
-    }
-    return validateTestingLiveSessionPath(candidate, sessionId);
-}
-function normalizeStatus(value) {
-    const root = unwrapRecord(value);
-    const env = record(root.env);
-    const recorder = record(root.recorder);
-    const server = record(root.server);
-    const session = record(root.session);
-    return {
-        env: {
-            browsersRunning: stringArray(env.browsersRunning, 20),
-            initialBrowser: boundedString(env.initialBrowser, 100),
-            isBrowserStarted: env.isBrowserStarted === true,
-            isWindowOpen: env.isWindowOpen === true,
-        },
-        recorder: { connected: recorder.connected === true },
-        server: {
-            ambleApiVersion: boundedString(server.ambleApiVersion, 100),
-            clientsConnected: safeNumber(server.clientsConnected),
-            inFatalErrorState: server.inFatalErrorState === true,
-            inShutdownState: server.inShutdownState === true,
-            serverTimeUtc: boundedString(server.serverTimeUtc, 100),
-            serverUptime: safeNumber(server.serverUptime),
-        },
-        session: {
-            activeRequests: safeNumber(session.activeRequests),
-            currentIdleTime: safeNumber(session.currentIdleTime),
-            isKeywordExecutionPending: session.isKeywordExecutionPending === true,
-            isRobotExecutorRunning: session.isRobotExecutorRunning === true,
-            sessionIdleTimeout: safeNumber(session.sessionIdleTimeout),
-            timeToExpire: safeNumber(session.timeToExpire),
-            totalElapsedTime: safeNumber(session.totalElapsedTime),
-        },
-    };
-}
-function sanitizeSystemState(value) {
-    if (typeof value !== 'string')
-        return sanitizeTestingOutput(value);
-    if (Buffer.byteLength(value) > TESTING_LIVE_MAX_DOM_BYTES)
-        throw new Error('CRT system state exceeded the safety limit.');
-    try {
-        return sanitizeTestingOutput(JSON.parse(value));
-    }
-    catch {
-        return { available: true, bytes: Buffer.byteLength(value) };
-    }
-}
-async function fetchTestingLiveSystemState(connection, options, maxResponseBytes) {
-    const startedAt = Date.now();
-    let scheduledDelayMs = 0;
-    let lastError;
-    for (let attempt = 0; attempt < TESTING_LIVE_SYSTEM_STATE_MAX_ATTEMPTS; attempt++) {
-        const remainingMs = TESTING_LIVE_SYSTEM_STATE_MAX_WAIT_MS - Math.max(Date.now() - startedAt, scheduledDelayMs);
-        if (remainingMs <= 0)
-            break;
-        try {
-            return unwrapRecord(await sessionCall(connection.metadata, connection.session, TESTING_LIVE_API_ENDPOINTS.systemState, 'GET', undefined, {
-                ...options,
-                maxResponseBytes,
-                timeoutMs: Math.min(TESTING_LIVE_SYSTEM_STATE_REQUEST_TIMEOUT_MS, remainingMs),
-            }));
-        }
-        catch (error) {
-            if (!(error instanceof TestingGatewayError) ||
-                (error.statusCode !== undefined && ![409, 422].includes(error.statusCode))) {
-                throw error;
-            }
-            lastError = error;
-        }
-        const retryDelayMs = Math.min(TESTING_LIVE_SYSTEM_STATE_RETRY_BASE_MS * (2 ** attempt), TESTING_LIVE_SYSTEM_STATE_RETRY_MAX_MS);
-        scheduledDelayMs += retryDelayMs;
-        if (attempt === TESTING_LIVE_SYSTEM_STATE_MAX_ATTEMPTS - 1 ||
-            scheduledDelayMs >= TESTING_LIVE_SYSTEM_STATE_MAX_WAIT_MS) {
-            break;
-        }
-        await testingLiveSystemStateDelay(retryDelayMs);
-    }
-    throw lastError ?? new Error('CRT system state was not available within the bounded retry window.');
-}
-function sanitizeUntrustedPageUrl(value) {
-    if (typeof value !== 'string' || value.trim().length === 0)
-        return undefined;
-    try {
-        const url = new URL(value);
-        if (!['http:', 'https:'].includes(url.protocol) || url.username.length > 0 || url.password.length > 0)
-            return undefined;
-        return sanitizeTestingUrl(url);
-    }
-    catch {
-        return undefined;
-    }
-}
-function readBoundedRobotFile(path) {
-    const contents = readFileSync(path, 'utf8');
-    if (Buffer.byteLength(contents) > 1024 * 1024)
-        throw new Error('Robot input file exceeds the safety limit.');
-    return contents;
-}
-function validateExplicitFilePath(path) {
-    if (path.trim().length === 0 || path.includes('\0'))
-        throw new Error('CRT output path must not be empty.');
-    return resolve(path);
-}
-function validateExplicitDirectory(path) {
-    const target = resolve(path);
-    if (path.trim().length === 0 || path.includes('\0') || target === sep) {
-        throw new Error('CRT output directory is invalid.');
-    }
-    return target;
-}
-function unwrapRecord(value) {
-    const root = record(value);
-    return record(root.data ?? root.result ?? root);
-}
-function record(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : {};
-}
-function positiveNumber(value, label) {
-    const parsed = typeof value === 'number' ? value : Number(value);
-    if (!Number.isSafeInteger(parsed) || parsed <= 0)
-        throw new Error(`CRT ${label} ID is missing or invalid.`);
-    return parsed;
-}
-function boundedString(value, max) {
-    return typeof value === 'string' ? sanitizeTestingOutput(value).slice(0, max) : '';
-}
-function boundedLabel(value, max) {
-    const clean = value.replaceAll('\0', '').trim();
-    if (clean.length === 0 || clean.length > max)
-        throw new Error(`CRT live value must contain 1-${max} characters.`);
-    return clean;
-}
-function boundedInteger(value, minimum, maximum, label) {
-    if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
-        throw new Error(`CRT live ${label} must be between ${minimum} and ${maximum} milliseconds.`);
-    }
-    return value;
-}
-function safeNumber(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
-}
-function stringArray(value, limit) {
-    return Array.isArray(value)
-        ? value.slice(0, limit).filter((item) => typeof item === 'string').map((item) => item.slice(0, 100))
-        : [];
-}
-async function delay(milliseconds) {
-    await new Promise((resolvePromise) => {
-        setTimeout(resolvePromise, milliseconds);
-    });
-}
-function gatewayOptions(options) {
-    const result = {};
-    if (typeof options.domain === 'string')
-        result.domain = options.domain;
-    if (typeof options.org === 'string' || typeof options.org === 'number')
-        result.org = options.org;
-    if (typeof options.pak === 'string')
-        result.pak = options.pak;
-    if (typeof options.pat === 'string')
-        result.pat = options.pat;
-    if (typeof options.timeoutMs === 'number')
-        result.timeoutMs = options.timeoutMs;
-    return result;
-}
-//# sourceMappingURL=testing-live-operations.js.map
+import {modules} from './runtime.js';
+const TESTING_LIVE_MAX_REPORT_BYTES = modules["testing-live-operations.js"]["TESTING_LIVE_MAX_REPORT_BYTES"]
+const TESTING_LIVE_MAX_SCREENSHOT_BYTES = modules["testing-live-operations.js"]["TESTING_LIVE_MAX_SCREENSHOT_BYTES"]
+const TESTING_LIVE_SYSTEM_STATE_MAX_WAIT_MS = modules["testing-live-operations.js"]["TESTING_LIVE_SYSTEM_STATE_MAX_WAIT_MS"]
+const clearTestingLive = modules["testing-live-operations.js"]["clearTestingLive"]
+const controlTestingLive = modules["testing-live-operations.js"]["controlTestingLive"]
+const executeTestingLive = modules["testing-live-operations.js"]["executeTestingLive"]
+const getTestingLiveHistory = modules["testing-live-operations.js"]["getTestingLiveHistory"]
+const getTestingLiveReports = modules["testing-live-operations.js"]["getTestingLiveReports"]
+const getTestingLiveStatus = modules["testing-live-operations.js"]["getTestingLiveStatus"]
+const inspectTestingLive = modules["testing-live-operations.js"]["inspectTestingLive"]
+const loadTestingLiveConnection = modules["testing-live-operations.js"]["loadTestingLiveConnection"]
+const saveTestingLiveScreenshot = modules["testing-live-operations.js"]["saveTestingLiveScreenshot"]
+const setTestingLiveOptions = modules["testing-live-operations.js"]["setTestingLiveOptions"]
+const setTestingLiveSystemStateDelayForTests = modules["testing-live-operations.js"]["setTestingLiveSystemStateDelayForTests"]
+const startTestingLive = modules["testing-live-operations.js"]["startTestingLive"]
+const stopTestingLive = modules["testing-live-operations.js"]["stopTestingLive"]
+const testingLiveViewUrl = modules["testing-live-operations.js"]["testingLiveViewUrl"]
+export {TESTING_LIVE_MAX_REPORT_BYTES, TESTING_LIVE_MAX_SCREENSHOT_BYTES, TESTING_LIVE_SYSTEM_STATE_MAX_WAIT_MS, clearTestingLive, controlTestingLive, executeTestingLive, getTestingLiveHistory, getTestingLiveReports, getTestingLiveStatus, inspectTestingLive, loadTestingLiveConnection, saveTestingLiveScreenshot, setTestingLiveOptions, setTestingLiveSystemStateDelayForTests, startTestingLive, stopTestingLive, testingLiveViewUrl};