plum-e2e 2.2.0 → 2.4.0

package/backend/services/backupService.js

@@ -17,45 +17,272 @@
 
 const prisma = require('./prisma');
 
+// ---------------------------------------------------------------------------
+// Export — all data except reports (reports are too large; use pg_dump instead)
+// ---------------------------------------------------------------------------
+
 const exportAll = async () => {
-	const [cronJobs, project] = await Promise.all([
+	const [cronJobs, project, testSuites, testRuns, users, runners] = await Promise.all([
 		prisma.cronJob.findMany({ orderBy: { createdAt: 'asc' } }),
-		prisma.project.findUnique({ where: { id: 1 } })
+		prisma.project.findUnique({ where: { id: 1 } }),
+		prisma.testSuite.findMany({
+			orderBy: { createdAt: 'asc' },
+			include: {
+				cases: {
+					include: { steps: { orderBy: { order: 'asc' } } },
+					orderBy: { createdAt: 'asc' }
+				}
+			}
+		}),
+		prisma.testRun.findMany({
+			orderBy: { createdAt: 'asc' },
+			include: { entries: { orderBy: { order: 'asc' } } }
+		}),
+		prisma.user.findMany({ orderBy: { createdAt: 'asc' } }),
+		prisma.runner.findMany({ orderBy: { createdAt: 'asc' } })
 	]);
 
 	return {
-		version: '1',
+		version: '2',
 		exportedAt: new Date().toISOString(),
-		cronJobs: cronJobs.map(({ id, createdAt, updatedAt, reports: _, ...r }) => r),
-		project: project ? { name: project.name, logoUrl: project.logoUrl } : null
+		disclaimer:
+			'Reports are not included in this backup. Use pg_dump on the PostgreSQL volume to back up report history.',
+		cronJobs: cronJobs.map(({ id, createdAt, updatedAt, reports: _, runnerId: __, ...r }) => r),
+		project: project
+			? {
+					name: project.name,
+					logoUrl: project.logoUrl,
+					testCasePrefix: project.testCasePrefix,
+					testSuitePrefix: project.testSuitePrefix,
+					discordWebhookUrl: project.discordWebhookUrl,
+					slackWebhookUrl: project.slackWebhookUrl,
+					notifyPublicUrl: project.notifyPublicUrl
+				}
+			: null,
+		users: users.map(({ updatedAt: _, ...u }) => u),
+		runners: runners.map(({ createdAt: _, cronJobs: __, reports: ___, ...r }) => r),
+		testSuites: testSuites.map(({ cases, ...suite }) => ({
+			...suite,
+			cases: cases.map(({ steps, runEntries: _, history: __, ...tc }) => ({
+				...tc,
+				steps: steps.map(({ createdAt: ___, ...step }) => step)
+			}))
+		})),
+		testRuns: testRuns.map(({ entries, history: _, ...run }) => ({
+			...run,
+			entries: entries.map(({ executedAt, ...entry }) => ({ ...entry, executedAt }))
+		}))
 	};
 };
 
-const importAll = async ({ cronJobs = [], project = null }, cronService) => {
-	await prisma.$transaction(async (tx) => {
-		for (const job of cronJobs) {
-			await tx.cronJob.upsert({
-				where: { taskName: job.taskName },
-				create: {
-					taskName: job.taskName,
-					cronExpression: job.cronExpression,
-					tags: job.tags,
-					workers: job.workers ?? 1
-				},
-				update: { cronExpression: job.cronExpression, tags: job.tags, workers: job.workers ?? 1 }
-			});
+// ---------------------------------------------------------------------------
+// Import — upsert all exported data, preserve IDs for relational integrity
+// ---------------------------------------------------------------------------
+
+const importAll = async (
+	{ cronJobs = [], project = null, users = [], runners = [], testSuites = [], testRuns = [] },
+	cronService
+) => {
+	await prisma.$transaction(
+		async (tx) => {
+			// 1. Users (needed before suites/runs reference createdById)
+			for (const user of users) {
+				await tx.user.upsert({
+					where: { email: user.email },
+					create: user,
+					update: { name: user.name, role: user.role }
+				});
+			}
+
+			// 2. Runners
+			for (const runner of runners) {
+				await tx.runner.upsert({
+					where: { id: runner.id },
+					create: runner,
+					update: {
+						name: runner.name,
+						url: runner.url,
+						token: runner.token,
+						browser: runner.browser
+					}
+				});
+			}
+
+			// 3. CronJobs
+			for (const job of cronJobs) {
+				await tx.cronJob.upsert({
+					where: { taskName: job.taskName },
+					create: {
+						taskName: job.taskName,
+						cronExpression: job.cronExpression,
+						tags: job.tags,
+						workers: job.workers ?? 1,
+						browser: job.browser ?? 'chromium',
+						enabled: job.enabled ?? true,
+						runnerIds: job.runnerIds ?? 'built-in',
+						notifyDiscord: job.notifyDiscord ?? false,
+						notifySlack: job.notifySlack ?? false
+					},
+					update: {
+						cronExpression: job.cronExpression,
+						tags: job.tags,
+						workers: job.workers ?? 1,
+						browser: job.browser ?? 'chromium',
+						runnerIds: job.runnerIds ?? 'built-in',
+						notifyDiscord: job.notifyDiscord ?? false,
+						notifySlack: job.notifySlack ?? false
+					}
+				});
+			}
+
+			// 4. Project settings
+			if (project) {
+				await tx.project.upsert({
+					where: { id: 1 },
+					create: { id: 1, ...project },
+					update: project
+				});
+			}
+
+			// 5. Test suites + cases + steps
+			for (const suite of testSuites) {
+				const { cases = [], ...suiteData } = suite;
+				await tx.testSuite.upsert({
+					where: { displayId: suiteData.displayId },
+					create: suiteData,
+					update: {
+						name: suiteData.name,
+						description: suiteData.description,
+						priority: suiteData.priority
+					}
+				});
+
+				for (const tc of cases) {
+					const { steps = [], ...caseData } = tc;
+					await tx.testCase.upsert({
+						where: { displayId: caseData.displayId },
+						create: caseData,
+						update: {
+							title: caseData.title,
+							description: caseData.description,
+							priority: caseData.priority,
+							isAutomated: caseData.isAutomated
+						}
+					});
+
+					// Replace all steps for this case (order may have changed)
+					await tx.testStep.deleteMany({ where: { caseId: caseData.id } });
+					for (const step of steps) {
+						await tx.testStep.create({ data: step });
+					}
+				}
+			}
+
+			// 6. Test runs + entries
+			for (const run of testRuns) {
+				const { entries = [], ...runData } = run;
+				await tx.testRun.upsert({
+					where: { id: runData.id },
+					create: runData,
+					update: { title: runData.title, status: runData.status }
+				});
+
+				for (const entry of entries) {
+					await tx.testRunEntry.upsert({
+						where: { id: entry.id },
+						create: entry,
+						update: { status: entry.status, notes: entry.notes, order: entry.order }
+					});
+				}
+			}
+		},
+		{ timeout: 30000 }
+	);
+
+	if (cronService) await cronService.reload();
+};
+
+// ---------------------------------------------------------------------------
+// S3 upload — S3-compatible object storage (AWS, R2, B2, MinIO)
+// ---------------------------------------------------------------------------
+
+const uploadToS3 = async (jsonData, config) => {
+	const { S3Client, PutObjectCommand } = await import('@aws-sdk/client-s3');
+
+	const {
+		backupS3Endpoint,
+		backupS3Region,
+		backupS3Bucket,
+		backupS3AccessKey,
+		backupS3SecretKey,
+		backupS3Prefix
+	} = config;
+
+	const clientConfig = {
+		region: backupS3Region || 'auto',
+		credentials: {
+			accessKeyId: backupS3AccessKey,
+			secretAccessKey: backupS3SecretKey
 		}
+	};
+	if (backupS3Endpoint) clientConfig.endpoint = backupS3Endpoint;
+
+	const client = new S3Client(clientConfig);
+
+	const date = new Date().toISOString().slice(0, 10);
+	const prefix = backupS3Prefix ? backupS3Prefix.replace(/\/?$/, '/') : '';
+	const key = `${prefix}plum-backup-${date}.json`;
+
+	await client.send(
+		new PutObjectCommand({
+			Bucket: backupS3Bucket,
+			Key: key,
+			Body: JSON.stringify(jsonData, null, 2),
+			ContentType: 'application/json'
+		})
+	);
+
+	return key;
+};
+
+const testS3Connection = async (config) => {
+	const { S3Client, PutObjectCommand, DeleteObjectCommand } = await import('@aws-sdk/client-s3');
 
-		if (project) {
-			await tx.project.upsert({
-				where: { id: 1 },
-				create: { id: 1, name: project.name ?? '', logoUrl: project.logoUrl ?? '' },
-				update: { name: project.name ?? '', logoUrl: project.logoUrl ?? '' }
-			});
+	const {
+		backupS3Endpoint,
+		backupS3Region,
+		backupS3Bucket,
+		backupS3AccessKey,
+		backupS3SecretKey,
+		backupS3Prefix
+	} = config;
+
+	const clientConfig = {
+		region: backupS3Region || 'auto',
+		credentials: {
+			accessKeyId: backupS3AccessKey,
+			secretAccessKey: backupS3SecretKey
 		}
-	});
+	};
+	if (backupS3Endpoint) clientConfig.endpoint = backupS3Endpoint;
 
-	if (cronService) await cronService.reload();
+	const client = new S3Client(clientConfig);
+	const prefix = backupS3Prefix ? backupS3Prefix.replace(/\/?$/, '/') : '';
+	const key = `${prefix}.plum-connection-test`;
+
+	await client.send(
+		new PutObjectCommand({
+			Bucket: backupS3Bucket,
+			Key: key,
+			Body: 'ok',
+			ContentType: 'text/plain'
+		})
+	);
+
+	// Clean up the test file
+	try {
+		await client.send(new DeleteObjectCommand({ Bucket: backupS3Bucket, Key: key }));
+	} catch {}
 };
 
-module.exports = { exportAll, importAll };
+module.exports = { exportAll, importAll, uploadToS3, testS3Connection };

package/backend/services/settingsService.js

@@ -15,6 +15,7 @@
  * along with Plum. If not, see https://www.gnu.org/licenses/.
  */
 
+const crypto = require('crypto');
 const prisma = require('./prisma');
 
 const getProject = async () => {
@@ -70,11 +71,74 @@ const updateWebhooks = async ({ discordWebhookUrl, slackWebhookUrl, notifyPublic
 	});
 };
 
+const getBackupConfig = async () => {
+	const project = await getProject();
+	return {
+		backupEnabled: project.backupEnabled,
+		backupCron: project.backupCron,
+		backupS3Endpoint: project.backupS3Endpoint,
+		backupS3Region: project.backupS3Region,
+		backupS3Bucket: project.backupS3Bucket,
+		backupS3AccessKey: project.backupS3AccessKey,
+		backupS3SecretKeySet: project.backupS3SecretKey.length > 0,
+		backupS3Prefix: project.backupS3Prefix,
+		backupLastRunAt: project.backupLastRunAt,
+		backupLastStatus: project.backupLastStatus
+	};
+};
+
+const updateBackupConfig = async ({
+	backupEnabled,
+	backupCron,
+	backupS3Endpoint,
+	backupS3Region,
+	backupS3Bucket,
+	backupS3AccessKey,
+	backupS3SecretKey,
+	backupS3Prefix
+}) => {
+	const update = {
+		...(backupEnabled !== undefined && { backupEnabled }),
+		...(backupCron !== undefined && { backupCron }),
+		...(backupS3Endpoint !== undefined && { backupS3Endpoint }),
+		...(backupS3Region !== undefined && { backupS3Region }),
+		...(backupS3Bucket !== undefined && { backupS3Bucket }),
+		...(backupS3AccessKey !== undefined && { backupS3AccessKey }),
+		...(backupS3SecretKey && { backupS3SecretKey }),
+		...(backupS3Prefix !== undefined && { backupS3Prefix })
+	};
+	return prisma.project.upsert({
+		where: { id: 1 },
+		create: { id: 1, ...update },
+		update
+	});
+};
+
+const getMcpConfig = async () => {
+	const project = await getProject();
+	return { mcpKeySet: project.mcpKey.length > 0, mcpKey: project.mcpKey };
+};
+
+const generateMcpKey = async () => {
+	const key = crypto.randomBytes(32).toString('hex');
+	await prisma.project.upsert({
+		where: { id: 1 },
+		create: { id: 1, mcpKey: key },
+		update: { mcpKey: key }
+	});
+	process.env.PLUM_MCP_KEY = key;
+	return { mcpKey: key };
+};
+
 module.exports = {
 	getProject,
 	updateProject,
 	getTestPrefixes,
 	updateTestPrefixes,
 	getWebhooks,
-	updateWebhooks
+	updateWebhooks,
+	getBackupConfig,
+	updateBackupConfig,
+	getMcpConfig,
+	generateMcpKey
 };

package/bin/plum.js

@@ -186,36 +186,18 @@ async function configureServer({ force }) {
 	const cfg = loadServerConfig(cwd);
 
 	const overrides = {
-		baseUrl: getFlag(args, '--base-url'),
 		headless: getFlag(args, '--headless'),
 		backendPort: getFlag(args, '--backend-port'),
-		frontendPort: getFlag(args, '--frontend-port'),
-		primaryPublicUrl: getFlag(args, '--primary-url')
+		frontendPort: getFlag(args, '--frontend-port')
 	};
-	if (overrides.baseUrl !== undefined) cfg.baseUrl = overrides.baseUrl;
 	if (overrides.headless !== undefined) cfg.headless = overrides.headless === 'true';
 	if (overrides.backendPort !== undefined) cfg.backendPort = overrides.backendPort;
 	if (overrides.frontendPort !== undefined) cfg.frontendPort = overrides.frontendPort;
-	if (overrides.primaryPublicUrl !== undefined) cfg.primaryPublicUrl = overrides.primaryPublicUrl;
 
-	const hasFlags = anyFlags(args, [
-		'--base-url',
-		'--headless',
-		'--backend-port',
-		'--frontend-port',
-		'--primary-url'
-	]);
+	const hasFlags = anyFlags(args, ['--headless', '--backend-port', '--frontend-port']);
 	const interactive = force || (interactiveAllowed() && !hasFlags);
 
 	if (interactive) {
-		const baseUrl = await clack.text({
-			message: 'App URL to test (BASE_URL)',
-			placeholder: cfg.baseUrl,
-			defaultValue: cfg.baseUrl
-		});
-		if (clack.isCancel(baseUrl)) cancelAndExit();
-		cfg.baseUrl = baseUrl || cfg.baseUrl;
-
 		const headless = await clack.confirm({
 			message: 'Run browsers headless?',
 			initialValue: cfg.headless
@@ -238,14 +220,6 @@ async function configureServer({ force }) {
 		});
 		if (clack.isCancel(frontendPort)) cancelAndExit();
 		cfg.frontendPort = frontendPort || cfg.frontendPort;
-
-		const primaryPublicUrl = await clack.text({
-			message: 'Primary public URL (share with node operators)',
-			placeholder: cfg.primaryPublicUrl,
-			defaultValue: cfg.primaryPublicUrl
-		});
-		if (clack.isCancel(primaryPublicUrl)) cancelAndExit();
-		cfg.primaryPublicUrl = primaryPublicUrl || cfg.primaryPublicUrl;
 	}
 
 	saveServerConfig(cwd, cfg);
@@ -277,8 +251,7 @@ async function serverStart() {
 	clack.intro(pc.bgMagenta(pc.white('  🟣 Plum — Server  ')));
 	const cfg = await configureServer({ force: false });
 	applyServerConfig(cfg);
-	clack.log.info(`UI:                    ${pc.cyan(`http://localhost:${cfg.frontendPort}`)}`);
-	clack.log.info(`Nodes register against: ${pc.dim(cfg.primaryPublicUrl)}`);
+	clack.log.info(`UI: ${pc.cyan(`http://localhost:${cfg.frontendPort}`)}`);
 
 	execSync('docker compose up --build -d', { cwd: plumRoot, stdio: 'inherit' });
 
@@ -355,9 +328,7 @@ async function serverReconfig() {
 	const cfg = await configureServer({ force: true });
 	applyServerConfig(cfg);
 	clack.log.success("Saved. Run 'plum server start' to apply.");
-	clack.outro(
-		`UI: ${pc.cyan(`http://localhost:${cfg.frontendPort}`)} · Nodes: ${pc.dim(cfg.primaryPublicUrl)}`
-	);
+	clack.outro(`UI: ${pc.cyan(`http://localhost:${cfg.frontendPort}`)}`);
 }
 
 /* -----------------------------------------------------
@@ -413,22 +384,6 @@ async function configureNode({ force }) {
 		});
 		if (clack.isCancel(urlVal)) cancelAndExit();
 		url = urlVal || defaultUrl;
-
-		const nameVal = await clack.text({
-			message: 'Runner name',
-			placeholder: name,
-			defaultValue: name
-		});
-		if (clack.isCancel(nameVal)) cancelAndExit();
-		name = nameVal || name;
-
-		const tokenVal = await clack.text({
-			message: 'Auth token (Enter to keep)',
-			placeholder: token,
-			defaultValue: token
-		});
-		if (clack.isCancel(tokenVal)) cancelAndExit();
-		token = tokenVal || token;
 	}
 
 	if (!url) url = `http://${detectLanIp()}:${port}`;
@@ -980,16 +935,27 @@ switch (command) {
 		break;
 	}
 
+	case 'mcp': {
+		const mcpScript = path.join(plumRoot, 'backend', 'mcp', 'server.js');
+		spawn(process.execPath, [mcpScript], {
+			stdio: 'inherit',
+			env: {
+				...process.env,
+				PLUM_API_URL: process.env.PLUM_API_URL || 'http://localhost:3001',
+				PLUM_API_KEY: process.env.PLUM_API_KEY || ''
+			}
+		});
+		break;
+	}
+
 	default:
 		console.log('--------------------------------------\n');
 		console.log('Usage: plum <command>\n');
 		console.log('  init                 Set up a new Plum project');
 		console.log('  server start         Start the full UI stack (interactive; alias: plum start)');
-		console.log('    --base-url <url>   App URL to test (skips the prompt)');
 		console.log('    --headless <bool>  Run browsers headless (true/false)');
 		console.log('    --backend-port <n> Host port for the backend/API (default: 3001)');
 		console.log('    --frontend-port <n> Host port for the UI (default: 5173)');
-		console.log('    --primary-url <url> Public URL node operators point --primary at');
 		console.log('  server reconfig      Re-enter server settings without starting');
 		console.log('  server stop          Stop the server  (alias: plum stop)');
 		console.log('  node start           Start a runner node (interactive), then open runner menu');
@@ -1014,5 +980,6 @@ switch (command) {
 		console.log('    --browser <name>   chromium | firefox (default: chromium)');
 		console.log('  create-step          Interactively scaffold a new step definition');
 		console.log('  create-test          Scaffold a new .feature + Page.ts + Steps.ts');
+		console.log('  mcp                  Start the Plum MCP server (stdio) for Claude integration');
 		console.log('\n--------------------------------------\n');
 }

package/frontend/src/lib/api/settings.js

@@ -16,6 +16,11 @@
  */
 
 import { API_BASE } from '$lib/constants';
+import { auth } from '$lib/stores/auth';
+
+function authHeaders() {
+	return { Authorization: `Bearer ${auth.getToken()}` };
+}
 
 export async function fetchProject() {
 	const res = await fetch(`${API_BASE}/settings/project`);
@@ -47,6 +52,47 @@ export async function importBackup(data) {
 	return res.json();
 }
 
+export async function fetchBackupConfig() {
+	const res = await fetch(`${API_BASE}/backup/config`);
+	if (!res.ok)
+		return {
+			backupEnabled: false,
+			backupCron: '0 2 * * *',
+			backupS3Endpoint: '',
+			backupS3Region: '',
+			backupS3Bucket: '',
+			backupS3AccessKey: '',
+			backupS3SecretKeySet: false,
+			backupS3Prefix: '',
+			backupLastRunAt: null,
+			backupLastStatus: ''
+		};
+	return res.json();
+}
+
+export async function saveBackupConfig(config) {
+	const res = await fetch(`${API_BASE}/backup/config`, {
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		body: JSON.stringify(config)
+	});
+	return res.json();
+}
+
+export async function testBackupS3(config) {
+	const res = await fetch(`${API_BASE}/backup/test-s3`, {
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		body: JSON.stringify(config)
+	});
+	return res.json();
+}
+
+export async function runBackupNow() {
+	const res = await fetch(`${API_BASE}/backup/run-now`, { method: 'POST' });
+	return res.json();
+}
+
 export async function fetchIntegrations() {
 	const res = await fetch(`${API_BASE}/settings/integrations`);
 	if (!res.ok) return { discordWebhookUrl: '', slackWebhookUrl: '', notifyPublicUrl: '' };
@@ -61,3 +107,18 @@ export async function saveIntegrations({ discordWebhookUrl, slackWebhookUrl, not
 	});
 	return res.json();
 }
+
+export async function fetchMcpConfig() {
+	const res = await fetch(`${API_BASE}/settings/mcp`, { headers: authHeaders() });
+	if (!res.ok) return { mcpKeySet: false, mcpKey: '' };
+	return res.json();
+}
+
+export async function generateMcpKey() {
+	const res = await fetch(`${API_BASE}/settings/mcp/generate`, {
+		method: 'POST',
+		headers: authHeaders()
+	});
+	if (!res.ok) throw new Error('Failed to generate key');
+	return res.json();
+}

package/frontend/src/lib/components/layout/Nav.svelte

@@ -20,7 +20,6 @@
 	import { slide } from 'svelte/transition';
 	import { onMount } from 'svelte';
 	import { auth } from '$lib/stores/auth';
-	import { goto } from '$app/navigation';
 	import { fetchProject } from '$lib/api/settings';
 
 	let menuOpen = false;

package/frontend/src/routes/+layout.js

@@ -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/.
+ */
+
+// Plum is a private authenticated app — SSR adds no value and causes
+// hydration mismatches (auth state differs between server and client).
+export const ssr = false;

package/frontend/src/routes/+layout.svelte

@@ -28,30 +28,38 @@
 
 	const PUBLIC_ROUTES = ['/login', '/setup'];
 
-	let ready = true;
+	let ready = false;
 
 	onMount(async () => {
 		const pathname = $page.url.pathname;
-		if (PUBLIC_ROUTES.includes(pathname)) return;
+		if (PUBLIC_ROUTES.includes(pathname)) {
+			ready = true;
+			return;
+		}
 
 		const token = $auth.token;
-		if (!token) {
-			try {
-				const needsSetup = await checkNeedsSetup();
-				goto(needsSetup ? '/setup' : '/login');
-			} catch {
-				goto('/login');
-			}
+		if (token) {
+			ready = true;
+			return;
+		}
+
+		try {
+			const needsSetup = await checkNeedsSetup();
+			goto(needsSetup ? '/setup' : '/login');
+		} catch {
+			goto('/login');
 		}
 	});
 </script>
 
-{#if $page.url.pathname === '/login' || $page.url.pathname === '/setup'}
-	<slot />
-{:else}
-	<Nav />
-	<PageShell>
+{#if ready}
+	{#if $page.url.pathname === '/login' || $page.url.pathname === '/setup'}
 		<slot />
-	</PageShell>
-	<RunnerPanel />
+	{:else}
+		<Nav />
+		<PageShell>
+			<slot />
+		</PageShell>
+		<RunnerPanel />
+	{/if}
 {/if}