magus-cli 7.8.0 → 7.9.0

package/src/__tests__/resolver.test.ts

@@ -1,24 +1,30 @@
 import { describe, expect, test } from "bun:test";
 import { PREDEFINED_PROFILES } from "../data/predefined-profiles.js";
 import {
-	dedupeBins,
+	mergeBins,
+	pinOfBin,
 	resolveAllProfiles,
 	resolveExtends,
 	resolveProfile,
 } from "../services/resolver.js";
 import type {
-	BinRequirement,
+	ManagedTool,
 	ProfileManifest,
 	ProfileManifestEntry,
 } from "../types/index.js";
+import { ownedAsDeclared, selected } from "./fixtures/bins.js";
 
-// A binResolver that returns canned requires.bin per plugin — keeps the
-// resolver tests hermetic (no marketplace cache / filesystem).
-function fakeBinResolver(
-	table: Record<string, BinRequirement[]>,
-): (pluginId: string) => Promise<BinRequirement[]> {
-	return async (pluginId) => table[pluginId] ?? [];
+// A binResolver that returns canned requirements per plugin — keeps the
+// resolver tests hermetic (no marketplace cache / filesystem). A catalogue
+// tool a plugin owns resolves as that plugin declares it today.
+function fakeBinResolver(table: Record<string, ManagedTool[]>) {
+	return async (pluginId: string) =>
+		(table[pluginId] ?? []).map((t) => selected(t));
 }
+const hermetic = (table: Record<string, ManagedTool[]> = {}) => ({
+	binResolver: fakeBinResolver(table),
+	ownedResolver: ownedAsDeclared,
+});
 
 function manifestOf(
 	profiles: Record<string, ProfileManifestEntry>,
@@ -26,44 +32,60 @@ function manifestOf(
 	return { version: 2, profiles };
 }
 
-describe("dedupeBins — precedence by order", () => {
-	test("first-seen wins installer/version; later contributes only provenance", () => {
-		const claudishPin: BinRequirement = {
-			name: "claudish",
-			via: "bun",
-			package: "claudish",
-			version: "1.2.0",
-		};
-		const claudishLoose: BinRequirement = {
-			name: "claudish",
-			via: "npm",
-			package: "claudish",
-		};
-		const result = dedupeBins([
-			{ bin: claudishPin, source: "profile:x.cliTools" },
-			{ bin: claudishLoose, source: "plugin:foo@magus" },
+describe("mergeBins — precedence by order", () => {
+	test("a profile pin absorbs a later declaration of the name; it adds only provenance", () => {
+		const result = mergeBins([
+			{
+				bin: selected({ name: "claudish", via: "bun", version: "1.2.0" }),
+				source: "profile:x.cliTools",
+			},
+			{
+				bin: selected({ name: "claudish", via: "npm" }),
+				source: "plugin:foo@magus",
+			},
 		]);
 		expect(result).toHaveLength(1);
-		expect(result[0]!.via).toBe("bun");
-		expect(result[0]!.version).toBe("1.2.0");
+		expect(result[0]!.chosen?.via).toBe("bun");
+		expect(pinOfBin(result[0]!)).toBe("1.2.0");
 		expect(result[0]!.sources).toEqual([
 			"profile:x.cliTools",
 			"plugin:foo@magus",
 		]);
 	});
 
-	test("a later entry fills a version the winner left unset", () => {
-		const loose: BinRequirement = { name: "tmux", via: "brew" };
-		const pinned: BinRequirement = {
-			name: "tmux",
-			via: "brew",
-			version: "3.4",
+	test("identical declarations merge; different plugin declarations of one name stay two", () => {
+		const jq = selected({ name: "jq", via: "brew", formula: "jq" });
+		const result = mergeBins([
+			{ bin: jq, source: "plugin:dev@magus" },
+			{ bin: { ...jq }, source: "plugin:code-search@magus" },
+			{
+				bin: selected({
+					name: "jq",
+					via: "brew",
+					formula: "jq",
+					check: "jq -V",
+				}),
+				source: "plugin:other@elsewhere",
+			},
+		]);
+		expect(result).toHaveLength(2);
+		expect(result[0]!.sources).toEqual([
+			"plugin:dev@magus",
+			"plugin:code-search@magus",
+		]);
+		expect(result[1]!.sources).toEqual(["plugin:other@elsewhere"]);
+	});
+
+	test("a check that reads the plugin root never merges across plugins", () => {
+		const env = {
+			...selected({ name: "env", via: "bun" }),
+			check: ["${CLAUDE_PLUGIN_ROOT}/x"],
 		};
-		const result = dedupeBins([
-			{ bin: loose, source: "plugin:a" },
-			{ bin: pinned, source: "plugin:b" },
+		const result = mergeBins([
+			{ bin: { ...env, root: "/a" }, source: "plugin:a@m" },
+			{ bin: { ...env, root: "/b" }, source: "plugin:b@m" },
 		]);
-		expect(result[0]!.version).toBe("3.4");
+		expect(result).toHaveLength(2);
 	});
 });
 
@@ -161,8 +183,10 @@ describe("resolveProfile", () => {
 			},
 		});
 
-		const closure = await resolveProfile(manifest, "frontend", {
-			binResolver: fakeBinResolver({
+		const closure = await resolveProfile(
+			manifest,
+			"frontend",
+			hermetic({
 				"terminal@magus": [
 					{ name: "tmux", via: "brew", formula: "tmux" },
 					// terminal ALSO wants claudish, but the profile pinned it →
@@ -170,7 +194,7 @@ describe("resolveProfile", () => {
 					{ name: "claudish", via: "npm", package: "claudish" },
 				],
 			}),
-		});
+		);
 
 		expect(closure.plugins).toEqual({
 			"terminal@magus": "4.1.0",
@@ -179,12 +203,13 @@ describe("resolveProfile", () => {
 		expect(closure.env.required).toEqual(["FIGMA_ACCESS_TOKEN"]);
 
 		const claudish = closure.bins.find((b) => b.name === "claudish")!;
-		expect(claudish.via).toBe("bun"); // from the cli-tools catalog, not npm
-		expect(claudish.version).toBe("1.2.0");
+		// claudish@magus's own declaration (bun), pinned by the profile — not npm.
+		expect(claudish.chosen?.via).toBe("bun");
+		expect(pinOfBin(claudish)).toBe("1.2.0");
 		expect(claudish.sources[0]).toContain("cliTools");
 
 		const tmux = closure.bins.find((b) => b.name === "tmux")!;
-		expect(tmux.via).toBe("brew");
+		expect(tmux.chosen?.via).toBe("brew");
 		expect(tmux.sources).toContain("plugin:terminal@magus");
 	});
 
@@ -213,9 +238,7 @@ describe("resolveAllProfiles — union", () => {
 			},
 		});
 
-		const union = await resolveAllProfiles(manifest, {
-			binResolver: fakeBinResolver({}),
-		});
+		const union = await resolveAllProfiles(manifest, hermetic());
 
 		expect(union.plugins["dev@magus"]).toBe("2.9.0"); // pin beat latest
 		expect(union.plugins["terminal@magus"]).toBe("4.1.0");
@@ -224,7 +247,9 @@ describe("resolveAllProfiles — union", () => {
 			"DATABASE_URL",
 			"FIGMA_ACCESS_TOKEN",
 		]);
-		expect(union.bins.find((b) => b.name === "mnemex")?.via).toBe("bun");
+		expect(union.bins.find((b) => b.name === "mnemex")?.chosen?.via).toBe(
+			"bun",
+		);
 		expect(union.conflicts).toBeUndefined(); // latest-vs-pin isn't a conflict
 	});
 
@@ -260,16 +285,68 @@ describe("resolveAllProfiles — union", () => {
 			a: { name: "A", cliTools: { claudish: "1.2.0" } },
 			b: { name: "B", cliTools: { claudish: "1.5.0" } },
 		});
-		const union = await resolveAllProfiles(manifest, {
-			binResolver: fakeBinResolver({}),
-		});
-		expect(union.bins.find((x) => x.name === "claudish")?.version).toBe(
-			"1.5.0",
-		);
+		const union = await resolveAllProfiles(manifest, hermetic());
+		const claudish = union.bins.find((x) => x.name === "claudish");
+		expect(claudish && pinOfBin(claudish)).toBe("1.5.0");
 		expect(union.conflicts?.some((c) => c.includes("claudish"))).toBe(true);
 	});
 });
 
+describe("a pin on a tool its plugin installs without a version", () => {
+	// claudish@magus as it declares claudish off Homebrew: its pinned release.
+	const RELEASE = {
+		via: "release" as const,
+		repo: "MadAppGang/claudish",
+		tag: "v10.3.0",
+		asset: "claudish-{os}-{arch}",
+		binary: "claudish",
+		sha256: { linux_amd64: "a".repeat(64) },
+	};
+	const ownedRelease = async (_pluginId: string, name: string) => ({
+		name,
+		check: [name, "--version"],
+		install: [RELEASE],
+		chosen: RELEASE,
+	});
+	const opts = {
+		binResolver: fakeBinResolver({}),
+		ownedResolver: ownedRelease,
+	};
+
+	test("is kept as refused: the release stays what installs, and no pin is invented", async () => {
+		const closure = await resolveProfile(
+			manifestOf({ p: { name: "P", cliTools: { claudish: "6.1.0" } } }),
+			"p",
+			opts,
+		);
+		const claudish = closure.bins.find((b) => b.name === "claudish");
+		expect(claudish?.chosen).toEqual(RELEASE);
+		expect(claudish && pinOfBin(claudish)).toBeUndefined();
+		expect(claudish?.refusedPins).toEqual(["6.1.0"]);
+	});
+
+	test("every profile's refused pin survives the union", async () => {
+		const union = await resolveAllProfiles(
+			manifestOf({
+				a: { name: "A", cliTools: { claudish: "6.1.0" } },
+				b: { name: "B", cliTools: { claudish: "7.0.0" } },
+			}),
+			opts,
+		);
+		const claudish = union.bins.find((b) => b.name === "claudish");
+		expect(claudish?.refusedPins).toEqual(["6.1.0", "7.0.0"]);
+	});
+
+	test("latest is not a pin, so nothing is refused", async () => {
+		const closure = await resolveProfile(
+			manifestOf({ p: { name: "P", cliTools: { claudish: "latest" } } }),
+			"p",
+			opts,
+		);
+		expect(closure.bins[0]?.refusedPins).toBeUndefined();
+	});
+});
+
 describe("marketplaces derived from plugin ids", () => {
 	const noBins = { binResolver: fakeBinResolver({}) };
 

package/src/__tests__/run.test.ts

@@ -0,0 +1,108 @@
+/**
+ * `runArgv` — the one runner: argv only, output captured and tailed, never
+ * written to the terminal, bounded by SIGTERM then SIGKILL.
+ */
+
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import {
+	OUTPUT_TAIL_BYTES,
+	runArgv,
+	runFailureReason,
+	succeeded,
+} from "../utils/run.js";
+
+const sh = (script: string) => ({ cmd: "/bin/sh", args: ["-c", script] });
+
+describe("runArgv", () => {
+	let out: ReturnType<typeof spyOn>;
+	let err: ReturnType<typeof spyOn>;
+	beforeEach(() => {
+		out = spyOn(process.stdout, "write");
+		err = spyOn(process.stderr, "write");
+	});
+	afterEach(() => {
+		out.mockRestore();
+		err.mockRestore();
+	});
+
+	test("captures stdout and stderr together, ANSI stripped, and never writes to the terminal", async () => {
+		const chunks: string[] = [];
+		const r = await runArgv(
+			sh("printf 'to-out\\n'; printf '\\033[31mto-err\\033[0m\\n' >&2"),
+			{ timeoutMs: 5_000, onOutput: (c) => chunks.push(c) },
+		);
+		expect(r.exitCode).toBe(0);
+		expect(succeeded(r)).toBe(true);
+		expect(r.outputTail).toContain("to-out");
+		expect(r.outputTail).toContain("to-err");
+		expect(r.outputTail).not.toContain("\u001b[");
+		expect(chunks.join("")).toContain("to-out");
+		expect(out).not.toHaveBeenCalled();
+		expect(err).not.toHaveBeenCalled();
+	});
+
+	test("keeps only the last 16 KiB of output", async () => {
+		const r = await runArgv(
+			sh(
+				"i=0; while [ $i -lt 2000 ]; do echo line-$i-xxxxxxxxxxxxxxxx; i=$((i+1)); done",
+			),
+			{ timeoutMs: 10_000 },
+		);
+		expect(Buffer.byteLength(r.outputTail)).toBeLessThanOrEqual(
+			OUTPUT_TAIL_BYTES,
+		);
+		expect(r.outputTail).toContain("line-1999-");
+		expect(r.outputTail).not.toContain("line-0-");
+	});
+
+	test("an argument is one argument: nothing reaches a shell", async () => {
+		const r = await runArgv(
+			{ cmd: "/bin/echo", args: ["a b; echo injected"] },
+			{ timeoutMs: 5_000 },
+		);
+		expect(r.outputTail.trim()).toBe("a b; echo injected");
+	});
+
+	test("stdin is not the terminal", async () => {
+		const r = await runArgv(sh("cat; echo done"), { timeoutMs: 5_000 });
+		expect(r.outputTail.trim()).toBe("done");
+	});
+
+	test("a missing executable is a spawn error, not a throw", async () => {
+		const r = await runArgv(
+			{ cmd: "/nonexistent/tool", args: [] },
+			{ timeoutMs: 5_000 },
+		);
+		expect(r.exitCode).toBeNull();
+		expect(r.spawnError).toContain("ENOENT");
+		expect(succeeded(r)).toBe(false);
+	});
+
+	test("over the limit: SIGTERM, then SIGKILL once the grace runs out", async () => {
+		const started = Date.now();
+		const r = await runArgv(sh("trap '' TERM; while :; do sleep 0.05; done"), {
+			timeoutMs: 200,
+			killGraceMs: 300,
+		});
+		expect(r.timedOut).toBe(true);
+		expect(r.signal).toBe("SIGKILL");
+		expect(Date.now() - started).toBeGreaterThanOrEqual(450);
+		expect(runFailureReason(r)).toStartWith("timed out");
+	});
+
+	test("a child that honours SIGTERM ends there", async () => {
+		const r = await runArgv(sh("exec sleep 10"), { timeoutMs: 200 });
+		expect(r.timedOut).toBe(true);
+		expect(r.signal).toBe("SIGTERM");
+	});
+
+	test("the failure reason is the installer's last line", async () => {
+		const r = await runArgv(
+			sh("echo progress; echo 'error: no such formula' >&2; exit 3"),
+			{
+				timeoutMs: 5_000,
+			},
+		);
+		expect(runFailureReason(r)).toBe("exit 3: error: no such formula");
+	});
+});

package/src/__tests__/tool-probe.test.ts

@@ -1395,7 +1395,7 @@ describe("binPinCommand — moving an installed tool to exactly its pin", () =>
 	test("bun/npm/go carry the version in the package token", () => {
 		expect(
 			binPinCommand({ name: "m", via: "bun", version: "1.0.0" }, uv),
-		).toEqual({ cmd: "bun", args: ["install", "-g", "m@1.0.0"] });
+		).toEqual({ cmd: "bun", args: ["add", "-g", "m@1.0.0"] });
 		expect(
 			binPinCommand(
 				{ name: "t", via: "go", module: "github.com/x/t", version: "v2.0.0" },

package/src/__tests__/toolchain.test.ts

@@ -2,12 +2,13 @@ import { describe, expect, test } from "bun:test";
 import {
 	PYTHON_CLI_INSTALLERS,
 	type PythonCliInstaller,
-	binInstallCommand,
 	binUpgradeCommand,
-	detectToolchains,
+	managedBins,
+	managedInstallCommand,
+	managedOption,
+	managedTool,
 	resolvePythonCliInstaller,
 } from "../services/toolchain.js";
-import type { ResolvedBin } from "../types/index.js";
 import { formatCommand } from "../utils/command-utils.js";
 
 /**
@@ -26,21 +27,21 @@ const UV = byProbe("uv");
 const PIPX = byProbe("pipx");
 const PY = byProbe("python3");
 
-describe("binInstallCommand", () => {
+describe("managedInstallCommand (rendered by requires-probe's renderInstall)", () => {
 	test("bun with and without a version pin", () => {
 		expect(
 			formatCommand(
-				binInstallCommand({
+				managedInstallCommand({
 					name: "claudish",
 					via: "bun",
 					package: "claudish",
 					version: "1.2.0",
 				}),
 			),
-		).toBe("bun install -g claudish@1.2.0");
+		).toBe("bun add -g claudish@1.2.0");
 		expect(
-			formatCommand(binInstallCommand({ name: "claudish", via: "bun" })),
-		).toBe("bun install -g claudish");
+			formatCommand(managedInstallCommand({ name: "claudish", via: "bun" })),
+		).toBe("bun add -g claudish");
 	});
 
 	test("the package name is ONE argv token, whatever is in it", () => {
@@ -51,18 +52,18 @@ describe("binInstallCommand", () => {
 		// 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 });
+		const cmd = managedInstallCommand({ name: "x", via: "bun", package: evil });
 		expect(cmd.cmd).toBe("bun");
-		expect(cmd.args).toEqual(["install", "-g", evil]);
+		expect(cmd.args).toEqual(["add", "-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 /'");
+		expect(formatCommand(cmd)).toBe("bun add -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({
+		const cmd = managedInstallCommand({
 			name: "claudish",
 			via: "bun",
 			version: "1.2.0",
@@ -76,24 +77,32 @@ describe("binInstallCommand", () => {
 		// 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" })),
+			formatCommand(
+				managedInstallCommand({ name: "x", via: "npm", package: "x" }),
+			),
 		).toBe("npm install -g x");
 		expect(
 			formatCommand(
-				binInstallCommand(
-					{ name: "aider", via: "pip", package: "aider", version: "0.1" },
-					UV,
-				),
+				managedInstallCommand({
+					name: "aider",
+					via: "pip",
+					package: "aider",
+					version: "0.1",
+				}),
 			),
 		).toBe("uv tool install aider==0.1");
 		expect(
 			formatCommand(
-				binInstallCommand({ name: "tmux", via: "brew", formula: "tmux" }),
+				managedInstallCommand({ name: "tmux", via: "brew", formula: "tmux" }),
 			),
 		).toBe("brew install tmux");
 		expect(
 			formatCommand(
-				binInstallCommand({ name: "t", via: "go", module: "github.com/x/t" }),
+				managedInstallCommand({
+					name: "t",
+					via: "go",
+					module: "github.com/x/t",
+				}),
 			),
 		).toBe("go install github.com/x/t@latest");
 	});
@@ -132,7 +141,7 @@ describe("binUpgradeCommand", () => {
 			// 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)),
+				formatCommand(managedInstallCommand(bin)),
 			);
 		}
 	});
@@ -172,20 +181,11 @@ describe("resolvePythonCliInstaller", () => {
 	});
 
 	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");
+		expect(PIPX.install("a", "1.2").args).toEqual(["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,
+			managedInstallCommand({ name: "a", via: "pip", version: "1.2" }).args,
 		).toEqual(["tool", "install", "a==1.2"]);
 	});
 
@@ -207,26 +207,97 @@ describe("resolvePythonCliInstaller", () => {
 	});
 });
 
-describe("detectToolchains", () => {
-	test("groups bins by installer and reports requiredBy + presence", async () => {
-		const bins: ResolvedBin[] = [
-			{ name: "claudish", via: "bun", sources: ["a"] },
-			{ name: "mnemex", via: "bun", sources: ["b"] },
-			{ name: "tmux", via: "brew", sources: ["c"] },
-		];
-		const statuses = await detectToolchains(bins);
-		const bun = statuses.find((s) => s.name === "bun")!;
-		const brew = statuses.find((s) => s.name === "brew")!;
-		expect(bun.requiredBy.sort()).toEqual(["claudish", "mnemex"]);
-		expect(brew.requiredBy).toEqual(["tmux"]);
-		// bun/brew are bootstrappable; the field is populated.
-		expect(bun.bootstrap).toContain("bun.sh");
-		expect(typeof bun.present).toBe("boolean");
-		// stable order: bun before brew
-		expect(statuses.map((s) => s.name)).toEqual(["bun", "brew"]);
-	});
-
-	test("returns only toolchains actually needed (empty for no bins)", async () => {
-		expect(await detectToolchains([])).toEqual([]);
+describe("managedTool — the version-managed view of a requirement", () => {
+	test("bun/npm/pip/go/brew options map onto the managed shape, pin included", () => {
+		expect(
+			managedTool({
+				name: "claudish",
+				check: ["claudish", "--version"],
+				install: [],
+				chosen: { via: "bun", package: "claudish", version: "1.2.0" },
+			}),
+		).toEqual({
+			name: "claudish",
+			via: "bun",
+			package: "claudish",
+			check: "claudish --version",
+			version: "1.2.0",
+		});
+		expect(
+			managedTool({
+				name: "t",
+				check: ["t"],
+				install: [],
+				chosen: { via: "go", package: "github.com/x/t" },
+			}),
+		).toMatchObject({ via: "go", module: "github.com/x/t" });
+		expect(
+			managedTool({
+				name: "tmux",
+				check: ["tmux", "-V"],
+				install: [],
+				chosen: { via: "brew", formula: "tmux" },
+			}),
+		).toMatchObject({ via: "brew", formula: "tmux" });
+	});
+
+	test("apt, release, bootstrap and the uv kinds have no managed version", () => {
+		const base = { name: "x", check: ["x"], install: [] };
+		for (const chosen of [
+			{ via: "apt" as const, packages: ["x"] },
+			{ via: "bootstrap" as const, tool: "uv" as const },
+			{ via: "uv-script" as const, script: "s.py", args: [] },
+			{ via: "uv-module" as const, script: "s.py", module: "m", args: [] },
+		]) {
+			expect(managedTool({ ...base, chosen })).toBeNull();
+		}
+		expect(managedTool({ ...base, chosen: null })).toBeNull();
+	});
+
+	test("managedBins keeps provenance and drops what is not managed", () => {
+		const bins = managedBins([
+			{
+				name: "a",
+				check: ["a"],
+				install: [],
+				chosen: { via: "npm", package: "a" },
+				sources: ["plugin:p@m"],
+			},
+			{
+				name: "b",
+				check: ["b"],
+				install: [],
+				chosen: { via: "apt", packages: ["b"] },
+				sources: ["plugin:p@m"],
+			},
+		]);
+		expect(bins).toEqual([
+			{
+				name: "a",
+				via: "npm",
+				package: "a",
+				check: "a",
+				sources: ["plugin:p@m"],
+			},
+		]);
+	});
+
+	test("managedOption round-trips through managedTool", () => {
+		for (const t of [
+			{ name: "c", via: "bun" as const, package: "c", version: "1" },
+			{ name: "t", via: "brew" as const, formula: "tmux" },
+			{ name: "g", via: "go" as const, module: "github.com/x/g" },
+			{ name: "p", via: "pip" as const, package: "p" },
+		]) {
+			const option = managedOption(t);
+			expect(
+				managedTool({
+					name: t.name,
+					check: [t.name],
+					install: [option],
+					chosen: option,
+				}),
+			).toMatchObject(t);
+		}
 	});
 });

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

@@ -859,7 +859,7 @@ describe("binNeedsWork — one predicate for apply, the meter and 'has work'", (
 				{ ...itemFor("upgrade"), name: "mnemex", target: "1.0.0" },
 				spec,
 			),
-		).toEqual({ cmd: "bun", args: ["install", "-g", "mnemex@1.0.0"] });
+		).toEqual({ cmd: "bun", args: ["add", "-g", "mnemex@1.0.0"] });
 		expect(
 			binCommandFor(
 				{ ...itemFor("upgrade"), target: "2.0.0" },

package/src/cli/ansi.ts

@@ -23,6 +23,7 @@
 
 import { barTrack } from "../ui/theme-mode.js";
 import { brand } from "../ui/theme.js";
+import { CSI, stripAnsi } from "../utils/string-utils.js";
 
 // -- colour capability -------------------------------------------------------
 
@@ -192,13 +193,7 @@ export function dim(text: string): string {
 
 // -- measuring ---------------------------------------------------------------
 
-/** Every CSI sequence, not only SGR — the live region emits cursor moves too. */
-// biome-ignore lint/suspicious/noControlCharactersInRegex: ESC is the thing being matched.
-const CSI = /\x1b\[[0-9;?]*[\x20-\x2f]*[\x40-\x7e]/g;
-
-export function stripAnsi(text: string): string {
-	return text.replace(CSI, "");
-}
+export { stripAnsi };
 
 /**
  * Cells one codepoint occupies: 0, 1 or 2.