plum-e2e 2.9.14 → 2.10.0

package/frontend/src/lib/copy/reports.js

@@ -91,3 +91,12 @@ export const runsInProgressHeading = (count) =>
 	count === 1 ? 'A run in progress' : `${count} runs in progress`;
 export const workersCountLabel = (count) => `${count} ${pluralize(count, 'worker')}`;
 export const redirectingIn = (seconds) => `Redirecting in ${seconds}s…`;
+
+// ── Queued / not-found run ──
+export const QUEUED_HEADING = 'Waiting for a runner';
+export const QUEUED_BODY = 'This run starts as soon as every runner it needs is free.';
+export const RUN_NOT_FOUND_HEADING = 'Run not found';
+export const RUN_NOT_FOUND_BODY =
+	'This run has finished or was never started. Check the reports list for its results.';
+export const RUN_SKIPPED_HEADING = 'Run skipped';
+export const queuePositionLine = (n) => (n > 0 ? `Position ${n} in the queue` : 'Next up');

package/frontend/src/lib/copy/runners.js

@@ -28,6 +28,8 @@ export const RUN_LABEL = 'Run';
 export const MANUAL_RUN_LABEL = 'Manual run';
 export const NO_TESTS_RUNNING = 'No tests currently running';
 export const LIVE_LABEL = 'Live';
+export const QUEUED_LABEL = 'Queued';
+export const CANCEL_RUN_LABEL = 'Cancel run';
 
 export const automatedCaseCount = (count) => `${count} automated`;
 export const discordNotifyTitle = (active) =>
@@ -38,13 +40,14 @@ export const runnersCountLabel = (count) => `${count} runners`;
 export const runKindLabel = (kind) => `${triggerLabel(kind)} run`;
 export const startedByLabel = (name) => `started by ${name}`;
 export const collapseOrExpandLabel = (expanded) => (expanded ? 'Collapse panel' : 'Expand panel');
+export const queuePositionLabel = (n) => (n > 0 ? `Queued · #${n}` : 'Queued');
 
