@openfactu/cli 0.0.7 → 0.0.8

package/README.md

@@ -11,20 +11,71 @@ npm i -g @openfactu/cli
 ## Inicio rapido
 
 ```bash
-openfactu install        # Descarga e instala OpenFactu
-openfactu deploy         # Configura acceso externo
-openfactu setup          # Configuracion inicial de BD
+openfactu install              # Wizard interactivo completo
+openfactu install:quick        # Instalacion rapida (non-interactive)
+openfactu deploy               # Configura acceso externo
+openfactu setup                # Configuracion inicial de BD
+openfactu doctor               # Diagnostico del entorno
 ```
 
 ## Comandos
 
-### Instalacion y actualizacion
+### Instalacion
 
 | Comando | Descripcion |
 |---------|-------------|
-| `openfactu install [dir]` | Descarga desde releases de GitHub con Docker |
+| `openfactu install [dir]` | Wizard completo: version, modo, Docker, contraseña BD, monitoreo (selección de servicios), servicio |
+| `openfactu install:quick` | Instalacion rapida non-interactive |
+| `openfactu install:script` | Generar script shell standalone para instalar sin CLI |
 | `openfactu update` | Actualiza sin perder datos |
 | `openfactu update:check` | Comprueba si hay versiones nuevas |
+| `openfactu uninstall` | Desinstalacion limpia con backup opcional |
+
+#### Opciones de `install`
+
+```bash
+openfactu install --tag v1.0.0           # Version especifica
+openfactu install --branch develop       # Desde branch
+openfactu install --mode full            # Modo: full, docker, minimal, download
+openfactu install --generate-env         # No preguntar: genera credenciales aleatorias
+openfactu install --monitoring           # Monitoreo: set basico (pgAdmin, Grafana, Prometheus, Portainer)
+openfactu install --with-analytics       # Monitoreo: set completo (+ Loki, Promtail, cAdvisor, Node Exporter)
+openfactu install --service              # Instalar como servicio systemd
+openfactu install -y                     # Non-interactive, acepta defaults
+openfactu install --no-preflight         # Saltar chequeos previos
+```
+
+> **Credenciales:** en modo interactivo, `install` pide la **contraseña de PostgreSQL**
+> (pulsa Enter para generar una segura) y escribe un `.env` completo **antes** del primer
+> arranque, de modo que Postgres se inicializa con ella. `deploy` reutiliza esa contraseña;
+> cambiarla luego no afecta a un volumen ya creado.
+>
+> **Monitoreo:** si activas monitoreo en modo interactivo, eliges con un **checkbox** qué
+> servicios instalar (pgAdmin, Grafana, Prometheus, Loki, Promtail, cAdvisor, Node Exporter,
+> Portainer, Alertmanager). Con `--monitoring`/`--with-analytics` se usan sets predefinidos.
+
+#### Modos de instalacion
+
+- **full** — Build + up + setup de BD + health checks
+- **docker** — Build + up (sin setup de BD)
+- **minimal** — Solo up, sin build
+- **download** — Solo descarga el codigo
+
+### Servicio systemd
+
+| Comando | Descripcion |
+|---------|-------------|
+| `openfactu service install` | Instalar como servicio systemd con auto-start |
+| `openfactu service start` | Iniciar servicio |
+| `openfactu service stop` | Detener servicio |
+| `openfactu service restart` | Reiniciar servicio |
+| `openfactu service status` | Ver estado |
+| `openfactu service logs` | Ver logs del servicio |
+| `openfactu service uninstall` | Remover servicio |
+
+```bash
+openfactu service install --restart always --healthcheck --with-monitoring
+```
 
 ### Despliegue
 
@@ -37,6 +88,61 @@ openfactu setup          # Configuracion inicial de BD
 | `openfactu stop` | Para todos los servicios |
 | `openfactu restart` | Reinicia sin rebuild |
 
