@wervt/cli 0.2.16 → 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
@@ -125,9 +287,40 @@ function auditSummary(entry) {
 		case "client.link":
 		case "client.delete": return text(d.name) || text(d.clientId);
 		case "app.delete": return `database ${text(d.database)}`;
+		case "domains.add":
+		case "domains.remove":
+		case "domains.primary": return text(d.domain);
 		default: return entry.account ?? "";
 	}
 }
+/** A saved query's alert in a few words: `alert at 5 in 5m, firing (7)`. */
+function alertSummary(query) {
+	const { alert, state } = query;
+	if (!alert) return "no alert";
+	const rule = `alert at ${alert.threshold} in ${alert.window}`;
+	if (!alert.enabled) return `${rule}, off`;
+	if (state?.error) return `${rule}, failing: ${state.error.split("\n")[0]}`;
+	if (state?.firing) return `${rule}, firing (${state.lastCount ?? "?"})`;
+	return state?.lastFiredAt ? `${rule}, last fired ${state.lastFiredAt.slice(0, 16)}` : rule;
+}
+/** `GET /api/x 500  12ms  3 entries, 1 error` for a request. */
+function requestSummary(group) {
+	const what = group.method && group.path ? [
+		group.method,
+		group.path,
+		group.status
+	].filter(Boolean).join(" ") : group.message ?? "(no request event)";
+	const counts = [
+		`${group.entries} ${group.entries === 1 ? "entry" : "entries"}`,
+		group.errors && `${group.errors} ${group.errors === 1 ? "error" : "errors"}`,
+		group.warnings && `${group.warnings} ${group.warnings === 1 ? "warning" : "warnings"}`
+	].filter(Boolean);
+	return [
+		what,
+		group.duration,
+		counts.join(", ")
+	].filter(Boolean).join("  ");
+}
 // src/source.ts
 async function git(dir, ...args) {
 	try {
@@ -256,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"
@@ -277,14 +474,18 @@ const deploy = defineCommand({
 			if ((await x(pm, ["run", "build"], {
 				nodeOptions: {
 					cwd: dir,
-					stdio: "inherit"
+					stdio: "inherit",
+					env: {
+						...process.env,
+						WERVT_APP: name
+					}
 				},
 				throwOnError: false
 			})).exitCode !== 0) throw new Error("Build failed");
 		}
 		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);
@@ -596,6 +797,63 @@ const access = defineCommand({
 		}
 	}
 });
