@wervt/cli 0.2.17 → 0.2.19

package/README.md

@@ -15,6 +15,10 @@ vp exec wervt access my-app --public      # or --add friend@example.com
 vp exec wervt logs my-app
 ```
 
+Nitro apps without Nuxt use `@wervt/nitro`. A static site sets `"build": "… && wervt build --static dist"`
+in package.json (any `export default { fetch }` module works too, without `--static`); see
+[Platform contract](https://wervt.app/api/platform-contract#wervt-build).
+
 Without [Vite+](https://viteplus.dev), use `npx @wervt/cli` and `pnpm exec wervt`. `wervt --help`
 lists every command: `apps`, `releases`, `audit`, `rollback`, `activate`, `env`, `tokens`, `token`, `members`,
 `tasks`, `stats`, `delete`, `whoami`, … Docs: [wervt.app](https://wervt.app/getting-started/quickstart).

package/dist/index.mjs

@@ -1,13 +1,160 @@
+import { builtinModules } from "node:module";
 import { existsSync } from "node:fs";
-import { appendFile, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { appendFile, cp, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { homedir, hostname } from "node:os";
-import { dirname, join, relative, resolve } from "node:path";
+import { dirname, join, relative, resolve, sep } from "node:path";
 import { styleText } from "node:util";
 import * as p from "@clack/prompts";
 import { defineCommand, runMain } from "citty";
 import { detectPackageManager } from "nypm";
 import { x } from "tinyexec";
 import { packTar } from "modern-tar";
+// ../core/src/manifest.ts
+/** The bundle's `wervt-bundle.json`, next to `server/` and `public/`. */
+const BUNDLE_MANIFEST = "wervt-bundle.json";
+// src/static-server.ts
+/** The source of `server/index.mjs`. */
+function staticServer({ pages, fallback }) {
+	return `const pages = ${JSON.stringify(pages)}
+const fallback = ${JSON.stringify(fallback ?? null)}
+const html = (body, status = 200) =>
+  new Response(body, { status, headers: { 'content-type': 'text/html; charset=utf-8' } })
+
+export default {
+  fetch(request) {
+    let path
+    try {
+      path = decodeURIComponent(new URL(request.url).pathname).replace(/^\\/+|\\/+$/g, '')
+    } catch {
+      return html(pages['404.html'] ?? 'Not found', 404)
+    }
+    for (const page of path ? [path + '/index.html', path + '.html'] : ['index.html'])
+      if (Object.hasOwn(pages, page)) return html(pages[page])
+    const wantsHtml = (request.headers.get('accept') ?? '').includes('text/html')
+    if (wantsHtml && fallback && Object.hasOwn(pages, fallback)) return html(pages[fallback])
+    return html(pages['404.html'] ?? 'Not found', 404)
+  },
+}
+`;
+}
+// src/build.ts
+const ENTRIES = [
+	"server.ts",
+	"src/server.ts",
+	"src/index.ts",
+	"server.js",
+	"src/index.js"
+];
+const exists$1 = (path) => stat(path).then(() => true, () => false);
+async function walk$1(dir) {
+	const entries = await readdir(dir, { withFileTypes: true });
+	return (await Promise.all(entries.map(async (e) => e.isDirectory() ? walk$1(join(dir, e.name)) : [join(dir, e.name)]))).flat();
+}
+/** The app's `wervt` settings from its package.json. */
+async function readBuildConfig(appDir) {
+	return JSON.parse(await readFile(join(appDir, "package.json"), "utf8").catch(() => "{}")).wervt ?? {};
+}
+async function build$1(appDir, options = {}) {
+	const config = {
+		...await readBuildConfig(appDir),
+		...definedOnly(options)
+	};
+	const out = join(appDir, options.out ?? ".output");
+	await rm(out, {
+		recursive: true,
+		force: true
+	});
+	await mkdir(join(out, "server"), { recursive: true });
+	let kind;
+	if (config.static) {
+		kind = "static";
+		await buildStatic(join(appDir, config.static), out, config.fallback);
+	} else {
+		kind = "server";
+		const entry = config.entry ?? await findEntry(appDir);
+		if (!entry) throw new Error(`No server entry. Add one of ${ENTRIES.join(", ")}, or set "wervt": { "entry" } in package.json (or "static" for a static site).`);
+		await bundleServer(join(appDir, entry), join(out, "server/index.mjs"));
+		const publicDir = join(appDir, config.public ?? "public");
+		if (await exists$1(publicDir)) await cp(publicDir, join(out, "public"), { recursive: true });
+	}
+	const manifest = bundleManifest(config, kind);
+	await writeFile(join(out, BUNDLE_MANIFEST), `${JSON.stringify(manifest, null, 2)}\n`);
+	return {
+		kind,
+		out,
+		manifest
+	};
+}
+async function findEntry(appDir) {
+	for (const entry of ENTRIES) if (await exists$1(join(appDir, entry))) return entry;
+}
+function bundleManifest(config, kind) {
+	const manifest = {
+		version: 2,
+		framework: config.framework ?? (kind === "static" ? "static" : "fetch")
+	};
+	if (config.database !== void 0) manifest.database = config.database;
+	if (config.immutable || config.noCache) manifest.public = {
+		immutable: config.immutable,
+		noCache: config.noCache
+	};
+	if (config.tasks || config.schedules) manifest.tasks = {
+		tasks: config.tasks ?? [],
+		schedules: config.schedules ?? [],
+		...config.timezone ? { timezone: config.timezone } : {}
+	};
+	if (config.shapes) manifest.shapes = config.shapes;
+	if (config.preview) manifest.preview = config.preview;
+	if (config.brand) manifest.brand = config.brand;
+	return manifest;
+}
+async function buildStatic(siteDir, out, fallback = "index.html") {
+	if (!await exists$1(siteDir)) throw new Error(`No ${siteDir} to deploy. Build the site first.`);
+	await cp(siteDir, join(out, "public"), { recursive: true });
+	const pages = {};
+	for (const file of await walk$1(siteDir)) if (file.endsWith(".html")) pages[relative(siteDir, file).split(sep).join("/")] = await readFile(file, "utf8");
+	await writeFile(join(out, "server/index.mjs"), staticServer({
+		pages,
+		fallback: fallback || void 0
+	}));
+}
+const builtins = new Set(builtinModules);
+/**
+* One ES module for Supabase Edge Runtime (Deno): every dependency inlined, Node built-ins
+* imported with `node:` (Deno rejects bare `crypto`), and the Node globals Deno lacks injected.
+*/
+async function bundleServer(entry, file) {
+	const { build: rolldown } = await import("rolldown");
+	await rolldown({
+		input: entry,
+		platform: "node",
+		logLevel: "warn",
+		plugins: [{
+			name: "wervt:node-prefix",
+			resolveId(id) {
+				const bare = id.startsWith("node:") ? id.slice(5) : id;
+				if (builtins.has(bare) || builtins.has(bare.split("/")[0])) return {
+					id: `node:${bare}`,
+					external: true
+				};
+				return null;
+			}
+		}],
+		transform: { inject: {
+			Buffer: ["node:buffer", "Buffer"],
+			setImmediate: ["node:timers", "setImmediate"],
+			clearImmediate: ["node:timers", "clearImmediate"]
+		} },
+		output: {
+			file,
+			format: "esm",
+			codeSplitting: false
+		}
+	});
+}
+function definedOnly(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== void 0));
+}
 // src/bundle.ts
 /** Files under `dir`. Follows symlinks: Nitro can leave traced dependencies in
 * server/node_modules as links into the local pnpm store, which won't exist on the server. */
@@ -23,14 +170,18 @@ async function gzip(data) {
 	return new Uint8Array(await new Response(stream).arrayBuffer());
 }
 const exists = (path) => stat(path).then(() => true, () => false);
-/** Packs `.output/server`, `.output/public` and `drizzle/` into the bundle the control plane expects. */
-async function createBundle(appDir) {
+/**
+* Packs the build output's `server/`, `public/` and `wervt-bundle.json` (in `out`, `.output` by
+* default) and the app's `drizzle/` into the bundle the control plane expects.
+*/
+async function createBundle(appDir, out = ".output") {
+	const outDir = join(appDir, out);
 	const roots = [
-		[join(appDir, ".output/server"), "server"],
-		[join(appDir, ".output/public"), "public"],
+		[join(outDir, "server"), "server"],
+		[join(outDir, "public"), "public"],
 		[join(appDir, "drizzle"), "drizzle"]
 	];
-	if (!await exists(roots[0][0])) throw new Error("No .output/server. Build the app first.");
+	if (!await exists(roots[0][0])) throw new Error(`No ${join(out, "server")}. Build the app first.`);
 	const files = [];
 	for (const [dir, prefix] of roots) {
 		if (!await exists(dir)) continue;
@@ -46,6 +197,17 @@ async function createBundle(appDir) {
 			});
 		}
 	}
+	const manifest = join(outDir, BUNDLE_MANIFEST);
+	if (await exists(manifest)) {
+		const data = await readFile(manifest);
+		files.push({
+			header: {
+				name: BUNDLE_MANIFEST,
+				size: data.byteLength
+			},
+			body: data
+		});
+	}
 	return {
 		data: await gzip(await packTar(files)),
 		files: files.length
@@ -258,6 +420,13 @@ function resolveAppDir(arg = ".") {
 	if (existsSync(join("apps", arg, "package.json"))) return resolve("apps", arg);
 	throw new Error(`No app found at ${arg}`);
 }
+const PREVIEW_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+/** `todos--pr-12` for `--preview pr-12`: the preview's own app name (control's previews.ts). */
+function previewName(app, preview) {
+	if (preview === void 0) return app;
+	if (!PREVIEW_RE.test(preview)) throw new Error(`--preview must be lowercase letters, digits and dashes, like pr-12`);
+	return `${app}--${preview}`;
+}
 async function appName(dir, name) {
 	if (!name) {
 		const pkg = JSON.parse(await readFile(join(dir, "package.json"), "utf8"));
@@ -282,11 +451,19 @@ const deploy = defineCommand({
 			type: "string",
 			description: "App name (default: package.json name)"
 		},
+		preview: {
+			type: "string",
+			description: "Deploy a preview of the app instead, at <app>--<preview> (like pr-12): own empty database, the app's access and env plus its preview env"
+		},
 		build: {
 			type: "boolean",
 			default: true,
 			description: "Build before deploying"
 		},
+		out: {
+			type: "string",
+			description: "Build output to pack (default: .output)"
+		},
 		check: {
 			type: "string",
 			description: "Pages to request once the release started, a 5xx fails (default: /). Shape routes are checked too; --check= turns all checks off"
@@ -300,7 +477,7 @@ const deploy = defineCommand({
 	},
 	async run({ args }) {
 		const dir = resolveAppDir(args.dir);
-		const name = await appName(dir, args.name);
+		const name = previewName(await appName(dir, args.name), args.preview);
 		p.intro(`wervt deploy ${name}`);
 		if (args.build) {
 			const pm = (await detectPackageManager(dir))?.name ?? "npm";
@@ -319,7 +496,7 @@ const deploy = defineCommand({
 		}
 		const spinner = progress();
 		spinner.start("Packing");
-		const bundle = await createBundle(dir);
+		const bundle = await createBundle(dir, args.out);
 		spinner.stop(`Packed ${bundle.files} files (${(bundle.data.byteLength / 1024).toFixed(0)} kB)`);
 		spinner.start("Uploading");
 		const source = await deploySource(dir);
@@ -746,6 +923,10 @@ const env = defineCommand({
 			type: "string",
 			description: "KEY (comma separated)"
 		},
+		preview: {
+			type: "boolean",
+			description: "The app's preview env instead: set on top of its env in every preview, from their next deploy"
+		},
 		...connection
 	},
 	async run({ args, rawArgs }) {
@@ -756,17 +937,18 @@ const env = defineCommand({
 			return [pair.slice(0, i), pair.slice(i + 1)];
 		}));
 		const unset = toList(args.unset);
-		const { keys, warnings = [] } = await (Object.keys(set).length || unset.length ? await api(`/v1/apps/${args.app}/env`, args, {
+		const path = `/v1/apps/${args.app}/${args.preview ? "preview-env" : "env"}`;
+		const { keys, warnings = [] } = await (Object.keys(set).length || unset.length ? await api(path, args, {
 			method: "PATCH",
 			headers: { "content-type": "application/json" },
 			body: JSON.stringify({
 				set,
 				unset
 			})
-		}) : await api(`/v1/apps/${args.app}/env`, args)).json();
+		}) : await api(path, args)).json();
 		console.log(keys.length ? keys.join("\n") : "No variables set.");
 		for (const warning of warnings) console.error(styleText("yellow", `Warning: ${warning}`));
-		if (Object.keys(set).length || unset.length) console.log("Applies from the next request.");
+		if (Object.keys(set).length || unset.length) console.log(args.preview ? "Previews get it with their next deploy." : "Applies from the next request.");
 	}
 });
 const SIZE_FLAGS = [
@@ -908,7 +1090,7 @@ const tokens = defineCommand({
 			})).json();
 			console.error(`Deploy token "${token.name}" for ${args.app} (shown once):`);
 			console.log(token.token);
-			console.error(styleText("dim", "It can deploy this app and nothing else. Store it as the WERVT_TOKEN secret."));
+			console.error(styleText("dim", "It can deploy this app and its previews, nothing else. Store it as the WERVT_TOKEN secret."));
 			return;
 		}
 		if (args.revoke) {
@@ -1211,13 +1393,17 @@ const tasks = defineCommand({
 const remove = defineCommand({
 	meta: {
 		name: "delete",
-		description: "Delete an app (releases, access, env)"
+		description: "Delete an app (releases, access, env) or one of its previews"
 	},
 	args: {
 		app: {
 			type: "positional",
-			required: true,
-			description: "App name"
+			required: false,
+			description: "App name (default: package.json name in the current directory)"
+		},
+		preview: {
+			type: "string",
+			description: "Delete the preview <app>--<preview> (like pr-12) and its data instead"
 		},
 		"drop-database": {
 			type: "boolean",
@@ -1230,16 +1416,18 @@ const remove = defineCommand({
 		...connection
 	},
 	async run({ args }) {
-		const dropDb = Boolean(args["drop-database"]);
+		const app = previewName(args.app ?? await appName(resolveAppDir()), args.preview);
+		const dropDb = Boolean(args["drop-database"]) || app.includes("--");
 		if (!args.yes) {
 			const ok = await p.confirm({
-				message: `Delete ${args.app}${dropDb ? " and ALL its data" : " (data is kept, the name stays yours)"}?`,
+				message: `Delete ${app}${dropDb ? " and ALL its data" : " (data is kept, the name stays yours)"}${app.includes("--") ? "" : ", and all its previews"}?`,
 				initialValue: false
 			});
 			if (p.isCancel(ok) || !ok) return p.cancel("Cancelled");
 		}
-		await api(`/v1/apps/${args.app}?dropDatabase=${dropDb}`, args, { method: "DELETE" });
-		console.log(`Deleted ${args.app}${dropDb ? " and its database" : ""}`);
+		const { previews = [] } = await (await api(`/v1/apps/${app}?dropDatabase=${dropDb}`, args, { method: "DELETE" })).json();
+		console.log(`Deleted ${app}${dropDb ? " and its database" : ""}`);
+		if (previews.length) console.log(`Also deleted its previews: ${previews.join(", ")}`);
 	}
 });
 const LEVEL_COLORS = {
@@ -1669,6 +1857,47 @@ const login = defineCommand({
 		outro(`Signed in to ${url} (saved to ${file})`);
 	}
 });
+const build = defineCommand({
+	meta: {
+		name: "build",
+		description: "Build a fetch handler (Hono, plain `export default { fetch }`) or a static site into a bundle"
+	},
+	args: {
+		dir: {
+			type: "positional",
+			required: false,
+			description: "App directory (default: .)"
+		},
+		entry: {
+			type: "string",
+			description: "Server module (default: server.ts, src/server.ts, src/index.ts)"
+		},
+		static: {
+			type: "string",
+			description: "Folder of a static site to deploy instead of a server, e.g. dist"
+		},
+		fallback: {
+			type: "string",
+			description: "Static site: page for unknown paths (default: index.html, for SPAs); --fallback= for none"
+		},
+		out: {
+			type: "string",
+			description: "Output directory (default: .output)"
+		}
+	},
+	async run({ args }) {
+		const dir = resolveAppDir(args.dir);
+		const started = performance.now();
+		const result = await build$1(dir, {
+			entry: args.entry,
+			static: args.static,
+			fallback: args.fallback === "" ? false : args.fallback,
+			out: args.out
+		});
+		const ms = Math.round(performance.now() - started);
+		console.log(`Built ${result.kind === "static" ? "a static site" : "the server"} into ${result.out} in ${ms} ms (${result.manifest.framework})`);
+	}
+});
 runMain(defineCommand({
 	meta: {
 		name: "wervt",
@@ -1676,6 +1905,7 @@ runMain(defineCommand({
 	},
 	subCommands: {
 		deploy,
+		build,
 		apps,
 		releases,
 		audit,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wervt/cli",
-  "version": "0.2.17",
+  "version": "0.2.19",
   "description": "Deploy and manage apps on wervt.",
   "keywords": [
     "agents",
@@ -32,8 +32,12 @@
     "citty": "^0.2.2",
     "modern-tar": "^0.8.6",
     "nypm": "^0.6.12",
+    "rolldown": "^1.2.16",
     "tinyexec": "^1.3.1"
   },
+  "devDependencies": {
+    "@wervt/core": "0.0.2"
+  },
   "scripts": {
     "build": "vp pack"
   }

package/skill/SKILL.md

@@ -123,7 +123,9 @@ git push -u origin main
 ```
 
 The pipe hands the deploy token straight to GitHub; it never appears in the output. A deploy token
-can only deploy that one app. Set the secret and variable **before** the first push, or the first
+can only deploy that one app and its previews: `.github/workflows/preview.yml` deploys every pull
+request to `<name>--pr-<number>` (own empty database, the app's access and env plus its preview
+env, `wervt env <name> --preview --set …`) and deletes it when the pull request closes. Set the secret and variable **before** the first push, or the first
 workflow run fails. Then `gh run watch` and check `pnpm exec wervt releases <name>`: the new
 release lists the commit.