plum-e2e 2.5.13 → 2.6.0

package/README.md

@@ -71,7 +71,7 @@ Full documentation is available at:
 | [Running Tests Locally](https://outline.silverlunah.com/s/12bf21d1-02ba-49e9-b0df-908976407afd/doc/running-tests-locally-GGhFcqaAQ8)       | `plum run-test` flags, parallel runs, debugging tips          |
 | [Setting Up the Server](https://outline.silverlunah.com/s/12bf21d1-02ba-49e9-b0df-908976407afd/doc/setting-up-the-server-vj0Ab1kJVs)       | Production server setup, reverse proxy (Nginx/Caddy), Docker  |
 | [Setting Up Nodes](https://outline.silverlunah.com/s/12bf21d1-02ba-49e9-b0df-908976407afd/doc/setting-up-nodes-dtmekJGJia)                 | Runner nodes, systemd service, managing nodes                 |
-| [Integrations](https://outline.silverlunah.com/s/12bf21d1-02ba-49e9-b0df-908976407afd/doc/integrations-qfiqfmdP0j)                         | Discord & Slack webhook notifications                         |
+| [Integrations](https://outline.silverlunah.com/s/12bf21d1-02ba-49e9-b0df-908976407afd/doc/integrations-qfiqfmdP0j)                         | Discord & Slack webhook notifications, CI/external triggers   |
 | [Backup](https://outline.silverlunah.com/s/12bf21d1-02ba-49e9-b0df-908976407afd/doc/backup-RNNObJfct9)                                     | Backup strategy                                               |
 
 ---

package/backend/constants/triggers.js

@@ -24,7 +24,8 @@
 const TRIGGER_TYPE = Object.freeze({
 	MANUAL: 'manual-trigger',
 	CLI: 'command-line-trigger',
-	MCP: 'mcp-trigger'
+	MCP: 'mcp-trigger',
+	EXTERNAL: 'external-trigger'
 });
 
 /**
@@ -45,6 +46,7 @@ const NON_SCHEDULED_TRIGGERS = new Set([
 	TRIGGER_TYPE.MANUAL,
 	TRIGGER_TYPE.CLI,
 	TRIGGER_TYPE.MCP,
+	TRIGGER_TYPE.EXTERNAL,
 	TRIGGER_REMOTE,
 	'undefined'
 ]);

package/backend/lib/screenshotPoller.js

@@ -0,0 +1,43 @@
+/*
+ * This file is part of Plum.
+ *
+ * Plum is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Plum is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Plum. If not, see https://www.gnu.org/licenses/.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function startSsPoller(ssDir, onScreenshot) {
+	const seenFiles = new Set();
+	return setInterval(() => {
+		try {
+			const files = fs
+				.readdirSync(ssDir)
+				.filter((f) => f.endsWith('.ss.json'))
+				.sort();
+			for (const f of files) {
+				if (seenFiles.has(f)) continue;
+				seenFiles.add(f);
+				const filePath = path.join(ssDir, f);
+				const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+				onScreenshot(data);
+				try {
+					fs.unlinkSync(filePath);
+				} catch {}
+			}
+		} catch {}
+	}, 400);
+}
+
+module.exports = { startSsPoller };

package/backend/mcp/server.js

@@ -88,7 +88,9 @@ async function pollJob(jobId, { maxMs = 600_000, intervalMs = 5_000 } = {}) {
 // ---------------------------------------------------------------------------
 
 function summariseReport(report) {
-	const features = report.content?.features ?? [];
+	// GET /reports/:id hoists content.features to a top-level `features` key
+	// and strips `content` entirely — see reportService.getReportDetail.
+	const features = report.features ?? report.content?.features ?? [];
 	const allScenarios = features.flatMap((f) => f.scenarios ?? []);
 	const total = allScenarios.length;
 	const passed = allScenarios.filter((s) => s.status === 'passed').length;
@@ -117,6 +119,18 @@ function summariseReport(report) {
 	};
 }
 
+// ---------------------------------------------------------------------------
+// Screenshots
+// ---------------------------------------------------------------------------
+
+const SCREENSHOT_FILENAME_RE = /^[\w.-]+\.(png|jpg|jpeg)$/i;
+
+function screenshotUrl(filename) {
+	return `${API_URL}/screenshots/${filename}`;
+}
+
+const SCREENSHOT_MIME_TYPES = { png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg' };
+
 // ---------------------------------------------------------------------------
 // Server setup
 // ---------------------------------------------------------------------------
@@ -326,7 +340,14 @@ server.tool(
 			)
 	},
 	async ({ tag, browser, workers, baseUrl, testRunId }) => {
-		const { jobId } = await post('/trigger', { tag, browser, workers, baseUrl, testRunId });
+		const { jobId } = await post('/trigger', {
+			tag,
+			browser,
+			workers,
+			baseUrl,
+			testRunId,
+			source: 'mcp'
+		});
 
 		const job = await pollJob(jobId);
 
@@ -437,6 +458,103 @@ server.tool(
 	}
 );
 
+server.tool(
+	'get_report_scenario_detail',
+	[
+		'Get full per-scenario, per-step detail for a Plum test report — the data needed to diagnose',
+		"and self-heal a failing test: every step's status, duration, full error message, and",
+		'screenshot URL (if one was captured for that step).',
+		'',
+		'Use get_report_screenshot to fetch the actual screenshot image for a filename returned here,',
+		'and get_report_logs for the raw test-run stdout/stderr.'
+	].join('\n'),
+	{
+		reportId: z.number().int().describe('Numeric report ID'),
+		onlyFailed: z
+			.boolean()
+			.optional()
+			.describe('Only include scenarios with a failed step (default true)')
+	},
+	async ({ reportId, onlyFailed = true }) => {
+		const data = await get(`/reports/${reportId}`);
+		const features = data.features ?? data.content?.features ?? [];
+
+		const scenarios = features.flatMap((feature) =>
+			(feature.scenarios ?? [])
+				.filter((s) => !onlyFailed || s.status === 'failed')
+				.map((s) => ({
+					feature: feature.name,
+					scenario: s.name,
+					tags: s.tags ?? [],
+					status: s.status,
+					duration: s.duration,
+					steps: (s.steps ?? []).map((st) => ({
+						keyword: st.keyword,
+						name: st.name,
+						status: st.status,
+						duration: st.duration,
+						error: st.error ?? null,
+						screenshot: st.screenshot ?? null,
+						screenshotUrl: st.screenshot ? screenshotUrl(st.screenshot) : null
+					}))
+				}))
+		);
+
+		return { content: [{ type: 'text', text: JSON.stringify({ reportId, scenarios }, null, 2) }] };
+	}
+);
+
+server.tool(
+	'get_report_screenshot',
+	'Fetch a screenshot captured during a test step and return it as an image, so it can be viewed ' +
+		"directly. Get the filename from get_report_scenario_detail's step.screenshot field.",
+	{
+		filename: z.string().describe('Screenshot filename, e.g. "3f9c1e2a-....png"')
+	},
+	async ({ filename }) => {
+		if (!SCREENSHOT_FILENAME_RE.test(filename)) {
+			throw new Error(`Invalid screenshot filename: ${filename}`);
+		}
+		const res = await fetch(screenshotUrl(filename));
+		if (!res.ok) throw new Error(`Screenshot not found: ${filename}`);
+		const buffer = Buffer.from(await res.arrayBuffer());
+		const ext = filename.split('.').pop().toLowerCase();
+
+		return {
+			content: [
+				{
+					type: 'image',
+					data: buffer.toString('base64'),
+					mimeType: SCREENSHOT_MIME_TYPES[ext]
+				}
+			]
+		};
+	}
+);
+
+server.tool(
+	'get_report_logs',
+	'Get the raw stdout/stderr log output captured during a Plum test run, tagged per runner. ' +
+		'Useful for diagnosing failures with no clear step-level error (crashes, timeouts, setup errors).',
+	{
+		reportId: z.number().int().describe('Numeric report ID'),
+		tail: z
+			.number()
+			.int()
+			.positive()
+			.optional()
+			.describe('Only return the last N lines (default: full log)')
+	},
+	async ({ reportId, tail }) => {
+		const data = await get(`/reports/${reportId}`);
+		let logs = data.logs ?? '';
+		if (tail) {
+			logs = logs.split('\n').slice(-tail).join('\n');
+		}
+		return { content: [{ type: 'text', text: logs || '(no logs captured for this report)' }] };
+	}
+);
+
 // ---------------------------------------------------------------------------
 // Start
 // ---------------------------------------------------------------------------

package/backend/prisma/migrations/20260713090000_add_report_duration/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "Report" ADD COLUMN "duration" INTEGER;

package/backend/prisma/schema.prisma

@@ -68,6 +68,7 @@ model Report {
   testRun     TestRun?          @relation(fields: [testRunId], references: [id], onDelete: SetNull)
   content     Json
   logs        String?
+  duration    Int?
   createdAt   DateTime          @default(now())
   testHistory TestCaseHistory[]
 

package/backend/routes/node.routes.js

@@ -60,7 +60,7 @@ router.post('/execute', authGuard, (req, res) => {
 		for (const [rel, content] of Object.entries(tests)) {
 			const dest = path.join(tempTestsDir, rel);
 			fs.mkdirSync(path.dirname(dest), { recursive: true });
-			fs.writeFileSync(dest, content, 'utf8');
+			fs.writeFileSync(dest, Buffer.from(content, 'base64'));
 		}
 	}
 

package/backend/routes/trigger.routes.js

@@ -16,12 +16,15 @@
  */
 
 const path = require('path');
+const fs = require('fs');
+const os = require('os');
 const { spawn } = require('child_process');
 const { randomUUID } = require('crypto');
 const express = require('express');
 const router = express.Router();
 const { jwtAuth } = require('../middleware/jwtAuth');
 const prisma = require('../services/prisma');
+const { startSsPoller } = require('../lib/screenshotPoller');
 const { TRIGGER_TYPE } = require('../constants/triggers');
 
 const BACKEND_DIR = path.resolve(__dirname, '..');
@@ -30,6 +33,11 @@ const JOB_TTL_MS = 60 * 60 * 1000; // 1 hour
 // In-memory job store: jobId → { status, exitCode, reportId, startedAt }
 const jobs = new Map();
 
+let _io = null;
+function setSocketIO(io) {
+	_io = io;
+}
+
 function pruneOldJobs() {
 	const cutoff = Date.now() - JOB_TTL_MS;
 	for (const [id, job] of jobs) {
@@ -41,18 +49,23 @@ router.post('/', jwtAuth, async (req, res, next) => {
 	try {
 		pruneOldJobs();
 
-		const { tag = '', browser = 'chromium', workers = 1, baseUrl, testRunId } = req.body;
+		const { tag = '', browser = 'chromium', workers = 1, baseUrl, testRunId, source } = req.body;
+		const trigger = source === 'mcp' ? TRIGGER_TYPE.MCP : TRIGGER_TYPE.EXTERNAL;
 
 		const jobId = randomUUID();
 		const startedAt = Date.now();
 		jobs.set(jobId, { status: 'running', exitCode: null, reportId: null, startedAt });
 
+		const ssDir = path.join(os.tmpdir(), `plum-trigger-ss-${jobId}`);
+		fs.mkdirSync(ssDir, { recursive: true });
+
 		const env = {
 			...process.env,
 			TAG: tag,
-			TRIGGER: TRIGGER_TYPE.MCP,
+			TRIGGER: trigger,
 			BROWSER: browser,
-			REPORT_RUNNERS: String(workers)
+			REPORT_RUNNERS: String(workers),
+			PLUM_SS_DIR: ssDir
 		};
 		if (Number(workers) > 1) env.PARALLEL = String(workers);
 		if (testRunId) env.TEST_RUN_ID = testRunId;
@@ -60,7 +73,31 @@ router.post('/', jwtAuth, async (req, res, next) => {
 
 		const proc = spawn('npm', ['run', 'test'], { env, shell: true, cwd: BACKEND_DIR });
 
+		if (_io) {
+			_io.emit('bg-run-start', {
+				runId: jobId,
+				kind: trigger,
+				label: trigger === TRIGGER_TYPE.MCP ? 'MCP run' : 'External run',
+				meta: { tag, browser, workers }
+			});
+		}
+
+		const ssPoller = startSsPoller(ssDir, ({ stepName, data }) => {
+			if (_io) _io.emit('bg-run-screenshot', { runId: jobId, stepName, data });
+		});
+
+		proc.stdout.on('data', (d) => {
+			if (_io) _io.emit('bg-run-log', { runId: jobId, log: d.toString() });
+		});
+		proc.stderr.on('data', (d) => {
+			if (_io) _io.emit('bg-run-log', { runId: jobId, log: `[ERROR] ${d.toString()}` });
+		});
+
 		proc.on('close', async (code) => {
+			clearInterval(ssPoller);
+			fs.rm(ssDir, { recursive: true, force: true }, () => {});
+
+			let reportId = null;
 			try {
 				// Find the latest report created after this job started
 				const report = await prisma.report.findFirst({
@@ -68,15 +105,24 @@ router.post('/', jwtAuth, async (req, res, next) => {
 					orderBy: { createdAt: 'desc' },
 					select: { id: true, status: true }
 				});
+				reportId = report?.id ?? null;
+				if (reportId) {
+					await prisma.report.update({
+						where: { id: reportId },
+						data: { duration: Date.now() - startedAt }
+					});
+				}
 				jobs.set(jobId, {
 					status: code === 130 ? 'cancelled' : 'done',
 					exitCode: code,
-					reportId: report?.id ?? null,
+					reportId,
 					startedAt
 				});
 			} catch {
 				jobs.set(jobId, { status: 'done', exitCode: code, reportId: null, startedAt });
 			}
+
+			if (_io) _io.emit('bg-run-done', { runId: jobId, code, reportId });
 		});
 
 		res.status(202).json({ jobId, status: 'running' });
@@ -92,3 +138,4 @@ router.get('/:jobId', jwtAuth, (req, res) => {
 });
 
 module.exports = router;
+router.setSocketIO = setSocketIO;

package/backend/server.js

@@ -48,6 +48,7 @@ if (!isNodeMode) {
 	backupCronService = require('./services/backupCronService');
 	socketHandler(io);
 	cronService.setSocketIO(io);
+	require('./routes/trigger.routes').setSocketIO(io);
 }
 
 async function start() {

package/backend/services/cronService.js

@@ -17,10 +17,14 @@
 
 const cron = require('node-cron');
 const { spawn } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
 const prisma = require('./prisma');
 const runnerService = require('./runnerService');
 const reportService = require('./reportService');
 const notificationService = require('./notificationService');
+const { startSsPoller } = require('../lib/screenshotPoller');
 const { BUILT_IN_RUNNER_ID, TRIGGER_REMOTE } = require('../constants/triggers');
 const { getTestIdsForTag, chunkTests, buildTagExpression } = require('../lib/testChunker');
 const { readCucumberReportFile } = require('../lib/reportFilename');
@@ -65,30 +69,54 @@ async function resolveLaneInfos(runnerIds) {
  * TRIGGER is set to taskName so generate-report.js can persist it correctly.
  */
 function runSingleBuiltIn({ taskName, tags, workers, browser, notifyDiscord, notifySlack }) {
+	const ssDir = path.join(os.tmpdir(), `plum-cron-ss-${Date.now()}`);
+	fs.mkdirSync(ssDir, { recursive: true });
+	const startedAt = Date.now();
+
 	const env = {
 		...process.env,
 		TAG: tags,
 		TRIGGER: taskName,
-		BROWSER: browser
+		BROWSER: browser,
+		PLUM_SS_DIR: ssDir
 	};
 	if (workers > 1) env.PARALLEL = String(workers);
 
 	const task = spawn('npm', ['run', 'test'], { env, shell: true });
-	task.stdout.on('data', (d) => process.stdout.write(d));
-	task.stderr.on('data', (d) => process.stderr.write(d));
+
+	const ssPoller = startSsPoller(ssDir, ({ stepName, data }) => {
+		if (_io) _io.emit('bg-run-screenshot', { runId: taskName, stepName, data });
+	});
+
+	task.stdout.on('data', (d) => {
+		process.stdout.write(d);
+		if (_io) _io.emit('bg-run-log', { runId: taskName, log: d.toString() });
+	});
+	task.stderr.on('data', (d) => {
+		process.stderr.write(d);
+		if (_io) _io.emit('bg-run-log', { runId: taskName, log: `[ERROR] ${d.toString()}` });
+	});
 	task.on('close', (code) => {
+		clearInterval(ssPoller);
+		fs.rm(ssDir, { recursive: true, force: true }, () => {});
 		console.log(`Task "${taskName}" finished with code ${code}`);
-		if (_io) _io.emit('cron-done', { taskName, code });
-
-		if (notifyDiscord || notifySlack) {
-			prisma.report
-				.findFirst({
-					where: { triggerType: taskName },
-					orderBy: { createdAt: 'desc' },
-					select: { id: true, status: true, content: true }
-				})
-				.then((report) => {
-					if (!report) return;
+
+		prisma.report
+			.findFirst({
+				where: { triggerType: taskName },
+				orderBy: { createdAt: 'desc' },
+				select: { id: true, status: true, content: true }
+			})
+			.then((report) => {
+				if (_io) _io.emit('bg-run-done', { runId: taskName, code, reportId: report?.id ?? null });
+
+				if (report) {
+					prisma.report
+						.update({ where: { id: report.id }, data: { duration: Date.now() - startedAt } })
+						.catch(() => {});
+				}
+
+				if (report && (notifyDiscord || notifySlack)) {
 					return notificationService.send({
 						jobName: taskName,
 						status: report.status,
@@ -99,9 +127,12 @@ function runSingleBuiltIn({ taskName, tags, workers, browser, notifyDiscord, not
 						notifyDiscord,
 						notifySlack
 					});
-				})
-				.catch((e) => console.error(`[cron] Notification failed: ${e.message}`));
-		}
+				}
+			})
+			.catch((e) => {
+				console.error(`[cron] Notification failed: ${e.message}`);
+				if (_io) _io.emit('bg-run-done', { runId: taskName, code, reportId: null });
+			});
 	});
 }
 
@@ -118,6 +149,7 @@ async function runDistributed({
 	notifyDiscord,
 	notifySlack
 }) {
+	const dispatchStartedAt = Date.now();
 	const allIds = getTestIdsForTag(tags);
 	const chunks = chunkTests(allIds, runnerIds.length);
 
@@ -127,24 +159,37 @@ async function runDistributed({
 
 	if (activeRunnerIds.length === 0) {
 		console.log(`Task "${taskName}" — no tests found, skipping.`);
-		if (_io) _io.emit('cron-done', { taskName, code: 0 });
+		if (_io) _io.emit('bg-run-done', { runId: taskName, code: 0, reportId: null });
 		return;
 	}
 
 	const laneInfos = await resolveLaneInfos(activeRunnerIds);
 
+	if (_io) {
+		_io.emit('bg-run-lanes-init', {
+			runId: taskName,
+			lanes: laneInfos.map((l, i) => ({ id: l.id, name: l.name, testCount: chunks[i].length }))
+		});
+	}
+
 	const collectedReports = new Array(activeRunnerIds.length).fill(null);
 	let doneCount = 0;
 	let overallCode = 0;
 
-	function onLaneDone(idx, code, reportContent) {
+	function onLaneDone(idx, laneId, code, reportContent) {
 		if (code !== 0) overallCode = code;
 		collectedReports[idx] = reportContent;
 		doneCount++;
+		if (_io) {
+			_io.emit('bg-run-lane-status', {
+				runId: taskName,
+				laneId,
+				status: code === 0 ? 'done' : 'error'
+			});
+		}
 
 		if (doneCount === activeRunnerIds.length) {
 			console.log(`Task "${taskName}" — all runners done (exit ${overallCode})`);
-			if (_io) _io.emit('cron-done', { taskName, code: overallCode });
 
 			reportService
 				.saveCombinedReport({
@@ -153,9 +198,17 @@ async function runDistributed({
 					overallCode,
 					tag: tags,
 					triggerType: taskName,
-					browser
+					browser,
+					duration: Date.now() - dispatchStartedAt
 				})
 				.then((saved) => {
+					if (_io) {
+						_io.emit('bg-run-done', {
+							runId: taskName,
+							code: overallCode,
+							reportId: saved?.id ?? null
+						});
+					}
 					if (saved && (notifyDiscord || notifySlack)) {
 						return notificationService.send({
 							jobName: taskName,
@@ -169,36 +222,66 @@ async function runDistributed({
 						});
 					}
 				})
-				.catch((e) => console.error(`[cron] Failed to save combined report: ${e.message}`));
+				.catch((e) => {
+					console.error(`[cron] Failed to save combined report: ${e.message}`);
+					if (_io) _io.emit('bg-run-done', { runId: taskName, code: overallCode, reportId: null });
+				});
 		}
 	}
 
 	for (let i = 0; i < activeRunnerIds.length; i++) {
 		const lane = laneInfos[i];
+		const laneId = lane.id;
 		const chunkTag = buildTagExpression(chunks[i]);
 
 		if (lane.id === BUILT_IN_RUNNER_ID) {
+			const ssDir = path.join(os.tmpdir(), `plum-cron-ss-${Date.now()}-${i}`);
+			fs.mkdirSync(ssDir, { recursive: true });
+
 			const env = {
 				...process.env,
 				TAG: chunkTag,
 				TRIGGER: TRIGGER_REMOTE, // node-mode: file naming only, not persisted to DB
 				BROWSER: browser,
-				PLUM_MODE: 'node'
+				PLUM_MODE: 'node',
+				PLUM_SS_DIR: ssDir
 			};
 			if (workers > 1) env.PARALLEL = String(workers);
 
 			const task = spawn('npm', ['run', 'test'], { env, shell: true });
-			task.stdout.on('data', (d) => process.stdout.write(d));
-			task.stderr.on('data', (d) => process.stderr.write(d));
+
+			const ssPoller = startSsPoller(ssDir, ({ stepName, data }) => {
+				if (_io) _io.emit('bg-run-lane-screenshot', { runId: taskName, laneId, stepName, data });
+			});
+
+			task.stdout.on('data', (d) => {
+				process.stdout.write(d);
+				if (_io) _io.emit('bg-run-lane-log', { runId: taskName, laneId, log: d.toString() });
+			});
+			task.stderr.on('data', (d) => {
+				const text = `[ERROR] ${d.toString()}`;
+				process.stderr.write(d);
+				if (_io) _io.emit('bg-run-lane-log', { runId: taskName, laneId, log: text });
+			});
 			const idx = i;
-			task.on('close', (code) => onLaneDone(idx, code, readCucumberReportFile()));
+			task.on('close', (code) => {
+				clearInterval(ssPoller);
+				fs.rm(ssDir, { recursive: true, force: true }, () => {});
+				onLaneDone(idx, laneId, code, readCucumberReportFile());
+			});
 		} else {
 			const idx = i;
 			runnerService.dispatchAndPoll(
 				lane.id,
 				{ tags: chunkTag, browser, workers },
-				(log) => process.stdout.write(log),
-				(code, content) => onLaneDone(idx, code, content)
+				(log) => {
+					process.stdout.write(log);
+					if (_io) _io.emit('bg-run-lane-log', { runId: taskName, laneId, log });
+				},
+				(code, content) => onLaneDone(idx, laneId, code, content),
+				({ stepName, data }) => {
+					if (_io) _io.emit('bg-run-lane-screenshot', { runId: taskName, laneId, stepName, data });
+				}
 			);
 		}
 	}
@@ -220,7 +303,14 @@ async function runCronJob(job) {
 	} = job;
 	const runnerIds = parseRunnerIds(runnerIdsStr);
 
-	if (_io) _io.emit('cron-start', { taskName });
+	if (_io) {
+		_io.emit('bg-run-start', {
+			runId: taskName,
+			kind: 'cron',
+			label: taskName,
+			meta: { tag: tags, browser, workers }
+		});
+	}
 	console.log(`Running scheduled task: "${taskName}" → runners: ${runnerIds.join(', ')}`);
 
 	const isSingleBuiltIn = runnerIds.length === 1 && runnerIds[0] === BUILT_IN_RUNNER_ID;

package/backend/services/reportService.js

@@ -291,6 +291,7 @@ const getReportDetail = async (id) => {
 			createdAt: true,
 			content: true,
 			logs: true,
+			duration: true,
 			testRun: { select: { id: true, title: true } }
 		}
 	});
@@ -327,7 +328,8 @@ const saveReport = async ({
 	runnerId,
 	testRunId,
 	forceFail = false,
-	logs = null
+	logs = null,
+	duration = null
 }) => {
 	const normTrigger = normaliseTrigger(triggerType);
 	const { features, status: derivedStatus } = processCucumberJson(rawCucumberJson);
@@ -346,7 +348,8 @@ const saveReport = async ({
 			cronJobId,
 			testRunId: testRunId ?? null,
 			content: { features },
-			logs: logs || null
+			logs: logs || null,
+			duration
 		}
 	});
 	syncAutomatedTags(report.id, features, testRunId ?? null);
@@ -364,6 +367,7 @@ const saveReport = async ({
  *   tag: string,
  *   triggerType: string,
  *   browser: string,
+ *   duration: number,
  * }} opts
  */
 const saveCombinedReport = async ({
@@ -374,7 +378,8 @@ const saveCombinedReport = async ({
 	triggerType,
 	browser,
 	testRunId,
-	laneLogs = null
+	laneLogs = null,
+	duration = null
 }) => {
 	const featureMap = new Map();
 	for (const content of reports) {
@@ -418,7 +423,8 @@ const saveCombinedReport = async ({
 		runnerId: null,
 		testRunId: testRunId ?? null,
 		forceFail: reports.some((r) => r === null),
-		logs: combinedLogs
+		logs: combinedLogs,
+		duration
 	});
 };