magus-cli 7.11.1 → 7.11.3

package/src/services/update-engine.ts

@@ -39,9 +39,11 @@ import type {
 import type { Command } from "../utils/command-utils.js";
 import { formatCommand } from "../utils/command-utils.js";
 import { runArgv, succeeded } from "../utils/run.js";
+import { selectProfileId } from "./active-closure.js";
 import type { PluginScope } from "./claude-cli.js";
 import {
 	installPlugin,
+	isNotInstalledAnswer,
 	repairPlugin,
 	uninstallPluginViaCli,
 	updatePlugin,
@@ -52,19 +54,24 @@ import {
 	getEnabledPlugins,
 	getGlobalEnabledPlugins,
 	getLocalEnabledPlugins,
+	inheritedRowsOf,
 	loadedVersionHere,
 	notDownloadedReason,
 	readInstalledPluginsRegistry,
 	repairStaleLoad,
 	rowBelongsToRepository,
 } from "./claude-settings.js";
+import { readManifest } from "./manifest.js";
+import { readPluginDependencies } from "./plugin-dependencies.js";
 import {
 	compareVersions,
 	isRepairablyBehind,
 	readInstalledVersionForScope,
 	saveInstalledPluginVersionForScope,
 } from "./plugin-manager.js";
+import { activeProfile } from "./profile-live.js";
 import { removePluginFromProfile } from "./profile-state.js";
+import { profileDependentsOf } from "./resolver.js";
 import { installSkill } from "./skills-manager.js";
 import {
 	type ToolFacts,
@@ -302,6 +309,17 @@ export interface PluginRemoveDeps {
 		scope: PluginScope,
 		projectPath: string,
 	) => Promise<void>;
+	/**
+	 * The plugins `profile` declares that need `pluginId` (`profileDependentsOf`).
+	 * While any is declared, the profile re-adds `pluginId` as their dependency,
+	 * so dropping it cannot take effect. `profile` undefined means the active
+	 * one. Optional so a double that does not model dependencies skips the check.
+	 */
+	dependents?: (
+		pluginId: string,
+		projectPath: string,
+		profile: string | null | undefined,
+	) => Promise<string[]>;
 }
 
 /** The settings a scope's install lives in — the classifier's definition. */
@@ -321,6 +339,23 @@ export const REAL_REMOVE_DEPS: PluginRemoveDeps = {
 	dropFromProfile: (pluginId, projectPath, profile) =>
 		removePluginFromProfile(projectPath, pluginId, profile),
 	forgetVersion: forgetInstalledPluginVersion,
+	// The profile picked as `removePluginFromProfile` picks it, so the check and
+	// the drop judge the same profile. A parse error throws, as it does there.
+	dependents: async (pluginId, projectPath, profile) => {
+		const manifest = await readManifest(projectPath);
+		const id =
+			profile === undefined
+				? selectProfileId(
+						Object.keys(manifest.profiles),
+						undefined,
+						await activeProfile(projectPath),
+					)
+				: profile;
+		if (!id) return [];
+		return profileDependentsOf(manifest, id, pluginId, (dep) =>
+			readPluginDependencies(dep, projectPath),
+		);
+	},
 };
 
 export const REAL_PLUGIN_DEPS: PluginApplyDeps = {
@@ -455,7 +490,7 @@ async function followMisdirectedUpdate(
 			notFollowed: `it went to v${version}, not the v${target} this update asked for`,
 		};
 	}
-	const repair = await deps.repairStaleLoad(pluginId, version, projectPath);
+	const repair = await repairLoadHere(deps, pluginId, version, projectPath);
 	return {
 		elsewhere,
 		version,
@@ -506,6 +541,39 @@ export async function bringLoadForward(
 	if (!deps.loadedVersion) return null;
 	const loaded = await deps.loadedVersion(pluginId, projectPath);
 	if (!isRepairablyBehind(target, loaded)) return null;
+	return repairLoadHere(deps, pluginId, target, projectPath);
+}
+
+/**
+ * `deps.repairStaleLoad`, clearing an ORPHAN USER row first when that is what
+ * blocks it.
+ *
+ * A USER registry row for a plugin USER settings do not turn on still wins the
+ * loader's resolution in every project, so the repair refuses on it — yet the
+ * user installs nothing at USER. Claude Code's startup sync adds such rows and
+ * never removes them. `claude plugin uninstall --scope user` removes just that
+ * row (measured, Claude Code 2.1.308), so it runs once and the repair is
+ * retried. A REAL USER install keeps the refusal: moving it is the user's call.
+ */
+async function repairLoadHere(
+	deps: PluginApplyDeps,
+	pluginId: string,
+	target: string,
+	projectPath: string,
+): Promise<StaleLoadRepairResult> {
+	const first = await deps.repairStaleLoad(pluginId, target, projectPath);
+	const remove = deps.remove;
+	if (first.ok || first.blockedBy !== "user" || !remove) return first;
+	if (await remove.isInstalled(pluginId, "user", projectPath)) return first;
+	try {
+		await remove.uninstall(pluginId, "user", projectPath);
+	} catch (error) {
+		// The CLI's own words: no fallback writes the registry in its place.
+		return {
+			...first,
+			error: error instanceof Error ? error.message : String(error),
+		};
+	}
 	return deps.repairStaleLoad(pluginId, target, projectPath);
 }
 
@@ -747,7 +815,8 @@ async function applyStaleLoad(
 		return;
 	}
 	try {
-		const outcome = await deps.repairStaleLoad(
+		const outcome = await repairLoadHere(
+			deps,
 			item.pluginId,
 			item.target,
 			projectPath,
@@ -816,11 +885,33 @@ async function applyRemove(
 	}
 	try {
 		let uninstallError: unknown = null;
+		// Errors of the inherited-row uninstalls, apart from the scope loop's: the
+		// CLI's "not installed in <scope> scope" is the expected answer there for a
+		// scope this folder only inherits, and is not a failure.
+		let inheritedError: unknown = null;
 		for (const scope of item.scopes) {
 			try {
 				await remove.uninstall(item.pluginId, scope, projectPath);
 			} catch (error) {
-				uninstallError ??= error;
+				if (!isNotInstalledAnswer(error)) uninstallError ??= error;
+			}
+		}
+		// A row this folder only INHERITS (a linked worktree reading its main
+		// checkout's install) is removed from the row's own folder; the CLI finds
+		// nothing to remove from anywhere else.
+		const inherited = await inheritedRowsOf(
+			(await readRows(deps, item.pluginId)) ?? [],
+			projectPath,
+		);
+		for (const row of inherited) {
+			try {
+				await remove.uninstall(
+					item.pluginId,
+					row.scope,
+					row.projectPath ?? projectPath,
+				);
+			} catch (error) {
+				inheritedError ??= error;
 			}
 		}
 		const unlisted = await remove.dropFromProfile(
@@ -846,6 +937,38 @@ async function applyRemove(
 					.catch(() => {});
 			}
 		}
+		// Success needs the rows READ and none remaining: a read-back that fails
+		// is a removal nobody confirmed, never "no rows remain".
+		const rowsNow = await readRows(deps, item.pluginId);
+		if (rowsNow === null && deps.registryRows) {
+			if (inheritedError instanceof Error) {
+				fail(inheritedError.message, "exception");
+			} else {
+				fail("could not confirm it was removed");
+			}
+			return;
+		}
+		const remaining = await inheritedRowsOf(rowsNow ?? [], projectPath);
+		if (remaining.length > 0) {
+			if (inheritedError instanceof Error) {
+				fail(inheritedError.message, "exception");
+				return;
+			}
+			const names = [
+				...new Set(
+					remaining
+						.map((r) => r.projectPath)
+						.filter((p): p is string => p !== undefined)
+						.map((p) => path.basename(p)),
+				),
+			];
+			fail(
+				names.length > 0
+					? `still installed in ${names.join(", ")}, another folder of this repository`
+					: "still installed in another folder of this repository",
+			);
+			return;
+		}
 		if (still.length > 0) {
 			// The CLI's own words when it said anything; ours otherwise.
 			if (uninstallError !== null) {
@@ -1131,6 +1254,80 @@ export async function updatePluginInScope(
 	);
 }
 
+/**
+ * Uninstall a plugin at ONE explicitly chosen scope, and stop the profile
+ * declaring it when that leaves nothing for the profile to keep.
+ *
+ * Without the profile step, a profile-declared plugin came straight back as
+ * "not installed — profile declares it". The profile is dropped when the scope
+ * was PROJECT — the settings the profile itself renders — or when the plugin is
+ * now installed at no scope. Never for a USER or LOCAL uninstall while PROJECT
+ * still installs it: the profile still describes that install.
+ *
+ * Success is read back, as in {@link applyRemove}: still installed at `scope`
+ * afterwards throws, whatever the command said.
+ *
+ * @param profile the profile to drop it from; undefined means the active one.
+ */
+export async function uninstallPluginInScope(
+	pluginId: string,
+	scope: PluginScope,
+	projectPath: string,
+	deps: PluginApplyDeps = REAL_PLUGIN_DEPS,
+	profile?: string | null,
+): Promise<void> {
+	const remove = deps.remove;
+	if (!remove) throw new Error("magus cannot remove plugins from here");
+
+	// Refuse BEFORE uninstalling when the profile drop below would be needed but
+	// cannot hold: a declared plugin that depends on this one re-adds it.
+	if (remove.dependents) {
+		let installedElsewhere = false;
+		for (const other of REMOVE_SCOPES) {
+			if (other === scope) continue;
+			if (await remove.isInstalled(pluginId, other, projectPath)) {
+				installedElsewhere = true;
+				break;
+			}
+		}
+		if (scope === "project" || !installedElsewhere) {
+			const dependents = await remove.dependents(
+				pluginId,
+				projectPath,
+				profile,
+			);
+			if (dependents.length > 0) {
+				const names = dependents.map(pluginName).join(", ");
+				const needs = dependents.length === 1 ? "needs" : "need";
+				throw new Error(
+					`${names} ${needs} ${pluginName(pluginId)} — uninstall ${names} first`,
+				);
+			}
+		}
+	}
+
+	await remove.uninstall(pluginId, scope, projectPath);
+	if (await remove.isInstalled(pluginId, scope, projectPath)) {
+		throw new Error(`still installed at ${scope.toUpperCase()} scope`);
+	}
+	// Best-effort, as in applyRemove: the read-back above is the judge.
+	await remove.forgetVersion?.(pluginId, scope, projectPath).catch(() => {});
+
+	let installedNowhere = true;
+	for (const other of REMOVE_SCOPES) {
+		if (await remove.isInstalled(pluginId, other, projectPath)) {
+			installedNowhere = false;
+			break;
+		}
+	}
+	if (scope !== "project" && !installedNowhere) return;
+	if (!(await remove.dropFromProfile(pluginId, projectPath, profile))) {
+		throw new Error(
+			`uninstalled at ${scope.toUpperCase()} scope, but the profile still lists it`,
+		);
+	}
+}
+
 // -- binaries ----------------------------------------------------------------
 
 /**

package/src/ui/screens/PluginsScreen.tsx

@@ -9,9 +9,14 @@ import {
 	type PluginScope,
 	addMarketplace as cliAddMarketplace,
 	repairPlugin as cliRepairPlugin,
-	uninstallPlugin as cliUninstallPlugin,
+	isNotInstalledAnswer,
+	uninstallPluginViaCli,
 } from "../../services/claude-cli.js";
-import { readSettings, setMcpEnvVar } from "../../services/claude-settings.js";
+import {
+	readInheritedRegistryRows,
+	readSettings,
+	setMcpEnvVar,
+} from "../../services/claude-settings.js";
 import { clearContentDriftCache } from "../../services/content-drift.js";
 import { missingPluginEnvVars } from "../../services/plugin-env-needs.js";
 import {
@@ -44,6 +49,7 @@ import {
 	applyPlugins,
 	installPluginInScope,
 	pluginNeedsWork,
+	uninstallPluginInScope,
 	updatePluginInScope,
 } from "../../services/update-engine.js";
 // The ONE plugin classifier, shared with `magus update`. Every state this
@@ -1019,7 +1025,15 @@ export function PluginsScreen() {
 					modal.loading(
 						`Uninstalling ${plugin.name} from ${scopeLabel}…\nclaude plugin uninstall ${plugin.id} --scope ${scope}`,
 					);
-					await cliUninstallPlugin(plugin.id, scope, state.projectPath);
+					// Through the engine, so the profile stops declaring what was
+					// just uninstalled and the result is read back.
+					await uninstallPluginInScope(
+						plugin.id,
+						scope,
+						state.projectPath || process.cwd(),
+						REAL_PLUGIN_DEPS,
+						activeProfileId,
+					);
 				} else if (action === "update") {
 					modal.loading(
 						`Updating ${plugin.name} in ${scopeLabel}…\nclaude plugin install ${plugin.id} --scope ${scope}`,
@@ -1185,7 +1199,14 @@ export function PluginsScreen() {
 				modal.loading(
 					`Uninstalling ${plugin.name} from ${scopeLabel}…\nclaude plugin uninstall ${plugin.id} --scope ${scope}`,
 				);
-				await cliUninstallPlugin(plugin.id, scope, state.projectPath);
+				// Engine uninstall: read back, and dropped from the profile — see above.
+				await uninstallPluginInScope(
+					plugin.id,
+					scope,
+					state.projectPath || process.cwd(),
+					REAL_PLUGIN_DEPS,
+					activeProfileId,
+				);
 			} else if (action === "update") {
 				modal.loading(
 					`Updating ${plugin.name} in ${scopeLabel}…\nclaude plugin install ${plugin.id} --scope ${scope}`,
@@ -1244,25 +1265,45 @@ export function PluginsScreen() {
 			return;
 		}
 
+		// Errors are collected, not dropped: only the CLI's "is not installed in
+		// <scope> scope" answer is expected, and only for a scope with no row.
+		const problems: unknown[] = [];
 		try {
 			// Remove from all scopes — try all to clean up stale references
 			const scopes: PluginScope[] = ["user", "project", "local"];
-			// Nothing tallies which scopes actually held it. The migrate dialog
-			// that consumed that tally is gone with the `moved` inference, and
-			// collecting it for no reader is how a value goes stale unnoticed.
 			for (const scope of scopes) {
 				try {
 					modal.loading(
 						`Removing ${plugin.name} from ${scope}…\nclaude plugin uninstall ${plugin.id} --scope ${scope}`,
 					);
-					await cliUninstallPlugin(plugin.id, scope, state.projectPath);
-				} catch {
-					// Ignore errors for scopes where it doesn't exist
+					await uninstallPluginViaCli(plugin.id, scope, state.projectPath);
+				} catch (error) {
+					if (!isNotInstalledAnswer(error)) problems.push(error);
+				}
+			}
+			// A folder of the same repository may hold the install this one only
+			// shows: the CLI removes it only when run from that folder.
+			const inherited = await readInheritedRegistryRows(
+				plugin.id,
+				state.projectPath || process.cwd(),
+			);
+			for (const row of inherited) {
+				if (!row.projectPath) continue;
+				try {
+					modal.loading(
+						`Removing ${plugin.name} from the repository's main folder, which this folder shares…\nclaude plugin uninstall ${plugin.id} --scope ${row.scope}`,
+					);
+					await uninstallPluginViaCli(plugin.id, row.scope, row.projectPath);
+				} catch (error) {
+					problems.push(error);
 				}
 			}
 
 			modal.hideModal();
 			fetchData();
+			if (problems.length > 0) {
+				await reportPluginFailure(plugin.id, "removed", problems[0]);
+			}
 		} catch (error) {
 			modal.hideModal();
 			await reportPluginFailure(plugin.id, "removed", error);