magus-cli 7.11.1 → 7.11.3

package/src/__tests__/worktree-deprecated-remove-reader.test.ts

@@ -0,0 +1,268 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import path from "node:path";
+import fs from "fs-extra";
+import { isNotInstalledAnswer } from "../services/claude-cli.js";
+import type { PluginScope } from "../services/claude-cli.js";
+import {
+	inheritedRegistryRows,
+	inheritedRowsOf,
+} from "../services/claude-settings.js";
+import { clearWorktreeCache } from "../services/git-worktree.js";
+import {
+	type ApplyReporter,
+	type PluginApplyDeps,
+	applyPlugins,
+} from "../services/update-engine.js";
+import type { PluginUpdateItem } from "../services/update-plan.js";
+import type { InstalledPluginEntry } from "../types/index.js";
+import { addWorktree, initRepo, makeScratch } from "./scratch-git.js";
+
+/**
+ * Removing a deprecated plugin from a linked worktree whose only registry row
+ * belongs to the main checkout: the reader that finds that row, the folder the
+ * uninstall runs in, and the failures that must not be swallowed.
+ *
+ * Repository membership is git's answer (`inheritablePaths`), so the cases that
+ * depend on it run against real scratch repositories.
+ */
+
+const OTHER = "/elsewhere/unrelated";
+const ID = "code-analysis@magus";
+
+let scratch: string;
+let MAIN: string;
+let TREE: string;
+// Two INDEPENDENT repositories, the second kept under the first's
+// `.claude/worktrees/` — a path shape that is not repository membership.
+let PARENT: string;
+let NESTED: string;
+
+beforeAll(async () => {
+	scratch = await makeScratch();
+	MAIN = path.join(scratch, "repo");
+	TREE = path.join(scratch, "feature");
+	await initRepo(MAIN);
+	addWorktree(MAIN, TREE, "feature");
+	PARENT = path.join(scratch, "parent");
+	NESTED = path.join(PARENT, ".claude", "worktrees", "child");
+	await initRepo(PARENT);
+	await initRepo(NESTED);
+	clearWorktreeCache();
+});
+
+afterAll(async () => {
+	if (scratch) await fs.remove(scratch);
+});
+
+const entry = (
+	scope: InstalledPluginEntry["scope"],
+	projectPath?: string,
+): InstalledPluginEntry => ({
+	scope,
+	version: "7.3.0",
+	projectPath,
+	installPath: "/cache/7.3.0",
+	installedAt: "2026-01-01T00:00:00.000Z",
+	lastUpdated: "2026-01-01T00:00:00.000Z",
+});
+
+describe("inheritedRegistryRows", () => {
+	test("finds the main checkout's project and local rows", () => {
+		const rows = inheritedRegistryRows(
+			[entry("project", MAIN), entry("local", MAIN)],
+			TREE,
+			[MAIN],
+		);
+		expect(rows.map((r) => r.scope).sort()).toEqual(["local", "project"]);
+		expect(rows.every((r) => r.projectPath === MAIN)).toBe(true);
+	});
+
+	test("does not return the project's own row", () => {
+		const rows = inheritedRegistryRows(
+			[entry("project", TREE), entry("project", MAIN)],
+			TREE,
+			[MAIN, TREE],
+		);
+		expect(rows.map((r) => r.projectPath)).toEqual([MAIN]);
+	});
+
+	test("never returns rows of an unrelated project or the user row", () => {
+		const rows = inheritedRegistryRows(
+			[entry("project", OTHER), entry("user")],
+			TREE,
+			[MAIN],
+		);
+		expect(rows).toEqual([]);
+	});
+
+	test("returns nothing when no same-repository folder is known", () => {
+		expect(inheritedRegistryRows([entry("project", MAIN)], TREE, [])).toEqual(
+			[],
+		);
+		expect(inheritedRegistryRows(undefined, TREE, [MAIN])).toEqual([]);
+	});
+
+	test("a linked worktree inherits its main checkout's row, per git", async () => {
+		const rows = await inheritedRowsOf(
+			[entry("project", MAIN), entry("project", OTHER)],
+			TREE,
+		);
+		expect(rows.map((r) => r.projectPath)).toEqual([MAIN]);
+	});
+
+	test("an unrelated parent repository's row is NEVER returned for a nested independent repository", async () => {
+		const rows = await inheritedRowsOf(
+			[entry("project", PARENT), entry("local", PARENT)],
+			NESTED,
+		);
+		expect(rows).toEqual([]);
+	});
+});
+
+describe("isNotInstalledAnswer", () => {
+	test("recognises the CLI's per-scope answer only", () => {
+		expect(
+			isNotInstalledAnswer(
+				new Error(`Plugin "${ID}" is not installed in project scope.`),
+			),
+		).toBe(true);
+		expect(isNotInstalledAnswer(new Error("claude timed out"))).toBe(false);
+	});
+});
+
+function harness(
+	rows: InstalledPluginEntry[],
+	uninstall: (id: string, scope: PluginScope, cwd: string) => Promise<void>,
+) {
+	const unused = async () => {
+		throw new Error("a removal must not install, update or repair");
+	};
+	const deps: PluginApplyDeps = {
+		install: unused,
+		update: unused,
+		repair: unused,
+		readInstalled: unused,
+		saveInstalled: unused,
+		repairStaleLoad: unused,
+		registryRows: async () => rows,
+		remove: {
+			uninstall,
+			isInstalled: async () => false,
+			dropFromProfile: async () => true,
+		},
+	};
+	const item: PluginUpdateItem = {
+		pluginId: ID,
+		pinned: "latest",
+		installed: null,
+		loaded: null,
+		available: null,
+		target: null,
+		action: "remove",
+		reason: "deprecated",
+		scopes: [],
+		beforeVersions: {},
+		note: "no longer published",
+	};
+	const details: string[] = [];
+	const reporter: ApplyReporter = {
+		begin: () => {},
+		finish: (_ok, _id, detail) => {
+			details.push(String(detail));
+		},
+		detach: (work) => work(),
+	};
+	return { deps, item, reporter, details };
+}
+
+describe("applyPlugins: removing an inherited row", () => {
+	test("runs the uninstall in the row's own folder", async () => {
+		let rows = [entry("project", MAIN), entry("project", OTHER)];
+		const calls: Array<[PluginScope, string]> = [];
+		const h = harness(rows, async (_id, scope, cwd) => {
+			calls.push([scope, cwd]);
+			rows = rows.filter((r) => r.projectPath !== cwd);
+		});
+		h.deps.registryRows = async () => rows;
+
+		const result = await applyPlugins([h.item], TREE, h.deps, h.reporter);
+
+		expect(calls).toEqual([["project", MAIN]]);
+		expect(result.failed).toEqual([]);
+		// The unrelated project's row is untouched.
+		expect(rows.map((r) => r.projectPath)).toEqual([OTHER]);
+	});
+
+	test("a real uninstall error surfaces instead of being swallowed", async () => {
+		const rows = [entry("project", MAIN)];
+		const h = harness(rows, async () => {
+			throw new Error("claude plugin uninstall timed out");
+		});
+
+		const result = await applyPlugins([h.item], TREE, h.deps, h.reporter);
+
+		expect(result.failed).toEqual([ID]);
+		expect(h.details.join(" ")).toContain("timed out");
+	});
+
+	test("says where it is still installed when the command reported nothing", async () => {
+		const rows = [entry("project", MAIN)];
+		const h = harness(rows, async () => {});
+
+		const result = await applyPlugins([h.item], TREE, h.deps, h.reporter);
+
+		expect(result.failed).toEqual([ID]);
+		const detail = h.details.join(" ");
+		expect(detail).toContain(
+			`still installed in ${path.basename(MAIN)}, another folder of this repository`,
+		);
+		// A folder is named, never an absolute path.
+		expect(detail).not.toContain(MAIN);
+	});
+
+	test("an unreadable registry after the uninstalls is a failed removal", async () => {
+		const rows = [entry("project", MAIN)];
+		let reads = 0;
+		const h = harness(rows, async () => {
+			throw new Error("claude plugin uninstall timed out");
+		});
+		h.deps.registryRows = async () => {
+			reads++;
+			if (reads > 1) throw new Error("registry unreadable");
+			return rows;
+		};
+
+		const result = await applyPlugins([h.item], TREE, h.deps, h.reporter);
+
+		expect(result.failed).toEqual([ID]);
+		expect(result.removed).toEqual([]);
+	});
+
+	test("an unreadable registry with no error from the CLI says it could not confirm", async () => {
+		const rows = [entry("project", MAIN)];
+		let reads = 0;
+		const h = harness(rows, async () => {});
+		h.deps.registryRows = async () => {
+			reads++;
+			if (reads > 1) throw new Error("registry unreadable");
+			return rows;
+		};
+
+		const result = await applyPlugins([h.item], TREE, h.deps, h.reporter);
+
+		expect(result.failed).toEqual([ID]);
+		expect(h.details.join(" ")).toContain("could not confirm it was removed");
+	});
+
+	test("never uninstalls an unrelated parent repository's row from a nested independent repository", async () => {
+		const rows = [entry("project", PARENT)];
+		const calls: string[] = [];
+		const h = harness(rows, async (_id, _scope, cwd) => {
+			calls.push(cwd);
+		});
+
+		await applyPlugins([h.item], NESTED, h.deps, h.reporter);
+
+		expect(calls).toEqual([]);
+	});
+});

