claudeup 4.41.0 → 4.42.0

package/src/__tests__/plugin-contents.test.ts

@@ -0,0 +1,371 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import type { PluginInfo } from "../services/plugin-manager.js";
+import {
+	fetchPluginContents,
+	splitSkillDocument,
+} from "../services/skills-manager.js";
+import type { Marketplace } from "../types/index.js";
+import {
+	buildPluginBrowserItems,
+	pluginContentsRepo,
+} from "../ui/adapters/pluginsAdapter.js";
+import type { PluginContentsEntry } from "../ui/state/types.js";
+
+// ─── fetchPluginContents ─────────────────────────────────────────────────────
+
+const realFetch = globalThis.fetch;
+
+/**
+ * Serve one canned git-tree response. `fetchGitTree` caches per repo for the
+ * life of the process, so every test must use a repo name of its own.
+ */
+function stubTree(paths: string[]): void {
+	globalThis.fetch = (async () =>
+		new Response(
+			JSON.stringify({
+				sha: "deadbeef",
+				truncated: false,
+				tree: paths.map((path) => ({
+					path,
+					mode: "100644",
+					type: "blob",
+					sha: `sha-${path}`,
+				})),
+			}),
+			{ status: 200, headers: { ETag: '"x"' } },
+		)) as unknown as typeof fetch;
+}
+
+afterEach(() => {
+	globalThis.fetch = realFetch;
+});
+
+describe("fetchPluginContents", () => {
+	it("counts a grouped skills/ tree once per skill, not once per group", async () => {
+		stubTree([
+			"README.md",
+			"skills/engineering/code-review/SKILL.md",
+			"skills/engineering/tdd/SKILL.md",
+			"skills/writing/prd/SKILL.md",
+		]);
+
+		const skills = await fetchPluginContents("fake/grouped", "./");
+
+		expect(skills.map((s) => s.name)).toEqual(["code-review", "tdd", "prd"]);
+		expect(skills.every((s) => s.kind === "skill")).toBe(true);
+		expect(skills[0].group).toBe("engineering");
+		expect(skills[2].group).toBe("writing");
+	});
+
+	it("ignores harness mirrors and translated docs trees", async () => {
+		// everything-claude-code's real shape: 286 skills under skills/, mirrored
+		// into four harness directories and six docs/<lang>/ trees for 898 files.
+		stubTree([
+			"skills/api-design/SKILL.md",
+			"skills/agent-sort/SKILL.md",
+			".agents/skills/api-design/SKILL.md",
+			".kiro/skills/api-design/SKILL.md",
+			".cursor/skills/api-design/SKILL.md",
+			"docs/ja-JP/skills/api-design/SKILL.md",
+			"docs/zh-CN/skills/api-design/SKILL.md",
+		]);
+
+		const skills = await fetchPluginContents("fake/mirrored", "./");
+
+		expect(skills.map((s) => s.name)).toEqual(["agent-sort", "api-design"]);
+	});
+
+	it("finds a plugin that is one skill at its root", async () => {
+		// blader/humanizer: a root SKILL.md and no skills/ directory at all.
+		stubTree([".claude-plugin/plugin.json", "SKILL.md", "README.md"]);
+
+		const skills = await fetchPluginContents("blader/humanizer", "./");
+
+		expect(skills).toHaveLength(1);
+		expect(skills[0].name).toBe("humanizer");
+		expect(skills[0].repoPath).toBe("SKILL.md");
+	});
+
+	it("scopes to one plugin's subtree in a multi-plugin marketplace", async () => {
+		stubTree([
+			"plugins/dev/skills/frontend/design-system/SKILL.md",
+			"plugins/dev/skills/backend/db-branching/SKILL.md",
+			"plugins/seo/skills/audit/SKILL.md",
+		]);
+
+		const skills = await fetchPluginContents("fake/multi", "./plugins/dev");
+
+		expect(skills.map((s) => s.name)).toEqual([
+			"db-branching",
+			"design-system",
+		]);
+	});
+
+	it("still lists commands and agents for a plugin with no skills", async () => {
+		stubTree(["agents/reviewer.md", "commands/go.md"]);
+
+		const found = await fetchPluginContents("fake/no-skills", "./");
+
+		expect(found.filter((c) => c.kind === "skill")).toEqual([]);
+		expect(found.map((c) => `${c.kind}:${c.name}`)).toEqual([
+			"command:go",
+			"agent:reviewer",
+		]);
+	});
+});
+
+// ─── splitSkillDocument ──────────────────────────────────────────────────────
+
+describe("splitSkillDocument", () => {
+	it("keeps frontmatter in file order so description stays near the top", () => {
+		const { frontmatter } = splitSkillDocument(
+			[
+				"---",
+				"name: code-review",
+				"description: Reviews a diff for correctness",
+				"allowed-tools: Read, Grep",
+				"---",
+				"",
+				"# Code review",
+			].join("\n"),
+		);
+
+		expect(frontmatter.map((f) => f.key)).toEqual([
+			"name",
+			"description",
+			"allowed-tools",
+		]);
+		expect(frontmatter[1].value).toBe("Reviews a diff for correctness");
+	});
+
+	it("flattens both list shapes to one display string", () => {
+		const { frontmatter } = splitSkillDocument(
+			[
+				"---",
+				'tags: ["tdd", "testing"]',
+				"allowed-tools:",
+				"  - Read",
+				"  - Bash",
+				"---",
+				"body",
+			].join("\n"),
+		);
+
+		expect(frontmatter[0]).toEqual({ key: "tags", value: "tdd, testing" });
+		expect(frontmatter[1]).toEqual({
+			key: "allowed-tools",
+			value: "Read, Bash",
+		});
+	});
+
+	it("separates the body and counts its lines", () => {
+		const doc = splitSkillDocument(
+			["---", "name: x", "---", "", "# Title", "", "Body text.", ""].join("\n"),
+		);
+
+		expect(doc.body).toBe("# Title\n\nBody text.");
+		expect(doc.bodyLines).toBe(3);
+	});
+
+	it("treats a file with no frontmatter as all body", () => {
+		const doc = splitSkillDocument("# Just markdown\n\nNo frontmatter here.");
+
+		expect(doc.frontmatter).toEqual([]);
+		expect(doc.body).toBe("# Just markdown\n\nNo frontmatter here.");
+	});
+
+	it("reports an empty body rather than a phantom line", () => {
+		const doc = splitSkillDocument("---\nname: x\ndescription: y\n---\n");
+
+		expect(doc.body).toBe("");
+		expect(doc.bodyLines).toBe(0);
+	});
+});
+
+// ─── buildPluginBrowserItems ─────────────────────────────────────────────────
+
+const marketplace: Marketplace = {
+	name: "mattpocock",
+	displayName: "Matt Pocock",
+	source: { source: "github", repo: "mattpocock/skills" },
+	description: "Agent skills for real engineering",
+	featured: true,
+};
+
+function makePlugin(overrides: Partial<PluginInfo> = {}): PluginInfo {
+	return {
+		id: "mattpocock-skills@mattpocock",
+		name: "mattpocock-skills",
+		version: "1.0.0",
+		description: "Matt Pocock's agent skills",
+		marketplace: "mattpocock",
+		marketplaceDisplay: "Matt Pocock",
+		enabled: false,
+		source: "./",
+		...overrides,
+	};
+}
+
+function build(
+	plugin: PluginInfo,
+	expandedPlugins: Set<string>,
+	pluginContents: Map<string, PluginContentsEntry> = new Map(),
+) {
+	return buildPluginBrowserItems({
+		marketplaces: [marketplace],
+		plugins: [plugin],
+		collapsedMarketplaces: new Set(),
+		expandedPlugins,
+		pluginContents,
+	});
+}
+
+describe("buildPluginBrowserItems component rows", () => {
+	it("marks a plugin expandable and emits no component rows while collapsed", () => {
+		const items = build(makePlugin(), new Set());
+
+		expect(items.map((i) => i.kind)).toEqual(["category", "plugin"]);
+		const row = items[1];
+		expect(row.kind === "plugin" && row.isExpandable).toBe(true);
+		expect(row.kind === "plugin" && row.isExpanded).toBe(false);
+	});
+
+	it("emits one row per component when expanded, of every kind", () => {
+		const items = build(
+			makePlugin(),
+			new Set(["mattpocock-skills@mattpocock"]),
+			new Map([
+				[
+					"mattpocock-skills@mattpocock",
+					{
+						status: "success",
+						components: [
+							{
+								kind: "skill",
+								name: "code-review",
+								repoPath: "skills/engineering/code-review/SKILL.md",
+								group: "engineering",
+							},
+							{ kind: "command", name: "go", repoPath: "commands/go.md" },
+							{ kind: "agent", name: "critic", repoPath: "agents/critic.md" },
+							{ kind: "mcp", name: "mnemex", repoPath: ".mcp.json" },
+						],
+					} satisfies PluginContentsEntry,
+				],
+			]),
+		);
+
+		expect(items.map((i) => i.kind)).toEqual([
+			"category",
+			"plugin",
+			"component",
+			"component",
+			"component",
+			"component",
+		]);
+		expect(items.slice(2).map((i) => i.label)).toEqual([
+			"code-review",
+			"go",
+			"critic",
+			"mnemex",
+		]);
+	});
+
+	it("gives an MCP-only plugin a row instead of rendering it as empty", () => {
+		// mnemex: no skills, no commands, no agents, one server. It used to show
+		// nothing at all, which read as a plugin that ships nothing.
+		const items = build(
+			makePlugin({ id: "mnemex@magus", name: "mnemex" }),
+			new Set(["mnemex@magus"]),
+			new Map([
+				[
+					"mnemex@magus",
+					{
+						status: "success",
+						components: [
+							{
+								kind: "mcp",
+								name: "mnemex",
+								repoPath: ".mcp.json",
+								mcpCommand: "mnemex --mcp",
+							},
+						],
+					} satisfies PluginContentsEntry,
+				],
+			]),
+		);
+
+		expect(items[2].kind).toBe("component");
+		expect(items[2].label).toBe("mnemex");
+	});
+
+	it("shows a loading row before the listing arrives", () => {
+		const items = build(
+			makePlugin(),
+			new Set(["mattpocock-skills@mattpocock"]),
+		);
+
+		expect(items[2].kind).toBe("contents-status");
+		expect(items[2].kind === "contents-status" && items[2].status).toBe(
+			"loading",
+		);
+	});
+
+	it("surfaces a failed listing instead of rendering an empty expansion", () => {
+		const items = build(
+			makePlugin(),
+			new Set(["mattpocock-skills@mattpocock"]),
+			new Map([
+				[
+					"mattpocock-skills@mattpocock",
+					{
+						status: "error",
+						error: "GitHub API rate limit exceeded",
+					} satisfies PluginContentsEntry,
+				],
+			]),
+		);
+
+		expect(items[2].kind === "contents-status" && items[2].status).toBe(
+			"error",
+		);
+		expect(items[2].kind === "contents-status" && items[2].error).toBe(
+			"GitHub API rate limit exceeded",
+		);
+	});
+
+	it("does not offer expansion for an orphaned plugin", () => {
+		const items = build(makePlugin({ isOrphaned: true }), new Set());
+
+		expect(items[1].kind === "plugin" && items[1].isExpandable).toBe(false);
+	});
+
+	it("does not offer expansion when the marketplace has no repo to read", () => {
+		const items = buildPluginBrowserItems({
+			marketplaces: [
+				{ ...marketplace, source: { source: "directory", repo: undefined } },
+			],
+			plugins: [makePlugin()],
+			collapsedMarketplaces: new Set(),
+			expandedPlugins: new Set(),
+			pluginContents: new Map(),
+		});
+
+		expect(items[1].kind === "plugin" && items[1].isExpandable).toBe(false);
+	});
+});
+
+describe("pluginContentsRepo", () => {
+	it("prefers a plugin's own repo over its marketplace's", () => {
+		const plugin = makePlugin({ sourceRepo: "addyosmani/agent-skills" });
+		expect(pluginContentsRepo(plugin, marketplace)).toBe(
+			"addyosmani/agent-skills",
+		);
+	});
+
+	it("falls back to the marketplace repo", () => {
+		expect(pluginContentsRepo(makePlugin(), marketplace)).toBe(
+			"mattpocock/skills",
+		);
+	});
+});

