plum-e2e 2.1.0 → 2.3.0

package/backend/lib/runnerProcess.js

@@ -49,6 +49,34 @@ function saveRegistry(registry) {
 	fs.writeFileSync(REGISTRY_PATH, JSON.stringify(registry, null, 2), 'utf8');
 }
 
+/**
+ * Returns the PID of the process listening on the given TCP port, or null.
+ * Uses lsof on macOS/Linux and netstat on Windows.
+ */
+function findPidOnPort(port) {
+	const portStr = String(port);
+	try {
+		if (process.platform === 'win32') {
+			const out = execSync('netstat -ano', { encoding: 'utf8' });
+			for (const line of out.split('\n')) {
+				const upper = line.toUpperCase();
+				if (upper.includes(`:${portStr}`) && upper.includes('LISTENING')) {
+					const parts = line.trim().split(/\s+/);
+					const pid = parseInt(parts[parts.length - 1], 10);
+					if (!isNaN(pid) && pid > 0) return pid;
+				}
+			}
+		} else {
+			const out = execSync(`lsof -i :${portStr} -t -sTCP:LISTEN`, { encoding: 'utf8' }).trim();
+			if (out) {
+				const pid = parseInt(out.split('\n')[0].trim(), 10);
+				if (!isNaN(pid) && pid > 0) return pid;
+			}
+		}
+	} catch {}
+	return null;
+}
+
 // Signal 0 performs the OS-level permission/existence check without actually
 // delivering a signal — the portable way to ask "is this pid alive?".
 function isAlive(pid) {
@@ -128,7 +156,13 @@ function startNode({ id, port, token }) {
 
 	const child = spawn(process.execPath, [SERVER_PATH], {
 		cwd: BACKEND_DIR,
-		env: { ...process.env, NODE_TOKEN: token, PLUM_MODE: 'node', PORT: String(port) },
+		env: {
+			...process.env,
+			NODE_TOKEN: token,
+			PLUM_MODE: 'node',
+			PORT: String(port),
+			RUNNER_ID: String(id)
+		},
 		detached: true,
 		stdio: ['ignore', out, out],
 		windowsHide: true
@@ -146,14 +180,25 @@ function startNode({ id, port, token }) {
 /**
  * Stops the managed process for a runner. Returns true if a live process was
  * signalled, false if nothing was running.
+ *
+ * Falls back to port-based PID discovery when the registry entry is missing or
+ * its PID is stale, using the port stored in the entry or an explicit fallback.
  */
-function stopNode(id) {
+function stopNode(id, fallbackPort = null) {
 	const registry = loadRegistry();
 	const entry = registry[id];
 	let signalled = false;
-	if (entry?.pid && isAlive(entry.pid)) {
+
+	let pid = entry?.pid && isAlive(entry.pid) ? entry.pid : null;
+
+	if (!pid) {
+		const port = fallbackPort ?? (entry?.port ? Number(entry.port) : null);
+		if (port) pid = findPidOnPort(port);
+	}
+
+	if (pid) {
 		try {
-			process.kill(entry.pid, 'SIGTERM');
+			process.kill(pid, 'SIGTERM');
 			signalled = true;
 		} catch {}
 	}
@@ -171,6 +216,7 @@ module.exports = {
 	isAlive,
 	isLocalUrl,
 	parsePort,
+	findPidOnPort,
 	pruneDead,
 	statusOf,
 	prepareEnv,

package/backend/logs/runner-cmqneqerz0000qq01i5ap2rvl.log

@@ -0,0 +1,22 @@
+/*
+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/.
+*/
+📂 Loading tests from: /Users/silverlunah/Projects/plum/backend/tests
+Backend running on port 3002 (node/runner mode)
+📂 Loading tests from: /Users/silverlunah/Projects/plum/backend/tests
+Backend running on port 3002 (node/runner mode)
+(node:14993) [DEP0190] DeprecationWarning: Passing args to a child process with shell option true can lead to security vulnerabilities, as the arguments are not escaped, only concatenated.
+(Use `node --trace-deprecation ...` to show where the warning was created)

package/backend/logs/runner-cmqnfv7kr0000r101aeocm8eu.log

@@ -0,0 +1,20 @@
+/*
+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/.
+*/
+📂 Loading tests from: /Users/silverlunah/Projects/plum/backend/tests
+Backend running on port 3002 (node/runner mode)
+(node:23570) [DEP0190] DeprecationWarning: Passing args to a child process with shell option true can lead to security vulnerabilities, as the arguments are not escaped, only concatenated.
+(Use `node --trace-deprecation ...` to show where the warning was created)

package/backend/logs/runner-cmqnfvb560001r101qoi0phau.log

@@ -0,0 +1,43 @@
+/*
+This file is part of Plum.
+
+Plum is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Plum is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Plum. If not, see https://www.gnu.org/licenses/.
+*/
+📂 Loading tests from: /Users/silverlunah/Projects/plum/backend/tests
+node:events:487
+      throw er; // Unhandled 'error' event
+      ^
+
+Error: listen EADDRINUSE: address already in use :::3002
+    at Server.setupListenHandle [as _listen2] (node:net:2008:16)
+    at listenInCluster (node:net:2065:12)
+    at Server.listen (node:net:2170:7)
+    at start (/Users/silverlunah/Projects/plum/backend/server.js:54:9)
+    at Object.<anonymous> (/Users/silverlunah/Projects/plum/backend/server.js:120:1)
+    at Module._compile (node:internal/modules/cjs/loader:1829:14)
+    at Module._extensions..js (node:internal/modules/cjs/loader:1969:10)
+    at Module.load (node:internal/modules/cjs/loader:1552:32)
+    at Module._load (node:internal/modules/cjs/loader:1354:12)
+    at wrapModuleLoad (node:internal/modules/cjs/loader:255:19)
+Emitted 'error' event on Server instance at:
+    at emitErrorNT (node:net:2044:8)
+    at process.processTicksAndRejections (node:internal/process/task_queues:90:21) {
+  code: 'EADDRINUSE',
+  errno: -48,
+  syscall: 'listen',
+  address: '::',
+  port: 3002
+}
+
+Node.js v25.9.0

package/backend/logs/runner-cmqnfvlm20002r101gsyqb837.log

@@ -0,0 +1,20 @@
+/*
+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/.
+*/
+📂 Loading tests from: /Users/silverlunah/Projects/plum/backend/tests
+Backend running on port 3003 (node/runner mode)
+(node:23686) [DEP0190] DeprecationWarning: Passing args to a child process with shell option true can lead to security vulnerabilities, as the arguments are not escaped, only concatenated.
+(Use `node --trace-deprecation ...` to show where the warning was created)

package/backend/logs/runner-cmqnfvqfy0003r101fh41pzx3.log

@@ -0,0 +1,20 @@
+/*
+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/.
+*/
+📂 Loading tests from: /Users/silverlunah/Projects/plum/backend/tests
+Backend running on port 3004 (node/runner mode)
+(node:23733) [DEP0190] DeprecationWarning: Passing args to a child process with shell option true can lead to security vulnerabilities, as the arguments are not escaped, only concatenated.
+(Use `node --trace-deprecation ...` to show where the warning was created)

package/backend/logs/runner-cmqnfvvwo0004r101q4dtqxd2.log

@@ -0,0 +1,20 @@
+/*
+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/.
+*/
+📂 Loading tests from: /Users/silverlunah/Projects/plum/backend/tests
+Backend running on port 3005 (node/runner mode)
+(node:23776) [DEP0190] DeprecationWarning: Passing args to a child process with shell option true can lead to security vulnerabilities, as the arguments are not escaped, only concatenated.
+(Use `node --trace-deprecation ...` to show where the warning was created)

package/backend/package.json

@@ -22,6 +22,7 @@
 		"typescript": "^5.9.2"
 	},
 	"dependencies": {
+		"@aws-sdk/client-s3": "^3.840.0",
 		"@clack/prompts": "^1.5.1",
 		"@cucumber/cucumber": "^11.2.0",
 		"@prisma/client": "^6.19.3",

package/backend/prisma/migrations/20260621000000_add_notifications/migration.sql

@@ -0,0 +1,8 @@
+-- AlterTable Project: add webhook and public URL fields
+ALTER TABLE "Project" ADD COLUMN "discordWebhookUrl" TEXT NOT NULL DEFAULT '';
+ALTER TABLE "Project" ADD COLUMN "slackWebhookUrl" TEXT NOT NULL DEFAULT '';
+ALTER TABLE "Project" ADD COLUMN "notifyPublicUrl" TEXT NOT NULL DEFAULT '';
+
+-- AlterTable CronJob: add notification toggles
+ALTER TABLE "CronJob" ADD COLUMN "notifyDiscord" BOOLEAN NOT NULL DEFAULT false;
+ALTER TABLE "CronJob" ADD COLUMN "notifySlack" BOOLEAN NOT NULL DEFAULT false;

package/backend/prisma/migrations/20260621000001_add_backup_config/migration.sql

@@ -0,0 +1,11 @@
+-- AlterTable Project: add S3 backup configuration fields
+ALTER TABLE "Project" ADD COLUMN "backupEnabled"    BOOLEAN NOT NULL DEFAULT false;
+ALTER TABLE "Project" ADD COLUMN "backupCron"       TEXT    NOT NULL DEFAULT '0 2 * * *';
+ALTER TABLE "Project" ADD COLUMN "backupS3Endpoint" TEXT    NOT NULL DEFAULT '';
+ALTER TABLE "Project" ADD COLUMN "backupS3Region"   TEXT    NOT NULL DEFAULT '';
+ALTER TABLE "Project" ADD COLUMN "backupS3Bucket"   TEXT    NOT NULL DEFAULT '';
+ALTER TABLE "Project" ADD COLUMN "backupS3AccessKey" TEXT   NOT NULL DEFAULT '';
+ALTER TABLE "Project" ADD COLUMN "backupS3SecretKey" TEXT   NOT NULL DEFAULT '';
+ALTER TABLE "Project" ADD COLUMN "backupS3Prefix"   TEXT    NOT NULL DEFAULT '';
+ALTER TABLE "Project" ADD COLUMN "backupLastRunAt"  TIMESTAMP(3);
+ALTER TABLE "Project" ADD COLUMN "backupLastStatus" TEXT    NOT NULL DEFAULT '';

package/backend/prisma/schema.prisma

@@ -44,6 +44,8 @@ model CronJob {
   enabled        Boolean  @default(true)
   runnerId       String?
   runnerIds      String   @default("built-in")
+  notifyDiscord  Boolean  @default(false)
+  notifySlack    Boolean  @default(false)
   runner         Runner?  @relation(fields: [runnerId], references: [id], onDelete: SetNull)
   createdAt      DateTime @default(now())
   updatedAt      DateTime @updatedAt
@@ -68,13 +70,26 @@ model Report {
 }
 
 model Project {
-  id              Int    @id @default(autoincrement())
-  name            String @default("")
-  logoUrl         String @default("")
-  testCasePrefix  String @default("TC")
-  testSuitePrefix String @default("TS")
-  caseSeqNext     Int    @default(0)
-  suiteSeqNext    Int    @default(0)
+  id                 Int       @id @default(autoincrement())
+  name               String    @default("")
+  logoUrl            String    @default("")
+  testCasePrefix     String    @default("TC")
+  testSuitePrefix    String    @default("TS")
+  caseSeqNext        Int       @default(0)
+  suiteSeqNext       Int       @default(0)
+  discordWebhookUrl  String    @default("")
+  slackWebhookUrl    String    @default("")
+  notifyPublicUrl    String    @default("")
+  backupEnabled      Boolean   @default(false)
+  backupCron         String    @default("0 2 * * *")
+  backupS3Endpoint   String    @default("")
+  backupS3Region     String    @default("")
+  backupS3Bucket     String    @default("")
+  backupS3AccessKey  String    @default("")
+  backupS3SecretKey  String    @default("")
+  backupS3Prefix     String    @default("")
+  backupLastRunAt    DateTime?
+  backupLastStatus   String    @default("")
 }
 
 model User {

package/backend/routes/backup.routes.js

@@ -18,7 +18,10 @@
 const express = require('express');
 const router = express.Router();
 const backupService = require('../services/backupService');
+const settingsService = require('../services/settingsService');
 const cronService = require('../services/cronService');
+const backupCronService = require('../services/backupCronService');
+const prisma = require('../services/prisma');
 
 router.get('/export', async (req, res) => {
 	try {
@@ -35,11 +38,15 @@ router.get('/export', async (req, res) => {
 
 router.post('/import', async (req, res) => {
 	try {
-		const { cronJobs, reports, project } = req.body;
-		if (!Array.isArray(cronJobs) && !Array.isArray(reports) && !project) {
-			return res.status(400).json({ error: 'Invalid backup format' });
-		}
-		await backupService.importAll({ cronJobs, reports, project }, cronService);
+		const { cronJobs, project, users, runners, testSuites, testRuns } = req.body;
+		const hasData = [cronJobs, project, users, runners, testSuites, testRuns].some(
+			(v) => v !== undefined && v !== null
+		);
+		if (!hasData) return res.status(400).json({ error: 'Invalid backup format' });
+		await backupService.importAll(
+			{ cronJobs, project, users, runners, testSuites, testRuns },
+			cronService
+		);
 		res.json({ message: 'Import successful' });
 	} catch (error) {
 		console.error('Import failed:', error);
@@ -47,4 +54,62 @@ router.post('/import', async (req, res) => {
 	}
 });
 
+router.get('/config', async (req, res) => {
+	try {
+		const config = await settingsService.getBackupConfig();
+		res.json(config);
+	} catch (error) {
+		console.error('Failed to get backup config:', error);
+		res.status(500).json({ error: 'Failed to get backup configuration' });
+	}
+});
+
+router.post('/config', async (req, res) => {
+	try {
+		await settingsService.updateBackupConfig(req.body);
+		await backupCronService.reload();
+		const config = await settingsService.getBackupConfig();
+		res.json(config);
+	} catch (error) {
+		console.error('Failed to save backup config:', error);
+		res.status(500).json({ error: 'Failed to save backup configuration' });
+	}
+});
+
+router.post('/test-s3', async (req, res) => {
+	try {
+		// If no secret key provided in the request, fall back to the stored one
+		let config = { ...req.body };
+		if (!config.backupS3SecretKey) {
+			const stored = await prisma.project.findUnique({ where: { id: 1 } });
+			config.backupS3SecretKey = stored?.backupS3SecretKey ?? '';
+		}
+
+		const required = ['backupS3Bucket', 'backupS3AccessKey', 'backupS3SecretKey'];
+		const missing = required.filter((k) => !config[k]);
+		if (missing.length > 0) {
+			return res.status(400).json({ error: `Missing required fields: ${missing.join(', ')}` });
+		}
+
+		await backupService.testS3Connection(config);
+		res.json({ ok: true });
+	} catch (error) {
+		res.status(400).json({ error: error.message || 'Connection failed' });
+	}
+});
+
+router.post('/run-now', async (req, res) => {
+	try {
+		await backupCronService.runBackup();
+		const config = await settingsService.getBackupConfig();
+		if (config.backupLastStatus?.startsWith('error:')) {
+			return res.status(500).json({ error: config.backupLastStatus.replace('error:', '') });
+		}
+		res.json({ ok: true, lastRunAt: config.backupLastRunAt, lastStatus: config.backupLastStatus });
+	} catch (error) {
+		console.error('Backup run-now failed:', error);
+		res.status(500).json({ error: error.message || 'Backup failed' });
+	}
+});
+
 module.exports = router;

package/backend/routes/node.routes.js

@@ -34,6 +34,15 @@ router.get('/ping', authGuard, (req, res) => {
 	res.json({ ok: true, mode: process.env.PLUM_MODE || 'server' });
 });
 
+// Graceful shutdown for node-mode processes (no-op on the primary server)
+router.post('/shutdown', authGuard, (req, res) => {
+	if (process.env.PLUM_MODE !== 'node') {
+		return res.status(403).json({ error: 'Not a node runner' });
+	}
+	res.json({ ok: true });
+	setTimeout(() => process.exit(0), 200);
+});
+
 // Start a remote test job
 router.post('/execute', authGuard, (req, res) => {
 	const { tags, browser = 'chromium', workers = 1, tests = null } = req.body;

package/backend/routes/runners.routes.js

@@ -64,6 +64,16 @@ router.put('/:id', async (req, res) => {
 
 router.delete('/:id', async (req, res) => {
 	try {
+		const runner = await runnerService.getById(req.params.id);
+		if (runner) {
+			try {
+				await fetch(`${runner.url}/api/shutdown`, {
+					method: 'POST',
+					headers: { Authorization: `Bearer ${runner.token}` },
+					signal: AbortSignal.timeout(3000)
+				});
+			} catch {}
+		}
 		await runnerService.remove(req.params.id);
 		res.json({ message: 'Runner deleted' });
 	} catch (e) {

package/backend/routes/settings.routes.js

@@ -76,4 +76,31 @@ router.post('/test-prefixes/migrate', jwtAuth, async (req, res, next) => {
 	}
 });
 
+router.get('/integrations', async (req, res, next) => {
+	try {
+		const webhooks = await settingsService.getWebhooks();
+		res.json(webhooks);
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.post('/integrations', async (req, res, next) => {
+	try {
+		const { discordWebhookUrl, slackWebhookUrl, notifyPublicUrl } = req.body;
+		const project = await settingsService.updateWebhooks({
+			discordWebhookUrl,
+			slackWebhookUrl,
+			notifyPublicUrl
+		});
+		res.json({
+			discordWebhookUrl: project.discordWebhookUrl,
+			slackWebhookUrl: project.slackWebhookUrl,
+			notifyPublicUrl: project.notifyPublicUrl
+		});
+	} catch (e) {
+		next(e);
+	}
+});
+
 module.exports = router;

package/backend/scripts/manage-runners.mjs

@@ -32,8 +32,16 @@ import pc from 'picocolors';
 import runnerProcess from '../lib/runnerProcess.js';
 import nodeRegister from '../lib/nodeRegister.js';
 
-const { isLocalUrl, parsePort, pruneDead, statusOf, prepareEnv, startNode, stopNode } =
-	runnerProcess;
+const {
+	isLocalUrl,
+	parsePort,
+	pruneDead,
+	statusOf,
+	prepareEnv,
+	startNode,
+	stopNode,
+	findPidOnPort
+} = runnerProcess;
 const { generateToken, registerWithPrimary } = nodeRegister;
 
 const API_URL = process.env.PLUM_API_URL || 'http://localhost:3001';
@@ -68,6 +76,9 @@ async function deleteRunner(id) {
 /**
  * Resolves the display + control state for every runner: reachability (ping),
  * whether we own a live process for it, and whether we can control it at all.
+ *
+ * Local runners that are online but absent from the registry are automatically
+ * reclaimed by scanning their port for a running process.
  */
 async function describeRunners() {
 	const runners = await fetchRunners();
@@ -77,7 +88,19 @@ async function describeRunners() {
 		runners.map(async (r) => {
 			const online = await pingRunner(r.id);
 			const local = isLocalUrl(r.url);
-			const managed = statusOf(r.id) === 'running';
+			let managed = statusOf(r.id) === 'running';
+
+			if (local && online && !managed) {
+				const port = Number(parsePort(r.url));
+				const pid = findPidOnPort(port);
+				if (pid) {
+					const registry = runnerProcess.loadRegistry();
+					registry[r.id] = { pid, port: String(port), startedAt: Date.now() };
+					runnerProcess.saveRegistry(registry);
+					managed = true;
+				}
+			}
+
 			let state;
 			if (managed) state = 'managed';
 			else if (online) state = 'unmanaged';
@@ -181,7 +204,7 @@ async function runAction(r) {
 		if (cancelled(confirmed) || !confirmed) return;
 		const s = clack.spinner();
 		s.start(`Deleting "${r.name}"...`);
-		if (r.managed) stopNode(r.id);
+		if (r.local) stopNode(r.id, Number(parsePort(r.url)));
 		try {
 			await deleteRunner(r.id);
 			s.stop(pc.green(`Deleted "${r.name}"`));
@@ -194,7 +217,11 @@ async function runAction(r) {
 async function addRunner() {
 	const suggested = `node-${generateToken().slice(0, 6)}`;
 
-	const name = await clack.text({ message: 'Runner name', placeholder: suggested, defaultValue: suggested });
+	const name = await clack.text({
+		message: 'Runner name',
+		placeholder: suggested,
+		defaultValue: suggested
+	});
 	if (cancelled(name)) return;
 
 	const port = await clack.text({
@@ -205,7 +232,11 @@ async function addRunner() {
 	if (cancelled(port)) return;
 
 	const defToken = process.env.NODE_TOKEN || generateToken();
-	const token = await clack.text({ message: 'Auth token', placeholder: defToken, defaultValue: defToken });
+	const token = await clack.text({
+		message: 'Auth token',
+		placeholder: defToken,
+		defaultValue: defToken
+	});
 	if (cancelled(token)) return;
 
 	// Dev nodes run as a bare process on the host; the dockerized primary reaches
@@ -216,9 +247,19 @@ async function addRunner() {
 	s.start(`Registering "${name}" with the primary...`);
 	let id;
 	try {
-		const res = await registerWithPrimary({ primary: API_URL, name, url, token, browser: 'chromium' });
+		const res = await registerWithPrimary({
+			primary: API_URL,
+			name,
+			url,
+			token,
+			browser: 'chromium'
+		});
 		id = res.id;
-		s.stop(res.reused ? pc.green(`Reusing existing runner "${name}"`) : pc.green(`Registered "${name}" (id ${id})`));
+		s.stop(
+			res.reused
+				? pc.green(`Reusing existing runner "${name}"`)
+				: pc.green(`Registered "${name}" (id ${id})`)
+		);
 	} catch (e) {
 		s.stop(pc.red(`Could not register "${name}": ${e.message}`));
 		return;

package/backend/server.js

@@ -41,19 +41,43 @@ const isNodeMode = process.env.PLUM_MODE === 'node';
 const port = parseInt(process.env.PORT || '3001', 10);
 
 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);
 }
 
 async function start() {
 	if (cronService) await cronService.init();
+	if (backupCronService) await backupCronService.init();
 
 	server.listen(port, async () => {
 		console.log(`Backend running on port ${port}${isNodeMode ? ' (node/runner mode)' : ''}`);
-		if (isNodeMode) return; // nodes don't watch files or schedule jobs
+		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();
+						delete reg[runnerId];
+						saveRegistry(reg);
+					} catch {}
+				};
+				process.once('SIGTERM', cleanup);
+				process.once('SIGINT', cleanup);
+				process.once('exit', cleanup);
+			}
+			return;
+		}
 
 		// chokidar v5+ is ESM-only — use dynamic import to stay compatible with CJS
 		let chokidar;