plum-e2e 2.3.0 → 2.4.1

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": "",
@@ -25,6 +26,7 @@
 		"@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/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

@@ -90,6 +90,7 @@ model Project {
   backupS3Prefix     String    @default("")
   backupLastRunAt    DateTime?
   backupLastStatus   String    @default("")
+  mcpKey             String    @default("")
 }
 
 model User {

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

@@ -54,6 +54,14 @@ 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) {

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 () => {
@@ -113,6 +114,22 @@ const updateBackupConfig = async ({
 	});
 };
 
+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,
@@ -121,5 +138,7 @@ module.exports = {
 	getWebhooks,
 	updateWebhooks,
 	getBackupConfig,
-	updateBackupConfig
+	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`);
@@ -102,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/lib/components/ui/Badge.svelte

@@ -16,7 +16,7 @@
  -->
 
 <script>
-	/** @type {'pass' | 'fail' | 'tag' | 'schedule' | 'neutral' | 'node'} */
+	/** @type {'pass' | 'fail' | 'tag' | 'schedule' | 'neutral' | 'node' | 'mcp'} */
 	export let variant = 'neutral';
 </script>
 
@@ -65,4 +65,9 @@
 		background: var(--node-soft);
 		color: var(--node);
 	}
+
+	.mcp {
+		background: var(--accent-soft);
+		color: var(--accent);
+	}
 </style>

package/frontend/src/lib/constants.js

@@ -24,7 +24,8 @@ export const BROWSERS = [
 
 export const TRIGGER_TYPES = Object.freeze({
 	MANUAL: 'manual-trigger',
-	CLI: 'command-line-trigger'
+	CLI: 'command-line-trigger',
+	MCP: 'mcp-trigger'
 });
 
 export const REPORTS_PER_PAGE = 15;

package/frontend/src/lib/utils/format.js

@@ -17,7 +17,12 @@
 
 import { TRIGGER_TYPES } from '$lib/constants';
 
-const NON_SCHEDULED = new Set([TRIGGER_TYPES.MANUAL, TRIGGER_TYPES.CLI, 'undefined']);
+const NON_SCHEDULED = new Set([
+	TRIGGER_TYPES.MANUAL,
+	TRIGGER_TYPES.CLI,
+	TRIGGER_TYPES.MCP,
+	'undefined'
+]);
 
 export function isScheduled(type) {
 	return !!type && !NON_SCHEDULED.has(type);
@@ -26,12 +31,14 @@ export function isScheduled(type) {
 export function triggerLabel(type) {
 	if (type === TRIGGER_TYPES.MANUAL) return 'Manual';
 	if (type === TRIGGER_TYPES.CLI || type === 'undefined') return 'CLI';
+	if (type === TRIGGER_TYPES.MCP) return 'MCP';
 	return 'Scheduled';
 }
 
 export function triggerVariant(type) {
 	if (type === TRIGGER_TYPES.MANUAL) return 'tag';
 	if (type === TRIGGER_TYPES.CLI || type === 'undefined') return 'neutral';
+	if (type === TRIGGER_TYPES.MCP) return 'mcp';
 	return 'schedule';
 }
 

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}