@selvajs/cli 4.7.4-beta.1 → 4.8.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@selvajs/cli",
-  "version": "4.7.4-beta.1",
+  "version": "4.8.0-beta.2",
   "description": "Scaffold and operate a Selva white-label deployment. `npx @selvajs/cli <dir>` to bootstrap, `selva <cmd>` to manage.",
   "license": "MIT",
   "author": "VektorNode",
@@ -40,6 +40,6 @@
   "scripts": {
     "start": "node ./bin/cli.js",
     "selva": "node ./bin/selva.js",
-    "test": "node --check ./bin/cli.js && node --check ./bin/selva.js && node --input-type=module -e \"for (const m of ['./src/cli.js','./src/prompts.js','./src/env.js','./src/paths.js','./src/secrets.js','./src/commands/create.js','./src/commands/init.js','./src/commands/doctor.js','./src/commands/pm2.js','./src/commands/migrate.js','./src/commands/keys.js']) { await import(m); }\""
+    "test": "node --check ./bin/cli.js && node --check ./bin/selva.js && node --input-type=module -e \"for (const m of ['./src/cli.js','./src/prompts.js','./src/env.js','./src/paths.js','./src/secrets.js','./src/commands/create.js','./src/commands/init.js','./src/commands/doctor.js','./src/commands/pm2.js','./src/commands/migrate.js','./src/commands/keys.js']) { await import(m); }\" && node --test \"./src/__tests__/*.test.js\""
   }
 }

package/src/__tests__/env-rename.test.js

@@ -0,0 +1,65 @@
+// `selva migrate` rewrites the operator's .env in place, so these pin the
+// blast radius: only the key changes, and only on lines that are live config.
+// Run by `pnpm test` via node's built-in runner.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { renameEnvKeys, RENAMED_ENV_VARS, REPLACED_ENV_VARS } from '../env.js';
+
+test('renames a deprecated key and leaves everything else byte-identical', () => {
+	const before = [
+		'# Selva deployment',
+		'ORIGIN=https://example.com',
+		'',
+		'# Longest a solve may run.',
+		'MAX_SOLVE_DURATION_MS=45000',
+		'COMPUTE_RATE_LIMIT_MAX=120',
+		''
+	].join('\n');
+
+	const { text, changes } = renameEnvKeys(before, RENAMED_ENV_VARS);
+
+	assert.deepEqual(changes, [['MAX_SOLVE_DURATION_MS', 'COMPUTE_SOLVE_DEADLINE_MS', 'renamed']]);
+	assert.equal(text, before.replace('MAX_SOLVE_DURATION_MS', 'COMPUTE_SOLVE_DEADLINE_MS'));
+});
+
+test('preserves the value verbatim, including quotes and spacing', () => {
+	const { text } = renameEnvKeys(
+		'COMPUTE_RESPONSE_CACHE_MB="512"\n   DEFINITION_CACHE_TTL_MS = 60000\n',
+		RENAMED_ENV_VARS
+	);
+	assert.match(text, /^COMPUTE_SOLVE_CACHE_MB="512"$/m);
+	assert.match(text, /^ {3}REMOTE_DEFINITION_CACHE_TTL_MS = 60000$/m);
+});
+
+test('drops the old line when the new name is already set', () => {
+	const { text, changes } = renameEnvKeys(
+		'MAX_SOLVE_DURATION_MS=45000\nCOMPUTE_SOLVE_DEADLINE_MS=30000\n',
+		RENAMED_ENV_VARS
+	);
+	// The server resolves the same way (new name wins), so keeping both would
+	// preserve a line that does nothing.
+	assert.deepEqual(changes, [['MAX_SOLVE_DURATION_MS', 'COMPUTE_SOLVE_DEADLINE_MS', 'dropped']]);
+	assert.equal(text, 'COMPUTE_SOLVE_DEADLINE_MS=30000\n');
+});
+
+test('reports no changes for an already-current file', () => {
+	const { changes } = renameEnvKeys('COMPUTE_SOLVE_DEADLINE_MS=30000\n', RENAMED_ENV_VARS);
+	assert.deepEqual(changes, []);
+});
+
+test('ignores a commented-out old name — it is not active config', () => {
+	const before = '# MAX_SOLVE_DURATION_MS=100000\n';
+	const { text, changes } = renameEnvKeys(before, RENAMED_ENV_VARS);
+	assert.deepEqual(changes, []);
+	assert.equal(text, before);
+});
+
+test('leaves value-changing replacements alone — migrate must not guess', () => {
+	const before = 'SELVA_FLAG_COMPUTE_DEBUG_VERBOSE=true\n';
+	const { text, changes } = renameEnvKeys(before, RENAMED_ENV_VARS);
+	assert.deepEqual(changes, []);
+	assert.equal(text, before);
+	// It is still reported by `selva doctor`, just not auto-fixed.
+	assert.ok(REPLACED_ENV_VARS.SELVA_FLAG_COMPUTE_DEBUG_VERBOSE);
+});

