claudeup 4.32.1 → 4.33.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeup",
-  "version": "4.32.1",
+  "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.1",
-    "claudeup-darwin-x64": "4.32.1",
-    "claudeup-linux-x64": "4.32.1"
+    "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__/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");
+	});
+});