claudeup 6.0.0 → 6.2.0

package/src/__tests__/shell-script-callers.test.ts

@@ -0,0 +1,92 @@
+/**
+ * `runShellScript` has exactly one legitimate caller, and this pins it.
+ *
+ * The whole of item 3 is the split between two ways of running a child process:
+ * argv (`runCommand`), which no shell ever sees, and a script (`runShellScript`),
+ * which `/bin/sh` parses. Every installer command belongs to the first, because
+ * it is assembled from package names that arrive in `.claude/profiles.json` and
+ * plugin `requires.bin` — hand-authored, committed by teammates, fetched from
+ * marketplaces, validated by nothing. The second exists only for the two
+ * `TOOLCHAIN_BOOTSTRAP` values, which are constants in this repo copied from
+ * bun.sh and brew.sh and which genuinely contain a pipe and a command
+ * substitution.
+ *
+ * Nothing in the type system distinguishes them — both are strings — so after
+ * the commit lands, the design decision is enforced by this test or by nothing.
+ * A branded `ShellScript` type would enforce it at compile time and was
+ * considered; for one map, two entries and one call site it is more machinery
+ * than the rule is worth, and unlike a brand this is greppable.
+ *
+ * Source-scanning precedent in this suite: `uppercase-keybindings.test.ts`.
+ */
+
+import { describe, expect, test } from "bun:test";
+import path from "node:path";
+import fs from "fs-extra";
+
+const SRC_DIR = path.join(import.meta.dir, "..");
+
+/** Files permitted to call `runShellScript`, relative to `src/`. */
+const ALLOWED = ["cli/install.ts"];
+
+/** The definition itself, plus this test, are not callers. */
+const NOT_CALLERS = ["utils/run.ts", "__tests__/shell-script-callers.test.ts"];
+
+async function sourceFiles(dir: string): Promise<string[]> {
+	const out: string[] = [];
+	for (const entry of await fs.readdir(dir, { withFileTypes: true })) {
+		const full = path.join(dir, entry.name);
+		if (entry.isDirectory()) out.push(...(await sourceFiles(full)));
+		else if (/\.tsx?$/.test(entry.name)) out.push(full);
+	}
+	return out;
+}
+
+const isComment = (line: string) => {
+	const t = line.trim();
+	return t.startsWith("//") || t.startsWith("*") || t.startsWith("/*");
+};
+
+async function callersOf(pattern: RegExp): Promise<string[]> {
+	const found = new Set<string>();
+	for (const file of await sourceFiles(SRC_DIR)) {
+		const rel = path.relative(SRC_DIR, file);
+		if (NOT_CALLERS.includes(rel)) continue;
+		const text = await fs.readFile(file, "utf8");
+		for (const line of text.split("\n")) {
+			if (isComment(line)) continue;
+			if (pattern.test(line)) found.add(rel);
+		}
+	}
+	return [...found].sort();
+}
+
+describe("only the toolchain bootstrap goes through a shell", () => {
+	test("runShellScript is called from exactly the allowed files", async () => {
+		expect(await callersOf(/\brunShellScript\(/)).toEqual(ALLOWED);
+	});
+
+	test("nothing spawns with `shell: true` outside utils/run.ts", async () => {
+		// Catches someone reaching for `spawn`/`exec` directly rather than
+		// through the seam — a second shell path that never names
+		// `runShellScript`.
+		//
+		// Scope, stated honestly: this checks `shell: true` only. Several
+		// version-DETECTION helpers in CliToolsScreen still pass
+		// `shell: "/bin/bash"` to run pipelines like `which -a x 2>/dev/null`.
+		// Those interpolate a catalogue `name`, not an installer command, and
+		// were out of scope here — so this assertion would be false if it
+		// claimed no shell exists anywhere.
+		expect(await callersOf(/shell:\s*true/)).toEqual([]);
+	});
+
+	test("the scan can actually fail", async () => {
+		// Negative control. The two assertions above pass trivially if the walk
+		// finds nothing or the pattern never matches, and a check that cannot
+		// fail is not evidence. `runCommand(` is known to be called from several
+		// files, so a working scan must find them.
+		const runCommandCallers = await callersOf(/\brunCommand\(/);
+		expect(runCommandCallers.length).toBeGreaterThan(0);
+		expect(runCommandCallers).toContain("cli/install.ts");
+	});
+});

package/src/__tests__/toolchain.test.ts

@@ -1,34 +1,101 @@
 import { describe, expect, test } from "bun:test";
 import {
+	PYTHON_CLI_INSTALLERS,
+	type PythonCliInstaller,
 	binInstallCommand,
 	binUpgradeCommand,
 	detectToolchains,
+	resolvePythonCliInstaller,
 } from "../services/toolchain.js";
 import type { ResolvedBin } from "../types/index.js";
+import { formatCommand } from "../utils/command-utils.js";
+
+/**
+ * Pin a Python installer explicitly in every `via: "pip"` assertion.
+ *
+ * The production default is resolved from PATH, so asserting a literal command
+ * would encode whatever happens to be installed on the machine running the
+ * suite — green here, red on a runner without uv.
+ */
+const byProbe = (probe: string): PythonCliInstaller => {
+	const found = PYTHON_CLI_INSTALLERS.find((i) => i.probe === probe);
+	if (!found) throw new Error(`no python installer with probe ${probe}`);
+	return found;
+};
+const UV = byProbe("uv");
+const PIPX = byProbe("pipx");
+const PY = byProbe("python3");
 
 describe("binInstallCommand", () => {
 	test("bun with and without a version pin", () => {
-		expect(binInstallCommand({ name: "claudish", via: "bun", package: "claudish", version: "1.2.0" })).toBe(
-			"bun install -g claudish@1.2.0",
-		);
-		expect(binInstallCommand({ name: "claudish", via: "bun" })).toBe(
-			"bun install -g claudish",
-		);
+		expect(
+			formatCommand(
+				binInstallCommand({
+					name: "claudish",
+					via: "bun",
+					package: "claudish",
+					version: "1.2.0",
+				}),
+			),
+		).toBe("bun install -g claudish@1.2.0");
+		expect(
+			formatCommand(binInstallCommand({ name: "claudish", via: "bun" })),
+		).toBe("bun install -g claudish");
+	});
+
+	test("the package name is ONE argv token, whatever is in it", () => {
+		// `bin.package` is hand-authored data — it arrives from
+		// `.claude/profiles.json` and from plugin `requires.bin`, committed by
+		// teammates and fetched from marketplaces, and nothing validates it.
+		// While commands were strings handed to `/bin/sh`, this string was four
+		// words and a command separator. As argv it cannot be anything but a
+		// (nonexistent) package name, so the install fails instead of running.
+		const evil = "a b; rm -rf /";
+		const cmd = binInstallCommand({ name: "x", via: "bun", package: evil });
+		expect(cmd.cmd).toBe("bun");
+		expect(cmd.args).toEqual(["install", "-g", evil]);
+		expect(cmd.args.at(-1)).toBe(evil); // unsplit: still exactly one token
+		// ...and rendering it for display quotes it rather than emitting syntax.
+		expect(formatCommand(cmd)).toBe("bun install -g 'a b; rm -rf /'");
+	});
+
+	test("a version pin joins the package as one token, not two", () => {
+		// Splitting `pkg@version` would ask the installer for two packages, the
+		// second of which is a version number.
+		const cmd = binInstallCommand({
+			name: "claudish",
+			via: "bun",
+			version: "1.2.0",
+		});
+		expect(cmd.args.at(-1)).toBe("claudish@1.2.0");
 	});
 
 	test("npm, pip, brew, go each render correctly", () => {
-		expect(binInstallCommand({ name: "x", via: "npm", package: "x" })).toBe(
-			"npm install -g x",
-		);
-		expect(binInstallCommand({ name: "aider", via: "pip", package: "aider", version: "0.1" })).toBe(
-			"pip install aider==0.1",
-		);
-		expect(binInstallCommand({ name: "tmux", via: "brew", formula: "tmux" })).toBe(
-			"brew install tmux",
-		);
-		expect(binInstallCommand({ name: "t", via: "go", module: "github.com/x/t" })).toBe(
-			"go install github.com/x/t@latest",
-		);
+		// Rendered, not raw, because these literals are also the display-
+		// neutrality claim: every token here is shell-safe, so `formatCommand`
+		// quotes nothing and the printed line is byte-identical to the string
+		// these builders returned before they returned argv.
+		expect(
+			formatCommand(binInstallCommand({ name: "x", via: "npm", package: "x" })),
+		).toBe("npm install -g x");
+		expect(
+			formatCommand(
+				binInstallCommand(
+					{ name: "aider", via: "pip", package: "aider", version: "0.1" },
+					UV,
+				),
+			),
+		).toBe("uv tool install aider==0.1");
+		expect(
+			formatCommand(
+				binInstallCommand({ name: "tmux", via: "brew", formula: "tmux" }),
+			),
+		).toBe("brew install tmux");
+		expect(
+			formatCommand(
+				binInstallCommand({ name: "t", via: "go", module: "github.com/x/t" }),
+			),
+		).toBe("go install github.com/x/t@latest");
 	});
 });
 
@@ -38,26 +105,104 @@ describe("binUpgradeCommand", () => {
 		// installed formula prints "already installed" and changes nothing, and
 		// `pip install` without --upgrade does the same. Reusing them would let
 		// `claudeup update` report success while advancing nothing.
-		expect(binUpgradeCommand({ name: "tmux", via: "brew", formula: "tmux" })).toBe(
-			"brew upgrade tmux",
-		);
-		expect(binUpgradeCommand({ name: "aider", via: "pip", package: "aider" })).toBe(
-			"pip install --upgrade aider",
-		);
+		expect(
+			formatCommand(
+				binUpgradeCommand({ name: "tmux", via: "brew", formula: "tmux" }),
+			),
+		).toBe("brew upgrade tmux");
+		expect(
+			formatCommand(
+				binUpgradeCommand({ name: "aider", via: "pip", package: "aider" }, PY),
+			),
+		).toBe("python3 -m pip install --user --upgrade aider");
+		expect(
+			formatCommand(
+				binUpgradeCommand({ name: "aider", via: "pip", package: "aider" }, UV),
+			),
+		).toBe("uv tool install --force --upgrade aider");
+	});
+
+	test("every Python installer distinguishes install from upgrade", () => {
+		// The same trap as brew: `uv tool install` on an already-installed tool
+		// is a no-op, so reusing the install command would report success while
+		// advancing nothing.
+		for (const python of PYTHON_CLI_INSTALLERS) {
+			const bin = { name: "aider", via: "pip" as const, package: "aider" };
+			// Compared RENDERED. Two `Command` objects are never `toBe`-equal —
+			// they are distinct references — so comparing them directly would be
+			// an assertion that cannot fail.
+			expect(formatCommand(binUpgradeCommand(bin, python))).not.toBe(
+				formatCommand(binInstallCommand(bin, python)),
+			);
+		}
+	});
+});
+
+describe("resolvePythonCliInstaller", () => {
+	test("never emits a bare `pip`", () => {
+		// The bug this exists for: `pip` is frequently a zsh ALIAS for pip3 and
+		// no such executable exists. Commands were spawned through /bin/sh, which
+		// sources no profile, so this died with `/bin/sh: pip: command not found`
+		// on a machine where typing `pip` at a prompt works.
+		//
+		// Now that a command is argv, `cmd` is the exact executable that gets
+		// looked up on PATH — so asserting on it is asserting on the syscall,
+		// not on a string a shell might later re-read.
+		for (const python of PYTHON_CLI_INSTALLERS) {
+			for (const cmd of [python.install("x"), python.upgrade("x")]) {
+				expect(cmd.cmd).not.toBe("pip");
+				expect(cmd.cmd).toBe(python.probe);
+			}
+		}
+	});
+
+	test("prefers an isolated-venv installer over the system interpreter", () => {
+		// `pip install` into a Homebrew interpreter is refused outright by PEP
+		// 668 (`externally-managed-environment`), so uv and pipx must outrank it.
+		const order = PYTHON_CLI_INSTALLERS.map((i) => i.probe);
+		expect(order.indexOf("uv")).toBeLessThan(order.indexOf("python3"));
+		expect(order.indexOf("pipx")).toBeLessThan(order.indexOf("python3"));
+	});
+
+	test("always resolves to something, and to one of the known options", () => {
+		// Returning null would force every caller to handle "no installer",
+		// which in practice means printing nothing and silently skipping.
+		const resolved = resolvePythonCliInstaller();
+		expect(PYTHON_CLI_INSTALLERS).toContain(resolved);
+	});
+
+	test("a version pin is expressed in the installer's own syntax", () => {
+		expect(
+			formatCommand(
+				binInstallCommand({ name: "a", via: "pip", version: "1.2" }, UV),
+			),
+		).toBe("uv tool install a==1.2");
+		expect(
+			formatCommand(
+				binInstallCommand({ name: "a", via: "pip", version: "1.2" }, PIPX),
+			),
+		).toBe("pipx install a==1.2");
+		// `a==1.2` is one token. Two would ask uv to install a package called
+		// "1.2".
+		expect(
+			binInstallCommand({ name: "a", via: "pip", version: "1.2" }, UV).args,
+		).toEqual(["tool", "install", "a==1.2"]);
 	});
 
 	test("bun and npm state @latest explicitly, so the printed command reads true", () => {
-		expect(binUpgradeCommand({ name: "claudish", via: "bun" })).toBe(
-			"bun install -g claudish@latest",
-		);
-		expect(binUpgradeCommand({ name: "x", via: "npm", package: "x" })).toBe(
-			"npm install -g x@latest",
-		);
+		expect(
+			formatCommand(binUpgradeCommand({ name: "claudish", via: "bun" })),
+		).toBe("bun install -g claudish@latest");
+		expect(
+			formatCommand(binUpgradeCommand({ name: "x", via: "npm", package: "x" })),
+		).toBe("npm install -g x@latest");
 	});
 
 	test("go installs the module at latest", () => {
 		expect(
-			binUpgradeCommand({ name: "t", via: "go", module: "github.com/x/t" }),
+			formatCommand(
+				binUpgradeCommand({ name: "t", via: "go", module: "github.com/x/t" }),
+			),
 		).toBe("go install github.com/x/t@latest");
 	});
 });

