plum-e2e 2.6.9 → 2.8.0

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.
  */
 
 /**
@@ -49,6 +37,14 @@ const API_URL = process.env.PLUM_API_URL || 'http://localhost:3001';
 
 const cancelled = (v) => clack.isCancel(v);
 
+// The /runners routes require an authenticated admin session, which this
+// headless CLI has no browser/JWT to provide — PLUM_NODE_KEY is the shared
+// secret that stands in for one (see backend/middleware/jwtAuth.js).
+function authHeaders() {
+	const nodeKey = process.env.PLUM_NODE_KEY;
+	return nodeKey ? { Authorization: `ApiKey ${nodeKey}` } : {};
+}
+
 /**
  * When the primary runs in Docker it cannot reach `localhost` on the host —
  * only substitute when the user explicitly enters localhost/127.0.0.1.
@@ -65,7 +61,7 @@ function resolveNodeUrl(url) {
 }
 
 async function fetchRunners() {
-	const res = await fetch(`${API_URL}/runners`);
+	const res = await fetch(`${API_URL}/runners`, { headers: authHeaders() });
 	if (!res.ok) throw new Error(`HTTP ${res.status}`);
 	const body = await res.json();
 	return body.runners ?? [];
@@ -73,7 +69,10 @@ async function fetchRunners() {
 
 async function pingRunner(id) {
 	try {
-		const res = await fetch(`${API_URL}/runners/${id}/ping`, { method: 'POST' });
+		const res = await fetch(`${API_URL}/runners/${id}/ping`, {
+			method: 'POST',
+			headers: authHeaders()
+		});
 		const body = await res.json().catch(() => ({}));
 		return body.ok === true;
 	} catch {
@@ -82,7 +81,7 @@ async function pingRunner(id) {
 }
 
 async function deleteRunner(id) {
-	const res = await fetch(`${API_URL}/runners/${id}`, { method: 'DELETE' });
+	const res = await fetch(`${API_URL}/runners/${id}`, { method: 'DELETE', headers: authHeaders() });
 	if (!res.ok) {
 		const body = await res.json().catch(() => ({}));
 		throw new Error(body.error || `HTTP ${res.status}`);
@@ -95,7 +94,10 @@ async function deleteRunner(id) {
  * reachable runner, not just ones whose process this manager owns by PID.
  */
 async function controlRunner(id, action) {
-	const res = await fetch(`${API_URL}/runners/${id}/${action}`, { method: 'POST' });
+	const res = await fetch(`${API_URL}/runners/${id}/${action}`, {
+		method: 'POST',
+		headers: authHeaders()
+	});
 	const body = await res.json().catch(() => ({}));
 	if (!res.ok || body.ok === false) throw new Error(body.error || `HTTP ${res.status}`);
 }

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
 					}

package/backend/services/cronService.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');
@@ -25,8 +13,13 @@ const runnerService = require('./runnerService');
 const reportService = require('./reportService');
 const settingsService = require('./settingsService');
 const notificationService = require('./notificationService');
+const activeRunsService = require('./activeRunsService');
 const { startSsPoller } = require('../lib/screenshotPoller');
-const { BUILT_IN_RUNNER_ID, TRIGGER_REMOTE } = require('../constants/triggers');
+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');
+const { SOCKET_EVENTS } = require('../constants/socketEvents');
+const { JOB_STATUS } = require('../constants/jobStatus');
 const { getTestIdsForTag, chunkTests, buildTagExpression } = require('../lib/testChunker');
 const { readCucumberReportFile } = require('../lib/reportFilename');
 const { runWithRetries } = require('../lib/retryRunner');
