magus-cli 7.13.0 → 7.14.1

package/src/__tests__/scope-uninstall-wrong-scope.test.ts

@@ -0,0 +1,341 @@
+/**
+ * A scope key on the Plugins screen uninstalls through `uninstallPluginInScope`.
+ * When the scope's settings.json turns the plugin on but Claude Code's registry
+ * holds its row at ANOTHER scope, `claude plugin uninstall --scope <scope>`
+ * refuses with "is installed in <other> scope, not <scope>" and changes
+ * nothing. In a profiled project that is the normal state of a PROJECT enable:
+ * the profile render wrote it, so the profile is what must drop it. Where no
+ * profile owns the enable, the refusal must reach the user in magus's terms,
+ * never as Claude Code's raw text.
+ *
+ * Real files, real reconcile: a temp project, HOME pointed at a temp dir. Only
+ * the `claude` CLI is doubled, and its uninstall refuses the way Claude Code
+ * does, touching no file.
+ */
+
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import fs from "fs-extra";
+import { readManifest, writeManifest } from "../services/manifest.js";
+import { activateProfile } from "../services/profile-activate.js";
+import {
+	type PluginApplyDeps,
+	REAL_PLUGIN_DEPS,
+	REAL_REMOVE_DEPS,
+	uninstallPluginInScope,
+} from "../services/update-engine.js";
+import type { ProfileManifest } from "../types/index.js";
+
+type Scope = "user" | "project" | "local";
+
+let project: string;
+let home: string;
+let log: ReturnType<typeof spyOn>;
+const saved = {
+	HOME: process.env.HOME,
+	CLAUDE_CONFIG_DIR: process.env.CLAUDE_CONFIG_DIR,
+};
+
+function manifest(): ProfileManifest {
+	return {
+		version: 2,
+		profiles: {
+			team: {
+				name: "Team",
+				plugins: { "dev@magus": "latest", "multimodel@magus": "latest" },
+			},
+		},
+	};
+}
+
+/** The settings.json `claude plugin … --scope <scope>` reads and writes. */
+function settingsFor(scope: Scope): string {
+	if (scope === "user") return join(home, ".claude", "settings.json");
+	if (scope === "local") return join(project, ".claude", "settings.local.json");
+	return join(project, ".claude", "settings.json");
+}
+
+async function setEnabled(scope: Scope, pluginId: string): Promise<void> {
+	const file = settingsFor(scope);
+	const json = (await fs.pathExists(file))
+		? ((await fs.readJson(file)) as Record<string, unknown>)
+		: {};
+	json.enabledPlugins = {
+		...((json.enabledPlugins as Record<string, boolean>) ?? {}),
+		[pluginId]: true,
+	};
+	await fs.outputFile(file, JSON.stringify(json));
+}
+
+async function enabledIn(scope: Scope): Promise<Record<string, boolean>> {
+	const file = settingsFor(scope);
+	if (!(await fs.pathExists(file))) return {};
+	const json = (await fs.readJson(file)) as {
+		enabledPlugins?: Record<string, boolean>;
+	};
+	return json.enabledPlugins ?? {};
+}
+
+async function profilePlugins(): Promise<Record<string, unknown>> {
+	const { profiles } = await readManifest(project);
+	return (profiles.team?.plugins ?? {}) as Record<string, unknown>;
+}
+
+/** Claude Code's refusal when the registry row is at `rowAt`, not `asked`. */
+function wrongScopeRefusal(pluginId: string, rowAt: Scope, asked: Scope) {
+	return new Error(
+		`✘ Failed to uninstall plugin "${pluginId}": Plugin "${pluginId}" is installed in ${rowAt} scope, not ${asked}. Use --scope ${rowAt} to uninstall.`,
+	);
+}
+
+/**
+ * The real engine deps with only the `claude` CLI and the version read-back
+ * doubled. `uninstall` is the given behaviour; it never touches a file.
+ */
+function deps(
+	uninstall: (pluginId: string, scope: Scope) => Promise<void>,
+): PluginApplyDeps {
+	const {
+		loadedVersion: _loaded,
+		registryRows: _rows,
+		...real
+	} = REAL_PLUGIN_DEPS;
+	return {
+		...real,
+		install: async () => {
+			throw new Error("install must not run here");
+		},
+		update: async () => {},
+		repair: async () => {},
+		readInstalled: async () => "1.0.0",
+		saveInstalled: async () => {},
+		repairStaleLoad: async () => {
+			throw new Error("repairStaleLoad must not run here");
+		},
+		remove: { ...REAL_REMOVE_DEPS, uninstall },
+	};
+}
+
+/** Claude Code holding the plugin's only registry row at `rowAt`. */
+function rowOnlyAt(rowAt: Scope): PluginApplyDeps {
+	return deps(async (pluginId, scope) => {
+		if (scope !== rowAt) throw wrongScopeRefusal(pluginId, rowAt, scope);
+	});
+}
+
+/** Claude Code's older refusal, which names no scope the plugin is at. */
+function notInstalledRefusal(pluginId: string, asked: Scope) {
+	return new Error(
+		`✘ Failed to uninstall plugin "${pluginId}": Plugin "${pluginId}" is not installed in ${asked} scope.`,
+	);
+}
+
+async function rejection(promise: Promise<unknown>): Promise<string> {
+	try {
+		await promise;
+	} catch (error) {
+		return error instanceof Error ? error.message : String(error);
+	}
+	throw new Error("expected the uninstall to reject, but it resolved");
+}
+
+beforeEach(async () => {
+	project = await mkdtemp(join(tmpdir(), "scope-wrong-scope-"));
+	home = await mkdtemp(join(tmpdir(), "scope-wrong-scope-home-"));
+	process.env.HOME = home;
+	process.env.CLAUDE_CONFIG_DIR = join(home, ".claude");
+	log = spyOn(console, "log").mockImplementation(() => {});
+});
+
+afterEach(async () => {
+	log.mockRestore();
+	process.env.HOME = saved.HOME;
+	if (saved.CLAUDE_CONFIG_DIR === undefined) {
+		// biome-ignore lint/performance/noDelete: an unset env var must be absent, not "undefined"
+		delete process.env.CLAUDE_CONFIG_DIR;
+	} else process.env.CLAUDE_CONFIG_DIR = saved.CLAUDE_CONFIG_DIR;
+	await rm(project, { recursive: true, force: true });
+	await rm(home, { recursive: true, force: true });
+});
+
+describe("a scope uninstall Claude Code refuses as the wrong scope", () => {
+	test("PROJECT, enabled by the active profile: the profile drops it and the project no longer enables it", async () => {
+		await writeManifest(manifest(), project);
+		await activateProfile(manifest(), "team", project, {
+			onDisplace: () => {},
+		});
+		expect(await enabledIn("project")).toHaveProperty("multimodel@magus", true);
+
+		await uninstallPluginInScope(
+			"multimodel@magus",
+			"project",
+			project,
+			rowOnlyAt("user"),
+			"team",
+		);
+
+		expect((await enabledIn("project"))["multimodel@magus"]).not.toBe(true);
+		expect(await profilePlugins()).not.toHaveProperty("multimodel@magus");
+	});
+
+	test("PROJECT, enabled with no profile to own it: refused in magus's terms, naming USER", async () => {
+		await setEnabled("project", "multimodel@magus");
+
+		const message = await rejection(
+			uninstallPluginInScope(
+				"multimodel@magus",
+				"project",
+				project,
+				rowOnlyAt("user"),
+			),
+		);
+
+		expect(message).toMatch(/USER/);
+		expect(message).not.toContain("Failed to uninstall plugin");
+		expect(message).not.toContain("--scope");
+	});
+
+	test("USER, enabled while the only row is PROJECT: refused in magus's terms, naming PROJECT", async () => {
+		await writeManifest(manifest(), project);
+		await activateProfile(manifest(), "team", project, {
+			onDisplace: () => {},
+		});
+		await setEnabled("user", "multimodel@magus");
+		const userBefore = await fs.readFile(settingsFor("user"), "utf8");
+
+		const message = await rejection(
+			uninstallPluginInScope(
+				"multimodel@magus",
+				"user",
+				project,
+				rowOnlyAt("project"),
+				"team",
+			),
+		);
+
+		expect(message).toMatch(/PROJECT/);
+		expect(message).not.toContain("Failed to uninstall plugin");
+		expect(message).not.toContain("--scope");
+		expect(await fs.readFile(settingsFor("user"), "utf8")).toBe(userBefore);
+		expect(await profilePlugins()).toHaveProperty("multimodel@magus");
+	});
+
+	test("PROJECT, any other CLI failure: rejected with its own text, the profile untouched", async () => {
+		await writeManifest(manifest(), project);
+		await activateProfile(manifest(), "team", project, {
+			onDisplace: () => {},
+		});
+		const failing = deps(async () => {
+			throw new Error("claude timed out");
+		});
+
+		const message = await rejection(
+			uninstallPluginInScope(
+				"multimodel@magus",
+				"project",
+				project,
+				failing,
+				"team",
+			),
+		);
+
+		expect(message).toBe("claude timed out");
+		expect(await profilePlugins()).toHaveProperty("multimodel@magus");
+		expect(await enabledIn("project")).toHaveProperty("multimodel@magus", true);
+	});
+
+	test("PROJECT, the older not-installed wording, no profile to own it: refused in magus's terms, naming PROJECT", async () => {
+		await setEnabled("project", "multimodel@magus");
+		const olderWording = deps(async (pluginId, scope) => {
+			throw notInstalledRefusal(pluginId, scope);
+		});
+
+		const message = await rejection(
+			uninstallPluginInScope(
+				"multimodel@magus",
+				"project",
+				project,
+				olderWording,
+			),
+		);
+
+		expect(message).toMatch(/PROJECT/);
+		expect(message).not.toContain("Failed to uninstall plugin");
+		expect(message).not.toContain("--scope");
+	});
+
+	test("LOCAL, enabled while the only row is USER: refused naming USER, the local settings untouched", async () => {
+		await setEnabled("local", "multimodel@magus");
+		const localBefore = await fs.readFile(settingsFor("local"), "utf8");
+
+		const message = await rejection(
+			uninstallPluginInScope(
+				"multimodel@magus",
+				"local",
+				project,
+				rowOnlyAt("user"),
+			),
+		);
+
+		expect(message).toMatch(/USER/);
+		expect(message).not.toContain("Failed to uninstall plugin");
+		expect(message).not.toContain("--scope");
+		expect(await fs.readFile(settingsFor("local"), "utf8")).toBe(localBefore);
+	});
+
+	test("USER, not enabled there while PROJECT installs it: resolves, the profile still lists it and the project still enables it", async () => {
+		await writeManifest(manifest(), project);
+		await activateProfile(manifest(), "team", project, {
+			onDisplace: () => {},
+		});
+		expect(await enabledIn("user")).not.toHaveProperty("multimodel@magus");
+
+		await uninstallPluginInScope(
+			"multimodel@magus",
+			"user",
+			project,
+			rowOnlyAt("project"),
+			"team",
+		);
+
+		expect(await profilePlugins()).toHaveProperty("multimodel@magus");
+		expect(await enabledIn("project")).toHaveProperty("multimodel@magus", true);
+		expect(await enabledIn("user")).not.toHaveProperty("multimodel@magus");
+	});
+
+	test("PROJECT, the profile lists it but the enable survives the drop: refused saying the profile no longer lists it, naming USER", async () => {
+		// The profile file lists the plugin; the remove double models a drop
+		// that succeeds while the PROJECT enable stays on.
+		await writeManifest(manifest(), project);
+		const base = rowOnlyAt("user");
+		const remove = base.remove;
+		if (!remove) throw new Error("the harness deps carry remove");
+		const surviving: PluginApplyDeps = {
+			...base,
+			recordInProfile: async () => {},
+			remove: {
+				...remove,
+				dependents: undefined,
+				dropFromProfile: async () => true,
+				isInstalled: async (_id, scope) => scope === "project",
+			},
+		};
+
+		const message = await rejection(
+			uninstallPluginInScope(
+				"multimodel@magus",
+				"project",
+				project,
+				surviving,
+				"team",
+			),
+		);
+
+		expect(message).toContain("no longer in the profile");
+		expect(message).toMatch(/USER/);
+		expect(message).not.toContain("Failed to uninstall plugin");
+		expect(message).not.toContain("--scope");
+	});
+});

