@openfactu/cli 0.0.6 → 0.0.8

package/dist/src/commands/sync-ports.js

@@ -0,0 +1,298 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSyncPortsCommand = registerSyncPortsCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../utils/logger");
+const paths_1 = require("../utils/paths");
+function readEnv(envPath) {
+    const env = {};
+    if (!fs_1.default.existsSync(envPath))
+        return env;
+    const lines = fs_1.default.readFileSync(envPath, 'utf-8').split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const eqIdx = trimmed.indexOf('=');
+        if (eqIdx > 0) {
+            env[trimmed.substring(0, eqIdx).trim()] = trimmed.substring(eqIdx + 1).trim();
+        }
+    }
+    return env;
+}
+function writeEnv(envPath, env) {
+    const lines = [];
+    for (const [key, value] of Object.entries(env)) {
+        lines.push(`${key}=${value}`);
+    }
+    fs_1.default.writeFileSync(envPath, lines.join('\n') + '\n');
+}
+function extractPortsFromCompose(composeContent) {
+    const ports = {};
+    const portRegex = /"([^"]*):(\d+)"|-\s*"(\d+):(\d+)"/g;
+    let match;
+    while ((match = portRegex.exec(composeContent)) !== null) {
+        const hostPort = match[2] || match[3];
+        const containerPort = match[4] || '';
+        if (hostPort) {
+            const portNum = parseInt(hostPort);
+            if (containerPort) {
+                const containerNum = parseInt(containerPort);
+                if (containerNum === 5432)
+                    ports.DB_PORT = portNum;
+                if (containerNum === 3000)
+                    ports.SERVER_PORT = portNum;
+                if (containerNum === 80)
+                    ports.WEB_PORT = portNum;
+                if (containerNum === 443)
+                    ports.HTTPS_PORT = portNum;
+            }
+            else {
+                if (portNum === 5432 || portNum === 5433)
+                    ports.DB_PORT = portNum;
+                if (portNum === 3000 || portNum === 3001)
+                    ports.SERVER_PORT = portNum;
+                if (portNum === 8080 || portNum === 8081)
+                    ports.WEB_PORT = portNum;
+            }
+        }
+    }
+    return ports;
+}
+function updateComposePorts(composePath, ports) {
+    if (!fs_1.default.existsSync(composePath))
+        return false;
+    let content = fs_1.default.readFileSync(composePath, 'utf-8');
+    let changed = false;
+    const portMappings = {
+        '5432': { container: 5432, envKey: 'DB_PORT' },
+        '3000': { container: 3000, envKey: 'SERVER_PORT' },
+        '80': { container: 80, envKey: 'WEB_PORT' },
+    };
+    for (const [containerPort, { envKey }] of Object.entries(portMappings)) {
+        const newPort = ports[envKey];
+        if (!newPort)
+            continue;
+        const containerNum = parseInt(containerPort);
+        // Pattern: "hostPort:containerPort"
+        const pattern1 = new RegExp(`"([^"]*):${containerNum}"`, 'g');
+        const match1 = content.match(pattern1);
+        if (match1) {
+            content = content.replace(pattern1, `"${newPort}:${containerNum}"`);
+            changed = true;
+        }
+        // Pattern: - "hostPort:containerPort"
+        const pattern2 = new RegExp(`-\\s*"([^"]*):${containerNum}"`, 'g');
+        const match2 = content.match(pattern2);
+        if (match2) {
+            content = content.replace(pattern2, `- "${newPort}:${containerNum}"`);
+            changed = true;
+        }
+        // Pattern: - "0.0.0.0:hostPort:containerPort"
+        const pattern3 = new RegExp(`-\\s*"0\\.0\\.0\\.0:([^:]*):${containerNum}"`, 'g');
+        const match3 = content.match(pattern3);
+        if (match3) {
+            content = content.replace(pattern3, `- "0.0.0.0:${newPort}:${containerNum}"`);
+            changed = true;
+        }
+        // Pattern: - "127.0.0.1:hostPort:containerPort"
+        const pattern4 = new RegExp(`-\\s*"127\\.0\\.0\\.1:([^:]*):${containerNum}"`, 'g');
+        const match4 = content.match(pattern4);
+        if (match4) {
+            content = content.replace(pattern4, `- "127.0.0.1:${newPort}:${containerNum}"`);
+            changed = true;
+        }
+    }
+    if (changed) {
+        fs_1.default.writeFileSync(composePath, content);
+    }
+    return changed;
+}
+function registerSyncPortsCommand(program) {
+    const syncCmd = program
+        .command('sync:ports')
+        .description('Sincroniza puertos entre .env y docker-compose files');
+    syncCmd
+        .command('env-to-compose')
+        .description('Copia puertos del .env a los docker-compose files')
+        .option('--path <path>', 'Ruta del proyecto')
+        .action(async (opts) => {
+        console.log();
+        console.log(chalk_1.default.bold.white('  OpenFactu — Sync Puertos (.env → compose)'));
+        console.log(chalk_1.default.dim('  ────────────────────────────────────'));
+        console.log();
+        try {
+            const root = opts.path || (0, paths_1.getProjectRoot)();
+            const envPath = path_1.default.join(root, '.env');
+            const env = readEnv(envPath);
+            const ports = {};
+            if (env.DB_PORT)
+                ports.DB_PORT = parseInt(env.DB_PORT);
+            if (env.SERVER_PORT)
+                ports.SERVER_PORT = parseInt(env.SERVER_PORT);
+            if (env.WEB_PORT)
+                ports.WEB_PORT = parseInt(env.WEB_PORT);
+            if (Object.keys(ports).length === 0) {
+                logger_1.log.warn('No se encontraron puertos en .env');
+                return;
+            }
+            logger_1.log.info('Puertos en .env:');
+            for (const [key, value] of Object.entries(ports)) {
+                logger_1.log.info(`  ${key}: ${value}`);
+            }
+            logger_1.log.blank();
+            const composeFiles = [
+                'docker-compose.yml',
+                'docker-compose.prod.yml',
+            ];
+            for (const composeFile of composeFiles) {
+                const composePath = path_1.default.join(root, composeFile);
+                if (fs_1.default.existsSync(composePath)) {
+                    const spinner = (0, ora_1.default)(`Actualizando ${composeFile}...`).start();
+                    const changed = updateComposePorts(composePath, ports);
+                    if (changed) {
+                        spinner.succeed(`${composeFile} actualizado`);
+                    }
+                    else {
+                        spinner.info(`${composeFile} no necesita cambios`);
+                    }
+                }
+            }
+            logger_1.log.blank();
+            logger_1.log.success('Sincronización completada');
+            logger_1.log.dim('  Reinicia los servicios con: docker compose up -d');
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+        }
+    });
+    syncCmd
+        .command('compose-to-env')
+        .description('Copia puertos de docker-compose al .env')
+        .option('--path <path>', 'Ruta del proyecto')
+        .action(async (opts) => {
+        console.log();
+        console.log(chalk_1.default.bold.white('  OpenFactu — Sync Puertos (compose → .env)'));
+        console.log(chalk_1.default.dim('  ────────────────────────────────────'));
+        console.log();
+        try {
+            const root = opts.path || (0, paths_1.getProjectRoot)();
+            const envPath = path_1.default.join(root, '.env');
+            const env = readEnv(envPath);
+            const composeFiles = [
+                'docker-compose.prod.yml',
+                'docker-compose.yml',
+            ];
+            let foundPorts = {};
+            for (const composeFile of composeFiles) {
+                const composePath = path_1.default.join(root, composeFile);
+                if (fs_1.default.existsSync(composePath)) {
+                    const content = fs_1.default.readFileSync(composePath, 'utf-8');
+                    const ports = extractPortsFromCompose(content);
+                    foundPorts = { ...foundPorts, ...ports };
+                }
+            }
+            if (Object.keys(foundPorts).length === 0) {
+                logger_1.log.warn('No se encontraron puertos en docker-compose files');
+                return;
+            }
+            logger_1.log.info('Puertos detectados en compose:');
+            for (const [key, value] of Object.entries(foundPorts)) {
+                const oldVal = env[key];
+                const marker = oldVal && parseInt(oldVal) !== value ? chalk_1.default.yellow(' (cambiado)') : '';
+                logger_1.log.info(`  ${key}: ${value}${marker}`);
+            }
+            logger_1.log.blank();
+            const { confirm } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: 'Actualizar .env con estos puertos?',
+                    default: true,
+                },
+            ]);
+            if (!confirm) {
+                logger_1.log.info('Cancelado');
+                return;
+            }
+            for (const [key, value] of Object.entries(foundPorts)) {
+                env[key] = String(value);
+            }
+            writeEnv(envPath, env);
+            logger_1.log.success('.env actualizado');
+            logger_1.log.dim('  Reinicia los servicios con: docker compose up -d');
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+        }
+    });
+    syncCmd
+        .command('check')
+        .description('Verifica si hay diferencias de puertos entre .env y compose')
+        .option('--path <path>', 'Ruta del proyecto')
+        .action(async (opts) => {
+        try {
+            const root = opts.path || (0, paths_1.getProjectRoot)();
+            const envPath = path_1.default.join(root, '.env');
+            const env = readEnv(envPath);
+            const composeFiles = [
+                'docker-compose.prod.yml',
+                'docker-compose.yml',
+            ];
+            let composePorts = {};
+            for (const composeFile of composeFiles) {
+                const composePath = path_1.default.join(root, composeFile);
+                if (fs_1.default.existsSync(composePath)) {
+                    const content = fs_1.default.readFileSync(composePath, 'utf-8');
+                    composePorts = { ...composePorts, ...extractPortsFromCompose(content) };
+                }
+            }
+            const envPorts = {};
+            if (env.DB_PORT)
+                envPorts.DB_PORT = parseInt(env.DB_PORT);
+            if (env.SERVER_PORT)
+                envPorts.SERVER_PORT = parseInt(env.SERVER_PORT);
+            if (env.WEB_PORT)
+                envPorts.WEB_PORT = parseInt(env.WEB_PORT);
+            logger_1.log.blank();
+            logger_1.log.info('Comparación de puertos:');
+            logger_1.log.blank();
+            const allKeys = [...new Set([...Object.keys(envPorts), ...Object.keys(composePorts)])];
+            let hasDifferences = false;
+            for (const key of allKeys.sort()) {
+                const envVal = envPorts[key];
+                const composeVal = composePorts[key];
+                if (envVal && composeVal && envVal !== composeVal) {
+                    logger_1.log.warn(`  ${key}: .env=${envVal} | compose=${composeVal} ${chalk_1.default.red('← DIFERENTE')}`);
+                    hasDifferences = true;
+                }
+                else if (envVal) {
+                    logger_1.log.info(`  ${key}: ${envVal} ${chalk_1.default.dim('(solo en .env)')}`);
+                }
+                else if (composeVal) {
+                    logger_1.log.info(`  ${key}: ${composeVal} ${chalk_1.default.dim('(solo en compose)')}`);
+                }
+            }
+            logger_1.log.blank();
+            if (!hasDifferences) {
+                logger_1.log.success('Todos los puertos están sincronizados');
+            }
+            else {
+                logger_1.log.warn('Hay diferencias. Usa uno de estos comandos para sincronizar:');
+                logger_1.log.dim('  openfactu sync:ports env-to-compose');
+                logger_1.log.dim('  openfactu sync:ports compose-to-env');
+            }
+            logger_1.log.blank();
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+        }
+    });
+}