@@ -85,12 +78,12 @@ function runSingleBuiltInAttempt({ taskName, currentTag, workers, browser, suppr
 			PLUM_SS_DIR: ssDir
 		};
 		if (workers > 1) env.PARALLEL = String(workers);
-		if (suppressSave) env.PLUM_MODE = 'node';
+		if (suppressSave) env.PLUM_MODE = PLUM_MODE_NODE;
 
 		const task = spawn('npm', ['run', 'test'], { env, shell: true });
 
 		const ssPoller = startSsPoller(ssDir, ({ stepName, data }) => {
-			if (_io) _io.emit('bg-run-screenshot', { runId: taskName, stepName, data });
+			if (_io) _io.emit(SOCKET_EVENTS.BG_RUN_SCREENSHOT, { runId: taskName, stepName, data });
 		});
 
 		task.stdout.on('data', (d) => {
@@ -118,7 +111,7 @@ async function runSingleBuiltIn({ taskName, tags, workers, browser, notifyDiscor
 	const { maxRetries } = await settingsService.getProject();
 
 	const onLog = (text) => {
-		if (_io) _io.emit('bg-run-log', { runId: taskName, log: text });
+		if (_io) _io.emit(SOCKET_EVENTS.BG_RUN_LOG, { runId: taskName, log: text });
 	};
 
 	if (maxRetries === 0) {
@@ -139,7 +132,13 @@ async function runSingleBuiltIn({ taskName, tags, workers, browser, notifyDiscor
 				select: { id: true, status: true, content: true }
 			})
 			.then((report) => {
-				if (_io) _io.emit('bg-run-done', { runId: taskName, code, reportId: report?.id ?? null });
+				activeRunsService.unregisterRun(taskName);
+				if (_io)
+					_io.emit(SOCKET_EVENTS.BG_RUN_DONE, {
+						runId: taskName,
+						code,
+						reportId: report?.id ?? null
+					});
 
 				if (report) {
 					prisma.report
@@ -162,7 +161,8 @@ async function runSingleBuiltIn({ taskName, tags, workers, browser, notifyDiscor
 			})
 			.catch((e) => {
 				console.error(`[cron] Notification failed: ${e.message}`);
-				if (_io) _io.emit('bg-run-done', { runId: taskName, code, reportId: null });
+				activeRunsService.unregisterRun(taskName);
+				if (_io) _io.emit(SOCKET_EVENTS.BG_RUN_DONE, { runId: taskName, code, reportId: null });
 			});
 		return;
 	}
@@ -199,7 +199,9 @@ async function runSingleBuiltIn({ taskName, tags, workers, browser, notifyDiscor
 		console.error(`[cron] Failed to save report: ${e.message}`);
 	}
 
-	if (_io) _io.emit('bg-run-done', { runId: taskName, code, reportId: report?.id ?? null });
+	activeRunsService.unregisterRun(taskName);
+	if (_io)
+		_io.emit(SOCKET_EVENTS.BG_RUN_DONE, { runId: taskName, code, reportId: report?.id ?? null });
 
 	if (report && (notifyDiscord || notifySlack)) {
 		notificationService
@@ -241,14 +243,15 @@ async function runDistributed({
 
 	if (activeRunnerIds.length === 0) {
 		console.log(`Task "${taskName}" — no tests found, skipping.`);
-		if (_io) _io.emit('bg-run-done', { runId: taskName, code: 0, reportId: null });
+		activeRunsService.unregisterRun(taskName);
+		if (_io) _io.emit(SOCKET_EVENTS.BG_RUN_DONE, { runId: taskName, code: 0, reportId: null });
 		return;
 	}
 
 	const laneInfos = await resolveLaneInfos(activeRunnerIds);
 
 	if (_io) {
-		_io.emit('bg-run-lanes-init', {
+		_io.emit(SOCKET_EVENTS.BG_RUN_LANES_INIT, {
 			runId: taskName,
 			lanes: laneInfos.map((l, i) => ({ id: l.id, name: l.name, testCount: chunks[i].length }))
 		});
@@ -265,10 +268,10 @@ async function runDistributed({
 		laneAttempts[idx] = attempts;
 		doneCount++;
 		if (_io) {
-			_io.emit('bg-run-lane-status', {
+			_io.emit(SOCKET_EVENTS.BG_RUN_LANE_STATUS, {
 				runId: taskName,
 				laneId,
-				status: code === 0 ? 'done' : 'error'
+				status: code === 0 ? JOB_STATUS.DONE : JOB_STATUS.ERROR
 			});
 		}
 
@@ -287,8 +290,9 @@ async function runDistributed({
 					attemptsByLane: laneAttempts
 				})
 				.then((saved) => {
+					activeRunsService.unregisterRun(taskName);
 					if (_io) {
-						_io.emit('bg-run-done', {
+						_io.emit(SOCKET_EVENTS.BG_RUN_DONE, {
 							runId: taskName,
 							code: overallCode,
 							reportId: saved?.id ?? null
@@ -309,7 +313,13 @@ async function runDistributed({
 				})
 				.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 });
+					activeRunsService.unregisterRun(taskName);
+					if (_io)
+						_io.emit(SOCKET_EVENTS.BG_RUN_DONE, {
+							runId: taskName,
+							code: overallCode,
+							reportId: null
+						});
 				});
 		}
 	}
@@ -322,7 +332,7 @@ async function runDistributed({
 		if (lane.id === BUILT_IN_RUNNER_ID) {
 			const idx = i;
 			const onLog = (text) => {
-				if (_io) _io.emit('bg-run-lane-log', { runId: taskName, laneId, log: text });
+				if (_io) _io.emit(SOCKET_EVENTS.BG_RUN_LANE_LOG, { runId: taskName, laneId, log: text });
 			};
 
 			const spawnBuiltInLaneAttempt = (currentTag) =>
@@ -335,7 +345,7 @@ async function runDistributed({
 						TAG: currentTag,
 						TRIGGER: TRIGGER_REMOTE, // node-mode: file naming only, not persisted to DB
 						BROWSER: browser,
-						PLUM_MODE: 'node',
+						PLUM_MODE: PLUM_MODE_NODE,
 						PLUM_SS_DIR: ssDir
 					};
 					if (workers > 1) env.PARALLEL = String(workers);
@@ -344,7 +354,12 @@ async function runDistributed({
 
 					const ssPoller = startSsPoller(ssDir, ({ stepName, data }) => {
 						if (_io)
-							_io.emit('bg-run-lane-screenshot', { runId: taskName, laneId, stepName, data });
+							_io.emit(SOCKET_EVENTS.BG_RUN_LANE_SCREENSHOT, {
+								runId: taskName,
+								laneId,
+								stepName,
+								data
+							});
 					});
 
 					task.stdout.on('data', (d) => {
@@ -374,7 +389,7 @@ async function runDistributed({
 			const idx = i;
 			const onLog = (log) => {
 				process.stdout.write(log);
-				if (_io) _io.emit('bg-run-lane-log', { runId: taskName, laneId, log });
+				if (_io) _io.emit(SOCKET_EVENTS.BG_RUN_LANE_LOG, { runId: taskName, laneId, log });
 			};
 
 			const spawnRemoteLaneAttempt = (currentTag) =>
@@ -386,7 +401,12 @@ async function runDistributed({
 						(code, content) => resolve({ code, rawJson: content ? JSON.parse(content) : [] }),
 						({ stepName, data }) => {
 							if (_io)
-								_io.emit('bg-run-lane-screenshot', { runId: taskName, laneId, stepName, data });
+								_io.emit(SOCKET_EVENTS.BG_RUN_LANE_SCREENSHOT, {
+									runId: taskName,
+									laneId,
+									stepName,
+									data
+								});
 						}
 					);
 				});
@@ -418,13 +438,11 @@ async function runCronJob(job) {
 	} = job;
 	const runnerIds = parseRunnerIds(runnerIdsStr);
 
+	const label = taskName;
+	const meta = { tag: tags, browser, workers };
+	activeRunsService.registerRun(taskName, { kind: TRIGGER_TYPE.CRON, label, meta });
 	if (_io) {
-		_io.emit('bg-run-start', {
-			runId: taskName,
-			kind: 'cron',
-			label: taskName,
-			meta: { tag: tags, browser, workers }
-		});
+		_io.emit(SOCKET_EVENTS.BG_RUN_START, { runId: taskName, kind: TRIGGER_TYPE.CRON, label, meta });
 	}
 	console.log(`Running scheduled task: "${taskName}" → runners: ${runnerIds.join(', ')}`);
 
@@ -504,7 +522,7 @@ const addCronJob = async ({
 			cronExpression,
 			tags: tags ?? '',
 			workers: workers ?? 1,
-			browser: browser ?? 'chromium',
+			browser: browser ?? DEFAULT_BROWSER,
 			runnerIds: runnerIdsStr,
 			notifyDiscord: notifyDiscord ?? false,
 			notifySlack: notifySlack ?? false,
@@ -559,7 +577,7 @@ const updateCronJob = async (
 			cronExpression,
 			tags,
 			workers: workers ?? 1,
-			browser: browser ?? 'chromium',
+			browser: browser ?? DEFAULT_BROWSER,
 			runnerIds: runnerIdsStr,
 			notifyDiscord: notifyDiscord ?? false,
 			notifySlack: notifySlack ?? false,