create-goodfellow 0.0.0-stage → 0.2.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/goodfellow-cms/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://goodfellow-cms.github.io/goodfellow-cms/) for everything else.
+
+More in the docs: [Create a site](https://goodfellow-cms.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,220 @@
+import { a as TEMPLATES, d as installPackages, h as scaffold, i as ScaffoldError, l as hostsFor, o as commitAll, p as parseRepo, r as HOSTS, t as BLOCK_CHOICES, u as initGitRepository } from "./scaffold-BGxzPdN1.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
+  --no-install        Don't run npm install
+  --no-git            Don't make the site a git repository, or commit it
+  -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" },
+			"no-git": { type: "boolean" },
+			"no-install": { type: "boolean" },
+			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 git = values["no-git"] ? void 0 : initGitRepository(target, backend);
+	let installed = false;
+	if (!values["no-install"]) {
+		stdout.write("\nInstalling the site's packages with npm...\n\n");
+		installed = installPackages(target);
+	}
+	const commit = git?.created && (installed || values["no-install"]) ? commitAll(target, "Create the site") : void 0;
+	const where = relative(process.cwd(), target) || ".";
+	const cd = where === "." ? [] : [`  cd ${/\s/.test(where) ? JSON.stringify(where) : where}`];
+	const lines = [
+		"",
+		`Created a new site in ${where}.`,
+		...git ? gitLines(git, commit, installed) : [],
+		...!installed && !values["no-install"] ? ["npm install didn't finish, so run it again in the site's folder."] : [],
+		"",
+		"Next:",
+		...cd,
+		...installed ? [] : ["  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`);
+}
+/** What happened with git, and what's left to do. */
+function gitLines(git, commit, installed) {
+	if (!git.created) return [git.reason === "inside-repository" ? "It's inside another git repository, so it isn't one of its own." : "Git isn't installed, so it isn't a git repository yet: once it is, run git init -b main in it, then commit."];
+	const repository = "It's a git repository on the branch main";
+	const origin = git.remote ? [`Its origin is ${git.remote}.`] : [];
+	if (commit === "committed") return [
+		`${repository}, with everything in its first commit.`,
+		...origin,
+		...installed ? [] : ["Commit package-lock.json after npm install: the deploy setups need it."]
+	];
+	if (commit === "no-identity") return [
+		`${repository}, but git doesn't know your name and email yet, so nothing is committed. Tell it, then commit:`,
+		"  git config --global user.name \"Your Name\"",
+		"  git config --global user.email you@example.com",
+		"  git add -A && git commit -m \"Create the site\"",
+		...origin
+	];
+	return [`${repository}. Nothing is committed yet: commit everything once npm install has run.`, ...origin];
+}
+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,34 @@
+import { BLOCK_CHOICES, BUNDLED_GITIGNORE, Backend, Backend as Backend$1, BlockChoice, HOSTS, Host, Host as Host$1, SiteFiles, TEMPLATES, TemplateName, configureBackend, hostsFor, parseRepo, sitePackageJson, withoutRepositoryNotes } from "@goodfellow-cms/core";
+//#region src/scaffold.d.ts
+/** A problem the person creating the site can fix, described in plain words. */
+export declare class ScaffoldError extends Error {
+  name: string;
+}
+/**
+ * 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 template's files, leaving out installed packages and build output, as `copyTemplate()` does. */
+export declare function readTemplate(dir: string): Promise<SiteFiles>;
+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$1;
+  /** Keeps only this host's setup file. All are kept if it isn't set. */
+  host?: Host$1;
+  /** 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 { BLOCK_CHOICES, BUNDLED_GITIGNORE, type Backend, type BlockChoice, HOSTS, type Host, type ScaffoldOptions, TEMPLATES, type TemplateName, configureBackend, hostsFor, parseRepo, sitePackageJson, withoutRepositoryNotes };

package/dist/index.js

@@ -0,0 +1,2 @@
+import { _ as withoutRepositoryNotes, a as TEMPLATES, c as copyTemplate, f as packageName, g as sitePackageJson, h as scaffold, i as ScaffoldError, l as hostsFor, m as readTemplate, n as BUNDLED_GITIGNORE, p as parseRepo, r as HOSTS, s as configureBackend, t as BLOCK_CHOICES } from "./scaffold-BGxzPdN1.js";
+export { BLOCK_CHOICES, BUNDLED_GITIGNORE, HOSTS, ScaffoldError, TEMPLATES, configureBackend, copyTemplate, hostsFor, packageName, parseRepo, readTemplate, scaffold, sitePackageJson, withoutRepositoryNotes };

package/dist/scaffold-BGxzPdN1.js

@@ -0,0 +1,150 @@
+import { spawnSync } from "node:child_process";
+import { cp, mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import { BLOCK_CHOICES, BUNDLED_GITIGNORE, BUNDLED_GITIGNORE as BUNDLED_GITIGNORE$1, GOODFELLOW_REGISTRY, HOSTS, TEMPLATES, configureBackend, hostsFor, parseRepo, planSite, sitePackageJson, sitePackageName, withoutRepositoryNotes } from "@goodfellow-cms/core";
+//#region src/scaffold.ts
+/** 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"
+]);
+/**
+* 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 sitePackageName(basename(resolve(folder)));
+}
+/** 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"))
+	};
+}
+/** Reads a template's files, leaving out installed packages and build output, as `copyTemplate()` does. */
+async function readTemplate(dir) {
+	const files = /* @__PURE__ */ new Map();
+	for (const entry of await readdir(dir, {
+		recursive: true,
+		withFileTypes: true
+	})) {
+		if (!entry.isFile()) continue;
+		const path = relative(dir, join(entry.parentPath, entry.name)).split(sep);
+		if (path.some((part) => SKIPPED.has(part)) || SKIPPED_AT_ROOT.has(path[0] ?? "")) continue;
+		files.set(path.join("/"), new Uint8Array(await readFile(join(dir, ...path))));
+	}
+	return files;
+}
+async function isEmptyFolder(path) {
+	try {
+		return (await readdir(path)).length === 0;
+	} catch (error) {
+		if (error.code === "ENOENT") return true;
+		throw error;
+	}
+}
+/** Where a backend's repository is pushed to, over HTTPS. */
+function remoteUrl(backend) {
+	return `https://${backend.host === "github" ? "github.com" : "gitlab.com"}/${backend.repo}.git`;
+}
+/**
+* Makes the new site a git repository on the branch `main`, which the deploy
+* setups build from, with `origin` set when the site's repository is known.
+* A folder inside another repository, such as a monorepo, is left as it is.
+*/
+function initGitRepository(target, backend) {
+	const git = (...args) => spawnSync("git", args, {
+		cwd: target,
+		encoding: "utf8"
+	});
+	const inside = git("rev-parse", "--is-inside-work-tree");
+	if (inside.error) return {
+		created: false,
+		reason: "no-git"
+	};
+	if (inside.status === 0) return {
+		created: false,
+		reason: "inside-repository"
+	};
+	if (git("init", "-q", "-b", "main").status !== 0) {
+		if (git("init", "-q").status !== 0) return {
+			created: false,
+			reason: "no-git"
+		};
+		git("symbolic-ref", "HEAD", "refs/heads/main");
+	}
+	if (!backend) return { created: true };
+	const remote = remoteUrl(backend);
+	git("remote", "add", "origin", remote);
+	return {
+		created: true,
+		remote
+	};
+}
+/**
+* Runs `npm install` in the new site, showing its output. Its `package-lock.json`
+* goes in the first commit, since the deploy setups install with `npm ci`.
+*/
+function installPackages(target) {
+	return (process.platform === "win32" ? spawnSync("npm install", {
+		cwd: target,
+		stdio: "inherit",
+		shell: true
+	}) : spawnSync("npm", ["install"], {
+		cwd: target,
+		stdio: "inherit"
+	})).status === 0;
+}
+/** Commits everything in the new site, which `.gitignore` doesn't leave out. */
+function commitAll(target, message) {
+	const git = (...args) => spawnSync("git", args, {
+		cwd: target,
+		encoding: "utf8"
+	});
+	if (git("add", "-A").status !== 0) return "failed";
+	const commit = git("commit", "-q", "-m", message);
+	if (commit.status === 0) return "committed";
+	return /user\.(name|email)|tell me who you are|identity/i.test(commit.stderr) ? "no-identity" : "failed";
+}
+/** 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.`);
+	const files = await planSite({
+		template: await readTemplate(template),
+		name: packageName(target),
+		versions,
+		backend,
+		host,
+		registry: registryDir ? localRegistry(registryDir) : void 0
+	});
+	await mkdir(target, { recursive: true });
+	for (const [path, file] of files) {
+		await mkdir(dirname(join(target, path)), { recursive: true });
+		await writeFile(join(target, path), file);
+	}
+}
+//#endregion
+export { withoutRepositoryNotes as _, TEMPLATES as a, copyTemplate as c, installPackages as d, packageName as f, sitePackageJson as g, scaffold as h, ScaffoldError as i, hostsFor as l, readTemplate as m, BUNDLED_GITIGNORE$1 as n, commitAll as o, parseRepo as p, HOSTS as r, configureBackend as s, BLOCK_CHOICES as t, initGitRepository 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.2.0",
+  "description": "Creates a new Goodfellow site: npm create goodfellow@latest my-site",
+  "keywords": [
+    "goodfellow",
+    "cms",
+    "website-builder",
+    "puck",
+    "create",
+    "starter",
+    "scaffold"
+  ],
+  "homepage": "https://goodfellow-cms.github.io/goodfellow-cms/docs/create-a-site",
+  "bugs": "https://github.com/goodfellow-cms/goodfellow-cms/issues",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/goodfellow-cms/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.2.0"
+  },
+  "devDependencies": {
+    "@goodfellow-cms/registry": "0.2.0",
+    "@goodfellow-cms/example-parish": "0.0.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,86 @@
+# 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. Each night it first installs Goodfellow's
+# newest fixes, and publishes them only if the site still builds with them,
+# unless content/updates.json turns automatic updates off.
+# 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:
+    inputs:
+      update:
+        description: "Update Goodfellow first: fixes, latest, or a release such as 0.5.0 (an older one goes back to it). Leave empty to only build."
+        required: false
+        default: ""
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: pages
+  cancel-in-progress: false
+
+jobs:
+  update:
+    # Each night, and when the admin panel's Updates screen asks.
+    if: github.event_name == 'schedule' || (github.event_name == 'workflow_dispatch' && inputs.update != '')
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    outputs:
+      sha: ${{ steps.update.outputs.sha }}
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-node@v5
+        with:
+          node-version: 22
+          cache: npm
+      - run: npm ci
+      - id: update
+        env:
+          TO: ${{ inputs.update || 'automatic' }}
+        run: npx goodfellow-next update --publish --to "$TO"
+
+  build:
+    needs: update
+    # Also when there was no update to run, or it didn't work: the site is built either way.
+    if: ${{ !cancelled() }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          # The update's commit, when it published one.
+          ref: ${{ needs.update.outputs.sha || github.sha }}
+      - 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
+    if: ${{ !cancelled() && needs.build.result == 'success' }}
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - id: deployment
+        uses: actions/deploy-pages@v4

package/templates/next/.gitlab-ci.yml

@@ -0,0 +1,28 @@
+# Builds the site and publishes it with GitLab Pages whenever the default
+# branch changes (including every Publish in the admin panel). On scheduled
+# pipelines, which the admin panel's Updates screen sets up to run each night,
+# it first installs Goodfellow's newest fixes, unless content/updates.json turns
+# automatic updates off (or the release GOODFELLOW_UPDATE names), and publishes
+# them only if the site still builds with them. That
+# needs "Allow Git push requests to the repository" under Settings → CI/CD →
+# Job token permissions, which the Updates screen turns on. See README.md.
+pages:
+  image: node:22
+  cache:
+    key:
+      files: [package-lock.json]
+    paths: [.npm/, .next/cache/]
+  script:
+    - npm ci --cache .npm --prefer-offline
+    - |
+      if [ "$CI_PIPELINE_SOURCE" = "schedule" ] || [ -n "$GOODFELLOW_UPDATE" ]; then
+        git remote set-url origin "https://gitlab-ci-token:${CI_JOB_TOKEN}@${CI_SERVER_FQDN:-$CI_SERVER_HOST}/${CI_PROJECT_PATH}.git"
+        npx goodfellow-next update --publish --to "${GOODFELLOW_UPDATE:-automatic}" || echo "The update wasn't published; building the site as it is."
+      fi
+    # Pages may serve the site from a subfolder, such as https://group.gitlab.io/site/.
+    - export GOODFELLOW_BASE="$(node -e 'console.log(new URL(process.env.CI_PAGES_URL).pathname)')"
+    - npx next build
+  pages:
+    publish: out
+  rules:
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH