@johpaz/hive-agents 0.0.35 → 0.0.37

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

@@ -0,0 +1,144 @@
+import * as fs from "fs";
+import * as path from "path";
+import { loadConfig, getHiveDir } from "@johpaz/hive-agents-core/config/loader";
+
+const getHiveDirConst = () => getHiveDir();
+const getWorkspace = () => path.join(getHiveDirConst(), "workspace");
+
+interface CheckResult {
+  category: string;
+  name: string;
+  status: "ok" | "warn" | "error";
+  message: string;
+}
+
+export async function securityAudit(): Promise<void> {
+  console.log("\n🔒 Hive Security Audit\n");
+
+  const results: CheckResult[] = [];
+  const config = loadConfig();
+
+  // Red
+  results.push({ category: "Red", name: "Gateway bind", status: "ok", message: "127.0.0.1 (loopback)" });
+  results.push({ category: "Red", name: "Puerto", status: "ok", message: "18790 (no expuesto externamente)" });
+
+  const gateway = config.gateway as Record<string, unknown> | undefined;
+  const token = gateway?.authToken as string | undefined;
+
+  results.push({
+    category: "Red",
+    name: "Token bearer",
+    status: token && token.length > 0 ? "ok" : "warn",
+    message: token && token.length > 0 ? "configurado" : "no configurado",
+  });
+
+  // Archivos
+  const authProfiles = path.join(getHiveDirConst(), "auth-profiles.json");
+  if (fs.existsSync(authProfiles)) {
+    const stat = fs.statSync(authProfiles);
+    const mode = stat.mode & 0o777;
+    results.push({
+      category: "Archivos",
+      name: "auth-profiles.json permisos",
+      status: mode === 0o600 ? "ok" : "warn",
+      message: mode === 0o600 ? "600 (seguro)" : `${(mode).toString(8)} — ejecuta: chmod 600 ${authProfiles}`,
+    });
+  }
+
+  const envFile = path.join(getHiveDirConst(), ".env");
+  if (fs.existsSync(envFile)) {
+    const stat = fs.statSync(envFile);
+    const mode = stat.mode & 0o777;
+    results.push({
+      category: "Archivos",
+      name: ".env permisos",
+      status: mode === 0o600 ? "ok" : "warn",
+      message: mode === 0o600 ? "600 (seguro)" : `${(mode).toString(8)} — ejecuta: chmod 600 ${envFile}`,
+    });
+  }
+
+  // Configuración
+  const models = config.models as Record<string, unknown> | undefined;
+  const providers = models?.providers as Record<string, Record<string, unknown>> | undefined;
+
+  let hasHardcodedKey = false;
+  if (providers) {
+    for (const [, p] of Object.entries(providers)) {
+      const apiKey = p.apiKey as string | undefined;
+      if (apiKey && !apiKey.startsWith("${") && !apiKey.startsWith("process.env")) {
+        hasHardcodedKey = true;
+      }
+    }
+  }
+
+  results.push({
+    category: "Configuración",
+    name: "API keys",
+    status: !hasHardcodedKey ? "ok" : "warn",
+    message: !hasHardcodedKey ? "en variables de entorno" : "hardcodeadas en config — considera usar env vars",
+  });
+
+  // Workspace
+  results.push({
+    category: "Workspace",
+    name: "Permisos workspace",
+    status: fs.existsSync(getWorkspace()) ? "ok" : "warn",
+    message: fs.existsSync(getWorkspace()) ? "existe" : "no existe",
+  });
+
+  // MCP
+  const mcp = config.mcp as Record<string, unknown> | undefined;
+  const servers = (mcp as any)?.servers as Record<string, Record<string, unknown>> | undefined;
+
+  if (servers && Object.keys(servers).length > 0) {
+    results.push({ category: "MCP", name: "Servidores", status: "ok", message: `${Object.keys(servers).length} configurado(s)` });
+
+    for (const [name, server] of Object.entries(servers)) {
+      const cmd = server.command as string | undefined;
+      const isKnown = cmd?.includes("@modelcontextprotocol") || cmd?.includes("mcp-server");
+      results.push({
+        category: "MCP",
+        name: `Servidor '${name}'`,
+        status: isKnown ? "ok" : "warn",
+        message: isKnown ? "fuente conocida" : "verificar comando manualmente",
+      });
+    }
+  } else {
+    results.push({ category: "MCP", name: "Servidores", status: "ok", message: "ninguno configurado" });
+  }
+
+  // Skills
+  const skillsDir = path.join(getHiveDirConst(), "skills");
+  if (fs.existsSync(skillsDir)) {
+    const managedSkills = fs.readdirSync(skillsDir).filter((f) => {
+      return fs.statSync(path.join(skillsDir, f)).isDirectory();
+    });
+    results.push({
+      category: "Skills",
+      name: "Skills de terceros",
+      status: managedSkills.length === 0 ? "ok" : "warn",
+      message: managedSkills.length === 0 ? "ninguna instalada" : `${managedSkills.length} instalada(s) — verificar manualmente`,
+    });
+  } else {
+    results.push({ category: "Skills", name: "Skills de terceros", status: "ok", message: "ninguna instalada" });
+  }
+
+  // Mostrar resultados
+  const categories = [...new Set(results.map((r) => r.category))];
+
+  for (const category of categories) {
+    console.log(`${category}`);
+    const catResults = results.filter((r) => r.category === category);
+    for (const result of catResults) {
+      const icon = result.status === "ok" ? "✅" : result.status === "warn" ? "⚠️ " : "❌";
+      console.log(`  ${icon} ${result.name}: ${result.message}`);
+    }
+    console.log();
+  }
+
+  // Resumen
+  const errors = results.filter((r) => r.status === "error");
+  const warns = results.filter((r) => r.status === "warn");
+
+  console.log(`📊 Resumen: ${results.length} checks, ${errors.length} errores, ${warns.length} advertencias`);
+}

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

