@django-stack/cli 0.0.0-stage → 0.1.0

package/dist/stack-OTrWHXrO.js

@@ -0,0 +1,712 @@
+import { createRequire } from "node:module";
+import { execFileSync } from "node:child_process";
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { randomBytes } from "node:crypto";
+import { fileURLToPath } from "node:url";
+// src/env.ts
+/** Reads a .env file: KEY=value lines, comments and blank lines ignored. */
+function parseEnv(text) {
+	const values = {};
+	for (const line of text.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const index = trimmed.indexOf("=");
+		if (index <= 0) continue;
+		let value = trimmed.slice(index + 1).trim();
+		if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+		values[trimmed.slice(0, index).trim()] = value;
+	}
+	return values;
+}
+/** Sets KEY=value lines in .env text, replacing existing ones and appending new ones. */
+function setEnvValues(text, values) {
+	let result = text;
+	for (const [key, value] of Object.entries(values)) {
+		const pattern = new RegExp(`^${key}=.*$`, "m");
+		result = pattern.test(result) ? result.replace(pattern, () => `${key}=${value}`) : `${result.trimEnd()}\n${key}=${value}\n`;
+	}
+	return result;
+}
+// src/doctor.ts
+const REQUIRED_KEYS = [
+	"DJANGO_SECRET_KEY",
+	"DATABASE_URL",
+	"API_SECRET_KEY",
+	"API_READ_KEY",
+	"PREVIEW_SECRET",
+	"REVALIDATE_SECRET",
+	"SITE_URL"
+];
+function command(cmd, args, cwd) {
+	try {
+		return execFileSync(cmd, args, {
+			cwd,
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+	} catch {
+		return;
+	}
+}
+async function fetchStatus(url, headers = {}) {
+	try {
+		return (await fetch(url, {
+			headers,
+			redirect: "manual",
+			signal: AbortSignal.timeout(5e3)
+		})).status;
+	} catch {
+		return;
+	}
+}
+/** Checks a project directory: tools, .env, and the running services. */
+async function runDoctor(directory) {
+	const checks = [];
+	const docker = command("docker", [
+		"version",
+		"--format",
+		"{{.Server.Version}}"
+	]);
+	checks.push({
+		name: "Docker is running",
+		ok: Boolean(docker),
+		detail: docker ? `Docker ${docker}` : "Install Docker and start it: https://docs.docker.com/get-docker/"
+	});
+	const compose = command("docker", [
+		"compose",
+		"version",
+		"--short"
+	]);
+	checks.push({
+		name: "Docker Compose v2",
+		ok: Boolean(compose),
+		detail: compose ? `Compose ${compose}` : "Docker Compose v2 is part of Docker Desktop and the docker-compose-plugin package."
+	});
+	const envPath = join(directory, ".env");
+	if (!existsSync(envPath)) {
+		checks.push({
+			name: ".env exists",
+			ok: false,
+			detail: "Run the doctor in the project directory, or copy .env.example to .env."
+		});
+		return checks;
+	}
+	const env = parseEnv(readFileSync(envPath, "utf8"));
+	const missing = REQUIRED_KEYS.filter((key) => !env[key]);
+	checks.push({
+		name: ".env has the required values",
+		ok: missing.length === 0,
+		detail: missing.length ? `Missing: ${missing.join(", ")}` : void 0
+	});
+	checks.push({
+		name: "The API keys differ",
+		ok: Boolean(env.API_SECRET_KEY) && env.API_SECRET_KEY !== env.API_READ_KEY,
+		detail: "API_SECRET_KEY has full access and API_READ_KEY only reads; they must not be the same."
+	});
+	if ([
+		"1",
+		"true",
+		"yes",
+		"on"
+	].includes((env.DJANGO_DEBUG ?? "").toLowerCase()) && env.SITE_URL?.startsWith("https://")) checks.push({
+		name: "Debug is off for an https site",
+		ok: false,
+		detail: "Set DJANGO_DEBUG=0 in production."
+	});
+	const prod = (env.COMPOSE_PROFILES ?? "").split(",").map((profile) => profile.trim()).includes("prod");
+	if (prod) {
+		checks.push({
+			name: "SITE_URL is https",
+			ok: (env.SITE_URL ?? "").startsWith("https://"),
+			detail: "In production SITE_URL is https://your-domain; Caddy gets the certificate for it."
+		});
+		checks.push({
+			name: "Mail goes to an SMTP server",
+			ok: Boolean(env.EMAIL_URL) && !env.EMAIL_URL?.includes("mailpit") && !env.EMAIL_URL?.includes("example.com"),
+			detail: "Set EMAIL_URL to your SMTP server; Mailpit only runs in development."
+		});
+	}
+	const running = command("docker", [
+		"compose",
+		"ps",
+		"--services",
+		"--filter",
+		"status=running"
+	], directory);
+	const services = running ? running.split("\n").filter(Boolean) : [];
+	const backendService = prod ? "backend-prod" : "backend";
+	const frontendService = prod ? "frontend-prod" : "frontend";
+	checks.push({
+		name: "Services are running",
+		ok: services.includes(backendService) && services.includes(frontendService),
+		warning: services.length === 0,
+		detail: services.length ? services.join(", ") : `Nothing is running. Start the project with \`docker compose up${prod ? " -d" : ""}\`.`
+	});
+	if (services.length === 0) return checks;
+	const health = command("docker", [
+		"compose",
+		"ps",
+		backendService,
+		"--format",
+		"{{.Health}}"
+	], directory);
+	checks.push({
+		name: "The backend is healthy",
+		ok: health === "healthy",
+		detail: health ? `The ${backendService} container is ${health}` : `See \`docker compose logs ${backendService}\`.`
+	});
+	const site = (env.SITE_URL ?? "http://localhost:3000").replace(/\/$/, "");
+	const frontend = await fetchStatus(site);
+	checks.push({
+		name: "The site answers",
+		ok: frontend !== void 0 && frontend < 500,
+		detail: frontend ? `${site} answered ${frontend}` : `No answer on ${site}. See \`docker compose logs ${prod ? "proxy" : frontendService}\`.`
+	});
+	const api = await fetchStatus(`${site}/api/content.sitesettings`, { "X-Secret-Key": env.API_READ_KEY ?? "" });
+	checks.push({
+		name: "The read-only key reads the API",
+		ok: api === 200,
+		detail: api ? `${site}/api answered ${api}` : "No answer from the API."
+	});
+	const closed = await fetchStatus(`${site}/api/content.sitesettings`);
+	checks.push({
+		name: "The API is closed without a key",
+		ok: closed === 401 || closed === 403,
+		detail: closed ? `The API answered ${closed} without a key` : void 0
+	});
+	return checks;
+}
+// src/secrets.ts
+/** A URL-safe random secret with `bytes` bytes of randomness. */
+function generateSecret(bytes = 32) {
+	return randomBytes(bytes).toString("base64url");
+}
+/** The secrets a project's .env needs, by the name used in `{{secret:<name>}}`. */
+function generateProjectSecrets() {
+	return {
+		django: generateSecret(48),
+		postgres: generateSecret(24),
+		api: generateSecret(32),
+		api_read: generateSecret(32),
+		preview: generateSecret(32),
+		revalidate: generateSecret(32),
+		admin: generateSecret(12)
+	};
+}
+// src/production.ts
+function validateDomain(domain) {
+	if (!/^(?=.{1,253}$)([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/i.test(domain)) return "Enter a domain name such as example.com, without https://.";
+}
+/**
+* The .env for a server, from a project's development .env: the prod
+* profile, HTTPS on the domain, and fresh secrets, so nothing from the
+* laptop works on the server.
+*/
+function productionEnv(devEnv, options) {
+	const domainError = validateDomain(options.domain);
+	if (domainError) throw new Error(domainError);
+	const current = parseEnv(devEnv);
+	const secrets = generateProjectSecrets();
+	const url = `https://${options.domain.toLowerCase()}`;
+	const todo = [];
+	const profiles = (current.COMPOSE_PROFILES ?? "dev,db").split(",").map((profile) => profile.trim()).filter((profile) => profile && profile !== "dev" && profile !== "s3");
+	profiles.unshift("prod");
+	const values = {
+		COMPOSE_PROFILES: [...new Set(profiles)].join(","),
+		SITE_URL: url,
+		BACKEND_URL: url,
+		DJANGO_DEBUG: "0",
+		DJANGO_SECRET_KEY: secrets.django ?? "",
+		API_SECRET_KEY: secrets.api ?? "",
+		API_READ_KEY: secrets.api_read ?? "",
+		PREVIEW_SECRET: secrets.preview ?? "",
+		REVALIDATE_SECRET: secrets.revalidate ?? "",
+		ADMIN_PASSWORD: secrets.admin ?? "",
+		DEFAULT_FROM_EMAIL: `${current.PROJECT_NAME ?? "site"} <noreply@${options.domain.toLowerCase()}>`
+	};
+	if (profiles.includes("db")) {
+		const user = current.POSTGRES_USER || "app";
+		const name = current.POSTGRES_DB || "app";
+		values.POSTGRES_PASSWORD = secrets.postgres ?? "";
+		values.DATABASE_URL = `postgres://${user}:${secrets.postgres}@db:5432/${name}`;
+	}
+	if (options.emailUrl) values.EMAIL_URL = options.emailUrl;
+	else if (!current.EMAIL_URL || current.EMAIL_URL.includes("mailpit")) {
+		values.EMAIL_URL = "smtp+tls://user:password@smtp.example.com:587";
+		todo.push("Set EMAIL_URL to your SMTP server, so password resets and notifications are sent.");
+	}
+	if ((current.S3_ENDPOINT_URL ?? "").includes("s3:8333")) {
+		Object.assign(values, {
+			S3_BUCKET: "",
+			S3_ENDPOINT_URL: "",
+			S3_REGION: "",
+			S3_ACCESS_KEY_ID: "",
+			S3_SECRET_ACCESS_KEY: "",
+			S3_PUBLIC_URL: "",
+			S3_CREATE_BUCKET: "0"
+		});
+		todo.push("Set the S3_* variables to your S3 service, or leave them empty to keep uploads on the server.");
+	}
+	if (!current.ADMIN_EMAIL || current.ADMIN_EMAIL.endsWith("@example.com")) todo.push("Set ADMIN_EMAIL to your address.");
+	if (current.SEED_DEMO_CONTENT === "1") todo.push("Set SEED_DEMO_CONTENT=0 unless the site should start with the demo pages and posts.");
+	return {
+		text: setEnvValues(devEnv, values),
+		adminPassword: values.ADMIN_PASSWORD ?? "",
+		todo
+	};
+}
+// src/version.ts
+/** The version of this package, the same for every @django-stack package. */
+const CLI_VERSION = createRequire(import.meta.url)("../package.json").version;
+// src/scaffold.ts
+const FRONTENDS = ["astro"];
+/** The local S3 service of the `s3` profile. It accepts any credentials. */
+const LOCAL_S3 = {
+	S3_BUCKET: "media",
+	S3_ENDPOINT_URL: "http://s3:8333",
+	S3_REGION: "us-east-1",
+	S3_ACCESS_KEY_ID: "local",
+	S3_SECRET_ACCESS_KEY: "local",
+	S3_PUBLIC_URL: "http://localhost:8333/media",
+	S3_CREATE_BUCKET: "1"
+};
+const TEXT_EXTENSIONS = /\.(py|ts|mjs|js|json|astro|css|md|yaml|yml|toml|txt|html|sh|svg)$|Dockerfile$|gitignore$|\.dockerignore$|env\.example$/;
+function defaultTemplatesDir() {
+	return fileURLToPath(new URL("../templates", import.meta.url));
+}
+/** A valid project name from a directory name: `My Site` becomes `my-site`. */
+function toProjectName(value) {
+	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
+}
+function validateProjectName(value) {
+	if (!/^[a-z][a-z0-9-]{0,49}$/.test(value)) return "Use lowercase letters, digits and dashes, starting with a letter.";
+}
+/** Postgres URLs for hosts other than this machine must use TLS. */
+function normalizeDatabaseUrl(url) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		throw new Error(`The database URL is not a URL: ${url}`);
+	}
+	if (!["postgres:", "postgresql:"].includes(parsed.protocol)) throw new Error("The database URL must start with postgres:// or postgresql://.");
+	if (![
+		"localhost",
+		"127.0.0.1",
+		"host.docker.internal",
+		"db"
+	].includes(parsed.hostname) && !parsed.searchParams.has("sslmode")) parsed.searchParams.set("sslmode", "require");
+	return parsed.toString();
+}
+function walk(directory) {
+	return readdirSync(directory).flatMap((entry) => {
+		const path = join(directory, entry);
+		return statSync(path).isDirectory() ? walk(path) : [path];
+	});
+}
+function render(text, values) {
+	return text.replace(/\{\{([a-z_]+)\}\}/g, (match, key) => values[key] ?? match);
+}
+/** The IANA time zones Node knows, with UTC first. */
+function timeZones() {
+	return ["UTC", ...Intl.supportedValuesOf("timeZone").filter((zone) => zone !== "UTC")];
+}
+function validateTimeZone(value) {
+	if (timeZones().includes(value)) return void 0;
+	return `${JSON.stringify(value)} is not a time zone. Use a name such as Europe/Amsterdam or UTC.`;
+}
+function scaffold(options) {
+	const templates = options.templatesDir ?? defaultTemplatesDir();
+	const target = options.directory;
+	if (existsSync(target) && readdirSync(target).length > 0) throw new Error(`${target} exists and is not empty. Choose another directory.`);
+	const nameError = validateProjectName(options.name);
+	if (nameError) throw new Error(`The project name ${JSON.stringify(options.name)} is not valid. ${nameError}`);
+	if (options.timeZone) {
+		const zoneError = validateTimeZone(options.timeZone);
+		if (zoneError) throw new Error(zoneError);
+	}
+	mkdirSync(target, { recursive: true });
+	cpSync(join(templates, "base"), target, { recursive: true });
+	cpSync(join(templates, "backend"), join(target, "backend"), { recursive: true });
+	cpSync(join(templates, `frontend-${options.frontend}`), join(target, "frontend"), { recursive: true });
+	renameSync(join(target, "gitignore"), join(target, ".gitignore"));
+	const values = {
+		project_name: options.name,
+		frontend: options.frontend,
+		cli_version: CLI_VERSION,
+		preset: options.preset ?? "a"
+	};
+	const files = walk(target);
+	for (const file of files) {
+		if (!TEXT_EXTENSIONS.test(file)) continue;
+		const text = readFileSync(file, "utf8");
+		const rendered = render(text, values);
+		if (rendered !== text) writeFileSync(file, rendered);
+	}
+	if (options.timeZone && options.timeZone !== "UTC") {
+		const settings = join(target, "backend", "config", "settings.py");
+		const text = readFileSync(settings, "utf8");
+		writeFileSync(settings, text.replace("TIME_ZONE = \"UTC\"", `TIME_ZONE = ${JSON.stringify(options.timeZone)}`));
+	}
+	const template = readFileSync(join(target, "env.example"), "utf8");
+	const secrets = generateProjectSecrets();
+	let env = template.replace(/\{\{secret:([a-z_]+)\}\}/g, (match, key) => secrets[key] ?? match);
+	const envExample = template.replace(/\{\{secret:[a-z_]+\}\}/g, "");
+	const profiles = ["dev"];
+	if (options.databaseUrl) env = setEnvValues(env, { DATABASE_URL: normalizeDatabaseUrl(options.databaseUrl) });
+	else profiles.push("db");
+	if (options.localS3) {
+		profiles.push("s3");
+		env = setEnvValues(env, LOCAL_S3);
+	}
+	env = setEnvValues(env, { COMPOSE_PROFILES: profiles.join(",") });
+	if (!options.demoContent) env = setEnvValues(env, { SEED_DEMO_CONTENT: "0" });
+	writeFileSync(join(target, ".env"), env, { mode: 384 });
+	writeFileSync(join(target, ".env.example"), envExample);
+	rmSync(join(target, "env.example"));
+	if (options.link) linkPackages(target, options.link);
+	return {
+		directory: target,
+		adminUsername: "admin",
+		adminPassword: secrets.admin ?? "",
+		files: walk(target).length
+	};
+}
+/**
+* Development only: build django-stack and @django-stack/utils from a
+* monorepo checkout into the project's vendor/ directories and point the
+* dependencies at them, so a project can run before a release.
+*/
+function linkPackages(target, monorepo) {
+	const backendVendor = join(target, "backend", "vendor");
+	const frontendVendor = join(target, "frontend", "vendor");
+	mkdirSync(backendVendor, { recursive: true });
+	mkdirSync(frontendVendor, { recursive: true });
+	execFileSync("uv", [
+		"build",
+		"--wheel",
+		"--out-dir",
+		backendVendor
+	], {
+		cwd: join(monorepo, "python", "django-stack"),
+		stdio: "ignore"
+	});
+	rmSync(join(backendVendor, ".gitignore"), { force: true });
+	const wheel = readdirSync(backendVendor).find((file) => file.endsWith(".whl"));
+	if (!wheel) throw new Error("Building the django-stack wheel failed.");
+	const pyproject = join(target, "backend", "pyproject.toml");
+	writeFileSync(pyproject, `${readFileSync(pyproject, "utf8").trimEnd()}\n\n[tool.uv.sources]\ndjango-stack = { path = "vendor/${wheel}" }\n`);
+	execFileSync("pnpm", [
+		"--filter",
+		"@django-stack/utils",
+		"build"
+	], {
+		cwd: monorepo,
+		stdio: "ignore"
+	});
+	execFileSync("pnpm", [
+		"pack",
+		"--pack-destination",
+		frontendVendor
+	], {
+		cwd: join(monorepo, "packages", "utils"),
+		stdio: "ignore"
+	});
+	const tarball = readdirSync(frontendVendor).find((file) => file.endsWith(".tgz"));
+	if (!tarball) throw new Error("Packing @django-stack/utils failed.");
+	const packageJson = join(target, "frontend", "package.json");
+	const manifest = JSON.parse(readFileSync(packageJson, "utf8"));
+	manifest.dependencies["@django-stack/utils"] = `file:vendor/${tarball}`;
+	writeFileSync(packageJson, `${JSON.stringify(manifest, null, 2)}\n`);
+}
+/** Locks the backend's dependencies with uv, when uv is installed. */
+function lockBackend(target) {
+	try {
+		execFileSync("uv", ["lock", "--quiet"], {
+			cwd: join(target, "backend"),
+			stdio: "ignore"
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+function relativeDirectory(directory) {
+	const path = relative(process.cwd(), directory) || ".";
+	return path.startsWith("..") ? directory : path;
+}
+// src/stack.ts
+const STACK_OPTIONS = [
+	{
+		key: "frontend",
+		flag: "--frontend",
+		message: "Frontend",
+		description: "The frontend framework",
+		values: [
+			{
+				value: "astro",
+				label: "Astro",
+				hint: "server-rendered, fast by default",
+				generated: true
+			},
+			{
+				value: "next",
+				label: "Next.js",
+				hint: "React, server components",
+				generated: false
+			},
+			{
+				value: "headless",
+				label: "Headless",
+				hint: "just the API and the admin",
+				generated: false
+			},
+			{
+				value: "templates",
+				label: "Django templates",
+				hint: "no Node, Django renders the site",
+				generated: false
+			}
+		]
+	},
+	{
+		key: "postgres",
+		flag: "--postgres",
+		message: "Postgres version",
+		description: "The bundled Postgres version",
+		values: [{
+			value: "stable",
+			label: "Stable",
+			hint: "Postgres 17",
+			generated: true
+		}, {
+			value: "latest",
+			label: "Latest",
+			hint: "Postgres 18",
+			generated: false
+		}]
+	},
+	{
+		key: "analytics",
+		flag: "--analytics",
+		message: "Analytics",
+		description: "Page analytics",
+		values: [{
+			value: "umami",
+			label: "Umami",
+			hint: "built in, private, no cookies",
+			generated: false
+		}, {
+			value: "off",
+			label: "Off",
+			generated: true
+		}]
+	},
+	{
+		key: "tasks",
+		flag: "--tasks",
+		message: "Background tasks",
+		description: "The task queue",
+		values: [{
+			value: "huey",
+			label: "Huey",
+			hint: "a worker container with Valkey",
+			generated: true
+		}, {
+			value: "off",
+			label: "Off",
+			generated: false
+		}]
+	},
+	{
+		key: "cache",
+		flag: "--cache",
+		message: "Cache",
+		description: "The cache backend",
+		values: [
+			{
+				value: "database",
+				label: "Database",
+				hint: "a Postgres table, nothing extra to run",
+				generated: false
+			},
+			{
+				value: "valkey",
+				label: "Valkey",
+				hint: "in memory, Redis-compatible",
+				generated: false
+			},
+			{
+				value: "off",
+				label: "Off",
+				generated: false
+			}
+		]
+	},
+	{
+		key: "notifications",
+		flag: "--notifications",
+		message: "Notifications",
+		description: "Notifications in the admin and by email",
+		values: [{
+			value: "on",
+			label: "On",
+			hint: "in the admin and by email",
+			generated: false
+		}, {
+			value: "off",
+			label: "Off",
+			generated: true
+		}]
+	},
+	{
+		key: "captcha",
+		flag: "--captcha",
+		message: "Captcha",
+		description: "The built-in captcha for forms",
+		values: [{
+			value: "on",
+			label: "On",
+			hint: "proof of work, no tracking",
+			generated: false
+		}, {
+			value: "off",
+			label: "Off",
+			generated: true
+		}]
+	},
+	{
+		key: "storage",
+		flag: "--storage",
+		message: "Uploads in development",
+		description: "Where uploads go in development",
+		values: [{
+			value: "local",
+			label: "Local files",
+			hint: "a Docker volume",
+			generated: true
+		}, {
+			value: "s3",
+			label: "Local S3",
+			hint: "the same code path as S3 in production",
+			generated: true
+		}]
+	},
+	{
+		key: "packageManager",
+		flag: "--package-manager",
+		message: "Package manager",
+		description: "The frontend's package manager",
+		values: [
+			{
+				value: "pnpm",
+				label: "pnpm",
+				generated: false
+			},
+			{
+				value: "npm",
+				label: "npm",
+				generated: true
+			},
+			{
+				value: "bun",
+				label: "Bun",
+				generated: false
+			}
+		]
+	}
+];
+function stackOption(key) {
+	const option = STACK_OPTIONS.find((candidate) => candidate.key === key);
+	if (!option) throw new Error(`Unknown stack option ${key}`);
+	return option;
+}
+const DEFAULT_STACK = Object.fromEntries(STACK_OPTIONS.map((option) => [option.key, option.values[0].value]));
+/** Whether an option applies to a stack: the package manager only with a Node frontend. */
+function applies(key, stack) {
+	if (key === "packageManager") return stack.frontend === void 0 || ["astro", "next"].includes(stack.frontend);
+	return true;
+}
+/** The preset format version, the first character of a code. */
+const VERSION = "a";
+const DIGITS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+/** A preset code for a stack: the version, then one character per option, trailing defaults left out. */
+function encodePreset(stack) {
+	const digits = STACK_OPTIONS.map((option) => {
+		const index = option.values.findIndex((value) => value.value === stack[option.key]);
+		if (index < 0) throw new Error(`${JSON.stringify(stack[option.key])} is not a ${option.key}.`);
+		return DIGITS[index];
+	}).join("").replace(/0+$/, "");
+	return VERSION + digits;
+}
+const UPGRADE = "This preset needs a newer CLI. Run npx @django-stack/cli@latest init.";
+/** The stack of a preset code. Throws with a one-line reason for a bad code. */
+function decodePreset(code) {
+	if (!/^[0-9a-zA-Z]+$/.test(code)) throw new Error(`${JSON.stringify(code)} is not a preset.`);
+	if (code[0] !== VERSION) {
+		if (DIGITS.indexOf(code[0] ?? "") > DIGITS.indexOf(VERSION)) throw new Error(UPGRADE);
+		throw new Error(`${JSON.stringify(code)} is not a preset.`);
+	}
+	const digits = code.slice(1);
+	if (digits.length > STACK_OPTIONS.length) throw new Error(UPGRADE);
+	const stack = { ...DEFAULT_STACK };
+	[...digits].forEach((digit, position) => {
+		const option = STACK_OPTIONS[position];
+		const value = option.values[DIGITS.indexOf(digit)];
+		if (!value) throw new Error(UPGRADE);
+		stack[option.key] = value.value;
+	});
+	return stack;
+}
+const NAMED_PRESETS = {
+	blog: {
+		description: "Astro with everything on (the defaults)",
+		stack: {}
+	},
+	api: {
+		description: "Headless: the API and the admin, no analytics",
+		stack: {
+			frontend: "headless",
+			analytics: "off"
+		}
+	},
+	minimal: {
+		description: "Astro with every optional service off",
+		stack: {
+			analytics: "off",
+			tasks: "off",
+			cache: "off",
+			notifications: "off",
+			captcha: "off"
+		}
+	}
+};
+/** The stack of a preset name or code. */
+function resolvePreset(input) {
+	const named = NAMED_PRESETS[input];
+	if (named) return {
+		...DEFAULT_STACK,
+		...named.stack
+	};
+	return decodePreset(input);
+}
+/** The choices this CLI version does not generate yet, as `--flag value`. */
+function pendingChoices(stack) {
+	return STACK_OPTIONS.flatMap((option) => {
+		const key = option.key;
+		if (!applies(key, stack)) return [];
+		const value = option.values.find((candidate) => candidate.value === stack[key]);
+		if (!value || value.generated) return [];
+		return [{
+			key,
+			choice: `${option.flag} ${value.value}`,
+			isDefault: value === option.values[0]
+		}];
+	});
+}
+export { generateProjectSecrets as C, setEnvValues as D, parseEnv as E, validateDomain as S, runDoctor as T, toProjectName as _, decodePreset as a, CLI_VERSION as b, resolvePreset as c, LOCAL_S3 as d, lockBackend as f, timeZones as g, scaffold as h, applies as i, stackOption as l, relativeDirectory as m, NAMED_PRESETS as n, encodePreset as o, normalizeDatabaseUrl as p, STACK_OPTIONS as r, pendingChoices as s, DEFAULT_STACK as t, FRONTENDS as u, validateProjectName as v, generateSecret as w, productionEnv as x, validateTimeZone as y };