@openfactu/cli 0.0.7 → 0.0.8

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

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

package/dist/src/commands/monitoring.js

@@ -0,0 +1,352 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMonitoringCommand = registerMonitoringCommand;
+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 logger_1 = require("../utils/logger");
+const paths_1 = require("../utils/paths");
+const helpers_1 = require("../utils/helpers");
+const monitoring_1 = require("../utils/monitoring");
+function readEnv(envPath) {
+    const env = {};
+    if (!fs_1.default.existsSync(envPath))
+        return env;
+    const lines = fs_1.default.readFileSync(envPath, 'utf-8').split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const eqIdx = trimmed.indexOf('=');
+        if (eqIdx > 0) {
+            env[trimmed.substring(0, eqIdx).trim()] = trimmed.substring(eqIdx + 1).trim();
+        }
+    }
+    return env;
+}
+function writeEnv(envPath, env) {
+    const lines = [];
+    for (const [key, value] of Object.entries(env)) {
+        lines.push(`${key}=${value}`);
+    }
+    fs_1.default.writeFileSync(envPath, lines.join('\n') + '\n');
+}
+function registerMonitoringCommand(program) {
+    // ── openfactu monitoring ──
+    program
+        .command('monitoring')
+        .description('Configura el stack de monitoreo y analitica')
+        .option('--generate-compose', 'Generar docker-compose.monitoring.yml')
+        .option('--with-analytics', 'Incluir stack completo de analitica')
+        .action(async (opts) => {
+        console.log();
+        console.log(chalk_1.default.bold.white('  OpenFactu — Configurar Monitoreo'));
+        console.log(chalk_1.default.dim('  ────────────────────────────────────'));
+        console.log();
+        try {
+            const root = (0, paths_1.getProjectRoot)();
+            const envPath = path_1.default.join(root, '.env');
+            const env = readEnv(envPath);
+            const includeAnalytics = opts.withAnalytics || false;
+            const { services } = await inquirer_1.default.prompt([
+                {
+                    type: 'checkbox',
+                    name: 'services',
+                    message: 'Servicios a activar:',
+                    choices: (0, monitoring_1.monitoringChoices)({ analytics: includeAnalytics }),
+                },
+            ]);
+            const serviceSet = new Set(services);
+            const { customizePorts } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'customizePorts',
+                    message: 'Personalizar puertos?',
+                    default: false,
+                },
+            ]);
+            const ports = {};
+            if (customizePorts) {
+                const portQuestions = [];
+                if (serviceSet.has('pgadmin'))
+                    portQuestions.push({ type: 'input', name: 'PGADMIN_PORT', message: 'Puerto pgAdmin:', default: env.PGADMIN_PORT || '5050' });
+                if (serviceSet.has('grafana'))
+                    portQuestions.push({ type: 'input', name: 'GRAFANA_PORT', message: 'Puerto Grafana:', default: env.GRAFANA_PORT || '3001' });
+                if (serviceSet.has('prometheus'))
+                    portQuestions.push({ type: 'input', name: 'PROMETHEUS_PORT', message: 'Puerto Prometheus:', default: env.PROMETHEUS_PORT || '9090' });
+                if (serviceSet.has('loki'))
+                    portQuestions.push({ type: 'input', name: 'LOKI_PORT', message: 'Puerto Loki:', default: env.LOKI_PORT || '3100' });
+                if (serviceSet.has('cadvisor'))
+                    portQuestions.push({ type: 'input', name: 'CADVISOR_PORT', message: 'Puerto cAdvisor:', default: env.CADVISOR_PORT || '8081' });
+                if (serviceSet.has('node-exporter'))
+                    portQuestions.push({ type: 'input', name: 'NODE_EXPORTER_PORT', message: 'Puerto Node Exporter:', default: env.NODE_EXPORTER_PORT || '9100' });
+                if (serviceSet.has('portainer'))
+                    portQuestions.push({ type: 'input', name: 'PORTAINER_PORT', message: 'Puerto Portainer:', default: env.PORTAINER_PORT || '9000' });
+                if (serviceSet.has('alertmanager'))
+                    portQuestions.push({ type: 'input', name: 'ALERTMANAGER_PORT', message: 'Puerto Alertmanager:', default: env.ALERTMANAGER_PORT || '9093' });
+                if (portQuestions.length > 0) {
+                    const answers = await inquirer_1.default.prompt(portQuestions);
+                    Object.assign(ports, answers);
+                }
+            }
+            const { customizeCredentials } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'customizeCredentials',
+                    message: 'Personalizar credenciales?',
+                    default: false,
+                },
+            ]);
+            if (customizeCredentials) {
+                if (serviceSet.has('pgadmin')) {
+                    const creds = await inquirer_1.default.prompt([
+                        { type: 'input', name: 'PGADMIN_EMAIL', message: 'Email pgAdmin:', default: env.PGADMIN_EMAIL || 'admin@openfactu.local' },
+                        { type: 'password', name: 'PGADMIN_PASSWORD', message: 'Password pgAdmin:', default: env.PGADMIN_PASSWORD || 'admin' },
+                    ]);
+                    Object.assign(ports, creds);
+                }
+                if (serviceSet.has('grafana')) {
+                    const creds = await inquirer_1.default.prompt([
+                        { type: 'input', name: 'GRAFANA_USER', message: 'Usuario Grafana:', default: env.GRAFANA_USER || 'admin' },
+                        { type: 'password', name: 'GRAFANA_PASSWORD', message: 'Password Grafana:', default: env.GRAFANA_PASSWORD || 'admin' },
+                    ]);
+                    Object.assign(ports, creds);
+                }
+            }
+            // Generate compose file
+            if (opts.generateCompose) {
+                const composeSpinner = (0, ora_1.default)('Generando docker-compose.monitoring.yml...').start();
+                const composeContent = (0, monitoring_1.generateMonitoringCompose)(serviceSet);
+                const composePath = path_1.default.join(root, 'docker-compose.monitoring.yml');
+                fs_1.default.writeFileSync(composePath, composeContent);
+                composeSpinner.succeed('docker-compose.monitoring.yml generado');
+                (0, monitoring_1.writeMonitoringConfigs)(root, serviceSet);
+            }
+            // Save config
+            const envSpinner = (0, ora_1.default)('Guardando configuracion...').start();
+            for (const [key, value] of Object.entries(ports)) {
+                env[key] = value;
+            }
+            env.MONITORING_SERVICES = services.join(',');
+            writeEnv(envPath, env);
+            envSpinner.succeed('Configuracion guardada en .env');
+            logger_1.log.blank();
+            const { start } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'start',
+                    message: 'Levantar los servicios de monitoreo ahora?',
+                    default: true,
+                },
+            ]);
+            if (start) {
+                const dockerCmd = (0, helpers_1.getDockerComposeCommand)();
+                const composePath = path_1.default.join(root, 'docker-compose.monitoring.yml');
+                if (!fs_1.default.existsSync(composePath)) {
+                    logger_1.log.warn('docker-compose.monitoring.yml no existe');
+                    logger_1.log.dim('  Ejecuta: openfactu monitoring --generate-compose');
+                    return;
+                }
+                const upSpinner = (0, ora_1.default)('Levantando servicios...').start();
+                try {
+                    const scaleFlags = [];
+                    for (const svc of monitoring_1.ALL_MONITORING_SERVICES) {
+                        scaleFlags.push(`--scale ${svc}=${serviceSet.has(svc) ? 1 : 0}`);
+                    }
+                    (0, child_process_1.execSync)(`${dockerCmd} -f docker-compose.monitoring.yml up -d ${scaleFlags.join(' ')}`, { cwd: root, stdio: 'pipe', timeout: 120000 });
+                    upSpinner.succeed('Servicios levantados');
+                }
+                catch (err) {
+                    upSpinner.fail('Error: ' + err.message);
+                }
+            }
+            logger_1.log.blank();
+            console.log(chalk_1.default.bold.green('  Monitoreo configurado'));
+            console.log(chalk_1.default.dim('  ────────────────────────────────────'));
+            logger_1.log.blank();
+            const urls = [];
+            if (serviceSet.has('pgadmin'))
+                urls.push(['pgAdmin', `http://localhost:${env.PGADMIN_PORT || '5050'}`]);
+            if (serviceSet.has('grafana'))
+                urls.push(['Grafana', `http://localhost:${env.GRAFANA_PORT || '3001'}`]);
+            if (serviceSet.has('prometheus'))
+                urls.push(['Prometheus', `http://localhost:${env.PROMETHEUS_PORT || '9090'}`]);
+            if (serviceSet.has('loki'))
+                urls.push(['Loki', `http://localhost:${env.LOKI_PORT || '3100'}`]);
+            if (serviceSet.has('cadvisor'))
+                urls.push(['cAdvisor', `http://localhost:${env.CADVISOR_PORT || '8081'}`]);
+            if (serviceSet.has('node-exporter'))
+                urls.push(['Node Exporter', `http://localhost:${env.NODE_EXPORTER_PORT || '9100'}`]);
+            if (serviceSet.has('portainer'))
+                urls.push(['Portainer', `http://localhost:${env.PORTAINER_PORT || '9000'}`]);
+            if (serviceSet.has('alertmanager'))
+                urls.push(['Alertmanager', `http://localhost:${env.ALERTMANAGER_PORT || '9093'}`]);
+            for (const [name, url] of urls) {
+                logger_1.log.info(`${chalk_1.default.dim(name.padEnd(15))} ${chalk_1.default.cyan(url)}`);
+            }
+            logger_1.log.blank();
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+            process.exitCode = 1;
+        }
+    });
+    // ── openfactu monitoring:up ──
+    program
+        .command('monitoring:up')
+        .description('Levanta los servicios de monitoreo')
+        .action(async () => {
+        try {
+            const root = (0, paths_1.getProjectRoot)();
+            const dockerCmd = (0, helpers_1.getDockerComposeCommand)();
+            const composeFile = path_1.default.join(root, 'docker-compose.monitoring.yml');
+            if (!fs_1.default.existsSync(composeFile)) {
+                logger_1.log.error('docker-compose.monitoring.yml no encontrado');
+                logger_1.log.dim('  Ejecuta: openfactu monitoring --generate-compose');
+                return;
+            }
+            const envPath = path_1.default.join(root, '.env');
+            const env = readEnv(envPath);
+            const services = (env.MONITORING_SERVICES || 'pgadmin,grafana,prometheus,loki,portainer').split(',');
+            const serviceSet = new Set(services);
+            const spinner = (0, ora_1.default)('Levantando servicios...').start();
+            const scaleFlags = [];
+            for (const svc of monitoring_1.ALL_MONITORING_SERVICES) {
+                scaleFlags.push(`--scale ${svc}=${serviceSet.has(svc) ? 1 : 0}`);
+            }
+            (0, child_process_1.execSync)(`${dockerCmd} -f docker-compose.monitoring.yml up -d ${scaleFlags.join(' ')}`, { cwd: root, stdio: 'pipe', timeout: 120000 });
+            spinner.succeed('Servicios levantados');
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+        }
+    });
+    // ── openfactu monitoring:down ──
+    program
+        .command('monitoring:down')
+        .description('Para los servicios de monitoreo')
+        .action(async () => {
+        try {
+            const root = (0, paths_1.getProjectRoot)();
+            const dockerCmd = (0, helpers_1.getDockerComposeCommand)();
+            const spinner = (0, ora_1.default)('Parando servicios...').start();
+            (0, child_process_1.execSync)(`${dockerCmd} -f docker-compose.monitoring.yml down`, { cwd: root, stdio: 'pipe' });
+            spinner.succeed('Servicios parados');
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+        }
+    });
+    // ── openfactu monitoring:status ──
+    program
+        .command('monitoring:status')
+        .description('Estado de los servicios de monitoreo')
+        .action(async () => {
+        try {
+            const root = (0, paths_1.getProjectRoot)();
+            const dockerCmd = (0, helpers_1.getDockerComposeCommand)();
+            const output = (0, child_process_1.execSync)(`${dockerCmd} -f docker-compose.monitoring.yml ps`, { cwd: root }).toString();
+            console.log(output);
+            const envPath = path_1.default.join(root, '.env');
+            const env = readEnv(envPath);
+            logger_1.log.blank();
+            if (env.PGADMIN_PORT)
+                logger_1.log.info(`pgAdmin:    http://localhost:${env.PGADMIN_PORT}`);
+            if (env.GRAFANA_PORT)
+                logger_1.log.info(`Grafana:    http://localhost:${env.GRAFANA_PORT}`);
+            if (env.PROMETHEUS_PORT)
+                logger_1.log.info(`Prometheus: http://localhost:${env.PROMETHEUS_PORT}`);
+            if (env.LOKI_PORT)
+                logger_1.log.info(`Loki:       http://localhost:${env.LOKI_PORT}`);
+            if (env.CADVISOR_PORT)
+                logger_1.log.info(`cAdvisor:   http://localhost:${env.CADVISOR_PORT}`);
+            if (env.NODE_EXPORTER_PORT)
+                logger_1.log.info(`Node Exp:   http://localhost:${env.NODE_EXPORTER_PORT}`);
+            if (env.PORTAINER_PORT)
+                logger_1.log.info(`Portainer:  http://localhost:${env.PORTAINER_PORT}`);
+        }
+        catch (err) {
+            logger_1.log.error('Servicios no disponibles');
+            logger_1.log.dim('  ' + err.message);
+        }
+    });
+    // ── openfactu monitoring:config ──
+    program
+        .command('monitoring:config')
+        .description('Cambiar configuracion del monitoreo')
+        .action(async () => {
+        try {
+            const root = (0, paths_1.getProjectRoot)();
+            const envPath = path_1.default.join(root, '.env');
+            const env = readEnv(envPath);
+            const { key } = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'key',
+                    message: 'Variable a cambiar:',
+                    choices: [
+                        { name: `PGADMIN_PORT (${env.PGADMIN_PORT || '5050'})`, value: 'PGADMIN_PORT' },
+                        { name: `GRAFANA_PORT (${env.GRAFANA_PORT || '3001'})`, value: 'GRAFANA_PORT' },
+                        { name: `PROMETHEUS_PORT (${env.PROMETHEUS_PORT || '9090'})`, value: 'PROMETHEUS_PORT' },
+                        { name: `LOKI_PORT (${env.LOKI_PORT || '3100'})`, value: 'LOKI_PORT' },
+                        { name: `CADVISOR_PORT (${env.CADVISOR_PORT || '8081'})`, value: 'CADVISOR_PORT' },
+                        { name: `NODE_EXPORTER_PORT (${env.NODE_EXPORTER_PORT || '9100'})`, value: 'NODE_EXPORTER_PORT' },
+                        { name: `PORTAINER_PORT (${env.PORTAINER_PORT || '9000'})`, value: 'PORTAINER_PORT' },
+                        { name: `PGADMIN_EMAIL (${env.PGADMIN_EMAIL || 'admin@openfactu.local'})`, value: 'PGADMIN_EMAIL' },
+                        { name: `GRAFANA_USER (${env.GRAFANA_USER || 'admin'})`, value: 'GRAFANA_USER' },
+                    ],
+                },
+            ]);
+            const { value } = await inquirer_1.default.prompt([
+                { type: 'input', name: 'value', message: `Nuevo valor para ${key}:`, default: env[key] },
+            ]);
+            env[key] = value;
+            writeEnv(envPath, env);
+            logger_1.log.success(`${key} actualizado a: ${value}`);
+            logger_1.log.info('Reinicia con: openfactu monitoring:down && openfactu monitoring:up');
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+        }
+    });
+    // ── openfactu monitoring:generate ──
+    program
+        .command('monitoring:generate')
+        .description('Generar docker-compose.monitoring.yml sin interaccion')
+        .option('--services <services>', 'Servicios separados por coma')
+        .option('--analytics', 'Incluir stack completo de analitica')
+        .action(async (opts) => {
+        try {
+            const root = (0, paths_1.getProjectRoot)();
+            const envPath = path_1.default.join(root, '.env');
+            const env = readEnv(envPath);
+            let services;
+            if (opts.services) {
+                services = opts.services.split(',');
+            }
+            else if (opts.analytics) {
+                services = (0, monitoring_1.fullMonitoringServices)();
+            }
+            else {
+                services = (0, monitoring_1.basicMonitoringServices)();
+            }
+            const serviceSet = new Set(services);
+            const composeContent = (0, monitoring_1.generateMonitoringCompose)(serviceSet);
+            const composePath = path_1.default.join(root, 'docker-compose.monitoring.yml');
+            fs_1.default.writeFileSync(composePath, composeContent);
+            logger_1.log.success('docker-compose.monitoring.yml generado');
+            (0, monitoring_1.writeMonitoringConfigs)(root, serviceSet);
+            env.MONITORING_SERVICES = services.join(',');
+            writeEnv(envPath, env);
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+        }
+    });
+}

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

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