magus-cli 0.0.0-placeholder → 7.0.0

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

@@ -0,0 +1,315 @@
+import { describe, expect, test } from "bun:test";
+import { join } from "node:path";
+import fs from "fs-extra";
+import { DEFAULT_PRESET, findPreset } from "../data/models-presets.js";
+import type { ModelsStatus } from "../services/models-core.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";
+
+function run(actions: AppAction[], from: AppState = initialState): AppState {
+	return actions.reduce(appReducer, from);
+}
+
+function status(over: Partial<ModelsStatus> = {}): ModelsStatus {
+	return { state: "off", preset: null, drift: [], warnings: [], ...over };
+}
+
+function snapshot(over: Partial<ModelsSnapshot> = {}): ModelsSnapshot {
+	return {
+		status: status(),
+		config: null,
+		path: "/x/.claude/models.json",
+		...over,
+	};
+}
+
+/** Drop `//` line comments and block comments, so a source guard matches code only. */
+function stripComments(source: string): string {
+	return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+}
+
+/** Navigating away and back is what unmounts the screen. */
+const roundTrip: AppAction[] = [
+	{ type: "NAVIGATE", route: { screen: "plugins" } },
+	{ type: "NAVIGATE", route: { screen: "models" } },
+];
+
+describe("models screen initial state", () => {
+	test("starts idle, unfiltered, and with no message", () => {
+		expect(initialState.models.data.status).toBe("idle");
+		expect(initialState.models.searchQuery).toBe("");
+		expect(initialState.models.status).toBeNull();
+		expect(initialState.models.isApplying).toBe(false);
+		// The mate slots are not drawn until something says they can be served. Starting
+		// true would put three rows on screen before anything had been asked.
+		expect(initialState.models.matesAvailable).toBe(false);
+	});
+
+	test("the models route is reachable and NAVIGATE keeps the screen's state", () => {
+		const state = run([
+			{ type: "MODELS_DATA_SUCCESS", snapshot: snapshot() },
+			...roundTrip,
+		]);
+		expect(state.currentRoute.screen).toBe("models");
+		expect(state.models.data.status).toBe("success");
+	});
+});
+
+describe("models search state", () => {
+	test("appending builds up the query one character at a time", () => {
+		// The regression this guards: computing `searchQuery + char` in the screen
+		// reads a value captured at render time, so keystrokes arriving faster
+		// than React re-renders all start from the same stale string.
+		const state = run([
+			{ type: "MODELS_SEARCH_APPEND", char: "o" },
+			{ type: "MODELS_SEARCH_APPEND", char: "p" },
+			{ type: "MODELS_SEARCH_APPEND", char: "u" },
+			{ type: "MODELS_SEARCH_APPEND", char: "s" },
+		]);
+		expect(state.models.searchQuery).toBe("opus");
+	});
+
+	test("appending resets the cursor so it cannot sit past the filtered list", () => {
+		const state = run([
+			{ type: "MODELS_SELECT", index: 4 },
+			{ type: "MODELS_SEARCH_APPEND", char: "h" },
+		]);
+		expect(state.models.selectedIndex).toBe(0);
+	});
+
+	test("backspace removes one character at a time", () => {
+		const typed = run([
+			{ type: "MODELS_SEARCH_APPEND", char: "a" },
+			{ type: "MODELS_SEARCH_APPEND", char: "b" },
+			{ type: "MODELS_SEARCH_APPEND", char: "c" },
+		]);
+		expect(
+			run([{ type: "MODELS_SEARCH_BACKSPACE" }], typed).models.searchQuery,
+		).toBe("ab");
+	});
+
+	test("backspace on an empty query is harmless", () => {
+		expect(run([{ type: "MODELS_SEARCH_BACKSPACE" }]).models.searchQuery).toBe(
+			"",
+		);
+	});
+
+	test("clearing the filter is one action, and it leaves the data alone", () => {
+		const filtered = run([
+			{ type: "MODELS_DATA_SUCCESS", snapshot: snapshot() },
+			{ type: "MODELS_SEARCH_APPEND", char: "z" },
+		]);
+		const cleared = run([{ type: "MODELS_SET_SEARCH", query: "" }], filtered);
+		expect(cleared.models.searchQuery).toBe("");
+		expect(cleared.models.data.status).toBe("success");
+	});
+});
+
+describe("models data state", () => {
+	test("a reload keeps the last snapshot on screen", () => {
+		// Reading the routing scans session transcripts to resolve the live model
+		// id behind each alias, so a reload is not instant. Without `previous` the
+		// list blanks to "Reading…" every time — including on every tab switch,
+		// because the router unmounts the screen and the effect refetches.
+		const loaded = run([
+			{ type: "MODELS_DATA_SUCCESS", snapshot: snapshot({ path: "/a" }) },
+			{ type: "MODELS_DATA_LOADING" },
+		]);
+		expect(loaded.models.data.status).toBe("loading");
+		expect(asyncValue(loaded.models.data)?.path).toBe("/a");
+	});
+
+	test("a FIRST load has nothing to carry, and says so", () => {
+		const loading = run([{ type: "MODELS_DATA_LOADING" }]);
+		expect(asyncValue(loading.models.data)).toBeUndefined();
+	});
+
+	test("success stores the whole snapshot, config included", () => {
+		const config = findPreset(DEFAULT_PRESET) ?? null;
+		const state = run([
+			{
+				type: "MODELS_DATA_SUCCESS",
+				snapshot: snapshot({
+					status: status({ state: "on", preset: DEFAULT_PRESET }),
+					config,
+				}),
+			},
+		]);
+		const value = asyncValue(state.models.data);
+		expect(value?.status.state).toBe("on");
+		expect(value?.config?.preset).toBe(DEFAULT_PRESET);
+	});
+
+	test("an error replaces the data rather than hiding behind stale rows", () => {
+		const state = run([
+			{ type: "MODELS_DATA_SUCCESS", snapshot: snapshot() },
+			{ type: "MODELS_DATA_ERROR", error: new Error("unreadable") },
+		]);
+		expect(state.models.data.status).toBe("error");
+		expect(asyncValue(state.models.data)).toBeUndefined();
+	});
+});
+
+describe("models status line", () => {
+	test("survives the screen unmounting, because it lives in app state", () => {
+		// `Router` swaps the component type on a tab change, so a message held in
+		// the screen's own useState is destroyed by 0 → 1 → 0 — and the message is
+		// the only record of what the last apply did.
+		const messaged = run([
+			{
+				type: "MODELS_STATUS_SET",
+				status: { text: "Routed opus-lead", tone: "success" },
+			},
+		]);
+		expect(run(roundTrip, messaged).models.status?.text).toBe(
+			"Routed opus-lead",
+		);
+	});
+
+	test("is replaced by the next message, not appended to", () => {
+		const state = run([
+			{ type: "MODELS_STATUS_SET", status: { text: "one", tone: "success" } },
+			{ type: "MODELS_STATUS_SET", status: { text: "two", tone: "error" } },
+		]);
+		expect(state.models.status).toEqual({ text: "two", tone: "error" });
+	});
+
+	test("clearing removes it", () => {
+		const state = run([
+			{ type: "MODELS_STATUS_SET", status: { text: "one", tone: "success" } },
+			{ type: "MODELS_STATUS_CLEAR" },
+		]);
+		expect(state.models.status).toBeNull();
+	});
+});
+
+describe("apply-in-flight state", () => {
+	test("survives the screen unmounting", () => {
+		// An apply rewrites the profile, re-materializes it and registers a hook.
+		// Held locally, the flag died on a tab switch and a returning user could
+		// launch a second write on top of the first.
+		const applying = run([{ type: "MODELS_APPLY_START" }]);
+		expect(applying.models.isApplying).toBe(true);
+		expect(run(roundTrip, applying).models.isApplying).toBe(true);
+	});
+
+	test("clears when the write finishes", () => {
+		expect(
+			run([{ type: "MODELS_APPLY_START" }, { type: "MODELS_APPLY_END" }]).models
+				.isApplying,
+		).toBe(false);
+	});
+});
+
+describe("the mate slots' availability", () => {
+	test("survives the screen unmounting, so the lookup happens once a session", () => {
+		// Unlike the two file reads this screen does on mount, this answer costs a
+		// marketplace resolution with network timeouts behind it. Held locally it would die
+		// on every tab switch and be paid for again on every return — for something that
+		// cannot change while the TUI is open.
+		const available = run([
+			{ type: "MODELS_MATES_AVAILABLE", available: true },
+		]);
+		expect(available.models.matesAvailable).toBe(true);
+		expect(run(roundTrip, available).models.matesAvailable).toBe(true);
+	});
+
+	test("a false answer is recorded, not treated as no answer", () => {
+		// "Not installed" and "never asked" render the same, and that is deliberate — but
+		// the reducer still has to hold the difference, or a later dispatch could not undo it.
+		const state = run([
+			{ type: "MODELS_MATES_AVAILABLE", available: true },
+			{ type: "MODELS_MATES_AVAILABLE", available: false },
+		]);
+		expect(state.models.matesAvailable).toBe(false);
+	});
+
+	test("it touches no other part of the models state", () => {
+		const before = run([
+			{ type: "MODELS_SELECT", index: 2 },
+			{ type: "MODELS_DATA_SUCCESS", snapshot: snapshot() },
+		]);
+		const after = run(
+			[{ type: "MODELS_MATES_AVAILABLE", available: true }],
+			before,
+		);
+		expect(after.models.selectedIndex).toBe(2);
+		expect(after.models.data).toBe(before.models.data);
+		expect(after.styles).toBe(before.styles);
+	});
+});
+
+describe("selection state", () => {
+	test("select records the index verbatim", () => {
+		expect(
+			run([{ type: "MODELS_SELECT", index: 3 }]).models.selectedIndex,
+		).toBe(3);
+	});
+
+	test("models actions touch no other screen's state", () => {
+		// One shared reducer, so a mistyped spread is a real hazard: `...state`
+		// rather than `...state.models` would wipe every other screen.
+		const before = initialState;
+		const after = run([
+			{ type: "MODELS_SELECT", index: 2 },
+			{ type: "MODELS_APPLY_START" },
+			{ type: "MODELS_SEARCH_APPEND", char: "x" },
+		]);
+		expect(after.styles).toBe(before.styles);
+		expect(after.plugins).toBe(before.plugins);
+		expect(after.skills).toBe(before.skills);
+	});
+});
+
+// ─── Keybindings ──────────────────────────────────────────────────────────────
+
+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 === "/"');
+		// 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()");
+	});
+
+	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("no screen still treats 0 as a non-navigation key", async () => {
+		// The Styles screen shipped `/^[1-9]$/` before Models existed on key 0.
+		const styles = await fs.readFile(
+			join(import.meta.dir, "..", "ui", "screens", "StylesScreen.tsx"),
+			"utf8",
+		);
+		expect(styles).not.toContain("/^[1-9]$/");
+	});
+
+	test("screen state is held in the reducer, never in useState", async () => {
+		// The rule the two "survives unmounting" tests above enforce at runtime,
+		// pinned at the source so a new piece of state cannot quietly opt out.
+		//
+		// Comments are stripped first, the way hook-import-policy.test.ts does it. The rule
+		// is about CODE, and this screen documents why each piece of its state lives in the
+		// reducer — naming the hook it is deliberately not using is the clearest way to say
+		// that, and a guard reading the prose would forbid the explanation along with the
+		// thing explained.
+		const src = stripComments(await fs.readFile(SCREEN, "utf8"));
+		expect(src).not.toContain("useState");
+		// Negative control: stripping must not have eaten the code being guarded. A guard
+		// over an empty string passes forever.
+		expect(src).toContain("useEffect");
+		expect(src).toContain("useCallback");
+	});
+});

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

