magus-cli 0.0.0-placeholder → 7.1.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/designer/skills/ui-analyse/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/__tests__/plugin-manager-fallback.test.ts

@@ -0,0 +1,320 @@
+import {
+	afterAll,
+	beforeAll,
+	beforeEach,
+	describe,
+	expect,
+	it,
+} from "bun:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { resetGitHubBudget } from "../services/github-budget";
+import type {
+	LocalMarketplace,
+	LocalMarketplacePlugin,
+} from "../services/local-marketplace";
+import {
+	clearMarketplaceCache,
+	fetchMarketplacePlugins,
+	getMarketplaceFetchFailures,
+	resolveMarketplacePlugins,
+} from "../services/marketplace-fetcher";
+
+/**
+ * Point the marketplace-clone lookup at an EMPTY temp directory.
+ *
+ * `resolveMarketplacePlugins` now consults a git remote ref before falling back
+ * to the checked-out clone. Without this, these tests found the operator's real
+ * `magus` clone, performed a live `git fetch`, and asserted against whatever
+ * happened to be published — 17 real plugins instead of the 2 in the fixture, and
+ * three seconds per test.
+ */
+let prevConfigDir: string | undefined;
+let emptyConfigDir: string;
+
+beforeAll(() => {
+	emptyConfigDir = fs.mkdtempSync(path.join(os.tmpdir(), "mp-fallback-"));
+	prevConfigDir = process.env.CLAUDE_CONFIG_DIR;
+	process.env.CLAUDE_CONFIG_DIR = emptyConfigDir;
+});
+
+afterAll(() => {
+	// biome-ignore lint/performance/noDelete: assigning undefined to process.env stores the string "undefined"; only delete unsets the variable
+	if (prevConfigDir === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+	else process.env.CLAUDE_CONFIG_DIR = prevConfigDir;
+	fs.rmSync(emptyConfigDir, { recursive: true, force: true });
+});
+
+/**
+ * Regression coverage for the "deprecated everything" bug.
+ *
+ * When `fetchMarketplacePlugins` returns an empty list (network down,
+ * repo moved, GitHub blocked, etc.), the orphan-detection loop in
+ * `getAvailablePlugins` would flag every installed plugin as
+ * `isOrphaned: true` and the UI rendered them all as "deprecated".
+ *
+ * `resolveMarketplacePlugins` adds the local-marketplace cache as a
+ * fallback so installed plugins keep rendering with their real metadata
+ * even when the machine is offline.
+ */
+
+function buildLocalMarketplace(
+	name: string,
+	plugins: LocalMarketplacePlugin[],
+): LocalMarketplace {
+	return { name, description: "", plugins };
+}
+
+describe("resolveMarketplacePlugins — offline fallback", () => {
+	beforeEach(() => {
+		// Session-level cache could otherwise carry over a previous test's
+		// successful fetch and short-circuit the fallback path.
+		clearMarketplaceCache();
+		// The per-host cooldown is deliberately NOT cleared by clearMarketplaceCache
+		// — it reflects GitHub's state, not ours — so a 429 in one test would
+		// otherwise gate every fetch in the next for the full backoff.
+		resetGitHubBudget();
+	});
+
+	it("falls back to the local cache when the remote fetch returns empty", async () => {
+		const local = new Map<string, LocalMarketplace>([
+			[
+				"magus",
+				buildLocalMarketplace("magus", [
+					{
+						name: "code-search",
+						version: "5.3.0",
+						description: "Codebase investigation tools",
+						category: "development",
+						author: { name: "Jack Rudenko" },
+					},
+					{
+						name: "dev",
+						version: "2.7.0",
+						description: "Dev workflow",
+					},
+				]),
+			],
+		]);
+
+		// An invalid repo string short-circuits `fetchMarketplacePlugins` to
+		// `[]` without any network call, simulating the offline case.
+		const resolved = await resolveMarketplacePlugins(
+			"magus",
+			"not a valid repo string",
+			local,
+		);
+
+		expect(resolved.plugins).toHaveLength(2);
+		expect(resolved.plugins.map((p) => p.name).sort()).toEqual([
+			"code-search",
+			"dev",
+		]);
+		const codeAnalysis = resolved.plugins.find((p) => p.name === "code-search");
+		expect(codeAnalysis?.version).toBe("5.3.0");
+		expect(codeAnalysis?.description).toBe("Codebase investigation tools");
+		expect(codeAnalysis?.category).toBe("development");
+		expect(codeAnalysis?.author?.name).toBe("Jack Rudenko");
+	});
+
+	it("labels the fallback answer as local-clone, not remote", async () => {
+		// The regression this guards: the fallback plugins were returned in the
+		// same shape as a successful remote fetch, so the caller compared installed
+		// versions against a clone nothing refreshes and reported "up to date".
+		// The source must travel with the data.
+		const local = new Map<string, LocalMarketplace>([
+			[
+				"magus",
+				buildLocalMarketplace("magus", [
+					{ name: "terminal", version: "4.1.4", description: "" },
+				]),
+			],
+		]);
+		const resolved = await resolveMarketplacePlugins(
+			"magus",
+			"not a valid repo string",
+			local,
+		);
+
+		expect(resolved.source).toBe("local-clone");
+		expect(resolved.failure).toBeDefined();
+		expect(resolved.failure?.kind).toBe("invalid-repo");
+		expect(resolved.failure?.marketplace).toBe("magus");
+	});
+
+	it("returns empty when both remote and cache are empty", async () => {
+		const local = new Map<string, LocalMarketplace>();
+		const resolved = await resolveMarketplacePlugins(
+			"magus",
+			"not a valid repo string",
+			local,
+		);
+		expect(resolved.plugins).toEqual([]);
+		expect(resolved.source).toBe("none");
+		expect(resolved.failure).toBeDefined();
+	});
+
+	it("returns empty when remote fails AND cache exists but has no plugins", async () => {
+		const local = new Map<string, LocalMarketplace>([
+			["magus", buildLocalMarketplace("magus", [])],
+		]);
+		const resolved = await resolveMarketplacePlugins(
+			"magus",
+			"not a valid repo string",
+			local,
+		);
+		expect(resolved.plugins).toEqual([]);
+		expect(resolved.source).toBe("none");
+	});
+
+	it("does not consult the cache when the remote returns plugins", async () => {
+		// We can't easily exercise the success branch without a live network,
+		// but we can verify that a cache entry for a DIFFERENT marketplace
+		// doesn't bleed into the requested one.
+		const local = new Map<string, LocalMarketplace>([
+			[
+				"other-marketplace",
+				buildLocalMarketplace("other-marketplace", [
+					{ name: "should-not-leak", version: "0.0.1", description: "" },
+				]),
+			],
+		]);
+		const resolved = await resolveMarketplacePlugins(
+			"magus",
+			"not a valid repo string",
+			local,
+		);
+		expect(resolved.plugins).toEqual([]);
+		expect(resolved.source).toBe("none");
+	});
+});
+
+/**
+ * The defect class these cover: a failed check that renders as a passed one.
+ *
+ * `fetchMarketplacePlugins` used to return `[]` for a rate limit, a timeout, a
+ * bad repo string and a genuinely empty marketplace alike. Every caller then had
+ * to guess, and all of them guessed "fine".
+ */
+describe("fetchMarketplacePlugins — failures are values", () => {
+	beforeEach(() => {
+		clearMarketplaceCache();
+		resetGitHubBudget();
+	});
+
+	it("classifies a rate limit distinctly from a network problem", async () => {
+		const original = globalThis.fetch;
+		globalThis.fetch = (async () =>
+			new Response("rate limited", {
+				status: 429,
+				statusText: "Too Many Requests",
+			})) as typeof globalThis.fetch;
+		try {
+			const result = await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+			expect(result.plugins).toEqual([]);
+			expect(result.failure?.kind).toBe("rate-limited");
+			expect(result.failure?.httpStatus).toBe(429);
+			expect(result.failure?.detail).toContain("rate limit");
+		} finally {
+			globalThis.fetch = original;
+		}
+	});
+
+	it("records the failure so the UI can report it without re-fetching", async () => {
+		const original = globalThis.fetch;
+		let calls = 0;
+		globalThis.fetch = (async () => {
+			calls++;
+			return new Response("nope", { status: 500, statusText: "Server Error" });
+		}) as typeof globalThis.fetch;
+		try {
+			await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+
+			const failures = getMarketplaceFetchFailures();
+			expect(failures.map((f) => f.marketplace)).toContain("magus");
+			expect(failures.find((f) => f.marketplace === "magus")?.kind).toBe(
+				"http",
+			);
+
+			// Second call must be served from the negative cache. Re-attempting on
+			// every screen mount is what cost 30-45s of "Loading..." per tab switch.
+			await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+			expect(calls).toBe(1);
+		} finally {
+			globalThis.fetch = original;
+		}
+	});
+
+	it("reports no failures when the fetch succeeds", async () => {
+		const original = globalThis.fetch;
+		globalThis.fetch = (async () =>
+			Response.json({
+				metadata: { version: "9.0.3" },
+				plugins: [{ name: "terminal", version: "4.1.6" }],
+			})) as typeof globalThis.fetch;
+		try {
+			const result = await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+			expect(result.failure).toBeUndefined();
+			expect(result.plugins).toHaveLength(1);
+			expect(getMarketplaceFetchFailures()).toEqual([]);
+		} finally {
+			globalThis.fetch = original;
+		}
+	});
+
+	it("does not send a request while the rate-limit window is still open", async () => {
+		// Deliberate: an explicit refresh clears OUR caches but not GitHub's limit.
+		// Retrying inside a known window cannot succeed, and on some endpoints a
+		// rejected request extends the penalty — so the screen waits and counts down
+		// instead. `clearMarketplaceCache()` must not be a way around that.
+		const original = globalThis.fetch;
+		let calls = 0;
+		globalThis.fetch = (async () => {
+			calls++;
+			return new Response("nope", { status: 429 });
+		}) as typeof globalThis.fetch;
+		try {
+			await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+			expect(calls).toBe(1);
+
+			clearMarketplaceCache();
+			const second = await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+
+			expect(calls).toBe(1); // no second request went out
+			expect(second.failure?.kind).toBe("rate-limited");
+			expect(second.failure?.retryAt).toBeGreaterThan(Date.now());
+		} finally {
+			globalThis.fetch = original;
+		}
+	});
+
+	it("clears the recorded failure once the window passes and the fetch succeeds", async () => {
+		const original = globalThis.fetch;
+		globalThis.fetch = (async () =>
+			new Response("nope", { status: 429 })) as typeof globalThis.fetch;
+		try {
+			await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+			expect(getMarketplaceFetchFailures()).toHaveLength(1);
+
+			// The cooldown expiring is what unblocks the retry — this stands in for the
+			// clock reaching `retryAt`, which is when the screen refetches by itself.
+			resetGitHubBudget();
+			clearMarketplaceCache();
+			globalThis.fetch = (async () =>
+				Response.json({
+					plugins: [{ name: "terminal", version: "4.2.0" }],
+				})) as typeof globalThis.fetch;
+
+			const recovered = await fetchMarketplacePlugins(
+				"magus",
+				"MadAppGang/magus",
+			);
+			expect(recovered.failure).toBeUndefined();
+			expect(recovered.plugins).toHaveLength(1);
+			expect(getMarketplaceFetchFailures()).toEqual([]);
+		} finally {
+			globalThis.fetch = original;
+		}
+	});
+});