package/dist/src/commands/uninstall.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerUninstallCommand(program: Command): void;

package/dist/src/commands/uninstall.js

@@ -0,0 +1,189 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerUninstallCommand = registerUninstallCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const logger_1 = require("../utils/logger");
+const paths_1 = require("../utils/paths");
+const helpers_1 = require("../utils/helpers");
+function registerUninstallCommand(program) {
+    program
+        .command('uninstall')
+        .description('Desinstalar OpenFactu de forma limpia')
+        .option('--path <path>', 'Ruta del proyecto a desinstalar')
+        .option('--force', 'No preguntar confirmacion')
+        .option('--keep-data', 'Mantener datos (BD, storage, configs)')
+        .option('--keep-backup', 'Crear backup antes de desinstalar')
+        .option('--remove-global', 'Remover CLI global tambien')
+        .action(async (opts) => {
+        console.log();
+        console.log(chalk_1.default.bold.white('  OpenFactu — Desinstalacion'));
+        console.log(chalk_1.default.dim('  ────────────────────────────────────'));
+        console.log();
+        try {
+            const root = opts.path || (0, paths_1.getProjectRoot)();
+            if (!fs_1.default.existsSync(root)) {
+                logger_1.log.error(`Directorio no encontrado: ${root}`);
+                return;
+            }
+            // Verificar que es un proyecto OpenFactu
+            const pkgPath = path_1.default.join(root, 'package.json');
+            if (!fs_1.default.existsSync(pkgPath)) {
+                logger_1.log.error('No parece ser un proyecto OpenFactu valido');
+                return;
+            }
+            if (!opts.force) {
+                logger_1.log.warn(`${chalk_1.default.red('ADVERTENCIA:')} Esta accion es destructiva`);
+                logger_1.log.blank();
+                logger_1.log.info(`Proyecto: ${chalk_1.default.cyan(root)}`);
+                const diskUsage = (0, child_process_1.execSync)(`du -sh "${root}" 2>/dev/null | cut -f1`, { stdio: 'pipe' }).toString().trim();
+                logger_1.log.info(`Tamano: ${chalk_1.default.cyan(diskUsage)}`);
+                logger_1.log.blank();
+                const { confirm } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'confirm',
+                        message: chalk_1.default.red('Estas seguro? Esta accion no se puede deshacer'),
+                        default: false,
+                    },
+                ]);
+                if (!confirm) {
+                    logger_1.log.info('Desinstalacion cancelada');
+                    return;
+                }
+            }
+            // Backup opcional
+            if (opts.keepBackup) {
+                const backupDir = path_1.default.join(os_1.default.homedir(), 'openfactu-backups', `backup-${(0, helpers_1.timestamp)()}`);
+                const backupSpinner = (0, ora_1.default)('Creando backup...').start();
+                try {
+                    (0, helpers_1.ensureDir)(backupDir);
+                    const dirsToBackup = ['storage', '.env', 'docker-compose*.yml', 'monitoring'];
+                    for (const item of dirsToBackup) {
+                        const src = path_1.default.join(root, item);
+                        if (fs_1.default.existsSync(src)) {
+                            const dest = path_1.default.join(backupDir, path_1.default.basename(item));
+                            if (fs_1.default.statSync(src).isDirectory()) {
+                                (0, helpers_1.copyDirRecursive)(src, dest);
+                            }
+                            else {
+                                fs_1.default.copyFileSync(src, dest);
+                            }
+                        }
+                    }
+                    // Database backup
+                    const dockerCmd = (0, helpers_1.getDockerComposeCommand)();
+                    const dbBackupPath = path_1.default.join(backupDir, 'database.sql');
+                    (0, child_process_1.execSync)(`${dockerCmd} exec -T db pg_dump -U openfactu openfactudb > "${dbBackupPath}" 2>/dev/null || true`, {
+                        stdio: 'pipe',
+                    });
+                    backupSpinner.succeed(`Backup creado: ${chalk_1.default.cyan(backupDir)}`);
+                }
+                catch (err) {
+                    backupSpinner.warn('Backup parcial (algunos archivos no se pudieron copiar)');
+                }
+            }
+            // Parar servicios Docker
+            const dockerSpinner = (0, ora_1.default)('Parando servicios Docker...').start();
+            try {
+                const dockerCmd = (0, helpers_1.getDockerComposeCommand)();
+                const composeFiles = [];
+                const possibleFiles = [
+                    'docker-compose.prod.yml',
+                    'docker-compose.prod.monitoring.yml',
+                    'docker-compose.monitoring.yml',
+                    'docker-compose.yml',
+                ];
+                for (const f of possibleFiles) {
+                    if (fs_1.default.existsSync(path_1.default.join(root, f))) {
+                        composeFiles.push(f);
+                    }
+                }
+                if (composeFiles.length > 0) {
+                    const fileFlags = composeFiles.map(f => `-f ${f}`).join(' ');
+                    (0, child_process_1.execSync)(`${dockerCmd} ${fileFlags} down -v`, { cwd: root, stdio: 'pipe' });
+                }
+                // Remover imagenes del proyecto
+                try {
+                    (0, child_process_1.execSync)(`${dockerCmd} -f docker-compose.yml rm -f 2>/dev/null || true`, { cwd: root, stdio: 'pipe' });
+                }
+                catch { }
+                dockerSpinner.succeed('Servicios parados');
+            }
+            catch {
+                dockerSpinner.warn('No se pudieron parar todos los servicios');
+            }
+            // Remover servicio systemd si existe
+            const serviceSpinner = (0, ora_1.default)('Verificando servicios systemd...').start();
+            try {
+                const services = ['openfactu', 'openfactu-platform'];
+                for (const svc of services) {
+                    const unitPath = `/etc/systemd/system/${svc}.service`;
+                    if (fs_1.default.existsSync(unitPath)) {
+                        (0, child_process_1.execSync)(`sudo systemctl stop ${svc} 2>/dev/null || true`, { stdio: 'pipe' });
+                        (0, child_process_1.execSync)(`sudo systemctl disable ${svc} 2>/dev/null || true`, { stdio: 'pipe' });
+                        (0, child_process_1.execSync)(`sudo rm ${unitPath}`, { stdio: 'pipe' });
+                        logger_1.log.info(`Servicio ${svc} removido`);
+                    }
+                }
+                (0, child_process_1.execSync)('sudo systemctl daemon-reload 2>/dev/null || true', { stdio: 'pipe' });
+                serviceSpinner.succeed('Servicios systemd verificados');
+            }
+            catch {
+                serviceSpinner.warn('No se encontraron servicios systemd');
+            }
+            // Remover archivos
+            if (!opts.keepData) {
+                const removeSpinner = (0, ora_1.default)('Removiendo archivos del proyecto...').start();
+                try {
+                    // Remover directorios grandes primero
+                    const largeDirs = ['node_modules', 'storage', '.git'];
+                    for (const dir of largeDirs) {
+                        const dirPath = path_1.default.join(root, dir);
+                        if (fs_1.default.existsSync(dirPath)) {
+                            (0, child_process_1.execSync)(`rm -rf "${dirPath}"`, { stdio: 'pipe' });
+                        }
+                    }
+                    // Remover resto
+                    (0, child_process_1.execSync)(`rm -rf "${root}"`, { stdio: 'pipe' });
+                    removeSpinner.succeed('Archivos removidos');
+                }
+                catch (err) {
+                    removeSpinner.fail('Error al remover archivos');
+                    logger_1.log.dim(`  Remueve manualmente: rm -rf ${root}`);
+                }
+            }
+            else {
+                logger_1.log.info('Datos mantenidos en: ' + chalk_1.default.cyan(root));
+            }
+            // Remover CLI global
+            if (opts.removeGlobal) {
+                const cliSpinner = (0, ora_1.default)('Removiendo CLI global...').start();
+                try {
+                    (0, child_process_1.execSync)('npm uninstall -g @openfactu/cli', { stdio: 'pipe' });
+                    cliSpinner.succeed('CLI global removido');
+                }
+                catch {
+                    cliSpinner.warn('No se pudo remover el CLI global');
+                    logger_1.log.dim('  Ejecuta: npm uninstall -g @openfactu/cli');
+                }
+            }
+            logger_1.log.blank();
+            console.log(chalk_1.default.bold.green('  Desinstalacion completada'));
+            console.log(chalk_1.default.dim('  ────────────────────────────────────'));
+            logger_1.log.blank();
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/src/index.js

@@ -10,12 +10,20 @@ const setup_1 = require("./commands/setup");
 const update_1 = require("./commands/update");
 const install_1 = require("./commands/install");
 const deploy_1 = require("./commands/deploy");
+const monitoring_1 = require("./commands/monitoring");
+const service_1 = require("./commands/service");
+const uninstall_1 = require("./commands/uninstall");
+const backup_1 = require("./commands/backup");
+const doctor_1 = require("./commands/doctor");
+const install_quick_1 = require("./commands/install-quick");
+const install_script_1 = require("./commands/install-script");
+const sync_ports_1 = require("./commands/sync-ports");
 function createCLI() {
     const program = new commander_1.Command();
     program
         .name('openfactu')
         .description('CLI para gestionar OpenFactu')
-        .version('0.0.4');
+        .version('0.0.7');
     (0, version_1.registerVersionCommand)(program);
     (0, migrate_1.registerMigrateCommand)(program);
     (0, tenant_1.registerTenantCommand)(program);
@@ -23,6 +31,14 @@ function createCLI() {
     (0, setup_1.registerSetupCommand)(program);
     (0, update_1.registerUpdateCommand)(program);
     (0, install_1.registerInstallCommand)(program);
+    (0, install_quick_1.registerInstallQuickCommand)(program);
+    (0, install_script_1.registerInstallScriptCommand)(program);
+    (0, sync_ports_1.registerSyncPortsCommand)(program);
     (0, deploy_1.registerDeployCommand)(program);
+    (0, monitoring_1.registerMonitoringCommand)(program);
+    (0, service_1.registerServiceCommand)(program);
+    (0, uninstall_1.registerUninstallCommand)(program);
+    (0, backup_1.registerBackupCommand)(program);
+    (0, doctor_1.registerDoctorCommand)(program);
     return program;
 }

package/dist/src/utils/config.d.ts

@@ -1,3 +1,11 @@
+/**
+ * El CLI se ejecuta en el HOST, pero el DATABASE_URL del .env apunta al
+ * hostname interno de Docker ('db'), que solo resuelve dentro de la red de
+ * contenedores. Esta función lo reescribe a 127.0.0.1 con el puerto publicado
+ * (DB_PORT) para que los comandos de host (setup, migrate, tenant) puedan
+ * conectar a la base de datos a través del puerto mapeado.
+ */
+export declare function resolveHostDatabaseUrl(databaseUrl: string, dbPort?: string): string;
 /**
  * Carga la configuración desde .env del proyecto OpenFactu.
  */

package/dist/src/utils/config.js

@@ -3,10 +3,33 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveHostDatabaseUrl = resolveHostDatabaseUrl;
 exports.loadConfig = loadConfig;
 const dotenv_1 = __importDefault(require("dotenv"));
 const fs_1 = __importDefault(require("fs"));
 const paths_1 = require("./paths");
+/**
+ * El CLI se ejecuta en el HOST, pero el DATABASE_URL del .env apunta al
+ * hostname interno de Docker ('db'), que solo resuelve dentro de la red de
+ * contenedores. Esta función lo reescribe a 127.0.0.1 con el puerto publicado
+ * (DB_PORT) para que los comandos de host (setup, migrate, tenant) puedan
+ * conectar a la base de datos a través del puerto mapeado.
+ */
+function resolveHostDatabaseUrl(databaseUrl, dbPort) {
+    try {
+        const u = new URL(databaseUrl);
+        if (u.hostname === 'db') {
+            u.hostname = '127.0.0.1';
+            if (dbPort)
+                u.port = dbPort;
+            return u.toString();
+        }
+    }
+    catch {
+        // URL no parseable: la devolvemos tal cual y dejamos que falle más arriba.
+    }
+    return databaseUrl;
+}
 /**
  * Carga la configuración desde .env del proyecto OpenFactu.
  */
@@ -15,8 +38,9 @@ function loadConfig() {
     if (fs_1.default.existsSync(envPath)) {
         dotenv_1.default.config({ path: envPath });
     }
+    const rawDatabaseUrl = process.env.DATABASE_URL || 'postgresql://openfactu:openfactu_pass@localhost:5432/openfactudb';
     return {
-        databaseUrl: process.env.DATABASE_URL || 'postgresql://openfactu:openfactu_pass@localhost:5432/openfactudb',
+        databaseUrl: resolveHostDatabaseUrl(rawDatabaseUrl, process.env.DB_PORT),
         jwtSecret: process.env.JWT_SECRET || 'super-secret-key',
         serverPort: process.env.SERVER_PORT || '3000',
     };

package/dist/src/utils/env.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Aplica un conjunto de overrides (clave=valor) sobre el contenido de un .env,
+ * preservando comentarios y orden del archivo base.
+ *
+ *  - Si la clave ya existe, reemplaza solo su valor.
+ *  - Si no existe, la añade al final.
+ *
+ * A diferencia de un merge ingenuo, opera sobre una única cadena acumulada para
+ * no duplicar el contenido del archivo en cada iteración.
+ */
+export declare function applyEnvOverrides(baseContent: string, overrides: Record<string, string>): string;

package/dist/src/utils/env.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyEnvOverrides = applyEnvOverrides;
+/**
+ * Aplica un conjunto de overrides (clave=valor) sobre el contenido de un .env,
+ * preservando comentarios y orden del archivo base.
+ *
+ *  - Si la clave ya existe, reemplaza solo su valor.
+ *  - Si no existe, la añade al final.
+ *
+ * A diferencia de un merge ingenuo, opera sobre una única cadena acumulada para
+ * no duplicar el contenido del archivo en cada iteración.
+ */
+function applyEnvOverrides(baseContent, overrides) {
+    let content = baseContent;
+    for (const [key, value] of Object.entries(overrides)) {
+        const re = new RegExp(`^${escapeRegExp(key)}=.*$`, 'm');
+        // Usamos la forma de función en replace para que '$' en el valor no se
+        // interprete como referencia de captura ($1, $&, $$...).
+        if (re.test(content)) {
+            content = content.replace(re, () => `${key}=${value}`);
+        }
+        else {
+            content = content.trimEnd() + `\n${key}=${value}`;
+        }
+    }
+    return content.endsWith('\n') ? content : content + '\n';
+}
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/src/utils/helpers.d.ts

@@ -0,0 +1,22 @@
+export interface SystemCheck {
+    name: string;
+    status: 'pass' | 'warn' | 'fail';
+    message: string;
+}
+export declare function generatePassword(length?: number): string;
+export declare function generateSlug(length?: number): string;
+export declare function checkDiskSpace(dir: string): {
+    availableGB: number;
+    totalGB: number;
+};
+export declare function checkPortInUse(port: number): boolean;
+export declare function getRunningServices(): string[];
+export declare function runPreflightChecks(targetDir?: string): SystemCheck[];
+export declare function waitForService(url: string, maxAttempts?: number, intervalMs?: number): Promise<boolean>;
+export declare function getDockerComposeCommand(): string;
+export declare function isLinux(): boolean;
+export declare function isSystemdAvailable(): boolean;
+export declare function formatBytes(bytes: number): string;
+export declare function timestamp(): string;
+export declare function ensureDir(dir: string): void;
+export declare function copyDirRecursive(src: string, dest: string): void;