magus-cli 7.10.2 → 7.10.4

package/src/__tests__/tool-rows-followups.test.ts

@@ -0,0 +1,315 @@
+// REGRESSION: follow-ups from gate B review of the magus update tool-rows fix — /dev:fix session dev-fix-20261008-133732-7ddf079e
+/**
+ * Follow-ups to docs/plans/2026-10-08-magus-update-tool-rows.md.
+ *
+ * The rule under test: no user-facing message — CLI or TUI — names a
+ * filesystem path, a Cellar, or a mechanism; and a tool brew owns is managed
+ * even when its version cannot be read.
+ *
+ * Written blind from the spec and the public contract. Same fake ToolProbeIO
+ * seam as tool-rows-reproduction.test.ts.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import {
+	type ExecResult,
+	type ToolFacts,
+	type ToolProbeIO,
+	classifyTool,
+	probeTool,
+} from "../services/tool-probe.js";
+import { type ApplyReporter, applyBins } from "../services/update-engine.js";
+import type { BinUpdateItem, UpdatePlan } from "../services/update-plan.js";
+import type { ManagedTool, ResolvedBin } from "../types/index.js";
+import {
+	buildToolRow,
+	cliToolEnterAction,
+	cliToolStatusText,
+} from "../ui/adapters/cliToolsAdapter.js";
+import { testCatalogue } from "./fixtures/bins.js";
+
+// ── fake IO (copied shape from tool-rows-reproduction.test.ts) ──────────────
+
+type Handler = Partial<ExecResult> | "timeout";
+
+interface Setup {
+	exec?: Record<string, Handler>;
+	onPath?: Record<string, string>;
+	real?: Record<string, string>;
+	env?: Record<string, string>;
+}
+
+const MISSING: ExecResult = {
+	code: null,
+	stdout: "",
+	stderr: "",
+	timedOut: false,
+	missing: true,
+};
+
+function fakeIO(setup: Setup): ToolProbeIO & { calls: string[] } {
+	const calls: string[] = [];
+	const answer = (h: Handler | undefined): ExecResult => {
+		if (h === undefined) return MISSING;
+		if (h === "timeout")
+			return {
+				code: null,
+				stdout: "",
+				stderr: "",
+				timedOut: true,
+				missing: false,
+			};
+		return {
+			code: 0,
+			stdout: "",
+			stderr: "",
+			timedOut: false,
+			missing: false,
+			...h,
+		};
+	};
+	return {
+		calls,
+		exec: async (command) => {
+			const key = [command.cmd, ...command.args].join(" ");
+			calls.push(key);
+			return answer(setup.exec?.[key]);
+		},
+		fetchJson: async () => ({ ok: false, reason: "returned 404" }),
+		readJson: async () => null,
+		readText: async () => null,
+		readlink: async () => null,
+		realpath: async (file) => setup.real?.[file] ?? file,
+		resolveExecutable: async (name) => setup.onPath?.[name] ?? null,
+		env: setup.env ?? {},
+		homedir: "/Users/j",
+	};
+}
+
+const OPTS = { timeoutMs: 500, deadlineMs: 3000 };
+const BREW_ENV = { HOMEBREW_PREFIX: "/opt/homebrew" };
+const OUTDATED_EMPTY = '{"formulae":[],"casks":[]}';
+
+const brewSpec = (name: string, formula?: string): ManagedTool => ({
+	name,
+	via: "brew",
+	...(formula ? { formula } : {}),
+});
+
+/** An absolute or relative path segment: `/x`, `a/b/`. */
+const PATH_SEGMENT = /\/[\w.@-]|[\w.@-]+\/[\w.@-]+\//;
+
+function expectNoPath(text: string): void {
+	expect(text).not.toMatch(PATH_SEGMENT);
+	for (const banned of ["Cellar", "homebrew/var", "rb_sysopen", ".lock"]) {
+		expect(text).not.toContain(banned);
+	}
+}
+
+const catalogue = (name: string) => {
+	const tool = testCatalogue().find((t) => t.name === name);
+	if (!tool) throw new Error(`no catalogue tool ${name}`);
+	return tool;
+};
+
+// ── 1. brew error text never carries a path ─────────────────────────────────
+
+describe("REQ-1: a brew failure is reported without a path", () => {
+	test("F1. brew list exits 1 with a lock-file Permission denied: the note and the TUI row name no path", async () => {
+		const io = fakeIO({
+			env: BREW_ENV,
+			onPath: { jq: "/opt/homebrew/bin/jq" },
+			exec: {
+				"brew list --versions jq": {
+					code: 1,
+					stdout: "",
+					stderr:
+						"Error: Permission denied @ rb_sysopen - /opt/homebrew/var/homebrew/locks/jq.formula.lock\n",
+				},
+				"jq --version": { stdout: "jq-1.8.2\n" },
+				"brew outdated --json=v2 jq": { stdout: OUTDATED_EMPTY },
+			},
+		});
+		const s = brewSpec("jq");
+		const f = await probeTool(s, io, OPTS);
+		const st = classifyTool(s, f);
+
+		// Guard: brew failing loudly is "owner could not be determined".
+		expect(st.state).toBe("unknown");
+		expect(st.note ?? "").not.toBe("");
+		expectNoPath(st.note ?? "");
+		expectNoPath(f.failure ?? "");
+
+		// What the TUI row shows for the same facts.
+		const row = buildToolRow(catalogue("mnemex"), s, f);
+		expectNoPath(JSON.stringify(cliToolStatusText(row)));
+		expectNoPath(row.status?.note ?? "");
+	});
+});
+
+// ── 2. post-install read-back names no path ─────────────────────────────────
+
+const binItem = (over: Partial<BinUpdateItem> = {}): BinUpdateItem => ({
+	name: "jq",
+	action: "upgrade",
+	reason: "behind",
+	installed: "1.8.1",
+	latest: "1.8.2",
+	target: "1.8.2",
+	sources: [],
+	...over,
+});
+
+function binPlan(item: BinUpdateItem): UpdatePlan {
+	const spec: ResolvedBin = { name: item.name, via: "brew", sources: [] };
+	return {
+		profileId: "test",
+		plugins: [],
+		bins: [item],
+		skills: [],
+		binSpecs: new Map([[item.name, spec]]),
+	};
+}
+
+describe("REQ-2: the read-back message says another copy runs, without a path", () => {
+	test("F2. upgrade read back with PATH still running another copy: detail names no path", async () => {
+		const rows: Array<{ ok: boolean; name: string; detail: string }> = [];
+		const reporter: ApplyReporter = {
+			begin: () => {},
+			finish: (ok, name, detail) => rows.push({ ok, name, detail }),
+			detach: (work) => work(),
+		};
+		const readBack: ToolFacts = {
+			name: "jq",
+			present: true,
+			resolvedPath: "/usr/local/Cellar/jq/1.8.1/bin/jq",
+			installed: "1.8.1",
+			latest: null,
+			behind: false,
+			managed: false,
+			sources: [],
+		};
+		const result = await applyBins(
+			binPlan(binItem()),
+			reporter,
+			async () => true,
+			async () => readBack,
+		);
+		expect(result.unchanged).toEqual(["jq"]);
+		expect(rows).toHaveLength(1);
+		const detail = rows[0]!.detail;
+		expectNoPath(detail);
+		expect(detail).toMatch(/another copy|different copy|another installation/i);
+	});
+});
+
+// ── 3. held back: Enter offers no upgrade ───────────────────────────────────
+
+describe("REQ-3: a held-back tool offers no upgrade on Enter", () => {
+	test("F3. brew pinned and behind: Enter is not an update that runs brew upgrade", () => {
+		const s = brewSpec("mnemex", "madappgang/tap/mnemex");
+		const f: ToolFacts = {
+			name: "mnemex",
+			present: true,
+			resolvedPath: "/opt/homebrew/bin/mnemex",
+			installed: "0.36.1",
+			latest: "0.37.0",
+			behind: true,
+			managed: true,
+			heldBack: "held by brew pin",
+			sources: ["brew"],
+		};
+		const row = buildToolRow(catalogue("mnemex"), s, f);
+		// Guard the input shape.
+		expect(row.status?.reason).toBe("held-back");
+
+		const action = cliToolEnterAction(row);
+		if (action !== null) {
+			expect(["update", "update-anyway"]).not.toContain(action.kind);
+			const argv = [action.command.cmd, ...action.command.args].join(" ");
+			expect(argv).not.toMatch(/\bupgrade\b/);
+		}
+	});
+});
+
+// ── 4. CliTool has no checkCommand ──────────────────────────────────────────
+
+describe("REQ-4: the TUI CliTool type carries no checkCommand", () => {
+	test("F4. CliTool in ui/state/types.ts declares no checkCommand field", () => {
+		// Spec decision 2: "The catalogue's `checkCommand` field is deleted, so
+		// each tool's version command exists once." bun:test does not type-check,
+		// so the contract file's declaration is read directly.
+		const src = readFileSync(
+			path.join(import.meta.dir, "..", "ui", "state", "types.ts"),
+			"utf8",
+		);
+		const block = /export interface CliTool \{([\s\S]*?)\n\}/.exec(src);
+		expect(block).not.toBeNull();
+		expect(block![1]).not.toMatch(/\bcheckCommand\??\s*:/);
+	});
+});
+
+// ── 5. brew HEAD build whose version the table cannot parse ─────────────────
+
+describe("REQ-5: a brew dev build is managed, version unknown", () => {
+	test("F5. brew lists tmux HEAD-abc1234, tmux -V prints `tmux next-3.7`: managed and current, no version", async () => {
+		const io = fakeIO({
+			env: BREW_ENV,
+			onPath: { tmux: "/opt/homebrew/bin/tmux" },
+			real: {
+				"/opt/homebrew/bin/tmux":
+					"/opt/homebrew/Cellar/tmux/HEAD-abc1234/bin/tmux",
+			},
+			exec: {
+				"brew list --versions tmux": { stdout: "tmux HEAD-abc1234\n" },
+				"brew list tmux": {
+					stdout: "/opt/homebrew/Cellar/tmux/HEAD-abc1234/bin/tmux\n",
+				},
+				"tmux -V": { stdout: "tmux next-3.7\n" },
+				"brew outdated --json=v2 tmux": { stdout: OUTDATED_EMPTY },
+			},
+		});
+		const s = brewSpec("tmux");
+		const f = await probeTool(s, io, OPTS);
+		const st = classifyTool(s, f);
+		expect({ managed: f.managed, state: st.state, reason: st.reason }).toEqual({
+			managed: true,
+			state: "current",
+			reason: "up-to-date",
+		});
+		expect(st.installed).toBeNull();
+	});
+});
+
+// ── 6. several brew versions, no version-table entry ────────────────────────
+
+describe("REQ-6: brew's several versions with no table entry stay managed", () => {
+	test("F6. brew lists testball 1.0 1.1, no table entry: managed and current, no version", async () => {
+		const io = fakeIO({
+			env: BREW_ENV,
+			onPath: { testball: "/opt/homebrew/bin/testball" },
+			real: {
+				"/opt/homebrew/bin/testball":
+					"/opt/homebrew/Cellar/testball/1.1/bin/testball",
+			},
+			exec: {
+				"brew list --versions testball": { stdout: "testball 1.0 1.1\n" },
+				"brew list testball": {
+					stdout: "/opt/homebrew/Cellar/testball/1.1/bin/testball\n",
+				},
+				"brew outdated --json=v2 testball": { stdout: OUTDATED_EMPTY },
+			},
+		});
+		const s = brewSpec("testball");
+		const f = await probeTool(s, io, OPTS);
+		const st = classifyTool(s, f);
+		expect({ managed: f.managed, state: st.state, reason: st.reason }).toEqual({
+			managed: true,
+			state: "current",
+			reason: "up-to-date",
+		});
+		expect(st.installed).toBeNull();
+	});
+});