@selvajs/cli 4.7.4-beta.0 → 4.8.0-beta.10

package/src/node-range.js

@@ -0,0 +1,66 @@
+// Node version-range matching, used by `selva doctor` to check an installed
+// runtime and by the scaffolder to refuse a too-old shell before writing files.
+
+/**
+ * Narrow `engines.node` range check — `>=X`, `^`, `~`, `||`, and bare/x-ranges.
+ * Returns null when unparseable so a misread never reports a false failure.
+ *
+ * Mirrors `satisfiesRange` in @selvajs/server/ops. Duplicated because the CLI is
+ * dependency-free by design (it scaffolds the deployment that installs the
+ * runtime, so it cannot import from it).
+ */
+export function satisfiesNodeRange(version, range) {
+	const core = /^v?(\d+)\.(\d+)\.(\d+)/.exec(String(version).trim());
+	if (!core) return null;
+	const v = [Number(core[1]), Number(core[2]), Number(core[3])];
+
+	let anyParsed = false;
+	for (const alt of String(range).split('||')) {
+		const clauses = alt.trim().split(/\s+/).filter(Boolean);
+		if (!clauses.length) continue;
+
+		let all = true;
+		let parsed = true;
+		for (const clause of clauses) {
+			const m = /^(>=|<=|>|<|\^|~|=)?\s*v?(\d+)(?:\.(\d+|x|\*))?(?:\.(\d+|x|\*))?/.exec(clause);
+			if (!m) {
+				parsed = false;
+				break;
+			}
+			const op = m[1] ?? '=';
+			const num = (s) => (s == null || s === 'x' || s === '*' ? 0 : Number(s));
+			const t = [Number(m[2]), num(m[3]), num(m[4])];
+			let cmp = 0;
+			for (let i = 0; i < 3; i++) {
+				if (v[i] > t[i]) {
+					cmp = 1;
+					break;
+				}
+				if (v[i] < t[i]) {
+					cmp = -1;
+					break;
+				}
+			}
+			let ok;
+			if (op === '>=') ok = cmp >= 0;
+			else if (op === '>') ok = cmp > 0;
+			else if (op === '<=') ok = cmp <= 0;
+			else if (op === '<') ok = cmp < 0;
+			else if (op === '^') ok = cmp >= 0 && v[0] === t[0];
+			else if (op === '~') ok = cmp >= 0 && v[0] === t[0] && v[1] === t[1];
+			else
+				ok =
+					v[0] === t[0] &&
+					(m[3] == null || m[3] === 'x' || m[3] === '*' || v[1] === t[1]) &&
+					(m[4] == null || m[4] === 'x' || m[4] === '*' || v[2] === t[2]);
+			if (!ok) {
+				all = false;
+				break;
+			}
+		}
+		if (!parsed) continue;
+		anyParsed = true;
+		if (all) return true;
+	}
+	return anyParsed ? false : null;
+}

package/src/paths.js

@@ -1,5 +1,69 @@
-import { existsSync, readdirSync } from 'node:fs';
-import { resolve, join } from 'node:path';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { resolve, join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/**
+ * The Node floor Selva requires, read from this CLI's own `engines.node`.
+ *
+ * Never hardcode it: the CLI, runtime, and server all declare the same range in
+ * package.json, and a copy in code silently keeps enforcing the old floor after
+ * a bump. Falls back to null (skip the check) rather than guessing a number —
+ * refusing to scaffold on a wrong guess is worse than not checking.
+ */
+export function requiredNodeRange() {
+	try {
+		const here = dirname(fileURLToPath(import.meta.url));
+		const pkg = JSON.parse(readFileSync(join(here, '..', 'package.json'), 'utf8'));
+		const range = pkg.engines?.node;
+		return typeof range === 'string' ? range : null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * This CLI's own version, written into `.selva-version` so a later `selva
+ * migrate` can tell which scaffold layout it is looking at.
+ *
+ * Read from package.json for the same reason as `requiredNodeRange`: a literal
+ * in code stops tracking the release the moment someone forgets to bump it, and
+ * the marker's whole job is to be accurate about which CLI wrote the directory.
+ */
+export function scaffoldVersion() {
+	try {
+		const here = dirname(fileURLToPath(import.meta.url));
+		const pkg = JSON.parse(readFileSync(join(here, '..', 'package.json'), 'utf8'));
+		return typeof pkg.version === 'string' ? pkg.version : '0.0.0';
+	} catch {
+		return '0.0.0';
+	}
+}
+
+/**
+ * A scaffolding template shipped inside the installed runtime. The CLI cannot
+ * import from `@selvajs/selva` — it is what installs it — so it reads the files
+ * out of node_modules after install.
+ */
+export function runtimeTemplatePath(dir, name) {
+	return join(dir, 'node_modules', '@selvajs', 'selva', 'templates', name);
+}
+
+/**
+ * The `.env` template to merge operator values into: the runtime's `.env.example`
+ * when installed, otherwise the deployment's own `.env` so its comments and
+ * ordering survive a rewrite.
+ *
+ * Returns `''` when neither exists rather than throwing — `mergeEnv` appends
+ * every value to an empty template, so the operator gets a usable file instead
+ * of an ENOENT from a command that was only asked to change one key.
+ */
+export function readEnvTemplate(dir) {
+	const template = runtimeTemplatePath(dir, '.env.example');
+	if (existsSync(template)) return readFileSync(template, 'utf8');
+	const env = join(dir, '.env');
+	if (existsSync(env)) return readFileSync(env, 'utf8');
+	return '';
+}
 
 // A deployment directory must contain an .env and an ecosystem.config.cjs.
 // Anything else (selva.config.js, node_modules) is "should be there" but the

package/src/prompts.js

@@ -527,5 +527,3 @@ function headerAuthSecurityWarning() {
 		pc.dim('See packages/providers/header-auth/README.md for the full deployment checklist.')
 	].join('\n');
 }
-
-export { p as prompts, pc as colors };

package/bin/create.js

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-import { runCreate } from '../src/commands/create.js';
-
-runCreate(process.argv.slice(2)).catch((err) => {
-	console.error(err instanceof Error ? err.message : err);
-	process.exit(1);
-});