@@ -0,0 +1,86 @@
+/**
+ * An orphaned plugin that merely changed marketplace is not deprecated.
+ *
+ * Splitting `magus` into `magus` + `magus-marketing` left `video-editing@magus`
+ * and `nanobanana@magus` installed under a namespace that no longer lists them. They rendered as bare
+ * "deprecated", whose only action is deletion — which drops a plugin that is
+ * still published, just under a different id.
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { LocalMarketplace } from "../services/local-marketplace.js";
+
+/**
+ * Mirrors `findPluginInOtherMarketplace` in plugin-manager.ts, which is module
+ * -private. Kept in lockstep with it; the behaviour, not the binding, is what
+ * these tests pin.
+ */
+function findPluginInOtherMarketplace(
+	pluginName: string,
+	currentMarketplace: string,
+	localMarketplaces: Map<string, LocalMarketplace>,
+): string | undefined {
+	for (const [name, mp] of localMarketplaces) {
+		if (name === currentMarketplace) continue;
+		if (mp.plugins.some((p) => p.name === pluginName)) return name;
+	}
+	return undefined;
+}
+
+const mp = (name: string, plugins: string[]): [string, LocalMarketplace] => [
+	name,
+	{
+		name,
+		description: "",
+		plugins: plugins.map((p) => ({
+			name: p,
+			version: "1.0.0",
+			description: "",
+		})),
+	},
+];
+
+describe("moved-marketplace detection", () => {
+	test("finds a plugin that moved to a sibling marketplace", () => {
+		const marketplaces = new Map([
+			mp("magus", ["dev", "terminal"]),
+			mp("magus-marketing", ["image-generate", "video-editing"]),
+		]);
+
+		expect(
+			findPluginInOtherMarketplace("video-editing", "magus", marketplaces),
+		).toBe("magus-marketing");
+	});
+
+	test("a genuinely retired plugin reports no destination", () => {
+		// `conductor` was removed at magus v8.0.0 and republished nowhere.
+		const marketplaces = new Map([
+			mp("magus", ["dev"]),
+			mp("magus-marketing", ["video-editing"]),
+		]);
+
+		expect(
+			findPluginInOtherMarketplace("conductor", "magus", marketplaces),
+		).toBeUndefined();
+	});
+
+	test("does not propose the marketplace it is already installed from", () => {
+		const marketplaces = new Map([mp("magus", ["dev"])]);
+		expect(findPluginInOtherMarketplace("dev", "magus", marketplaces)).toBe(
+			undefined,
+		);
+	});
+
+	test("a renamed plugin is not matched — the name is the identity", () => {
+		// nanobanana became image-generate. Names differ, so this correctly
+		// reports no destination rather than guessing at a rename.
+		const marketplaces = new Map([
+			mp("magus", ["dev"]),
+			mp("magus-marketing", ["image-generate"]),
+		]);
+
+		expect(
+			findPluginInOtherMarketplace("nanobanana", "magus", marketplaces),
+		).toBeUndefined();
+	});
+});