package/src/__tests__/worktree-deprecated-remove.test.ts

@@ -0,0 +1,115 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import path from "node:path";
+import fs from "fs-extra";
+import type { PluginScope } from "../services/claude-cli.js";
+import { clearWorktreeCache } from "../services/git-worktree.js";
+import {
+	type ApplyReporter,
+	type PluginApplyDeps,
+	applyPlugins,
+} from "../services/update-engine.js";
+import type { PluginUpdateItem } from "../services/update-plan.js";
+import type { InstalledPluginEntry } from "../types/index.js";
+import { addWorktree, initRepo, makeScratch } from "./scratch-git.js";
+
+/**
+ * `d` on a deprecated plugin from a linked worktree, when the only registry
+ * row for it belongs to the MAIN checkout.
+ *
+ * The orphan row exists because the registry row is inherited from the main
+ * checkout, but no settings file here turns the plugin on, so the plan carries
+ * no scopes. The removal then runs zero uninstalls.
+ */
+
+const ID = "code-analysis@magus";
+
+// A real repository with a real linked worktree, so `inheritablePaths` answers
+// the way git does rather than from a path shape.
+let scratch: string;
+let MAIN: string;
+let TREE: string;
+
+beforeAll(async () => {
+	scratch = await makeScratch();
+	MAIN = path.join(scratch, "repo");
+	TREE = path.join(scratch, "feature");
+	await initRepo(MAIN);
+	addWorktree(MAIN, TREE, "feature");
+	clearWorktreeCache();
+});
+
+afterAll(async () => {
+	if (scratch) await fs.remove(scratch);
+});
+
+function row(projectPath: string): InstalledPluginEntry {
+	return {
+		scope: "project",
+		version: "7.3.0",
+		projectPath,
+		installPath: "/cache/7.3.0",
+		installedAt: "2026-01-01T00:00:00.000Z",
+		lastUpdated: "2026-01-01T00:00:00.000Z",
+	};
+}
+
+describe("applyPlugins: remove from a linked worktree", () => {
+	// REGRESSION: worktree d on a deprecated plugin removed nothing and showed no error — Fixed in /dev:fix session dev-fix-20261026-155239-490d2c7e
+	test("should not report success while the main checkout's registry row remains when removing from a linked worktree", async () => {
+		let rows: InstalledPluginEntry[] = [row(MAIN)];
+		const unused = async () => {
+			throw new Error("a removal must not install, update or repair");
+		};
+		const deps: PluginApplyDeps = {
+			install: unused,
+			update: unused,
+			repair: unused,
+			readInstalled: unused,
+			saveInstalled: unused,
+			repairStaleLoad: unused,
+			registryRows: async () => rows,
+			remove: {
+				// Like `claude plugin uninstall --scope project`: only the row
+				// pinned to exactly the cwd it runs in can be removed.
+				uninstall: async (_id, scope: PluginScope, cwd) => {
+					const hit = rows.some(
+						(r) => r.scope === scope && r.projectPath === cwd,
+					);
+					if (!hit) {
+						throw new Error(
+							`Plugin "${ID}" is not installed in ${scope} scope.`,
+						);
+					}
+					rows = rows.filter((r) => r.projectPath !== cwd);
+				},
+				// Settings-derived: no settings turn the plugin on here.
+				isInstalled: async () => false,
+				dropFromProfile: async () => true,
+			},
+		};
+		const item: PluginUpdateItem = {
+			pluginId: ID,
+			pinned: "latest",
+			installed: null,
+			loaded: null,
+			available: null,
+			target: null,
+			action: "remove",
+			reason: "deprecated",
+			scopes: [],
+			beforeVersions: {},
+			note: "no longer published",
+		};
+		const reporter: ApplyReporter = {
+			begin: () => {},
+			finish: () => {},
+			detach: (work) => work(),
+		};
+
+		const result = await applyPlugins([item], TREE, deps, reporter);
+
+		// Either the row is really gone (uninstall ran in the main checkout), or
+		// the removal says it failed. Success with the row still there is the bug.
+		expect(rows.length === 0 || result.failed.includes(ID)).toBe(true);
+	});
+});