+### Monitoreo y Analitica
+
+| Comando | Descripcion |
+|---------|-------------|
+| `openfactu monitoring` | Wizard para configurar stack de monitoreo |
+| `openfactu monitoring:generate` | Generar compose sin interaccion |
+| `openfactu monitoring:up` | Levantar servicios de monitoreo |
+| `openfactu monitoring:down` | Parar servicios de monitoreo |
+| `openfactu monitoring:status` | Estado de los servicios |
+| `openfactu monitoring:config` | Cambiar configuracion |
+
+#### Servicios disponibles
+
+- **pgAdmin** — Gestion de base de datos (puerto 5050)
+- **Grafana** — Dashboards y visualizacion (puerto 3001)
+- **Prometheus** — Metricas y alertas (puerto 9090)
+- **Loki** — Agregacion de logs (puerto 3100)
+- **Promtail** — Envio de logs a Loki
+- **cAdvisor** — Metricas de contenedores Docker (puerto 8081)
+- **Node Exporter** — Metricas del host (puerto 9100)
+- **Portainer** — Gestion de Docker (puerto 9000)
+- **Alertmanager** — Gestion de alertas (puerto 9093)
+
+```bash
+openfactu monitoring --with-analytics        # Stack completo de analitica
+openfactu monitoring:generate --analytics    # Generar compose con todo
+```
+
+### Backup y Restore
+
+| Comando | Descripcion |
+|---------|-------------|
+| `openfactu backup create` | Crear backup completo |
+| `openfactu backup list` | Listar backups disponibles |
+| `openfactu backup restore` | Restaurar desde backup |
+| `openfactu backup delete` | Eliminar backup |
+
+```bash
+openfactu backup create --name produccion-2024
+openfactu backup create --db-only              # Solo base de datos
+openfactu backup restore --name produccion-2024
+openfactu uninstall --keep-backup              # Backup antes de desinstalar
+```
+
+### Diagnostico
+
+| Comando | Descripcion |
+|---------|-------------|
+| `openfactu doctor` | Diagnostico completo del entorno |
+
+```bash
+openfactu doctor          # Verificacion visual
+openfactu doctor --json   # Salida en JSON para scripts
+```
+
 ### Base de datos
 
 | Comando | Descripcion |
@@ -74,6 +180,56 @@ openfactu setup          # Configuracion inicial de BD
 |---------|-------------|
 | `openfactu version` | Versiones del sistema |
 
