@openfactu/cli 0.0.6 → 0.0.8

package/dist/src/commands/install.js

@@ -13,9 +13,12 @@ const os_1 = __importDefault(require("os"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const logger_1 = require("../utils/logger");
-const REPO_URL = 'https://github.com/AngelAcedo12/OpenFactu.git';
-const GITHUB_OWNER = 'AngelAcedo12';
-const GITHUB_REPO = 'OpenFactu';
+const env_1 = require("../utils/env");
+const monitoring_1 = require("../utils/monitoring");
+const helpers_1 = require("../utils/helpers");
+const REPO_URL = 'https://github.com/OpenFactu/platform.git';
+const GITHUB_OWNER = 'OpenFactu';
+const GITHUB_REPO = 'platform';
 function fetchJSON(url) {
     return new Promise((resolve, reject) => {
         https_1.default.get(url, { headers: { 'User-Agent': 'openfactu-cli' } }, (res) => {
@@ -66,28 +69,206 @@ function getAvailableBranches() {
 function checkDocker() {
     try {
         (0, child_process_1.execSync)('docker --version', { stdio: 'pipe' });
-        (0, child_process_1.execSync)('docker compose version', { stdio: 'pipe' });
+        try {
+            (0, child_process_1.execSync)('docker compose version', { stdio: 'pipe' });
+        }
+        catch {
+            (0, child_process_1.execSync)('docker-compose --version', { stdio: 'pipe' });
+        }
         return true;
     }
     catch {
         return false;
     }
 }
+function validateRepoStructure(targetDir) {
+    const required = [
+        'package.json',
+        'docker-compose.yml',
+        'apps/web',
+        'apps/server',
+    ];
+    const missing = required.filter(f => !fs_1.default.existsSync(path_1.default.join(targetDir, f)));
+    return { valid: missing.length === 0, missing };
+}
+const installLog = [];
+function logStep(message, status = 'info') {
+    const timestamp = new Date().toISOString();
+    const prefix = status === 'success' ? '✓' : status === 'error' ? '✗' : status === 'warn' ? '⚠' : '•';
+    const entry = `[${timestamp}] ${prefix} ${message}`;
+    installLog.push(entry);
+}
+function writeInstallLog(targetDir) {
+    try {
+        const logDir = path_1.default.join(targetDir, '.openfactu');
+        if (!fs_1.default.existsSync(logDir)) {
+            fs_1.default.mkdirSync(logDir, { recursive: true });
+        }
+        const logFile = path_1.default.join(logDir, 'install.log');
+        fs_1.default.writeFileSync(logFile, installLog.join('\n') + '\n');
+    }
+    catch { }
+}
+function generateEnvConfig(dbPassword) {
+    const postgresUser = 'openfactu';
+    const postgresDb = 'openfactudb';
+    const jwtSecret = (0, helpers_1.generatePassword)(48);
+    const sessionSecret = (0, helpers_1.generatePassword)(32);
+    const adminPassword = (0, helpers_1.generatePassword)(16);
+    return {
+        POSTGRES_USER: postgresUser,
+        POSTGRES_PASSWORD: dbPassword,
+        POSTGRES_DB: postgresDb,
+        DATABASE_URL: `postgresql://${postgresUser}:${encodeURIComponent(dbPassword)}@db:5432/${postgresDb}`,
+        SERVER_PORT: '3000',
+        WEB_PORT: '8080',
+        DB_PORT: '5432',
+        JWT_SECRET: jwtSecret,
+        SESSION_SECRET: sessionSecret,
+        NODE_ENV: 'production',
+        HOST: 'localhost',
+        CORS_ORIGIN: 'http://localhost:8080',
+        VITE_API_URL: 'http://localhost:3000',
+        ADMIN_EMAIL: 'admin@openfactu.local',
+        ADMIN_PASSWORD: adminPassword,
+    };
+}
+function generateEnvFileContent(envConfig) {
+    return `# ============================================================
+# OpenFactu - Configuración
+# Generado automáticamente por @openfactu/cli
+# ============================================================
+# IMPORTANTE: Revisa y ajusta los valores marcados con [EDITAR]
+# ============================================================
+
+# ── Base de datos ──────────────────────────────────────────
+# [EDITAR] Si cambias el puerto de PostgreSQL, actualiza DATABASE_URL
+POSTGRES_USER=${envConfig.POSTGRES_USER}
+POSTGRES_PASSWORD=${envConfig.POSTGRES_PASSWORD}
+POSTGRES_DB=${envConfig.POSTGRES_DB}
+DB_PORT=${envConfig.DB_PORT}
+
+# [EDITAR] La URL interna del contenedor (no cambiar a menos que uses otro host de BD)
+DATABASE_URL=${envConfig.DATABASE_URL}
+
+# ── Puertos de la aplicación ───────────────────────────────
+# [EDITAR] Cambia estos puertos si hay conflictos en tu servidor
+SERVER_PORT=${envConfig.SERVER_PORT}
+WEB_PORT=${envConfig.WEB_PORT}
+
+# ── Seguridad ─────────────────────────────────────────────
+# [NO EDITAR] Secrets generados automáticamente
+JWT_SECRET=${envConfig.JWT_SECRET}
+SESSION_SECRET=${envConfig.SESSION_SECRET}
+
+# ── Entorno ────────────────────────────────────────────────
+NODE_ENV=${envConfig.NODE_ENV}
+
+# ── URLs y acceso externo ──────────────────────────────────
+# [EDITAR] Cambia HOST por tu dominio o IP pública
+HOST=${envConfig.HOST}
+
+# [EDITAR] Cambia estas URLs según tu dominio/IP y puertos
+# Ejemplo con dominio: https://erp.miempresa.com
+# Ejemplo con IP: http://192.168.1.100:8080
+CORS_ORIGIN=${envConfig.CORS_ORIGIN}
+VITE_API_URL=${envConfig.VITE_API_URL}
+
+# ── Credenciales de administrador ──────────────────────────
+# [EDITAR] Cambia el email y password del admin inicial
+ADMIN_EMAIL=${envConfig.ADMIN_EMAIL}
+ADMIN_PASSWORD=${envConfig.ADMIN_PASSWORD}
+`;
+}
+function installService(targetDir, dockerCmd, serviceName, unitPath) {
+    const unitContent = `[Unit]
+Description=OpenFactu ERP Platform
+After=docker.service network-online.target
+Requires=docker.service
+Wants=network-online.target
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+WorkingDirectory=${targetDir}
+ExecStart=${dockerCmd} -f docker-compose.yml up -d
+ExecStop=${dockerCmd} -f docker-compose.yml down
+Restart=on-failure
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
+`;
+    fs_1.default.writeFileSync(`/tmp/${serviceName}.service`, unitContent);
+    (0, child_process_1.execSync)(`sudo mv /tmp/${serviceName}.service ${unitPath}`, { stdio: 'pipe' });
+    (0, child_process_1.execSync)('sudo systemctl daemon-reload', { stdio: 'pipe' });
+    (0, child_process_1.execSync)(`sudo systemctl enable ${serviceName}`, { stdio: 'pipe' });
+    logger_1.log.success(`Servicio ${serviceName} instalado y habilitado`);
+    logger_1.log.dim(`  sudo systemctl start ${serviceName}`);
+    logger_1.log.dim(`  sudo systemctl status ${serviceName}`);
+}
 function registerInstallCommand(program) {
     program
         .command('install [directory]')
         .description('Descarga e instala OpenFactu en un directorio')
         .option('-t, --tag <tag>', 'Versión/tag específico (ej: v1.0.0)')
-        .option('-b, --branch <branch>', 'Branch específica (default: main)')
+        .option('-b, --branch <branch>', 'Branch específico (default: main)')
         .option('--repo <url>', 'URL del repositorio', REPO_URL)
         .option('--skip-deps', 'No instalar dependencias (npm install)')
+        .option('--mode <mode>', 'Modo: full, docker, minimal, download (default: interactive)')
+        .option('--no-preflight', 'Saltar chequeos previos')
+        .option('--no-healthcheck', 'Saltar health checks post-instalación')
+        .option('--generate-env', 'Generar .env con credenciales seguras aleatorias')
+        .option('--service', 'Instalar como servicio systemd después de instalar')
+        .option('--monitoring', 'Incluir stack de monitoreo (Grafana, Prometheus, etc.)')
+        .option('--with-analytics', 'Incluir stack completo de analítica (Loki, cAdvisor, Node Exporter)')
+        .option('-y, --yes', 'Aceptar defaults sin preguntar (non-interactive)')
         .action(async (directory, opts) => {
         console.log();
         console.log(chalk_1.default.bold.white('  OpenFactu — Instalación'));
         console.log(chalk_1.default.dim('  ────────────────────────────────────'));
         console.log();
+        let targetDir = directory;
         try {
             const repoUrl = opts.repo;
+            const nonInteractive = opts.yes || false;
+            logStep('Inicio de instalación', 'info');
+            // 0. Preflight checks
+            if (opts.preflight !== false) {
+                const checkSpinner = (0, ora_1.default)('Ejecutando chequeos del sistema...').start();
+                const checks = (0, helpers_1.runPreflightChecks)(directory || os_1.default.homedir());
+                const fails = checks.filter(c => c.status === 'fail');
+                const warns = checks.filter(c => c.status === 'warn');
+                if (fails.length > 0) {
+                    checkSpinner.fail('Chequeos fallidos');
+                    logStep(`Preflight fallido: ${fails.map(f => f.name).join(', ')}`, 'error');
+                    logger_1.log.blank();
+                    logger_1.log.error('Requisitos no cumplidos:');
+                    for (const f of fails) {
+                        logger_1.log.error(`  ✗ ${f.name}: ${f.message}`);
+                    }
+                    logger_1.log.blank();
+                    if (!nonInteractive) {
+                        const { continueAnyway } = await inquirer_1.default.prompt([
+                            { type: 'confirm', name: 'continueAnyway', message: 'Continuar de todos modos?', default: false },
+                        ]);
+                        if (!continueAnyway)
+                            return;
+                    }
+                }
+                else if (warns.length > 0) {
+                    checkSpinner.warn('Chequeos con advertencias');
+                    logStep(`Preflight con advertencias: ${warns.map(w => w.name).join(', ')}`, 'warn');
+                    for (const w of warns) {
+                        logger_1.log.warn(`  ⚠ ${w.name}: ${w.message}`);
+                    }
+                }
+                else {
+                    checkSpinner.succeed(`${checks.length} chequeos pasados`);
+                    logStep('Preflight OK', 'success');
+                }
+                logger_1.log.blank();
+            }
             // 1. Obtener releases de GitHub
             const fetchSpinner = (0, ora_1.default)('Consultando releases en GitHub...').start();
             const releases = await getGithubReleases();
@@ -101,10 +282,12 @@ function registerInstallCommand(program) {
             else if (opts.branch) {
                 ref = opts.branch;
             }
+            else if (nonInteractive) {
+                const stable = releases.filter((r) => !r.prerelease);
+                ref = stable.length > 0 ? stable[0].tag_name : 'main';
+            }
             else {
-                // Menú interactivo
                 const choices = [];
-                // Releases estables primero
                 const stable = releases.filter((r) => !r.prerelease);
                 const prerelease = releases.filter((r) => r.prerelease);
                 for (const rel of stable.slice(0, 10)) {
@@ -150,43 +333,53 @@ function registerInstallCommand(program) {
             }
             logger_1.log.info(`Versión seleccionada: ${chalk_1.default.cyan(ref)}`);
             // 3. Directorio destino
-            let targetDir = directory;
             if (!targetDir) {
-                const { dir } = await inquirer_1.default.prompt([
-                    {
-                        type: 'input',
-                        name: 'dir',
-                        message: 'Directorio de instalación:',
-                        default: path_1.default.join(os_1.default.homedir(), 'openfactu'),
-                    },
-                ]);
-                targetDir = dir;
+                if (nonInteractive) {
+                    targetDir = path_1.default.join(os_1.default.homedir(), 'openfactu');
+                }
+                else {
+                    const { dir } = await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'dir',
+                            message: 'Directorio de instalación:',
+                            default: path_1.default.join(os_1.default.homedir(), 'openfactu'),
+                        },
+                    ]);
+                    targetDir = dir;
+                }
             }
             targetDir = path_1.default.resolve(targetDir);
-            // Verificar si el directorio ya existe
             if (fs_1.default.existsSync(targetDir)) {
                 const contents = fs_1.default.readdirSync(targetDir);
                 if (contents.length > 0) {
-                    const { overwrite } = await inquirer_1.default.prompt([
-                        {
-                            type: 'confirm',
-                            name: 'overwrite',
-                            message: `El directorio ${targetDir} no está vacío. ¿Continuar?`,
-                            default: false,
-                        },
-                    ]);
-                    if (!overwrite) {
-                        logger_1.log.info('Instalación cancelada');
-                        return;
+                    if (nonInteractive) {
+                        logger_1.log.warn(`Directorio ${targetDir} no está vacío, se usará igual`);
+                    }
+                    else {
+                        const { overwrite } = await inquirer_1.default.prompt([
+                            {
+                                type: 'confirm',
+                                name: 'overwrite',
+                                message: `El directorio ${targetDir} no está vacío. ¿Continuar?`,
+                                default: false,
+                            },
+                        ]);
+                        if (!overwrite) {
+                            logger_1.log.info('Instalación cancelada');
+                            return;
+                        }
                     }
                 }
             }
             logger_1.log.info(`Directorio: ${chalk_1.default.dim(targetDir)}`);
+            logStep(`Directorio: ${targetDir}`, 'info');
             logger_1.log.blank();
-            // 4. Crear directorio si no existe (con sudo si hace falta)
+            // 4. Crear directorio
             if (!fs_1.default.existsSync(targetDir)) {
                 try {
                     fs_1.default.mkdirSync(targetDir, { recursive: true });
+                    logStep('Directorio creado', 'success');
                 }
                 catch (mkdirErr) {
                     if (mkdirErr.code === 'EACCES') {
@@ -194,11 +387,13 @@ function registerInstallCommand(program) {
                         try {
                             const user = process.env.USER || process.env.USERNAME || 'root';
                             (0, child_process_1.execSync)(`sudo mkdir -p "${targetDir}" && sudo chown -R ${user}:${user} "${targetDir}"`, {
-                                stdio: 'inherit',
+                                stdio: 'pipe',
                             });
+                            logStep('Directorio creado con sudo', 'success');
                         }
                         catch {
                             logger_1.log.error(`No se pudo crear ${targetDir}. Ejecuta con sudo o elige otro directorio.`);
+                            logStep(`Error creando directorio: ${targetDir}`, 'error');
                             return;
                         }
                     }
@@ -209,6 +404,7 @@ function registerInstallCommand(program) {
             }
             // 5. Clonar repositorio
             const cloneSpinner = (0, ora_1.default)('Descargando OpenFactu...').start();
+            logStep('Iniciando clonación del repositorio', 'info');
             const isTag = releases.some((r) => r.tag_name === ref);
             const cloneCmd = isTag
                 ? `git clone --depth 1 --branch ${ref} ${repoUrl} "${targetDir}"`
@@ -216,72 +412,755 @@ function registerInstallCommand(program) {
             try {
                 (0, child_process_1.execSync)(cloneCmd, { stdio: 'pipe', timeout: 120000 });
                 cloneSpinner.succeed('Código descargado');
+                logStep(`Repositorio clonado: ${ref}`, 'success');
             }
             catch (err) {
-                // Fallback: clonar todo y checkout
                 try {
                     cloneSpinner.text = 'Descargando (método alternativo)...';
                     (0, child_process_1.execSync)(`git clone ${repoUrl} "${targetDir}"`, { stdio: 'pipe', timeout: 180000 });
                     (0, child_process_1.execSync)(`git checkout ${ref}`, { cwd: targetDir, stdio: 'pipe' });
                     cloneSpinner.succeed('Código descargado');
+                    logStep(`Repositorio clonado (alternativo): ${ref}`, 'success');
                 }
                 catch (err2) {
                     cloneSpinner.fail('Error al descargar: ' + err2.message);
+                    logStep(`Error clonando repositorio: ${err2.message}`, 'error');
                     return;
                 }
             }
-            // 6. Copiar .env.example a .env
-            const envExample = path_1.default.join(targetDir, '.env.example');
-            const envFile = path_1.default.join(targetDir, '.env');
-            if (fs_1.default.existsSync(envExample) && !fs_1.default.existsSync(envFile)) {
-                fs_1.default.copyFileSync(envExample, envFile);
-                logger_1.log.success('Archivo .env creado desde .env.example');
+            // 6. Validar estructura del repo
+            const validation = validateRepoStructure(targetDir);
+            if (!validation.valid) {
+                logger_1.log.warn(`Estructura incompleta: ${validation.missing.join(', ')}`);
+                logStep(`Estructura incompleta: ${validation.missing.join(', ')}`, 'warn');
+                logger_1.log.dim('  Algunos comandos pueden no funcionar correctamente');
+            }
+            else {
+                logStep('Estructura del repositorio válida', 'success');
             }
-            // 7. Preguntar modo de instalación
-            const hasDocker = checkDocker();
-            if (!hasDocker) {
-                logger_1.log.warn('Docker no detectado. OpenFactu requiere Docker para funcionar.');
-                logger_1.log.dim('  Instala Docker Desktop: https://docs.docker.com/get-docker/');
+            // 7. Configurar .env — las credenciales (incluida la contraseña de BD) se
+            //    fijan AQUI, antes del primer arranque, para que el volumen de Postgres
+            //    se inicialice con ellas y no acabe usando la contraseña por defecto.
+            {
+                const envFile = path_1.default.join(targetDir, '.env');
+                const envExample = path_1.default.join(targetDir, '.env.example');
+                // Decidir la contraseña de PostgreSQL.
+                let dbPassword;
+                if (opts.generateEnv || nonInteractive) {
+                    dbPassword = (0, helpers_1.generatePassword)(24);
+                }
+                else {
+                    const suggested = (0, helpers_1.generatePassword)(24);
+                    const { pw } = await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'pw',
+                            message: 'Contraseña de PostgreSQL (Enter = generar una segura):',
+                            default: suggested,
+                        },
+                    ]);
+                    dbPassword = typeof pw === 'string' && pw.trim() ? pw.trim() : suggested;
+                }
+                const envSpinner = (0, ora_1.default)('Configurando .env con credenciales seguras...').start();
+                const envConfig = generateEnvConfig(dbPassword);
+                // Plantilla base: .env.example si existe (preserva comentarios y claves
+                // propias de la plataforma); si no, un .env generado desde cero.
+                const baseContent = fs_1.default.existsSync(envExample)
+                    ? fs_1.default.readFileSync(envExample, 'utf-8')
+                    : generateEnvFileContent(envConfig);
+                fs_1.default.writeFileSync(envFile, (0, env_1.applyEnvOverrides)(baseContent, envConfig));
+                envSpinner.succeed('.env configurado con credenciales seguras');
+                logStep('.env configurado con credenciales seguras', 'success');
+                logger_1.log.blank();
+                logger_1.log.info(`${chalk_1.default.dim('Admin:')} ${envConfig.ADMIN_EMAIL} / ${chalk_1.default.yellow(envConfig.ADMIN_PASSWORD)}`);
+                logger_1.log.info(`${chalk_1.default.dim('DB Password:')} ${chalk_1.default.yellow(envConfig.POSTGRES_PASSWORD)}`);
+                logger_1.log.dim('  Guarda estas credenciales en un lugar seguro');
                 logger_1.log.blank();
             }
-            const { installMode } = await inquirer_1.default.prompt([
-                {
-                    type: 'list',
-                    name: 'installMode',
-                    message: 'Modo de instalación:',
-                    choices: [
-                        ...(hasDocker ? [{
-                                name: `${chalk_1.default.green('Docker')} ${chalk_1.default.dim('— recomendado, funciona en Windows/Mac/Linux')}`,
-                                value: 'docker',
-                            }] : []),
+            // 8. Determinar modo de instalación
+            let installMode = opts.mode;
+            if (!installMode) {
+                const hasDocker = checkDocker();
+                if (!hasDocker) {
+                    logger_1.log.warn('Docker no detectado. OpenFactu requiere Docker para funcionar.');
+                    logger_1.log.dim('  Instala Docker: https://docs.docker.com/get-docker/');
+                    logger_1.log.blank();
+                }
+                if (nonInteractive) {
+                    installMode = hasDocker ? 'docker' : 'download';
+                }
+                else {
+                    const disk = (0, helpers_1.checkDiskSpace)(targetDir);
+                    const { selectedMode } = await inquirer_1.default.prompt([
                         {
-                            name: `${chalk_1.default.dim('Solo descargar')} ${chalk_1.default.dim('— instalar dependencias manualmente después')}`,
-                            value: 'none',
+                            type: 'list',
+                            name: 'selectedMode',
+                            message: 'Modo de instalación:',
+                            choices: [
+                                ...(hasDocker ? [
+                                    {
+                                        name: `${chalk_1.default.green('Completa (Docker)')} ${chalk_1.default.dim('— build + up + setup completo')}`,
+                                        value: 'full',
+                                    },
+                                    {
+                                        name: `${chalk_1.default.cyan('Docker')} ${chalk_1.default.dim('— build + up, sin setup DB')}`,
+                                        value: 'docker',
+                                    },
+                                    {
+                                        name: `${chalk_1.default.yellow('Mínima')} ${chalk_1.default.dim('— solo compose up, sin build')}`,
+                                        value: 'minimal',
+                                    },
+                                ] : []),
+                                {
+                                    name: `${chalk_1.default.dim('Solo descarga')} ${chalk_1.default.dim('— sin Docker')}`,
+                                    value: 'download',
+                                },
+                            ],
+                        },
+                    ]);
+                    installMode = selectedMode;
+                }
+            }
+            // Verificar conflictos de puertos ANTES de hacer más preguntas
+            if (installMode === 'full' || installMode === 'docker' || installMode === 'minimal') {
+                const commonPorts = [
+                    { port: 5432, name: 'PostgreSQL', container: 'db' },
+                    { port: 8080, name: 'Web', container: 'web' },
+                    { port: 3000, name: 'API Server', container: 'server' },
+                ];
+                const conflicts = commonPorts.filter(p => {
+                    try {
+                        // Excluir docker-pr (proxies de Docker) que pueden quedar colgados
+                        const output = (0, child_process_1.execSync)(`lsof -i :${p.port} -sTCP:LISTEN 2>/dev/null | grep -v 'docker-pr' | grep -v 'COMMAND' || true`, { stdio: 'pipe' }).toString().trim();
+                        return output.length > 0;
+                    }
+                    catch {
+                        return false;
+                    }
+                });
+                if (conflicts.length > 0 && !nonInteractive) {
+                    logger_1.log.blank();
+                    logger_1.log.warn('Puertos en conflicto detectados:');
+                    for (const c of conflicts) {
+                        let processInfo = '';
+                        try {
+                            const pid = (0, child_process_1.execSync)(`lsof -i :${c.port} -sTCP:LISTEN -t 2>/dev/null | grep -v 'docker-pr' | head -1`, { stdio: 'pipe' }).toString().trim();
+                            if (pid) {
+                                const procName = (0, child_process_1.execSync)(`ps -p ${pid} -o comm= 2>/dev/null || echo 'desconocido'`, { stdio: 'pipe' }).toString().trim();
+                                processInfo = ` (${procName})`;
+                            }
+                        }
+                        catch { }
+                        logger_1.log.warn(`  Puerto ${c.port} (${c.name}): ocupado${processInfo}`);
+                    }
+                    logger_1.log.blank();
+                    const { portAction } = await inquirer_1.default.prompt([
+                        {
+                            type: 'list',
+                            name: 'portAction',
+                            message: '¿Cómo resolver el conflicto?',
+                            choices: [
+                                { name: 'Detener el proceso que ocupa el puerto', value: 'stop' },
+                                { name: 'Usar puertos alternativos (5433, 8081, 3001)', value: 'alternate' },
+                                { name: 'Continuar igual (puede fallar)', value: 'continue' },
+                                { name: 'Cancelar instalación', value: 'cancel' },
+                            ],
                         },
-                    ],
-                },
-            ]);
-            if (installMode === 'docker') {
-                // Docker: build + up
-                const dockerSpinner = (0, ora_1.default)('Construyendo contenedores Docker...').start();
-                try {
-                    (0, child_process_1.execSync)('docker compose build', { cwd: targetDir, stdio: 'pipe', timeout: 300000 });
-                    dockerSpinner.succeed('Contenedores construidos');
-                    const { startNow } = await inquirer_1.default.prompt([
-                        { type: 'confirm', name: 'startNow', message: '¿Arrancar los servicios?', default: true },
                     ]);
-                    if (startNow) {
-                        const upSpinner = (0, ora_1.default)('Levantando servicios...').start();
-                        (0, child_process_1.execSync)('docker compose up -d', { cwd: targetDir, stdio: 'pipe', timeout: 120000 });
-                        upSpinner.succeed('Servicios levantados');
+                    if (portAction === 'cancel') {
+                        logger_1.log.info('Instalación cancelada');
+                        writeInstallLog(targetDir);
+                        return;
+                    }
+                    if (portAction === 'stop') {
+                        for (const c of conflicts) {
+                            const stopSpinner = (0, ora_1.default)(`Deteniendo proceso en puerto ${c.port}...`).start();
+                            try {
+                                const pid = (0, child_process_1.execSync)(`lsof -i :${c.port} -sTCP:LISTEN -t 2>/dev/null | head -1`, { stdio: 'pipe' }).toString().trim();
+                                if (pid) {
+                                    (0, child_process_1.execSync)(`kill -9 ${pid} 2>/dev/null || true`, { stdio: 'pipe' });
+                                    stopSpinner.succeed(`Proceso en puerto ${c.port} detenido`);
+                                    logStep(`Puerto ${c.port} liberado`, 'success');
+                                }
+                                else {
+                                    stopSpinner.warn(`No se encontró proceso en puerto ${c.port}`);
+                                }
+                            }
+                            catch {
+                                stopSpinner.fail(`No se pudo detener el proceso en puerto ${c.port}`);
+                                logger_1.log.dim(`  Intenta manualmente: sudo lsof -i :${c.port} -t | xargs kill -9`);
+                            }
+                        }
+                        logger_1.log.blank();
                     }
+                    if (portAction === 'alternate') {
+                        const portMap = { 5432: 5433, 8080: 8081, 3000: 3001 };
+                        // Actualizar .env
+                        const envPath = path_1.default.join(targetDir, '.env');
+                        if (fs_1.default.existsSync(envPath)) {
+                            let envContent = fs_1.default.readFileSync(envPath, 'utf-8');
+                            for (const [oldPort, newPort] of Object.entries(portMap)) {
+                                const oldPortNum = parseInt(oldPort);
+                                if (conflicts.some(c => c.port === oldPortNum)) {
+                                    envContent = envContent.replace(new RegExp(`:${oldPortNum}\\b`, 'g'), `:${newPort}`);
+                                    envContent = envContent.replace(new RegExp(`PORT=${oldPortNum}`, 'g'), `PORT=${newPort}`);
+                                    logger_1.log.info(`Puerto ${oldPort} → ${newPort}`);
+                                }
+                            }
+                            fs_1.default.writeFileSync(envPath, envContent);
+                            logStep('Puertos alternativos configurados en .env', 'success');
+                        }
+                        // Actualizar docker-compose files
+                        const composeFiles = [
+                            'docker-compose.yml',
+                            'docker-compose.prod.yml',
+                        ];
+                        for (const composeFile of composeFiles) {
+                            const composePath = path_1.default.join(targetDir, composeFile);
+                            if (fs_1.default.existsSync(composePath)) {
+                                let composeContent = fs_1.default.readFileSync(composePath, 'utf-8');
+                                for (const [oldPort, newPort] of Object.entries(portMap)) {
+                                    const oldPortNum = parseInt(oldPort);
+                                    if (conflicts.some(c => c.port === oldPortNum)) {
+                                        composeContent = composeContent.replace(new RegExp(`"([^"]*):${oldPortNum}"`, 'g'), `$1:${newPort}"`);
+                                        composeContent = composeContent.replace(new RegExp(`- "${oldPortNum}:${oldPortNum}"`, 'g'), `- "${newPort}:${oldPortNum}"`);
+                                        composeContent = composeContent.replace(new RegExp(`- "0\\.0\\.0\\.0:${oldPortNum}:`, 'g'), `- "0.0.0.0:${newPort}:`);
+                                        composeContent = composeContent.replace(new RegExp(`- "127\\.0\\.0\\.1:${oldPortNum}:`, 'g'), `- "127.0.0.1:${newPort}:`);
+                                    }
+                                }
+                                fs_1.default.writeFileSync(composePath, composeContent);
+                                logStep(`Puertos actualizados en ${composeFile}`, 'success');
+                            }
+                        }
+                        logger_1.log.blank();
+                    }
+                }
+            }
+            // 9. Monitoreo — selección granular de servicios
+            let includeMonitoring = false;
+            let monitoringServices = [];
+            if (installMode === 'full' || installMode === 'docker') {
+                if (opts.withAnalytics) {
+                    includeMonitoring = true;
+                    monitoringServices = (0, monitoring_1.fullMonitoringServices)();
+                }
+                else if (opts.monitoring) {
+                    includeMonitoring = true;
+                    monitoringServices = (0, monitoring_1.basicMonitoringServices)();
+                }
+                else if (!nonInteractive) {
+                    const { monitoring } = await inquirer_1.default.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'monitoring',
+                            message: 'Incluir stack de monitoreo (Grafana, Prometheus, pgAdmin, Portainer…)?',
+                            default: false,
+                        },
+                    ]);
+                    if (monitoring) {
+                        const { services } = await inquirer_1.default.prompt([
+                            {
+                                type: 'checkbox',
+                                name: 'services',
+                                message: 'Servicios de monitoreo a instalar:',
+                                choices: (0, monitoring_1.monitoringChoices)(),
+                            },
+                        ]);
+                        monitoringServices = services;
+                        includeMonitoring = monitoringServices.length > 0;
+                    }
+                }
+            }
+            // Generar docker-compose.monitoring.yml + configs con los servicios elegidos
+            if (includeMonitoring && monitoringServices.length > 0) {
+                const monSpinner = (0, ora_1.default)('Generando stack de monitoreo...').start();
+                const serviceSet = new Set(monitoringServices);
+                fs_1.default.writeFileSync(path_1.default.join(targetDir, 'docker-compose.monitoring.yml'), (0, monitoring_1.generateMonitoringCompose)(serviceSet));
+                (0, monitoring_1.writeMonitoringConfigs)(targetDir, serviceSet);
+                const envFile = path_1.default.join(targetDir, '.env');
+                if (fs_1.default.existsSync(envFile)) {
+                    fs_1.default.writeFileSync(envFile, (0, env_1.applyEnvOverrides)(fs_1.default.readFileSync(envFile, 'utf-8'), {
+                        MONITORING_SERVICES: monitoringServices.join(','),
+                    }));
+                }
+                monSpinner.succeed(`Monitoreo: ${monitoringServices.join(', ')}`);
+                logStep(`Monitoreo configurado: ${monitoringServices.join(', ')}`, 'success');
+            }
+            else {
+                includeMonitoring = false;
+            }
+            // Preguntar por servicio systemd (siempre, si es Linux)
+            if (!nonInteractive && (0, helpers_1.isLinux)() && (installMode === 'full' || installMode === 'docker' || installMode === 'minimal')) {
+                const { installService } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'installService',
+                        message: 'Instalar como servicio systemd (auto-start al iniciar el sistema)?',
+                        default: false,
+                    },
+                ]);
+                if (installService)
+                    opts.service = true;
+            }
+            // 10. Ejecutar instalación según modo
+            const dockerCmd = (0, helpers_1.getDockerComposeCommand)();
+            logStep(`Modo de instalación: ${installMode}`, 'info');
+            // Verificar conflictos de puertos antes de levantar contenedores
+            if (installMode === 'full' || installMode === 'docker' || installMode === 'minimal') {
+                const commonPorts = [
+                    { port: 5432, name: 'PostgreSQL', container: 'db' },
+                    { port: 8080, name: 'Web', container: 'web' },
+                    { port: 3000, name: 'API Server', container: 'server' },
+                ];
+                const conflicts = commonPorts.filter(p => {
+                    try {
+                        const output = (0, child_process_1.execSync)(`lsof -i :${p.port} -sTCP:LISTEN 2>/dev/null | grep -v 'docker-pr' | grep -v 'COMMAND' || true`, { stdio: 'pipe' }).toString().trim();
+                        return output.length > 0;
+                    }
+                    catch {
+                        return false;
+                    }
+                });
+                if (conflicts.length > 0 && !nonInteractive) {
+                    logger_1.log.blank();
+                    logger_1.log.warn('Puertos en conflicto detectados:');
+                    for (const c of conflicts) {
+                        let processInfo = '';
+                        try {
+                            const pid = (0, child_process_1.execSync)(`lsof -i :${c.port} -sTCP:LISTEN -t 2>/dev/null | grep -v 'docker-pr' | head -1 || true`, { stdio: 'pipe' }).toString().trim();
+                            if (pid) {
+                                const procName = (0, child_process_1.execSync)(`ps -p ${pid} -o comm= 2>/dev/null || echo 'desconocido'`, { stdio: 'pipe' }).toString().trim();
+                                processInfo = ` (${procName})`;
+                            }
+                        }
+                        catch { }
+                        logger_1.log.warn(`  Puerto ${c.port} (${c.name}): ocupado${processInfo}`);
+                    }
+                    logger_1.log.blank();
+                    const { portAction } = await inquirer_1.default.prompt([
+                        {
+                            type: 'list',
+                            name: 'portAction',
+                            message: '¿Cómo resolver el conflicto?',
+                            choices: [
+                                { name: 'Detener el proceso que ocupa el puerto', value: 'stop' },
+                                { name: 'Usar puertos alternativos (5433, 8081, 3001)', value: 'alternate' },
+                                { name: 'Continuar igual (puede fallar)', value: 'continue' },
+                                { name: 'Cancelar instalación', value: 'cancel' },
+                            ],
+                        },
+                    ]);
+                    if (portAction === 'cancel') {
+                        logger_1.log.info('Instalación cancelada');
+                        writeInstallLog(targetDir);
+                        return;
+                    }
+                    if (portAction === 'stop') {
+                        for (const c of conflicts) {
+                            const stopSpinner = (0, ora_1.default)(`Deteniendo proceso en puerto ${c.port}...`).start();
+                            try {
+                                const pid = (0, child_process_1.execSync)(`lsof -i :${c.port} -sTCP:LISTEN -t 2>/dev/null | head -1`, { stdio: 'pipe' }).toString().trim();
+                                if (pid) {
+                                    (0, child_process_1.execSync)(`kill -9 ${pid} 2>/dev/null || true`, { stdio: 'pipe' });
+                                    stopSpinner.succeed(`Proceso en puerto ${c.port} detenido`);
+                                    logStep(`Puerto ${c.port} liberado`, 'success');
+                                }
+                                else {
+                                    stopSpinner.warn(`No se encontró proceso en puerto ${c.port}`);
+                                }
+                            }
+                            catch {
+                                stopSpinner.fail(`No se pudo detener el proceso en puerto ${c.port}`);
+                                logger_1.log.dim(`  Intenta manualmente: sudo lsof -i :${c.port} -t | xargs kill -9`);
+                            }
+                        }
+                        logger_1.log.blank();
+                    }
+                    if (portAction === 'alternate') {
+                        const portMap = { 5432: 5433, 8080: 8081, 3000: 3001 };
+                        // Actualizar .env
+                        const envPath = path_1.default.join(targetDir, '.env');
+                        if (fs_1.default.existsSync(envPath)) {
+                            let envContent = fs_1.default.readFileSync(envPath, 'utf-8');
+                            for (const [oldPort, newPort] of Object.entries(portMap)) {
+                                const oldPortNum = parseInt(oldPort);
+                                if (conflicts.some(c => c.port === oldPortNum)) {
+                                    envContent = envContent.replace(new RegExp(`:${oldPortNum}\\b`, 'g'), `:${newPort}`);
+                                    envContent = envContent.replace(new RegExp(`PORT=${oldPortNum}`, 'g'), `PORT=${newPort}`);
+                                    logger_1.log.info(`Puerto ${oldPort} → ${newPort}`);
+                                }
+                            }
+                            fs_1.default.writeFileSync(envPath, envContent);
+                            logStep('Puertos alternativos configurados en .env', 'success');
+                        }
+                        // Actualizar docker-compose files
+                        const composeFiles = [
+                            'docker-compose.yml',
+                            'docker-compose.prod.yml',
+                        ];
+                        for (const composeFile of composeFiles) {
+                            const composePath = path_1.default.join(targetDir, composeFile);
+                            if (fs_1.default.existsSync(composePath)) {
+                                let composeContent = fs_1.default.readFileSync(composePath, 'utf-8');
+                                for (const [oldPort, newPort] of Object.entries(portMap)) {
+                                    const oldPortNum = parseInt(oldPort);
+                                    if (conflicts.some(c => c.port === oldPortNum)) {
+                                        // Reemplazar puertos en mappings de Docker "host:container"
+                                        composeContent = composeContent.replace(new RegExp(`"([^"]*):${oldPortNum}"`, 'g'), `$1:${newPort}"`);
+                                        composeContent = composeContent.replace(new RegExp(`- "${oldPortNum}:${oldPortNum}"`, 'g'), `- "${newPort}:${oldPortNum}"`);
+                                        composeContent = composeContent.replace(new RegExp(`- "0\\.0\\.0\\.0:${oldPortNum}:`, 'g'), `- "0.0.0.0:${newPort}:`);
+                                        composeContent = composeContent.replace(new RegExp(`- "127\\.0\\.0\\.1:${oldPortNum}:`, 'g'), `- "127.0.0.1:${newPort}:`);
+                                    }
+                                }
+                                fs_1.default.writeFileSync(composePath, composeContent);
+                                logStep(`Puertos actualizados en ${composeFile}`, 'success');
+                            }
+                        }
+                        logger_1.log.blank();
+                    }
+                }
+            }
+            if (installMode === 'full' || installMode === 'docker' || installMode === 'minimal') {
+                if (installMode === 'full' || installMode === 'docker') {
+                    const dockerSpinner = (0, ora_1.default)('Construyendo contenedores Docker...').start();
+                    logStep('Iniciando build de Docker', 'info');
+                    try {
+                        (0, child_process_1.execSync)(`${dockerCmd} build`, { cwd: targetDir, stdio: 'pipe', timeout: 300000 });
+                        dockerSpinner.succeed('Contenedores construidos');
+                        logStep('Build de Docker completado', 'success');
+                    }
+                    catch (err) {
+                        dockerSpinner.fail('Error en build: ' + err.message);
+                        logStep(`Error en build de Docker: ${err.message}`, 'error');
+                        // Detectar error de permisos de Docker
+                        if (err.message?.includes('permission denied') && err.message?.includes('docker.sock')) {
+                            logger_1.log.blank();
+                            logger_1.log.warn('Error de permisos de Docker detectado');
+                            logger_1.log.dim('  Tu usuario no tiene acceso al socket de Docker');
+                            logger_1.log.blank();
+                            if (!nonInteractive) {
+                                const { fixPermissions } = await inquirer_1.default.prompt([
+                                    {
+                                        type: 'confirm',
+                                        name: 'fixPermissions',
+                                        message: '¿Agregar tu usuario al grupo docker para arreglarlo? (requiere sudo)',
+                                        default: true,
+                                    },
+                                ]);
+                                if (fixPermissions) {
+                                    const fixSpinner = (0, ora_1.default)('Agregando usuario al grupo docker...').start();
+                                    logStep('Arreglando permisos de Docker', 'info');
+                                    try {
+                                        const user = process.env.USER || process.env.USERNAME || 'root';
+                                        (0, child_process_1.execSync)(`sudo usermod -aG docker ${user}`, { stdio: 'pipe' });
+                                        fixSpinner.succeed('Usuario agregado al grupo docker');
+                                        logStep('Permisos de Docker arreglados', 'success');
+                                        logger_1.log.blank();
+                                        logger_1.log.info('Los cambios se aplican en la próxima sesión');
+                                        logger_1.log.dim(`  Ejecuta: newgrp docker`);
+                                        logger_1.log.dim(`  O cierra sesión y vuelve a entrar`);
+                                        logger_1.log.blank();
+                                        const { retryBuild } = await inquirer_1.default.prompt([
+                                            {
+                                                type: 'confirm',
+                                                name: 'retryBuild',
+                                                message: '¿Reintentar el build ahora?',
+                                                default: false,
+                                            },
+                                        ]);
+                                        if (retryBuild) {
+                                            const retrySpinner = (0, ora_1.default)('Reintentando build...').start();
+                                            try {
+                                                (0, child_process_1.execSync)(`${dockerCmd} build`, { cwd: targetDir, stdio: 'pipe', timeout: 300000 });
+                                                retrySpinner.succeed('Build completado');
+                                                logStep('Build completado tras arreglar permisos', 'success');
+                                            }
+                                            catch {
+                                                retrySpinner.warn('Aún hay error de permisos');
+                                                logStep('Reintento de build fallido', 'warn');
+                                            }
+                                        }
+                                    }
+                                    catch (fixErr) {
+                                        fixSpinner.fail('No se pudieron arreglar los permisos');
+                                        logStep(`Error arreglando permisos: ${fixErr.message}`, 'error');
+                                        logger_1.log.dim('  Ejecuta manualmente: sudo usermod -aG docker $USER');
+                                    }
+                                }
+                            }
+                            else {
+                                logger_1.log.dim('  Ejecuta: sudo usermod -aG docker $USER');
+                            }
+                        }
+                        logger_1.log.blank();
+                        const { continueWithoutBuild } = await inquirer_1.default.prompt([
+                            {
+                                type: 'confirm',
+                                name: 'continueWithoutBuild',
+                                message: 'El build falló. ¿Continuar sin build y solo levantar contenedores existentes?',
+                                default: false,
+                            },
+                        ]);
+                        if (!continueWithoutBuild) {
+                            logger_1.log.info('Instalación cancelada');
+                            writeInstallLog(targetDir);
+                            return;
+                        }
+                    }
+                }
+                const upSpinner = (0, ora_1.default)('Levantando servicios...').start();
+                logStep('Levantando servicios Docker', 'info');
+                let composeFiles = '-f docker-compose.yml';
+                if (fs_1.default.existsSync(path_1.default.join(targetDir, 'docker-compose.prod.yml'))) {
+                    composeFiles = '-f docker-compose.prod.yml';
+                }
+                if (includeMonitoring) {
+                    const monPath = path_1.default.join(targetDir, 'docker-compose.monitoring.yml');
+                    if (fs_1.default.existsSync(monPath)) {
+                        composeFiles += ` -f docker-compose.monitoring.yml`;
+                    }
+                }
+                try {
+                    (0, child_process_1.execSync)(`${dockerCmd} ${composeFiles} up -d`, { cwd: targetDir, stdio: 'pipe', timeout: 120000 });
+                    upSpinner.succeed('Servicios levantados');
+                    logStep('Servicios Docker levantados', 'success');
                 }
                 catch (err) {
-                    dockerSpinner.fail('Error Docker: ' + err.message);
-                    logger_1.log.dim(`  Ejecuta manualmente: cd ${targetDir} && docker compose up -d`);
+                    upSpinner.fail('Error: ' + err.message);
+                    logStep(`Error levantando servicios: ${err.message}`, 'error');
+                    // Detectar error de permisos de Docker
+                    if (err.message?.includes('permission denied') && err.message?.includes('docker.sock')) {
+                        logger_1.log.blank();
+                        logger_1.log.warn('Error de permisos de Docker detectado');
+                        logger_1.log.dim('  Tu usuario no tiene acceso al socket de Docker');
+                        logger_1.log.blank();
+                        if (!nonInteractive) {
+                            const { fixPermissions } = await inquirer_1.default.prompt([
+                                {
+                                    type: 'confirm',
+                                    name: 'fixPermissions',
+                                    message: '¿Agregar tu usuario al grupo docker para arreglarlo? (requiere sudo)',
+                                    default: true,
+                                },
+                            ]);
+                            if (fixPermissions) {
+                                const fixSpinner = (0, ora_1.default)('Agregando usuario al grupo docker...').start();
+                                logStep('Arreglando permisos de Docker', 'info');
+                                try {
+                                    const user = process.env.USER || process.env.USERNAME || 'root';
+                                    (0, child_process_1.execSync)(`sudo usermod -aG docker ${user}`, { stdio: 'pipe' });
+                                    fixSpinner.succeed('Usuario agregado al grupo docker');
+                                    logStep('Permisos de Docker arreglados', 'success');
+                                    logger_1.log.blank();
+                                    logger_1.log.info('Los cambios se aplican en la próxima sesión');
+                                    logger_1.log.dim(`  Ejecuta: newgrp docker`);
+                                    logger_1.log.dim(`  O cierra sesión y vuelve a entrar`);
+                                    logger_1.log.blank();
+                                    const { retryNow } = await inquirer_1.default.prompt([
+                                        {
+                                            type: 'confirm',
+                                            name: 'retryNow',
+                                            message: '¿Intentar levantar los servicios ahora? (puede fallar hasta que apliquen los permisos)',
+                                            default: false,
+                                        },
+                                    ]);
+                                    if (retryNow) {
+                                        const retrySpinner = (0, ora_1.default)('Reintentando...').start();
+                                        try {
+                                            (0, child_process_1.execSync)(`${dockerCmd} ${composeFiles} up -d`, { cwd: targetDir, stdio: 'pipe', timeout: 120000 });
+                                            retrySpinner.succeed('Servicios levantados');
+                                            logStep('Servicios levantados tras arreglar permisos', 'success');
+                                        }
+                                        catch (retryErr) {
+                                            retrySpinner.warn('Aún hay error de permisos');
+                                            logStep('Reintento fallido, permisos no aplicados aún', 'warn');
+                                            logger_1.log.dim('  Cierra sesión y vuelve a entrar, luego ejecuta:');
+                                            logger_1.log.dim(`  cd ${targetDir} && ${dockerCmd} up -d`);
+                                        }
+                                    }
+                                }
+                                catch (fixErr) {
+                                    fixSpinner.fail('No se pudieron arreglar los permisos');
+                                    logStep(`Error arreglando permisos: ${fixErr.message}`, 'error');
+                                    logger_1.log.dim('  Ejecuta manualmente: sudo usermod -aG docker $USER');
+                                }
+                            }
+                        }
+                        else {
+                            logger_1.log.dim('  Ejecuta: sudo usermod -aG docker $USER');
+                            logger_1.log.dim('  Luego cierra sesión y vuelve a entrar');
+                        }
+                    }
+                    else if (err.message?.includes('Bind for') && err.message?.includes('port is already allocated')) {
+                        // Detectar error de puerto ocupado
+                        logger_1.log.blank();
+                        logger_1.log.warn('Puerto ocupado detectado');
+                        const portMatch = err.message.match(/Bind for [\d.]+:(\d+)/);
+                        const occupiedPort = portMatch ? portMatch[1] : 'desconocido';
+                        logger_1.log.warn(`  Puerto ${occupiedPort} ya está en uso`);
+                        logger_1.log.blank();
+                        if (!nonInteractive) {
+                            const { portAction } = await inquirer_1.default.prompt([
+                                {
+                                    type: 'list',
+                                    name: 'portAction',
+                                    message: '¿Cómo resolverlo?',
+                                    choices: [
+                                        { name: 'Detener el proceso que ocupa el puerto', value: 'stop' },
+                                        { name: 'Cambiar puerto en .env y reintentar', value: 'change' },
+                                        { name: 'Cancelar', value: 'cancel' },
+                                    ],
+                                },
+                            ]);
+                            if (portAction === 'cancel') {
+                                logger_1.log.info('Instalación cancelada');
+                                writeInstallLog(targetDir);
+                                return;
+                            }
+                            if (portAction === 'stop') {
+                                const stopSpinner = (0, ora_1.default)(`Deteniendo proceso en puerto ${occupiedPort}...`).start();
+                                try {
+                                    const pid = (0, child_process_1.execSync)(`lsof -i :${occupiedPort} -sTCP:LISTEN -t 2>/dev/null | head -1`, { stdio: 'pipe' }).toString().trim();
+                                    if (pid) {
+                                        (0, child_process_1.execSync)(`kill -9 ${pid} 2>/dev/null || true`, { stdio: 'pipe' });
+                                        stopSpinner.succeed(`Proceso detenido`);
+                                        logStep(`Puerto ${occupiedPort} liberado`, 'success');
+                                        const { retry } = await inquirer_1.default.prompt([
+                                            { type: 'confirm', name: 'retry', message: '¿Reintentar levantar servicios?', default: true },
+                                        ]);
+                                        if (retry) {
+                                            const retrySpinner = (0, ora_1.default)('Reintentando...').start();
+                                            try {
+                                                (0, child_process_1.execSync)(`${dockerCmd} ${composeFiles} up -d`, { cwd: targetDir, stdio: 'pipe', timeout: 120000 });
+                                                retrySpinner.succeed('Servicios levantados');
+                                                logStep('Servicios levantados tras liberar puerto', 'success');
+                                            }
+                                            catch {
+                                                retrySpinner.fail('Aún hay error');
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        stopSpinner.warn('No se encontró el proceso');
+                                    }
+                                }
+                                catch {
+                                    stopSpinner.fail('No se pudo detener el proceso');
+                                    logger_1.log.dim(`  Manual: sudo lsof -i :${occupiedPort} -t | xargs kill -9`);
+                                }
+                            }
+                            if (portAction === 'change') {
+                                const envPath = path_1.default.join(targetDir, '.env');
+                                if (fs_1.default.existsSync(envPath)) {
+                                    const { newPort } = await inquirer_1.default.prompt([
+                                        { type: 'input', name: 'newPort', message: `Nuevo puerto para reemplazar ${occupiedPort}:`, default: String(parseInt(occupiedPort) + 1) },
+                                    ]);
+                                    let envContent = fs_1.default.readFileSync(envPath, 'utf-8');
+                                    envContent = envContent.replace(new RegExp(`:${occupiedPort}\\b`, 'g'), `:${newPort}`);
+                                    envContent = envContent.replace(new RegExp(`PORT=${occupiedPort}`, 'g'), `PORT=${newPort}`);
+                                    fs_1.default.writeFileSync(envPath, envContent);
+                                    logger_1.log.success(`Puerto cambiado a ${newPort} en .env`);
+                                    logStep(`Puerto ${occupiedPort} → ${newPort}`, 'success');
+                                    const { retry } = await inquirer_1.default.prompt([
+                                        { type: 'confirm', name: 'retry', message: '¿Reintentar levantar servicios?', default: true },
+                                    ]);
+                                    if (retry) {
+                                        const retrySpinner = (0, ora_1.default)('Reintentando...').start();
+                                        try {
+                                            (0, child_process_1.execSync)(`${dockerCmd} ${composeFiles} up -d`, { cwd: targetDir, stdio: 'pipe', timeout: 120000 });
+                                            retrySpinner.succeed('Servicios levantados');
+                                        }
+                                        catch {
+                                            retrySpinner.fail('Aún hay error');
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            logger_1.log.dim(`  Puerto ${occupiedPort} ocupado. Cambia el puerto en .env o detén el proceso.`);
+                        }
+                    }
+                    else {
+                        logger_1.log.dim(`  cd ${targetDir} && ${dockerCmd} up -d`);
+                    }
+                }
+                // Health checks
+                if (opts.healthcheck !== false && (installMode === 'full' || installMode === 'docker')) {
+                    logger_1.log.blank();
+                    const healthSpinner = (0, ora_1.default)('Verificando servicios...').start();
+                    logStep('Ejecutando health checks', 'info');
+                    const webHealthy = await (0, helpers_1.waitForService)('http://localhost:8080', 20, 3000);
+                    const apiHealthy = await (0, helpers_1.waitForService)('http://localhost:3000/api/health', 15, 3000);
+                    if (webHealthy && apiHealthy) {
+                        healthSpinner.succeed('Servicios operativos');
+                        logStep('Health checks: Web OK, API OK', 'success');
+                    }
+                    else {
+                        healthSpinner.warn('Algunos servicios tardan en iniciar');
+                        logStep(`Health checks: Web=${webHealthy ? 'OK' : 'FAIL'}, API=${apiHealthy ? 'OK' : 'FAIL'}`, 'warn');
+                        logger_1.log.dim('  Verifica con: docker compose ps');
+                    }
+                }
+                // Setup DB si es full
+                if (installMode === 'full') {
+                    logger_1.log.blank();
+                    logger_1.log.info('Ejecutando configuración inicial de base de datos...');
+                    logStep('Configurando base de datos', 'info');
+                    try {
+                        (0, child_process_1.execSync)('docker compose exec -T server sh -c "npm run db:push || true"', {
+                            cwd: targetDir,
+                            stdio: 'pipe',
+                            timeout: 60000,
+                        });
+                        logger_1.log.success('Base de datos configurada');
+                        logStep('Base de datos configurada', 'success');
+                    }
+                    catch {
+                        logger_1.log.dim('  Ejecuta manualmente: openfactu setup');
+                        logStep('Configuración de BD omitida', 'warn');
+                    }
+                }
+            }
+            // 11. Instalar como servicio si se pidió
+            if (opts.service) {
+                logger_1.log.blank();
+                logger_1.log.info('Instalando servicio systemd...');
+                try {
+                    const serviceName = 'openfactu';
+                    const unitPath = `/etc/systemd/system/${serviceName}.service`;
+                    const serviceExists = fs_1.default.existsSync(unitPath);
+                    if (serviceExists && !nonInteractive) {
+                        const { overwriteService } = await inquirer_1.default.prompt([
+                            {
+                                type: 'confirm',
+                                name: 'overwriteService',
+                                message: `El servicio ${serviceName} ya existe. ¿Sobrescribir?`,
+                                default: false,
+                            },
+                        ]);
+                        if (!overwriteService) {
+                            logger_1.log.info('Servicio no modificado');
+                        }
+                        else {
+                            installService(targetDir, dockerCmd, serviceName, unitPath);
+                        }
+                    }
+                    else if (serviceExists && nonInteractive) {
+                        logger_1.log.warn(`El servicio ${serviceName} ya existe, sobrescribiendo`);
+                        installService(targetDir, dockerCmd, serviceName, unitPath);
+                    }
+                    else {
+                        installService(targetDir, dockerCmd, serviceName, unitPath);
+                    }
+                }
+                catch (err) {
+                    logger_1.log.warn('No se pudo instalar el servicio: ' + err.message);
                 }
             }
-            // 7. Resumen
+            // 12. Escribir log de instalacion
+            writeInstallLog(targetDir);
+            // 12. Resumen
             const installedPkg = path_1.default.join(targetDir, 'package.json');
             let installedVersion = '?';
             if (fs_1.default.existsSync(installedPkg)) {
@@ -304,20 +1183,35 @@ function registerInstallCommand(program) {
             console.log(`  ${chalk_1.default.dim('Commit:')}     ${chalk_1.default.cyan(installedCommit)}`);
             console.log(`  ${chalk_1.default.dim('Directorio:')} ${chalk_1.default.white(targetDir)}`);
             console.log(`  ${chalk_1.default.dim('Modo:')}       ${chalk_1.default.white(installMode)}`);
+            if (includeMonitoring)
+                console.log(`  ${chalk_1.default.dim('Monitoreo:')}  ${chalk_1.default.green(monitoringServices.join(', '))}`);
             logger_1.log.blank();
+            logStep('Instalación completada exitosamente', 'success');
+            logStep(`Versión: ${installedVersion}, Ref: ${ref}, Commit: ${installedCommit}`, 'info');
             logger_1.log.dim('  Próximos pasos:');
             logger_1.log.dim(`    cd ${targetDir}`);
-            if (installMode === 'docker') {
+            if (installMode !== 'download') {
                 logger_1.log.dim('    openfactu deploy         — Configurar acceso externo');
+                logger_1.log.dim('    openfactu setup          — Configurar base de datos');
                 logger_1.log.dim('    openfactu deploy:status  — Ver estado de servicios');
+                if (includeMonitoring) {
+                    logger_1.log.dim('    openfactu monitoring     — Configurar monitoreo');
+                }
             }
             else {
-                logger_1.log.dim('    docker compose up -d     — Levantar con Docker');
+                logger_1.log.dim(`    ${dockerCmd} up -d         — Levantar con Docker`);
                 logger_1.log.dim('    openfactu deploy         — Configurar acceso externo');
             }
             logger_1.log.blank();
+            logger_1.log.dim(`  Log de instalación: ${chalk_1.default.dim(path_1.default.join(targetDir, '.openfactu', 'install.log'))}`);
+            logger_1.log.blank();
         }
         catch (err) {
+            logStep(`Error fatal: ${err.message}`, 'error');
+            try {
+                writeInstallLog(targetDir || os_1.default.homedir());
+            }
+            catch { }
             logger_1.log.error(err.message);
             process.exitCode = 1;
         }