@@ -0,0 +1,50 @@
+import * as fs from "fs";
+import * as path from "path";
+import { execSync } from "child_process";
+
+const HOME = process.env.HOME || "";
+const SYSTEMD_DIR = path.join(HOME, ".config", "systemd", "user");
+
+export async function installService(): Promise<void> {
+  console.log("🔧 Instalando servicio systemd para Hive...\n");
+
+  if (!fs.existsSync(SYSTEMD_DIR)) {
+    fs.mkdirSync(SYSTEMD_DIR, { recursive: true });
+  }
+
+  const serviceContent = `[Unit]
+Description=Hive Personal AI Gateway
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${HOME}/.bun/bin/hive start
+ExecStop=${HOME}/.bun/bin/hive stop
+Restart=on-failure
+RestartSec=5
+Environment=PATH=${HOME}/.bun/bin:${HOME}/.npm-global/bin:/usr/local/bin:/usr/bin:/bin
+WorkingDirectory=${HOME}
+
+[Install]
+WantedBy=default.target
+`;
+
+  const servicePath = path.join(SYSTEMD_DIR, "hive.service");
+
+  fs.writeFileSync(servicePath, serviceContent, "utf-8");
+  console.log(`✅ Archivo de servicio creado: ${servicePath}\n`);
+
+  console.log("Recargando systemd...");
+  execSync("systemctl --user daemon-reload", { stdio: "inherit" });
+
+  console.log("Habilitando servicio...");
+  execSync("systemctl --user enable hive", { stdio: "inherit" });
+
+  console.log("\n✅ Servicio instalado correctamente.\n");
+  console.log("Comandos disponibles:");
+  console.log("  systemctl --user start hive    # Iniciar");
+  console.log("  systemctl --user stop hive     # Detener");
+  console.log("  systemctl --user status hive   # Ver estado");
+  console.log("  journalctl --user -u hive -f   # Ver logs");
+}

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