+## Flujos de trabajo
+
+### Instalacion para produccion
+
+```bash
+# 1. Instalacion completa con todo
+openfactu install --mode full --monitoring --with-analytics --service --generate-env
+
+# 2. Verificar que todo esta bien
+openfactu doctor
+
+# 3. Configurar acceso externo
+openfactu deploy
+
+# 4. Configurar base de datos
+openfactu setup
+```
+
+### Instalacion rapida para desarrollo
+
+```bash
+openfactu install:quick --generate-env
+```
+
+### Instalar en servidor remoto sin CLI
+
+```bash
+# Generar script en tu maquina
+openfactu install:script --output deploy.sh --monitoring --service
+
+# Subir y ejecutar en el servidor
+scp deploy.sh usuario@servidor:~/
+ssh usuario@servidor "chmod +x ~/deploy.sh && ~/deploy.sh"
+```
+
+### Backup antes de actualizar
+
+```bash
+openfactu backup create --name pre-update
+openfactu update
+# Si algo sale mal:
+openfactu backup restore --name pre-update
+```
+
+### Instalar como servicio con auto-start
+
+```bash
+openfactu service install --restart always --healthcheck --healthcheck-interval 5min
+```
+
 ## Desarrollo remoto de plugins
 
 ```bash

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

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

package/dist/src/commands/backup.js

@@ -0,0 +1,424 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBackupCommand = registerBackupCommand;
+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 getBackupDir() {
+    return path_1.default.join(os_1.default.homedir(), 'openfactu-backups');
+}
+function listBackups() {
+    const backupDir = getBackupDir();
+    if (!fs_1.default.existsSync(backupDir))
+        return [];
+    const entries = fs_1.default.readdirSync(backupDir, { withFileTypes: true });
+    const backups = [];
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            const fullPath = path_1.default.join(backupDir, entry.name);
+            const stat = fs_1.default.statSync(fullPath);
+            const size = (0, child_process_1.execSync)(`du -sh "${fullPath}" 2>/dev/null | cut -f1`, { stdio: 'pipe' }).toString().trim();
+            backups.push({
+                name: entry.name,
+                path: fullPath,
+                date: stat.mtime.toLocaleString('es-ES'),
+                size,
+            });
+        }
+    }
+    return backups.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
+}
+function registerBackupCommand(program) {
+    const backupCmd = program
+        .command('backup')
+        .description('Backup y restore de OpenFactu');
+    backupCmd
+        .command('create')
+        .description('Crear backup completo')
+        .option('--name <name>', 'Nombre del backup')
+        .option('--db-only', 'Solo backup de base de datos')
+        .option('--config-only', 'Solo backup de configuracion')
+        .option('--path <path>', 'Ruta del proyecto')
+        .option('--output <dir>', 'Directorio de salida')
+        .action(async (opts) => {
+        console.log();
+        console.log(chalk_1.default.bold.white('  OpenFactu — Crear Backup'));
+        console.log(chalk_1.default.dim('  ────────────────────────────────────'));
+        console.log();
+        try {
+            const root = opts.path || (0, paths_1.getProjectRoot)();
+            const dockerCmd = (0, helpers_1.getDockerComposeCommand)();
+            const backupName = opts.name || `backup-${(0, helpers_1.timestamp)()}`;
+            const outputDir = opts.output || getBackupDir();
+            const backupPath = path_1.default.join(outputDir, backupName);
+            (0, helpers_1.ensureDir)(outputDir);
+            (0, helpers_1.ensureDir)(backupPath);
+            const dbOnly = opts.dbOnly || false;
+            const configOnly = opts.configOnly || false;
+            // Database backup
+            if (!configOnly) {
+                const dbSpinner = (0, ora_1.default)('Backup de base de datos...').start();
+                try {
+                    const dbBackupPath = path_1.default.join(backupPath, 'database.sql');
+                    const dbContainer = (0, child_process_1.execSync)(`${dockerCmd} ps --format '{{.Names}}' | grep db || true`, {
+                        cwd: root,
+                        stdio: 'pipe',
+                    }).toString().trim();
+                    if (dbContainer) {
+                        (0, child_process_1.execSync)(`${dockerCmd} exec -T ${dbContainer} pg_dump -U openfactu openfactudb > "${dbBackupPath}"`, { cwd: root, stdio: 'pipe', timeout: 300000 });
+                        const dbSize = fs_1.default.statSync(dbBackupPath).size;
+                        dbSpinner.succeed(`BD backup: ${(dbSize / 1024 / 1024).toFixed(2)}MB`);
+                    }
+                    else {
+                        dbSpinner.warn('Contenedor de BD no encontrado');
+                    }
+                }
+                catch (err) {
+                    dbSpinner.fail('Error en backup de BD: ' + err.message);
+                }
+            }
+            // Config backup
+            if (!dbOnly) {
+                const configSpinner = (0, ora_1.default)('Backup de configuracion...').start();
+                try {
+                    const configFiles = [
+                        '.env',
+                        'docker-compose.yml',
+                        'docker-compose.prod.yml',
+                        'docker-compose.prod.monitoring.yml',
+                        'docker-compose.monitoring.yml',
+                    ];
+                    for (const file of configFiles) {
+                        const src = path_1.default.join(root, file);
+                        if (fs_1.default.existsSync(src)) {
+                            fs_1.default.copyFileSync(src, path_1.default.join(backupPath, file));
+                        }
+                    }
+                    // Monitoring configs
+                    const monitoringDir = path_1.default.join(root, 'monitoring');
+                    if (fs_1.default.existsSync(monitoringDir)) {
+                        const dest = path_1.default.join(backupPath, 'monitoring');
+                        (0, child_process_1.execSync)(`cp -r "${monitoringDir}" "${dest}"`, { stdio: 'pipe' });
+                    }
+                    configSpinner.succeed('Configuracion respaldada');
+                }
+                catch (err) {
+                    configSpinner.fail('Error en backup de config: ' + err.message);
+                }
+            }
+            // Storage backup (optional, can be large)
+            if (!dbOnly && !configOnly) {
+                const { backupStorage } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'backupStorage',
+                        message: 'Incluir storage (archivos, documentos)? Puede ser grande',
+                        default: false,
+                    },
+                ]);
+                if (backupStorage) {
+                    const storageSpinner = (0, ora_1.default)('Backup de storage...').start();
+                    try {
+                        const storageSrc = path_1.default.join(root, 'storage');
+                        if (fs_1.default.existsSync(storageSrc)) {
+                            const storageDest = path_1.default.join(backupPath, 'storage');
+                            (0, child_process_1.execSync)(`cp -r "${storageSrc}" "${storageDest}"`, { stdio: 'pipe', timeout: 300000 });
+                            const size = (0, child_process_1.execSync)(`du -sh "${storageDest}" | cut -f1`, { stdio: 'pipe' }).toString().trim();
+                            storageSpinner.succeed(`Storage backup: ${size}`);
+                        }
+                        else {
+                            storageSpinner.warn('Directorio storage no encontrado');
+                        }
+                    }
+                    catch (err) {
+                        storageSpinner.fail('Error en backup de storage');
+                    }
+                }
+            }
+            // Create manifest
+            const manifest = {
+                name: backupName,
+                date: new Date().toISOString(),
+                project: root,
+                dbOnly,
+                configOnly,
+                files: fs_1.default.readdirSync(backupPath),
+            };
+            fs_1.default.writeFileSync(path_1.default.join(backupPath, 'manifest.json'), JSON.stringify(manifest, null, 2));
+            const totalSize = (0, child_process_1.execSync)(`du -sh "${backupPath}" | cut -f1`, { stdio: 'pipe' }).toString().trim();
+            logger_1.log.blank();
+            console.log(chalk_1.default.bold.green('  Backup completado'));
+            console.log(chalk_1.default.dim('  ────────────────────────────────────'));
+            logger_1.log.info(`Nombre: ${chalk_1.default.cyan(backupName)}`);
+            logger_1.log.info(`Ubicacion: ${chalk_1.default.cyan(backupPath)}`);
+            logger_1.log.info(`Tamano: ${chalk_1.default.cyan(totalSize)}`);
+            logger_1.log.blank();
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+            process.exitCode = 1;
+        }
+    });
+    backupCmd
+        .command('list')
+        .description('Listar backups disponibles')
+        .action(async () => {
+        try {
+            const backups = listBackups();
+            if (backups.length === 0) {
+                logger_1.log.info('No hay backups disponibles');
+                return;
+            }
+            console.log();
+            console.log(chalk_1.default.bold.white('  OpenFactu — Backups'));
+            console.log(chalk_1.default.dim('  ────────────────────────────────────'));
+            console.log();
+            for (const backup of backups) {
+                console.log(`  ${chalk_1.default.cyan(backup.name)}`);
+                console.log(`    ${chalk_1.default.dim('Fecha:')} ${backup.date}`);
+                console.log(`    ${chalk_1.default.dim('Tamano:')} ${backup.size}`);
+                console.log(`    ${chalk_1.default.dim('Ruta:')} ${chalk_1.default.dim(backup.path)}`);
+                console.log();
+            }
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+        }
+    });
+    backupCmd
+        .command('restore')
+        .description('Restaurar desde un backup')
+        .option('--name <name>', 'Nombre del backup a restaurar')
+        .option('--path <path>', 'Ruta del proyecto destino')
+        .option('--db-only', 'Solo restaurar base de datos')
+        .option('--config-only', 'Solo restaurar configuracion')
+        .option('--force', 'No preguntar confirmacion')
+        .action(async (opts) => {
+        console.log();
+        console.log(chalk_1.default.bold.white('  OpenFactu — Restaurar Backup'));
+        console.log(chalk_1.default.dim('  ────────────────────────────────────'));
+        console.log();
+        try {
+            const backups = listBackups();
+            if (backups.length === 0) {
+                logger_1.log.error('No hay backups disponibles');
+                return;
+            }
+            let backupPath;
+            if (opts.name) {
+                const backup = backups.find(b => b.name === opts.name);
+                if (!backup) {
+                    logger_1.log.error(`Backup no encontrado: ${opts.name}`);
+                    return;
+                }
+                backupPath = backup.path;
+            }
+            else {
+                const choices = backups.map(b => ({
+                    name: `${chalk_1.default.cyan(b.name)} ${chalk_1.default.dim(`(${b.date}, ${b.size})`)}`,
+                    value: b.path,
+                }));
+                const { selected } = await inquirer_1.default.prompt([
+                    {
+                        type: 'list',
+                        name: 'selected',
+                        message: 'Selecciona el backup a restaurar:',
+                        choices,
+                    },
+                ]);
+                backupPath = selected;
+            }
+            const root = opts.path || (0, paths_1.getProjectRoot)();
+            const dockerCmd = (0, helpers_1.getDockerComposeCommand)();
+            const dbOnly = opts.dbOnly || false;
+            const configOnly = opts.configOnly || false;
+            if (!opts.force) {
+                logger_1.log.info(`Backup: ${chalk_1.default.cyan(backupPath)}`);
+                logger_1.log.info(`Destino: ${chalk_1.default.cyan(root)}`);
+                logger_1.log.blank();
+                const { confirm } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'confirm',
+                        message: 'Restaurar backup? Esto puede sobrescribir datos existentes',
+                        default: false,
+                    },
+                ]);
+                if (!confirm)
+                    return;
+            }
+            // Restore database
+            if (!configOnly) {
+                const dbBackup = path_1.default.join(backupPath, 'database.sql');
+                if (fs_1.default.existsSync(dbBackup)) {
+                    const dbSpinner = (0, ora_1.default)('Restaurando base de datos...').start();
+                    try {
+                        const dbContainer = (0, child_process_1.execSync)(`${dockerCmd} ps --format '{{.Names}}' | grep db || true`, {
+                            cwd: root,
+                            stdio: 'pipe',
+                        }).toString().trim();
+                        if (dbContainer) {
+                            (0, child_process_1.execSync)(`${dockerCmd} exec -T ${dbContainer} psql -U openfactu openfactudb < "${dbBackup}"`, { cwd: root, stdio: 'pipe', timeout: 300000 });
+                            dbSpinner.succeed('Base de datos restaurada');
+                        }
+                        else {
+                            dbSpinner.warn('Contenedor de BD no encontrado');
+                        }
+                    }
+                    catch (err) {
+                        dbSpinner.fail('Error al restaurar BD');
+                    }
+                }
+            }
+            // Restore config
+            if (!dbOnly) {
+                const configSpinner = (0, ora_1.default)('Restaurando configuracion...').start();
+                try {
+                    const configFiles = [
+                        '.env',
+                        'docker-compose.yml',
+                        'docker-compose.prod.yml',
+                        'docker-compose.prod.monitoring.yml',
+                        'docker-compose.monitoring.yml',
+                    ];
+                    for (const file of configFiles) {
+                        const src = path_1.default.join(backupPath, file);
+                        if (fs_1.default.existsSync(src)) {
+                            fs_1.default.copyFileSync(src, path_1.default.join(root, file));
+                        }
+                    }
+                    const monitoringSrc = path_1.default.join(backupPath, 'monitoring');
+                    if (fs_1.default.existsSync(monitoringSrc)) {
+                        const monitoringDest = path_1.default.join(root, 'monitoring');
+                        (0, child_process_1.execSync)(`cp -r "${monitoringSrc}" "${monitoringDest}"`, { stdio: 'pipe' });
+                    }
+                    configSpinner.succeed('Configuracion restaurada');
+                }
+                catch (err) {
+                    configSpinner.fail('Error al restaurar config');
+                }
+            }
+            // Restore storage
+            const storageSrc = path_1.default.join(backupPath, 'storage');
+            if (fs_1.default.existsSync(storageSrc)) {
+                const { restoreStorage } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'restoreStorage',
+                        message: 'Restaurar storage?',
+                        default: false,
+                    },
+                ]);
+                if (restoreStorage) {
+                    const storageSpinner = (0, ora_1.default)('Restaurando storage...').start();
+                    try {
+                        const storageDest = path_1.default.join(root, 'storage');
+                        (0, child_process_1.execSync)(`cp -r "${storageSrc}"/* "${storageDest}/" 2>/dev/null || cp -r "${storageSrc}" "${storageDest}"`, {
+                            stdio: 'pipe',
+                            timeout: 300000,
+                        });
+                        storageSpinner.succeed('Storage restaurado');
+                    }
+                    catch {
+                        storageSpinner.fail('Error al restaurar storage');
+                    }
+                }
+            }
+            logger_1.log.blank();
+            console.log(chalk_1.default.bold.green('  Restauracion completada'));
+            console.log(chalk_1.default.dim('  ────────────────────────────────────'));
+            logger_1.log.dim('  Reinicia los servicios con: openfactu restart');
+            logger_1.log.blank();
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+            process.exitCode = 1;
+        }
+    });
+    backupCmd
+        .command('delete')
+        .description('Eliminar un backup')
+        .option('--name <name>', 'Nombre del backup')
+        .option('--all', 'Eliminar todos los backups')
+        .option('--force', 'No preguntar confirmacion')
+        .action(async (opts) => {
+        try {
+            const backups = listBackups();
+            if (backups.length === 0) {
+                logger_1.log.info('No hay backups para eliminar');
+                return;
+            }
+            if (opts.all) {
+                if (!opts.force) {
+                    const { confirm } = await inquirer_1.default.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'confirm',
+                            message: `Eliminar ${backups.length} backups?`,
+                            default: false,
+                        },
+                    ]);
+                    if (!confirm)
+                        return;
+                }
+                const spinner = (0, ora_1.default)('Eliminando todos los backups...').start();
+                (0, child_process_1.execSync)(`rm -rf "${getBackupDir()}"`, { stdio: 'pipe' });
+                spinner.succeed('Todos los backups eliminados');
+            }
+            else {
+                let backupPath;
+                if (opts.name) {
+                    const backup = backups.find(b => b.name === opts.name);
+                    if (!backup) {
+                        logger_1.log.error(`Backup no encontrado: ${opts.name}`);
+                        return;
+                    }
+                    backupPath = backup.path;
+                }
+                else {
+                    const choices = backups.map(b => ({
+                        name: `${chalk_1.default.cyan(b.name)} ${chalk_1.default.dim(`(${b.date}, ${b.size})`)}`,
+                        value: b.path,
+                    }));
+                    const { selected } = await inquirer_1.default.prompt([
+                        {
+                            type: 'list',
+                            name: 'selected',
+                            message: 'Selecciona el backup a eliminar:',
+                            choices,
+                        },
+                    ]);
+                    backupPath = selected;
+                }
+                if (!opts.force) {
+                    const { confirm } = await inquirer_1.default.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'confirm',
+                            message: `Eliminar backup ${path_1.default.basename(backupPath)}?`,
+                            default: false,
+                        },
+                    ]);
+                    if (!confirm)
+                        return;
+                }
+                const spinner = (0, ora_1.default)('Eliminando backup...').start();
+                (0, child_process_1.execSync)(`rm -rf "${backupPath}"`, { stdio: 'pipe' });
+                spinner.succeed('Backup eliminado');
+            }
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+        }
+    });
+}