package/src/__tests__/ui-version-writers.test.ts

@@ -0,0 +1,88 @@
+/**
+ * The UI records a plugin version only through a function that read it back.
+ *
+ * `installedPluginVersions` is claudeup's own bookkeeping — the Claude CLI does
+ * not maintain it — and `install --check` reads it to decide whether a machine
+ * has drifted from its profile. So a version written from an EXPECTATION rather
+ * than from disk is not a cosmetic inaccuracy: the drift gate ends up comparing
+ * a number against a copy of itself and reporting clean forever. That is what
+ * PluginsScreen's install branches did, via a local `saveVersionForScope`
+ * helper that duplicated `plugin-manager.ts`'s scope dispatcher and took the
+ * version as a parameter.
+ *
+ * Deleting the helper removed the UI's *ability* to make that mistake. This
+ * test is what keeps it removed: a screen may still install and update, but
+ * only through `installPluginInScope`, which reads the version off disk and
+ * writes nothing when it cannot.
+ *
+ * A source scan rather than a behavioural test because these are `.tsx` screens
+ * this suite cannot render. It encodes the rule directly instead of the symptom
+ * — the precedent for source-scanning guards here is
+ * `uppercase-keybindings.test.ts`.
+ */
+
+import { describe, expect, test } from "bun:test";
+import path from "node:path";
+import fs from "fs-extra";
+
+const UI_DIR = path.join(import.meta.dir, "..", "ui");
+
+/** The version writers that take the number on trust from their caller. */
+const RAW_WRITERS = [
+	"saveGlobalInstalledPluginVersion",
+	"saveLocalInstalledPluginVersion",
+	"saveInstalledPluginVersion",
+	"saveInstalledPluginVersionForScope",
+];
+
+async function uiSourceFiles(dir: string): Promise<string[]> {
+	const out: string[] = [];
+	for (const entry of await fs.readdir(dir, { withFileTypes: true })) {
+		const full = path.join(dir, entry.name);
+		if (entry.isDirectory()) out.push(...(await uiSourceFiles(full)));
+		else if (/\.tsx?$/.test(entry.name)) out.push(full);
+	}
+	return out;
+}
+
+const isComment = (line: string) => {
+	const t = line.trim();
+	return t.startsWith("//") || t.startsWith("*") || t.startsWith("/*");
+};
+
+describe("no UI file writes a plugin version it did not read back", () => {
+	test("the raw version writers are absent from src/ui", async () => {
+		const files = await uiSourceFiles(UI_DIR);
+		expect(files.length).toBeGreaterThan(10); // guard: the walk found real files
+
+		const offenders: string[] = [];
+		for (const file of files) {
+			const text = await fs.readFile(file, "utf8");
+			text.split("\n").forEach((line, i) => {
+				if (isComment(line)) return;
+				for (const writer of RAW_WRITERS) {
+					// Word-bounded: `saveInstalledPluginVersion` is a prefix of
+					// `saveInstalledPluginVersionForScope`, and both are banned, so a
+					// substring match would just double-report the same line.
+					if (new RegExp(`\\b${writer}\\b`).test(line)) {
+						offenders.push(
+							`${path.relative(UI_DIR, file)}:${i + 1}  ${line.trim()}`,
+						);
+					}
+				}
+			});
+		}
+
+		expect(offenders).toEqual([]);
+	});
+
+	test("the guard can actually fail", () => {
+		// Negative control. The assertion above passes trivially if the walk or
+		// the pattern is broken, and a guard that cannot fail is not evidence.
+		const line = "\t\t\tawait saveGlobalInstalledPluginVersion(id, version);";
+		expect(isComment(line)).toBe(false);
+		expect(RAW_WRITERS.some((w) => new RegExp(`\\b${w}\\b`).test(line))).toBe(
+			true,
+		);
+	});
+});

