magus-cli 7.8.0 → 7.9.1

package/src/__tests__/plugin-setup.test.ts

@@ -1,1016 +0,0 @@
-/**
- * Tests for plugin-setup.ts: go package manager and required binary validator.
- *
- * Tests extractGoBinaryName (pure function), and uses module mocking to
- * verify installPluginDeps() and checkMissingDeps() behavior for `go`
- * and `required` setup keys.
- */
-
-import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
-import * as actualChildProcess from "node:child_process";
-import { chmod, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-// Real modules captured before the mock.module() overrides, so the mocks spread
-// the full surface instead of stripping exports (e.g. resolveExecutable) that
-// bun's global, non-restored mock.module would otherwise remove for later files.
-import * as actualCommandUtils from "../utils/command-utils.js";
-
-// ---------------------------------------------------------------------------
-// Mocks — must be set up BEFORE any import from plugin-setup
-// ---------------------------------------------------------------------------
-
-// Track which commands are "available" and what execFile calls return
-let availableBinaries: Set<string>;
-let execResults: Map<
-	string,
-	{ stdout: string; stderr: string; error?: boolean }
->;
-
-// Mock command-utils BEFORE importing plugin-setup
-mock.module("../utils/command-utils.js", () => ({
-	...actualCommandUtils,
-	which: async (cmd: string) => {
-		return availableBinaries.has(cmd) ? `/usr/bin/${cmd}` : null;
-	},
-}));
-
-// Mock child_process execFile — promisify wraps this callback-based API
-mock.module("node:child_process", () => ({
-	...actualChildProcess,
-	execFile: (
-		cmd: string,
-		args: string[],
-		opts: unknown,
-		cb?: (
-			err: Error | null,
-			result: { stdout: string; stderr: string },
-		) => void,
-	) => {
-		const key = `${cmd} ${args.join(" ")}`;
-
-		// Find matching result by prefix
-		let result = execResults.get(key);
-		if (!result) {
-			for (const [k, v] of execResults.entries()) {
-				if (key.startsWith(k)) {
-					result = v;
-					break;
-				}
-			}
-		}
-
-		if (!result) {
-			result = { stdout: "", stderr: "", error: false };
-		}
-
-		if (typeof cb === "function") {
-			if (result.error) {
-				const err = new Error(result.stderr) as Error & {
-					stdout: string;
-					stderr: string;
-				};
-				err.stdout = result.stdout;
-				err.stderr = result.stderr;
-				cb(err, { stdout: result.stdout, stderr: result.stderr });
-			} else {
-				cb(null, { stdout: result.stdout, stderr: result.stderr });
-			}
-		}
-	},
-}));
-
-// Import AFTER mocks are set up
-const {
-	extractGoBinaryName,
-	extractGoVersion,
-	extractBinaryName,
-	parseAtSpec,
-	parseGoSpec,
-	parsePipSpec,
-	goDepNeedsInstall,
-	goDepDecision,
-	parseGoEnv,
-	classifyInstallReach,
-	installPluginDeps,
-	checkMissingDeps,
-} = await import("../services/plugin-setup.js");
-
-// ---------------------------------------------------------------------------
-// 1. Pure function tests — extractGoBinaryName
-// ---------------------------------------------------------------------------
-
-describe("extractGoBinaryName", () => {
-	it("extracts binary name from module@version", () => {
-		expect(extractGoBinaryName("github.com/MadAppGang/tmux-mcp@latest")).toBe(
-			"tmux-mcp",
-		);
-	});
-
-	it("extracts binary name from module@semver", () => {
-		expect(extractGoBinaryName("github.com/user/tool@v1.2.3")).toBe("tool");
-	});
-
-	it("extracts binary name from module without version", () => {
-		expect(extractGoBinaryName("github.com/user/tool")).toBe("tool");
-	});
-
-	it("handles single-segment package name", () => {
-		expect(extractGoBinaryName("mytool")).toBe("mytool");
-	});
-
-	it("handles module with nested path and version", () => {
-		expect(extractGoBinaryName("github.com/org/repo/cmd/mycli@v2.0.0")).toBe(
-			"mycli",
-		);
-	});
-
-	it("handles empty string gracefully", () => {
-		expect(extractGoBinaryName("")).toBe("");
-	});
-
-	// Negative control for the /vN fix: a plain basename returns "v2" here.
-	// Without the go-module helper wired in, this test FAILS.
-	it("names the binary after the module, not its /v2 major-version suffix", () => {
-		expect(
-			extractGoBinaryName("github.com/MadAppGang/tmux-mcp/v2@v2.0.0"),
-		).toBe("tmux-mcp");
-	});
-
-	it("strips the /v2 suffix from an unpinned module path too", () => {
-		expect(extractGoBinaryName("github.com/MadAppGang/tmux-mcp/v2")).toBe(
-			"tmux-mcp",
-		);
-	});
-
-	it("keeps a name that merely starts with v2", () => {
-		expect(extractGoBinaryName("github.com/x/v2tool@v1.0.0")).toBe("v2tool");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// 1b. parseGoSpec — the Go-specific view over parseAtSpec
-// ---------------------------------------------------------------------------
-
-describe("parseGoSpec", () => {
-	it("v1 module: name and pinned version", () => {
-		expect(parseGoSpec("github.com/MadAppGang/tmux-mcp@v1.7.1")).toEqual({
-			spec: "github.com/MadAppGang/tmux-mcp@v1.7.1",
-			name: "tmux-mcp",
-			version: "v1.7.1",
-		});
-	});
-
-	it("v2 module: the /v2 suffix is not the name, the version survives", () => {
-		expect(parseGoSpec("github.com/MadAppGang/tmux-mcp/v2@v2.0.0")).toEqual({
-			spec: "github.com/MadAppGang/tmux-mcp/v2@v2.0.0",
-			name: "tmux-mcp",
-			version: "v2.0.0",
-		});
-	});
-
-	it("v2 module without a pin: name resolved, version null", () => {
-		expect(parseGoSpec("github.com/MadAppGang/tmux-mcp/v2")).toEqual({
-			spec: "github.com/MadAppGang/tmux-mcp/v2",
-			name: "tmux-mcp",
-			version: null,
-		});
-	});
-
-	it("a segment that starts with v2 is a real name", () => {
-		expect(parseGoSpec("github.com/x/v2tool@v1.0.0")).toEqual({
-			spec: "github.com/x/v2tool@v1.0.0",
-			name: "v2tool",
-			version: "v1.0.0",
-		});
-	});
-
-	it("@latest is unpinned, same as parseAtSpec", () => {
-		expect(parseGoSpec("github.com/MadAppGang/tmux-mcp/v2@latest")).toEqual({
-			spec: "github.com/MadAppGang/tmux-mcp/v2@latest",
-			name: "tmux-mcp",
-			version: null,
-		});
-	});
-
-	// Terminal 5.0.0 contract cases (test plan Area 3, C5 and C6). They live
-	// here rather than in their own file because any test file that imports
-	// plugin-setup.js ahead of the mock.module seam above bakes the real
-	// execFile into promisify() and fails the installPluginDeps suites.
-	it("C5: a /v10 suffix is stripped in full, not only its first digit", () => {
-		const { name, version } = parseGoSpec("github.com/x/tool/v10@v10.1.0");
-		expect({ name, version }).toEqual({ name: "tool", version: "v10.1.0" });
-	});
-
-	it("C6: /v1 is never a Go major-version suffix, so it stays the name", () => {
-		const { name, version } = parseGoSpec("github.com/x/tool/v1@v1.0.0");
-		expect({ name, version }).toEqual({ name: "v1", version: "v1.0.0" });
-	});
-
-	it("C6 control: the same shape at /v2 is a suffix and is stripped", () => {
-		const { name, version } = parseGoSpec("github.com/x/tool/v2@v2.0.0");
-		expect({ name, version }).toEqual({ name: "tool", version: "v2.0.0" });
-	});
-});
-
-// ---------------------------------------------------------------------------
-// 2. Integration tests — installPluginDeps with go packages
-// ---------------------------------------------------------------------------
-
-describe("installPluginDeps — go packages", () => {
-	beforeEach(() => {
-		availableBinaries = new Set(["go"]); // go is available by default
-		execResults = new Map();
-	});
-
-	it("skips go packages when binary already exists", async () => {
-		availableBinaries.add("tmux-mcp");
-
-		const result = await installPluginDeps({
-			go: ["github.com/MadAppGang/tmux-mcp@latest"],
-		});
-
-		expect(result.skipped).toContain(
-			"go:github.com/MadAppGang/tmux-mcp@latest",
-		);
-		expect(result.installed).toHaveLength(0);
-		expect(result.failed).toHaveLength(0);
-	});
-
-	it("installs go packages when binary not found", async () => {
-		// go is available but tmux-mcp is not
-		execResults.set("/usr/bin/go install", {
-			stdout: "",
-			stderr: "",
-		});
-
-		const result = await installPluginDeps({
-			go: ["github.com/MadAppGang/tmux-mcp@latest"],
-		});
-
-		expect(result.installed).toContain(
-			"go:github.com/MadAppGang/tmux-mcp@latest",
-		);
-		expect(result.failed).toHaveLength(0);
-	});
-
-	it("reports failure when go is not available", async () => {
-		availableBinaries.delete("go");
-
-		const result = await installPluginDeps({
-			go: ["github.com/MadAppGang/tmux-mcp@latest"],
-		});
-
-		expect(result.failed).toHaveLength(1);
-		expect(result.failed[0].pkg).toBe(
-			"go:github.com/MadAppGang/tmux-mcp@latest",
-		);
-		expect(result.failed[0].error).toBe("go not found");
-	});
-
-	it("reports failure when go install fails", async () => {
-		execResults.set("/usr/bin/go install", {
-			stdout: "",
-			stderr: "build error: something went wrong",
-			error: true,
-		});
-
-		const result = await installPluginDeps({
-			go: ["github.com/MadAppGang/tmux-mcp@latest"],
-		});
-
-		expect(result.failed).toHaveLength(1);
-		expect(result.failed[0].error).toContain("something went wrong");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// 3. Integration tests — installPluginDeps with required binaries
-// ---------------------------------------------------------------------------
-
-describe("installPluginDeps — required binaries", () => {
-	beforeEach(() => {
-		availableBinaries = new Set();
-		execResults = new Map();
-	});
-
-	it("skips required binaries that are present", async () => {
-		availableBinaries.add("tmux");
-
-		const result = await installPluginDeps({
-			required: ["tmux"],
-		});
-
-		expect(result.skipped).toContain("required:tmux");
-		expect(result.failed).toHaveLength(0);
-	});
-
-	it("reports failure for missing required binaries", async () => {
-		const result = await installPluginDeps({
-			required: ["tmux"],
-		});
-
-		expect(result.failed).toHaveLength(1);
-		expect(result.failed[0].pkg).toBe("required:tmux");
-		expect(result.failed[0].error).toContain(
-			"Required binary 'tmux' not found in PATH",
-		);
-		expect(result.failed[0].error).toContain("install it manually");
-	});
-
-	it("handles multiple required binaries with mixed availability", async () => {
-		availableBinaries.add("tmux");
-		// ffmpeg is not available
-
-		const result = await installPluginDeps({
-			required: ["tmux", "ffmpeg"],
-		});
-
-		expect(result.skipped).toContain("required:tmux");
-		expect(result.failed).toHaveLength(1);
-		expect(result.failed[0].pkg).toBe("required:ffmpeg");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// 4. checkMissingDeps tests — go packages
-// ---------------------------------------------------------------------------
-
-describe("checkMissingDeps — go packages", () => {
-	beforeEach(() => {
-		availableBinaries = new Set();
-		execResults = new Map();
-	});
-
-	it("detects missing go packages when binary not in PATH", async () => {
-		const missing = await checkMissingDeps({
-			go: ["github.com/MadAppGang/tmux-mcp@latest"],
-		});
-
-		expect(missing.go).toEqual(["github.com/MadAppGang/tmux-mcp@latest"]);
-	});
-
-	it("does not report go packages when binary exists", async () => {
-		availableBinaries.add("tmux-mcp");
-
-		const missing = await checkMissingDeps({
-			go: ["github.com/MadAppGang/tmux-mcp@latest"],
-		});
-
-		expect(missing.go).toBeUndefined();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// 4b. Version-aware go dependencies — a bumped plugin must pull the new binary
-// ---------------------------------------------------------------------------
-
-describe("extractGoVersion", () => {
-	it("returns the pinned version", () => {
-		expect(extractGoVersion("github.com/MadAppGang/tmux-mcp@v1.6.2")).toBe(
-			"v1.6.2",
-		);
-	});
-	it("returns null for @latest (a moving target)", () => {
-		expect(
-			extractGoVersion("github.com/MadAppGang/tmux-mcp@latest"),
-		).toBeNull();
-	});
-	it("returns null when unpinned", () => {
-		expect(extractGoVersion("github.com/user/tool")).toBeNull();
-	});
-	it("reads the pin behind a /v2 module path", () => {
-		expect(extractGoVersion("github.com/MadAppGang/tmux-mcp/v2@v2.0.0")).toBe(
-			"v2.0.0",
-		);
-	});
-	it("a /v2 module path with no pin is unpinned, not pinned to v2", () => {
-		expect(extractGoVersion("github.com/MadAppGang/tmux-mcp/v2")).toBeNull();
-	});
-});
-
-describe("goDepNeedsInstall — version awareness", () => {
-	beforeEach(() => {
-		availableBinaries = new Set(["go"]);
-		execResults = new Map();
-	});
-
-	it("reinstalls when the pinned version differs from the installed one", async () => {
-		availableBinaries.add("tmux-mcp");
-		execResults.set("/usr/bin/tmux-mcp --version", {
-			stdout: "v1.6.1",
-			stderr: "",
-		});
-
-		expect(
-			await goDepNeedsInstall("github.com/MadAppGang/tmux-mcp@v1.6.2"),
-		).toBe(true);
-	});
-
-	it("skips when the installed version matches the pin (v-prefix insensitive)", async () => {
-		availableBinaries.add("tmux-mcp");
-		execResults.set("/usr/bin/tmux-mcp --version", {
-			stdout: "1.6.2",
-			stderr: "",
-		});
-
-		expect(
-			await goDepNeedsInstall("github.com/MadAppGang/tmux-mcp@v1.6.2"),
-		).toBe(false);
-	});
-
-	it("reinstalls when the binary can't report its version", async () => {
-		availableBinaries.add("tmux-mcp");
-		execResults.set("/usr/bin/tmux-mcp --version", {
-			stdout: "",
-			stderr: "flag provided but not defined: -version",
-			error: true,
-		});
-
-		expect(
-			await goDepNeedsInstall("github.com/MadAppGang/tmux-mcp@v1.6.2"),
-		).toBe(true);
-	});
-
-	it("installs when the binary is absent", async () => {
-		expect(
-			await goDepNeedsInstall("github.com/MadAppGang/tmux-mcp@v1.6.2"),
-		).toBe(true);
-	});
-
-	it("leaves an unpinned (@latest) present binary alone", async () => {
-		availableBinaries.add("tmux-mcp");
-		expect(
-			await goDepNeedsInstall("github.com/MadAppGang/tmux-mcp@latest"),
-		).toBe(false);
-	});
-});
-
-describe("checkMissingDeps — pinned go version mismatch", () => {
-	beforeEach(() => {
-		availableBinaries = new Set(["go", "tmux-mcp"]);
-		execResults = new Map();
-	});
-
-	it("reports a present-but-outdated pinned binary as missing", async () => {
-		execResults.set("/usr/bin/tmux-mcp --version", {
-			stdout: "v1.6.1",
-			stderr: "",
-		});
-
-		const missing = await checkMissingDeps({
-			go: ["github.com/MadAppGang/tmux-mcp@v1.6.2"],
-		});
-
-		expect(missing.go).toEqual(["github.com/MadAppGang/tmux-mcp@v1.6.2"]);
-	});
-});
-
-describe("installPluginDeps — reinstalls an outdated pinned go binary", () => {
-	beforeEach(() => {
-		availableBinaries = new Set(["go", "tmux-mcp"]);
-		execResults = new Map();
-	});
-
-	it("runs go install when the pinned version is newer than installed", async () => {
-		execResults.set("/usr/bin/tmux-mcp --version", {
-			stdout: "v1.6.1",
-			stderr: "",
-		});
-		execResults.set("/usr/bin/go install", { stdout: "", stderr: "" });
-
-		const result = await installPluginDeps({
-			go: ["github.com/MadAppGang/tmux-mcp@v1.6.2"],
-		});
-
-		expect(result.installed).toContain(
-			"go:github.com/MadAppGang/tmux-mcp@v1.6.2",
-		);
-		expect(result.skipped).toHaveLength(0);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// 4c. Install reach — a version check is worthless if the install lands
-//     somewhere PATH never looks. Pure ordering rules, no mocking needed.
-// ---------------------------------------------------------------------------
-
-describe("parseGoEnv", () => {
-	it("reads GOBIN and GOPATH", () => {
-		expect(
-			parseGoEnv('{"GOBIN": "/custom/gobin", "GOPATH": "/home/u/go"}'),
-		).toEqual({ gobin: "/custom/gobin", gopath: "/home/u/go" });
-	});
-
-	// The line-oriented `go env GOBIN GOPATH` puts an EMPTY line first when GOBIN
-	// is unset. run() trims stdout, which used to shift GOPATH into GOBIN's slot
-	// and aim the install dir at ~/go instead of ~/go/bin. Keyed JSON can't shift.
-	it("keeps an unset GOBIN empty even though output gets trimmed", () => {
-		expect(parseGoEnv('{"GOBIN": "", "GOPATH": "/Users/jack/go"}')).toEqual({
-			gobin: "",
-			gopath: "/Users/jack/go",
-		});
-	});
-
-	it("survives empty output", () => {
-		expect(parseGoEnv("")).toEqual({ gobin: "", gopath: "" });
-	});
-
-	it("survives non-JSON output", () => {
-		expect(parseGoEnv("go: unknown flag -json")).toEqual({
-			gobin: "",
-			gopath: "",
-		});
-	});
-
-	it("ignores non-string values", () => {
-		expect(parseGoEnv('{"GOBIN": null, "GOPATH": 7}')).toEqual({
-			gobin: "",
-			gopath: "",
-		});
-	});
-});
-
-describe("classifyInstallReach", () => {
-	it("wins when the install dir is the first PATH entry holding it", () => {
-		expect(
-			classifyInstallReach(
-				["/home/u/go/bin", "/usr/bin"],
-				[],
-				"/home/u/go/bin",
-			),
-		).toEqual({ reach: "wins" });
-	});
-
-	it("wins when the install dir precedes another copy", () => {
-		expect(
-			classifyInstallReach(
-				["/home/u/go/bin", "/opt/homebrew/bin"],
-				["/opt/homebrew/bin"],
-				"/home/u/go/bin",
-			),
-		).toEqual({ reach: "wins" });
-	});
-
-	it("is shadowed when another copy precedes the install dir", () => {
-		expect(
-			classifyInstallReach(
-				["/home/u/.local/bin", "/home/u/go/bin"],
-				["/home/u/.local/bin"],
-				"/home/u/go/bin",
-			),
-		).toEqual({ reach: "shadowed", byDir: "/home/u/.local/bin" });
-	});
-
-	// The generalisation of the tmux-mcp incident: no foreign package needed,
-	// just Homebrew ahead of GOPATH/bin. go install writes one file, the version
-	// probe reads another, and the mismatch never resolves.
-	it("is shadowed by a homebrew copy ordered ahead of the go bin dir", () => {
-		expect(
-			classifyInstallReach(
-				["/opt/homebrew/bin", "/home/u/go/bin"],
-				["/opt/homebrew/bin"],
-				"/home/u/go/bin",
-			),
-		).toEqual({ reach: "shadowed", byDir: "/opt/homebrew/bin" });
-	});
-
-	it("reports off-path when the install dir is absent from PATH", () => {
-		expect(
-			classifyInstallReach(["/usr/bin", "/bin"], [], "/home/u/go/bin"),
-		).toEqual({ reach: "off-path" });
-	});
-
-	it("normalises trailing slashes and redundant segments", () => {
-		expect(
-			classifyInstallReach(["/home/u/go/bin/"], [], "/home/u/go/./bin"),
-		).toEqual({ reach: "wins" });
-	});
-
-	it("lets the first of several duplicate PATH entries decide", () => {
-		expect(
-			classifyInstallReach(
-				["/home/u/.local/bin", "/home/u/go/bin", "/home/u/.local/bin"],
-				["/home/u/.local/bin"],
-				"/home/u/go/bin",
-			),
-		).toEqual({ reach: "shadowed", byDir: "/home/u/.local/bin" });
-	});
-});
-
-// ---------------------------------------------------------------------------
-// 4d. End-to-end shadowing — real directories on a real PATH, so the fs scan
-//     is exercised rather than stubbed. Mirrors the tmux-mcp incident: a
-//     foreign binary earlier in PATH that cannot report a version.
-// ---------------------------------------------------------------------------
-
-describe("go deps shadowed by an earlier PATH entry", () => {
-	let tmpRoot: string;
-	let shadowDir: string;
-	let goBinDir: string;
-	let originalPath: string | undefined;
-
-	beforeEach(async () => {
-		availableBinaries = new Set(["go", "tmux-mcp"]);
-		execResults = new Map();
-
-		tmpRoot = await mkdtemp(path.join(tmpdir(), "magus-shadow-"));
-		shadowDir = path.join(tmpRoot, "shadow");
-		goBinDir = path.join(tmpRoot, "gobin");
-		await mkdir(shadowDir);
-		await mkdir(goBinDir);
-
-		// A foreign `tmux-mcp` earlier in PATH than the go install target.
-		const shim = path.join(shadowDir, "tmux-mcp");
-		await writeFile(shim, "#!/bin/sh\nexit 1\n");
-		await chmod(shim, 0o755);
-
-		originalPath = process.env.PATH;
-		process.env.PATH = [shadowDir, goBinDir].join(path.delimiter);
-
-		// GOBIN points at the (later) go bin dir.
-		execResults.set("/usr/bin/go env -json GOBIN GOPATH", {
-			stdout: JSON.stringify({ GOBIN: goBinDir, GOPATH: tmpRoot }),
-			stderr: "",
-		});
-		// The shim chokes on --version, exactly like the npm package did.
-		execResults.set("/usr/bin/tmux-mcp --version", {
-			stdout: "",
-			stderr: "ERR_PARSE_ARGS_UNKNOWN_OPTION",
-			error: true,
-		});
-	});
-
-	afterEach(async () => {
-		process.env.PATH = originalPath ?? "";
-		await rm(tmpRoot, { recursive: true, force: true });
-	});
-
-	it("reports blocked instead of asking for a futile install", async () => {
-		const decision = await goDepDecision(
-			"github.com/MadAppGang/tmux-mcp@v1.6.2",
-		);
-
-		expect(decision.action).toBe("blocked");
-		if (decision.action !== "blocked") return;
-		expect(decision.reason).toBe("shadowed");
-		expect(decision.detail).toContain(path.join(shadowDir, "tmux-mcp"));
-		expect(decision.detail).toContain(goBinDir);
-		expect(decision.detail).toContain("cannot change what runs");
-	});
-
-	it("fails the install rather than reporting a success that changes nothing", async () => {
-		execResults.set("/usr/bin/go install", { stdout: "", stderr: "" });
-
-		const result = await installPluginDeps({
-			go: ["github.com/MadAppGang/tmux-mcp@v1.6.2"],
-		});
-
-		expect(result.installed).toHaveLength(0);
-		expect(result.skipped).toHaveLength(0);
-		expect(result.failed).toHaveLength(1);
-		expect(result.failed[0].pkg).toBe(
-			"go:github.com/MadAppGang/tmux-mcp@v1.6.2",
-		);
-		expect(result.failed[0].error).toContain("cannot change what runs");
-	});
-
-	it("still counts as needing attention, so the UI surfaces it", async () => {
-		expect(
-			await goDepNeedsInstall("github.com/MadAppGang/tmux-mcp@v1.6.2"),
-		).toBe(true);
-
-		const missing = await checkMissingDeps({
-			go: ["github.com/MadAppGang/tmux-mcp@v1.6.2"],
-		});
-		expect(missing.go).toEqual(["github.com/MadAppGang/tmux-mcp@v1.6.2"]);
-	});
-
-	it("installs normally once the shadow is out of the way", async () => {
-		process.env.PATH = [goBinDir, shadowDir].join(path.delimiter);
-		execResults.set("/usr/bin/go install", { stdout: "", stderr: "" });
-
-		const result = await installPluginDeps({
-			go: ["github.com/MadAppGang/tmux-mcp@v1.6.2"],
-		});
-
-		expect(result.installed).toContain(
-			"go:github.com/MadAppGang/tmux-mcp@v1.6.2",
-		);
-		expect(result.failed).toHaveLength(0);
-	});
-
-	it("reports off-path when the go bin dir is not in PATH at all", async () => {
-		process.env.PATH = path.join(tmpRoot, "elsewhere");
-		availableBinaries.delete("tmux-mcp");
-
-		const decision = await goDepDecision(
-			"github.com/MadAppGang/tmux-mcp@v1.6.2",
-		);
-
-		expect(decision.action).toBe("blocked");
-		if (decision.action !== "blocked") return;
-		expect(decision.reason).toBe("install-dir-off-path");
-		expect(decision.detail).toContain("not in PATH");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// 4e. Spec parsing — the root of both bug directions. Go never reinstalled
-//     because the pin was never compared; npm/cargo/pip always reinstalled
-//     because the raw spec was used as a lookup key.
-// ---------------------------------------------------------------------------
-
-describe("parseAtSpec", () => {
-	it("splits name and pinned version", () => {
-		expect(parseAtSpec("ripgrep@14.1.0")).toEqual({
-			spec: "ripgrep@14.1.0",
-			name: "ripgrep",
-			version: "14.1.0",
-		});
-	});
-
-	it("treats a leading @ as an npm scope, not a version", () => {
-		expect(parseAtSpec("@babel/cli")).toEqual({
-			spec: "@babel/cli",
-			name: "cli",
-			version: null,
-		});
-	});
-
-	it("pins a scoped npm package", () => {
-		expect(parseAtSpec("@babel/cli@7.0.0")).toEqual({
-			spec: "@babel/cli@7.0.0",
-			name: "cli",
-			version: "7.0.0",
-		});
-	});
-
-	it("keeps go module paths working", () => {
-		expect(parseAtSpec("github.com/MadAppGang/tmux-mcp@v1.6.2")).toEqual({
-			spec: "github.com/MadAppGang/tmux-mcp@v1.6.2",
-			name: "tmux-mcp",
-			version: "v1.6.2",
-		});
-	});
-
-	it("treats @latest as unpinned", () => {
-		expect(parseAtSpec("tool@latest").version).toBeNull();
-	});
-
-	it("does NOT apply the Go /vN rule — an npm scope may be named v2", () => {
-		// The Go major-version strip lives in parseGoSpec only; folding it in
-		// here would turn this scoped npm package into "@scope".
-		expect(parseAtSpec("@scope/v2@1.0.0")).toEqual({
-			spec: "@scope/v2@1.0.0",
-			name: "v2",
-			version: "1.0.0",
-		});
-	});
-
-	it("treats a bare name as unpinned", () => {
-		expect(parseAtSpec("tool")).toEqual({
-			spec: "tool",
-			name: "tool",
-			version: null,
-		});
-	});
-});
-
-describe("parsePipSpec", () => {
-	it("reads an == pin", () => {
-		expect(parsePipSpec("mcp==1.2.3")).toEqual({
-			spec: "mcp==1.2.3",
-			name: "mcp",
-			version: "1.2.3",
-		});
-	});
-
-	it("tolerates whitespace around ==", () => {
-		expect(parsePipSpec("mcp == 1.2.3").version).toBe("1.2.3");
-	});
-
-	// A range is not a single version, so there is nothing to verify against.
-	it("treats >= as unpinned but still reads the name", () => {
-		expect(parsePipSpec("browser-use>=0.1.0")).toEqual({
-			spec: "browser-use>=0.1.0",
-			name: "browser-use",
-			version: null,
-		});
-	});
-
-	it("strips extras from the name", () => {
-		expect(parsePipSpec("uvicorn[standard]").name).toBe("uvicorn");
-	});
-
-	it("handles a bare distribution name", () => {
-		expect(parsePipSpec("browser-use")).toEqual({
-			spec: "browser-use",
-			name: "browser-use",
-			version: null,
-		});
-	});
-});
-
-describe("extractBinaryName — brew", () => {
-	it("drops the tap prefix", () => {
-		expect(extractBinaryName("memextech/tap/ht-mcp")).toBe("ht-mcp");
-	});
-
-	// brew's @ is part of the formula name, but the binary it provides is not
-	// called "node@18" — the old code looked for exactly that and never found it.
-	it("drops a versioned-formula suffix from the binary name", () => {
-		expect(extractBinaryName("node@18")).toBe("node");
-	});
-
-	it("leaves a plain formula alone", () => {
-		expect(extractBinaryName("ripgrep")).toBe("ripgrep");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// 4f. Version awareness across the other managers
-// ---------------------------------------------------------------------------
-
-describe("pipDepNeedsInstall — via installPluginDeps", () => {
-	const PIP_VERSION = /^python3 -c import importlib\.metadata/;
-
-	beforeEach(() => {
-		availableBinaries = new Set(["uv"]);
-		execResults = new Map();
-	});
-
-	function pipVersion(stdout: string, error = false) {
-		// The probe is `python3 -c "...m.version('mcp')"`, matched by prefix.
-		execResults.set("python3 -c import importlib.metadata as m", {
-			stdout,
-			stderr: error ? "no such distribution" : "",
-			error,
-		});
-	}
-
-	it("skips a pinned package already at that version", async () => {
-		pipVersion("1.2.3");
-		const result = await installPluginDeps({ pip: ["mcp==1.2.3"] });
-
-		expect(result.skipped).toContain("pip:mcp==1.2.3");
-		expect(result.installed).toHaveLength(0);
-	});
-
-	it("reinstalls a pinned package sitting at another version", async () => {
-		pipVersion("1.2.2");
-		execResults.set("/usr/bin/uv pip install", { stdout: "", stderr: "" });
-
-		const result = await installPluginDeps({ pip: ["mcp==1.2.3"] });
-
-		expect(result.installed).toContain("pip:mcp==1.2.3");
-		expect(result.skipped).toHaveLength(0);
-	});
-
-	it("skips an unpinned package that is present", async () => {
-		pipVersion("0.9.0");
-		const result = await installPluginDeps({ pip: ["browser-use"] });
-
-		expect(result.skipped).toContain("pip:browser-use");
-	});
-
-	it("installs when the distribution is absent", async () => {
-		pipVersion("", true);
-		execResults.set("/usr/bin/uv pip install", { stdout: "", stderr: "" });
-
-		const result = await installPluginDeps({ pip: ["browser-use"] });
-
-		expect(result.installed).toContain("pip:browser-use");
-	});
-
-	it("reports a pinned mismatch through checkMissingDeps too", async () => {
-		pipVersion("1.2.2");
-		const missing = await checkMissingDeps({ pip: ["mcp==1.2.3"] });
-		expect(missing.pip).toEqual(["mcp==1.2.3"]);
-		expect(PIP_VERSION.test("python3 -c import importlib.metadata")).toBe(true);
-	});
-});
-
-describe("npm and cargo version awareness", () => {
-	// The reach check consults the real PATH and filesystem, so both are pinned
-	// to a temp dir here. Without that these tests would pass or fail depending
-	// on whether the machine running them happens to have ~/.cargo/bin on PATH.
-	let envRoot: string;
-	let savedPath: string | undefined;
-	let savedCargoRoot: string | undefined;
-
-	beforeEach(async () => {
-		availableBinaries = new Set(["bun", "cargo", "ripgrep"]);
-		execResults = new Map();
-
-		envRoot = await mkdtemp(path.join(tmpdir(), "magus-env-"));
-		await mkdir(path.join(envRoot, "bin"));
-		savedPath = process.env.PATH;
-		savedCargoRoot = process.env.CARGO_INSTALL_ROOT;
-		process.env.PATH = path.join(envRoot, "bin");
-		process.env.CARGO_INSTALL_ROOT = envRoot;
-	});
-
-	afterEach(async () => {
-		process.env.PATH = savedPath ?? "";
-		if (savedCargoRoot === undefined) process.env.CARGO_INSTALL_ROOT = "";
-		else process.env.CARGO_INSTALL_ROOT = savedCargoRoot;
-		await rm(envRoot, { recursive: true, force: true });
-	});
-
-	// The old code passed "ripgrep@14.1.0" to which(), never matched, and
-	// reinstalled on every single run.
-	it("skips a pinned npm package already at that version", async () => {
-		execResults.set("/usr/bin/ripgrep --version", {
-			stdout: "14.1.0",
-			stderr: "",
-		});
-		execResults.set("/usr/bin/bun pm bin -g", { stdout: "", stderr: "" });
-
-		const result = await installPluginDeps({ npm: ["ripgrep@14.1.0"] });
-
-		expect(result.skipped).toContain("npm:ripgrep@14.1.0");
-		expect(result.installed).toHaveLength(0);
-	});
-
-	it("reinstalls a pinned npm package at the wrong version", async () => {
-		execResults.set("/usr/bin/ripgrep --version", {
-			stdout: "14.0.0",
-			stderr: "",
-		});
-		execResults.set("/usr/bin/bun install -g", { stdout: "", stderr: "" });
-
-		const result = await installPluginDeps({ npm: ["ripgrep@14.1.0"] });
-
-		expect(result.installed).toContain("bun:ripgrep@14.1.0");
-	});
-
-	it("skips a pinned cargo crate already at that version", async () => {
-		execResults.set("/usr/bin/ripgrep --version", {
-			stdout: "ripgrep 14.1.0",
-			stderr: "",
-		});
-
-		const result = await installPluginDeps({ cargo: ["ripgrep@14.1.0"] });
-
-		expect(result.skipped).toContain("cargo:ripgrep@14.1.0");
-	});
-
-	it("installs a pinned cargo crate with --version, not crate@ver", async () => {
-		execResults.set("/usr/bin/ripgrep --version", {
-			stdout: "ripgrep 14.0.0",
-			stderr: "",
-		});
-		execResults.set("/usr/bin/cargo install ripgrep --version 14.1.0", {
-			stdout: "",
-			stderr: "",
-		});
-
-		const result = await installPluginDeps({ cargo: ["ripgrep@14.1.0"] });
-
-		// Only the exact `--version` invocation is stubbed as success, so this
-		// passing proves the argv shape.
-		expect(result.installed).toContain("cargo:ripgrep@14.1.0");
-		expect(result.failed).toHaveLength(0);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// 5. checkMissingDeps tests — required binaries
-// ---------------------------------------------------------------------------
-
-describe("checkMissingDeps — required binaries", () => {
-	beforeEach(() => {
-		availableBinaries = new Set();
-		execResults = new Map();
-	});
-
-	it("detects missing required binaries", async () => {
-		const missing = await checkMissingDeps({
-			required: ["tmux", "ffmpeg"],
-		});
-
-		expect(missing.required).toEqual(["tmux", "ffmpeg"]);
-	});
-
-	it("does not report present required binaries", async () => {
-		availableBinaries.add("tmux");
-		availableBinaries.add("ffmpeg");
-
-		const missing = await checkMissingDeps({
-			required: ["tmux", "ffmpeg"],
-		});
-
-		expect(missing.required).toBeUndefined();
-	});
-
-	it("reports only missing required binaries", async () => {
-		availableBinaries.add("tmux");
-
-		const missing = await checkMissingDeps({
-			required: ["tmux", "ffmpeg"],
-		});
-
-		expect(missing.required).toEqual(["ffmpeg"]);
-	});
-});