@johpaz/hive 1.1.4 → 1.1.5

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

@@ -0,0 +1,444 @@
+"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.start = start;
+exports.stop = stop;
+exports.status = status;
+exports.reload = reload;
+const hive_core_1 = require("@johpaz/hive-core");
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const child_process_1 = require("child_process");
+const children = [];
+function cleanup() {
+    if (children.length === 0)
+        return;
+    console.log("\n🧹 Limpiando procesos hijos...");
+    for (const child of children) {
+        if (child.pid) {
+            try {
+                // En Linux, matar el grupo de procesos si fue iniciado como detached
+                process.kill(-child.pid, "SIGTERM");
+            }
+            catch {
+                child.kill("SIGTERM");
+            }
+        }
+    }
+}
+// Listen for termination signals
+process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+});
+process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+});
+// Ensure cleanup on normal exit
+process.on("exit", () => {
+    cleanup();
+});
+function getDefaultPidFile() {
+    return path.join((0, hive_core_1.getHiveDir)(), "gateway.pid");
+}
+function getLogFile() {
+    return path.join((0, hive_core_1.getHiveDir)(), "logs", "gateway.log");
+}
+async function getPidFile() {
+    try {
+        const config = await (0, hive_core_1.loadConfig)();
+        return (0, hive_core_1.expandConfigPath)(config.gateway?.pidFile) ?? getDefaultPidFile();
+    }
+    catch {
+        return getDefaultPidFile();
+    }
+}
+function ensureLogDir() {
+    const logDir = path.dirname(getLogFile());
+    if (!(0, node_fs_1.existsSync)(logDir)) {
+        (0, node_fs_1.mkdirSync)(logDir, { recursive: true });
+    }
+}
+function openBrowser(url) {
+    const platform = process.platform;
+    // Build the shell command for the platform
+    let shellCmd;
+    if (platform === "win32") {
+        shellCmd = `start "" "${url}"`;
+    }
+    else if (platform === "darwin") {
+        shellCmd = `open "${url}"`;
+    }
+    else {
+        // Linux: try gio open first (GNOME/Wayland native, no DISPLAY needed),
+        // then xdg-open, then common browser names. '|| true' ensures exit 0.
+        shellCmd = `gio open "${url}" 2>/dev/null || xdg-open "${url}" 2>/dev/null || sensible-browser "${url}" 2>/dev/null || x-www-browser "${url}" 2>/dev/null || true`;
+    }
+    console.log(`🌐 Abriendo navegador en ${url}`);
+    try {
+        const shell = platform === "win32" ? "cmd" : "/bin/sh";
+        const shellArg = platform === "win32" ? "/c" : "-c";
+        // Bun.spawn is the native Bun API — more reliable than child_process.spawn in Bun
+        const proc = Bun.spawn([shell, shellArg, shellCmd], {
+            stdout: "ignore",
+            stderr: "ignore",
+            stdin: "ignore",
+        });
+        proc.unref(); // Don't keep event loop alive waiting for the browser process
+    }
+    catch {
+        console.log(`\n🌐 Abre Hive aquí: ${url}\n`);
+    }
+}
+async function isSetupMode() {
+    const hiveDir = (0, hive_core_1.getHiveDir)();
+    const dbPath = path.join(hiveDir, "data", "hive.db");
+    return !(0, node_fs_1.existsSync)(dbPath);
+}
+async function isRunning() {
+    const pidFile = await getPidFile();
+    if (!(0, node_fs_1.existsSync)(pidFile))
+        return false;
+    const pid = parseInt((0, node_fs_1.readFileSync)(pidFile, "utf-8").trim(), 10);
+    if (isNaN(pid))
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        try {
+            (0, node_fs_1.unlinkSync)(pidFile);
+        }
+        catch { }
+        return false;
+    }
+}
+async function waitForPort(port, timeout = 30000) {
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+        try {
+            const response = await fetch(`http://127.0.0.1:${port}/health`, {
+                method: "HEAD",
+                signal: AbortSignal.timeout(1000)
+            });
+            if (response.ok || response.status === 204) {
+                return true;
+            }
+        }
+        catch {
+            // Port not ready yet
+        }
+        await Bun.sleep(500);
+    }
+    return false;
+}
+async function waitForVite(port, timeout = 30000) {
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+        try {
+            // Usar 127.0.0.1 en lugar de localhost para evitar demoras de resolución DNS (IPv6 vs IPv4)
+            const response = await fetch(`http://127.0.0.1:${port}`, {
+                method: "HEAD",
+                signal: AbortSignal.timeout(200) // Timeout más agresivo para una conexión local
+            });
+            if (response.ok || response.status === 200) {
+                return true;
+            }
+        }
+        catch {
+            // Puerto aún no disponible
+        }
+        await Bun.sleep(200); // Poll más frecuente
+    }
+    return false;
+}
+async function start(flags) {
+    const daemon = flags.includes("--daemon");
+    const skipCheck = flags.includes("--skip-check");
+    const devInternal = flags.includes("--dev-internal");
+    // Check if we're in dev mode and config doesn't exist
+    const isDev = process.env.HIVE_DEV === "true" || process.env.NODE_ENV === "development";
+    const hiveDir = (0, hive_core_1.getHiveDir)();
+    const dbPath = path.join(hiveDir, "data", "hive.db");
+    // Skip onboarding check if running as child process in dev mode
+    const isGatewayChild = process.env.HIVE_GATEWAY_CHILD === "1";
+    // Database-centric onboarding check
+    if (isDev && !isGatewayChild) {
+        let hasCompletedOnboarding = false;
+        if ((0, node_fs_1.existsSync)(dbPath)) {
+            try {
+                const { initializeDatabase, getDb } = await Promise.resolve().then(() => __importStar(require("../../../core/src/storage/sqlite")));
+                initializeDatabase();
+                const db = getDb();
+                const existingAgent = db.query("SELECT id FROM agents WHERE is_coordinator = 1 AND status = 'idle' LIMIT 1").get();
+                hasCompletedOnboarding = !!existingAgent;
+            }
+            catch (e) {
+                hasCompletedOnboarding = false;
+            }
+        }
+        if (!hasCompletedOnboarding) {
+            console.log("\n🚀 Sistema no inicializado. Ejecutando onboard...\n");
+            const { onboard } = await Promise.resolve().then(() => __importStar(require("./onboard")));
+            await onboard();
+            // Verify onboarding success via DB
+            try {
+                const { getDb } = await Promise.resolve().then(() => __importStar(require("../../../core/src/storage/sqlite")));
+                const db = getDb();
+                const existingAgent = db.query("SELECT id FROM agents WHERE is_coordinator = 1 AND status = 'idle' LIMIT 1").get();
+                if (!existingAgent) {
+                    console.error("❌ Onboard no completó la inicialización correctamente");
+                    return;
+                }
+            }
+            catch (e) {
+                console.error("❌ Error verificando inicialización:", e.message);
+                return;
+            }
+        }
+    }
+    if (!skipCheck && await isRunning()) {
+        console.log("⚠️  Hive Gateway ya está corriendo");
+        return;
+    }
+    const config = await (0, hive_core_1.loadConfig)();
+    if (config.logging?.level) {
+        hive_core_1.logger.setLevel(config.logging.level);
+    }
+    // Only show banner if not running as child process (parent already shows status)
+    if (!isGatewayChild) {
+        console.log(`
+ ╔═══════════════════════════════════════════╗
+ ║                                            ║
+ ║   ██╗  ██╗██╗██╗   ██╗███████╗             ║
+ ║   ██║  ██║██║██║   ██║██╔════╝             ║
+ ║   ███████║██║██║   ██║█████╗               ║
+ ║   ██╔══██║██║╚██╗ ██╔╝██╔══╝               ║
+ ║   ██║  ██║██║ ╚████╔╝ ███████╗             ║
+ ║   ╚═╝  ╚═╝╚═╝  ╚═══╝  ╚══════╝             ║
+ ║                                            ║
+ ║   Personal Swarm AI Gateway — v1.0.10      ║
+ ╚════════════════════════════════════════════╝
+`);
+    }
+    if (daemon) {
+        ensureLogDir();
+        const logFile = getLogFile();
+        const child = (0, child_process_1.spawn)(process.execPath, [process.argv[1] || "", "start", "--skip-check"], {
+            detached: true,
+            stdio: ["ignore", (0, node_fs_1.openSync)(logFile, "a"), (0, node_fs_1.openSync)(logFile, "a")],
+        });
+        child.unref();
+        (0, node_fs_1.writeFileSync)(await getPidFile(), child.pid?.toString() || "");
+        console.log(`✅ Hive Gateway iniciado en modo daemon (PID: ${child.pid})`);
+        console.log(`   Logs: ${logFile}`);
+        return;
+    }
+    // In dev mode, start Vite and Gateway concurrently for faster startup
+    if (isDev) {
+        // ── CHILD PROCESS: Only run Gateway server ───────────────────────────────
+        if (isGatewayChild) {
+            // Child process: skip Vite and Code Bridge, just start Gateway
+            hive_core_1.logger.info("Starting Gateway server (child process)...");
+            await (0, hive_core_1.startGateway)(config);
+            return;
+        }
+        // ── PARENT PROCESS: Start Vite, Code Bridge, and spawn child Gateway ─────
+        const hiveUiPath = path.join(process.cwd(), "packages/hive-ui");
+        const hasVite = (0, node_fs_1.existsSync)(path.join(hiveUiPath, "package.json"));
+        // Start Vite in background (don't wait)
+        if (hasVite) {
+            console.log("🎨 Iniciando Vite (UI)...\n");
+            const viteProcess = (0, child_process_1.spawn)("bun", ["run", "dev"], {
+                cwd: hiveUiPath,
+                stdio: ["ignore", "pipe", "pipe"],
+                detached: true,
+            });
+            // Pipe logs to stdout/stderr with a prefix
+            viteProcess.stdout?.on("data", (data) => {
+                const lines = data.toString().split("\n");
+                for (const line of lines) {
+                    if (line.trim())
+                        console.log(`[Vite] ${line}`);
+                }
+            });
+            viteProcess.stderr?.on("data", (data) => {
+                const lines = data.toString().split("\n");
+                for (const line of lines) {
+                    if (line.trim())
+                        console.error(`[Vite] ${line}`);
+                }
+            });
+            viteProcess.on("error", (error) => {
+                console.error(`❌ Error iniciando Vite: ${error.message}`);
+            });
+            if (!daemon) {
+                children.push(viteProcess);
+            }
+            else {
+                viteProcess.unref();
+            }
+        }
+        // Start Code Bridge sidecar (parent process only)
+        try {
+            await Promise.resolve().then(() => __importStar(require("@johpaz/hive-code-bridge")));
+        }
+        catch (error) {
+            console.warn(`⚠️  No se pudo iniciar el Code Bridge: ${error.message}`);
+        }
+        // Start Gateway in a separate process (non-blocking)
+        const gatewayProcess = (0, child_process_1.spawn)(process.execPath, [process.argv[1] || "", "start", "--skip-check", "--dev-internal"], {
+            detached: true,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: { ...process.env, HIVE_DEV: "true", HIVE_GATEWAY_CHILD: "1" },
+        });
+        gatewayProcess.stdout?.on("data", (data) => {
+            const lines = data.toString().split("\n");
+            for (const line of lines) {
+                if (line.trim())
+                    console.log(`[Gateway] ${line}`);
+            }
+        });
+        gatewayProcess.stderr?.on("data", (data) => {
+            const lines = data.toString().split("\n");
+            for (const line of lines) {
+                if (line.trim())
+                    console.error(`[Gateway] ${line}`);
+            }
+        });
+        gatewayProcess.on("error", (error) => {
+            console.error(`❌ Error iniciando Gateway: ${error.message}`);
+        });
+        if (!daemon) {
+            children.push(gatewayProcess);
+        }
+        else {
+            gatewayProcess.unref();
+        }
+        // Wait for both Vite and Gateway to be ready
+        console.log("⏳ Esperando servicios...");
+        const [viteReady, gatewayReady] = await Promise.all([
+            hasVite ? waitForVite(5173, 30000) : Promise.resolve(true),
+            waitForPort(18790, 30000),
+        ]);
+        if (!viteReady && hasVite) {
+            console.error("⚠️  Vite no respondió a tiempo");
+        }
+        if (!gatewayReady) {
+            console.error("⚠️  Gateway no respondió a tiempo");
+            return;
+        }
+        console.log("✅ Servicios listos\n");
+        // Determine if we should open /setup or /ui
+        const setupMode = await isSetupMode();
+        const url = setupMode
+            ? "http://localhost:5173/setup"
+            : "http://localhost:5173";
+        console.log(`
+╔════════════════════════════════════════╗
+║  🐝  Hive — Modo Desarrollo            ║
+╠════════════════════════════════════════╣
+║  UI:        ${url.padEnd(24)}║
+║  API:       http://127.0.0.1:18790     ║
+║  WebSocket: ws://127.0.0.1:18790/ws    ║
+║  Canvas:    ws://127.0.0.1:18790/canvas║
+╠════════════════════════════════════════╣
+║  ${setupMode ? "🎉 Primer arranque — abriendo setup..." : "Administra tu Hive aquí                "}║
+╚════════════════════════════════════════╝
+`);
+        openBrowser(url);
+        // Keep the process alive
+        if (!daemon) {
+            await new Promise(() => { }); // Infinite wait
+        }
+        return;
+    }
+    // Production mode (not dev) - start Gateway blocking
+    await (0, hive_core_1.startGateway)(config);
+}
+async function stop() {
+    if (!(await isRunning())) {
+        console.log("⚠️  Hive Gateway no está corriendo");
+        return;
+    }
+    const pidFile = await getPidFile();
+    const pid = parseInt((0, node_fs_1.readFileSync)(pidFile, "utf-8").trim(), 10);
+    try {
+        process.kill(pid, "SIGTERM");
+        (0, node_fs_1.unlinkSync)(pidFile);
+        console.log("✅ Hive Gateway detenido");
+    }
+    catch (e) {
+        console.error("❌ Error deteniendo el Gateway:", e);
+    }
+}
+async function status(flags) {
+    const running = await isRunning();
+    const hiveDir = (0, hive_core_1.getHiveDir)();
+    console.log("🐝 Hive Gateway Status\n");
+    const config = await (0, hive_core_1.loadConfig)();
+    const pidFile = await getPidFile();
+    console.log(`Estado:      ${running ? "✅ Corriendo" : "⏹️  Detenido"}`);
+    if (running) {
+        const pid = (0, node_fs_1.readFileSync)(pidFile, "utf-8").trim();
+        console.log(`PID:         ${pid}`);
+    }
+    console.log(`Puerto:      ${config.gateway?.port || 18790}`);
+    console.log(`Host:        ${config.gateway?.host || "127.0.0.1"}`);
+    const provider = config.models?.defaultProvider || "no configurado";
+    const model = config.models?.defaults?.[provider] || config.models?.defaults?.default || "no configurado";
+    console.log(`Modelo:      ${provider} / ${model}`);
+    console.log(`Home:        ${hiveDir}`);
+    console.log(`Logs:        ${getLogFile()}`);
+    if (flags.includes("--json")) {
+        console.log("\n" + JSON.stringify({ running, pid: running ? (0, node_fs_1.readFileSync)(pidFile, "utf-8").trim() : null, config }, null, 2));
+    }
+}
+async function reload() {
+    if (!(await isRunning())) {
+        console.log("⚠️  Hive Gateway no está corriendo");
+        return;
+    }
+    const pid = parseInt((0, node_fs_1.readFileSync)(await getPidFile(), "utf-8").trim(), 10);
+    try {
+        process.kill(pid, "SIGHUP");
+        console.log("✅ Configuración recargada");
+    }
+    catch (e) {
+        console.error("❌ Error recargando configuración:", e);
+    }
+}

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