package/src/commands/doctor.js

@@ -7,7 +7,7 @@ import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
-import { readEnvFile } from '../env.js';
+import { readEnvFile, RENAMED_ENV_VARS, REPLACED_ENV_VARS } from '../env.js';
 import { requireDeploymentDir, resolveDeploymentDir } from '../paths.js';
 import { detectDrift } from './migrate.js';
 
@@ -85,6 +85,21 @@ export async function runDoctor() {
 		checks.push(yellow('ORIGIN unset — required behind a reverse proxy'));
 	}
 
+	for (const [oldName, newName] of Object.entries(RENAMED_ENV_VARS)) {
+		if (env[oldName] === undefined) continue;
+		checks.push(
+			env[newName] === undefined
+				? yellow(`${oldName} is deprecated — \`selva migrate\` renames it to ${newName}`)
+				: yellow(`${oldName} is deprecated and ignored — ${newName} is set and wins`)
+		);
+	}
+
+	// Not auto-fixable: the replacement encodes a value, so migrate won't guess.
+	for (const [oldName, replacement] of Object.entries(REPLACED_ENV_VARS)) {
+		if (env[oldName] === undefined) continue;
+		checks.push(yellow(`${oldName} is deprecated — replace it with ${replacement}`));
+	}
+
 	// ── Render ─────────────────────────────────────────────────────────
 	let failures = 0;
 	for (const c of await Promise.all(checks)) {
@@ -321,9 +336,7 @@ function checkBootPersistence(dir) {
 
 	// systemd unit: present and pointing at deployment-local pm2.
 	const user = process.env.USER ?? process.env.LOGNAME;
-	const unitPath = user
-		? `/etc/systemd/system/pm2-${user}.service`
-		: null;
+	const unitPath = user ? `/etc/systemd/system/pm2-${user}.service` : null;
 
 	if (unitPath && existsSync(unitPath)) {
 		const localPm2 = join(dir, 'node_modules', 'pm2', 'bin', 'pm2');
@@ -494,8 +507,7 @@ function checkHeaderAuth(dir, env, dataProvider) {
 		Boolean(env.HEADER_AUTH_EMAIL_HEADER),
 		Boolean(env.HEADER_AUTH_DISPLAY_NAME_HEADER)
 	].filter(Boolean).length;
-	const headerList =
-		`UPN=${resolved.upn}, Email=${resolved.email}, DisplayName=${resolved.displayName}`;
+	const headerList = `UPN=${resolved.upn}, Email=${resolved.email}, DisplayName=${resolved.displayName}`;
 	if (overrides === 0) {
 		out.push(green(`header names (bundled defaults): ${headerList}`));
 	} else if (overrides === 3) {

package/src/commands/migrate.js

@@ -2,18 +2,13 @@
 // provider packages), remove stale selva.config.js, update ecosystem.config.cjs.
 // Idempotent; mirrors update's lifecycle (stop/mutate/start with rollback on failure).
 
-import {
-	existsSync,
-	readFileSync,
-	writeFileSync,
-	copyFileSync,
-	rmSync
-} from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, copyFileSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { spawnSync, execSync } from 'node:child_process';
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import { requireDeploymentDir, resolveDeploymentDir } from '../paths.js';
+import { renameEnvKeys, RENAMED_ENV_VARS } from '../env.js';
 
 const APP_NAME = 'selva-compute';
 
@@ -66,9 +61,31 @@ export async function runMigrate() {
 	const ecoHasStaleRuntime =
 		existsSync(ecoPath) && readFileSync(ecoPath, 'utf8').includes('@selvajs/runtime');
 
+	// Deprecated env keys. The server reads the old names for one more minor
+	// version, so this is a warning today and a silent fallback to defaults once
+	// that shim goes — rewriting now is what keeps a tuned value tuned.
+	const envPath = join(dir, '.env');
+	const envBefore = existsSync(envPath) ? readFileSync(envPath, 'utf8') : null;
+	const envRename = envBefore
+		? renameEnvKeys(envBefore, RENAMED_ENV_VARS)
+		: { text: '', changes: [] };
+
 	const sideFileChanges = [];
-	if (hasStaleConfig) sideFileChanges.push(`${pc.red('-')} selva.config.js ${pc.dim('(no longer needed; providers are env-driven)')}`);
-	if (ecoHasStaleRuntime) sideFileChanges.push(`${pc.yellow('~')} ecosystem.config.cjs ${pc.dim('(rewrite: @selvajs/runtime → @selvajs/selva)')}`);
+	if (hasStaleConfig)
+		sideFileChanges.push(
+			`${pc.red('-')} selva.config.js ${pc.dim('(no longer needed; providers are env-driven)')}`
+		);
+	if (ecoHasStaleRuntime)
+		sideFileChanges.push(
+			`${pc.yellow('~')} ecosystem.config.cjs ${pc.dim('(rewrite: @selvajs/runtime → @selvajs/selva)')}`
+		);
+	for (const [oldName, newName, action] of envRename.changes) {
+		sideFileChanges.push(
+			action === 'dropped'
+				? `${pc.red('-')} .env ${pc.dim(`${oldName} (deprecated; ${newName} is already set)`)}`
+				: `${pc.yellow('~')} .env ${pc.dim(`${oldName} → ${newName}`)}`
+		);
+	}
 
 	if (pkgDiff.length === 0 && sideFileChanges.length === 0) {
 		p.outro(pc.green('Already on the current layout — nothing to migrate.'));
@@ -114,6 +131,11 @@ export async function runMigrate() {
 		writeFileSync(ecoPath, ecoContent, 'utf8');
 	}
 
+	if (envRename.changes.length > 0) {
+		copyFileSync(envPath, envPath + '.bak');
+		writeFileSync(envPath, envRename.text, 'utf8');
+	}
+
 	// Clean install required (major version changes break legacy lockfile).
 	rmSync(join(dir, 'node_modules'), { recursive: true, force: true });
 	rmSync(join(dir, 'package-lock.json'), { force: true });
@@ -137,6 +159,9 @@ export async function runMigrate() {
 		if (ecoHasStaleRuntime && existsSync(ecoPath + '.bak')) {
 			copyFileSync(ecoPath + '.bak', ecoPath);
 		}
+		if (envRename.changes.length > 0 && existsSync(envPath + '.bak')) {
+			copyFileSync(envPath + '.bak', envPath);
+		}
 		// Try to bring the process back up (best-effort; at least package.json is consistent).
 		runPm2(dir, ['start', APP_NAME, '--update-env'], { inherit: false });
 		p.outro(pc.red(`Migration aborted: ${err.message ?? err}`));
@@ -147,6 +172,7 @@ export async function runMigrate() {
 	const backupHints = ['package.json.bak'];
 	if (hasStaleConfig) backupHints.push('selva.config.js.bak');
 	if (ecoHasStaleRuntime) backupHints.push('ecosystem.config.cjs.bak');
+	if (envRename.changes.length > 0) backupHints.push('.env.bak');
 
 	if (status === 0) {
 		p.outro(
@@ -231,7 +257,8 @@ export function detectDrift(pkgJson, dir) {
 	const reasons = [];
 	if (deps['@selvajs/runtime']) reasons.push('@selvajs/runtime is the old runtime package');
 	if (deps['@selvajs/create']) reasons.push('@selvajs/create is the old CLI package');
-	if (deps['@selvajs/platform']) reasons.push('@selvajs/platform is now bundled into @selvajs/selva');
+	if (deps['@selvajs/platform'])
+		reasons.push('@selvajs/platform is now bundled into @selvajs/selva');
 	if (deps['@selvajs/local-provider'])
 		reasons.push('@selvajs/local-provider is now bundled into @selvajs/selva');
 	if (deps['@selvajs/supabase-provider'])
@@ -251,6 +278,13 @@ export function detectDrift(pkgJson, dir) {
 		if (existsSync(ecoPath) && readFileSync(ecoPath, 'utf8').includes('@selvajs/runtime')) {
 			reasons.push('ecosystem.config.cjs still references @selvajs/runtime');
 		}
+		const envPath = join(dir, '.env');
+		if (existsSync(envPath)) {
+			const { changes } = renameEnvKeys(readFileSync(envPath, 'utf8'), RENAMED_ENV_VARS);
+			for (const [oldName, newName] of changes) {
+				reasons.push(`.env still uses ${oldName} (renamed to ${newName})`);
+			}
+		}
 	}
 
 	return reasons;

package/src/env.js

@@ -2,6 +2,29 @@
 
 import { readFileSync, writeFileSync, existsSync } from 'node:fs';
 
+/**
+ * Old env name → its replacement, for keys renamed without changing meaning.
+ * The server still reads each old name for one minor version and warns at boot
+ * (`readRenamed` in `@selvajs/server` `resolveComputeLimits`); `selva doctor`
+ * reports them and `selva migrate` rewrites them. Keep in sync with that list,
+ * and drop an entry when the server stops reading it.
+ */
+export const RENAMED_ENV_VARS = {
+	COMPUTE_DEFINITION_BYTE_CACHE_MB: 'COMPUTE_DEFINITION_CACHE_MB',
+	COMPUTE_RESPONSE_CACHE_MB: 'COMPUTE_SOLVE_CACHE_MB',
+	DEFINITION_CACHE_TTL_MS: 'REMOTE_DEFINITION_CACHE_TTL_MS',
+	MAX_SOLVE_DURATION_MS: 'COMPUTE_SOLVE_DEADLINE_MS'
+};
+
+/**
+ * Deprecated vars whose replacement changes the VALUE too, so they can't be
+ * rewritten by renaming a key. `selva doctor` reports these; migrate leaves
+ * them alone rather than guessing.
+ */
+export const REPLACED_ENV_VARS = {
+	SELVA_FLAG_COMPUTE_DEBUG_VERBOSE: 'SELVA_FLAG_COMPUTE_DEBUG=verbose'
+};
+
 // Parse a .env file into { key: value }. Preserves nothing else.
 export function parseEnv(text) {
 	const out = {};
@@ -78,6 +101,48 @@ export function writeEnvFile(path, template, values) {
 	writeFileSync(path, mergeEnv(template, values), 'utf8');
 }
 
+/**
+ * Rewrite deprecated keys to their current names, in place. `renames` maps old
+ * name → new name. Only the key is touched — the value, comments, ordering and
+ * spacing survive, so an operator's tuned file stays recognisably theirs.
+ *
+ * A key already present under its new name is left alone and its old line is
+ * dropped: the server resolves the same way (new name wins), so keeping both
+ * would preserve a line that does nothing.
+ *
+ * Returns `{ text, changes }` where `changes` is `[oldName, newName, 'renamed'
+ * | 'dropped']` per line acted on; an empty array means the file was already
+ * current and nothing should be written.
+ */
+export function renameEnvKeys(text, renames) {
+	const present = new Set(Object.keys(parseEnv(text)));
+	const changes = [];
+	const out = [];
+
+	for (const line of text.split(/\r?\n/)) {
+		const stripped = line.trim();
+		const eq = stripped.indexOf('=');
+		if (!stripped || stripped.startsWith('#') || eq === -1) {
+			out.push(line);
+			continue;
+		}
+		const key = stripped.slice(0, eq).trim();
+		const newName = renames[key];
+		if (!newName) {
+			out.push(line);
+			continue;
+		}
+		if (present.has(newName)) {
+			changes.push([key, newName, 'dropped']);
+			continue;
+		}
+		out.push(line.replace(key, newName));
+		changes.push([key, newName, 'renamed']);
+	}
+
+	return { text: out.join('\n'), changes };
+}
+
 function quoteIfNeeded(value) {
 	const s = String(value);
 	if (s === '') return '""';