plum-e2e 1.2.4 → 1.3.0

package/backend/routes/node.routes.js

@@ -0,0 +1,121 @@
+/*
+ * 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 express = require('express');
+const router = express.Router();
+const { spawn } = require('child_process');
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { authGuard } = require('../middleware/auth');
+const { TRIGGER_REMOTE } = require('../constants/triggers');
+
+// In-memory job store for active remote executions.
+// Jobs are purged after 10 minutes post-completion.
+const jobs = {};
+
+// Health check — primary server uses this to confirm the node is reachable
+router.get('/ping', authGuard, (req, res) => {
+	res.json({ ok: true, mode: process.env.PLUM_MODE || 'server' });
+});
+
+// Start a remote test job
+router.post('/execute', authGuard, (req, res) => {
+	const { tags, browser = 'chromium', workers = 1, tests = null } = req.body;
+	const jobId = crypto.randomUUID();
+
+	// Write test files sent by the primary into a per-job temp dir
+	let tempTestsDir = null;
+	if (tests && Object.keys(tests).length > 0) {
+		tempTestsDir = path.join(os.tmpdir(), `plum-job-${jobId}`);
+		for (const [rel, content] of Object.entries(tests)) {
+			const dest = path.join(tempTestsDir, rel);
+			fs.mkdirSync(path.dirname(dest), { recursive: true });
+			fs.writeFileSync(dest, content, 'utf8');
+		}
+	}
+
+	jobs[jobId] = {
+		status: 'running',
+		logs: '',
+		exitCode: null,
+		startedAt: Date.now(),
+		meta: { tags: tags || '', browser, workers },
+		tempTestsDir
+	};
+
+	const env = {
+		...process.env,
+		TAG: tags || '',
+		TRIGGER: TRIGGER_REMOTE,
+		BROWSER: browser,
+		REPORT_RUNNERS: String(workers),
+		...(tempTestsDir ? { TESTS_ROOT: tempTestsDir } : {})
+	};
+	if (workers > 1) env.PARALLEL = String(workers);
+
+	const proc = spawn('npm', ['run', 'test'], { env, shell: true });
+	proc.stdout.on('data', (d) => {
+		jobs[jobId].logs += d.toString();
+	});
+	proc.stderr.on('data', (d) => {
+		jobs[jobId].logs += d.toString();
+	});
+	proc.on('close', (code) => {
+		jobs[jobId].status = code === 0 ? 'done' : 'error';
+		jobs[jobId].exitCode = code;
+
+		try {
+			const reportPath = path.resolve(process.cwd(), 'reports', 'cucumber_report.json');
+			if (fs.existsSync(reportPath)) {
+				jobs[jobId].reportContent = fs.readFileSync(reportPath, 'utf8');
+			}
+		} catch {}
+
+		if (jobs[jobId].tempTestsDir) {
+			fs.rm(jobs[jobId].tempTestsDir, { recursive: true, force: true }, () => {});
+		}
+
+		setTimeout(() => delete jobs[jobId], 600_000);
+	});
+
+	res.json({ jobId, status: 'started' });
+});
+
+// Fetch the final report content after a job completes
+router.get('/report/:jobId', authGuard, (req, res) => {
+	const job = jobs[req.params.jobId];
+	if (!job) return res.status(404).json({ error: 'Job not found' });
+	if (!job.reportContent) return res.status(404).json({ error: 'Report not ready' });
+	res.json({ content: job.reportContent, meta: job.meta });
+});
+
+// Poll job status and streamed logs
+router.get('/execute/:jobId', authGuard, (req, res) => {
+	const job = jobs[req.params.jobId];
+	if (!job) return res.status(404).json({ error: 'Job not found' });
+
+	const offset = parseInt(req.query.offset || '0', 10);
+	res.json({
+		status: job.status,
+		logs: job.logs.slice(offset),
+		exitCode: job.exitCode
+	});
+});
+
+module.exports = router;

package/backend/routes/reports.routes.js

@@ -23,47 +23,50 @@ router.get('/', async (req, res) => {
 	try {
 		const reports = await reportService.getAllReports();
 		res.json({ reports });
-	} catch (error) {
-		console.error('Error fetching reports:', error);
+	} catch {
 		res.status(500).json({ error: 'Failed to fetch reports' });
 	}
 });
 
 router.get('/latest', async (req, res) => {
 	try {
-		const latestReport = await reportService.getLatestReport();
-		res.json({ latestReport });
-	} catch (error) {
-		console.error('Error fetching latest report:', error);
+		const latestReportId = await reportService.getLatestReportId();
+		res.json({ latestReportId });
+	} catch {
 		res.status(500).json({ error: 'Failed to fetch latest report' });
 	}
 });
 
-router.get('/:fileName/detail', (req, res) => {
-	const detail = reportService.getReportDetail(req.params.fileName);
+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' });
+	const detail = await reportService.getReportDetail(id);
 	if (!detail) return res.status(404).json({ error: 'Report not found' });
 	res.json(detail);
 });
 
 router.delete('/bulk', async (req, res) => {
-	const { fileNames } = req.body;
-	if (!Array.isArray(fileNames) || fileNames.length === 0)
-		return res.status(400).json({ error: 'fileNames array required' });
+	const { ids } = req.body;
+	if (!Array.isArray(ids) || ids.length === 0) {
+		return res.status(400).json({ error: 'ids array required' });
+	}
+	const numericIds = ids.map(Number).filter((n) => !isNaN(n));
+	if (numericIds.length === 0) return res.status(400).json({ error: 'No valid ids' });
 	try {
-		await reportService.deleteReports(fileNames);
-		res.json({ deleted: fileNames.length });
-	} catch (error) {
-		console.error('Error deleting reports:', error);
+		await reportService.deleteReports(numericIds);
+		res.json({ deleted: numericIds.length });
+	} catch {
 		res.status(500).json({ error: 'Failed to delete reports' });
 	}
 });
 
-router.delete('/:fileName', async (req, res) => {
+router.delete('/:id', async (req, res) => {
+	const id = parseInt(req.params.id, 10);
+	if (isNaN(id)) return res.status(400).json({ error: 'Invalid report id' });
 	try {
-		await reportService.deleteReport(req.params.fileName);
-		res.json({ deleted: req.params.fileName });
-	} catch (error) {
-		console.error('Error deleting report:', error);
+		await reportService.deleteReport(id);
+		res.json({ deleted: id });
+	} catch {
 		res.status(500).json({ error: 'Failed to delete report' });
 	}
 });

package/backend/routes/runners.routes.js

@@ -0,0 +1,83 @@
+/*
+ * 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 express = require('express');
+const router = express.Router();
+const runnerService = require('../services/runnerService');
+
+router.get('/', async (req, res) => {
+	try {
+		const runners = await runnerService.getAll();
+		res.json({ runners });
+	} catch (e) {
+		res.status(500).json({ error: 'Failed to fetch runners' });
+	}
+});
+
+router.post('/probe', async (req, res) => {
+	try {
+		const { url, token } = req.body;
+		if (!url || !token)
+			return res.status(400).json({ ok: false, error: 'url and token are required' });
+		const result = await runnerService.probe({ url, token });
+		res.json(result);
+	} catch (e) {
+		res.status(500).json({ ok: false, error: e.message });
+	}
+});
+
+router.post('/', async (req, res) => {
+	try {
+		const { name, url, token, browser } = req.body;
+		if (!name || !url || !token)
+			return res.status(400).json({ error: 'name, url and token are required' });
+		const runner = await runnerService.create({ name, url, token, browser });
+		res.status(201).json({ runner });
+	} catch (e) {
+		res.status(500).json({ error: 'Failed to create runner' });
+	}
+});
+
+router.put('/:id', async (req, res) => {
+	try {
+		const { name, url, token, browser } = req.body;
+		const runner = await runnerService.update(req.params.id, { name, url, token, browser });
+		res.json({ runner });
+	} catch (e) {
+		res.status(500).json({ error: 'Failed to update runner' });
+	}
+});
+
+router.delete('/:id', async (req, res) => {
+	try {
+		await runnerService.remove(req.params.id);
+		res.json({ message: 'Runner deleted' });
+	} catch (e) {
+		res.status(500).json({ error: 'Failed to delete runner' });
+	}
+});
+
+router.post('/:id/ping', async (req, res) => {
+	try {
+		const result = await runnerService.ping(req.params.id);
+		res.json(result);
+	} catch (e) {
+		res.status(500).json({ ok: false, error: e.message });
+	}
+});
+
+module.exports = router;

package/backend/scripts/add-local-runner.js

@@ -0,0 +1,120 @@
+/*
+ * 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/.
+ */
+
+/**
+ * Interactively registers a local node runner with the Plum primary server,
+ * then starts the node server in the foreground.
+ *
+ * Usage:  node scripts/add-local-runner.js
+ *    or:  npm run add-local-runner     (from the backend directory)
+ */
+
+const readline = require('readline');
+const { spawn } = require('child_process');
+const path = require('path');
+
+const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+function ask(question, defaultValue) {
+	return new Promise((resolve) => {
+		const hint = defaultValue ? ` (default: ${defaultValue})` : '';
+		rl.question(`  ${question}${hint}: `, (answer) => {
+			resolve(answer.trim() || defaultValue || '');
+		});
+	});
+}
+
+async function main() {
+	console.log('\nRegister a local node runner with the Plum server');
+	console.log('─'.repeat(51));
+	console.log('The runner URL will use host.docker.internal so that');
+	console.log('the Plum Docker container can reach your host machine.\n');
+
+	const name = await ask('Runner name', 'local-node');
+	const token = await ask('Node auth token (NODE_TOKEN)', process.env.NODE_TOKEN || 'test123');
+	const port = await ask('Port the node will run on', '3002');
+	const browser = await ask('Default browser (chromium/firefox/webkit)', 'chromium');
+	const apiUrl = await ask('Plum server API URL', 'http://localhost:3001');
+
+	rl.close();
+
+	const nodeUrl = `http://host.docker.internal:${port}`;
+	console.log(`\nRegistering "${name}" at ${nodeUrl} via ${apiUrl}...`);
+
+	let res;
+	try {
+		res = await fetch(`${apiUrl}/runners`, {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/json' },
+			body: JSON.stringify({ name, url: nodeUrl, token, browser })
+		});
+	} catch (e) {
+		console.error(`\n✗ Could not reach Plum server at ${apiUrl}`);
+		console.error(`  ${e.message}`);
+		console.error('\nMake sure the Docker stack is running:');
+		console.error('  docker compose up -d');
+		process.exit(1);
+	}
+
+	const body = await res.json().catch(() => ({}));
+
+	if (!res.ok) {
+		console.error(`\n✗ Server returned HTTP ${res.status}`);
+		if (body.error) console.error(`  ${body.error}`);
+		process.exit(1);
+	}
+
+	if (body.error) {
+		console.error('\n✗ Error:', body.error);
+		process.exit(1);
+	}
+
+	const runner = body.runner;
+	console.log(`\n✓ Runner "${runner.name}" registered (id: ${runner.id})`);
+	console.log(`  URL:     ${runner.url}`);
+	console.log(`  Token:   ${runner.token}`);
+	console.log(`  Browser: ${runner.browser}`);
+	console.log('\nStarting node server… (Ctrl+C to stop)\n');
+
+	// Start the node server in the foreground — the script stays alive until the user kills it
+	const serverPath = path.resolve(__dirname, '..', 'server.js');
+	const child = spawn(process.execPath, [serverPath], {
+		env: {
+			...process.env,
+			NODE_TOKEN: token,
+			PLUM_MODE: 'node',
+			PORT: port
+		},
+		stdio: 'inherit',
+		cwd: path.resolve(__dirname, '..')
+	});
+
+	child.on('error', (e) => {
+		console.error('✗ Failed to start node server:', e.message);
+		process.exit(1);
+	});
+
+	child.on('close', (code) => {
+		process.exit(code ?? 0);
+	});
+}
+
+main().catch((e) => {
+	rl.close();
+	console.error('\n✗', e.message);
+	process.exit(1);
+});

