@copado/agentia-cli 1.2.0 → 1.4.0

package/dist/commands/testing/live/recorder.js

@@ -1,42 +0,0 @@
-import { Flags } from '@oclif/core';
-import { AgentiaCommand } from '../../../lib/agentia-command.js';
-import { testingLiveCommonFlags, testingLiveOptionalJobArg } from '../../../lib/testing-live-command.js';
-import { recordTestingLiveSession } from '../../../lib/testing-live-operations.js';
-export default class TestingLiveRecorder extends AgentiaCommand {
-    static args = testingLiveOptionalJobArg;
-    static description = 'Record CRT live interactions as bounded Robot Framework lines';
-    static enableJsonFlag = false;
-    static examples = ['<%= config.bin %> <%= command.id %> --project <project-id> --output recorded.robot'];
-    static flags = {
-        ...testingLiveCommonFlags,
-        debug: Flags.boolean({ default: false, description: 'Print frame sizes and event types without frame bodies.' }),
-        'no-enable': Flags.boolean({ default: false, description: 'Do not manage the server recorder toggle.' }),
-        output: Flags.string({ char: 'o', description: 'Explicit .robot file to append recorded keywords to.' }),
-    };
-    async run() {
-        const { args, flags } = await this.parse(TestingLiveRecorder);
-        const controller = new AbortController();
-        const stop = () => controller.abort();
-        process.once('SIGINT', stop);
-        try {
-            return await recordTestingLiveSession({
-                appendRobot: flags.output,
-                jobId: args['job-id'],
-                noEnable: flags['no-enable'],
-                onDebugFrame: flags.debug
-                    ? ({ bytes, type }) => this.warn(`Recorder event ${type} (${bytes} bytes).`)
-                    : undefined,
-                onError: (error) => this.warn(error.message),
-                onKeywordLine: (line) => this.log(line),
-                onReady: () => this.log('Recording CRT interactions. Press Ctrl-C to stop.'),
-                projectId: flags.project,
-                sessionId: flags['session-id'],
-                signal: controller.signal,
-            });
-        }
-        finally {
-            process.removeListener('SIGINT', stop);
-        }
-    }
-}
-//# sourceMappingURL=recorder.js.map

package/dist/commands/testing/live/reports.js

@@ -1,31 +0,0 @@
-import { Flags } from '@oclif/core';
-import { AgentiaCommand } from '../../../lib/agentia-command.js';
-import { testingLiveCommonFlags, testingLiveOptionalJobArg } from '../../../lib/testing-live-command.js';
-import { getTestingLiveReports } from '../../../lib/testing-live-operations.js';
-export default class TestingLiveReports extends AgentiaCommand {
-    static args = testingLiveOptionalJobArg;
-    static description = 'List or save bounded report artifacts from an active CRT live session';
-    static examples = [
-        '<%= config.bin %> <%= command.id %> --project <project-id>',
-        '<%= config.bin %> <%= command.id %> --project <project-id> --output-dir ./reports',
-    ];
-    static flags = {
-        ...testingLiveCommonFlags,
-        'output-dir': Flags.string({ description: 'Explicit directory for log.html, report.html, and output.xml.' }),
-    };
-    async run() {
-        const { args, flags } = await this.parse(TestingLiveReports);
-        const result = await this.withSpinner('Reading CRT live reports', () => getTestingLiveReports({
-            jobId: args['job-id'],
-            outputDir: flags['output-dir'],
-            projectId: flags.project,
-            sessionId: flags['session-id'],
-        }));
-        this.display(() => {
-            for (const file of result.files)
-                this.log(`${file.name}: ${file.bytes} bytes${file.path === undefined ? '' : ` -> ${file.path}`}`);
-        });
-        return result;
-    }
-}
-//# sourceMappingURL=reports.js.map

package/dist/commands/testing/live/screenshot.js

