@doubledigit/cli 0.1.0 → 0.2.0

package/dist/lib/onboarding.js

@@ -1,28 +1,29 @@
-import fs from 'node:fs';
-import net from 'node:net';
-import os from 'node:os';
-import path from 'node:path';
-import { randomBytes } from 'node:crypto';
-import { execFileSync, spawn } from 'node:child_process';
-import { createRequire } from 'node:module';
-import { createInterface } from 'node:readline/promises';
-import { pathToFileURL } from 'node:url';
-export const DEFAULT_DATABASE_URL = 'postgresql://doubledigit:doubledigit@localhost:5432/doubledigit';
-export const DEFAULT_APP_URL = 'http://localhost:3000';
+import fs from "node:fs";
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+import { randomBytes } from "node:crypto";
+import { execFileSync, spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { createInterface } from "node:readline/promises";
+import { pathToFileURL } from "node:url";
+export const DEFAULT_DATABASE_URL = "postgresql://doubledigit:doubledigit@localhost:5432/doubledigit";
 export const DEFAULT_EMBEDDED_POSTGRES_PORT = 54329;
-export const DEFAULT_EMBEDDED_POSTGRES_INSTANCE_ID = 'default';
-export const DEFAULT_EMBEDDED_POSTGRES_HOME = path.join(os.homedir(), '.doubledigit');
-export const DEFAULT_EMBEDDED_POSTGRES_DATA_DIR = path.join(DEFAULT_EMBEDDED_POSTGRES_HOME, 'instances', DEFAULT_EMBEDDED_POSTGRES_INSTANCE_ID, 'db');
+export const DEFAULT_EMBEDDED_POSTGRES_INSTANCE_ID = "default";
+export const DEFAULT_EMBEDDED_POSTGRES_HOME = path.join(os.homedir(), ".doubledigit");
+export const DEFAULT_EMBEDDED_POSTGRES_DATA_DIR = path.join(DEFAULT_EMBEDDED_POSTGRES_HOME, "instances", DEFAULT_EMBEDDED_POSTGRES_INSTANCE_ID, "db");
 const DEFAULT_DOCKER_POSTGRES_PORT = 5432;
 const EMBEDDED_POSTGRES_LOOKAHEAD = 20;
-const EMBEDDED_POSTGRES_USER = 'doubledigit';
-const EMBEDDED_POSTGRES_PASSWORD = 'doubledigit';
-const EMBEDDED_POSTGRES_DATABASE = 'doubledigit';
+const EMBEDDED_POSTGRES_USER = "doubledigit";
+const EMBEDDED_POSTGRES_PASSWORD = "doubledigit";
+const EMBEDDED_POSTGRES_DATABASE = "doubledigit";
 const EMBEDDED_LOG_BUFFER_LIMIT = 40;
-const DEFAULT_APP_PORT = 3000;
+const DEFAULT_APP_PORT = 3111;
 const APP_PORT_LOOKAHEAD = 20;
 const INITIAL_DATABASE_URL = process.env.DATABASE_URL?.trim();
 const INITIAL_DATABASE_MODE = process.env.DD_DATABASE_MODE?.trim();
+const buildAppUrl = (port) => `http://localhost:${port}`;
+export const DEFAULT_APP_URL = buildAppUrl(DEFAULT_APP_PORT);
 /**
  * Snapshot of shell-originated environment at module load time.
  * Values present here must never be overwritten by .env file loading —
@@ -35,24 +36,24 @@ for (const key of Object.keys(process.env)) {
     }
 }
 const REQUIRED_ENV_KEYS = [
-    'DATABASE_URL',
-    'PAYLOAD_SECRET',
-    'BETTER_AUTH_SECRET',
-    'BETTER_AUTH_URL',
+    "DATABASE_URL",
+    "PAYLOAD_SECRET",
+    "BETTER_AUTH_SECRET",
+    "BETTER_AUTH_URL",
 ];
 export function getEnvPath(paths) {
-    return path.join(paths.mainAppDir, '.env');
+    return path.join(paths.mainAppDir, ".env");
 }
 export function getEnvExamplePath(paths) {
-    return path.join(paths.root, '.env.example');
+    return path.join(paths.root, ".env.example");
 }
 export function getGeneratedTypesPath(paths) {
-    return path.join(paths.root, 'packages', 'shared', 'src', 'types', 'payload-types.ts');
+    return path.join(paths.root, "packages", "shared", "src", "types", "payload-types.ts");
 }
 export function commandExists(command) {
-    const lookup = process.platform === 'win32' ? 'where' : 'which';
+    const lookup = process.platform === "win32" ? "where" : "which";
     try {
-        execFileSync(lookup, [command], { stdio: 'pipe' });
+        execFileSync(lookup, [command], { stdio: "pipe" });
         return true;
     }
     catch {
@@ -60,11 +61,11 @@ export function commandExists(command) {
     }
 }
 export function dockerAvailable() {
-    if (!commandExists('docker')) {
+    if (!commandExists("docker")) {
         return false;
     }
     try {
-        execFileSync('docker', ['info'], { stdio: 'pipe' });
+        execFileSync("docker", ["info"], { stdio: "pipe" });
         return true;
     }
     catch {
@@ -75,7 +76,7 @@ export function runChecked(command, args, cwd, label, envOverrides = {}) {
     try {
         execFileSync(command, args, {
             cwd,
-            stdio: 'inherit',
+            stdio: "inherit",
             env: {
                 ...process.env,
                 ...envOverrides,
@@ -90,8 +91,8 @@ export function captureCommand(command, args, cwd, envOverrides = {}) {
     try {
         const output = execFileSync(command, args, {
             cwd,
-            stdio: 'pipe',
-            encoding: 'utf8',
+            stdio: "pipe",
+            encoding: "utf8",
             env: {
                 ...process.env,
                 ...envOverrides,
@@ -100,15 +101,15 @@ export function captureCommand(command, args, cwd, envOverrides = {}) {
         return { ok: true, output };
     }
     catch (error) {
-        const stdout = typeof error.stdout === 'string'
+        const stdout = typeof error.stdout === "string"
             ? error.stdout
-            : '';
-        const stderr = typeof error.stderr === 'string'
+            : "";
+        const stderr = typeof error.stderr === "string"
             ? error.stderr
-            : '';
+            : "";
         return {
             ok: false,
-            output: [stdout, stderr].filter(Boolean).join('\n').trim(),
+            output: [stdout, stderr].filter(Boolean).join("\n").trim(),
         };
     }
 }
@@ -117,13 +118,13 @@ export function readEnvFile(filePath) {
         return {};
     }
     const result = {};
-    const content = fs.readFileSync(filePath, 'utf-8');
+    const content = fs.readFileSync(filePath, "utf-8");
     for (const line of content.split(/\r?\n/)) {
         const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#')) {
+        if (!trimmed || trimmed.startsWith("#")) {
             continue;
         }
-        const separator = trimmed.indexOf('=');
+        const separator = trimmed.indexOf("=");
         if (separator === -1) {
             continue;
         }
@@ -134,10 +135,10 @@ export function readEnvFile(filePath) {
     return result;
 }
 function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function upsertEnvValue(content, key, value) {
-    const pattern = new RegExp(`^${escapeRegExp(key)}=.*$`, 'm');
+    const pattern = new RegExp(`^${escapeRegExp(key)}=.*$`, "m");
     if (pattern.test(content)) {
         return content.replace(pattern, `${key}=${value}`);
     }
@@ -145,11 +146,11 @@ function upsertEnvValue(content, key, value) {
     return `${trimmed}\n${key}=${value}\n`;
 }
 function removeEnvValue(content, key) {
-    const pattern = new RegExp(`^${escapeRegExp(key)}=.*(?:\\r?\\n)?`, 'm');
-    return content.replace(pattern, '');
+    const pattern = new RegExp(`^${escapeRegExp(key)}=.*(?:\\r?\\n)?`, "m");
+    return content.replace(pattern, "");
 }
 function generateSecret() {
-    return randomBytes(32).toString('base64');
+    return randomBytes(32).toString("base64");
 }
 function buildManagedDatabaseUrl(port, database = EMBEDDED_POSTGRES_DATABASE) {
     return `postgresql://${EMBEDDED_POSTGRES_USER}:${EMBEDDED_POSTGRES_PASSWORD}@127.0.0.1:${port}/${database}`;
@@ -165,22 +166,25 @@ function parsePositiveInt(value) {
     return parsed;
 }
 function expandHomePrefix(value) {
-    if (value === '~') {
+    if (value === "~") {
         return os.homedir();
     }
-    if (value.startsWith('~/')) {
+    if (value.startsWith("~/")) {
         return path.resolve(os.homedir(), value.slice(2));
     }
     return value;
 }
 function resolveEmbeddedDataDir(env) {
-    return path.resolve(expandHomePrefix(env.DD_EMBEDDED_POSTGRES_DATA_DIR?.trim() || DEFAULT_EMBEDDED_POSTGRES_DATA_DIR));
+    return path.resolve(expandHomePrefix(env.DD_EMBEDDED_POSTGRES_DATA_DIR?.trim() ||
+        DEFAULT_EMBEDDED_POSTGRES_DATA_DIR));
 }
 function resolveEmbeddedPort(env) {
-    return parsePositiveInt(env.DD_EMBEDDED_POSTGRES_PORT) || DEFAULT_EMBEDDED_POSTGRES_PORT;
+    return (parsePositiveInt(env.DD_EMBEDDED_POSTGRES_PORT) ||
+        DEFAULT_EMBEDDED_POSTGRES_PORT);
 }
 function resolveDockerPort(env) {
-    return parsePositiveInt(env.DD_DOCKER_POSTGRES_PORT) || DEFAULT_DOCKER_POSTGRES_PORT;
+    return (parsePositiveInt(env.DD_DOCKER_POSTGRES_PORT) ||
+        DEFAULT_DOCKER_POSTGRES_PORT);
 }
 function applyEnvToProcess(env) {
     for (const [key, value] of Object.entries(env)) {
@@ -197,32 +201,32 @@ function isLegacyLocalDatabaseUrl(value) {
     return value?.trim() === DEFAULT_DATABASE_URL;
 }
 function isLoopbackHost(host) {
-    return host === '127.0.0.1' || host === 'localhost' || host === '::1';
+    return host === "127.0.0.1" || host === "localhost" || host === "::1";
 }
 function hasEmbeddedRuntimeHints(env) {
-    return Boolean(env.DD_EMBEDDED_POSTGRES_PORT?.trim()
-        || env.DD_EMBEDDED_POSTGRES_DATA_DIR?.trim());
+    return Boolean(env.DD_EMBEDDED_POSTGRES_PORT?.trim() ||
+        env.DD_EMBEDDED_POSTGRES_DATA_DIR?.trim());
 }
 function hasDockerRuntimeHints(env) {
-    return Boolean(env.DD_DATABASE_MODE?.trim() === 'docker'
-        || env.DD_DOCKER_POSTGRES_PORT?.trim());
+    return Boolean(env.DD_DATABASE_MODE?.trim() === "docker" ||
+        env.DD_DOCKER_POSTGRES_PORT?.trim());
 }
 function canonicalManagedDatabaseUrl(databaseUrl) {
     try {
         const url = new URL(databaseUrl);
-        if (url.protocol !== 'postgresql:' && url.protocol !== 'postgres:') {
+        if (url.protocol !== "postgresql:" && url.protocol !== "postgres:") {
             return undefined;
         }
         if (!isLoopbackHost(url.hostname) || url.search || url.hash) {
             return undefined;
         }
         const port = parsePositiveInt(url.port) || DEFAULT_DOCKER_POSTGRES_PORT;
-        const database = url.pathname.replace(/^\/+/, '');
+        const database = url.pathname.replace(/^\/+/, "");
         const username = decodeURIComponent(url.username);
         const password = decodeURIComponent(url.password);
-        if (username !== EMBEDDED_POSTGRES_USER
-            || password !== EMBEDDED_POSTGRES_PASSWORD
-            || database !== EMBEDDED_POSTGRES_DATABASE) {
+        if (username !== EMBEDDED_POSTGRES_USER ||
+            password !== EMBEDDED_POSTGRES_PASSWORD ||
+            database !== EMBEDDED_POSTGRES_DATABASE) {
             return undefined;
         }
         return buildManagedDatabaseUrl(port, database);
@@ -235,26 +239,28 @@ function isEmbeddedManagedDatabaseUrl(databaseUrl, env) {
     if (!databaseUrl || !hasEmbeddedRuntimeHints(env)) {
         return false;
     }
-    return canonicalManagedDatabaseUrl(databaseUrl) === buildManagedDatabaseUrl(resolveEmbeddedPort(env));
+    return (canonicalManagedDatabaseUrl(databaseUrl) ===
+        buildManagedDatabaseUrl(resolveEmbeddedPort(env)));
 }
 function isDockerManagedDatabaseUrl(databaseUrl, env) {
     if (!databaseUrl || !hasDockerRuntimeHints(env)) {
         return false;
     }
-    return canonicalManagedDatabaseUrl(databaseUrl) === buildManagedDatabaseUrl(resolveDockerPort(env));
+    return (canonicalManagedDatabaseUrl(databaseUrl) ===
+        buildManagedDatabaseUrl(resolveDockerPort(env)));
 }
 function hasExplicitExternalDatabaseUrl(databaseUrl, env) {
     const trimmed = databaseUrl?.trim();
-    return Boolean(trimmed
-        && !isLegacyLocalDatabaseUrl(trimmed)
-        && !isEmbeddedManagedDatabaseUrl(trimmed, env)
-        && !isDockerManagedDatabaseUrl(trimmed, env));
+    return Boolean(trimmed &&
+        !isLegacyLocalDatabaseUrl(trimmed) &&
+        !isEmbeddedManagedDatabaseUrl(trimmed, env) &&
+        !isDockerManagedDatabaseUrl(trimmed, env));
 }
 export function isPlaceholderValue(key, value) {
     if (!value) {
         return true;
     }
-    if (value.includes('change-me')) {
+    if (value.includes("change-me")) {
         return true;
     }
     return false;
@@ -271,52 +277,56 @@ export function ensureLocalEnv(paths, options = {}) {
         fs.copyFileSync(envExamplePath, envPath);
         created = true;
     }
-    let content = fs.readFileSync(envPath, 'utf-8');
+    let content = fs.readFileSync(envPath, "utf-8");
     const current = readEnvFile(envPath);
     const updates = {};
     const removals = new Set();
     const currentDatabaseMode = current.DD_DATABASE_MODE?.trim();
     const currentDatabaseUrl = current.DATABASE_URL?.trim();
-    if (!options.databaseMode && currentDatabaseMode === 'external') {
-        removals.add('DD_DATABASE_MODE');
-    }
-    if (!options.databaseUrl
-        && (isEmbeddedManagedDatabaseUrl(currentDatabaseUrl, current)
-            || isDockerManagedDatabaseUrl(currentDatabaseUrl, current))) {
-        removals.add('DATABASE_URL');
-    }
-    if (!options.databaseMode
-        && isEmbeddedManagedDatabaseUrl(current.DATABASE_URL, current)
-        && currentDatabaseMode !== 'embedded') {
-        updates.DD_DATABASE_MODE = 'embedded';
-    }
-    if (!options.databaseMode
-        && currentDatabaseMode
-        && currentDatabaseMode !== 'external'
-        && hasExplicitExternalDatabaseUrl(current.DATABASE_URL, current)) {
-        removals.add('DD_DATABASE_MODE');
-    }
-    const normalizedCurrentDatabaseMode = removals.has('DD_DATABASE_MODE')
+    if (!options.databaseMode && currentDatabaseMode === "external") {
+        removals.add("DD_DATABASE_MODE");
+    }
+    if (!options.databaseUrl &&
+        (isEmbeddedManagedDatabaseUrl(currentDatabaseUrl, current) ||
+            isDockerManagedDatabaseUrl(currentDatabaseUrl, current))) {
+        removals.add("DATABASE_URL");
+    }
+    if (!options.databaseMode &&
+        isEmbeddedManagedDatabaseUrl(current.DATABASE_URL, current) &&
+        currentDatabaseMode !== "embedded") {
+        updates.DD_DATABASE_MODE = "embedded";
+    }
+    if (!options.databaseMode &&
+        currentDatabaseMode &&
+        currentDatabaseMode !== "external" &&
+        hasExplicitExternalDatabaseUrl(current.DATABASE_URL, current)) {
+        removals.add("DD_DATABASE_MODE");
+    }
+    const normalizedCurrentDatabaseMode = removals.has("DD_DATABASE_MODE")
         ? undefined
         : currentDatabaseMode;
-    const effectiveDatabaseMode = options.databaseMode || updates.DD_DATABASE_MODE || normalizedCurrentDatabaseMode;
-    if (isPlaceholderValue('PAYLOAD_SECRET', current.PAYLOAD_SECRET)) {
+    const effectiveDatabaseMode = options.databaseMode ||
+        updates.DD_DATABASE_MODE ||
+        normalizedCurrentDatabaseMode;
+    if (isPlaceholderValue("PAYLOAD_SECRET", current.PAYLOAD_SECRET)) {
         updates.PAYLOAD_SECRET = generateSecret();
     }
-    if (isPlaceholderValue('BETTER_AUTH_SECRET', current.BETTER_AUTH_SECRET)) {
+    if (isPlaceholderValue("BETTER_AUTH_SECRET", current.BETTER_AUTH_SECRET)) {
         updates.BETTER_AUTH_SECRET = generateSecret();
     }
-    if (isPlaceholderValue('BETTER_AUTH_URL', current.BETTER_AUTH_URL)) {
+    if (isPlaceholderValue("BETTER_AUTH_URL", current.BETTER_AUTH_URL)) {
         updates.BETTER_AUTH_URL = DEFAULT_APP_URL;
     }
-    if (!effectiveDatabaseMode && (!current.DATABASE_URL?.trim() || isLegacyLocalDatabaseUrl(current.DATABASE_URL))) {
-        updates.DD_DATABASE_MODE = 'embedded';
+    if (!effectiveDatabaseMode &&
+        (!current.DATABASE_URL?.trim() ||
+            isLegacyLocalDatabaseUrl(current.DATABASE_URL))) {
+        updates.DD_DATABASE_MODE = "embedded";
     }
     if (options.databaseMode) {
         updates.DD_DATABASE_MODE = options.databaseMode;
     }
     const resolvedDatabaseMode = options.databaseMode || updates.DD_DATABASE_MODE || currentDatabaseMode;
-    if (resolvedDatabaseMode === 'embedded') {
+    if (resolvedDatabaseMode === "embedded") {
         if (options.embeddedPort) {
             updates.DD_EMBEDDED_POSTGRES_PORT = String(options.embeddedPort);
         }
@@ -327,10 +337,11 @@ export function ensureLocalEnv(paths, options = {}) {
             updates.DD_EMBEDDED_POSTGRES_DATA_DIR = options.embeddedDataDir;
         }
         else if (!current.DD_EMBEDDED_POSTGRES_DATA_DIR?.trim()) {
-            updates.DD_EMBEDDED_POSTGRES_DATA_DIR = DEFAULT_EMBEDDED_POSTGRES_DATA_DIR;
+            updates.DD_EMBEDDED_POSTGRES_DATA_DIR =
+                DEFAULT_EMBEDDED_POSTGRES_DATA_DIR;
         }
     }
-    if (resolvedDatabaseMode === 'docker') {
+    if (resolvedDatabaseMode === "docker") {
         if (options.dockerPort) {
             updates.DD_DOCKER_POSTGRES_PORT = String(options.dockerPort);
         }
@@ -347,8 +358,8 @@ export function ensureLocalEnv(paths, options = {}) {
     for (const [key, value] of Object.entries(updates)) {
         content = upsertEnvValue(content, key, value);
     }
-    if (Object.keys(updates).length > 0) {
-        fs.writeFileSync(envPath, content, 'utf-8');
+    if (Object.keys(updates).length > 0 || removals.size > 0) {
+        fs.writeFileSync(envPath, content, "utf-8");
     }
     const env = readEnvFile(envPath);
     applyEnvToProcess(env);
@@ -368,12 +379,12 @@ export function inspectLocalEnv(paths) {
     };
 }
 export function parseDatabaseUrl(databaseUrl) {
-    const normalized = databaseUrl.replace(/^postgres:\/\//, 'postgresql://');
+    const normalized = databaseUrl.replace(/^postgres:\/\//, "postgresql://");
     const parsed = new URL(normalized);
     return {
-        host: parsed.hostname || 'localhost',
+        host: parsed.hostname || "localhost",
         port: parsed.port ? Number(parsed.port) : 5432,
-        database: parsed.pathname.replace(/^\//, ''),
+        database: parsed.pathname.replace(/^\//, ""),
         username: parsed.username || undefined,
     };
 }
@@ -391,15 +402,15 @@ export async function checkDatabaseReachability(databaseUrl) {
             resolve(true);
         });
         socket.setTimeout(1500);
-        socket.on('error', () => resolve(false));
-        socket.on('timeout', () => {
+        socket.on("error", () => resolve(false));
+        socket.on("timeout", () => {
             socket.destroy();
             resolve(false);
         });
     });
 }
 export async function confirmYesNo(message) {
-    if (!process.stdin.isTTY || process.env.CI === 'true') {
+    if (!process.stdin.isTTY || process.env.CI === "true") {
         return true;
     }
     const rl = createInterface({
@@ -409,7 +420,7 @@ export async function confirmYesNo(message) {
     try {
         const answer = await rl.question(`${message} [Y/n] `);
         const normalized = answer.trim().toLowerCase();
-        return normalized === '' || normalized === 'y' || normalized === 'yes';
+        return normalized === "" || normalized === "y" || normalized === "yes";
     }
     finally {
         rl.close();
@@ -417,7 +428,17 @@ export async function confirmYesNo(message) {
 }
 export async function waitForDockerDatabase(paths, envOverrides = {}) {
     for (let attempt = 0; attempt < 30; attempt++) {
-        const result = captureCommand('docker', ['compose', 'exec', 'db', 'pg_isready', '-U', 'doubledigit', '-d', 'doubledigit', '-q'], paths.root, envOverrides);
+        const result = captureCommand("docker", [
+            "compose",
+            "exec",
+            "db",
+            "pg_isready",
+            "-U",
+            "doubledigit",
+            "-d",
+            "doubledigit",
+            "-q",
+        ], paths.root, envOverrides);
         if (result.ok) {
             return true;
         }
@@ -426,7 +447,8 @@ export async function waitForDockerDatabase(paths, envOverrides = {}) {
     return false;
 }
 export async function startDevServer(paths, envOverrides = {}) {
-    const preferredPort = parsePositiveInt(process.env.APP_PORT || envOverrides.APP_PORT) || DEFAULT_APP_PORT;
+    const preferredPort = parsePositiveInt(process.env.APP_PORT || envOverrides.APP_PORT) ||
+        DEFAULT_APP_PORT;
     let port;
     try {
         port = await findAvailablePort(preferredPort, APP_PORT_LOOKAHEAD);
@@ -437,44 +459,54 @@ export async function startDevServer(paths, envOverrides = {}) {
     if (port !== preferredPort) {
         console.log(`⚠  Port ${preferredPort} is busy — using port ${port} instead.`);
     }
-    const betterAuthUrl = `http://localhost:${port}`;
-    const child = spawn('pnpm', ['--dir', 'apps/main-app', 'exec', 'next', 'dev', '--turbo', '--port', String(port)], {
+    const betterAuthUrl = buildAppUrl(port);
+    const child = spawn("pnpm", [
+        "--dir",
+        "apps/main-app",
+        "exec",
+        "next",
+        "dev",
+        "--turbo",
+        "--port",
+        String(port),
+    ], {
         cwd: paths.root,
-        stdio: 'inherit',
+        stdio: "inherit",
         env: {
             ...process.env,
             ...envOverrides,
             PORT: String(port),
+            APP_PORT: String(port),
             BETTER_AUTH_URL: betterAuthUrl,
         },
-        shell: process.platform === 'win32',
+        shell: process.platform === "win32",
     });
-    child.on('exit', (code) => {
+    child.on("exit", (code) => {
         process.exit(code ?? 0);
     });
-    process.on('SIGINT', () => {
-        child.kill('SIGINT');
+    process.on("SIGINT", () => {
+        child.kill("SIGINT");
     });
-    process.on('SIGTERM', () => {
-        child.kill('SIGTERM');
+    process.on("SIGTERM", () => {
+        child.kill("SIGTERM");
     });
 }
 export function printNextSteps() {
-    console.log('\nNext steps:\n');
-    console.log('  pnpm dev');
-    console.log('  open http://localhost:3000');
-    console.log('  open http://localhost:3000/admin');
-    console.log('');
+    console.log("\n✅ Setup complete! Next steps:\n");
+    console.log("  pnpm dev              # start the development server");
+    console.log(`  open ${DEFAULT_APP_URL}`);
+    console.log(`  open ${buildAppUrl(DEFAULT_APP_PORT)}/admin`);
+    console.log("");
 }
 function createEmbeddedPostgresLogBuffer(limit = EMBEDDED_LOG_BUFFER_LIMIT) {
     const recentLogs = [];
     return {
         append(message) {
-            const text = typeof message === 'string'
+            const text = typeof message === "string"
                 ? message
                 : message instanceof Error
                     ? message.message
-                    : String(message ?? '');
+                    : String(message ?? "");
             for (const rawLine of text.split(/\r?\n/)) {
                 const line = rawLine.trim();
                 if (!line) {
@@ -499,29 +531,29 @@ function summarizeEmbeddedPostgresLogs(recentLogs) {
         .slice(-8)
         .map((line) => line.trim())
         .filter(Boolean)
-        .join(' | ');
+        .join(" | ");
 }
 function formatEmbeddedPostgresError(error, fallbackMessage, recentLogs) {
     const base = error instanceof Error
         ? error.message
         : `${fallbackMessage}: ${String(error ?? fallbackMessage)}`;
     const parts = [base];
-    const haystack = recentLogs.join('\n').toLowerCase();
-    if (haystack.includes('could not create shared memory segment')) {
-        parts.push('Embedded PostgreSQL could not allocate shared memory. Stop other local PostgreSQL servers or raise the host shared-memory limits, then retry.');
+    const haystack = recentLogs.join("\n").toLowerCase();
+    if (haystack.includes("could not create shared memory segment")) {
+        parts.push("Embedded PostgreSQL could not allocate shared memory. Stop other local PostgreSQL servers or raise the host shared-memory limits, then retry.");
     }
     const recentSummary = summarizeEmbeddedPostgresLogs(recentLogs);
     if (recentSummary) {
         parts.push(`Recent embedded Postgres logs: ${recentSummary}`);
     }
-    return new Error(parts.join(' '));
+    return new Error(parts.join(" "));
 }
 export function resolveDatabasePreference(env) {
     const shellDatabaseUrl = INITIAL_DATABASE_URL;
     if (shellDatabaseUrl) {
         return {
-            mode: 'external',
-            reason: 'DATABASE_URL',
+            mode: "external",
+            reason: "DATABASE_URL",
             databaseUrl: shellDatabaseUrl,
         };
     }
@@ -531,89 +563,94 @@ export function resolveDatabasePreference(env) {
     const configuredExternalDatabaseUrl = hasExplicitExternalDatabaseUrl(configuredDatabaseUrl, env);
     if (configuredExternalDatabaseUrl) {
         return {
-            mode: 'external',
-            reason: 'apps/main-app/.env',
+            mode: "external",
+            reason: "apps/main-app/.env",
             databaseUrl: configuredDatabaseUrl,
         };
     }
-    if (modeHint === 'external' && (configuredDatabaseUrl || INITIAL_DATABASE_MODE)) {
+    if (modeHint === "external" &&
+        (configuredDatabaseUrl || INITIAL_DATABASE_MODE)) {
         if (!INITIAL_DATABASE_MODE && embeddedManagedDatabaseUrl) {
             return {
-                mode: 'embedded',
-                reason: 'embedded-managed-url',
+                mode: "embedded",
+                reason: "embedded-managed-url",
                 databaseUrl: configuredDatabaseUrl,
             };
         }
         return {
-            mode: 'external',
-            reason: 'DD_DATABASE_MODE',
+            mode: "external",
+            reason: "DD_DATABASE_MODE",
             databaseUrl: configuredDatabaseUrl,
         };
     }
-    if (modeHint === 'docker') {
+    if (modeHint === "docker") {
         return {
-            mode: 'docker',
-            reason: 'DD_DATABASE_MODE',
-            databaseUrl: configuredDatabaseUrl || buildManagedDatabaseUrl(resolveDockerPort(env)),
+            mode: "docker",
+            reason: "DD_DATABASE_MODE",
+            databaseUrl: configuredDatabaseUrl ||
+                buildManagedDatabaseUrl(resolveDockerPort(env)),
         };
     }
-    if (modeHint === 'embedded') {
+    if (modeHint === "embedded") {
         return {
-            mode: 'embedded',
-            reason: 'DD_DATABASE_MODE',
-            databaseUrl: configuredDatabaseUrl || buildManagedDatabaseUrl(resolveEmbeddedPort(env)),
+            mode: "embedded",
+            reason: "DD_DATABASE_MODE",
+            databaseUrl: configuredDatabaseUrl ||
+                buildManagedDatabaseUrl(resolveEmbeddedPort(env)),
         };
     }
     if (embeddedManagedDatabaseUrl) {
         return {
-            mode: 'embedded',
-            reason: 'embedded-managed-url',
+            mode: "embedded",
+            reason: "embedded-managed-url",
             databaseUrl: configuredDatabaseUrl,
         };
     }
-    if (configuredDatabaseUrl && !isLegacyLocalDatabaseUrl(configuredDatabaseUrl)) {
+    if (configuredDatabaseUrl &&
+        !isLegacyLocalDatabaseUrl(configuredDatabaseUrl)) {
         return {
-            mode: 'external',
-            reason: 'apps/main-app/.env',
+            mode: "external",
+            reason: "apps/main-app/.env",
             databaseUrl: configuredDatabaseUrl,
         };
     }
     return {
-        mode: 'embedded',
-        reason: configuredDatabaseUrl ? 'legacy-default' : 'no-database-url',
-        databaseUrl: configuredDatabaseUrl || buildManagedDatabaseUrl(resolveEmbeddedPort(env)),
+        mode: "embedded",
+        reason: configuredDatabaseUrl ? "legacy-default" : "no-database-url",
+        databaseUrl: configuredDatabaseUrl ||
+            buildManagedDatabaseUrl(resolveEmbeddedPort(env)),
     };
 }
 function getEmbeddedPostgresPlatformPackageName() {
     switch (process.platform) {
-        case 'darwin':
-            if (process.arch === 'arm64') {
-                return '@embedded-postgres/darwin-arm64';
+        case "darwin":
+            if (process.arch === "arm64") {
+                return "@embedded-postgres/darwin-arm64";
             }
-            if (process.arch === 'x64') {
-                return '@embedded-postgres/darwin-x64';
+            if (process.arch === "x64") {
+                return "@embedded-postgres/darwin-x64";
             }
             break;
-        case 'linux':
-            if (process.arch === 'arm') {
-                return '@embedded-postgres/linux-arm';
+        case "linux":
+            if (process.arch === "arm") {
+                return "@embedded-postgres/linux-arm";
             }
-            if (process.arch === 'arm64') {
-                return '@embedded-postgres/linux-arm64';
+            if (process.arch === "arm64") {
+                return "@embedded-postgres/linux-arm64";
             }
-            if (process.arch === 'ia32') {
-                return '@embedded-postgres/linux-ia32';
+            if (process.arch === "ia32") {
+                return "@embedded-postgres/linux-ia32";
             }
-            if (process.arch === 'ppc64') {
-                return '@embedded-postgres/linux-ppc64';
+            if (process.arch === "ppc64") {
+                return "@embedded-postgres/linux-ppc64";
             }
-            if (process.arch === 'x64') {
-                return '@embedded-postgres/linux-x64';
+            if (process.arch === "x64") {
+                return "@embedded-postgres/linux-x64";
             }
             break;
-        case 'win32':
-            if (process.arch === 'x64') {
-                return '@embedded-postgres/windows-x64';
+        case "win32":
+            if (process.arch === "x64") {
+                return "@embedded-postgres/windows-x64";
             }
             break;
         default:
@@ -623,15 +660,15 @@ function getEmbeddedPostgresPlatformPackageName() {
 }
 function hydrateEmbeddedPostgresSymlinks() {
     const resolver = createRequire(import.meta.url);
-    const embeddedEntry = resolver.resolve('embedded-postgres');
+    const embeddedEntry = resolver.resolve("embedded-postgres");
     const embeddedRequire = createRequire(embeddedEntry);
     const packageEntryPath = embeddedRequire.resolve(getEmbeddedPostgresPlatformPackageName());
     const packageRoot = path.dirname(path.dirname(packageEntryPath));
-    const symlinkFile = path.join(packageRoot, 'native', 'pg-symlinks.json');
+    const symlinkFile = path.join(packageRoot, "native", "pg-symlinks.json");
     if (!fs.existsSync(symlinkFile)) {
         return;
     }
-    const symlinks = JSON.parse(fs.readFileSync(symlinkFile, 'utf8'));
+    const symlinks = JSON.parse(fs.readFileSync(symlinkFile, "utf8"));
     for (const { source, target } of symlinks) {
         const sourcePath = path.resolve(packageRoot, source);
         const targetPath = path.resolve(packageRoot, target);
@@ -646,11 +683,11 @@ function hydrateEmbeddedPostgresSymlinks() {
 async function loadEmbeddedPostgresBinaries() {
     hydrateEmbeddedPostgresSymlinks();
     const resolver = createRequire(import.meta.url);
-    const embeddedEntry = resolver.resolve('embedded-postgres');
+    const embeddedEntry = resolver.resolve("embedded-postgres");
     const embeddedRequire = createRequire(embeddedEntry);
     const packageEntryPath = embeddedRequire.resolve(getEmbeddedPostgresPlatformPackageName());
     const packageRoot = path.dirname(path.dirname(packageEntryPath));
-    const mod = await import(pathToFileURL(packageEntryPath).href);
+    const mod = (await import(pathToFileURL(packageEntryPath).href));
     return {
         packageRoot,
         initdb: mod.initdb,
@@ -659,8 +696,8 @@ async function loadEmbeddedPostgresBinaries() {
     };
 }
 async function createPgClient(connectionString) {
-    const pgMod = await import('pg');
-    const pg = 'default' in pgMod ? pgMod.default : pgMod;
+    const pgMod = await import("pg");
+    const pg = "default" in pgMod ? pgMod.default : pgMod;
     return new pg.Client({ connectionString });
 }
 function ensureExecutable(filePath) {
@@ -671,8 +708,10 @@ function ensureExecutable(filePath) {
     }
 }
 function createEmbeddedPasswordFile() {
-    const passwordFile = path.join(os.tmpdir(), `dd-embedded-postgres-${randomBytes(6).toString('hex')}.txt`);
-    fs.writeFileSync(passwordFile, `${EMBEDDED_POSTGRES_PASSWORD}\n`, { mode: 0o600 });
+    const passwordFile = path.join(os.tmpdir(), `dd-embedded-postgres-${randomBytes(6).toString("hex")}.txt`);
+    fs.writeFileSync(passwordFile, `${EMBEDDED_POSTGRES_PASSWORD}\n`, {
+        mode: 0o600,
+    });
     return passwordFile;
 }
 function appendEmbeddedOutput(logBuffer, output) {
@@ -681,9 +720,9 @@ function appendEmbeddedOutput(logBuffer, output) {
     }
 }
 function getEmbeddedPostgresLogPath(dataDir) {
-    const logsDir = path.join(path.dirname(dataDir), 'logs');
+    const logsDir = path.join(path.dirname(dataDir), "logs");
     fs.mkdirSync(logsDir, { recursive: true });
-    return path.join(logsDir, 'postgres.log');
+    return path.join(logsDir, "postgres.log");
 }
 async function getPostgresDataDirectory(connectionString) {
     const client = await createPgClient(connectionString);
@@ -691,7 +730,7 @@ async function getPostgresDataDirectory(connectionString) {
     try {
         const result = await client.query(`SELECT current_setting('data_directory') AS data_directory`);
         const dataDirectory = result.rows[0]?.data_directory;
-        return typeof dataDirectory === 'string' ? dataDirectory : null;
+        return typeof dataDirectory === "string" ? dataDirectory : null;
     }
     finally {
         await client.end().catch(() => undefined);
@@ -701,13 +740,13 @@ async function ensurePostgresDatabase(adminConnectionString, databaseName) {
     const client = await createPgClient(adminConnectionString);
     await client.connect();
     try {
-        const lookup = await client.query('SELECT 1 FROM pg_database WHERE datname = $1 LIMIT 1', [databaseName]);
+        const lookup = await client.query("SELECT 1 FROM pg_database WHERE datname = $1 LIMIT 1", [databaseName]);
         if (lookup.rowCount > 0) {
-            return 'existing';
+            return "existing";
         }
         const safeDatabaseName = databaseName.replace(/"/g, '""');
         await client.query(`CREATE DATABASE "${safeDatabaseName}"`);
-        return 'created';
+        return "created";
     }
     finally {
         await client.end().catch(() => undefined);
@@ -718,7 +757,7 @@ function readRunningPostmasterPid(postmasterPidFile) {
         return null;
     }
     try {
-        const pid = Number(fs.readFileSync(postmasterPidFile, 'utf8').split('\n')[0]?.trim());
+        const pid = Number(fs.readFileSync(postmasterPidFile, "utf8").split("\n")[0]?.trim());
         if (!Number.isInteger(pid) || pid <= 0) {
             return null;
         }
@@ -734,7 +773,7 @@ function readPostmasterPort(postmasterPidFile) {
         return null;
     }
     try {
-        const port = Number(fs.readFileSync(postmasterPidFile, 'utf8').split('\n')[3]?.trim());
+        const port = Number(fs.readFileSync(postmasterPidFile, "utf8").split("\n")[3]?.trim());
         return Number.isInteger(port) && port > 0 ? port : null;
     }
     catch {
@@ -745,10 +784,10 @@ async function isPortInUse(port) {
     return await new Promise((resolve) => {
         const server = net.createServer();
         server.unref();
-        server.once('error', (error) => {
-            resolve(error.code === 'EADDRINUSE');
+        server.once("error", (error) => {
+            resolve(error.code === "EADDRINUSE");
         });
-        server.listen(port, '127.0.0.1', () => {
+        server.listen(port, "127.0.0.1", () => {
             server.close();
             resolve(false);
         });
@@ -767,20 +806,21 @@ async function ensureEmbeddedDatabaseRuntime(env) {
     const binaries = await loadEmbeddedPostgresBinaries();
     const dataDir = resolveEmbeddedDataDir(env);
     const preferredPort = resolveEmbeddedPort(env);
-    const postmasterPidFile = path.join(dataDir, 'postmaster.pid');
-    const pgVersionFile = path.join(dataDir, 'PG_VERSION');
+    const postmasterPidFile = path.join(dataDir, "postmaster.pid");
+    const pgVersionFile = path.join(dataDir, "PG_VERSION");
     const runningPid = readRunningPostmasterPid(postmasterPidFile);
     const runningPort = readPostmasterPort(postmasterPidFile);
-    const adminUrl = buildManagedDatabaseUrl(preferredPort, 'postgres');
+    const adminUrl = buildManagedDatabaseUrl(preferredPort, "postgres");
     const logBuffer = createEmbeddedPostgresLogBuffer();
     fs.mkdirSync(path.dirname(dataDir), { recursive: true });
     if (!runningPid && fs.existsSync(pgVersionFile)) {
         try {
             const actualDataDir = await getPostgresDataDirectory(adminUrl);
-            if (actualDataDir && path.resolve(actualDataDir) === path.resolve(dataDir)) {
+            if (actualDataDir &&
+                path.resolve(actualDataDir) === path.resolve(dataDir)) {
                 await ensurePostgresDatabase(adminUrl, EMBEDDED_POSTGRES_DATABASE);
                 return {
-                    mode: 'embedded',
+                    mode: "embedded",
                     databaseUrl: buildManagedDatabaseUrl(preferredPort),
                     source: `embedded-postgres@${preferredPort}`,
                     reachable: true,
@@ -795,10 +835,10 @@ async function ensureEmbeddedDatabaseRuntime(env) {
     }
     if (runningPid) {
         const port = runningPort || preferredPort;
-        const runningAdminUrl = buildManagedDatabaseUrl(port, 'postgres');
+        const runningAdminUrl = buildManagedDatabaseUrl(port, "postgres");
         await ensurePostgresDatabase(runningAdminUrl, EMBEDDED_POSTGRES_DATABASE);
         return {
-            mode: 'embedded',
+            mode: "embedded",
             databaseUrl: buildManagedDatabaseUrl(port),
             source: `embedded-postgres@${port}`,
             reachable: true,
@@ -814,18 +854,18 @@ async function ensureEmbeddedDatabaseRuntime(env) {
         try {
             const initResult = captureCommand(binaries.initdb, [
                 `--pgdata=${dataDir}`,
-                '--auth=password',
+                "--auth=password",
                 `--username=${EMBEDDED_POSTGRES_USER}`,
                 `--pwfile=${passwordFile}`,
-                '--lc-messages=C',
-                '--encoding=UTF8',
-                '--locale=C',
+                "--lc-messages=C",
+                "--encoding=UTF8",
+                "--locale=C",
             ], binaries.packageRoot, {
-                LC_MESSAGES: 'C',
+                LC_MESSAGES: "C",
             });
             appendEmbeddedOutput(logBuffer, initResult.output);
             if (!initResult.ok) {
-                throw new Error(initResult.output || 'initdb failed');
+                throw new Error(initResult.output || "initdb failed");
             }
         }
         catch (error) {
@@ -840,23 +880,23 @@ async function ensureEmbeddedDatabaseRuntime(env) {
     }
     const logPath = getEmbeddedPostgresLogPath(dataDir);
     try {
-        const startResult = captureCommand(binaries.pgCtl, ['-D', dataDir, '-l', logPath, '-w', 'start', '-o', `-p ${selectedPort}`], binaries.packageRoot, {
-            LC_MESSAGES: 'C',
+        const startResult = captureCommand(binaries.pgCtl, ["-D", dataDir, "-l", logPath, "-w", "start", "-o", `-p ${selectedPort}`], binaries.packageRoot, {
+            LC_MESSAGES: "C",
         });
         appendEmbeddedOutput(logBuffer, startResult.output);
         if (fs.existsSync(logPath)) {
-            appendEmbeddedOutput(logBuffer, fs.readFileSync(logPath, 'utf8'));
+            appendEmbeddedOutput(logBuffer, fs.readFileSync(logPath, "utf8"));
         }
         if (!startResult.ok) {
-            throw new Error(startResult.output || 'pg_ctl start failed');
+            throw new Error(startResult.output || "pg_ctl start failed");
         }
     }
     catch (error) {
         throw formatEmbeddedPostgresError(error, `Failed to start embedded PostgreSQL on port ${selectedPort}`, logBuffer.getRecentLogs());
     }
-    await ensurePostgresDatabase(buildManagedDatabaseUrl(selectedPort, 'postgres'), EMBEDDED_POSTGRES_DATABASE);
+    await ensurePostgresDatabase(buildManagedDatabaseUrl(selectedPort, "postgres"), EMBEDDED_POSTGRES_DATABASE);
     return {
-        mode: 'embedded',
+        mode: "embedded",
         databaseUrl: buildManagedDatabaseUrl(selectedPort),
         source: `embedded-postgres@${selectedPort}`,
         reachable: true,
@@ -870,15 +910,15 @@ async function ensureDockerDatabaseRuntime(paths, env) {
     const envOverrides = {
         DB_PORT: String(selectedPort),
     };
-    runChecked('docker', ['compose', 'up', '-d', 'db'], paths.root, 'Docker db startup', envOverrides);
+    runChecked("docker", ["compose", "up", "-d", "db"], paths.root, "Docker db startup", envOverrides);
     const ready = await waitForDockerDatabase(paths, envOverrides);
     if (!ready) {
-        throw new Error('Docker PostgreSQL did not become ready in time.');
+        throw new Error("Docker PostgreSQL did not become ready in time.");
     }
     return {
-        mode: 'docker',
+        mode: "docker",
         databaseUrl: buildManagedDatabaseUrl(selectedPort),
-        source: 'docker-compose',
+        source: "docker-compose",
         reachable: true,
         dockerPort: selectedPort,
     };
@@ -898,25 +938,26 @@ export async function probeEmbeddedPostgresSupport() {
 export async function ensureDatabaseReady(paths, options = {}) {
     const env = readEnvFile(getEnvPath(paths));
     const preference = resolveDatabasePreference(env);
-    if (preference.mode === 'external') {
+    if (preference.mode === "external") {
         if (!preference.databaseUrl) {
-            throw new Error('DD_DATABASE_MODE=external requires DATABASE_URL to be set.');
+            throw new Error("DD_DATABASE_MODE=external requires DATABASE_URL to be set.");
         }
         const reachable = await checkDatabaseReachability(preference.databaseUrl);
         if (!reachable) {
-            throw new Error('Database is not reachable. Start PostgreSQL or update apps/main-app/.env first.');
+            throw new Error("Database is not reachable. Start PostgreSQL or update apps/main-app/.env first.");
         }
         return {
-            mode: 'external',
+            mode: "external",
             databaseUrl: preference.databaseUrl,
             source: preference.reason,
             reachable,
         };
     }
-    if (preference.mode === 'docker') {
-        if (preference.databaseUrl && await checkDatabaseReachability(preference.databaseUrl)) {
+    if (preference.mode === "docker") {
+        if (preference.databaseUrl &&
+            (await checkDatabaseReachability(preference.databaseUrl))) {
             return {
-                mode: 'docker',
+                mode: "docker",
                 databaseUrl: preference.databaseUrl,
                 source: preference.reason,
                 reachable: true,
@@ -924,17 +965,18 @@ export async function ensureDatabaseReady(paths, options = {}) {
             };
         }
         if (!dockerAvailable()) {
-            throw new Error('Docker is not available, so the configured Docker database cannot be started.');
+            throw new Error("Docker is not available, so the configured Docker database cannot be started.");
         }
         return ensureDockerDatabaseRuntime(paths, env);
     }
-    if (preference.databaseUrl && isLegacyLocalDatabaseUrl(preference.databaseUrl)) {
+    if (preference.databaseUrl &&
+        isLegacyLocalDatabaseUrl(preference.databaseUrl)) {
         const reachable = await checkDatabaseReachability(preference.databaseUrl);
         if (reachable) {
             return {
-                mode: 'external',
+                mode: "external",
                 databaseUrl: preference.databaseUrl,
-                source: 'legacy-localhost',
+                source: "legacy-localhost",
                 reachable: true,
             };
         }
@@ -946,7 +988,7 @@ export async function ensureDatabaseReady(paths, options = {}) {
         if (options.allowDockerFallback && dockerAvailable()) {
             const useDocker = options.yes
                 ? true
-                : await confirmYesNo('Embedded PostgreSQL failed. Start PostgreSQL via Docker instead?');
+                : await confirmYesNo("Embedded PostgreSQL failed. Start PostgreSQL via Docker instead?");
             if (useDocker) {
                 return ensureDockerDatabaseRuntime(paths, env);
             }
@@ -955,23 +997,23 @@ export async function ensureDatabaseReady(paths, options = {}) {
     }
 }
 export function localDependenciesInstalled(paths) {
-    return fs.existsSync(path.join(paths.root, 'packages', 'cli', 'node_modules', 'embedded-postgres'))
-        && fs.existsSync(path.join(paths.root, 'packages', 'cli', 'node_modules', 'pg'));
+    return (fs.existsSync(path.join(paths.root, "packages", "cli", "node_modules", "embedded-postgres")) &&
+        fs.existsSync(path.join(paths.root, "packages", "cli", "node_modules", "pg")));
 }
 export function databaseRuntimeToEnvOptions(runtime) {
     const options = {};
-    if (runtime.mode === 'embedded') {
+    if (runtime.mode === "embedded") {
         options.databaseMode = runtime.mode;
         options.embeddedDataDir = runtime.embeddedDataDir;
         options.embeddedPort = runtime.embeddedPort;
         return options;
     }
-    if (runtime.mode === 'docker') {
+    if (runtime.mode === "docker") {
         options.databaseMode = runtime.mode;
         options.dockerPort = runtime.dockerPort;
         return options;
     }
-    if (runtime.source !== 'DATABASE_URL') {
+    if (runtime.source !== "DATABASE_URL") {
         options.databaseUrl = runtime.databaseUrl;
     }
     return options;
@@ -989,15 +1031,18 @@ export function trimOutput(output, maxLines = 12) {
         .map((line) => line.trimEnd())
         .filter(Boolean);
     if (lines.length <= maxLines) {
-        return lines.join('\n');
+        return lines.join("\n");
     }
-    return lines.slice(-maxLines).join('\n');
+    return lines.slice(-maxLines).join("\n");
 }
 export function requiredEnvKeysMissing(env) {
     const databasePreference = resolveDatabasePreference(env);
     return REQUIRED_ENV_KEYS.filter((key) => {
-        if (key === 'DATABASE_URL') {
-            return !env[key] && databasePreference.mode !== 'embedded' && databasePreference.mode !== 'docker';
+        if (key === "DATABASE_URL") {
+            return (!env[key] &&
+                databasePreference.mode !== "embedded" &&
+                databasePreference.mode !== "docker" &&
+                databasePreference.reason !== "DATABASE_URL");
         }
         return !env[key];
     });