package/src/services/claude-cli.ts

@@ -268,6 +268,15 @@ export async function uninstallPluginViaCli(
 	);
 }
 
+/**
+ * Is `error` the CLI's answer that the plugin is not installed at the scope it
+ * was asked about — the one failure of an uninstall that means "nothing to do".
+ */
+export function isNotInstalledAnswer(error: unknown): boolean {
+	const message = error instanceof Error ? error.message : String(error);
+	return /not installed in (user|project|local) scope/i.test(message);
+}
+
 /**
  * Repair a plugin whose files drifted from the marketplace under an unchanged
  * version — uninstall, then install again at the same scope.

package/src/services/claude-settings.ts

@@ -434,6 +434,74 @@ export function ownRegistryEntry(
 	);
 }
 
+/**
+ * The project and local rows of one plugin that `projectPath` INHERITS: rows
+ * pinned to a same-repository folder (`fallbackPaths`, as
+ * {@link pickRegistryEntry} reads them) rather than to `projectPath` itself.
+ *
+ * These are the rows that make a plugin show up in a linked worktree that never
+ * installed it, and `claude plugin uninstall` removes them only when run from the
+ * row's own folder. Rows of any other project are never returned, and neither is
+ * the project's own row ({@link ownRegistryEntry} answers that one).
+ */
+export function inheritedRegistryRows(
+	entries: readonly InstalledPluginEntry[] | undefined,
+	projectPath: string,
+	fallbackPaths: readonly string[],
+): InstalledPluginEntry[] {
+	if (!Array.isArray(entries)) return [];
+	const own = path.resolve(projectPath);
+	const sources = new Set(fallbackPaths.map((p) => path.resolve(p)));
+	sources.delete(own);
+	return entries.filter(
+		(e) =>
+			(e.scope === "project" || e.scope === "local") &&
+			e.projectPath !== undefined &&
+			sources.has(path.resolve(e.projectPath)),
+	);
+}
+
+/**
+ * Same-repository folders whose rows `projectPath` inherits: git's
+ * `inheritablePaths`, the one definition the read side ({@link pickRegistryEntry})
+ * uses too. `[]` when git cannot answer.
+ */
+async function inheritableFolders(projectPath: string): Promise<string[]> {
+	return inheritablePaths(projectPath);
+}
+
+/**
+ * Read-only: the inherited rows of `pluginId` for `projectPath`, read from the
+ * registry. `[]` when the registry cannot be read or there are none.
+ */
+export async function readInheritedRegistryRows(
+	pluginId: string,
+	projectPath: string,
+): Promise<InstalledPluginEntry[]> {
+	try {
+		const registry = await readInstalledPluginsRegistry();
+		return inheritedRegistryRows(
+			registry.plugins?.[pluginId],
+			projectPath,
+			await inheritableFolders(projectPath),
+		);
+	} catch {
+		return [];
+	}
+}
+
+/** The inherited rows within `rows` already read, for a caller holding them. */
+export async function inheritedRowsOf(
+	rows: readonly InstalledPluginEntry[],
+	projectPath: string,
+): Promise<InstalledPluginEntry[]> {
+	return inheritedRegistryRows(
+		rows,
+		projectPath,
+		await inheritableFolders(projectPath),
+	);
+}
+
 async function overlayRegistryVersions(
 	base: Record<string, string>,
 	scope: "user" | "project" | "local",
@@ -1947,6 +2015,12 @@ export interface StaleLoadRepairResult {
 	ok: boolean;
 	/** Why it failed. Absent when `ok`. */
 	error?: string;
+	/**
+	 * Set when it refused because a machine-wide row wins here, naming that
+	 * scope — so a caller can tell a real USER install from an orphan USER row
+	 * without matching on `error`.
+	 */
+	blockedBy?: "user" | "managed";
 }
 
 /**
@@ -2087,11 +2161,19 @@ export async function repairStaleLoad(
 		// plugins, which the registry type in types/index.ts does not name — see
 		// `LoaderScope` in plugin-resolution.ts.
 		const scope: string = winner.scope;
-		return fail(
-			scope === "managed"
-				? "Claude Code loads the install your administrator manages here — ask them to update it"
-				: "Claude Code loads the USER install of it here — update it at USER scope",
-		);
+		return scope === "managed"
+			? {
+					...fail(
+						"Claude Code loads the install your administrator manages here — ask them to update it",
+					),
+					blockedBy: "managed",
+				}
+			: {
+					...fail(
+						"Claude Code loads the USER install of it here — update it at USER scope",
+					),
+					blockedBy: "user",
+				};
 	}
 
 	const stale = rows.filter(

package/src/services/resolver.ts

@@ -195,6 +195,38 @@ export async function requirersHere(
 	return edges;
 }
 
+/**
+ * The plugins `profileId` declares that need `pluginId` to load, directly or
+ * transitively — sorted ids, none when the profile does not exist.
+ *
+ * `resolveProfile` re-adds every dependency of a declared plugin, so while one
+ * of these is declared, the profile cannot stop enabling `pluginId`. Each
+ * declared plugin's closure is walked with the same `resolveDependencies` the
+ * resolve uses, so the two cannot disagree about what comes back.
+ */
+export async function profileDependentsOf(
+	manifest: ProfileManifest,
+	profileId: string,
+	pluginId: string,
+	dependencyResolver: PluginDependencyReader,
+): Promise<string[]> {
+	const raw = manifest.profiles[profileId];
+	if (!raw) return [];
+	const entry = resolveExtends(raw);
+	const off = new Set(
+		Object.entries(entry.plugins ?? {})
+			.filter(([, ver]) => ver === false)
+			.map(([id]) => id),
+	);
+	const dependents: string[] = [];
+	for (const id of Object.keys(normalizePlugins(entry.plugins))) {
+		if (id === pluginId) continue;
+		const report = await resolveDependencies([id], off, dependencyResolver);
+		if (report.derived.includes(pluginId)) dependents.push(id);
+	}
+	return dependents.sort();
+}
+
 function hasDependencies(report: DependencyReport): boolean {
 	return (
 		report.derived.length > 0 ||