plum-e2e 2.6.5 → 2.6.7

package/backend/lib/runnerProcess.js

@@ -77,12 +77,17 @@ function findPidOnPort(port) {
 		if (process.platform === 'win32') {
 			const out = execSync('netstat -ano', { encoding: 'utf8' });
 			for (const line of out.split('\n')) {
-				const upper = line.toUpperCase();
-				if (upper.includes(`:${portStr}`) && upper.includes('LISTENING')) {
-					const parts = line.trim().split(/\s+/);
-					const pid = parseInt(parts[parts.length - 1], 10);
-					if (!isNaN(pid) && pid > 0) return pid;
-				}
+				if (!line.toUpperCase().includes('LISTENING')) continue;
+				const parts = line.trim().split(/\s+/);
+				// Columns: Proto, Local Address, Foreign Address, State, PID.
+				// Match the port exactly off the local address (e.g. "0.0.0.0:3002"
+				// or "[::]:3002") — a substring check would false-positive port
+				// "300" against "3002", "13000", etc.
+				const localAddress = parts[1] ?? '';
+				const localPort = localAddress.slice(localAddress.lastIndexOf(':') + 1);
+				if (localPort !== portStr) continue;
+				const pid = parseInt(parts[parts.length - 1], 10);
+				if (!isNaN(pid) && pid > 0) return pid;
 			}
 		} else {
 			const out = execSync(`lsof -i :${portStr} -t -sTCP:LISTEN`, { encoding: 'utf8' }).trim();
@@ -122,12 +127,18 @@ function parsePort(url) {
 	}
 }
 
-/** Drops registry entries whose process has died and persists the result. */
+/**
+ * Clears the pid of registry entries whose process has died, and persists the
+ * result. Keeps the entry itself (with its `port`) rather than deleting it —
+ * that's the only place the last-used port for a runner is remembered, so a
+ * later Start can reuse it instead of falling back to whatever's in the
+ * runner's URL (or a hardcoded default, if the URL has no explicit port).
+ */
 function pruneDead(registry = loadRegistry()) {
 	let changed = false;
 	for (const [id, entry] of Object.entries(registry)) {
-		if (!entry?.pid || !isAlive(entry.pid)) {
-			delete registry[id];
+		if (entry?.pid && !isAlive(entry.pid)) {
+			registry[id] = { ...entry, pid: null };
 			changed = true;
 		}
 	}
@@ -233,10 +244,10 @@ function stopNode(id, fallbackPort = null) {
 	let signalled = false;
 
 	let pid = entry?.pid && isAlive(entry.pid) ? entry.pid : null;
+	const port = fallbackPort ?? (entry?.port ? Number(entry.port) : null);
 
-	if (!pid) {
-		const port = fallbackPort ?? (entry?.port ? Number(entry.port) : null);
-		if (port) pid = findPidOnPort(port);
+	if (!pid && port) {
+		pid = findPidOnPort(port);
 	}
 
 	if (pid) {
@@ -245,11 +256,53 @@ function stopNode(id, fallbackPort = null) {
 			signalled = true;
 		} catch {}
 	}
-	delete registry[id];
+
+	// Keep the port on record (clearing only the pid) so a later Start reuses
+	// the same port instead of falling back to the runner's URL — which may
+	// not even have an explicit port — or a hardcoded default.
+	if (port) {
+		registry[id] = { ...entry, pid: null, port: String(port) };
+	} else {
+		delete registry[id];
+	}
 	saveRegistry(registry);
 	return signalled;
 }
 
+/**
+ * Frees a TCP port by killing whatever process is bound to it, so Start can't
+ * fail with EADDRINUSE against a stale/orphaned process this manager lost
+ * track of (e.g. one that ignored SIGTERM from a previous stop, or was never
+ * in the registry to begin with). SIGTERM first, escalating to SIGKILL if the
+ * process is still alive after a short grace period.
+ *
+ * Returns true if a process was found (and signalled), false if the port was
+ * already free.
+ */
+async function killPort(port) {
+	let pid = findPidOnPort(port);
+	if (!pid) return false;
+
+	try {
+		process.kill(pid, 'SIGTERM');
+	} catch {}
+
+	const deadline = Date.now() + 2000;
+	while (Date.now() < deadline && isAlive(pid)) {
+		await new Promise((resolve) => setTimeout(resolve, 150));
+	}
+
+	pid = findPidOnPort(port);
+	if (pid && isAlive(pid)) {
+		try {
+			process.kill(pid, 'SIGKILL');
+		} catch {}
+		await new Promise((resolve) => setTimeout(resolve, 200));
+	}
+
+	return true;
+}
+
 module.exports = {
 	BACKEND_DIR,
 	LOGS_DIR,
@@ -260,6 +313,7 @@ module.exports = {
 	isLocalUrl,
 	parsePort,
 	findPidOnPort,
+	killPort,
 	pruneDead,
 	statusOf,
 	prepareEnv,

package/backend/logs/runner-cmrkl8sym0000qy01euz4270n.log

@@ -0,0 +1,18 @@
+/*
+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/.
+*/
+📂 Loading tests from: /Users/silverlunah/Projects/plum/backend/tests
+Backend running on port 3996 (node/runner mode)

package/backend/logs/runner-cmrkl9oyx0001qy0137nzr94d.log

@@ -0,0 +1,18 @@
+/*
+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/.
+*/
+📂 Loading tests from: /Users/silverlunah/Projects/plum/backend/tests
+Backend running on port 3996 (node/runner mode)

package/backend/scripts/manage-runners.mjs

@@ -40,7 +40,8 @@ const {
 	prepareEnv,
 	startNode,
 	stopNode,
-	findPidOnPort
+	findPidOnPort,
+	killPort
 } = runnerProcess;
 const { generateToken, registerWithPrimary, detectLanIp } = nodeRegister;
 
@@ -203,15 +204,26 @@ async function runAction(r) {
 	const action = await clack.select({ message: `${r.name} — ${r.url}`, options });
 	if (cancelled(action) || action === 'back') return;
 
-	const port = parsePort(r.url);
+	// Prefer the port this runner actually last ran on (remembered in the
+	// local registry even after being stopped) over parsing the URL — the URL
+	// may not carry an explicit port at all, and would otherwise silently fall
+	// back to the primary's own default port.
+	const remembered = runnerProcess.loadRegistry()[r.id]?.port;
+	const port = remembered || parsePort(r.url);
 
 	if (action === 'start') {
+		const s = clack.spinner();
+		s.start(`Freeing port ${port}...`);
+		const killed = await killPort(Number(port));
+		s.stop(killed ? pc.dim(`Freed port ${port}`) : pc.dim(`Port ${port} was already free`));
+
 		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') {
 		if (r.managed) {
 			const ok = stopNode(r.id);
+			await killPort(Number(port));
 			clack.log.success(
 				ok ? pc.green(`Stopped "${r.name}"`) : pc.dim(`"${r.name}" was not running`)
 			);
@@ -223,6 +235,11 @@ async function runAction(r) {
 				s.stop(pc.green(`Stopped "${r.name}"`));
 			} catch (e) {
 				s.stop(pc.red(`Could not stop "${r.name}": ${e.message}`));
+			} finally {
+				// Belt-and-suspenders: if this runner happens to be local (or
+				// the network shutdown call above silently failed), make sure
+				// nothing is left bound to its port.
+				await killPort(Number(port));
 			}
 		}
 	} else if (action === 'restart') {
@@ -230,7 +247,7 @@ async function runAction(r) {
 			const s = clack.spinner();
 			s.start(`Restarting "${r.name}"...`);
 			stopNode(r.id);
-			await new Promise((resolve) => setTimeout(resolve, 600));
+			await killPort(Number(port));
 			const entry = startNode({ id: r.id, port, token: r.token });
 			s.stop(pc.green(`Restarted "${r.name}" (pid ${entry.pid})`));
 		} else {

package/backend/server.js

@@ -92,16 +92,30 @@ async function start() {
 					try {
 						const reg = loadRegistry();
 						// A self-restart already wrote the replacement's pid under this
-						// id before this process exits — only clear the entry if it's
-						// still ours, so we don't erase the new process's registration.
+						// id before this process exits — only touch the entry if it's
+						// still ours, so we don't clobber the new process's registration.
+						// Keep the entry (with its port) rather than deleting it — that's
+						// the only place a later manual Start can find the port this
+						// runner was last running on.
 						if (reg[runnerId]?.pid === process.pid) {
-							delete reg[runnerId];
+							reg[runnerId] = { ...reg[runnerId], pid: null };
 							saveRegistry(reg);
 						}
 					} catch {}
 				};
-				process.once('SIGTERM', cleanup);
-				process.once('SIGINT', cleanup);
+				// Adding a SIGTERM/SIGINT listener suppresses Node's default
+				// "terminate immediately" behavior — the handler must exit itself,
+				// or the process (and the port it's bound to) lives on forever
+				// after a plain `kill`/SIGTERM with nothing left to stop it short
+				// of SIGKILL.
+				process.once('SIGTERM', () => {
+					cleanup();
+					process.exit(0);
+				});
+				process.once('SIGINT', () => {
+					cleanup();
+					process.exit(0);
+				});
 				process.once('exit', cleanup);
 			}
 			return;

package/package.json

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