plum-e2e 2.5.8 → 2.5.10

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/mcp/server.js

@@ -67,6 +67,7 @@ async function api(method, path, body) {
 const get = (path) => api('GET', path);
 const post = (path, body) => api('POST', path, body);
 const put = (path, body) => api('PUT', path, body);
+const del = (path) => api('DELETE', path);
 
 // ---------------------------------------------------------------------------
 // Polling helper for test runs
@@ -176,6 +177,33 @@ server.tool(
 	}
 );
 
+server.tool(
+	'update_test_suite',
+	"Update a test suite's name, description, or priority. Only the fields provided are changed.",
+	{
+		suiteId: z.string().describe('UUID of the suite to update'),
+		name: z.string().min(1).optional(),
+		description: z.string().optional(),
+		priority: z.enum(['Critical', 'High', 'Medium', 'Low']).optional()
+	},
+	async ({ suiteId, name, description, priority }) => {
+		const data = await put(`/test-suites/${suiteId}`, { name, description, priority });
+		return { content: [{ type: 'text', text: JSON.stringify(data.suite, null, 2) }] };
+	}
+);
+
+server.tool(
+	'delete_test_suite',
+	'Permanently delete a test suite and all of its test cases. This cannot be undone.',
+	{
+		suiteId: z.string().describe('UUID of the suite to delete')
+	},
+	async ({ suiteId }) => {
+		await del(`/test-suites/${suiteId}`);
+		return { content: [{ type: 'text', text: `Suite ${suiteId} deleted.` }] };
+	}
+);
+
 // -- Test Repository: Cases -------------------------------------------------
 
 server.tool(
@@ -193,6 +221,45 @@ server.tool(
 	}
 );
 
+server.tool(
+	'get_test_case',
+	'Get a test case by ID, including its manual steps and recent execution history.',
+	{
+		caseId: z.string().describe('UUID of the test case')
+	},
+	async ({ caseId }) => {
+		const data = await get(`/test-cases/${caseId}`);
+		return { content: [{ type: 'text', text: JSON.stringify(data.testCase, null, 2) }] };
+	}
+);
+
+server.tool(
+	'update_test_case',
+	"Update a test case's title, description, or priority. Only the fields provided are changed.",
+	{
+		caseId: z.string().describe('UUID of the test case to update'),
+		title: z.string().min(1).optional(),
+		description: z.string().optional(),
+		priority: z.enum(['Critical', 'High', 'Medium', 'Low']).optional()
+	},
+	async ({ caseId, title, description, priority }) => {
+		const data = await put(`/test-cases/${caseId}`, { title, description, priority });
+		return { content: [{ type: 'text', text: JSON.stringify(data.testCase, null, 2) }] };
+	}
+);
+
+server.tool(
+	'delete_test_case',
+	'Permanently delete a test case and its steps. This cannot be undone.',
+	{
+		caseId: z.string().describe('UUID of the test case to delete')
+	},
+	async ({ caseId }) => {
+		await del(`/test-cases/${caseId}`);
+		return { content: [{ type: 'text', text: `Test case ${caseId} deleted.` }] };
+	}
+);
+
 server.tool(
 	'set_test_steps',
 	'Set (replace) the manual test steps for a test case. Each step has an action, optional test data, and optional expected output.',

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.8",
+	"version": "2.5.10",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/silverlunah/plum.git"