magus-cli 7.12.2 → 7.14.0

package/src/__tests__/market-r2-local-items.test.ts

@@ -0,0 +1,197 @@
+import { afterEach, expect, test } from "bun:test";
+import { mkdirSync, symlinkSync } from "node:fs";
+import { join } from "node:path";
+import type { LocalItem } from "../services/market-types.js";
+import {
+	MarketFixture,
+	SKILL,
+	sourceModule,
+	write,
+	writeJson,
+} from "./market-fixture.js";
+
+let f: MarketFixture | undefined;
+afterEach(() => {
+	f?.close();
+	f = undefined;
+});
+
+function discover(
+	world: MarketFixture,
+	companySkills: string[] = [],
+): LocalItem[] {
+	return world.value<LocalItem[]>(
+		`const {localItems}=await import(${JSON.stringify(sourceModule("services/market-local.js"))});console.log(JSON.stringify(await localItems(${JSON.stringify(world.project)},new Set(${JSON.stringify(companySkills)}))));`,
+	);
+}
+
+test("R4.1 TEST-31 absent skills roots yield no local items and create no folders", () => {
+	f = new MarketFixture(true);
+	const before = f.snapshot();
+
+	expect(discover(f)).toEqual([]);
+	expect(f.snapshot()).toEqual(before);
+});
+
+test("R4.1 TEST-31 localItems detects both scopes, distinguishes plugins, and sorts by name then scope", () => {
+	f = new MarketFixture(true);
+	const projectAlpha = f.folder("project", "alpha");
+	const userAlpha = f.folder("global", "alpha");
+	write(join(projectAlpha, "SKILL.md"), SKILL);
+	write(join(userAlpha, "SKILL.md"), SKILL);
+	const renamedPlugin = f.folder("project", "folder-label");
+	writeJson(join(renamedPlugin, ".claude-plugin", "plugin.json"), {
+		name: "beta-kit",
+		version: "1.2.3",
+	});
+	write(join(renamedPlugin, "SKILL.md"), SKILL);
+	const fallbackPlugin = f.folder("global", "gamma-kit");
+	writeJson(join(fallbackPlugin, ".claude-plugin", "plugin.json"), {
+		version: "1.0.0",
+	});
+	write(join(f.folder("global", "zeta"), "SKILL.md"), SKILL);
+	write(
+		join(f.folder("project", "not-a-skill"), "README.md"),
+		"No skill entry point\n",
+	);
+	write(join(f.project, ".claude", "skills", "regular-file"), SKILL);
+	write(join(f.home, ".claude", "skills", "wrong-config"), SKILL);
+	write(join(f.home, ".claude", "skills", "decoy", "SKILL.md"), SKILL);
+	const before = f.snapshot();
+
+	const items = discover(f);
+
+	expect(items).toEqual([
+		{ kind: "skill", name: "alpha", scope: "project", path: projectAlpha },
+		{ kind: "skill", name: "alpha", scope: "user", path: userAlpha },
+		{ kind: "plugin", name: "beta-kit", scope: "project", path: renamedPlugin },
+		{ kind: "plugin", name: "gamma-kit", scope: "user", path: fallbackPlugin },
+		{
+			kind: "skill",
+			name: "zeta",
+			scope: "user",
+			path: f.folder("global", "zeta"),
+		},
+	]);
+	expect(f.snapshot()).toEqual(before);
+});
+
+test("R4.1 TEST-32 origin copies, held-by-name skills and project profile skills are omitted, not USER namesakes", () => {
+	f = new MarketFixture(true);
+	for (const scope of ["project", "global"] as const) {
+		write(join(f.folder(scope, "company-name"), "SKILL.md"), SKILL);
+		write(join(f.folder(scope, "origin-copy"), "SKILL.md"), SKILL);
+		write(
+			join(f.folder(scope, "origin-copy"), ".magus-origin"),
+			"Even an unrecognized token excludes this copy\n",
+		);
+		write(join(f.folder(scope, "managed"), "SKILL.md"), SKILL);
+	}
+	f.profile({}, {});
+	f.active({ managed: "a".repeat(64) });
+	const unmanaged = f.folder("project", "unmanaged");
+	write(join(unmanaged, "SKILL.md"), SKILL);
+	const before = f.snapshot();
+
+	const items = discover(f, ["company-name"]);
+
+	expect(items).toEqual([
+		{
+			kind: "skill",
+			name: "managed",
+			scope: "user",
+			path: f.folder("global", "managed"),
+		},
+		{ kind: "skill", name: "unmanaged", scope: "project", path: unmanaged },
+	]);
+	expect(f.snapshot()).toEqual(before);
+});
+
+test("R4.1 TEST-32 linked directories and nonregular plugin manifests are not local items", () => {
+	f = new MarketFixture();
+	const outside = join(f.root, "outside");
+	write(join(outside, "SKILL.md"), SKILL);
+	writeJson(join(outside, ".claude-plugin", "plugin.json"), {
+		name: "outside-kit",
+	});
+	mkdirSync(join(f.project, ".claude", "skills"), { recursive: true });
+	mkdirSync(join(f.config, "skills"), { recursive: true });
+	symlinkSync(outside, f.folder("project", "linked-project"));
+	symlinkSync(outside, f.folder("global", "linked-user"));
+	const linkedManifest = join(
+		f.folder("project", "linked-manifest"),
+		".claude-plugin",
+	);
+	mkdirSync(linkedManifest, { recursive: true });
+	symlinkSync(
+		join(outside, ".claude-plugin", "plugin.json"),
+		join(linkedManifest, "plugin.json"),
+	);
+	mkdirSync(
+		join(
+			f.folder("project", "directory-manifest"),
+			".claude-plugin",
+			"plugin.json",
+		),
+		{ recursive: true },
+	);
+	const before = f.snapshot();
+
+	expect(discover(f)).toEqual([]);
+	expect(f.snapshot()).toEqual(before);
+});
+
+test.each([false, true])(
+	"R4.1 R4.4 TEST-33 text and JSON list the same local items; company marketplace=%s",
+	(withCompany) => {
+		f = new MarketFixture(true);
+		const repo = withCompany ? f.seed() : undefined;
+		if (repo) {
+			f.register(repo);
+			write(join(f.folder(), "SKILL.md"), SKILL);
+		}
+		const skill = f.folder("project", "authoring");
+		const plugin = f.folder("global", "personal-kit");
+		write(
+			join(skill, "SKILL.md"),
+			"---\nname: authoring\n---\nWrite guides.\n",
+		);
+		writeJson(join(plugin, ".claude-plugin", "plugin.json"), {
+			name: "personal-kit",
+			version: "1.0.0",
+		});
+		write(join(f.folder("project", "tracked-copy"), "SKILL.md"), SKILL);
+		write(
+			join(f.folder("project", "tracked-copy"), ".magus-origin"),
+			"tracked\n",
+		);
+		const before = f.snapshot();
+		const head = repo ? f.head(repo) : undefined;
+
+		const json = f.market(["list"]);
+		const text = f.cli(["market", "list"]);
+
+		expect(json.code).toBe(0);
+		expect(json.result.local).toEqual([
+			{ kind: "skill", name: "authoring", scope: "project", path: skill },
+			{ kind: "plugin", name: "personal-kit", scope: "user", path: plugin },
+		]);
+		expect(json.result.marketplaces?.map((entry) => entry.name)).toEqual(
+			withCompany ? ["acme"] : [],
+		);
+		expect(text.code).toBe(0);
+		expect(text.out).toContain("authoring");
+		expect(text.out).toContain("personal-kit");
+		expect(text.out).toContain("PROJECT");
+		expect(text.out).toContain("USER");
+		expect(text.out).not.toContain("tracked-copy");
+		if (repo) {
+			expect(text.out.indexOf("authoring")).toBeGreaterThan(
+				text.out.indexOf("acme"),
+			);
+			expect(f.head(repo)).toBe(head!);
+		}
+		expect(f.snapshot()).toEqual(before);
+	},
+	30_000,
+);

