@copado/agentia-cli 1.2.0 → 1.4.0

package/dist/commands/cicd/work/test.js

@@ -1,28 +1,39 @@
 import { Flags } from '@oclif/core';
 import path from 'node:path';
-import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { CicdCommand } from '../../../lib/cicd-command.js';
 import { getCurrentBranch } from '../../../lib/git-worktree.js';
-import { LocalQualityGatesError, parseQualityGatesEnvAssignments, resolveLocalQualityGatesScript, } from '../../../lib/local-quality-gates.js';
-import { runWorkTestLocalQualityGates } from '../../../lib/stock-quality-gates.js';
-import { reportLocalQualityGatesFailure, reportLocalQualityGatesOutcome, } from '../../../lib/work-local-run-tests.js';
+import { isInsideQualityGatesScript, LocalQualityGatesError, parseQualityGatesEnvAssignments, resolveLocalQualityGatesScript, } from '../../../lib/local-quality-gates.js';
+import { formatDeclaredQualityGates, isApexOnlySelection, resolveQualityGateSelection, UnknownQualityGateError, } from '../../../lib/quality-gates.js';
+import { listLocalQualityGates, runWorkTestLocalQualityGates } from '../../../lib/stock-quality-gates.js';
+import { executeWorkApexTestRun, WorkApexRerunError } from '../../../lib/work-apex-test-failures.js';
+import { DEFAULT_APEX_TEST_WAIT_MINUTES, formatWorkApexTestHuman, parseApexTestClassNames, validateApexTestWaitMinutes, WorkApexTestError, } from '../../../lib/work-apex-test.js';
+import { reportApexGateRun, reportLocalQualityGatesFailure, reportLocalQualityGatesOutcome, } from '../../../lib/work-local-run-tests.js';
 import { extractUserStoryFromFeatureBranch } from '../../../lib/work-types.js';
