create-goodfellow 0.1.0 → 0.2.0

package/README.md

@@ -7,9 +7,9 @@ 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.
+[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://chartung17.github.io/goodfellow-cms/docs/create-a-site).
+More in the docs: [Create a site](https://goodfellow-cms.github.io/goodfellow-cms/docs/create-a-site).
 
 ## License
 

package/dist/cli.js

@@ -1,4 +1,4 @@
-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 { 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";
@@ -16,6 +16,8 @@ Options:
   --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
 `;
@@ -72,6 +74,8 @@ async function main() {
 			gitlab: { type: "string" },
 			host: { type: "string" },
 			blocks: { type: "string" },
+			"no-git": { type: "boolean" },
+			"no-install": { type: "boolean" },
 			yes: {
 				type: "boolean",
 				short: "y"
@@ -150,14 +154,24 @@ async function main() {
 		...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:",
-		...where === "." ? [] : [`  cd ${/\s/.test(where) ? JSON.stringify(where) : where}`],
-		"  npm install",
+		...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."
@@ -165,6 +179,25 @@ async function main() {
 	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");

package/dist/index.d.ts

@@ -1,56 +1,9 @@
+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
-/** 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.
@@ -60,34 +13,8 @@ export declare function copyTemplate(from: string, to: string, { bundling }?: {
 }): 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[]>;
+/** 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;
@@ -95,13 +22,13 @@ interface ScaffoldOptions {
   target: string;
   /** Versions of Goodfellow's packages, by name, to replace the template's workspace links. */
   versions: Record<string, string>;
-  backend?: Backend;
+  backend?: Backend$1;
   /** Keeps only this host's setup file. All are kept if it isn't set. */
-  host?: Host;
+  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 type { Backend, BlockChoice, Host, ScaffoldOptions, TemplateName };
+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

@@ -1,2 +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 };
+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,6 @@
 {
   "name": "create-goodfellow",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Creates a new Goodfellow site: npm create goodfellow@latest my-site",
   "keywords": [
     "goodfellow",
@@ -11,12 +11,12 @@
     "starter",
     "scaffold"
   ],
-  "homepage": "https://chartung17.github.io/goodfellow-cms/docs/create-a-site",
-  "bugs": "https://github.com/chartung17/goodfellow-cms/issues",
+  "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/chartung17/goodfellow-cms.git",
+    "url": "git+https://github.com/goodfellow-cms/goodfellow-cms.git",
     "directory": "packages/create-goodfellow"
   },
   "type": "module",
@@ -39,11 +39,11 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@goodfellow-cms/core": "0.1.0"
+    "@goodfellow-cms/core": "0.2.0"
   },
   "devDependencies": {
+    "@goodfellow-cms/registry": "0.2.0",
     "@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"
   },

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

@@ -1,7 +1,10 @@
 # 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.
+# 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:
@@ -10,6 +13,11 @@ on:
   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
@@ -21,10 +29,36 @@ concurrency:
   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
@@ -42,6 +76,7 @@ jobs:
 
   deploy:
     needs: build
+    if: ${{ !cancelled() && needs.build.result == 'success' }}
     runs-on: ubuntu-latest
     environment:
       name: github-pages

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

@@ -1,6 +1,11 @@
 # Builds the site and publishes it with GitLab Pages whenever the default
-# branch changes (including every Publish in the admin panel). For nightly
-# rebuilds, add a schedule under Build → Pipeline schedules. See README.md.
+# 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:
@@ -9,6 +14,11 @@ pages:
     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

package/templates/next/README.md

@@ -1,6 +1,6 @@
 # My site
 
-A website built with [Goodfellow](https://github.com/chartung17/goodfellow-cms) and [Next.js](https://nextjs.org). Pages are files in `content/`, edited in the admin panel at `/admin`, and built into static files that a free host serves.
+A website built with [Goodfellow](https://github.com/goodfellow-cms/goodfellow-cms) and [Next.js](https://nextjs.org). Pages are files in `content/`, edited in the admin panel at `/admin`, and built into static files that a free host serves.
 
 ## Working on the site
 
@@ -27,14 +27,14 @@ The News page and its stories are an example of a collection: a group of similar
 | `app/(site)/[[...path]]/page.tsx` | Every page in `content/`, rendered as Server Components. Links between pages use `next/link`, and images `next/image`. |
 | `app/not-found.tsx` | The site's "Page not found" page, `content/pages/404.json` |
 | `app/admin/page.tsx` | The admin panel |
-| `app/admin/demo-content.json/route.ts` | For a [demo](https://github.com/chartung17/goodfellow-cms#demo-mode) (`demo: true` in the config), the copy of the content its admin panel starts from |
+| `app/admin/demo-content.json/route.ts` | For a [demo](https://goodfellow-cms.github.io/goodfellow-cms/docs/demo-mode) (`demo: true` in the config), the copy of the content its admin panel starts from |
 | `app/site.css` | The site's styles: Tailwind, the theme, and the custom CSS from the admin panel |
 | `app/layout.tsx`, `app/sitemap.ts`, `app/robots.ts` | The page around everything, and files for search engines |
 | `next.config.ts` | `withGoodfellow()` builds static files, serves the site from a subfolder when the host needs it, and runs the admin panel's local backend in `next dev` |
 
 Your own Next.js pages can go beside these, in `app/`, and import from the project root as `@/`, such as `@/lib/site`.
 
-More blocks, such as an FAQ, tabs and a pricing table, can be added on the admin panel's **Blocks** screen, which publishes their code into `blocks/installed/` and the shadcn components they use into `components/ui/`. See [Blocks from block registries](https://github.com/chartung17/goodfellow-cms#blocks-from-block-registries).
+More blocks, such as an FAQ, tabs and a pricing table, can be added on the admin panel's **Blocks** screen, which publishes their code into `blocks/installed/` and the shadcn components they use into `components/ui/`. See [Add blocks](https://goodfellow-cms.github.io/goodfellow-cms/docs/add-blocks).
 
 Blocks are React components in `blocks/`, added to the editor in `goodfellow.config.tsx`. For links and images, use `SiteLink` and `SiteImage` from `@goodfellow-cms/react` rather than `<a>` and `<img>`, so they follow the site's address and use `next/link` and `next/image`. Read the site's settings, menus and collections with `useSite()`.
 
@@ -48,7 +48,14 @@ Setup takes four steps. It's done once, usually by whoever set up the site.
 
 ### 1. Store the site on GitHub or GitLab
 
-Create a repository and push this folder to it, including `package-lock.json`.
+Create an empty repository on GitHub or GitLab, without a README, and push this folder to it:
+
+```sh
+git remote add origin https://github.com/your-name/your-site.git   # unless origin is already set
+git push -u origin main
+```
+
+`create-goodfellow` makes the new site a git repository on the branch `main`, with everything, `package-lock.json` included, in its first commit, and sets `origin` when it's given the repository. Commit any changes since (`git add -A` and `git commit`) before pushing.
 
 ### 2. Tell Goodfellow where the site is stored
 
@@ -70,7 +77,7 @@ Also set the site's address under **Site settings → General → Site address**
 
 ### 3. Choose a host
 
-Each host's free plan has its own rules about business use. If the site is for a business, sells anything, shows ads, or is built or looked after by someone who's paid for it, check those rules first. As of October 2026, GitHub Pages and Vercel's free plan don't allow most of these, and GitLab Pages has no rule against them that we know of. See [Commercial sites](https://github.com/chartung17/goodfellow-cms#requirements-and-limits) in Goodfellow's README.
+Each host's free plan has its own rules about business use. If the site is for a business, sells anything, shows ads, or is built or looked after by someone who's paid for it, check those rules first. As of October 2026, GitHub Pages and Vercel's free plan don't allow most of these, and GitLab Pages has no rule against them that we know of. See [Hosts and business sites](https://goodfellow-cms.github.io/goodfellow-cms/docs/hosts) in Goodfellow's documentation.
 
 **GitHub Pages** (free for public repositories; not for online businesses or shops)
 
@@ -85,7 +92,7 @@ Each host's free plan has its own rules about business use. If the site is for a
 
 **Vercel** (works with GitHub and GitLab; the free plan is for non-commercial sites only)
 
-1. Import the repository in Vercel, which recognizes it as a Next.js site.
+1. Import the repository in Vercel, which recognizes it as a Next.js site, and sends the site's redirects itself.
 2. For nightly rebuilds, create a deploy hook under **Settings → Git → Deploy Hooks**, and call it from a scheduled GitHub Action or GitLab pipeline schedule.
 
 Delete the setup files for the hosts you don't use.
@@ -113,7 +120,7 @@ Upload images and files on the admin panel's **Media** screen, or with the **Cho
 
 ## Writing with AI
 
-The admin panel's **AI** tab can draft pages, rewrite blocks and fill in news stories. Each editor picks an AI service there. Claude and some others need the editor's own API key and charge for use; there are free options, including copying the request into a chat app such as Claude.ai. To offer only some services, or to turn the assistant off, see `ai` in [Goodfellow's README](https://github.com/chartung17/goodfellow-cms#ai-services).
+The admin panel's **AI** tab can draft pages, rewrite blocks and fill in news stories. Each editor picks an AI service there. Claude and some others need the editor's own API key and charge for use; there are free options, including copying the request into a chat app such as Claude.ai. To offer only some services, or to turn the assistant off, see `ai` in [Configuration](https://goodfellow-cms.github.io/goodfellow-cms/docs/configuration).
 
 ## Publishing
 

package/templates/next/app/admin/layout.tsx

@@ -1,7 +1,7 @@
-import type { Metadata } from "next";
 import type { ReactNode } from "react";
+import { site } from "@/lib/site";
 
-export const metadata: Metadata = { title: "Site admin", robots: { index: false } };
+export const generateMetadata = site.adminMetadata;
 
 export default function AdminLayout({ children }: { children: ReactNode }) {
   return children;

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

@@ -1,7 +1,10 @@
 # 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.
+# 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:
@@ -10,6 +13,11 @@ on:
   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
@@ -21,10 +29,36 @@ concurrency:
   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 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
@@ -40,6 +74,7 @@ jobs:
 
   deploy:
     needs: build
+    if: ${{ !cancelled() && needs.build.result == 'success' }}
     runs-on: ubuntu-latest
     environment:
       name: github-pages