@copado/agentia-cli 0.111.0-alpha.0 → 0.113.0-alpha.0

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

@@ -0,0 +1,676 @@
+/* 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