@@ -1,25 +0,0 @@
-import { Flags } from '@oclif/core';
-import { AgentiaCommand } from '../../../lib/agentia-command.js';
-import { testingLiveCommonFlags, testingLiveOptionalJobArg } from '../../../lib/testing-live-command.js';
-import { saveTestingLiveScreenshot } from '../../../lib/testing-live-operations.js';
-export default class TestingLiveScreenshot extends AgentiaCommand {
-    static args = testingLiveOptionalJobArg;
-    static description = 'Save a bounded CRT live browser screenshot to an explicit file';
-    static examples = ['<%= config.bin %> <%= command.id %> --project <project-id> --output screenshot.png'];
-    static flags = {
-        ...testingLiveCommonFlags,
-        output: Flags.string({ char: 'o', description: 'Explicit screenshot output path.', required: true }),
-    };
-    async run() {
-        const { args, flags } = await this.parse(TestingLiveScreenshot);
-        const result = await this.withSpinner('Saving CRT live screenshot', () => saveTestingLiveScreenshot({
-            jobId: args['job-id'],
-            output: flags.output,
-            projectId: flags.project,
-            sessionId: flags['session-id'],
-        }));
-        this.display(() => this.log(`Wrote ${result.bytes} bytes to ${result.path}.`));
-        return result;
-    }
-}
-//# sourceMappingURL=screenshot.js.map

package/dist/commands/testing/live/set-options.js

@@ -1,35 +0,0 @@
-import { AgentiaCommand } from '../../../lib/agentia-command.js';
-import { testingLiveCommonFlags, testingLiveOptionalJobArg, testingLiveRecorderOptionFlags, testingLiveRecorderOptions, } from '../../../lib/testing-live-command.js';
-import { setTestingLiveOptions } from '../../../lib/testing-live-operations.js';
-export default class TestingLiveSetOptions extends AgentiaCommand {
-    static args = testingLiveOptionalJobArg;
-    static description = 'Set the complete validated CRT live recorder option block';
-    static examples = [
-        '<%= config.bin %> <%= command.id %> --project <project-id> --enable --scroll-text --table-keywords',
-    ];
-    static flags = { ...testingLiveCommonFlags, ...testingLiveRecorderOptionFlags };
-    async run() {
-        const { args, flags } = await this.parse(TestingLiveSetOptions);
-        const optionNames = [
-            'enable',
-            'healing-context',
-            'hover-text',
-            'scroll-text',
-            'system-state',
-            'table-keywords',
-            'verify-text',
-        ];
-        if (!optionNames.some((name) => flags[name] !== undefined)) {
-            throw new Error('Provide at least one recorder option; unspecified options are set to false.');
-        }
-        const result = await setTestingLiveOptions({
-            jobId: args['job-id'],
-            projectId: flags.project,
-            recorder: testingLiveRecorderOptions(flags),
-            sessionId: flags['session-id'],
-        });
-        this.display(() => this.log('CRT live recorder options updated.'));
-        return result;
-    }
-}
-//# sourceMappingURL=set-options.js.map

package/dist/commands/testing/live/start.js

