plum-e2e 2.6.8 → 2.7.1

package/backend/routes/trigger.routes.js

@@ -1,189 +1,47 @@
 /*
  * 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/.
+ * Licensed under the MIT License. See LICENSE file in the project root for details.
  */
 
-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 settingsService = require('../services/settingsService');
-const reportService = require('../services/reportService');
-const { readCucumberReportFile } = require('../lib/reportFilename');
-const { runWithRetries } = require('../lib/retryRunner');
-
-const BACKEND_DIR = path.resolve(__dirname, '..');
-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) {
-		if (job.startedAt < cutoff) jobs.delete(id);
-	}
-}
+const { DEFAULT_BROWSER } = require('../constants/defaults');
+const { JOB_STATUS } = require('../constants/jobStatus');
+const triggerService = require('../services/triggerService');
 
 router.post('/', jwtAuth, async (req, res, next) => {
 	try {
-		pruneOldJobs();
-
-		const { tag = '', browser = 'chromium', workers = 1, baseUrl, testRunId, source } = req.body;
+		const {
+			tag = '',
+			browser = DEFAULT_BROWSER,
+			workers = 1,
+			baseUrl,
+			testRunId,
+			source
+		} = req.body;
 		const trigger = source === 'mcp' ? TRIGGER_TYPE.MCP : TRIGGER_TYPE.EXTERNAL;
-		const { maxRetries } = await settingsService.getProject();
-
-		const jobId = randomUUID();
-		const startedAt = Date.now();
-		jobs.set(jobId, { status: 'running', exitCode: null, reportId: null, startedAt });
-
-		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 onLog = (text) => {
-			if (_io) _io.emit('bg-run-log', { runId: jobId, log: text });
-		};
-
-		function runAttempt(currentTag, suppressSave) {
-			return new Promise((resolve) => {
-				const ssDir = path.join(os.tmpdir(), `plum-trigger-ss-${jobId}-${Date.now()}`);
-				fs.mkdirSync(ssDir, { recursive: true });
-
-				const env = {
-					...process.env,
-					TAG: currentTag,
-					TRIGGER: trigger,
-					BROWSER: browser,
-					REPORT_RUNNERS: String(workers),
-					PLUM_SS_DIR: ssDir
-				};
-				if (Number(workers) > 1) env.PARALLEL = String(workers);
-				if (testRunId) env.TEST_RUN_ID = testRunId;
-				if (baseUrl) env.BASE_URL = baseUrl;
-				if (suppressSave) env.PLUM_MODE = 'node';
-
-				const proc = spawn('npm', ['run', 'test'], { env, shell: true, cwd: BACKEND_DIR });
-
-				const ssPoller = startSsPoller(ssDir, ({ stepName, data }) => {
-					if (_io) _io.emit('bg-run-screenshot', { runId: jobId, stepName, data });
-				});
-
-				proc.stdout.on('data', (d) => onLog(d.toString()));
-				proc.stderr.on('data', (d) => onLog(`[ERROR] ${d.toString()}`));
-
-				proc.on('close', (code) => {
-					clearInterval(ssPoller);
-					fs.rm(ssDir, { recursive: true, force: true }, () => {});
-					resolve({ code, raw: suppressSave ? readCucumberReportFile() : null });
-				});
-			});
-		}
-
-		if (maxRetries === 0) {
-			runAttempt(tag, false).then(async ({ code }) => {
-				let reportId = null;
-				try {
-					// Find the latest report created after this job started
-					const report = await prisma.report.findFirst({
-						where: { createdAt: { gte: new Date(startedAt) } },
-						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,
-						startedAt
-					});
-				} catch {
-					jobs.set(jobId, { status: 'done', exitCode: code, reportId: null, startedAt });
-				}
-
-				if (_io) _io.emit('bg-run-done', { runId: jobId, code, reportId });
-			});
-		} else {
-			runWithRetries({
-				maxRetries,
-				spawnAttempt: async (tagOverride) => {
-					const { code, raw } = await runAttempt(tagOverride ?? tag, true);
-					return { code, rawJson: raw ? JSON.parse(raw) : [] };
-				},
-				onLog
-			}).then(async ({ code, rawJson, attempts }) => {
-				let reportId = null;
-				try {
-					const report = await reportService.saveReport({
-						rawCucumberJson: rawJson,
-						tags: tag,
-						triggerType: trigger,
-						browser,
-						testRunId: testRunId ?? null,
-						duration: Date.now() - startedAt,
-						attempts
-					});
-					reportId = report.id;
-					jobs.set(jobId, {
-						status: code === 130 ? 'cancelled' : 'done',
-						exitCode: code,
-						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' });
+		const jobId = await triggerService.startRun({
+			tag,
+			browser,
+			workers,
+			baseUrl,
+			testRunId,
+			trigger
+		});
+		res.status(202).json({ jobId, status: JOB_STATUS.RUNNING });
 	} catch (e) {
 		next(e);
 	}
 });
 
 router.get('/:jobId', jwtAuth, (req, res) => {
-	const job = jobs.get(req.params.jobId);
+	const job = triggerService.getJob(req.params.jobId);
 	if (!job) return res.status(404).json({ error: 'Job not found' });
 	res.json(job);
 });
 
 module.exports = router;
-router.setSocketIO = setSocketIO;
+router.setSocketIO = triggerService.setSocketIO;

package/backend/routes/users.routes.js

@@ -1,18 +1,6 @@
 /*
  * 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/.
+ * Licensed under the MIT License. See LICENSE file in the project root for details.
  */
 
 const express = require('express');

package/backend/scripts/manage-runners.mjs

@@ -1,18 +1,6 @@
 /*
  * 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/.
+ * Licensed under the MIT License. See LICENSE file in the project root for details.
  */
 
 /**

package/backend/server.js

@@ -1,173 +1,56 @@
 /*
  * 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/.
+ * Licensed under the MIT License. See LICENSE file in the project root for details.
  */
 
 const http = require('http');
+const path = require('path');
 const { Server } = require('socket.io');
 const app = require('./app');
-const server = http.createServer(app);
-const io = new Server(server, { cors: { origin: '*' } });
-const path = require('path');
-const fs = require('fs');
-
-// Always point to the mounted tests directory
+const { PLUM_MODE_NODE, DEFAULT_PORT } = require('./constants/env');
+const {
+	ensureTestsDir,
+	attachListenRetry,
+	wireRealtimeServices,
+	initCronServices,
+	bootstrapMcpKey,
+	onServerListening
+} = require('./lib/serverBootstrap');
+
+// Runner nodes receive their test files from dispatched jobs; the main
+// server expects them to already be mounted on disk.
 const testsDir = path.resolve(process.cwd(), 'tests');
 
-if (!fs.existsSync(testsDir)) {
-	if (process.env.PLUM_MODE === 'node') {
-		console.warn('⚠️  No tests folder found — will be populated when a job is received');
-	} else {
-		console.error('❌ No tests folder found at /app/tests');
-		process.exit(1);
-	}
-} else {
-	console.log('📂 Loading tests from:', testsDir);
-}
+// Node/runner mode strips out everything that only makes sense on the main
+// server (cron, MCP, socket.io, file watching).
+const isNodeMode = process.env.PLUM_MODE === PLUM_MODE_NODE;
 
-const isNodeMode = process.env.PLUM_MODE === 'node';
-const port = parseInt(process.env.PORT || '3001', 10);
+const port = parseInt(process.env.PORT || DEFAULT_PORT, 10);
 
-// A self-restart (POST /api/restart) spawns the replacement before this
-// process has released the port, so the first bind attempt can briefly hit
-// EADDRINUSE — retry instead of dying immediately.
-let listenRetriesLeft = 20;
-server.on('error', (err) => {
-	if (err.code === 'EADDRINUSE' && listenRetriesLeft > 0) {
-		listenRetriesLeft -= 1;
-		setTimeout(() => server.listen(port), 250);
-	} else {
-		console.error(`❌ Failed to bind port ${port}:`, err.message);
-		process.exit(1);
-	}
-});
+// The underlying HTTP server, shared by Express and Socket.io.
+const server = http.createServer(app);
 
-let cronService = null;
-let backupCronService = null;
-if (!isNodeMode) {
-	const socketHandler = require('./websockets/socketHandler.js');
-	cronService = require('./services/cronService');
-	backupCronService = require('./services/backupCronService');
-	socketHandler(io);
-	cronService.setSocketIO(io);
-	require('./routes/trigger.routes').setSocketIO(io);
-}
+// Real-time transport for live test output, screenshots, and run status.
+const io = new Server(server, { cors: { origin: '*' } });
 
 async function start() {
-	if (cronService) await cronService.init();
-	if (backupCronService) await backupCronService.init();
-
-	if (!isNodeMode && !process.env.PLUM_MCP_KEY) {
-		try {
-			const settingsService = require('./services/settingsService');
-			const { mcpKey } = await settingsService.getMcpConfig();
-			if (mcpKey) process.env.PLUM_MCP_KEY = mcpKey;
-		} catch {}
-	}
-
-	server.listen(port, async () => {
-		console.log(`Backend running on port ${port}${isNodeMode ? ' (node/runner mode)' : ''}`);
-		if (isNodeMode) {
-			// Self-register PID so manage-runners can track and stop this process.
-			const runnerId = process.env.RUNNER_ID;
-			if (runnerId) {
-				const { loadRegistry, saveRegistry } = require('./lib/runnerProcess');
-				const registry = loadRegistry();
-				registry[runnerId] = { pid: process.pid, port: String(port), startedAt: Date.now() };
-				saveRegistry(registry);
-
-				const cleanup = () => {
-					try {
-						const reg = loadRegistry();
-						// A self-restart already wrote the replacement's pid under this
-						// id before this process exits — only touch the entry if it's
-						// still ours, so we don't clobber the new process's registration.
-						// Keep the entry (with its port) rather than deleting it — that's
-						// the only place a later manual Start can find the port this
-						// runner was last running on.
-						if (reg[runnerId]?.pid === process.pid) {
-							reg[runnerId] = { ...reg[runnerId], pid: null };
-							saveRegistry(reg);
-						}
-					} catch {}
-				};
-				// Adding a SIGTERM/SIGINT listener suppresses Node's default
-				// "terminate immediately" behavior — the handler must exit itself,
-				// or the process (and the port it's bound to) lives on forever
-				// after a plain `kill`/SIGTERM with nothing left to stop it short
-				// of SIGKILL.
-				process.once('SIGTERM', () => {
-					cleanup();
-					process.exit(0);
-				});
-				process.once('SIGINT', () => {
-					cleanup();
-					process.exit(0);
-				});
-				process.once('exit', cleanup);
-			}
-			return;
-		}
+	// Confirm the tests directory is in place before doing anything else.
+	ensureTestsDir(testsDir, isNodeMode);
 
-		// Sync automated flags from feature files on every startup
-		require('./services/reportService')
-			.syncAutomatedFromFeatures()
-			.catch(() => {});
+	// Survive the brief EADDRINUSE window a self-restart can hit.
+	attachListenRetry(server, port);
 
-		// chokidar v5+ is ESM-only — use dynamic import to stay compatible with CJS
-		let chokidar;
-		try {
-			chokidar = (await import('chokidar')).default;
-		} catch {
-			console.warn('⚠️  chokidar unavailable — file watching disabled');
-			return;
-		}
+	// Connect socket.io to the runner/cron services (a no-op in node mode).
+	const { cronService, backupCronService } = wireRealtimeServices(io, isNodeMode);
 
-		const watchOpts = { usePolling: true, interval: 800, ignoreInitial: true };
+	// Start the scheduled test and backup cron jobs.
+	await initCronServices(cronService, backupCronService);
 
-		// Watch tests/features/ — notify UI when feature files are added/changed/removed
-		const featuresDir = path.join(testsDir, 'features');
-		if (fs.existsSync(featuresDir)) {
-			let debounce = null;
-			chokidar.watch(featuresDir, watchOpts).on('all', (event, filePath) => {
-				clearTimeout(debounce);
-				debounce = setTimeout(() => {
-					console.log(
-						`📝 Tests changed (${event}: ${path.basename(filePath)}) — notifying clients`
-					);
-					io.emit('tests-changed');
-					require('./services/reportService')
-						.syncAutomatedFromFeatures()
-						.catch(() => {});
-				}, 300);
-			});
-			console.log('👀 Watching for test file changes...');
-		}
+	// Load the saved MCP API key into the environment for the MCP server.
+	await bootstrapMcpKey(isNodeMode);
 
-		// Watch reports/ — notify UI when a new report file lands
-		const reportsDir = path.resolve(process.cwd(), 'reports');
-		fs.mkdirSync(reportsDir, { recursive: true });
-		chokidar.watch(reportsDir, { ...watchOpts, interval: 1200 }).on('add', (filePath) => {
-			const name = path.basename(filePath);
-			if ((name.startsWith('PASS_') || name.startsWith('FAIL_')) && name.endsWith('.json')) {
-				console.log(`📊 New report: ${name} — notifying clients`);
-				io.emit('report-ready');
-			}
-		});
-		console.log('👀 Watching for new reports...');
-	});
+	// Begin accepting connections, then run mode-specific startup work.
+	server.listen(port, () => onServerListening({ port, io, testsDir, isNodeMode }));
 }
 
 start().catch((err) => {

package/backend/services/activeRunsService.js

@@ -0,0 +1,55 @@
+/*
+ * This file is part of Plum.
+ * Licensed under the MIT License. See LICENSE file in the project root for details.
+ */
+
+// In-memory registry of every run currently in progress (manual, cron, REST/MCP-triggered),
+// so a client connecting or reconnecting after a run already started — e.g. after a page
+// refresh — can hydrate its "currently running" UI instead of only relying on the live
+// socket events emitted at the moment a run began.
+const activeRuns = new Map();
+
+// Same staleness problem trigger.routes.js already solves for its own `jobs` Map
+// (see JOB_TTL_MS/pruneOldJobs there) — a run whose completion callback never runs
+// (an unhandled rejection, a crash mid-chain) must not stay "running" forever.
+const RUN_TTL_MS = 60 * 60 * 1000; // 1 hour
+
+function pruneStaleRuns() {
+	const cutoff = Date.now() - RUN_TTL_MS;
+	for (const [runId, run] of activeRuns) {
+		if (run.startedAt < cutoff) activeRuns.delete(runId);
+	}
+}
+
+// Cron re-triggers (e.g. "Run now" while the schedule is already mid-run) register the
+// same taskName twice concurrently — refCount keeps the entry alive until every
+// concurrent registration for that id has unregistered, instead of the second run's
+// completion prematurely erasing the still-running first one (or vice versa).
+function registerRun(runId, info) {
+	pruneStaleRuns();
+	const existing = activeRuns.get(runId);
+	activeRuns.set(runId, {
+		...info,
+		startedAt: existing?.startedAt ?? Date.now(),
+		refCount: (existing?.refCount ?? 0) + 1
+	});
+}
+
+/** Returns true once the id has no other concurrent registration left (i.e. it's actually gone). */
+function unregisterRun(runId) {
+	const existing = activeRuns.get(runId);
+	if (!existing) return false;
+	if (existing.refCount > 1) {
+		activeRuns.set(runId, { ...existing, refCount: existing.refCount - 1 });
+		return false;
+	}
+	activeRuns.delete(runId);
+	return true;
+}
+
+function listActiveRuns() {
+	pruneStaleRuns();
+	return Array.from(activeRuns, ([runId, run]) => ({ runId, ...run }));
+}
+
+module.exports = { registerRun, unregisterRun, listActiveRuns };

package/backend/services/backupCronService.js

@@ -1,18 +1,6 @@
 /*
  * 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/.
+ * Licensed under the MIT License. See LICENSE file in the project root for details.
  */
 
 const cron = require('node-cron');

package/backend/services/backupService.js

@@ -1,21 +1,11 @@
 /*
  * 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/.
+ * Licensed under the MIT License. See LICENSE file in the project root for details.
  */
 
 const prisma = require('./prisma');
+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)
@@ -118,9 +108,9 @@ const importAll = async (
 						cronExpression: job.cronExpression,
 						tags: job.tags,
 						workers: job.workers ?? 1,
-						browser: job.browser ?? 'chromium',
+						browser: job.browser ?? DEFAULT_BROWSER,
 						enabled: job.enabled ?? true,
-						runnerIds: job.runnerIds ?? 'built-in',
+						runnerIds: job.runnerIds ?? BUILT_IN_RUNNER_ID,
 						notifyDiscord: job.notifyDiscord ?? false,
 						notifySlack: job.notifySlack ?? false
 					},
@@ -128,8 +118,8 @@ const importAll = async (
 						cronExpression: job.cronExpression,
 						tags: job.tags,
 						workers: job.workers ?? 1,
-						browser: job.browser ?? 'chromium',
-						runnerIds: job.runnerIds ?? 'built-in',
+						browser: job.browser ?? DEFAULT_BROWSER,
+						runnerIds: job.runnerIds ?? BUILT_IN_RUNNER_ID,
 						notifyDiscord: job.notifyDiscord ?? false,
 						notifySlack: job.notifySlack ?? false
 					}