@openfactu/cli 0.0.7 → 0.0.8

package/dist/src/utils/helpers.js

@@ -0,0 +1,244 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePassword = generatePassword;
+exports.generateSlug = generateSlug;
+exports.checkDiskSpace = checkDiskSpace;
+exports.checkPortInUse = checkPortInUse;
+exports.getRunningServices = getRunningServices;
+exports.runPreflightChecks = runPreflightChecks;
+exports.waitForService = waitForService;
+exports.getDockerComposeCommand = getDockerComposeCommand;
+exports.isLinux = isLinux;
+exports.isSystemdAvailable = isSystemdAvailable;
+exports.formatBytes = formatBytes;
+exports.timestamp = timestamp;
+exports.ensureDir = ensureDir;
+exports.copyDirRecursive = copyDirRecursive;
+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 crypto_1 = __importDefault(require("crypto"));
+function generatePassword(length = 32) {
+    // Solo alfanumericos: los simbolos (! @ # $ % ^ & *) rompen el stack.
+    //  - '$' dispara la interpolacion de variables de Docker Compose al leer el
+    //    .env, vaciando la contraseña y haciendo que Postgres caiga al default.
+    //  - '@ # % / : ?' rompen el parseo del connection string en DATABASE_URL.
+    // Con 62 caracteres y longitud >= 24 la entropia sigue siendo de sobra (>140 bits).
+    const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+    let result = '';
+    const bytes = crypto_1.default.randomBytes(length);
+    for (let i = 0; i < length; i++) {
+        result += chars[bytes[i] % chars.length];
+    }
+    return result;
+}
+function generateSlug(length = 12) {
+    return crypto_1.default.randomBytes(length).toString('hex').slice(0, length);
+}
+function checkDiskSpace(dir) {
+    try {
+        const output = (0, child_process_1.execSync)(`df -BG "${dir}" | tail -1`, { stdio: 'pipe' }).toString();
+        const parts = output.trim().split(/\s+/);
+        return {
+            availableGB: parseInt(parts[3]) || 0,
+            totalGB: parseInt(parts[1]) || 0,
+        };
+    }
+    catch {
+        return { availableGB: 0, totalGB: 0 };
+    }
+}
+function checkPortInUse(port) {
+    try {
+        (0, child_process_1.execSync)(`lsof -i :${port} -sTCP:LISTEN`, { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getRunningServices() {
+    try {
+        const output = (0, child_process_1.execSync)('docker compose ps --services 2>/dev/null || docker-compose ps --services 2>/dev/null', {
+            stdio: 'pipe',
+        }).toString();
+        return output.trim().split('\n').filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+function runPreflightChecks(targetDir) {
+    const checks = [];
+    // Node.js version
+    try {
+        const version = process.version;
+        const major = parseInt(version.slice(1).split('.')[0]);
+        if (major >= 18) {
+            checks.push({ name: 'Node.js', status: 'pass', message: `${version}` });
+        }
+        else {
+            checks.push({ name: 'Node.js', status: 'warn', message: `${version} (recomendado >= 18)` });
+        }
+    }
+    catch {
+        checks.push({ name: 'Node.js', status: 'fail', message: 'No detectado' });
+    }
+    // Git
+    try {
+        const version = (0, child_process_1.execSync)('git --version', { stdio: 'pipe' }).toString().trim();
+        checks.push({ name: 'Git', status: 'pass', message: version });
+    }
+    catch {
+        checks.push({ name: 'Git', status: 'fail', message: 'No instalado' });
+    }
+    // Docker
+    try {
+        const version = (0, child_process_1.execSync)('docker --version', { stdio: 'pipe' }).toString().trim();
+        checks.push({ name: 'Docker', status: 'pass', message: version });
+    }
+    catch {
+        checks.push({ name: 'Docker', status: 'fail', message: 'No instalado' });
+    }
+    // Docker Compose
+    try {
+        let version = '';
+        try {
+            version = (0, child_process_1.execSync)('docker compose version', { stdio: 'pipe' }).toString().trim();
+        }
+        catch {
+            version = (0, child_process_1.execSync)('docker-compose --version', { stdio: 'pipe' }).toString().trim();
+        }
+        checks.push({ name: 'Docker Compose', status: 'pass', message: version });
+    }
+    catch {
+        checks.push({ name: 'Docker Compose', status: 'fail', message: 'No instalado' });
+    }
+    // Disk space
+    if (targetDir) {
+        const dir = path_1.default.dirname(targetDir);
+        if (fs_1.default.existsSync(dir)) {
+            const disk = checkDiskSpace(dir);
+            if (disk.availableGB >= 10) {
+                checks.push({ name: 'Disco disponible', status: 'pass', message: `${disk.availableGB}GB libres` });
+            }
+            else if (disk.availableGB >= 5) {
+                checks.push({ name: 'Disco disponible', status: 'warn', message: `${disk.availableGB}GB libres (minimo 5GB)` });
+            }
+            else {
+                checks.push({ name: 'Disco disponible', status: 'fail', message: `${disk.availableGB}GB libres (minimo 5GB)` });
+            }
+        }
+    }
+    // Port conflicts
+    const commonPorts = [
+        { port: 5432, name: 'PostgreSQL' },
+        { port: 8080, name: 'Web' },
+        { port: 3000, name: 'API Server' },
+        { port: 9090, name: 'Prometheus' },
+        { port: 3001, name: 'Grafana' },
+        { port: 5050, name: 'pgAdmin' },
+        { port: 9000, name: 'Portainer' },
+    ];
+    const conflictedPorts = commonPorts.filter(p => checkPortInUse(p.port));
+    if (conflictedPorts.length === 0) {
+        checks.push({ name: 'Puertos', status: 'pass', message: 'Sin conflictos' });
+    }
+    else {
+        const portList = conflictedPorts.map(p => `${p.name}:${p.port}`).join(', ');
+        checks.push({ name: 'Puertos', status: 'warn', message: `En uso: ${portList}` });
+    }
+    // OS info
+    checks.push({ name: 'Sistema', status: 'pass', message: `${os_1.default.type()} ${os_1.default.release()} (${os_1.default.arch()})` });
+    return checks;
+}
+function waitForService(url, maxAttempts = 30, intervalMs = 2000) {
+    return new Promise((resolve) => {
+        let attempts = 0;
+        const http = url.startsWith('https') ? require('https') : require('http');
+        const check = () => {
+            attempts++;
+            const req = http.get(url, { timeout: 3000 }, (res) => {
+                if (res.statusCode) {
+                    resolve(true);
+                }
+                else {
+                    retry();
+                }
+            });
+            req.on('error', () => {
+                if (attempts >= maxAttempts) {
+                    resolve(false);
+                }
+                else {
+                    retry();
+                }
+            });
+            req.on('timeout', () => {
+                req.destroy();
+                retry();
+            });
+        };
+        const retry = () => {
+            setTimeout(check, intervalMs);
+        };
+        check();
+    });
+}
+function getDockerComposeCommand() {
+    try {
+        (0, child_process_1.execSync)('docker compose version', { stdio: 'pipe' });
+        return 'docker compose';
+    }
+    catch {
+        return 'docker-compose';
+    }
+}
+function isLinux() {
+    return os_1.default.platform() === 'linux';
+}
+function isSystemdAvailable() {
+    if (!isLinux())
+        return false;
+    try {
+        const pid = (0, child_process_1.execSync)('cat /run/systemd/system 2>/dev/null && echo 1 || echo 0', { stdio: 'pipe' }).toString().trim();
+        return pid === '1' || fs_1.default.existsSync('/run/systemd/system');
+    }
+    catch {
+        return false;
+    }
+}
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+function timestamp() {
+    return new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+}
+function ensureDir(dir) {
+    if (!fs_1.default.existsSync(dir)) {
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    }
+}
+function copyDirRecursive(src, dest) {
+    ensureDir(dest);
+    const entries = fs_1.default.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path_1.default.join(src, entry.name);
+        const destPath = path_1.default.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirRecursive(srcPath, destPath);
+        }
+        else {
+            fs_1.default.copyFileSync(srcPath, destPath);
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+/**
+ * Catálogo de servicios de monitoreo. Fuente única usada tanto por el comando
+ * `monitoring` como por `install` para construir el checkbox de selección.
+ */
+export interface MonitoringService {
+    value: string;
+    label: string;
+    /** Marcado por defecto en un stack básico. */
+    basic: boolean;
+    /** Pertenece al stack de analítica avanzada (logs/métricas extendidas). */
+    analytics: boolean;
+}
+export declare const MONITORING_CATALOG: MonitoringService[];
+export declare const ALL_MONITORING_SERVICES: string[];
+/** Opciones para un prompt tipo checkbox de inquirer. */
+export declare function monitoringChoices(opts?: {
+    analytics?: boolean;
+}): {
+    name: string;
+    value: string;
+    checked: boolean;
+}[];
+/** Conjunto básico (pgAdmin, Grafana, Prometheus, Portainer). */
+export declare function basicMonitoringServices(): string[];
+/** Conjunto completo (básico + analítica). */
+export declare function fullMonitoringServices(): string[];
+/** Genera el docker-compose.monitoring.yml con solo los servicios seleccionados. */
+export declare function generateMonitoringCompose(serviceSet: Set<string>): string;
+export declare function generatePrometheusConfig(): string;
+export declare function generateLokiConfig(): string;
+export declare function generatePromtailConfig(): string;
+export declare function generateAlertmanagerConfig(): string;
+/**
+ * Escribe los archivos de configuración necesarios para los servicios
+ * seleccionados. Cada servicio que monta un archivo de config debe generarlo
+ * aquí; si no, Docker crea un directorio en su lugar y el bind-mount falla.
+ */
+export declare function writeMonitoringConfigs(root: string, serviceSet: Set<string>): void;

package/dist/src/utils/monitoring.js

@@ -0,0 +1,353 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_MONITORING_SERVICES = exports.MONITORING_CATALOG = void 0;
+exports.monitoringChoices = monitoringChoices;
+exports.basicMonitoringServices = basicMonitoringServices;
+exports.fullMonitoringServices = fullMonitoringServices;
+exports.generateMonitoringCompose = generateMonitoringCompose;
+exports.generatePrometheusConfig = generatePrometheusConfig;
+exports.generateLokiConfig = generateLokiConfig;
+exports.generatePromtailConfig = generatePromtailConfig;
+exports.generateAlertmanagerConfig = generateAlertmanagerConfig;
+exports.writeMonitoringConfigs = writeMonitoringConfigs;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+exports.MONITORING_CATALOG = [
+    { value: 'pgadmin', label: 'pgAdmin (gestion BD)', basic: true, analytics: false },
+    { value: 'grafana', label: 'Grafana (dashboards)', basic: true, analytics: false },
+    { value: 'prometheus', label: 'Prometheus (metricas)', basic: true, analytics: false },
+    { value: 'loki', label: 'Loki (agregacion de logs)', basic: false, analytics: true },
+    { value: 'promtail', label: 'Promtail (envio de logs a Loki)', basic: false, analytics: true },
+    { value: 'cadvisor', label: 'cAdvisor (metricas contenedores)', basic: false, analytics: true },
+    { value: 'node-exporter', label: 'Node Exporter (metricas host)', basic: false, analytics: true },
+    { value: 'portainer', label: 'Portainer (gestion Docker)', basic: true, analytics: false },
+    { value: 'alertmanager', label: 'Alertmanager (alertas)', basic: false, analytics: false },
+];
+exports.ALL_MONITORING_SERVICES = exports.MONITORING_CATALOG.map((s) => s.value);
+/** Opciones para un prompt tipo checkbox de inquirer. */
+function monitoringChoices(opts = {}) {
+    return exports.MONITORING_CATALOG.map((s) => ({
+        name: s.label,
+        value: s.value,
+        checked: s.basic || (opts.analytics ? s.analytics : false),
+    }));
+}
+/** Conjunto básico (pgAdmin, Grafana, Prometheus, Portainer). */
+function basicMonitoringServices() {
+    return exports.MONITORING_CATALOG.filter((s) => s.basic).map((s) => s.value);
+}
+/** Conjunto completo (básico + analítica). */
+function fullMonitoringServices() {
+    return exports.MONITORING_CATALOG.filter((s) => s.basic || s.analytics).map((s) => s.value);
+}
+/**
+ * Renderiza un bloque `depends_on:` con solo las dependencias que están en el
+ * conjunto seleccionado (evita "depends on undefined service" cuando se elige
+ * un subconjunto). Devuelve '' si no queda ninguna dependencia presente.
+ */
+function dependsOn(serviceSet, deps) {
+    const present = deps.filter((d) => serviceSet.has(d));
+    if (present.length === 0)
+        return '';
+    return `    depends_on:\n` + present.map((d) => `      - ${d}`).join('\n') + '\n';
+}
+/** Genera el docker-compose.monitoring.yml con solo los servicios seleccionados. */
+function generateMonitoringCompose(serviceSet) {
+    let compose = `# OpenFactu Monitoring Stack
+# Generated by @openfactu/cli
+# Services: ${Array.from(serviceSet).join(', ')}
+
+services:
+`;
+    if (serviceSet.has('pgadmin')) {
+        compose += `
+  pgadmin:
+    image: dpage/pgadmin4:latest
+    container_name: openfactu-pgadmin
+    environment:
+      PGADMIN_DEFAULT_EMAIL: \${PGADMIN_EMAIL:-admin@openfactu.local}
+      PGADMIN_DEFAULT_PASSWORD: \${PGADMIN_PASSWORD:-admin}
+      PGADMIN_CONFIG_SERVER_MODE: 'False'
+    ports:
+      - "\${PGADMIN_PORT:-5050}:80"
+    volumes:
+      - ./storage/pgadmin_data:/var/lib/pgadmin
+    restart: unless-stopped
+    networks:
+      - openfactu_net
+`;
+    }
+    if (serviceSet.has('prometheus')) {
+        compose += `
+  prometheus:
+    image: prom/prometheus:latest
+    container_name: openfactu-prometheus
+    command:
+      - '--config.file=/etc/prometheus/prometheus.yml'
+      - '--storage.tsdb.path=/prometheus'
+      - '--storage.tsdb.retention.time=15d'
+      - '--web.enable-lifecycle'
+      - '--web.enable-admin-api'
+    ports:
+      - "\${PROMETHEUS_PORT:-9090}:9090"
+    volumes:
+      - ./monitoring/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
+      - ./storage/prometheus_data:/prometheus
+    restart: unless-stopped
+    networks:
+      - openfactu_net
+`;
+    }
+    if (serviceSet.has('grafana')) {
+        compose += `
+  grafana:
+    image: grafana/grafana:latest
+    container_name: openfactu-grafana
+    environment:
+      - GF_SECURITY_ADMIN_USER=\${GRAFANA_USER:-admin}
+      - GF_SECURITY_ADMIN_PASSWORD=\${GRAFANA_PASSWORD:-admin}
+      - GF_USERS_ALLOW_SIGN_UP=false
+      - GF_INSTALL_PLUGINS=grafana-piechart-panel
+    ports:
+      - "\${GRAFANA_PORT:-3001}:3000"
+    volumes:
+      - ./storage/grafana_data:/var/lib/grafana
+      - ./monitoring/grafana/provisioning:/etc/grafana/provisioning:ro
+${dependsOn(serviceSet, ['prometheus', 'loki'])}    restart: unless-stopped
+    networks:
+      - openfactu_net
+`;
+    }
+    if (serviceSet.has('loki')) {
+        compose += `
+  loki:
+    image: grafana/loki:latest
+    container_name: openfactu-loki
+    command: -config.file=/etc/loki/local-config.yaml
+    ports:
+      - "\${LOKI_PORT:-3100}:3100"
+    volumes:
+      - ./storage/loki_data:/loki
+      - ./monitoring/loki/loki-config.yaml:/etc/loki/local-config.yaml:ro
+    restart: unless-stopped
+    networks:
+      - openfactu_net
+`;
+    }
+    if (serviceSet.has('promtail')) {
+        compose += `
+  promtail:
+    image: grafana/promtail:latest
+    container_name: openfactu-promtail
+    command: -config.file=/etc/promtail/config.yml
+    volumes:
+      - ./monitoring/promtail/promtail-config.yaml:/etc/promtail/config.yml:ro
+      - /var/log:/var/log
+      - ./storage:/app/storage:ro
+${dependsOn(serviceSet, ['loki'])}    restart: unless-stopped
+    networks:
+      - openfactu_net
+`;
+    }
+    if (serviceSet.has('cadvisor')) {
+        compose += `
+  cadvisor:
+    image: gcr.io/cadvisor/cadvisor:latest
+    container_name: openfactu-cadvisor
+    ports:
+      - "\${CADVISOR_PORT:-8081}:8080"
+    volumes:
+      - /:/rootfs:ro
+      - /var/run:/var/run:ro
+      - /sys:/sys:ro
+      - /var/lib/docker/:/var/lib/docker:ro
+      - /dev/disk/:/dev/disk:ro
+    devices:
+      - /dev/kmsg
+    restart: unless-stopped
+    networks:
+      - openfactu_net
+`;
+    }
+    if (serviceSet.has('node-exporter')) {
+        compose += `
+  node-exporter:
+    image: prom/node-exporter:latest
+    container_name: openfactu-node-exporter
+    command:
+      - '--path.rootfs=/host'
+    ports:
+      - "\${NODE_EXPORTER_PORT:-9100}:9100"
+    volumes:
+      - /:/host:ro,rslave
+    restart: unless-stopped
+    networks:
+      - openfactu_net
+`;
+    }
+    if (serviceSet.has('portainer')) {
+        compose += `
+  portainer:
+    image: portainer/portainer-ce:latest
+    container_name: openfactu-portainer
+    command: -H unix:///var/run/docker.sock
+    ports:
+      - "\${PORTAINER_PORT:-9000}:9000"
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock:ro
+      - ./storage/portainer_data:/data
+    restart: unless-stopped
+    networks:
+      - openfactu_net
+`;
+    }
+    if (serviceSet.has('alertmanager')) {
+        compose += `
+  alertmanager:
+    image: prom/alertmanager:latest
+    container_name: openfactu-alertmanager
+    command:
+      - '--config.file=/etc/alertmanager/alertmanager.yml'
+      - '--storage.path=/alertmanager'
+    ports:
+      - "\${ALERTMANAGER_PORT:-9093}:9093"
+    volumes:
+      - ./monitoring/alertmanager/alertmanager.yml:/etc/alertmanager/alertmanager.yml:ro
+      - ./storage/alertmanager_data:/alertmanager
+    restart: unless-stopped
+    networks:
+      - openfactu_net
+`;
+    }
+    compose += `
+networks:
+  openfactu_net:
+    name: openfactu_net
+    driver: bridge
+`;
+    return compose;
+}
+function generatePrometheusConfig() {
+    return `global:
+  scrape_interval: 15s
+  evaluation_interval: 15s
+
+scrape_configs:
+  - job_name: 'prometheus'
+    static_configs:
+      - targets: ['localhost:9090']
+
+  - job_name: 'node-exporter'
+    static_configs:
+      - targets: ['node-exporter:9100']
+
+  - job_name: 'cadvisor'
+    static_configs:
+      - targets: ['cadvisor:8080']
+
+  - job_name: 'openfactu-server'
+    metrics_path: '/api/metrics'
+    static_configs:
+      - targets: ['server:3000']
+`;
+}
+function generateLokiConfig() {
+    return `auth_enabled: false
+
+server:
+  http_listen_port: 3100
+
+common:
+  path_prefix: /loki
+  storage:
+    filesystem:
+      chunks_directory: /loki/chunks
+      rules_directory: /loki/rules
+  replication_factor: 1
+  ring:
+    kvstore:
+      store: inmemory
+
+schema_config:
+  configs:
+    - from: 2020-10-24
+      store: boltdb-shipper
+      object_store: filesystem
+      schema: v11
+      index:
+        prefix: index_
+        period: 24h
+
+limits_config:
+  reject_old_samples: true
+  reject_old_samples_max_age: 168h
+`;
+}
+function generatePromtailConfig() {
+    return `server:
+  http_listen_port: 9080
+  grpc_listen_port: 0
+
+positions:
+  filename: /tmp/positions.yaml
+
+clients:
+  - url: http://loki:3100/loki/api/v1/push
+
+scrape_configs:
+  - job_name: openfactu-logs
+    static_configs:
+      - targets:
+          - localhost
+        labels:
+          job: openfactu
+          __path__: /app/storage/**/*.log
+`;
+}
+function generateAlertmanagerConfig() {
+    return `route:
+  receiver: 'default'
+  group_by: ['alertname']
+  group_wait: 30s
+  group_interval: 5m
+  repeat_interval: 3h
+
+receivers:
+  - name: 'default'
+`;
+}
+/**
+ * Escribe los archivos de configuración necesarios para los servicios
+ * seleccionados. Cada servicio que monta un archivo de config debe generarlo
+ * aquí; si no, Docker crea un directorio en su lugar y el bind-mount falla.
+ */
+function writeMonitoringConfigs(root, serviceSet) {
+    if (serviceSet.has('prometheus')) {
+        const dir = path_1.default.join(root, 'monitoring/prometheus');
+        fs_1.default.mkdirSync(dir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'prometheus.yml'), generatePrometheusConfig());
+    }
+    if (serviceSet.has('loki')) {
+        const dir = path_1.default.join(root, 'monitoring/loki');
+        fs_1.default.mkdirSync(dir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'loki-config.yaml'), generateLokiConfig());
+    }
+    if (serviceSet.has('promtail')) {
+        const dir = path_1.default.join(root, 'monitoring/promtail');
+        fs_1.default.mkdirSync(dir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'promtail-config.yaml'), generatePromtailConfig());
+    }
+    if (serviceSet.has('alertmanager')) {
+        const dir = path_1.default.join(root, 'monitoring/alertmanager');
+        fs_1.default.mkdirSync(dir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'alertmanager.yml'), generateAlertmanagerConfig());
+    }
+    if (serviceSet.has('grafana')) {
+        // El servicio monta ./monitoring/grafana/provisioning (directorio :ro).
+        // Lo creamos vacío para que el mount tenga una fuente real.
+        fs_1.default.mkdirSync(path_1.default.join(root, 'monitoring/grafana/provisioning'), { recursive: true });
+    }
+}

package/dist/src/utils/paths.d.ts

@@ -16,3 +16,4 @@ export declare function getServerSrcDir(): string;
 export declare function getMigrationsDir(): string;
 export declare function getPluginsDir(): string;
 export declare function getEnvPath(): string;
+export declare function getMonitoringComposePath(): string;

package/dist/src/utils/paths.js

@@ -10,6 +10,7 @@ exports.getServerSrcDir = getServerSrcDir;
 exports.getMigrationsDir = getMigrationsDir;
 exports.getPluginsDir = getPluginsDir;
 exports.getEnvPath = getEnvPath;
+exports.getMonitoringComposePath = getMonitoringComposePath;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 let _projectRoot = null;
@@ -82,3 +83,4 @@ function getServerSrcDir() { return path_1.default.join(getServerDir(), 'src');
 function getMigrationsDir() { return path_1.default.join(getServerSrcDir(), 'core/tenant/migrations'); }
 function getPluginsDir() { return path_1.default.join(getProjectRoot(), 'plugins'); }
 function getEnvPath() { return path_1.default.join(getProjectRoot(), '.env'); }
+function getMonitoringComposePath() { return path_1.default.join(getProjectRoot(), 'docker-compose.monitoring.yml'); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfactu/cli",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "CLI para gestionar OpenFactu: migraciones, tenants, plugins y setup",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
@@ -16,10 +16,12 @@
   },
   "scripts": {
     "build": "tsc",
-    "dev": "ts-node bin/openfactu.ts"
+    "dev": "ts-node bin/openfactu.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
-    "bcrypt": "^5.1.1",
     "chalk": "^4.1.2",
     "cli-table3": "^0.6.5",
     "commander": "^12.0.0",
@@ -31,10 +33,11 @@
     "pg": "^8.13.0"
   },
   "devDependencies": {
-    "@types/bcrypt": "^5.0.0",
     "@types/inquirer": "^8.2.0",
     "@types/pg": "^8.11.0",
+    "@vitest/coverage-v8": "^4.1.6",
     "ts-node": "^10.9.0",
-    "typescript": "^5.3.3"
+    "typescript": "^5.3.3",
+    "vitest": "^4.1.6"
   }
 }