@openfactu/cli 0.0.7 → 0.0.8

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

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

package/dist/src/commands/doctor.js

@@ -0,0 +1,295 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDoctorCommand = registerDoctorCommand;
+const chalk_1 = __importDefault(require("chalk"));
+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 paths_1 = require("../utils/paths");
+const helpers_1 = require("../utils/helpers");
+function registerDoctorCommand(program) {
+    program
+        .command('doctor')
+        .description('Diagnostico completo del entorno OpenFactu')
+        .option('--path <path>', 'Ruta del proyecto')
+        .option('--json', 'Salida en formato JSON')
+        .action(async (opts) => {
+        console.log();
+        console.log(chalk_1.default.bold.white('  OpenFactu — Doctor'));
+        console.log(chalk_1.default.dim('  ────────────────────────────────────'));
+        console.log();
+        const checks = [];
+        // System info
+        checks.push({
+            category: 'Sistema',
+            name: 'Plataforma',
+            status: 'ok',
+            message: `${os_1.default.type()} ${os_1.default.release()} (${os_1.default.arch()})`,
+        });
+        checks.push({
+            category: 'Sistema',
+            name: 'Node.js',
+            status: 'ok',
+            message: process.version,
+        });
+        checks.push({
+            category: 'Sistema',
+            name: 'Memoria total',
+            status: 'ok',
+            message: (0, helpers_1.formatBytes)(os_1.default.totalmem()),
+        });
+        checks.push({
+            category: 'Sistema',
+            name: 'Memoria libre',
+            status: 'ok',
+            message: (0, helpers_1.formatBytes)(os_1.default.freemem()),
+        });
+        // Preflight checks
+        const root = opts.path || process.cwd();
+        const preflight = (0, helpers_1.runPreflightChecks)(root);
+        for (const check of preflight) {
+            checks.push({
+                category: 'Requisitos',
+                name: check.name,
+                status: check.status === 'pass' ? 'ok' : check.status === 'warn' ? 'warn' : 'error',
+                message: check.message,
+            });
+        }
+        // Project structure
+        try {
+            const projectRoot = (0, paths_1.getProjectRoot)();
+            checks.push({
+                category: 'Proyecto',
+                name: 'Raiz detectada',
+                status: 'ok',
+                message: projectRoot,
+            });
+            // Check key files
+            const keyFiles = [
+                { path: 'package.json', name: 'package.json' },
+                { path: 'docker-compose.yml', name: 'docker-compose.yml' },
+                { path: '.env', name: '.env' },
+                { path: 'apps/web', name: 'apps/web' },
+                { path: 'apps/server', name: 'apps/server' },
+            ];
+            for (const file of keyFiles) {
+                const fullPath = path_1.default.join(projectRoot, file.path);
+                const exists = fs_1.default.existsSync(fullPath);
+                checks.push({
+                    category: 'Proyecto',
+                    name: file.name,
+                    status: exists ? 'ok' : 'warn',
+                    message: exists ? 'Presente' : 'No encontrado',
+                });
+            }
+            // Disk usage
+            const diskUsage = (0, child_process_1.execSync)(`du -sh "${projectRoot}" 2>/dev/null | cut -f1`, { stdio: 'pipe' }).toString().trim();
+            checks.push({
+                category: 'Proyecto',
+                name: 'Tamano del proyecto',
+                status: 'ok',
+                message: diskUsage,
+            });
+            // Disk space available
+            const disk = (0, helpers_1.checkDiskSpace)(projectRoot);
+            checks.push({
+                category: 'Proyecto',
+                name: 'Espacio disponible',
+                status: disk.availableGB >= 10 ? 'ok' : disk.availableGB >= 5 ? 'warn' : 'error',
+                message: `${disk.availableGB}GB libres de ${disk.totalGB}GB`,
+            });
+        }
+        catch (err) {
+            checks.push({
+                category: 'Proyecto',
+                name: 'Raiz del proyecto',
+                status: 'error',
+                message: 'No detectado',
+            });
+        }
+        // Docker status
+        try {
+            const dockerCmd = (0, helpers_1.getDockerComposeCommand)();
+            const dockerInfo = (0, child_process_1.execSync)('docker info --format "{{.ServerVersion}}" 2>/dev/null || echo "unknown"', {
+                stdio: 'pipe',
+            }).toString().trim();
+            checks.push({
+                category: 'Docker',
+                name: 'Version del servidor',
+                status: 'ok',
+                message: dockerInfo,
+            });
+            // Running containers
+            const runningContainers = (0, child_process_1.execSync)('docker ps --format "{{.Names}}" 2>/dev/null || true', {
+                stdio: 'pipe',
+            }).toString().trim();
+            const containerList = runningContainers ? runningContainers.split('\n') : [];
+            checks.push({
+                category: 'Docker',
+                name: 'Contenedores corriendo',
+                status: containerList.length > 0 ? 'ok' : 'warn',
+                message: containerList.length > 0 ? containerList.join(', ') : 'Ninguno',
+            });
+            // Docker images
+            const imageCount = (0, child_process_1.execSync)('docker images --format "{{.ID}}" 2>/dev/null | wc -l', {
+                stdio: 'pipe',
+            }).toString().trim();
+            const dockerDisk = (0, child_process_1.execSync)('docker system df --format "{{.Size}}" 2>/dev/null | head -1 || echo "unknown"', {
+                stdio: 'pipe',
+            }).toString().trim();
+            checks.push({
+                category: 'Docker',
+                name: 'Imagenes',
+                status: 'ok',
+                message: `${imageCount} imagenes, ${dockerDisk} en disco`,
+            });
+            // Docker networks
+            const networks = (0, child_process_1.execSync)('docker network ls --format "{{.Name}}" 2>/dev/null | grep openfactu || true', {
+                stdio: 'pipe',
+            }).toString().trim();
+            checks.push({
+                category: 'Docker',
+                name: 'Redes OpenFactu',
+                status: networks ? 'ok' : 'warn',
+                message: networks || 'Ninguna detectada',
+            });
+            // Docker volumes
+            const volumes = (0, child_process_1.execSync)('docker volume ls --format "{{.Name}}" 2>/dev/null | grep openfactu || true', {
+                stdio: 'pipe',
+            }).toString().trim();
+            checks.push({
+                category: 'Docker',
+                name: 'Volumenes OpenFactu',
+                status: volumes ? 'ok' : 'warn',
+                message: volumes || 'Ninguno detectado',
+            });
+        }
+        catch (err) {
+            checks.push({
+                category: 'Docker',
+                name: 'Estado',
+                status: 'error',
+                message: err.message,
+            });
+        }
+        // Services status
+        try {
+            const projectRoot = (0, paths_1.getProjectRoot)();
+            const dockerCmd = (0, helpers_1.getDockerComposeCommand)();
+            const composeFiles = [
+                'docker-compose.prod.yml',
+                'docker-compose.yml',
+            ];
+            for (const composeFile of composeFiles) {
+                const composePath = path_1.default.join(projectRoot, composeFile);
+                if (fs_1.default.existsSync(composePath)) {
+                    try {
+                        const psOutput = (0, child_process_1.execSync)(`${dockerCmd} -f ${composeFile} ps --format json 2>/dev/null || true`, {
+                            cwd: projectRoot,
+                            stdio: 'pipe',
+                        }).toString().trim();
+                        if (psOutput) {
+                            const services = psOutput.split('\n').filter(Boolean);
+                            checks.push({
+                                category: 'Servicios',
+                                name: composeFile,
+                                status: 'ok',
+                                message: `${services.length} servicios definidos`,
+                            });
+                        }
+                    }
+                    catch {
+                        checks.push({
+                            category: 'Servicios',
+                            name: composeFile,
+                            status: 'warn',
+                            message: 'No se pudo obtener estado',
+                        });
+                    }
+                }
+            }
+        }
+        catch { }
+        // Systemd services
+        try {
+            const services = (0, child_process_1.execSync)('systemctl list-units --type=service --state=running 2>/dev/null | grep openfactu || true', {
+                stdio: 'pipe',
+            }).toString().trim();
+            if (services) {
+                checks.push({
+                    category: 'Systemd',
+                    name: 'Servicios activos',
+                    status: 'ok',
+                    message: services,
+                });
+            }
+        }
+        catch { }
+        // Git status
+        try {
+            const projectRoot = (0, paths_1.getProjectRoot)();
+            if (fs_1.default.existsSync(path_1.default.join(projectRoot, '.git'))) {
+                const branch = (0, child_process_1.execSync)('git branch --show-current 2>/dev/null || echo "detached"', {
+                    cwd: projectRoot,
+                    stdio: 'pipe',
+                }).toString().trim();
+                const status = (0, child_process_1.execSync)('git status --porcelain 2>/dev/null | wc -l', {
+                    cwd: projectRoot,
+                    stdio: 'pipe',
+                }).toString().trim();
+                checks.push({
+                    category: 'Git',
+                    name: 'Branch',
+                    status: 'ok',
+                    message: branch,
+                });
+                checks.push({
+                    category: 'Git',
+                    name: 'Cambios locales',
+                    status: parseInt(status) === 0 ? 'ok' : 'warn',
+                    message: parseInt(status) === 0 ? 'Limpio' : `${status} archivos modificados`,
+                });
+            }
+        }
+        catch { }
+        // Display results
+        if (opts.json) {
+            console.log(JSON.stringify(checks, null, 2));
+            return;
+        }
+        const categories = [...new Set(checks.map(c => c.category))];
+        for (const category of categories) {
+            const categoryChecks = checks.filter(c => c.category === category);
+            console.log(chalk_1.default.bold(`  ${category}`));
+            console.log(chalk_1.default.dim('  ' + '─'.repeat(50)));
+            for (const check of categoryChecks) {
+                const icon = check.status === 'ok'
+                    ? chalk_1.default.green('✓')
+                    : check.status === 'warn'
+                        ? chalk_1.default.yellow('⚠')
+                        : chalk_1.default.red('✗');
+                console.log(`  ${icon} ${chalk_1.default.dim(check.name.padEnd(25))} ${check.message}`);
+            }
+            console.log();
+        }
+        // Summary
+        const errors = checks.filter(c => c.status === 'error');
+        const warns = checks.filter(c => c.status === 'warn');
+        if (errors.length === 0 && warns.length === 0) {
+            console.log(chalk_1.default.bold.green('  Todo esta correcto'));
+        }
+        else {
+            if (errors.length > 0) {
+                console.log(chalk_1.default.bold.red(`  ${errors.length} error(es) encontrado(s)`));
+            }
+            if (warns.length > 0) {
+                console.log(chalk_1.default.bold.yellow(`  ${warns.length} advertencia(s)`));
+            }
+        }
+        console.log();
+    });
+}

