claudeup 4.22.0 → 4.24.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeup",
-  "version": "4.22.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.22.0",
-    "claudeup-darwin-x64": "4.22.0",
-    "claudeup-linux-x64": "4.22.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/__tests__/marketplace-badge.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, test } from "bun:test";
+import { buildPluginBrowserItems } from "../ui/adapters/pluginsAdapter.js";
+import type { Marketplace } from "../types/index.js";
+
+/**
+ * The marketplace category badge is the line users read on every claudeup launch,
+ * and it had no coverage. The MadAppGang byline must not leak onto anyone else's
+ * marketplace, and the Official/Deprecated markers must still win.
+ */
+
+const mp = (over: Partial<Marketplace> & { name: string }): Marketplace => ({
+  displayName: over.displayName ?? over.name,
+  source: { source: "github", repo: `someone/${over.name}` },
+  description: "",
+  ...over,
+});
+
+/** Badge for a marketplace when it has plugins and is expanded. */
+function badgeFor(marketplace: Marketplace): string | undefined {
+  const items = buildPluginBrowserItems({
+    marketplaces: [marketplace],
+    plugins: [
+      {
+        id: `demo@${marketplace.name}`,
+        name: "demo",
+        marketplace: marketplace.name,
+        // Only the fields the adapter groups on matter here.
+      } as never,
+    ],
+    collapsedMarketplaces: new Set(),
+  });
+  const category = items.find((i) => i.kind === "category");
+  return category && "badge" in category ? category.badge : undefined;
+}
+
+describe("marketplace category badge", () => {
+  test("MadAppGang marketplaces carry the byline instead of a generic label", () => {
+    for (const name of ["magus", "magus-marketing", "magus-alpha"]) {
+      const badge = badgeFor(
+        mp({ name, source: { source: "github", repo: `MadAppGang/${name}` } }),
+      );
+      expect(badge).toBe("made with ❤️ by MadAppGang");
+    }
+  });
+
+  test("owner match is case-insensitive", () => {
+    // The npm/GitHub casing of the org has varied in config; don't depend on it.
+    const badge = badgeFor(
+      mp({ name: "magus", source: { source: "github", repo: "madappgang/magus" } }),
+    );
+    expect(badge).toBe("made with ❤️ by MadAppGang");
+  });
+
+  test("someone else's marketplace does NOT claim the byline", () => {
+    const badge = badgeFor(
+      mp({
+        name: "superpowers-marketplace",
+        source: { source: "github", repo: "obra/superpowers-marketplace" },
+      }),
+    );
+    expect(badge).toBe("✓ Added");
+  });
+
+  test("a repo merely containing 'madappgang' downstream does not match", () => {
+    // Guards against a substring check — only the owner segment counts.
+    const badge = badgeFor(
+      mp({ name: "impostor", source: { source: "github", repo: "evil/madappgang-magus" } }),
+    );
+    expect(badge).toBe("✓ Added");
+  });
+
+  test("Official and Deprecated still take precedence", () => {
+    expect(
+      badgeFor(
+        mp({
+          name: "claude-plugins-official",
+          source: { source: "github", repo: "anthropics/claude-plugins-official" },
+        }),
+      ),
+    ).toBe("★ Official");
+
+    expect(
+      badgeFor(
+        mp({
+          name: "claude-code-plugins",
+          source: { source: "github", repo: "anthropics/claude-code" },
+        }),
+      ),
+    ).toBe("⚠ Deprecated");
+  });
+});

package/src/__tests__/resolver.test.ts

@@ -86,10 +86,10 @@ describe("resolveExtends", () => {
 			extends: "growth-marketer",
 		};
 		const merged = resolveExtends(entry);
-		// seo/nanobanana/video-editing ship on the magus-marketing channel and
+		// seo/image-generate/video-editing ship on the magus-marketing channel and
 		// pin it explicitly — they must NOT be rewritten to @magus.
 		expect(merged.plugins!["seo@magus-marketing"]).toBe("latest");
-		expect(merged.plugins!["nanobanana@magus-marketing"]).toBe("latest");
+		expect(merged.plugins!["image-generate@magus-marketing"]).toBe("latest");
 		expect(merged.plugins!["video-editing@magus-marketing"]).toBe("latest");
 		expect(merged.plugins!["seo@magus"]).toBeUndefined();
 		// Bare names still default to @magus.

package/src/data/predefined-profiles.ts

@@ -201,7 +201,7 @@ export const PREDEFINED_PROFILES: PredefinedProfile[] = [
 			"statusline",
 			"seo@magus-marketing",
 			"browser-use",
-			"nanobanana@magus-marketing",
+			"image-generate@magus-marketing",
 			"video-editing@magus-marketing",
 		],
 		anthropicPlugins: [

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/adapters/pluginsAdapter.ts

@@ -65,9 +65,22 @@ function categoryStyling(
   if (mp.official) {
     return { tone: "yellow", badge: "★ Official" };
   }
+  if (isMadAppGang(mp)) {
+    return { tone: "green", badge: "made with ❤️ by MadAppGang" };
+  }
   return { tone: "green", badge: "✓ Added" };
 }
 
+/**
+ * Our own marketplaces (magus, magus-marketing, magus-alpha) get the byline
+ * instead of the generic "Added". Matched on the repo owner rather than a list
+ * of names, so a new channel picks it up without a code change. Same idiom the
+ * marketplace sort uses to float MadAppGang entries to the top.
+ */
+function isMadAppGang(mp: Marketplace): boolean {
+  return (mp.source.repo ?? "").toLowerCase().startsWith("madappgang/");
+}
+
 /**
  * Builds the flat list of items for the PluginsScreen list panel.
  * Extracted from PluginsScreen so it can be tested independently.

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>
   );
 }