@johpaz/hive-cli 1.0.2 → 1.0.4

package/src/commands/doctor.ts

@@ -0,0 +1,153 @@
+import * as p from "@clack/prompts";
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+import { execSync } from "child_process";
+
+const HIVE_DIR = path.join(process.env.HOME || "", ".hive");
+const CONFIG_PATH = path.join(HIVE_DIR, "hive.yaml");
+const WORKSPACE = path.join(HIVE_DIR, "workspace");
+const PID_FILE = path.join(HIVE_DIR, "hive.pid");
+
+function checkFile(path: string, name: string): { ok: boolean; message: string } {
+  if (fs.existsSync(path)) {
+    const stat = fs.statSync(path);
+    const mode = (stat.mode & 0o777).toString(8);
+    return { ok: true, message: `${name} existe (permisos: ${mode})` };
+  }
+  return { ok: false, message: `${name} no existe` };
+}
+
+function checkBun(): { ok: boolean; version: string } {
+  try {
+    const version = execSync("bun --version", { encoding: "utf-8" }).trim();
+    return { ok: true, version };
+  } catch {
+    return { ok: false, version: "no instalado" };
+  }
+}
+
+function checkNode(): { ok: boolean; version: string } {
+  try {
+    const version = execSync("node --version", { encoding: "utf-8" }).trim();
+    return { ok: true, version };
+  } catch {
+    return { ok: false, version: "no instalado" };
+  }
+}
+
+function isGatewayRunning(): boolean {
+  if (!fs.existsSync(PID_FILE)) return false;
+  const pid = parseInt(fs.readFileSync(PID_FILE, "utf-8").trim(), 10);
+  if (isNaN(pid)) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function doctor(): Promise<void> {
+  console.log("\n🐝 Hive Doctor — Diagnóstico del sistema\n");
+
+  const checks: Array<{ category: string; name: string; status: "ok" | "warn" | "error"; message: string; hint?: string }> = [];
+
+  // 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)` });
+
+  // Configuración
+  const configCheck = checkFile(CONFIG_PATH, "hive.yaml");
+  if (configCheck.ok) {
+    checks.push({ category: "Configuración", name: "hive.yaml", status: "ok", message: "existe" });
+
+    // Verificar permisos
+    const stat = fs.statSync(CONFIG_PATH);
+    const mode = stat.mode & 0o777;
+    if (mode === 0o600) {
+      checks.push({ category: "Configuración", name: "Permisos", status: "ok", message: "600 (seguro)" });
+    } else {
+      checks.push({ category: "Configuración", name: "Permisos", status: "warn", message: `${(mode).toString(8)} — ejecuta: chmod 600 ${CONFIG_PATH}` });
+    }
+
+    // Verificar LLM config
+    try {
+      const content = fs.readFileSync(CONFIG_PATH, "utf-8");
+      const config = yaml.load(content) as Record<string, unknown>;
+      const models = config.models as Record<string, unknown> | undefined;
+      const provider = models?.defaultProvider as string | undefined;
+      
+      if (provider) {
+        checks.push({ category: "Configuración", name: "Proveedor LLM", status: "ok", message: provider });
+        
+        const providers = models?.providers as Record<string, Record<string, unknown>> | undefined;
+        const providerConfig = providers?.[provider] as Record<string, unknown> | undefined;
+        const apiKey = providerConfig?.apiKey as string | undefined;
+        
+        if (apiKey && apiKey.length > 0) {
+          checks.push({ category: "Configuración", name: "API Key", status: "ok", message: "presente" });
+        } else {
+          checks.push({ category: "Configuración", name: "API Key", status: "warn", message: "no configurada" });
+        }
+      } else {
+        checks.push({ category: "Configuración", name: "Proveedor LLM", status: "error", message: "no configurado" });
+      }
+    } catch (e) {
+      checks.push({ category: "Configuración", name: "hive.yaml", status: "error", message: `error parseando: ${(e as Error).message}` });
+    }
+  } else {
+    checks.push({ category: "Configuración", name: "hive.yaml", status: "error", message: "no existe — ejecuta: hive onboard" });
+  }
+
+  // Workspace
+  checks.push({ category: "Workspace", name: "Directorio", status: fs.existsSync(WORKSPACE) ? "ok" : "warn", message: fs.existsSync(WORKSPACE) ? "existe" : "no existe" });
+  checks.push({ category: "Workspace", name: "SOUL.md", status: fs.existsSync(path.join(WORKSPACE, "SOUL.md")) ? "ok" : "warn", message: fs.existsSync(path.join(WORKSPACE, "SOUL.md")) ? "presente" : "falta" });
+  checks.push({ category: "Workspace", name: "USER.md", status: fs.existsSync(path.join(WORKSPACE, "USER.md")) ? "ok" : "warn", message: fs.existsSync(path.join(WORKSPACE, "USER.md")) ? "presente" : "falta" });
+  checks.push({ category: "Workspace", name: "ETHICS.md", status: fs.existsSync(path.join(WORKSPACE, "ETHICS.md")) ? "ok" : "warn", message: fs.existsSync(path.join(WORKSPACE, "ETHICS.md")) ? "presente" : "falta" });
+
+  // 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 import("./onboard");
+      await onboard();
+    }
+  } else if (warns.length > 0) {
+    console.log(`⚠️  ${warns.length} advertencia(s)`);
+  } else {
+    console.log("✅ Todo en orden");
+  }
+}