@@ -1,58 +0,0 @@
-import { Args, Flags } from '@oclif/core';
-import { AgentiaCommand } from '../../../lib/agentia-command.js';
-import { testingLiveCommonFlags } from '../../../lib/testing-live-command.js';
-import { startTestingLive } from '../../../lib/testing-live-operations.js';
-import { TESTING_LIVE_LIBRARIES } from '../../../lib/testing-live-types.js';
-export default class TestingLiveStart extends AgentiaCommand {
-    static args = {
-        'job-id': Args.integer({ description: 'CRT job ID.', required: true }),
-    };
-    static description = 'Start and bootstrap a bounded Copado Robotic Testing live session';
-    static examples = [
-        '<%= config.bin %> <%= command.id %> <job-id> --project <project-id>',
-        '<%= config.bin %> <%= command.id %> <job-id> --project <project-id> --file smoke.robot --section "Login"',
-    ];
-    static flags = {
-        ...testingLiveCommonFlags,
-        description: Flags.string({ description: 'Nonsecret session label.' }),
-        file: Flags.string({ description: 'Robot Framework file used to bootstrap a selected test/task.' }),
-        'jap-ime': Flags.boolean({ default: false, description: 'Enable Japanese IME in the live environment.' }),
-        library: Flags.option({
-            default: 'QWeb',
-            description: 'Robot Framework library to bootstrap.',
-            options: [...TESTING_LIVE_LIBRARIES],
-        })(),
-        'no-bootstrap': Flags.boolean({ default: false, description: 'Create the host without readiness/bootstrap calls.' }),
-        'no-browser': Flags.boolean({ default: false, description: 'Do not open Chrome during QWeb/QForce bootstrap.' }),
-        'poll-interval': Flags.integer({ default: 3, description: 'Readiness polling interval in seconds.', min: 1 }),
-        screen: Flags.string({ description: 'Session screen as WIDTHxHEIGHTxDEPTH.' }),
-        section: Flags.string({ description: 'Robot test/task name to bootstrap.' }),
-        'section-index': Flags.integer({ description: 'One-based Robot test/task index to bootstrap.', min: 1 }),
-        'session-version': Flags.string({ description: 'CRT live environment version.' }),
-        timeout: Flags.integer({ default: 120, description: 'Readiness timeout in seconds.', min: 1 }),
-        viewport: Flags.string({ description: 'Session viewport as WIDTHxHEIGHT (24-bit depth).' }),
-    };
-    async run() {
-        const { args, flags } = await this.parse(TestingLiveStart);
-        const result = await this.withSpinner('Starting CRT live session', () => startTestingLive({
-            description: flags.description,
-            file: flags.file,
-            japIme: flags['jap-ime'],
-            jobId: args['job-id'],
-            library: flags.library,
-            noBootstrap: flags['no-bootstrap'],
-            noBrowser: flags['no-browser'],
-            pollIntervalMs: flags['poll-interval'] * 1000,
-            projectId: flags.project,
-            screen: flags.screen,
-            section: flags.section,
-            sectionIndex: flags['section-index'],
-            sessionVersion: flags['session-version'],
-            timeoutMs: flags.timeout * 1000,
-            viewport: flags.viewport,
-        }));
-        this.display(() => this.log(`CRT live session ${result.sessionId} is ready for job ${result.jobId}.`));
-        return result;
-    }
-}
-//# sourceMappingURL=start.js.map

package/dist/commands/testing/live/status.js

@@ -1,24 +0,0 @@
-import { AgentiaCommand } from '../../../lib/agentia-command.js';
-import { testingLiveCommonFlags, testingLiveOptionalJobArg } from '../../../lib/testing-live-command.js';
-import { getTestingLiveStatus } from '../../../lib/testing-live-operations.js';
-export default class TestingLiveStatus extends AgentiaCommand {
-    static args = testingLiveOptionalJobArg;
-    static description = 'Inspect sanitized status for the active CRT live session';
-    static examples = ['<%= config.bin %> <%= command.id %> --project <project-id> --json'];
-    static flags = testingLiveCommonFlags;
-    async run() {
-        const { args, flags } = await this.parse(TestingLiveStatus);
-        const result = await this.withSpinner('Reading CRT live status', () => getTestingLiveStatus({
-            jobId: args['job-id'],
-            projectId: flags.project,
-            sessionId: flags['session-id'],
-        }));
-        this.display(() => {
-            this.log(`Session: ${result.metadata.sessionId} (${result.metadata.status})`);
-            this.log(`Browser started: ${result.status.env.isBrowserStarted}`);
-            this.log(`Executor running: ${result.status.session.isRobotExecutorRunning}`);
-        });
-        return result;
-    }
-}
-//# sourceMappingURL=status.js.map

package/dist/commands/testing/live/stop.js

@@ -1,36 +0,0 @@
-import { Flags } from '@oclif/core';
-import { AgentiaCommand } from '../../../lib/agentia-command.js';
-import { confirmTestingAction } from '../../../lib/testing-confirmation.js';
-import { testingLiveCommonFlags, testingLiveOptionalJobArg } from '../../../lib/testing-live-command.js';
-import { stopTestingLive } from '../../../lib/testing-live-operations.js';
-export default class TestingLiveStop extends AgentiaCommand {
-    static args = testingLiveOptionalJobArg;
-    static description = 'Stop the active Copado Robotic Testing live session';
-    static examples = [
-        '<%= config.bin %> <%= command.id %> --project <project-id>',
-        '<%= config.bin %> <%= command.id %> <job-id> --project <project-id> --yes --json',
-    ];
-    static flags = {
-        ...testingLiveCommonFlags,
-        yes: Flags.boolean({ char: 'y', default: false, description: 'Confirm live session shutdown.' }),
-    };
-    async run() {
-        const { args, flags } = await this.parse(TestingLiveStop);
-        const confirmed = await confirmTestingAction({
-            action: 'CRT live session shutdown',
-            json: this.jsonEnabled(),
-            message: 'Stop the active CRT live session?',
-            yes: flags.yes,
-        });
-        if (!confirmed)
-            return { stopped: false };
-        const result = await this.withSpinner('Stopping CRT live session', () => stopTestingLive({
-            jobId: args['job-id'],
-            projectId: flags.project,
-            sessionId: flags['session-id'],
-        }));
-        this.display(() => this.log(`Stopped CRT live session ${result.sessionId}.`));
-        return result;
-    }
-}
-//# sourceMappingURL=stop.js.map

