magus-cli 7.5.3 → 7.5.4

package/src/__tests__/installed-version-scope.test.tsx

@@ -0,0 +1,425 @@
+/**
+ * A plugin's installed version comes only from scopes where it is INSTALLED —
+ * and "does this project hold a row?" reads only this project's own row.
+ *
+ * `getAvailablePlugins` took `installedVersion` from the project lookup whenever
+ * the plugin was installed anywhere, and that lookup resolves a row inherited
+ * from another checkout, installed here or not. So with the plugin installed at
+ * user scope at 0.9.0 beside an inherited project row at 0.8.1, the panel said
+ * "(v0.8.1 installed)" next to a status of current at 0.9.0; with its user files
+ * missing, the header said "● Installed" above a status saying files missing.
+ *
+ * The same kind of fallback sat under the apply engine's row check: the
+ * read-back fell back to the user row, so a plugin installed only at user scope,
+ * and turned on in project settings, ran `update --scope project` from a folder
+ * holding no project row.
+ *
+ * The pure halves — which row each question reads — are in
+ * scope-row-lookup.test.ts.
+ *
+ * The real `getAvailablePlugins` and the real registry read-back run in a CHILD
+ * process that starts with HOME, CLAUDE_CONFIG_DIR and XDG_* inside a temp dir:
+ * Bun's `os.homedir()` ignores a HOME changed at runtime, and the registry path
+ * is built from it. The child's `fetch` serves one catalog and 404s the rest, and
+ * its PATH holds only `git`, so no network and no `claude` CLI is reachable.
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { spawnSync } from "node:child_process";
+import {
+	mkdir,
+	mkdtemp,
+	readFile,
+	realpath,
+	rm,
+	symlink,
+	writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { testRender } from "@opentui/react/test-utils";
+import { type ReactNode, act } from "react";
+import {
+	type PluginInfo,
+	hasMissingFiles,
+} from "../services/plugin-manager.js";
+import {
+	type PluginUpdateItem,
+	classifyPluginRows,
+} from "../services/update-plan.js";
+import type { InstalledPluginEntry, Marketplace } from "../types/index.js";
+import {
+	type PluginPluginItem,
+	buildPluginBrowserItems,
+} from "../ui/adapters/pluginsAdapter.js";
+import { renderPluginDetail } from "../ui/renderers/pluginRenderers.js";
+import { pluginRowText } from "../ui/renderers/pluginRowText.js";
+
+const ID = "probe@magus";
+const SRC = join(import.meta.dir, "..");
+
+const MAGUS: Marketplace = {
+	name: "magus",
+	displayName: "Magus",
+	source: { source: "github", repo: "MadAppGang/magus" },
+	description: "",
+	owned: true,
+} as Marketplace;
+
+// ── the child ────────────────────────────────────────────────────────────────
+
+/**
+ * Loads the plugin list with the real `getAvailablePlugins`, and — when the job
+ * asks — plans it and applies it with the real engine and the real registry
+ * read-back, the Claude CLI's three commands recorded instead of run.
+ */
+const CHILD = `
+const job = JSON.parse(await Bun.file(process.argv[2]).text());
+const os = await import("node:os");
+if (os.homedir() !== job.home) {
+	await Bun.write(job.out, JSON.stringify({ guard: false }));
+	process.exit(0);
+}
+globalThis.fetch = async (input) => {
+	const url = String(input instanceof Request ? input.url : input);
+	if (url === job.catalogUrl) {
+		return new Response(JSON.stringify(job.catalog), {
+			status: 200,
+			headers: { "content-type": "application/json" },
+		});
+	}
+	return new Response("", { status: 404, statusText: "Not Found" });
+};
+console.log = () => {};
+const pm = await import(job.modules.pluginManager);
+const plugins = await pm.getAvailablePlugins(job.project);
+let apply = null;
+if (job.apply) {
+	const plan = await import(job.modules.updatePlan);
+	const engine = await import(job.modules.updateEngine);
+	const item = plan.planPluginUpdates({}, plugins).find((i) => i.pluginId === job.id);
+	const calls = [];
+	const record = (command) => async (_id, scope) => { calls.push([command, scope]); };
+	await engine.applyPlugins([item], job.project, {
+		...engine.REAL_PLUGIN_DEPS,
+		install: record("install"),
+		update: record("update"),
+		repair: record("repair"),
+		saveInstalled: async () => {},
+		repairStaleLoad: async () => { throw new Error("no stale-load repair expected"); },
+		loadedVersion: undefined,
+		registryRows: undefined,
+	});
+	apply = { action: item.action, scopes: item.scopes, calls };
+}
+await Bun.write(job.out, JSON.stringify({ guard: true, plugins, apply }));
+process.exit(0);
+`;
+
+interface World {
+	base: string;
+	home: string;
+	/** A git repository: its root's registry rows are inherited by `project`. */
+	repo: string;
+	/** `<repo>/sub` — the directory magus runs in. */
+	project: string;
+	env: Record<string, string>;
+}
+
+interface Seed {
+	/** `~/.claude/settings.json` enabledPlugins. */
+	userEnabled?: Record<string, boolean>;
+	/** `<project>/.claude/settings.json` enabledPlugins. */
+	projectEnabled?: Record<string, boolean>;
+	/** The plugin's registry rows; `onDisk` creates the row's cache directory. */
+	rows: Array<{
+		scope: "user" | "project" | "local";
+		projectPath?: string;
+		version: string;
+		onDisk: boolean;
+	}>;
+	/** The version the magus catalog publishes for the plugin. */
+	catalogVersion: string;
+	/** Plan and apply the plugin, recording the Claude CLI calls. */
+	apply?: boolean;
+}
+
+interface ChildResult {
+	plugins: PluginInfo[];
+	apply: {
+		action: string;
+		scopes: string[];
+		calls: Array<[string, string]>;
+	} | null;
+}
+
+let root: string;
+let binDir: string;
+let childScript: string;
+
+beforeAll(async () => {
+	root = await realpath(await mkdtemp(join(tmpdir(), "installed-version-")));
+	binDir = join(root, "bin");
+	await mkdir(binDir);
+	const git = Bun.which("git");
+	if (!git) throw new Error("git is required: inherited rows are found by it");
+	await symlink(git, join(binDir, "git"));
+	childScript = join(root, "child.ts");
+	await writeFile(childScript, CHILD);
+});
+
+afterAll(async () => {
+	await rm(root, { recursive: true, force: true });
+});
+
+let worlds = 0;
+async function world(): Promise<World> {
+	const base = join(root, `world-${++worlds}`);
+	const home = join(base, "home");
+	const xdg = join(base, "xdg");
+	const repo = join(base, "repo");
+	const project = join(repo, "sub");
+	await mkdir(join(home, ".claude", "plugins"), { recursive: true });
+	for (const kind of ["config", "cache", "data", "state"]) {
+		await mkdir(join(xdg, kind), { recursive: true });
+	}
+	await mkdir(join(project, ".claude"), { recursive: true });
+	const env = {
+		PATH: `${binDir}:/usr/bin:/bin`,
+		HOME: home,
+		CLAUDE_CONFIG_DIR: join(home, ".claude"),
+		XDG_CONFIG_HOME: join(xdg, "config"),
+		XDG_CACHE_HOME: join(xdg, "cache"),
+		XDG_DATA_HOME: join(xdg, "data"),
+		XDG_STATE_HOME: join(xdg, "state"),
+		TMPDIR: tmpdir(),
+		NO_COLOR: "1",
+		TERM: "dumb",
+		GIT_CONFIG_NOSYSTEM: "1",
+		GIT_CONFIG_GLOBAL: "/dev/null",
+	};
+	const init = spawnSync("git", ["init", "-q", repo], { env });
+	if (init.status !== 0) throw new Error(`git init failed: ${init.stderr}`);
+	return { base, home, repo, project, env };
+}
+
+async function writeJson(file: string, value: unknown): Promise<void> {
+	await mkdir(dirname(file), { recursive: true });
+	await writeFile(file, JSON.stringify(value, null, 2));
+}
+
+async function run(w: World, seed: Seed): Promise<ChildResult> {
+	const claude = join(w.home, ".claude");
+	await writeJson(join(claude, "settings.json"), {
+		enabledPlugins: seed.userEnabled ?? {},
+	});
+	await writeJson(join(w.project, ".claude", "settings.json"), {
+		enabledPlugins: seed.projectEnabled ?? {},
+	});
+	const rows: InstalledPluginEntry[] = [];
+	for (const row of seed.rows) {
+		const installPath = join(
+			claude,
+			"plugins",
+			"cache",
+			"magus",
+			"probe",
+			row.version,
+		);
+		if (row.onDisk) await mkdir(installPath, { recursive: true });
+		rows.push({
+			scope: row.scope,
+			...(row.projectPath ? { projectPath: row.projectPath } : {}),
+			installPath,
+			version: row.version,
+			installedAt: "2026-09-01T00:00:00.000Z",
+			lastUpdated: "2026-09-01T00:00:00.000Z",
+		});
+	}
+	await writeJson(join(claude, "plugins", "installed_plugins.json"), {
+		version: 2,
+		plugins: { [ID]: rows },
+	});
+
+	const out = join(w.base, "result.json");
+	const jobFile = join(w.base, "job.json");
+	await writeJson(jobFile, {
+		home: w.home,
+		project: w.project,
+		id: ID,
+		out,
+		apply: seed.apply ?? false,
+		catalogUrl:
+			"https://raw.githubusercontent.com/MadAppGang/magus/main/.claude-plugin/marketplace.json",
+		catalog: {
+			name: "magus",
+			plugins: [
+				{
+					name: "probe",
+					version: seed.catalogVersion,
+					description: "Probe plugin.",
+					source: "./plugins/probe",
+				},
+			],
+		},
+		modules: {
+			pluginManager: join(SRC, "services", "plugin-manager.ts"),
+			updatePlan: join(SRC, "services", "update-plan.ts"),
+			updateEngine: join(SRC, "services", "update-engine.ts"),
+		},
+	});
+
+	const proc = spawnSync(
+		process.execPath,
+		["--no-env-file", childScript, jobFile],
+		{ cwd: w.project, env: w.env, timeout: 60_000 },
+	);
+	let raw: string;
+	try {
+		raw = await readFile(out, "utf8");
+	} catch {
+		throw new Error(
+			`child produced no result (exit ${proc.status}):\n${proc.stderr}`,
+		);
+	}
+	const result = JSON.parse(raw) as ChildResult & { guard: boolean };
+	if (!result.guard) throw new Error("the child's home was not redirected");
+	return result;
+}
+
+// ── the surfaces, rendered the way the Plugins screen renders them ───────────
+
+async function detailText(item: PluginPluginItem): Promise<string> {
+	const { captureCharFrame, renderOnce, renderer } = await testRender(
+		<box flexDirection="column">
+			{renderPluginDetail(item, new Set<string>()) as ReactNode}
+		</box>,
+		{ width: 120, height: 80 },
+	);
+	await act(async () => {
+		await renderOnce();
+		await renderOnce();
+	});
+	const frame = captureCharFrame();
+	await act(async () => renderer.destroy());
+	return frame;
+}
+
+interface Surfaces {
+	plugin: PluginInfo;
+	status: PluginUpdateItem;
+	row: string;
+	detail: string;
+}
+
+/** The screen's own path: classify, build the browser items, render. */
+async function surfaces(plugins: PluginInfo[]): Promise<Surfaces> {
+	const items = buildPluginBrowserItems({
+		marketplaces: [MAGUS],
+		plugins,
+		collapsedMarketplaces: new Set(),
+		statuses: classifyPluginRows(plugins, {}),
+	});
+	const item = items.find(
+		(i): i is PluginPluginItem => i.kind === "plugin" && i.plugin.id === ID,
+	);
+	if (!item?.status) throw new Error(`no classified row for ${ID}`);
+	return {
+		plugin: item.plugin,
+		status: item.status,
+		row: pluginRowText(item).text,
+		detail: await detailText(item),
+	};
+}
+
+// ── Finding 2 ────────────────────────────────────────────────────────────────
+
+describe("installedVersion comes only from installed scopes", () => {
+	test("case B: installed at user v0.9.0 beside an inherited project row v0.8.1 — every surface says 0.9.0", async () => {
+		const w = await world();
+		const { plugins } = await run(w, {
+			userEnabled: { [ID]: true },
+			rows: [
+				{ scope: "user", version: "0.9.0", onDisk: true },
+				{
+					scope: "project",
+					projectPath: w.repo,
+					version: "0.8.1",
+					onDisk: false,
+				},
+			],
+			catalogVersion: "0.9.0",
+		});
+		const s = await surfaces(plugins);
+
+		// The reported shape: user installed at 0.9.0, the inherited row not on here.
+		expect(s.plugin.userScope).toEqual({ installed: true, version: "0.9.0" });
+		expect(s.plugin.projectScope).toEqual({
+			installed: false,
+			version: "0.8.1",
+		});
+
+		expect(s.status.action).toBe("current");
+		expect(s.status.installed).toBe("0.9.0");
+		expect(s.plugin.installedVersion).toBe("0.9.0");
+		expect(s.plugin.installedVersion ?? null).toBe(s.status.installed);
+		expect(hasMissingFiles(s.plugin)).toBe(false);
+		expect(s.row).toBe(" v0.9.0");
+		expect(s.detail).toContain("● Installed");
+		expect(s.detail).not.toContain("files missing");
+		// Not "(v0.8.1 installed)", and not anywhere else either.
+		expect(s.detail).not.toContain("0.8.1");
+	});
+
+	test("case A: files missing at user scope beside the same inherited row — every surface says files missing", async () => {
+		const w = await world();
+		const { plugins } = await run(w, {
+			userEnabled: { [ID]: true },
+			rows: [
+				{
+					scope: "project",
+					projectPath: w.repo,
+					version: "0.8.1",
+					onDisk: false,
+				},
+			],
+			catalogVersion: "0.9.0",
+		});
+		const s = await surfaces(plugins);
+
+		expect(s.plugin.userScope).toEqual({ installed: true });
+		expect(s.plugin.projectScope).toEqual({
+			installed: false,
+			version: "0.8.1",
+		});
+
+		expect(s.status.action).toBe("install");
+		expect(s.status.reason).toBe("files-missing");
+		expect(s.status.installed).toBeNull();
+		expect(s.plugin.installedVersion).toBeUndefined();
+		expect(hasMissingFiles(s.plugin)).toBe(true);
+		// No version beside "files missing" — the row has none to show.
+		expect(s.row).toBe(" files missing");
+		expect(s.detail).toContain("● Installed — files missing");
+		expect(s.detail).not.toContain("0.8.1");
+	});
+});
+
+// ── Finding 3 ────────────────────────────────────────────────────────────────
+
+describe("no row for this project → install, not update", () => {
+	test("a user row only, turned on in project settings: `install --scope project`, never `update`", async () => {
+		const w = await world();
+		const { apply } = await run(w, {
+			projectEnabled: { [ID]: true },
+			rows: [{ scope: "user", version: "1.0.0", onDisk: true }],
+			catalogVersion: "2.0.0",
+			apply: true,
+		});
+
+		// Planned as project scope behind — the project resolves to the user row.
+		expect(apply?.action).toBe("update");
+		expect(apply?.scopes).toEqual(["project"]);
+		expect(apply?.calls).toEqual([["install", "project"]]);
+	});
+});

