@wervt/cli 0.0.0 → 0.2.0

package/bin/wervt.js

@@ -1,2 +1,6 @@
 #!/usr/bin/env node
-console.log('wervt is not released yet. Follow along at https://www.npmjs.com/org/wervt')
+// Published builds run dist/; inside the wervt repo the TypeScript source runs directly.
+import { existsSync } from 'node:fs'
+
+const dist = new URL('../dist/index.mjs', import.meta.url)
+await import(existsSync(dist) ? dist.href : new URL('../src/index.ts', import.meta.url).href)

package/dist/index.mjs

@@ -0,0 +1,542 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { dirname, join, relative, resolve } 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";
+import { homedir } from "node:os";
+//#region 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. */
+async function walk(dir) {
+	const entries = await readdir(dir, { withFileTypes: true });
+	return (await Promise.all(entries.map(async (e) => {
+		const path = join(dir, e.name);
+		return (e.isSymbolicLink() ? (await stat(path)).isDirectory() : e.isDirectory()) ? walk(path) : [path];
+	}))).flat();
+}
+async function gzip(data) {
+	const stream = new Blob([data]).stream().pipeThrough(new CompressionStream("gzip"));
+	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) {
+	const roots = [
+		[join(appDir, ".output/server"), "server"],
+		[join(appDir, ".output/public"), "public"],
+		[join(appDir, "drizzle"), "drizzle"]
+	];
+	if (!await exists(roots[0][0])) throw new Error("No .output/server. Build the app first.");
+	const files = [];
+	for (const [dir, prefix] of roots) {
+		if (!await exists(dir)) continue;
+		for (const path of await walk(dir)) {
+			if (path.endsWith(".map")) continue;
+			const data = await readFile(path);
+			files.push({
+				header: {
+					name: `${prefix}/${relative(dir, path)}`,
+					size: data.byteLength
+				},
+				body: data
+			});
+		}
+	}
+	return {
+		data: await gzip(await packTar(files)),
+		files: files.length
+	};
+}
+//#endregion
+//#region src/config.ts
+const file = join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "wervt", "config.json");
+/** Flags > WERVT_URL / WERVT_TOKEN > ~/.config/wervt/config.json. */
+async function resolveConfig(flags) {
+	const saved = JSON.parse(await readFile(file, "utf8").catch(() => "{}"));
+	const url = flags.url ?? process.env.WERVT_URL ?? saved.url;
+	const token = flags.token ?? process.env.WERVT_TOKEN ?? saved.token;
+	if (!url || !token) throw new Error("Not logged in. Run `wervt login --url <control url> --token <token>`.");
+	return {
+		url: url.replace(/\/$/, ""),
+		token
+	};
+}
+async function saveConfig(config) {
+	await mkdir(dirname(file), { recursive: true });
+	await writeFile(file, `${JSON.stringify(config, null, 2)}\n`, { mode: 384 });
+	return file;
+}
+//#endregion
+//#region src/index.ts
+const connection = {
+	url: {
+		type: "string",
+		description: "Control plane URL (or WERVT_URL)"
+	},
+	token: {
+		type: "string",
+		description: "Deploy or read token (or WERVT_TOKEN)"
+	}
+};
+async function api(path, flags, init = {}) {
+	const { url, token } = await resolveConfig(flags);
+	const headers = new Headers(init.headers);
+	headers.set("authorization", `Bearer ${token}`);
+	const res = await fetch(`${url}${path}`, {
+		...init,
+		headers
+	});
+	if (!res.ok) {
+		const body = await res.text();
+		let message = body;
+		try {
+			message = JSON.parse(body).error ?? body;
+		} catch {}
+		console.error(styleText("red", `Error (${res.status}): ${message}`));
+		process.exit(1);
+	}
+	return res;
+}
+/** App directory from the argument: a path, or an app name inside the wervt repo's apps/. */
+function resolveAppDir(arg = ".") {
+	if (existsSync(join(arg, "package.json"))) return resolve(arg);
+	if (existsSync(join("apps", arg, "package.json"))) return resolve("apps", arg);
+	throw new Error(`No app found at ${arg}`);
+}
+async function appName(dir, name) {
+	if (!name) {
+		const pkg = JSON.parse(await readFile(join(dir, "package.json"), "utf8"));
+		name = String(pkg.name ?? "").replace(/^@[^/]+\//, "");
+	}
+	const normalized = name.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
+	if (!normalized) throw new Error("Could not determine the app name, pass --name");
+	return normalized;
+}
+const deploy = defineCommand({
+	meta: {
+		name: "deploy",
+		description: "Build an app and deploy it"
+	},
+	args: {
+		dir: {
+			type: "positional",
+			required: false,
+			description: "App directory (default: .)"
+		},
+		name: {
+			type: "string",
+			description: "App name (default: package.json name)"
+		},
+		build: {
+			type: "boolean",
+			default: true,
+			description: "Build before deploying"
+		},
+		...connection
+	},
+	async run({ args }) {
+		const dir = resolveAppDir(args.dir);
+		const name = await appName(dir, args.name);
+		p.intro(`wervt deploy ${name}`);
+		if (args.build) {
+			const pm = (await detectPackageManager(dir))?.name ?? "npm";
+			p.log.step(`${pm} run build`);
+			if ((await x(pm, ["run", "build"], {
+				nodeOptions: {
+					cwd: dir,
+					stdio: "inherit"
+				},
+				throwOnError: false
+			})).exitCode !== 0) throw new Error("Build failed");
+		}
+		const spinner = p.spinner();
+		spinner.start("Packing");
+		const bundle = await createBundle(dir);
+		spinner.stop(`Packed ${bundle.files} files (${(bundle.data.byteLength / 1024).toFixed(0)} kB)`);
+		spinner.start("Uploading");
+		const res = await api(`/v1/apps/${name}/deploys`, args, {
+			method: "POST",
+			headers: { "content-type": "application/gzip" },
+			body: new Uint8Array(bundle.data)
+		});
+		const labels = {
+			extract: "Extracting",
+			migrate: "Migrating database",
+			activate: "Activating"
+		};
+		const decoder = new TextDecoder();
+		let buffer = "";
+		for await (const chunk of res.body) {
+			buffer += decoder.decode(chunk, { stream: true });
+			let newline;
+			while ((newline = buffer.indexOf("\n")) >= 0) {
+				const event = JSON.parse(buffer.slice(0, newline));
+				buffer = buffer.slice(newline + 1);
+				if (event.error) {
+					spinner.error(event.error);
+					process.exitCode = 1;
+					return;
+				}
+				if (event.done) {
+					spinner.stop(`Release ${event.release}`);
+					p.outro(`Deployed → ${event.url}`);
+					return;
+				}
+				spinner.message(labels[event.step] ?? event.step);
+			}
+		}
+	}
+});
+const apps = defineCommand({
+	meta: {
+		name: "apps",
+		description: "List deployed apps"
+	},
+	args: connection,
+	async run({ args }) {
+		const list = await (await api("/v1/apps", args)).json();
+		if (!list.length) return console.log("No apps deployed.");
+		for (const app of list) console.log(`${app.app.padEnd(20)} ${(app.release ?? "-").padEnd(22)} ${app.database ? "db " : "   "} ${app.url}`);
+	}
+});
+const rollback = defineCommand({
+	meta: {
+		name: "rollback",
+		description: "Activate the previous release (migrations stay applied)"
+	},
+	args: {
+		app: {
+			type: "positional",
+			required: true,
+			description: "App name"
+		},
+		...connection
+	},
+	async run({ args }) {
+		const result = await (await api(`/v1/apps/${args.app}/rollback`, args, { method: "POST" })).json();
+		console.log(`${args.app} is now on release ${result.release}`);
+	}
+});
+const releases = defineCommand({
+	meta: {
+		name: "releases",
+		description: "List an app's releases, newest first"
+	},
+	args: {
+		app: {
+			type: "positional",
+			required: true,
+			description: "App name"
+		},
+		...connection
+	},
+	async run({ args }) {
+		const info = await (await api(`/v1/apps/${args.app}`, args)).json();
+		for (const release of [...info.releases].reverse()) console.log(`${release}${release === info.release ? "  (active)" : ""}`);
+	}
+});
+const activate = defineCommand({
+	meta: {
+		name: "activate",
+		description: "Activate a release of an app (migrations stay applied)"
+	},
+	args: {
+		app: {
+			type: "positional",
+			required: true,
+			description: "App name"
+		},
+		release: {
+			type: "positional",
+			required: true,
+			description: "Release id (see `releases`)"
+		},
+		...connection
+	},
+	async run({ args }) {
+		const info = await (await api(`/v1/apps/${args.app}`, args)).json();
+		const result = await (await api(`/v1/apps/${args.app}/activate`, args, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				release: args.release,
+				ifActive: info.release ?? null
+			})
+		})).json();
+		console.log(`${args.app} is now on release ${result.release}`);
+	}
+});
+const reprovision = defineCommand({
+	meta: {
+		name: "reprovision",
+		description: "Recreate an app's database role, grants and ownership and run its migrations (after a restore)"
+	},
+	args: {
+		app: {
+			type: "positional",
+			required: false,
+			description: "App name"
+		},
+		all: {
+			type: "boolean",
+			description: "Every app"
+		},
+		...connection
+	},
+	async run({ args }) {
+		if (!args.app === !args.all) throw new Error("Pass an app name or --all");
+		const results = [await (await api(args.all ? "/v1/reprovision" : `/v1/apps/${args.app}/reprovision`, args, { method: "POST" })).json()].flat();
+		for (const r of results) console.log(`${r.app.padEnd(20)} ${r.error ?? (r.database ? "ok" : "no database")}`);
+		if (results.some((r) => r.error)) process.exitCode = 1;
+	}
+});
+const toList = (value) => (Array.isArray(value) ? value : value === void 0 ? [] : [value]).flatMap((v) => String(v).split(","));
+const access = defineCommand({
+	meta: {
+		name: "access",
+		description: "Show or change who can open an app (private apps need a login)"
+	},
+	args: {
+		app: {
+			type: "positional",
+			required: true,
+			description: "App name"
+		},
+		public: {
+			type: "boolean",
+			description: "Make the app public"
+		},
+		private: {
+			type: "boolean",
+			description: "Make the app private"
+		},
+		add: {
+			type: "string",
+			description: "Allow emails or *@domain (comma separated)"
+		},
+		remove: {
+			type: "string",
+			description: "Remove emails or *@domain (comma separated)"
+		},
+		...connection
+	},
+	async run({ args }) {
+		const change = {};
+		if (args.public) change.visibility = "public";
+		if (args.private) change.visibility = "private";
+		if (args.add) change.add = toList(args.add);
+		if (args.remove) change.remove = toList(args.remove);
+		const result = await (Object.keys(change).length ? await api(`/v1/apps/${args.app}/access`, args, {
+			method: "PATCH",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify(change)
+		}) : await api(`/v1/apps/${args.app}/access`, args)).json();
+		if (args.app === "auth") return console.log("auth is the login app and always public");
+		console.log(`${args.app} is ${result.visibility}`);
+		if (result.visibility === "private") console.log(result.allow.length ? `allowed: ${result.allow.join(", ")}` : "allowed: admins only");
+	}
+});
+const env = defineCommand({
+	meta: {
+		name: "env",
+		description: "Set or unset app environment variables (values are write-only)"
+	},
+	args: {
+		app: {
+			type: "positional",
+			required: true,
+			description: "App name"
+		},
+		set: {
+			type: "string",
+			description: "KEY=value (repeatable)"
+		},
+		unset: {
+			type: "string",
+			description: "KEY (comma separated)"
+		},
+		...connection
+	},
+	async run({ args, rawArgs }) {
+		const pairs = rawArgs.flatMap((arg, i) => arg === "--set" ? [rawArgs[i + 1] ?? ""] : arg.startsWith("--set=") ? [arg.slice(6)] : []);
+		const set = Object.fromEntries(pairs.map((pair) => {
+			const i = pair.indexOf("=");
+			if (i < 1) throw new Error(`Expected KEY=value, got "${pair}"`);
+			return [pair.slice(0, i), pair.slice(i + 1)];
+		}));
+		const unset = toList(args.unset);
+		const { keys } = await (Object.keys(set).length || unset.length ? await api(`/v1/apps/${args.app}/env`, args, {
+			method: "PATCH",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				set,
+				unset
+			})
+		}) : await api(`/v1/apps/${args.app}/env`, args)).json();
+		console.log(keys.length ? keys.join("\n") : "No variables set.");
+		if (Object.keys(set).length || unset.length) console.log("Applies to newly started isolates (next deploy or after idle timeout).");
+	}
+});
+const remove = defineCommand({
+	meta: {
+		name: "delete",
+		description: "Delete an app (releases, access, env)"
+	},
+	args: {
+		app: {
+			type: "positional",
+			required: true,
+			description: "App name"
+		},
+		"drop-database": {
+			type: "boolean",
+			description: "Also drop the app's schema and all its data"
+		},
+		yes: {
+			type: "boolean",
+			description: "Skip the confirmation"
+		},
+		...connection
+	},
+	async run({ args }) {
+		const dropDb = Boolean(args["drop-database"]);
+		if (!args.yes) {
+			const ok = await p.confirm({
+				message: `Delete ${args.app}${dropDb ? " and ALL its data" : " (database is kept)"}?`,
+				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 LEVEL_COLORS = {
+	error: "red",
+	warn: "yellow",
+	info: "cyan",
+	debug: "gray"
+};
+/** `09:07:52.060 error  <message>`, or the entry as one JSON line. */
+function printLog(entry, asJson) {
+	if (asJson) return console.log(JSON.stringify(entry));
+	const time = new Date(entry._time).toISOString().slice(11, 23);
+	const level = String(entry.level ?? "info");
+	const color = LEVEL_COLORS[level] ?? "white";
+	console.log(`${styleText("dim", time)} ${styleText(color, level.padEnd(5))} ${entry._msg ?? ""}`);
+}
+const logs = defineCommand({
+	meta: {
+		name: "logs",
+		description: "Show an app's logs: console output, request events and isolate events"
+	},
+	args: {
+		app: {
+			type: "positional",
+			required: true,
+			description: "App name"
+		},
+		query: {
+			type: "positional",
+			required: false,
+			description: "LogsQL filter, e.g. 'level:error' or 'status:>=500' (default: all)"
+		},
+		since: {
+			type: "string",
+			default: "1h",
+			description: "How far back, e.g. 15m, 6h, 2d"
+		},
+		until: {
+			type: "string",
+			description: "End of the range (default: now)"
+		},
+		limit: {
+			type: "string",
+			default: "100",
+			description: "Newest entries to show (max 1000)"
+		},
+		follow: {
+			type: "boolean",
+			alias: "f",
+			description: "Keep printing new entries"
+		},
+		json: {
+			type: "boolean",
+			description: "One JSON object per line, with every field"
+		},
+		...connection
+	},
+	async run({ args }) {
+		const params = new URLSearchParams();
+		if (args.query) params.set("query", args.query);
+		if (args.follow) {
+			params.set("since", args.since);
+			const res = await api(`/v1/apps/${args.app}/logs/tail?${params.toString()}`, args);
+			let rest = "";
+			for await (const chunk of res.body.pipeThrough(new TextDecoderStream())) {
+				const lines = (rest + chunk).split("\n");
+				rest = lines.pop() ?? "";
+				for (const line of lines) if (line) printLog(JSON.parse(line), Boolean(args.json));
+			}
+			return;
+		}
+		params.set("start", args.since);
+		if (args.until) params.set("end", args.until);
+		params.set("limit", args.limit);
+		const entries = await (await api(`/v1/apps/${args.app}/logs?${params.toString()}`, args)).json();
+		if (!entries.length && !args.json) return console.error(`No logs in the last ${args.since}.`);
+		for (const entry of entries.reverse()) printLog(entry, Boolean(args.json));
+	}
+});
+const login = defineCommand({
+	meta: {
+		name: "login",
+		description: "Save the control plane URL and token"
+	},
+	args: {
+		url: {
+			type: "string",
+			required: true,
+			description: "Control plane URL"
+		},
+		token: {
+			type: "string",
+			required: true,
+			description: "Deploy token, or the read token"
+		}
+	},
+	async run({ args }) {
+		const res = await fetch(`${args.url.replace(/\/$/, "")}/v1/apps`, { headers: { authorization: `Bearer ${args.token}` } });
+		if (!res.ok) throw new Error(`Login failed: ${res.status} ${res.statusText}`);
+		const file = await saveConfig({
+			url: args.url,
+			token: args.token
+		});
+		console.log(`Saved to ${file}`);
+	}
+});
+runMain(defineCommand({
+	meta: {
+		name: "wervt",
+		description: "Deploy and manage wervt apps"
+	},
+	subCommands: {
+		deploy,
+		apps,
+		releases,
+		logs,
+		activate,
+		rollback,
+		reprovision,
+		access,
+		env,
+		delete: remove,
+		login
+	}
+}));
+//#endregion
+export {};

package/package.json

@@ -1,11 +1,39 @@
 {
   "name": "@wervt/cli",
-  "version": "0.0.0",
-  "description": "Build and host small Nuxt apps written by agents. Coming soon.",
+  "version": "0.2.0",
+  "description": "Deploy and manage apps on wervt.",
+  "keywords": [
+    "agents",
+    "cli",
+    "hosting",
+    "nitro",
+    "nuxt"
+  ],
+  "homepage": "https://wervt.app",
   "license": "MIT",
   "author": "Niki2k1",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wervt-app/wervt.git",
+    "directory": "packages/cli"
+  },
+  "bin": {
+    "wervt": "bin/wervt.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "README.md"
+  ],
   "type": "module",
-  "keywords": ["agents", "nuxt", "nitro", "hosting", "cli"],
-  "bin": { "wervt": "bin/wervt.js" },
-  "files": ["bin", "README.md"]
-}
+  "dependencies": {
+    "@clack/prompts": "^1.8.1",
+    "citty": "^0.2.2",
+    "modern-tar": "^0.8.5",
+    "nypm": "^0.6.10",
+    "tinyexec": "^1.3.1"
+  },
+  "scripts": {
+    "build": "vp pack"
+  }
+}