@@ -0,0 +1,116 @@
+import * as fs from "fs";
+import * as path from "path";
+
+const HIVE_DIR = path.join(process.env.HOME || "", ".hive");
+const SESSIONS_DIR = path.join(HIVE_DIR, "sessions");
+
+export async function sessions(subcommand: string | undefined, args: string[]): Promise<void> {
+  switch (subcommand) {
+    case "list":
+      await listSessions();
+      break;
+    case "view":
+      await viewSession(args[0]);
+      break;
+    case "prune":
+      await pruneSessions();
+      break;
+    default:
+      console.log(`
+Usage: hive sessions <command>
+
+Commands:
+  list        Listar sesiones
+  view <id>   Ver transcripción
+  prune       Eliminar sesiones inactivas
+`);
+  }
+}
+
+async function listSessions(): Promise<void> {
+  if (!fs.existsSync(SESSIONS_DIR)) {
+    console.log("No hay sesiones");
+    return;
+  }
+
+  const sessions = fs.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json"));
+
+  if (sessions.length === 0) {
+    console.log("No hay sesiones");
+    return;
+  }
+
+  console.log("\n📋 Sesiones:\n");
+
+  for (const session of sessions) {
+    const sessionPath = path.join(SESSIONS_DIR, session);
+    const stat = fs.statSync(sessionPath);
+    const id = session.replace(".json", "");
+    const date = stat.mtime.toLocaleDateString();
+    const time = stat.mtime.toLocaleTimeString();
+
+    let messageCount = 0;
+    try {
+      const content = JSON.parse(fs.readFileSync(sessionPath, "utf-8"));
+      messageCount = content.messages?.length || 0;
+    } catch {
+      // ignore
+    }
+
+    console.log(`  ${id}`);
+    console.log(`    Última actividad: ${date} ${time}`);
+    console.log(`    Mensajes: ${messageCount}`);
+    console.log();
+  }
+}
+
+async function viewSession(id: string | undefined): Promise<void> {
+  if (!id) {
+    console.log("❌ Especifica el ID de la sesión: hive sessions view <id>");
+    return;
+  }
+
+  const sessionPath = path.join(SESSIONS_DIR, `${id}.json`);
+
+  if (!fs.existsSync(sessionPath)) {
+    console.log(`❌ Sesión no encontrada: ${id}`);
+    return;
+  }
+
+  const content = JSON.parse(fs.readFileSync(sessionPath, "utf-8"));
+  const messages = content.messages || [];
+
+  console.log(`\n📜 Sesión: ${id}\n`);
+
+  for (const msg of messages) {
+    const role = msg.role === "user" ? "👤 Usuario" : "🤖 Agente";
+    console.log(`${role}:`);
+    console.log(`  ${msg.content}`);
+    console.log();
+  }
+}
+
+async function pruneSessions(): Promise<void> {
+  if (!fs.existsSync(SESSIONS_DIR)) {
+    console.log("No hay sesiones para limpiar");
+    return;
+  }
+
+  const sessions = fs.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json"));
+  const now = Date.now();
+  const maxAge = 7 * 24 * 60 * 60 * 1000; // 7 días
+
+  let pruned = 0;
+
+  for (const session of sessions) {
+    const sessionPath = path.join(SESSIONS_DIR, session);
+    const stat = fs.statSync(sessionPath);
+
+    if (now - stat.mtimeMs > maxAge) {
+      fs.unlinkSync(sessionPath);
+      pruned++;
+    }
+  }
+
+  console.log(`✅ Sesiones eliminadas: ${pruned}`);
+}

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

