create-better-fullstack 2.1.5 → 2.1.6

package/dist/registry-CxeEOPot.mjs

@@ -0,0 +1,394 @@
+#!/usr/bin/env node
+import { r as readBtsConfig, y as types_exports } from "./bts-config-BceXPcpI.mjs";
+import { t as renderTitle } from "./render-title-zvyKC1ej.mjs";
+import { t as CLIError } from "./errors-ns_o2OKg.mjs";
+import { intro, log, outro } from "@clack/prompts";
+import pc from "picocolors";
+import fs from "fs-extra";
+import path from "node:path";
+import * as JSONC from "jsonc-parser";
+import { fileURLToPath } from "node:url";
+import { VirtualFileSystem, processTemplateString } from "@better-fullstack/template-generator";
+import { writeTreeToFilesystem } from "@better-fullstack/template-generator/fs-writer";
+
+//#region src/utils/registry-bts.ts
+const BTS_CONFIG_FILE = "bts.jsonc";
+/**
+* Additively records an installed capability pack in the project's bts.jsonc
+* under a dedicated `capabilityPacks` array (list of "name@version"), plus any
+* addon ids the pack declares under `capabilityPackAddons`.
+*
+* This is intentionally self-contained: it does NOT flow through
+* `updateBtsConfig` (whose typed signature is limited to addons/webDeploy/
+* serverDeploy and would rewrite the derived stack graph). It edits the two
+* dedicated keys in place with JSONC.modify so comments and formatting survive.
+*/
+async function recordPackInBtsConfig(projectDir, manifest) {
+	const configPath = path.join(projectDir, BTS_CONFIG_FILE);
+	if (!await fs.pathExists(configPath)) return;
+	let content = await fs.readFile(configPath, "utf-8");
+	const errors = [];
+	const parsed = JSONC.parse(content, errors, {
+		allowTrailingComma: true,
+		disallowComments: false
+	});
+	if (errors.length > 0 || typeof parsed !== "object" || parsed === null) return;
+	const packRef = `${manifest.name}@${manifest.version}`;
+	const nextPacks = [...(Array.isArray(parsed.capabilityPacks) ? parsed.capabilityPacks : []).filter((entry) => !entry.startsWith(`${manifest.name}@`)), packRef];
+	const existingAddons = Array.isArray(parsed.capabilityPackAddons) ? parsed.capabilityPackAddons : [];
+	const nextAddons = [...new Set([...existingAddons, ...manifest.addons ?? []])];
+	const formattingOptions = {
+		tabSize: 2,
+		insertSpaces: true,
+		eol: "\n"
+	};
+	const packEdit = JSONC.modify(content, ["capabilityPacks"], nextPacks, { formattingOptions });
+	content = JSONC.applyEdits(content, packEdit);
+	if (nextAddons.length > 0) {
+		const addonEdit = JSONC.modify(content, ["capabilityPackAddons"], nextAddons, { formattingOptions });
+		content = JSONC.applyEdits(content, addonEdit);
+	}
+	await fs.writeFile(configPath, content, "utf-8");
+}
+
+//#endregion
+//#region src/helpers/core/registry-handler.ts
+const LOCK_DIR = ".better-fullstack";
+const LOCK_FILE = "registry.json";
+const MANIFEST_FILE = "registry.json";
+/** Preference order for the .env.example a pack's env vars are appended to. */
+const ENV_EXAMPLE_CANDIDATES = ["apps/server/.env.example", ".env.example"];
+/** Formats a ZodError's issues into a single readable message. */
+function formatManifestIssues(error) {
+	return error.issues.map((issue) => {
+		return `  - ${issue.path.length > 0 ? issue.path.join(".") : "(root)"}: ${issue.message}`;
+	}).join("\n");
+}
+/**
+* Resolves a pack source (local path or file:// URL) to its registry.json.
+* The `https` scheme is reserved but intentionally unsupported in the MVP so
+* pack installs stay offline and deterministic.
+*/
+async function resolvePackSource(source) {
+	if (/^https?:\/\//i.test(source)) throw new CLIError(`Remote pack sources are not yet supported (got '${source}'). Use a local path or a file:// URL.`);
+	let candidate;
+	if (source.startsWith("file://")) candidate = fileURLToPath(source);
+	else candidate = path.resolve(source);
+	if (!await fs.pathExists(candidate)) throw new CLIError(`Pack source not found: ${source}`);
+	const manifestPath = (await fs.stat(candidate)).isDirectory() ? path.join(candidate, MANIFEST_FILE) : candidate;
+	if (!await fs.pathExists(manifestPath)) throw new CLIError(`No ${MANIFEST_FILE} found at ${manifestPath}. A capability pack must ship a ${MANIFEST_FILE} manifest.`);
+	return {
+		manifestPath,
+		packDir: path.dirname(manifestPath),
+		resolvedSource: manifestPath
+	};
+}
+/** Reads and validates a pack manifest, raising a clear CLIError on any failure. */
+async function loadPackManifest(manifestPath) {
+	let raw;
+	try {
+		raw = await fs.readFile(manifestPath, "utf-8");
+	} catch (error) {
+		throw new CLIError(`Failed to read pack manifest ${manifestPath}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	let json;
+	try {
+		json = JSON.parse(raw);
+	} catch (error) {
+		throw new CLIError(`Pack manifest ${manifestPath} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const parsed = types_exports.CapabilityPackManifestSchema.safeParse(json);
+	if (!parsed.success) throw new CLIError(`Invalid capability pack manifest (${manifestPath}):\n${formatManifestIssues(parsed.error)}`);
+	return parsed.data;
+}
+function lockPath(projectDir) {
+	return path.join(projectDir, LOCK_DIR, LOCK_FILE);
+}
+/** Reads the per-project registry lockfile, tolerating a missing/empty file. */
+async function readRegistryLock(projectDir) {
+	const file = lockPath(projectDir);
+	if (!await fs.pathExists(file)) return {
+		version: types_exports.REGISTRY_LOCK_VERSION,
+		packs: []
+	};
+	try {
+		const raw = await fs.readFile(file, "utf-8");
+		const parsed = types_exports.RegistryLockSchema.safeParse(JSON.parse(raw));
+		if (!parsed.success) return {
+			version: types_exports.REGISTRY_LOCK_VERSION,
+			packs: []
+		};
+		return parsed.data;
+	} catch {
+		return {
+			version: types_exports.REGISTRY_LOCK_VERSION,
+			packs: []
+		};
+	}
+}
+async function writeRegistryLock(projectDir, lock) {
+	const file = lockPath(projectDir);
+	await fs.ensureDir(path.dirname(file));
+	await fs.writeFile(file, `${JSON.stringify(lock, null, 2)}\n`, "utf-8");
+}
+/** Lists packs recorded as installed in the per-project lockfile. */
+async function listInstalledPacks(projectDir) {
+	return (await readRegistryLock(projectDir)).packs;
+}
+function parseEnvKeys(content) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const line of content.split("\n")) {
+		const match = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=/);
+		if (match?.[1]) keys.add(match[1]);
+	}
+	return keys;
+}
+/** Appends any missing env vars (with optional comment/value) to existing content. */
+function appendEnvVars(content, vars) {
+	const existing = parseEnvKeys(content);
+	const missing = vars.filter((entry) => !existing.has(entry.key));
+	if (missing.length === 0) return {
+		content,
+		keys: []
+	};
+	return {
+		content: `${content}${content.trim().length === 0 ? "" : content.endsWith("\n") ? "\n" : "\n\n"}${missing.map((entry) => {
+			return `${entry.description ? `# ${entry.description}\n` : ""}${entry.key}=${entry.value ?? ""}`;
+		}).join("\n")}\n`,
+		keys: missing.map((entry) => entry.key)
+	};
+}
+async function resolveEnvExamplePath(projectDir) {
+	for (const candidate of ENV_EXAMPLE_CANDIDATES) if (await fs.pathExists(path.join(projectDir, candidate))) return candidate;
+	return ".env.example";
+}
+/**
+* Rejects a capability pack whose resolved target path escapes the project
+* directory (path traversal via `..` segments or an absolute path in the
+* manifest). Applied to both file writes and dependency-map target dirs so a
+* pack can never write outside / mutate sibling projects.
+*/
+function assertPathInsideProject(projectDir, targetAbs, label) {
+	const rel = path.relative(projectDir, targetAbs);
+	if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) throw new CLIError(`Capability pack ${label} escapes the project directory and was rejected: ${targetAbs}`);
+}
+/**
+* Merges a pack's dependencies/devDependencies into the target package.json
+* files. Pack dependency versions are arbitrary name->version pairs, so they
+* are merged directly (they cannot flow through addPackageDependency, which is
+* restricted to the AvailableDependencies enum).
+*/
+async function planDependencyChanges(projectDir, manifest) {
+	const changes = [];
+	const writes = /* @__PURE__ */ new Map();
+	const groups = [{
+		map: manifest.dependencies,
+		dev: false
+	}, {
+		map: manifest.devDependencies,
+		dev: true
+	}];
+	for (const { map, dev } of groups) {
+		if (!map) continue;
+		for (const [dir, deps] of Object.entries(map)) {
+			if (Object.keys(deps).length === 0) continue;
+			const pkgRelPath = path.join(dir === "." ? "" : dir, "package.json");
+			const pkgAbsPath = path.join(projectDir, pkgRelPath);
+			assertPathInsideProject(projectDir, pkgAbsPath, `dependency target "${dir}"`);
+			if (!await fs.pathExists(pkgAbsPath)) throw new CLIError(`Pack targets ${pkgRelPath} which does not exist in this project. Cannot merge dependencies.`);
+			const pkgJson = writes.get(pkgAbsPath) ?? await fs.readJson(pkgAbsPath);
+			const field = dev ? "devDependencies" : "dependencies";
+			const bucket = { ...pkgJson[field] };
+			for (const [name, version] of Object.entries(deps)) {
+				bucket[name] = version;
+				changes.push({
+					dir,
+					name,
+					version,
+					dev
+				});
+			}
+			pkgJson[field] = bucket;
+			writes.set(pkgAbsPath, pkgJson);
+		}
+	}
+	return {
+		changes,
+		writes
+	};
+}
+/**
+* Installs a capability pack into an existing Better Fullstack project.
+*
+* Reuses the same building blocks as the `add` handler: readBtsConfig to assert
+* a real project, the template-generator VFS + writeTreeToFilesystem to stage
+* and write files, and processTemplateString to render templated files.
+*/
+async function addPack(options) {
+	const projectDir = path.resolve(options.projectDir);
+	const dryRun = options.dryRun ?? false;
+	const btsConfig = await readBtsConfig(projectDir);
+	if (!btsConfig) throw new CLIError(`No Better Fullstack project found in ${projectDir}. Make sure bts.jsonc exists.`);
+	const { manifestPath, resolvedSource } = await resolvePackSource(options.source);
+	const manifest = await loadPackManifest(manifestPath);
+	const templateContext = btsConfig;
+	const vfs = new VirtualFileSystem();
+	const filesWritten = [];
+	const filesSkipped = [];
+	for (const file of manifest.files) {
+		const normalized = file.path.replaceAll("\\", "/").replace(/^\.\//, "");
+		const targetAbs = path.join(projectDir, normalized);
+		assertPathInsideProject(projectDir, targetAbs, `file path "${file.path}"`);
+		if (!file.overwrite && await fs.pathExists(targetAbs)) {
+			filesSkipped.push(normalized);
+			continue;
+		}
+		const content = file.template ? processTemplateString(file.content, templateContext) : file.content;
+		vfs.writeFile(normalized, content);
+		filesWritten.push(normalized);
+	}
+	const { changes: dependencies, writes: packageJsonWrites } = await planDependencyChanges(projectDir, manifest);
+	let envFile;
+	let envKeys = [];
+	let envContent;
+	if (manifest.env.length > 0) {
+		envFile = await resolveEnvExamplePath(projectDir);
+		const envAbs = path.join(projectDir, envFile);
+		const merged = appendEnvVars(await fs.pathExists(envAbs) ? await fs.readFile(envAbs, "utf-8") : "", manifest.env);
+		envKeys = merged.keys;
+		if (merged.keys.length > 0) envContent = merged.content;
+		else envFile = void 0;
+	}
+	if (dryRun) return {
+		pack: {
+			name: manifest.name,
+			version: manifest.version
+		},
+		source: resolvedSource,
+		filesWritten,
+		filesSkipped,
+		dependencies,
+		envKeys,
+		envFile,
+		dryRun: true
+	};
+	if (filesWritten.length > 0) await writeTreeToFilesystem({
+		root: vfs.toTree(manifest.name),
+		fileCount: vfs.getFileCount(),
+		directoryCount: vfs.getDirectoryCount(),
+		config: templateContext
+	}, projectDir);
+	for (const [pkgAbsPath, pkgJson] of packageJsonWrites) await fs.writeJson(pkgAbsPath, pkgJson, { spaces: 2 });
+	if (envFile && envContent !== void 0) await fs.writeFile(path.join(projectDir, envFile), envContent, "utf-8");
+	const lock = await readRegistryLock(projectDir);
+	const installed = {
+		name: manifest.name,
+		version: manifest.version,
+		source: resolvedSource,
+		files: filesWritten,
+		installedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	lock.version = types_exports.REGISTRY_LOCK_VERSION;
+	lock.packs = [...lock.packs.filter((pack) => pack.name !== manifest.name), installed];
+	await writeRegistryLock(projectDir, lock);
+	await recordPackInBtsConfig(projectDir, manifest);
+	return {
+		pack: {
+			name: manifest.name,
+			version: manifest.version
+		},
+		source: resolvedSource,
+		filesWritten,
+		filesSkipped,
+		dependencies,
+		envKeys,
+		envFile,
+		dryRun: false
+	};
+}
+
+//#endregion
+//#region src/commands/registry.ts
+function formatCount(count, noun) {
+	return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+function reportAddResult(result) {
+	const label = result.dryRun ? "[dry run] Would install" : "Installed";
+	log.info(pc.cyan(`${label} ${result.pack.name}@${result.pack.version}`));
+	const fileLabel = result.dryRun ? "would write" : "wrote";
+	log.message(pc.dim(`Files: ${fileLabel} ${formatCount(result.filesWritten.length, "file")}` + (result.filesSkipped.length > 0 ? `, skipped ${formatCount(result.filesSkipped.length, "existing file")}` : "")));
+	for (const file of result.filesWritten) log.message(pc.dim(`  + ${file}`));
+	for (const file of result.filesSkipped) log.message(pc.dim(`  = ${file} (exists, not overwritten)`));
+	if (result.dependencies.length > 0) {
+		log.message(pc.dim(`Dependencies: ${formatCount(result.dependencies.length, "change")}`));
+		for (const dep of result.dependencies) log.message(pc.dim(`  + ${dep.dir}: ${dep.name}@${dep.version}${dep.dev ? " (dev)" : ""}`));
+	}
+	if (result.envKeys.length > 0 && result.envFile) {
+		log.message(pc.dim(`Env: ${formatCount(result.envKeys.length, "var")} -> ${result.envFile}`));
+		for (const key of result.envKeys) log.message(pc.dim(`  + ${key}`));
+	}
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function reportJsonError(error) {
+	console.log(JSON.stringify({
+		ok: false,
+		error: errorMessage(error)
+	}, null, 2));
+	process.exitCode = 1;
+}
+async function registryHandler(input) {
+	const projectDir = path.resolve(input.projectDir || process.cwd());
+	if (input.action === "list") {
+		const packs = await listInstalledPacks(projectDir);
+		if (input.json) {
+			console.log(JSON.stringify(packs, null, 2));
+			return;
+		}
+		renderTitle();
+		intro(pc.magenta("Installed capability packs"));
+		if (packs.length === 0) {
+			log.info(pc.dim("No capability packs installed. Add one with `registry add <source>`."));
+			outro(pc.magenta("Nothing installed."));
+			return;
+		}
+		for (const pack of packs) log.message(`${pc.bold(pack.name)}@${pack.version} ${pc.dim(`(${formatCount(pack.files.length, "file")}, from ${pack.source})`)}`);
+		outro(pc.magenta(`${formatCount(packs.length, "pack")} installed.`));
+		return;
+	}
+	if (!input.source) {
+		const error = new CLIError("registry add requires a <source> (a local path or file:// URL to a capability pack).");
+		if (input.json) {
+			reportJsonError(error);
+			return;
+		}
+		throw error;
+	}
+	const dryRun = input.dryRun ?? false;
+	let result;
+	try {
+		result = await addPack({
+			projectDir,
+			source: input.source,
+			dryRun
+		});
+	} catch (error) {
+		if (input.json) {
+			reportJsonError(error);
+			return;
+		}
+		throw error;
+	}
+	if (input.json) {
+		console.log(JSON.stringify(result, null, 2));
+		return;
+	}
+	renderTitle();
+	intro(pc.magenta(dryRun ? "Preview capability pack install" : "Install capability pack"));
+	reportAddResult(result);
+	outro(pc.magenta(dryRun ? "Dry run complete. No files were written." : "Capability pack installed."));
+}
+
+//#endregion
+export { registryHandler };

package/dist/run-3AkXloH1.mjs

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import "./bts-config-BceXPcpI.mjs";
+import { a as createBtsCli, c as history, d as telemetry, f as update, i as create, l as router, n as builder, o as docs, r as check, s as doctor, t as add, u as sponsors } from "./run-D80ZtSO8.mjs";
+import "./render-title-zvyKC1ej.mjs";
+import "./errors-ns_o2OKg.mjs";
+import "./addons-setup-C_lxdJqU.mjs";
+import "./file-formatter-XU6ti05V.mjs";
+import "./install-dependencies-DHoYa3P-.mjs";
+import "./generated-checks-Dt4Xqp1x.mjs";
+import "./config-processing-B_1wTe3g.mjs";
+import "./scaffold-manifest-GV1fbhpD.mjs";
+
+export { createBtsCli };