plum-e2e 2.9.8 → 2.9.12

package/backend/lib/runnerProcess.js

@@ -201,6 +201,29 @@ function prepareEnv() {
 	});
 }
 
+/**
+ * Polls a node's own /api/ping (at `baseUrl`, e.g. http://localhost:3002) until
+ * it reports mode:'node', or the timeout elapses. A detached spawn returns a
+ * pid immediately even when the process goes on to die on EADDRINUSE — callers
+ * use this to report honestly whether the node actually came up.
+ */
+async function nodeReachable(baseUrl, token, timeoutMs = 15000) {
+	const url = `${String(baseUrl).replace(/\/+$/, '')}/api/ping`;
+	const headers = token ? { Authorization: `Bearer ${token}` } : {};
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		try {
+			const res = await fetch(url, { headers, signal: AbortSignal.timeout(3000) });
+			if (res.ok) {
+				const body = await res.json().catch(() => ({}));
+				if (body.ok && body.mode === 'node') return true;
+			}
+		} catch {}
+		await new Promise((r) => setTimeout(r, 500));
+	}
+	return false;
+}
+
 /**
  * Spawns a detached node-mode server for the given runner and records its pid.
  * Returns the registry entry.
@@ -316,6 +339,7 @@ module.exports = {
 	parsePort,
 	findPidOnPort,
 	killPort,
+	nodeReachable,
 	pruneDead,
 	statusOf,
 	ensureBackendDeps,

package/backend/scripts/manage-runners.mjs

@@ -30,30 +30,33 @@ const {
 	startNode,
 	stopNode,
 	findPidOnPort,
-	killPort
+	killPort,
+	nodeReachable
 } = runnerProcess;
-const { generateToken, registerWithPrimary, detectLanIp, loadNodeConfig } = nodeRegister;
+const { generateToken, registerWithPrimary, detectLanIp, loadNodeConfig, saveNodeConfig } =
+	nodeRegister;
 
 const API_URL = process.env.PLUM_API_URL || 'http://localhost:3001';
 
 const cancelled = (v) => clack.isCancel(v);
 
-// The mutating /runners routes take a registered runner's own token in place of
-// an admin session (runnerOrAdmin.js), and this manager has no JWT — so find
-// any node token on this machine, falling back to PLUM_MCP_KEY.
-function resolveAuthHeader() {
+// The mutating /runners routes accept any registered runner's own token in
+// place of an admin session (runnerOrAdmin.js). Use one: handed in by `plum`
+// (which reads it from the primary's DB when run on the server host), or from
+// a node's own .plum-node.json — this folder, then any other node install.
+function resolveRunnerToken() {
+	if (process.env.PLUM_RUNNER_TOKEN) return process.env.PLUM_RUNNER_TOKEN;
 	const cwdToken = loadNodeConfig(process.cwd()).token;
-	if (cwdToken) return { Authorization: `Bearer ${cwdToken}` };
+	if (cwdToken) return cwdToken;
 	for (const dir of globalRegistry.getInstalls('node')) {
 		const token = loadNodeConfig(dir).token;
-		if (token) return { Authorization: `Bearer ${token}` };
+		if (token) return token;
 	}
-	if (process.env.PLUM_MCP_KEY) return { Authorization: `ApiKey ${process.env.PLUM_MCP_KEY}` };
-	return {};
+	return null;
 }
-const AUTH_HEADER = resolveAuthHeader();
+const RUNNER_TOKEN = resolveRunnerToken();
 function authHeaders() {
-	return AUTH_HEADER;
+	return RUNNER_TOKEN ? { Authorization: `Bearer ${RUNNER_TOKEN}` } : {};
 }
 
 /**
@@ -301,26 +304,6 @@ async function runAction(r) {
 	}
 }
 
-// Polls a node's own /api/ping until it reports mode:'node' or the timeout
-// elapses — used to confirm a runner actually serves before its registration
-// is kept (see addRunner).
-async function nodeIsUp(baseUrl, token, timeoutMs) {
-	const url = `${baseUrl.replace(/\/+$/, '')}/api/ping`;
-	const headers = token ? { Authorization: `Bearer ${token}` } : {};
-	const deadline = Date.now() + timeoutMs;
-	while (Date.now() < deadline) {
-		try {
-			const res = await fetch(url, { headers, signal: AbortSignal.timeout(3000) });
-			if (res.ok) {
-				const body = await res.json().catch(() => ({}));
-				if (body.ok && body.mode === 'node') return true;
-			}
-		} catch {}
-		await new Promise((r) => setTimeout(r, 750));
-	}
-	return false;
-}
-
 async function addRunner() {
 	const suggested = `node-${generateToken().slice(0, 6)}`;
 
@@ -361,7 +344,6 @@ async function addRunner() {
 	if (cancelled(urlInput)) return;
 
 	const url = resolveNodeUrl(urlInput || defaultUrl);
-	const local = isLocalUrl(url);
 
 	const s = clack.spinner();
 	s.start(`Registering "${name}" with the primary...`);
@@ -382,51 +364,69 @@ async function addRunner() {
 		return;
 	}
 
-	// Verify the node actually answers before keeping the registration — start a
-	// local one here, expect a remote one to already be up. A failed check rolls
-	// the registration back so no dead runner is left behind.
-	let entry = null;
-	let ok = false;
-	if (local) {
-		prepareNodeEnv();
-		entry = startNode({ id, port, token });
-		s.start(`Waiting for "${name}" to come up on port ${port}...`);
-		ok = await nodeIsUp(`http://localhost:${port}`, token, 20000);
-		s.stop(ok ? pc.green(`"${name}" is up (pid ${entry.pid})`) : pc.red(`"${name}" did not start`));
-	} else {
-		s.start(`Checking for a Plum node at ${url}...`);
-		ok = await nodeIsUp(url, token, 8000);
-		s.stop(ok ? pc.green(`"${name}" is reachable`) : pc.red(`No Plum node answered at ${url}`));
+	// A node whose URL points at another machine has to be started over there
+	// (`plum node start`), so registering it before it's up is normal — just
+	// tell the operator what to run. Only a node we can start from here gets
+	// started + verified, and rolled back if it never comes up.
+	if (!isLocalUrl(url)) {
+		s.start(`Checking ${url}...`);
+		const up = await nodeReachable(url, token, 5000);
+		s.stop(
+			up
+				? pc.green(`"${name}" registered and answering`)
+				: pc.yellow(`"${name}" registered — no node answering there yet`)
+		);
+		if (!up) {
+			clack.log.info(
+				`Start it on that host:\n  plum node start --name ${name} --url ${url} --port <port> ` +
+					`--primary ${API_URL} --token ${token}`
+			);
+		}
+		return;
 	}
 
-	if (ok) {
+	prepareNodeEnv();
+	if (findPidOnPort(Number(port))) await killPort(Number(port));
+	const entry = startNode({ id, port, token });
+	s.start(`Starting "${name}" on port ${port}...`);
+	const up = await nodeReachable(`http://localhost:${port}`, token, 20000);
+	s.stop(up ? pc.green(`"${name}" is up (pid ${entry.pid})`) : pc.red(`"${name}" did not start`));
+
+	if (up) {
+		// Persist the same way `plum node start` does, so `plum node stop`/
+		// `restart` and `plum update`'s restart sweep can find this node too.
+		saveNodeConfig(process.cwd(), {
+			...loadNodeConfig(process.cwd()),
+			id,
+			name,
+			url,
+			token,
+			primary: API_URL,
+			browser: 'chromium',
+			port
+		});
+		globalRegistry.registerInstall('node', process.cwd());
 		clack.log.success(pc.green(`Runner "${name}" is ready.`));
 		return;
 	}
 
-	if (entry) stopNode(id, Number(port));
+	stopNode(id, Number(port));
 	if (!reused) {
 		try {
 			await deleteRunner(id);
 		} catch {}
 	}
-	if (entry?.logFile) clack.note(entry.logFile, 'Node log');
-	clack.log.warn(
-		pc.yellow(
-			reused
-				? `"${name}" stays registered but is unreachable — check the port/URL.`
-				: `"${name}" was not registered — check the port/URL and try again.`
-		)
-	);
+	if (entry.logFile) clack.note(entry.logFile, 'Node log');
+	clack.log.warn(pc.yellow(`"${name}" was not registered — check ${entry.logFile} and try again.`));
 }
 
 async function main() {
 	clack.intro(pc.bgMagenta(pc.white('  🟣 Plum — Manage Runners  ')));
 
-	if (!AUTH_HEADER.Authorization) {
+	if (!RUNNER_TOKEN) {
 		clack.log.warn(
-			'No runner credential found on this machine — stop / restart / delete will be rejected.\n' +
-				'Run this from a folder where you started a node, or export PLUM_MCP_KEY.'
+			'No runner token available — stop / restart / delete will be rejected.\n' +
+				'Run `plum manage-runners` on the primary host, or from a folder where you started a node.'
 		);
 	}
 

package/bin/plum.js

@@ -595,7 +595,8 @@ async function configureNode({ force }) {
 	const saved = loadNodeConfig(cwd);
 
 	let primary = getFlag(args, '--primary') ?? process.env.PRIMARY_URL ?? saved.primary ?? '';
-	let port = getFlag(args, '--port') ?? saved.port ?? '3001';
+	// Not 3001 — that's the primary's default; a co-located node must not collide.
+	let port = getFlag(args, '--port') ?? saved.port ?? '3002';
 	let browser = getFlag(args, '--browser') ?? saved.browser ?? 'chromium';
 	let token = getFlag(args, '--token') ?? process.env.NODE_TOKEN ?? saved.token ?? generateToken();
 	let name = getFlag(args, '--name') ?? saved.name ?? `node-${token.slice(0, 6)}`;
@@ -613,6 +614,14 @@ async function configureNode({ force }) {
 	const interactive = force || (interactiveAllowed() && !hasFlags);
 
 	if (interactive) {
+		const nameVal = await clack.text({
+			message: 'Runner name',
+			placeholder: name,
+			defaultValue: name
+		});
+		if (clack.isCancel(nameVal)) cancelAndExit();
+		name = nameVal || name;
+
 		const primaryVal = await clack.text({
 			message: 'Your Plum server backend URL',
 			placeholder: primary || 'http://localhost:3001',
@@ -716,6 +725,21 @@ async function nodeStart({ reconfig }) {
 	const { statusOf } = runnerProcessLib();
 	const existing = loadNodeConfig(process.cwd());
 
+	// One folder holds one node's config (.plum-node.json). Starting a
+	// different-named node here would overwrite it — orphaning the previous
+	// node's still-running process and losing the config needed to stop it.
+	const wantName = getFlag(process.argv.slice(3), '--name');
+	if (!reconfig && existing.name && wantName && wantName !== existing.name) {
+		clack.log.error(
+			`This folder is set up for node "${existing.name}". Run each node from its own folder:\n\n` +
+				`  mkdir -p ~/plum-nodes/${wantName} && cd ~/plum-nodes/${wantName}\n` +
+				`  plum node start --name ${wantName} …`
+		);
+		clack.outro(pc.red('Not started — use a fresh folder for this node.'));
+		process.exitCode = 1;
+		return;
+	}
+
 	// 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
@@ -732,7 +756,13 @@ async function nodeStart({ reconfig }) {
 	const cfg = await configureNode({ force: reconfig });
 	const registeredId = await registerNode(cfg);
 
-	const { prepareEnv, startNode: startNodeProc } = runnerProcessLib();
+	const {
+		prepareEnv,
+		startNode: startNodeProc,
+		findPidOnPort,
+		killPort,
+		nodeReachable
+	} = runnerProcessLib();
 
 	clack.log.step('Preparing environment (deps + browsers)...');
 	try {
@@ -749,12 +779,30 @@ async function nodeStart({ reconfig }) {
 
 	if (registeredId) {
 		try {
+			// A stale process on this port makes the new node die on EADDRINUSE
+			// after a silent retry loop — clear it first (almost always a
+			// previous instance of this same node).
+			if (findPidOnPort(Number(cfg.port))) {
+				clack.log.step(`Port ${cfg.port} is in use — freeing it...`);
+				await killPort(Number(cfg.port));
+			}
 			const entry = startNodeProc({ id: String(registeredId), port: cfg.port, token: cfg.token });
-			clack.log.success(
-				pc.green(
-					`Node "${cfg.name}" running in background (pid ${entry.pid}) — logs at backend/logs/runner-${registeredId}.log`
-				)
-			);
+			clack.log.step(`Starting "${cfg.name}" (pid ${entry.pid})...`);
+			const up = await nodeReachable(`http://localhost:${cfg.port}`, cfg.token, 15000);
+			if (up) {
+				clack.log.success(
+					pc.green(
+						`Node "${cfg.name}" running in background (pid ${entry.pid}) — logs at ${entry.logFile}`
+					)
+				);
+			} else {
+				clack.log.error(
+					pc.red(
+						`Node "${cfg.name}" did not come up on port ${cfg.port}. Check ${entry.logFile} — the port may still be held by another process.`
+					)
+				);
+				process.exitCode = 1;
+			}
 		} catch (e) {
 			clack.log.warn(`Could not start runner process: ${e.message}`);
 		}
@@ -769,7 +817,7 @@ async function nodeStart({ reconfig }) {
 async function nodeRestart() {
 	clack.intro(pc.bgMagenta(pc.white('  🟣 Plum — Node Restart  ')));
 	const { loadNodeConfig } = nodeRegisterLib();
-	const { prepareEnv, stopNode, startNode } = runnerProcessLib();
+	const { prepareEnv, stopNode, startNode, killPort, nodeReachable } = runnerProcessLib();
 	const cfg = loadNodeConfig(process.cwd());
 
 	if (!cfg.id) {
@@ -802,17 +850,27 @@ async function nodeRestart() {
 	}
 
 	try {
+		await killPort(Number(cfg.port));
 		const entry = startNode({ id: String(cfg.id), port: cfg.port, token: cfg.token });
-		clack.log.success(
-			pc.green(
-				`Node "${cfg.name}" restarted (pid ${entry.pid}) — logs at backend/logs/runner-${cfg.id}.log`
-			)
-		);
+		const up = await nodeReachable(`http://localhost:${cfg.port}`, cfg.token, 15000);
+		if (up) {
+			clack.log.success(
+				pc.green(`Node "${cfg.name}" restarted (pid ${entry.pid}) — logs at ${entry.logFile}`)
+			);
+			clack.outro(pc.green('Node restarted.'));
+		} else {
+			clack.log.error(
+				pc.red(
+					`Node "${cfg.name}" did not come back up on port ${cfg.port}. Check ${entry.logFile}.`
+				)
+			);
+			process.exitCode = 1;
+			clack.outro(pc.red('Node not restarted.'));
+		}
 	} catch (e) {
 		clack.log.warn(`Could not restart node: ${e.message}`);
+		clack.outro(pc.red('Node not restarted.'));
 	}
-
-	clack.outro(pc.green('Node restarted.'));
 }
 
 async function nodeReconfig() {
@@ -823,13 +881,41 @@ async function nodeReconfig() {
 	clack.outro(pc.dim('Done.'));
 }
 
+// stop/restart/delete on the /runners API want a registered runner's token
+// (runnerOrAdmin). On the primary host those tokens sit in the backend's DB —
+// pull one straight from the running container so the menu can authenticate
+// without a node's .plum-node.json in the current folder. Best-effort: on a
+// node-only box (no server install / no Docker) this no-ops and the menu falls
+// back to a local .plum-node.json.
+function readRunnerTokenFromPrimary() {
+	const { getInstalls } = globalRegistryLib();
+	const script =
+		"require('./services/prisma').runner.findFirst({select:{token:true}})" +
+		".then(r=>{process.stdout.write(r&&r.token||'');process.exit(0)}).catch(()=>process.exit(1))";
+	for (const dir of getInstalls('server')) {
+		try {
+			const token = execSync(`docker compose exec -T backend node -e "${script}"`, {
+				cwd: dir,
+				stdio: ['ignore', 'pipe', 'ignore'],
+				timeout: 15000
+			})
+				.toString()
+				.trim();
+			if (token) return token;
+		} catch {}
+	}
+	return null;
+}
+
 async function openManageRunnersMenu(primaryUrl) {
 	const manageScript = path.join(plumRoot, 'backend', 'scripts', 'manage-runners.mjs');
 	const apiUrl = primaryUrl || 'http://localhost:3001';
-	const menu = spawn(process.execPath, [manageScript], {
-		stdio: 'inherit',
-		env: { ...process.env, PLUM_API_URL: apiUrl }
-	});
+	const env = { ...process.env, PLUM_API_URL: apiUrl };
+	if (!env.PLUM_RUNNER_TOKEN) {
+		const token = readRunnerTokenFromPrimary();
+		if (token) env.PLUM_RUNNER_TOKEN = token;
+	}
+	const menu = spawn(process.execPath, [manageScript], { stdio: 'inherit', env });
 	await new Promise((resolve) => menu.on('exit', resolve));
 }
 

package/package.json

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