+const domains = defineCommand({
+	meta: {
+		name: "domains",
+		description: "Show or change an app's own domains (e.g. example.com); <app>.<base domain> then forwards to the primary one"
+	},
+	args: {
+		app: {
+			type: "positional",
+			required: true,
+			description: "App name"
+		},
+		add: {
+			type: "string",
+			description: "Add a domain; it serves the app once its DNS points here"
+		},
+		remove: {
+			type: "string",
+			description: "Remove a domain"
+		},
+		primary: {
+			type: "string",
+			description: "Make a verified domain the app's main address"
+		},
+		verify: {
+			type: "string",
+			description: "Check a pending domain's DNS now"
+		},
+		...connection
+	},
+	async run({ args }) {
+		const changes = [
+			"add",
+			"remove",
+			"primary",
+			"verify"
+		].filter((key) => args[key]);
+		if (changes.length > 1) throw new Error("Pass one of --add, --remove, --primary or --verify");
+		const change = changes[0];
+		const result = await (change ? await api(`/v1/apps/${args.app}/domains`, args, {
+			method: "PATCH",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({ [change]: args[change] })
+		}) : await api(`/v1/apps/${args.app}/domains`, args)).json();
+		if (!result.configured) console.log("This server doesn't support custom domains.");
+		if (!result.domains.length) return console.log(`${args.app} has no domains of its own.`);
+		for (const d of result.domains) {
+			const label = d.status === "active" ? styleText("green", d.primary ? "active, primary" : "active") : styleText("yellow", "pending");
+			console.log(`${d.domain}  ${label}${d.error ? `  ${styleText("dim", d.error)}` : ""}`);
+		}
+		const pending = result.domains.filter((d) => d.status === "pending");
+		if (!pending.length || !result.target) return;
+		console.log(`\nPoint each pending domain at ${result.target}: a CNAME (subdomains), or an A record with its addresses (a bare domain).`);
+		console.log("Behind a proxy of your own (Cloudflare), add a TXT record instead, the proxy has to send the traffic on:");
+		for (const d of pending) console.log(`  ${d.txt.name}  TXT  ${d.txt.value}`);
+		console.log("Pending domains are checked every few minutes, or now with --verify <domain>.");
+	}
+});
 const members = defineCommand({
 	meta: {
 		name: "members",
@@ -728,9 +986,36 @@ const accounts = defineCommand({
 			type: "string",
 			description: "Space all releases of their apps may take, e.g. 2GB. \"none\", \"default\""
 		},
+		into: {
+			type: "string",
+			description: "Merge the account into this one (same person, two sign-ups): its logins, apps and access move over, apps move their data, then it is deleted"
+		},
 		...connection
 	},
 	async run({ args }) {
+		if (args.email && args.into) {
+			const result = await (await api("/v1/accounts/merge", args, {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify({
+					from: args.email,
+					into: args.into
+				})
+			})).json();
+			console.log(`${result.from.email} merged into ${result.into.email}`);
+			console.log(`  logins moved: ${result.logins.join(", ") || "none"}`);
+			if (result.owners.length) console.log(`  owner or member of: ${result.owners.join(", ")}`);
+			if (result.access.length) console.log(`  allowed in: ${result.access.join(", ")}`);
+			const payload = JSON.stringify({
+				from: result.from,
+				into: result.into
+			});
+			for (const [app, run] of Object.entries(result.apps)) {
+				console.log(`  ${app}: ${run.status}${run.error ? ` (${run.error})` : ""}`);
+				if (run.status !== "ok") console.log(styleText("dim", `    retry: wervt tasks ${app} --run wervt:account-merged --payload '${payload}'`));
+			}
+			return;
+		}
 		if (args.email) {
 			const change = {};
 			if (args.apps) change.apps = args.apps === "none" ? null : args.apps === "default" ? "default" : Number(args.apps);
@@ -1172,6 +1457,14 @@ const logs = defineCommand({
 			alias: "f",
 			description: "Keep printing new entries"
 		},
+		requests: {
+			type: "boolean",
+			description: "One line per request (requestId): what it was and how much it logged"
+		},
+		saved: {
+			type: "string",
+			description: "Use a saved query by name (see `wervt queries`)"
+		},
 		json: {
 			type: "boolean",
 			description: "One JSON object per line, with every field"
@@ -1180,7 +1473,31 @@ const logs = defineCommand({
 	},
 	async run({ args }) {
 		const params = new URLSearchParams();
-		if (args.query) params.set("query", args.query);
+		if (args.saved) {
+			if (args.query) throw new Error("Give either a query or --saved, not both");
+			const saved = await findSavedQuery(args.app, args.saved, args);
+			params.set("query", saved.query);
+			if (saved.levels?.length) params.set("levels", saved.levels.join(","));
+		} else if (args.query) params.set("query", args.query);
+		if (args.requests) {
+			if (args.follow) throw new Error("--requests and --follow do not go together");
+			params.set("start", args.since);
+			if (args.until) params.set("end", args.until);
+			params.set("limit", args.limit);
+			const groups = await (await api(`/v1/apps/${args.app}/logs/requests?${params.toString()}`, args)).json();
+			if (!groups.length && !args.json) return console.error(`No requests with a requestId in the last ${args.since}.`);
+			for (const group of groups.reverse()) {
+				if (args.json) {
+					console.log(JSON.stringify(group));
+					continue;
+				}
+				const time = new Date(group.last).toISOString().slice(11, 23);
+				const color = group.errors ? "red" : group.warnings ? "yellow" : "white";
+				console.log(`${styleText("dim", time)} ${styleText(color, requestSummary(group))}  ${styleText("dim", group.requestId)}`);
+			}
+			if (!args.json) console.error(styleText("dim", `\nOne request: wervt logs ${args.app} 'requestId:=<id>' --since ${args.since}`));
+			return;
+		}
 		if (args.follow) {
 			params.set("since", args.since);
 			const res = await api(`/v1/apps/${args.app}/logs/tail?${params.toString()}`, args);
@@ -1200,6 +1517,111 @@ const logs = defineCommand({
 		for (const entry of entries.reverse()) printLog(entry, Boolean(args.json));
 	}
 });
+/** `/v1/apps/<app>/logs/queries`, or across apps (admins) without an app. */
+const queriesPath = (app) => app ? `/v1/apps/${app}/logs/queries` : "/v1/logs/queries";
+async function findSavedQuery(app, name, flags) {
+	const list = await (await api(queriesPath(app), flags)).json();
+	const found = list.find((query) => query.id === name || query.name.toLowerCase() === name.toLowerCase());
+	if (!found) throw new Error(`No saved query "${name}"${list.length ? `. Saved: ${list.map((q) => q.name).join(", ")}` : ""}`);
+	return found;
+}
+const queries = defineCommand({
+	meta: {
+		name: "queries",
+		description: "List, save or delete saved log queries and the alerts on them"
+	},
+	args: {
+		app: {
+			type: "positional",
+			required: false,
+			description: "App name (default: queries across all apps, admins only)"
+		},
+		save: {
+			type: "string",
+			description: "Save a query under this name, or change the one that has it"
+		},
+		query: {
+			type: "string",
+			description: "LogsQL for --save, e.g. 'level:error'"
+		},
+		levels: {
+			type: "string",
+			description: "Only these levels for --save, e.g. error,warn"
+		},
+		alert: {
+			type: "string",
+			description: "on or off: mail the app owner and members when the query matches"
+		},
+		threshold: {
+			type: "string",
+			description: "Alert when at least this many entries match"
+		},
+		window: {
+			type: "string",
+			description: "Alert window, e.g. 5m (1m to 24h)"
+		},
+		cooldown: {
+			type: "string",
+			description: "Quiet time after an alert, e.g. 1h (5m to 7d)"
+		},
+		delete: {
+			type: "string",
+			description: "Delete the saved query with this name"
+		},
+		json: {
+			type: "boolean",
+			description: "Print JSON"
+		},
+		...connection
+	},
+	async run({ args }) {
+		const path = queriesPath(args.app);
+		const json = { "content-type": "application/json" };
+		if (args.delete) {
+			const found = await findSavedQuery(args.app, args.delete, args);
+			await api(`${path}/${found.id}`, args, { method: "DELETE" });
+			return console.log(`Deleted ${found.name}`);
+		}
+		if (args.save) {
+			if (args.alert !== void 0 && !["on", "off"].includes(args.alert)) throw new Error("--alert is on or off");
+			const alertFields = {
+				...args.threshold ? { threshold: Number(args.threshold) } : {},
+				...args.window ? { window: args.window } : {},
+				...args.cooldown ? { cooldown: args.cooldown } : {}
+			};
+			const alert = args.alert === "off" ? null : args.alert === "on" || Object.keys(alertFields).length ? {
+				enabled: true,
+				...alertFields
+			} : void 0;
+			const body = {
+				name: args.save,
+				...args.query !== void 0 ? { query: args.query } : {},
+				...args.levels !== void 0 ? { levels: args.levels } : {},
+				...alert !== void 0 ? { alert } : {}
+			};
+			const existing = (await (await api(path, args)).json()).find((q) => q.name.toLowerCase() === args.save.toLowerCase());
+			const saved = await (await api(existing ? `${path}/${existing.id}` : path, args, {
+				method: existing ? "PATCH" : "POST",
+				headers: json,
+				body: JSON.stringify(body)
+			})).json();
+			if (args.json) return console.log(JSON.stringify(saved));
+			return console.log(`${existing ? "Changed" : "Saved"} ${saved.name}: ${saved.query}  ${styleText("dim", alertSummary(saved))}`);
+		}
+		const list = await (await api(path, args)).json();
+		if (args.json) return console.log(JSON.stringify(list));
+		if (!list.length) {
+			const target = args.app ? ` ${args.app}` : "";
+			return console.log(`No saved queries. Save one: wervt queries${target} --save Errors --query 'level:error' --alert on`);
+		}
+		for (const query of list) {
+			const levels = query.levels?.length ? styleText("dim", ` [${query.levels.join(",")}]`) : "";
+			const color = query.state?.error ? "red" : query.alert?.enabled && query.state?.firing ? "yellow" : "dim";
+			console.log(`${styleText("bold", query.name)}  ${query.query}${levels}  ${styleText(color, alertSummary(query))}`);
+		}
+		if (args.app) console.log(styleText("dim", `\nRun one: wervt logs ${args.app} --saved '${list[0].name}'`));
+	}
+});
 const SPARKS = "▁▂▃▄▅▆▇█";
 const stats = defineCommand({
 	meta: {
@@ -1413,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",
@@ -1420,14 +1883,17 @@ runMain(defineCommand({
 	},
 	subCommands: {
 		deploy,
+		build,
 		apps,
 		releases,
 		audit,
 		logs,
+		queries,
 		activate,
 		rollback,
 		reprovision,
 		access,
+		domains,
 		members,
 		accounts,
 		env,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wervt/cli",
-  "version": "0.2.16",
+  "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"
   }

package/skill/SKILL.md

@@ -42,6 +42,8 @@ existing app, work in its repository instead.
 
 ## 3. Build
 
+<!-- build.wervt.app: from here to the end marker, also the MCP server's instructions -->
+
 - Keep the app small and complete: data in Postgres through `useDb()`, writes through API routes,
   lists through `useShape` so every open tab stays live. Ask only when the request is genuinely
   ambiguous; otherwise choose sensible defaults and say what you chose.
@@ -54,10 +56,13 @@ existing app, work in its repository instead.
   MCP clients at `https://<app>.wervt.app/mcp`, signed in through wervt. Details in the app's
   `AGENTS.md`.
 - After changing `server/db/schema.ts`: `pnpm db:generate`, and commit the migration.
+- Finish with `pnpm exec vp check --fix` passing.
+
+<!-- end -->
+
 - `pnpm dev` runs against a local wervt stack, which the user may not have. When it isn't running,
   don't set one up: `pnpm build` plus `pnpm exec vp check --fix` are the checks, and the
   deployed app is the test.
-- Finish with `pnpm exec vp check --fix` passing.
 
 ## 4. Ship
 
@@ -69,8 +74,12 @@ pnpm exec wervt access <name> --invite            # private, and people with acc
 pnpm exec wervt access <name> --invite-by owners  # only owner, members and admins may invite
 pnpm exec wervt members <name> --add a@x.com      # who may deploy and manage it (the first deploy owns it)
 pnpm exec wervt env <name> --set NUXT_API_KEY=…   # runtimeConfig.apiKey, applied from the next request
+pnpm exec wervt domains <name> --add example.com  # its own domain; prints the DNS records to set
+pnpm exec wervt deploy --name <other>             # the same code as another app (own data, env, domains)
 ```
 
+<!-- build.wervt.app -->
+
 - Ask before making an app public if it shows personal or private data. "Ship it" alone doesn't
   decide that. Private, with the user's email allowed, is the safe default.
 - App configuration and secrets go through Nuxt's `runtimeConfig`, never `process.env` in app
@@ -78,6 +87,9 @@ pnpm exec wervt env <name> --set NUXT_API_KEY=…   # runtimeConfig.apiKey, appl
   it with `useRuntimeConfig()` and set it as `NUXT_` + the key in SCREAMING_SNAKE_CASE
   (`apiKey` → `NUXT_API_KEY`, `public.mapStyle` → `NUXT_PUBLIC_MAP_STYLE`). Keys missing from
   `runtimeConfig` are ignored.
+
+<!-- end -->
+
 - Secrets for `wervt env` (API keys) come from the user. Ask them to run the command themselves
   (`! pnpm exec wervt env <name> --set NUXT_API_KEY=…`) instead of pasting the value to you.
 - `wervt deploy` requests `/` once the release started and fails (exit 1, with the first logged
@@ -122,6 +134,8 @@ pnpm exec wervt apps                           # every app, active release, URL
 pnpm exec wervt releases <name>                # newest first, with commit, author, failed deploys
 pnpm exec wervt audit <name>                   # who deployed, rolled back, changed env or access
 pnpm exec wervt logs <name> 'status:>=500' --since 1d --json
+pnpm exec wervt logs <name> --requests --since 1h  # one line per request
+pnpm exec wervt queries <name>                 # saved queries and their alerts
 pnpm exec wervt tasks <name>                   # tasks, schedules, next runs
 pnpm exec wervt tasks <name> --run <task>      # run one now
 pnpm exec wervt rollback <name>                # the previous release (migrations stay)