@copado/agentia-cli 1.1.0 → 1.3.0

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

@@ -0,0 +1,194 @@
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { executeTestingLive, getTestingLiveHistory, getTestingLiveReports, getTestingLiveStatus, inspectTestingLive, saveTestingLiveScreenshot, setTestingLiveOptions, startTestingLive, stopTestingLive, } from '../testing-browser-operations.js';
+import { assertTestingLiveStopConfirmed, normalizeTestingLiveExecuteSource, normalizeTestingLiveRecorderOptions, normalizeTestingLiveStartScreen, shapeTestingLiveHistoryResult, } from '../testing-browser-requests.js';
+import { TESTING_LIVE_LIBRARIES } from '../testing-browser-types.js';
+import { safelyHandleTool } from './result.js';
+async function testingBrowserStart(args) {
+    const screen = normalizeTestingLiveStartScreen(args);
+    return {
+        result: await startTestingLive({
+            japIme: args.japIme,
+            jobId: args.job,
+            library: args.library,
+            noBootstrap: args.noBootstrap,
+            noBrowser: args.noBrowser,
+            projectId: args.project,
+            screen,
+            timeoutMs: args.timeoutSeconds === undefined ? undefined : args.timeoutSeconds * 1000,
+        }),
+    };
+}
+async function testingBrowserStop(args) {
+    assertTestingLiveStopConfirmed(args.confirm);
+    return { result: await stopTestingLive({ jobId: args.job, projectId: args.project, sessionId: args.sessionId }) };
+}
+async function testingBrowserStatus(args) {
+    return { result: await getTestingLiveStatus({ jobId: args.job, projectId: args.project, sessionId: args.sessionId }) };
+}
+async function testingBrowserExecute(args) {
+    normalizeTestingLiveExecuteSource({ keyword: args.keyword, lines: args.line }, { keyword: 'keyword', line: 'line' });
+    return {
+        result: await executeTestingLive({
+            args: args.argument,
+            jobId: args.job,
+            keyword: args.keyword,
+            lines: args.line,
+            projectId: args.project,
+            raw: args.raw,
+            sessionId: args.sessionId,
+        }),
+    };
+}
+async function testingBrowserInspect(args) {
+    return {
+        result: await inspectTestingLive({
+            jobId: args.job,
+            projectId: args.project,
+            sessionId: args.sessionId,
+        }),
+    };
+}
+async function testingBrowserScreenshot(args) {
+    const outputDir = await mkdtemp(join(tmpdir(), 'agentia-mcp-browser-screenshot-'));
+    return {
+        result: await saveTestingLiveScreenshot({
+            jobId: args.job,
+            output: join(outputDir, 'screenshot.png'),
+            projectId: args.project,
+            sessionId: args.sessionId,
+        }),
+    };
+}
+async function testingBrowserReports(args) {
+    return {
+        result: await getTestingLiveReports({
+            jobId: args.job,
+            projectId: args.project,
+            sessionId: args.sessionId,
+        }),
+    };
+}
+async function testingBrowserSetOptions(args) {
+    return {
+        result: await setTestingLiveOptions({
+            jobId: args.job,
+            projectId: args.project,
+            recorder: normalizeTestingLiveRecorderOptions(args.recorder),
+            sessionId: args.sessionId,
+        }),
+    };
+}
+async function testingBrowserHistory(args) {
+    const result = await getTestingLiveHistory({
+        includeFailed: args.includeFailed,
+        jobId: args.job,
+        keyword: args.keyword,
+        limit: args.limit,
+        projectId: args.project,
+        status: args.status,
+    });
+    return { result: shapeTestingLiveHistoryResult(result, args.linesOnly === true) };
+}
+export const testingBrowserMcpHandlers = {
+    testingBrowserExecute,
+    testingBrowserHistory,
+    testingBrowserInspect,
+    testingBrowserReports,
+    testingBrowserScreenshot,
+    testingBrowserSetOptions,
+    testingBrowserStart,
+    testingBrowserStatus,
+    testingBrowserStop,
+};
+const liveSessionSchema = {
+    job: z.number().int().positive().optional().describe('Optional CRT job ID.'),
+    project: z.number().int().positive().describe('CRT project ID.'),
+    sessionId: z.number().int().positive().optional().describe('Optional active CRT browser session ID.'),
+};
+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_browser_start', {
+        description: 'Start and bootstrap a CRT browser session.',
+        inputSchema: {
+            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(),
+            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(),
+            timeoutSeconds: z.number().int().min(1).max(600).optional(),
+            viewport: z.string().max(100).optional(),
+        },
+        title: 'Agentia Testing Browser Start',
+    }, (args) => safelyHandleTool(() => testingBrowserStart(args)));
+    server.registerTool('agentia_testing_browser_stop', {
+        description: 'Stop the active CRT browser session. Requires explicit confirmation.',
+        inputSchema: { confirm: z.boolean().describe('Must be true to stop the session.'), ...liveSessionSchema },
+        title: 'Agentia Testing Browser Stop',
+    }, (args) => safelyHandleTool(() => testingBrowserStop(args)));
+    server.registerTool('agentia_testing_browser_status', {
+        description: 'Read status for the active CRT browser session.',
+        inputSchema: liveSessionSchema,
+        title: 'Agentia Testing Browser Status',
+    }, (args) => safelyHandleTool(() => testingBrowserStatus(args)));
+    server.registerTool('agentia_testing_browser_execute', {
+        description: 'Execute Robot Framework keywords in the active CRT browser 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(),
+            ...liveSessionSchema,
+        },
+        title: 'Agentia Testing Browser Execute',
+    }, (args) => safelyHandleTool(() => testingBrowserExecute(args)));
+    server.registerTool('agentia_testing_browser_inspect', {
+        description: 'Inspect page state from the active CRT browser session.',
+        inputSchema: liveSessionSchema,
+        title: 'Agentia Testing Browser Inspect',
+    }, (args) => safelyHandleTool(() => testingBrowserInspect(args)));
+    server.registerTool('agentia_testing_browser_screenshot', {
+        description: 'Save a CRT browser screenshot to a temporary path.',
+        inputSchema: liveSessionSchema,
+        title: 'Agentia Testing Browser Screenshot',
+    }, (args) => safelyHandleTool(() => testingBrowserScreenshot(args)));
+    server.registerTool('agentia_testing_browser_reports', {
+        description: 'List browser session report metadata.',
+        inputSchema: liveSessionSchema,
+        title: 'Agentia Testing Browser Reports',
+    }, (args) => safelyHandleTool(() => testingBrowserReports(args)));
+    server.registerTool('agentia_testing_browser_set_options', {
+        description: 'Set CRT browser recorder options.',
+        inputSchema: { recorder: liveRecorderOptionsSchema, ...liveSessionSchema },
+        title: 'Agentia Testing Browser Set Options',
+    }, (args) => safelyHandleTool(() => testingBrowserSetOptions(args)));
+    server.registerTool('agentia_testing_browser_history', {
+        description: 'Read local CRT browser execution history.',
+        inputSchema: {
+            includeFailed: z.boolean().optional().describe('Include failed keyword executions.'),
+            job: z.number().int().positive().optional().describe('CRT job ID; defaults to the active session.'),
+            keyword: z.string().max(200).optional().describe('Filter by Robot Framework keyword name.'),
+            limit: z.number().int().min(1).max(500).optional(),
+            linesOnly: z.boolean().optional().describe('Flatten history into replayable keyword lines.'),
+            project: z.number().int().positive().describe('CRT project ID.'),
+            status: z.enum(['completed', 'failed', 'recorded']).optional(),
+        },
+        title: 'Agentia Testing Browser History',
+    }, (args) => safelyHandleTool(() => testingBrowserHistory(args)));
+}
+//# sourceMappingURL=testing-browser-tools.js.map