plum-e2e 1.3.3 → 1.3.5

package/README.md

@@ -282,11 +282,11 @@ plum run-test --parallel 4 @suite-login  # run a suite in parallel
 plum run-test --browser firefox          # run in a specific browser
 ```
 
-| Flag               | Description                                  |
-| ------------------ | -------------------------------------------- |
-| `@tag`             | Run only tests matching the tag              |
-| `--parallel <n>`   | Run across `n` parallel workers              |
-| `--browser <name>` | `chromium` (default), `firefox`, or `webkit` |
+| Flag               | Description                       |
+| ------------------ | --------------------------------- |
+| `@tag`             | Run only tests matching the tag   |
+| `--parallel <n>`   | Run across `n` parallel workers   |
+| `--browser <name>` | `chromium` (default) or `firefox` |
 
 > `plum run-test` syncs your tests, installs dependencies, and runs Cucumber. No Docker needed.
 
@@ -296,6 +296,8 @@ plum run-test --browser firefox          # run in a specific browser
 
 Runners are additional machines that execute tests in parallel alongside the primary server, letting you distribute a large suite across many nodes. A node runs as a plain Node process — **no Docker required**.
 
+Each node automatically installs **Chromium and Firefox** — no browser selection needed. When triggering a test run from the UI, you choose which browser to use at run time.
+
 ### Start a runner node
 
 On the machine that will act as a runner, navigate to your Plum project and run:
@@ -304,7 +306,7 @@ On the machine that will act as a runner, navigate to your Plum project and run:
 plum node start
 ```
 
-Plum asks a few questions and then **registers the node with your server automatically** — you don't need to add anything in the UI by hand:
+Plum asks a few questions, **registers the node with your server automatically**, starts it in the background, then opens the runner management menu:
 
 | Prompt             | Default                   | What it sets                                                         |
 | ------------------ | ------------------------- | -------------------------------------------------------------------- |
@@ -312,10 +314,11 @@ Plum asks a few questions and then **registers the node with your server automat
 | **Local port**     | `3001`                    | The port this node process listens on                                |
 | **Advertised URL** | `http://<your-ip>:<port>` | The address the **server** uses to reach this node                   |
 | **Runner name**    | `node-<random>`           | The name shown in the UI                                             |
-| **Browser**        | `chromium`                | Default browser for this node                                        |
 | **Auth token**     | auto-generated            | Shared secret; press Enter to keep the generated one                 |
 
-When it registers, Plum prints a details card with the assigned **id**, **token**, and **url**, then boots the node (Ctrl+C to stop). Settings are saved to `.plum-node.json`, so re-running reuses them and never creates a duplicate.
+The node starts as a **background daemon** — your terminal is free immediately. Logs go to `backend/logs/runner-<id>.log`. Settings are saved to `.plum-node.json`, so re-running reuses them and never creates a duplicate.
+
+After setup, the **runner management menu** opens automatically. From there you can start, stop, restart, and ping any runner registered on the primary. Exit the menu any time — the node keeps running.
 
 **Skip the prompts** with flags (handy for CI or scripted nodes):
 
@@ -330,7 +333,6 @@ plum node start --primary http://192.168.1.5:3001 --port 3001 --name ci-node-1
 | `--port <n>`       | Local HTTP port the node listens on (default `3001`).                                    |
 | `--token <secret>` | Auth token. Auto-generated and saved if omitted.                                         |
 | `--name <name>`    | Runner name shown in the UI.                                                             |
-| `--browser <name>` | `chromium` (default), `firefox`, or `webkit`.                                            |
 
 #### Nodes behind a domain or reverse proxy
 
@@ -342,6 +344,20 @@ plum node start --primary https://plum.example.com --url https://node1.example.c
 
 The server reaches the node at `https://node1.example.com`; the proxy forwards to the node on port `3001`. The advertised `--url` must be reachable from the server.
 
+### Manage runners
+
+```bash
+plum manage-runners
+```
+
+Opens the interactive runner management menu at any time (reads the primary URL from your saved node config). You can also pass a different server:
+
+```bash
+plum manage-runners --primary http://192.168.1.5:3001
+```
+
+> In development, the equivalent command is `npm run manage-runners` from the `backend/` directory.
+
 ### Change settings later
 
 ```bash
@@ -364,26 +380,27 @@ If you run `plum node start` without a reachable `--primary`, Plum prints the no
 plum node stop
 ```
 
-Stops the node started from the current folder.
+Stops the node started from the current folder. You can also stop individual runners from the `plum manage-runners` menu.
 
 ---
 
 ## Command Reference
 
