magus-cli 7.3.0 → 7.4.0

package/src/__tests__/blind/child-run.ts

@@ -0,0 +1,114 @@
+/**
+ * Run a contract call in a child `bun` process whose HOME is a temp dir.
+ *
+ * Why a child: under Bun, `os.homedir()` ignores a `process.env.HOME` change
+ * made at runtime, but honours HOME set when the process starts
+ * (architecture.md C2, correction of 2026-09-18). Anything that could resolve
+ * `~/.claude` therefore runs here, never in the test process.
+ *
+ * Safety, in order:
+ *  1. the child's env pins HOME, CLAUDE_CONFIG_DIR and XDG_CONFIG_HOME inside
+ *     the temp home, and its cwd is a temp dir;
+ *  2. before importing anything under test, the child checks that
+ *     `os.homedir()` IS the temp home, and stops if not ("guard" stage);
+ *  3. the child reports only a JSON summary chosen by the test (booleans,
+ *     names, URLs) on a marker line. Values read from files and error
+ *     messages are never printed, and the child's raw stdout/stderr is never
+ *     surfaced — so no test output can echo the contents of a user file.
+ */
+import path from "node:path";
+
+const MARK = "__BLIND_RESULT__";
+
+export type ChildResult = Record<string, unknown> & { stage: string };
+
+export interface ChildRun {
+	/** Temp HOME for the child. */
+	home: string;
+	/** Working directory for the child — always a temp dir. */
+	cwd: string;
+	/** Absolute path of the module under test, or undefined for none. */
+	module?: string;
+	/** Passed to the child as `job` (JSON). */
+	job?: Record<string, unknown>;
+	/** JS run BEFORE the module is imported (e.g. install a fetch mock). */
+	setup?: string;
+	/** JS run after import. Has `job`, `mod`, `out(summary)` in scope. */
+	body: string;
+	timeoutMs?: number;
+}
+
+function childScript(setup: string, body: string): string {
+	return `
+const MARK = ${JSON.stringify(MARK)};
+const out = async (o) => { await Bun.write(Bun.stdout, "\\n" + MARK + JSON.stringify(o) + "\\n"); };
+(async () => {
+	try {
+		const os = await import("node:os");
+		const job = JSON.parse(process.env.BLIND_JOB || "{}");
+		if (os.homedir() !== job.__home || process.env.HOME !== job.__home) {
+			await out({ stage: "guard", homeRedirected: false });
+			return;
+		}
+		${setup}
+		let mod = null;
+		if (job.__module) {
+			try {
+				mod = await import(job.__module);
+			} catch (e) {
+				await out({ stage: "import", error: String((e && e.message) || e).split("\\n")[0] });
+				return;
+			}
+		}
+		${body}
+	} catch (e) {
+		await out({ stage: "harness", name: (e && e.name) || typeof e });
+	}
+})().then(() => process.exit(0));
+`;
+}
+
+export function runInChild(run: ChildRun): ChildResult {
+	const job = {
+		...(run.job ?? {}),
+		__home: run.home,
+		__module: run.module ?? null,
+	};
+	const proc = Bun.spawnSync(
+		[
+			process.execPath,
+			"--no-env-file",
+			"-e",
+			childScript(run.setup ?? "", run.body),
+		],
+		{
+			cwd: run.cwd,
+			env: {
+				...process.env,
+				HOME: run.home,
+				CLAUDE_CONFIG_DIR: path.join(run.home, ".claude"),
+				XDG_CONFIG_HOME: path.join(run.home, ".config"),
+				BLIND_JOB: JSON.stringify(job),
+			},
+			stdout: "pipe",
+			stderr: "pipe",
+			timeout: run.timeoutMs ?? 25_000,
+		},
+	);
+	const line = proc.stdout
+		.toString()
+		.split("\n")
+		.reverse()
+		.find((l) => l.startsWith(MARK));
+	if (!line) {
+		// Withhold the child's output: it could echo a file's contents. A
+		// module-resolution line names paths only, so that one is safe to show.
+		const moduleLine = proc.stderr
+			.toString()
+			.match(/Cannot find module[^\n]*/)?.[0];
+		throw new Error(
+			`child bun produced no result (exit ${proc.exitCode}${moduleLine ? `; ${moduleLine}` : ""}); its raw output is withheld`,
+		);
+	}
+	return JSON.parse(line.slice(MARK.length)) as ChildResult;
+}

package/src/__tests__/cli-tools-adapter.test.ts