package/dist/commands/testing/live/view.js

@@ -1,36 +0,0 @@
-import { Flags } from '@oclif/core';
-import { AgentiaCommand } from '../../../lib/agentia-command.js';
-import { openUrl } from '../../../lib/open-browser.js';
-import { testingLiveCommonFlags } from '../../../lib/testing-live-command.js';
-import { testingLiveViewUrl } from '../../../lib/testing-live-operations.js';
-export default class TestingLiveView extends AgentiaCommand {
-    static description = 'Open the authenticated CRT run/session page without putting viewer secrets in the URL';
-    static examples = [
-        '<%= config.bin %> <%= command.id %> --project <project-id>',
-        '<%= config.bin %> <%= command.id %> --project <project-id> --no-open --json',
-    ];
-    static flags = {
-        ...testingLiveCommonFlags,
-        interactive: Flags.boolean({ default: false, description: 'Request interactive viewer controls when available.' }),
-        'no-open': Flags.boolean({ default: false, description: 'Return the nonsecret URL without opening a browser.' }),
-    };
-    async run() {
-        const { flags } = await this.parse(TestingLiveView);
-        if (this.jsonEnabled() && !flags['no-open']) {
-            throw new Error('CRT live view cannot open a browser with --json. Re-run with --no-open.');
-        }
-        const url = await testingLiveViewUrl({
-            interactive: flags.interactive,
-            projectId: flags.project,
-            sessionId: flags['session-id'],
-        });
-        if (!flags['no-open'])
-            await openUrl(url);
-        this.display(() => {
-            this.log(url);
-            this.warn('Viewer secrets are intentionally not transported in the URL; this opens only the authenticated CRT session page.');
-        });
-        return { access: 'authenticated-page-only', opened: !flags['no-open'], url };
-    }
-}
-//# sourceMappingURL=view.js.map

package/dist/lib/mcp/testing-live-tools.js