package/backend/scripts/create-test.js

@@ -0,0 +1,148 @@
+/*
+ * 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/.
+ */
+
+/**
+ * Scaffolds a new feature file, page object, and step definition from templates.
+ *
+ * Usage:  node scripts/create-test.js
+ *    or:  npm run create-test     (from the backend directory)
+ */
+
+const readline = require('readline');
+const fs = require('fs');
+const path = require('path');
+
+const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+function ask(question, defaultValue) {
+	return new Promise((resolve) => {
+		const hint = defaultValue ? ` (default: ${defaultValue})` : '';
+		rl.question(`  ${question}${hint}: `, (answer) => {
+			resolve(answer.trim() || defaultValue || '');
+		});
+	});
+}
+
+function toPascalCase(str) {
+	return str
+		.replace(/[-_\s]+(.)/g, (_, c) => c.toUpperCase())
+		.replace(/^(.)/, (c) => c.toUpperCase());
+}
+
+function toKebabCase(str) {
+	return str
+		.replace(/([A-Z])/g, (c) => `-${c.toLowerCase()}`)
+		.replace(/[-_\s]+/g, '-')
+		.replace(/^-/, '');
+}
+
+async function main() {
+	const testsRoot = process.env.TESTS_ROOT || path.resolve(__dirname, '..', 'tests');
+
+	console.log('\nScaffold a new test');
+	console.log('─'.repeat(40));
+
+	const rawName = await ask('Feature name (e.g. "Cart", "Checkout")', '');
+	if (!rawName) {
+		console.error('\n✗ Feature name is required.\n');
+		rl.close();
+		process.exit(1);
+	}
+
+	const pascal = toPascalCase(rawName);
+	const kebab = toKebabCase(pascal);
+	const suiteTag = `@suite-${kebab}`;
+	const testTag = `@test-${kebab}-1`;
+
+	const featurePath = path.join(testsRoot, 'features', `${pascal}.feature`);
+	const pagePath = path.join(testsRoot, 'pages', `${pascal}Page.ts`);
+	const stepsPath = path.join(testsRoot, 'step_definitions', `${pascal}Steps.ts`);
+
+	const conflicts = [featurePath, pagePath, stepsPath].filter(fs.existsSync);
+	if (conflicts.length > 0) {
+		console.error('\n✗ The following files already exist:');
+		conflicts.forEach((f) => console.error(`  ${f}`));
+		console.error('\nDelete them first or choose a different name.\n');
+		rl.close();
+		process.exit(1);
+	}
+
+	rl.close();
+
+	const feature = `${suiteTag}
+Feature: ${pascal}
+
+  ${testTag}
+  Scenario: Example scenario
+    Given I am on the ${pascal} page
+    When I perform an action
+    Then I should see the expected result
+`;
+
+	const page = `import { page } from '../utils/browser';
+
+export class ${pascal}Page {
+  static async goTo() {
+    await page().goto(process.env.BASE_URL as string);
+  }
+
+  static async performAction() {
+    // TODO: implement
+  }
+
+  static async verifyResult() {
+    // TODO: implement
+  }
+}
+`;
+
+	const steps = `import { Given, When, Then } from '@cucumber/cucumber';
+import { ${pascal}Page } from '../pages/${pascal}Page';
+
+Given('I am on the ${pascal} page', async () => {
+  await ${pascal}Page.goTo();
+});
+
+When('I perform an action', async () => {
+  await ${pascal}Page.performAction();
+});
+
+Then('I should see the expected result', async () => {
+  await ${pascal}Page.verifyResult();
+});
+`;
+
+	fs.mkdirSync(path.join(testsRoot, 'features'), { recursive: true });
+	fs.mkdirSync(path.join(testsRoot, 'pages'), { recursive: true });
+	fs.mkdirSync(path.join(testsRoot, 'step_definitions'), { recursive: true });
+
+	fs.writeFileSync(featurePath, feature, 'utf8');
+	fs.writeFileSync(pagePath, page, 'utf8');
+	fs.writeFileSync(stepsPath, steps, 'utf8');
+
+	console.log('\n✅ Test scaffold created:');
+	console.log(`   ${featurePath}`);
+	console.log(`   ${pagePath}`);
+	console.log(`   ${stepsPath}`);
+	console.log(`\nRun with:  npm test -- ${testTag}\n`);
+}
+
+main().catch((e) => {
+	rl.close();
+	console.error('\n✗', e.message);
+	process.exit(1);
+});

