claudeup 4.23.0 → 4.24.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeup",
-  "version": "4.23.0",
+  "version": "4.24.0",
   "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.23.0",
-    "claudeup-darwin-x64": "4.23.0",
-    "claudeup-linux-x64": "4.23.0"
+    "claudeup-darwin-arm64": "4.24.0",
+    "claudeup-darwin-x64": "4.24.0",
+    "claudeup-linux-x64": "4.24.0"
   }
 }

package/src/__tests__/enabled-not-installed.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, test } from "bun:test";
+import { isEnabledButNotInstalled } from "../services/plugin-manager.js";
+import type { PluginInfo } from "../services/plugin-manager.js";
+
+/**
+ * "Enabled but not installed" is a broken state that previously rendered
+ * identically to a healthy install: a green scope square and no version.
+ *
+ * It is also invisible to every update path, because the check is
+ * `installedVersion && compare(latest, installedVersion) > 0` — with no
+ * installed version that is false, so neither the update list nor the
+ * prerunner's auto-update will ever touch it.
+ */
+
+const plugin = (over: Partial<PluginInfo>): PluginInfo =>
+  ({
+    id: "x@magus",
+    name: "x",
+    version: "1.0.0",
+    description: "",
+    marketplace: "magus",
+    marketplaceDisplay: "Magus",
+    enabled: true,
+    ...over,
+  }) as PluginInfo;
+
+describe("isEnabledButNotInstalled", () => {
+  test("enabled in project scope with no installed version is flagged", () => {
+    // The real case: terminal/code-analysis are in this project's enabledPlugins
+    // but have no registry entry for it and none at user scope.
+    expect(
+      isEnabledButNotInstalled(
+        plugin({ projectScope: { enabled: true }, installedVersion: undefined }),
+      ),
+    ).toBe(true);
+  });
+
+  test("a healthy install is not flagged", () => {
+    expect(
+      isEnabledButNotInstalled(
+        plugin({ projectScope: { enabled: true }, installedVersion: "1.0.0" }),
+      ),
+    ).toBe(false);
+  });
+
+  test('installedVersion "0.0.0" means installed-with-unknown-version, not missing', () => {
+    // Anthropic's official plugins record exactly this. Treating it as missing
+    // would mislabel every one of them as broken.
+    expect(
+      isEnabledButNotInstalled(
+        plugin({ userScope: { enabled: true }, installedVersion: "0.0.0" }),
+      ),
+    ).toBe(false);
+  });
+
+  test("not enabled anywhere is not flagged — it is simply available", () => {
+    expect(isEnabledButNotInstalled(plugin({ installedVersion: undefined }))).toBe(false);
+  });
+
+  test("orphaned plugins are excluded — they have their own 'deprecated' state", () => {
+    expect(
+      isEnabledButNotInstalled(
+        plugin({
+          isOrphaned: true,
+          projectScope: { enabled: true },
+          installedVersion: undefined,
+        }),
+      ),
+    ).toBe(false);
+  });
+
+  test("any enabled scope counts, not just project", () => {
+    for (const scope of ["userScope", "projectScope", "localScope"] as const) {
+      expect(
+        isEnabledButNotInstalled(plugin({ [scope]: { enabled: true } })),
+      ).toBe(true);
+    }
+  });
+
+  test("a scope present but disabled does not count as enabled", () => {
+    expect(
+      isEnabledButNotInstalled(
+        plugin({ projectScope: { enabled: false }, installedVersion: undefined }),
+      ),
+    ).toBe(false);
+  });
+});

package/src/services/plugin-manager.ts

@@ -74,6 +74,30 @@ export interface PluginInfo {
 	isOrphaned?: boolean;
 }
 
+/**
+ * True when a plugin is enabled in some scope but no installed version resolves
+ * anywhere — it is listed in `enabledPlugins` but was never actually installed.
+ *
+ * This is a broken state, not a healthy one: Claude Code will not load the
+ * plugin, and because the update check is `installedVersion && compare(...)`,
+ * it is also invisible to both the update list and the prerunner's auto-update.
+ * It previously rendered identically to a working install.
+ *
+ * `isOrphaned` is a different failure — installed, but no longer offered by any
+ * marketplace — and is rendered as "deprecated" already.
+ *
+ * "0.0.0" means installed-with-unknown-version (Anthropic's official plugins
+ * record exactly that), so it must NOT count as missing.
+ */
+export function isEnabledButNotInstalled(plugin: PluginInfo): boolean {
+	if (plugin.isOrphaned) return false;
+	const enabledSomewhere =
+		!!plugin.userScope?.enabled ||
+		!!plugin.projectScope?.enabled ||
+		!!plugin.localScope?.enabled;
+	return enabledSomewhere && !plugin.installedVersion;
+}
+
 
 export async function getAvailablePlugins(
 	projectPath?: string,

package/src/ui/renderers/pluginRenderers.tsx

@@ -15,6 +15,7 @@ import {
 } from "../components/primitives/index.js";
 import { theme } from "../theme.js";
 import { highlightMatches } from "../../utils/fuzzy-search.js";
+import { isEnabledButNotInstalled } from "../../services/plugin-manager.js";
 
 // ─── Category renderers ───────────────────────────────────────────────────────
 
@@ -113,10 +114,16 @@ function pluginRow(item: PluginPluginItem, isSelected: boolean): React.ReactNode
   const hasLocal = !!plugin.localScope?.enabled;
   const hasAnyScope = hasUser || hasProject || hasLocal;
 
+  // Enabled somewhere but nothing actually installed — a broken state that used
+  // to render exactly like a healthy install.
+  const notInstalled = isEnabledButNotInstalled(plugin);
+
   // Build version string — only show if plugin is installed in at least one scope
   let versionStr = "";
   if (plugin.isOrphaned) {
     versionStr = " deprecated";
+  } else if (notInstalled) {
+    versionStr = " not installed";
   } else if (hasAnyScope && plugin.installedVersion && plugin.installedVersion !== "0.0.0") {
     versionStr = ` v${plugin.installedVersion}`;
     if (plugin.hasUpdate && plugin.version) {
@@ -158,8 +165,13 @@ function pluginRow(item: PluginPluginItem, isSelected: boolean): React.ReactNode
       <span> </span>
       <ScopeSquares user={hasUser} project={hasProject} local={hasLocal} />
       <span> </span>
-      <span fg={hasAnyScope ? theme.colors.text : theme.colors.muted}>{displayName}</span>
-      <MetaText text={versionStr} tone={plugin.hasUpdate ? "warning" : "muted"} />
+      <span fg={hasAnyScope && !notInstalled ? theme.colors.text : theme.colors.muted}>
+        {displayName}
+      </span>
+      <MetaText
+        text={versionStr}
+        tone={notInstalled || plugin.hasUpdate ? "warning" : "muted"}
+      />
     </text>
   );
 }