@@ -1,226 +0,0 @@
-import { mkdtemp } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { z } from 'zod';
-import { controlTestingLive, executeTestingLive, getTestingLiveHistory, getTestingLiveReports, getTestingLiveStatus, inspectTestingLive, parseTestingLiveScreen, saveTestingLiveScreenshot, setTestingLiveOptions, startTestingLive, stopTestingLive, } from '../testing-live-operations.js';
-import { TESTING_LIVE_LIBRARIES } from '../testing-live-types.js';
-import { safelyHandleTool } from './result.js';
-async function testingLiveStart(args) {
-    const hasScreenParts = args.screenDepth !== undefined || args.screenHeight !== undefined || args.screenWidth !== undefined;
-    if (hasScreenParts && (args.screen !== undefined || args.viewport !== undefined)) {
-        throw new Error('Use either screen/viewport or screenWidth/screenHeight/screenDepth, not both.');
-    }
-    let screenInput = args.screen;
-    if (hasScreenParts) {
-        if (args.screenDepth === undefined || args.screenHeight === undefined || args.screenWidth === undefined) {
-            throw new Error('Provide screenWidth, screenHeight, and screenDepth together.');
-        }
-        screenInput = { depth: args.screenDepth, height: args.screenHeight, width: args.screenWidth };
-    }
-    const screen = parseTestingLiveScreen(screenInput, args.viewport);
-    return {
-        result: await startTestingLive({
-            description: args.description,
-            japIme: args.japIme,
-            jobId: args.job,
-            library: args.library,
-            noBootstrap: args.noBootstrap,
-            noBrowser: args.noBrowser,
-            pollIntervalMs: args.pollIntervalSeconds === undefined ? undefined : args.pollIntervalSeconds * 1000,
-            projectId: args.project,
-            screen,
-            section: args.section,
-            sectionIndex: args.sectionIndex,
-            sessionVersion: args.sessionVersion,
-            timeoutMs: args.timeoutSeconds === undefined ? undefined : args.timeoutSeconds * 1000,
-        }),
-    };
-}
-async function testingLiveStop(args) {
-    if (args.confirm !== true)
-        throw new Error('CRT live session shutdown requires confirm: true.');
-    return { result: await stopTestingLive({ jobId: args.job, projectId: args.project, sessionId: args.sessionId }) };
-}
-async function testingLiveStatus(args) {
-    return { result: await getTestingLiveStatus({ jobId: args.job, projectId: args.project, sessionId: args.sessionId }) };
-}
-async function testingLiveExecute(args) {
-    const modes = [args.keyword !== undefined, (args.line?.length ?? 0) > 0].filter(Boolean);
-    if (modes.length !== 1)
-        throw new Error('Use exactly one of keyword or line.');
-    return {
-        result: await executeTestingLive({
-            args: args.argument,
-            jobId: args.job,
-            keyword: args.keyword,
-            lines: args.line,
-            projectId: args.project,
-            raw: args.raw,
-            section: args.section,
-            sectionIndex: args.sectionIndex,
-            sessionId: args.sessionId,
-        }),
-    };
-}
-async function testingLiveControl(action, args) {
-    return {
-        result: await controlTestingLive(action, { jobId: args.job, projectId: args.project, sessionId: args.sessionId }),
-    };
-}
-async function testingLiveInspect(args) {
-    return {
-        result: await inspectTestingLive({
-            jobId: args.job,
-            projectId: args.project,
-            sessionId: args.sessionId,
-        }),
-    };
-}
-async function testingLiveScreenshot(args) {
-    const outputDir = await mkdtemp(join(tmpdir(), 'agentia-mcp-live-screenshot-'));
-    return {
-        result: await saveTestingLiveScreenshot({
-            jobId: args.job,
-            output: join(outputDir, 'screenshot.png'),
-            projectId: args.project,
-            sessionId: args.sessionId,
-        }),
-    };
-}
-async function testingLiveReports(args) {
-    return {
-        result: await getTestingLiveReports({
-            jobId: args.job,
-            projectId: args.project,
-            sessionId: args.sessionId,
-        }),
-    };
-}
-async function testingLiveSetOptions(args) {
-    return {
-        result: await setTestingLiveOptions({
-            jobId: args.job,
-            projectId: args.project,
-            recorder: args.recorder,
-            sessionId: args.sessionId,
-        }),
-    };
-}
-async function testingLiveHistory(args) {
-    return {
-        result: getTestingLiveHistory({ jobId: args.job, limit: args.limit, projectId: args.project, status: args.status }),
-    };
-}
-export const testingLiveMcpHandlers = {
-    testingLiveContinue: (args) => testingLiveControl('continue', args),
-    testingLiveExecute,
-    testingLiveHistory,
-    testingLiveInspect,
-    testingLiveInterrupt: (args) => testingLiveControl('interrupt', args),
-    testingLiveReports,
-    testingLiveScreenshot,
-    testingLiveSetOptions,
-    testingLiveStart,
-    testingLiveStatus,
-    testingLiveStop,
-};
-const liveSessionSchema = {
-    job: z.number().int().positive().optional().describe('Optional CRT job ID guard.'),
-    project: z.number().int().positive().describe('CRT project ID.'),
-    sessionId: z.number().int().positive().optional().describe('Optional active live session ID guard.'),
-};
-const liveRecorderOptionsSchema = z.object({
-    enabled: z.boolean(),
-    enableHealingContext: z.boolean(),
-    enableHoverText: z.boolean(),
-    enableScrollText: z.boolean(),
-    enableSystemState: z.boolean(),
-    enableVerifyText: z.boolean(),
-    preferTableKeywords: z.boolean(),
-});
-export function registerTestingLiveMcpTools(server) {
-    server.registerTool('agentia_testing_live_start', {
-        description: 'Start and bootstrap a bounded CRT live-testing session.',
-        inputSchema: {
-            description: z.string().max(500).optional(),
-            japIme: z.boolean().optional(),
-            job: z.number().int().positive().describe('CRT job ID.'),
-            library: z.enum(TESTING_LIVE_LIBRARIES).optional(),
-            noBootstrap: z.boolean().optional(),
-            noBrowser: z.boolean().optional(),
-            pollIntervalSeconds: z.number().int().min(1).max(30).optional(),
-            project: z.number().int().positive().describe('CRT project ID.'),
-            screen: z.string().max(100).optional(),
-            screenDepth: z.number().int().min(8).max(32).optional(),
-            screenHeight: z.number().int().min(240).max(4320).optional(),
-            screenWidth: z.number().int().min(320).max(7680).optional(),
-            section: z.string().max(500).optional(),
-            sectionIndex: z.number().int().positive().optional(),
-            sessionVersion: z.string().max(100).optional(),
-            timeoutSeconds: z.number().int().min(1).max(600).optional(),
-            viewport: z.string().max(100).optional(),
-        },
-        title: 'Agentia Testing Live Start',
-    }, (args) => safelyHandleTool(() => testingLiveStart(args)));
-    server.registerTool('agentia_testing_live_stop', {
-        description: 'Stop the active CRT live-testing session. Requires explicit confirmation.',
-        inputSchema: { confirm: z.boolean().describe('Must be true to stop the session.'), ...liveSessionSchema },
-        title: 'Agentia Testing Live Stop',
-    }, (args) => safelyHandleTool(() => testingLiveStop(args)));
-    server.registerTool('agentia_testing_live_status', {
-        description: 'Read sanitized status for the active CRT live-testing session.',
-        inputSchema: liveSessionSchema,
-        title: 'Agentia Testing Live Status',
-    }, (args) => safelyHandleTool(() => testingLiveStatus(args)));
-    server.registerTool('agentia_testing_live_execute', {
-        description: 'Execute bounded Robot Framework keywords in the active CRT live-testing session.',
-        inputSchema: {
-            argument: z.array(z.string().max(16_384)).max(100).optional(),
-            keyword: z.string().max(16_384).optional(),
-            line: z.array(z.string().max(16_384)).max(500).optional(),
-            raw: z.boolean().optional(),
-            section: z.string().max(500).optional(),
-            sectionIndex: z.number().int().positive().optional(),
-            ...liveSessionSchema,
-        },
-        title: 'Agentia Testing Live Execute',
-    }, (args) => safelyHandleTool(() => testingLiveExecute(args)));
-    for (const action of ['continue', 'interrupt']) {
-        server.registerTool(`agentia_testing_live_${action}`, {
-            description: `${action === 'continue' ? 'Continue' : 'Interrupt'} execution in the active CRT live-testing session.`,
-            inputSchema: liveSessionSchema,
-            title: `Agentia Testing Live ${action === 'continue' ? 'Continue' : 'Interrupt'}`,
-        }, (args) => safelyHandleTool(() => testingLiveControl(action, args)));
-    }
-    server.registerTool('agentia_testing_live_inspect', {
-        description: 'Read bounded sanitized page state without local file access.',
-        inputSchema: liveSessionSchema,
-        title: 'Agentia Testing Live Inspect',
-    }, (args) => safelyHandleTool(() => testingLiveInspect(args)));
-    server.registerTool('agentia_testing_live_screenshot', {
-        description: 'Save a bounded CRT live screenshot to an isolated temporary path.',
-        inputSchema: liveSessionSchema,
-        title: 'Agentia Testing Live Screenshot',
-    }, (args) => safelyHandleTool(() => testingLiveScreenshot(args)));
-    server.registerTool('agentia_testing_live_reports', {
-        description: 'List bounded live report metadata without local file access.',
-        inputSchema: liveSessionSchema,
-        title: 'Agentia Testing Live Reports',
-    }, (args) => safelyHandleTool(() => testingLiveReports(args)));
-    server.registerTool('agentia_testing_live_set_options', {
-        description: 'Set the complete validated CRT live recorder option block.',
-        inputSchema: { recorder: liveRecorderOptionsSchema, ...liveSessionSchema },
-        title: 'Agentia Testing Live Set Options',
-    }, (args) => safelyHandleTool(() => testingLiveSetOptions(args)));
-    server.registerTool('agentia_testing_live_history', {
-        description: 'Read bounded sanitized local CRT live execution history.',
-        inputSchema: {
-            job: z.number().int().positive().describe('CRT job ID.'),
-            limit: z.number().int().min(1).max(500).optional(),
-            project: z.number().int().positive().describe('CRT project ID.'),
-            status: z.enum(['completed', 'failed', 'recorded']).optional(),
-        },
-        title: 'Agentia Testing Live History',
-    }, (args) => safelyHandleTool(() => testingLiveHistory(args)));
-}
-//# sourceMappingURL=testing-live-tools.js.map

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

