@tideworthy/tidysites-platform 0.9.1 → 0.10.1

package/README.md

@@ -133,6 +133,10 @@ Applies the template seed's structure to a site that is already set up: block ty
 
 Runs EmDash's scheduled work now (scheduled publishing, cleanup) and returns what it published. Workers in a dispatch namespace never receive cron triggers, so the platform's cron calls this on every site each minute.
 
+### `GET|POST /_tidy/revisions`
+
+The site's revision history for the signed-in editor (the Astro session is the gate, no bearer). `GET ?path=/x` lists every publish; `GET ?id=<revision>&path=/x` returns that page as it was in the revision, read from the control plane's stored copy; `POST {action:"restore", id}` puts the live site and the staging content back on it; `POST {action:"publish"}` makes the live site follow staging now. The editor bar's Revisions and Publish live controls call it; `?tidy-revisions=1` on any page opens the list and `?tidy-revision=<id>` opens that revision of the page.
+
 ## Publish hooks
 
 The plugin registers `content:afterPublish`, `content:afterUnpublish`, and `content:afterDelete`. Each posts `{ reason, collection, id }` to `POST <TIDY_CONTROL_ORIGIN>/sites/<TIDY_SITE_ID>/publish` over the `PLATFORM` binding with the site secret as bearer. Hooks run with `errorPolicy: "continue"` and an 8 second timeout, so a slow or failing control plane never fails the editor's publish.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tideworthy/tidysites-platform",
-	"version": "0.9.1",
+	"version": "0.10.1",
 	"description": "The Tidysites platform integration for EmDash sites: bootstrap, sessions, maintenance, health, and publish hooks under /_tidy/*.",
 	"license": "MIT",
 	"type": "module",
@@ -30,7 +30,8 @@
 		"./routes/rotate-token": "./src/routes/rotate-token.ts",
 		"./routes/fill": "./src/routes/fill.ts",
 		"./routes/schema": "./src/routes/schema.ts",