-| Command                       | Description                                                             |
-| ----------------------------- | ----------------------------------------------------------------------- |
-| `plum init`                   | Initialize a new project in the current folder                          |
-| `plum server start`           | Start the full UI stack via Docker, interactively (alias: `plum start`) |
-| `plum server reconfig`        | Re-enter server settings (URL, ports) without starting                  |
-| `plum server stop`            | Stop the server and preserve data (alias: `plum stop`)                  |
-| `plum run-test`               | Run all tests locally without Docker                                    |
-| `plum run-test @tag`          | Run tests matching a tag                                                |
-| `plum run-test --parallel N`  | Run tests across N parallel workers                                     |
-| `plum run-test --browser <b>` | Run in a specific browser (chromium/firefox/webkit)                     |
-| `plum create-step`            | Interactively scaffold a new step definition                            |
-| `plum node start`             | Start a runner node (interactive) and auto-register it with the server  |
-| `plum node reconfig`          | Re-enter node settings + re-register, without starting                  |
-| `plum node stop`              | Stop the runner node started from this folder                           |
+| Command                       | Description                                                                    |
+| ----------------------------- | ------------------------------------------------------------------------------ |
+| `plum init`                   | Initialize a new project in the current folder                                 |
+| `plum server start`           | Start the full UI stack via Docker, interactively (alias: `plum start`)        |
+| `plum server reconfig`        | Re-enter server settings (URL, ports) without starting                         |
+| `plum server stop`            | Stop the server and preserve data (alias: `plum stop`)                         |
+| `plum run-test`               | Run all tests locally without Docker                                           |
+| `plum run-test @tag`          | Run tests matching a tag                                                       |
+| `plum run-test --parallel N`  | Run tests across N parallel workers                                            |
+| `plum run-test --browser <b>` | Run in a specific browser (`chromium` or `firefox`)                            |
+| `plum create-step`            | Interactively scaffold a new step definition                                   |
+| `plum node start`             | Configure, register, and start a runner node; opens the runner management menu |
+| `plum node reconfig`          | Re-enter node settings + re-register, without starting                         |
+| `plum node stop`              | Stop the runner node started from this folder                                  |
+| `plum manage-runners`         | Open the interactive runner management menu                                    |
 
 ---
 

package/backend/config/scripts/create-step.mjs

@@ -1,19 +1,20 @@
 /*
-This file is part of Plum.
+ * 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 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/.
-*/
 import * as clack from '@clack/prompts';
 import pc from 'picocolors';
 import fs from 'fs';

package/backend/lib/runnerProcess.js

