@doubledigit/cli 0.1.0

package/dist/lib/onboarding.js

@@ -0,0 +1,1004 @@
+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';
+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');
+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_LOG_BUFFER_LIMIT = 40;
+const DEFAULT_APP_PORT = 3000;
+const APP_PORT_LOOKAHEAD = 20;
+const INITIAL_DATABASE_URL = process.env.DATABASE_URL?.trim();
+const INITIAL_DATABASE_MODE = process.env.DD_DATABASE_MODE?.trim();
+/**
+ * Snapshot of shell-originated environment at module load time.
+ * Values present here must never be overwritten by .env file loading —
+ * explicit runtime env always wins over file-based defaults.
+ */
+const SHELL_ENV_SNAPSHOT = {};
+for (const key of Object.keys(process.env)) {
+    if (process.env[key] !== undefined) {
+        SHELL_ENV_SNAPSHOT[key] = process.env[key];
+    }
+}
+const REQUIRED_ENV_KEYS = [
+    'DATABASE_URL',
+    'PAYLOAD_SECRET',
+    'BETTER_AUTH_SECRET',
+    'BETTER_AUTH_URL',
+];
+export function getEnvPath(paths) {
+    return path.join(paths.mainAppDir, '.env');
+}
+export function getEnvExamplePath(paths) {
+    return path.join(paths.root, '.env.example');
+}
+export function getGeneratedTypesPath(paths) {
+    return path.join(paths.root, 'packages', 'shared', 'src', 'types', 'payload-types.ts');
+}
+export function commandExists(command) {
+    const lookup = process.platform === 'win32' ? 'where' : 'which';
+    try {
+        execFileSync(lookup, [command], { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function dockerAvailable() {
+    if (!commandExists('docker')) {
+        return false;
+    }
+    try {
+        execFileSync('docker', ['info'], { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function runChecked(command, args, cwd, label, envOverrides = {}) {
+    try {
+        execFileSync(command, args, {
+            cwd,
+            stdio: 'inherit',
+            env: {
+                ...process.env,
+                ...envOverrides,
+            },
+        });
+    }
+    catch {
+        throw new Error(`${label} failed.`);
+    }
+}
+export function captureCommand(command, args, cwd, envOverrides = {}) {
+    try {
+        const output = execFileSync(command, args, {
+            cwd,
+            stdio: 'pipe',
+            encoding: 'utf8',
+            env: {
+                ...process.env,
+                ...envOverrides,
+            },
+        });
+        return { ok: true, output };
+    }
+    catch (error) {
+        const stdout = typeof error.stdout === 'string'
+            ? error.stdout
+            : '';
+        const stderr = typeof error.stderr === 'string'
+            ? error.stderr
+            : '';
+        return {
+            ok: false,
+            output: [stdout, stderr].filter(Boolean).join('\n').trim(),
+        };
+    }
+}
+export function readEnvFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return {};
+    }
+    const result = {};
+    const content = fs.readFileSync(filePath, 'utf-8');
+    for (const line of content.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) {
+            continue;
+        }
+        const separator = trimmed.indexOf('=');
+        if (separator === -1) {
+            continue;
+        }
+        const key = trimmed.slice(0, separator).trim();
+        const value = trimmed.slice(separator + 1).trim();
+        result[key] = value;
+    }
+    return result;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function upsertEnvValue(content, key, value) {
+    const pattern = new RegExp(`^${escapeRegExp(key)}=.*$`, 'm');
+    if (pattern.test(content)) {
+        return content.replace(pattern, `${key}=${value}`);
+    }
+    const trimmed = content.trimEnd();
+    return `${trimmed}\n${key}=${value}\n`;
+}
+function removeEnvValue(content, key) {
+    const pattern = new RegExp(`^${escapeRegExp(key)}=.*(?:\\r?\\n)?`, 'm');
+    return content.replace(pattern, '');
+}
+function generateSecret() {
+    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}`;
+}
+function parsePositiveInt(value) {
+    if (!value?.trim()) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(value.trim(), 10);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        return undefined;
+    }
+    return parsed;
+}
+function expandHomePrefix(value) {
+    if (value === '~') {
+        return os.homedir();
+    }
+    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));
+}
+function resolveEmbeddedPort(env) {
+    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;
+}
+function applyEnvToProcess(env) {
+    for (const [key, value] of Object.entries(env)) {
+        // Never overwrite values that were explicitly set in the shell environment.
+        // Explicit runtime env (export DATABASE_URL=... / DATABASE_URL=... pnpm dev)
+        // must always take precedence over .env file values.
+        if (key in SHELL_ENV_SNAPSHOT) {
+            continue;
+        }
+        process.env[key] = value;
+    }
+}
+function isLegacyLocalDatabaseUrl(value) {
+    return value?.trim() === DEFAULT_DATABASE_URL;
+}
+function isLoopbackHost(host) {
+    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());
+}
+function hasDockerRuntimeHints(env) {
+    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:') {
+            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 username = decodeURIComponent(url.username);
+        const password = decodeURIComponent(url.password);
+        if (username !== EMBEDDED_POSTGRES_USER
+            || password !== EMBEDDED_POSTGRES_PASSWORD
+            || database !== EMBEDDED_POSTGRES_DATABASE) {
+            return undefined;
+        }
+        return buildManagedDatabaseUrl(port, database);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isEmbeddedManagedDatabaseUrl(databaseUrl, env) {
+    if (!databaseUrl || !hasEmbeddedRuntimeHints(env)) {
+        return false;
+    }
+    return canonicalManagedDatabaseUrl(databaseUrl) === buildManagedDatabaseUrl(resolveEmbeddedPort(env));
+}
+function isDockerManagedDatabaseUrl(databaseUrl, env) {
+    if (!databaseUrl || !hasDockerRuntimeHints(env)) {
+        return false;
+    }
+    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));
+}
+export function isPlaceholderValue(key, value) {
+    if (!value) {
+        return true;
+    }
+    if (value.includes('change-me')) {
+        return true;
+    }
+    return false;
+}
+export function ensureLocalEnv(paths, options = {}) {
+    const envPath = getEnvPath(paths);
+    const envExamplePath = getEnvExamplePath(paths);
+    let created = false;
+    if (!fs.existsSync(envPath)) {
+        if (!fs.existsSync(envExamplePath)) {
+            throw new Error(`Missing ${path.relative(paths.root, envExamplePath)}.`);
+        }
+        fs.mkdirSync(path.dirname(envPath), { recursive: true });
+        fs.copyFileSync(envExamplePath, envPath);
+        created = true;
+    }
+    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')
+        ? undefined
+        : currentDatabaseMode;
+    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)) {
+        updates.BETTER_AUTH_SECRET = generateSecret();
+    }
+    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 (options.databaseMode) {
+        updates.DD_DATABASE_MODE = options.databaseMode;
+    }
+    const resolvedDatabaseMode = options.databaseMode || updates.DD_DATABASE_MODE || currentDatabaseMode;
+    if (resolvedDatabaseMode === 'embedded') {
+        if (options.embeddedPort) {
+            updates.DD_EMBEDDED_POSTGRES_PORT = String(options.embeddedPort);
+        }
+        else if (!current.DD_EMBEDDED_POSTGRES_PORT?.trim()) {
+            updates.DD_EMBEDDED_POSTGRES_PORT = String(DEFAULT_EMBEDDED_POSTGRES_PORT);
+        }
+        if (options.embeddedDataDir) {
+            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;
+        }
+    }
+    if (resolvedDatabaseMode === 'docker') {
+        if (options.dockerPort) {
+            updates.DD_DOCKER_POSTGRES_PORT = String(options.dockerPort);
+        }
+        else if (!current.DD_DOCKER_POSTGRES_PORT?.trim()) {
+            updates.DD_DOCKER_POSTGRES_PORT = String(DEFAULT_DOCKER_POSTGRES_PORT);
+        }
+    }
+    if (options.databaseUrl) {
+        updates.DATABASE_URL = options.databaseUrl;
+    }
+    for (const key of removals) {
+        content = removeEnvValue(content, key);
+    }
+    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');
+    }
+    const env = readEnvFile(envPath);
+    applyEnvToProcess(env);
+    return {
+        envPath,
+        created,
+        updatedKeys: Object.keys(updates),
+        env,
+    };
+}
+export function inspectLocalEnv(paths) {
+    const envPath = getEnvPath(paths);
+    return {
+        envPath,
+        exists: fs.existsSync(envPath),
+        env: readEnvFile(envPath),
+    };
+}
+export function parseDatabaseUrl(databaseUrl) {
+    const normalized = databaseUrl.replace(/^postgres:\/\//, 'postgresql://');
+    const parsed = new URL(normalized);
+    return {
+        host: parsed.hostname || 'localhost',
+        port: parsed.port ? Number(parsed.port) : 5432,
+        database: parsed.pathname.replace(/^\//, ''),
+        username: parsed.username || undefined,
+    };
+}
+export async function checkDatabaseReachability(databaseUrl) {
+    let info;
+    try {
+        info = parseDatabaseUrl(databaseUrl);
+    }
+    catch {
+        return false;
+    }
+    return await new Promise((resolve) => {
+        const socket = net.createConnection({ host: info.host, port: info.port }, () => {
+            socket.end();
+            resolve(true);
+        });
+        socket.setTimeout(1500);
+        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') {
+        return true;
+    }
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = await rl.question(`${message} [Y/n] `);
+        const normalized = answer.trim().toLowerCase();
+        return normalized === '' || normalized === 'y' || normalized === 'yes';
+    }
+    finally {
+        rl.close();
+    }
+}
+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);
+        if (result.ok) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+    return false;
+}
+export async function startDevServer(paths, envOverrides = {}) {
+    const preferredPort = parsePositiveInt(process.env.APP_PORT || envOverrides.APP_PORT) || DEFAULT_APP_PORT;
+    let port;
+    try {
+        port = await findAvailablePort(preferredPort, APP_PORT_LOOKAHEAD);
+    }
+    catch {
+        throw new Error(`Could not find a free port starting from ${preferredPort}. Free a port or set APP_PORT=<port>.`);
+    }
+    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)], {
+        cwd: paths.root,
+        stdio: 'inherit',
+        env: {
+            ...process.env,
+            ...envOverrides,
+            PORT: String(port),
+            BETTER_AUTH_URL: betterAuthUrl,
+        },
+        shell: process.platform === 'win32',
+    });
+    child.on('exit', (code) => {
+        process.exit(code ?? 0);
+    });
+    process.on('SIGINT', () => {
+        child.kill('SIGINT');
+    });
+    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('');
+}
+function createEmbeddedPostgresLogBuffer(limit = EMBEDDED_LOG_BUFFER_LIMIT) {
+    const recentLogs = [];
+    return {
+        append(message) {
+            const text = typeof message === 'string'
+                ? message
+                : message instanceof Error
+                    ? message.message
+                    : String(message ?? '');
+            for (const rawLine of text.split(/\r?\n/)) {
+                const line = rawLine.trim();
+                if (!line) {
+                    continue;
+                }
+                recentLogs.push(line);
+                if (recentLogs.length > limit) {
+                    recentLogs.splice(0, recentLogs.length - limit);
+                }
+            }
+        },
+        getRecentLogs() {
+            return [...recentLogs];
+        },
+    };
+}
+function summarizeEmbeddedPostgresLogs(recentLogs) {
+    if (recentLogs.length === 0) {
+        return null;
+    }
+    return recentLogs
+        .slice(-8)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .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 recentSummary = summarizeEmbeddedPostgresLogs(recentLogs);
+    if (recentSummary) {
+        parts.push(`Recent embedded Postgres logs: ${recentSummary}`);
+    }
+    return new Error(parts.join(' '));
+}
+export function resolveDatabasePreference(env) {
+    const shellDatabaseUrl = INITIAL_DATABASE_URL;
+    if (shellDatabaseUrl) {
+        return {
+            mode: 'external',
+            reason: 'DATABASE_URL',
+            databaseUrl: shellDatabaseUrl,
+        };
+    }
+    const modeHint = INITIAL_DATABASE_MODE || env.DD_DATABASE_MODE?.trim();
+    const configuredDatabaseUrl = env.DATABASE_URL?.trim();
+    const embeddedManagedDatabaseUrl = isEmbeddedManagedDatabaseUrl(configuredDatabaseUrl, env);
+    const configuredExternalDatabaseUrl = hasExplicitExternalDatabaseUrl(configuredDatabaseUrl, env);
+    if (configuredExternalDatabaseUrl) {
+        return {
+            mode: 'external',
+            reason: 'apps/main-app/.env',
+            databaseUrl: configuredDatabaseUrl,
+        };
+    }
+    if (modeHint === 'external' && (configuredDatabaseUrl || INITIAL_DATABASE_MODE)) {
+        if (!INITIAL_DATABASE_MODE && embeddedManagedDatabaseUrl) {
+            return {
+                mode: 'embedded',
+                reason: 'embedded-managed-url',
+                databaseUrl: configuredDatabaseUrl,
+            };
+        }
+        return {
+            mode: 'external',
+            reason: 'DD_DATABASE_MODE',
+            databaseUrl: configuredDatabaseUrl,
+        };
+    }
+    if (modeHint === 'docker') {
+        return {
+            mode: 'docker',
+            reason: 'DD_DATABASE_MODE',
+            databaseUrl: configuredDatabaseUrl || buildManagedDatabaseUrl(resolveDockerPort(env)),
+        };
+    }
+    if (modeHint === 'embedded') {
+        return {
+            mode: 'embedded',
+            reason: 'DD_DATABASE_MODE',
+            databaseUrl: configuredDatabaseUrl || buildManagedDatabaseUrl(resolveEmbeddedPort(env)),
+        };
+    }
+    if (embeddedManagedDatabaseUrl) {
+        return {
+            mode: 'embedded',
+            reason: 'embedded-managed-url',
+            databaseUrl: configuredDatabaseUrl,
+        };
+    }
+    if (configuredDatabaseUrl && !isLegacyLocalDatabaseUrl(configuredDatabaseUrl)) {
+        return {
+            mode: 'external',
+            reason: 'apps/main-app/.env',
+            databaseUrl: configuredDatabaseUrl,
+        };
+    }
+    return {
+        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';
+            }
+            if (process.arch === 'x64') {
+                return '@embedded-postgres/darwin-x64';
+            }
+            break;
+        case 'linux':
+            if (process.arch === 'arm') {
+                return '@embedded-postgres/linux-arm';
+            }
+            if (process.arch === 'arm64') {
+                return '@embedded-postgres/linux-arm64';
+            }
+            if (process.arch === 'ia32') {
+                return '@embedded-postgres/linux-ia32';
+            }
+            if (process.arch === 'ppc64') {
+                return '@embedded-postgres/linux-ppc64';
+            }
+            if (process.arch === 'x64') {
+                return '@embedded-postgres/linux-x64';
+            }
+            break;
+        case 'win32':
+            if (process.arch === 'x64') {
+                return '@embedded-postgres/windows-x64';
+            }
+            break;
+        default:
+            break;
+    }
+    throw new Error(`Embedded PostgreSQL is not supported on ${process.platform}/${process.arch}.`);
+}
+function hydrateEmbeddedPostgresSymlinks() {
+    const resolver = createRequire(import.meta.url);
+    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');
+    if (!fs.existsSync(symlinkFile)) {
+        return;
+    }
+    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);
+        if (fs.existsSync(targetPath)) {
+            continue;
+        }
+        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+        const relativeSource = path.relative(path.dirname(targetPath), sourcePath);
+        fs.symlinkSync(relativeSource, targetPath);
+    }
+}
+async function loadEmbeddedPostgresBinaries() {
+    hydrateEmbeddedPostgresSymlinks();
+    const resolver = createRequire(import.meta.url);
+    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);
+    return {
+        packageRoot,
+        initdb: mod.initdb,
+        pgCtl: mod.pg_ctl,
+        postgres: mod.postgres,
+    };
+}
+async function createPgClient(connectionString) {
+    const pgMod = await import('pg');
+    const pg = 'default' in pgMod ? pgMod.default : pgMod;
+    return new pg.Client({ connectionString });
+}
+function ensureExecutable(filePath) {
+    const executableBits = 0o555;
+    const stat = fs.statSync(filePath);
+    if ((stat.mode & executableBits) !== executableBits) {
+        fs.chmodSync(filePath, stat.mode | executableBits);
+    }
+}
+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 });
+    return passwordFile;
+}
+function appendEmbeddedOutput(logBuffer, output) {
+    if (output.trim()) {
+        logBuffer.append(output);
+    }
+}
+function getEmbeddedPostgresLogPath(dataDir) {
+    const logsDir = path.join(path.dirname(dataDir), 'logs');
+    fs.mkdirSync(logsDir, { recursive: true });
+    return path.join(logsDir, 'postgres.log');
+}
+async function getPostgresDataDirectory(connectionString) {
+    const client = await createPgClient(connectionString);
+    await client.connect();
+    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;
+    }
+    finally {
+        await client.end().catch(() => undefined);
+    }
+}
+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]);
+        if (lookup.rowCount > 0) {
+            return 'existing';
+        }
+        const safeDatabaseName = databaseName.replace(/"/g, '""');
+        await client.query(`CREATE DATABASE "${safeDatabaseName}"`);
+        return 'created';
+    }
+    finally {
+        await client.end().catch(() => undefined);
+    }
+}
+function readRunningPostmasterPid(postmasterPidFile) {
+    if (!fs.existsSync(postmasterPidFile)) {
+        return null;
+    }
+    try {
+        const pid = Number(fs.readFileSync(postmasterPidFile, 'utf8').split('\n')[0]?.trim());
+        if (!Number.isInteger(pid) || pid <= 0) {
+            return null;
+        }
+        process.kill(pid, 0);
+        return pid;
+    }
+    catch {
+        return null;
+    }
+}
+function readPostmasterPort(postmasterPidFile) {
+    if (!fs.existsSync(postmasterPidFile)) {
+        return null;
+    }
+    try {
+        const port = Number(fs.readFileSync(postmasterPidFile, 'utf8').split('\n')[3]?.trim());
+        return Number.isInteger(port) && port > 0 ? port : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function isPortInUse(port) {
+    return await new Promise((resolve) => {
+        const server = net.createServer();
+        server.unref();
+        server.once('error', (error) => {
+            resolve(error.code === 'EADDRINUSE');
+        });
+        server.listen(port, '127.0.0.1', () => {
+            server.close();
+            resolve(false);
+        });
+    });
+}
+async function findAvailablePort(startPort, lookahead = EMBEDDED_POSTGRES_LOOKAHEAD) {
+    let port = startPort;
+    for (let attempt = 0; attempt < lookahead; attempt += 1, port += 1) {
+        if (!(await isPortInUse(port))) {
+            return port;
+        }
+    }
+    throw new Error(`Could not find a free local port from ${startPort} to ${startPort + lookahead - 1}.`);
+}
+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 runningPid = readRunningPostmasterPid(postmasterPidFile);
+    const runningPort = readPostmasterPort(postmasterPidFile);
+    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)) {
+                await ensurePostgresDatabase(adminUrl, EMBEDDED_POSTGRES_DATABASE);
+                return {
+                    mode: 'embedded',
+                    databaseUrl: buildManagedDatabaseUrl(preferredPort),
+                    source: `embedded-postgres@${preferredPort}`,
+                    reachable: true,
+                    embeddedDataDir: dataDir,
+                    embeddedPort: preferredPort,
+                };
+            }
+        }
+        catch {
+            // Fall through to a managed embedded start.
+        }
+    }
+    if (runningPid) {
+        const port = runningPort || preferredPort;
+        const runningAdminUrl = buildManagedDatabaseUrl(port, 'postgres');
+        await ensurePostgresDatabase(runningAdminUrl, EMBEDDED_POSTGRES_DATABASE);
+        return {
+            mode: 'embedded',
+            databaseUrl: buildManagedDatabaseUrl(port),
+            source: `embedded-postgres@${port}`,
+            reachable: true,
+            embeddedDataDir: dataDir,
+            embeddedPort: port,
+        };
+    }
+    const selectedPort = await findAvailablePort(preferredPort);
+    ensureExecutable(binaries.initdb);
+    ensureExecutable(binaries.pgCtl);
+    if (!fs.existsSync(pgVersionFile)) {
+        const passwordFile = createEmbeddedPasswordFile();
+        try {
+            const initResult = captureCommand(binaries.initdb, [
+                `--pgdata=${dataDir}`,
+                '--auth=password',
+                `--username=${EMBEDDED_POSTGRES_USER}`,
+                `--pwfile=${passwordFile}`,
+                '--lc-messages=C',
+                '--encoding=UTF8',
+                '--locale=C',
+            ], binaries.packageRoot, {
+                LC_MESSAGES: 'C',
+            });
+            appendEmbeddedOutput(logBuffer, initResult.output);
+            if (!initResult.ok) {
+                throw new Error(initResult.output || 'initdb failed');
+            }
+        }
+        catch (error) {
+            throw formatEmbeddedPostgresError(error, `Failed to initialize embedded PostgreSQL in ${dataDir}`, logBuffer.getRecentLogs());
+        }
+        finally {
+            fs.rmSync(passwordFile, { force: true });
+        }
+    }
+    if (fs.existsSync(postmasterPidFile)) {
+        fs.rmSync(postmasterPidFile, { force: true });
+    }
+    const logPath = getEmbeddedPostgresLogPath(dataDir);
+    try {
+        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'));
+        }
+        if (!startResult.ok) {
+            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);
+    return {
+        mode: 'embedded',
+        databaseUrl: buildManagedDatabaseUrl(selectedPort),
+        source: `embedded-postgres@${selectedPort}`,
+        reachable: true,
+        embeddedDataDir: dataDir,
+        embeddedPort: selectedPort,
+    };
+}
+async function ensureDockerDatabaseRuntime(paths, env) {
+    const desiredPort = resolveDockerPort(env);
+    const selectedPort = await findAvailablePort(desiredPort);
+    const envOverrides = {
+        DB_PORT: String(selectedPort),
+    };
+    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.');
+    }
+    return {
+        mode: 'docker',
+        databaseUrl: buildManagedDatabaseUrl(selectedPort),
+        source: 'docker-compose',
+        reachable: true,
+        dockerPort: selectedPort,
+    };
+}
+export async function probeEmbeddedPostgresSupport() {
+    try {
+        await loadEmbeddedPostgresBinaries();
+        return { supported: true };
+    }
+    catch (error) {
+        return {
+            supported: false,
+            reason: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export async function ensureDatabaseReady(paths, options = {}) {
+    const env = readEnvFile(getEnvPath(paths));
+    const preference = resolveDatabasePreference(env);
+    if (preference.mode === 'external') {
+        if (!preference.databaseUrl) {
+            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.');
+        }
+        return {
+            mode: 'external',
+            databaseUrl: preference.databaseUrl,
+            source: preference.reason,
+            reachable,
+        };
+    }
+    if (preference.mode === 'docker') {
+        if (preference.databaseUrl && await checkDatabaseReachability(preference.databaseUrl)) {
+            return {
+                mode: 'docker',
+                databaseUrl: preference.databaseUrl,
+                source: preference.reason,
+                reachable: true,
+                dockerPort: resolveDockerPort(env),
+            };
+        }
+        if (!dockerAvailable()) {
+            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)) {
+        const reachable = await checkDatabaseReachability(preference.databaseUrl);
+        if (reachable) {
+            return {
+                mode: 'external',
+                databaseUrl: preference.databaseUrl,
+                source: 'legacy-localhost',
+                reachable: true,
+            };
+        }
+    }
+    try {
+        return await ensureEmbeddedDatabaseRuntime(env);
+    }
+    catch (error) {
+        if (options.allowDockerFallback && dockerAvailable()) {
+            const useDocker = options.yes
+                ? true
+                : await confirmYesNo('Embedded PostgreSQL failed. Start PostgreSQL via Docker instead?');
+            if (useDocker) {
+                return ensureDockerDatabaseRuntime(paths, env);
+            }
+        }
+        throw error;
+    }
+}
+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'));
+}
+export function databaseRuntimeToEnvOptions(runtime) {
+    const options = {};
+    if (runtime.mode === 'embedded') {
+        options.databaseMode = runtime.mode;
+        options.embeddedDataDir = runtime.embeddedDataDir;
+        options.embeddedPort = runtime.embeddedPort;
+        return options;
+    }
+    if (runtime.mode === 'docker') {
+        options.databaseMode = runtime.mode;
+        options.dockerPort = runtime.dockerPort;
+        return options;
+    }
+    if (runtime.source !== 'DATABASE_URL') {
+        options.databaseUrl = runtime.databaseUrl;
+    }
+    return options;
+}
+export function applyRuntimeDatabaseUrl(env, runtime) {
+    process.env.DATABASE_URL = runtime.databaseUrl;
+    return {
+        ...env,
+        DATABASE_URL: runtime.databaseUrl,
+    };
+}
+export function trimOutput(output, maxLines = 12) {
+    const lines = output
+        .split(/\r?\n/)
+        .map((line) => line.trimEnd())
+        .filter(Boolean);
+    if (lines.length <= maxLines) {
+        return lines.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';
+        }
+        return !env[key];
+    });
+}