-		"./routes/maintenance": "./src/routes/maintenance.ts"
+		"./routes/maintenance": "./src/routes/maintenance.ts",
+		"./routes/revisions": "./src/routes/revisions.ts"
 	},
 	"scripts": {
 		"typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.editor.json",

package/src/editor/TidyEditor.astro

@@ -52,6 +52,7 @@ const htmlClass = !signedIn ? "" : !active ? "tidy-has-bar tidy-idle" : "tidy-ha
 			</div>
 		</div>
 		<script is:inline define:vars={{ htmlClass }}>document.documentElement.className += " " + htmlClass;</script>
+		<script src="./revisions.ts"></script>
 	</>
 )}
 {config && (
@@ -119,4 +120,9 @@ const htmlClass = !signedIn ? "" : !active ? "tidy-has-bar tidy-idle" : "tidy-ha
 	.tidy-add-item { display: grid; gap: 2px; text-align: left; padding: 10px 12px; border: 1px solid #d3dcd6; border-radius: 8px; background: #fff; cursor: pointer; font: inherit; }
 	.tidy-add-item:hover { border-color: #2b7fd1; background: rgba(43,127,209,.06); }
 	.tidy-add-item span { color: #4a5851; font-size: 13px; }
+	.tidy-viewer { position: fixed; inset: 0; z-index: 2147483002; display: flex; flex-direction: column; background: #fff; }
+	.tidy-viewer[hidden] { display: none; }
+	.tidy-viewer-bar { display: flex; align-items: center; gap: 8px; padding: 0 16px; height: 44px; background: #17211c; color: #fff; font: 500 13px/1 system-ui, sans-serif; }
+	.tidy-viewer-label { flex: 1; opacity: .85; }
+	.tidy-viewer-frame { flex: 1; width: 100%; border: 0; }
 </style>

package/src/editor/revisions.ts

@@ -0,0 +1,159 @@
+/// <reference lib="dom" />
+/// <reference lib="dom.iterable" />
+/**
+ * Revision history and Publish live, on the editor bar for anyone signed in,
+ * editing or not. Revisions are the site's publishes (the control plane keeps
+ * a full copy of each). Pick one and the page you are on shows as it was
+ * then; Restore puts the live site, and the staging content, back on it.
+ * Publish live makes the live site follow staging now.
+ *
+ * Deep links: ?tidy-revisions=1 opens the list; ?tidy-revision=<id> opens
+ * that revision of this page.
+ */
+
+interface Revision {
+	id: string;
+	at: string;
+	pages: number | null;
+	restoredFrom: string | null;
+}
+
+const ROUTE = "/_tidy/revisions";
+
+function el<K extends keyof HTMLElementTagNameMap>(tag: K, attrs: Record<string, string> = {}, children: Array<Node | string> = []): HTMLElementTagNameMap[K] {
+	const node = document.createElement(tag);
+	for (const [k, v] of Object.entries(attrs)) {
+		if (k === "class") node.className = v;
+		else if (k === "text") node.textContent = v;
+		else node.setAttribute(k, v);
+	}
+	for (const c of children) node.append(c);
+	return node;
+}
+
+function when(iso: string): string {
+	return new Date(iso).toLocaleString(undefined, { month: "short", day: "numeric", year: "numeric", hour: "numeric", minute: "2-digit" });
+}
+
+export function startRevisions(): void {
+	const actions = document.getElementById("tidy-bar-actions");
+	if (!actions) return;
+	const here = location.pathname;
+	const revBtn = el("button", { type: "button", class: "tidy-btn", text: "Revisions" });
+	const liveBtn = el("button", { type: "button", class: "tidy-btn", text: "Publish live" });
+	actions.prepend(revBtn, liveBtn);
+
+	// --- the panel --------------------------------------------------------
+	const panel = el("div", { class: "tidy-panel", hidden: "" });
+	document.body.append(panel);
+	let revisions: Revision[] = [];
+
+	async function load(): Promise<Revision[]> {
+		const r = await fetch(`${ROUTE}?path=${encodeURIComponent(here)}`, { credentials: "same-origin" });
+		if (!r.ok) throw new Error(`${r.status}`);
+		const j = (await r.json()) as { revisions: Revision[] };
+		revisions = j.revisions;
+		return revisions;
+	}
+
+	function close() {
+		panel.hidden = true;
+		panel.replaceChildren();
+		viewer.hidden = true;
+		frame.removeAttribute("srcdoc");
+	}
+
+	function renderList() {
+		const head = el("div", { class: "tidy-panel-head" }, [el("h2", { text: "Revisions" }), el("p", { text: "Every time the website was published. Open one to see this page as it was then." })]);
+		const list = el("div", { class: "tidy-add-list" });
+		revisions.forEach((rev, i) => {
+			const note = i === 0 ? "Live now" : rev.restoredFrom ? "Restored" : "";
+			const item = el("button", { type: "button", class: "tidy-add-item" }, [el("strong", { text: when(rev.at) }), el("span", { text: [note, rev.pages ? `${rev.pages} pages` : ""].filter(Boolean).join(" · ") })]);
+			item.addEventListener("click", () => void view(rev, i === 0));
+			list.append(item);
+		});
+		if (revisions.length === 0) list.append(el("p", { class: "tidy-field-note", text: "Nothing published yet." }));
+		const closeBtn = el("button", { type: "button", class: "tidy-btn", text: "Close" });
+		closeBtn.addEventListener("click", close);
+		panel.replaceChildren(head, list, el("div", { class: "tidy-panel-actions" }, [closeBtn]));
+		panel.hidden = false;
+	}
+
+	// --- the viewer: this page as it was in a revision --------------------
+	const viewer = el("div", { class: "tidy-viewer", hidden: "" });
+	const viewerBar = el("div", { class: "tidy-viewer-bar" });
+	const viewerLabel = el("span", { class: "tidy-viewer-label" });
+	const backBtn = el("button", { type: "button", class: "tidy-btn", text: "Back to revisions" });
+	const restoreBtn = el("button", { type: "button", class: "tidy-btn tidy-btn-primary", text: "Restore this version" });
+	const frame = el("iframe", { class: "tidy-viewer-frame", title: "This page in an earlier revision", sandbox: "allow-same-origin" });
+	viewerBar.append(viewerLabel, backBtn, restoreBtn);
+	viewer.append(viewerBar, frame);
+	document.body.append(viewer);
+	backBtn.addEventListener("click", () => { viewer.hidden = true; frame.removeAttribute("srcdoc"); renderList(); });
+
+	async function view(rev: Revision, isLive: boolean) {
+		panel.hidden = true;
+		viewerLabel.textContent = `${when(rev.at)}${isLive ? " · live now" : ""}`;
+		restoreBtn.hidden = isLive;
+		const r = await fetch(`${ROUTE}?id=${encodeURIComponent(rev.id)}&path=${encodeURIComponent(here)}`, { credentials: "same-origin" });
+		if (!r.ok) {
+			const j = (await r.json().catch(() => ({}))) as { error?: string };
+			frame.srcdoc = `<p style="font:15px system-ui;margin:2rem">${j.error ?? "This revision could not be read."}</p>`;
+		} else {
+			// The stored copy links its built assets by absolute path (/_astro/...);
+			// those are read from the revision itself, so the page shows the way it
+			// was built. Everything else (uploads, links) resolves against this site.
+			const html = await r.text();
+			const own = (p: string) => `${ROUTE}?id=${encodeURIComponent(rev.id)}&path=${encodeURIComponent(p)}`;
+			frame.srcdoc = html
+				.replace(/(href|src)="(\/_astro\/[^"]+)"/g, (_m, attr: string, p: string) => `${attr}="${own(p)}"`)
+				.replace(/<head([^>]*)>/i, `<head$1><base href="${location.origin}/"><style>html.tidy-has-bar body{padding-top:0!important}#tidy-bar,.tidy-bar{display:none!important}</style>`);
+		}
+		viewer.hidden = false;
+		restoreBtn.onclick = async () => {
+			if (!confirm(`Restore the website to ${when(rev.at)}?\n\nThe live site goes back to how it was then, and so does staging: every change made since is lost.`)) return;
+			restoreBtn.disabled = true;
+			restoreBtn.textContent = "Restoring";
+			const p = await fetch(ROUTE, { method: "POST", credentials: "same-origin", headers: { "content-type": "application/json" }, body: JSON.stringify({ action: "restore", id: rev.id }) });
+			if (p.ok) location.href = here;
+			else {
+				restoreBtn.disabled = false;
+				restoreBtn.textContent = "Restore failed. Try again";
+			}
+		};
+	}
+
+	revBtn.addEventListener("click", async () => {
+		if (!panel.hidden) return close();
+		try {
+			await load();
+			renderList();
+		} catch {
+			panel.replaceChildren(el("p", { class: "tidy-field-note", text: "The revisions could not be read right now." }));
+			panel.hidden = false;
+		}
+	});
+
+	liveBtn.addEventListener("click", async () => {
+		if (!confirm("Publish the website?\n\nEverything on staging goes live, every change made since the last publish.")) return;
+		liveBtn.disabled = true;
+		liveBtn.textContent = "Publishing";
+		const p = await fetch(ROUTE, { method: "POST", credentials: "same-origin", headers: { "content-type": "application/json" }, body: JSON.stringify({ action: "publish" }) });
+		liveBtn.disabled = false;
+		liveBtn.textContent = p.ok ? "Published" : "Publish failed";
+		setTimeout(() => (liveBtn.textContent = "Publish live"), 4000);
+	});
+
+	// Deep links from the platform.
+	const params = new URLSearchParams(location.search);
+	const want = params.get("tidy-revision");
+	if (want || params.get("tidy-revisions")) {
+		void load().then((list) => {
+			const rev = want ? list.find((x) => x.id === want) : null;
+			if (rev) void view(rev, list[0]?.id === rev.id);
+			else renderList();
+		}).catch(() => undefined);
+	}
+}
+
+startRevisions();

package/src/index.ts

@@ -30,7 +30,8 @@ export const PLATFORM_ROUTES = [
 	{ pattern: "/_tidy/rotate-token", entrypoint: `${PACKAGE}/routes/rotate-token` },
 	{ pattern: "/_tidy/fill", entrypoint: `${PACKAGE}/routes/fill` },
 	{ pattern: "/_tidy/schema", entrypoint: `${PACKAGE}/routes/schema` },
-	{ pattern: "/_tidy/maintenance", entrypoint: `${PACKAGE}/routes/maintenance` }
+	{ pattern: "/_tidy/maintenance", entrypoint: `${PACKAGE}/routes/maintenance` },
+	{ pattern: "/_tidy/revisions", entrypoint: `${PACKAGE}/routes/revisions` }
 ] as const;
 
 /**

package/src/routes/revisions.ts

@@ -0,0 +1,78 @@
+/**
+ * /_tidy/revisions: the site's revision history for the signed-in editor,
+ * read from the control plane with the site's own secret. No bearer: the
+ * browser calls it from the editor bar, and the Astro session is the gate.
+ *
+ *   GET  ?path=/reviews            the revisions (every publish, newest first)
+ *   GET  ?id=<revision>&path=/x    the page as it was in that revision (HTML)
+ *   POST { action: "restore", id } put the live site (and staging) back on it
+ *   POST { action: "publish" }     make the live site follow staging now
+ */
+import type { APIContext, APIRoute } from "astro";
+import { workerEnv } from "../lib/env";
+import { isSafeLocalPath, json, readJson } from "../lib/http";
+import { methodNotAllowed } from "./_shared";
+
+export const prerender = false;
+
+interface ControlEnv {
+	TIDY_CONTROL_ORIGIN?: unknown;
+	TIDY_SITE_ID?: unknown;
+	TIDY_PLATFORM_SECRET?: unknown;
+	PLATFORM?: { fetch(input: string, init?: RequestInit): Promise<Response> };
+}
+
+async function control(context: APIContext): Promise<{ call(path: string, init?: RequestInit): Promise<Response> } | Response> {
+	const user = context.session ? await context.session.get("user") : null;
+	if (!user) return new Response("Unauthorized", { status: 401 });
+	const env = (await workerEnv()) as ControlEnv | undefined;
+	const origin = env?.TIDY_CONTROL_ORIGIN;
+	const siteId = env?.TIDY_SITE_ID;
+	const secret = env?.TIDY_PLATFORM_SECRET;
+	const platform = env?.PLATFORM;
+	if (!platform || typeof origin !== "string" || typeof siteId !== "string" || typeof secret !== "string") return new Response("Not found", { status: 404 });
+	const base = `${origin.replace(/\/+$/, "")}/sites/${encodeURIComponent(siteId)}`;
+	return {
+		call: (path, init = {}) => platform.fetch(`${base}${path}`, { ...init, headers: { authorization: `Bearer ${secret}`, ...(init.headers as Record<string, string> | undefined) } })
+	};
+}
+
+export const GET: APIRoute = async (context) => {
+	const c = await control(context);
+	if (c instanceof Response) return c;
+	const id = context.url.searchParams.get("id");
+	const rawPath = context.url.searchParams.get("path");
+	const path = isSafeLocalPath(rawPath) ? rawPath.replace(/[?#].*$/, "") : "/";
+	if (id) {
+		if (!/^[0-9a-f-]{36}$/i.test(id)) return json({ error: "bad revision id" }, 400);
+		const r = await c.call(`/releases/${id}/page?path=${encodeURIComponent(path)}`);
+		if (!r.ok) return json({ error: r.status === 404 ? "That page was not in this revision." : "The revision could not be read." }, r.status === 404 ? 404 : 502);
+		// A page comes back as HTML; a path with an extension is one of the
+		// revision's own files (its stylesheets, scripts, images), passed through
+		// with its type so the page shows the way it was built.
+		const type = r.headers.get("content-type") ?? "application/octet-stream";
+		return new Response(r.body, { headers: { "content-type": type, "cache-control": "no-store" } });
+	}
+	const r = await c.call("/releases");
+	if (!r.ok) return json({ error: "The revisions could not be read." }, 502);
+	const body = (await r.json().catch(() => ({}))) as { releases?: Array<{ deployId: string; at: string; pages?: number; restoredFrom?: string }> };
+	return json({ revisions: (body.releases ?? []).map((x) => ({ id: x.deployId, at: x.at, pages: x.pages ?? null, restoredFrom: x.restoredFrom ?? null })) }, 200, { "cache-control": "no-store" });
+};
+
+export const POST: APIRoute = async (context) => {
+	const c = await control(context);
+	if (c instanceof Response) return c;
+	const body = await readJson<{ action?: unknown; id?: unknown; keepContent?: unknown }>(context.request);
+	if (body.action === "publish") {
+		const r = await c.call("/publish-live", { method: "POST" });
+		return json(await r.json().catch(() => ({})), r.ok ? 200 : 502);
+	}
+	if (body.action === "restore") {
+		if (typeof body.id !== "string" || !/^[0-9a-f-]{36}$/i.test(body.id)) return json({ error: "bad revision id" }, 400);
+		const r = await c.call(`/releases/${body.id}/restore`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ keepContent: body.keepContent === true }) });
+		return json(await r.json().catch(() => ({})), r.ok ? 200 : 502);
+	}
+	return json({ error: "action must be publish or restore" }, 400);
+};
+
+export const ALL = methodNotAllowed("GET, POST");

package/src/version.ts

@@ -1,3 +1,3 @@
 /** Kept in step with package.json by the release checklist in MAINTAINING.md. */
-export const VERSION = "0.9.1";
+export const VERSION = "0.10.1";
 export const PLUGIN_ID = "tidy-platform";