@wervt/cli 0.2.17 → 0.2.18

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
@@ -287,6 +449,10 @@ const deploy = defineCommand({
 			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"
@@ -319,7 +485,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);
@@ -1669,6 +1835,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 +1883,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.18",
   "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"
   }