package/src/__tests__/market-r2-plugin-add.test.ts

@@ -0,0 +1,470 @@
+import { afterEach, expect, test } from "bun:test";
+import { mkdirSync, readFileSync, symlinkSync } from "node:fs";
+import { join, relative } from "node:path";
+import {
+	MANIFEST,
+	MarketFixture,
+	type Repo,
+	SKILL,
+	write,
+	writeJson,
+} from "./market-fixture.js";
+
+let f: MarketFixture | undefined;
+afterEach(() => {
+	f?.close();
+	f = undefined;
+});
+
+function localPlugin(
+	world: MarketFixture,
+	name = "local-kit",
+	version: string | undefined = "1.2.3",
+): string {
+	const folder = world.folder("project", "copy-me");
+	writeJson(join(folder, ".claude-plugin", "plugin.json"), {
+		name,
+		description: "Local tools",
+		...(version === undefined ? {} : { version }),
+	});
+	write(join(folder, "README.md"), "Local tools documentation\n");
+	return folder;
+}
+
+function sourceSnapshot(
+	world: MarketFixture,
+	folder: string,
+): Record<string, string> {
+	const prefix = relative(world.root, folder);
+	return Object.fromEntries(
+		Object.entries(world.snapshot()).filter(
+			([path]) => path === prefix || path.startsWith(`${prefix}/`),
+		),
+	);
+}
+
+function oneCommit(world: MarketFixture, repo: Repo, old: string): void {
+	expect(
+		world.git(
+			world.root,
+			"--git-dir",
+			repo.bare,
+			"rev-list",
+			"--count",
+			`${old}..HEAD`,
+		),
+	).toBe("1");
+}
+
+test("R4.3 R4.5 TEST-38 plugin add copies the exact allowed set in one approved commit and keeps the entire local folder", () => {
+	f = new MarketFixture();
+	const repo = f.seed({
+		extras: { ".gitignore": "plugins/local-kit/ignored-there.txt\n" },
+	});
+	f.register(repo);
+	const folder = localPlugin(f);
+	writeJson(join(folder, ".claude-plugin", "metadata.json"), { public: true });
+	write(join(folder, "src", "main.ts"), "export const greeting = 'hello';\n");
+	write(join(folder, "skills", "solo", "SKILL.md"), SKILL);
+	write(join(folder, ".env"), "KEEP_SECRET=here\n");
+	write(join(folder, ".mcp.json"), '{"private":"kept locally"}\n');
+	write(join(folder, ".hidden", "notes.md"), "Private notes\n");
+	write(join(folder, "src", ".credentials"), "Private credentials\n");
+	write(join(folder, "node_modules", "package", "index.js"), "dependency\n");
+	write(
+		join(folder, "src", "node_modules", "nested", "index.js"),
+		"nested dependency\n",
+	);
+	write(join(folder, "ignored-here.txt"), "Ignored by source\n");
+	write(join(folder, "ignored-there.txt"), "Ignored by destination\n");
+	write(
+		join(f.project, ".gitignore"),
+		`${relative(f.project, folder)}/ignored-here.txt\n`,
+	);
+	const secret = join(f.root, "private-file");
+	write(secret, "Never follow this link\n");
+	symlinkSync(secret, join(folder, "linked-secret"));
+	const privateDirectory = join(f.root, "private-directory");
+	write(join(privateDirectory, "outside.txt"), "Outside plugin\n");
+	symlinkSync(privateDirectory, join(folder, "linked-directory"));
+	const before = f.snapshot();
+	const sourceBefore = sourceSnapshot(f, folder);
+	const old = f.head(repo);
+	const args = ["plugin", "add", relative(f.project, folder), "--to", "acme"];
+
+	const plan = f.market(args);
+
+	expect({ exit: plan.code, outcome: plan.result.outcome }).toEqual({
+		exit: 3,
+		outcome: "needs-consent",
+	});
+	expect(typeof plan.result.planId).toBe("string");
+	for (const [path, reason] of [
+		[".env", "dotfile"],
+		[".mcp.json", "dotfile"],
+		[".hidden/notes.md", "dotfile"],
+		["src/.credentials", "dotfile"],
+		["node_modules/package/index.js", "node_modules"],
+		["src/node_modules/nested/index.js", "node_modules"],
+		["ignored-here.txt", "ignored-here"],
+		["ignored-there.txt", "ignored-by-marketplace"],
+		["linked-secret", "symlink"],
+		["linked-directory", "symlink"],
+	]) {
+		expect(
+			plan.result.notPublished?.some(
+				(file) => file.path.endsWith(path!) && file.reason === reason,
+			),
+		).toBe(true);
+	}
+	expect(f.snapshot()).toEqual(before);
+	expect(f.head(repo)).toBe(old);
+
+	const result = f.market([...args, `--yes=${plan.result.planId}`]);
+
+	expect({ exit: result.code, outcome: result.result.outcome }).toEqual({
+		exit: 0,
+		outcome: "ok",
+	});
+	oneCommit(f, repo, old);
+	const expected = [
+		"plugins/local-kit/.claude-plugin/metadata.json",
+		"plugins/local-kit/.claude-plugin/plugin.json",
+		"plugins/local-kit/README.md",
+		"plugins/local-kit/skills/solo/SKILL.md",
+		"plugins/local-kit/src/main.ts",
+	];
+	expect(
+		f
+			.remotePaths(repo)
+			.filter((path) => path.startsWith("plugins/local-kit/"))
+			.sort(),
+	).toEqual(expected.sort());
+	expect(
+		f
+			.git(f.root, "--git-dir", repo.bare, "diff", "--name-only", old, "HEAD")
+			.split("\n")
+			.sort(),
+	).toEqual([MANIFEST, ...expected].sort());
+	expect(f.remoteBytes(repo, "plugins/local-kit/skills/solo/SKILL.md")).toBe(
+		SKILL,
+	);
+	expect(f.remoteJson(repo, MANIFEST).plugins).toContainEqual({
+		name: "local-kit",
+		source: "./plugins/local-kit",
+		description: "Local tools",
+		version: "1.2.3",
+	});
+	expect(result.result.steps.map((step) => step.id)).toEqual([
+		"copy",
+		"validate",
+		"commit",
+		"deliver",
+		"refresh",
+	]);
+	expect(f.version("local-kit@acme")).toBeNull();
+	expect(sourceSnapshot(f, folder)).toEqual(sourceBefore);
+	f.assertOwned();
+}, 60_000);
+
+test.each([
+	{
+		version: "2.3.4",
+		override: undefined,
+		expectedName: "local-kit",
+		expectedVersion: "2.3.4",
+	},
+	{
+		version: undefined,
+		override: undefined,
+		expectedName: "local-kit",
+		expectedVersion: "0.1.0",
+	},
+	{
+		version: "not-a-version",
+		override: undefined,
+		expectedName: "local-kit",
+		expectedVersion: "0.1.0",
+	},
+	{
+		version: "1.2.3-beta",
+		override: undefined,
+		expectedName: "local-kit",
+		expectedVersion: "0.1.0",
+	},
+	{
+		version: "2.3.4",
+		override: "renamed-kit",
+		expectedName: "renamed-kit",
+		expectedVersion: "2.3.4",
+	},
+])(
+	"R4.3 TEST-39 plugin add normalizes target name/version while keeping the original: %j",
+	({ version, override, expectedName, expectedVersion }) => {
+		f = new MarketFixture();
+		const repo = f.seed();
+		f.register(repo);
+		const folder = localPlugin(f, "local-kit", version);
+		// The helper's default argument is bypassed for the no-version case.
+		if (version === undefined)
+			writeJson(join(folder, ".claude-plugin", "plugin.json"), {
+				name: "local-kit",
+				description: "Local tools",
+			});
+		const before = sourceSnapshot(f, folder);
+		const old = f.head(repo);
+
+		const result = f.market([
+			"plugin",
+			"add",
+			folder,
+			...(override ? ["--name", override] : []),
+			"--yes",
+		]);
+
+		expect(result.code).toBe(0);
+		oneCommit(f, repo, old);
+		const plugin = f.remoteJson(
+			repo,
+			`plugins/${expectedName}/.claude-plugin/plugin.json`,
+		);
+		expect(plugin.name).toBe(expectedName);
+		expect(plugin.version).toBe(expectedVersion);
+		expect(f.remoteJson(repo, MANIFEST).plugins).toContainEqual({
+			name: expectedName,
+			source: `./plugins/${expectedName}`,
+			description: "Local tools",
+			version: expectedVersion,
+		});
+		expect(sourceSnapshot(f, folder)).toEqual(before);
+		f.assertOwned();
+	},
+	60_000,
+);
+
+test.each([false, true])(
+	"R4.3 TEST-40 a taken plugin name refuses the copy; override=%s",
+	(override) => {
+		f = new MarketFixture();
+		const repo = f.seed();
+		f.register(repo);
+		const folder = localPlugin(f, override ? "my-tools" : "review-kit");
+		const before = f.snapshot();
+		const old = f.head(repo);
+
+		const result = f.market([
+			"plugin",
+			"add",
+			folder,
+			...(override ? ["--name", "review-kit"] : []),
+			"--yes",
+		]);
+
+		expect({
+			exit: result.code,
+			outcome: result.result.outcome,
+			error: result.result.error?.code,
+		}).toEqual({
+			exit: 1,
+			outcome: "failed",
+			error: "name-taken",
+		});
+		expect(f.head(repo)).toBe(old);
+		expect(f.snapshot()).toEqual(before);
+	},
+	30_000,
+);
+
+test.each([
+	{ kind: "missing", code: 2, error: "not-found" },
+	{ kind: "no-manifest", code: 2, error: "not-found" },
+	{ kind: "file", code: 1, error: "other" },
+	{ kind: "folder-link", code: 1, error: "other" },
+	{ kind: "config-plugins", code: 1, error: "other" },
+	{ kind: "manifest-link", code: 1, error: "other" },
+	{ kind: "invalid-json", code: 1, error: "other" },
+	{ kind: "invalid-name", code: 2, error: "invalid-name" },
+])(
+	"R4.3 TEST-41 plugin add refuses $kind source with the contracted exit",
+	({ kind, code, error }) => {
+		f = new MarketFixture();
+		const repo = f.seed();
+		f.register(repo);
+		let folder = join(f.project, "source-plugin");
+		switch (kind) {
+			case "missing":
+				break;
+			case "no-manifest":
+				write(join(folder, "README.md"), "No plugin manifest\n");
+				break;
+			case "file":
+				write(folder, "Not a directory\n");
+				break;
+			case "folder-link": {
+				const actual = localPlugin(f);
+				symlinkSync(actual, folder);
+				break;
+			}
+			case "config-plugins":
+				folder = join(f.config, "plugins", "cache", "local", "local-kit");
+				writeJson(join(folder, ".claude-plugin", "plugin.json"), {
+					name: "local-kit",
+					version: "1.0.0",
+				});
+				break;
+			case "manifest-link": {
+				mkdirSync(join(folder, ".claude-plugin"), { recursive: true });
+				const actual = join(f.root, "external-plugin.json");
+				writeJson(actual, { name: "local-kit", version: "1.0.0" });
+				symlinkSync(actual, join(folder, ".claude-plugin", "plugin.json"));
+				break;
+			}
+			case "invalid-json":
+				write(join(folder, ".claude-plugin", "plugin.json"), "{invalid");
+				break;
+			case "invalid-name":
+				writeJson(join(folder, ".claude-plugin", "plugin.json"), {
+					name: "../escape",
+					version: "1.0.0",
+				});
+				break;
+		}
+		const before = f.snapshot();
+		const old = f.head(repo);
+
+		const result = f.market(["plugin", "add", folder, "--yes"]);
+
+		expect({
+			exit: result.code,
+			outcome: result.result.outcome,
+			error: result.result.error?.code,
+		}).toEqual({
+			exit: code,
+			outcome: "failed",
+			error,
+		});
+		expect(f.head(repo)).toBe(old);
+		expect(f.snapshot()).toEqual(before);
+	},
+	30_000,
+);
+
+test.each([
+	{ args: ["plugin", "add"] },
+	{ args: ["plugin", "add", "one", "two"] },
+])(
+	"R4.3 TEST-42 plugin add rejects the wrong positional argument count: $args",
+	({ args }) => {
+		f = new MarketFixture();
+		const before = f.snapshot();
+
+		const result = f.market(args);
+
+		expect(result.code).toBe(2);
+		expect(f.snapshot()).toEqual(before);
+	},
+	30_000,
+);
+
+test("R4.3 TEST-42 --to is required with several marketplaces and changes only the chosen marketplace", () => {
+	f = new MarketFixture();
+	const a = f.seed();
+	const b = f.seed({ name: "beta", slug: "beta/market" });
+	f.register(a);
+	f.register(b);
+	const folder = localPlugin(f);
+	const before = f.snapshot();
+	const oldA = f.head(a);
+	const oldB = f.head(b);
+
+	const ambiguous = f.market(["plugin", "add", folder]);
+
+	expect(ambiguous.code).toBe(2);
+	expect(ambiguous.result.error?.code).toBe("ambiguous");
+	expect(f.snapshot()).toEqual(before);
+	const result = f.market(["plugin", "add", folder, "--to", "beta", "--yes"]);
+	expect(result.code).toBe(0);
+	expect(f.head(a)).toBe(oldA);
+	oneCommit(f, b, oldB);
+	expect(
+		f
+			.remoteJson(b, MANIFEST)
+			.plugins.some((plugin: { name: string }) => plugin.name === "local-kit"),
+	).toBe(true);
+	f.assertOwned();
+}, 60_000);
+
+test.each(["skill", "plugin"] as const)(
+	"R4.4 TEST-43 adding a local %s with no company explains create/connect first and keeps it",
+	(kind) => {
+		f = new MarketFixture();
+		const folder =
+			kind === "plugin" ? localPlugin(f) : f.folder("project", "solo");
+		if (kind === "skill") write(join(folder, "SKILL.md"), SKILL);
+		const before = f.snapshot();
+		const args =
+			kind === "plugin"
+				? ["plugin", "add", folder]
+				: ["skill", "add", "solo", "--plugin", "fresh-kit", "--create-plugin"];
+
+		const result = f.market([...args, "--yes"]);
+
+		expect(result.code).toBe(2);
+		expect(result.result.error?.code).toBe("not-found");
+		expect(JSON.stringify(result.result)).toMatch(/create|connect/i);
+		expect(JSON.stringify(result.result)).toMatch(/marketplace/i);
+		expect(f.snapshot()).toEqual(before);
+	},
+	30_000,
+);
+
+test.each(["source", "name", "target"] as const)(
+	"R4.5 TEST-44 plugin add refuses consent after changing %s",
+	(changed) => {
+		f = new MarketFixture();
+		const repo = f.seed();
+		f.register(repo);
+		const beta =
+			changed === "target"
+				? f.seed({ name: "beta", slug: "beta/market" })
+				: undefined;
+		if (beta) f.register(beta);
+		const folder = localPlugin(f);
+		const args = ["plugin", "add", folder, "--to", "acme"];
+		const before = f.snapshot();
+		const plan = f.market(args);
+		expect(plan.code).toBe(3);
+		expect(typeof plan.result.planId).toBe("string");
+		expect(f.snapshot()).toEqual(before);
+		if (changed === "source")
+			write(join(folder, "README.md"), "Changed after consent\n");
+		const sourceBefore = sourceSnapshot(f, folder);
+		const old = f.head(repo);
+		const oldBeta = beta ? f.head(beta) : undefined;
+		const changedArgs =
+			changed === "target"
+				? ["plugin", "add", folder, "--to", "beta"]
+				: [...args, ...(changed === "name" ? ["--name", "different-kit"] : [])];
+
+		const result = f.market([...changedArgs, `--yes=${plan.result.planId}`]);
+
+		expect({
+			exit: result.code,
+			outcome: result.result.outcome,
+			error: result.result.error?.code,
+		}).toEqual({
+			exit: 3,
+			outcome: "needs-consent",
+			error: "plan-changed",
+		});
+		expect(result.result.planId).not.toBe(plan.result.planId);
+		expect(f.head(repo)).toBe(old);
+		if (beta) expect(f.head(beta)).toBe(oldBeta!);
+		expect(sourceSnapshot(f, folder)).toEqual(sourceBefore);
+		expect(
+			readFileSync(join(folder, ".claude-plugin", "plugin.json"), "utf8"),
+		).toContain('"local-kit"');
+		f.assertOwned();
+	},
+	60_000,
+);