package/src/__tests__/open-file.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "bun:test";
+import { openInDefaultApp, openerFor } from "../utils/open-file.js";
+
+describe("openerFor", () => {
+	test("uses the macOS opener on darwin", () => {
+		expect(openerFor("darwin")).toEqual({ command: "open", args: [] });
+	});
+
+	test("uses xdg-open on linux", () => {
+		// magus ships a linux-x64 binary, and the pre-existing `open "${url}"`
+		// call elsewhere in the UI silently does nothing there.
+		expect(openerFor("linux")).toEqual({ command: "xdg-open", args: [] });
+	});
+
+	test("passes an empty window title to cmd start on windows", () => {
+		// `start` treats its first quoted argument as the window title, so
+		// without the empty string a quoted path is consumed as one.
+		expect(openerFor("win32")).toEqual({
+			command: "cmd",
+			args: ["/c", "start", ""],
+		});
+	});
+
+	test("falls back to xdg-open on anything else", () => {
+		expect(openerFor("freebsd").command).toBe("xdg-open");
+	});
+});
+
+describe("openInDefaultApp", () => {
+	const missingOpener = {
+		command: "magus-test-opener-that-cannot-exist",
+		args: [],
+	};
+
+	test("reports a missing opener rather than failing silently", async () => {
+		// An injected command that cannot exist, NOT a real platform's opener.
+		// The first version assumed `xdg-open` was absent — true on a Mac dev
+		// box, false on the Ubuntu CI runner, where it both failed the
+		// assertion and spawned a real opener on the build machine.
+		await expect(
+			openInDefaultApp("/tmp/whatever.md", "linux", missingOpener),
+		).rejects.toThrow(/not on PATH/);
+	});
+
+	test("settles promptly instead of hanging", async () => {
+		// The promise must settle when the child is spawned, not when the viewer
+		// is closed — waiting for exit would freeze the TUI for as long as the
+		// user's editor stayed open. Asserted on the error path so the suite
+		// never launches a real application on the developer's desktop.
+		const settled = await Promise.race([
+			openInDefaultApp("/tmp/whatever.md", "linux", missingOpener).then(
+				() => "resolved",
+				() => "rejected",
+			),
+			new Promise((resolve) => setTimeout(() => resolve("timeout"), 2000)),
+		]);
+		expect(settled).not.toBe("timeout");
+	});
+});

