claudeup 4.32.0 → 4.32.1

package/package.json

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

package/src/__tests__/scope-action.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, test } from "bun:test";
+import {
+  isInstalledInScope,
+  resolveScopeAction,
+} from "../services/plugin-manager.js";
+
+/**
+ * The scope keys (u / p / l) and the Enter scope picker both decide between
+ * install, update and uninstall. That decision used to read `scope.enabled` —
+ * the `enabledPlugins` flag from a settings file — and ignore `scope.version`,
+ * which is the registry-backed answer to "did Claude Code actually install
+ * this".
+ *
+ * Those two disagree in a real, common state: a plugin listed in
+ * `enabledPlugins` with no entry in `installed_plugins.json` for the current
+ * project path. The list row renders it "not installed" (isEnabledButNotInstalled),
+ * and pressing its scope key ran `claude plugin uninstall`. The user asked to
+ * install the thing the UI told them was missing, and it was removed instead.
+ */
+
+describe("isInstalledInScope", () => {
+  test("enabled with a registry version is installed", () => {
+    expect(isInstalledInScope({ enabled: true, version: "3.0.2" })).toBe(true);
+  });
+
+  test("enabled with NO version is not installed — the broken state", () => {
+    // dev@magus, measured: `.claude/settings.json` had "dev@magus": true while
+    // installed_plugins.json had no entry resolving for the project path.
+    expect(isInstalledInScope({ enabled: true })).toBe(false);
+  });
+
+  test("a version with the flag off is not installed either", () => {
+    expect(isInstalledInScope({ enabled: false, version: "3.0.2" })).toBe(false);
+  });
+
+  test("an absent scope is not installed", () => {
+    expect(isInstalledInScope(undefined)).toBe(false);
+  });
+
+  test('"0.0.0" counts as installed — Anthropic official plugins record it', () => {
+    expect(isInstalledInScope({ enabled: true, version: "0.0.0" })).toBe(true);
+  });
+});
+
+describe("resolveScopeAction", () => {
+  test("REGRESSION: enabled but not installed resolves to install, never uninstall", () => {
+    // This is the reported bug. Before the fix this returned "uninstall".
+    expect(resolveScopeAction({ enabled: true }, "3.0.2")).toBe("install");
+  });
+
+  test("a scope that was never enabled resolves to install", () => {
+    expect(resolveScopeAction(undefined, "3.0.2")).toBe("install");
+    expect(resolveScopeAction({ enabled: false }, "3.0.2")).toBe("install");
+  });
+
+  test("a healthy install at the latest version resolves to uninstall (toggle off)", () => {
+    expect(resolveScopeAction({ enabled: true, version: "3.0.2" }, "3.0.2")).toBe(
+      "uninstall",
+    );
+  });
+
+  test("a healthy install behind the catalog resolves to update", () => {
+    expect(resolveScopeAction({ enabled: true, version: "2.9.0" }, "3.0.2")).toBe(
+      "update",
+    );
+  });
+
+  test('an unknown catalog version ("0.0.0") never fabricates an update', () => {
+    // There is nothing to update *to*, so toggling must still mean uninstall.
+    expect(resolveScopeAction({ enabled: true, version: "3.0.2" }, "0.0.0")).toBe(
+      "uninstall",
+    );
+  });
+
+  test("installed with unknown version resolves to update when a real version is published", () => {
+    // "0.0.0" installed against a real catalog version is a genuine upgrade
+    // path, not the broken state — it must not be treated as uninstall.
+    expect(resolveScopeAction({ enabled: true, version: "0.0.0" }, "3.0.2")).toBe(
+      "update",
+    );
+  });
+});

package/src/services/plugin-manager.ts

@@ -135,6 +135,48 @@ export function isEnabledButNotInstalled(plugin: PluginInfo): boolean {
 	return enabledSomewhere && !plugin.installedVersion;
 }
 
