@johpaz/hive-cli 1.0.6 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johpaz/hive-cli",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Hive CLI — Command line interface for the Hive AI Gateway",
   "bin": {
     "hive": "src/index.ts"
@@ -15,11 +15,12 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.0.1",
-    "@johpaz/hive-core": "^1.0.6",
+    "@johpaz/hive-core": "^1.0.7",
+    "@johpaz/hive-orchestrator": "workspace:*",
     "js-yaml": "latest"
   },
   "devDependencies": {
     "typescript": "latest",
     "@types/bun": "latest"
   }
-}
+}

package/src/commands/gateway.ts

@@ -1,12 +1,21 @@
-import { loadConfig, startGateway, logger } from "@johpaz/hive-core";
+import { loadConfig, startGateway, logger, expandConfigPath } 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 DEFAULT_PID_FILE = path.join(process.env.HOME || "", ".hive", "gateway.pid");
 const LOG_FILE = path.join(process.env.HOME || "", ".hive", "logs", "gateway.log");
 
+function getPidFile(): string {
+  try {
+    const config = loadConfig();
+    return expandConfigPath(config.gateway?.pidFile) ?? DEFAULT_PID_FILE;
+  } catch {
+    return DEFAULT_PID_FILE;
+  }
+}
+
 function ensureLogDir(): void {
   const logDir = path.dirname(LOG_FILE);
   if (!fs.existsSync(logDir)) {
@@ -15,22 +24,26 @@ function ensureLogDir(): void {
 }
 
 function isRunning(): boolean {
-  if (!fs.existsSync(PID_FILE)) return false;
-  const pid = parseInt(fs.readFileSync(PID_FILE, "utf-8").trim(), 10);
+  const pidFile = getPidFile();
+  if (!fs.existsSync(pidFile)) return false;
+  const pid = parseInt(fs.readFileSync(pidFile, "utf-8").trim(), 10);
   if (isNaN(pid)) return false;
   try {
     process.kill(pid, 0);
     return true;
   } catch {
-    fs.unlinkSync(PID_FILE);
+    try {
+      fs.unlinkSync(pidFile);
+    } catch { }
     return false;
   }
 }
 
 export async function start(flags: string[]): Promise<void> {
   const daemon = flags.includes("--daemon");
+  const skipCheck = flags.includes("--skip-check");
 
-  if (isRunning()) {
+  if (!skipCheck && isRunning()) {
     console.log("⚠️  Hive Gateway ya está corriendo");
     return;
   }
@@ -51,23 +64,30 @@ export async function start(flags: string[]): Promise<void> {
  ║   ██║  ██║██║ ╚████╔╝ ███████╗             ║
  ║   ╚═╝  ╚═╝╚═╝  ╚═══╝  ╚══════╝             ║
  ║                                            ║
- ║   Personal AI Gateway — v1.0.6             ║
+ ║   Personal AI Gateway — v1.0.7             ║
  ╚════════════════════════════════════════════╝
 `);
 
   if (daemon) {
     ensureLogDir();
-    const child = spawn(process.execPath, [process.argv[1] || "", "start"], {
+    const child = spawn(process.execPath, [process.argv[1] || "", "start", "--skip-check"], {
       detached: true,
       stdio: ["ignore", fs.openSync(LOG_FILE, "a"), fs.openSync(LOG_FILE, "a")],
     });
     child.unref();
-    fs.writeFileSync(PID_FILE, child.pid?.toString() || "");
+    fs.writeFileSync(getPidFile(), child.pid?.toString() || "");
     console.log(`✅ Hive Gateway iniciado en modo daemon (PID: ${child.pid})`);
     console.log(`   Logs: ${LOG_FILE}`);
     return;
   }
 
+  try {
+    // Start Orchestrator sidecar in the same process
+    await import("@johpaz/hive-orchestrator");
+  } catch (error) {
+    console.warn(`⚠️  No se pudo iniciar el Orchestrator de Dashboards: ${(error as Error).message}`);
+  }
+
   await startGateway(config);
 }
 
@@ -77,10 +97,11 @@ export async function stop(): Promise<void> {
     return;
   }
 
-  const pid = parseInt(fs.readFileSync(PID_FILE, "utf-8").trim(), 10);
+  const pidFile = getPidFile();
+  const pid = parseInt(fs.readFileSync(pidFile, "utf-8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
-    fs.unlinkSync(PID_FILE);
+    fs.unlinkSync(pidFile);
     console.log("✅ Hive Gateway detenido");
   } catch (e) {
     console.error("❌ Error deteniendo el Gateway:", e);
@@ -99,20 +120,23 @@ export async function status(flags: string[]): Promise<void> {
   }
 
   const config = loadConfig();
+  const pidFile = getPidFile();
 
   console.log(`Estado:      ${running ? "✅ Corriendo" : "⏹️  Detenido"}`);
   if (running) {
-    const pid = fs.readFileSync(PID_FILE, "utf-8").trim();
+    const pid = fs.readFileSync(pidFile, "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"}`);
+  const provider = config.models?.defaultProvider || "no configurado";
+  const model = config.models?.defaults?.[provider] || "no configurado";
+  console.log(`Modelo:      ${provider} / ${model}`);
   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));
+    console.log("\n" + JSON.stringify({ running, pid: running ? fs.readFileSync(pidFile, "utf-8").trim() : null, config }, null, 2));
   }
 }
 