package/src/__tests__/mate-availability.test.ts

@@ -23,7 +23,6 @@ const plugin = (overrides: Partial<PluginInfo> = {}): PluginInfo => ({
 	description: "",
 	marketplace: "magus",
 	marketplaceDisplay: "Magus",
-	enabled: true,
 	...overrides,
 });
 
@@ -43,9 +42,9 @@ describe("areMatesAvailable", () => {
 	test("true when it is installed at ANY scope", async () => {
 		// Any scope, because a mate is served by whatever Claude Code has loaded when the
 		// agent spawns — the union of the three. A user-scope install serves a project that
-		// enables nothing of its own.
+		// installs nothing of its own.
 		for (const scope of ["userScope", "projectScope", "localScope"] as const) {
-			const one = plugin({ [scope]: { enabled: true, version: "1.0.0" } });
+			const one = plugin({ [scope]: { installed: true, version: "1.0.0" } });
 			expect({
 				scope,
 				available: await areMatesAvailable(undefined, lister([one])),
@@ -54,27 +53,26 @@ describe("areMatesAvailable", () => {
 	});
 
 	/**
-	 * The enabled-but-not-installed state is NOT installed.
+	 * Files missing does not serve a mate.
 	 *
-	 * `enabledPlugins` is a flag only magus and the user maintain; the version comes from
-	 * the registry, which is what Claude Code actually loaded. Flag set with no version is the
-	 * broken state the plugin list already renders as "not installed" — and a mate row drawn
-	 * on the strength of it would promise routing through a plugin that never loaded.
+	 * Installed with no version is the broken state the plugin list renders as "files
+	 * missing": Claude Code wants to load the plugin and has nothing to load — and a mate row
+	 * drawn on the strength of it would promise routing through a plugin that never loaded.
 	 */
-	test("false when it is enabled but never actually installed", async () => {
-		const flagged = plugin({ userScope: { enabled: true } });
+	test("false when it is installed but its files are missing", async () => {
+		const flagged = plugin({ userScope: { installed: true } });
 		expect(await areMatesAvailable(undefined, lister([flagged]))).toBe(false);
 	});
 
-	test("false when it is installed but disabled", async () => {
+	test("false when only a registry row exists and it is not installed", async () => {
 		const off = plugin({
-			userScope: { enabled: false, version: "1.0.0" },
+			userScope: { installed: false, version: "1.0.0" },
 		});
 		expect(await areMatesAvailable(undefined, lister([off]))).toBe(false);
 	});
 
 	test('a version of "0.0.0" still counts — that is how some plugins record themselves', async () => {
-		const zero = plugin({ userScope: { enabled: true, version: "0.0.0" } });
+		const zero = plugin({ userScope: { installed: true, version: "0.0.0" } });
 		expect(await areMatesAvailable(undefined, lister([zero]))).toBe(true);
 	});
 

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

@@ -200,7 +200,6 @@ function makePlugin(overrides: Partial<PluginInfo> = {}): PluginInfo {
 		description: "Matt Pocock's agent skills",
 		marketplace: "mattpocock",
 		marketplaceDisplay: "Matt Pocock",
-		enabled: false,
 		source: "./",
 		...overrides,
 	};