magus-cli 7.12.2 → 7.14.0

package/src/services/market-publish.ts

@@ -0,0 +1,468 @@
+/**
+ * market-publish.ts — what happens to a local skill folder around a push:
+ * the sets read from it before, and the two tails after.
+ *
+ * - {@link readSourceSets}: the folder's inventory `S`, the files that will
+ *   be published `P` (with blob ids and their hash `H`), and `N`, every file
+ *   that will not, with the reason.
+ * - {@link moveInstalls}: bring this machine's installs to the version just
+ *   pushed, through `claude plugin` commands only (`advanceViaCli`), after a
+ *   fast-forward of Claude Code's clone.
+ * - {@link removeLocalCopy}: delete the folder only when it holds exactly the
+ *   committed files, file by file; otherwise keep it and say why.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import {
+	readGlobalSettings,
+	readLocalSettings,
+	readSettings,
+} from "./claude-settings.js";
+import { checkIgnore, hashObject } from "./git-write.js";
+import { ORIGIN_FILE, forgetBase } from "./market-bases.js";
+import { advanceViaCli } from "./market-install.js";
+import {
+	type SkillFile,
+	excludedByShape,
+	joinRel,
+	treeHash,
+} from "./market-layout.js";
+import {
+	type InstallRow,
+	type InstallScope,
+	type LocalCopy,
+	MarketError,
+	type NotPublishedReason,
+} from "./market-types.js";
+import { fastForwardCloneIfPresent } from "./marketplace-refresh.js";
+import {
+	buildScopeStatus,
+	isInstalledInScope,
+	readInstalledVersionForScope,
+} from "./plugin-manager.js";
+import { readActiveMarker } from "./profile-live.js";
+
+// ─── Source sets ─────────────────────────────────────────────────────────────
+
+export interface InventoryItem {
+	/** Path inside the folder, with `/`. */
+	path: string;
+	symlink: boolean;
+}
+
+/** Every file and symlink under `folder`, `.magus-origin` left out. */
+export function inventory(folder: string): InventoryItem[] {
+	const out: InventoryItem[] = [];
+	const walk = (dir: string, rel: string) => {
+		for (const d of fs.readdirSync(dir, { withFileTypes: true })) {
+			const childRel = rel ? `${rel}/${d.name}` : d.name;
+			if (childRel === ORIGIN_FILE) continue;
+			if (d.isSymbolicLink()) out.push({ path: childRel, symlink: true });
+			else if (d.isDirectory()) walk(path.join(dir, d.name), childRel);
+			else if (d.isFile()) out.push({ path: childRel, symlink: false });
+		}
+	};
+	walk(folder, "");
+	return out.sort((a, b) => (a.path < b.path ? -1 : 1));
+}
+
+export interface SourceSets {
+	/** The files that will be published, with blob ids. */
+	published: SkillFile[];
+	/** `H`: the hash of {@link published}. */
+	hash: string;
+	notPublished: Array<{ path: string; reason: NotPublishedReason }>;
+	/** True when the folder is not tracked by the project's git at all. */
+	untrackedFolder: boolean;
+}
+
+/**
+ * Read a skill folder's copy set against the marketplace it is going to.
+ * `destRepo` is the local copy of the marketplace the plan read and
+ * `destDir` the skill's directory in it (repository-relative); destination
+ * ignore rules are read there, read-only.
+ */
+export async function readSourceSets(
+	folder: string,
+	destRepo: string,
+	destDir: string,
+	/**
+	 * A top-level folder whose own dot-name does not exclude it: a plugin's
+	 * `.claude-plugin`. What lies inside it is judged by the usual rules.
+	 */
+	keepDotDir?: string,
+): Promise<SourceSets> {
+	const items = inventory(folder);
+	const notPublished: SourceSets["notPublished"] = [];
+	const candidates: string[] = [];
+	for (const item of items) {
+		const judged =
+			keepDotDir && item.path.startsWith(`${keepDotDir}/`)
+				? item.path.slice(keepDotDir.length + 1)
+				: item.path;
+		const shape = excludedByShape(judged, item.symlink);
+		if (shape) notPublished.push({ path: item.path, reason: shape });
+		else candidates.push(item.path);
+	}
+
+	// The project's own ignore rules apply unless the skill folder itself is
+	// ignored: magus ignores the skill folders a profile installs, and every
+	// file would then read as excluded. Outside a work tree there are none.
+	const parent = path.dirname(folder);
+	const base = path.basename(folder);
+	const folderIgnored = await checkIgnore(parent, [base, `${base}/`]);
+	const untrackedFolder = folderIgnored.ok && folderIgnored.value.size > 0;
+	let ignoredHere = new Set<string>();
+	if (!untrackedFolder && candidates.length > 0) {
+		const r = await checkIgnore(folder, candidates);
+		if (r.ok) ignoredHere = r.value;
+	}
+	const afterHere: string[] = [];
+	for (const p of candidates) {
+		if (ignoredHere.has(p))
+			notPublished.push({ path: p, reason: "ignored-here" });
+		else afterHere.push(p);
+	}
+
+	let ignoredThere = new Set<string>();
+	if (afterHere.length > 0) {
+		const r = await checkIgnore(
+			destRepo,
+			afterHere.map((p) => joinRel(destDir, p)),
+		);
+		if (r.ok) ignoredThere = r.value;
+	}
+	const kept: string[] = [];
+	for (const p of afterHere) {
+		if (ignoredThere.has(joinRel(destDir, p))) {
+			notPublished.push({ path: p, reason: "ignored-by-marketplace" });
+		} else {
+			kept.push(p);
+		}
+	}
+
+	const ids = await hashObject(folder, kept);
+	if (!ids.ok) {
+		throw new MarketError(
+			"other",
+			`Could not read the skill's files: ${ids.message}`,
+		);
+	}
+	const published = kept.map((p, i) => ({ path: p, oid: ids.value[i] ?? "" }));
+	return {
+		published,
+		hash: treeHash(published),
+		notPublished: notPublished.sort((a, b) => (a.path < b.path ? -1 : 1)),
+		untrackedFolder,
+	};
+}
+
+// ─── Installs ────────────────────────────────────────────────────────────────
+
+export interface InstalledAt {
+	scope: InstallScope;
+	version: string;
+}
+
+/** The scope's own `enabledPlugins`; an unreadable file turns nothing on. */
+async function enabledAt(
+	scope: InstallScope,
+	cwd: string,
+): Promise<Record<string, boolean>> {
+	try {
+		const settings =
+			scope === "user"
+				? await readGlobalSettings()
+				: scope === "project"
+					? await readSettings(cwd)
+					: await readLocalSettings(cwd);
+		return settings.enabledPlugins ?? {};
+	} catch {
+		return {};
+	}
+}
+
+/**
+ * The version of `pluginId` installed at `scope` for this project, or null
+ * where it is not installed. Installed means what it means everywhere in
+ * magus ({@link isInstalledInScope}): the scope's settings turn the plugin
+ * on. A registry row alone is not an install: it can outlive the setting, or
+ * belong to another checkout. Read-only.
+ */
+export async function installedVersionAt(
+	pluginId: string,
+	scope: InstallScope,
+	cwd: string,
+): Promise<string | null> {
+	const version = await readInstalledVersionForScope(pluginId, scope, cwd);
+	const status = buildScopeStatus(
+		await enabledAt(scope, cwd),
+		version ? { [pluginId]: version } : {},
+		pluginId,
+	);
+	return isInstalledInScope(status) ? (version ?? null) : null;
+}
+
+/** Where this project (or USER) has `pluginId` installed, read-only. */
+export async function installedScopes(
+	pluginId: string,
+	cwd: string,
+): Promise<InstalledAt[]> {
+	const out: InstalledAt[] = [];
+	for (const scope of ["user", "project", "local"] as const) {
+		const version = await installedVersionAt(pluginId, scope, cwd);
+		if (version) out.push({ scope, version });
+	}
+	return out;
+}
+
+export interface MoveResult {
+	installs: InstallRow[];
+	/** True when every scope moved and this folder loads the target. */
+	ok: boolean;
+	loaded: string | null;
+	message?: string;
+	fix?: string;
+}
+
+/**
+ * Move each installed scope to `target`. Claude Code's clone is fast-forwarded
+ * first (`claude plugin update` does not fetch); a clone with local changes,
+ * or one that would not pull, stops the move with its own reason.
+ */
+export async function moveInstalls(
+	marketplace: string,
+	pluginId: string,
+	scopes: readonly InstalledAt[],
+	target: string,
+	cwd: string,
+): Promise<MoveResult> {
+	if (scopes.length === 0) return { installs: [], ok: true, loaded: null };
+	const ff = await fastForwardCloneIfPresent(marketplace);
+	if (ff === "skipped" || ff === "failed") {
+		const message =
+			ff === "skipped"
+				? `Claude Code's copy of ${marketplace} has local changes, so it could not take the new version`
+				: `Claude Code's copy of ${marketplace} could not be brought up to date`;
+		const fix =
+			ff === "skipped"
+				? "discard those changes, then run `magus update`"
+				: "magus update";
+		return {
+			ok: false,
+			loaded: null,
+			message,
+			fix,
+			installs: scopes.map((s) => ({
+				scope: s.scope,
+				from: s.version,
+				to: s.version,
+				status: "failed",
+				message,
+				fix,
+			})),
+		};
+	}
+	const moved = await advanceViaCli(
+		pluginId,
+		scopes.map((s) => s.scope),
+		cwd,
+		target,
+	);
+	return {
+		installs: moved.installs.map((i) => ({
+			scope: i.scope,
+			from: i.from,
+			to: i.to,
+			loaded: i.loaded,
+			status: i.status,
+			...(i.message ? { message: i.message } : {}),
+			...(i.fix ? { fix: i.fix } : {}),
+		})),
+		ok: moved.outcome === "ok",
+		loaded: moved.loaded,
+		...(moved.message ? { message: moved.message } : {}),
+		...(moved.fix ? { fix: moved.fix } : {}),
+	};
+}
+
+// ─── The local copy ──────────────────────────────────────────────────────────
+
+/** True when this project's active profile installs the skill folder `name`. */
+export async function profileManaged(
+	cwd: string,
+	name: string,
+): Promise<boolean> {
+	const marker = await readActiveMarker(cwd);
+	return !!marker && Object.hasOwn(marker.skills ?? {}, name);
+}
+
+/**
+ * The scope whose setting turns `pluginId` off in this project, or null when
+ * it is on here. Claude Code reads LOCAL over PROJECT over USER, so the first
+ * of them that names the plugin decides; one naming it `false` wins over an
+ * install at a lower scope. Read-only.
+ */
+export async function turnedOffHere(
+	pluginId: string,
+	cwd: string,
+): Promise<InstallScope | null> {
+	for (const scope of ["local", "project", "user"] as const) {
+		const flag = (await enabledAt(scope, cwd))[pluginId];
+		if (flag === undefined) continue;
+		return flag === true ? null : scope;
+	}
+	return null;
+}
+
+/** Why the plugin will not replace a local copy here, or null when it will. */
+export async function offHereReason(
+	plugin: string,
+	pluginId: string,
+	cwd: string,
+): Promise<string | null> {
+	const off = await turnedOffHere(pluginId, cwd);
+	return off
+		? `${plugin} does not load in this project (not installed at ${off.toUpperCase()} scope, which comes first), so nothing would replace this copy`
+		: null;
+}
+
+/**
+ * The local-copy tail of a push: remove the copy when the plan predicted it
+ * and every install moved, and the plugin still loads here when read again
+ * now; otherwise keep it with the reason.
+ */
+export async function settleLocalCopy(input: {
+	folder: string;
+	committed: readonly SkillFile[];
+	copy: { scope: "project" | "user"; name: string };
+	keepReason: string | null;
+	moved: boolean;
+	plugin: string;
+	pluginId: string;
+	cwd: string;
+}): Promise<LocalCopy> {
+	const kept = (reason: string): LocalCopy => ({
+		...input.copy,
+		action: "kept",
+		reason,
+	});
+	if (input.keepReason !== null) return kept(input.keepReason);
+	if (!input.moved) return kept("not every install moved");
+	const off = await offHereReason(input.plugin, input.pluginId, input.cwd);
+	if (off !== null) return kept(off);
+	return removeLocalCopy(input.folder, input.committed, input.copy);
+}
+
+/** Does an install at one of `scopes` reach where a copy at `from` loads? */
+export function installReaches(
+	from: "project" | "user",
+	scopes: readonly InstallScope[],
+): boolean {
+	return from === "user" ? scopes.includes("user") : scopes.length > 0;
+}
+
+/**
+ * Why `folder` does not hold exactly `committed` (path and blob id), or null
+ * when it does. Read-only: the removal rule, and its prediction in a plan.
+ * `verb` finishes "holds files that …" ("were not published", "will not be
+ * published").
+ */
+export async function copyMismatch(
+	folder: string,
+	committed: readonly SkillFile[],
+	verb: string,
+): Promise<string | null> {
+	const items = inventory(folder);
+	const expected = new Map(committed.map((f) => [f.path, f.oid]));
+	const extra = items.filter((i) => i.symlink || !expected.has(i.path));
+	if (extra.length > 0) {
+		const names = extra
+			.slice(0, 5)
+			.map((i) => i.path)
+			.join(", ");
+		return `holds files that ${verb}: ${names}${extra.length > 5 ? ", …" : ""}`;
+	}
+	const files = items.map((i) => i.path);
+	if (files.length !== expected.size) return "changed since it was published";
+	const ids = await hashObject(folder, files);
+	if (!ids.ok || files.some((f, i) => expected.get(f) !== ids.value[i])) {
+		return "changed since it was published";
+	}
+	return null;
+}
+
+/**
+ * Remove `folder` when its files, read now, are exactly `committed` (path and
+ * blob id). Files are deleted one by one and directories only when empty;
+ * `.magus-origin` and the base record go last. Anything else keeps the copy.
+ */
+export async function removeLocalCopy(
+	folder: string,
+	committed: readonly SkillFile[],
+	copy: { scope: "project" | "user"; name: string },
+): Promise<LocalCopy> {
+	const kept = (reason: string): LocalCopy => ({
+		...copy,
+		action: "kept",
+		reason,
+	});
+	const mismatch = await copyMismatch(folder, committed, "were not published");
+	if (mismatch) return kept(mismatch);
+	// Delete only the files just verified, never a fresh listing: a file that
+	// appeared after the check was not published and stays. Each one is
+	// checked again first, as a regular file still holding its committed blob.
+	const files = committed.map((f) => f.path);
+	const regular = files.every((f) => {
+		try {
+			return fs.lstatSync(path.join(folder, f)).isFile();
+		} catch {
+			return false;
+		}
+	});
+	const again = regular ? await hashObject(folder, files) : null;
+	if (!again?.ok || committed.some((f, i) => again.value[i] !== f.oid)) {
+		return kept("changed since it was published");
+	}
+	for (const f of files) fs.rmSync(path.join(folder, f), { force: true });
+	// From here the folder no longer holds the published tree. If something
+	// else is left in it, its base and token would describe files that are
+	// gone, so both are dropped and the next publish asks how to compare.
+	const partly = (): LocalCopy => {
+		const left = inventory(folder).map((i) => i.path);
+		forgetBase(folder);
+		fs.rmSync(path.join(folder, ORIGIN_FILE), { force: true });
+		const names = left.slice(0, 5).join(", ");
+		return {
+			...kept(
+				`files appeared while it was removed, so only they are left${names ? `: ${names}${left.length > 5 ? ", …" : ""}` : ""}`,
+			),
+			partial: true,
+		};
+	};
+	const dirs = new Set<string>();
+	for (const f of files) {
+		let d = path.posix.dirname(f);
+		while (d !== "." && d !== "") {
+			dirs.add(d);
+			d = path.posix.dirname(d);
+		}
+	}
+	for (const d of [...dirs].sort((a, b) => b.length - a.length)) {
+		try {
+			fs.rmdirSync(path.join(folder, d));
+		} catch {
+			return partly();
+		}
+	}
+	if (inventory(folder).length > 0) return partly();
+	fs.rmSync(path.join(folder, ORIGIN_FILE), { force: true });
+	forgetBase(folder);
+	try {
+		fs.rmdirSync(folder);
+	} catch {
+		return partly();
+	}
+	return { ...copy, action: "removed" };
+}