@@ -0,0 +1,215 @@
+import * as p from "@clack/prompts";
+import * as fs from "fs";
+import * as path from "path";
+
+const SKILLS_DIR = path.join(process.env.HOME || "", ".hive", "skills");
+const BUNDLED_SKILLS: Array<{ slug: string; name: string; description: string }> = [
+  { slug: "web-search", name: "Web Search", description: "Search the web using multiple search engines" },
+  { slug: "code-exec", name: "Code Execution", description: "Execute code snippets safely" },
+  { slug: "file-ops", name: "File Operations", description: "Read, write, and manage files" },
+  { slug: "memory", name: "Memory", description: "Persistent memory and notes" },
+  { slug: "cron", name: "Cron Jobs", description: "Schedule recurring tasks" },
+];
+
+export async function skills(subcommand: string | undefined, args: string[]): Promise<void> {
+  switch (subcommand) {
+    case "list":
+      await listSkills();
+      break;
+    case "search":
+      await searchSkills(args[0]);
+      break;
+    case "install":
+      await installSkill(args[0]);
+      break;
+    case "remove":
+      await removeSkill(args[0]);
+      break;
+    case "update":
+      await updateSkills();
+      break;
+    default:
+      console.log(`
+Usage: hive skills <command>
+
+Commands:
+  list              Listar skills instaladas
+  search <query>    Buscar skills
+  install <slug>    Instalar skill
+  remove <nombre>   Eliminar skill
+  update            Actualizar skills
+`);
+  }
+}
+
+async function listSkills(): Promise<void> {
+  console.log("\n📚 Skills instaladas:\n");
+
+  console.log("  Bundled (incluidas):");
+  for (const skill of BUNDLED_SKILLS) {
+    console.log(`    • ${skill.name} (${skill.slug})`);
+    console.log(`      ${skill.description}`);
+  }
+
+  if (fs.existsSync(SKILLS_DIR)) {
+    const managedSkills = fs.readdirSync(SKILLS_DIR).filter((f) => {
+      const skillPath = path.join(SKILLS_DIR, f);
+      return fs.statSync(skillPath).isDirectory();
+    });
+
+    if (managedSkills.length > 0) {
+      console.log("\n  Managed (instaladas):");
+      for (const slug of managedSkills) {
+        const skillPath = path.join(SKILLS_DIR, slug, "skill.json");
+        if (fs.existsSync(skillPath)) {
+          const meta = JSON.parse(fs.readFileSync(skillPath, "utf-8"));
+          console.log(`    • ${meta.name || slug}`);
+          console.log(`      ${meta.description || "Sin descripción"}`);
+        } else {
+          console.log(`    • ${slug}`);
+        }
+      }
+    }
+  }
+
+  console.log();
+}
+
+async function searchSkills(query: string | undefined): Promise<void> {
+  if (!query) {
+    console.log("❌ Especifica un término de búsqueda: hive skills search <query>");
+    return;
+  }
+
+  console.log(`\n🔍 Buscando: "${query}"\n`);
+
+  const results = BUNDLED_SKILLS.filter(
+    (s) =>
+      s.name.toLowerCase().includes(query.toLowerCase()) ||
+      s.slug.toLowerCase().includes(query.toLowerCase()) ||
+      s.description.toLowerCase().includes(query.toLowerCase())
+  );
+
+  if (results.length === 0) {
+    console.log("No se encontraron skills");
+    return;
+  }
+
+  for (const skill of results) {
+    console.log(`  ${skill.slug}`);
+    console.log(`    ${skill.name}`);
+    console.log(`    ${skill.description}`);
+    console.log(`    Tipo: bundled`);
+    console.log();
+  }
+}
+
+async function installSkill(slug: string | undefined): Promise<void> {
+  if (!slug) {
+    const result = await p.text({
+      message: "Slug de la skill a instalar:",
+      placeholder: "example-skill",
+      validate: (v) => (!v ? "El slug es requerido" : undefined),
+    });
+
+    if (p.isCancel(result)) {
+      p.cancel("Cancelado");
+      return;
+    }
+    slug = result;
+  }
+
+  console.log(`\n📦 Instalando skill: ${slug}`);
+
+  if (!fs.existsSync(SKILLS_DIR)) {
+    fs.mkdirSync(SKILLS_DIR, { recursive: true });
+  }
+
+  const skillPath = path.join(SKILLS_DIR, slug);
+  if (fs.existsSync(skillPath)) {
+    console.log("⚠️  La skill ya está instalada");
+    return;
+  }
+
+  fs.mkdirSync(skillPath, { recursive: true });
+
+  const meta = {
+    name: slug,
+    version: "1.0.0",
+    description: "Skill instalada manualmente",
+    installed: new Date().toISOString(),
+  };
+
+  fs.writeFileSync(path.join(skillPath, "skill.json"), JSON.stringify(meta, null, 2));
+
+  console.log(`✅ Skill "${slug}" instalada`);
+}
+
+async function removeSkill(slug: string | undefined): Promise<void> {
+  if (!slug) {
+    console.log("❌ Especifica la skill: hive skills remove <slug>");
+    return;
+  }
+
+  const skillPath = path.join(SKILLS_DIR, slug);
+
+  if (!fs.existsSync(skillPath)) {
+    console.log(`❌ La skill "${slug}" no está instalada`);
+    return;
+  }
+
+  const confirm = await p.confirm({
+    message: `¿Eliminar la skill "${slug}"?`,
+    initialValue: false,
+  });
+
+  if (p.isCancel(confirm) || !confirm) {
+    console.log("Cancelado");
+    return;
+  }
+
+  fs.rmSync(skillPath, { recursive: true });
+  console.log(`✅ Skill "${slug}" eliminada`);
+}
+
+async function updateSkills(): Promise<void> {
+  console.log("\n🔄 Actualizando skills...\n");
+
+  try {
+    // 1. Contar skills actuales en BD
+    const { initializeDatabase, getDb } = await import("@johpaz/hive-agents-core/storage/sqlite");
+    initializeDatabase();
+    const db = getDb();
+
+    const beforeCount = (db.query("SELECT COUNT(*) as n FROM skills").get() as { n: number })?.n ?? 0;
+    console.log(`   Skills actuales en BD: ${beforeCount}`);
+
+    // 2. Recargar skills desde SkillLoader y re-semear
+    const { seedAllData } = await import("@johpaz/hive-agents-core/storage/seed");
+    seedAllData();
+
+    // 3. Contar skills después del re-seed
+    const afterCount = (db.query("SELECT COUNT(*) as n FROM skills").get() as { n: number })?.n ?? 0;
+    const newSkills = afterCount - beforeCount;
+
+    if (newSkills > 0) {
+      console.log(`   ✅ +${newSkills} nuevas skills añadidas`);
+    } else {
+      console.log(`   ✅ Todas las skills están actualizadas`);
+    }
+
+    // 4. Verificar si el gateway está corriendo
+    const { existsSync } = await import("node:fs");
+    const { getHiveDir } = await import("@johpaz/hive-agents-core/config/loader");
+    const path = await import("node:path");
+    const pidFile = path.join(getHiveDir(), "gateway.pid");
+    if (existsSync(pidFile)) {
+      console.log(`\n   💡 El gateway está corriendo. Ejecuta 'hive reload' para aplicar cambios.`);
+    }
+
+    console.log();
+  } catch (err) {
+    console.log(`   ⚠️  No se pudieron actualizar las skills: ${(err as Error).message}`);
+    console.log(`   💡 Ejecuta 'hive start' para inicializar la base de datos primero.\n`);
+  }
+}