package/src/commands/gateway.ts

@@ -0,0 +1,132 @@
+import { loadConfig, startGateway, logger } from "@johpaz/hive-core";
+import * as p from "@clack/prompts";
+import * as fs from "fs";
+import * as path from "path";
+import { spawn, spawnSync, ChildProcess } from "child_process";
+
+const PID_FILE = path.join(process.env.HOME || "", ".hive", "hive.pid");
+const LOG_FILE = path.join(process.env.HOME || "", ".hive", "logs", "gateway.log");
+
+function ensureLogDir(): void {
+  const logDir = path.dirname(LOG_FILE);
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+}
+
+function isRunning(): boolean {
+  if (!fs.existsSync(PID_FILE)) return false;
+  const pid = parseInt(fs.readFileSync(PID_FILE, "utf-8").trim(), 10);
+  if (isNaN(pid)) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    fs.unlinkSync(PID_FILE);
+    return false;
+  }
+}
+
+export async function start(flags: string[]): Promise<void> {
+  const daemon = flags.includes("--daemon");
+
+  if (isRunning()) {
+    console.log("⚠️  Hive Gateway ya está corriendo");
+    return;
+  }
+
+  const config = loadConfig();
+
+  if (config.logging?.level) {
+    logger.setLevel(config.logging.level);
+  }
+
+  console.log(`
+ ╔═══════════════════════════════════════════╗
+ ║                                            ║
+ ║   ██╗  ██╗██╗██╗   ██╗███████╗             ║
+ ║   ██║  ██║██║██║   ██║██╔════╝             ║
+ ║   ███████║██║██║   ██║█████╗               ║
+ ║   ██╔══██║██║╚██╗ ██╔╝██╔══╝               ║
+ ║   ██║  ██║██║ ╚████╔╝ ███████╗             ║
+ ║   ╚═╝  ╚═╝╚═╝  ╚═══╝  ╚══════╝             ║
+ ║                                            ║
+ ║   Personal AI Gateway — v1.0.4             ║
+ ╚════════════════════════════════════════════╝
+`);
+
+  if (daemon) {
+    ensureLogDir();
+    const child = spawn(process.execPath, [process.argv[1] || "", "start"], {
+      detached: true,
+      stdio: ["ignore", fs.openSync(LOG_FILE, "a"), fs.openSync(LOG_FILE, "a")],
+    });
+    child.unref();
+    fs.writeFileSync(PID_FILE, child.pid?.toString() || "");
+    console.log(`✅ Hive Gateway iniciado en modo daemon (PID: ${child.pid})`);
+    console.log(`   Logs: ${LOG_FILE}`);
+    return;
+  }
+
+  await startGateway(config);
+}
+
+export async function stop(): Promise<void> {
+  if (!isRunning()) {
+    console.log("⚠️  Hive Gateway no está corriendo");
+    return;
+  }
+
+  const pid = parseInt(fs.readFileSync(PID_FILE, "utf-8").trim(), 10);
+  try {
+    process.kill(pid, "SIGTERM");
+    fs.unlinkSync(PID_FILE);
+    console.log("✅ Hive Gateway detenido");
+  } catch (e) {
+    console.error("❌ Error deteniendo el Gateway:", e);
+  }
+}
+
+export async function status(flags: string[]): Promise<void> {
+  const running = isRunning();
+  const configPath = path.join(process.env.HOME || "", ".hive", "hive.yaml");
+
+  console.log("🐝 Hive Gateway Status\n");
+
+  if (!fs.existsSync(configPath)) {
+    console.log("❌ No hay configuración. Ejecuta: hive onboard");
+    return;
+  }
+
+  const config = loadConfig();
+
+  console.log(`Estado:      ${running ? "✅ Corriendo" : "⏹️  Detenido"}`);
+  if (running) {
+    const pid = fs.readFileSync(PID_FILE, "utf-8").trim();
+    console.log(`PID:         ${pid}`);
+  }
+  console.log(`Puerto:      ${config.gateway?.port || 18790}`);
+  console.log(`Host:        ${config.gateway?.host || "127.0.0.1"}`);
+  console.log(`Modelo:      ${config.models?.defaultProvider || "no configurado"} / ${(config.models?.defaults as Record<string, string>)?.default || "no configurado"}`);
+  console.log(`Config:      ${configPath}`);
+  console.log(`Logs:        ${LOG_FILE}`);
+
+  if (flags.includes("--json")) {
+    console.log("\n" + JSON.stringify({ running, pid: running ? fs.readFileSync(PID_FILE, "utf-8").trim() : null, config }, null, 2));
+  }
+}
+
+export async function reload(): Promise<void> {
+  if (!isRunning()) {
+    console.log("⚠️  Hive Gateway no está corriendo");
+    return;
+  }
+
+  const pid = parseInt(fs.readFileSync(PID_FILE, "utf-8").trim(), 10);
+  try {
+    process.kill(pid, "SIGHUP");
+    console.log("✅ Configuración recargada");
+  } catch (e) {
+    console.error("❌ Error recargando configuración:", e);
+  }
+}

