@openfactu/cli 0.0.2

package/dist/bin/openfactu.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/openfactu.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Registrar ts-node para resolver imports de .ts del server
+try {
+    require('ts-node').register({
+        transpileOnly: true,
+        compilerOptions: { module: 'commonjs', esModuleInterop: true },
+    });
+}
+catch { }
+// Opción --path para usar desde cualquier directorio
+const pathIdx = process.argv.indexOf('--path');
+if (pathIdx !== -1 && process.argv[pathIdx + 1]) {
+    const { setProjectRoot } = require('../src/utils/paths');
+    setProjectRoot(process.argv[pathIdx + 1]);
+    // Quitar --path y su valor de argv para que commander no los procese
+    process.argv.splice(pathIdx, 2);
+}
+const index_1 = require("../src/index");
+const program = (0, index_1.createCLI)();
+program.option('--path <dir>', 'Ruta a la instalación de OpenFactu');
+program.parse(process.argv);

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

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

package/dist/src/commands/migrate.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMigrateCommand = registerMigrateCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const db_1 = require("../utils/db");
+const logger_1 = require("../utils/logger");
+const MIGRATIONS_DIR = require('../utils/paths').getMigrationsDir();
+function getMigrationFiles() {
+    if (!fs_1.default.existsSync(MIGRATIONS_DIR))
+        return [];
+    return fs_1.default.readdirSync(MIGRATIONS_DIR).filter((f) => f.endsWith('.sql')).sort();
+}
+async function getAppliedMigrations(tenantDb, schemaName) {
+    try {
+        const result = await tenantDb.execute(db_1.sql.raw(`SELECT id FROM "${schemaName}"."_MigrationHistory" ORDER BY id`));
+        return result.rows.map((r) => r.id);
+    }
+    catch {
+        return [];
+    }
+}
+async function applyMigration(tenantDb, schemaName, file) {
+    const migrationId = file.replace('.sql', '');
+    const filePath = path_1.default.join(MIGRATIONS_DIR, file);
+    let rawSql = fs_1.default.readFileSync(filePath, 'utf8');
+    const processedSql = rawSql.replace(/{{schema}}/g, schemaName);
+    const statements = processedSql
+        .split(/;(?=(?:[^$]*\$\$[^$]*\$\$)*[^$]*$)/)
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    for (const statement of statements) {
+        await tenantDb.execute(db_1.sql.raw(statement));
+    }
+    await tenantDb.execute(db_1.sql.raw(`INSERT INTO "${schemaName}"."_MigrationHistory" (id, description) VALUES ('${migrationId}', 'Aplicado desde CLI')`));
+}
+function registerMigrateCommand(program) {
+    // ── openfactu migrate ──
+    program
+        .command('migrate')
+        .description('Ejecuta migraciones pendientes en todos los tenants')
+        .option('-t, --tenant <name>', 'Migrar solo un tenant específico')
+        .action(async (opts) => {
+        const spinner = (0, ora_1.default)('Conectando a la base de datos...').start();
+        try {
+            const allFiles = getMigrationFiles();
+            if (allFiles.length === 0) {
+                spinner.fail('No se encontraron archivos de migración');
+                return;
+            }
+            let tenants;
+            if (opts.tenant) {
+                const tenant = await (0, db_1.getTenantByName)(opts.tenant);
+                if (!tenant) {
+                    spinner.fail(`Tenant "${opts.tenant}" no encontrado`);
+                    return;
+                }
+                tenants = [tenant];
+            }
+            else {
+                tenants = await (0, db_1.getAllTenants)();
+            }
+            if (tenants.length === 0) {
+                spinner.warn('No hay tenants registrados');
+                return;
+            }
+            spinner.succeed(`${tenants.length} tenant(s) encontrado(s), ${allFiles.length} migraciones disponibles`);
+            logger_1.log.blank();
+            let totalApplied = 0;
+            for (const tenant of tenants) {
+                const tenantDb = (0, db_1.getTenantDb)(tenant.schemaName);
+                const applied = await getAppliedMigrations(tenantDb, tenant.schemaName);
+                const pending = allFiles.filter((f) => !applied.includes(f.replace('.sql', '')));
+                if (pending.length === 0) {
+                    logger_1.log.dim(`  ${tenant.name} (${tenant.schemaName}) — al dia`);
+                    continue;
+                }
+                logger_1.log.title(`  ${tenant.name} (${tenant.schemaName})`);
+                for (const file of pending) {
+                    const migSpinner = (0, ora_1.default)(`  Aplicando ${file}...`).start();
+                    try {
+                        await applyMigration(tenantDb, tenant.schemaName, file);
+                        migSpinner.succeed(`  ${file}`);
+                        totalApplied++;
+                    }
+                    catch (err) {
+                        migSpinner.fail(`  ${file}: ${err.message}`);
+                        throw err;
+                    }
+                }
+            }
+            logger_1.log.blank();
+            if (totalApplied > 0) {
+                logger_1.log.success(`${totalApplied} migración(es) aplicada(s)`);
+            }
+            else {
+                logger_1.log.success('Todos los tenants están al día');
+            }
+        }
+        catch (err) {
+            spinner.fail(err.message);
+            process.exitCode = 1;
+        }
+        finally {
+            await (0, db_1.disconnect)();
+        }
+    });
+    // ── openfactu migrate:status ──
+    program
+        .command('migrate:status')
+        .description('Muestra el estado de migraciones por tenant')
+        .action(async () => {
+        const spinner = (0, ora_1.default)('Leyendo estado de migraciones...').start();
+        try {
+            const allFiles = getMigrationFiles();
+            const tenants = await (0, db_1.getAllTenants)();
+            if (tenants.length === 0) {
+                spinner.warn('No hay tenants registrados');
+                return;
+            }
+            spinner.succeed(`${tenants.length} tenant(s), ${allFiles.length} migraciones`);
+            logger_1.log.blank();
+            for (const tenant of tenants) {
+                const tenantDb = (0, db_1.getTenantDb)(tenant.schemaName);
+                const applied = await getAppliedMigrations(tenantDb, tenant.schemaName);
+                const pending = allFiles.filter((f) => !applied.includes(f.replace('.sql', '')));
+                const table = new cli_table3_1.default({
+                    head: [chalk_1.default.white('Migración'), chalk_1.default.white('Estado')],
+                    colWidths: [45, 15],
+                    style: { head: [], border: ['dim'] },
+                });
+                for (const file of allFiles) {
+                    const migId = file.replace('.sql', '');
+                    const isApplied = applied.includes(migId);
+                    table.push([
+                        migId,
+                        isApplied ? chalk_1.default.green('✓ Aplicada') : chalk_1.default.yellow('Pendiente'),
+                    ]);
+                }
+                console.log(chalk_1.default.bold(`\n  ${tenant.name}`) + chalk_1.default.dim(` (${tenant.schemaName})`));
+                console.log(chalk_1.default.dim(`  ${applied.length} aplicadas, `) +
+                    (pending.length > 0 ? chalk_1.default.yellow(`${pending.length} pendientes`) : chalk_1.default.green('al día')));
+                console.log(table.toString());
+            }
+        }
+        catch (err) {
+            spinner.fail(err.message);
+            process.exitCode = 1;
+        }
+        finally {
+            await (0, db_1.disconnect)();
+        }
+    });
+}

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

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

