plum-e2e 2.5.7 → 2.5.9

package/backend/config/scripts/run-tests.js

@@ -69,18 +69,13 @@ try {
 
 		// hooks.ts calls dotenv.config() with no path, which defaults to process.cwd().
 		// When running from a temp dir there is no .env there, so vars like BASE_URL
-		// would be undefined. Pre-load BACKEND_DIR's .env so they are already in
-		// process.env before dotenv.config() runs (dotenv never overwrites existing vars).
-		const backendEnvPath = path.resolve(__dirname, '..', '..', '.env');
-		if (fs.existsSync(backendEnvPath)) {
-			for (const line of fs.readFileSync(backendEnvPath, 'utf8').split(/\r?\n/)) {
-				const m = line.match(/^([A-Za-z_]\w*)\s*=\s*(.*?)(\s*#.*)?$/);
-				if (m) {
-					const key = m[1];
-					const val = m[2].trim().replace(/^(['"])(.*)\1$/, '$2');
-					if (!(key in process.env)) process.env[key] = val;
-				}
-			}
+		// would be undefined. A dispatched node job already has these injected into
+		// process.env by node.routes.js from the primary's payload; this is just a
+		// fallback for local/standalone runs, so it never overwrites what's already set.
+		const { loadTestEnv } = require('../../lib/testEnv');
+		const backendEnv = loadTestEnv(path.resolve(__dirname, '..', '..'));
+		for (const [key, val] of Object.entries(backendEnv)) {
+			if (!(key in process.env)) process.env[key] = val;
 		}
 
 		fs.writeFileSync(

package/backend/lib/globalRegistry.js

@@ -0,0 +1,67 @@
+/*
+ * 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-server.json`/`.plum-node.json` live in whatever directory the user
+ * happened to run `plum server start`/`plum node start` from. `plum update`
+ * needs to find and restart those installs later regardless of the cwd it's
+ * invoked from — this is the one place, independent of any project
+ * directory, that remembers where they are.
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const REGISTRY_DIR = path.join(os.homedir(), '.plum');
+const REGISTRY_PATH = path.join(REGISTRY_DIR, 'installs.json');
+
+function load() {
+	try {
+		return JSON.parse(fs.readFileSync(REGISTRY_PATH, 'utf8'));
+	} catch {
+		return { server: [], node: [] };
+	}
+}
+
+function save(data) {
+	fs.mkdirSync(REGISTRY_DIR, { recursive: true });
+	fs.writeFileSync(REGISTRY_PATH, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+/** Records `dir` as a known `type` ('server' | 'node') install location. */
+function registerInstall(type, dir) {
+	const data = load();
+	if (!data[type]) data[type] = [];
+	if (!data[type].includes(dir)) {
+		data[type].push(dir);
+		save(data);
+	}
+}
+
+/** Known install dirs for `type`, pruned of any that no longer exist on disk. */
+function getInstalls(type) {
+	const data = load();
+	const dirs = (data[type] || []).filter((d) => fs.existsSync(d));
+	if (dirs.length !== (data[type] || []).length) {
+		data[type] = dirs;
+		save(data);
+	}
+	return dirs;
+}
+
+module.exports = { REGISTRY_PATH, registerInstall, getInstalls };

package/backend/lib/testEnv.js

@@ -0,0 +1,38 @@
+/*
+ * 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 fs = require('fs');
+const path = require('path');
+
+/**
+ * Parses a dir's `.env` into a plain object. Used to hand a remote runner node
+ * the same BASE_URL/IS_HEADLESS/custom test vars the primary has, so nodes stay
+ * stateless runners instead of needing their own local `.env`.
+ */
+function loadTestEnv(dir) {
+	const out = {};
+	try {
+		const txt = fs.readFileSync(path.join(dir, '.env'), 'utf8');
+		for (const line of txt.split(/\r?\n/)) {
+			const m = line.match(/^([A-Za-z_]\w*)\s*=\s*(.*?)(\s*#.*)?$/);
+			if (m) out[m[1]] = m[2].trim().replace(/^(['"])(.*)\1$/, '$2');
+		}
+	} catch {}
+	return out;
+}
+
+module.exports = { loadTestEnv };

package/backend/routes/node.routes.js

@@ -47,7 +47,7 @@ router.post('/shutdown', authGuard, (req, res) => {
 
 // Start a remote test job
 router.post('/execute', authGuard, (req, res) => {
-	const { tags, browser = 'chromium', workers = 1, tests = null } = req.body;
+	const { tags, browser = 'chromium', workers = 1, tests = null, env: userEnv = {} } = req.body;
 	const jobId = crypto.randomUUID();
 
 	// path.resolve ensures absolute even if TMPDIR env var is set to a relative path
@@ -84,6 +84,11 @@ router.post('/execute', authGuard, (req, res) => {
 
 	const env = {
 		...process.env,
+		// User/test vars (BASE_URL, IS_HEADLESS, custom secrets) forwarded from the
+		// primary's own .env — nodes are stateless runners and shouldn't need their
+		// own copy. Spread before the job-control vars below so a stray same-named
+		// var in the user's .env can never override how this job actually runs.
+		...userEnv,
 		TAG: tags || '',
 		TRIGGER: TRIGGER_REMOTE,
 		BROWSER: browser,

package/backend/services/runnerService.js

@@ -18,6 +18,7 @@
 const fs = require('fs');
 const path = require('path');
 const prisma = require('./prisma');
+const { loadTestEnv } = require('../lib/testEnv');
 
 // ---------------------------------------------------------------------------
 // Runner CRUD
@@ -170,7 +171,13 @@ async function dispatchAndPoll(
 				'Content-Type': 'application/json',
 				Authorization: `Bearer ${runner.token}`
 			},
-			body: JSON.stringify({ tags, browser, workers, tests: collectTestFiles() }),
+			body: JSON.stringify({
+				tags,
+				browser,
+				workers,
+				tests: collectTestFiles(),
+				env: loadTestEnv(process.cwd())
+			}),
 			signal: AbortSignal.timeout(10000)
 		});
 		if (!res.ok) throw new Error(`HTTP ${res.status}`);

package/bin/plum.js

@@ -138,6 +138,7 @@ const backendLib = path.join(plumRoot, 'backend', 'lib');
 const serverConfigLib = () => require(path.join(backendLib, 'serverConfig.js'));
 const nodeRegisterLib = () => require(path.join(backendLib, 'nodeRegister.js'));
 const runnerProcessLib = () => require(path.join(backendLib, 'runnerProcess.js'));
+const globalRegistryLib = () => require(path.join(backendLib, 'globalRegistry.js'));
 
 /* -----------------------------------------------------
  *                 Interactive prompts
@@ -254,6 +255,7 @@ async function configureServer({ force }) {
 	}
 
 	saveServerConfig(cwd, cfg);
+	globalRegistryLib().registerInstall('server', cwd);
 	return cfg;
 }
 
@@ -484,9 +486,15 @@ function npmInstallLatestWithRetry() {
 	return false;
 }
 
+function readPlumVersion() {
+	return JSON.parse(fs.readFileSync(path.join(plumRoot, 'package.json'), 'utf8')).version;
+}
+
 async function serverUpdate() {
 	clack.intro(pc.bgMagenta(pc.white('  🟣 Plum — Update  ')));
-	clack.log.step('Fetching latest Plum version…');
+
+	const fromVersion = readPlumVersion();
+	clack.log.step(`Fetching latest Plum version… (currently ${fromVersion})`);
 	if (!npmInstallLatestWithRetry()) {
 		clack.log.error(
 			`Failed to install the latest version after ${NPM_INSTALL_RETRIES} attempts. Try again shortly, or run "npm install -g plum-e2e@latest" manually to see the full error.`
@@ -495,39 +503,61 @@ async function serverUpdate() {
 		process.exitCode = 1;
 		return;
 	}
-	clack.log.success('Plum CLI updated.');
 
-	const serverCfgPath = path.join(process.cwd(), '.plum-server.json');
-	const hasServerCfg = fs.existsSync(serverCfgPath);
+	// Re-read from disk (not require-cached) so this reflects what npm just installed.
+	const toVersion = readPlumVersion();
+	clack.log.success(`Plum CLI updated: ${fromVersion} → ${toVersion}`);
 
+	// Every install registers its directory here when configured (see
+	// configureServer/configureNode), so this finds them regardless of the cwd
+	// `plum update` happens to be run from.
+	const { getInstalls } = globalRegistryLib();
 	const { loadNodeConfig } = nodeRegisterLib();
 	const { loadRegistry, isAlive } = runnerProcessLib();
-	const nodeCfg = loadNodeConfig(process.cwd());
-	const registry = loadRegistry();
-	const nodeRunning = !!(
-		nodeCfg.id &&
-		registry[String(nodeCfg.id)]?.pid &&
-		isAlive(registry[String(nodeCfg.id)].pid)
-	);
 
-	// Re-exec `plum` as a fresh process for the restart steps rather than
-	// calling serverRestart()/nodeRestart() directly — this same process
-	// already loaded the OLD code into memory before npm install ran above,
-	// so calling them in-process would rebuild using stale logic no matter
-	// how new the just-installed files on disk actually are.
-	if (hasServerCfg) {
-		clack.log.step('Rebuilding server with the newly installed version…');
-		execSync('plum server restart', { stdio: 'inherit' });
+	let restartedAnything = false;
+
+	// Re-exec `plum` as a fresh process (cwd set to each install dir) for the
+	// restart steps rather than calling serverRestart()/nodeRestart() directly —
+	// this same process already loaded the OLD code into memory before npm
+	// install ran above, so calling them in-process would rebuild using stale
+	// logic no matter how new the just-installed files on disk actually are.
+	for (const dir of getInstalls('server')) {
+		if (!fs.existsSync(path.join(dir, '.plum-server.json'))) continue;
+		clack.log.step(`Rebuilding server at ${dir}…`);
+		try {
+			execSync('plum server restart', { stdio: 'inherit', cwd: dir });
+			restartedAnything = true;
+		} catch (e) {
+			clack.log.warn(`Could not restart server at ${dir}: ${e.message}`);
+		}
 	}
 
-	if (nodeRunning) {
-		clack.log.step('Restarting node runner with the newly installed version…');
-		execSync('plum node restart', { stdio: 'inherit' });
+	const registry = loadRegistry();
+	for (const dir of getInstalls('node')) {
+		const nodeCfg = loadNodeConfig(dir);
+		const running = !!(
+			nodeCfg.id &&
+			registry[String(nodeCfg.id)]?.pid &&
+			isAlive(registry[String(nodeCfg.id)].pid)
+		);
+		if (!running) continue;
+		clack.log.step(`Restarting node runner at ${dir}…`);
+		try {
+			execSync('plum node restart', { stdio: 'inherit', cwd: dir });
+			restartedAnything = true;
+		} catch (e) {
+			clack.log.warn(`Could not restart node at ${dir}: ${e.message}`);
+		}
 	}
 
-	if (!hasServerCfg && !nodeRunning) {
-		clack.outro(pc.green('Plum updated. Run `plum server start` or `plum node start` to launch.'));
+	if (!restartedAnything) {
+		clack.log.info(
+			'No running server or node found — run `plum server start` or `plum node start` when ready.'
+		);
 	}
+
+	clack.outro(pc.green(`Plum updated: ${fromVersion} → ${toVersion}`));
 }
 
 async function serverReconfig() {
@@ -610,6 +640,7 @@ async function configureNode({ force }) {
 		port,
 		pid: saved.pid ?? null
 	});
+	globalRegistryLib().registerInstall('node', cwd);
 	return { primary, port, browser, token, name, url };
 }
 
@@ -665,6 +696,23 @@ async function nodeStart({ reconfig }) {
 	const backendDir = path.join(plumRoot, 'backend');
 	clack.intro(pc.bgMagenta(pc.white('  🟣 Plum — Node Runner  ')));
 
+	const { loadNodeConfig } = nodeRegisterLib();
+	const { statusOf } = runnerProcessLib();
+	const existing = loadNodeConfig(process.cwd());
+
+	// Re-running `node start` on an already-running node used to spawn a second
+	// process on the same port (orphaning the first) and re-register a duplicate
+	// runner on the primary. Route to the same menu this command ends on anyway
+	// instead of repeating the whole configure/register/spawn dance.
+	if (!reconfig && existing.id && statusOf(String(existing.id)) === 'running') {
+		clack.log.info(
+			`Node "${existing.name ?? existing.id}" is already running from this folder — opening the runner menu instead of starting a new one.`
+		);
+		await openManageRunnersMenu(existing.primary);
+		clack.outro(`Manage runners anytime: ${pc.cyan('plum manage-runners')}`);
+		return;
+	}
+
 	const cfg = await configureNode({ force: reconfig });
 	const registeredId = await registerNode(cfg);
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "plum-e2e",
-	"version": "2.5.7",
+	"version": "2.5.9",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/silverlunah/plum.git"