package/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/src/commands/mcp.ts

@@ -0,0 +1,215 @@
+import * as p from "@clack/prompts";
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+import { spawn } from "child_process";
+
+const CONFIG_PATH = path.join(process.env.HOME || "", ".hive", "hive.yaml");
+
+interface MCPServerConfig {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+  disabled?: boolean;
+}
+
+function loadConfig(): Record<string, unknown> | null {
+  if (!fs.existsSync(CONFIG_PATH)) return null;
+  const content = fs.readFileSync(CONFIG_PATH, "utf-8");
+  return yaml.load(content) as Record<string, unknown>;
+}
+
+function saveConfig(config: Record<string, unknown>): void {
+  fs.writeFileSync(CONFIG_PATH, yaml.dump(config, { lineWidth: -1 }), "utf-8");
+}
+
+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();
+  if (!config) {
+    console.log("❌ No hay configuración. Ejecuta: hive onboard");
+    return;
+  }
+
+  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();
+  if (!config) {
+    console.log("❌ No hay configuración. Ejecuta: hive onboard");
+    return;
+  }
+
+  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,
+  };
+
+  if (!config.mcp) config.mcp = {};
+  (config.mcp as Record<string, MCPServerConfig>)[name as string] = serverConfig;
+  saveConfig(config);
+
+  console.log(`✅ Servidor MCP "${name}" añadido`);
+}
+
+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();
+  if (!config) {
+    console.log("❌ No hay configuración.");
+    return;
+  }
+
+  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();
+  if (!config) {
+    console.log("❌ No hay configuración.");
+    return;
+  }
+
+  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;
+  }
+
+  delete mcpServers[name];
+  saveConfig(config);
+
+  console.log(`✅ Servidor MCP "${name}" eliminado`);
+}