package/dist/src/commands/plugin.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPluginCommand = registerPluginCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const db_1 = require("../utils/db");
+const logger_1 = require("../utils/logger");
+const paths_1 = require("../utils/paths");
+const PLUGINS_DIR = (0, paths_1.getPluginsDir)();
+function registerPluginCommand(program) {
+    const plugin = program
+        .command('plugin')
+        .description('Gestión de plugins');
+    // ── openfactu plugin list ──
+    plugin
+        .command('list')
+        .description('Lista plugins instalados')
+        .action(async () => {
+        const spinner = (0, ora_1.default)('Leyendo plugins...').start();
+        try {
+            // Leer plugins del filesystem
+            const installed = [];
+            if (fs_1.default.existsSync(PLUGINS_DIR)) {
+                const dirs = fs_1.default.readdirSync(PLUGINS_DIR).filter((d) => fs_1.default.statSync(path_1.default.join(PLUGINS_DIR, d)).isDirectory());
+                installed.push(...dirs);
+            }
+            if (installed.length === 0) {
+                spinner.warn('No hay plugins instalados');
+                return;
+            }
+            // Leer estado de activación por tenant
+            const publicDb = (0, db_1.getPublicDb)();
+            let tenantPlugins = [];
+            try {
+                tenantPlugins = await publicDb.select().from(db_1.schema.tenantPlugins);
+            }
+            catch {
+                // Tabla puede no existir aún
+            }
+            const tenants = await (0, db_1.getAllTenants)();
+            spinner.succeed(`${installed.length} plugin(s) instalado(s)`);
+            logger_1.log.blank();
+            const table = new cli_table3_1.default({
+                head: [
+                    chalk_1.default.white('Plugin'),
+                    chalk_1.default.white('Manifest'),
+                    ...tenants.map((t) => chalk_1.default.white(t.name)),
+                ],
+                style: { head: [], border: ['dim'] },
+            });
+            for (const pluginId of installed) {
+                const manifestPath = path_1.default.join(PLUGINS_DIR, pluginId, 'manifest.json');
+                const hasManifest = fs_1.default.existsSync(manifestPath);
+                let manifest = null;
+                if (hasManifest) {
+                    try {
+                        manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf-8'));
+                    }
+                    catch { }
+                }
+                const row = [
+                    chalk_1.default.bold(manifest?.name || pluginId),
+                    hasManifest ? chalk_1.default.green('Si') : chalk_1.default.dim('No'),
+                ];
+                for (const tenant of tenants) {
+                    const tp = tenantPlugins.find((r) => r.tenantId === tenant.id && r.pluginId === pluginId);
+                    if (tp?.isActive) {
+                        row.push(chalk_1.default.green('Activo'));
+                    }
+                    else if (tp) {
+                        row.push(chalk_1.default.dim('Inactivo'));
+                    }
+                    else {
+                        row.push(chalk_1.default.dim('-'));
+                    }
+                }
+                table.push(row);
+            }
+            console.log(table.toString());
+        }
+        catch (err) {
+            spinner.fail(err.message);
+            process.exitCode = 1;
+        }
+        finally {
+            await (0, db_1.disconnect)();
+        }
+    });
+}

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

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