@@ -0,0 +1 @@
+export declare function logs(flags: string[]): Promise<void>;

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

@@ -0,0 +1,87 @@
+"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.logs = logs;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const LOG_DIR = path.join(process.env.HOME || "", ".hive", "logs");
+const LOG_FILE = path.join(LOG_DIR, "gateway.log");
+async function logs(flags) {
+    if (flags.includes("--clear")) {
+        await clearLogs();
+        return;
+    }
+    if (!fs.existsSync(LOG_FILE)) {
+        console.log("No hay logs disponibles");
+        return;
+    }
+    const follow = flags.includes("--follow") || flags.includes("-f");
+    const levelFlag = flags.find((f) => f.startsWith("--level"));
+    const level = levelFlag ? levelFlag.split("=")[1] || flags[flags.indexOf(levelFlag) + 1] : null;
+    const agentFlag = flags.find((f) => f.startsWith("--agent"));
+    const agent = agentFlag ? agentFlag.split("=")[1] || flags[flags.indexOf(agentFlag) + 1] : null;
+    const lines = 100;
+    if (follow) {
+        const tail = (0, child_process_1.spawn)("tail", ["-f", LOG_FILE], { stdio: "inherit" });
+        process.on("SIGINT", () => {
+            tail.kill();
+            process.exit(0);
+        });
+    }
+    else {
+        let content = fs.readFileSync(LOG_FILE, "utf-8");
+        const allLines = content.split("\n");
+        let filtered = allLines;
+        if (level) {
+            const levelLower = level.toLowerCase();
+            filtered = filtered.filter((l) => l.toLowerCase().includes(levelLower));
+        }
+        if (agent) {
+            filtered = filtered.filter((l) => l.includes(agent));
+        }
+        const lastLines = filtered.slice(-lines);
+        console.log(lastLines.join("\n"));
+    }
+}
+async function clearLogs() {
+    if (fs.existsSync(LOG_FILE)) {
+        fs.writeFileSync(LOG_FILE, "");
+        console.log("✅ Logs limpiados");
+    }
+    else {
+        console.log("No hay logs para limpiar");
+    }
+}

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

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