package/backend/server.js

@@ -29,19 +29,28 @@ const fs = require('fs');
 const testsDir = path.resolve(process.cwd(), 'tests');
 
 if (!fs.existsSync(testsDir)) {
-	console.error('❌ No tests folder found at /app/tests');
-	process.exit(1);
+	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);
 }
 
-console.log('📂 Loading tests from:', testsDir);
+const isNodeMode = process.env.PLUM_MODE === 'node';
+const port = parseInt(process.env.PORT || '3001', 10);
 
 socketHandler(io);
-cronService.setSocketIO(io);
+if (!isNodeMode) cronService.setSocketIO(io);
 
 async function start() {
-	await cronService.init();
-	server.listen(3001, async () => {
-		console.log('Backend running on port 3001');
+	if (!isNodeMode) await cronService.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
 
 		// chokidar v5+ is ESM-only — use dynamic import to stay compatible with CJS
 		let chokidar;

package/backend/services/backupService.js

@@ -18,36 +18,23 @@
 const prisma = require('./prisma');
 
 const exportAll = async () => {
-	const [cronJobs, reports, project] = await Promise.all([
+	const [cronJobs, project] = await Promise.all([
 		prisma.cronJob.findMany({ orderBy: { createdAt: 'asc' } }),
-		prisma.report.findMany({
-			orderBy: { createdAt: 'asc' },
-			include: { cronJob: { select: { taskName: true } } }
-		}),
 		prisma.project.findUnique({ where: { id: 1 } })
 	]);
 
-	// Annotate each report with the cronJob's taskName for portable restoration
-	const portableReports = reports.map(({ cronJob, cronJobId, ...r }) => ({
-		...r,
-		cronJobTaskName: cronJob?.taskName ?? null
-	}));
-
 	return {
 		version: '1',
 		exportedAt: new Date().toISOString(),
 		cronJobs: cronJobs.map(({ id, createdAt, updatedAt, reports: _, ...r }) => r),
-		reports: portableReports.map(({ id, createdAt, ...r }) => r),
 		project: project ? { name: project.name, logoUrl: project.logoUrl } : null
 	};
 };
 
-const importAll = async ({ cronJobs = [], reports = [], project = null }, cronService) => {
+const importAll = async ({ cronJobs = [], project = null }, cronService) => {
 	await prisma.$transaction(async (tx) => {
-		// Upsert cron jobs and build taskName → id map
-		const taskNameToId = {};
 		for (const job of cronJobs) {
-			const upserted = await tx.cronJob.upsert({
+			await tx.cronJob.upsert({
 				where: { taskName: job.taskName },
 				create: {
 					taskName: job.taskName,
@@ -57,21 +44,8 @@ const importAll = async ({ cronJobs = [], reports = [], project = null }, cronSe
 				},
 				update: { cronExpression: job.cronExpression, tags: job.tags, workers: job.workers ?? 1 }
 			});
-			taskNameToId[job.taskName] = upserted.id;
-		}
-
-		// Upsert reports, resolving cronJobId from the taskName map
-		for (const report of reports) {
-			const { cronJobTaskName, ...data } = report;
-			const cronJobId = cronJobTaskName ? (taskNameToId[cronJobTaskName] ?? null) : null;
-			await tx.report.upsert({
-				where: { fileName: data.fileName },
-				create: { ...data, cronJobId },
-				update: { ...data, cronJobId }
-			});
 		}
 
-		// Restore project settings
 		if (project) {
 			await tx.project.upsert({
 				where: { id: 1 },
@@ -81,7 +55,6 @@ const importAll = async ({ cronJobs = [], reports = [], project = null }, cronSe
 		}
 	});
 
-	// Re-schedule cron jobs after import
 	if (cronService) await cronService.reload();
 };