@johpaz/hive-agents 0.0.34 → 0.0.36

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

@@ -0,0 +1,203 @@
+// Paquete principal de Hive — instala el CLI con todas sus dependencias
+const MAIN_PACKAGE = "@johpaz/hive-agents";
+
+export async function update(): Promise<void> {
+  console.log("🔄 Actualizando Hive...\n");
+
+  // Detectar tipo de instalación
+  const { existsSync } = await import("node:fs");
+  const isGitRepo = existsSync(".git") && existsSync("package.json");
+
+  if (isGitRepo) {
+    await updateFromGitRepo();
+  } else {
+    await updateFromGlobalPackage();
+  }
+}
+
+/**
+ * Actualiza desde el repositorio local (git pull + build)
+ */
+async function updateFromGitRepo(): Promise<void> {
+  const { execSync } = await import("child_process");
+
+  // Mostrar versión actual
+  try {
+    const currentVersion = execSync("bun packages/cli/src/index.ts --version", { encoding: "utf-8" }).trim();
+    console.log(`Versión actual: ${currentVersion}`);
+  } catch {
+    console.log("Versión actual: desconocida");
+  }
+
+  console.log("\n📥 Obteniendo cambios del repositorio...");
+
+  try {
+    // Verificar que git está disponible
+    try {
+      execSync("git --version", { encoding: "utf-8" });
+    } catch {
+      console.log("\n❌ git no está instalado. Instala git o usa: bun install -g @johpaz/hive-agents@latest");
+      return;
+    }
+
+    // Git pull
+    console.log("   Ejecutando git pull...");
+    const pullResult = execSync("git pull --rebase", { encoding: "utf-8", stdio: "pipe" });
+    if (pullResult.includes("Already up to date")) {
+      console.log("   ✅ Ya estás en la última versión");
+    } else {
+      console.log("   ✅ Cambios obtenidos");
+
+      // Instalar dependencias
+      console.log("\n📦 Instalando dependencias...");
+      execSync("bun install", { encoding: "utf-8", stdio: "inherit" });
+
+      // Build
+      console.log("\n🔨 Construyendo el proyecto...");
+      execSync("bun run build", { encoding: "utf-8", stdio: "inherit" });
+    }
+
+    // Verificar nueva versión
+    try {
+      const newVersion = execSync("bun packages/cli/src/index.ts --version", { encoding: "utf-8" }).trim();
+      console.log(`\n✅ Hive actualizado: ${newVersion}`);
+    } catch {
+      console.log("\n✅ Hive actualizado");
+    }
+
+    // Aplicar actualizaciones de BD
+    await applyDatabaseUpdates();
+
+    console.log("\n   Ejecuta 'hive doctor' para validar el entorno.\n");
+  } catch (e) {
+    console.log(`\n❌ Error durante la actualización: ${(e as Error).message}`);
+    console.log(`   Intenta manualmente: git pull && bun install && bun run build\n`);
+  }
+}
+
+/**
+ * Actualiza desde paquete global (bun install -g)
+ */
+async function updateFromGlobalPackage(): Promise<void> {
+  // Mostrar versión actual antes de actualizar
+  try {
+    const { execSync } = await import("child_process");
+    const currentVersion = execSync("hive --version", { encoding: "utf-8" }).trim();
+    console.log(`Versión actual: ${currentVersion}`);
+  } catch {
+    console.log("Versión actual: desconocida");
+  }
+
+  // Detectar gestor de paquetes disponible
+  const { execSync } = await import("child_process");
+  let packageManager: "bun" | "npm" = "npm";
+  try {
+    execSync("bun --version", { encoding: "utf-8", stdio: "pipe" });
+    packageManager = "bun";
+  } catch {
+    // bun no disponible, usar npm
+  }
+
+  const installCmd = packageManager === "bun"
+    ? ["bun", "install", "-g", `${MAIN_PACKAGE}@latest`]
+    : ["npm", "install", "-g", `${MAIN_PACKAGE}@latest`];
+
+  console.log(`\nDescargando ${MAIN_PACKAGE}@latest (via ${packageManager})...`);
+
+  try {
+    const proc = Bun.spawn(installCmd, {
+      stdout: "inherit",
+      stderr: "inherit",
+    });
+    const exitCode = await proc.exited;
+
+    if (exitCode !== 0) {
+      console.log(`\n⚠️  Error durante la actualización (exit code ${exitCode})`);
+      console.log(`   Intenta manualmente: ${installCmd.join(" ")}\n`);
+      return;
+    }
+
+    console.log(`\n✅ Hive actualizado correctamente.`);
+
+    // ──────────────────────────────────────────────
+    // Re-seed de la base de datos existente
+    // ──────────────────────────────────────────────
+    await applyDatabaseUpdates();
+
+    console.log(`\n   Ejecuta 'hive --version' para verificar la nueva versión.`);
+    console.log(`   Ejecuta 'hive doctor' para validar el entorno.\n`);
+  } catch (e) {
+    console.log(`\n⚠️  No se pudo actualizar: ${(e as Error).message}`);
+    console.log(`   Intenta manualmente: bun install -g ${MAIN_PACKAGE}@latest\n`);
+  }
+}
+
+/**
+ * Aplica actualizaciones de schema y seed a la BD existente.
+ * Se ejecuta después de una actualización del paquete.
+ */
+async function applyDatabaseUpdates(): Promise<void> {
+  const { existsSync } = await import("node:fs");
+  const { getHiveDir } = await import("@johpaz/hive-agents-core/config/loader");
+  const path = await import("node:path");
+
+  const dbPath = path.join(getHiveDir(), "data", "hive.db");
+
+  if (!existsSync(dbPath)) {
+    console.log(`   ℹ️  No se encontró base de datos existente. Se creará en el próximo 'hive start'.`);
+    return;
+  }
+
+  console.log(`\n🔄 Verificando base de datos...`);
+
+  try {
+    const { initializeDatabase, getDb } = await import("@johpaz/hive-agents-core/storage/sqlite");
+
+    // 1. Inicializar BD y aplicar sync de schema (ensureSchemaSync se ejecuta internamente)
+    initializeDatabase();
+    console.log(`   ✅ Schema verificado`);
+
+    const db = getDb();
+
+    // 2. Contar datos actuales antes del re-seed
+    const toolsBefore = (db.query("SELECT COUNT(*) as n FROM tools").get() as { n: number })?.n ?? 0;
+    const modelsBefore = (db.query("SELECT COUNT(*) as n FROM models").get() as { n: number })?.n ?? 0;
+    const providersBefore = (db.query("SELECT COUNT(*) as n FROM providers").get() as { n: number })?.n ?? 0;
+    const skillsBefore = (db.query("SELECT COUNT(*) as n FROM skills").get() as { n: number })?.n ?? 0;
+
+    // 3. Ejecutar re-seed (idempotente: INSERT OR IGNORE / INSERT OR REPLACE)
+    const { seedAllData } = await import("@johpaz/hive-agents-core/storage/seed");
+    seedAllData();
+
+    // 4. Contar datos después del re-seed
+    const toolsAfter = (db.query("SELECT COUNT(*) as n FROM tools").get() as { n: number })?.n ?? 0;
+    const modelsAfter = (db.query("SELECT COUNT(*) as n FROM models").get() as { n: number })?.n ?? 0;
+    const providersAfter = (db.query("SELECT COUNT(*) as n FROM providers").get() as { n: number })?.n ?? 0;
+    const skillsAfter = (db.query("SELECT COUNT(*) as n FROM skills").get() as { n: number })?.n ?? 0;
+
+    // 5. Reportar cambios
+    const newTools = toolsAfter - toolsBefore;
+    const newModels = modelsAfter - modelsBefore;
+    const newProviders = providersAfter - providersBefore;
+    const newSkills = skillsAfter - skillsBefore;
+
+    if (newTools > 0) console.log(`   📦 +${newTools} nuevas tools`);
+    if (newModels > 0) console.log(`   📦 +${newModels} nuevos modelos`);
+    if (newProviders > 0) console.log(`   📦 +${newProviders} nuevos providers`);
+    if (newSkills > 0) console.log(`   📦 +${newSkills} nuevas skills actualizadas`);
+
+    if (newTools === 0 && newModels === 0 && newProviders === 0 && newSkills === 0) {
+      console.log(`   ✅ Datos actualizados, sin cambios nuevos`);
+    }
+
+    // 6. Verificar si el gateway está corriendo para sugerir reload
+    const hiveDir = getHiveDir();
+    const pidFile = path.join(hiveDir, "gateway.pid");
+    if (existsSync(pidFile)) {
+      console.log(`\n   💡 El gateway está corriendo. Ejecuta 'hive reload' para aplicar cambios.`);
+    }
+  } catch (err) {
+    console.log(`   ⚠️  No se pudo verificar la base de datos: ${(err as Error).message}`);
+    console.log(`   💡 Ejecuta 'hive start' para inicializar la base de datos.`);
+  }
+}