@@ -240,7 +240,7 @@ describe("buildToolRow — which installer a catalogue row is judged through", (
 });
 
 describe("cliToolStatusText — the row's words", () => {
-	test("unknown renders as ? <note>, the note verbatim", () => {
+	test("unknown renders as ? <short label>; the full note stays on the status", () => {
 		const tool = catalogue("crush");
 		const spec = specForCatalogTool(tool, null, {
 			primary: "npm",
@@ -250,7 +250,10 @@ describe("cliToolStatusText — the row's words", () => {
 		const row = buildToolRow(tool, spec, f);
 		const text = cliToolStatusText(row);
 		expect(text.tone).toBe("warning");
-		expect(text.suffix).toBe(` ? ${classifyTool(spec, f).note}`);
+		expect(text.suffix).toBe(" ? not managed by npm");
+		// The note (with its path) is for the detail pane's "Why", not the row.
+		expect(row.status?.note).toBe(classifyTool(spec, f).note);
+		expect(text.suffix).not.toContain("/");
 	});
 
 	test("upgrade names the target once, with one v", () => {

package/src/__tests__/component-badge.test.ts

@@ -1,8 +1,8 @@
 import { afterEach, describe, expect, it } from "bun:test";
 import {
-	COMPONENT_BADGE,
+	COMPONENT_CHIP,
 	CONTRAST_REFERENCE_KEYS,
-	componentBadge,
+	componentChip,
 	resetThemeMode,
 	setThemeMode,
 } from "../ui/theme-mode.js";
@@ -30,51 +30,44 @@ function contrast(a: string, b: string): number {
 	return (hi + 0.05) / (lo + 0.05);
 }
 
-const KINDS = ["skill", "command", "agent", "mcp"] as const;
-
-describe("componentBadge", () => {
+/**
+ * The chip behind a plugin component's type glyph. It used to be a wash in a
+ * different hue per kind; the glyph already says the kind, so it is now one
+ * neutral chip for all of them (see `COMPONENT_CHIP`).
+ */
+describe("componentChip", () => {
 	it("serves the dark pair before any resolution", () => {
 		// There is no unknown: dark is the stated default, so a chip is always a
 		// pair, never null, and the caller has no bare-glyph branch to keep.
-		for (const kind of KINDS) {
-			expect(componentBadge(kind)).toEqual(COMPONENT_BADGE[kind].dark);
-		}
+		expect(componentChip()).toEqual(COMPONENT_CHIP.dark);
 	});
 
 	it("serves the light pair on a light terminal", () => {
 		setThemeMode("light");
-
-		expect(componentBadge("skill")).toEqual(COMPONENT_BADGE.skill.light);
-		expect(componentBadge("mcp")).toEqual(COMPONENT_BADGE.mcp.light);
+		expect(componentChip()).toEqual(COMPONENT_CHIP.light);
 	});
 
 	it("serves the dark pair on a dark terminal", () => {
 		setThemeMode("dark");
-
-		expect(componentBadge("skill")).toEqual(COMPONENT_BADGE.skill.dark);
-		expect(componentBadge("mcp")).toEqual(COMPONENT_BADGE.mcp.dark);
+		expect(componentChip()).toEqual(COMPONENT_CHIP.dark);
 	});
 
-	it("keeps every glyph legible on its own chip", () => {
+	it("keeps the glyph legible on its own chip", () => {
 		// 3:1 is the floor the rest of the palette is measured to. A chip whose
 		// glyph disappears into its wash is worse than no chip at all.
-		for (const kind of KINDS) {
-			for (const mode of ["light", "dark"] as const) {
-				const { bg, fg } = COMPONENT_BADGE[kind][mode];
-				expect(contrast(bg, fg)).toBeGreaterThanOrEqual(3);
-			}
+		for (const mode of ["light", "dark"] as const) {
+			const { bg, fg } = COMPONENT_CHIP[mode];
+			expect(contrast(bg, fg)).toBeGreaterThanOrEqual(3);
 		}
 	});
 
-	it("keeps every chip quiet against the page it is drawn on", () => {
+	it("keeps the chip quiet against the page it is drawn on", () => {
 		// The wash must read as a tint of the page, not as a block on it. Above
 		// ~1.6 it stops being a chip and starts being a highlight bar.
-		for (const kind of KINDS) {
-			for (const mode of ["light", "dark"] as const) {
-				const { bg } = COMPONENT_BADGE[kind][mode];
-				const page = CONTRAST_REFERENCE_KEYS[mode];
-				expect(contrast(bg, page)).toBeLessThan(1.6);
-			}
+		for (const mode of ["light", "dark"] as const) {
+			const { bg } = COMPONENT_CHIP[mode];
+			const page = CONTRAST_REFERENCE_KEYS[mode];
+			expect(contrast(bg, page)).toBeLessThan(1.6);
 		}
 	});
 
@@ -86,13 +79,4 @@ describe("componentBadge", () => {
 		expect(CONTRAST_REFERENCE_KEYS.light).toBe(CONTRAST_REFERENCE.light);
 		expect(CONTRAST_REFERENCE_KEYS.dark).toBe(CONTRAST_REFERENCE.dark);
 	});
-
-	it("gives each kind a distinguishable hue", () => {
-		// Single-character colour carries no readable hue *shift*, only a readable
-		// hue *difference* — the same reason the scope squares are far apart.
-		for (const mode of ["light", "dark"] as const) {
-			const fills = KINDS.map((k) => COMPONENT_BADGE[k][mode].bg);
-			expect(new Set(fills).size).toBe(KINDS.length);
-		}
-	});
 });

package/src/__tests__/footer-hints.test.ts

@@ -7,7 +7,7 @@
  * does not exist.
  */
 import { describe, expect, test } from "bun:test";
-import { joinKeys } from "../ui/components/layout/FooterHints.js";
+import { joinKeys } from "../ui/keymap.js";
 
 describe("joinKeys", () => {
 	test("single-character keys butt together, the way an arrow pair is written", () => {

package/src/__tests__/manifest.test.ts

@@ -32,20 +32,6 @@ describe("migrateToV2", () => {
 		expect(v2.profiles.mine!.plugins).toEqual({ "dev@magus": true });
 	});
 
-	test("null/garbage input degrades to an empty manifest", () => {
-		expect(migrateToV2(null)).toEqual(emptyManifest());
-		expect(migrateToV2(42)).toEqual(emptyManifest());
-		expect(migrateToV2({})).toEqual(emptyManifest());
-	});
-
-	test("non-object profile entries are dropped", () => {
-		const v2 = migrateToV2({
-			version: 2,
-			profiles: { good: { name: "G" }, bad: 5 },
-		});
-		expect(Object.keys(v2.profiles)).toEqual(["good"]);
-	});
-
 	test("strictVersions is carried through as a boolean", () => {
 		expect(
 			migrateToV2({ version: 2, strictVersions: true, profiles: {} })
@@ -226,9 +212,9 @@ describe("mergeManifestSettings", () => {
 		);
 	});
 
-	// readManifest degrades a corrupt file to an empty manifest. Reusing it here
-	// would record nothing and report success, leaving the caller's live setting
-	// to be reverted by the next install with no way to learn why.
+	// A merge that quietly treated a corrupt file as empty would record nothing and
+	// report success, leaving the caller's live setting to be reverted by the next
+	// install with no way to learn why.
 	test("throws on an unreadable manifest instead of silently doing nothing", async () => {
 		await fs.outputFile(join(dir, ".claude", "profiles.json"), "{ not json");
 
@@ -278,4 +264,26 @@ describe("readManifest / writeManifest", () => {
 		expect(m.version).toBe(2);
 		expect(m.profiles.legacy!.name).toBe("L");
 	});
+
+	// These inputs used to degrade to an empty manifest (garbage) or lose the
+	// bad entry (non-object profile). "Empty" is the state that offers to save a
+	// first profile over the file, so both are now refusals.
+	test("null/garbage input is refused, not read as an empty manifest", async () => {
+		const file = join(dir, ".claude", "profiles.json");
+		for (const garbage of ["null", "42"]) {
+			await fs.outputFile(file, garbage);
+			await expect(readManifest(dir)).rejects.toThrow(file);
+		}
+		await fs.outputFile(file, "{}");
+		expect(await readManifest(dir)).toEqual(emptyManifest());
+	});
+
+	test("a non-object profile entry is refused, not dropped", async () => {
+		const file = join(dir, ".claude", "profiles.json");
+		await fs.outputJson(file, {
+			version: 2,
+			profiles: { good: { name: "G" }, bad: 5 },
+		});
+		await expect(readManifest(dir)).rejects.toThrow(file);
+	});
 });

package/src/__tests__/marketplace-badge.test.ts

@@ -52,8 +52,8 @@ function toneFor(marketplace: Marketplace): string | undefined {
 
 describe("marketplace category badge", () => {
 	test("the byline uses a low-key tone, not an attention-grabbing one", () => {
-		// It is a signature, not a status. Green reads as "action succeeded" and
-		// competes with the plugin rows for attention.
+		// It is a signature, not a status. The success role reads as "action
+		// succeeded" and competes with the plugin rows for attention.
 		expect(
 			toneFor(
 				mp({
@@ -63,7 +63,7 @@ describe("marketplace category badge", () => {
 			),
 		).toBe("byline");
 
-		// A third-party marketplace still uses the green "Added" status tone.
+		// A third-party marketplace still uses the "Added" status tone, by role.
 		expect(
 			toneFor(
 				mp({
@@ -71,7 +71,7 @@ describe("marketplace category badge", () => {
 					source: { source: "github", repo: "obra/superpowers-marketplace" },
 				}),
 			),
-		).toBe("green");
+		).toBe("success");
 	});
 
 	test("MadAppGang marketplaces carry the byline instead of a generic label", () => {

package/src/__tests__/models-screen-state.test.ts

@@ -1,8 +1,11 @@
 import { describe, expect, test } from "bun:test";
 import { join } from "node:path";
+import { parseKeypress } from "@opentui/core";
 import fs from "fs-extra";
 import { DEFAULT_PRESET, findPreset } from "../data/models-presets.js";
 import type { ModelsStatus } from "../services/models-core.js";
+import type { KeyPress } from "../ui/input/key-dispatch.js";
+import { SCREEN_BINDINGS, matchBinding } from "../ui/keymap.js";
 import { appReducer, initialState } from "../ui/state/reducer.js";
 import type { AppAction, AppState, ModelsSnapshot } from "../ui/state/types.js";
 import { asyncValue } from "../ui/state/types.js";
@@ -11,6 +14,18 @@ function run(actions: AppAction[], from: AppState = initialState): AppState {
 	return actions.reduce(appReducer, from);
 }
 
+/** A real parsed keypress, in the shape the keymap matches. */
+function press(raw: string): KeyPress {
+	const k = parseKeypress(raw);
+	return {
+		name: k?.name ?? "",
+		sequence: k?.sequence ?? "",
+		ctrl: k?.ctrl === true,
+		meta: k?.meta === true,
+		shift: k?.shift === true,
+	};
+}
+
 function status(over: Partial<ModelsStatus> = {}): ModelsStatus {
 	return { state: "off", preset: null, drift: [], warnings: [], ...over };
 }
@@ -268,23 +283,31 @@ const SCREEN = join(import.meta.dir, "..", "ui", "screens", "ModelsScreen.tsx");
 
 describe("ModelsScreen keybindings", () => {
 	test("a and Enter both apply, and c clears", async () => {
-		const src = await fs.readFile(SCREEN, "utf8");
-		expect(src).toContain('event.name === "a"');
-		expect(src).toContain('event.name === "c"');
-		expect(src).toContain('event.name === "r"');
-		expect(src).toContain('event.name === "/"');
+		const models = SCREEN_BINDINGS.models;
+		expect(matchBinding(models, press("a"))?.id).toBe("apply");
+		expect(matchBinding(models, press("c"))?.id).toBe("off");
+		expect(matchBinding(models, press("r"))?.id).toBe("reload");
+		expect(matchBinding(models, press("/"))?.id).toBe("search");
 		// Enter is the same action as `a`. There is nothing to "open" here, so
 		// binding the most obvious key to nothing would be the wrong lesson.
-		const enter = src.indexOf('event.name === "return"');
-		expect(enter).toBeGreaterThan(-1);
-		expect(src.slice(enter, enter + 400)).toContain("handleApply()");
+		expect(matchBinding(models, press("\r"))?.id).toBe("apply");
+		const src = await fs.readFile(SCREEN, "utf8");
+		const apply = src.indexOf("apply: () =>");
+		expect(apply).toBeGreaterThan(-1);
+		expect(src.slice(apply, apply + 120)).toContain("handleApply()");
 	});
 
-	test("digits are treated as navigation, so a message survives a tab round trip", async () => {
-		// Every digit now navigates, 0 included. Clearing the status line on the
-		// way OUT of the tab loses the message the state was changed to preserve.
-		const src = await fs.readFile(SCREEN, "utf8");
-		expect(src).toContain("/^[0-9]$/.test(event.name");
+	test("digits and Tab never reach the screen, so a message survives a tab round trip", () => {
+		// The status line is cleared only by this screen's own bindings. Every
+		// digit (0 included) and Tab navigate, and they belong to the global key
+		// layer: no Models binding may claim one, or the message would be wiped
+		// on the way OUT of the tab — the loss the state was moved to prevent.
+		for (const digit of "1234567890") {
+			expect(
+				matchBinding(SCREEN_BINDINGS.models, press(digit)),
+			).toBeUndefined();
+		}
+		expect(matchBinding(SCREEN_BINDINGS.models, press("\t"))).toBeUndefined();
 	});
 
 	test("no screen still treats 0 as a non-navigation key", async () => {

package/src/__tests__/npm-package-name-api.test.ts

@@ -0,0 +1,111 @@
+/**
+ * The npm package name has one source of truth, and the self-upgrade builders
+ * read it.
+ *
+ * `MAGUS_NPM_PACKAGE` is `package.json` `name` (`magus-cli`). It is the npm
+ * package, NOT the command: the command is the `bin` key (`magus`), and the
+ * bare npm name belongs to an unrelated package. `selfUpgradeCommand` and
+ * `duplicateInstallRemoval` are the pure builders behind `magus upgrade`.
+ *
+ * Written black-box from the API contract. On the old tree this file fails at
+ * import, because none of these exports existed.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+	type SelfUpgradeManager,
+	duplicateInstallRemoval,
+	selfUpgradeCommand,
+} from "../cli/upgrade.js";
+import { MAGUS_NPM_PACKAGE } from "../data/npm-package.js";
+
+// Read at test time: the single source of truth the requirements name.
+const PKG = JSON.parse(
+	readFileSync(join(import.meta.dir, "..", "..", "package.json"), "utf8"),
+) as { name: string; version: string; bin: Record<string, string> };
+
+const COMMAND = "magus";
+const PACKAGE = "magus-cli";
+const MANAGERS: SelfUpgradeManager[] = ["bun", "npm"];
+
+describe("MAGUS_NPM_PACKAGE", () => {
+	test("is package.json `name`", () => {
+		expect(typeof MAGUS_NPM_PACKAGE).toBe("string");
+		expect(MAGUS_NPM_PACKAGE).toBe(PKG.name);
+		expect(MAGUS_NPM_PACKAGE).toBe(PACKAGE);
+	});
+
+	test("is not the command", () => {
+		const commands = Object.keys(PKG.bin);
+		expect(commands).toContain(COMMAND);
+		expect(commands).not.toContain(MAGUS_NPM_PACKAGE);
+		expect(MAGUS_NPM_PACKAGE).not.toBe(COMMAND);
+	});
+});
+
+describe("selfUpgradeCommand", () => {
+	test("bun installs `<package>@latest` globally", () => {
+		expect(selfUpgradeCommand("bun")).toEqual({
+			cmd: "bun",
+			args: ["install", "-g", `${PACKAGE}@latest`],
+		});
+	});
+
+	test("npm installs `<package>@latest` globally", () => {
+		expect(selfUpgradeCommand("npm")).toEqual({
+			cmd: "npm",
+			args: ["install", "-g", `${PACKAGE}@latest`],
+		});
+	});
+
+	test("is pure: the answer does not depend on PATH", () => {
+		const expected = MANAGERS.map((m) => selfUpgradeCommand(m));
+		const emptyDir = mkdtempSync(join(tmpdir(), "magus-selfupgrade-path-"));
+		const savedPath = process.env.PATH;
+		try {
+			process.env.PATH = emptyDir;
+			const again = MANAGERS.map((m) => selfUpgradeCommand(m));
+			expect(again).toEqual(expected);
+		} finally {
+			process.env.PATH = savedPath;
+			rmSync(emptyDir, { recursive: true, force: true });
+		}
+		expect(MANAGERS.map((m) => selfUpgradeCommand(m))).toEqual(expected);
+	});
+
+	test("reads the package name from the single source", () => {
+		for (const m of MANAGERS) {
+			const { cmd, args } = selfUpgradeCommand(m);
+			expect(cmd).toBe(m);
+			expect(args[args.length - 1]).toBe(`${MAGUS_NPM_PACKAGE}@latest`);
+		}
+	});
+});
+
+describe("duplicateInstallRemoval", () => {
+	test("bun names the package", () => {
+		expect(duplicateInstallRemoval("bun")).toBe(`bun uninstall -g ${PACKAGE}`);
+	});
+
+	test("npm names the package", () => {
+		expect(duplicateInstallRemoval("npm")).toBe(`npm uninstall -g ${PACKAGE}`);
+	});
+
+	test("carries no leading indentation (the caller indents)", () => {
+		for (const m of MANAGERS) {
+			const hint = duplicateInstallRemoval(m);
+			expect(hint).toBe(hint.trimStart());
+		}
+	});
+
+	test("reads the package name from the single source", () => {
+		for (const m of MANAGERS) {
+			const tokens = duplicateInstallRemoval(m).split(" ");
+			expect(tokens[0]).toBe(m);
+			expect(tokens[tokens.indexOf("-g") + 1]).toBe(MAGUS_NPM_PACKAGE);
+		}
+	});
+});