create-goodfellow 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Goodfellow contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,16 @@
-# Temporary Holding Version
+# create-goodfellow
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Creates a new Goodfellow site from a starter, the parish example or the Next.js starter, and sets up where it's stored and where it's put online.
+
+```sh
+npm create goodfellow@latest my-site
+npm create goodfellow@latest my-site -- --template parish --host github-pages
+```
+
+[Goodfellow](https://github.com/chartung17/goodfellow-cms) is a website builder for people who aren't developers, with no server or database: pages are files in your own GitHub or GitLab repository, edited in a visual editor built on [Puck](https://puckeditor.com). To start a new site, run `npm create goodfellow@latest my-site`. See the [documentation](https://chartung17.github.io/goodfellow-cms/) for everything else.
+
+More in the docs: [Create a site](https://chartung17.github.io/goodfellow-cms/docs/create-a-site).
+
+## License
+
+MIT

package/bin/create-goodfellow.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/cli.js";

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/cli.js

@@ -0,0 +1,187 @@
+import { a as TEMPLATES, c as hostsFor, d as parseRepo, f as scaffold, i as ScaffoldError, r as HOSTS, t as BLOCK_CHOICES } from "./scaffold-4nOF_fOJ.js";
+import { join, relative, resolve } from "node:path";
+import { readFileSync } from "node:fs";
+import { stdin, stdout } from "node:process";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+//#region src/cli.ts
+const HELP = `Creates a new Goodfellow site.
+
+Usage: npm create goodfellow@latest [folder] -- [options]
+
+Options:
+  --template <name>   starter (the default), parish, or next for a Next.js site
+  --github <repo>     The GitHub repository the site will be stored in, such as your-name/your-site
+  --gitlab <project>  The GitLab project the site will be stored in, such as your-group/your-site
+  --host <host>       github-pages, gitlab-pages or vercel. Keeps only that host's setup file.
+  --blocks <choice>   recommended (the default) to add the recommended blocks, or built-in for Goodfellow's own only
+  -y, --yes           Don't ask anything: use the options given, and defaults for the rest
+  -h, --help          Show this help
+`;
+/** Bundled into the package when it's built: see scripts/bundle-templates.mjs. */
+const templatesDir = fileURLToPath(new URL("../templates/", import.meta.url));
+const HOST_NAMES = {
+	github: "GitHub",
+	gitlab: "GitLab"
+};
+async function choose(rl, question, choices) {
+	stdout.write(`\n${question}\n`);
+	choices.forEach((choice, index) => {
+		stdout.write(`  ${index + 1}. ${choice.label}${choice.note ? `\n     ${choice.note}` : ""}\n`);
+	});
+	for (;;) {
+		const answer = (await rl.question(`Choose 1-${choices.length} (1): `)).trim();
+		const choice = choices[answer === "" ? 0 : Number(answer) - 1];
+		if (choice) return choice.value;
+	}
+}
+async function askRepo(rl, host) {
+	const example = host === "github" ? "your-name/your-site" : "your-group/your-site";
+	for (;;) {
+		const answer = await rl.question(`\nThe ${HOST_NAMES[host]} ${host === "github" ? "repository" : "project"}, such as ${example} (leave empty if it doesn't exist yet): `);
+		if (answer.trim() === "") return void 0;
+		const repo = parseRepo(host, answer);
+		if (repo) return repo;
+		stdout.write(`That doesn't look like a ${HOST_NAMES[host]} address. Type it as ${example}.\n`);
+	}
+}
+function isTemplate(name) {
+	return Object.hasOwn(TEMPLATES, name);
+}
+function isHost(name) {
+	return Object.hasOwn(HOSTS, name);
+}
+function backendFromOptions(github, gitlab) {
+	if (github !== void 0 && gitlab !== void 0) throw new ScaffoldError("Choose either --github or --gitlab, not both.");
+	const host = github !== void 0 ? "github" : gitlab !== void 0 ? "gitlab" : void 0;
+	if (!host) return void 0;
+	const repo = parseRepo(host, github ?? gitlab);
+	if (!repo) throw new ScaffoldError(host === "github" ? "--github takes a repository such as your-name/your-site." : "--gitlab takes a project such as your-group/your-site.");
+	return {
+		host,
+		repo
+	};
+}
+async function main() {
+	const { positionals, values } = parseArgs({
+		allowPositionals: true,
+		options: {
+			template: { type: "string" },
+			github: { type: "string" },
+			gitlab: { type: "string" },
+			host: { type: "string" },
+			blocks: { type: "string" },
+			yes: {
+				type: "boolean",
+				short: "y"
+			},
+			help: {
+				type: "boolean",
+				short: "h"
+			}
+		}
+	});
+	if (values.help) {
+		stdout.write(HELP);
+		return;
+	}
+	let folder = positionals[0];
+	let template = values.template;
+	if (template !== void 0 && !isTemplate(template)) throw new ScaffoldError(`There's no template called "${template}". Choose ${Object.keys(TEMPLATES).join(" or ")}.`);
+	let backend = backendFromOptions(values.github, values.gitlab);
+	let host = values.host;
+	if (host !== void 0 && !isHost(host)) throw new ScaffoldError(`--host takes ${Object.keys(HOSTS).join(", ")}.`);
+	let blocks = values.blocks;
+	if (blocks !== void 0 && !(blocks in BLOCK_CHOICES)) throw new ScaffoldError(`--blocks takes ${Object.keys(BLOCK_CHOICES).join(" or ")}.`);
+	if (stdin.isTTY && !values.yes) {
+		const rl = createInterface({
+			input: stdin,
+			output: stdout
+		});
+		try {
+			if (!folder) folder = (await rl.question("Folder for the new site (my-site): ")).trim() || "my-site";
+			template ??= await choose(rl, "Start from:", Object.entries(TEMPLATES).map(([value, { label, description }]) => ({
+				value,
+				label,
+				note: description
+			})));
+			let storage = backend?.host;
+			if (!backend) {
+				storage = await choose(rl, "Where will the site be stored? Editors sign in there, and publishing saves to it.", [
+					{
+						value: "github",
+						label: "GitHub"
+					},
+					{
+						value: "gitlab",
+						label: "GitLab"
+					},
+					{
+						value: void 0,
+						label: "Not decided yet"
+					}
+				]);
+				const repo = storage && await askRepo(rl, storage);
+				if (storage && repo) backend = {
+					host: storage,
+					repo
+				};
+			}
+			host ??= await chooseHost(rl, storage);
+			blocks ??= await choose(rl, "Which blocks should the editor offer to start with?", Object.entries(BLOCK_CHOICES).map(([value, { label, description }]) => ({
+				value,
+				label,
+				note: description
+			})));
+		} finally {
+			rl.close();
+		}
+	}
+	if (!folder) throw new ScaffoldError("Say which folder to create the site in, such as: npm create goodfellow@latest my-site");
+	if (host && backend && !hostsFor(backend.host).includes(host)) throw new ScaffoldError(`${HOSTS[host].label} can't serve a site stored on ${HOST_NAMES[backend.host]}.`);
+	const target = resolve(folder);
+	const versions = JSON.parse(readFileSync(join(templatesDir, "versions.json"), "utf8"));
+	await scaffold({
+		template: join(templatesDir, template ?? "starter"),
+		target,
+		versions,
+		...backend && { backend },
+		...host && { host },
+		...(blocks ?? "recommended") === "recommended" && { registryDir: join(templatesDir, "registry") }
+	});
+	const where = relative(process.cwd(), target) || ".";
+	const lines = [
+		"",
+		`Created a new site in ${where}.`,
+		"",
+		"Next:",
+		...where === "." ? [] : [`  cd ${/\s/.test(where) ? JSON.stringify(where) : where}`],
+		"  npm install",
+		"  npm run dev",
+		"",
+		"Then open http://localhost:4321/admin to start editing. README.md explains how to put the site online."
+	];
+	if (!backend) lines.push("Before you do, say where the site is stored in goodfellow.config.tsx; README.md shows how.");
+	stdout.write(`${lines.join("\n")}\n`);
+}
+async function chooseHost(rl, storage) {
+	stdout.write("\nEach host's free plan has its own rules about business use. Check them if the site is for a business,");
+	stdout.write("\nsells anything, shows ads, or anyone is paid to build or look after it.\n");
+	return choose(rl, "Where will the site be hosted?", [...hostsFor(storage).map((value) => ({
+		value,
+		label: HOSTS[value].label,
+		note: HOSTS[value].note
+	})), {
+		value: void 0,
+		label: "Not decided yet",
+		note: "Keeps the setup files for every host."
+	}]);
+}
+main().catch((error) => {
+	if (error.code === "ABORT_ERR") process.exit(130);
+	console.error(error instanceof ScaffoldError ? error.message : error);
+	process.exit(1);
+});
+//#endregion
+export {};

package/dist/index.d.ts

@@ -0,0 +1,107 @@
+//#region src/scaffold.d.ts
+/** The sites a new site can start from. The keys are what `--template` takes. */
+export declare const TEMPLATES: {
+  readonly starter: {
+    readonly label: "Starter";
+    readonly description: "A simple site with a few pages and a news section";
+  };
+  readonly parish: {
+    readonly label: "Parish example";
+    readonly description: "A made-up parish with Mass times, events, news, bulletins and staff, and blocks of its own";
+  };
+  readonly next: {
+    readonly label: "Starter for Next.js";
+    readonly description: "The starter as a Next.js site, for developers who want their own Next.js pages beside it";
+  };
+};
+type TemplateName = keyof typeof TEMPLATES;
+/** Where the site's repository is stored, which the admin panel publishes to. */
+interface Backend {
+  host: "github" | "gitlab";
+  /** `owner/name` on GitHub, or the project's path on GitLab, such as `group/subgroup/site`. */
+  repo: string;
+}
+/** Where the built site is served from. Each has its own setup file in the template. */
+export declare const HOSTS: {
+  readonly "github-pages": {
+    readonly label: "GitHub Pages";
+    readonly files: readonly [".github/workflows/deploy.yml"];
+    readonly note: "Free for public repositories. Not allowed for online businesses or shops.";
+  };
+  readonly "gitlab-pages": {
+    readonly label: "GitLab Pages";
+    readonly files: readonly [".gitlab-ci.yml"];
+    readonly note: "Free, including for private projects. No rule against business sites that we know of.";
+  };
+  readonly vercel: {
+    readonly label: "Vercel";
+    readonly files: readonly ["vercel.json"];
+    readonly note: "Works with GitHub and GitLab. The free plan is for non-commercial sites only.";
+  };
+};
+type Host = keyof typeof HOSTS;
+/** The hosts that can serve a site stored with `backend`: GitHub Pages only builds GitHub repositories, and so on. */
+export declare function hostsFor(backend: Backend["host"] | undefined): Host[];
+/** A problem the person creating the site can fix, described in plain words. */
+export declare class ScaffoldError extends Error {
+  name: string;
+}
+/**
+ * npm leaves `.gitignore` files out of published packages, so templates are
+ * bundled with `_gitignore` instead, and it's renamed back in the new site.
+ */
+export declare const BUNDLED_GITIGNORE = "_gitignore";
+/**
+ * Copies a template's files, leaving out installed packages and build output.
+ * `bundling` renames `.gitignore` files for publishing; otherwise they're renamed back.
+ */
+export declare function copyTemplate(from: string, to: string, { bundling }?: {
+  bundling?: boolean | undefined;
+}): Promise<void>;
+/** A valid npm package name from a folder name, such as `My Parish` → `my-parish`. */
+export declare function packageName(folder: string): string;
+/**
+ * Reads a repository from what someone typed: `owner/name`, or its address on
+ * GitHub or GitLab. Returns `undefined` if it isn't one.
+ */
+export declare function parseRepo(host: Backend["host"], input: string): string | undefined;
+/** The template's `package.json`, named for the new site and with workspace links replaced by published versions. */
+export declare function sitePackageJson(source: string, name: string, versions: Record<string, string>): string;
+/** Turns on one of the commented-out `backend` lines in a template's `goodfellow.config.tsx`. */
+export declare function configureBackend(config: string, backend: Backend): string;
+/** A site's README without the notes for people reading it in the Goodfellow repository. */
+export declare function withoutRepositoryNotes(readme: string): string;
+/** Which blocks a new site starts with, besides the built-in ones. */
+export declare const BLOCK_CHOICES: {
+  readonly recommended: {
+    readonly label: "Recommended";
+    readonly description: "Adds the recommended blocks, such as Hero, Cards and FAQ. Others can be added in the admin panel.";
+  };
+  readonly "built-in": {
+    readonly label: "Built-in blocks only";
+    readonly description: "Starts with Goodfellow's own blocks. More can be added in the admin panel.";
+  };
+};
+type BlockChoice = keyof typeof BLOCK_CHOICES;
+/**
+ * Installs the registry's recommended blocks into a new site, as the admin
+ * panel's Blocks screen would, so the site can add and remove them there later.
+ */
+export declare function installRecommendedBlocks(target: string, registryDir: string): Promise<string[]>;
+interface ScaffoldOptions {
+  /** The template's folder. */
+  template: string;
+  /** The new site's folder. It must be empty or not exist yet. */
+  target: string;
+  /** Versions of Goodfellow's packages, by name, to replace the template's workspace links. */
+  versions: Record<string, string>;
+  backend?: Backend;
+  /** Keeps only this host's setup file. All are kept if it isn't set. */
+  host?: Host;
+  /** The built block registry to install recommended blocks from. Without it, the site has the built-in blocks only. */
+  registryDir?: string;
+}
+/** Creates a new site in `target` from a template. */
+export declare function scaffold({ template, target, versions, backend, host, registryDir }: ScaffoldOptions): Promise<void>;
+//#endregion
+export type { Backend, BlockChoice, Host, ScaffoldOptions, TemplateName };

package/dist/index.js

@@ -0,0 +1,2 @@
+import { a as TEMPLATES, c as hostsFor, d as parseRepo, f as scaffold, i as ScaffoldError, l as installRecommendedBlocks, m as withoutRepositoryNotes, n as BUNDLED_GITIGNORE, o as configureBackend, p as sitePackageJson, r as HOSTS, s as copyTemplate, t as BLOCK_CHOICES, u as packageName } from "./scaffold-4nOF_fOJ.js";
+export { BLOCK_CHOICES, BUNDLED_GITIGNORE, HOSTS, ScaffoldError, TEMPLATES, configureBackend, copyTemplate, hostsFor, installRecommendedBlocks, packageName, parseRepo, scaffold, sitePackageJson, withoutRepositoryNotes };

package/dist/scaffold-4nOF_fOJ.js

@@ -0,0 +1,207 @@
+import { cp, mkdir, readFile, readdir, rename, rm, rmdir, writeFile } from "node:fs/promises";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import { EMPTY_RECORD, GOODFELLOW_REGISTRY, availableBlocks, planInstall } from "@goodfellow-cms/core";
+//#region src/scaffold.ts
+/** The sites a new site can start from. The keys are what `--template` takes. */
+const TEMPLATES = {
+	starter: {
+		label: "Starter",
+		description: "A simple site with a few pages and a news section"
+	},
+	parish: {
+		label: "Parish example",
+		description: "A made-up parish with Mass times, events, news, bulletins and staff, and blocks of its own"
+	},
+	next: {
+		label: "Starter for Next.js",
+		description: "The starter as a Next.js site, for developers who want their own Next.js pages beside it"
+	}
+};
+/** Where the built site is served from. Each has its own setup file in the template. */
+const HOSTS = {
+	"github-pages": {
+		label: "GitHub Pages",
+		files: [".github/workflows/deploy.yml"],
+		note: "Free for public repositories. Not allowed for online businesses or shops."
+	},
+	"gitlab-pages": {
+		label: "GitLab Pages",
+		files: [".gitlab-ci.yml"],
+		note: "Free, including for private projects. No rule against business sites that we know of."
+	},
+	vercel: {
+		label: "Vercel",
+		files: ["vercel.json"],
+		note: "Works with GitHub and GitLab. The free plan is for non-commercial sites only."
+	}
+};
+/** The hosts that can serve a site stored with `backend`: GitHub Pages only builds GitHub repositories, and so on. */
+function hostsFor(backend) {
+	if (backend === "github") return ["github-pages", "vercel"];
+	if (backend === "gitlab") return ["gitlab-pages", "vercel"];
+	return [
+		"github-pages",
+		"gitlab-pages",
+		"vercel"
+	];
+}
+/** A problem the person creating the site can fix, described in plain words. */
+var ScaffoldError = class extends Error {
+	name = "ScaffoldError";
+};
+/** Never copied, wherever they are: installed packages and build caches. */
+const SKIPPED = /* @__PURE__ */ new Set(["node_modules", ".turbo"]);
+/** Never copied from the template's own folder: build output, and files only the Goodfellow repository uses. */
+const SKIPPED_AT_ROOT = /* @__PURE__ */ new Set([
+	"dist",
+	"out",
+	".next",
+	"next-env.d.ts",
+	"turbo.json"
+]);
+/**
+* npm leaves `.gitignore` files out of published packages, so templates are
+* bundled with `_gitignore` instead, and it's renamed back in the new site.
+*/
+const BUNDLED_GITIGNORE = "_gitignore";
+/**
+* Copies a template's files, leaving out installed packages and build output.
+* `bundling` renames `.gitignore` files for publishing; otherwise they're renamed back.
+*/
+async function copyTemplate(from, to, { bundling = false } = {}) {
+	await cp(from, to, {
+		recursive: true,
+		filter: (source) => {
+			const path = relative(from, source).split(sep);
+			return !path.some((part) => SKIPPED.has(part)) && !SKIPPED_AT_ROOT.has(path[0] ?? "");
+		}
+	});
+	const [find, replace] = bundling ? [".gitignore", BUNDLED_GITIGNORE] : [BUNDLED_GITIGNORE, ".gitignore"];
+	for (const file of await readdir(to, { recursive: true })) if (basename(file) === find) await rename(join(to, file), join(to, file.slice(0, -find.length) + replace));
+}
+/** A valid npm package name from a folder name, such as `My Parish` → `my-parish`. */
+function packageName(folder) {
+	return basename(resolve(folder)).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[._-]+|[-]+$/g, "").slice(0, 214) || "my-site";
+}
+/**
+* Reads a repository from what someone typed: `owner/name`, or its address on
+* GitHub or GitLab. Returns `undefined` if it isn't one.
+*/
+function parseRepo(host, input) {
+	let path = input.trim().replace(/\.git$/, "").replace(/\/+$/, "");
+	const prefix = host === "github" ? /^(?:https?:\/\/)?(?:www\.)?github\.com\//i : /^(?:https?:\/\/)?gitlab\.com\//i;
+	path = path.replace(prefix, "");
+	return (host === "github" ? /^[A-Za-z0-9-]+\/[A-Za-z0-9._-]+$/ : /^[A-Za-z0-9][A-Za-z0-9._-]*(?:\/[A-Za-z0-9._-]+)+$/).test(path) ? path : void 0;
+}
+/** The template's `package.json`, named for the new site and with workspace links replaced by published versions. */
+function sitePackageJson(source, name, versions) {
+	const pkg = JSON.parse(source);
+	const result = {
+		...pkg,
+		name
+	};
+	for (const key of ["dependencies", "devDependencies"]) {
+		const deps = pkg[key];
+		if (!deps) continue;
+		result[key] = Object.fromEntries(Object.entries(deps).map(([dep, range]) => {
+			if (!range.startsWith("workspace:")) return [dep, range];
+			const version = versions[dep];
+			if (!version) throw new Error(`No version of ${dep} to use in the new site.`);
+			return [dep, `^${version}`];
+		}));
+	}
+	return `${JSON.stringify(result, null, 2)}\n`;
+}
+/** Turns on one of the commented-out `backend` lines in a template's `goodfellow.config.tsx`. */
+function configureBackend(config, backend) {
+	const importLine = `// import { ${backend.host} } from "@goodfellow-cms/${backend.host}";`;
+	const backendLine = new RegExp(`^([ \\t]*)// backend: ${backend.host}\\(.*$`, "m");
+	if (!config.includes(importLine) || !backendLine.test(config)) throw new Error(`The template's goodfellow.config.tsx has no ${backend.host} line to turn on.`);
+	const call = backend.host === "github" ? `github({ repo: ${JSON.stringify(backend.repo)} })` : `gitlab({ project: ${JSON.stringify(backend.repo)} })`;
+	return config.replace(importLine, importLine.slice(3)).replace(backendLine, `$1backend: ${call},`);
+}
+/** Notes in a site's README for people reading it in the Goodfellow repository, which new sites don't need. */
+const REPOSITORY_NOTE = /<!-- goodfellow-repository -->[\s\S]*?<!-- \/goodfellow-repository -->\n*/g;
+/** A site's README without the notes for people reading it in the Goodfellow repository. */
+function withoutRepositoryNotes(readme) {
+	return readme.replace(REPOSITORY_NOTE, "");
+}
+/** Which blocks a new site starts with, besides the built-in ones. */
+const BLOCK_CHOICES = {
+	recommended: {
+		label: "Recommended",
+		description: "Adds the recommended blocks, such as Hero, Cards and FAQ. Others can be added in the admin panel."
+	},
+	"built-in": {
+		label: "Built-in blocks only",
+		description: "Starts with Goodfellow's own blocks. More can be added in the admin panel."
+	}
+};
+/** Reads a built registry from disk, as the admin panel would read it from its address. */
+function localRegistry(dir) {
+	const base = "https://registry.invalid/r/";
+	return {
+		registries: { [GOODFELLOW_REGISTRY]: `${base}{name}.json` },
+		fetchJson: async (url) => JSON.parse(await readFile(join(dir, url.slice(27)), "utf8"))
+	};
+}
+/**
+* Installs the registry's recommended blocks into a new site, as the admin
+* panel's Blocks screen would, so the site can add and remove them there later.
+*/
+async function installRecommendedBlocks(target, registryDir) {
+	const { registries, fetchJson } = localRegistry(registryDir);
+	const recommended = (await availableBlocks(registries, fetchJson)).filter((block) => block.recommended);
+	const readSiteFile = (path) => readFile(join(target, path), "utf8").catch(() => void 0);
+	let record = EMPTY_RECORD;
+	for (const block of recommended) {
+		const plan = await planInstall({
+			ref: block.ref,
+			registries,
+			fetchJson,
+			readFile: readSiteFile,
+			record,
+			blocks: []
+		});
+		for (const change of plan.changes) {
+			if (!("content" in change)) continue;
+			await mkdir(dirname(join(target, change.path)), { recursive: true });
+			await writeFile(join(target, change.path), change.content);
+		}
+		record = plan.record;
+	}
+	return recommended.map((block) => block.title);
+}
+async function isEmptyFolder(path) {
+	try {
+		return (await readdir(path)).length === 0;
+	} catch (error) {
+		if (error.code === "ENOENT") return true;
+		throw error;
+	}
+}
+/** Creates a new site in `target` from a template. */
+async function scaffold({ template, target, versions, backend, host, registryDir }) {
+	if (!await isEmptyFolder(target)) throw new ScaffoldError(`The folder ${target} already has files in it. Choose a new folder for the site.`);
+	await mkdir(target, { recursive: true });
+	await copyTemplate(template, target);
+	const pkgPath = join(target, "package.json");
+	await writeFile(pkgPath, sitePackageJson(await readFile(pkgPath, "utf8"), packageName(target), versions));
+	const readmePath = join(target, "README.md");
+	const readme = await readFile(readmePath, "utf8").catch(() => void 0);
+	if (readme !== void 0) await writeFile(readmePath, withoutRepositoryNotes(readme));
+	if (registryDir) await installRecommendedBlocks(target, registryDir);
+	if (backend) {
+		const configPath = join(target, "goodfellow.config.tsx");
+		await writeFile(configPath, configureBackend(await readFile(configPath, "utf8"), backend));
+	}
+	if (host) {
+		for (const [name, { files }] of Object.entries(HOSTS)) {
+			if (name === host) continue;
+			for (const file of files) await rm(join(target, file), { force: true });
+		}
+		for (const dir of [".github/workflows", ".github"]) if (await isEmptyFolder(join(target, dir))) await rmdir(join(target, dir)).catch(() => void 0);
+	}
+}
+//#endregion
+export { TEMPLATES as a, hostsFor as c, parseRepo as d, scaffold as f, ScaffoldError as i, installRecommendedBlocks as l, withoutRepositoryNotes as m, BUNDLED_GITIGNORE as n, configureBackend as o, sitePackageJson as p, HOSTS as r, copyTemplate as s, BLOCK_CHOICES as t, packageName as u };

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "create-goodfellow",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Creates a new Goodfellow site: npm create goodfellow@latest my-site",
+  "keywords": [
+    "goodfellow",
+    "cms",
+    "website-builder",
+    "puck",
+    "create",
+    "starter",
+    "scaffold"
+  ],
+  "homepage": "https://chartung17.github.io/goodfellow-cms/docs/create-a-site",
+  "bugs": "https://github.com/chartung17/goodfellow-cms/issues",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chartung17/goodfellow-cms.git",
+    "directory": "packages/create-goodfellow"
+  },
+  "type": "module",
+  "bin": {
+    "create-goodfellow": "./bin/create-goodfellow.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "templates"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@goodfellow-cms/core": "0.1.0"
+  },
+  "devDependencies": {
+    "@goodfellow-cms/example-parish": "0.0.0",
+    "@goodfellow-cms/registry": "0.1.0",
+    "@goodfellow-cms/template-starter": "0.0.0",
+    "@goodfellow-cms/template-next": "0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown && node scripts/bundle-templates.mjs",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "vitest run"
+  }
 }

package/templates/next/.github/workflows/deploy.yml

@@ -0,0 +1,51 @@
+# Builds the site and publishes it with GitHub Pages whenever the main branch
+# changes (including every Publish in the admin panel), and once a night so
+# date-based content stays current. In the repository's Settings → Pages, set
+# "Source" to "GitHub Actions". See README.md.
+name: Deploy to GitHub Pages
+
+on:
+  push:
+    branches: [main]
+  schedule:
+    - cron: "17 4 * * *"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: pages
+  cancel-in-progress: false
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-node@v5
+        with:
+          node-version: 22
+          cache: npm
+      - id: pages
+        uses: actions/configure-pages@v5
+      - run: npm ci
+      # Project sites live in a subfolder (/repository-name/); user and organization sites don't.
+      - run: npx next build
+        env:
+          GOODFELLOW_BASE: ${{ steps.pages.outputs.base_path }}/
+      - uses: actions/upload-pages-artifact@v4
+        with:
+          path: out
+
+  deploy:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - id: deployment
+        uses: actions/deploy-pages@v4