plum-e2e 2.8.6 → 2.9.1

package/backend/services/nodeExecutionService.js

@@ -8,7 +8,8 @@ const os = require('os');
 const path = require('path');
 const crypto = require('crypto');
 const { spawn } = require('child_process');
-const { startSsPoller } = require('../lib/screenshotPoller');
+const { io: ioClient } = require('socket.io-client');
+const { startRRwebPoller } = require('../lib/rrwebPoller');
 const { TRIGGER_REMOTE } = require('../constants/triggers');
 const { DEFAULT_BROWSER } = require('../constants/defaults');
 const { JOB_STATUS } = require('../constants/jobStatus');
@@ -23,17 +24,40 @@ function getJob(jobId) {
 	return jobs[jobId];
 }
 
+// Opens this node's own outbound connection back to the primary for this job
+// — logs/rrweb events are pushed the moment they happen instead of waiting to
+// be polled. Uses the same token this node already validates incoming HTTP
+// calls against (see authGuard), so there's no separate credential to manage.
+// Best-effort: if the primary is unreachable this way, the job still runs —
+// dispatchAndPoll falls back to draining logs from the HTTP poll when it
+// never registered a socket relay for this jobId.
+function connectPrimaryStream(primaryUrl, jobId) {
+	try {
+		const socket = ioClient(`${primaryUrl}/node-stream`, {
+			auth: { token: process.env.NODE_TOKEN },
+			reconnectionAttempts: 5,
+			timeout: 8000
+		});
+		socket.on('connect', () => socket.emit('join', jobId));
+		return socket;
+	} catch {
+		return null;
+	}
+}
+
 // Starts a remote test job dispatched from the primary server: materializes