+/**
+ * True when a scope genuinely has the plugin installed.
+ *
+ * `enabled` on its own is not proof. It is the `enabledPlugins` flag out of a
+ * settings file, and only claudeup and the user maintain it; `version` comes
+ * from `installed_plugins.json` via `overlayRegistryVersions`, which is what
+ * Claude Code actually loaded. When the two disagree — flag set, no registry
+ * entry — the plugin is in the broken enabled-but-not-installed state that the
+ * list already renders as "not installed".
+ *
+ * Every action that touches the filesystem must use this, not the flag alone.
+ * Deciding on the flag is what made the scope keys uninstall a plugin the row
+ * had just labelled "not installed".
+ *
+ * A version of "0.0.0" still counts as installed — Anthropic's official plugins
+ * record exactly that — which is why this tests presence, not `isKnownVersion`.
+ */
+export function isInstalledInScope(scope: ScopeStatus | undefined): boolean {
+	return !!scope?.enabled && !!scope.version;
+}
+
+/**
+ * What a scope toggle (`u` / `p` / `l`, or the Enter scope picker) should do.
+ *
+ * `install` doubles as the repair for enabled-but-not-installed. Measured
+ * against Claude Code 2.1.223 in exactly that state — `dev@magus` flagged in
+ * `.claude/settings.json` with no registry entry for the project path —
+ * `claude plugin install dev@magus --scope project` installed it normally and
+ * wrote the registry entry. It does not report "already installed", so this
+ * needs no uninstall-first dance (unlike content drift, see repairPlugin).
+ */
+export function resolveScopeAction(
+	scope: ScopeStatus | undefined,
+	latestVersion: string,
+): "install" | "update" | "uninstall" {
+	if (!isInstalledInScope(scope)) return "install";
+	const installed = scope?.version;
+	const hasUpdate =
+		!!installed && latestVersion !== "0.0.0" && installed !== latestVersion;
+	return hasUpdate ? "update" : "uninstall";
+}
+
 
 export async function getAvailablePlugins(
 	projectPath?: string,

package/src/ui/renderers/pluginRenderers.tsx

@@ -16,9 +16,13 @@ import {
 import { theme } from "../theme.js";
 import { highlightMatches } from "../../utils/fuzzy-search.js";
 import { getMarketplaceVersion } from "../../services/marketplace-fetcher.js";
-import { isEnabledButNotInstalled } from "../../services/plugin-manager.js";
+import {
+  isEnabledButNotInstalled,
+  isInstalledInScope,
+} from "../../services/plugin-manager.js";
 import { isKnownVersion } from "../../services/version-snapshot.js";
 import type { PluginRelease } from "../../types/index.js";
+import type { ScopeStatus } from "../../services/plugin-manager.js";
 
 // ─── Category renderers ───────────────────────────────────────────────────────
 
@@ -223,10 +227,14 @@ function pluginRow(item: PluginPluginItem, isSelected: boolean): React.ReactNode
 
 function pluginDetail(item: PluginPluginItem): React.ReactNode {
   const { plugin } = item;
+  // "Installed" has to mean the same thing here as in the list row. Reading the
+  // `enabledPlugins` flag alone made this panel print "● Installed" for the
+  // exact plugin the row beside it was labelling "not installed".
   const isInstalled =
-    plugin.userScope?.enabled ||
-    plugin.projectScope?.enabled ||
-    plugin.localScope?.enabled;
+    isInstalledInScope(plugin.userScope) ||
+    isInstalledInScope(plugin.projectScope) ||
+    isInstalledInScope(plugin.localScope);
+  const brokenInstall = isEnabledButNotInstalled(plugin);
 
   // Orphaned/deprecated plugin
   if (plugin.isOrphaned) {
@@ -284,10 +292,30 @@ function pluginDetail(item: PluginPluginItem): React.ReactNode {
 
       {/* Status line */}
       <box marginTop={1}>
-        <text fg={isInstalled ? theme.colors.success : theme.colors.muted}>
-          {isInstalled ? "● Installed" : "○ Not installed"}
+        <text
+          fg={
+            isInstalled
+              ? theme.colors.success
+              : brokenInstall
+                ? theme.colors.warning
+                : theme.colors.muted
+          }
+        >
+          {isInstalled
+            ? "● Installed"
+            : brokenInstall
+              ? "○ Not installed — enabled in settings, no files on disk"
+              : "○ Not installed"}
         </text>
       </box>
+      {brokenInstall ? (
+        <box>
+          <text fg={theme.colors.muted}>
+            Claude Code cannot load it in this state. Press the scope key to
+            repair.
+          </text>
+        </box>
+      ) : null}
 
       {/* Description */}
       <box marginTop={1} marginBottom={1}>
@@ -331,48 +359,27 @@ function pluginDetail(item: PluginPluginItem): React.ReactNode {
           <strong>Scopes:</strong>
         </text>
         <box marginTop={1} flexDirection="column">
-          <text>
-            <span bg={theme.scopes.user} fg="black">
-              {" "}
-              u{" "}
-            </span>
-            <span fg={plugin.userScope?.enabled ? theme.scopes.user : theme.colors.muted}>
-              {plugin.userScope?.enabled ? " ● " : " ○ "}
-            </span>
-            <span fg={theme.scopes.user}>User</span>
-            <span> global</span>
-            {plugin.userScope?.version ? (
-              <span fg={theme.scopes.user}> v{plugin.userScope.version}</span>
-            ) : null}
-          </text>
-          <text>
-            <span bg={theme.scopes.project} fg="black">
-              {" "}
-              p{" "}
-            </span>
-            <span fg={plugin.projectScope?.enabled ? theme.scopes.project : theme.colors.muted}>
-              {plugin.projectScope?.enabled ? " ● " : " ○ "}
-            </span>
-            <span fg={theme.scopes.project}>Project</span>
-            <span> team</span>
-            {plugin.projectScope?.version ? (
-              <span fg={theme.scopes.project}> v{plugin.projectScope.version}</span>
-            ) : null}
-          </text>
-          <text>
-            <span bg={theme.scopes.local} fg="black">
-              {" "}
-              l{" "}
-            </span>
-            <span fg={plugin.localScope?.enabled ? theme.scopes.local : theme.colors.muted}>
-              {plugin.localScope?.enabled ? " ● " : " ○ "}
-            </span>
-            <span fg={theme.scopes.local}>Local</span>
-            <span> private</span>
-            {plugin.localScope?.version ? (
-              <span fg={theme.scopes.local}> v{plugin.localScope.version}</span>
-            ) : null}
-          </text>
+          <ScopeLine
+            keyHint="u"
+            name="User"
+            qualifier="global"
+            color={theme.scopes.user}
+            scope={plugin.userScope}
+          />
+          <ScopeLine
+            keyHint="p"
+            name="Project"
+            qualifier="team"
+            color={theme.scopes.project}
+            scope={plugin.projectScope}
+          />
+          <ScopeLine
+            keyHint="l"
+            name="Local"
+            qualifier="private"
+            color={theme.scopes.local}
+            scope={plugin.localScope}
+          />
         </box>
       </DetailSection>
 
@@ -389,6 +396,47 @@ function pluginDetail(item: PluginPluginItem): React.ReactNode {
   );
 }
 
+/**
+ * One line of the detail panel's scope breakdown.
+ *
+ * The filled dot means installed — registry-backed, same as everywhere else.
+ * A scope that is enabled with nothing installed is called out explicitly
+ * rather than shown as a plain empty dot, because those two states need
+ * different actions from the user and used to look identical.
+ */
+function ScopeLine({
+  keyHint,
+  name,
+  qualifier,
+  color,
+  scope,
+}: {
+  keyHint: string;
+  name: string;
+  qualifier: string;
+  color: string;
+  scope?: ScopeStatus;
+}): React.ReactNode {
+  const installed = isInstalledInScope(scope);
+  return (
+    <text>
+      <span bg={color} fg="black">
+        {" "}
+        {keyHint}{" "}
+      </span>
+      <span fg={installed ? color : theme.colors.muted}>
+        {installed ? " ● " : " ○ "}
+      </span>
+      <span fg={color}>{name}</span>
+      <span> {qualifier}</span>
+      {scope?.version ? <span fg={color}> v{scope.version}</span> : null}
+      {!installed && scope?.enabled ? (
+        <span fg={theme.colors.warning}> enabled, not installed</span>
+      ) : null}
+    </text>
+  );
+}
+
 /**
  * Recent release history, newest first.
  *

package/src/ui/screens/PluginsScreen.tsx

@@ -18,8 +18,11 @@ import {
 	refreshAllMarketplaces,
 	clearMarketplaceCache,
 	getLocalMarketplacesInfo,
+	isInstalledInScope,
+	resolveScopeAction,
 	saveInstalledPluginVersion,
 	type PluginInfo,
+	type ScopeStatus,
 } from "../../services/plugin-manager.js";
 import {
 	setMcpEnvVar,
@@ -605,10 +608,10 @@ export function PluginsScreen() {
 
 			const buildScopeLabel = (
 				name: string,
-				scope: { enabled?: boolean; version?: string } | undefined,
+				scope: ScopeStatus | undefined,
 				desc: string,
 			) => {
-				const installed = scope?.enabled;
+				const installed = isInstalledInScope(scope);
 				const ver = scope?.version;
 				const hasUpdate =
 					ver &&
@@ -619,6 +622,10 @@ export function PluginsScreen() {
 				label += ` (${desc})`;
 				if (ver) label += ` v${ver}`;
 				if (hasUpdate) label += ` → v${latestVersion}`;
+				// Enabled in settings with nothing installed. Without saying so the
+				// row reads exactly like a scope that was never enabled, and the
+				// user cannot tell that picking it repairs rather than adds.
+				if (!installed && scope?.enabled) label += " — not installed, repairs";
 				return label;
 			};
 
@@ -650,8 +657,6 @@ export function PluginsScreen() {
 					: scopeValue === "project"
 						? plugin.projectScope
 						: plugin.localScope;
-			const isInstalledInScope = selectedScope?.enabled;
-			const installedVersion = selectedScope?.version;
 			const scopeLabel =
 				scopeValue === "user"
 					? "User"
@@ -659,20 +664,9 @@ export function PluginsScreen() {
 						? "Project"
 						: "Local";
 
-			const hasUpdateInScope =
-				isInstalledInScope &&
-				installedVersion &&
-				latestVersion !== "0.0.0" &&
-				installedVersion !== latestVersion;
-
-			let action: "update" | "install" | "uninstall";
-			if (isInstalledInScope && hasUpdateInScope) {
-				action = "update";
-			} else if (isInstalledInScope) {
-				action = "uninstall";
-			} else {
-				action = "install";
-			}
+			// Decided from the registry-backed version, not the `enabledPlugins`
+			// flag alone — see resolveScopeAction.
+			const action = resolveScopeAction(selectedScope, latestVersion);
 
 			try {
 				const scope = scopeValue as PluginScope;
@@ -843,23 +837,12 @@ export function PluginsScreen() {
 				: scope === "project"
 					? plugin.projectScope
 					: plugin.localScope;
-		const isInstalledInScope = scopeData?.enabled;
-		const installedVersion = scopeData?.version;
-
-		const hasUpdateInScope =
-			isInstalledInScope &&
-			installedVersion &&
-			latestVersion !== "0.0.0" &&
-			installedVersion !== latestVersion;
-
-		let action: "update" | "install" | "uninstall";
-		if (isInstalledInScope && hasUpdateInScope) {
-			action = "update";
-		} else if (isInstalledInScope) {
-			action = "uninstall";
-		} else {
-			action = "install";
-		}
+
+		// This used to key off `scopeData.enabled` alone, so a plugin the list
+		// had just labelled "not installed" answered its own scope key by
+		// uninstalling itself — the `enabledPlugins` flag was set, the registry
+		// entry was missing, and only the flag was consulted.
+		const action = resolveScopeAction(scopeData, latestVersion);
 
 		try {
 			if (action === "uninstall") {