@openfactu/cli 0.0.7 → 0.0.8

package/dist/src/commands/service.js

@@ -0,0 +1,402 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerServiceCommand = registerServiceCommand;
+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 getServiceName(name) {
+    return `openfactu${name !== 'openfactu' ? `-${name}` : ''}`;
+}
+function generateUnitFile(serviceName, workDir, composeFile, options) {
+    const dockerCmd = (0, helpers_1.getDockerComposeCommand)();
+    const user = options.user || os_1.default.userInfo().username;
+    const envFile = path_1.default.join(workDir, '.env');
+    let composeFlags = `-f ${composeFile}`;
+    if (options.includeMonitoring && options.monitoringComposeFile) {
+        composeFlags += ` -f ${options.monitoringComposeFile}`;
+    }
+    let envVars = '';
+    if (options.environment) {
+        for (const [key, value] of Object.entries(options.environment)) {
+            envVars += `Environment="${key}=${value}"\n`;
+        }
+    }
+    return `[Unit]
+Description=OpenFactu ${serviceName} Service
+After=docker.service network-online.target
+Requires=docker.service
+Wants=network-online.target
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+WorkingDirectory=${workDir}
+User=${user}
+ExecStart=${dockerCmd} ${composeFlags} up -d
+ExecStop=${dockerCmd} ${composeFlags} down
+ExecReload=${dockerCmd} ${composeFlags} restart
+Restart=${options.restartPolicy}
+RestartSec=30
+TimeoutStartSec=300
+TimeoutStopSec=120
+
+${envVars}
+EnvironmentFile=${envFile}
+
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=${serviceName}
+
+[Install]
+WantedBy=multi-user.target
+`;
+}
+function generateTimerFile(serviceName, interval) {
+    return `[Unit]
+Description=OpenFactu ${serviceName} Health Check Timer
+
+[Timer]
+OnBootSec=5min
+OnUnitActiveSec=${interval}
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`;
+}
+function generateHealthCheckScript(workDir) {
+    const dockerCmd = (0, helpers_1.getDockerComposeCommand)();
+    return `#!/bin/bash
+# OpenFactu Health Check Script
+set -e
+
+cd "${workDir}"
+
+# Check if containers are running
+FAILED=$(${dockerCmd} ps --format '{{.Name}}:{{.Status}}' | grep -v "Up" || true)
+
+if [ -n "$FAILED" ]; then
+  echo "$(date): Some containers are not running:"
+  echo "$FAILED"
+  echo "Attempting restart..."
+  ${dockerCmd} restart
+  exit 1
+fi
+
+echo "$(date): All containers healthy"
+exit 0
+`;
+}
+function registerServiceCommand(program) {
+    const serviceCmd = program
+        .command('service')
+        .description('Gestionar OpenFactu como servicio del sistema');
+    serviceCmd
+        .command('install')
+        .description('Instalar OpenFactu como servicio systemd')
+        .option('--name <name>', 'Nombre del servicio', 'openfactu')
+        .option('--restart <policy>', 'Politica de reinicio (no, on-failure, always)', 'on-failure')
+        .option('--with-monitoring', 'Incluir servicios de monitoreo')
+        .option('--healthcheck', 'Agregar health check automatico')
+        .option('--healthcheck-interval <interval>', 'Intervalo del health check', '5min')
+        .option('--user <user>', 'Usuario para ejecutar el servicio')
+        .option('--path <path>', 'Ruta del proyecto OpenFactu')
+        .action(async (opts) => {
+        console.log();
+        console.log(chalk_1.default.bold.white('  OpenFactu — Instalar Servicio'));
+        console.log(chalk_1.default.dim('  ────────────────────────────────────'));
+        console.log();
+        if (!(0, helpers_1.isSystemdAvailable)()) {
+            logger_1.log.error('systemd no esta disponible en este sistema');
+            logger_1.log.dim('  Este comando solo funciona en Linux con systemd');
+            return;
+        }
+        try {
+            const root = opts.path || (0, paths_1.getProjectRoot)();
+            const serviceName = getServiceName(opts.name);
+            // Detectar compose files
+            const composeFiles = [];
+            const possibleFiles = [
+                'docker-compose.prod.yml',
+                'docker-compose.yml',
+            ];
+            for (const f of possibleFiles) {
+                if (fs_1.default.existsSync(path_1.default.join(root, f))) {
+                    composeFiles.push(f);
+                }
+            }
+            if (composeFiles.length === 0) {
+                logger_1.log.error('No se encontro docker-compose.yml en el proyecto');
+                return;
+            }
+            const mainCompose = composeFiles[0];
+            // Monitoring
+            let includeMonitoring = opts.withMonitoring || false;
+            let monitoringCompose;
+            if (!includeMonitoring) {
+                const { addMonitoring } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'addMonitoring',
+                        message: 'Incluir stack de monitoreo en el servicio?',
+                        default: false,
+                    },
+                ]);
+                includeMonitoring = addMonitoring;
+            }
+            if (includeMonitoring) {
+                const monFiles = [
+                    'docker-compose.prod.monitoring.yml',
+                    'docker-compose.monitoring.yml',
+                ];
+                for (const f of monFiles) {
+                    if (fs_1.default.existsSync(path_1.default.join(root, f))) {
+                        monitoringCompose = f;
+                        break;
+                    }
+                }
+                if (!monitoringCompose) {
+                    logger_1.log.warn('No se encontro compose de monitoreo, se omitira');
+                }
+            }
+            // Confirmar configuracion
+            logger_1.log.blank();
+            logger_1.log.info(`${chalk_1.default.dim('Servicio:')} ${chalk_1.default.cyan(serviceName)}`);
+            logger_1.log.info(`${chalk_1.default.dim('Directorio:')} ${chalk_1.default.cyan(root)}`);
+            logger_1.log.info(`${chalk_1.default.dim('Compose:')} ${chalk_1.default.cyan(mainCompose)}`);
+            logger_1.log.info(`${chalk_1.default.dim('Reinicio:')} ${chalk_1.default.cyan(opts.restart)}`);
+            logger_1.log.blank();
+            const { confirm } = await inquirer_1.default.prompt([
+                { type: 'confirm', name: 'confirm', message: 'Instalar servicio?', default: true },
+            ]);
+            if (!confirm)
+                return;
+            // Generar unit file
+            const spinner = (0, ora_1.default)('Generando unit file...').start();
+            const unitContent = generateUnitFile(serviceName, root, mainCompose, {
+                restartPolicy: opts.restart,
+                includeMonitoring: includeMonitoring && !!monitoringCompose,
+                monitoringComposeFile: monitoringCompose,
+                user: opts.user,
+            });
+            const unitPath = `/etc/systemd/system/${serviceName}.service`;
+            const tempPath = `/tmp/${serviceName}.service`;
+            fs_1.default.writeFileSync(tempPath, unitContent);
+            // Instalar con sudo
+            (0, child_process_1.execSync)(`sudo mv ${tempPath} ${unitPath}`, { stdio: 'pipe' });
+            (0, child_process_1.execSync)('sudo systemctl daemon-reload', { stdio: 'pipe' });
+            spinner.succeed('Unit file instalado');
+            // Health check opcional
+            if (opts.healthcheck) {
+                const hcSpinner = (0, ora_1.default)('Configurando health check...').start();
+                const scriptPath = path_1.default.join(root, '.openfactu-healthcheck.sh');
+                fs_1.default.mkdirSync(path_1.default.join(root), { recursive: true });
+                fs_1.default.writeFileSync(scriptPath, generateHealthCheckScript(root));
+                (0, child_process_1.execSync)(`chmod +x "${scriptPath}"`, { stdio: 'pipe' });
+                const timerName = `${serviceName}-healthcheck`;
+                const timerContent = generateTimerFile(serviceName, opts.healthcheckInterval);
+                const timerPath = `/etc/systemd/system/${timerName}.timer`;
+                const serviceContent = `[Unit]
+Description=OpenFactu Health Check
+
+[Service]
+Type=oneshot
+ExecStart=${scriptPath}
+`;
+                const servicePath = `/etc/systemd/system/${timerName}.service`;
+                fs_1.default.writeFileSync(`/tmp/${timerName}.timer`, timerContent);
+                fs_1.default.writeFileSync(`/tmp/${timerName}.service`, serviceContent);
+                (0, child_process_1.execSync)(`sudo mv /tmp/${timerName}.timer ${timerPath}`, { stdio: 'pipe' });
+                (0, child_process_1.execSync)(`sudo mv /tmp/${timerName}.service ${servicePath}`, { stdio: 'pipe' });
+                (0, child_process_1.execSync)('sudo systemctl daemon-reload', { stdio: 'pipe' });
+                (0, child_process_1.execSync)(`sudo systemctl enable ${timerName}.timer`, { stdio: 'pipe' });
+                hcSpinner.succeed('Health check configurado');
+            }
+            // Enable service
+            const enableSpinner = (0, ora_1.default)('Habilitando servicio...').start();
+            (0, child_process_1.execSync)(`sudo systemctl enable ${serviceName}`, { stdio: 'pipe' });
+            enableSpinner.succeed('Servicio habilitado');
+            logger_1.log.blank();
+            console.log(chalk_1.default.bold.green('  Servicio instalado'));
+            console.log(chalk_1.default.dim('  ────────────────────────────────────'));
+            logger_1.log.blank();
+            logger_1.log.dim('  Comandos utiles:');
+            logger_1.log.dim(`    sudo systemctl start ${serviceName}`);
+            logger_1.log.dim(`    sudo systemctl stop ${serviceName}`);
+            logger_1.log.dim(`    sudo systemctl restart ${serviceName}`);
+            logger_1.log.dim(`    sudo systemctl status ${serviceName}`);
+            logger_1.log.dim(`    journalctl -u ${serviceName} -f`);
+            logger_1.log.blank();
+            const { startNow } = await inquirer_1.default.prompt([
+                { type: 'confirm', name: 'startNow', message: 'Iniciar servicio ahora?', default: true },
+            ]);
+            if (startNow) {
+                const startSpinner = (0, ora_1.default)('Iniciando servicio...').start();
+                try {
+                    (0, child_process_1.execSync)(`sudo systemctl start ${serviceName}`, { stdio: 'pipe' });
+                    startSpinner.succeed('Servicio iniciado');
+                }
+                catch (err) {
+                    startSpinner.fail('Error al iniciar');
+                    logger_1.log.dim(`  sudo systemctl status ${serviceName}`);
+                }
+            }
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+            process.exitCode = 1;
+        }
+    });
+    serviceCmd
+        .command('status')
+        .description('Ver estado del servicio')
+        .option('--name <name>', 'Nombre del servicio', 'openfactu')
+        .action(async (opts) => {
+        try {
+            const serviceName = getServiceName(opts.name);
+            const output = (0, child_process_1.execSync)(`systemctl status ${serviceName} 2>&1 || true`, { stdio: 'pipe' }).toString();
+            console.log(output);
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+        }
+    });
+    serviceCmd
+        .command('start')
+        .description('Iniciar servicio')
+        .option('--name <name>', 'Nombre del servicio', 'openfactu')
+        .action(async (opts) => {
+        try {
+            const serviceName = getServiceName(opts.name);
+            const spinner = (0, ora_1.default)('Iniciando servicio...').start();
+            (0, child_process_1.execSync)(`sudo systemctl start ${serviceName}`, { stdio: 'pipe' });
+            spinner.succeed('Servicio iniciado');
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+        }
+    });
+    serviceCmd
+        .command('stop')
+        .description('Detener servicio')
+        .option('--name <name>', 'Nombre del servicio', 'openfactu')
+        .action(async (opts) => {
+        try {
+            const serviceName = getServiceName(opts.name);
+            const spinner = (0, ora_1.default)('Deteniendo servicio...').start();
+            (0, child_process_1.execSync)(`sudo systemctl stop ${serviceName}`, { stdio: 'pipe' });
+            spinner.succeed('Servicio detenido');
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+        }
+    });
+    serviceCmd
+        .command('restart')
+        .description('Reiniciar servicio')
+        .option('--name <name>', 'Nombre del servicio', 'openfactu')
+        .action(async (opts) => {
+        try {
+            const serviceName = getServiceName(opts.name);
+            const spinner = (0, ora_1.default)('Reiniciando servicio...').start();
+            (0, child_process_1.execSync)(`sudo systemctl restart ${serviceName}`, { stdio: 'pipe' });
+            spinner.succeed('Servicio reiniciado');
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+        }
+    });
+    serviceCmd
+        .command('uninstall')
+        .description('Remover servicio systemd')
+        .option('--name <name>', 'Nombre del servicio', 'openfactu')
+        .option('--keep-data', 'Mantener datos del proyecto')
+        .action(async (opts) => {
+        console.log();
+        console.log(chalk_1.default.bold.white('  OpenFactu — Remover Servicio'));
+        console.log(chalk_1.default.dim('  ────────────────────────────────────'));
+        console.log();
+        try {
+            const serviceName = getServiceName(opts.name);
+            const { confirm } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: `Remover servicio ${serviceName}?`,
+                    default: false,
+                },
+            ]);
+            if (!confirm)
+                return;
+            const spinner = (0, ora_1.default)('Removiendo servicio...').start();
+            (0, child_process_1.execSync)(`sudo systemctl stop ${serviceName} 2>/dev/null || true`, { stdio: 'pipe' });
+            (0, child_process_1.execSync)(`sudo systemctl disable ${serviceName} 2>/dev/null || true`, { stdio: 'pipe' });
+            const unitPath = `/etc/systemd/system/${serviceName}.service`;
+            if (fs_1.default.existsSync(unitPath)) {
+                (0, child_process_1.execSync)(`sudo rm ${unitPath}`, { stdio: 'pipe' });
+            }
+            // Remover health check si existe
+            const timerName = `${serviceName}-healthcheck`;
+            const timerPath = `/etc/systemd/system/${timerName}.timer`;
+            const hcServicePath = `/etc/systemd/system/${timerName}.service`;
+            if (fs_1.default.existsSync(timerPath))
+                (0, child_process_1.execSync)(`sudo rm ${timerPath}`, { stdio: 'pipe' });
+            if (fs_1.default.existsSync(hcServicePath))
+                (0, child_process_1.execSync)(`sudo rm ${hcServicePath}`, { stdio: 'pipe' });
+            (0, child_process_1.execSync)('sudo systemctl daemon-reload', { stdio: 'pipe' });
+            spinner.succeed('Servicio removido');
+            if (!opts.keepData) {
+                const { removeData } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'removeData',
+                        message: 'Remover tambien los contenedores Docker?',
+                        default: false,
+                    },
+                ]);
+                if (removeData) {
+                    try {
+                        const root = (0, paths_1.getProjectRoot)();
+                        const dockerCmd = (0, helpers_1.getDockerComposeCommand)();
+                        (0, child_process_1.execSync)(`${dockerCmd} down`, { cwd: root, stdio: 'pipe' });
+                        logger_1.log.success('Contenedores removidos');
+                    }
+                    catch {
+                        logger_1.log.warn('No se pudieron remover los contenedores');
+                    }
+                }
+            }
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+        }
+    });
+    serviceCmd
+        .command('logs')
+        .description('Ver logs del servicio')
+        .option('--name <name>', 'Nombre del servicio', 'openfactu')
+        .option('-f, --follow', 'Seguir logs en tiempo real')
+        .option('-n, --lines <number>', 'Numero de lineas', '100')
+        .action(async (opts) => {
+        try {
+            const serviceName = getServiceName(opts.name);
+            const follow = opts.follow ? ' -f' : '';
+            (0, child_process_1.execSync)(`journalctl -u ${serviceName}${follow} -n ${opts.lines}`, {
+                stdio: 'inherit',
+            });
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+        }
+    });
+}

package/dist/src/commands/setup.js

@@ -8,7 +8,6 @@ const chalk_1 = __importDefault(require("chalk"));
 const ora_1 = __importDefault(require("ora"));
 const inquirer_1 = __importDefault(require("inquirer"));
 const crypto_1 = __importDefault(require("crypto"));
-const bcrypt_1 = __importDefault(require("bcrypt"));
 const db_1 = require("../utils/db");
 const logger_1 = require("../utils/logger");
 function registerSetupCommand(program) {
@@ -66,7 +65,13 @@ function registerSetupCommand(program) {
                         mask: '*',
                     },
                 ]);
-                const hashedPassword = await bcrypt_1.default.hash(adminPassword, 10);
+                const hashedPassword = await new Promise((resolve, reject) => {
+                    crypto_1.default.scrypt(adminPassword, 'openfactu-salt', 64, (err, derivedKey) => {
+                        if (err)
+                            reject(err);
+                        resolve(derivedKey.toString('hex'));
+                    });
+                });
                 await publicDb.insert((0, db_1.schema)().globalUsers).values({
                     id: crypto_1.default.randomUUID(),
                     email: 'admin@openfactu.com',

package/dist/src/commands/sync-ports.d.ts

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