plum-e2e 2.2.0 → 2.4.0

package/backend/package.json

@@ -8,7 +8,8 @@
 		"create-env": "node services/envService.js",
 		"test": "node config/scripts/run-tests.js",
 		"manage-runners": "node scripts/manage-runners.mjs",
-		"create-test": "node scripts/create-test.js"
+		"create-test": "node scripts/create-test.js",
+		"mcp": "node mcp/server.js"
 	},
 	"keywords": [],
 	"author": "",
@@ -22,8 +23,10 @@
 		"typescript": "^5.9.2"
 	},
 	"dependencies": {
+		"@aws-sdk/client-s3": "^3.840.0",
 		"@clack/prompts": "^1.5.1",
 		"@cucumber/cucumber": "^11.2.0",
+		"@modelcontextprotocol/sdk": "^1.29.0",
 		"@prisma/client": "^6.19.3",
 		"bcryptjs": "^2.4.3",
 		"chai": "^4.3.6",

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/migrations/20260621000002_add_mcp_key/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "Project" ADD COLUMN "mcpKey" TEXT NOT NULL DEFAULT '';

package/backend/prisma/schema.prisma

@@ -70,16 +70,27 @@ 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)
-  discordWebhookUrl String @default("")
-  slackWebhookUrl   String @default("")
-  notifyPublicUrl   String @default("")
+  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("")
+  mcpKey             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/settings.routes.js

@@ -103,4 +103,22 @@ router.post('/integrations', async (req, res, next) => {
 	}
 });
 