package/src/cli/market-view.ts

@@ -8,6 +8,7 @@
  */
 
 import type {
+	LocalCopy,
 	MarketPlan,
 	MarketResult,
 	SkillStatusRow,
@@ -89,23 +90,24 @@ export function stepLine(step: StepRecord, label: string): string {
 	return fail(`${label}: ${step.detail ?? "failed"}`);
 }
 
-function localCopyLine(result: MarketResult): string[] {
-	const copy = result.localCopy;
-	if (!copy) return [];
+function copyLine(copy: LocalCopy): string {
 	const whose = copy.scope === "user" ? "your USER" : "this project's";
 	if (copy.action === "removed") {
-		return [
-			ok(
-				`removed ${whose} copy of ${bold(copy.name)}${copy.scope === "project" ? ` — commit the deletion (.claude/skills/${copy.name})` : ""}`,
-			),
-		];
+		return ok(
+			`removed ${whose} copy of ${bold(copy.name)}${copy.scope === "project" ? ` — commit the deletion (.claude/skills/${copy.name})` : ""}`,
+		);
 	}
 	if (copy.action === "created") {
-		return [ok(`${whose} copy of ${bold(copy.name)} is ready to edit`)];
+		return ok(`${whose} copy of ${bold(copy.name)} is ready to edit`);
 	}
+	return info(`kept ${whose} copy of ${bold(copy.name)}: ${copy.reason ?? ""}`);
+}
+
+function localCopyLine(result: MarketResult): string[] {
 	return [
-		info(`kept ${whose} copy of ${bold(copy.name)}: ${copy.reason ?? ""}`),
-	];
+		...(result.localCopy ? [result.localCopy] : []),
+		...(result.localCopies ?? []),
+	].map(copyLine);
 }
 
 function installLines(result: MarketResult): string[] {
@@ -213,6 +215,22 @@ export function statusLines(result: MarketResult): string[] {
 export function listLines(result: MarketResult): string[] {
 	const lines = headerFor("market list");
 	const rows = result.marketplaces ?? [];
+	const local = result.local ?? [];
+	const localLines =
+		local.length === 0
+			? []
+			: [
+					`  ${bold("Here, in no marketplace")}`,
+					...local.map(
+						(l) => `  ${scopeBadge(l.scope)} ${bold(l.name)}  ${dim(l.kind)}`,
+					),
+					note(
+						rows.length === 0
+							? "a company marketplace is needed before these can be added to one"
+							: "add one with `magus market skill add <skill> --plugin <p@m> --create-plugin` or `magus market plugin add <path>`",
+					),
+					"",
+				];
 	if (rows.length === 0) {
 		lines.push(info(result.message));
 		lines.push(
@@ -220,10 +238,13 @@ export function listLines(result: MarketResult): string[] {
 				"create one with `magus market create`, or `magus market connect` an existing one",
 			),
 		);
-		return [...lines, ""];
+		return [...lines, "", ...localLines];
 	}
 	for (const m of rows) {
-		lines.push(`  ${bold(m.name)}  ${dim(m.repo)}  ${scopeBadge(m.scope)}`);
+		const by = m.company ? `  by ${m.company}` : "";
+		lines.push(
+			`  ${bold(m.name)}${by}  ${dim(m.repo)}  ${scopeBadge(m.scope)}`,
+		);
 		if (m.plugins.length === 0) lines.push(listItem(dim("no plugins yet")));
 		for (const p of m.plugins) {
 			lines.push(
@@ -235,7 +256,7 @@ export function listLines(result: MarketResult): string[] {
 		}
 		lines.push("");
 	}
-	return lines;
+	return [...lines, ...localLines];
 }
 
 /** `magus market --help`. */
@@ -244,23 +265,38 @@ export function marketHelp(): string {
 
 Usage: magus market <command> [args]
 
+The screen for all of this is \`magus edit\`; these commands run without one.
+
   list                      Company marketplaces on this machine, with their
                             plugins and skills. Changes nothing.
   fetch [<m>]               Bring magus's copies of company marketplaces up to
                             date with GitHub. Changes nothing else.
-  create <owner>/<repo> --private|--public [--name <m>] [--description <t>]
+  create <owner>/<repo> --private|--public [--name <m>] [--company <name>]
+         [--description <t>]
                             Create a GitHub repository holding a new company
                             marketplace and add it to this machine.
-  connect <owner/repo|git-url|path> [--name <m>]
+                            --company is the name magus shows it by ("by
+                            <name>"); the GitHub owner when left out. One line,
+                            at most 64 characters.
+  connect <owner/repo|git-url|path> [--name <m>] [--company <name>]
                             Use an existing repository as a company marketplace.
-                            --name only when the repository holds no marketplace.
+                            --name and --company only when the repository holds
+                            no marketplace; otherwise its manifest names both.
   remove <m>                Remove a company marketplace from this machine,
                             uninstalling its plugins. The repository stays.
   plugin create <p@m> [--description <t>]
   plugin delete <p@m>       Add or delete a plugin in the marketplace.
-  skill add <skill> --plugin <p@m> [--from project|global] [--keep-local]
+  plugin add <path> [--to <m>] [--name <p>]
+                            Copy a plugin folder of your own (one holding
+                            .claude-plugin/plugin.json) into the marketplace
+                            as a new plugin, at its own version (0.1.0 when it
+                            has none). The folder stays where it is.
+  skill add <skill> --plugin <p@m> [--create-plugin [--description <t>]]
+            [--from project|global] [--keep-local]
                             Add a skill from this project (or your USER skills)
                             to a plugin, then use the plugin's version.
+                            --create-plugin creates the plugin in the same
+                            commit when the marketplace has none of that name.
   skill edit <skill> [--plugin <p@m>] [--to project|global]
                             Copy a plugin's skill here to edit it.
   skill remove <skill> --plugin <p@m>
@@ -274,6 +310,11 @@ Usage: magus market <command> [args]
                             then remove the local copy. --force replaces the
                             plugin's version when the copy's origin is unknown
                             or both sides changed. --dry-run shows the plan.
+  publish --plugin <p@m> [--keep-local] [--dry-run]
+                            Send every skill of the plugin edited here as one
+                            new patch version. A copy whose origin is unknown,
+                            or that changed on both sides, is left out: publish
+                            it on its own with --force.
 
   @m may be left out when this machine has one company marketplace.