-export function statusLabel(state, anyBgRunning, anyBgCronRunning) {
-	if (state.running) return 'Running';
-	if (state.status === 'pass') return 'Passed';
-	if (state.status === 'fail') return 'Failed';
-	if (anyBgCronRunning) return 'Scheduled';
-	if (anyBgRunning) return 'Running';
+export function statusLabel({ running, queued, verdict }) {
+	if (running > 0 && queued > 0) return `${running} running · ${queued} queued`;
+	if (running > 0) return running === 1 ? 'Running' : `${running} running`;
+	if (queued > 0) return queued === 1 ? 'Queued' : `${queued} queued`;
+	if (verdict === 'pass') return 'Passed';
+	if (verdict === 'fail') return 'Failed';
 	return 'Ready';
 }
 

package/frontend/src/lib/socketEvents.js

@@ -8,30 +8,18 @@
 // mirrors backend/constants/socketEvents.js by hand — keep both in sync when
 // adding or renaming an event.
 export 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
+	BG_RUN_QUEUED: 'bg-run-queued',
 	BG_RUN_START: 'bg-run-start',
 	BG_RUN_LOG: 'bg-run-log',
 	BG_RUN_DONE: 'bg-run-done',
 	BG_RUN_LANES_INIT: 'bg-run-lanes-init',
 	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',
 	BG_RUN_LANE_RRWEB_BATCH: 'bg-run-lane-rrweb-batch',
 
 	// Global notifications (any client, not tied to a specific run)

package/frontend/src/lib/stores/runner.js

@@ -4,31 +4,45 @@
  */
 
 import { writable, get } from 'svelte/store';
-import { BROWSERS } from '$lib/constants';
+import { BROWSERS, TRIGGER_TYPES } from '$lib/constants';
 import { SOCKET_EVENTS } from '$lib/socketEvents';
+import { MANUAL_RUN_LABEL } from '$lib/copy/runners';
 import { auth } from './auth';
 
 export const socket = writable(null);
 
-export const runnerState = writable({
-	output: '',
-	running: false,
-	testCompleted: false,
-	latestReportId: null, // number | null — set after test finishes
-	status: 'idle', // 'idle' | 'running' | 'pass' | 'fail'
-	lastRunId: '',
-	lanes: [], // [{ id, name, testCount, status, logs }] multi-runner only
-	currentRun: null, // { tag, workers, browser, runners } — set while running
-	// { [laneId]: { [workerId]: { events: [] } } } — always keyed by laneId even
-	// for a plain single-runner run (BUILT_IN_RUNNER_ID), so the live view's
-	// Runner/Worker tabs don't need a separate code path for that case.
-	rrwebByLane: {}
-});
+// runId → run entry. One store for every run whatever its origin (manual, cron,
+// REST, MCP): each is a queued job streamed over the bg-run-* events. Seeded
+// optimistically by triggerRun, then kept current by the socket handlers in
+// RunnerPanel.
+export const backgroundRuns = writable({});
+
+export function makeRunEntry({ kind, label, meta, status }) {
+	return {
+		kind,
+		label,
+		status, // 'queued' | 'running' | 'done'
+		testCompleted: false,
+		latestReportId: null,
+		verdict: 'idle', // 'idle' | 'pass' | 'fail' | 'cancelled'
+		output: '',
+		lanes: [], // [{ id, name, testCount, status, logs }]
+		currentRun: {
+			tag: meta?.tag ?? '',
+			workers: meta?.workers,
+			browser: meta?.browser,
+			runTitle: label,
+			startedBy: meta?.startedBy ?? null
+		},
+		// { [laneId]: { [workerId]: { events: [] } } } — always keyed by laneId
+		// even for a single-runner run, so the live view's Runner/Worker tabs
+		// don't need a separate code path for that case.
+		rrwebByLane: {}
+	};
+}
 
-// Merges a batch of rrweb events into the right lane/worker bucket, creating
-// it on first sight — Svelte only re-renders on a *new* object/array
-// reference, so this rebuilds the path down to the mutated bucket rather than
-// pushing in place. Shared by runnerState (interactive) and backgroundRuns.
+// Rebuilds the path down to the mutated bucket (Svelte only re-renders on a new
+// reference) rather than pushing in place.
 export function mergeRRwebBatch(rrwebByLane, { id: laneId, workerId, events }) {
 	const lane = rrwebByLane[laneId] ?? {};
 	const worker = lane[workerId] ?? { events: [] };
@@ -41,10 +55,6 @@ export function mergeRRwebBatch(rrwebByLane, { id: laneId, workerId, events }) {
 	};
 }
 
-export function appendRRwebBatch(batch) {
-	runnerState.update((s) => ({ ...s, rrwebByLane: mergeRRwebBatch(s.rrwebByLane, batch) }));
-}
-
 export const runnerConfig = writable({
 	workers: 1,
 	testID: '',
@@ -59,34 +69,31 @@ export const builtInEnabled = writable(true);
 export const reportsVersion = writable(0);
 export const runsVersion = writable(0);
 
-// Map of runId → runnerState-shaped object (plus kind/label) for every
-// non-manual run currently executing (scheduled cron jobs, REST/MCP-triggered
-// runs) — these are spawned server-side with no single browser socket to
-// stream to, so they're tracked separately from `runnerState`.
-export const backgroundRuns = writable({});
-
+// Enqueues a run and returns its id so the caller can navigate to /live/<id>.
+// The run stays `queued` until every runner it targets is free.
 export function triggerRun(id, testRunId, notify = {}, runTitle = null) {
 	const s = get(socket);
-	if (!s) return;
+	if (!s) return null;
 
 	const { workers, testID, browser, selectedRunners } = get(runnerConfig);
-	const runId = (id !== undefined ? id : testID).trim().replace(/\sOR\s/gi, (m) => m.toLowerCase());
+	const tag = (id !== undefined ? id : testID).trim().replace(/\sOR\s/gi, (m) => m.toLowerCase());
+	const runId = crypto.randomUUID();
+	const startedBy = get(auth).user?.name ?? null;
 
-	runnerState.set({
-		output: `Running: ${runId || '(all tests)'}\n`,
-		running: true,
-		testCompleted: false,
-		latestReportId: null,
-		status: 'running',
-		lastRunId: runId,
-		lanes: [],
-		currentRun: { tag: runId, workers, browser, runners: selectedRunners, runTitle },
-		rrwebByLane: {}
-	});
+	backgroundRuns.update((r) => ({
+		...r,
+		[runId]: makeRunEntry({
+			kind: TRIGGER_TYPES.MANUAL,
+			label: runTitle || tag || MANUAL_RUN_LABEL,
+			meta: { tag, workers, browser, startedBy },
+			status: 'queued'
+		})
+	}));
 	panelExpanded.set(true);
 
 	s.emit(SOCKET_EVENTS.RUN_TEST, {
-		tag: runId,
+		runId,
+		tag,
 		workers,
 		browser,
 		runners: selectedRunners,
@@ -94,11 +101,20 @@ export function triggerRun(id, testRunId, notify = {}, runTitle = null) {
 		notifyDiscord: notify.notifyDiscord ?? false,
 		notifySlack: notify.notifySlack ?? false,
 		runTitle,
-		startedBy: get(auth).user?.name ?? null
+		startedBy
 	});
+
+	return runId;
 }
 
-export function cancelRun() {
+export function cancelRun(id) {
 	const s = get(socket);
-	if (s) s.emit(SOCKET_EVENTS.CANCEL_TEST);
+	if (s && id) s.emit(SOCKET_EVENTS.CANCEL_TEST, { runId: id });
+}
+
+// Cron runs get a generated run id, not the task name — match one by kind + label.
+export function findActiveCronRun(runs, taskName) {
+	return Object.values(runs).find(
+		(r) => r.kind === TRIGGER_TYPES.CRON && r.label === taskName && r.status !== 'done'
+	);
 }