magus-cli 7.12.2 → 7.14.0

package/src/services/market-ops-repo.ts

@@ -0,0 +1,916 @@
+/**
+ * market-ops-repo.ts — plans for the marketplace itself: `create`, `connect`
+ * and `remove`.
+ *
+ * Each planner is read-only. The one write a plan may make is `connect`'s
+ * shallow clone into a new directory under the OS temp dir, for a repository
+ * gh cannot read; it is removed before the plan returns.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import {
+	addMarketplace,
+	listMarketplaces,
+	listPlugins,
+	marketplaceAddHint,
+	removeMarketplace,
+} from "./claude-cli.js";
+import {
+	type RemoteHead,
+	catFile,
+	cloneShallowTemp,
+	initWithRemote,
+	lsRemoteHead,
+	push,
+} from "./git-write.js";
+import {
+	authStatus,
+	ghAvailable,
+	isRepoSlug,
+	repoCreate,
+	repoExists,
+	repoFileRaw,
+	repoPermissions,
+} from "./github-cli.js";
+import { getManifestPath, readManifest } from "./manifest.js";
+import { forgetBasesFor } from "./market-bases.js";
+import {
+	type ChangeSpec,
+	changeSteps,
+	cloneOf,
+	deliveryTarget,
+	linkRefusal,
+	readJson,
+	targetLine,
+	writeJson,
+} from "./market-change.js";
+import { cloneUrl, gitError, workingClonePath } from "./market-clone.js";
+import { refuseLinkUnder, writeFileUnder } from "./market-fs.js";
+import { validPackageName } from "./market-layout.js";
+import { readMarker, withMarker } from "./market-marker.js";
+import { type MarketCommand, computePlanId, planError } from "./market-ops.js";
+import {
+	isGithubSource,
+	listCompanyMarketplaces,
+	normaliseSource,
+	readTrust,
+	registeredSource,
+	sameSource,
+	trust,
+	untrust,
+} from "./market-registry.js";
+import {
+	MarketError,
+	type MarketPlan,
+	type MarketStep,
+	type PlanAnswer,
+} from "./market-types.js";
+import { fastForwardCloneIfPresent } from "./marketplace-refresh.js";
+
+const MANIFEST = ".claude-plugin/marketplace.json";
+const README = "README.md";
+
+/** The longest company name a marketplace may carry, in characters. */
+export const COMPANY_NAME_MAX = 64;
+
+/**
+ * Check a company name for `owner.name`: one line, not blank, at most
+ * {@link COMPANY_NAME_MAX} characters once trimmed. Returns it trimmed; a
+ * bad one is a usage error (exit 2).
+ */
+export function checkCompanyName(value: string): string {
+	const company = value.trim();
+	if (company === "") {
+		throw new MarketError(
+			"invalid-name",
+			"The company name is empty",
+			"pass --company <name>",
+			2,
+		);
+	}
+	// Every control character (C0, DEL, C1 — NEL included) and the Unicode
+	// line and paragraph separators.
+	if (/[\p{Cc}\u2028\u2029]/u.test(company)) {
+		throw new MarketError(
+			"invalid-name",
+			"The company name must be a single line",
+			"pass --company <name>",
+			2,
+		);
+	}
+	if ([...company].length > COMPANY_NAME_MAX) {
+		throw new MarketError(
+			"invalid-name",
+			`The company name is longer than ${COMPANY_NAME_MAX} characters`,
+			"pass a shorter --company <name>",
+			2,
+		);
+	}
+	return company;
+}
+
+function companyLine(company: string): string {
+	return `Company name: ${company} (magus shows the marketplace as "by ${company}")`;
+}
+
+function newManifest(name: string, company: string, description?: string) {
+	return withMarker({
+		name,
+		owner: { name: company },
+		metadata: {
+			description: description ?? `${name} company plugin marketplace`,
+		},
+		plugins: [],
+	});
+}
+
+function readme(name: string, repo: string): string {
+	return `# ${name}
+
+The ${name} company plugin marketplace for Claude Code, managed with \`magus market\`.
+
+Add it on a machine with:
+
+\`\`\`
+claude plugin marketplace add ${repo}
+\`\`\`
+`;
+}
+
+/** Name checks shared by create and connect. */
+async function checkNameFree(name: string, source: string): Promise<boolean> {
+	const registered = await registeredSource(name);
+	if (registered && !sameSource(registered, source)) {
+		throw new MarketError(
+			"name-taken",
+			`A marketplace named ${name} is already on this machine, from ${registered}`,
+			"pick another name with --name, or remove the other one first",
+		);
+	}
+	const trusted = (await readTrust()).marketplaces[name];
+	if (trusted && !sameSource(trusted.source, source)) {
+		throw new MarketError(
+			"name-taken",
+			`${name} is already a company marketplace on this machine, from ${trusted.source}`,
+			"pick another name with --name",
+		);
+	}
+	return registered !== null;
+}
+
+/** Register at USER scope through Claude Code, then read the registration back. */
+function registerStep(name: string, claudeSource: string): MarketStep {
+	return {
+		id: "register",
+		label: `added ${name} to this machine`,
+		outside: true,
+		async run() {
+			try {
+				await addMarketplace(claudeSource, "user");
+			} catch (error) {
+				const hint = marketplaceAddHint(error);
+				throw new MarketError(
+					hint ? "gh-auth" : "other",
+					`Claude Code could not add ${name}: ${error instanceof Error ? error.message : String(error)}`,
+					hint ?? undefined,
+				);
+			}
+			const rows = await listMarketplaces();
+			if (!rows.some((r) => r.name === name)) {
+				throw new MarketError(
+					"other",
+					`Claude Code added the marketplace, but not under the name ${name}`,
+				);
+			}
+			return undefined;
+		},
+	};
+}
+
+function trustStep(
+	name: string,
+	source: string,
+	via: "create" | "connect",
+): MarketStep {
+	return {
+		id: "trust",
+		label: `${name} is a company marketplace on this machine`,
+		outside: true,
+		async run() {
+			const r = await trust(name, source, via);
+			if (r === "conflict") {
+				throw new MarketError(
+					"name-taken",
+					`${name} is already trusted from another source`,
+				);
+			}
+			return r === "exists" ? { skipped: true } : undefined;
+		},
+	};
+}
+
+/** Write a new marketplace into an empty working clone and commit it. */
+function initSteps(
+	name: string,
+	source: string,
+	company: string,
+	branch: string,
+	description: string | undefined,
+): MarketStep[] {
+	const state = {};
+	return [
+		{
+			id: "init",
+			label: "wrote the marketplace",
+			outside: false,
+			async run(ctx) {
+				const dir = cloneOf(ctx);
+				fs.rmSync(dir, { recursive: true, force: true });
+				const r = await initWithRemote(dir, cloneUrl(source), branch);
+				if (!r.ok) throw gitError(r, name);
+				writeJson(dir, MANIFEST, newManifest(name, company, description), name);
+				writeFileUnder(dir, README, readme(name, source), linkRefusal(name));
+				return undefined;
+			},
+		},
+		...changeSteps({
+			label: name,
+			source,
+			branch,
+			target: "push-or-pr",
+			stage: [MANIFEST, README],
+			files: [
+				{ path: MANIFEST, change: "added" },
+				{ path: README, change: "added" },
+			],
+			message: `Create the ${name} marketplace`,
+			slug: name,
+			prBody: "",
+			state,
+		}).filter((s) => s.id !== "deliver"),
+		{
+			id: "push",
+			label: `pushed to ${source}`,
+			outside: true,
+			async run(ctx) {
+				const r = await push(cloneOf(ctx), branch, { setUpstream: true });
+				if (!r.ok) throw gitError(r, name);
+				return undefined;
+			},
+		},
+	];
+}
+
+/** Every step after the repository exists says how to finish by hand. */
+function afterCreate(step: MarketStep, repo: string): MarketStep {
+	return {
+		...step,
+		async run(ctx) {
+			try {
+				return await step.run(ctx);
+			} catch (error) {
+				const e =
+					error instanceof MarketError
+						? error
+						: new MarketError("other", String(error));
+				throw new MarketError(
+					e.code,
+					`${repo} was created on GitHub, but ${e.message}`,
+					`run \`magus market connect ${repo}\` to finish`,
+				);
+			}
+		},
+	};
+}
+
+/**
+ * For a marketplace already on this machine: fast-forward Claude Code's copy
+ * after the connect, then check magus now finds it as a company marketplace.
+ * magus discovers company marketplaces by the marker in that copy, so a copy
+ * left behind would leave the connect invisible. A change that went out as a
+ * pull request has nothing on the branch yet: the marker arrives when it is
+ * merged.
+ */
+function discoveryStep(
+	name: string,
+	action: "init" | "add" | "mark" | "register",
+	delivered: ChangeSpec["state"],
+): MarketStep {
+	return {
+		id: "refresh",
+		label: `brought Claude Code's copy of ${name} up to date`,
+		outside: true,
+		async run() {
+			if ((action === "mark" || action === "add") && !delivered.pushed) {
+				return {
+					skipped: true,
+					detail: "the marker arrives with the pull request",
+				};
+			}
+			const r = await fastForwardCloneIfPresent(name);
+			const found = (await listCompanyMarketplaces()).some(
+				(m) => m.name === name,
+			);
+			if (found) return r === "refreshed" ? undefined : { skipped: true };
+			throw new MarketError(
+				"other",
+				r === "skipped"
+					? `${name} is connected, but Claude Code's copy of it has local changes, so magus cannot see the marker yet`
+					: `${name} is connected, but Claude Code's copy of it could not be brought up to date, so magus cannot see the marker yet`,
+				r === "skipped"
+					? "discard those changes, then run `magus update`"
+					: "run `magus update`",
+			);
+		},
+	};
+}
+
+// ─── create ──────────────────────────────────────────────────────────────────
+
+export interface CreateArgs {
+	repo: string;
+	visibility: "private" | "public";
+	name?: string;
+	description?: string;
+	/**
+	 * The company name written as the manifest's `owner.name`; the GitHub
+	 * owner of `repo` when absent.
+	 */
+	company?: string;
+}
+
+/**
+ * A gh failure before anything was created: a host gh could not reach is a
+ * network problem, never a sign-in one.
+ */
+function ghCreateError(r: { failure: string; message: string }): MarketError {
+	if (r.failure === "no-network" || r.failure === "timeout") {
+		return new MarketError(
+			"no-network",
+			"Could not reach GitHub — nothing was created",
+			"check your network connection, then run the command again",
+		);
+	}
+	if (r.failure === "gh-auth") {
+		return new MarketError(
+			"gh-auth",
+			"Not signed in to GitHub",
+			"run `gh auth login`, then `gh auth setup-git`",
+		);
+	}
+	return new MarketError("other", r.message);
+}
+
+export async function planCreate(args: CreateArgs): Promise<PlanAnswer> {
+	const command: MarketCommand = "market create";
+	try {
+		if (!isRepoSlug(args.repo)) {
+			throw new MarketError(
+				"invalid-name",
+				`${args.repo} is not a GitHub owner/repo`,
+			);
+		}
+		const [owner = "", repoName = ""] = args.repo.split("/");
+		const company = checkCompanyName(args.company ?? owner);
+		const name = args.name ?? repoName.toLowerCase();
+		if (!validPackageName(name)) {
+			throw new MarketError(
+				"invalid-name",
+				`${name} cannot be a marketplace name (lower case letters, digits and dashes)`,
+				"pass --name <name>",
+			);
+		}
+		const auth = await authStatus();
+		if (!auth.ok) {
+			if (auth.failure === "gh-missing") {
+				throw new MarketError(
+					"gh-missing",
+					"gh is needed to create a GitHub repository",
+					"install gh, then run `gh auth login`",
+				);
+			}
+			throw ghCreateError(auth);
+		}
+		const exists = await repoExists(args.repo);
+		if (!exists.ok) throw ghCreateError(exists);
+		if (exists.value) {
+			throw new MarketError(
+				"name-taken",
+				`${args.repo} already exists on GitHub`,
+				`use \`magus market connect ${args.repo}\``,
+			);
+		}
+		const source = normaliseSource(args.repo);
+		if (await checkNameFree(name, source)) {
+			throw new MarketError(
+				"name-taken",
+				`A marketplace named ${name} is already on this machine`,
+				"pick another name with --name",
+			);
+		}
+		const branch = "main";
+		const steps: MarketStep[] = [
+			{
+				id: "repo",
+				label: `created ${args.repo} on GitHub`,
+				outside: true,
+				async run() {
+					const r = await repoCreate(
+						args.repo,
+						args.visibility,
+						args.description,
+					);
+					if (!r.ok) {
+						throw new MarketError(
+							r.failure === "gh-auth" ? "gh-auth" : "other",
+							`GitHub did not create ${args.repo}: ${r.message}`,
+						);
+					}
+					return undefined;
+				},
+			},
+			...[
+				...initSteps(name, source, company, branch, args.description),
+				registerStep(name, source),
+				trustStep(name, source, "create"),
+			].map((s) => afterCreate(s, args.repo)),
+		];
+		const plan: MarketPlan = {
+			command,
+			lines: [
+				`Creates the ${args.visibility} GitHub repository ${args.repo}`,
+				`Writes a company marketplace named ${name} into it and pushes it to ${branch}`,
+				companyLine(company),
+				`Adds ${name} to this machine at USER scope and marks it as a company marketplace here`,
+			],
+			planId: computePlanId({
+				op: "create",
+				...args,
+				name,
+				company,
+				branch,
+			}),
+			summary: { marketplace: name },
+			steps: steps.map((s) =>
+				s.id === "init" ||
+				s.id === "validate" ||
+				s.id === "commit" ||
+				s.id === "push"
+					? {
+							...s,
+							run: (ctx) => s.run({ ...ctx, clone: workingClonePath(name) }),
+						}
+					: s,
+			),
+			sync: null,
+			lock: name,
+			replan: () => planCreate(args),
+			doneMessage: `${name} is ready on GitHub and on this machine. ${teammateNote(name)}`,
+		};
+		return { kind: "plan", plan };
+	} catch (error) {
+		return planError(command, error);
+	}
+}
+
+function teammateNote(name: string): string {
+	return `For teammates: install one of its plugins at PROJECT scope in a project (or save a project profile in magus), then commit .claude/profiles.json; their \`magus update\` adds ${name}.`;
+}
+
+// ─── connect ─────────────────────────────────────────────────────────────────
+
+export interface ConnectArgs {
+	source: string;
+	name?: string;
+	/**
+	 * The company name for a manifest connect writes (`init` and `add` only);
+	 * the GitHub owner of the source when absent. A repository that already
+	 * holds a marketplace keeps the `owner.name` its manifest gives.
+	 */
+	company?: string;
+}
+
+async function readRemoteManifest(
+	source: string,
+	head: RemoteHead,
+): Promise<unknown> {
+	if (!head.commit) return null;
+	let text: string | null = null;
+	let read = false;
+	if (isGithubSource(source) && (await ghAvailable())) {
+		const r = await repoFileRaw(source, MANIFEST, head.branch ?? undefined);
+		if (r.ok) {
+			text = r.value;
+			read = true;
+		}
+	}
+	if (!read) {
+		const temp = await cloneShallowTemp(cloneUrl(source));
+		if (!temp.ok) throw gitError(temp, source);
+		try {
+			const r = await catFile(temp.value.dir, `HEAD:${MANIFEST}`);
+			text = r.ok ? r.value : null;
+		} finally {
+			temp.value.dispose();
+		}
+	}
+	if (text === null) return null;
+	try {
+		return JSON.parse(text) as unknown;
+	} catch {
+		throw new MarketError(
+			"other",
+			`${source} holds a marketplace manifest that is not valid JSON`,
+		);
+	}
+}
+
+export async function planConnect(
+	args: ConnectArgs,
+	cwd: string,
+): Promise<PlanAnswer> {
+	const command: MarketCommand = "market connect";
+	try {
+		// The value's form is checked before any GitHub or git work.
+		if (args.company !== undefined) checkCompanyName(args.company);
+		const source = normaliseSource(args.source, cwd);
+		const github = isGithubSource(source);
+		const url = cloneUrl(source);
+		const head = await lsRemoteHead(url);
+		if (!head.ok) throw gitError(head, source);
+		const manifest = await readRemoteManifest(source, head.value);
+		// No manifest in an empty repository: a new history. No manifest in one
+		// with commits: the marketplace is committed on top of its history.
+		const action =
+			manifest === null
+				? head.value.commit === null
+					? "init"
+					: "add"
+				: readMarker(manifest)
+					? "register"
+					: "mark";
+		const fresh = action === "init" || action === "add";
+		if (args.name !== undefined && !fresh) {
+			throw new MarketError(
+				"other",
+				"--name applies only when connect sets up a repository with no marketplace in it; Claude Code registers this one under the name its manifest gives",
+				"run it again without --name",
+				2,
+			);
+		}
+		if (args.company !== undefined && !fresh) {
+			throw new MarketError(
+				"other",
+				"--company applies only when connect sets up a repository with no marketplace in it; this one keeps the company name its manifest gives",
+				"run it again without --company",
+				2,
+			);
+		}
+		const base = path
+			.basename(source)
+			.replace(/\.git$/, "")
+			.toLowerCase();
+		const name = fresh
+			? (args.name ?? base)
+			: String((manifest as { name?: unknown }).name ?? "");
+		if (!validPackageName(name)) {
+			throw new MarketError(
+				"invalid-name",
+				`${name || "(none)"} cannot be a marketplace name (lower case letters, digits and dashes)`,
+				fresh ? "pass --name <name>" : undefined,
+			);
+		}
+		const registered = await checkNameFree(name, source);
+		const trusted = (await readTrust()).marketplaces[name] !== undefined;
+		// Registered and trusted is not yet connected: magus finds a company
+		// marketplace by the marker in Claude Code's copy. A connect whose
+		// discovery failed, or a marker pull request merged since, leaves that
+		// copy behind; then the plan below brings it up to date instead.
+		const discovered =
+			registered &&
+			trusted &&
+			(await listCompanyMarketplaces()).some((m) => m.name === name);
+		if (action === "register" && discovered) {
+			return {
+				kind: "result",
+				result: {
+					command,
+					outcome: "unchanged",
+					message: `${name} is already a company marketplace on this machine`,
+					marketplace: name,
+					steps: [],
+				},
+			};
+		}
+		if (action !== "register" && github && (await ghAvailable())) {
+			const can = await repoPermissions(source);
+			if (!can.ok || !can.value) {
+				throw new MarketError(
+					"no-access",
+					`Your account cannot write to ${source}, and connecting it needs a commit`,
+					"ask its owner for write access",
+				);
+			}
+		}
+		const branch = head.value.branch ?? "main";
+		const claudeSource = github
+			? source
+			: args.source.includes("://")
+				? args.source
+				: source;
+		const steps: MarketStep[] = [];
+		const lines: string[] = [];
+		const company = fresh
+			? checkCompanyName(
+					args.company ?? (github ? (source.split("/")[0] ?? name) : name),
+				)
+			: null;
+		const delivered: ChangeSpec["state"] = {};
+		if (action === "init") {
+			lines.push(
+				`${source} holds no marketplace yet: writes a company marketplace named ${name} into it and pushes it to ${branch}`,
+				companyLine(company as string),
+			);
+			steps.push(
+				...initSteps(name, source, company as string, branch, undefined).map(
+					(s) => ({
+						...s,
+						run: (ctx: Parameters<MarketStep["run"]>[0]) =>
+							s.run({ ...ctx, clone: workingClonePath(name) }),
+					}),
+				),
+			);
+		} else if (action === "mark" || action === "add") {
+			const target = await deliveryTarget(source, name);
+			lines.push(
+				action === "mark"
+					? `${name} is a marketplace without the company marker: commits the marker to its manifest`
+					: `${source} holds no marketplace yet: commits a company marketplace named ${name} on top of its ${branch} history, leaving its files as they are`,
+				...(action === "add" ? [companyLine(company as string)] : []),
+				targetLine(target, branch),
+			);
+			const state = delivered;
+			steps.push(
+				{
+					id: "marker",
+					label:
+						action === "mark"
+							? "added the company marker"
+							: "wrote the marketplace",
+					outside: false,
+					async run(ctx) {
+						const clone = cloneOf(ctx);
+						// The repository's own history can commit a link at
+						// `.claude-plugin` or the manifest: refuse before reading
+						// or writing through it.
+						refuseLinkUnder(clone, MANIFEST, linkRefusal(name));
+						const file = path.join(clone, MANIFEST);
+						if (action === "add") {
+							if (fs.existsSync(file)) {
+								throw new MarketError(
+									"plan-changed",
+									`${source} gained a marketplace while this ran — nothing was pushed`,
+									"run the command again to see the new plan",
+								);
+							}
+							writeJson(
+								clone,
+								MANIFEST,
+								newManifest(name, company as string, undefined),
+								name,
+							);
+							return undefined;
+						}
+						const current = readJson(clone, MANIFEST, name);
+						writeJson(clone, MANIFEST, withMarker(current), name);
+						return undefined;
+					},
+				},
+				...changeSteps({
+					label: name,
+					source,
+					branch,
+					target,
+					stage: [MANIFEST],
+					files: [
+						{
+							path: MANIFEST,
+							change: action === "mark" ? "modified" : "added",
+						},
+					],
+					message:
+						action === "mark"
+							? `Mark ${name} as a company marketplace`
+							: `Create the ${name} marketplace`,
+					slug: `${name}-company-marker`,
+					prBody:
+						action === "mark"
+							? `Adds the \`metadata.magus\` marker, so \`magus market\` treats ${name} as a company marketplace.`
+							: `Adds a company marketplace manifest, so \`magus market\` treats ${name} as a company marketplace.`,
+					state,
+				}).map((s) =>
+					s.id === "deliver"
+						? {
+								...s,
+								run: async (ctx: Parameters<MarketStep["run"]>[0]) => {
+									const out = await s.run(ctx);
+									if (!out?.stop) return out;
+									// A marker pull request still connects: the manifest is on
+									// the branch and the marker arrives when it is merged. A new
+									// manifest is not on the branch yet, so Claude Code has
+									// nothing to add until the pull request is merged.
+									if (action === "mark") return { ...out, stop: false };
+									return {
+										...out,
+										patch: {
+											...out.patch,
+											message: `${out.patch?.message ?? "Opened a pull request"}. After it is merged, run \`magus market connect ${args.source}\` to add ${name} to this machine`,
+										},
+									};
+								},
+							}
+						: s,
+				),
+			);
+		} else {
+			lines.push(`${name} is already a company marketplace`);
+		}
+		if (!registered) {
+			lines.push(
+				action === "add"
+					? `Adds ${name} to this machine at USER scope once the marketplace is on ${branch}; if it goes out as a pull request, that waits until it is merged`
+					: `Adds ${name} to this machine at USER scope`,
+			);
+			steps.push(registerStep(name, claudeSource));
+		}
+		if (!trusted) {
+			lines.push(`Marks ${name} as a company marketplace on this machine`);
+		}
+		steps.push(trustStep(name, source, "connect"));
+		if (registered) {
+			lines.push(
+				`Brings Claude Code's copy of ${name} up to date, so magus finds it as a company marketplace`,
+			);
+			steps.push(discoveryStep(name, action, delivered));
+		}
+		if (!github) {
+			lines.push(
+				"Works on this machine only: a project profile cannot record a repository outside GitHub for teammates",
+			);
+		}
+		const plan: MarketPlan = {
+			command,
+			lines,
+			planId: computePlanId({
+				op: "connect",
+				source,
+				commit: head.value.commit,
+				branch,
+				action,
+				name,
+				company,
+				registered,
+			}),
+			summary: { marketplace: name },
+			steps,
+			sync: action === "mark" || action === "add" ? { name, url } : null,
+			lock: name,
+			replan: () => planConnect(args, cwd),
+			doneMessage:
+				`${name} is connected as a company marketplace on this machine. ${github ? teammateNote(name) : ""}`.trim(),
+		};
+		return { kind: "plan", plan };
+	} catch (error) {
+		return planError(command, error);
+	}
+}
+
+// ─── remove ──────────────────────────────────────────────────────────────────
+
+const SCOPE_WORD = {
+	user: "USER",
+	project: "PROJECT",
+	local: "LOCAL",
+} as const;
+
+async function profileNames(cwd: string, name: string): Promise<boolean> {
+	try {
+		if (!fs.existsSync(getManifestPath(cwd))) return false;
+		const manifest = await readManifest(cwd);
+		return Object.values(manifest.profiles).some(
+			(p) =>
+				(p.marketplaces && Object.hasOwn(p.marketplaces, name)) ||
+				Object.keys(p.plugins ?? {}).some((id) => id.endsWith(`@${name}`)),
+		);
+	} catch {
+		// An unreadable profile file only loses this one line of the plan.
+		return false;
+	}
+}
+
+export async function planRemove(
+	name: string,
+	cwd: string,
+): Promise<PlanAnswer> {
+	const command: MarketCommand = "market remove";
+	try {
+		const source = await registeredSource(name);
+		if (!source) {
+			throw new MarketError(
+				"not-found",
+				`${name} is not a marketplace on this machine`,
+				"`magus market list` shows the company marketplaces here",
+			);
+		}
+		if (!(await readTrust()).marketplaces[name]) {
+			throw new MarketError(
+				"not-company",
+				`${name} is not a company marketplace on this machine; magus market removes only those`,
+				"remove other marketplaces with `claude plugin marketplace remove`",
+			);
+		}
+		const installs = (await listPlugins(cwd))
+			.filter((p) => p.id.endsWith(`@${name}`))
+			.map((p) => ({
+				id: p.id,
+				scope: p.scope,
+				version: p.version ?? null,
+				project: p.projectPath ?? null,
+			}));
+		const describe = (i: (typeof installs)[number]) => {
+			const where = i.project ? ` in ${path.basename(i.project)}` : "";
+			const version = i.version ? ` ${i.version}` : "";
+			return `${i.id.split("@")[0]}${version} (${SCOPE_WORD[i.scope]}${where})`;
+		};
+		const lines = [
+			installs.length > 0
+				? `Removing ${name} from this machine uninstalls every plugin from it wherever it is installed: ${installs.map(describe).join(", ")} — and deletes their saved settings and data`
+				: `Removes ${name} from this machine; no plugin from it is installed`,
+			"The GitHub repository is not touched",
+		];
+		if (await profileNames(cwd, name)) {
+			lines.push(
+				`This project's profile lists ${name}: the next \`magus update\` here adds it back`,
+			);
+		}
+		const steps: MarketStep[] = [
+			{
+				id: "unregister",
+				label: `removed ${name} from Claude Code`,
+				outside: true,
+				async run() {
+					await removeMarketplace(name);
+					const rows = await listMarketplaces();
+					if (rows.some((r) => r.name === name)) {
+						throw new MarketError(
+							"other",
+							`Claude Code still lists ${name} after removing it`,
+						);
+					}
+					return undefined;
+				},
+			},
+			{
+				id: "untrust",
+				label: `${name} is no longer a company marketplace here`,
+				outside: true,
+				async run() {
+					return (await untrust(name)) ? undefined : { skipped: true };
+				},
+			},
+			{
+				id: "clone",
+				label: "removed magus's working copy",
+				outside: false,
+				async run() {
+					fs.rmSync(workingClonePath(name), { recursive: true, force: true });
+					return undefined;
+				},
+			},
+			{
+				id: "bases",
+				label: "forgot where local skill copies came from",
+				outside: true,
+				async run() {
+					forgetBasesFor(name);
+					return undefined;
+				},
+			},
+		];
+		const plan: MarketPlan = {
+			command,
+			lines,
+			planId: computePlanId({ op: "remove", name, source, installs }),
+			summary: { marketplace: name },
+			steps,
+			sync: null,
+			lock: name,
+			replan: () => planRemove(name, cwd),
+			doneMessage: `${name} is no longer on this machine. Takes effect in new sessions, or after /reload-plugins.`,
+		};
+		return { kind: "plan", plan };
+	} catch (error) {
+		return planError(command, error);
+	}
+}