-// any uploaded test files, spawns `npm run test`, and tracks logs/screenshots
-// for later HTTP polling (see pollJob).
+// any uploaded test files, spawns `npm run test`, and tracks logs for later
+// HTTP polling (see pollJob).
 function startJob({
 	tags,
 	browser = DEFAULT_BROWSER,
 	workers = 1,
 	tests = null,
-	env: userEnv = {}
+	env: userEnv = {},
+	primaryUrl = null
 }) {
 	const jobId = crypto.randomUUID();
+	const primaryStream = primaryUrl ? connectPrimaryStream(primaryUrl, jobId) : null;
 
 	// path.resolve ensures absolute even if TMPDIR env var is set to a relative path
 	const tmpdir = path.resolve(os.tmpdir());
@@ -63,8 +87,7 @@ function startJob({
 		meta: { tags: tags || '', browser, workers },
 		tempTestsDir,
 		reportFile,
-		ssDir,
-		pendingScreenshots: []
+		ssDir
 	};
 
 	const env = {
@@ -84,19 +107,24 @@ function startJob({
 	};
 	if (workers > 1) env.PARALLEL = String(workers);
 
-	const ssPoller = startSsPoller(ssDir, (data) => {
-		jobs[jobId]?.pendingScreenshots.push(data);
+	const ssPoller = startRRwebPoller(ssDir, (batch) => {
+		primaryStream?.emit('rrweb-batch', batch);
 	});
 
 	const proc = spawn('npm', ['run', 'test'], { env, shell: true, cwd: BACKEND_DIR });
 	proc.stdout.on('data', (d) => {
-		jobs[jobId].logs += d.toString();
+		const text = d.toString();
+		jobs[jobId].logs += text;
+		primaryStream?.emit('log', text);
 	});
 	proc.stderr.on('data', (d) => {
-		jobs[jobId].logs += d.toString();
+		const text = d.toString();
+		jobs[jobId].logs += text;
+		primaryStream?.emit('log', text);
 	});
 	proc.on('close', (code) => {
 		clearInterval(ssPoller);
+		primaryStream?.close();
 		jobs[jobId].status = code === 0 ? JOB_STATUS.DONE : JOB_STATUS.ERROR;
 		jobs[jobId].exitCode = code;
 
@@ -123,17 +151,15 @@ function startJob({
 	return jobId;
 }
 
-// Drains and returns pending screenshots plus logs since `offset` — used by
-// the primary's HTTP polling loop (this node has no socket.io connection back).
+// Drains and returns logs since `offset` — used by the primary's HTTP polling
+// loop (this node has no socket.io connection back).
 function pollJob(jobId, offset) {
 	const job = jobs[jobId];
 	if (!job) return null;
-	const screenshots = job.pendingScreenshots.splice(0);
 	return {
 		status: job.status,
 		logs: job.logs.slice(offset),
-		exitCode: job.exitCode,
-		screenshots
+		exitCode: job.exitCode
 	};
 }
 

package/backend/services/nodeStreamRegistry.js

@@ -0,0 +1,24 @@
+/*
+ * This file is part of Plum.
+ * Licensed under the MIT License. See LICENSE file in the project root for details.
+ */
+
+// In-memory jobId -> relay callbacks, so an incoming node socket (which only
+// knows its own jobId) can find where to forward live rrweb/log events —
+// registered by whichever dispatch call (socketHandler, cronService) started
+// this job and already knows the browser-facing emit target/laneId.
+const relays = new Map();
+
+function registerRelay(jobId, { onRRwebBatch, onLog }) {
+	relays.set(jobId, { onRRwebBatch, onLog });
+}
+
+function unregisterRelay(jobId) {
+	relays.delete(jobId);
+}
+
+function getRelay(jobId) {
+	return relays.get(jobId);
+}
+
+module.exports = { registerRelay, unregisterRelay, getRelay };

package/backend/services/reportService.js

@@ -5,12 +5,20 @@
 
 const fs = require('fs');
 const path = require('path');
-const crypto = require('crypto');
+const zlib = require('zlib');
 const prisma = require('./prisma');
 const { isScheduledTrigger, normaliseTrigger } = require('../constants/triggers');
 const { DEFAULT_BROWSER } = require('../constants/defaults');
 const { REPORT_STATUS } = require('../constants/jobStatus');
-const { SCREENSHOTS_DIR } = require('../lib/reportFilename');
+
+// Matched by string literal in backend/tests/utils/browser.ts (flushRecordings) —
+// the two runtimes don't share a module, mirroring how 'image/png' is already
+// duplicated between the two files.
+const RRWEB_MIME_TYPE = 'application/x-plum-rrweb+json';
+// Small, always-attached marker (independent of whether any tab actually
+// recorded events) so a scenario's worker is always recoverable for grouping,
+// even on an instant-failure scenario with an empty recording.
+const WORKER_META_MIME_TYPE = 'application/x-plum-worker+json';
 
 // ---------------------------------------------------------------------------
 // Auto-sync: mark test cases as automated and record history from Cucumber tags
@@ -101,22 +109,6 @@ async function resolveCronJobId(triggerType) {
 	return job?.id ?? null;
 }
 
-/**
- * Walks a screenshot filename out of the content JSON tree.
- * Used when deleting reports to clean up screenshot files.
- */
-function collectScreenshotFiles(content) {
-	const files = [];
-	for (const feature of content?.features ?? []) {
-		for (const scenario of feature?.scenarios ?? []) {
-			for (const step of scenario?.steps ?? []) {
-				if (step.screenshot) files.push(step.screenshot);
-			}
-		}
-	}
-	return files;
-}
-
 /**
  * Stable identity for a Cucumber feature across distributed lanes. Dispatched
  * runs report an absolute temp uri (…/plum-job-<uuid>/features/Login.feature)
@@ -139,10 +131,36 @@ function scenarioIdTag(scenario) {
 	return (scenario.tags ?? []).map((t) => t.name).find(isTestCaseTag) ?? null;
 }
 
+// Cucumber's legacy JSON `id` is identical for every Examples row of a Scenario
+// Outline — `line` (the row's own line in the feature file) is the only field
+// that actually differs between them, so combine the two for a truly unique key.
+function scenarioUniqueId(scenario) {
+	return `${scenario.id};;${scenario.line}`;
+}
+
 function scenarioFailed(scenario) {
 	return (scenario.steps ?? []).some((s) => s.result?.status === 'failed');
 }
 
+/**
+ * Reads the worker-id marker browser.ts attaches unconditionally in the After
+ * hook (separate from rrweb recordings, which can legitimately be empty).
+ */
+function extractWorkerId(scenario) {
+	const marker = (scenario.steps || [])
+		.filter((s) => s.hidden)
+		.flatMap(
+			(step) => step.embeddings?.filter((e) => e.mime_type === WORKER_META_MIME_TYPE) ?? []
+		)[0];
+	if (!marker) return 1;
+	try {
+		const { workerId } = JSON.parse(Buffer.from(marker.data, 'base64').toString('utf8'));
+		return Number.isFinite(workerId) ? workerId : 1;
+	} catch {
+		return 1;
+	}
+}
+
 /**
  * Test-ID tags (see scenarioIdTag) of every failed scenario in a raw Cucumber
  * JSON payload, deduped. Used to scope the next retry attempt to just the
@@ -178,7 +196,9 @@ function mergeRawAttempt(accumulated, attemptRawJson, round, attemptsMap) {
 			accumulated.push(accFeature);
 		}
 		for (const scenario of feature.elements ?? []) {
-			accFeature.elements = accFeature.elements.filter((e) => e.id !== scenario.id);
+			accFeature.elements = accFeature.elements.filter(
+				(e) => scenarioUniqueId(e) !== scenarioUniqueId(scenario)
+			);
 			accFeature.elements.push(scenario);
 			const idTag = scenarioIdTag(scenario);
 			if (idTag) attemptsMap[idTag] = round;
@@ -187,61 +207,61 @@ function mergeRawAttempt(accumulated, attemptRawJson, round, attemptsMap) {
 	return accumulated;
 }
 
-function deleteScreenshotFiles(content) {
-	for (const file of collectScreenshotFiles(content)) {
-		const p = path.join(SCREENSHOTS_DIR, file);
-		try {
-			if (fs.existsSync(p)) fs.unlinkSync(p);
-		} catch {}
-	}
+/**
+ * Parses one scenario's hidden hook-step rrweb attachments (flushed from
+ * browser.ts's flushRecordings via the After hook) into Recording rows ready
+ * for prisma.recording.createMany, keyed to this scenario via scenarioUniqueId.
+ */
+function extractRecordings(scenario) {
+	const hookRecordings = (scenario.steps || [])
+		.filter((s) => s.hidden)
+		.flatMap((step) => step.embeddings?.filter((e) => e.mime_type === RRWEB_MIME_TYPE) ?? []);
+
+	return hookRecordings
+		.map((embedding) => {
+			try {
+				const decompressed = zlib.gunzipSync(Buffer.from(embedding.data, 'base64'));
+				const { workerId, tabId, tabIndex, events, openedAt, closedAt } = JSON.parse(
+					decompressed.toString('utf8')
+				);
+				return {
+					scenarioId: scenarioUniqueId(scenario),
+					workerId,
+					tabId,
+					tabIndex,
+					// Real Playwright open/close times (browser.ts), not inferred from the
+					// events themselves — a static page can go quiet, or emit nothing at
+					// all, long before it actually closes, which made the last-event
+					// timestamp an unreliable stand-in for how long a tab stayed relevant.
+					startedAt: BigInt(openedAt ?? events[0]?.timestamp ?? 0),
+					endedAt: BigInt(closedAt ?? events[events.length - 1]?.timestamp ?? 0),
+					events: zlib.gzipSync(Buffer.from(JSON.stringify(events), 'utf8'))
+				};
+			} catch (e) {
+				console.error(`[report] Failed to parse rrweb recording: ${e.message}`);
+				return null;
+			}
+		})
+		.filter(Boolean);
 }
 
 /**
  * Transforms raw Cucumber JSON into our stored format:
  * - Resolves pass/fail status per step/scenario/feature
- * - Extracts base64 screenshots to PNG files on disk
- * - Stores only the filename in the content (not the base64 blob)
+ * - Extracts rrweb recordings attached via the After hook
  *
- * Returns { features, status } where status is 'PASS' | 'FAIL'.
+ * Returns { features, status, recordings } where status is 'PASS' | 'FAIL'.
  */
 function processCucumberJson(raw, attempts = {}) {
-	fs.mkdirSync(SCREENSHOTS_DIR, { recursive: true });
+	const recordings = [];
 
 	const features = raw.map((feature) => {
 		const scenarios = (feature.elements || []).map((scenario) => {
+			recordings.push(...extractRecordings(scenario));
+
 			const visibleSteps = (scenario.steps || []).filter((s) => !s.hidden);
-			const hookScreenshots = (scenario.steps || [])
-				.filter((s) => s.hidden)
-				.flatMap((step) => step.embeddings?.filter((e) => e.mime_type === 'image/png') ?? []);
-			const failedStepIndex = visibleSteps.findLastIndex((s) => s.result?.status === 'failed');
-
-			const steps = visibleSteps.map((step, index) => {
-				// AfterStep hook attachments land in step.after[].embeddings in Cucumber.js JSON
-				const afterStepScreenshot =
-					(step.after ?? []).flatMap(
-						(a) => a.embeddings?.filter((e) => e.mime_type === 'image/png') ?? []
-					)[0]?.data ?? null;
-
-				const screenshotData =
-					step.embeddings?.find((e) => e.mime_type === 'image/png')?.data ??
-					afterStepScreenshot ??
-					(index === failedStepIndex ? hookScreenshots[0]?.data : null) ??
-					null;
-
-				let screenshotFile = null;
-				if (screenshotData) {
-					screenshotFile = `${crypto.randomUUID()}.png`;
-					try {
-						fs.writeFileSync(
-							path.join(SCREENSHOTS_DIR, screenshotFile),
-							Buffer.from(screenshotData, 'base64')
-						);
-					} catch (e) {
-						console.error(`[report] Failed to write screenshot: ${e.message}`);
-						screenshotFile = null;
-					}
-				}
 
+			const steps = visibleSteps.map((step) => {
 				const rawStatus = step.result?.status ?? 'pending';
 				// Undefined/ambiguous steps rank below 'failed' otherwise, so a step
 				// definition mismatch reports as passing instead of failing.
@@ -254,7 +274,7 @@ function processCucumberJson(raw, attempts = {}) {
 					status,
 					duration: Math.round((step.result?.duration ?? 0) / 1_000_000),
 					error: step.result?.error_message ?? null,
-					screenshot: screenshotFile
+					dataTable: step.arguments?.[0]?.rows?.map((row) => row.cells) ?? null
 				};
 			});
 
@@ -264,12 +284,15 @@ function processCucumberJson(raw, attempts = {}) {
 			}, 'passed');
 
 			return {
+				id: scenarioUniqueId(scenario),
 				name: scenario.name,
 				keyword: scenario.keyword,
 				tags: (scenario.tags ?? []).map((t) => t.name),
 				status: worstStatus,
 				duration: steps.reduce((s, st) => s + st.duration, 0),
 				attempts: attempts[scenarioIdTag(scenario)] ?? 1,
+				workerId: extractWorkerId(scenario),
+				runnerName: scenario.__plumRunnerName ?? null,
 				steps
 			};
 		});
@@ -283,7 +306,7 @@ function processCucumberJson(raw, attempts = {}) {
 	});
 
 	const hasFailures = features.some((f) => f.status === 'failed');
-	return { features, status: hasFailures ? REPORT_STATUS.FAIL : REPORT_STATUS.PASS };
+	return { features, recordings, status: hasFailures ? REPORT_STATUS.FAIL : REPORT_STATUS.PASS };
 }
 
 // ---------------------------------------------------------------------------
@@ -295,7 +318,8 @@ const reportListSelect = {
 	status: true,
 	tags: true,
 	triggerType: true,
-	runners: true,
+	runnerCount: true,
+	workerCount: true,
 	browser: true,
 	runnerName: true,
 	createdAt: true,
@@ -340,7 +364,8 @@ const getReportDetail = async (id) => {
 			status: true,
 			tags: true,
 			triggerType: true,
-			runners: true,
+			runnerCount: true,
+			workerCount: true,
 			browser: true,
 			runnerName: true,
 			createdAt: true,
@@ -355,6 +380,47 @@ const getReportDetail = async (id) => {
 	return { ...meta, features: content?.features ?? [] };
 };
 
+/**
+ * Metadata for every recording on a report — deliberately excludes `events`
+ * (can be large) so the replay UI can work out tab timing/order before
+ * fetching any actual event data.
+ */
+const getRecordings = async (reportId) => {
+	const recordings = await prisma.recording.findMany({
+		where: { reportId },
+		select: {
+			id: true,
+			scenarioId: true,
+			workerId: true,
+			tabId: true,
+			tabIndex: true,
+			startedAt: true,
+			endedAt: true
+		},
+		orderBy: { tabIndex: 'asc' }
+	});
+	// BigInt doesn't survive JSON.stringify — both fit safely in a JS Number
+	// (epoch ms is well under Number.MAX_SAFE_INTEGER).
+	return recordings.map((r) => ({
+		...r,
+		startedAt: r.startedAt === null ? null : Number(r.startedAt),
+		endedAt: r.endedAt === null ? null : Number(r.endedAt)
+	}));
+};
+
+/**
+ * Decompresses one recording's rrweb event array, fetched lazily by the
+ * replay UI only once a tab is actually selected for playback.
+ */
+const getRecordingEvents = async (recordingId) => {
+	const recording = await prisma.recording.findUnique({
+		where: { id: recordingId },
+		select: { events: true }
+	});
+	if (!recording) return null;
+	return JSON.parse(zlib.gunzipSync(recording.events).toString('utf8'));
+};
+
 // ---------------------------------------------------------------------------
 // Write operations
 // ---------------------------------------------------------------------------
@@ -366,7 +432,8 @@ const getReportDetail = async (id) => {
  *   rawCucumberJson: object[],
  *   tags: string,
  *   triggerType: string,
- *   nodeCount?: number,
+ *   runnerCount?: number,
+ *   workerCount?: number,
  *   browser?: string,
  *   runnerName?: string,
  *   runnerId?: string,
@@ -377,7 +444,8 @@ const saveReport = async ({
 	rawCucumberJson,
 	tags,
 	triggerType,
-	nodeCount,
+	runnerCount = 1,
+	workerCount = 1,
 	browser,
 	runnerName,
 	runnerId,
@@ -388,7 +456,11 @@ const saveReport = async ({
 	attempts = {}
 }) => {
 	const normTrigger = normaliseTrigger(triggerType);
-	const { features, status: derivedStatus } = processCucumberJson(rawCucumberJson, attempts);
+	const {
+		features,
+		recordings,
+		status: derivedStatus
+	} = processCucumberJson(rawCucumberJson, attempts);
 	const status = forceFail ? REPORT_STATUS.FAIL : derivedStatus;
 	const cronJobId = await resolveCronJobId(normTrigger);
 
@@ -397,7 +469,8 @@ const saveReport = async ({
 			status,
 			tags: (tags ?? '').replace(/^\(|\)$/g, '') || '@all-tests',
 			triggerType: normTrigger,
-			runners: nodeCount ?? 1,
+			runnerCount,
+			workerCount,
 			browser: browser ?? DEFAULT_BROWSER,
 			runnerName: runnerName ?? null,
 			runnerId: runnerId ?? null,
@@ -408,17 +481,23 @@ const saveReport = async ({
 			duration
 		}
 	});
+	if (recordings.length > 0) {
+		await prisma.recording.createMany({
+			data: recordings.map((r) => ({ ...r, reportId: report.id }))
+		});
+	}
 	syncAutomatedTags(report.id, features, testRunId ?? null);
 	return report;
 };
 
 /**
- * Merges Cucumber JSON from all distributed lanes, processes screenshots,
- * and persists one combined report to the database.
+ * Merges Cucumber JSON from all distributed lanes and persists one combined
+ * report to the database.
  *
  * @param {{
  *   reports: (string|null)[],
  *   runners: { id: string, name: string, dbId: string|null }[],
+ *   workers?: number,
  *   overallCode: number,
  *   tag: string,
  *   triggerType: string,
@@ -429,6 +508,7 @@ const saveReport = async ({
 const saveCombinedReport = async ({
 	reports,
 	runners,
+	workers = 1,
 	overallCode,
 	tag,
 	triggerType,
@@ -439,15 +519,23 @@ const saveCombinedReport = async ({
 	attemptsByLane = null
 }) => {
 	const featureMap = new Map();
-	for (const content of reports) {
-		if (!content) continue;
+	reports.forEach((content, laneIdx) => {
+		if (!content) return;
 		let parsed;
 		try {
 			parsed = JSON.parse(content);
 		} catch {
-			continue;
+			return;
 		}
+		const lane = runners[laneIdx];
 		for (const feature of parsed) {
+			// Merging loses which lane a scenario came from — the raw Cucumber JSON
+			// has no such field — so stamp it here, before the merge, while we still
+			// know. processCucumberJson reads this to group the report's scenario
+			// list by runner.
+			for (const scenario of feature.elements ?? []) {
+				scenario.__plumRunnerName = lane?.name ?? null;
+			}
 			// Each lane runs from its own temp dir, so the same feature reports a
 			// different absolute uri per runner. Key on the path from `features/`
 			// onward (falling back to name) so one feature's scenarios from every
@@ -459,7 +547,7 @@ const saveCombinedReport = async ({
 				featureMap.set(key, { ...feature, elements: [...(feature.elements ?? [])] });
 			}
 		}
-	}
+	});
 	const combined = [...featureMap.values()];
 
 	let combinedLogs = null;
@@ -478,7 +566,8 @@ const saveCombinedReport = async ({
 		rawCucumberJson: combined,
 		tags: tag,
 		triggerType,
-		nodeCount: runners.length,
+		runnerCount: runners.length,
+		workerCount: workers,
 		browser,
 		runnerName: runners.map((r) => r.name).join(', '),
 		runnerId: null,
@@ -508,17 +597,10 @@ const attachDurationToLatestReport = async ({ afterTimestamp, duration }) => {
 // ---------------------------------------------------------------------------
 
 const deleteReport = async (id) => {
-	const report = await prisma.report.findUnique({ where: { id }, select: { content: true } });
-	if (report) deleteScreenshotFiles(report.content);
 	await prisma.report.delete({ where: { id } });
 };
 
 const deleteReports = async (ids) => {
-	const reports = await prisma.report.findMany({
-		where: { id: { in: ids } },
-		select: { content: true }
-	});
-	for (const r of reports) deleteScreenshotFiles(r.content);
 	await prisma.report.deleteMany({ where: { id: { in: ids } } });
 };
 
@@ -546,6 +628,8 @@ module.exports = {
 	getReports,
 	getLatestReportId,
 	getReportDetail,
+	getRecordings,
+	getRecordingEvents,
 	saveReport,
 	saveCombinedReport,
 	attachDurationToLatestReport,

package/backend/services/runnerService.js

@@ -11,6 +11,8 @@ const { BUILT_IN_RUNNER_ID } = require('../constants/triggers');
 const { DEFAULT_BROWSER } = require('../constants/defaults');
 const { bearerHeader } = require('../lib/authHeader');
 const { JOB_STATUS } = require('../constants/jobStatus');
+const settingsService = require('./settingsService');
+const nodeStreamRegistry = require('./nodeStreamRegistry');
 
 // ---------------------------------------------------------------------------
 // Runner CRUD
@@ -198,7 +200,7 @@ async function dispatchAndPoll(
 	{ tags, browser, workers },
 	onLog,
 	onDone,
-	onScreenshot = null
+	onRRwebBatch = null
 ) {
 	// The async poll callback can overlap if a tick takes longer than the interval;
 	// guard so the run resolves exactly once and can't be finalised while a lane
@@ -207,6 +209,7 @@ async function dispatchAndPoll(
 	const finish = (code, content) => {
 		if (settled) return;
 		settled = true;
+		if (jobId) nodeStreamRegistry.unregisterRelay(jobId);
 		onDone(code, content);
 	};
 
@@ -217,6 +220,12 @@ async function dispatchAndPoll(
 		return;
 	}
 
+	// The node needs to know where to open its own socket back to us — without
+	// this it has no way to reach the primary, since today only the reverse
+	// (primary knowing each node's url) is configured.
+	const { notifyPublicUrl } = await settingsService.getWebhooks();
+	const primaryUrl = notifyPublicUrl ? notifyPublicUrl.replace(/\/$/, '') : null;
+
 	let jobId;
 	try {
 		const res = await fetch(`${runner.url}/api/execute`, {
@@ -230,7 +239,8 @@ async function dispatchAndPoll(
 				browser,
 				workers,
 				tests: collectTestFiles(),
-				env: loadTestEnv(process.cwd())
+				env: loadTestEnv(process.cwd()),
+				...(primaryUrl ? { primaryUrl } : {})
 			}),
 			signal: AbortSignal.timeout(10000)
 		});
@@ -244,6 +254,12 @@ async function dispatchAndPoll(
 
 	onLog(`Connected to runner "${runner.name}" — job ${jobId}\n`);
 
+	// With a primaryUrl configured, the node streams logs/rrweb events over its
+	// own socket instead — draining them from the poll too would duplicate them.
+	if (primaryUrl) {
+		nodeStreamRegistry.registerRelay(jobId, { onRRwebBatch, onLog });
+	}
+
 	let logOffset = 0;
 	let polling = false;
 	const poll = setInterval(async () => {
@@ -257,15 +273,11 @@ async function dispatchAndPoll(
 			if (!res.ok) return;
 			const body = await res.json();
 
-			if (body.logs) {
+			if (!primaryUrl && body.logs) {
 				onLog(body.logs);
 				logOffset += body.logs.length;
 			}
 
-			if (onScreenshot && Array.isArray(body.screenshots)) {
-				for (const ss of body.screenshots) onScreenshot(ss);
-			}
-
 			if (body.status === JOB_STATUS.DONE || body.status === JOB_STATUS.ERROR) {
 				clearInterval(poll);
 				const content = await fetchReportContent(runner, jobId, onLog);

package/backend/services/settingsService.js

@@ -97,7 +97,8 @@ const getBackupConfig = async () => {
 		backupS3SecretKeySet: project.backupS3SecretKey.length > 0,
 		backupS3Prefix: project.backupS3Prefix,
 		backupLastRunAt: project.backupLastRunAt,
-		backupLastStatus: project.backupLastStatus
+		backupLastStatus: project.backupLastStatus,
+		backupIncludeReports: project.backupIncludeReports
 	};
 };
 
@@ -109,7 +110,8 @@ const updateBackupConfig = async ({
 	backupS3Bucket,
 	backupS3AccessKey,
 	backupS3SecretKey,
-	backupS3Prefix
+	backupS3Prefix,
+	backupIncludeReports
 }) => {
 	const update = {
 		...(backupEnabled !== undefined && { backupEnabled }),
@@ -119,7 +121,8 @@ const updateBackupConfig = async ({
 		...(backupS3Bucket !== undefined && { backupS3Bucket }),
 		...(backupS3AccessKey !== undefined && { backupS3AccessKey }),
 		...(backupS3SecretKey && { backupS3SecretKey }),
-		...(backupS3Prefix !== undefined && { backupS3Prefix })
+		...(backupS3Prefix !== undefined && { backupS3Prefix }),
+		...(backupIncludeReports !== undefined && { backupIncludeReports })
 	};
 	return prisma.project.upsert({
 		where: { id: 1 },