@johpaz/hive 1.1.4 → 1.1.5

package/packages/cli/dist/commands/chat.js

@@ -0,0 +1,152 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chat = chat;
+const fs = __importStar(require("fs"));
+const readline = __importStar(require("readline"));
+const loader_1 = require("@johpaz/hive-core/config/loader");
+const getHiveDirConst = () => (0, loader_1.getHiveDir)();
+async function chat(flags) {
+    const config = (0, loader_1.loadConfig)();
+    const HIVE_DIR = getHiveDirConst();
+    if (!fs.existsSync(HIVE_DIR)) {
+        console.log("❌ Directorio Hive no encontrado. Ejecuta: hive onboard");
+        return;
+    }
+    const agentId = flags.find((f) => f.startsWith("--agent"))?.split("=")[1] ||
+        flags[flags.indexOf("--agent") + 1] ||
+        "main";
+    console.log(`\n🐝 Chat con agente: ${agentId}`);
+    console.log("   Escribe /exit para salir, /new para nueva sesión\n");
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const question = (prompt) => {
+        return new Promise((resolve) => {
+            rl.question(prompt, resolve);
+        });
+    };
+    const messages = [];
+    while (true) {
+        const input = await question("> ");
+        const trimmed = input.trim();
+        if (!trimmed)
+            continue;
+        if (trimmed === "/exit" || trimmed === "/quit") {
+            console.log("👋 ¡Hasta luego!");
+            rl.close();
+            break;
+        }
+        if (trimmed === "/new") {
+            messages.length = 0;
+            console.log("📝 Nueva sesión iniciada\n");
+            continue;
+        }
+        if (trimmed === "/help") {
+            console.log(`
+Comandos disponibles:
+  /exit, /quit  - Salir del chat
+  /new          - Iniciar nueva sesión
+  /help         - Mostrar esta ayuda
+`);
+            continue;
+        }
+        messages.push({ role: "user", content: trimmed });
+        console.log("\n🤖 Pensando...\n");
+        try {
+            const response = await callLLM(config, messages);
+            messages.push({ role: "assistant", content: response });
+            console.log(`\n${response}\n`);
+        }
+        catch (error) {
+            console.log(`❌ Error: ${error.message}\n`);
+        }
+    }
+}
+async function callLLM(config, messages) {
+    const models = config.models;
+    const provider = models?.defaultProvider || "anthropic";
+    const defaults = models?.defaults;
+    const model = defaults?.default || defaults?.[provider] || "claude-sonnet-4-5";
+    const providers = models?.providers;
+    const providerConfig = providers?.[provider];
+    // Try to get API key from config, then process.env
+    const apiKey = providerConfig?.apiKey ||
+        process.env[`${provider.toUpperCase()}_API_KEY`] ||
+        "";
+    if (provider === "anthropic") {
+        const response = await fetch("https://api.anthropic.com/v1/messages", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-api-key": apiKey,
+                "anthropic-version": "2023-06-01",
+                "anthropic-dangerous-direct-browser-access": "true",
+            },
+            body: JSON.stringify({
+                model,
+                max_tokens: 4096,
+                messages: messages.map((m) => ({ role: m.role, content: m.content })),
+            }),
+        });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            throw new Error(`Anthropic API error: ${response.status} - ${JSON.stringify(errorData)}`);
+        }
+        const data = (await response.json());
+        return data.content[0]?.text || "Sin respuesta";
+    }
+    if (provider === "openai") {
+        const response = await fetch("https://api.openai.com/v1/chat/completions", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({
+                model,
+                messages: messages.map((m) => ({ role: m.role, content: m.content })),
+            }),
+        });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            throw new Error(`OpenAI API error: ${response.status} - ${JSON.stringify(errorData)}`);
+        }
+        const data = (await response.json());
+        return data.choices[0]?.message?.content || "Sin respuesta";
+    }
+    return `Proveedor '${provider}' no soportado en modo chat CLI. Usa 'hive start' para el Gateway completo.`;
+}

