claudeup 4.32.0 → 4.33.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeup",
-  "version": "4.32.0",
+  "version": "4.33.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.32.0",
-    "claudeup-darwin-x64": "4.32.0",
-    "claudeup-linux-x64": "4.32.0"
+    "claudeup-darwin-arm64": "4.33.0",
+    "claudeup-darwin-x64": "4.33.0",
+    "claudeup-linux-x64": "4.33.0"
   }
 }

package/src/__tests__/mcp-registry.test.ts

@@ -0,0 +1,158 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import {
+	fetchCuratedMcpServers,
+	searchMcpServers,
+} from "../services/mcp-registry.js";
+
+const realFetch = globalThis.fetch;
+const originalApiUrl = process.env.MCP_REGISTRY_API_URL;
+
+const server = {
+	name: "io.example/filesystem",
+	url: "npm:@example/filesystem",
+	short_description: "Filesystem tools",
+	version: "1.2.3",
+	source_code_url: "https://github.com/example/filesystem",
+	package_registry: "npm",
+	published_at: "2026-08-01T00:00:00.000Z",
+};
+
+afterEach(() => {
+	globalThis.fetch = realFetch;
+	if (originalApiUrl === undefined) {
+		Reflect.deleteProperty(process.env, "MCP_REGISTRY_API_URL");
+	} else {
+		process.env.MCP_REGISTRY_API_URL = originalApiUrl;
+	}
+});
+
+describe("searchMcpServers", () => {
+	it("calls the models-index endpoint with encoded normalized parameters", async () => {
+		process.env.MCP_REGISTRY_API_URL = "";
+		let requestedUrl = "";
+		globalThis.fetch = (async (input) => {
+			requestedUrl = String(input);
+			return Response.json({ servers: [server], next_cursor: "next page" });
+		}) as typeof fetch;
+
+		const result = await searchMcpServers({
+			query: "file system & tools",
+			limit: 7,
+			cursor: "page/2?x=1",
+		});
+
+		const url = new URL(requestedUrl);
+		expect(`${url.origin}${url.pathname}`).toBe(
+			"https://us-central1-claudish-6da10.cloudfunctions.net/mcpRegistry/search",
+		);
+		expect(Object.fromEntries(url.searchParams)).toEqual({
+			q: "file system & tools",
+			limit: "7",
+			cursor: "page/2?x=1",
+		});
+		expect(result).toEqual({ servers: [server], next_cursor: "next page" });
+	});
+
+	it("uses MCP_REGISTRY_API_URL and omits an empty query", async () => {
+		process.env.MCP_REGISTRY_API_URL = "https://registry.example.test/base/";
+		let requestedUrl = "";
+		globalThis.fetch = (async (input) => {
+			requestedUrl = String(input);
+			return Response.json({ servers: [] });
+		}) as typeof fetch;
+
+		await searchMcpServers({ query: "", limit: 4 });
+
+		expect(requestedUrl).toBe(
+			"https://registry.example.test/base/search?limit=4",
+		);
+	});
+
+	it("throws on an HTTP failure", async () => {
+		globalThis.fetch = (async () =>
+			new Response("unavailable", {
+				status: 503,
+				statusText: "Service Unavailable",
+			})) as typeof fetch;
+
+		expect(searchMcpServers({ query: "filesystem" })).rejects.toThrow(
+			"MCP Registry API error: 503 Service Unavailable",
+		);
+	});
+
+	it("throws when the normalized response or a server is malformed", async () => {
+		globalThis.fetch = (async () =>
+			Response.json({
+				servers: [{ name: "missing-url", short_description: "Broken" }],
+			})) as typeof fetch;
+
+		expect(searchMcpServers()).rejects.toThrow(
+			"MCP Registry API returned a malformed response",
+		);
+	});
+
+	it("throws when the response is not valid JSON", async () => {
+		globalThis.fetch = (async () =>
+			new Response("not json", {
+				status: 200,
+				headers: { "content-type": "application/json" },
+			})) as typeof fetch;
+
+		expect(searchMcpServers()).rejects.toThrow(
+			"MCP Registry API returned a malformed response",
+		);
+	});
+
+	it("passes the caller abort signal to fetch", async () => {
+		const controller = new AbortController();
+		let receivedSignal: AbortSignal | null | undefined;
+		globalThis.fetch = (async (_input, init) => {
+			receivedSignal = init?.signal;
+			return Response.json({ servers: [] });
+		}) as typeof fetch;
+
+		await searchMcpServers({ signal: controller.signal });
+
+		expect(receivedSignal).toBe(controller.signal);
+	});
+});
+
+describe("fetchCuratedMcpServers", () => {
+	it("loads install-ready configurations from models-index", async () => {
+		process.env.MCP_REGISTRY_API_URL = "https://catalog.example.test/";
+		let requestedUrl = "";
+		globalThis.fetch = (async (input) => {
+			requestedUrl = String(input);
+			return Response.json({
+				schemaVersion: 1,
+				version: 2,
+				servers: [
+					{
+						name: "memory",
+						description: "Persistent memory",
+						command: "npx",
+						args: ["-y", "@modelcontextprotocol/server-memory@latest"],
+						category: "productivity",
+					},
+				],
+			});
+		}) as typeof fetch;
+
+		const result = await fetchCuratedMcpServers();
+		expect(requestedUrl).toBe("https://catalog.example.test/recommended");
+		expect(result).toHaveLength(1);
+		expect(result[0].name).toBe("memory");
+	});
+
+	it("rejects malformed install configurations", async () => {
+		globalThis.fetch = (async () =>
+			Response.json({
+				servers: [
+					{ name: "missing-command", description: "Broken", category: "ai" },
+				],
+			})) as typeof fetch;
+		expect(fetchCuratedMcpServers()).rejects.toThrow(
+			"MCP catalog API returned a malformed response",
+		);
+	});
+});

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/__tests__/skills-catalog-client.test.ts

@@ -0,0 +1,48 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { fetchCuratedSkillsCatalog } from "../services/skillsmp-client.js";
+
+const realFetch = globalThis.fetch;
+
+afterEach(() => {
+	globalThis.fetch = realFetch;
+});
+
+describe("fetchCuratedSkillsCatalog", () => {
+	it("loads the versioned models-index catalog", async () => {
+		let requestedUrl = "";
+		globalThis.fetch = (async (input) => {
+			requestedUrl = String(input);
+			return Response.json({
+				schemaVersion: 1,
+				version: 1,
+				generatedAt: "2026-08-07T00:00:00.000Z",
+				skills: [
+					{
+						name: "Find Skills",
+						repo: "vercel-labs/skills",
+						skillPath: "skills/find-skills",
+						description: "Find skills",
+						category: "search",
+					},
+				],
+				skillSets: [],
+			});
+		}) as typeof fetch;
+
+		const catalog = await fetchCuratedSkillsCatalog();
+		expect(requestedUrl).toBe(
+			"https://us-central1-claudish-6da10.cloudfunctions.net/skills/recommended",
+		);
+		expect(catalog.skills[0].skillPath).toBe("skills/find-skills");
+	});
+
+	it("rejects HTTP and malformed responses", async () => {
+		globalThis.fetch = (async () =>
+			new Response("down", { status: 503 })) as typeof fetch;
+		expect(fetchCuratedSkillsCatalog()).rejects.toThrow("HTTP 503");
+
+		globalThis.fetch = (async () =>
+			Response.json({ skills: [] })) as typeof fetch;
+		expect(fetchCuratedSkillsCatalog()).rejects.toThrow("malformed response");
+	});
+});