magus-cli 7.12.2 → 7.14.0

package/src/services/market-bases.ts

@@ -0,0 +1,191 @@
+/**
+ * market-bases.ts — where each local copy of a company skill came from.
+ *
+ * A base record says which marketplace commit a local skill folder matched:
+ * `{marketplace, repo, plugin, skill, commit, tree, token}`, kept in
+ * `<claude config dir>/magus-market/bases.json` and keyed by the folder's
+ * absolute path (its parent's real path plus the folder name).
+ *
+ * A record is bound to the copy it was made for by a provenance token: every
+ * {@link recordBase} writes a fresh random token into the folder as
+ * `.magus-origin`, then the same token into the record. {@link readBase}
+ * answers the record only while the folder still holds that token, so a
+ * folder recreated by hand, copied from elsewhere or restored from an older
+ * backup has no base. The path alone never gives one.
+ *
+ * Written only by apply steps; reading never writes.
+ */
+
+import { randomBytes } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import {
+	claudeConfigDirOrNull,
+	requireClaudeConfigDir,
+} from "../utils/config-dir.js";
+import { writeFileNoFollow } from "./market-fs.js";
+
+export const ORIGIN_FILE = ".magus-origin";
+const SCHEMA = 1;
+
+export interface BaseRecord {
+	marketplace: string;
+	repo: string;
+	plugin: string;
+	skill: string;
+	/** The marketplace commit the copy matches. */
+	commit: string;
+	/** The skill's tree hash at that commit, over the compare domain. */
+	tree: string;
+	token: string;
+}
+
+interface BasesFile {
+	schema: number;
+	bases: Record<string, BaseRecord>;
+}
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+function basesFile(root: string): string {
+	return path.join(root, "magus-market", "bases.json");
+}
+
+/** The key for a folder: its parent's real path plus its own name. */
+export function folderKey(folder: string): string {
+	const abs = path.resolve(folder);
+	let parent = path.dirname(abs);
+	try {
+		parent = fs.realpathSync(parent);
+	} catch {
+		// A parent that does not exist keys by its plain absolute path.
+	}
+	return path.join(parent, path.basename(abs));
+}
+
+function parse(raw: unknown): BasesFile {
+	const out: BasesFile = { schema: SCHEMA, bases: {} };
+	if (!isRecord(raw) || !isRecord(raw.bases)) return out;
+	for (const [key, v] of Object.entries(raw.bases)) {
+		if (
+			isRecord(v) &&
+			typeof v.marketplace === "string" &&
+			typeof v.repo === "string" &&
+			typeof v.plugin === "string" &&
+			typeof v.skill === "string" &&
+			typeof v.commit === "string" &&
+			typeof v.tree === "string" &&
+			typeof v.token === "string"
+		) {
+			out.bases[key] = {
+				marketplace: v.marketplace,
+				repo: v.repo,
+				plugin: v.plugin,
+				skill: v.skill,
+				commit: v.commit,
+				tree: v.tree,
+				token: v.token,
+			};
+		}
+	}
+	return out;
+}
+
+function readFile(root: string | null): BasesFile {
+	if (!root) return { schema: SCHEMA, bases: {} };
+	try {
+		return parse(JSON.parse(fs.readFileSync(basesFile(root), "utf8")));
+	} catch {
+		return { schema: SCHEMA, bases: {} };
+	}
+}
+
+/** The file for a writer: absent is empty, unparseable refuses to be replaced. */
+function readForWrite(file: string): BasesFile {
+	if (!fs.existsSync(file)) return { schema: SCHEMA, bases: {} };
+	try {
+		return parse(JSON.parse(fs.readFileSync(file, "utf8")));
+	} catch {
+		throw new Error(
+			`The record of where local skill copies came from cannot be read (${file}) — fix or delete it, then run the command again`,
+		);
+	}
+}
+
+function write(file: string, data: BasesFile): void {
+	fs.mkdirSync(path.dirname(file), { recursive: true });
+	const tmp = `${file}.${randomBytes(6).toString("hex")}.tmp`;
+	fs.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}\n`);
+	fs.renameSync(tmp, file);
+}
+
+function readToken(folder: string): string | null {
+	try {
+		return (
+			fs.readFileSync(path.join(folder, ORIGIN_FILE), "utf8").trim() || null
+		);
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * The record for `folder`, or null unless the folder holds `.magus-origin`
+ * with the record's token.
+ */
+export function readBase(folder: string): BaseRecord | null {
+	const record = readFile(claudeConfigDirOrNull()).bases[folderKey(folder)];
+	if (!record) return null;
+	return readToken(folder) === record.token ? record : null;
+}
+
+/** Write a fresh token into `folder`, then the record carrying it. */
+export function recordBase(
+	folder: string,
+	base: Omit<BaseRecord, "token">,
+): BaseRecord {
+	const token = randomBytes(16).toString("hex");
+	// A new file, never written through a link left at that name.
+	writeFileNoFollow(path.join(folder, ORIGIN_FILE), `${token}\n`);
+	const file = basesFile(requireClaudeConfigDir());
+	const data = readForWrite(file);
+	const record = { ...base, token };
+	data.bases[folderKey(folder)] = record;
+	write(file, data);
+	return record;
+}
+
+/** Drop the record for `folder`. True when there was one. */
+export function forgetBase(folder: string): boolean {
+	const root = claudeConfigDirOrNull();
+	if (!root) return false;
+	const file = basesFile(root);
+	const data = readForWrite(file);
+	const key = folderKey(folder);
+	if (!Object.hasOwn(data.bases, key)) return false;
+	delete data.bases[key];
+	write(file, data);
+	return true;
+}
+
+/** Drop every record for `marketplace`, or only those for one plugin's skill. */
+export function forgetBasesFor(
+	marketplace: string,
+	only?: { plugin: string; skill: string },
+): number {
+	const root = claudeConfigDirOrNull();
+	if (!root) return 0;
+	const file = basesFile(root);
+	const data = readForWrite(file);
+	let removed = 0;
+	for (const [key, r] of Object.entries(data.bases)) {
+		if (r.marketplace !== marketplace) continue;
+		if (only && (r.plugin !== only.plugin || r.skill !== only.skill)) continue;
+		delete data.bases[key];
+		removed++;
+	}
+	if (removed > 0) write(file, data);
+	return removed;
+}

package/src/services/market-change.ts

@@ -0,0 +1,242 @@
+/**
+ * market-change.ts — the steps every change to a marketplace repository ends
+ * with: validate, commit exactly the planned paths, deliver.
+ *
+ * The commit is a function of the plan, not of whatever the working clone
+ * holds: only the plan's paths are staged, the staged changes must equal the
+ * plan's file list exactly, and a skill's committed tree is checked against
+ * the files the plan listed before anything is pushed.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { validatePath } from "./claude-cli.js";
+import {
+	addPaths,
+	commit as gitCommit,
+	lsTree,
+	stagedChanges,
+} from "./git-write.js";
+import { ghAvailable, repoForkAllowed, repoPermissions } from "./github-cli.js";
+import { deliver, gitError } from "./market-clone.js";
+import { type LinkError, readJsonUnder, writeJsonUnder } from "./market-fs.js";
+import { type SkillFile, sameFiles } from "./market-layout.js";
+import { isGithubSource } from "./market-registry.js";
+import {
+	type DeliveryTarget,
+	type FileChange,
+	MarketError,
+	type MarketStep,
+	type StepContext,
+} from "./market-types.js";
+
+/** The working clone a step runs in; a plan that syncs always has one. */
+export function cloneOf(ctx: StepContext): string {
+	if (!ctx.clone) throw new MarketError("other", "no working copy to change");
+	return ctx.clone;
+}
+
+/**
+ * The refusal for a write into `label`'s working clone that would pass a
+ * link the repository committed. It stops the step before anything is
+ * written outside the clone.
+ */
+export function linkRefusal(label: string): LinkError {
+	return (link) =>
+		new MarketError(
+			"other",
+			`${label} holds a link at ${link}, and magus does not write through links — nothing was pushed`,
+			"replace the link with a folder in the marketplace repository, then run the command again",
+		);
+}
+
+/**
+ * Write JSON to `rel` in a working clone the way marketplace files are
+ * written (two spaces, newline), refusing a path that passes a link.
+ */
+export function writeJson(
+	clone: string,
+	rel: string,
+	value: unknown,
+	label: string,
+): void {
+	writeJsonUnder(clone, rel, value, linkRefusal(label));
+}
+
+/** Read JSON from `rel` in a working clone, refusing a path through a link. */
+export function readJson(
+	clone: string,
+	rel: string,
+	label: string,
+): Record<string, unknown> {
+	return readJsonUnder(clone, rel, linkRefusal(label));
+}
+
+const LETTER: Record<FileChange, string> = {
+	added: "A",
+	modified: "M",
+	deleted: "D",
+};
+
+/**
+ * How a change can reach the repository, decided at plan time: push (with a
+ * pull request on a protected branch), or a pull request from a fork when
+ * this account cannot push. A repository that allows neither is refused here.
+ */
+export async function deliveryTarget(
+	source: string,
+	label: string,
+): Promise<DeliveryTarget> {
+	if (!isGithubSource(source) || !(await ghAvailable())) return "push-or-pr";
+	const push = await repoPermissions(source);
+	if (!push.ok) {
+		if (push.failure === "gh-auth") {
+			throw new MarketError(
+				"gh-auth",
+				"Not signed in to GitHub",
+				"run `gh auth login`, then `gh auth setup-git`",
+			);
+		}
+		if (push.failure === "not-found") {
+			throw new MarketError(
+				"no-access",
+				`Your GitHub account cannot see ${label} (${source})`,
+				"ask its owner for access",
+			);
+		}
+		if (push.failure === "no-network") {
+			throw new MarketError("no-network", "Could not reach GitHub");
+		}
+		return "push-or-pr";
+	}
+	if (push.value) return "push-or-pr";
+	const fork = await repoForkAllowed(source);
+	if (fork.ok && fork.value) return "fork-pr";
+	throw new MarketError(
+		"fork-not-allowed",
+		`Your account cannot write to ${label}, and it does not allow forks`,
+		"ask its owner for write access",
+	);
+}
+
+/** The plan line for a delivery target. */
+export function targetLine(target: DeliveryTarget, branch: string): string {
+	return target === "push-or-pr"
+		? `Pushes to ${branch}; if ${branch} is protected, opens a pull request instead`
+		: "Opens a pull request from a fork of your own (your account cannot push here)";
+}
+
+export interface ChangeSpec {
+	/** The marketplace's name, for messages. */
+	label: string;
+	source: string;
+	branch: string;
+	target: DeliveryTarget;
+	/** Repository paths to stage — nothing else is. */
+	stage: string[];
+	/** The staged changes the plan expects, exactly. */
+	files: Array<{ path: string; change: FileChange }>;
+	message: string;
+	/** Names a pull-request branch. */
+	slug: string;
+	prBody: string;
+	/** Directories whose committed files must equal these, each. */
+	verify?: ReadonlyArray<{ dir: string; files: readonly SkillFile[] }>;
+	/** Set when the commit is made, for later steps. */
+	state: { commit?: string; pushed?: boolean };
+}
+
+/** `validate`, `commit` and `deliver`, in that order. */
+export function changeSteps(spec: ChangeSpec): MarketStep[] {
+	return [
+		{
+			id: "validate",
+			label: "checked with claude plugin validate",
+			outside: false,
+			async run(ctx) {
+				const r = await validatePath(cloneOf(ctx));
+				if (!r.ok) {
+					throw new MarketError(
+						"validate-failed",
+						`Claude Code does not accept ${spec.label} after this change: ${r.output}`,
+					);
+				}
+				return undefined;
+			},
+		},
+		{
+			id: "commit",
+			label: "committed",
+			outside: false,
+			async run(ctx) {
+				const dir = cloneOf(ctx);
+				const staged = await addPaths(dir, spec.stage);
+				if (!staged.ok) throw gitError(staged, spec.label);
+				const changes = await stagedChanges(dir);
+				if (!changes.ok) throw gitError(changes, spec.label);
+				const want = new Map(spec.files.map((f) => [f.path, LETTER[f.change]]));
+				const matches =
+					changes.value.length === want.size &&
+					changes.value.every((c) => want.get(c.path) === c.status);
+				if (!matches) {
+					throw new MarketError(
+						"other",
+						"the working copy did not match the plan — nothing was pushed",
+					);
+				}
+				const made = await gitCommit(dir, spec.message);
+				if (!made.ok) throw gitError(made, spec.label);
+				for (const check of spec.verify ?? []) {
+					const tree = await lsTree(dir, made.value, check.dir);
+					if (!tree.ok) throw gitError(tree, spec.label);
+					const prefix = `${check.dir}/`;
+					const committed = tree.value.map((e) => ({
+						path: e.path.slice(prefix.length),
+						oid: e.oid,
+					}));
+					if (!sameFiles(committed, check.files)) {
+						throw new MarketError(
+							"other",
+							"the commit did not hold exactly the planned files — nothing was pushed",
+						);
+					}
+				}
+				spec.state.commit = made.value;
+				return {
+					detail: made.value.slice(0, 7),
+					patch: { commit: made.value },
+				};
+			},
+		},
+		{
+			id: "deliver",
+			label: `delivered to ${spec.source}`,
+			outside: true,
+			async run(ctx) {
+				const d = await deliver({
+					clone: cloneOf(ctx),
+					branch: spec.branch,
+					source: spec.source,
+					target: spec.target,
+					slug: spec.slug,
+					title: spec.message,
+					body: spec.prBody,
+					label: spec.label,
+				});
+				if (d.kind === "pushed") {
+					spec.state.pushed = true;
+					return { detail: `pushed to ${spec.branch}` };
+				}
+				return {
+					detail: `pull request opened from ${d.branch}`,
+					stop: true,
+					patch: {
+						outcome: "pull-request",
+						pullRequest: d.url,
+						message: `Opened a pull request — the change lands in ${spec.label} once it is merged: ${d.url}`,
+					},
+				};
+			},
+		},
+	];
+}