@johpaz/hive 1.1.3 → 1.1.5

package/packages/cli/dist/commands/security.d.ts

@@ -0,0 +1 @@
+export declare function securityAudit(): Promise<void>;

package/packages/cli/dist/commands/security.js

@@ -0,0 +1,155 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.securityAudit = securityAudit;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const loader_1 = require("@johpaz/hive-core/config/loader");
+const getHiveDirConst = () => (0, loader_1.getHiveDir)();
+const getWorkspace = () => path.join(getHiveDirConst(), "workspace");
+async function securityAudit() {
+    console.log("\n🔒 Hive Security Audit\n");
+    const results = [];
+    const config = (0, loader_1.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;
+    const token = gateway?.authToken;
+    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;
+    const providers = models?.providers;
+    let hasHardcodedKey = false;
+    if (providers) {
+        for (const [, p] of Object.entries(providers)) {
+            const apiKey = p.apiKey;
+            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;
+    const servers = mcp?.servers;
+    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;
+            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/dist/commands/service.d.ts

@@ -0,0 +1 @@
+export declare function installService(): Promise<void>;

package/packages/cli/dist/commands/service.js

@@ -0,0 +1,77 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installService = installService;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const HOME = process.env.HOME || "";
+const SYSTEMD_DIR = path.join(HOME, ".config", "systemd", "user");
+async function installService() {
+    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...");
+    (0, child_process_1.execSync)("systemctl --user daemon-reload", { stdio: "inherit" });
+    console.log("Habilitando servicio...");
+    (0, child_process_1.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/dist/commands/sessions.d.ts

@@ -0,0 +1 @@
+export declare function sessions(subcommand: string | undefined, args: string[]): Promise<void>;

package/packages/cli/dist/commands/sessions.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessions = sessions;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const HIVE_DIR = path.join(process.env.HOME || "", ".hive");
+const SESSIONS_DIR = path.join(HIVE_DIR, "sessions");
+async function sessions(subcommand, args) {
+    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() {
+    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) {
+    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() {
+    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/dist/commands/skills.d.ts

@@ -0,0 +1 @@
+export declare function skills(subcommand: string | undefined, args: string[]): Promise<void>;

package/packages/cli/dist/commands/skills.js

@@ -0,0 +1,190 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skills = skills;
+const p = __importStar(require("@clack/prompts"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const SKILLS_DIR = path.join(process.env.HOME || "", ".hive", "skills");
+const BUNDLED_SKILLS = [
+    { 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" },
+];
+async function skills(subcommand, args) {
+    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() {
+    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) {
+    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) {
+    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) {
+    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() {
+    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/packages/cli/dist/commands/update.d.ts

@@ -0,0 +1 @@
+export declare function update(): Promise<void>;

package/packages/cli/dist/commands/update.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.update = update;
+const PACKAGES = ["@johpaz/hive-cli"];
+async function update() {
+    console.log("🔄 Actualizando Hive...\n");
+    for (const pkg of PACKAGES) {
+        console.log(`Actualizando ${pkg}...`);
+        try {
+            const proc = Bun.spawn(["bun", "install", "-g", `${pkg}@latest`], {
+                stdout: "inherit",
+                stderr: "inherit",
+            });
+            const exitCode = await proc.exited;
+            if (exitCode === 0) {
+                console.log(`✅ ${pkg} actualizado\n`);
+            }
+            else {
+                console.log(`⚠️  Error actualizando ${pkg}\n`);
+            }
+        }
+        catch (e) {
+            console.log(`⚠️  Error actualizando ${pkg}: ${e.message}\n`);
+        }
+    }
+    console.log("✅ Hive actualizado. Ejecuta 'hive --version' para verificar.");
+}

package/packages/cli/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};