@@ -109,13 +109,12 @@ function statusOf(id, registry = loadRegistry()) {
  * an interactive prompt running in the same terminal (the caller's menu would
  * wedge after the install finishes).
  */
-function prepareEnv(browser) {
+function prepareEnv() {
 	const stdio = ['ignore', 'inherit', 'inherit'];
 	if (!fs.existsSync(path.join(BACKEND_DIR, 'node_modules'))) {
 		execSync('npm install', { cwd: BACKEND_DIR, stdio, shell: true });
 	}
-	const target = browser && browser !== 'all' ? ` ${browser}` : '';
-	execSync(`npx playwright install${target}`, { cwd: BACKEND_DIR, stdio, shell: true });
+	execSync('npx playwright install chromium firefox', { cwd: BACKEND_DIR, stdio, shell: true });
 }
 
 /**

package/backend/scripts/manage-runners.mjs

@@ -103,10 +103,10 @@ function statusBadge(r) {
  * npm/playwright progress is visible. A failure is surfaced but non-fatal — the
  * operator can retry or fix it manually.
  */
-function prepareNodeEnv(browser) {
-	clack.log.step(`Preparing node environment (deps + ${browser ?? 'browser'})...`);
+function prepareNodeEnv() {
+	clack.log.step('Preparing node environment (deps + browsers)...');
 	try {
-		prepareEnv(browser);
+		prepareEnv();
 		clack.log.success(pc.green('Environment ready.'));
 		return true;
 	} catch (e) {
@@ -152,7 +152,7 @@ async function runAction(r) {
 	const port = parsePort(r.url);
 
 	if (action === 'start') {
-		prepareNodeEnv(r.browser);
+		prepareNodeEnv();
 		const entry = startNode({ id: r.id, port, token: r.token });
 		clack.log.success(pc.green(`Started "${r.name}" on port ${port} (pid ${entry.pid})`));
 	} else if (action === 'stop') {
@@ -204,17 +204,6 @@ async function addRunner() {
 	});
 	if (cancelled(port)) return;
 
-	const browser = await clack.select({
-		message: 'Default browser',
-		options: [
-			{ value: 'chromium', label: 'Chrome' },
-			{ value: 'firefox', label: 'Firefox' },
-			{ value: 'webkit', label: 'WebKit' }
-		],
-		initialValue: 'chromium'
-	});
-	if (cancelled(browser)) return;
-
 	const defToken = process.env.NODE_TOKEN || generateToken();
 	const token = await clack.text({ message: 'Auth token', placeholder: defToken, defaultValue: defToken });
 	if (cancelled(token)) return;
@@ -227,7 +216,7 @@ async function addRunner() {
 	s.start(`Registering "${name}" with the primary...`);
 	let id;
 	try {
-		const res = await registerWithPrimary({ primary: API_URL, name, url, token, browser });
+		const res = await registerWithPrimary({ primary: API_URL, name, url, token, browser: 'chromium' });
 		id = res.id;
 		s.stop(res.reused ? pc.green(`Reusing existing runner "${name}"`) : pc.green(`Registered "${name}" (id ${id})`));
 	} catch (e) {
@@ -235,7 +224,7 @@ async function addRunner() {
 		return;
 	}
 
-	prepareNodeEnv(browser);
+	prepareNodeEnv();
 
 	const startNow = await clack.confirm({ message: 'Start this runner now?' });
 	if (!cancelled(startNow) && startNow) {

package/backend/services/cronService.js

@@ -88,9 +88,20 @@ function runSingleBuiltIn({ taskName, tags, workers, browser }) {
 async function runDistributed({ taskName, tags, workers, browser, runnerIds }) {
 	const allIds = getTestIdsForTag(tags);
 	const chunks = chunkTests(allIds, runnerIds.length);
-	const laneInfos = await resolveLaneInfos(runnerIds);
 
-	const collectedReports = new Array(runnerIds.length).fill(null);
+	// Surplus runners beyond the number of non-empty chunks would fall back to
+	// running the full tag expression, producing duplicate scenarios in the report.
+	const activeRunnerIds = runnerIds.slice(0, chunks.length);
+
+	if (activeRunnerIds.length === 0) {
+		console.log(`Task "${taskName}" — no tests found, skipping.`);
+		if (_io) _io.emit('cron-done', { taskName, code: 0 });
+		return;
+	}
+
+	const laneInfos = await resolveLaneInfos(activeRunnerIds);
+
+	const collectedReports = new Array(activeRunnerIds.length).fill(null);
 	let doneCount = 0;
 	let overallCode = 0;
 
@@ -99,7 +110,7 @@ async function runDistributed({ taskName, tags, workers, browser, runnerIds }) {
 		collectedReports[idx] = reportContent;
 		doneCount++;
 
-		if (doneCount === runnerIds.length) {
+		if (doneCount === activeRunnerIds.length) {
 			console.log(`Task "${taskName}" — all runners done (exit ${overallCode})`);
 			if (_io) _io.emit('cron-done', { taskName, code: overallCode });
 
@@ -116,9 +127,9 @@ async function runDistributed({ taskName, tags, workers, browser, runnerIds }) {
 		}
 	}
 
-	for (let i = 0; i < runnerIds.length; i++) {
+	for (let i = 0; i < activeRunnerIds.length; i++) {
 		const lane = laneInfos[i];
-		const chunkTag = chunks[i]?.length > 0 ? buildTagExpression(chunks[i]) : tags;
+		const chunkTag = buildTagExpression(chunks[i]);
 
 		if (lane.id === BUILT_IN_RUNNER_ID) {
 			const env = {

package/backend/websockets/socketHandler.js

@@ -118,8 +118,26 @@ async function runDistributed(io, socket, activeProcs, tag, workers, browser, ru
 	const allIds = getTestIdsForTag(tag);
 	const chunks = chunkTests(allIds, runnerIds.length);
 
+	// Surplus runners beyond the number of non-empty chunks would fall back to
+	// running the full tag expression, producing duplicate scenarios in the report.
+	const activeRunnerIds = runnerIds.slice(0, chunks.length);
+
+	if (activeRunnerIds.length === 0) {
+		socket.emit('log', '\nNo tests found matching the selected tag.\n');
+		socket.emit('done', 0);
+		return;
+	}
+
+	if (activeRunnerIds.length < runnerIds.length) {
+		const skipped = runnerIds.length - activeRunnerIds.length;
+		socket.emit(
+			'log',
+			`[INFO] ${skipped} runner(s) not used — fewer tests than runners selected.\n`
+		);
+	}
+
 	const laneInfos = await Promise.all(
-		runnerIds.map(async (id) => {
+		activeRunnerIds.map(async (id) => {
 			if (id === BUILT_IN_RUNNER_ID) return { id, name: 'Built-in', dbId: null };
 			const r = await runnerService.getById(id);
 			return { id, name: r?.name ?? id, dbId: r?.id ?? null };
@@ -128,10 +146,10 @@ async function runDistributed(io, socket, activeProcs, tag, workers, browser, ru
 
 	socket.emit(
 		'runner-lanes-init',
-		laneInfos.map((l, i) => ({ id: l.id, name: l.name, testCount: (chunks[i] || []).length }))
+		laneInfos.map((l, i) => ({ id: l.id, name: l.name, testCount: chunks[i].length }))
 	);
 
-	const total = runnerIds.length;
+	const total = activeRunnerIds.length;
 	const collectedReports = new Array(total).fill(null);
 	let doneCount = 0;
 	let overallCode = 0;
@@ -168,9 +186,9 @@ async function runDistributed(io, socket, activeProcs, tag, workers, browser, ru
 		}
 	}
 
-	for (let i = 0; i < runnerIds.length; i++) {
+	for (let i = 0; i < activeRunnerIds.length; i++) {
 		const lane = laneInfos[i];
-		const chunkTag = chunks[i]?.length > 0 ? buildTagExpression(chunks[i]) : tag;
+		const chunkTag = buildTagExpression(chunks[i]);
 
 		if (lane.id === BUILT_IN_RUNNER_ID) {
 			const env = {