package/packages/cli/src/index.ts

@@ -0,0 +1,210 @@
+#!/usr/bin/env bun
+import { onboard } from "./commands/onboard";
+import { start, stop, status, reload } from "./commands/gateway";
+import { dev } from "./commands/dev";
+import { agents } from "./commands/agents";
+import { mcp } from "./commands/mcp";
+import { skills } from "./commands/skills";
+import { config } from "./commands/config";
+import { logs } from "./commands/logs";
+import { chat } from "./commands/chat";
+import { sessions } from "./commands/sessions";
+import { cron } from "./commands/cron";
+import { doctor } from "./commands/doctor";
+import { securityAudit } from "./commands/security";
+import { installService } from "./commands/service";
+import { update } from "./commands/update";
+import { message } from "./commands/message";
+import { agent } from "./commands/agent-run";
+import { migrate } from "./commands/migrate";
+import pkg from "../../../package.json";
+
+const VERSION = pkg.version;
+
+const HELP = `
+🐝 Hive — Personal Swarm AI Gateway v${VERSION}
+
+Usage: hive <command> [subcommand] [options]
+
+Gateway:
+  start [--daemon]           Arrancar el Gateway (abre setup web si es primera vez)
+  dev                        Modo desarrollo con hot-reload (usa ~/.hive-dev)
+  stop                       Detener el Gateway
+  reload                     Recargar config sin reiniciar
+  status                     Estado del Gateway y agentes
+  onboard                    Asistente de configuración inicial paso a paso
+
+Chat y mensajes:
+  chat [--agent <id>]        Chat directo en terminal
+  logs [--follow] [--level]  Ver logs del Gateway en tiempo real
+  message send --to <id> --content <text>
+                             Enviar mensaje por canal
+  agent run --message <text> [--wait]
+                             Ejecutar agente con mensaje
+
+Agentes:
+  agents list [--bindings]   Listar agentes activos e hibernados
+  agents create              Crear agente con asistente interactivo
+  agents add <id>            Crear agente (forma rápida)
+  agents remove <id>         Eliminar agente
+  agents logs <agent-id>     Ver logs de un agente específico
+  agents hibernate <id>      Poner agente en sleep (conserva contexto)
+  agents wake <id>           Despertar agente hibernado
+  agents terminate <id>      Terminar agente permanentemente
+  agents tree                Mostrar árbol jerárquico de agentes
+
+MCP:
+  mcp list                   Listar servidores MCP conectados
+  mcp add                    Añadir servidor MCP (asistente interactivo)
+  mcp test <nombre>          Verificar conectividad de un servidor MCP
+  mcp tools <nombre>         Listar tools disponibles en un servidor
+  mcp remove <nombre>        Eliminar servidor MCP
+
+Skills:
+  skills list                Listar skills instaladas
+  skills search <query>      Buscar skills en el catálogo
+  skills install <slug>      Instalar skill
+  skills remove <nombre>     Eliminar skill
+  skills update              Actualizar todas las skills
+
+Configuración:
+  config get <key>           Leer valor de config
+  config set <key> <value>   Escribir valor de config
+  config show                Mostrar config completa
+
+Sesiones y cron:
+  sessions list              Listar sesiones de conversación
+  sessions view <id>         Ver transcripción de una sesión
+  sessions prune             Eliminar sesiones inactivas
+  cron list                  Listar tareas programadas
+  cron add                   Añadir tarea programada
+  cron remove <id>           Eliminar tarea programada
+  cron logs                  Ver logs de ejecuciones cron
+
+Sistema:
+  doctor                     Diagnóstico completo y auto-reparación
+  update                     Actualizar Hive a la última versión
+  migrate                    Migrar schema y datos de la BD existente
+  security audit             Auditoría de seguridad del entorno
+  install-service            Instalar servicio systemd (Linux)
+
+Options:
+  --help, -h                 Mostrar esta ayuda
+  --version, -v              Mostrar versión
+
+Examples:
+  hive start                 Arrancar Hive (el browser se abre automáticamente)
+  hive onboard               Configurar Hive por primera vez
+  hive chat                  Chatear con el agente en terminal
+  hive message send --to 123 --content "Hola"
+  hive agent run --message "Analiza README.md" --wait
+  hive agents create         Crear nuevo agente con asistente
+  hive mcp add               Añadir servidor MCP
+  hive doctor                Diagnosticar problemas del sistema
+  hive update                Actualizar a la última versión
+`;
+
+async function main(): Promise<void> {
+  // In compiled Bun binaries, process.argv is [binaryPath, arg0, arg1, ...]
+  // In dev mode (bun run script.ts), it is [bun, scriptPath, arg0, arg1, ...]
+  // We detect dev mode by checking if argv[1] ends with .ts
+  const isDev = process.argv[1]?.endsWith(".ts");
+  // Skip bun executable and script path in dev mode
+  const args = process.argv.slice(isDev ? 2 : 1);
+  // Skip script path in compiled mode (first arg is the script/binary path)
+  const normalizedArgs = args[0]?.includes("\\") || args[0]?.includes("/") ? args.slice(1) : args;
+  const command = normalizedArgs[0];
+  const subcommand = normalizedArgs[1];
+  const flags = normalizedArgs.filter((a) => a.startsWith("--"));
+
+  switch (command) {
+    case "onboard":
+      await onboard();
+      break;
+    case "dev":
+      await dev();
+      break;
+    case "start":
+      await start(flags);
+      break;
+    case "stop":
+      await stop();
+      break;
+    case "reload":
+      await reload();
+      break;
+    case "status":
+      await status(flags);
+      break;
+    case "chat":
+      await chat(flags);
+      break;
+    case "logs":
+      await logs(flags);
+      break;
+    case "message":
+      await message(subcommand, args.slice(2));
+      break;
+    case "agent":
+      await agent(subcommand, args.slice(2));
+      break;
+    case "agents":
+      await agents(subcommand, args.slice(2));
+      break;
+    case "mcp":
+      await mcp(subcommand, args.slice(2));
+      break;
+    case "skills":
+      await skills(subcommand, args.slice(2));
+      break;
+    case "config":
+      await config(subcommand, args.slice(2));
+      break;
+    case "sessions":
+      await sessions(subcommand, args.slice(2));
+      break;
+    case "cron":
+      await cron(subcommand, args.slice(2));
+      break;
+    case "doctor":
+      await doctor();
+      break;
+    case "security":
+      if (subcommand === "audit") {
+        await securityAudit();
+      } else {
+        console.log("Usage: hive security audit");
+      }
+      break;
+    case "install-service":
+      await installService();
+      break;
+    case "update":
+      await update();
+      break;
+    case "migrate":
+      await migrate();
+      break;
+    case "--version":
+    case "-v":
+    case "version":
+      console.log(`Hive v${VERSION}`);
+      process.exit(0);
+      break;
+    case "--help":
+    case "-h":
+    case "help":
+    case undefined:
+      console.log(HELP);
+      break;
+    default:
+      console.error(`❌ Comando desconocido: "${command}"\n`);
+      console.log(HELP);
+      process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error("Fatal error:", error.message);
+  process.exit(1);
+});

package/packages/cli/src/ui-bundle.generated.ts

@@ -0,0 +1,3 @@
+// Auto-generated by scripts/generate-ui-bundle.ts before binary compilation.
+// This stub is published with the npm package (embeddedUI.size === 0 → uses filesystem).
+export const embeddedUI = new Map<string, { data: Buffer; mime: string }>();

package/packages/cli/src/utils/token.ts

@@ -0,0 +1,6 @@
+import { randomBytes } from "node:crypto"
+
+export function generateAuthToken(): string {
+    // 32 bytes → 43 caracteres base64url seguros
+    return randomBytes(32).toString("base64url")
+}