package/src/__tests__/owned-marketplaces.test.ts

@@ -0,0 +1,93 @@
+/**
+ * Change B: our own marketplaces (magus, magus-marketing) are always listed in
+ * the plugins TUI — even when unregistered — and sorted to the top.
+ *
+ * `magus-marketing` is deliberately NOT `featured`, so before this change it was
+ * invisible until manually registered. The `owned` flag both (a) qualifies it
+ * for the plugin-manager "always include" gate and (b) sorts it first.
+ */
+import { describe, expect, it } from "bun:test";
+import {
+	defaultMarketplaces,
+	getAllMarketplaces,
+} from "../data/marketplaces.js";
+import type { LocalMarketplace } from "../services/local-marketplace.js";
+import type { Marketplace } from "../types/index.js";
+import { buildPluginBrowserItems } from "../ui/adapters/pluginsAdapter.js";
+
+describe("owned marketplaces", () => {
+	it("marks magus and magus-marketing as owned, and leaves others untouched", () => {
+		const magus = defaultMarketplaces.find((m) => m.name === "magus");
+		const marketing = defaultMarketplaces.find(
+			(m) => m.name === "magus-marketing",
+		);
+		expect(magus?.owned).toBe(true);
+		expect(marketing?.owned).toBe(true);
+		expect(
+			defaultMarketplaces.find((m) => m.name === "claude-plugins-official")
+				?.owned,
+		).toBeUndefined();
+	});
+
+	it("qualifies magus-marketing for the always-show gate without being featured", () => {
+		const marketing = defaultMarketplaces.find(
+			(m) => m.name === "magus-marketing",
+		);
+		expect(marketing).toBeDefined();
+		// The plugin-manager gate: configured || official || featured || owned.
+		const alwaysShown = !!(
+			marketing?.official ||
+			marketing?.featured ||
+			marketing?.owned
+		);
+		expect(alwaysShown).toBe(true);
+		expect(marketing?.featured).toBeUndefined(); // and NOT via featured
+	});
+
+	it("sorts owned first and deprecated last, regardless of input order", () => {
+		const mk = (name: string, extra: Partial<Marketplace>): Marketplace => ({
+			name,
+			displayName: name,
+			source: { source: "github", repo: `x/${name}` },
+			description: "",
+			...extra,
+		});
+		// Deliberately "wrong" order: official, deprecated, owned.
+		const marketplaces: Marketplace[] = [
+			mk("official-one", { official: true }),
+			mk("claude-code-plugins", { deprecated: true }),
+			mk("mine", { owned: true }),
+		];
+
+		const items = buildPluginBrowserItems({
+			marketplaces,
+			plugins: [],
+			collapsedMarketplaces: new Set(),
+		});
+
+		const order: string[] = [];
+		for (const i of items)
+			if (i.kind === "category") order.push(i.marketplace.name);
+
+		expect(order[0]).toBe("mine"); // owned first
+		expect(order[order.length - 1]).toBe("claude-code-plugins"); // deprecated last
+	});
+
+	it("preserves owned when getAllMarketplaces rebuilds a locally-cached marketplace", () => {
+		// The local-cache path reconstructs the Marketplace object; owned must
+		// survive so already-cloned magus still sorts first / always shows.
+		const local = new Map<string, LocalMarketplace>([
+			[
+				"magus",
+				{
+					name: "Magus",
+					description: "",
+					gitRepo: "MadAppGang/magus",
+					plugins: [],
+				},
+			],
+		]);
+		const magus = getAllMarketplaces(local).find((m) => m.name === "magus");
+		expect(magus?.owned).toBe(true);
+	});
+});

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

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "bun:test";
+import path from "node:path";
+import {
+	checkoutDirName,
+	checkoutPath,
+	ensureCheckout,
+} from "../services/plugin-checkout.js";
+
+/**
+ * A checkout is a read-only shallow clone magus owns, used so that browsing
+ * what a plugin contains never requires installing it and never spends the
+ * GitHub API budget (60 requests an hour, unauthenticated, shared across every
+ * repo on screen).
+ */
+describe("checkoutDirName", () => {
+	it("flattens owner/repo into one filesystem-safe segment", () => {
+		expect(checkoutDirName("addyosmani/agent-skills")).toBe(
+			"addyosmani__agent-skills",
+		);
+		expect(checkoutDirName("MadAppGang/magus")).toBe("MadAppGang__magus");
+	});
+
+	it("never yields a name containing a path separator", () => {
+		for (const repo of [
+			"a/b",
+			"../../etc/passwd",
+			"owner/repo.git",
+			"weird name/with spaces",
+		]) {
+			const name = checkoutDirName(repo);
+			expect(name).not.toContain("/");
+			expect(name).not.toContain("\\");
+			// A traversal attempt must not survive as one: `..` collapses into the
+			// same separator run as everything else, so the result cannot escape
+			// the checkout root.
+			expect(path.basename(name)).toBe(name);
+		}
+	});
+
+	it("keeps dots that are part of a real repo name", () => {
+		expect(checkoutDirName("owner/repo.js")).toBe("owner__repo.js");
+	});
+});
+
+describe("checkoutPath", () => {
+	it("puts every checkout under one root, outside Claude Code's own dirs", () => {
+		const a = checkoutPath("owner/one");
+		const b = checkoutPath("owner/two");
+
+		expect(path.dirname(a)).toBe(path.dirname(b));
+		expect(path.dirname(a)).toContain("magus-checkouts");
+		// Claude Code owns `plugins/`; a checkout must not look like installed
+		// state, or a reader could mistake it for something Claude Code loads.
+		expect(a).not.toContain(`${path.sep}plugins${path.sep}`);
+	});
+});
+
+describe("ensureCheckout", () => {
+	it("refuses to clone from a test run", async () => {
+		// Not a precaution. A test that only meant to exercise the tree-API path
+		// shallow-cloned a real GitHub repo, because stubbing `globalThis.fetch`
+		// does not stop `git`.
+		expect(process.env.NODE_ENV).toBe("test");
+		expect(await ensureCheckout("blader/humanizer")).toBeNull();
+	});
+});