@voltro/cli 0.33.0 → 0.34.0

package/dist/serveCommand-DOvbgRnQ.js

@@ -0,0 +1,2 @@
+import { n as e } from "./serveCommand-B_isw7q4.js";
+export { e as runServeDispatch };

package/dist/serveEntry.js

@@ -1,5 +1,5 @@
-import { ct as e } from "./inspectMetrics-1xzTKAFx.js";
-import { c as t } from "./seedRunner-Bqxgp7HZ.js";
-import { r as n } from "./appModuleLoader-C9r9mxZt.js";
-import { t as r } from "./serveCommand-DdaM4Hup.js";
-export { e as loadDotEnv, n as registerAppModules, t as registerDriver, r as runServe };
+import { t as e } from "./loadEnv-D9nEOClM.js";
+import { r as t } from "./appModuleLoader-C9r9mxZt.js";
+import { i as n } from "./dialectDriver-CgXnDfec.js";
+import { t as r } from "./serveCommand-B_isw7q4.js";
+export { e as loadDotEnv, t as registerAppModules, n as registerDriver, r as runServe };

package/dist/serverlessCommand-CfJZy6dS.js

@@ -0,0 +1,482 @@
+import { t as e } from "./cliRuntime-Dh7UDinH.js";
+import { t } from "./discover-C9XKJDco.js";
+import { t as n } from "./commandRunner-BLAEFLjp.js";
+import { basename as r, dirname as i, join as a, relative as o, resolve as s } from "node:path";
+import { pathToFileURL as c } from "node:url";
+import { Data as l, Effect as u } from "effect";
+import { tmpdir as d } from "node:os";
+import { mkdir as f, rm as p, writeFile as m } from "node:fs/promises";
+import * as h from "esbuild";
+import { serveServerless as g } from "@voltro/serverless/node";
+import { ServerlessDeployError as _, cloudflarePlatform as v, nodePlatform as y, scalewayPlatform as b } from "@voltro/serverless";
+//#region src/serverless/bundle.ts
+var x = class extends l.TaggedError("BundleError") {}, S = 0, C = (e) => a(d(), `voltro-sls-${e}-${process.pid}-${S++}.mjs`), w = (e) => u.tryPromise({
+	try: async () => {
+		let t = C(r(e).replace(/\W+/g, "-"));
+		await h.build({
+			entryPoints: [e],
+			outfile: t,
+			bundle: !0,
+			platform: "node",
+			format: "esm",
+			logLevel: "silent"
+		});
+		try {
+			let e = (await import(c(t).href)).default;
+			if (!e || typeof e.name != "string" || typeof e.handler != "function") throw Error("file has no `export default defineServerless({ … })`");
+			return e;
+		} finally {
+			await p(t, { force: !0 });
+		}
+	},
+	catch: (t) => new x({
+		file: e,
+		message: t instanceof Error ? t.message : String(t)
+	})
+}), T = (e) => e === "browser" ? "browser" : e === "neutral" ? "neutral" : "node", E = (e) => u.gen(function* () {
+	let t = yield* w(e.sourceFile), n = a(e.outDir, t.name), r = a(n, e.platform.esbuild.entryFile ?? (e.platform.esbuild.format === "esm" ? "index.mjs" : "index.js"));
+	return yield* u.tryPromise({
+		try: async () => {
+			await f(n, { recursive: !0 }), await h.build({
+				stdin: {
+					contents: e.platform.entryModule(e.sourceFile),
+					resolveDir: i(e.sourceFile),
+					loader: "ts",
+					sourcefile: "__voltro_entry.ts"
+				},
+				outfile: r,
+				bundle: !0,
+				platform: T(e.platform.esbuild.platform),
+				format: e.platform.esbuild.format,
+				...e.platform.esbuild.targetEs ? { target: e.platform.esbuild.targetEs } : {},
+				...e.platform.esbuild.conditions ? { conditions: [...e.platform.esbuild.conditions] } : {},
+				...e.platform.esbuild.external ? { external: [...e.platform.esbuild.external] } : {},
+				...e.platform.esbuild.banner ? { banner: { js: e.platform.esbuild.banner } } : {},
+				logLevel: "silent"
+			});
+		},
+		catch: (t) => new x({
+			file: e.sourceFile,
+			message: t instanceof Error ? t.message : String(t)
+		})
+	}), {
+		name: t.name,
+		file: r,
+		dir: n,
+		...t.runtime ? { runtime: t.runtime } : {}
+	};
+}), D = (e, t = {}) => u.async((n) => {
+	let r;
+	return g(e, t).then((t) => {
+		r = t, console.log(`Serving ${e.length} function(s) on http://${t.host}:${t.port}`);
+		for (let e of t.routes) console.log(`  ▸ ${e.name}  ${e.method} http://${t.host}:${t.port}${e.path}`);
+		console.log("  (Ctrl-C to stop)");
+	}).catch((e) => n(u.fail(e instanceof Error ? e : Error(String(e))))), u.promise(() => r ? r.close() : Promise.resolve());
+}), O = (e) => JSON.stringify(e), k = (e, t) => {
+	let n = [
+		`name = ${O(e.name)}`,
+		`main = ${O(r(e.file))}`,
+		`compatibility_date = ${O(t.compatibilityDate ?? "2024-09-23")}`
+	];
+	t.nodeCompat && n.push("compatibility_flags = [\"nodejs_compat\"]"), n.push(`workers_dev = ${t.workersDev === !1 ? "false" : "true"}`);
+	let i = t.vars ?? {}, a = Object.keys(i);
+	if (a.length > 0) {
+		n.push("", "[vars]");
+		for (let e of a) n.push(`${e} = ${O(i[e])}`);
+	}
+	return n.join("\n") + "\n";
+}, A = /https:\/\/[^\s'"()<>]+workers\.dev[^\s'"()<>]*/, j = (e) => ({
+	...v,
+	deploy: (t, n) => u.gen(function* () {
+		let r = n.options ?? {}, i = a(t.dir, "wrangler.toml");
+		yield* u.tryPromise({
+			try: () => m(i, k(t, r), "utf8"),
+			catch: (e) => new _({
+				target: "cloudflare",
+				message: `failed to write wrangler.toml: ${String(e)}`
+			})
+		});
+		let o = [
+			"deploy",
+			"--no-bundle",
+			"--config",
+			i
+		];
+		if (n.dryRun) return yield* u.logInfo("dry-run: would deploy Cloudflare Worker", {
+			name: t.name,
+			command: `wrangler ${o.join(" ")}`,
+			cwd: t.dir
+		}), {
+			target: "cloudflare",
+			name: t.name
+		};
+		let s = n.env.CLOUDFLARE_API_TOKEN, c = n.env.CLOUDFLARE_ACCOUNT_ID;
+		if (!s || !c) return yield* u.fail(new _({
+			target: "cloudflare",
+			message: "missing CLOUDFLARE_API_TOKEN and/or CLOUDFLARE_ACCOUNT_ID"
+		}));
+		if (!(yield* e.which("wrangler"))) return yield* u.fail(new _({
+			target: "cloudflare",
+			message: "`wrangler` not found on PATH (install: npm i -g wrangler)"
+		}));
+		let l = yield* e.exec("wrangler", o, {
+			cwd: t.dir,
+			env: {
+				CLOUDFLARE_API_TOKEN: s,
+				CLOUDFLARE_ACCOUNT_ID: c
+			}
+		}).pipe(u.mapError((e) => new _({
+			target: "cloudflare",
+			message: `wrangler deploy failed (exit ${e.exitCode})`,
+			detail: e.stderr
+		}))), d = A.exec(l.stdout)?.[0];
+		return {
+			target: "cloudflare",
+			name: t.name,
+			...d ? { url: d } : {}
+		};
+	})
+}), M = /https:\/\/[^\s'"()<>]+\.fnc\.[a-z0-9-]+\.scw\.cloud[^\s'"()<>]*/, N = "handler.handle", P = (e, t) => {
+	let n = [`handler=${N}`, "http-option=enabled"], r = e.runtime;
+	return r?.memoryMb !== void 0 && n.push(`memory-limit=${r.memoryMb}`), r?.timeoutSeconds !== void 0 && n.push(`timeout=${r.timeoutSeconds}s`), r?.minScale !== void 0 && n.push(`min-scale=${r.minScale}`), r?.maxScale !== void 0 && n.push(`max-scale=${r.maxScale}`), t && n.push(`privacy=${t}`), n;
+}, F = (e, t) => u.try({
+	try: () => {
+		let n = e.trim();
+		if (!n) return;
+		let r = JSON.parse(n);
+		return (Array.isArray(r) ? r : []).find((e) => typeof e == "object" && !!e && e.name === t && typeof e.id == "string")?.id;
+	},
+	catch: (e) => new _({
+		target: "scaleway",
+		message: "could not parse `scw function list` output",
+		detail: e instanceof Error ? e.message : String(e)
+	})
+}), I = (e) => ({
+	...b,
+	deploy: (t, n) => u.gen(function* () {
+		let r = n.options ?? {}, i = a(t.dir, "function.zip"), o = r.runtime ?? "node22", s = r.namespaceId;
+		if (n.dryRun) return yield* u.logInfo("dry-run: would deploy Scaleway Function", {
+			name: t.name,
+			zip: `zip -r -q ${i} . (cwd ${t.dir})`,
+			ensure: `scw function function create|update name=${t.name} runtime=${o} ${P(t, r.privacy).join(" ")}`,
+			deploy: `scw function deploy name=${t.name} runtime=${o} zip-file=${i}${s ? ` namespace-id=${s}` : ""}`
+		}), {
+			target: "scaleway",
+			name: t.name
+		};
+		if (!s) return yield* u.fail(new _({
+			target: "scaleway",
+			message: "missing options.namespaceId (create one with `scw function namespace create`)"
+		}));
+		if (!(yield* e.which("zip"))) return yield* u.fail(new _({
+			target: "scaleway",
+			message: "`zip` not found on PATH (needed to package the function)"
+		}));
+		if (!(yield* e.which("scw"))) return yield* u.fail(new _({
+			target: "scaleway",
+			message: "`scw` not found on PATH (install the Scaleway CLI)"
+		}));
+		let c = (e) => (t) => new _({
+			target: "scaleway",
+			message: `${e} failed (exit ${t.exitCode})`,
+			detail: t.stderr
+		});
+		yield* e.exec("zip", [
+			"-r",
+			"-q",
+			i,
+			"."
+		], { cwd: t.dir }).pipe(u.mapError(c("zip")));
+		let l = yield* F((yield* e.exec("scw", [
+			"function",
+			"function",
+			"list",
+			`namespace-id=${s}`,
+			`name=${t.name}`,
+			"-o",
+			"json"
+		], { env: n.env }).pipe(u.mapError(c("scw function list")))).stdout, t.name);
+		l ? yield* e.exec("scw", [
+			"function",
+			"function",
+			"update",
+			l,
+			`runtime=${o}`,
+			...P(t, r.privacy)
+		], { env: n.env }).pipe(u.mapError(c("scw function update"))) : yield* e.exec("scw", [
+			"function",
+			"function",
+			"create",
+			`namespace-id=${s}`,
+			`name=${t.name}`,
+			`runtime=${o}`,
+			...P(t, r.privacy)
+		], { env: n.env }).pipe(u.mapError(c("scw function create")));
+		let d = yield* e.exec("scw", [
+			"function",
+			"deploy",
+			`name=${t.name}`,
+			`namespace-id=${s}`,
+			`runtime=${o}`,
+			`zip-file=${i}`
+		], { env: n.env }).pipe(u.mapError(c("scw function deploy"))), f = M.exec(d.stdout)?.[0];
+		return {
+			target: "scaleway",
+			name: t.name,
+			...l ? { id: l } : {},
+			...f ? { url: f } : {}
+		};
+	})
+}), L = (e, t) => `# AUTO-GENERATED by @voltro/serverless — self-hosted Node function image.
+FROM node:22-slim
+WORKDIR /app
+COPY ${e} ./
+ENV PORT=${t}
+EXPOSE ${t}
+CMD ["node", "${e}"]
+`, R = (e, t, n) => `# ${e} — self-hosted serverless function
+
+Built by \`voltro serverless\`. This folder is a complete, runnable artifact — the
+same handler that would run on Cloudflare/Scaleway, on your own infra.
+
+## Run with Node (needs Node 22+)
+
+\`\`\`bash
+PORT=${n} node ${t}
+# POST http://localhost:${n}/        — your function
+# GET  http://localhost:${n}/internal/liveness   → ok
+# GET  http://localhost:${n}/internal/readiness  → ready
+\`\`\`
+
+## Run with Docker
+
+\`\`\`bash
+docker build -t ${e} .
+docker run -p ${n}:${n} ${e}
+\`\`\`
+
+## docker-compose
+
+\`\`\`yaml
+services:
+  ${e}:
+    build: .
+    ports: ["${n}:${n}"]
+    # environment:
+    #   SOME_SECRET: "…"   # reaches the handler via ctx.env
+    restart: unless-stopped
+\`\`\`
+
+## Behind a reverse proxy (Caddy)
+
+\`\`\`
+${e}.example.com {
+  reverse_proxy localhost:${n}
+}
+\`\`\`
+
+To run ALL of a project's functions in ONE process instead of a per-function
+image, use \`voltro serverless serve\` from the project root.
+`, z = (e, t) => u.tryPromise({
+	try: async () => {
+		let n = r(e.file);
+		return await m(a(e.dir, "Dockerfile"), L(n, t), "utf8"), await m(a(e.dir, "README.md"), R(e.name, n, t), "utf8"), ["Dockerfile", "README.md"];
+	},
+	catch: (e) => new _({
+		target: "node",
+		message: `failed to write self-host kit: ${String(e)}`
+	})
+}), B = () => ({
+	...y,
+	deploy: (e, t) => u.gen(function* () {
+		let n = (t.options ?? {}).port ?? 8910, i = r(e.file), a = {
+			artifact: e.file,
+			run: `PORT=${n} node ${i}`,
+			docker: `docker build -t ${e.name} ${e.dir} && docker run -p ${n}:${n} ${e.name}`,
+			hint: "or run all functions in one process with: voltro serverless serve"
+		};
+		return t.dryRun ? (yield* u.logInfo("dry-run: would emit self-hosted Node artifact + kit (Dockerfile, README)", a), {
+			target: "node",
+			name: e.name
+		}) : (yield* z(e, n), yield* u.logInfo("self-hosted Node artifact + kit ready", a), {
+			target: "node",
+			name: e.name,
+			url: `http://localhost:${n}`
+		});
+	})
+}), V = [
+	"node",
+	"cloudflare",
+	"scaleway"
+], H = (e) => V.includes(e), U = (e, t) => {
+	switch (e) {
+		case "node": return B();
+		case "cloudflare": return j(t);
+		case "scaleway": return I(t);
+	}
+}, W = (e) => u.sync(() => console.log(e)), G = (e, t) => {
+	let n = "node", r = a(t, ".voltro", "serverless"), i = !1, o = {}, c = [], l;
+	for (let a = 0; a < e.length; a++) {
+		let u = e[a];
+		switch (u) {
+			case "--target":
+				n = e[++a] ?? "";
+				break;
+			case "--out":
+				r = s(t, e[++a] ?? ".");
+				break;
+			case "--dry-run":
+				i = !0;
+				break;
+			case "--namespace-id":
+				o.namespaceId = e[++a];
+				break;
+			case "--compat-date":
+				o.compatibilityDate = e[++a];
+				break;
+			case "--node-compat":
+				o.nodeCompat = !0;
+				break;
+			case "--region":
+				o.region = e[++a];
+				break;
+			case "--runtime":
+				o.runtime = e[++a];
+				break;
+			case "--port":
+				o.port = Number(e[++a]);
+				break;
+			default: u.startsWith("-") ? l = `unknown flag '${u}'` : c.push(u);
+		}
+	}
+	return H(n) || (l = `unknown --target '${n}' (one of: ${V.join(", ")})`, n = "node"), {
+		target: n,
+		out: r,
+		dryRun: i,
+		options: o,
+		positional: c,
+		error: l
+	};
+}, K = (e, n) => e.length > 0 ? u.succeed(e.map((e) => s(n, e))) : t(n), q = () => W([
+	"voltro serverless <list|dev|serve|build|deploy> [options] [files…]",
+	"",
+	"  list                       discover *.serverless.ts files",
+	"  dev     [--port <n>] [f]   run ONE function locally (default port 8910)",
+	"  serve   [--port][--host]   run ALL functions (self-hosted production sidecar)",
+	"  build   [--target <id>]    bundle each function (no upload)",
+	"  deploy  [--target <id>]    ship: node → self-host artifact, cloudflare/scaleway → vendor",
+	"",
+	"Options:",
+	`  --target <id>              ${V.join(" | ")}  (default node)`,
+	"  --out <dir>                artifact dir (default .voltro/serverless)",
+	"  --dry-run                  bundle, then print the deploy plan",
+	"  --port <n>                 dev/serve: listen port (default 8910)",
+	"  --host <h>                 serve: bind host (default 0.0.0.0)",
+	"  --port <n> (deploy)        node: port the image exposes",
+	"  --namespace-id <id>        Scaleway: target namespace",
+	"  --node-compat              Cloudflare: add nodejs_compat flag",
+	"  --compat-date <date>       Cloudflare: compatibility_date",
+	"  --runtime <r>              Scaleway: node20 | node22"
+].join("\n")).pipe(u.as(0)), J = (e) => {
+	let t = 8910, n, r = [], i;
+	for (let a = 0; a < e.length; a++) {
+		let o = e[a];
+		o === "--port" ? t = Number(e[++a] ?? "8910") : o === "--host" ? n = e[++a] : o.startsWith("-") ? i = `unknown flag '${o}'` : r.push(o);
+	}
+	return (!Number.isInteger(t) || t <= 0) && (i = "--port must be a positive integer"), {
+		port: t,
+		host: n,
+		files: r,
+		error: i
+	};
+}, Y = (e, n, r) => u.gen(function* () {
+	let { port: i, host: a, files: c, error: l } = J(e);
+	if (l) return yield* W(`voltro serverless ${r.label}: ${l}`), 2;
+	let d = c.length > 0 ? c.map((e) => s(n, e)) : yield* t(n);
+	if (d.length === 0) return yield* W("No *.serverless.ts function found."), 0;
+	if (r.single && d.length > 1) return yield* W(`voltro serverless dev: multiple functions found — name one (or use \`serve\`):\n${d.map((e) => `  ${o(n, e)}`).join("\n")}`), 2;
+	let f = yield* u.forEach(d, (e) => w(e).pipe(u.map((e) => ({
+		ok: !0,
+		d: e
+	})), u.catchAll((e) => u.succeed({
+		ok: !1,
+		message: `${e.file}: ${e.message}`
+	})))), p = f.filter((e) => !e.ok);
+	for (let e of p) e.ok || (yield* W(`  ✗ ${e.message}`));
+	let m = f.flatMap((e) => e.ok ? [e.d] : []);
+	if (m.length === 0) return 1;
+	let h = a ?? r.defaultHost;
+	return yield* D(m, {
+		port: i,
+		...h ? { host: h } : {}
+	}).pipe(u.as(0), u.catchAll((e) => u.as(W(`server error: ${e.message}`), 1)));
+}), X = (e) => u.gen(function* () {
+	let [t, ...r] = e, i = process.cwd();
+	if (t === void 0 || t === "help" || t === "--help" || t === "-h") return yield* q();
+	if (t === "dev") return yield* Y(r, i, {
+		single: !0,
+		defaultHost: "127.0.0.1",
+		label: "dev"
+	});
+	if (t === "serve") return yield* Y(r, i, {
+		single: !1,
+		defaultHost: "0.0.0.0",
+		label: "serve"
+	});
+	if (t !== "list" && t !== "build" && t !== "deploy") return yield* W(`voltro serverless: unknown subcommand '${t}'`), 2;
+	let s = G(r, i);
+	if (s.error) return yield* W(`voltro serverless: ${s.error}`), 2;
+	let c = yield* K(s.positional, i);
+	if (c.length === 0) return yield* W("No *.serverless.ts functions found."), 0;
+	if (t === "list") {
+		yield* W(`Found ${c.length} serverless function(s):`);
+		for (let e of c) yield* W(`  ${o(i, e)}`);
+		return 0;
+	}
+	let l = n, d = U(s.target, l), f = a(s.out, d.id), p = 0;
+	for (let e of c) {
+		let n = yield* E({
+			platform: d,
+			sourceFile: e,
+			outDir: f
+		}).pipe(u.map((e) => ({
+			ok: !0,
+			b: e
+		})), u.catchAll((e) => u.succeed({
+			ok: !1,
+			message: `${e.file}: ${e.message}`
+		})));
+		if (!n.ok) {
+			p++, yield* W(`  ✗ bundle ${n.message}`);
+			continue;
+		}
+		if (t === "build") {
+			if (d.id === "node") {
+				let e = typeof s.options.port == "number" ? s.options.port : 8910;
+				yield* z(n.b, e).pipe(u.catchAll(() => u.void));
+			}
+			yield* W(`  ✓ bundled ${n.b.name} → ${o(i, n.b.file)} [${d.id}]`);
+			continue;
+		}
+		let r = {
+			env: process.env,
+			options: s.options,
+			dryRun: s.dryRun
+		}, a = yield* d.deploy(n.b, r).pipe(u.map((e) => ({
+			ok: !0,
+			r: e
+		})), u.catchAll((e) => u.succeed({
+			ok: !1,
+			message: `${e.message}${e.detail ? ` — ${String(e.detail)}` : ""}`
+		})));
+		if (!a.ok) {
+			p++, yield* W(`  ✗ deploy ${n.b.name}: ${a.message}`);
+			continue;
+		}
+		let c = a.r.url ? ` → ${a.r.url}` : s.dryRun ? " (dry-run)" : "";
+		yield* W(`  ✓ ${t === "deploy" ? "deployed" : "built"} ${n.b.name} [${d.id}]${c}`);
+	}
+	return +(p > 0);
+}), Z = (t) => e(X(t), { scope: "voltro:serverless" });
+//#endregion
+export { Z as runServerlessCommand };