@@ -1,8 +0,0 @@
-import {modules} from './runtime.js';
-const parseTestingLiveScreen = modules["testing-live-command.js"]["parseTestingLiveScreen"]
-const runTestingLiveControlCommand = modules["testing-live-command.js"]["runTestingLiveControlCommand"]
-const testingLiveCommonFlags = modules["testing-live-command.js"]["testingLiveCommonFlags"]
-const testingLiveOptionalJobArg = modules["testing-live-command.js"]["testingLiveOptionalJobArg"]
-const testingLiveRecorderOptionFlags = modules["testing-live-command.js"]["testingLiveRecorderOptionFlags"]
-const testingLiveRecorderOptions = modules["testing-live-command.js"]["testingLiveRecorderOptions"]
-export {parseTestingLiveScreen, runTestingLiveControlCommand, testingLiveCommonFlags, testingLiveOptionalJobArg, testingLiveRecorderOptionFlags, testingLiveRecorderOptions};

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

@@ -1,25 +0,0 @@
-import {modules} from './runtime.js';
-const TESTING_LIVE_API_ENDPOINTS = modules["testing-live-operations.js"]["TESTING_LIVE_API_ENDPOINTS"]
-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 collectTestingLiveDom = modules["testing-live-operations.js"]["collectTestingLiveDom"]
-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 parseTestingLiveScreen = modules["testing-live-operations.js"]["parseTestingLiveScreen"]
-const recordTestingLiveSession = modules["testing-live-operations.js"]["recordTestingLiveSession"]
-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 testingLiveJobSessionEndpoint = modules["testing-live-operations.js"]["testingLiveJobSessionEndpoint"]
-const testingLiveRecorderOptions = modules["testing-live-operations.js"]["testingLiveRecorderOptions"]
-const testingLiveViewUrl = modules["testing-live-operations.js"]["testingLiveViewUrl"]
-export {TESTING_LIVE_API_ENDPOINTS, TESTING_LIVE_MAX_REPORT_BYTES, TESTING_LIVE_MAX_SCREENSHOT_BYTES, TESTING_LIVE_SYSTEM_STATE_MAX_WAIT_MS, clearTestingLive, collectTestingLiveDom, controlTestingLive, executeTestingLive, getTestingLiveHistory, getTestingLiveReports, getTestingLiveStatus, inspectTestingLive, loadTestingLiveConnection, parseTestingLiveScreen, recordTestingLiveSession, saveTestingLiveScreenshot, setTestingLiveOptions, setTestingLiveSystemStateDelayForTests, startTestingLive, stopTestingLive, testingLiveJobSessionEndpoint, testingLiveRecorderOptions, testingLiveViewUrl};

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