+router.get('/mcp', jwtAuth, async (req, res, next) => {
+	try {
+		const config = await settingsService.getMcpConfig();
+		res.json(config);
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.post('/mcp/generate', jwtAuth, async (req, res, next) => {
+	try {
+		const config = await settingsService.generateMcpKey();
+		res.json(config);
+	} catch (e) {
+		next(e);
+	}
+});
+
 module.exports = router;

package/backend/routes/trigger.routes.js

@@ -0,0 +1,94 @@
+/*
+ * 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/.
+ */
+
+const path = require('path');
+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 { TRIGGER_TYPE } = require('../constants/triggers');
+
+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();
+
+function pruneOldJobs() {
+	const cutoff = Date.now() - JOB_TTL_MS;
+	for (const [id, job] of jobs) {
+		if (job.startedAt < cutoff) jobs.delete(id);
+	}
+}
+
+router.post('/', jwtAuth, async (req, res, next) => {
+	try {
+		pruneOldJobs();
+
+		const { tag = '', browser = 'chromium', workers = 1, baseUrl, testRunId } = req.body;
+
+		const jobId = randomUUID();
+		const startedAt = Date.now();
+		jobs.set(jobId, { status: 'running', exitCode: null, reportId: null, startedAt });
+
+		const env = {
+			...process.env,
+			TAG: tag,
+			TRIGGER: TRIGGER_TYPE.MCP,
+			BROWSER: browser,
+			REPORT_RUNNERS: String(workers)
+		};
+		if (Number(workers) > 1) env.PARALLEL = String(workers);
+		if (testRunId) env.TEST_RUN_ID = testRunId;
+		if (baseUrl) env.BASE_URL = baseUrl;
+
+		const proc = spawn('npm', ['run', 'test'], { env, shell: true, cwd: BACKEND_DIR });
+
+		proc.on('close', async (code) => {
+			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 }
+				});
+				jobs.set(jobId, {
+					status: code === 130 ? 'cancelled' : 'done',
+					exitCode: code,
+					reportId: report?.id ?? null,
+					startedAt
+				});
+			} catch {
+				jobs.set(jobId, { status: 'done', exitCode: code, reportId: null, startedAt });
+			}
+		});
+
+		res.status(202).json({ jobId, status: 'running' });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.get('/:jobId', jwtAuth, (req, res) => {
+	const job = jobs.get(req.params.jobId);
+	if (!job) return res.status(404).json({ error: 'Job not found' });
+	res.json(job);
+});
+
+module.exports = router;

package/backend/scripts/manage-runners.mjs

@@ -42,12 +42,27 @@ const {
 	stopNode,
 	findPidOnPort
 } = runnerProcess;
-const { generateToken, registerWithPrimary } = nodeRegister;
+const { generateToken, registerWithPrimary, detectLanIp } = nodeRegister;
 
 const API_URL = process.env.PLUM_API_URL || 'http://localhost:3001';
 
 const cancelled = (v) => clack.isCancel(v);
 
+/**
+ * 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.
+ */
+function resolveNodeUrl(url) {
+	try {
+		const u = new URL(url);
+		if (u.hostname === 'localhost' || u.hostname === '127.0.0.1') {
+			u.hostname = 'host.docker.internal';
+			return u.toString();
+		}
+	} catch {}
+	return url;
+}
+
 async function fetchRunners() {
 	const res = await fetch(`${API_URL}/runners`);
 	if (!res.ok) throw new Error(`HTTP ${res.status}`);
@@ -239,9 +254,15 @@ async function addRunner() {
 	});
 	if (cancelled(token)) return;
 
-	// Dev nodes run as a bare process on the host; the dockerized primary reaches
-	// them via host.docker.internal.
-	const url = `http://host.docker.internal:${port}`;
+	const defaultUrl = `http://${detectLanIp()}:${port}`;
+	const urlInput = await clack.text({
+		message: 'URL the Plum server uses to reach this node',
+		placeholder: defaultUrl,
+		defaultValue: defaultUrl
+	});
+	if (cancelled(urlInput)) return;
+
+	const url = resolveNodeUrl(urlInput || defaultUrl);
 
 	const s = clack.spinner();
 	s.start(`Registering "${name}" with the primary...`);

package/backend/server.js

@@ -41,15 +41,26 @@ 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();
+
+	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)' : ''}`);

package/backend/services/backupCronService.js

@@ -0,0 +1,82 @@
+/*
+ * 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/.
+ */
+
+const cron = require('node-cron');
+const prisma = require('./prisma');
+const backupService = require('./backupService');
+
+let scheduledJob = null;
+
+const runBackup = async () => {
+	let project;
+	try {
+		project = await prisma.project.findUnique({ where: { id: 1 } });
+	} catch (err) {
+		console.error('❌ Backup: could not read project config:', err.message);
+		return;
+	}
+
+	if (!project?.backupEnabled) return;
+
+	try {
+		const data = await backupService.exportAll();
+		const key = await backupService.uploadToS3(data, project);
+
+		await prisma.project.update({
+			where: { id: 1 },
+			data: {
+				backupLastRunAt: new Date(),
+				backupLastStatus: `success:${key}`
+			}
+		});
+		console.log(`✅ Backup uploaded: ${key}`);
+	} catch (err) {
+		console.error('❌ Backup failed:', err.message);
+		try {
+			await prisma.project.update({
+				where: { id: 1 },
+				data: {
+					backupLastRunAt: new Date(),
+					backupLastStatus: `error:${err.message}`
+				}
+			});
+		} catch {}
+	}
+};
+
+const schedule = (cronExpr, enabled) => {
+	if (scheduledJob) {
+		scheduledJob.stop();
+		scheduledJob = null;
+	}
+	if (!enabled || !cronExpr || !cron.validate(cronExpr)) return;
+	scheduledJob = cron.schedule(cronExpr, runBackup);
+	console.log(`⏰ Backup scheduled: ${cronExpr}`);
+};
+
+const init = async () => {
+	try {
+		const project = await prisma.project.findUnique({ where: { id: 1 } });
+		schedule(project?.backupCron, project?.backupEnabled);
+	} catch (err) {
+		console.error('Failed to initialize backup cron:', err.message);
+	}
+};
+
+const reload = init;
+
+module.exports = { init, reload, runBackup };