package/dist/src/commands/setup.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSetupCommand = registerSetupCommand;
+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) {
+    program
+        .command('setup')
+        .description('Configuración inicial de OpenFactu')
+        .action(async () => {
+        console.log();
+        console.log(chalk_1.default.bold.white('  OpenFactu — Setup Inicial'));
+        console.log(chalk_1.default.dim('  ────────────────────────────────────'));
+        console.log();
+        try {
+            // 1. Verificar conexión
+            const connSpinner = (0, ora_1.default)('Verificando conexión a la base de datos...').start();
+            const connected = await (0, db_1.testConnection)();
+            if (!connected) {
+                connSpinner.fail('No se pudo conectar a la base de datos');
+                logger_1.log.blank();
+                logger_1.log.warn('Verifica que DATABASE_URL esté configurado en .env');
+                logger_1.log.warn('Ejemplo: DATABASE_URL=postgresql://openfactu:openfactu_pass@localhost:5432/openfactudb');
+                return;
+            }
+            connSpinner.succeed('Conexión a la base de datos establecida');
+            const publicDb = (0, db_1.getPublicDb)();
+            // 2. Crear tablas del schema público
+            const schemaSpinner = (0, ora_1.default)('Verificando schema público...').start();
+            try {
+                // Verificar si la tabla Tenant existe
+                await publicDb.execute(db_1.sql.raw('SELECT 1 FROM "Tenant" LIMIT 1'));
+                schemaSpinner.succeed('Schema público OK');
+            }
+            catch {
+                schemaSpinner.text = 'Creando tablas del schema público...';
+                // Las tablas se crean con drizzle push — aquí solo verificamos
+                schemaSpinner.warn('Schema público necesita inicialización. Ejecuta: npm run db:push:public');
+                return;
+            }
+            // 3. Verificar/crear admin
+            const adminSpinner = (0, ora_1.default)('Verificando usuario administrador...').start();
+            const [existingAdmin] = await publicDb
+                .select()
+                .from(db_1.schema.globalUsers)
+                .where((0, db_1.eq)(db_1.schema.globalUsers.username, 'admin'));
+            if (existingAdmin) {
+                adminSpinner.succeed('Usuario admin ya existe');
+            }
+            else {
+                adminSpinner.text = 'Creando usuario administrador...';
+                const { adminPassword } = await inquirer_1.default.prompt([
+                    {
+                        type: 'password',
+                        name: 'adminPassword',
+                        message: 'Password para el usuario admin:',
+                        default: 'admin123',
+                        mask: '*',
+                    },
+                ]);
+                const hashedPassword = await bcrypt_1.default.hash(adminPassword, 10);
+                await publicDb.insert(db_1.schema.globalUsers).values({
+                    id: crypto_1.default.randomUUID(),
+                    email: 'admin@openfactu.com',
+                    username: 'admin',
+                    password: hashedPassword,
+                    role: 'SUPERUSER',
+                });
+                adminSpinner.succeed('Usuario admin creado (admin@openfactu.com)');
+            }
+            // 4. Verificar/crear primer tenant
+            const tenants = await publicDb.select().from(db_1.schema.tenants);
+            if (tenants.length > 0) {
+                logger_1.log.success(`${tenants.length} tenant(s) ya existen`);
+            }
+            else {
+                logger_1.log.blank();
+                const { createTenant } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'createTenant',
+                        message: 'No hay empresas. ¿Crear la primera?',
+                        default: true,
+                    },
+                ]);
+                if (createTenant) {
+                    const { tenantName } = await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'tenantName',
+                            message: 'Nombre de la empresa:',
+                            default: 'Mi Empresa',
+                        },
+                    ]);
+                    const schemaName = 'tenant_' + tenantName
+                        .toLowerCase()
+                        .replace(/[^a-z0-9]+/g, '_')
+                        .replace(/^_|_$/g, '');
+                    const tenantSpinner = (0, ora_1.default)(`Creando empresa "${tenantName}"...`).start();
+                    const tenantId = crypto_1.default.randomUUID();
+                    await publicDb.insert(db_1.schema.tenants).values({
+                        id: tenantId,
+                        name: tenantName,
+                        schemaName,
+                        config: JSON.stringify({ createdAt: new Date(), createdBy: 'CLI Setup' }),
+                        updatedAt: new Date(),
+                    });
+                    await publicDb.execute(db_1.sql.raw(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`));
+                    tenantSpinner.succeed(`Empresa "${tenantName}" creada (${schemaName})`);
+                    // Asignar admin al tenant
+                    const [admin] = await publicDb
+                        .select()
+                        .from(db_1.schema.globalUsers)
+                        .where((0, db_1.eq)(db_1.schema.globalUsers.username, 'admin'));
+                    if (admin) {
+                        await publicDb.insert(db_1.schema.userTenantMemberships).values({
+                            id: crypto_1.default.randomUUID(),
+                            userId: admin.id,
+                            tenantId,
+                            role: 'ADMIN',
+                        });
+                        logger_1.log.success('Admin asignado a la empresa');
+                    }
+                    logger_1.log.info('Ejecuta "openfactu migrate" para aplicar migraciones al nuevo tenant');
+                }
+            }
+            logger_1.log.blank();
+            logger_1.log.success(chalk_1.default.bold('Setup completado'));
+            logger_1.log.blank();
+            logger_1.log.dim('  Próximos pasos:');
+            logger_1.log.dim('    openfactu migrate        — Aplicar migraciones');
+            logger_1.log.dim('    openfactu tenant list     — Ver empresas');
+            logger_1.log.dim('    openfactu version         — Ver versiones');
+            logger_1.log.blank();
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+            process.exitCode = 1;
+        }
+        finally {
+            await (0, db_1.disconnect)();
+        }
+    });
+}

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

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

package/dist/src/commands/tenant.js

@@ -0,0 +1,220 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTenantCommand = registerTenantCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const crypto_1 = __importDefault(require("crypto"));
+const db_1 = require("../utils/db");
+const logger_1 = require("../utils/logger");
+function registerTenantCommand(program) {
+    const tenant = program
+        .command('tenant')
+        .description('Gestión de tenants (empresas)');
+    // ── openfactu tenant list ──
+    tenant
+        .command('list')
+        .description('Lista todos los tenants')
+        .action(async () => {
+        const spinner = (0, ora_1.default)('Cargando tenants...').start();
+        try {
+            const tenants = await (0, db_1.getAllTenants)();
+            if (tenants.length === 0) {
+                spinner.warn('No hay tenants registrados');
+                return;
+            }
+            spinner.succeed(`${tenants.length} tenant(s) encontrado(s)`);
+            const table = new cli_table3_1.default({
+                head: [chalk_1.default.white('Nombre'), chalk_1.default.white('Schema'), chalk_1.default.white('ID'), chalk_1.default.white('Creado')],
+                style: { head: [], border: ['dim'] },
+            });
+            for (const t of tenants) {
+                table.push([
+                    chalk_1.default.bold(t.name),
+                    chalk_1.default.cyan(t.schemaName),
+                    chalk_1.default.dim(t.id.substring(0, 8) + '...'),
+                    t.createdAt ? new Date(t.createdAt).toLocaleDateString('es-ES') : '-',
+                ]);
+            }
+            console.log(table.toString());
+        }
+        catch (err) {
+            spinner.fail(err.message);
+            process.exitCode = 1;
+        }
+        finally {
+            await (0, db_1.disconnect)();
+        }
+    });
+    // ── openfactu tenant create ──
+    tenant
+        .command('create [name]')
+        .description('Crea un nuevo tenant')
+        .action(async (name) => {
+        try {
+            let tenantName = name;
+            if (!tenantName) {
+                const answers = await inquirer_1.default.prompt([
+                    {
+                        type: 'input',
+                        name: 'name',
+                        message: 'Nombre de la empresa:',
+                        validate: (v) => v.trim().length > 0 || 'El nombre es obligatorio',
+                    },
+                ]);
+                tenantName = answers.name;
+            }
+            const schemaName = 'tenant_' + tenantName
+                .toLowerCase()
+                .replace(/[^a-z0-9]+/g, '_')
+                .replace(/^_|_$/g, '');
+            logger_1.log.info(`Empresa: ${chalk_1.default.bold(tenantName)}`);
+            logger_1.log.info(`Schema:  ${chalk_1.default.cyan(schemaName)}`);
+            logger_1.log.blank();
+            const spinner = (0, ora_1.default)('Creando tenant...').start();
+            const publicDb = (0, db_1.getPublicDb)();
+            // Verificar que no exista
+            const [existing] = await publicDb
+                .select()
+                .from(db_1.schema.tenants)
+                .where((0, db_1.eq)(db_1.schema.tenants.name, tenantName));
+            if (existing) {
+                spinner.warn(`El tenant "${tenantName}" ya existe (${existing.id})`);
+                return;
+            }
+            // Crear registro en la tabla Tenant
+            const tenantId = crypto_1.default.randomUUID();
+            await publicDb.insert(db_1.schema.tenants).values({
+                id: tenantId,
+                name: tenantName,
+                schemaName,
+                config: JSON.stringify({ createdAt: new Date(), createdBy: 'CLI' }),
+                updatedAt: new Date(),
+            });
+            spinner.text = 'Creando schema de PostgreSQL...';
+            await publicDb.execute(db_1.sql.raw(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`));
+            spinner.text = 'Ejecutando migraciones...';
+            // Aplicar migraciones
+            const fs = require('fs');
+            const path = require('path');
+            const MIGRATIONS_DIR = require('../utils/paths').getMigrationsDir();
+            if (fs.existsSync(MIGRATIONS_DIR)) {
+                const tenantDb = (0, db_1.getTenantDb)(schemaName);
+                // Crear tabla de historia
+                await tenantDb.execute(db_1.sql.raw(`
+              CREATE TABLE IF NOT EXISTS "${schemaName}"."_MigrationHistory" (
+                "id" TEXT PRIMARY KEY,
+                "description" TEXT,
+                "appliedAt" TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+              )
+            `));
+                const files = fs.readdirSync(MIGRATIONS_DIR).filter((f) => f.endsWith('.sql')).sort();
+                for (const file of files) {
+                    spinner.text = `Aplicando ${file}...`;
+                    const migrationId = file.replace('.sql', '');
+                    const filePath = path.join(MIGRATIONS_DIR, file);
+                    let rawSql = fs.readFileSync(filePath, 'utf8');
+                    const processedSql = rawSql.replace(/{{schema}}/g, schemaName);
+                    const statements = processedSql
+                        .split(/;(?=(?:[^$]*\$\$[^$]*\$\$)*[^$]*$)/)
+                        .map((s) => s.trim())
+                        .filter((s) => s.length > 0);
+                    for (const statement of statements) {
+                        await tenantDb.execute(db_1.sql.raw(statement));
+                    }
+                    await tenantDb.execute(db_1.sql.raw(`INSERT INTO "${schemaName}"."_MigrationHistory" (id, description) VALUES ('${migrationId}', 'Creado desde CLI')`));
+                }
+            }
+            spinner.succeed('Tenant creado correctamente');
+            logger_1.log.blank();
+            logger_1.log.success(`ID:      ${chalk_1.default.dim(tenantId)}`);
+            logger_1.log.success(`Nombre:  ${chalk_1.default.bold(tenantName)}`);
+            logger_1.log.success(`Schema:  ${chalk_1.default.cyan(schemaName)}`);
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+            process.exitCode = 1;
+        }
+        finally {
+            await (0, db_1.disconnect)();
+        }
+    });
+    // ── openfactu tenant sync ──
+    tenant
+        .command('sync [name]')
+        .description('Sincroniza migraciones de un tenant o todos')
+        .action(async (name) => {
+        const spinner = (0, ora_1.default)('Sincronizando...').start();
+        try {
+            let tenants;
+            if (name) {
+                const t = await (0, db_1.getAllTenants)();
+                const found = t.find((x) => x.name.toLowerCase() === name.toLowerCase());
+                if (!found) {
+                    spinner.fail(`Tenant "${name}" no encontrado`);
+                    return;
+                }
+                tenants = [found];
+            }
+            else {
+                tenants = await (0, db_1.getAllTenants)();
+            }
+            spinner.succeed(`Sincronizando ${tenants.length} tenant(s)...`);
+            // Usamos el mismo proceso de migración
+            const fs = require('fs');
+            const path = require('path');
+            const MIGRATIONS_DIR = require('../utils/paths').getMigrationsDir();
+            const files = fs.existsSync(MIGRATIONS_DIR)
+                ? fs.readdirSync(MIGRATIONS_DIR).filter((f) => f.endsWith('.sql')).sort()
+                : [];
+            for (const tenant of tenants) {
+                const tenantDb = (0, db_1.getTenantDb)(tenant.schemaName);
+                // Asegurar tabla de historia
+                await tenantDb.execute(db_1.sql.raw(`
+              CREATE TABLE IF NOT EXISTS "${tenant.schemaName}"."_MigrationHistory" (
+                "id" TEXT PRIMARY KEY,
+                "description" TEXT,
+                "appliedAt" TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+              )
+            `));
+                const result = await tenantDb.execute(db_1.sql.raw(`SELECT id FROM "${tenant.schemaName}"."_MigrationHistory" ORDER BY id`));
+                const applied = result.rows.map((r) => r.id);
+                const pending = files.filter((f) => !applied.includes(f.replace('.sql', '')));
+                if (pending.length === 0) {
+                    logger_1.log.dim(`  ${tenant.name} — al día`);
+                }
+                else {
+                    logger_1.log.info(`  ${tenant.name} — ${pending.length} pendiente(s)`);
+                    for (const file of pending) {
+                        const migrationId = file.replace('.sql', '');
+                        const filePath = path.join(MIGRATIONS_DIR, file);
+                        let rawSql = fs.readFileSync(filePath, 'utf8');
+                        const processedSql = rawSql.replace(/{{schema}}/g, tenant.schemaName);
+                        const statements = processedSql
+                            .split(/;(?=(?:[^$]*\$\$[^$]*\$\$)*[^$]*$)/)
+                            .map((s) => s.trim())
+                            .filter((s) => s.length > 0);
+                        for (const statement of statements) {
+                            await tenantDb.execute(db_1.sql.raw(statement));
+                        }
+                        await tenantDb.execute(db_1.sql.raw(`INSERT INTO "${tenant.schemaName}"."_MigrationHistory" (id, description) VALUES ('${migrationId}', 'Sync CLI')`));
+                        logger_1.log.success(`    ${file}`);
+                    }
+                }
+            }
+            logger_1.log.blank();
+            logger_1.log.success('Sincronización completada');
+        }
+        catch (err) {
+            spinner.fail(err.message);
+            process.exitCode = 1;
+        }
+        finally {
+            await (0, db_1.disconnect)();
+        }
+    });
+}

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

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