plum-e2e 2.9.17 → 2.10.0

package/backend/constants/socketEvents.js

@@ -10,18 +10,14 @@
  * in sync when adding or renaming an event.
  */
 const SOCKET_EVENTS = Object.freeze({
-	// Interactive single-run (built-in runner, one browser tab watching)
+	// Client → server: request a run / cancel a run by id
 	RUN_TEST: 'run-test',
 	CANCEL_TEST: 'cancel-test',
-	LOG: 'log',
-	DONE: 'done',
 
-	// Multi-lane distributed run (single interactive run, several runners)
-	RUNNER_LANES_INIT: 'runner-lanes-init',
-	RUNNER_LANE_LOG: 'runner-lane-log',
-	RUNNER_LANE_STATUS: 'runner-lane-status',
-
-	// Background runs (cron / REST / MCP triggered, no single owning socket)
+	// Server → every client: one run's lifecycle, keyed by runId. Every run
+	// (manual, cron, REST, MCP) flows through the queue and streams over these —
+	// there is no separate "interactive" socket path.
+	BG_RUN_QUEUED: 'bg-run-queued',
 	BG_RUN_START: 'bg-run-start',
 	BG_RUN_LOG: 'bg-run-log',
 	BG_RUN_DONE: 'bg-run-done',
@@ -29,11 +25,9 @@ const SOCKET_EVENTS = Object.freeze({
 	BG_RUN_LANE_LOG: 'bg-run-lane-log',
 	BG_RUN_LANE_STATUS: 'bg-run-lane-status',
 
-	// Live rrweb streaming — one shape for every run type, always
-	// carrying a lane id (BUILT_IN_RUNNER_ID for the plain single-run case) and
-	// a workerId, so a single built-in run with --parallel workers is finally
-	// attributable per worker instead of one flat interleaved stream.
-	RUNNER_LANE_RRWEB_BATCH: 'runner-lane-rrweb-batch',
+	// Live rrweb streaming — always carries a lane id (BUILT_IN_RUNNER_ID for the
+	// plain single-runner case) and a workerId, so a run with --parallel workers
+	// is attributable per worker instead of one flat interleaved stream.
 	BG_RUN_LANE_RRWEB_BATCH: 'bg-run-lane-rrweb-batch',
 
 	// Global notifications (any client, not tied to a specific run)

package/backend/lib/serverBootstrap.js

@@ -40,17 +40,17 @@ function attachListenRetry(server, port) {
 }
 
 function wireRealtimeServices(io, isNodeMode) {
-	if (isNodeMode) return { cronService: null, backupCronService: null };
+	if (isNodeMode) return { cronService: null, backupCronService: null, runQueueService: null };
 
 	const socketHandler = require('../websockets/socketHandler.js');
 	const cronService = require('../services/cronService');
 	const backupCronService = require('../services/backupCronService');
+	const runQueueService = require('../services/runQueueService');
 
 	socketHandler(io);
-	cronService.setSocketIO(io);
-	require('../routes/trigger.routes').setSocketIO(io);
+	runQueueService.setSocketIO(io);
 
-	return { cronService, backupCronService };
+	return { cronService, backupCronService, runQueueService };
 }
 
 async function initCronServices(cronService, backupCronService) {

package/backend/mcp/server.js

@@ -41,8 +41,8 @@ async function pollJob(jobId, { maxMs = 600_000, intervalMs = 5_000 } = {}) {
 	const deadline = Date.now() + maxMs;
 	while (Date.now() < deadline) {
 		await new Promise((r) => setTimeout(r, intervalMs));
-		const job = triggerService.getJob(jobId);
-		if (job.status !== JOB_STATUS.RUNNING) return job;
+		const job = await triggerService.getJob(jobId);
+		if (job && job.status !== JOB_STATUS.RUNNING) return job;
 	}
 	return { status: 'timeout', jobId };
 }
@@ -379,7 +379,7 @@ function createMcpServer({ userId }) {
 			jobId: z.string().uuid().describe('Job ID returned by run_tests')
 		},
 		async ({ jobId }) => {
-			const job = triggerService.getJob(jobId);
+			const job = await triggerService.getJob(jobId);
 			if (!job) throw new Error('Job not found');
 			return { content: [{ type: 'text', text: JSON.stringify(job, null, 2) }] };
 		}

package/backend/prisma/migrations/20260829000000_add_run_queue/migration.sql

@@ -0,0 +1,29 @@
+-- CreateTable
+CREATE TABLE "RunQueue" (
+    "id" TEXT NOT NULL,
+    "kind" TEXT NOT NULL,
+    "triggerType" TEXT NOT NULL DEFAULT 'manual-trigger',
+    "label" TEXT NOT NULL DEFAULT '',
+    "status" TEXT NOT NULL DEFAULT 'queued',
+    "tag" TEXT NOT NULL DEFAULT '',
+    "workers" INTEGER NOT NULL DEFAULT 1,
+    "browser" TEXT NOT NULL DEFAULT 'chromium',
+    "runnerIds" TEXT NOT NULL DEFAULT 'built-in',
+    "testRunId" TEXT,
+    "baseUrl" TEXT,
+    "runTitle" TEXT,
+    "startedBy" TEXT,
+    "notifyDiscord" BOOLEAN NOT NULL DEFAULT false,
+    "notifySlack" BOOLEAN NOT NULL DEFAULT false,
+    "reportId" INTEGER,
+    "exitCode" INTEGER,
+    "note" TEXT,
+    "queuedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "startedAt" TIMESTAMP(3),
+    "finishedAt" TIMESTAMP(3),
+
+    CONSTRAINT "RunQueue_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "RunQueue_status_queuedAt_idx" ON "RunQueue"("status", "queuedAt");

package/backend/prisma/schema.prisma

@@ -219,6 +219,36 @@ model TestRunEntry {
   @@index([caseId])
 }
 
+// One row per run request (manual, cron, external, mcp). A run stays `queued`
+// until every runner it targets is free, then flips to `running`, then `done`.
+// DB-backed so the queue survives a restart — stale `running` rows are
+// reconciled to `done` on boot and queued rows resume.
+model RunQueue {
+  id            String    @id
+  kind          String
+  triggerType   String    @default("manual-trigger")
+  label         String    @default("")
+  status        String    @default("queued")
+  tag           String    @default("")
+  workers       Int       @default(1)
+  browser       String    @default("chromium")
+  runnerIds     String    @default("built-in")
+  testRunId     String?
+  baseUrl       String?
+  runTitle      String?
+  startedBy     String?
+  notifyDiscord Boolean   @default(false)
+  notifySlack   Boolean   @default(false)
+  reportId      Int?
+  exitCode      Int?
+  note          String?
+  queuedAt      DateTime  @default(now())
+  startedAt     DateTime?
+  finishedAt    DateTime?
+
+  @@index([status, queuedAt])
+}
+
 model TestCaseHistory {
   id           String   @id @default(cuid())
   caseId       String

package/backend/routes/active-runs.routes.js

@@ -5,14 +5,18 @@
 
 const express = require('express');
 const router = express.Router();
-const activeRunsService = require('../services/activeRunsService');
+const runQueueService = require('../services/runQueueService');
 const { jwtAuth } = require('../middleware/jwtAuth');
 
-// Runs carry a real user's display name (`startedBy`) — gate this the same way as
-// other identity-bearing routes (test-suites, test-runs, users), not left open like
-// the purely operational GET routes (reports, tests) that never touch user identity.
-router.get('/', jwtAuth, (req, res) => {
-	res.json({ runs: activeRunsService.listActiveRuns() });
+// Queued + running rows carry a real user's display name (`startedBy`) — gate
+// this the same way as other identity-bearing routes, not left open like the
+// purely operational GET routes.
+router.get('/', jwtAuth, async (req, res, next) => {
+	try {
+		res.json({ runs: await runQueueService.listActive() });
+	} catch (e) {
+		next(e);
+	}
 });
 
 module.exports = router;

package/backend/routes/node.routes.js

@@ -49,6 +49,13 @@ router.post('/execute', authGuard, (req, res) => {
 	res.json({ jobId, status: 'started' });
 });
 
+// Stop a running job (primary server relays a user's cancel)
+router.post('/cancel/:jobId', authGuard, (req, res) => {
+	const ok = nodeExecutionService.cancelJob(req.params.jobId);
+	if (!ok) return res.status(404).json({ error: 'Job not found' });
+	res.json({ ok: true });
+});
+
 // Fetch the final report content after a job completes
 router.get('/report/:jobId', authGuard, (req, res) => {
 	const job = nodeExecutionService.getJob(req.params.jobId);

package/backend/routes/trigger.routes.js

@@ -37,11 +37,14 @@ router.post('/', jwtAuth, async (req, res, next) => {
 	}
 });
 
-router.get('/:jobId', jwtAuth, (req, res) => {
-	const job = triggerService.getJob(req.params.jobId);
-	if (!job) return res.status(404).json({ error: 'Job not found' });
-	res.json(job);
+router.get('/:jobId', jwtAuth, async (req, res, next) => {
+	try {
+		const job = await triggerService.getJob(req.params.jobId);
+		if (!job) return res.status(404).json({ error: 'Job not found' });
+		res.json(job);
+	} catch (e) {
+		next(e);
+	}
 });
 
 module.exports = router;
-router.setSocketIO = triggerService.setSocketIO;

package/backend/server.js

@@ -41,11 +41,15 @@ async function start() {
 	attachListenRetry(server, port);
 
 	// Connect socket.io to the runner/cron services (a no-op in node mode).
-	const { cronService, backupCronService } = wireRealtimeServices(io, isNodeMode);
+	const { cronService, backupCronService, runQueueService } = wireRealtimeServices(io, isNodeMode);
 
 	// Start the scheduled test and backup cron jobs.
 	await initCronServices(cronService, backupCronService);
 
+	// Reconcile the persisted run queue: clear rows left "running" by a crash,
+	// then resume anything still queued.
+	if (runQueueService) await runQueueService.init(io);
+
 	// Load the saved MCP API key into the environment for the MCP server.
 	await bootstrapMcpKey(isNodeMode);