plum-e2e 2.8.6 → 2.9.0

package/backend/routes/backup.routes.js

@@ -14,7 +14,8 @@ const { requireAdmin } = require('../middleware/requireAdmin');
 
 router.get('/export', jwtAuth, requireAdmin, async (req, res) => {
 	try {
-		const data = await backupService.exportAll();
+		const { backupIncludeReports } = await settingsService.getBackupConfig();
+		const data = await backupService.exportAll(backupIncludeReports);
 		const fileName = `plum-backup-${new Date().toISOString().slice(0, 10)}.json`;
 		res.setHeader('Content-Disposition', `attachment; filename="${fileName}"`);
 		res.setHeader('Content-Type', 'application/json');
@@ -87,6 +88,51 @@ router.post('/test-s3', jwtAuth, requireAdmin, async (req, res) => {
 	}
 });
 
+router.get('/s3-backups', jwtAuth, requireAdmin, async (req, res) => {
+	try {
+		const config = await settingsService.getProjectRaw();
+		const required = ['backupS3Bucket', 'backupS3AccessKey', 'backupS3SecretKey'];
+		const missing = required.filter((k) => !config[k]);
+		if (missing.length > 0) {
+			return res
+				.status(400)
+				.json({ error: `S3 is not configured (missing: ${missing.join(', ')})` });
+		}
+		const backups = await backupService.listS3Backups(config);
+		res.json({ backups });
+	} catch (error) {
+		console.error('Failed to list S3 backups:', error);
+		res.status(500).json({ error: error.message || 'Failed to list S3 backups' });
+	}
+});
+
+router.post('/s3-restore', jwtAuth, requireAdmin, async (req, res) => {
+	try {
+		const { key } = req.body;
+		if (!key) return res.status(400).json({ error: 'Missing backup key' });
+
+		const config = await settingsService.getProjectRaw();
+		const required = ['backupS3Bucket', 'backupS3AccessKey', 'backupS3SecretKey'];
+		const missing = required.filter((k) => !config[k]);
+		if (missing.length > 0) {
+			return res
+				.status(400)
+				.json({ error: `S3 is not configured (missing: ${missing.join(', ')})` });
+		}
+
+		const data = await backupService.downloadFromS3(key, config);
+		const { cronJobs, project, users, runners, testSuites, testRuns } = data;
+		await backupService.importAll(
+			{ cronJobs, project, users, runners, testSuites, testRuns },
+			cronService
+		);
+		res.json({ message: 'Restore successful' });
+	} catch (error) {
+		console.error('S3 restore failed:', error);
+		res.status(500).json({ error: error.message || 'Restore failed' });
+	}
+});
+
 router.post('/run-now', jwtAuth, requireAdmin, async (req, res) => {
 	try {
 		await backupCronService.runBackup();

package/backend/routes/reports.routes.js

@@ -27,6 +27,29 @@ router.get('/latest', async (req, res) => {
 	}
 });
 
+router.get('/:id/recordings', async (req, res) => {
+	const id = parseInt(req.params.id, 10);
+	if (isNaN(id)) return res.status(400).json({ error: 'Invalid report id' });
+	try {
+		const recordings = await reportService.getRecordings(id);
+		res.json(recordings);
+	} catch {
+		res.status(500).json({ error: 'Failed to fetch recordings' });
+	}
+});
+
+router.get('/:id/recordings/:recordingId/events', async (req, res) => {
+	const recordingId = parseInt(req.params.recordingId, 10);
+	if (isNaN(recordingId)) return res.status(400).json({ error: 'Invalid recording id' });
+	try {
+		const events = await reportService.getRecordingEvents(recordingId);
+		if (!events) return res.status(404).json({ error: 'Recording not found' });
+		res.json({ events });
+	} catch {
+		res.status(500).json({ error: 'Failed to fetch recording events' });
+	}
+});
+
 router.get('/:id', async (req, res) => {
 	const id = parseInt(req.params.id, 10);
 	if (isNaN(id)) return res.status(400).json({ error: 'Invalid report id' });

package/backend/server.js

@@ -30,7 +30,7 @@ const port = parseInt(process.env.PORT || DEFAULT_PORT, 10);
 // The underlying HTTP server, shared by Express and Socket.io.
 const server = http.createServer(app);
 
-// Real-time transport for live test output, screenshots, and run status.
+// Real-time transport for live test output, the rrweb stream, and run status.
 const io = new Server(server, { cors: { origin: '*' } });
 
 async function start() {

package/backend/services/backupCronService.js

@@ -21,7 +21,7 @@ const runBackup = async () => {
 	if (!project?.backupEnabled) return;
 
 	try {
-		const data = await backupService.exportAll();
+		const data = await backupService.exportAll(project.backupIncludeReports);
 		const key = await backupService.uploadToS3(data, project);
 
 		await prisma.project.update({

package/backend/services/backupService.js

@@ -8,11 +8,33 @@ const { BUILT_IN_RUNNER_ID } = require('../constants/triggers');
 const { DEFAULT_BROWSER } = require('../constants/defaults');
 
 // ---------------------------------------------------------------------------
-// Export — all data except reports (reports are too large; use pg_dump instead)
+// Export
 // ---------------------------------------------------------------------------
 
-const exportAll = async () => {
-	const [cronJobs, project, testSuites, testRuns, users, runners] = await Promise.all([
+// Reports (with their rrweb recordings) are opt-in — they can be large, and
+// this used to be a hard no ("reports are too large, use pg_dump") back when
+// screenshots lived as external files on disk. Now everything lives in
+// Postgres, so it's just a size tradeoff the admin can choose. Recording.events
+// is gzip-compressed BYTEA — base64 it for JSON transport; startedAt/endedAt
+// are BigInt, which JSON.stringify can't serialize natively.
+async function exportReports() {
+	const reports = await prisma.report.findMany({
+		orderBy: { createdAt: 'asc' },
+		include: { recordings: true }
+	});
+	return reports.map(({ recordings, ...report }) => ({
+		...report,
+		recordings: recordings.map(({ events, startedAt, endedAt, ...rec }) => ({
+			...rec,
+			events: events.toString('base64'),
+			startedAt: startedAt?.toString() ?? null,
+			endedAt: endedAt?.toString() ?? null
+		}))
+	}));
+}
+
+const exportAll = async (includeReports = false) => {
+	const [cronJobs, project, testSuites, testRuns, users, runners, reports] = await Promise.all([
 		prisma.cronJob.findMany({ orderBy: { createdAt: 'asc' } }),
 		prisma.project.findUnique({ where: { id: 1 } }),
 		prisma.testSuite.findMany({
@@ -29,14 +51,16 @@ const exportAll = async () => {
 			include: { entries: { orderBy: { order: 'asc' } } }
 		}),
 		prisma.user.findMany({ orderBy: { createdAt: 'asc' } }),
-		prisma.runner.findMany({ orderBy: { createdAt: 'asc' } })
+		prisma.runner.findMany({ orderBy: { createdAt: 'asc' } }),
+		includeReports ? exportReports() : Promise.resolve(null)
 	]);
 
 	return {
-		version: '2',
+		version: '3',
 		exportedAt: new Date().toISOString(),
-		disclaimer:
-			'Reports are not included in this backup. Use pg_dump on the PostgreSQL volume to back up report history.',
+		disclaimer: includeReports
+			? 'Reports and recordings are included in this backup.'
+			: 'Reports are not included in this backup. Enable "Include reports" in Settings → Backup, or use pg_dump on the PostgreSQL volume, to back up report history.',
 		cronJobs: cronJobs.map(({ id, createdAt, updatedAt, reports: _, runnerId: __, ...r }) => r),
 		project: project
 			? {
@@ -62,7 +86,8 @@ const exportAll = async () => {
 		testRuns: testRuns.map(({ entries, history: _, ...run }) => ({
 			...run,
 			entries: entries.map(({ executedAt, ...entry }) => ({ ...entry, executedAt }))
-		}))
+		})),
+		...(reports !== null && { reports })
 	};
 };
 
@@ -71,7 +96,15 @@ const exportAll = async () => {
 // ---------------------------------------------------------------------------
 
 const importAll = async (
-	{ cronJobs = [], project = null, users = [], runners = [], testSuites = [], testRuns = [] },
+	{
+		cronJobs = [],
+		project = null,
+		users = [],
+		runners = [],
+		testSuites = [],
+		testRuns = [],
+		reports = []
+	},
 	cronService
 ) => {
 	await prisma.$transaction(
@@ -186,8 +219,41 @@ const importAll = async (
 					});
 				}
 			}
+
+			// 7. Reports + recordings (opt-in — only present if this backup
+			// included them). Recordings are always deleted and recreated
+			// rather than upserted — same pattern as test steps above.
+			for (const report of reports) {
+				const { recordings = [], cronJobId: _staleCronJobId, ...reportData } = report;
+
+				// cronJobId can't be trusted as exported — cron jobs above are
+				// upserted keyed on taskName, not id, so the id a report recorded
+				// at export time may no longer point at the right row (or any
+				// row). Re-resolve it the same way reportService does when a
+				// report is first created: a scheduled report's triggerType is
+				// always its cron job's taskName.
+				const cronJob = reportData.triggerType
+					? await tx.cronJob.findUnique({ where: { taskName: reportData.triggerType } })
+					: null;
+
+				const data = { ...reportData, cronJobId: cronJob?.id ?? null };
+				await tx.report.upsert({ where: { id: data.id }, create: data, update: data });
+
+				await tx.recording.deleteMany({ where: { reportId: data.id } });
+				for (const rec of recordings) {
+					await tx.recording.create({
+						data: {
+							...rec,
+							reportId: data.id,
+							events: Buffer.from(rec.events, 'base64'),
+							startedAt: rec.startedAt !== null ? BigInt(rec.startedAt) : null,
+							endedAt: rec.endedAt !== null ? BigInt(rec.endedAt) : null
+						}
+					});
+				}
+			}
 		},
-		{ timeout: 30000 }
+		{ timeout: 60000 }
 	);
 
 	if (cronService) await cronService.reload();
@@ -197,18 +263,16 @@ const importAll = async (
 // S3 upload — S3-compatible object storage (AWS, R2, B2, MinIO)
 // ---------------------------------------------------------------------------
 
-const uploadToS3 = async (jsonData, config) => {
-	const { S3Client, PutObjectCommand } = await import('@aws-sdk/client-s3');
-
-	const {
-		backupS3Endpoint,
-		backupS3Region,
-		backupS3Bucket,
-		backupS3AccessKey,
-		backupS3SecretKey,
-		backupS3Prefix
-	} = config;
-
+// A custom endpoint means R2/B2/MinIO/on-prem, not real AWS S3 — those
+// virtually always need path-style addressing (bucket.endpoint/... resolves
+// nowhere for a self-hosted host like a docker service name). Real AWS S3
+// (no custom endpoint) keeps the SDK's virtual-hosted-style default.
+function buildS3ClientConfig({
+	backupS3Endpoint,
+	backupS3Region,
+	backupS3AccessKey,
+	backupS3SecretKey
+}) {
 	const clientConfig = {
 		region: backupS3Region || 'auto',
 		credentials: {
@@ -216,9 +280,17 @@ const uploadToS3 = async (jsonData, config) => {
 			secretAccessKey: backupS3SecretKey
 		}
 	};
-	if (backupS3Endpoint) clientConfig.endpoint = backupS3Endpoint;
+	if (backupS3Endpoint) {
+		clientConfig.endpoint = backupS3Endpoint;
+		clientConfig.forcePathStyle = true;
+	}
+	return clientConfig;
+}
 
-	const client = new S3Client(clientConfig);
+const uploadToS3 = async (jsonData, config) => {
+	const { S3Client, PutObjectCommand } = await import('@aws-sdk/client-s3');
+	const { backupS3Bucket, backupS3Prefix } = config;
+	const client = new S3Client(buildS3ClientConfig(config));
 
 	const date = new Date().toISOString().slice(0, 10);
 	const prefix = backupS3Prefix ? backupS3Prefix.replace(/\/?$/, '/') : '';
@@ -236,28 +308,39 @@ const uploadToS3 = async (jsonData, config) => {
 	return key;
 };
 
-const testS3Connection = async (config) => {
-	const { S3Client, PutObjectCommand, DeleteObjectCommand } = await import('@aws-sdk/client-s3');
+// Lists backups previously uploaded by uploadToS3, newest first — the data
+// needed for a "restore from S3" flow that doesn't require the admin to pull
+// the file down through the S3 console/CLI themselves first.
+const listS3Backups = async (config) => {
+	const { S3Client, ListObjectsV2Command } = await import('@aws-sdk/client-s3');
+	const { backupS3Bucket, backupS3Prefix } = config;
+	const client = new S3Client(buildS3ClientConfig(config));
+	const prefix = backupS3Prefix ? backupS3Prefix.replace(/\/?$/, '/') : '';
 
-	const {
-		backupS3Endpoint,
-		backupS3Region,
-		backupS3Bucket,
-		backupS3AccessKey,
-		backupS3SecretKey,
-		backupS3Prefix
-	} = config;
+	const res = await client.send(
+		new ListObjectsV2Command({ Bucket: backupS3Bucket, Prefix: prefix })
+	);
 
-	const clientConfig = {
-		region: backupS3Region || 'auto',
-		credentials: {
-			accessKeyId: backupS3AccessKey,
-			secretAccessKey: backupS3SecretKey
-		}
-	};
-	if (backupS3Endpoint) clientConfig.endpoint = backupS3Endpoint;
+	return (res.Contents ?? [])
+		.filter((o) => o.Key.endsWith('.json'))
+		.map((o) => ({ key: o.Key, size: o.Size, lastModified: o.LastModified }))
+		.sort((a, b) => new Date(b.lastModified) - new Date(a.lastModified));
+};
+
+// Fetches and parses one backup previously uploaded by uploadToS3.
+const downloadFromS3 = async (key, config) => {
+	const { S3Client, GetObjectCommand } = await import('@aws-sdk/client-s3');
+	const { backupS3Bucket } = config;
+	const client = new S3Client(buildS3ClientConfig(config));
+	const res = await client.send(new GetObjectCommand({ Bucket: backupS3Bucket, Key: key }));
+	const text = await res.Body.transformToString('utf8');
+	return JSON.parse(text);
+};
 
-	const client = new S3Client(clientConfig);
+const testS3Connection = async (config) => {
+	const { S3Client, PutObjectCommand, DeleteObjectCommand } = await import('@aws-sdk/client-s3');
+	const { backupS3Bucket, backupS3Prefix } = config;
+	const client = new S3Client(buildS3ClientConfig(config));
 	const prefix = backupS3Prefix ? backupS3Prefix.replace(/\/?$/, '/') : '';
 	const key = `${prefix}.plum-connection-test`;
 
@@ -276,4 +359,11 @@ const testS3Connection = async (config) => {
 	} catch {}
 };
 
-module.exports = { exportAll, importAll, uploadToS3, testS3Connection };
+module.exports = {
+	exportAll,
+	importAll,
+	uploadToS3,
+	listS3Backups,
+	downloadFromS3,
+	testS3Connection
+};

package/backend/services/cronService.js

@@ -14,7 +14,7 @@ const reportService = require('./reportService');
 const settingsService = require('./settingsService');
 const notificationService = require('./notificationService');
 const activeRunsService = require('./activeRunsService');
-const { startSsPoller } = require('../lib/screenshotPoller');
+const { startRRwebPoller } = require('../lib/rrwebPoller');
 const { BUILT_IN_RUNNER_ID, TRIGGER_REMOTE, TRIGGER_TYPE } = require('../constants/triggers');
 const { DEFAULT_BROWSER } = require('../constants/defaults');
 const { PLUM_MODE_NODE } = require('../constants/env');
@@ -82,8 +82,14 @@ function runSingleBuiltInAttempt({ taskName, currentTag, workers, browser, suppr
 
 		const task = spawn('npm', ['run', 'test'], { env, shell: true });
 
-		const ssPoller = startSsPoller(ssDir, ({ stepName, data }) => {
-			if (_io) _io.emit(SOCKET_EVENTS.BG_RUN_SCREENSHOT, { runId: taskName, stepName, data });
+		const ssPoller = startRRwebPoller(ssDir, (batch) => {
+			if (_io) {
+				_io.emit(SOCKET_EVENTS.BG_RUN_LANE_RRWEB_BATCH, {
+					runId: taskName,
+					id: BUILT_IN_RUNNER_ID,
+					...batch
+				});
+			}
 		});
 
 		task.stdout.on('data', (d) => {
@@ -191,6 +197,7 @@ async function runSingleBuiltIn({ taskName, tags, workers, browser, notifyDiscor
 			rawCucumberJson: rawJson,
 			tags,
 			triggerType: taskName,
+			workerCount: workers,
 			browser,
 			duration: Date.now() - startedAt,
 			attempts
@@ -282,6 +289,7 @@ async function runDistributed({
 				.saveCombinedReport({
 					reports: collectedReports,
 					runners: laneInfos,
+					workers,
 					overallCode,
 					tag: tags,
 					triggerType: taskName,
@@ -352,14 +360,14 @@ async function runDistributed({
 
 					const task = spawn('npm', ['run', 'test'], { env, shell: true });
 
-					const ssPoller = startSsPoller(ssDir, ({ stepName, data }) => {
-						if (_io)
-							_io.emit(SOCKET_EVENTS.BG_RUN_LANE_SCREENSHOT, {
+					const ssPoller = startRRwebPoller(ssDir, (batch) => {
+						if (_io) {
+							_io.emit(SOCKET_EVENTS.BG_RUN_LANE_RRWEB_BATCH, {
 								runId: taskName,
-								laneId,
-								stepName,
-								data
+								id: laneId,
+								...batch
 							});
+						}
 					});
 
 					task.stdout.on('data', (d) => {
@@ -399,14 +407,14 @@ async function runDistributed({
 						{ tags: currentTag, browser, workers },
 						onLog,
 						(code, content) => resolve({ code, rawJson: content ? JSON.parse(content) : [] }),
-						({ stepName, data }) => {
-							if (_io)
-								_io.emit(SOCKET_EVENTS.BG_RUN_LANE_SCREENSHOT, {
+						(batch) => {
+							if (_io) {
+								_io.emit(SOCKET_EVENTS.BG_RUN_LANE_RRWEB_BATCH, {
 									runId: taskName,
-									laneId,
-									stepName,
-									data
+									id: laneId,
+									...batch
 								});
+							}
 						}
 					);
 				});

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 };