@@ -122,7 +146,7 @@ export async function reload(): Promise<void> {
     return;
   }
 
-  const pid = parseInt(fs.readFileSync(PID_FILE, "utf-8").trim(), 10);
+  const pid = parseInt(fs.readFileSync(getPidFile(), "utf-8").trim(), 10);
   try {
     process.kill(pid, "SIGHUP");
     console.log("✅ Configuración recargada");

package/src/commands/onboard.ts

@@ -3,7 +3,7 @@ import * as fs from "fs";
 import * as path from "path";
 import * as yaml from "js-yaml";
 
-const VERSION = "1.0.6";
+const VERSION = "1.0.8";
 
 const DEFAULT_MODELS: Record<string, string> = {
   anthropic: "claude-sonnet-4-6",
@@ -87,14 +87,29 @@ const AVAILABLE_MODELS: Record<string, Array<{ value: string; label: string; hin
   ],
 };
 
+const BUNDLED_SKILLS = [
+  { name: "web_search", label: "Web Search", hint: "Buscar en la web", default: true },
+  { name: "shell", label: "Shell", hint: "Ejecutar comandos", default: true },
+  { name: "file_manager", label: "File Manager", hint: "Operaciones de archivos", default: true },
+  { name: "http_client", label: "HTTP Client", hint: "Peticiones HTTP", default: true },
+  { name: "memory", label: "Memory", hint: "Memoria persistente", default: true },
+  { name: "cron_manager", label: "Cron Manager", hint: "Tareas programadas", default: false },
+  { name: "system_notify", label: "System Notify", hint: "Notificaciones desktop", default: false },
+  { name: "browser_automation", label: "Browser Automation", hint: "Automatizar navegador", default: false },
+  { name: "context_compact", label: "Context Compact", hint: "Compactar contexto", default: false },
+];
+
 interface OnboardConfig {
   agentName: string;
+  userName: string;
+  userId: string;
   provider: string;
   model: string;
   apiKey: string;
   channel: string;
   channelToken: string;
   workspace: string;
+  skills: string[];
 }
 
 function generateToken(): string {
@@ -106,6 +121,42 @@ function generateToken(): string {
   return token;
 }
 
+function generateUserId(): string {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let token = "user_";
+  for (let i = 0; i < 12; i++) {
+    token += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return token;
+}
+
+async function verifyTelegramToken(token: string): Promise<{ ok: boolean; username?: string }> {
+  try {
+    const res = await fetch(
+      `https://api.telegram.org/bot${token}/getMe`,
+      { signal: AbortSignal.timeout(5000) }
+    );
+    const data = (await res.json()) as {
+      ok: boolean;
+      result?: { username: string; first_name: string };
+    };
+    return {
+      ok: data.ok,
+      username: data.result?.username,
+    };
+  } catch {
+    return { ok: false };
+  }
+}
+
+function validateDiscordToken(token: string): boolean {
+  return token.length >= 50;
+}
+
+function validateSlackToken(token: string): boolean {
+  return token.startsWith("xoxb-") || token.startsWith("xoxp-");
+}
+
 async function testLLMConnection(provider: string, apiKey: string, model: string): Promise<boolean> {
   if (provider === "ollama") {
     try {
@@ -254,6 +305,11 @@ async function generateConfig(config: OnboardConfig): Promise<void> {
   const configObj: Record<string, unknown> = {
     name: config.agentName,
     version: VERSION,
+    user: {
+      id: config.userId,
+      name: config.userName,
+      channels: {},
+    },
     gateway: {
       host: "127.0.0.1",
       port: 18790,
@@ -279,7 +335,9 @@ async function generateConfig(config: OnboardConfig): Promise<void> {
     },
     channels: {},
     skills: {
-      allowBundled: [],
+      allowBundled: config.skills,
+      managedDir: path.join(process.env.HOME || "", ".hive", "skills"),
+      hotReload: true,
     },
     sessions: {
       pruneAfterHours: 168,
@@ -297,6 +355,7 @@ async function generateConfig(config: OnboardConfig): Promise<void> {
         accounts: {
           default: {
             botToken: config.channelToken,
+            dmPolicy: "open",
           },
         },
       },
@@ -317,7 +376,7 @@ async function generateConfig(config: OnboardConfig): Promise<void> {
   fs.chmodSync(configPath, 0o600);
 }
 
-async function generateWorkspace(workspace: string, agentName: string, ethicsChoice: string): Promise<void> {
+async function generateWorkspace(workspace: string, agentName: string, userName: string, userId: string, userLanguage: string, userTimezone: string, ethicsChoice: string): Promise<void> {
   if (!fs.existsSync(workspace)) {
     fs.mkdirSync(workspace, { recursive: true });
   }
@@ -355,16 +414,39 @@ Help the user with their tasks, answer questions, and provide assistance.
   if (!fs.existsSync(userPath)) {
     fs.writeFileSync(
       userPath,
-      `# User Profile
+      `# ${userName} — Perfil de Usuario
+
+## Identidad
+
+- **Nombre:** ${userName}
+- **ID Interno:** \`${userId}\` (este ID es para uso interno del sistema)
+- **Idioma preferido:** ${userLanguage}
+- **Zona horaria:** ${userTimezone}
+
+## Canales Vinculados
+
+Tu ID único (\`${userId}\`) se usa para unificar conversaciones entre canales.
 
-## Preferences
+| Canal | ID de Usuario |
+|-------|---------------|
+| Telegram | - |
+| WhatsApp | - |
+| Discord | - |
+| Slack | - |
 
-- Language: Spanish
-- Timezone: Auto-detect
+Para vincular un canal, usa:
+\`\`\`bash
+hive config set user.channels.telegram "tu_telegram_id"
+\`\`\`
 
-## Notes
+## Preferencias
 
-Add personal notes about the user here.
+- Idioma: ${userLanguage}
+- Zona horaria: ${userTimezone}
+
+## Notas
+
+Notas personales sobre ti.
 `,
       "utf-8"
     );
@@ -435,7 +517,345 @@ WantedBy=default.target
   spawnSync("systemctl", ["--user", "enable", "hive"], { stdio: "inherit" });
 }
 
-export async function onboard(): Promise<void> {
+async function isGatewayRunning(): Promise<boolean> {
+  const pidFile = path.join(process.env.HOME || "", ".hive", "gateway.pid");
+  if (!fs.existsSync(pidFile)) return false;
+  
+  try {
+    const pid = parseInt(fs.readFileSync(pidFile, "utf-8").trim(), 10);
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function reloadGateway(): Promise<void> {
+  const pidFile = path.join(process.env.HOME || "", ".hive", "gateway.pid");
+  if (!fs.existsSync(pidFile)) return;
+  
+  try {
+    const pid = parseInt(fs.readFileSync(pidFile, "utf-8").trim(), 10);
+    process.kill(pid, "SIGHUP");
+  } catch {
+    // Gateway not running
+  }
+}
+
+interface ExistingConfig {
+  agentName: string;
+  provider: string;
+  model: string;
+  channels: string[];
+  apiKey: string;
+  workspace: string;
+  skills: string[];
+  raw: Record<string, unknown>;
+}
+
+function parseExistingConfig(raw: Record<string, unknown>): ExistingConfig {
+  const agents = (raw.agents as Record<string, unknown>)?.list as Array<Record<string, unknown>> | undefined;
+  const models = raw.models as Record<string, unknown> | undefined;
+  const providers = models?.providers as Record<string, Record<string, unknown>> | undefined;
+  const defaultProvider = models?.defaultProvider as string | undefined;
+  const providerConfig = providers?.[defaultProvider || ""] as Record<string, unknown> | undefined;
+  
+  return {
+    agentName: (agents?.[0]?.name as string) ?? "Hive",
+    provider: defaultProvider ?? "gemini",
+    model: (models?.defaults as Record<string, string>)?.[defaultProvider || ""] ?? "",
+    channels: Object.keys((raw.channels as Record<string, unknown>) ?? {}),
+    apiKey: (providerConfig?.apiKey as string) ?? "",
+    workspace: (agents?.[0]?.workspace as string) ?? path.join(process.env.HOME || "", ".hive", "workspace"),
+    skills: ((raw.skills as Record<string, unknown>)?.allowBundled as string[]) ?? [],
+    raw,
+  };
+}
+
+async function runUpdateWizard(configPath: string, existing: ExistingConfig): Promise<void> {
+  p.note(
+    "Presiona Enter para mantener el valor actual de cada campo.",
+    "✏️  Modo actualización"
+  );
+
+  // Nombre del agente
+  const agentName = await p.text({
+    message: "Nombre del agente:",
+    placeholder: existing.agentName,
+    defaultValue: existing.agentName,
+  });
+
+  if (p.isCancel(agentName)) {
+    p.cancel("Actualización cancelada.");
+    process.exit(0);
+  }
+
+  // Proveedor LLM
+  const changeProvider = await p.confirm({
+    message: `Proveedor actual: ${existing.provider} (${existing.model || "no configurado"}). ¿Cambiar?`,
+    initialValue: false,
+  });
+
+  if (p.isCancel(changeProvider)) {
+    p.cancel("Actualización cancelada.");
+    process.exit(0);
+  }
+
+  let provider = existing.provider;
+  let model = existing.model;
+  let apiKey = existing.apiKey;
+
+  if (changeProvider) {
+    provider = await p.select({
+      message: "Nuevo proveedor LLM:",
+      options: [
+        { value: "anthropic", label: "Anthropic (Claude)", hint: "Recomendado — Claude 4.6" },
+        { value: "openai", label: "OpenAI (GPT-5)", hint: "GPT-5.2" },
+        { value: "gemini", label: "Google Gemini", hint: "Gemini 3 Flash" },
+        { value: "deepseek", label: "DeepSeek", hint: "Muy económico" },
+        { value: "kimi", label: "Kimi (Moonshot AI)", hint: "Contexto largo" },
+        { value: "openrouter", label: "OpenRouter", hint: "Multi-modelo" },
+        { value: "ollama", label: "Ollama (local)", hint: "Sin costo" },
+      ],
+    }) as string;
+
+    if (p.isCancel(provider)) {
+      p.cancel("Actualización cancelada.");
+      process.exit(0);
+    }
+
+    const models = AVAILABLE_MODELS[provider] || [{ value: DEFAULT_MODELS[provider], label: DEFAULT_MODELS[provider] }];
+    
+    if (models.length > 1) {
+      model = await p.select({
+        message: `Modelo de ${provider}:`,
+        options: models,
+      }) as string;
+
+      if (p.isCancel(model)) {
+        p.cancel("Actualización cancelada.");
+        process.exit(0);
+      }
+    } else {
+      model = models[0].value;
+    }
+
+    if (provider !== "ollama") {
+      const link = API_KEY_LINKS[provider];
+      if (link) {
+        p.note(`Obtén tu API key en:\n${link}`, `API key de ${provider}`);
+      }
+
+      const keyResult = await p.text({
+        message: `API key de ${provider}:`,
+        placeholder: API_KEY_PLACEHOLDERS[provider] || "sk-...",
+        validate: (v: string) => (!v || v.length < 10 ? "La key parece muy corta" : undefined),
+      });
+
+      if (p.isCancel(keyResult)) {
+        p.cancel("Actualización cancelada.");
+        process.exit(0);
+      }
+      apiKey = keyResult;
+
+      const spinner = p.spinner();
+      spinner.start(`Verificando conexión con ${provider}...`);
+
+      const connected = await testLLMConnection(provider, apiKey, model as string);
+
+      if (!connected) {
+        spinner.stop(`❌ Error conectando con ${provider}`);
+        p.outro("API key inválida. Ejecuta 'hive onboard' de nuevo con la key correcta.");
+        process.exit(1);
+      }
+
+      spinner.stop(`✅ Conexión con ${provider} verificada`);
+    }
+  }
+
+  // Canales
+  const currentChannels = existing.channels.length > 0 ? existing.channels.join(", ") : "ninguno";
+  const changeChannel = await p.confirm({
+    message: `Canales configurados: ${currentChannels}. ¿Añadir o cambiar?`,
+    initialValue: false,
+  });
+
+  if (p.isCancel(changeChannel)) {
+    p.cancel("Actualización cancelada.");
+    process.exit(0);
+  }
+
+  let channels = existing.raw.channels as Record<string, unknown> | undefined;
+
+  if (changeChannel) {
+    const channel = await p.select({
+      message: "Canal a configurar:",
+      options: [
+        { value: "telegram", label: "Telegram", hint: "Recomendado" },
+        { value: "discord", label: "Discord" },
+        { value: "webchat", label: "WebChat (local)" },
+        { value: "none", label: "Ninguno" },
+      ],
+    }) as string;
+
+    if (p.isCancel(channel)) {
+      p.cancel("Actualización cancelada.");
+      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("Actualización cancelada.");
+        process.exit(0);
+      }
+
+      const spinner = p.spinner();
+      spinner.start("Verificando token de Telegram...");
+      const tg = await verifyTelegramToken(tokenResult as string);
+      if (tg.ok && tg.username) {
+        spinner.stop(`✅ Bot verificado: @${tg.username}`);
+      } else {
+        spinner.stop("⚠️  Token no verificado — se guardará de todas formas");
+        p.note(
+          "El token se guardó pero no pudo verificarse.\n" +
+          "Si es incorrecto, ejecuta: hive onboard (opción actualizar)",
+          "Aviso"
+        );
+      }
+
+      const telegramAccount: Record<string, unknown> = {
+        botToken: tokenResult,
+        dmPolicy: "open",
+      };
+
+      channels = {
+        telegram: {
+          accounts: {
+            default: telegramAccount,
+          },
+        },
+      };
+    } 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("Actualización cancelada.");
+        process.exit(0);
+      }
+
+      channels = {
+        discord: {
+          accounts: {
+            default: {
+              token: tokenResult,
+            },
+          },
+        },
+      };
+    }
+  }
+
+  // Guardar cambios
+  const spinner = p.spinner();
+  spinner.start("Guardando cambios...");
+
+  const baseUrlMap: Record<string, string> = {
+    gemini: "https://generativelanguage.googleapis.com/v1beta",
+    deepseek: "https://api.deepseek.com/v1",
+    kimi: "https://api.moonshot.cn/v1",
+    ollama: "http://localhost:11434/api",
+  };
+
+  const providersConfig: Record<string, Record<string, unknown>> = {};
+  if (provider !== "ollama" && apiKey) {
+    providersConfig[provider] = { apiKey };
+    if (baseUrlMap[provider]) {
+      providersConfig[provider].baseUrl = baseUrlMap[provider];
+    }
+  }
+
+  const updatedConfig: Record<string, unknown> = {
+    ...existing.raw,
+    name: agentName,
+    agents: {
+      list: [
+        {
+          id: "main",
+          default: true,
+          name: agentName,
+          workspace: existing.workspace,
+          agentDir: path.join(process.env.HOME || "", ".hive", "agents", "main", "agent"),
+        },
+      ],
+    },
+    models: {
+      defaultProvider: provider,
+      defaults: {
+        [provider]: model,
+      },
+      providers: providersConfig,
+    },
+  };
+
+  if (channels) {
+    updatedConfig.channels = channels;
+  }
+
+  fs.writeFileSync(configPath, yaml.dump(updatedConfig, { lineWidth: -1 }), "utf-8");
+  fs.chmodSync(configPath, 0o600);
+
+  spinner.stop("Cambios guardados ✅");
+
+  // Recargar Gateway si está corriendo
+  const running = await isGatewayRunning();
+  if (running) {
+    const reload = await p.confirm({
+      message: "El Gateway está corriendo. ¿Recargar configuración ahora?",
+      initialValue: true,
+    });
+
+    if (reload) {
+      await reloadGateway();
+      p.log.success("Configuración recargada ✅");
+    }
+  }
+
+  const channelDisplay = channels ? Object.keys(channels).join(", ") || "ninguno" : existing.channels.join(", ") || "ninguno";
+
+  p.outro(
+    `✅ Configuración actualizada.\n\n` +
+    `  Agente:    ${agentName}\n` +
+    `  Proveedor: ${provider} (${model})\n` +
+    `  Canales:   ${channelDisplay}\n\n` +
+    `  hive status   → ver estado actual\n` +
+    `  hive reload   → recargar manualmente`
+  );
+}
+
+async function runFullWizard(configPath: string): Promise<void> {
   p.intro("🐝 Bienvenido a Hive — Personal AI Gateway");
 
   const agentName = await p.text({
@@ -449,6 +869,44 @@ export async function onboard(): Promise<void> {
     process.exit(0);
   }
 
+  const userName = await p.text({
+    message: "¿Cómo te llamas? (nombre para identificarte)",
+    placeholder: "Usuario",
+    defaultValue: "Usuario",
+  });
+
+  if (p.isCancel(userName)) {
+    p.cancel("Onboarding cancelado.");
+    process.exit(0);
+  }
+
+  const userLanguage = await p.select({
+    message: "¿En qué idioma prefieres que te responda?",
+    options: [
+      { value: "Spanish", label: "Español" },
+      { value: "English", label: "English" },
+      { value: "Spanish, English", label: "Ambos / Both" },
+    ],
+  });
+
+  if (p.isCancel(userLanguage)) {
+    p.cancel("Onboarding cancelado.");
+    process.exit(0);
+  }
+
+  const userTimezone = await p.text({
+    message: "¿Cuál es tu zona horaria? (ej: America/Bogota, Europe/Madrid)",
+    placeholder: "America/Bogota",
+    defaultValue: "America/Bogota",
+  });
+
+  if (p.isCancel(userTimezone)) {
+    p.cancel("Onboarding cancelado.");
+    process.exit(0);
+  }
+
+  const userId = generateUserId();
+
   const provider = await p.select({
     message: "¿Qué proveedor LLM quieres usar?",
     options: [
@@ -619,6 +1077,23 @@ export async function onboard(): Promise<void> {
         process.exit(0);
       }
       channelToken = tokenResult;
+
+      const verifySpinner = p.spinner();
+      verifySpinner.start("Verificando token de Telegram...");
+      const tg = await verifyTelegramToken(channelToken);
+      if (tg.ok && tg.username) {
+        verifySpinner.stop(`✅ Bot verificado: @${tg.username}`);
+      } else {
+        verifySpinner.stop("⚠️  Token no verificado — se guardará de todas formas");
+        p.note(
+          "El token no pudo verificarse. Si es incorrecto, ejecuta 'hive onboard' después.\n\n" +
+          "Para obtener tu Telegram ID y autorizarte:\n" +
+          "1. Inicia el bot con 'hive start'\n" +
+          "2. Escribe /myid al bot\n" +
+          "3. Añade tu ID a ~/.hive/hive.yaml",
+          "Próximos pasos"
+        );
+      }
     } else if (channel === "discord") {
       p.note(
         "1. Ve a https://discord.com/developers/applications\n" +
@@ -640,6 +1115,23 @@ export async function onboard(): Promise<void> {
     }
   }
 
+  // Skills selection
+  p.note("Skills son capacidades predefinidas que el agente puede usar.\nActiva las que necesites.", "Skills disponibles");
+  const selectedSkills = await p.multiselect({
+    message: "¿Qué skills deseas activar?",
+    options: BUNDLED_SKILLS.map(s => ({
+      value: s.name,
+      label: s.label,
+      hint: s.hint,
+    })),
+    initialValues: BUNDLED_SKILLS.filter(s => s.default).map(s => s.name),
+  });
+
+  if (p.isCancel(selectedSkills)) {
+    p.cancel("Onboarding cancelado.");
+    process.exit(0);
+  }
+
   const installService = await p.confirm({
     message: "¿Instalar Hive como servicio del sistema? (arranca automáticamente)",
     initialValue: false,
@@ -655,15 +1147,18 @@ export async function onboard(): Promise<void> {
 
   await generateConfig({
     agentName: agentName as string,
+    userName: userName as string,
+    userId: userId,
     provider: providerKey,
     model: model as string,
     apiKey,
     channel: channel as string,
     channelToken,
     workspace: workspace as string,
+    skills: selectedSkills as string[],
   });
 
-  await generateWorkspace(workspace as string, agentName as string, ethicsChoice as string);
+  await generateWorkspace(workspace as string, agentName as string, userName as string, userId, userLanguage as string, userTimezone as string, ethicsChoice as string);
 
   spinner.stop("Configuración creada ✅");
 
@@ -699,3 +1194,59 @@ export async function onboard(): Promise<void> {
       `  hive agents add <nombre>`
   );
 }
+
+export async function onboard(): Promise<void> {
+  const hiveDir = path.join(process.env.HOME || "", ".hive");
+  const configPath = path.join(hiveDir, "hive.yaml");
+
+  if (fs.existsSync(configPath)) {
+    p.intro("🔍 Configuración existente detectada");
+    
+    const rawConfig = yaml.load(fs.readFileSync(configPath, "utf-8")) as Record<string, unknown>;
+    const existing = parseExistingConfig(rawConfig);
+    
+    p.note(
+      `  Agente:    ${existing.agentName}\n` +
+      `  Proveedor: ${existing.provider} (${existing.model || "no configurado"})\n` +
+      `  Canales:   ${existing.channels.length > 0 ? existing.channels.join(", ") : "ninguno"}\n` +
+      `  Workspace: ${existing.workspace}`,
+      "Config actual"
+    );
+    
+    const action = await p.select({
+      message: "¿Qué quieres hacer?",
+      options: [
+        { value: "update", label: "Actualizar", hint: "Modificar algunos campos" },
+        { value: "reset", label: "Reiniciar", hint: "Crear config desde cero" },
+        { value: "cancel", label: "Cancelar", hint: "Salir sin cambios" },
+      ],
+    });
+    
+    if (p.isCancel(action) || action === "cancel") {
+      p.cancel("Operación cancelada.");
+      process.exit(0);
+    }
+    
+    if (action === "reset") {
+      const confirm = await p.confirm({
+        message: "⚠️  Esto borrará tu config actual. ¿Continuar?",
+        initialValue: false,
+      });
+      
+      if (p.isCancel(confirm) || !confirm) {
+        p.cancel("Operación cancelada.");
+        process.exit(0);
+      }
+      
+      const backupPath = path.join(hiveDir, `hive.yaml.backup.${Date.now()}`);
+      fs.copyFileSync(configPath, backupPath);
+      p.log.info(`Backup creado: ${backupPath}`);
+      
+      await runFullWizard(configPath);
+    } else {
+      await runUpdateWizard(configPath, existing);
+    }
+  } else {
+    await runFullWizard(configPath);
+  }
+}

package/src/index.ts

@@ -14,7 +14,7 @@ import { securityAudit } from "./commands/security";
 import { installService } from "./commands/service";
 import { update } from "./commands/update";
 
-const VERSION = "1.0.6";
+const VERSION = "1.0.7";
 
 const HELP = `
 🐝 Hive — Personal AI Gateway v${VERSION}