package/src/data/marketplaces.ts

@@ -161,6 +161,28 @@ export const defaultMarketplaces: Marketplace[] = [
 			"Designs and redesigns frontend UI and marketing graphics, routing to specialist skills per artifact type",
 		featured: true,
 	},
+	// A community port, deliberately, because the original cannot be installed.
+	// pstack is published by Cursor in cursor/plugins, whose manifests all live
+	// under `.cursor-plugin/` — measured over the whole tree: 61 `.cursor-plugin`
+	// files, 0 `.claude-plugin` files. Claude Code reads
+	// `.claude-plugin/marketplace.json` only, so `claude plugin marketplace add
+	// cursor/plugins` cannot resolve it. Same reason github/spec-kit is absent.
+	//
+	// Of the ports that relocate the manifest, this is the most starred: 95
+	// against pstack-claude's 94. backnotprop/pstack has more (140) but carries
+	// no Claude manifest either, and peadar/pstack (261) is an unrelated C
+	// stack-trace tool.
+	{
+		name: "open-pstack",
+		displayName: "pstack",
+		source: {
+			source: "github",
+			repo: "ericlitman/open-pstack",
+		},
+		description:
+			"Rigorous, parallelizable agent workflows that favour going deep before going fast. Community port of Cursor's pstack",
+		featured: true,
+	},
 	{
 		name: "claude-code-plugins",
 		displayName: "Anthropic Deprecated",

package/src/services/local-marketplace.ts

@@ -1,7 +1,7 @@
-import fs from "fs-extra";
-import path from "node:path";
-import os from "node:os";
 import { execSync } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+import fs from "fs-extra";
 import type { PluginRelease } from "../types/index.js";
 import { normalizeReleases } from "./plugin-releases.js";
 
@@ -43,6 +43,18 @@ const KNOWN_MARKETPLACES_FILE = path.join(
 	"known_marketplaces.json",
 );
 
+/**
+ * Where Claude Code keeps a marketplace's clone, whether or not it exists.
+ *
+ * Exported so a reader can prefer the clone over the network. Anything already
+ * added is on disk in full, and reading it costs no GitHub request — which
+ * matters because an unauthenticated client gets 60 an hour for every repo on
+ * screen combined.
+ */
+export function getMarketplaceClonePath(marketplaceName: string): string {
+	return path.join(CLAUDE_PLUGINS_DIR, marketplaceName);
+}
+
 interface KnownMarketplaceEntry {
 	source: { source: string; url?: string; repo?: string };
 	installLocation: string;
@@ -97,6 +109,99 @@ function getGitRemote(marketplacePath: string): string | undefined {
 /**
  * Scan a single marketplace directory and return marketplace info
  */
+/**
+ * Names of the skills under `skillsDir`, recursing through grouping directories.
+ *
+ * A skill is a directory holding a SKILL.md, and it may sit one or more levels
+ * down: dev groups its 43 skills under `skills/frontend/`, `skills/backend/`
+ * and so on, and mattpocock groups its 37 under `skills/engineering/`. Reading
+ * only the top level counted the *groups* — dev reported 9 skills against 43 on
+ * disk, mattpocock 5 against 37 — and that count is what the plugin detail
+ * panel prints.
+ *
+ * Depth is capped because this runs over every plugin of every cloned
+ * marketplace on each list load, and a skill nested four levels below `skills/`
+ * does not exist in practice.
+ */
+export async function scanSkillDirs(
+	skillsDir: string,
+	depth = 0,
+): Promise<string[]> {
+	if (depth > 3) return [];
+	if (!(await fs.pathExists(skillsDir))) return [];
+
+	let entries: import("node:fs").Dirent[];
+	try {
+		entries = await fs.readdir(skillsDir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+
+	const found: string[] = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const child = path.join(skillsDir, entry.name);
+		if (await fs.pathExists(path.join(child, "SKILL.md"))) {
+			found.push(entry.name);
+		} else {
+			found.push(...(await scanSkillDirs(child, depth + 1)));
+		}
+	}
+	return found;
+}
+
+/**
+ * Names of the MCP servers a plugin declares.
+ *
+ * Two locations are in use, and only one of them used to be read. An
+ * `mcp-servers/` directory of one JSON per server was the only thing scanned;
+ * a root `.mcp.json`, which is the form `plugin.json` points at with
+ * `"mcpServers": "./.mcp.json"`, was invisible. In this marketplace that is 5
+ * plugins of 7, mnemex among them — and mnemex ships *nothing else*, so it
+ * reported zero components of every kind and read as an empty plugin.
+ *
+ * Inside `.mcp.json`, both a bare `{ "<name>": {...} }` map and the
+ * `{ "mcpServers": {...} }` wrapper appear in the wild.
+ */
+export async function scanMcpServers(pluginPath: string): Promise<string[]> {
+	const found: string[] = [];
+
+	const mcpDir = path.join(pluginPath, "mcp-servers");
+	if (await fs.pathExists(mcpDir)) {
+		try {
+			const files = await fs.readdir(mcpDir);
+			found.push(
+				...files
+					.filter((f) => f.endsWith(".json"))
+					.map((f) => f.replace(".json", "")),
+			);
+		} catch {
+			// Ignore scan errors
+		}
+	}
+
+	const mcpFile = path.join(pluginPath, ".mcp.json");
+	if (await fs.pathExists(mcpFile)) {
+		try {
+			const raw = (await fs.readJson(mcpFile)) as Record<string, unknown>;
+			const servers =
+				raw.mcpServers && typeof raw.mcpServers === "object"
+					? (raw.mcpServers as Record<string, unknown>)
+					: raw;
+			for (const name of Object.keys(servers)) {
+				if (!found.includes(name)) found.push(name);
+			}
+		} catch {
+			// Unreadable or malformed. The file exists, so the plugin does declare a
+			// server — report one rather than dropping to zero, which is the exact
+			// "ships nothing" misreport this function exists to fix.
+			if (found.length === 0) found.push("mcp");
+		}
+	}
+
+	return found;
+}
+
 async function scanSingleMarketplace(
 	marketplacePath: string,
 	marketplaceName: string,
@@ -159,23 +264,9 @@ async function scanSingleMarketplace(
 								.map((f) => f.replace(".md", ""));
 						}
 						// Scan for skills
-						const skillsDir = path.join(pluginPath, "skills");
-						if (await fs.pathExists(skillsDir)) {
-							const skillFiles = await fs.readdir(skillsDir);
-							skills = skillFiles.filter(
-								(f) =>
-									f.endsWith(".md") ||
-									fs.statSync(path.join(skillsDir, f)).isDirectory(),
-							);
-						}
+						skills = await scanSkillDirs(path.join(pluginPath, "skills"));
 						// Scan for MCP servers
-						const mcpDir = path.join(pluginPath, "mcp-servers");
-						if (await fs.pathExists(mcpDir)) {
-							const mcpFiles = await fs.readdir(mcpDir);
-							mcpServers = mcpFiles
-								.filter((f) => f.endsWith(".json"))
-								.map((f) => f.replace(".json", ""));
-						}
+						mcpServers = await scanMcpServers(pluginPath);
 					} catch {
 						// Ignore scan errors
 					}

package/src/services/marketplace-catalog.ts

@@ -26,6 +26,17 @@ export interface MarketplacePlugin {
 	homepage?: string;
 	tags?: string[];
 	releases?: PluginRelease[];
+	/**
+	 * The plugin's directory inside the marketplace repo, as declared. "" means
+	 * the repo root, which is how every single-plugin marketplace publishes
+	 * ("source": "./").
+	 */
+	source?: string;
+	/**
+	 * Set only when the plugin declares an object source naming a repo other
+	 * than the marketplace's own. Its files live there, not in the marketplace.
+	 */
+	sourceRepo?: string;
 }
 
 // Session-level cache for each marketplace's declared version (from
@@ -58,6 +69,28 @@ interface RawPlugin {
 	homepage?: string;
 	tags?: string[];
 	releases?: unknown;
+	source?: string | { source?: string; repo?: string };
+}
+
+/**
+ * Split a manifest `source` into a repo-relative directory and, when the plugin
+ * points at a different repo than the marketplace, that repo.
+ *
+ * Both forms are in use: a string path ("./", "./plugins/dev") and an object
+ * ({"source":"github","repo":"owner/name"}), which addyosmani/agent-skills
+ * publishes. The object form has no path — the plugin is the whole repo.
+ */
+function splitSource(source: RawPlugin["source"]): {
+	source?: string;
+	sourceRepo?: string;
+} {
+	if (typeof source === "string") {
+		return { source: source.replace(/^\.\//, "").replace(/\/+$/, "") };
+	}
+	if (source && typeof source === "object" && typeof source.repo === "string") {
+		return { source: "", sourceRepo: source.repo };
+	}
+	return {};
 }
 
 /** Parse a `marketplace.json` payload into plugin entries. */
@@ -87,6 +120,7 @@ export function normalizeCatalogJson(
 				homepage: plugin.homepage,
 				tags: plugin.tags,
 				releases: normalizeReleases(plugin.releases),
+				...splitSource(plugin.source),
 			});
 		}
 	}