@@ -1,11 +0,0 @@
-import {modules} from './runtime.js';
-const TESTING_LIVE_MAX_DOM_BYTES = modules["testing-live-recorder.js"]["TESTING_LIVE_MAX_DOM_BYTES"]
-const TESTING_LIVE_MAX_WS_FRAME_BYTES = modules["testing-live-recorder.js"]["TESTING_LIVE_MAX_WS_FRAME_BYTES"]
-const acquireTestingLiveRecorderLock = modules["testing-live-recorder.js"]["acquireTestingLiveRecorderLock"]
-const connectTestingLiveWebSocket = modules["testing-live-recorder.js"]["connectTestingLiveWebSocket"]
-const feedTestingLiveDomFrame = modules["testing-live-recorder.js"]["feedTestingLiveDomFrame"]
-const parseTestingLiveRecorderFrame = modules["testing-live-recorder.js"]["parseTestingLiveRecorderFrame"]
-const resetTestingLiveWebSocketForTests = modules["testing-live-recorder.js"]["resetTestingLiveWebSocketForTests"]
-const robotLinesFromRecorderEvent = modules["testing-live-recorder.js"]["robotLinesFromRecorderEvent"]
-const setTestingLiveWebSocketForTests = modules["testing-live-recorder.js"]["setTestingLiveWebSocketForTests"]
-export {TESTING_LIVE_MAX_DOM_BYTES, TESTING_LIVE_MAX_WS_FRAME_BYTES, acquireTestingLiveRecorderLock, connectTestingLiveWebSocket, feedTestingLiveDomFrame, parseTestingLiveRecorderFrame, resetTestingLiveWebSocketForTests, robotLinesFromRecorderEvent, setTestingLiveWebSocketForTests};

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

