@multiplatform.one/cli 7.10.0 → 7.15.0

package/lib/commands/provenance.mjs

@@ -0,0 +1,108 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+//#region src/commands/provenance.ts
+const PROVENANCE_FILE = ".mpo.json";
+function validateName(name) {
+	const trimmed = name.trim();
+	if (!trimmed) throw new Error("Project name is required");
+	if (!/^[a-z][a-z0-9-]*$/.test(trimmed)) throw new Error(`Invalid project name "${trimmed}". Use lowercase letters, numbers, and hyphens (e.g. my-app).`);
+	return trimmed;
+}
+/** Root package.json name with any @scope/ prefix stripped (adopt derives the project name from it). */
+function packageJsonName(projectDir) {
+	try {
+		return JSON.parse(readFileSync(join(projectDir, "package.json"), "utf-8")).name?.replace(/^@[^/]+\//u, "");
+	} catch {
+		return;
+	}
+}
+function cliRoot() {
+	return resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+}
+function cliVersion() {
+	try {
+		return JSON.parse(readFileSync(join(cliRoot(), "package.json"), "utf-8")).version;
+	} catch {
+		return;
+	}
+}
+/** `^x.y.z` for a bare version; explicit ranges pass through. */
+function mpoRange(explicit, fallbackVersion = cliVersion()) {
+	if (explicit) return explicit.startsWith("^") || explicit.startsWith("~") || explicit === "*" ? explicit : `^${explicit}`;
+	return fallbackVersion ? `^${fallbackVersion}` : "^0.0.0";
+}
+function writeProvenance(targetDir, provenance) {
+	const pieces = [...provenance.pieces].sort();
+	const record = provenance.source ? {
+		cliVersion: provenance.cliVersion,
+		source: provenance.source,
+		apps: provenance.apps,
+		services: [...provenance.services].sort(),
+		pieces
+	} : {
+		template: provenance.template ?? "none",
+		cliVersion: provenance.cliVersion,
+		name: provenance.name,
+		mpoVersion: provenance.mpoVersion ?? `^${provenance.cliVersion}`,
+		pieces,
+		...provenance.reconciled === false ? { reconciled: false } : {}
+	};
+	writeFileSync(join(targetDir, PROVENANCE_FILE), `${JSON.stringify(record, null, 2)}\n`);
+}
+/**
+* Reads both shapes: the clone-derived record ({cliVersion, source, apps,
+* services, pieces}) and the older {template, name} record written by
+* `mpo adopt` and the retired template scaffolder.
+*/
+function readProvenance(projectDir) {
+	const file = join(projectDir, PROVENANCE_FILE);
+	if (!existsSync(file)) return void 0;
+	let raw;
+	try {
+		raw = JSON.parse(readFileSync(file, "utf-8"));
+	} catch {
+		return;
+	}
+	if (typeof raw.cliVersion !== "string") return void 0;
+	const strings = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+	const pieces = strings(raw.pieces).sort();
+	const source = raw.source;
+	if (source && typeof source.sha === "string") return {
+		cliVersion: raw.cliVersion,
+		source: {
+			sha: source.sha,
+			...typeof source.url === "string" ? { url: source.url } : {}
+		},
+		apps: strings(raw.apps),
+		services: strings(raw.services).sort(),
+		pieces
+	};
+	const template = raw.template;
+	if (template !== "none" && template !== "universal" && template !== "app") {
+		if (Array.isArray(raw.apps)) return {
+			cliVersion: raw.cliVersion,
+			apps: strings(raw.apps),
+			services: strings(raw.services).sort(),
+			pieces,
+			template: "universal",
+			name: strings(raw.apps)[0]
+		};
+		return;
+	}
+	if (typeof raw.name !== "string") return void 0;
+	return {
+		cliVersion: raw.cliVersion,
+		apps: template === "none" ? [] : [raw.name],
+		services: [],
+		pieces,
+		template,
+		name: raw.name,
+		mpoVersion: typeof raw.mpoVersion === "string" ? raw.mpoVersion : `^${raw.cliVersion}`,
+		...raw.reconciled === false ? { reconciled: false } : {}
+	};
+}
+
+//#endregion
+export { PROVENANCE_FILE, cliRoot, cliVersion, mpoRange, packageJsonName, readProvenance, validateName, writeProvenance };

package/lib/commands/scaffold.mjs

@@ -0,0 +1,105 @@
+import { cliRoot, readProvenance } from "./provenance.mjs";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import spawn from "nano-spawn";
+import { tmpdir } from "node:os";
+
+//#region src/commands/scaffold.ts
+/** The scaffold itself: POSIX sh, runs standalone. The TS commands only call it. */
+function scaffoldScript() {
+	return join(cliRoot(), "scripts/scaffold.sh");
+}
+var ScaffoldError = class extends Error {
+	constructor(message, request) {
+		super(message);
+		this.request = request;
+	}
+};
+/** --into keeps every path the target already had; name them, since mpo update will not touch them. */
+function reportKept(stdout) {
+	const prefix = "skipped (exists): ";
+	const kept = stdout.split("\n").filter((line) => line.startsWith(prefix)).map((line) => line.slice(18));
+	if (!kept.length) return;
+	console.log(`\nKept ${kept.length} path(s) already here, pinned in .updateignore:`);
+	for (const path of kept) console.log(`  ${path}`);
+}
+/** Run scaffold.sh and return the provenance it wrote. */
+async function runScaffold(request) {
+	const args = [scaffoldScript()];
+	for (const app of request.apps) args.push("--app", app);
+	for (const service of request.services) args.push("--service", service);
+	if (request.mpoVersion) args.push("--mpo-version", request.mpoVersion);
+	if (request.into) args.push("--into");
+	if (request.sourceUrl) args.push("--source-url", request.sourceUrl);
+	if (request.name) args.push("--name", request.name);
+	args.push("--", request.source, request.ref, request.target);
+	let stdout = "";
+	try {
+		stdout = (await spawn("sh", args, { stdio: request.verbose ? "inherit" : [
+			"ignore",
+			"pipe",
+			"pipe"
+		] })).stdout;
+	} catch (err) {
+		throw new ScaffoldError(((err.stderr ?? "").trim().split("\n").filter(Boolean).pop() ?? err.message).replace(/^scaffold: /, ""), request);
+	}
+	if (request.into && !request.verbose) reportKept(stdout);
+	const provenance = readProvenance(request.target);
+	if (!provenance?.source) throw new ScaffoldError(`scaffold.sh wrote no provenance into ${request.target}`, request);
+	return provenance;
+}
+/** A scaffold in a temp dir (merge baselines). */
+async function scaffoldToTemp(request) {
+	const parent = mkdtempSync(join(tmpdir(), "mpo-scaffold-"));
+	const dir = join(parent, "project");
+	const cleanup = () => rmSync(parent, {
+		recursive: true,
+		force: true
+	});
+	try {
+		return {
+			dir,
+			provenance: await runScaffold({
+				...request,
+				target: dir
+			}),
+			cleanup
+		};
+	} catch (err) {
+		cleanup();
+		throw err;
+	}
+}
+/**
+* One subtree of the monorepo at a ref, extracted into `dest` (the piece
+* templates of an older CLI version, for adopted-project merge bases).
+*/
+async function archiveSubtree(source, ref, subtree, dest) {
+	await spawn("sh", [
+		"-c",
+		[
+			"set -eu",
+			"SOURCE=\"$1\"; REF=\"$2\"; SUBTREE=\"$3\"; DEST=\"$4\"",
+			"if [ -d \"$SOURCE\" ]; then REPO=\"$SOURCE\"; else",
+			"  REPO=\"$(mktemp -d \"${TMPDIR:-/tmp}/mpo-archive.XXXXXX\")\"",
+			"  trap 'rm -rf \"$REPO\"' EXIT",
+			"  git clone -q --depth 1 --no-checkout --branch \"$REF\" \"$SOURCE\" \"$REPO\"",
+			"  REF=HEAD",
+			"fi",
+			"mkdir -p \"$DEST\"",
+			"git -C \"$REPO\" archive --format=tar \"$REF\" \"$SUBTREE\" | tar -xf - -C \"$DEST\""
+		].join("\n"),
+		"sh",
+		source,
+		ref,
+		subtree,
+		dest
+	], { stdio: [
+		"ignore",
+		"ignore",
+		"pipe"
+	] });
+}
+
+//#endregion
+export { ScaffoldError, archiveSubtree, runScaffold, scaffoldScript, scaffoldToTemp };