@johpaz/hive-agents 0.0.34 → 0.0.36

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-agents-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)`);
+}

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

@@ -0,0 +1,77 @@
+import { loadConfig } from "@johpaz/hive-agents-core/config/loader";
+
+interface MessageResult {
+  success: boolean;
+  messageId?: string;
+  error?: string;
+}
+
+function getGatewayUrl(config: any): string {
+  const gateway = config?.gateway;
+  const host = gateway?.host ?? "localhost";
+  const port = gateway?.port ?? 3000;
+  return `http://${host}:${port}`;
+}
+
+export async function message(subcommand: string | undefined, args: string[]): Promise<void> {
+  switch (subcommand) {
+    case "send":
+      await messageSend(args);
+      break;
+    default:
+      console.log(`
+Usage: hive message <command>
+
+Commands:
+  send --to <id> --content <text>  Enviar mensaje
+`);
+  }
+}
+
+async function messageSend(args: string[]): Promise<void> {
+  const toIndex = args.indexOf("--to");
+  const contentIndex = args.indexOf("--content");
+  const channelIndex = args.indexOf("--channel");
+
+  if (toIndex === -1 || contentIndex === -1) {
+    console.log("❌ Faltan parámetros requeridos");
+    console.log("   hive message send --to <id> --content <texto>");
+    return;
+  }
+
+  const to = args[toIndex + 1];
+  const content = args[contentIndex + 1];
+  const channel = channelIndex !== -1 ? args[channelIndex + 1] : "default";
+
+  if (!to || !content) {
+    console.log("❌ Parámetros inválidos");
+    return;
+  }
+
+  const config = loadConfig();
+  const gatewayUrl = getGatewayUrl(config);
+
+  try {
+    const response = await fetch(`${gatewayUrl}/api/messages/send`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ to, content, channel }),
+    });
+
+    if (!response.ok) {
+      console.log(`❌ Error: ${response.statusText}`);
+      return;
+    }
+
+    const result = (await response.json()) as MessageResult;
+
+    if (result.success) {
+      console.log(`✓ Mensaje enviado: ${result.messageId}`);
+    } else {
+      console.log(`❌ Error: ${result.error}`);
+    }
+  } catch (error) {
+    console.log(`❌ No se pudo conectar al Gateway: ${(error as Error).message}`);
+    console.log("   ¿Está corriendo? Ejecuta: hive start");
+  }
+}

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

@@ -0,0 +1,90 @@
+/**
+ * Migrate Command — Fuerza la migración de schema y re-seed de datos
+ *
+ * Útil cuando:
+ * - Se actualizó el paquete pero el seed no se aplicó
+ * - Se agregaron nuevas tools/models/providers al seed
+ * - Se necesitan crear columnas nuevas en tablas existentes
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getHiveDir } from "@johpaz/hive-agents-core/config/loader";
+
+export async function migrate(): Promise<void> {
+  console.log("\n🔄 Migrando base de datos de Hive...\n");
+
+  const dbPath = path.join(getHiveDir(), "data", "hive.db");
+
+  if (!fs.existsSync(dbPath)) {
+    console.log("⚠️  No se encontró base de datos existente.");
+    console.log("   Ejecuta 'hive start' o 'hive onboard' para crear una nueva.\n");
+    return;
+  }
+
+  try {
+    const { initializeDatabase, getDb } = await import("@johpaz/hive-agents-core/storage/sqlite");
+
+    // 1. Inicializar BD y aplicar sync de schema
+    console.log("📐 Verificando schema...");
+    initializeDatabase();
+    console.log("   ✅ Schema sincronizado");
+
+    const db = getDb();
+
+    // 2. Contar datos actuales
+    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;
+    const playbookBefore = (db.query("SELECT COUNT(*) as n FROM playbook").get() as { n: number })?.n ?? 0;
+
+    // 3. Ejecutar re-seed (idempotente)
+    console.log("\n🌱 Aplicando seed de datos...");
+    const { seedAllData } = await import("@johpaz/hive-agents-core/storage/seed");
+    seedAllData();
+
+    // 4. Contar datos después
+    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;
+    const playbookAfter = (db.query("SELECT COUNT(*) as n FROM playbook").get() as { n: number })?.n ?? 0;
+
+    // 5. Reportar cambios
+    console.log("\n📊 Resumen de cambios:");
+
+    const changes: Array<{ name: string; before: number; after: number }> = [
+      { name: "Tools", before: toolsBefore, after: toolsAfter },
+      { name: "Models", before: modelsBefore, after: modelsAfter },
+      { name: "Providers", before: providersBefore, after: providersAfter },
+      { name: "Skills", before: skillsBefore, after: skillsAfter },
+      { name: "Playbook Rules", before: playbookBefore, after: playbookAfter },
+    ];
+
+    let hadChanges = false;
+    for (const c of changes) {
+      const diff = c.after - c.before;
+      if (diff > 0) {
+        console.log(`   ✅ +${diff} ${c.name.toLowerCase()}`);
+        hadChanges = true;
+      }
+    }
+
+    if (!hadChanges) {
+      console.log("   ✅ Todo actualizado, sin cambios nuevos");
+    }
+
+    // 6. Sugerir reload si gateway está corriendo
+    const pidFile = path.join(getHiveDir(), "gateway.pid");
+    if (fs.existsSync(pidFile)) {
+      console.log("\n   💡 El gateway está corriendo. Ejecuta 'hive reload' para aplicar cambios.");
+    }
+
+    console.log("\n✅ Migración completada.\n");
+  } catch (err) {
+    console.error(`\n❌ Error durante la migración: ${(err as Error).message}`);
+    console.error("   💡 Ejecuta 'hive doctor' para más diagnóstico.\n");
+    process.exit(1);
+  }
+}