package/src/__tests__/update-apply.test.ts

@@ -7,7 +7,12 @@
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
-import { type PluginApplyDeps, applyPlugins } from "../cli/update.js";
+import {
+	type PluginApplyDeps,
+	applyPlugins,
+	installPluginInScope,
+	updatePluginInScope,
+} from "../services/update-engine.js";
 import type { PluginScope } from "../services/claude-cli.js";
 import type { PluginUpdateItem } from "../services/update-plan.js";
 
@@ -18,10 +23,14 @@ function stubDeps(
 	installedAfter: string | null | ((scope: PluginScope) => string | null),
 ) {
 	const saved: Array<{ id: string; version: string; scope: PluginScope }> = [];
+	const installed: Array<{ id: string; scope: PluginScope }> = [];
 	const updated: Array<{ id: string; scope: PluginScope }> = [];
 	const repaired: Array<{ id: string; scope: PluginScope }> = [];
 
 	const deps: PluginApplyDeps = {
+		install: mock(async (id: string, scope: PluginScope) => {
+			installed.push({ id, scope });
+		}),
 		update: mock(async (id: string, scope: PluginScope) => {
 			updated.push({ id, scope });
 		}),
@@ -39,7 +48,7 @@ function stubDeps(
 			},
 		),
 	};
-	return { deps, saved, updated, repaired };
+	return { deps, saved, installed, updated, repaired };
 }
 
 function item(over: Partial<PluginUpdateItem>): PluginUpdateItem {
@@ -128,13 +137,77 @@ describe("what gets RECORDED is what got installed", () => {
 
 describe("scope handling", () => {
 	test("a fresh install goes to project scope only", async () => {
-		const { deps, updated } = stubDeps("2.0.0");
+		const { deps, installed } = stubDeps("2.0.0");
 		await applyPlugins(
 			[item({ action: "install", installed: null, scopes: [] })],
 			PROJECT,
 			deps,
 		);
+		expect(installed).toEqual([{ id: "dev@magus", scope: "project" }]);
+	});
+
+	// Three actions, three Claude Code commands, each a silent no-op in the
+	// other two cases. Folding `install` and `update` together is what made
+	// every claudeup update path exit 0 having changed nothing: measured on
+	// Claude Code 2.1.252, `claude plugin install designer@magus --scope
+	// project` answers "already installed" and leaves 0.6.0 in place while
+	// 0.6.1 is published, and `claude plugin update` is the command that moves
+	// it. The reverse holds too — `update` on a plugin absent from the scope
+	// answers "already at the latest version" and installs nothing — so this
+	// asserts BOTH directions, not just the one that was broken.
+
+	test("an update runs `update`, never `install`", async () => {
+		const { deps, installed, updated } = stubDeps("2.0.0");
+		await applyPlugins([item({ action: "update" })], PROJECT, deps);
 		expect(updated).toEqual([{ id: "dev@magus", scope: "project" }]);
+		expect(installed).toEqual([]);
+	});
+
+	test("an update with NO row for this project installs instead", async () => {
+		// `claude plugin update --scope project` resolves the project from the
+		// working directory, and with no row there it updates some OTHER
+		// project's row instead. Measured on 2.1.252 from a directory holding no
+		// madbench row, it moved /Users/jack/mag/tmux-mcp — a project nobody
+		// named. Live for git worktrees, which inherit the parent repo's version
+		// while owning no row of their own.
+		const { deps, installed, updated } = stubDeps(null);
+		await applyPlugins([item({ action: "update" })], PROJECT, deps);
+		expect(installed).toEqual([{ id: "dev@magus", scope: "project" }]);
+		expect(updated).toEqual([]);
+	});
+
+	test("the row check is per scope, not per plugin", async () => {
+		// user scope holds a row, project scope does not: one must update and
+		// the other install, in the same pass.
+		const { deps, installed, updated } = stubDeps((scope) =>
+			scope === "user" ? "1.5.0" : null,
+		);
+		await applyPlugins([item({ scopes: ["user", "project"] })], PROJECT, deps);
+		expect(updated).toEqual([{ id: "dev@magus", scope: "user" }]);
+		expect(installed).toEqual([{ id: "dev@magus", scope: "project" }]);
+	});
+
+	test("a fresh install runs `install`, never `update`", async () => {
+		const { deps, installed, updated } = stubDeps("2.0.0");
+		await applyPlugins(
+			[item({ action: "install", installed: null, scopes: [] })],
+			PROJECT,
+			deps,
+		);
+		expect(installed).toEqual([{ id: "dev@magus", scope: "project" }]);
+		expect(updated).toEqual([]);
+	});
+
+	test("a repair runs neither — content drift needs uninstall+install", async () => {
+		const { deps, installed, updated, repaired } = stubDeps("1.0.0");
+		await applyPlugins(
+			[item({ action: "repair", target: "1.0.0", scopes: ["project"] })],
+			PROJECT,
+			deps,
+		);
+		expect(repaired).toEqual([{ id: "dev@magus", scope: "project" }]);
+		expect(installed).toEqual([]);
+		expect(updated).toEqual([]);
 	});
 
 	test("every outdated scope is updated AND recorded separately", async () => {
@@ -221,3 +294,64 @@ describe("failure handling", () => {
 		expect(result.ok).toBe(0);
 	});
 });
+
+describe("installPluginInScope — a fresh install records what landed", () => {
+	// The TUI's install branches called the CLI directly and then wrote the
+	// version they had ASKED for. A marketplace serves whatever it publishes at
+	// the moment of the call, so that number was a guess — and `install --check`
+	// reads back the same field, so it compared the guess against a copy of
+	// itself and reported clean forever. Routing installs through the read-back
+	// the update branches already used is what closes it.
+	//
+	// The read-back semantics are pinned in cli-apply-seams.test.ts
+	// ("installPluginInScope — the scope-targeted path"). What these add is the
+	// property that makes the whole class of bug unrepresentable rather than
+	// merely absent right now.
+
+	test("takes no version parameter, so a caller cannot supply a wrong one", () => {
+		// Arity, not behaviour — and that is the point. Re-adding a `version`
+		// argument would reopen the defect without failing any behavioural test,
+		// because the new parameter would simply be believed.
+		// (pluginId, scope, projectPath, deps = REAL_PLUGIN_DEPS) — the defaulted
+		// parameter is not counted by Function.length.
+		expect(installPluginInScope.length).toBe(3);
+	});
+
+	test("saves the version read back, not one the caller chose", async () => {
+		const { deps, saved } = stubDeps("9.9.9");
+		await installPluginInScope("dev@magus", "user", PROJECT, deps);
+		expect(saved).toEqual([
+			{ id: "dev@magus", version: "9.9.9", scope: "user" },
+		]);
+	});
+
+	test("an unreadable version writes nothing at all", async () => {
+		// Never guess. A missing record is recoverable; a wrong one is not,
+		// because nothing downstream can tell it from a true one.
+		const { deps, saved } = stubDeps(null);
+		expect(
+			await installPluginInScope("dev@magus", "user", PROJECT, deps),
+		).toBeNull();
+		expect(saved).toEqual([]);
+	});
+
+	// The scope menu's update branch went through the install helper for as
+	// long as both issued `claude plugin install`. They no longer do, so the
+	// two helpers must reach different commands or the menu silently no-ops
+	// exactly the way "update all" did.
+	test("the install helper runs `install`, the update helper runs `update`", async () => {
+		const a = stubDeps("2.0.0");
+		await installPluginInScope("dev@magus", "user", PROJECT, a.deps);
+		expect(a.installed).toEqual([{ id: "dev@magus", scope: "user" }]);
+		expect(a.updated).toEqual([]);
+
+		const b = stubDeps("2.0.0");
+		await updatePluginInScope("dev@magus", "user", PROJECT, b.deps);
+		expect(b.updated).toEqual([{ id: "dev@magus", scope: "user" }]);
+		expect(b.installed).toEqual([]);
+	});
+
+	test("the update helper takes no version parameter either", () => {
+		expect(updatePluginInScope.length).toBe(3);
+	});
+});

package/src/cli/install.ts

@@ -47,9 +47,10 @@ import type {
 	ResolvedClosure,
 	SkillInfo,
 } from "../types/index.js";
-import { resolveExecutable } from "../utils/command-utils.js";
+import { formatCommand, resolveExecutable } from "../utils/command-utils.js";
 import { ensureManifest } from "./bootstrap.js";
-import { confirm, promptValue, runShell } from "./prompt.js";
+import { confirm, promptValue } from "./prompt.js";
+import { runCommand, runShellScript } from "../utils/run.js";
 
 interface InstallFlags {
 	check: boolean;
@@ -125,7 +126,10 @@ async function ensureToolchains(
 			));
 		if (ok) {
 			console.log(`Installing ${tc.name}…`);
-			if (!(await runShell(bootstrap))) {
+			// A bootstrap line IS shell text — bun's contains a pipe, Homebrew's a
+			// command substitution — and it is a constant in this repo, not
+			// profile data. This is the only legitimate caller.
+			if (!(await runShellScript(bootstrap))) {
 				console.warn(`⚠ Failed to install ${tc.name}. Continuing.`);
 			}
 		}
@@ -163,8 +167,10 @@ async function installBins(bins: ResolvedBin[]): Promise<void> {
 			continue; // already installed and runnable (not a dangling link)
 		}
 		const cmd = binInstallCommand(bin);
-		console.log(`+ ${bin.name}  (${cmd})`);
-		if (!(await runShell(cmd))) {
+		// Printed rendered, executed as argv. The package name in `cmd.args` came
+		// from a profile or a plugin manifest, so it must never reach a shell.
+		console.log(`+ ${bin.name}  (${formatCommand(cmd)})`);
+		if (!(await runCommand(cmd))) {
 			console.warn(`⚠ failed to install ${bin.name} via ${bin.via}`);
 		}
 	}

package/src/cli/prompt.ts

@@ -31,12 +31,3 @@ export async function promptValue(question: string): Promise<string> {
 	}
 }
 
-/** Run a shell command, streaming output; resolve true on exit 0. */
-export async function runShell(command: string): Promise<boolean> {
-	const { spawn } = await import("node:child_process");
-	return new Promise((resolve) => {
-		const child = spawn(command, { stdio: "inherit", shell: true });
-		child.on("exit", (code) => resolve(code === 0));
-		child.on("error", () => resolve(false));
-	});
-}

package/src/cli/update-view.ts

@@ -32,6 +32,7 @@ import type {
 } from "../services/update-plan.js";
 import { binInstallCommand, binUpgradeCommand } from "../services/toolchain.js";
 import { brand } from "../ui/theme.js";
+import { formatCommand } from "../utils/command-utils.js";
 import {
 	badge,
 	bold,
@@ -256,7 +257,9 @@ function binDetail(item: BinUpdateItem, plan: UpdatePlan): string {
 		item.action === "install"
 			? binInstallCommand(spec)
 			: binUpgradeCommand(spec);
-	return dim(cmd);
+	// Rendered for the reader's eyes only — this row says what WILL run, while
+	// applyBins runs the argv itself.
+	return dim(formatCommand(cmd));
 }
 
 /**