package/packages/cli/dist/commands/config.d.ts

@@ -0,0 +1 @@
+export declare function config(subcommand: string | undefined, args: string[]): Promise<void>;

package/packages/cli/dist/commands/config.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = config;
+const loader_1 = require("@johpaz/hive-core/config/loader");
+async function config(subcommand, args) {
+    switch (subcommand) {
+        case "show":
+            await showConfig();
+            break;
+        case "edit":
+            console.log("⚠️ La edición manual de archivos YAML ha sido deshabilitada.");
+            console.log("Configura Hive a través de variables de entorno o la base de datos.");
+            break;
+        default:
+            console.log(`
+Usage: hive config <command>
+
+Commands:
+  show      Mostrar la configuración actual (redactada)
+  edit      (Deshabilitado) Edición manual de configuración
+`);
+    }
+}
+function redactSecrets(obj, depth = 0) {
+    if (depth > 10)
+        return obj;
+    if (typeof obj !== "object" || obj === null)
+        return obj;
+    const sensitiveKeys = ["apiKey", "token", "botToken", "password", "secret", "key"];
+    if (Array.isArray(obj)) {
+        return obj.map((item) => redactSecrets(item, depth + 1));
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (sensitiveKeys.some((sk) => key.toLowerCase().includes(sk.toLowerCase()))) {
+            result[key] = "***REDACTED***";
+        }
+        else {
+            result[key] = redactSecrets(value, depth + 1);
+        }
+    }
+    return result;
+}
+async function showConfig() {
+    const config = (0, loader_1.loadConfig)();
+    console.log("\n⚙️  Configuración Actual (Redactada):\n");
+    console.log(JSON.stringify(redactSecrets(config), null, 2));
+    console.log();
+}

package/packages/cli/dist/commands/cron.d.ts

@@ -0,0 +1 @@
+export declare function cron(subcommand: string | undefined, args: string[]): Promise<void>;

package/packages/cli/dist/commands/cron.js

