magus-cli 7.11.1 → 7.11.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magus-cli",
-  "version": "7.11.1",
+  "version": "7.11.3",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",
@@ -65,8 +65,8 @@
     "typescript": "^5.6.3"
   },
   "optionalDependencies": {
-    "magus-cli-darwin-arm64": "7.11.1",
-    "magus-cli-darwin-x64": "7.11.1",
-    "magus-cli-linux-x64": "7.11.1"
+    "magus-cli-darwin-arm64": "7.11.3",
+    "magus-cli-darwin-x64": "7.11.3",
+    "magus-cli-linux-x64": "7.11.3"
   }
 }

package/src/__tests__/blind/requires-min-version/manifests.test.ts

@@ -40,8 +40,10 @@ describe("shipped plugin manifests under schema 2", () => {
 	}
 
 	// REQ-26: claudish gets a minVersion floor; no other requirement gets one. The floor
-	// moved from 10.7.0 to 11.1.0 with claudish plugin 2.5.0, which needs SlotRow.recent.
-	test("REQ-26 claudish's claudish requirement has minVersion 11.1.0", () => {
+	// moved from 10.7.0 to 11.1.0 with claudish plugin 2.5.0, which needs SlotRow.recent, and
+	// to 12.1.0 with claudish plugin 2.6.2, for resize_session, and to 12.3.0 with 2.8.1, whose
+	// resize goes down to 40 columns.
+	test("REQ-26 claudish's claudish requirement has minVersion 12.3.0", () => {
 		const claudish = declaring.find(({ name }) => name === "claudish");
 		if (!claudish) throw new Error("plugins/claudish declares no requires");
 		const result = parseRequires(claudish.json);
@@ -51,7 +53,7 @@ describe("shipped plugin manifests under schema 2", () => {
 			| (Record<string, unknown> & { name: string })
 			| undefined;
 		expect(req).toBeDefined();
-		expect(req?.minVersion).toBe("11.1.0");
+		expect(req?.minVersion).toBe("12.3.0");
 	});
 
 	test("REQ-26 no other shipped requirement declares a floor", () => {

package/src/__tests__/orphan-user-row-repair.test.ts

@@ -0,0 +1,102 @@
+// REGRESSION: MTL-221 orphan USER registry row blocks PROJECT install/repair; scope uninstall must drop from profile — Fixed in /dev:fix session dev-fix-20261022-magus-scope-7c3e
+
+/**
+ * An orphan USER registry row — a `user` row in installed_plugins.json for a
+ * plugin USER settings do not turn on — wins Claude Code's load resolution.
+ * The stale-load repair refused on it ("update it at USER scope") without
+ * asking whether USER actually installs the plugin, so every PROJECT install
+ * failed. The engine must remove the orphan through `claude plugin uninstall
+ * --scope user` and retry, and keep refusing when USER really installs it.
+ *
+ * Doubles only: nothing here reads or writes the real ~/.claude.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+import type { StaleLoadRepairResult } from "../services/claude-settings.js";
+import {
+	type PluginApplyDeps,
+	type PluginRemoveDeps,
+	installPluginInScope,
+} from "../services/update-engine.js";
+
+const PROJECT = "/tmp/mtl-221-project";
+const ID = "dev@magus";
+const OLD = "9.2.0";
+const NEW = "9.4.0";
+
+/** The refusal `repairStaleLoad` gives when the winning row is USER's. */
+function userRefusal(): StaleLoadRepairResult & { blockedBy: "user" } {
+	return {
+		pluginId: ID,
+		target: NEW,
+		rewritten: 0,
+		backup: null,
+		loaded: null,
+		ok: false,
+		error:
+			"Claude Code loads the USER install of it here — update it at USER scope",
+		blockedBy: "user",
+	};
+}
+
+function repaired(): StaleLoadRepairResult {
+	return {
+		pluginId: ID,
+		target: NEW,
+		rewritten: 0,
+		backup: null,
+		loaded: NEW,
+		ok: true,
+	};
+}
+
+function setup(userReallyInstalls: boolean) {
+	let repairCalls = 0;
+	const remove: PluginRemoveDeps = {
+		uninstall: mock(async () => {}),
+		isInstalled: mock(async (_id: string, scope: string) =>
+			scope === "user" ? userReallyInstalls : scope === "project",
+		),
+		dropFromProfile: mock(async () => true),
+		forgetVersion: mock(async () => {}),
+	};
+	const deps: PluginApplyDeps = {
+		install: mock(async () => {}),
+		update: mock(async () => {}),
+		repair: mock(async () => {}),
+		readInstalled: mock(async () => NEW),
+		saveInstalled: mock(async () => {}),
+		// The orphan USER row still wins until something removes it.
+		loadedVersion: mock(async () => OLD),
+		repairStaleLoad: mock(async () => {
+			repairCalls += 1;
+			return repairCalls === 1 ? userRefusal() : repaired();
+		}),
+		remove,
+	};
+	return { deps, remove, repairCalls: () => repairCalls };
+}
+
+describe("MTL-221: PROJECT install behind an orphan USER registry row", () => {
+	test("a. orphan USER row: uninstalled at USER once, repair retried, install succeeds", async () => {
+		const { deps, remove, repairCalls } = setup(false);
+
+		await expect(
+			installPluginInScope(ID, "project", PROJECT, deps),
+		).resolves.toBe(NEW);
+
+		expect(remove.uninstall).toHaveBeenCalledTimes(1);
+		expect(remove.uninstall).toHaveBeenCalledWith(ID, "user", PROJECT);
+		expect(repairCalls()).toBe(2);
+	});
+
+	test("b. real USER install: never uninstalled, the install still refuses naming USER", async () => {
+		const { deps, remove } = setup(true);
+
+		await expect(
+			installPluginInScope(ID, "project", PROJECT, deps),
+		).rejects.toThrow(/USER/);
+
+		expect(remove.uninstall).not.toHaveBeenCalled();
+	});
+});

package/src/__tests__/scope-uninstall-dependents.test.ts

@@ -0,0 +1,173 @@
+// REGRESSION: MTL-221 uninstalling a plugin a declared plugin depends on must refuse, not leave it declared — Fixed in /dev:fix session dev-fix-20261022-magus-scope-7c3e
+
+/**
+ * A profile's resolved closure re-adds every dependency of a plugin it
+ * declares (`resolveProfile` → `resolveDependencies` → `dependencies.derived`).
+ * `dev@magus` depends on `claudish@magus`, so dropping claudish from a profile
+ * that declares dev cannot take effect: claudish comes straight back.
+ *
+ * When an uninstall would need the profile to stop declaring the plugin
+ * (scope PROJECT, or no OTHER scope installs it) and a plugin the profile
+ * declares depends on it, `uninstallPluginInScope` refuses before doing
+ * anything, naming both plugins by name. A USER/LOCAL uninstall while PROJECT
+ * still installs it needs no profile change, so it is never refused.
+ *
+ * Doubles only: nothing here reads or writes the real ~/.claude.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+import * as resolver from "../services/resolver.js";
+import * as engine from "../services/update-engine.js";
+import type {
+	PluginApplyDeps,
+	PluginRemoveDeps,
+} from "../services/update-engine.js";
+import type { ProfileManifest } from "../types/index.js";
+
+const PROJECT = "/tmp/mtl-221-project";
+const ID = "claudish@magus";
+const PROFILE = "team";
+
+type Scope = "user" | "project" | "local";
+
+/**
+ * Remove deps over an in-memory install set, plus the assumed new optional
+ * `dependents` seam answering which declared plugins need `pluginId`.
+ */
+function setup(installedAt: Scope[], dependentIds: string[]) {
+	const installed = new Set<Scope>(installedAt);
+	const calls: string[] = [];
+	const dependents = mock(
+		async (
+			_pluginId: string,
+			_projectPath: string,
+			_profile: string | null | undefined,
+		) => dependentIds,
+	);
+	const remove = {
+		uninstall: mock(async (id: string, scope: Scope, path: string) => {
+			calls.push(`uninstall:${id}:${scope}:${path}`);
+			installed.delete(scope);
+		}),
+		isInstalled: mock(async (_id: string, scope: Scope) =>
+			installed.has(scope),
+		),
+		dropFromProfile: mock(async () => {
+			calls.push("dropFromProfile");
+			return true;
+		}),
+		forgetVersion: mock(async () => {
+			calls.push("forgetVersion");
+		}),
+		dependents,
+	} as PluginRemoveDeps & { dependents: typeof dependents };
+	const deps: PluginApplyDeps = {
+		install: mock(async () => {}),
+		update: mock(async () => {}),
+		repair: mock(async () => {}),
+		readInstalled: mock(async () => null),
+		saveInstalled: mock(async () => {}),
+		repairStaleLoad: mock(async () => {
+			throw new Error("repairStaleLoad must not run on an uninstall");
+		}),
+		remove,
+	};
+	return { deps, remove, calls };
+}
+
+const uninstallPluginInScope = engine.uninstallPluginInScope;
+
+describe("MTL-221: uninstalling a plugin a declared plugin depends on", () => {
+	test("f. PROJECT uninstall of a dependency of a declared plugin: refuses before doing anything", async () => {
+		const { deps, remove, calls } = setup(["project"], ["dev@magus"]);
+
+		let message: string | null = null;
+		try {
+			await uninstallPluginInScope(ID, "project", PROJECT, deps, PROFILE);
+		} catch (err) {
+			message = err instanceof Error ? err.message : String(err);
+		}
+
+		expect(message).not.toBeNull();
+		expect(message).toContain("dev needs claudish");
+		expect(message).toContain("uninstall dev first");
+		// Plugin names, not ids.
+		expect(message).not.toContain("@magus");
+		expect(remove.uninstall).not.toHaveBeenCalled();
+		expect(remove.forgetVersion).not.toHaveBeenCalled();
+		expect(remove.dropFromProfile).not.toHaveBeenCalled();
+		expect(calls).toEqual([]);
+	});
+
+	test("g. PROJECT uninstall with no declared dependent: uninstalls, then drops from the profile once", async () => {
+		const { deps, remove, calls } = setup(["project"], []);
+
+		await uninstallPluginInScope(ID, "project", PROJECT, deps, PROFILE);
+
+		expect(remove.uninstall).toHaveBeenCalledWith(ID, "project", PROJECT);
+		expect(remove.dropFromProfile).toHaveBeenCalledTimes(1);
+		expect(calls).toEqual([
+			`uninstall:${ID}:project:${PROJECT}`,
+			"forgetVersion",
+			"dropFromProfile",
+		]);
+	});
+
+	test("h. USER uninstall while PROJECT still installs it: not refused, profile untouched", async () => {
+		const { deps, remove } = setup(["user", "project"], ["dev@magus"]);
+
+		await uninstallPluginInScope(ID, "user", PROJECT, deps, PROFILE);
+
+		expect(remove.uninstall).toHaveBeenCalledWith(ID, "user", PROJECT);
+		expect(remove.dropFromProfile).not.toHaveBeenCalled();
+	});
+});
+
+/**
+ * Assumed signature, consistent with `resolveProfile` /
+ * `ResolveOptions.dependencyResolver` (a `PluginDependencyReader`):
+ *
+ *   profileDependentsOf(
+ *     manifest: ProfileManifest,
+ *     profileId: string,
+ *     pluginId: string,
+ *     dependencyResolver: PluginDependencyReader,
+ *   ): Promise<string[]>
+ *
+ * Answers the ids of plugins the profile declares that need `pluginId`.
+ */
+const profileDependentsOf = (resolver as Record<string, unknown>)
+	.profileDependentsOf as (
+	manifest: ProfileManifest,
+	profileId: string,
+	pluginId: string,
+	dependencyResolver: (
+		pluginId: string,
+		projectPath?: string,
+	) => Promise<string[] | null>,
+) => Promise<string[]>;
+
+describe("MTL-221: profileDependentsOf", () => {
+	test("i. names the declared plugin that depends on the given one", async () => {
+		const manifest: ProfileManifest = {
+			version: 2,
+			profiles: {
+				[PROFILE]: {
+					name: PROFILE,
+					plugins: { "dev@magus": "latest", "claudish@magus": "latest" },
+				},
+			},
+		};
+		const graph: Record<string, string[]> = {
+			"dev@magus": ["claudish@magus", "mnemex@magus"],
+			"claudish@magus": [],
+			"mnemex@magus": [],
+		};
+		const dependencyResolver = async (id: string) => graph[id] ?? [];
+
+		expect(typeof profileDependentsOf).toBe("function");
+		expect(
+			await profileDependentsOf(manifest, PROFILE, ID, dependencyResolver),
+		).toEqual(["dev@magus"]);
+	});
+});

package/src/__tests__/scope-uninstall-profile.test.ts

@@ -0,0 +1,103 @@
+// REGRESSION: MTL-221 orphan USER registry row blocks PROJECT install/repair; scope uninstall must drop from profile — Fixed in /dev:fix session dev-fix-20261022-magus-scope-7c3e
+
+/**
+ * The Plugins screen's scope uninstall never dropped the plugin from the
+ * active profile, so a profile-declared plugin came straight back as "not
+ * installed — profile declares it". `uninstallPluginInScope` is the one engine
+ * function both screen call sites will use: uninstall at the scope, read back,
+ * and drop from the profile when the scope was PROJECT or nothing installs the
+ * plugin any more — never while PROJECT still installs it.
+ *
+ * Doubles only: nothing here reads or writes the real ~/.claude.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+import * as engine from "../services/update-engine.js";
+import type {
+	PluginApplyDeps,
+	PluginRemoveDeps,
+} from "../services/update-engine.js";
+
+const PROJECT = "/tmp/mtl-221-project";
+const ID = "dev@magus";
+const PROFILE = "team";
+
+type Scope = "user" | "project" | "local";
+
+/**
+ * Remove deps over an in-memory install set: `uninstall` takes the scope out,
+ * `isInstalled` reads the set back.
+ */
+function setup(installedAt: Scope[]) {
+	const installed = new Set<Scope>(installedAt);
+	const calls: string[] = [];
+	const remove: PluginRemoveDeps = {
+		uninstall: mock(async (id: string, scope: Scope, path: string) => {
+			calls.push(`uninstall:${id}:${scope}:${path}`);
+			installed.delete(scope);
+		}),
+		isInstalled: mock(async (_id: string, scope: Scope) =>
+			installed.has(scope),
+		),
+		dropFromProfile: mock(async () => {
+			calls.push("dropFromProfile");
+			return true;
+		}),
+		forgetVersion: mock(async () => {}),
+	};
+	const deps: PluginApplyDeps = {
+		install: mock(async () => {}),
+		update: mock(async () => {}),
+		repair: mock(async () => {}),
+		readInstalled: mock(async () => null),
+		saveInstalled: mock(async () => {}),
+		repairStaleLoad: mock(async () => {
+			throw new Error("repairStaleLoad must not run on an uninstall");
+		}),
+		remove,
+	};
+	return { deps, remove, calls };
+}
+
+// Looked up off the namespace so the file loads before the export exists (RED).
+const uninstallPluginInScope = (engine as Record<string, unknown>)
+	.uninstallPluginInScope as (
+	pluginId: string,
+	scope: Scope,
+	projectPath: string,
+	deps?: PluginApplyDeps,
+	profile?: string | null,
+) => Promise<unknown>;
+
+describe("MTL-221: uninstallPluginInScope drops the plugin from the profile", () => {
+	test("c. PROJECT uninstall: uninstalls at PROJECT, then drops from the profile once", async () => {
+		const { deps, remove, calls } = setup(["project"]);
+
+		await uninstallPluginInScope(ID, "project", PROJECT, deps, PROFILE);
+
+		expect(remove.uninstall).toHaveBeenCalledWith(ID, "project", PROJECT);
+		expect(remove.dropFromProfile).toHaveBeenCalledTimes(1);
+		expect(calls).toEqual([
+			`uninstall:${ID}:project:${PROJECT}`,
+			"dropFromProfile",
+		]);
+	});
+
+	test("d. USER uninstall while PROJECT still installs it: the profile is untouched", async () => {
+		const { deps, remove } = setup(["user", "project"]);
+
+		await uninstallPluginInScope(ID, "user", PROJECT, deps, PROFILE);
+
+		expect(remove.uninstall).toHaveBeenCalledWith(ID, "user", PROJECT);
+		expect(remove.dropFromProfile).not.toHaveBeenCalled();
+	});
+
+	test("e. LOCAL uninstall leaving it installed nowhere: drops from the profile once", async () => {
+		const { deps, remove } = setup(["local"]);
+
+		await uninstallPluginInScope(ID, "local", PROJECT, deps, PROFILE);
+
+		expect(remove.uninstall).toHaveBeenCalledWith(ID, "local", PROJECT);
+		expect(remove.dropFromProfile).toHaveBeenCalledTimes(1);
+	});
+});

package/src/__tests__/scratch-git.ts

@@ -0,0 +1,48 @@
+import { execFileSync } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+import fs from "fs-extra";
+
+/**
+ * Real scratch git repositories for tests that need `inheritablePaths` to
+ * answer for real. Everything lives under os.tmpdir(); nothing touches the
+ * operator's home or config.
+ */
+
+// Isolate from the operator's git config (signing, default branch, excludes).
+const GIT_CFG = [
+	"-c",
+	"user.name=test",
+	"-c",
+	"user.email=test@example.com",
+	"-c",
+	"commit.gpgsign=false",
+	"-c",
+	"init.defaultBranch=main",
+];
+
+export const git = (cwd: string, ...args: string[]): string =>
+	execFileSync("git", [...GIT_CFG, ...args], {
+		cwd,
+		encoding: "utf8",
+		stdio: ["ignore", "pipe", "pipe"],
+	}).trim();
+
+/** A new scratch directory; realpath'd because git reports real paths. */
+export async function makeScratch(): Promise<string> {
+	return fs.realpath(await fs.mkdtemp(path.join(os.tmpdir(), "magus-remove-")));
+}
+
+/** `git init` plus one commit at `dir`. */
+export async function initRepo(dir: string): Promise<void> {
+	await fs.ensureDir(dir);
+	git(dir, "init", "-q");
+	await fs.writeFile(path.join(dir, "README.md"), "hello\n");
+	git(dir, "add", "-A");
+	git(dir, "commit", "-qm", "initial");
+}
+
+/** A linked worktree of `main` at `dir`, on a new branch. */
+export function addWorktree(main: string, dir: string, branch: string): void {
+	git(main, "worktree", "add", "-q", "-b", branch, dir);
+}