@johpaz/hive 1.1.0

package/packages/cli/src/commands/gateway.ts

@@ -0,0 +1,443 @@
+import { loadConfig, startGateway, logger, expandConfigPath, expandPath, getHiveDir } from "@johpaz/hive-core";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, unlinkSync, openSync } from "node:fs";
+import * as path from "node:path";
+import { spawn, ChildProcess } from "child_process";
+
+
+const children: ChildProcess[] = [];
+
+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(): string {
+  return path.join(getHiveDir(), "gateway.pid");
+}
+
+function getLogFile(): string {
+  return path.join(getHiveDir(), "logs", "gateway.log");
+}
+
+async function getPidFile(): Promise<string> {
+  try {
+    const config = await loadConfig();
+    return expandConfigPath(config.gateway?.pidFile) ?? getDefaultPidFile();
+  } catch {
+    return getDefaultPidFile();
+  }
+}
+
+function ensureLogDir(): void {
+  const logDir = path.dirname(getLogFile());
+  if (!existsSync(logDir)) {
+    mkdirSync(logDir, { recursive: true });
+  }
+}
+
+function openBrowser(url: string): void {
+  const platform = process.platform;
+
+  // Build the shell command for the platform
+  let shellCmd: string;
+  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(): Promise<boolean> {
+  const hiveDir = getHiveDir();
+  const dbPath = path.join(hiveDir, "data", "hive.db");
+  return !existsSync(dbPath);
+}
+
+async function isRunning(): Promise<boolean> {
+  const pidFile = await getPidFile();
+  if (!existsSync(pidFile)) return false;
+  const pid = parseInt(readFileSync(pidFile, "utf-8").trim(), 10);
+  if (isNaN(pid)) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    try {
+      unlinkSync(pidFile);
+    } catch { }
+    return false;
+  }
+}
+
+async function waitForPort(port: number, timeout: number = 30000): Promise<boolean> {
+  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: number, timeout: number = 30000): Promise<boolean> {
+  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;
+}
+
+export async function start(flags: string[]): Promise<void> {
+  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 = 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 (existsSync(dbPath)) {
+      try {
+        const { initializeDatabase, getDb } = await import("../../../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 import("./onboard");
+      await onboard();
+
+      // Verify onboarding success via DB
+      try {
+        const { getDb } = await import("../../../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 as Error).message);
+        return;
+      }
+    }
+  }
+
+  if (!skipCheck && await isRunning()) {
+    console.log("⚠️  Hive Gateway ya está corriendo");
+    return;
+  }
+
+  const config = await loadConfig();
+
+  if (config.logging?.level) {
+    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 = spawn(process.execPath, [process.argv[1] || "", "start", "--skip-check"], {
+      detached: true,
+      stdio: ["ignore", openSync(logFile, "a"), openSync(logFile, "a")],
+    });
+    child.unref();
+    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
+      logger.info("Starting Gateway server (child process)...");
+      await startGateway(config);
+      return;
+    }
+
+    // ── PARENT PROCESS: Start Vite, Code Bridge, and spawn child Gateway ─────
+    const hiveUiPath = path.join(process.cwd(), "packages/hive-ui");
+    const hasVite = existsSync(path.join(hiveUiPath, "package.json"));
+
+    // Start Vite in background (don't wait)
+    if (hasVite) {
+      console.log("🎨 Iniciando Vite (UI)...\n");
+
+      const viteProcess = 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 import("@johpaz/hive-code-bridge");
+    } catch (error) {
+      console.warn(`⚠️  No se pudo iniciar el Code Bridge: ${(error as Error).message}`);
+    }
+
+    // Start Gateway in a separate process (non-blocking)
+    const gatewayProcess = 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 startGateway(config);
+}
+
+export async function stop(): Promise<void> {
+  if (!(await isRunning())) {
+    console.log("⚠️  Hive Gateway no está corriendo");
+    return;
+  }
+
+  const pidFile = await getPidFile();
+  const pid = parseInt(readFileSync(pidFile, "utf-8").trim(), 10);
+  try {
+    process.kill(pid, "SIGTERM");
+    unlinkSync(pidFile);
+    console.log("✅ Hive Gateway detenido");
+  } catch (e) {
+    console.error("❌ Error deteniendo el Gateway:", e);
+  }
+}
+
+export async function status(flags: string[]): Promise<void> {
+  const running = await isRunning();
+  const hiveDir = getHiveDir();
+
+  console.log("🐝 Hive Gateway Status\n");
+
+  const config = await loadConfig();
+  const pidFile = await getPidFile();
+
+  console.log(`Estado:      ${running ? "✅ Corriendo" : "⏹️  Detenido"}`);
+  if (running) {
+    const pid = 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 as any)?.defaults?.[provider] || (config.models as any)?.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 ? readFileSync(pidFile, "utf-8").trim() : null, config }, null, 2));
+  }
+}
+
+export async function reload(): Promise<void> {
+  if (!(await isRunning())) {
+    console.log("⚠️  Hive Gateway no está corriendo");
+    return;
+  }
+
+  const pid = parseInt(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/src/commands/logs.ts

@@ -0,0 +1,57 @@
+import * as fs from "fs";
+import * as path from "path";
+import { spawn } from "child_process";
+
+const LOG_DIR = path.join(process.env.HOME || "", ".hive", "logs");
+const LOG_FILE = path.join(LOG_DIR, "gateway.log");
+
+export async function logs(flags: string[]): Promise<void> {
+  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 = 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(): Promise<void> {
+  if (fs.existsSync(LOG_FILE)) {
+    fs.writeFileSync(LOG_FILE, "");
+    console.log("✅ Logs limpiados");
+  } else {
+    console.log("No hay logs para limpiar");
+  }
+}

package/packages/cli/src/commands/mcp.ts

@@ -0,0 +1,175 @@
+import * as p from "@clack/prompts";
+import { spawn } from "child_process";
+import { loadConfig } from "@johpaz/hive-core/config/loader";
+
+interface MCPServerConfig {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+  disabled?: boolean;
+}
+
+export async function mcp(subcommand: string | undefined, args: string[]): Promise<void> {
+  switch (subcommand) {
+    case "list":
+      await listMCP();
+      break;
+    case "add":
+      await addMCP();
+      break;
+    case "test":
+      await testMCP(args[0]);
+      break;
+    case "tools":
+      await toolsMCP(args[0]);
+      break;
+    case "remove":
+      await removeMCP(args[0]);
+      break;
+    default:
+      console.log(`
+Usage: hive mcp <command>
+
+Commands:
+  list              Listar servidores MCP
+  add               Añadir servidor MCP
+  test <nombre>     Verificar servidor MCP
+  tools <nombre>    Listar tools de un servidor
+  remove <nombre>   Eliminar servidor MCP
+`);
+  }
+}
+
+async function listMCP(): Promise<void> {
+  const config = loadConfig();
+  const mcpServers = (config.mcp as Record<string, MCPServerConfig>) || {};
+
+  if (Object.keys(mcpServers).length === 0) {
+    console.log("No hay servidores MCP configurados");
+    return;
+  }
+
+  console.log("\n🔌 Servidores MCP:\n");
+  for (const [name, server] of Object.entries(mcpServers)) {
+    const status = server.disabled ? "⏸️  Deshabilitado" : "✅ Activo";
+    console.log(`  ${name}`);
+    console.log(`    Estado:   ${status}`);
+    console.log(`    Comando:  ${server.command} ${(server.args || []).join(" ")}`);
+    console.log();
+  }
+}
+
+async function addMCP(): Promise<void> {
+  const config = loadConfig();
+
+  const name = await p.text({
+    message: "Nombre del servidor MCP:",
+    placeholder: "filesystem",
+    validate: (v) => (!v ? "El nombre es requerido" : undefined),
+  });
+
+  if (p.isCancel(name)) {
+    p.cancel("Cancelado");
+    return;
+  }
+
+  const command = await p.text({
+    message: "Comando para ejecutar:",
+    placeholder: "npx",
+    validate: (v) => (!v ? "El comando es requerido" : undefined),
+  });
+
+  if (p.isCancel(command)) {
+    p.cancel("Cancelado");
+    return;
+  }
+
+  const argsInput = await p.text({
+    message: "Argumentos (separados por espacio):",
+    placeholder: "-y @modelcontextprotocol/server-filesystem /path/to/dir",
+  });
+
+  if (p.isCancel(argsInput)) {
+    p.cancel("Cancelado");
+    return;
+  }
+
+  const args = argsInput ? (argsInput as string).split(" ").filter(Boolean) : [];
+
+  const serverConfig: MCPServerConfig = {
+    command: command as string,
+    args,
+  };
+
+  console.log(`✅ Servidor MCP "${name}" añadido (usa la UI o API del gateway para persistirlo en BD)`);
+}
+
+async function testMCP(name: string | undefined): Promise<void> {
+  if (!name) {
+    console.log("❌ Especifica el nombre del servidor: hive mcp test <nombre>");
+    return;
+  }
+
+  const config = loadConfig();
+  const mcpServers = (config.mcp as Record<string, MCPServerConfig>) || {};
+  const server = mcpServers[name];
+
+  if (!server) {
+    console.log(`❌ No existe el servidor MCP "${name}"`);
+    return;
+  }
+
+  console.log(`🔌 Probando conexión con ${name}...`);
+
+  const proc = spawn(server.command, server.args || [], {
+    env: { ...process.env, ...server.env },
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  proc.on("error", (err) => {
+    console.log(`❌ Error: ${err.message}`);
+  });
+
+  setTimeout(() => {
+    proc.kill();
+    console.log(`✅ Servidor ${name} responde`);
+  }, 2000);
+}
+
+async function toolsMCP(name: string | undefined): Promise<void> {
+  if (!name) {
+    console.log("❌ Especifica el nombre del servidor: hive mcp tools <nombre>");
+    return;
+  }
+
+  console.log(`📋 Tools de ${name}:`);
+  console.log("   (Esta funcionalidad requiere conexión MCP activa)");
+  console.log("   Usa 'hive mcp test <nombre>' para verificar conexión");
+}
+
+async function removeMCP(name: string | undefined): Promise<void> {
+  if (!name) {
+    console.log("❌ Especifica el nombre del servidor: hive mcp remove <nombre>");
+    return;
+  }
+
+  const config = loadConfig();
+  const mcpServers = (config.mcp as Record<string, MCPServerConfig>) || {};
+
+  if (!mcpServers[name]) {
+    console.log(`❌ No existe el servidor MCP "${name}"`);
+    return;
+  }
+
+  const confirm = await p.confirm({
+    message: `¿Eliminar el servidor MCP "${name}"?`,
+    initialValue: false,
+  });
+
+  if (p.isCancel(confirm) || !confirm) {
+    console.log("Cancelado");
+    return;
+  }
+
+  console.log(`✅ Servidor MCP "${name}" eliminado (usa la UI o API del gateway para persistirlo en BD)`);
+}