@@ -1,9 +0,0 @@
-import {modules} from './runtime.js';
-const TESTING_LIVE_MAX_KEYWORD_LINES = modules["testing-live-robot.js"]["TESTING_LIVE_MAX_KEYWORD_LINES"]
-const TESTING_LIVE_MAX_LINE_BYTES = modules["testing-live-robot.js"]["TESTING_LIVE_MAX_LINE_BYTES"]
-const TESTING_LIVE_MAX_ROBOT_BYTES = modules["testing-live-robot.js"]["TESTING_LIVE_MAX_ROBOT_BYTES"]
-const escapeTestingLiveXpathEquals = modules["testing-live-robot.js"]["escapeTestingLiveXpathEquals"]
-const parseTestingRobot = modules["testing-live-robot.js"]["parseTestingRobot"]
-const summarizeTestingLiveKeywordLines = modules["testing-live-robot.js"]["summarizeTestingLiveKeywordLines"]
-const validateKeywordLines = modules["testing-live-robot.js"]["validateKeywordLines"]
-export {TESTING_LIVE_MAX_KEYWORD_LINES, TESTING_LIVE_MAX_LINE_BYTES, TESTING_LIVE_MAX_ROBOT_BYTES, escapeTestingLiveXpathEquals, parseTestingRobot, summarizeTestingLiveKeywordLines, validateKeywordLines};

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

@@ -1,12 +0,0 @@
-import {modules} from './runtime.js';
-const TESTING_LIVE_HISTORY_MAX_LIMIT = modules["testing-live-state.js"]["TESTING_LIVE_HISTORY_MAX_LIMIT"]
-const TESTING_LIVE_HISTORY_MAX_LINE_BYTES = modules["testing-live-state.js"]["TESTING_LIVE_HISTORY_MAX_LINE_BYTES"]
-const TESTING_LIVE_HISTORY_MAX_READ_BYTES = modules["testing-live-state.js"]["TESTING_LIVE_HISTORY_MAX_READ_BYTES"]
-const appendTestingLiveHistory = modules["testing-live-state.js"]["appendTestingLiveHistory"]
-const clearTestingLiveState = modules["testing-live-state.js"]["clearTestingLiveState"]
-const readTestingLiveHistory = modules["testing-live-state.js"]["readTestingLiveHistory"]
-const readTestingLiveState = modules["testing-live-state.js"]["readTestingLiveState"]
-const testingLiveSessionPath = modules["testing-live-state.js"]["testingLiveSessionPath"]
-const validateTestingLiveSessionPath = modules["testing-live-state.js"]["validateTestingLiveSessionPath"]
-const writeTestingLiveState = modules["testing-live-state.js"]["writeTestingLiveState"]
-export {TESTING_LIVE_HISTORY_MAX_LIMIT, TESTING_LIVE_HISTORY_MAX_LINE_BYTES, TESTING_LIVE_HISTORY_MAX_READ_BYTES, appendTestingLiveHistory, clearTestingLiveState, readTestingLiveHistory, readTestingLiveState, testingLiveSessionPath, validateTestingLiveSessionPath, writeTestingLiveState};

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

@@ -1,3 +0,0 @@
-import {modules} from './runtime.js';
-const TESTING_LIVE_LIBRARIES = modules["testing-live-types.js"]["TESTING_LIVE_LIBRARIES"]
-export {TESTING_LIVE_LIBRARIES};