@openfactu/cli 0.0.2

package/dist/src/commands/update.js

@@ -0,0 +1,282 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerUpdateCommand = registerUpdateCommand;
+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 ROOT_DIR = (0, paths_1.getProjectRoot)();
+const BACKUP_DIRS = ['storage', 'plugins', '.env'];
+const SAFE_DIRS = ['storage', 'plugins', 'node_modules', '.env', '.git'];
+function getCurrentVersion() {
+    try {
+        const pkg = JSON.parse(fs_1.default.readFileSync(path_1.default.join(ROOT_DIR, 'package.json'), 'utf-8'));
+        return pkg.version || '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+function getCurrentBranch() {
+    try {
+        return (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', { cwd: ROOT_DIR }).toString().trim();
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function getCurrentCommit() {
+    try {
+        return (0, child_process_1.execSync)('git rev-parse --short HEAD', { cwd: ROOT_DIR }).toString().trim();
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function hasUncommittedChanges() {
+    try {
+        const output = (0, child_process_1.execSync)('git status --porcelain', { cwd: ROOT_DIR }).toString().trim();
+        return output.length > 0;
+    }
+    catch {
+        return true;
+    }
+}
+function getRemoteTags() {
+    try {
+        (0, child_process_1.execSync)('git fetch --tags', { cwd: ROOT_DIR, stdio: 'pipe' });
+        const output = (0, child_process_1.execSync)('git tag --list "v*" --sort=-version:refname', { cwd: ROOT_DIR }).toString().trim();
+        return output ? output.split('\n') : [];
+    }
+    catch {
+        return [];
+    }
+}
+function getRemoteLatestCommit(branch) {
+    try {
+        (0, child_process_1.execSync)('git fetch origin', { cwd: ROOT_DIR, stdio: 'pipe' });
+        return (0, child_process_1.execSync)(`git rev-parse --short origin/${branch}`, { cwd: ROOT_DIR }).toString().trim();
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function registerUpdateCommand(program) {
+    // ── openfactu update ──
+    program
+        .command('update')
+        .description('Actualiza OpenFactu a la última versión')
+        .option('--branch <branch>', 'Branch específica (default: main)')
+        .option('--tag <tag>', 'Tag/versión específica (ej: v1.2.0)')
+        .option('--force', 'Forzar actualización sin confirmación')
+        .action(async (opts) => {
+        console.log();
+        console.log(chalk_1.default.bold.white('  OpenFactu — Actualización'));
+        console.log(chalk_1.default.dim('  ────────────────────────────────────'));
+        console.log();
+        try {
+            const currentVersion = getCurrentVersion();
+            const currentBranch = getCurrentBranch();
+            const currentCommit = getCurrentCommit();
+            logger_1.log.info(`Versión actual:  ${chalk_1.default.cyan(currentVersion)}`);
+            logger_1.log.info(`Branch:          ${chalk_1.default.cyan(currentBranch)}`);
+            logger_1.log.info(`Commit:          ${chalk_1.default.cyan(currentCommit)}`);
+            logger_1.log.blank();
+            // 1. Verificar cambios sin commitear
+            if (hasUncommittedChanges()) {
+                logger_1.log.warn('Hay cambios sin commitear en el repositorio');
+                if (!opts.force) {
+                    const { proceed } = await inquirer_1.default.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'proceed',
+                            message: 'Hay cambios locales. ¿Continuar? (se hará stash automático)',
+                            default: false,
+                        },
+                    ]);
+                    if (!proceed) {
+                        logger_1.log.info('Actualización cancelada');
+                        return;
+                    }
+                }
+                // Guardar cambios locales
+                const stashSpinner = (0, ora_1.default)('Guardando cambios locales (git stash)...').start();
+                try {
+                    (0, child_process_1.execSync)('git stash push -m "openfactu-cli-update-backup"', { cwd: ROOT_DIR, stdio: 'pipe' });
+                    stashSpinner.succeed('Cambios locales guardados en stash');
+                }
+                catch (err) {
+                    stashSpinner.warn('No se pudieron guardar cambios: ' + err.message);
+                }
+            }
+            // 2. Fetch remoto
+            const fetchSpinner = (0, ora_1.default)('Descargando información del repositorio...').start();
+            try {
+                (0, child_process_1.execSync)('git fetch --all --tags', { cwd: ROOT_DIR, stdio: 'pipe' });
+                fetchSpinner.succeed('Repositorio actualizado');
+            }
+            catch (err) {
+                fetchSpinner.fail('No se pudo conectar al repositorio remoto: ' + err.message);
+                return;
+            }
+            // 3. Determinar versión objetivo
+            let target;
+            if (opts.tag) {
+                // Actualizar a un tag específico
+                target = opts.tag;
+                logger_1.log.info(`Actualizando al tag: ${chalk_1.default.bold(target)}`);
+            }
+            else {
+                const branch = opts.branch || currentBranch || 'main';
+                const remoteCommit = getRemoteLatestCommit(branch);
+                if (remoteCommit === currentCommit) {
+                    logger_1.log.success('Ya estás en la última versión');
+                    return;
+                }
+                // Mostrar commits pendientes
+                try {
+                    const behindCount = (0, child_process_1.execSync)(`git rev-list --count HEAD..origin/${branch}`, { cwd: ROOT_DIR }).toString().trim();
+                    logger_1.log.info(`Commits nuevos disponibles: ${chalk_1.default.yellow(behindCount)}`);
+                    // Mostrar resumen de cambios
+                    const changelog = (0, child_process_1.execSync)(`git log --oneline HEAD..origin/${branch} --max-count=10`, { cwd: ROOT_DIR }).toString().trim();
+                    if (changelog) {
+                        logger_1.log.blank();
+                        logger_1.log.dim('  Cambios recientes:');
+                        for (const line of changelog.split('\n')) {
+                            logger_1.log.dim(`    ${line}`);
+                        }
+                        logger_1.log.blank();
+                    }
+                }
+                catch { }
+                target = `origin/${branch}`;
+            }
+            // 4. Confirmación
+            if (!opts.force) {
+                const { confirm } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'confirm',
+                        message: `¿Actualizar a ${target}?`,
+                        default: true,
+                    },
+                ]);
+                if (!confirm) {
+                    logger_1.log.info('Actualización cancelada');
+                    return;
+                }
+            }
+            // 5. Backup de configuración
+            const backupSpinner = (0, ora_1.default)('Verificando archivos protegidos...').start();
+            const protectedFiles = [];
+            for (const item of BACKUP_DIRS) {
+                const itemPath = path_1.default.join(ROOT_DIR, item);
+                if (fs_1.default.existsSync(itemPath)) {
+                    protectedFiles.push(item);
+                }
+            }
+            backupSpinner.succeed(`Archivos protegidos: ${protectedFiles.join(', ') || 'ninguno'}`);
+            // 6. Aplicar actualización
+            const updateSpinner = (0, ora_1.default)('Aplicando actualización...').start();
+            try {
+                if (opts.tag) {
+                    (0, child_process_1.execSync)(`git checkout ${opts.tag}`, { cwd: ROOT_DIR, stdio: 'pipe' });
+                }
+                else {
+                    const branch = opts.branch || currentBranch || 'main';
+                    (0, child_process_1.execSync)(`git pull origin ${branch} --ff-only`, { cwd: ROOT_DIR, stdio: 'pipe' });
+                }
+                updateSpinner.succeed('Código actualizado');
+            }
+            catch (err) {
+                updateSpinner.fail('Error al actualizar: ' + err.message);
+                logger_1.log.warn('Intentando merge...');
+                try {
+                    const branch = opts.branch || currentBranch || 'main';
+                    (0, child_process_1.execSync)(`git pull origin ${branch}`, { cwd: ROOT_DIR, stdio: 'pipe' });
+                    logger_1.log.success('Merge completado');
+                }
+                catch (mergeErr) {
+                    logger_1.log.error('Conflicto de merge. Resuelve manualmente con:');
+                    logger_1.log.dim('  git status');
+                    logger_1.log.dim('  git merge --abort  (para cancelar)');
+                    return;
+                }
+            }
+            // 7. Instalar dependencias
+            const depsSpinner = (0, ora_1.default)('Instalando dependencias...').start();
+            try {
+                (0, child_process_1.execSync)('npm install', { cwd: ROOT_DIR, stdio: 'pipe', timeout: 120000 });
+                depsSpinner.succeed('Dependencias instaladas');
+            }
+            catch (err) {
+                depsSpinner.warn('Error instalando dependencias: ' + err.message);
+            }
+            // 8. Mostrar nueva versión
+            const newVersion = getCurrentVersion();
+            const newCommit = getCurrentCommit();
+            logger_1.log.blank();
+            logger_1.log.success(chalk_1.default.bold('Actualización completada'));
+            logger_1.log.blank();
+            logger_1.log.info(`Versión: ${chalk_1.default.dim(currentVersion)} ${chalk_1.default.white('→')} ${chalk_1.default.cyan(newVersion)}`);
+            logger_1.log.info(`Commit:  ${chalk_1.default.dim(currentCommit)} ${chalk_1.default.white('→')} ${chalk_1.default.cyan(newCommit)}`);
+            logger_1.log.blank();
+            logger_1.log.dim('  Próximos pasos:');
+            logger_1.log.dim('    openfactu migrate        — Aplicar migraciones de BD pendientes');
+            logger_1.log.dim('    openfactu migrate:status  — Ver estado de migraciones');
+            logger_1.log.blank();
+        }
+        catch (err) {
+            logger_1.log.error(err.message);
+            process.exitCode = 1;
+        }
+    });
+    // ── openfactu update:check ──
+    program
+        .command('update:check')
+        .description('Comprueba si hay actualizaciones disponibles')
+        .action(async () => {
+        const spinner = (0, ora_1.default)('Comprobando actualizaciones...').start();
+        try {
+            const currentVersion = getCurrentVersion();
+            const currentBranch = getCurrentBranch();
+            const currentCommit = getCurrentCommit();
+            (0, child_process_1.execSync)('git fetch --all --tags', { cwd: ROOT_DIR, stdio: 'pipe' });
+            const remoteCommit = getRemoteLatestCommit(currentBranch);
+            const tags = getRemoteTags();
+            spinner.stop();
+            logger_1.log.info(`Versión actual:  ${chalk_1.default.cyan(currentVersion)} (${currentCommit})`);
+            logger_1.log.info(`Branch:          ${chalk_1.default.cyan(currentBranch)}`);
+            if (remoteCommit === currentCommit) {
+                logger_1.log.success('Estás en la última versión');
+            }
+            else {
+                const behindCount = (0, child_process_1.execSync)(`git rev-list --count HEAD..origin/${currentBranch}`, { cwd: ROOT_DIR }).toString().trim();
+                logger_1.log.warn(`Hay ${chalk_1.default.yellow(behindCount)} commit(s) nuevos disponibles`);
+                logger_1.log.dim(`  Ejecuta: openfactu update`);
+            }
+            if (tags.length > 0) {
+                logger_1.log.blank();
+                logger_1.log.info('Versiones disponibles (tags):');
+                for (const tag of tags.slice(0, 5)) {
+                    const isCurrent = tag === `v${currentVersion}`;
+                    console.log(`  ${isCurrent ? chalk_1.default.green('→') : ' '} ${chalk_1.default.cyan(tag)}${isCurrent ? chalk_1.default.dim(' (actual)') : ''}`);
+                }
+                if (tags.length > 5) {
+                    logger_1.log.dim(`  ... y ${tags.length - 5} más`);
+                }
+            }
+        }
+        catch (err) {
+            spinner.fail('No se pudo comprobar: ' + err.message);
+            process.exitCode = 1;
+        }
+    });
+}

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

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

package/dist/src/commands/version.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerVersionCommand = registerVersionCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const paths_1 = require("../utils/paths");
+function registerVersionCommand(program) {
+    program
+        .command('version')
+        .description('Muestra la versión de OpenFactu')
+        .action(() => {
+        let root;
+        try {
+            root = (0, paths_1.getProjectRoot)();
+        }
+        catch {
+            root = '';
+        }
+        const cliPkg = readPkg(path_1.default.resolve(__dirname, '../../package.json'));
+        const serverPkg = root ? readPkg(path_1.default.join(root, 'apps/server/package.json')) : null;
+        const webPkg = root ? readPkg(path_1.default.join(root, 'apps/web/package.json')) : null;
+        const rootPkg = root ? readPkg(path_1.default.join(root, 'package.json')) : null;
+        console.log();
+        console.log(chalk_1.default.bold.white('  OpenFactu'));
+        console.log(chalk_1.default.dim('  ─────────────────────────────'));
+        console.log(`  ${chalk_1.default.dim('CLI:')}      ${chalk_1.default.cyan(cliPkg?.version || '?')}`);
+        console.log(`  ${chalk_1.default.dim('Server:')}   ${chalk_1.default.cyan(serverPkg?.version || '?')}`);
+        console.log(`  ${chalk_1.default.dim('Web:')}      ${chalk_1.default.cyan(webPkg?.version || '?')}`);
+        console.log(`  ${chalk_1.default.dim('Root:')}     ${chalk_1.default.cyan(rootPkg?.version || '?')}`);
+        console.log(`  ${chalk_1.default.dim('Node:')}     ${chalk_1.default.cyan(process.version)}`);
+        if (root) {
+            console.log(`  ${chalk_1.default.dim('Path:')}     ${chalk_1.default.dim(root)}`);
+        }
+        console.log();
+    });
+}
+function readPkg(pkgPath) {
+    try {
+        if (fs_1.default.existsSync(pkgPath)) {
+            return JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf-8'));
+        }
+    }
+    catch { }
+    return null;
+}

package/dist/src/index.d.ts

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

package/dist/src/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCLI = createCLI;
+const commander_1 = require("commander");
+const version_1 = require("./commands/version");
+const migrate_1 = require("./commands/migrate");
+const tenant_1 = require("./commands/tenant");
+const plugin_1 = require("./commands/plugin");
+const setup_1 = require("./commands/setup");
+const update_1 = require("./commands/update");
+function createCLI() {
+    const program = new commander_1.Command();
+    program
+        .name('openfactu')
+        .description('CLI para gestionar OpenFactu')
+        .version('0.1.0');
+    (0, version_1.registerVersionCommand)(program);
+    (0, migrate_1.registerMigrateCommand)(program);
+    (0, tenant_1.registerTenantCommand)(program);
+    (0, plugin_1.registerPluginCommand)(program);
+    (0, setup_1.registerSetupCommand)(program);
+    (0, update_1.registerUpdateCommand)(program);
+    return program;
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Carga la configuración desde .env del proyecto OpenFactu.
+ */
+export declare function loadConfig(): {
+    databaseUrl: string;
+    jwtSecret: string;
+    serverPort: string;
+};

package/dist/src/utils/config.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+const dotenv_1 = __importDefault(require("dotenv"));
+const fs_1 = __importDefault(require("fs"));
+const paths_1 = require("./paths");
+/**
+ * Carga la configuración desde .env del proyecto OpenFactu.
+ */
+function loadConfig() {
+    const envPath = (0, paths_1.getEnvPath)();
+    if (fs_1.default.existsSync(envPath)) {
+        dotenv_1.default.config({ path: envPath });
+    }
+    return {
+        databaseUrl: process.env.DATABASE_URL || 'postgresql://openfactu:openfactu_pass@localhost:5432/openfactudb',
+        jwtSecret: process.env.JWT_SECRET || 'super-secret-key',
+        serverPort: process.env.SERVER_PORT || '3000',
+    };
+}

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

@@ -0,0 +1,12 @@
+import { Pool } from 'pg';
+import { eq, sql } from 'drizzle-orm';
+declare const schema: any;
+export declare function getPublicDb(): any;
+export declare function getTenantDb(schemaName: string): import("drizzle-orm/node-postgres").NodePgDatabase<any> & {
+    $client: Pool;
+};
+export declare function getAllTenants(): Promise<any>;
+export declare function getTenantByName(name: string): Promise<any>;
+export declare function testConnection(): Promise<boolean>;
+export declare function disconnect(): Promise<void>;
+export { schema, sql, eq };

package/dist/src/utils/db.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eq = exports.sql = exports.schema = void 0;
+exports.getPublicDb = getPublicDb;
+exports.getTenantDb = getTenantDb;
+exports.getAllTenants = getAllTenants;
+exports.getTenantByName = getTenantByName;
+exports.testConnection = testConnection;
+exports.disconnect = disconnect;
+const node_postgres_1 = require("drizzle-orm/node-postgres");
+const pg_1 = require("pg");
+const drizzle_orm_1 = require("drizzle-orm");
+Object.defineProperty(exports, "eq", { enumerable: true, get: function () { return drizzle_orm_1.eq; } });
+Object.defineProperty(exports, "sql", { enumerable: true, get: function () { return drizzle_orm_1.sql; } });
+const config_1 = require("./config");
+// Importar schema de forma dinámica según la ruta del proyecto
+const paths_1 = require("./paths");
+const schemaPath = require('path').join((0, paths_1.getServerSrcDir)(), 'db/schema');
+const schema = require(schemaPath);
+exports.schema = schema;
+let pool = null;
+let db = null;
+function getPublicDb() {
+    if (db)
+        return db;
+    const config = (0, config_1.loadConfig)();
+    pool = new pg_1.Pool({ connectionString: config.databaseUrl });
+    db = (0, node_postgres_1.drizzle)(pool, { schema });
+    return db;
+}
+function getTenantDb(schemaName) {
+    const config = (0, config_1.loadConfig)();
+    const url = `${config.databaseUrl}${config.databaseUrl.includes('?') ? '&' : '?'}options=-csearch_path%3D${schemaName}%2Cpublic`;
+    const tenantPool = new pg_1.Pool({ connectionString: url });
+    return (0, node_postgres_1.drizzle)(tenantPool, { schema });
+}
+async function getAllTenants() {
+    const publicDb = getPublicDb();
+    return publicDb.select().from(schema.tenants);
+}
+async function getTenantByName(name) {
+    const publicDb = getPublicDb();
+    const [tenant] = await publicDb
+        .select()
+        .from(schema.tenants)
+        .where((0, drizzle_orm_1.eq)(schema.tenants.name, name));
+    return tenant || null;
+}
+async function testConnection() {
+    try {
+        const publicDb = getPublicDb();
+        await publicDb.execute(drizzle_orm_1.sql.raw('SELECT 1'));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function disconnect() {
+    if (pool) {
+        await pool.end();
+        pool = null;
+        db = null;
+    }
+}

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

@@ -0,0 +1,9 @@
+export declare const log: {
+    info: (msg: string) => void;
+    success: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    dim: (msg: string) => void;
+    title: (msg: string) => void;
+    blank: () => void;
+};

package/dist/src/utils/logger.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+exports.log = {
+    info: (msg) => console.log(chalk_1.default.blue('i'), msg),
+    success: (msg) => console.log(chalk_1.default.green('✓'), msg),
+    warn: (msg) => console.log(chalk_1.default.yellow('!'), msg),
+    error: (msg) => console.log(chalk_1.default.red('✗'), msg),
+    dim: (msg) => console.log(chalk_1.default.dim(msg)),
+    title: (msg) => console.log('\n' + chalk_1.default.bold.white(msg)),
+    blank: () => console.log(),
+};

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

@@ -0,0 +1,18 @@
+/**
+ * Detecta la raíz del proyecto OpenFactu.
+ * Busca en este orden:
+ *   1. Variable de entorno OPENFACTU_HOME
+ *   2. El directorio actual (si contiene package.json con name "openfactu")
+ *   3. Hacia arriba desde el directorio actual
+ *   4. Ruta relativa desde el paquete CLI instalado (monorepo)
+ */
+export declare function getProjectRoot(): string;
+/**
+ * Setea manualmente la raíz del proyecto.
+ */
+export declare function setProjectRoot(root: string): void;
+export declare function getServerDir(): string;
+export declare function getServerSrcDir(): string;
+export declare function getMigrationsDir(): string;
+export declare function getPluginsDir(): string;
+export declare function getEnvPath(): string;

package/dist/src/utils/paths.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectRoot = getProjectRoot;
+exports.setProjectRoot = setProjectRoot;
+exports.getServerDir = getServerDir;
+exports.getServerSrcDir = getServerSrcDir;
+exports.getMigrationsDir = getMigrationsDir;
+exports.getPluginsDir = getPluginsDir;
+exports.getEnvPath = getEnvPath;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+let _projectRoot = null;
+/**
+ * Detecta la raíz del proyecto OpenFactu.
+ * Busca en este orden:
+ *   1. Variable de entorno OPENFACTU_HOME
+ *   2. El directorio actual (si contiene package.json con name "openfactu")
+ *   3. Hacia arriba desde el directorio actual
+ *   4. Ruta relativa desde el paquete CLI instalado (monorepo)
+ */
+function getProjectRoot() {
+    if (_projectRoot)
+        return _projectRoot;
+    // 1. Variable de entorno
+    if (process.env.OPENFACTU_HOME) {
+        const envPath = path_1.default.resolve(process.env.OPENFACTU_HOME);
+        if (isOpenFactuRoot(envPath)) {
+            _projectRoot = envPath;
+            return _projectRoot;
+        }
+    }
+    // 2. Directorio actual
+    if (isOpenFactuRoot(process.cwd())) {
+        _projectRoot = process.cwd();
+        return _projectRoot;
+    }
+    // 3. Buscar hacia arriba desde el cwd
+    let dir = process.cwd();
+    while (dir !== path_1.default.dirname(dir)) {
+        if (isOpenFactuRoot(dir)) {
+            _projectRoot = dir;
+            return _projectRoot;
+        }
+        dir = path_1.default.dirname(dir);
+    }
+    // 4. Relativo al paquete CLI (dentro del monorepo)
+    const monorepoRoot = path_1.default.resolve(__dirname, '../../../..');
+    if (isOpenFactuRoot(monorepoRoot)) {
+        _projectRoot = monorepoRoot;
+        return _projectRoot;
+    }
+    throw new Error('No se encontró la instalación de OpenFactu.\n' +
+        'Opciones:\n' +
+        '  1. Ejecuta el comando desde el directorio de OpenFactu\n' +
+        '  2. Configura OPENFACTU_HOME=/ruta/a/OpenFactu\n');
+}
+/**
+ * Setea manualmente la raíz del proyecto.
+ */
+function setProjectRoot(root) {
+    _projectRoot = root;
+}
+function isOpenFactuRoot(dir) {
+    const pkgPath = path_1.default.join(dir, 'package.json');
+    if (!fs_1.default.existsSync(pkgPath))
+        return false;
+    try {
+        const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf-8'));
+        // Detectar por nombre o por la estructura de workspaces
+        return pkg.name === 'openfactu' || (pkg.workspaces && fs_1.default.existsSync(path_1.default.join(dir, 'apps/server')));
+    }
+    catch {
+        return false;
+    }
+}
+// Paths derivados
+function getServerDir() { return path_1.default.join(getProjectRoot(), 'apps/server'); }
+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'); }

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@openfactu/cli",
+  "version": "0.0.2",
+  "description": "CLI para gestionar OpenFactu: migraciones, tenants, plugins y setup",
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "bin": {
+    "openfactu": "./dist/bin/openfactu.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node bin/openfactu.ts"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "chalk": "^4.1.2",
+    "ora": "^5.4.1",
+    "inquirer": "^8.2.6",
+    "dotenv": "^16.0.0",
+    "cli-table3": "^0.6.5",
+    "drizzle-orm": "^0.45.2",
+    "pg": "^8.13.0",
+    "bcrypt": "^5.1.1"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^8.2.0",
+    "@types/pg": "^8.11.0",
+    "@types/bcrypt": "^5.0.0",
+    "typescript": "^5.3.3",
+    "ts-node": "^10.9.0"
+  }
+}