@johpaz/hive-cli 1.0.2 → 1.0.4

package/src/commands/security.ts

@@ -0,0 +1,189 @@
+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");
+
+interface CheckResult {
+  category: string;
+  name: string;
+  status: "ok" | "warn" | "error";
+  message: string;
+}
+
+function check(name: string, pass: boolean, okMsg: string, failMsg: string): CheckResult {
+  return {
+    category: "",
+    name,
+    status: pass ? "ok" : "error",
+    message: pass ? okMsg : failMsg,
+  };
+}
+
+export async function securityAudit(): Promise<void> {
+  console.log("\n🔒 Hive Security Audit\n");
+
+  const results: CheckResult[] = [];
+
+  // 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)" });
+
+  if (fs.existsSync(CONFIG_PATH)) {
+    try {
+      const content = fs.readFileSync(CONFIG_PATH, "utf-8");
+      const config = yaml.load(content) as Record<string, unknown>;
+      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",
+      });
+    } catch {
+      results.push({ category: "Red", name: "Token bearer", status: "error", message: "error leyendo config" });
+    }
+  }
+
+  // Archivos
+  if (fs.existsSync(CONFIG_PATH)) {
+    const stat = fs.statSync(CONFIG_PATH);
+    const mode = stat.mode & 0o777;
+    results.push({
+      category: "Archivos",
+      name: "hive.yaml permisos",
+      status: mode === 0o600 ? "ok" : "warn",
+      message: mode === 0o600 ? "600 (seguro)" : `${(mode).toString(8)} — ejecuta: chmod 600 ${CONFIG_PATH}`,
+    });
+  }
+
+  const authProfiles = path.join(HIVE_DIR, "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(HIVE_DIR, ".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
+  if (fs.existsSync(CONFIG_PATH)) {
+    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 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",
+      });
+    } catch {
+      results.push({ category: "Configuración", name: "API keys", status: "warn", message: "no se pudo verificar" });
+    }
+  }
+
+  // Workspace
+  results.push({
+    category: "Workspace",
+    name: "Permisos workspace",
+    status: fs.existsSync(WORKSPACE) ? "ok" : "warn",
+    message: fs.existsSync(WORKSPACE) ? "existe" : "no existe",
+  });
+
+  // MCP
+  if (fs.existsSync(CONFIG_PATH)) {
+    try {
+      const content = fs.readFileSync(CONFIG_PATH, "utf-8");
+      const config = yaml.load(content) as Record<string, unknown>;
+      const mcp = config.mcp as Record<string, unknown> | undefined;
+      const servers = mcp?.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" });
+      }
+    } catch {
+      results.push({ category: "MCP", name: "Servidores", status: "warn", message: "error verificando" });
+    }
+  }
+
+  // Skills
+  const skillsDir = path.join(HIVE_DIR, "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/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/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/src/commands/skills.ts

@@ -0,0 +1,187 @@
+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> {
+  if (!fs.existsSync(SKILLS_DIR)) {
+    console.log("No hay skills instaladas para actualizar");
+    return;
+  }
+
+  const spinner = p.spinner();
+  spinner.start("Actualizando skills...");
+
+  await new Promise((resolve) => setTimeout(resolve, 1000));
+
+  spinner.stop("Skills actualizadas ✅");
+}

package/src/commands/update.ts

@@ -0,0 +1,25 @@
+import { execSync } from "child_process";
+
+const PACKAGES = [
+  "@johpaz/hive-cli",
+  "@johpaz/hive-core",
+  "@johpaz/hive-sdk",
+  "@johpaz/hive-mcp",
+  "@johpaz/hive-skills",
+];
+
+export async function update(): Promise<void> {
+  console.log("🔄 Actualizando Hive...\n");
+
+  for (const pkg of PACKAGES) {
+    console.log(`Actualizando ${pkg}...`);
+    try {
+      execSync(`npm install -g ${pkg}@latest`, { stdio: "inherit" });
+      console.log(`✅ ${pkg} actualizado\n`);
+    } catch (e) {
+      console.log(`⚠️  Error actualizando ${pkg}: ${(e as Error).message}\n`);
+    }
+  }
+
+  console.log("✅ Hive actualizado. Ejecuta 'hive --version' para verificar.");
+}