@@ -0,0 +1,166 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cron = cron;
+const p = __importStar(require("@clack/prompts"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const loader_1 = require("@johpaz/hive-core/config/loader");
+const getHiveDirConst = () => (0, loader_1.getHiveDir)();
+const getCronDir = () => path.join(getHiveDirConst(), "cron");
+const CRON_DB = path.join(getCronDir(), "jobs.json");
+function loadJobs() {
+    if (!fs.existsSync(CRON_DB))
+        return [];
+    try {
+        return JSON.parse(fs.readFileSync(CRON_DB, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+function saveJobs(jobs) {
+    if (!fs.existsSync(getCronDir())) {
+        fs.mkdirSync(getCronDir(), { recursive: true });
+    }
+    fs.writeFileSync(CRON_DB, JSON.stringify(jobs, null, 2));
+}
+async function cron(subcommand, args) {
+    switch (subcommand) {
+        case "list":
+            await listCron();
+            break;
+        case "add":
+            await addCron();
+            break;
+        case "remove":
+            await removeCron(args[0]);
+            break;
+        case "logs":
+            await cronLogs();
+            break;
+        default:
+            console.log(`
+Usage: hive cron <command>
+
+Commands:
+  list        Listar cron jobs
+  add         Añadir cron job
+  remove <id> Eliminar cron job
+  logs        Ver logs de cron
+`);
+    }
+}
+async function listCron() {
+    const jobs = loadJobs();
+    if (jobs.length === 0) {
+        console.log("No hay cron jobs configurados");
+        return;
+    }
+    console.log("\n⏰ Cron Jobs:\n");
+    for (const job of jobs) {
+        const status = job.enabled ? "✅ Activo" : "⏸️  Pausado";
+        console.log(`  ${job.id}`);
+        console.log(`    Estado:    ${status}`);
+        console.log(`    Schedule:  ${job.schedule}`);
+        console.log(`    Comando:   ${job.command}`);
+        if (job.lastRun) {
+            console.log(`    Última:    ${job.lastRun}`);
+        }
+        console.log();
+    }
+}
+async function addCron() {
+    const idValue = await p.text({
+        message: "ID del cron job:",
+        placeholder: "daily-report",
+        validate: (v) => (!v ? "El ID es requerido" : undefined),
+    });
+    if (p.isCancel(idValue)) {
+        p.cancel("Cancelado");
+        return;
+    }
+    const scheduleValue = await p.text({
+        message: "Schedule (cron expression):",
+        placeholder: "0 9 * * *",
+        validate: (v) => (!v ? "El schedule es requerido" : undefined),
+    });
+    if (p.isCancel(scheduleValue)) {
+        p.cancel("Cancelado");
+        return;
+    }
+    const commandValue = await p.text({
+        message: "Comando a ejecutar:",
+        placeholder: "hive chat --agent work 'Genera el reporte diario'",
+        validate: (v) => (!v ? "El comando es requerido" : undefined),
+    });
+    if (p.isCancel(commandValue)) {
+        p.cancel("Cancelado");
+        return;
+    }
+    const jobs = loadJobs();
+    jobs.push({
+        id: idValue,
+        schedule: scheduleValue,
+        command: commandValue,
+        enabled: true,
+    });
+    saveJobs(jobs);
+    console.log(`✅ Cron job "${idValue}" creado`);
+}
+async function removeCron(id) {
+    if (!id) {
+        console.log("❌ Especifica el ID: hive cron remove <id>");
+        return;
+    }
+    const jobs = loadJobs();
+    const index = jobs.findIndex((j) => j.id === id);
+    if (index === -1) {
+        console.log(`❌ Cron job no encontrado: ${id}`);
+        return;
+    }
+    jobs.splice(index, 1);
+    saveJobs(jobs);
+    console.log(`✅ Cron job "${id}" eliminado`);
+}
+async function cronLogs() {
+    const logFile = path.join(getCronDir(), "cron.log");
+    if (!fs.existsSync(logFile)) {
+        console.log("No hay logs de cron");
+        return;
+    }
+    const content = fs.readFileSync(logFile, "utf-8");
+    console.log(content);
+}

package/packages/cli/dist/commands/dev.d.ts

@@ -0,0 +1 @@
+export declare function dev(): Promise<void>;

package/packages/cli/dist/commands/dev.js

@@ -0,0 +1,120 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dev = dev;
+const p = __importStar(require("@clack/prompts"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const loader_1 = require("../../../core/src/config/loader");
+function showDevBanner() {
+    const hiveDir = (0, loader_1.getHiveDir)();
+    console.log(`
+╔══════════════════════════════════════════════════╗
+║  🔧  HIVE DEV MODE                               ║
+║  Configuración en: ${hiveDir}
+║  Tu configuración real en ~/.hive/ no será modificada.    ║
+╚══════════════════════════════════════════════════╝
+`);
+}
+async function dev() {
+    const hiveDir = (0, loader_1.getHiveDir)();
+    const dbPath = path.join(hiveDir, "data", "hive.db");
+    // Create hiveDir if it doesn't exist
+    if (!fs.existsSync(hiveDir)) {
+        fs.mkdirSync(hiveDir, { recursive: true });
+    }
+    // ── Step 1: Si existe sesión anterior, preguntar si limpiar ──
+    if (fs.readdirSync(hiveDir).length > 0) {
+        const stats = fs.statSync(hiveDir);
+        const hoursAgo = Math.floor((Date.now() - stats.mtime.getTime()) / (1000 * 60 * 60));
+        const timeAgo = hoursAgo < 1 ? "hace unos minutos" : `hace ${hoursAgo} hora${hoursAgo > 1 ? "s" : ""}`;
+        console.log(`\n⚠️  Se encontró una sesión de dev anterior en ${hiveDir}\n    Última configuración: ${timeAgo}\n`);
+        const shouldClean = await p.confirm({
+            message: "¿Limpiar y empezar de nuevo?",
+            initialValue: true,
+        });
+        if (p.isCancel(shouldClean)) {
+            p.cancel("Operación cancelada.");
+            process.exit(0);
+        }
+        if (shouldClean) {
+            console.log("🧹 Limpiando entorno de dev anterior...");
+            fs.rmSync(hiveDir, { recursive: true, force: true });
+            fs.mkdirSync(hiveDir, { recursive: true });
+        }
+    }
+    showDevBanner();
+    // ── Step 2: Verificar si ya hay un agente configurado ──
+    let hasCompletedAgent = false;
+    if (fs.existsSync(dbPath)) {
+        try {
+            const { initializeDatabase, getDb } = await Promise.resolve().then(() => __importStar(require("../../../core/src/storage/sqlite")));
+            initializeDatabase();
+            const db = getDb();
+            const agent = db.query("SELECT id FROM agents WHERE is_coordinator = 1 AND status = 'idle' LIMIT 1").get();
+            hasCompletedAgent = !!agent;
+        }
+        catch {
+            hasCompletedAgent = false;
+        }
+    }
+    // ── Step 3: Si no hay agente, ejecutar onboarding (él crea dir + BD) ──
+    if (!hasCompletedAgent) {
+        console.log("🚀 Ejecutando onboarding interactivo...\n");
+        const { onboard } = await Promise.resolve().then(() => __importStar(require("./onboard")));
+        await onboard();
+        // Verificar que onboarding creó el agente
+        try {
+            const { getDb } = await Promise.resolve().then(() => __importStar(require("../../../core/src/storage/sqlite")));
+            const db = getDb();
+            const agent = db.query("SELECT id FROM agents WHERE is_coordinator = 1 AND status = 'idle' LIMIT 1").get();
+            if (!agent) {
+                console.error("❌ Onboard no creó la configuración en BD");
+                process.exit(1);
+            }
+        }
+        catch (e) {
+            console.error("❌ Error verificando configuración:", e.message);
+            process.exit(1);
+        }
+        console.log("\n✅ Onboarding completado. Arrancando el servidor...\n");
+    }
+    else {
+        console.log("🚀 Arrancando gateway con configuración existente...\n");
+    }
+    // ── Step 4: Arrancar gateway ──
+    const { start } = await Promise.resolve().then(() => __importStar(require("./gateway")));
+    await start(["--skip-check"]);
+}

package/packages/cli/dist/commands/doctor.d.ts

@@ -0,0 +1 @@
+export declare function doctor(): Promise<void>;

package/packages/cli/dist/commands/doctor.js

@@ -0,0 +1,161 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctor = doctor;
+const p = __importStar(require("@clack/prompts"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const loader_1 = require("@johpaz/hive-core/config/loader");
+const getHiveDirConst = () => (0, loader_1.getHiveDir)();
+const getWorkspace = () => path.join(getHiveDirConst(), "workspace");
+const getPidFile = () => path.join(getHiveDirConst(), "hive.pid");
+const getDbFile = () => path.join(getHiveDirConst(), "hive.db");
+function checkBun() {
+    try {
+        const version = (0, child_process_1.execSync)("bun --version", { encoding: "utf-8" }).trim();
+        return { ok: true, version };
+    }
+    catch {
+        return { ok: false, version: "no instalado" };
+    }
+}
+function checkNode() {
+    try {
+        const version = (0, child_process_1.execSync)("node --version", { encoding: "utf-8" }).trim();
+        return { ok: true, version };
+    }
+    catch {
+        return { ok: false, version: "no instalado" };
+    }
+}
+function isGatewayRunning() {
+    if (!fs.existsSync(getPidFile()))
+        return false;
+    const pid = parseInt(fs.readFileSync(getPidFile(), "utf-8").trim(), 10);
+    if (isNaN(pid))
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function doctor() {
+    console.log("\n🐝 Hive Doctor — Diagnóstico del sistema\n");
+    const checks = [];
+    // Runtime
+    const bun = checkBun();
+    checks.push({ category: "Runtime", name: "Bun", status: bun.ok ? "ok" : "error", message: `v${bun.version}` });
+    const node = checkNode();
+    checks.push({ category: "Runtime", name: "Node.js", status: node.ok ? "ok" : "warn", message: `${node.version} (para MCP servers)` });
+    // Directorio Base
+    if (fs.existsSync(getHiveDirConst())) {
+        checks.push({ category: "Sistema", name: "Directorio Hive", status: "ok", message: getHiveDirConst() });
+    }
+    else {
+        checks.push({ category: "Sistema", name: "Directorio Hive", status: "error", message: "no existe", hint: "Ejecuta 'hive onboard'" });
+    }
+    // Base de Datos
+    if (fs.existsSync(getDbFile())) {
+        checks.push({ category: "Sistema", name: "Base de Datos", status: "ok", message: "hive.db presente" });
+    }
+    else {
+        checks.push({ category: "Sistema", name: "Base de Datos", status: "warn", message: "hive.db no existe" });
+    }
+    // Configuración (In-memory/Env)
+    try {
+        const config = (0, loader_1.loadConfig)();
+        const gateway = config.gateway;
+        if (gateway) {
+            checks.push({ category: "Configuración", name: "Gateway Config", status: "ok", message: "cargada" });
+        }
+        else {
+            checks.push({ category: "Configuración", name: "Gateway Config", status: "warn", message: "usando valores por defecto" });
+        }
+        const models = config.models;
+        const provider = models?.defaultProvider;
+        if (provider) {
+            checks.push({ category: "Configuración", name: "Proveedor LLM", status: "ok", message: provider });
+        }
+        else {
+            checks.push({ category: "Configuración", name: "Proveedor LLM", status: "warn", message: "no configurado" });
+        }
+    }
+    catch (e) {
+        checks.push({ category: "Configuración", name: "Carga", status: "error", message: `Error: ${e.message}` });
+    }
+    // Workspace
+    checks.push({ category: "Workspace", name: "Directorio", status: fs.existsSync(getWorkspace()) ? "ok" : "warn", message: fs.existsSync(getWorkspace()) ? "existe" : "no existe" });
+    // Gateway
+    const running = isGatewayRunning();
+    checks.push({ category: "Gateway", name: "Estado", status: running ? "ok" : "warn", message: running ? "corriendo" : "detenido" });
+    // Mostrar resultados
+    const categories = [...new Set(checks.map((c) => c.category))];
+    for (const category of categories) {
+        console.log(`${category}`);
+        const categoryChecks = checks.filter((c) => c.category === category);
+        for (const check of categoryChecks) {
+            const icon = check.status === "ok" ? "✅" : check.status === "warn" ? "⚠️ " : "❌";
+            console.log(`  ${icon} ${check.name}: ${check.message}`);
+            if (check.hint) {
+                console.log(`     💡 ${check.hint}`);
+            }
+        }
+        console.log();
+    }
+    // Resumen
+    const errors = checks.filter((c) => c.status === "error");
+    const warns = checks.filter((c) => c.status === "warn");
+    if (errors.length > 0) {
+        console.log(`❌ ${errors.length} error(es) encontrado(s)`);
+        const fix = await p.confirm({
+            message: "¿Deseas ejecutar el onboarding para reparar?",
+            initialValue: false,
+        });
+        if (fix) {
+            const { onboard } = await Promise.resolve().then(() => __importStar(require("./onboard")));
+            await onboard();
+        }
+    }
+    else if (warns.length > 0) {
+        console.log(`⚠️  ${warns.length} advertencia(s)`);
+    }
+    else {
+        console.log("✅ Todo en orden");
+    }
+}

package/packages/cli/dist/commands/gateway.d.ts

@@ -0,0 +1,4 @@
+export declare function start(flags: string[]): Promise<void>;
+export declare function stop(): Promise<void>;
+export declare function status(flags: string[]): Promise<void>;
+export declare function reload(): Promise<void>;