package/dist/src/commands/install-quick.d.ts

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

package/dist/src/commands/install-quick.js

@@ -0,0 +1,249 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerInstallQuickCommand = registerInstallQuickCommand;
+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 helpers_1 = require("../utils/helpers");
+const REPO_URL = 'https://github.com/OpenFactu/platform.git';
+function registerInstallQuickCommand(program) {
+    program
+        .command('install:quick')
+        .description('Instalacion rapida de OpenFactu (non-interactive)')
+        .option('--tag <tag>', 'Version especifica', 'latest')
+        .option('--dir <dir>', 'Directorio de instalacion')
+        .option('--no-docker', 'No levantar Docker')
+        .option('--monitoring', 'Incluir monitoreo')
+        .option('--analytics', 'Incluir analitica completa')
+        .option('--service', 'Instalar como servicio systemd')
+        .option('--generate-env', 'Generar .env con credenciales seguras')
+        .action(async (opts) => {
+        console.log();
+        console.log(chalk_1.default.bold.white('  OpenFactu — Instalacion Rapida'));
+        console.log(chalk_1.default.dim('  ────────────────────────────────────'));
+        console.log();
+        try {
+            let targetDir = opts.dir || path_1.default.join(os_1.default.homedir(), 'openfactu');
+            const dockerCmd = (0, helpers_1.getDockerComposeCommand)();
+            // Check Docker
+            const hasDocker = (() => {
+                try {
+                    (0, child_process_1.execSync)('docker --version', { stdio: 'pipe' });
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            })();
+            if (!hasDocker && opts.docker !== false) {
+                logger_1.log.error('Docker es requerido para la instalacion rapida');
+                logger_1.log.dim('  Instala Docker: https://docs.docker.com/get-docker/');
+                return;
+            }
+            // Clone
+            const cloneSpinner = (0, ora_1.default)('Clonando repositorio...').start();
+            let ref = opts.tag;
+            if (ref === 'latest') {
+                try {
+                    const releases = JSON.parse((0, child_process_1.execSync)('curl -s https://api.github.com/repos/OpenFactu/platform/releases | head -100', { stdio: 'pipe' }).toString());
+                    const stable = releases.filter((r) => !r.prerelease && !r.draft);
+                    if (stable.length > 0) {
+                        ref = stable[0].tag_name;
+                    }
+                    else {
+                        ref = 'main';
+                    }
+                }
+                catch {
+                    ref = 'main';
+                }
+            }
+            const isTag = ref.startsWith('v');
+            // Verificar si el directorio ya existe
+            if (fs_1.default.existsSync(targetDir)) {
+                const contents = fs_1.default.readdirSync(targetDir);
+                if (contents.length > 0) {
+                    logger_1.log.warn(`El directorio ${targetDir} ya existe y no esta vacio`);
+                    const { action } = await inquirer_1.default.prompt([
+                        {
+                            type: 'list',
+                            name: 'action',
+                            message: 'Que quieres hacer?',
+                            choices: [
+                                { name: 'Sobrescribir (eliminar y reinstalar)', value: 'overwrite' },
+                                { name: 'Usar directorio existente (solo configurar)', value: 'reuse' },
+                                { name: 'Elegir otro directorio', value: 'newdir' },
+                                { name: 'Cancelar', value: 'cancel' },
+                            ],
+                        },
+                    ]);
+                    if (action === 'cancel') {
+                        logger_1.log.info('Instalacion cancelada');
+                        return;
+                    }
+                    if (action === 'overwrite') {
+                        const removeSpinner = (0, ora_1.default)('Limpiando directorio...').start();
+                        (0, child_process_1.execSync)(`rm -rf "${targetDir}"`, { stdio: 'pipe' });
+                        fs_1.default.mkdirSync(targetDir, { recursive: true });
+                        removeSpinner.succeed('Directorio limpiado');
+                    }
+                    if (action === 'newdir') {
+                        const { newDir } = await inquirer_1.default.prompt([
+                            { type: 'input', name: 'newDir', message: 'Nuevo directorio:', default: path_1.default.join(os_1.default.homedir(), 'openfactu-2') },
+                        ]);
+                        targetDir = path_1.default.resolve(newDir);
+                        fs_1.default.mkdirSync(targetDir, { recursive: true });
+                    }
+                    if (action === 'reuse') {
+                        logger_1.log.info('Usando directorio existente');
+                    }
+                }
+            }
+            else {
+                fs_1.default.mkdirSync(targetDir, { recursive: true });
+            }
+            const cloneCmd = isTag
+                ? `git clone --depth 1 --branch ${ref} ${REPO_URL} "${targetDir}"`
+                : `git clone --branch ${ref} ${REPO_URL} "${targetDir}"`;
+            try {
+                (0, child_process_1.execSync)(cloneCmd, { stdio: 'pipe', timeout: 120000 });
+                cloneSpinner.succeed('Repositorio clonado');
+            }
+            catch (err) {
+                if (err.message?.includes('ya existe') || err.message?.includes('already exists')) {
+                    cloneSpinner.warn('Directorio ya existe, usando existente');
+                }
+                else {
+                    cloneSpinner.fail('Error al clonar: ' + err.message);
+                    return;
+                }
+            }
+            // Generate .env
+            if (opts.generateEnv) {
+                const envSpinner = (0, ora_1.default)('Generando configuracion...').start();
+                const dbPassword = (0, helpers_1.generatePassword)(24);
+                const jwtSecret = (0, helpers_1.generatePassword)(48);
+                const envContent = `POSTGRES_USER=openfactu
+POSTGRES_PASSWORD=${dbPassword}
+POSTGRES_DB=openfactudb
+DATABASE_URL=postgresql://openfactu:${encodeURIComponent(dbPassword)}@db:5432/openfactudb
+SERVER_PORT=3000
+WEB_PORT=8080
+DB_PORT=5432
+JWT_SECRET=${jwtSecret}
+SESSION_SECRET=${(0, helpers_1.generatePassword)(32)}
+NODE_ENV=production
+HOST=localhost
+CORS_ORIGIN=http://localhost:8080
+VITE_API_URL=http://localhost:3000
+ADMIN_EMAIL=admin@openfactu.local
+ADMIN_PASSWORD=${(0, helpers_1.generatePassword)(16)}
+`;
+                fs_1.default.writeFileSync(path_1.default.join(targetDir, '.env'), envContent);
+                envSpinner.succeed('.env generado');
+                logger_1.log.blank();
+                logger_1.log.info(`${chalk_1.default.dim('Admin:')} admin@openfactu.local / ${chalk_1.default.yellow('ver .env')}`);
+                logger_1.log.blank();
+            }
+            else {
+                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);
+                }
+            }
+            // Docker build and up
+            if (opts.docker !== false) {
+                const buildSpinner = (0, ora_1.default)('Construyendo contenedores...').start();
+                try {
+                    (0, child_process_1.execSync)(`${dockerCmd} build`, { cwd: targetDir, stdio: 'pipe', timeout: 300000 });
+                    buildSpinner.succeed('Contenedores construidos');
+                }
+                catch (err) {
+                    buildSpinner.fail('Error en build');
+                    logger_1.log.dim(`  cd ${targetDir} && ${dockerCmd} build`);
+                }
+                const upSpinner = (0, ora_1.default)('Levantando servicios...').start();
+                try {
+                    let composeFlags = '-f docker-compose.yml';
+                    if (fs_1.default.existsSync(path_1.default.join(targetDir, 'docker-compose.prod.yml'))) {
+                        composeFlags = '-f docker-compose.prod.yml';
+                    }
+                    if (opts.monitoring) {
+                        const monPath = path_1.default.join(targetDir, 'docker-compose.monitoring.yml');
+                        if (fs_1.default.existsSync(monPath)) {
+                            composeFlags += ' -f docker-compose.monitoring.yml';
+                        }
+                    }
+                    (0, child_process_1.execSync)(`${dockerCmd} ${composeFlags} up -d`, {
+                        cwd: targetDir,
+                        stdio: 'pipe',
+                        timeout: 120000,
+                    });
+                    upSpinner.succeed('Servicios levantados');
+                }
+                catch (err) {
+                    upSpinner.fail('Error: ' + err.message);
+                }
+            }
+            // Install as service
+            if (opts.service) {
+                const svcSpinner = (0, ora_1.default)('Instalando servicio systemd...').start();
+                try {
+                    const unitContent = `[Unit]
+Description=OpenFactu ERP Platform
+After=docker.service network-online.target
+Requires=docker.service
+
+[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=30
+
+[Install]
+WantedBy=multi-user.target
+`;
+                    const tempPath = '/tmp/openfactu.service';
+                    const unitPath = '/etc/systemd/system/openfactu.service';
+                    fs_1.default.writeFileSync(tempPath, unitContent);
+                    (0, child_process_1.execSync)(`sudo mv ${tempPath} ${unitPath}`, { stdio: 'pipe' });
+                    (0, child_process_1.execSync)('sudo systemctl daemon-reload', { stdio: 'pipe' });
+                    (0, child_process_1.execSync)('sudo systemctl enable openfactu', { stdio: 'pipe' });
+                    svcSpinner.succeed('Servicio instalado');
+                }
+                catch (err) {
+                    svcSpinner.fail('No se pudo instalar el servicio');
+                }
+            }
+            // Summary
+            logger_1.log.blank();
+            console.log(chalk_1.default.bold.green('  Instalacion rapida completada'));
+            console.log(chalk_1.default.dim('  ────────────────────────────────────'));
+            logger_1.log.info(`Directorio: ${chalk_1.default.cyan(targetDir)}`);
+            logger_1.log.info(`Version: ${chalk_1.default.cyan(ref)}`);
+            logger_1.log.blank();
+            logger_1.log.dim('  Comandos utiles:');
+            logger_1.log.dim(`    cd ${targetDir}`);
+            logger_1.log.dim('    openfactu setup');
+            logger_1.log.dim('    openfactu deploy');
+            logger_1.log.dim('    openfactu doctor');
+            logger_1.log.blank();
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/src/commands/install-script.d.ts

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