-export default class WorkTest extends AgentiaCommand {
+export default class WorkTest extends CicdCommand {
     static description = [
         'Run quality gates for the current work item.',
-        'With --local (the default) it runs project-root .agentia_quality_gates.sh (macOS/Linux) or',
-        '.agentia_quality_gates.cmd (Windows) when present.',
-        'When no project script exists it warns, runs the stock Agentia setup sample from a temporary file, then deletes that file.',
+        'Runs the project-root .agentia_quality_gates.sh (macOS/Linux) or .agentia_quality_gates.cmd (Windows);',
+        'when none exists it warns and runs the stock Agentia sample from a temporary file.',
+        'Every gate runs by default. Use --gate <id> (repeatable or comma-separated) to select gates; the selection is exported as AGENTIA_GATES.',
+        'Standard ids are apex, lint and lwc; scripts declare gates with `# agentia-gate: <id> - <description>` comments (see --list-gates).',
+        '`--gate apex` alone skips the script, runs the Apex tests directly and uploads the result to the work item (nested inside a script it does not upload; the outer run reports).',
         'With --cloud it runs remote Copado quality gates (not implemented yet).',
     ].join(' ');
     static examples = [
         '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --local --apex-test-classes=MyTest,OtherTest',
-        '<%= config.bin %> <%= command.id %> --local --rerun-failed-apex-tests',
+        '<%= config.bin %> <%= command.id %> --gate lint --gate lwc',
+        '<%= config.bin %> <%= command.id %> --gate apex --apex-test-classes=MyTest,OtherTest',
+        '<%= config.bin %> <%= command.id %> --list-gates',
         '<%= config.bin %> <%= command.id %> -e SKIP_LWC_TESTS=1 -e TOOL_API_KEY=secret',
         '<%= config.bin %> <%= command.id %> --json',
         '<%= config.bin %> <%= command.id %> --cloud',
     ];
     static flags = {
+        all: Flags.boolean({
+            default: false,
+            description: 'Run every gate in the quality-gates script (the default when no --gate is given).',
+            exclusive: ['gate', 'list-gates'],
+        }),
         'apex-test-classes': Flags.string({
             description: 'Comma-separated Apex test class names passed to local quality gates as AGENTIA_APEX_TEST_CLASSES',
         }),
@@ -35,13 +46,27 @@ export default class WorkTest extends AgentiaCommand {
             description: 'Extra environment variable for the quality-gate script as NAME=value. Repeatable. Applied before reserved AGENTIA_APEX_* variables.',
             multiple: true,
         }),
+        gate: Flags.string({
+            description: 'Run only this gate id (for example apex, lint, lwc or a custom id declared in the script). Repeatable or comma-separated. Exported to the script as AGENTIA_GATES.',
+            exclusive: ['all', 'list-gates'],
+            multiple: true,
+        }),
+        'list-gates': Flags.boolean({
+            default: false,
+            description: 'List the gates declared in the quality-gates script (or the stock sample) and exit.',
+        }),
         local: Flags.boolean({
             default: false,
             description: 'Run local project-root quality gates scripts. Used by default when --cloud is omitted.',
         }),
         'rerun-failed-apex-tests': Flags.boolean({
             default: false,
-            description: 'Pass AGENTIA_APEX_RERUN_FAILED=--rerun-failed-apex-tests to local quality gates so sample scripts forward that flag to work test apex.',
+            description: 'Pass AGENTIA_APEX_RERUN_FAILED=--rerun-failed-apex-tests to local quality gates so sample scripts forward that flag to the apex gate.',
+        }),
+        wait: Flags.integer({
+            char: 'w',
+            default: DEFAULT_APEX_TEST_WAIT_MINUTES,
+            description: 'Minutes to wait for Apex test results (only with --gate apex alone).',
         }),
     };
     async run() {
@@ -62,6 +87,19 @@ export default class WorkTest extends AgentiaCommand {
         catch (error) {
             this.error(error.message, { exit: 2 });
         }
+        let selection;
+        try {
+            selection = resolveQualityGateSelection({ all: flags.all, gates: flags.gate });
+        }
+        catch (error) {
+            this.error(error.message, { exit: 2 });
+        }
+        if (flags['list-gates']) {
+            return this.listGates();
+        }
+        if (isApexOnlySelection(selection)) {
+            return this.runApexGate({ classNames: flags['apex-test-classes'], rerunFailed: flags['rerun-failed-apex-tests'] === true, wait: flags.wait }, startedAt);
+        }
         let qualityGates;
         try {
             const scriptPath = resolveLocalQualityGatesScript();
@@ -78,6 +116,7 @@ export default class WorkTest extends AgentiaCommand {
             qualityGates = await runWorkTestLocalQualityGates({
                 apexTestClasses: flags['apex-test-classes'],
                 env: flags.env,
+                gates: selection.gates,
                 onWarning: (message) => this.warn(message),
                 rerunFailed: flags['rerun-failed-apex-tests'] === true,
             });
@@ -100,6 +139,9 @@ export default class WorkTest extends AgentiaCommand {
                     exit: error.exitCode || 1,
                 });
             }
+            if (error instanceof UnknownQualityGateError) {
+                this.error(error.message, { exit: 2 });
+            }
             throw error;
         }
         this.logElapsed(startedAt);
@@ -108,6 +150,35 @@ export default class WorkTest extends AgentiaCommand {
             qualityGates,
         };
     }
+    async listGates() {
+        const catalog = await listLocalQualityGates();
+        this.display(() => {
+            if (catalog.gates.length === 0) {
+                this.log('No gates declared. Add `# agentia-gate: <id> - <description>` comments to the quality-gates script.');
+                return;
+            }
+            this.log(`Gates declared in ${catalog.stock ? 'the stock sample' : path.basename(catalog.scriptPath)}:`);
+            this.log(formatDeclaredQualityGates(catalog.gates));
+        });
+        return { gates: catalog.gates, local: true, qualityGates: { ran: false, skipped: false } };
+    }
+    async reportApexGate(result, failed) {
+        if (isInsideQualityGatesScript()) {
+            return;
+        }
+        const workItem = await this.resolveWorkItemForReport();
+        if (workItem === undefined) {
+            this.warn('Failed to report local quality gates result: not on a feature/US-XXXX branch.');
+            return;
+        }
+        await reportApexGateRun({
+            failed,
+            onLog: (message) => this.display(() => this.log(message)),
+            onWarning: (message) => this.warn(message),
+            result,
+            workItem,
+        });
+    }
     async reportLocalFailure(error) {
         const workItem = await this.resolveWorkItemForReport();
         if (workItem === undefined) {
@@ -138,5 +209,39 @@ export default class WorkTest extends AgentiaCommand {
         const branch = await getCurrentBranch();
         return extractUserStoryFromFeatureBranch(branch);
     }
+    async runApexGate(options, startedAt) {
+        let requestedClassNames;
+        let waitMinutes;
+        try {
+            requestedClassNames = parseApexTestClassNames(options.classNames);
+            waitMinutes = validateApexTestWaitMinutes(options.wait);
+        }
+        catch (error) {
+            this.error(error.message, { exit: 2 });
+        }
+        try {
+            const apex = await executeWorkApexTestRun({
+                requestedClassNames,
+                rerunFailed: options.rerunFailed,
+                waitMinutes,
+            }, {
+                onResult: (result) => this.display(() => this.log(formatWorkApexTestHuman(result))),
+                onSkip: (message) => this.display(() => this.log(message)),
+                withSpinner: (message, action) => this.withSpinner(message, action),
+            });
+            await this.reportApexGate(apex, false);
+            this.logElapsed(startedAt);
+            return { apex, local: true, qualityGates: { ran: apex.skipped !== true, skipped: false } };
+        }
+        catch (error) {
+            if (error instanceof WorkApexRerunError) {
+                this.error(error.message, { exit: 2 });
+            }
+            if (error instanceof WorkApexTestError) {
+                await this.reportApexGate(error.result, true);
+            }
+            throw error;
+        }
+    }
 }
 //# sourceMappingURL=test.js.map

package/dist/commands/cicd/work/update.js

@@ -1,17 +1,17 @@
 import { Args } from '@oclif/core';
-import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { CicdCommand } from '../../../lib/cicd-command.js';
 import { CicdGateway } from '../../../lib/cicd-gateway.js';
 import { resolveWorkItemId, WorkActiveResolutionError } from '../../../lib/work-active.js';
 import { buildWorkMutationPayload, collectWorkMutationFlagKeys, validateWorkMutationPayload, workMutationFlags, } from '../../../lib/work-flags.js';
 import { workEndpoint } from '../../../lib/work-types.js';
-export default class WorkUpdate extends AgentiaCommand {
+export default class WorkUpdate extends CicdCommand {
     static args = {
         id: Args.string({
-            description: 'User story ID (defaults to the active work item from `work set`)',
+            description: 'User story ID or name (defaults to the active work item from `work set`)',
             required: false,
         }),
     };
-    static description = 'Update a Copado user story by ID';
+    static description = 'Update a Copado user story by ID or name';
     static examples = [
         '<%= config.bin %> <%= command.id %> --title "Updated story"',
         '<%= config.bin %> <%= command.id %> --custom-field JIRA_Key__c=CICD-1',

package/dist/commands/help-agent.js

@@ -0,0 +1,15 @@
+import { AgentiaCommand } from '../lib/agentia-command.js';
+import { runInteractiveHelpAgent } from '../lib/help-agent-command.js';
+export default class HelpAgent extends AgentiaCommand {
+    static description = `Chat interactively with the Copado Help Agent.
+
+Starts without a credential preflight, sends bounded non-secret CLI context, and requests a fresh short-lived AI token through the CICD gateway for every turn. Type /help during the session to list chat commands.`;
+    static enableJsonFlag = false;
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static experimental = true;
+    async run() {
+        await this.parse(HelpAgent);
+        return runInteractiveHelpAgent(this);
+    }
+}
+//# sourceMappingURL=help-agent.js.map

package/dist/commands/help.js

@@ -0,0 +1,38 @@
+import { Args, Flags, loadHelpClass } from '@oclif/core';
+import { AgentiaCommand } from '../lib/agentia-command.js';
+import { runInteractiveHelpAgent } from '../lib/help-agent-command.js';
+export default class Help extends AgentiaCommand {
+    static args = {
+        command: Args.string({ description: 'Command to show help for.', required: false }),
+    };
+    static description = 'Display help for <%= config.bin %> or open the interactive Copado support expert.';
+    static enableJsonFlag = false;
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> <command>',
+        '<%= config.bin %> <%= command.id %> --agent',
+    ];
+    static flags = {
+        agent: Flags.boolean({
+            description: 'Open the interactive Copado support expert.',
+        }),
+        'nested-commands': Flags.boolean({
+            char: 'n',
+            description: 'Include all nested commands in the output.',
+        }),
+    };
+    static strict = false;
+    async run() {
+        const { argv, flags } = await this.parse(Help);
+        if (flags.agent) {
+            if (argv.length > 0 || flags['nested-commands']) {
+                this.error('--agent cannot be combined with a command or --nested-commands.', { exit: 2 });
+            }
+            return runInteractiveHelpAgent(this);
+        }
+        const HelpClass = await loadHelpClass(this.config);
+        const help = new HelpClass(this.config, { all: flags['nested-commands'] });
+        await help.showHelp(argv);
+    }
+}
+//# sourceMappingURL=help.js.map

package/dist/commands/history/clear.js

@@ -0,0 +1,42 @@
+import { confirm } from '@inquirer/prompts';
+import { Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../lib/agentia-command.js';
+import { clearCommandHistory } from '../../lib/command-history.js';
+import { clearHelpAgentInteractions } from '../../lib/help-agent-interaction-history.js';
+import { redactErrorMessage } from '../../lib/secret-redaction.js';
+export default class HistoryClear extends AgentiaCommand {
+    static description = 'Clear temporary command and Help Agent interaction history';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --yes',
+        '<%= config.bin %> <%= command.id %> --yes --json',
+    ];
+    static flags = {
+        yes: Flags.boolean({
+            char: 'y',
+            default: false,
+            description: 'Confirm clearing temporary history without prompting.',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(HistoryClear);
+        if (!flags.yes) {
+            if (this.jsonEnabled() || process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
+                this.error('Clearing temporary history requires confirmation. Pass --yes for headless or JSON execution.', {
+                    exit: 2,
+                });
+            }
+            if (!(await confirm({ default: false, message: 'Clear temporary command and Help Agent history?' }))) {
+                this.error('History clearing canceled.', { exit: 1 });
+            }
+        }
+        try {
+            await Promise.all([clearCommandHistory(), clearHelpAgentInteractions()]);
+        }
+        catch (error) {
+            this.error(`Could not clear temporary history: ${redactErrorMessage(error)}`, { exit: 1 });
+        }
+        this.display(() => this.log('Temporary history cleared.'));
+        return { cleared: true };
+    }
+}
+//# sourceMappingURL=clear.js.map

package/dist/commands/history/list.js

@@ -0,0 +1,50 @@
+import { Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../lib/agentia-command.js';
+import { COMMAND_HISTORY_DEFAULT_LIST_LIMIT, COMMAND_HISTORY_LIMIT, readCommandHistory, } from '../../lib/command-history.js';
+import { table } from '../../lib/format.js';
+export default class HistoryList extends AgentiaCommand {
+    static description = 'List recent sanitized Agentia CLI command executions';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --limit 10',
+        '<%= config.bin %> <%= command.id %> --limit 10 --json',
+    ];
+    static flags = {
+        limit: Flags.integer({
+            default: COMMAND_HISTORY_DEFAULT_LIST_LIMIT,
+            description: 'Maximum entries to return (newest first).',
+            max: COMMAND_HISTORY_LIMIT,
+            min: 1,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(HistoryList);
+        const history = await readCommandHistory();
+        const entries = history.slice(-flags.limit).reverse();
+        this.display(() => {
+            if (entries.length === 0) {
+                this.log('No command history.');
+                return;
+            }
+            this.log(table([
+                { alias: 'Timestamp', value: 'timestamp' },
+                { alias: 'Command', minContentWidth: 12, value: 'commandId' },
+                { alias: 'Origin', value: 'clientOrigin' },
+                { alias: 'Status', value: 'status' },
+                { alias: 'Exit', value: 'exitCode' },
+                { alias: 'Duration', value: 'duration' },
+                { alias: 'Workspace', minContentWidth: 8, value: 'workspace' },
+            ], entries.map((entry) => ({
+                clientOrigin: entry.clientOrigin ?? 'unknown',
+                commandId: entry.commandId,
+                duration: `${entry.durationMs}ms`,
+                exitCode: entry.exitCode,
+                status: entry.status,
+                timestamp: entry.timestamp,
+                workspace: entry.workspace,
+            }))));
+        });
+        return { entries, limit: flags.limit, total: history.length };
+    }
+}
+//# sourceMappingURL=list.js.map

package/dist/commands/support.js

@@ -0,0 +1,15 @@
+import { AgentiaCommand } from '../lib/agentia-command.js';
+import { runInteractiveHelpAgent } from '../lib/help-agent-command.js';
+export default class Support extends AgentiaCommand {
+    static description = `Chat interactively with the Copado support expert.
+
+Sends bounded local CLI context and requests a fresh short-lived AI token through the CICD gateway for every turn. Type /help during the session to list chat commands.`;
+    static enableJsonFlag = false;
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static experimental = true;
+    async run() {
+        await this.parse(Support);
+        return runInteractiveHelpAgent(this);
+    }
+}
+//# sourceMappingURL=support.js.map

package/dist/commands/testing/browser/execute.js

@@ -0,0 +1,49 @@
+import { Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { testingBrowserCommonFlags, testingBrowserOptionalJobArg } from '../../../lib/testing-browser-command.js';
+import { executeTestingLive } from '../../../lib/testing-browser-operations.js';
+import { normalizeTestingLiveExecuteSource } from '../../../lib/testing-browser-requests.js';
+import { TESTING_LIVE_MAX_ROBOT_BYTES } from '../../../lib/testing-browser-robot.js';
+import { readBoundedStream } from '../../../lib/testing-secret-input.js';
+export default class TestingBrowserExecute extends AgentiaCommand {
+    static args = testingBrowserOptionalJobArg;
+    static deprecateAliases = true;
+    static description = 'Execute Robot Framework keywords in an active CRT browser session';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --project <project-id> --keyword GoTo --arg https://example.com',
+        '<%= config.bin %> <%= command.id %> --project <project-id> --line "GoTo    https://example.com"',
+        '<%= config.bin %> <%= command.id %> <job-id> --project <project-id> --file smoke.robot',
+        'cat smoke.robot | <%= config.bin %> <%= command.id %> --project <project-id> --stdin',
+    ];
+    static flags = {
+        ...testingBrowserCommonFlags,
+        arg: Flags.string({ description: 'Keyword argument. Repeat for multiple arguments.', multiple: true }),
+        file: Flags.string({ description: 'Robot Framework input file.' }),
+        keyword: Flags.string({ description: 'Robot Framework keyword name.' }),
+        line: Flags.string({ description: 'Raw Robot Framework keyword line. Repeat for multiple lines.', multiple: true }),
+        raw: Flags.boolean({ default: false, description: 'Treat file or stdin input as raw keyword lines.' }),
+        stdin: Flags.boolean({ default: false, description: 'Read Robot Framework lines or suite content from stdin.' }),
+    };
+    static hiddenAliases = ['testing:live:execute'];
+    async run() {
+        const { args, flags } = await this.parse(TestingBrowserExecute);
+        const source = normalizeTestingLiveExecuteSource({ file: flags.file, keyword: flags.keyword, lines: flags.line, stdin: flags.stdin }, { file: '--file', keyword: '--keyword', line: '--line', stdin: '--stdin' });
+        const stdinText = source === 'stdin'
+            ? await readBoundedStream(process.stdin, 'Robot input', TESTING_LIVE_MAX_ROBOT_BYTES)
+            : undefined;
+        const result = await this.withSpinner('Executing CRT browser keyword', () => executeTestingLive({
+            args: flags.arg,
+            file: flags.file,
+            jobId: args['job-id'],
+            keyword: flags.keyword,
+            lines: flags.line,
+            projectId: flags.project,
+            raw: flags.raw,
+            sessionId: flags['session-id'],
+            text: stdinText,
+        }));
+        this.display(() => this.log(`Execution ${result.executionId}: ${result.status}`));
+        return result;
+    }
+}
+//# sourceMappingURL=execute.js.map

package/dist/commands/testing/browser/history.js

@@ -0,0 +1,49 @@
+import { Args, Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { testingBrowserCommonFlags } from '../../../lib/testing-browser-command.js';
+import { getTestingLiveHistory } from '../../../lib/testing-browser-operations.js';
+import { formatTestingLiveHistoryLines } from '../../../lib/testing-browser-requests.js';
+export default class TestingBrowserHistory extends AgentiaCommand {
+    static args = {
+        'job-id': Args.integer({ description: 'CRT job ID; defaults to the active session.', required: false }),
+    };
+    static deprecateAliases = true;
+    static description = 'Read local CRT browser execution history';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> <job-id> --project <project-id> --limit 20 --json',
+        '<%= config.bin %> <%= command.id %> --project <project-id> --keyword ClickText --lines-only',
+    ];
+    static flags = {
+        ...testingBrowserCommonFlags,
+        'include-failed': Flags.boolean({ default: false, description: 'Include failed keyword executions.' }),
+        job: Flags.integer({
+            description: 'CRT job ID override; defaults to the positional job-id or active session.',
+            min: 1,
+        }),
+        keyword: Flags.string({ description: 'Filter to records containing this Robot Framework keyword name.' }),
+        limit: Flags.integer({ default: 10, description: 'Maximum records to return.', max: 500, min: 1 }),
+        'lines-only': Flags.boolean({ default: false, description: 'Print only the keyword lines for script export.' }),
+        status: Flags.option({
+            description: 'Execution status filter.',
+            options: ['completed', 'failed', 'recorded'],
+        })(),
+    };
+    static hiddenAliases = ['testing:live:history'];
+    async run() {
+        const { args, flags } = await this.parse(TestingBrowserHistory);
+        const result = await getTestingLiveHistory({
+            includeFailed: flags['include-failed'],
+            jobId: args['job-id'] ?? flags.job,
+            keyword: flags.keyword,
+            limit: flags.limit,
+            projectId: flags.project,
+            status: flags.status,
+        });
+        this.display(() => {
+            for (const line of formatTestingLiveHistoryLines(result, flags['lines-only']))
+                this.log(line);
+        });
+        return result;
+    }
+}
+//# sourceMappingURL=history.js.map

package/dist/commands/testing/browser/inspect.js

@@ -0,0 +1,35 @@
+import { Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { testingBrowserCommonFlags, testingBrowserOptionalJobArg } from '../../../lib/testing-browser-command.js';
+import { inspectTestingLive } from '../../../lib/testing-browser-operations.js';
+import { normalizeTestingLiveInspectDom } from '../../../lib/testing-browser-requests.js';
+import { formatTestingRecord } from '../../../lib/testing-types.js';
+export default class TestingBrowserInspect extends AgentiaCommand {
+    static args = testingBrowserOptionalJobArg;
+    static deprecateAliases = true;
+    static description = 'Inspect page state from an active CRT browser session';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --project <project-id> --json',
+        '<%= config.bin %> <%= command.id %> --project <project-id> --dom --output page.html',
+    ];
+    static flags = {
+        ...testingBrowserCommonFlags,
+        dom: Flags.boolean({ default: false, description: 'Fetch raw page DOM; requires --output unless --json is used.' }),
+        output: Flags.string({ dependsOn: ['dom'], description: 'Output file path for raw DOM.' }),
+    };
+    static hiddenAliases = ['testing:live:inspect'];
+    async run() {
+        const { args, flags } = await this.parse(TestingBrowserInspect);
+        const dom = normalizeTestingLiveInspectDom({ dom: flags.dom, json: this.jsonEnabled(), output: flags.output });
+        const result = await this.withSpinner('Inspecting CRT browser session', () => inspectTestingLive({
+            ...dom,
+            jobId: args['job-id'],
+            output: flags.output,
+            projectId: flags.project,
+            sessionId: flags['session-id'],
+        }));
+        this.display(() => this.log(flags.dom ? `DOM written to ${String(result.path)}.` : formatTestingRecord(result)));
+        return result;
+    }
+}
+//# sourceMappingURL=inspect.js.map

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

@@ -0,0 +1,52 @@
+import { Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { testingBrowserCommonFlags, testingBrowserOptionalJobArg } from '../../../lib/testing-browser-command.js';
+import { recordTestingLiveSession } from '../../../lib/testing-browser-operations.js';
+export default class TestingBrowserRecorder extends AgentiaCommand {
+    static args = testingBrowserOptionalJobArg;
+    static deprecateAliases = true;
+    static description = 'Record CRT browser interactions as Robot Framework lines';
+    static enableJsonFlag = false;
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --project <project-id> --output recorded.robot',
+        '<%= config.bin %> <%= command.id %> --project <project-id> --json',
+    ];
+    static flags = {
+        ...testingBrowserCommonFlags,
+        debug: Flags.boolean({ default: false, description: 'Print recorder event types and sizes.' }),
+        force: Flags.boolean({ default: false, description: 'Override an existing recorder lock for this session.' }),
+        json: Flags.boolean({ default: false, description: 'Stream each recorded keyword event as a JSON line.' }),
+        'no-enable': Flags.boolean({ default: false, description: 'Do not manage the server recorder toggle.' }),
+        output: Flags.string({ char: 'o', description: 'Robot file to append recorded keywords to.' }),
+    };
+    static hiddenAliases = ['testing:live:recorder'];
+    async run() {
+        const { args, flags } = await this.parse(TestingBrowserRecorder);
+        const controller = new AbortController();
+        const stop = () => controller.abort();
+        process.once('SIGINT', stop);
+        try {
+            return await recordTestingLiveSession({
+                appendRobot: flags.output,
+                force: flags.force,
+                jobId: args['job-id'],
+                noEnable: flags['no-enable'],
+                onError: (error) => this.warn(error.message),
+                onFrameSummary: flags.debug
+                    ? ({ bytes, type }) => this.warn(`Recorder event ${type} (${bytes} bytes).`)
+                    : undefined,
+                onKeywordLine: flags.json ? undefined : (line) => this.log(line),
+                onReady: flags.json ? undefined : () => this.log('Recording CRT interactions. Press Ctrl-C to stop.'),
+                onRecorderEvent: flags.json ? (event) => this.log(JSON.stringify(event)) : undefined,
+                onTimeout: (message) => this.warn(`Recorder session timed out: ${message}`),
+                projectId: flags.project,
+                sessionId: flags['session-id'],
+                signal: controller.signal,
+            });
+        }
+        finally {
+            process.removeListener('SIGINT', stop);
+        }
+    }
+}
+//# sourceMappingURL=recorder.js.map

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

@@ -0,0 +1,27 @@
+import { Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { testingBrowserCommonFlags, testingBrowserOptionalJobArg } from '../../../lib/testing-browser-command.js';
+import { saveTestingLiveScreenshot } from '../../../lib/testing-browser-operations.js';
+export default class TestingBrowserScreenshot extends AgentiaCommand {
+    static args = testingBrowserOptionalJobArg;
+    static deprecateAliases = true;
+    static description = 'Save a CRT browser screenshot to a file';
+    static examples = ['<%= config.bin %> <%= command.id %> --project <project-id> --output screenshot.png'];
+    static flags = {
+        ...testingBrowserCommonFlags,
+        output: Flags.string({ char: 'o', description: 'Screenshot output file path.', required: true }),
+    };
+    static hiddenAliases = ['testing:live:screenshot'];
+    async run() {
+        const { args, flags } = await this.parse(TestingBrowserScreenshot);
+        const result = await this.withSpinner('Saving CRT browser 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/browser/set-options.js

@@ -0,0 +1,35 @@
+import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { testingBrowserCommonFlags, testingBrowserOptionalJobArg, testingBrowserRecorderOptionFlags, } from '../../../lib/testing-browser-command.js';
+import { setTestingLiveOptions } from '../../../lib/testing-browser-operations.js';
+import { normalizeTestingLiveRecorderOptions } from '../../../lib/testing-browser-requests.js';
+export default class TestingBrowserSetOptions extends AgentiaCommand {
+    static args = testingBrowserOptionalJobArg;
+    static deprecateAliases = true;
+    static description = 'Set CRT browser recorder options';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --project <project-id> --enable --scroll-text --table-keywords',
+    ];
+    static flags = { ...testingBrowserCommonFlags, ...testingBrowserRecorderOptionFlags };
+    static hiddenAliases = ['testing:live:set-options'];
+    async run() {
+        const { args, flags } = await this.parse(TestingBrowserSetOptions);
+        const recorder = normalizeTestingLiveRecorderOptions({
+            enabled: flags.enable,
+            enableHealingContext: flags['healing-context'],
+            enableHoverText: flags['hover-text'],
+            enableScrollText: flags['scroll-text'],
+            enableSystemState: flags['system-state'],
+            enableVerifyText: flags['verify-text'],
+            preferTableKeywords: flags['table-keywords'],
+        });
+        const result = await setTestingLiveOptions({
+            jobId: args['job-id'],
+            projectId: flags.project,
+            recorder,
+            sessionId: flags['session-id'],
+        });
+        this.display(() => this.log('CRT browser recorder options updated.'));
+        return result;
+    }
+}
+//# sourceMappingURL=set-options.js.map