@johpaz/hive-cli 1.0.3 → 1.0.5

package/src/commands/onboard.ts

@@ -0,0 +1,690 @@
+import * as p from "@clack/prompts";
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+
+const VERSION = "1.0.5";
+
+const DEFAULT_MODELS: Record<string, string> = {
+  anthropic: "claude-sonnet-4-6",
+  openai: "gpt-5.2",
+  gemini: "gemini-2.5-flash",
+  deepseek: "deepseek-chat",
+  kimi: "kimi-k2.5",
+  openrouter: "meta-llama/llama-3.3-70b-instruct",
+  ollama: "llama3.3:8b",
+};
+
+const PROVIDER_BASE_URLS: Record<string, string> = {
+  anthropic: "https://api.anthropic.com",
+  openai: "https://api.openai.com",
+  gemini: "https://generativelanguage.googleapis.com",
+  deepseek: "https://api.deepseek.com",
+  kimi: "https://api.moonshot.cn",
+  openrouter: "https://openrouter.ai/api",
+  ollama: "http://localhost:11434",
+};
+
+const API_KEY_PLACEHOLDERS: Record<string, string> = {
+  anthropic: "sk-ant-...",
+  openai: "sk-...",
+  gemini: "AIza...",
+  deepseek: "sk-...",
+  kimi: "sk-...",
+  openrouter: "sk-or-...",
+  ollama: "",
+};
+
+const API_KEY_LINKS: Record<string, string> = {
+  anthropic: "https://console.anthropic.com/keys",
+  openai: "https://platform.openai.com/api-keys",
+  gemini: "https://aistudio.google.com/app/apikey",
+  deepseek: "https://platform.deepseek.com/api_keys",
+  kimi: "https://platform.moonshot.cn/console/api-keys",
+  openrouter: "https://openrouter.ai/keys",
+  ollama: "",
+};
+
+const AVAILABLE_MODELS: Record<string, Array<{ value: string; label: string; hint?: string }>> = {
+  anthropic: [
+    { value: "claude-sonnet-4-6", label: "Claude Sonnet 4.6", hint: "Recomendado — mejor equilibrio, 1M contexto" },
+    { value: "claude-opus-4-6", label: "Claude Opus 4.6", hint: "Más potente — agentic coding, 1M contexto" },
+    { value: "claude-haiku-4-6", label: "Claude Haiku 4.6", hint: "Más rápido y económico" },
+  ],
+  openai: [
+    { value: "gpt-5.2", label: "GPT-5.2", hint: "Recomendado — 400K contexto, latest" },
+    { value: "gpt-5.1", label: "GPT-5.1", hint: "Versión anterior estable" },
+    { value: "gpt-5.2-codex", label: "GPT-5.2 Codex", hint: "Especializado en código" },
+    { value: "o4-mini", label: "o4-mini", hint: "Razonamiento avanzado, económico" },
+  ],
+  gemini: [
+    { value: "gemini-3-flash-preview", label: "Gemini 3 Flash (Preview)", hint: "Frontier-class, muy económico" },
+    { value: "gemini-2.5-flash", label: "Gemini 2.5 Flash", hint: "Recomendado — estable, rápido" },
+    { value: "gemini-2.5-pro", label: "Gemini 2.5 Pro", hint: "Más potente — razonamiento profundo" },
+    { value: "gemini-3.1-pro-preview", label: "Gemini 3.1 Pro (Preview)", hint: "Latest — tareas complejas" },
+  ],
+  deepseek: [
+    { value: "deepseek-chat", label: "DeepSeek-V3", hint: "Recomendado — muy económico, capaz" },
+    { value: "deepseek-reasoner", label: "DeepSeek-R1", hint: "Razonamiento profundo" },
+    { value: "deepseek-coder", label: "DeepSeek Coder", hint: "Especializado en código" },
+  ],
+  kimi: [
+    { value: "kimi-k2.5", label: "Kimi K2.5", hint: "Recomendado — multimodal, agentic, 1T params" },
+    { value: "kimi-k2-thinking", label: "Kimi K2 Thinking", hint: "Largo razonamiento" },
+    { value: "kimi-k2-turbo-preview", label: "Kimi K2 Turbo", hint: "Rápido, preview" },
+  ],
+  openrouter: [
+    { value: "meta-llama/llama-3.3-70b-instruct", label: "Llama 3.3 70B", hint: "Gratis — GPT-4 level" },
+    { value: "google/gemini-2.0-flash-exp:free", label: "Gemini 2.0 Flash", hint: "Gratis — 1M contexto" },
+    { value: "deepseek/deepseek-r1:free", label: "DeepSeek R1", hint: "Gratis — razonamiento fuerte" },
+    { value: "anthropic/claude-sonnet-4-6", label: "Claude Sonnet 4.6", hint: "Vía OpenRouter" },
+  ],
+  ollama: [
+    { value: "llama3.3:8b", label: "Llama 3.3 8B", hint: "Recomendado — general, ~5GB RAM" },
+    { value: "qwen2.5:7b", label: "Qwen 2.5 7B", hint: "Multilingual, código, ~4.5GB RAM" },
+    { value: "mistral:7b", label: "Mistral 7B", hint: "Rápido, ~4GB RAM" },
+    { value: "phi4:14b", label: "Phi-4 14B", hint: "Mejor calidad, ~8GB RAM" },
+  ],
+};
+
+interface OnboardConfig {
+  agentName: string;
+  provider: string;
+  model: string;
+  apiKey: string;
+  channel: string;
+  channelToken: string;
+  workspace: string;
+}
+
+function generateToken(): string {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let token = "";
+  for (let i = 0; i < 32; i++) {
+    token += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return token;
+}
+
+async function testLLMConnection(provider: string, apiKey: string, model: string): Promise<boolean> {
+  if (provider === "ollama") {
+    try {
+      const response = await fetch("http://localhost:11434/api/tags");
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  const testMessages = [{ role: "user" as const, content: "Say 'ok' if you can read this." }];
+
+  try {
+    if (provider === "anthropic") {
+      const response = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01",
+          "anthropic-dangerous-direct-browser-access": "true",
+        },
+        body: JSON.stringify({
+          model: model,
+          max_tokens: 10,
+          messages: testMessages,
+        }),
+      });
+      return response.ok;
+    }
+
+    if (provider === "openai") {
+      const response = await fetch("https://api.openai.com/v1/chat/completions", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+          model: model,
+          max_tokens: 10,
+          messages: testMessages,
+        }),
+      });
+      return response.ok;
+    }
+
+    if (provider === "gemini") {
+      const response = await fetch(
+        `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            contents: [{ parts: [{ text: "Say ok" }] }],
+          }),
+        }
+      );
+      return response.ok;
+    }
+
+    if (provider === "deepseek") {
+      const response = await fetch("https://api.deepseek.com/v1/chat/completions", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+          model: model,
+          max_tokens: 10,
+          messages: testMessages,
+        }),
+      });
+      return response.ok;
+    }
+
+    if (provider === "kimi") {
+      const response = await fetch("https://api.moonshot.cn/v1/chat/completions", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+          model: model,
+          max_tokens: 10,
+          messages: testMessages,
+        }),
+      });
+      return response.ok;
+    }
+
+    if (provider === "openrouter") {
+      const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+          model: model,
+          max_tokens: 10,
+          messages: testMessages,
+        }),
+      });
+      return response.ok;
+    }
+
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+async function generateConfig(config: OnboardConfig): Promise<void> {
+  const hiveDir = path.join(process.env.HOME || "", ".hive");
+  const configPath = path.join(hiveDir, "hive.yaml");
+
+  if (!fs.existsSync(hiveDir)) {
+    fs.mkdirSync(hiveDir, { recursive: true });
+  }
+
+  const configObj: Record<string, unknown> = {
+    name: config.agentName,
+    version: VERSION,
+    gateway: {
+      port: 18790,
+      host: "127.0.0.1",
+      token: generateToken(),
+    },
+    model: {
+      provider: config.provider,
+      name: config.model,
+      apiKey: config.provider === "ollama" ? "" : config.apiKey,
+    },
+    agents: {
+      list: [
+        {
+          id: "main",
+          default: true,
+          name: config.agentName,
+          workspace: config.workspace,
+          agentDir: path.join(process.env.HOME || "", ".hive", "agents", "main", "agent"),
+        },
+      ],
+    },
+    channels: {},
+    skills: {
+      watch: true,
+      allowBundled: [],
+      denyBundled: [],
+    },
+    sessions: {
+      pruneAfterHours: 168,
+      pruneInterval: 24,
+    },
+    logging: {
+      level: "info",
+      dir: path.join(process.env.HOME || "", ".hive", "logs"),
+      redactSensitive: true,
+    },
+  };
+
+  if (config.provider === "gemini") {
+    (configObj.model as Record<string, unknown>).baseUrl = "https://generativelanguage.googleapis.com/v1beta";
+  } else if (config.provider === "deepseek") {
+    (configObj.model as Record<string, unknown>).baseUrl = "https://api.deepseek.com/v1";
+  } else if (config.provider === "kimi") {
+    (configObj.model as Record<string, unknown>).baseUrl = "https://api.moonshot.cn/v1";
+  } else if (config.provider === "ollama") {
+    (configObj.model as Record<string, unknown>).baseUrl = "http://localhost:11434/api";
+  }
+
+  if (config.channel === "telegram" && config.channelToken) {
+    configObj.channels = {
+      telegram: {
+        accounts: {
+          default: {
+            botToken: config.channelToken,
+          },
+        },
+      },
+    };
+  } else if (config.channel === "discord" && config.channelToken) {
+    configObj.channels = {
+      discord: {
+        accounts: {
+          default: {
+            token: config.channelToken,
+          },
+        },
+      },
+    };
+  }
+
+  fs.writeFileSync(configPath, yaml.dump(configObj, { lineWidth: -1 }), "utf-8");
+  fs.chmodSync(configPath, 0o600);
+}
+
+async function generateWorkspace(workspace: string, agentName: string, ethicsChoice: string): Promise<void> {
+  if (!fs.existsSync(workspace)) {
+    fs.mkdirSync(workspace, { recursive: true });
+  }
+
+  const soulPath = path.join(workspace, "SOUL.md");
+  if (!fs.existsSync(soulPath)) {
+    fs.writeFileSync(
+      soulPath,
+      `# ${agentName} — Soul
+
+You are ${agentName}, a personal AI assistant.
+
+## Purpose
+
+Help the user with their tasks, answer questions, and provide assistance.
+
+## Personality
+
+- Helpful and friendly
+- Concise but thorough
+- Proactive in suggesting solutions
+
+## Capabilities
+
+- Execute commands and scripts
+- Read and write files
+- Search the web
+- Manage tasks
+`,
+      "utf-8"
+    );
+  }
+
+  const userPath = path.join(workspace, "USER.md");
+  if (!fs.existsSync(userPath)) {
+    fs.writeFileSync(
+      userPath,
+      `# User Profile
+
+## Preferences
+
+- Language: Spanish
+- Timezone: Auto-detect
+
+## Notes
+
+Add personal notes about the user here.
+`,
+      "utf-8"
+    );
+  }
+
+  const ethicsPath = path.join(workspace, "ETHICS.md");
+  if (!fs.existsSync(ethicsPath) && ethicsChoice === "default") {
+    fs.writeFileSync(
+      ethicsPath,
+      `# Ethical Guidelines
+
+## Core Principles
+
+1. **Respect Privacy**: Never share or expose sensitive user data
+2. **Honesty**: Provide accurate information, admit uncertainty
+3. **Safety**: Avoid harmful actions, warn about risks
+4. **Autonomy**: Respect user decisions and preferences
+
+## Boundaries
+
+- Do not execute commands that could harm the system
+- Do not access files outside the workspace without permission
+- Do not share API keys or credentials
+
+## Uncertainty
+
+When uncertain about an action:
+1. Ask for clarification
+2. Explain the risks
+3. Suggest alternatives
+`,
+      "utf-8"
+    );
+  }
+}
+
+async function installSystemdService(): Promise<void> {
+  const home = process.env.HOME || "";
+  const systemdDir = path.join(home, ".config", "systemd", "user");
+
+  if (!fs.existsSync(systemdDir)) {
+    fs.mkdirSync(systemdDir, { 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(systemdDir, "hive.service");
+  fs.writeFileSync(servicePath, serviceContent, "utf-8");
+
+  const { spawnSync } = require("child_process");
+  spawnSync("systemctl", ["--user", "daemon-reload"], { stdio: "inherit" });
+  spawnSync("systemctl", ["--user", "enable", "hive"], { stdio: "inherit" });
+}
+
+export async function onboard(): Promise<void> {
+  p.intro("🐝 Bienvenido a Hive — Personal AI Gateway");
+
+  const agentName = await p.text({
+    message: "¿Cómo se llama tu agente?",
+    placeholder: "Hive",
+    defaultValue: "Hive",
+  });
+
+  if (p.isCancel(agentName)) {
+    p.cancel("Onboarding cancelado.");
+    process.exit(0);
+  }
+
+  const provider = await p.select({
+    message: "¿Qué proveedor LLM quieres usar?",
+    options: [
+      { value: "anthropic", label: "Anthropic (Claude)", hint: "Recomendado — Claude 4.6, 1M contexto" },
+      { value: "openai", label: "OpenAI (GPT-5)", hint: "GPT-5.2, 400K contexto" },
+      { value: "gemini", label: "Google Gemini", hint: "Gemini 3 Flash/Pro, 1M contexto" },
+      { value: "deepseek", label: "DeepSeek", hint: "V3/R1 — muy económico, 1/100 costo" },
+      { value: "kimi", label: "Kimi (Moonshot AI)", hint: "K2.5 — multimodal, agentic, 1T params" },
+      { value: "openrouter", label: "OpenRouter", hint: "Gratis: Llama 3.3 70B, Gemini Flash" },
+      { value: "ollama", label: "Ollama (local)", hint: "Llama 3.3, Qwen 2.5, sin costo" },
+    ],
+  });
+
+  if (p.isCancel(provider)) {
+    p.cancel("Onboarding cancelado.");
+    process.exit(0);
+  }
+
+  const providerKey = provider as string;
+  const models = AVAILABLE_MODELS[providerKey] || [{ value: DEFAULT_MODELS[providerKey], label: DEFAULT_MODELS[providerKey] }];
+  
+  let model: string | symbol;
+  if (models.length > 1) {
+    model = await p.select({
+      message: `¿Qué modelo de ${providerKey} quieres usar?`,
+      options: models,
+    });
+    if (p.isCancel(model)) {
+      p.cancel("Onboarding cancelado.");
+      process.exit(0);
+    }
+  } else {
+    model = models[0].value;
+  }
+
+  let apiKey = "";
+  if (providerKey !== "ollama") {
+    const link = API_KEY_LINKS[providerKey];
+    if (link) {
+      p.note(`Obtén tu API key en:\n${link}`, `API key de ${providerKey}`);
+    }
+
+    const keyResult = await p.text({
+      message: `API key de ${providerKey}:`,
+      placeholder: API_KEY_PLACEHOLDERS[providerKey] || "sk-...",
+      validate: (v) => (!v || v.length < 10 ? "La key parece muy corta" : undefined),
+    });
+
+    if (p.isCancel(keyResult)) {
+      p.cancel("Onboarding cancelado.");
+      process.exit(0);
+    }
+    apiKey = keyResult;
+
+    const spinner = p.spinner();
+    spinner.start("Verificando conexión con el LLM...");
+
+    const connected = await testLLMConnection(providerKey, apiKey, model as string);
+    
+    if (!connected) {
+      spinner.stop(`❌ Error conectando con ${providerKey}`);
+      p.note(
+        `Verifica que:\n` +
+          `1. La API key es correcta\n` +
+          `2. Tienes saldo/créditos en tu cuenta\n` +
+          `3. Tu conexión a internet funciona`,
+        "Error de conexión"
+      );
+      const retry = await p.confirm({
+        message: "¿Quieres introducir la API key de nuevo?",
+      });
+      if (p.isCancel(retry) || !retry) {
+        p.cancel("Onboarding cancelado. Ejecuta 'hive onboard' cuando tengas la key correcta.");
+        process.exit(1);
+      }
+      const retryKey = await p.text({
+        message: `API key de ${providerKey}:`,
+        placeholder: API_KEY_PLACEHOLDERS[providerKey] || "sk-...",
+        validate: (v) => (!v || v.length < 10 ? "La key parece muy corta" : undefined),
+      });
+      if (p.isCancel(retryKey)) {
+        p.cancel("Onboarding cancelado.");
+        process.exit(0);
+      }
+      apiKey = retryKey;
+      
+      spinner.start("Verificando conexión con el LLM...");
+      const retryConnected = await testLLMConnection(providerKey, apiKey, model as string);
+      if (!retryConnected) {
+        spinner.stop(`❌ Error conectando con ${providerKey}`);
+        p.cancel("No se pudo verificar la conexión. Verifica tu API key e intenta de nuevo.");
+        process.exit(1);
+      }
+      spinner.stop(`✅ Conexión con ${providerKey} verificada`);
+    } else {
+      spinner.stop(`✅ Conexión con ${providerKey} verificada`);
+    }
+  }
+
+  const workspaceDefault = `${process.env.HOME}/.hive/workspace`;
+  const workspace = await p.text({
+    message: "Directorio de trabajo del agente:",
+    placeholder: workspaceDefault,
+    defaultValue: workspaceDefault,
+  });
+
+  if (p.isCancel(workspace)) {
+    p.cancel("Onboarding cancelado.");
+    process.exit(0);
+  }
+
+  const ethicsChoice = await p.select({
+    message: "Lineamientos éticos del agente:",
+    options: [
+      { value: "default", label: "Usar defaults (recomendado)" },
+      { value: "skip", label: "Configurar después" },
+    ],
+  });
+
+  if (p.isCancel(ethicsChoice)) {
+    p.cancel("Onboarding cancelado.");
+    process.exit(0);
+  }
+
+  const configureChannel = await p.confirm({
+    message: "¿Quieres configurar un canal ahora? (puedes hacerlo después)",
+    initialValue: false,
+  });
+
+  if (p.isCancel(configureChannel)) {
+    p.cancel("Onboarding cancelado.");
+    process.exit(0);
+  }
+
+  let channel = "none";
+  let channelToken = "";
+
+  if (configureChannel) {
+    channel = await p.select({
+      message: "¿Qué canal quieres configurar?",
+      options: [
+        { value: "telegram", label: "Telegram", hint: "Recomendado para empezar" },
+        { value: "discord", label: "Discord" },
+        { value: "webchat", label: "WebChat (UI web local)" },
+        { value: "none", label: "Ninguno por ahora" },
+      ],
+    }) as string;
+
+    if (p.isCancel(channel)) {
+      p.cancel("Onboarding cancelado.");
+      process.exit(0);
+    }
+
+    if (channel === "telegram") {
+      p.note(
+        "1. Abre Telegram y busca @BotFather\n" +
+          "2. Escribe /newbot y sigue las instrucciones\n" +
+          "3. Copia el token que te da BotFather",
+        "Cómo obtener el token de Telegram"
+      );
+      const tokenResult = await p.text({
+        message: "Token de Telegram BotFather:",
+        placeholder: "123456789:ABCdefGHI...",
+      });
+
+      if (p.isCancel(tokenResult)) {
+        p.cancel("Onboarding cancelado.");
+        process.exit(0);
+      }
+      channelToken = tokenResult;
+    } else if (channel === "discord") {
+      p.note(
+        "1. Ve a https://discord.com/developers/applications\n" +
+          "2. Crea una nueva aplicación\n" +
+          "3. Ve a Bot → Reset Token\n" +
+          "4. Habilita 'Message Content Intent'",
+        "Cómo obtener el token de Discord"
+      );
+      const tokenResult = await p.text({
+        message: "Token del bot de Discord:",
+        placeholder: "MTk4NjIyNDgzNDcxO...",
+      });
+
+      if (p.isCancel(tokenResult)) {
+        p.cancel("Onboarding cancelado.");
+        process.exit(0);
+      }
+      channelToken = tokenResult;
+    }
+  }
+
+  const installService = await p.confirm({
+    message: "¿Instalar Hive como servicio del sistema? (arranca automáticamente)",
+    initialValue: false,
+  });
+
+  if (p.isCancel(installService)) {
+    p.cancel("Onboarding cancelado.");
+    process.exit(0);
+  }
+
+  const spinner = p.spinner();
+  spinner.start("Creando configuración...");
+
+  await generateConfig({
+    agentName: agentName as string,
+    provider: providerKey,
+    model: model as string,
+    apiKey,
+    channel: channel as string,
+    channelToken,
+    workspace: workspace as string,
+  });
+
+  await generateWorkspace(workspace as string, agentName as string, ethicsChoice as string);
+
+  spinner.stop("Configuración creada ✅");
+
+  if (installService) {
+    const serviceSpinner = p.spinner();
+    serviceSpinner.start("Instalando servicio systemd...");
+    await installSystemdService();
+    serviceSpinner.stop("Servicio instalado ✅");
+  }
+
+  const channelDisplay = channel === "none" || channel === "webchat" ? "WebChat (local)" : channel;
+
+  p.outro(
+    `🐝 Hive está listo.\n\n` +
+      `  Tu agente: ${agentName}\n` +
+      `  Proveedor: ${providerKey} (${model})\n` +
+      `  Canal:     ${channelDisplay}\n\n` +
+      `  Comandos:\n` +
+      `  ─────────────────────────────────────\n` +
+      `  hive start              Arrancar el Gateway\n` +
+      `  hive chat               Chatear en la terminal\n` +
+      `  hive status             Ver estado\n` +
+      `  hive logs --follow      Ver logs en tiempo real\n\n` +
+      `  Control UI:\n` +
+      `  ─────────────────────────────────────\n` +
+      `  http://127.0.0.1:18790/ui\n\n` +
+      `  Config guardada en:\n` +
+      `  ─────────────────────────────────────\n` +
+      `  ~/.hive/hive.yaml  (permisos 600)\n\n` +
+      `  Para añadir más canales o agentes:\n` +
+      `  ─────────────────────────────────────\n` +
+      `  hive config edit\n` +
+      `  hive agents add <nombre>`
+  );
+}