@goodfellow-cms/next 0.5.0 → 0.7.0

package/README.md

@@ -4,7 +4,7 @@ Goodfellow pages and the admin panel in a Next.js App Router site, exported as s
 
 Start from the Next.js starter: `npm create goodfellow@latest my-site -- --template next`.
 
-[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.
+[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, GitLab or Bitbucket 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: [Next.js](https://goodfellow-cms.github.io/goodfellow-cms/docs/nextjs) and [Full-stack Next.js sites](https://goodfellow-cms.github.io/goodfellow-cms/docs/full-stack-nextjs).
 

package/bin/goodfellow-next.js

@@ -1,19 +1,22 @@
 #!/usr/bin/env node
 // After `next build`: `goodfellow-next finish out` fixes the export's prefetch files on Windows,
 // writes the calendar files of collections of events, collections' feeds, the pages at redirects' old addresses and Cloudflare Pages' _redirects, and the search index for sites with a search block,
-// copies the site's Google Fonts into the export, starts every page with the admin address's guard for a site with one, and reports what automated checks find on the exported pages. `index` only writes the index.
+// copies the site's Google Fonts into the export, builds plugins' admin frames and runs their build steps, starts every page with the admin address's guard for a site with one, and reports what automated checks find on the exported pages. `index` only writes the index.
 // `goodfellow-next update` updates Goodfellow, as `goodfellow update` does for other sites.
-// `goodfellow-next due [--since <time>]` says whether a scheduled change has come due, as `goodfellow due` does.
+// `goodfellow-next task [--out <file>]` runs one of a plugin's tasks for the admin panel, as `goodfellow task` does.
+// `goodfellow-next due [--since <time>] [--output <file>]` says whether a scheduled change has come due, as `goodfellow due` does.
 // `goodfellow-next nightly [--mode <mode>]` says whether tonight's build is needed, as `goodfellow nightly` does.
 // `goodfellow-next content link|copy [folder]` puts a content repository's files in place, for a site whose
 // content is kept in a repository of its own.
 // `goodfellow-next import wordpress <file or address> [--dry-run]` imports a WordPress site, as `goodfellow import` does.
 // `goodfellow-next export wordpress [file]` writes the site as a WordPress export file, as `goodfellow export` does.
+// `goodfellow-next blocks add <item> [--registry <folder>] [--native <app>]` makes a block of a shadcn item, as
+// `goodfellow blocks add` does, and with --native its version for an Expo app.
 // `goodfellow-next admin add <address>|check|remove` sets the admin address, and `goodfellow-next broker use <address>|remove`
 // the token broker, in goodfellow.config.tsx, as `goodfellow admin` and `goodfellow broker` do.
 import { existsSync, readFileSync } from "node:fs";
 import { rm } from "node:fs/promises";
-import { relative } from "node:path";
+import { relative, resolve } from "node:path";
 import { parseArgs } from "node:util";
 import { buildNotes, CLOUDFLARE_REDIRECTS_LIMIT, configAdmin, formatUpdateResult } from "@goodfellow-cms/core";
 import { reportSiteProblems } from "@goodfellow-cms/core/accessibility";
@@ -38,8 +41,10 @@ import {
   update,
 } from "@goodfellow-cms/core/node";
 import { writePagesSearchIndex, writeSearchIndex } from "@goodfellow-cms/core/search-index";
+import { addShadcnBlock, blockWorks, formatShadcnBlock, ShadcnBlockError } from "@goodfellow-cms/core/shadcn";
 import { WordPressReadError } from "@goodfellow-cms/core/wordpress";
 import {
+  blockPageRender,
   buildFileFolders,
   builtPages,
   checkPages,
@@ -49,11 +54,14 @@ import {
   NEXT_SITE_FILES,
   writeBuildRecordFile,
   writeCalendarFiles,
+  writeContentApi,
   writeEditorPolicy,
   writeFeedFiles,
   writeFontFiles,
   writePageLanguages,
+  writePluginFiles,
   writeRedirectFiles,
+  writeTaskResult,
 } from "@goodfellow-cms/next/export";
 
 const [command, dir = "out"] = process.argv.slice(2);
@@ -77,9 +85,15 @@ if (command === "finish" && dir === "--server") {
   if (calendars > 0) console.log(`Wrote ${calendars} calendar files, in public/calendars`);
   const feeds = await writeFeedFiles("public");
   if (feeds > 0) console.log(`Wrote ${feeds} feeds, in public/feeds`);
+  const api = await writeContentApi("public");
+  if (api !== undefined) console.log(`Wrote the content API, with ${api} pages, in public/api`);
   // Before the pages are read, so the search index and the checks see each page's language.
   const languages = await writePageLanguages(undefined);
   if (languages > 0) console.log(`Marked ${languages} pages with their language`);
+  // Plugins' admin frames and build steps, into public/, which next start serves.
+  const plugins = await writePluginFiles("public");
+  if (plugins.frames.length > 0)
+    console.log(`Wrote the admin frames of ${plugins.frames.join(", ")}, in public/admin/plugins`);
   const pages = await builtPages();
   const indexed = await writePagesSearchIndex(pages, "public/pagefind");
   console.log(
@@ -102,9 +116,30 @@ if (command === "update") {
   console.log(formatUpdateResult(result));
   process.exit(result.state === "failed" ? 1 : 0);
 }
+if (command === "task") {
+  const { values } = parseArgs({ args: process.argv.slice(3), options: { out: { type: "string" } } });
+  const env = process.env;
+  await writeTaskResult(
+    ".",
+    {
+      id: env.GOODFELLOW_TASK_REQUEST ?? "",
+      plugin: env.GOODFELLOW_TASK_PLUGIN ?? "",
+      task: env.GOODFELLOW_TASK_NAME ?? "",
+      input: env.GOODFELLOW_TASK_INPUT ?? "",
+      key: env.GOODFELLOW_TASK_KEY ?? "",
+    },
+    values.out,
+  );
+  process.exit(0);
+}
 if (command === "due") {
-  const { values } = parseArgs({ args: process.argv.slice(3), options: { since: { type: "string" } } });
-  for (const line of await reportDue(await scheduleDue({ since: values.since }))) console.log(line);
+  const { values } = parseArgs({
+    args: process.argv.slice(3),
+    options: { since: { type: "string" }, output: { type: "string" } },
+  });
+  const result = await scheduleDue({ since: values.since });
+  for (const line of await reportDue(result, process.env, values.output ?? process.env.GITHUB_OUTPUT))
+    console.log(line);
   process.exit(0);
 }
 if (command === "nightly") {
@@ -199,6 +234,31 @@ if (command === "export") {
     process.exit(0);
   }
 }
+if (command === "blocks") {
+  const { positionals, values } = parseArgs({
+    args: process.argv.slice(3),
+    allowPositionals: true,
+    options: { registry: { type: "string" }, native: { type: "string" } },
+  });
+  const [action, item] = positionals;
+  if (action === "add" && item) {
+    try {
+      const result = await addShadcnBlock({
+        root: process.cwd(),
+        item,
+        ...(values.registry && { registry: resolve(values.registry) }),
+        ...(values.native && { native: resolve(values.native) }),
+        render: blockPageRender("."),
+      });
+      console.log(formatShadcnBlock(result));
+      process.exit(blockWorks(result) ? 0 : 1);
+    } catch (error) {
+      if (!(error instanceof ShadcnBlockError)) throw error;
+      console.error(error.message);
+      process.exit(1);
+    }
+  }
+}
 if (command !== "finish" && command !== "index") {
   console.error(
     [
@@ -206,18 +266,20 @@ if (command !== "finish" && command !== "index") {
       "       goodfellow-next finish --server",
       "       goodfellow-next index [folder]",
       "       goodfellow-next update [--to fixes|automatic|latest|<release>] [--publish | --commit]",
-      "       goodfellow-next due [--since <time>]",
+      "       goodfellow-next due [--since <time>] [--output <file>]",
       "       goodfellow-next nightly [--mode changed|always|off] [--output <file>]",
       "       goodfellow-next content link|copy [folder]",
       "       goodfellow-next import wordpress <file or address> [--dry-run]",
       "       goodfellow-next export wordpress [file]",
+      "       goodfellow-next blocks add <item> [--registry <folder>] [--native <app>]",
       "       goodfellow-next admin add <address> | check | remove",
       "       goodfellow-next broker use <address> | remove",
       "",
       "finish  Gets the exported site in folder (default: out) ready to publish: puts the files",
       "        Next.js uses to load pages ahead where browsers look for them, writes calendar files",
       "        for collections of events, collections' feeds and pages that send visitors on from",
-      "        old addresses, indexes it for search, and lists what automated accessibility checks",
+      "        old addresses, builds plugins' admin frames and runs their build steps, indexes it",
+      "        for search, and lists what automated accessibility checks",
       "        find on its pages. With --server, for a full-stack site, writes the calendar files",
       "        and feeds into public/calendars and public/feeds and indexes and checks the pages",
       "        next build rendered, with the index in public/pagefind, instead.",
@@ -227,7 +289,7 @@ if (command !== "finish" && command !== "index") {
       "        that runs none of the site's code to publish.",
       "due     Says whether a scheduled change has come due since --since (default: the last",
       "        hour), so the site needs building again, and sets the step's due output on",
-      "        GitHub Actions.",
+      "        GitHub Actions, or adds it to --output.",
       "nightly Says whether tonight's build is needed: when the site has changed since the live",
       "        site was built, what it shows by today's date has, or an update is available",
       "        (--mode, or GOODFELLOW_NIGHTLY: changed, the default, always or off), and sets the",
@@ -240,6 +302,11 @@ if (command !== "finish" && command !== "index") {
       "        says what it would bring across and changes nothing.",
       "export  Writes this site as a WordPress export file (default: named after the site),",
       "        which WordPress imports with Tools → Import → WordPress.",
+      "blocks  Installs a shadcn registry item (button, @acme/hero, or an item's address) with",
+      "        shadcn's own CLI, makes a block of its component, with fields from its props, and",
+      "        says what it couldn't do. With --registry, writes the block into the block registry",
+      "        in folder instead. Needs TypeScript 7 as typescript-7, since Next.js builds with 5:",
+      "        npm install --save-dev typescript-7@npm:typescript@7.0.2",
       "admin   The admin panel's address of its own, such as admin.example.org, in",
       "        goodfellow.config.tsx: add names it; check checks it once the site has rebuilt with",
       "        it, then starts the admin panel only there; remove stops using it.",
@@ -259,6 +326,8 @@ if (command === "finish") {
   if (calendars > 0) console.log(`Wrote ${calendars} calendar files`);
   const feeds = await writeFeedFiles(dir);
   if (feeds > 0) console.log(`Wrote ${feeds} feeds`);
+  const api = await writeContentApi(dir);
+  if (api !== undefined) console.log(`Wrote the content API, with ${api} pages, in api/`);
   const languages = await writePageLanguages(dir);
   if (languages > 0) console.log(`Marked ${languages} pages with their language`);
   // Before the redirects' pages, which aren't the site's.
@@ -271,6 +340,9 @@ if (command === "finish") {
     );
   }
   for (const line of buildNotes(await writeFontFiles(dir))) console.log(line);
+  // Plugins' admin frames and build steps, once Goodfellow has written the rest, before the index and the guards.
+  const plugins = await writePluginFiles(dir);
+  if (plugins.frames.length > 0) console.log(`Wrote the admin frames of ${plugins.frames.join(", ")}`);
   // What the site was built from, and when it stops being current, for the nightly check.
   const currentUntil = await writeBuildRecordFile(dir);
   if (currentUntil) {

package/dist/admin.js

@@ -58,6 +58,7 @@ function useEditorRebuilds() {
 * dependencies are.
 */
 const HOSTS = {
+	"@goodfellow-cms/bitbucket": () => import("@goodfellow-cms/bitbucket"),
 	"@goodfellow-cms/github": () => import("@goodfellow-cms/github"),
 	"@goodfellow-cms/gitlab": () => import("@goodfellow-cms/gitlab")
 };

package/dist/config.js

@@ -1,5 +1,5 @@
 import { CALENDARS_DIR, FEEDS_DIR, allPages, brokerOrigin, configAdmin, configBroker, loadSiteContent, normalizeBase, redirectFrom, redirectProblems, shownContent, vercelAdminHeaders } from "@goodfellow-cms/core";
-import { BUILD_DATES_DIR, BUILD_DATES_ENV, DEV_API_PREFIX, contentRepositoryProblem, fileSystemSource, handleDevApi, isLocalOrigin, localFileStore, localRegistryDir } from "@goodfellow-cms/core/node";
+import { BUILD_DATES_DIR, BUILD_DATES_ENV, DEV_API_PREFIX, builtSiteSource, contentRepositoryProblem, handleDevApi, isLocalOrigin, localFileStore, localRegistryDir } from "@goodfellow-cms/core/node";
 import { existsSync, readFileSync } from "node:fs";
 import { rm } from "node:fs/promises";
 import { createServer } from "node:http";
@@ -41,15 +41,21 @@ function startDevApi(root) {
 	globals[SERVER_KEY] ??= new Promise((resolvePort, reject) => {
 		const store = localFileStore(root);
 		const registryDir = localRegistryDir(root);
-		const editor = import("./dev-editor-DiPKrIAS.js").then(({ startDevEditor }) => startDevEditor(root)).catch((error) => {
+		const editor = import("./dev-editor-CzE9HofK.js").then(({ startDevEditor }) => startDevEditor(root)).catch((error) => {
 			console.error(`The editor's frames can't be served: ${error.message}`);
 			return { serve: async () => false };
 		});
+		const tasks = {
+			root,
+			plugins: async () => (await (await import("./plugins-K5i8XztM.js").then((n) => n.o)).loadSiteConfig(root)).plugins ?? [],
+			server: "next-dev"
+		};
 		const server = createServer(async (req, res) => {
 			if (await (await editor).serve(req, res)) return;
 			if (!await handleDevApi(store, req, res, {
 				trustOrigin: isLocalOrigin,
-				registryDir
+				registryDir,
+				tasks
 			})) res.writeHead(404).end();
 		});
 		server.on("error", reject);
@@ -95,7 +101,7 @@ function redirectSource(path) {
 * Content with a problem gives none, and the build reports the problem.
 */
 async function siteRedirects(root) {
-	const content = await loadSiteContent(fileSystemSource(root)).then(shownContent, () => void 0);
+	const content = await loadSiteContent(builtSiteSource(root)).then(shownContent, () => void 0);
 	if (!content?.redirects) return [];
 	const taken = new Set(allPages(content).map((page) => page.path));
 	const problems = redirectProblems(content.redirects);

package/dist/{dev-editor-DiPKrIAS.js → dev-editor-CzE9HofK.js}

@@ -1,4 +1,5 @@
-import { DEV_EDITOR_PREFIX, EDITOR_PRELUDE, editorPage } from "@goodfellow-cms/core";
+import { i as loadSiteConfig, t as buildPluginFrame } from "./plugins-K5i8XztM.js";
+import { DEV_EDITOR_PREFIX, EDITOR_PRELUDE, editorPage, pluginId } from "@goodfellow-cms/core";
 import { existsSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join, resolve, sep } from "node:path";
@@ -101,8 +102,53 @@ async function startDevEditor(root) {
 			built();
 		}
 	});
+	const pluginsDir = join(root, "node_modules/.goodfellow/next-plugins");
+	const pluginsPrefix = DEV_EDITOR_PREFIX.replace(/editor\/$/, "plugins/");
+	const pluginBuilds = /* @__PURE__ */ new Map();
+	const pluginFrame = (id) => {
+		let ready = pluginBuilds.get(id);
+		if (!ready) {
+			ready = (async () => {
+				const plugin = (await loadSiteConfig(root)).plugins?.find((candidate) => pluginId(candidate.name) === id && candidate.admin);
+				if (!plugin) {
+					pluginBuilds.delete(id);
+					return false;
+				}
+				await new Promise((done) => {
+					buildPluginFrame(plugin, {
+						root,
+						dir: join(pluginsDir, id),
+						watch: { onBuilt(error) {
+							if (error) console.error(`${plugin.title}'s admin frame couldn't be built: ${error.message}`);
+							done();
+						} }
+					}).catch((error) => {
+						console.error(`${plugin.title}'s admin frame couldn't be built: ${error.message}`);
+						done();
+					});
+				});
+				return true;
+			})();
+			pluginBuilds.set(id, ready);
+		}
+		return ready;
+	};
 	return { async serve(req, res) {
 		const pathname = new URL(req.url ?? "/", "http://localhost").pathname;
+		if (pathname.startsWith(pluginsPrefix) && (req.method === "GET" || req.method === "HEAD")) {
+			const [id = "", ...rest] = decodeURIComponent(pathname.slice(pluginsPrefix.length)).split("/");
+			const file = resolve(pluginsDir, id, rest.join("/") || "index.html");
+			if (!file.startsWith(`${pluginsDir}${sep}`) || !await pluginFrame(id)) return false;
+			try {
+				const data = await readFile(file);
+				res.setHeader("Content-Type", TYPES[file.slice(file.lastIndexOf(".") + 1)] ?? "application/octet-stream");
+				res.setHeader("Cache-Control", "no-store");
+				res.end(req.method === "HEAD" ? void 0 : data);
+			} catch {
+				res.writeHead(404).end();
+			}
+			return true;
+		}
 		const page = pathname === DEV_EDITOR_PREFIX.slice(0, -1);
 		if (!(page || pathname.startsWith(DEV_EDITOR_PREFIX)) || req.method !== "GET" && req.method !== "HEAD") return false;
 		await ready;

package/dist/export.d.ts

@@ -1,5 +1,6 @@
-import { SelfHostedResult, SiteProblem } from "@goodfellow-cms/core";
+import { PluginTaskRequest, SelfHostedResult, SiteProblem, TaskResultFile } from "@goodfellow-cms/core";
 import { SiteFile } from "@goodfellow-cms/core/node";
+import { PageRender } from "@goodfellow-cms/core/shadcn";
 //#region src/site-files.d.ts
 /**
  * The Next.js starter's files that `goodfellow-next update` keeps up to date
@@ -20,12 +21,35 @@ export declare function writeCalendarFiles(outDir: string, root?: string): Promi
  * build` does. Returns how many it wrote: none without the site's address.
  */
 export declare function writeFeedFiles(outDir: string, root?: string): Promise<number>;
+/**
+ * Writes the content API (`/api/`) into the export, as `goodfellow build`
+ * does: the site's content as JSON, each page as it's shown, prepared in Node
+ * with the site's config as `goodfellow build` prepares it, so both write the
+ * same files. Returns how many pages it has, or `undefined` where the
+ * config's `api` is `false`.
+ */
+export declare function writeContentApi(outDir: string, root?: string): Promise<number | undefined>;
 /**
  * The folders the calendar files and feeds go in: `calendars/` and `feeds/`,
  * and on a site in several languages, the same under each other language's
  * code, such as `es/feeds/`.
  */
 export declare function buildFileFolders(root?: string): Promise<string[]>;
+/** What `writePluginFiles()` wrote and ran. */
+export interface PluginFilesWritten {
+  /** The plugins whose admin frames were written. */
+  frames: string[];
+  /** The build steps that ran, as `plugin: step`. */
+  steps: string[];
+}
+/**
+ * Plugins' parts that builds make: each plugin's admin frame, beside the
+ * editor's frames at `admin/plugins/<id>/`, and its build steps, each in a
+ * process of its own held to what the plugin declared. Into a static export
+ * (`outDir`), or a full-stack site's `public/`, where `next start` serves
+ * them. The config is loaded outside Next.js only when it lists plugins.
+ */
+export declare function writePluginFiles(outDir: string, root?: string): Promise<PluginFilesWritten>;
 /** What `writeFontFiles()` did, for `buildNotes()`. */
 export interface FontsWritten {
   fonts?: SelfHostedResult;
@@ -118,4 +142,17 @@ export declare function exportedPages(outDir: string): Promise<BuiltPage[]>;
  * Pages that aren't the site's, such as Next.js's own, are left out.
  */
 export declare function checkPages(pages: readonly BuiltPage[], root?: string): Promise<SiteProblem[]>;
+/**
+ * Runs one of a plugin's tasks for the admin panel, as `goodfellow task`
+ * does for other sites, with the site's config loaded in Node, and writes its
+ * answer sealed to the request's key, even when the task fails. Secrets are
+ * taken out of the environment before the config loads.
+ */
+export declare function writeTaskResult(root: string, request: PluginTaskRequest, out?: string): Promise<TaskResultFile>;
+/**
+ * Renders a page with a block from its own file as well as the site's config's,
+ * for `goodfellow-next blocks add`'s check that a block it made renders: both
+ * loaded in Node, as `goodfellow-next finish` loads the config.
+ */
+export declare function blockPageRender(root: string): PageRender;
 //#endregion

package/dist/export.js

@@ -1,10 +1,12 @@
+import { a as loadSiteModule, i as loadSiteConfig, n as buildPluginFrames, r as configHasPlugins } from "./plugins-K5i8XztM.js";
 import { r as NEXT_SITE_FILES } from "./site-files-BeLnLxCl.js";
-import { CALENDARS_DIR, CLOUDFLARE_REDIRECTS_PATH, EDITOR_PRELUDE, FEEDS_DIR, SITE_DESCRIPTION_PATH, absoluteUrl, allPages, calendarFiles, cloudflareRedirects, editorPolicy, feedFiles, hasLanguages, loadSiteContent, parseSiteDescription, pathLanguage, redirectFiles, rootRobotsUrl, shownContent, siteLanguages } from "@goodfellow-cms/core";
-import { BUILD_DATES_DIR, fileSystemSource, guardBuiltSite, reportedDate, selfHostFonts, writeBuildRecord } from "@goodfellow-cms/core/node";
+import { CALENDARS_DIR, CLOUDFLARE_REDIRECTS_PATH, EDITOR_PRELUDE, FEEDS_DIR, SITE_DESCRIPTION_PATH, TASK_RESULT_FILE, absoluteUrl, allPages, calendarFiles, cloudflareRedirects, editorPolicy, feedFiles, hasLanguages, loadSiteContent, parseSiteDescription, pathLanguage, pluginId, redirectFiles, rootRobotsUrl, sealTaskAnswer, shownContent, siteLanguages, sitePages, taskRequestProblem, todayIn } from "@goodfellow-cms/core";
+import { BUILD_DATES_DIR, builtSiteSource, guardBuiltSite, reportedDate, runPluginBuildSteps, runPluginTask, selfHostFonts, taskSecretsFrom, writeBuildRecord } from "@goodfellow-cms/core/node";
 import { access, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, join, relative, resolve } from "node:path";
 import { createHash } from "node:crypto";
 import { checkBuiltPages } from "@goodfellow-cms/core/accessibility";
+import { CONTENT_API_DIR } from "@goodfellow-cms/core/content-api";
 //#region src/export.ts
 /**
 * Writes the calendar files of the site's collections of events into the
@@ -12,7 +14,7 @@ import { checkBuiltPages } from "@goodfellow-cms/core/accessibility";
 * how many it wrote.
 */
 async function writeCalendarFiles(outDir, root = process.cwd()) {
-	const files = calendarFiles(shownContent(await loadSiteContent(fileSystemSource(resolve(root)))));
+	const files = calendarFiles(shownContent(await loadSiteContent(builtSiteSource(resolve(root)))));
 	for (const file of files) {
 		const target = join(outDir, file.path.slice(1));
 		await mkdir(dirname(target), { recursive: true });
@@ -25,7 +27,7 @@ async function writeCalendarFiles(outDir, root = process.cwd()) {
 * build` does. Returns how many it wrote: none without the site's address.
 */
 async function writeFeedFiles(outDir, root = process.cwd()) {
-	const files = feedFiles(shownContent(await loadSiteContent(fileSystemSource(resolve(root)))));
+	const files = feedFiles(shownContent(await loadSiteContent(builtSiteSource(resolve(root)))));
 	for (const file of files) {
 		const target = join(outDir, file.path.slice(1));
 		await mkdir(dirname(target), { recursive: true });
@@ -34,12 +36,38 @@ async function writeFeedFiles(outDir, root = process.cwd()) {
 	return files.length;
 }
 /**
+* Writes the content API (`/api/`) into the export, as `goodfellow build`
+* does: the site's content as JSON, each page as it's shown, prepared in Node
+* with the site's config as `goodfellow build` prepares it, so both write the
+* same files. Returns how many pages it has, or `undefined` where the
+* config's `api` is `false`.
+*/
+async function writeContentApi(outDir, root = process.cwd()) {
+	const dir = resolve(root);
+	const config = await loadSiteConfig(dir);
+	if (config.api === false) return void 0;
+	const { contentApi } = await import("@goodfellow-cms/react/server");
+	const content = shownContent(await loadSiteContent(builtSiteSource(dir)));
+	const pages = sitePages(content, todayIn(content.settings.timeZone), config.blocks);
+	const files = await contentApi(config, content, pages, { base: await exportBasePath(dir) });
+	await rm(join(outDir, CONTENT_API_DIR), {
+		recursive: true,
+		force: true
+	});
+	for (const file of files) {
+		const target = join(outDir, file.path.slice(1));
+		await mkdir(dirname(target), { recursive: true });
+		await writeFile(target, file.content);
+	}
+	return pages.length;
+}
+/**
 * The folders the calendar files and feeds go in: `calendars/` and `feeds/`,
 * and on a site in several languages, the same under each other language's
 * code, such as `es/feeds/`.
 */
 async function buildFileFolders(root = process.cwd()) {
-	const { settings } = await loadSiteContent(fileSystemSource(resolve(root)));
+	const { settings } = await loadSiteContent(builtSiteSource(resolve(root)));
 	return siteLanguages(settings).flatMap((language) => [CALENDARS_DIR, FEEDS_DIR].map((dir) => `${language.prefix.slice(1)}${language.prefix ? "/" : ""}${dir}`));
 }
 /** The `basePath` the export was built with, which Next.js records in `.next/routes-manifest.json`. */
@@ -51,6 +79,36 @@ async function exportBasePath(root) {
 		return "";
 	}
 }
+/**
+* Plugins' parts that builds make: each plugin's admin frame, beside the
+* editor's frames at `admin/plugins/<id>/`, and its build steps, each in a
+* process of its own held to what the plugin declared. Into a static export
+* (`outDir`), or a full-stack site's `public/`, where `next start` serves
+* them. The config is loaded outside Next.js only when it lists plugins.
+*/
+async function writePluginFiles(outDir, root = process.cwd()) {
+	const site = resolve(root);
+	if (!await configHasPlugins(site)) return {
+		frames: [],
+		steps: []
+	};
+	const config = await loadSiteConfig(site);
+	const base = `${await exportBasePath(site)}/`;
+	const dir = resolve(site, outDir);
+	return {
+		frames: await buildPluginFrames(config.plugins, {
+			root: site,
+			outDir: dir
+		}),
+		steps: (await runPluginBuildSteps({
+			root: site,
+			outDir: dir,
+			base,
+			plugins: config.plugins ?? [],
+			onStep: (step) => console.log(`Running ${step.title}, from ${step.plugin}…`)
+		})).map((step) => `${step.plugin}: ${step.title}`)
+	};
+}
 async function exists(path) {
 	return access(path).then(() => true, () => false);
 }
@@ -61,7 +119,7 @@ async function exists(path) {
 * subfolder (`rootRobotsUrl()`).
 */
 async function writeFontFiles(outDir, root = process.cwd()) {
-	const { settings } = await loadSiteContent(fileSystemSource(resolve(root)));
+	const { settings } = await loadSiteContent(builtSiteSource(resolve(root)));
 	const fonts = await selfHostFonts(outDir, settings.theme, { base: await exportBasePath(root) });
 	const robotsElsewhere = rootRobotsUrl(settings.url);
 	return {
@@ -78,7 +136,7 @@ async function writeFontFiles(outDir, root = process.cwd()) {
 */
 async function writeBuildRecordFile(outDir, root = process.cwd()) {
 	const dir = resolve(root);
-	const content = await loadSiteContent(fileSystemSource(dir));
+	const content = await loadSiteContent(builtSiteSource(dir));
 	const date = await reportedDate(join(dir, ".next", BUILD_DATES_DIR));
 	return (await writeBuildRecord(outDir, {
 		root: dir,
@@ -95,7 +153,7 @@ async function writeBuildRecordFile(outDir, root = process.cwd()) {
 */
 async function writeRedirectFiles(outDir, root = process.cwd()) {
 	const dir = resolve(root);
-	const content = shownContent(await loadSiteContent(fileSystemSource(dir)));
+	const content = shownContent(await loadSiteContent(builtSiteSource(dir)));
 	const base = await exportBasePath(dir);
 	const files = redirectFiles(content, {
 		taken: allPages(content).map((page) => page.path),
@@ -131,7 +189,7 @@ async function guardExport(outDir, root = process.cwd()) {
 	const admin = parsed?.ok ? parsed.description.admin : void 0;
 	if (!admin) return void 0;
 	const dir = resolve(root);
-	const content = await loadSiteContent(fileSystemSource(dir));
+	const content = await loadSiteContent(builtSiteSource(dir));
 	return guardBuiltSite(outDir, {
 		admin,
 		...parsed?.ok && parsed.description.broker && { broker: parsed.description.broker },
@@ -215,7 +273,7 @@ function withPageLanguage(html, language) {
 */
 async function writePageLanguages(outDir, root = process.cwd()) {
 	const dir = resolve(root);
-	const { settings } = await loadSiteContent(fileSystemSource(dir));
+	const { settings } = await loadSiteContent(builtSiteSource(dir));
 	if (!hasLanguages(settings)) return 0;
 	const base = outDir ?? join(dir, ".next/server/app");
 	const files = (await readdir(base, { recursive: true })).map((file) => file.split("\\").join("/")).filter((file) => file.endsWith(".html") && !/^(admin|_next|pagefind)\//.test(file));
@@ -283,7 +341,7 @@ function contentFile(pages, path) {
 * Pages that aren't the site's, such as Next.js's own, are left out.
 */
 async function checkPages(pages, root = process.cwd()) {
-	const known = allPages(shownContent(await loadSiteContent(fileSystemSource(resolve(root)))));
+	const known = allPages(shownContent(await loadSiteContent(builtSiteSource(resolve(root)))));
 	return checkBuiltPages(pages.flatMap((page) => {
 		const path = page.url.replace(/(.)\/$/, "$1");
 		const file = contentFile(known, path);
@@ -294,5 +352,62 @@ async function checkPages(pages, root = process.cwd()) {
 		}] : [];
 	}));
 }
+/**
+* Runs one of a plugin's tasks for the admin panel, as `goodfellow task`
+* does for other sites, with the site's config loaded in Node, and writes its
+* answer sealed to the request's key, even when the task fails. Secrets are
+* taken out of the environment before the config loads.
+*/
+async function writeTaskResult(root, request, out = TASK_RESULT_FILE) {
+	const secrets = taskSecretsFrom(process.env);
+	const problem = taskRequestProblem(request);
+	if (problem) throw new Error(problem);
+	let answer;
+	try {
+		const plugin = ((await loadSiteConfig(resolve(root))).plugins ?? []).find((candidate) => pluginId(candidate.name) === request.plugin);
+		answer = plugin ? await runPluginTask({
+			root: resolve(root),
+			plugin,
+			task: request.task,
+			input: request.input,
+			secrets
+		}) : {
+			ok: false,
+			error: `The site has no plugin ${request.plugin}.`
+		};
+	} catch (error) {
+		answer = {
+			ok: false,
+			error: `The site couldn't run the task: ${error instanceof Error ? error.message : error}`
+		};
+	}
+	const sealed = await sealTaskAnswer(answer, request.key);
+	await writeFile(resolve(root, out), `${JSON.stringify(sealed)}\n`);
+	return sealed;
+}
+/**
+* Renders a page with a block from its own file as well as the site's config's,
+* for `goodfellow-next blocks add`'s check that a block it made renders: both
+* loaded in Node, as `goodfellow-next finish` loads the config.
+*/
+function blockPageRender(root) {
+	return async (page, block) => {
+		const site = resolve(root);
+		const config = await loadSiteConfig(site);
+		const entry = (await loadSiteModule(site, join(site, block.entry))).default;
+		const { createPageRenderer } = await import("@goodfellow-cms/react/server");
+		return createPageRenderer({
+			...config,
+			blocks: {
+				...config.blocks,
+				[block.name]: entry
+			}
+		})(await loadSiteContent(builtSiteSource(site)), {
+			path: "/",
+			file: "content/pages/index.json",
+			content: page
+		});
+	};
+}
 //#endregion
-export { EDITOR_PAGES, NEXT_SITE_FILES, buildFileFolders, builtPages, checkPages, exportedPages, fixSegmentFiles, guardExport, writeBuildRecordFile, writeCalendarFiles, writeEditorPolicy, writeFeedFiles, writeFontFiles, writePageLanguages, writeRedirectFiles };
+export { EDITOR_PAGES, NEXT_SITE_FILES, blockPageRender, buildFileFolders, builtPages, checkPages, exportedPages, fixSegmentFiles, guardExport, writeBuildRecordFile, writeCalendarFiles, writeContentApi, writeEditorPolicy, writeFeedFiles, writeFontFiles, writePageLanguages, writePluginFiles, writeRedirectFiles, writeTaskResult };

package/dist/index.js

@@ -1,6 +1,6 @@
 import { ByLanguage, CurrentMenuLinks, NextImage, NextLink, PageLanguage } from "./components.js";
-import { absoluteUrl, colorSchemeMeta, colorSchemeScript, contentForPage, demoContent, feedLinks, findRedirect, fontPreloads, googleFontsUrl, hasLanguages, languageMap, loadSiteContent, normalizePagePath, pageHead, shownContent, siteLanguages, sitePages, sitemapPages, themeToCss, todayIn, withBase } from "@goodfellow-cms/core";
-import { BUILD_DATES_ENV, fileSystemSource, fontStandIns, readMediaSizes, readStylesheet, reportDatesTo } from "@goodfellow-cms/core/node";
+import { absoluteUrl, adminSiteForCopy, colorSchemeMeta, colorSchemeScript, contentForPage, demoContent, describedForCopy, feedLinks, findRedirect, fontPreloads, googleFontsUrl, hasLanguages, languageMap, loadSiteContent, normalizePagePath, pageHead, shownContent, siteCopyFrom, siteLanguages, sitePages, sitemapPages, storedMediaSizes, themeToCss, todayIn, withBase } from "@goodfellow-cms/core";
+import { BUILD_DATES_ENV, builtSiteSource, fileSystemSource, fontStandIns, readMediaSizes, readStylesheet, reportDatesTo } from "@goodfellow-cms/core/node";
 import { BodyCode, HeadCode, PageBody, PageContent, PageFooter, PageHeader, adminSite, applyPageEntry, createPuckConfigs, describeSite, prepareLayout, preparePage } from "@goodfellow-cms/react";
 import { notFound, redirect } from "next/navigation";
 import { cache } from "react";
@@ -24,7 +24,7 @@ function configuredBasePath() {
 * for the length of one request, so a page and its metadata read it once, and
 * content edits show on reload in development.
 */
-const loadSite = cache(async (root = process.cwd()) => shownContent(await loadSiteContent(fileSystemSource(root))));
+const loadSite = cache(async (root = process.cwd()) => shownContent(await loadSiteContent(builtSiteSource(root))));
 function pathOf(segments) {
 	try {
 		return normalizePagePath(`/${(segments ?? []).map((segment) => decodeURIComponent(segment)).join("/")}`);
@@ -87,7 +87,10 @@ function goodfellowPages(config, options = {}) {
 	const renderOptions = async () => ({
 		base: basePath(),
 		components,
-		media: await readMediaSizes(root)
+		media: {
+			...await readMediaSizes(root),
+			...storedMediaSizes((await site()).mediaStorage)
+		}
 	});
 	/** The site's theme and fonts, which React moves into the document's head. themeToCss escapes its output. */
 	async function Theme({ content }) {
@@ -134,7 +137,7 @@ function goodfellowPages(config, options = {}) {
 		* editor's frames, at `app/admin/editor/page.tsx`.
 		*/
 		admin() {
-			return adminSite(config);
+			return adminSiteForCopy(adminSite(config), siteCopyFrom(process.env));
 		},
 		/** For `app/admin/layout.tsx`: the admin panel's title, kept out of search engines, with the site's icon. */
 		async adminMetadata() {
@@ -268,7 +271,7 @@ function goodfellowPages(config, options = {}) {
 		* edit its content without its code, such as the Claude connector.
 		*/
 		siteDescription() {
-			return Response.json(describeSite(config));
+			return Response.json(describedForCopy(describeSite(config), siteCopyFrom(process.env)));
 		},
 		/** For `app/robots.ts`: lets search engines in, and points them at the sitemap once the site's address is set. */
 		async robots() {

package/dist/plugins-K5i8XztM.js

@@ -0,0 +1,197 @@
+import { EDITOR_PRELUDE, INSTALLED_PLUGINS_INDEX, PLUGINS_PATH, framedPlugins, pluginFrameEntry, pluginFramePage, pluginId } from "@goodfellow-cms/core";
+import { LICENSES_FILE, licensesPlugin } from "@goodfellow-cms/core/node";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { isAbsolute, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/plugins.ts
+/**
+* Plugins on Next.js sites: their admin frames, bundled with Rolldown as
+* `next dev` bundles the editor's frames, and their build steps, both run by
+* `goodfellow-next finish` from the site's config, which Next.js alone
+* bundles otherwise. Node only.
+*/
+var plugins_exports = /* @__PURE__ */ __exportAll({
+	buildPluginFrame: () => buildPluginFrame,
+	buildPluginFrames: () => buildPluginFrames,
+	configHasPlugins: () => configHasPlugins,
+	findConfigFile: () => findConfigFile,
+	loadSiteConfig: () => loadSiteConfig,
+	loadSiteModule: () => loadSiteModule
+});
+const CONFIG_FILES = [
+	"goodfellow.config.tsx",
+	"goodfellow.config.ts",
+	"goodfellow.config.jsx",
+	"goodfellow.config.js"
+];
+const FRAME_ENTRY = "\0goodfellow:plugin-frame";
+function findConfigFile(root) {
+	return CONFIG_FILES.map((name) => join(root, name)).find((file) => existsSync(file));
+}
+/**
+* Whether the site's config lists plugins, read from its text, so builds of
+* sites without any never load the config outside Next.js: plugins of its
+* own, or any installed from the admin panel, which `plugins/installed/`
+* lists.
+*/
+async function configHasPlugins(root) {
+	const file = findConfigFile(root);
+	const listed = file && /\bplugins\s*:\s*([^\n]*)/.exec(await readFile(file, "utf8"))?.[1];
+	if (!listed) return false;
+	if (!/^installedPlugins\s*,?$/.test(listed.trim())) return true;
+	const index = join(root, INSTALLED_PLUGINS_INDEX);
+	return existsSync(index) && /\binstalledPlugin\(/.test(await readFile(index, "utf8"));
+}
+/**
+* A module of the site, loaded in Node: bundled with Rolldown, with the
+* packages it imports left for Node to load and stylesheets left out, then
+* imported.
+*/
+async function loadSiteModule(root, input) {
+	const { build } = await import("rolldown");
+	const outDir = join(root, "node_modules/.goodfellow");
+	await mkdir(outDir, { recursive: true });
+	const file = join(outDir, `module-${process.pid}-${Date.now()}.mjs`);
+	await build({
+		input,
+		cwd: root,
+		platform: "node",
+		tsconfig: existsSync(join(root, "tsconfig.json")) ? join(root, "tsconfig.json") : false,
+		transform: { jsx: { runtime: "automatic" } },
+		external: (id, _importer, resolved) => resolved ? /[\\/]node_modules[\\/]/.test(id) : !id.startsWith(".") && !isAbsolute(id) && !id.startsWith("@/"),
+		plugins: [{
+			name: "goodfellow:no-styles",
+			load: (id) => id.endsWith(".css") ? {
+				code: "",
+				moduleType: "js"
+			} : void 0
+		}],
+		onLog(level, log, handler) {
+			if (log.code === "MODULE_LEVEL_DIRECTIVE") return;
+			handler(level, log);
+		},
+		output: {
+			file,
+			format: "esm",
+			codeSplitting: false
+		}
+	});
+	try {
+		return await import(pathToFileURL(file).href);
+	} finally {
+		await rm(file, { force: true });
+	}
+}
+/** The site's config, loaded in Node with `loadSiteModule()`. Only what plugins and checks need is read from it. */
+async function loadSiteConfig(root) {
+	const configFile = findConfigFile(root);
+	if (!configFile) throw new Error(`No goodfellow.config.tsx in ${root}.`);
+	return (await loadSiteModule(root, configFile)).default;
+}
+/** A plugin's admin module as the bundler imports it: a package's export, or a path from the site's root. */
+function adminModule(root, specifier) {
+	return specifier.startsWith("./") || specifier.startsWith("../") ? resolve(root, specifier) : specifier;
+}
+/**
+* Bundles a plugin's admin module into its frame, at `admin/plugins/<id>/`
+* under `outDir`: one classic script starting with `EDITOR_PRELUDE`, its
+* stylesheets in one file, `pluginFramePage()`, whose Content Security
+* Policy reaches only the addresses the plugin declared, and the notices of
+* what it bundles (`LICENSES_FILE`). Answers a function that stops rebuilding.
+*/
+async function buildPluginFrame(plugin, { root, dir, watch }) {
+	if (!plugin.admin) throw new Error(`${plugin.name} has no admin module.`);
+	const rolldown = await import("rolldown");
+	await mkdir(dir, { recursive: true });
+	const stylesheets = /* @__PURE__ */ new Set();
+	const writePage = async () => {
+		const css = await Promise.all([...stylesheets].map((file) => readFile(file, "utf8")));
+		await writeFile(join(dir, "plugin.css"), css.join("\n"));
+		await writeFile(join(dir, "index.html"), pluginFramePage({
+			permissions: plugin.permissions ?? {},
+			scripts: ["plugin.js"],
+			stylesheets: ["plugin.css"],
+			licenses: LICENSES_FILE,
+			editor: Boolean(plugin.editor)
+		}));
+	};
+	const options = {
+		input: { plugin: FRAME_ENTRY },
+		cwd: root,
+		platform: "browser",
+		tsconfig: existsSync(join(root, "tsconfig.json")) ? join(root, "tsconfig.json") : false,
+		transform: {
+			jsx: { runtime: "automatic" },
+			define: { "process.env.NODE_ENV": JSON.stringify(watch ? "development" : "production") }
+		},
+		plugins: [{
+			name: "goodfellow:plugin-frame",
+			resolveId: (id) => id === FRAME_ENTRY ? id : void 0,
+			load(id) {
+				if (id === FRAME_ENTRY) return pluginFrameEntry(adminModule(root, plugin.admin ?? ""));
+				if (id.endsWith(".css")) {
+					stylesheets.add(id);
+					return {
+						code: "",
+						moduleType: "js"
+					};
+				}
+			}
+		}, licensesPlugin(plugin.title, LICENSES_FILE)],
+		onLog(level, log, handler) {
+			if (log.code === "MODULE_LEVEL_DIRECTIVE") return;
+			handler(level, log);
+		},
+		output: {
+			dir,
+			format: "iife",
+			codeSplitting: false,
+			entryFileNames: "plugin.js",
+			banner: EDITOR_PRELUDE,
+			...watch ? { sourcemap: true } : { minify: true }
+		}
+	};
+	if (!watch) {
+		await rolldown.build(options);
+		await writePage();
+		return async () => {};
+	}
+	const watcher = rolldown.watch(options);
+	watcher.on("event", (event) => {
+		if (event.code === "BUNDLE_END") {
+			event.result.close();
+			writePage().then(() => watch.onBuilt(), (error) => watch.onBuilt(error));
+		} else if (event.code === "ERROR") {
+			event.result?.close();
+			watch.onBuilt(event.error);
+		}
+	});
+	return () => watcher.close();
+}
+/** Builds every plugin's admin frame into `admin/plugins/<id>/` in `outDir`. Answers the plugins' names. */
+async function buildPluginFrames(plugins, { root, outDir }) {
+	const built = [];
+	for (const plugin of framedPlugins(plugins)) {
+		await buildPluginFrame(plugin, {
+			root,
+			dir: join(outDir, PLUGINS_PATH, pluginId(plugin.name))
+		});
+		built.push(plugin.name);
+	}
+	return built;
+}
+//#endregion
+export { loadSiteModule as a, loadSiteConfig as i, buildPluginFrames as n, plugins_exports as o, configHasPlugins as r, buildPluginFrame as t };

package/dist/server.d.ts

@@ -31,6 +31,13 @@ export interface GoodfellowApiOptions {
   ai?: ServerKeys;
   /** Told about failures editors only hear about as "something went wrong". Defaults to `console.error`. */
   onError?: (error: unknown) => void;
+  /**
+   * The server modules of the config's plugins, by plugin name, imported in
+   * the route's file, such as `{ "goodfellow-plugin-s3": s3Server }` from
+   * `import s3Server from "goodfellow-plugin-s3/server"`. Each answers
+   * `plugins/<id>/…`, and runs with everything the server has.
+   */
+  plugins?: AppApiOptions["plugins"];
 }
 /** The route parameters of a catch-all route named `[...path]`. */
 interface RouteContext {

package/dist/server.js

@@ -31,7 +31,8 @@ function goodfellowApi(options) {
 			signIn: options.signIn,
 			...options.signOut && { signOut: options.signOut },
 			...ai && ai.services.length > 0 && { ai },
-			...options.onError && { onError: options.onError }
+			...options.onError && { onError: options.onError },
+			...options.plugins && { plugins: options.plugins }
 		});
 		return api;
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodfellow-cms/next",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Goodfellow pages and the admin panel in a Next.js site.",
   "keywords": [
     "goodfellow",
@@ -63,22 +63,23 @@
     "dist"
   ],
   "dependencies": {
-    "@goodfellow-cms/ai": "0.5.0",
-    "@goodfellow-cms/core": "0.5.0",
-    "@goodfellow-cms/react": "0.5.0",
+    "@goodfellow-cms/ai": "0.7.0",
+    "@goodfellow-cms/core": "0.7.0",
+    "@goodfellow-cms/react": "0.7.0",
     "rolldown": "1.2.12"
   },
   "peerDependencies": {
-    "@goodfellow-cms/admin": "0.5.0",
+    "@goodfellow-cms/admin": "0.7.0",
     "@puckeditor/core": "0.23.0",
     "next": "^16.0.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   },
   "devDependencies": {
-    "@goodfellow-cms/admin": "0.5.0",
-    "@goodfellow-cms/github": "0.5.0",
-    "@goodfellow-cms/gitlab": "0.5.0",
+    "@goodfellow-cms/admin": "0.7.0",
+    "@goodfellow-cms/bitbucket": "0.7.0",
+    "@goodfellow-cms/github": "0.7.0",
+    "@goodfellow-cms/gitlab": "0.7.0",
     "@puckeditor/core": "0.23.0",
     "@tailwindcss/browser": "4.3.3",
     "@types/react": "^19.2.0",