@johpaz/hive-agents 0.0.35 → 0.0.36

package/packages/core/src/gateway/llm-local/manager.ts

@@ -0,0 +1,186 @@
+/**
+ * Hive Local LLM — Server Manager
+ * Gestiona procesos persistentes de llama-server
+ */
+
+import { spawn, type Subprocess } from "bun"
+import { getModelConfig, buildLlamaServerArgs, type ModelConfig } from "./models"
+import { type ModelId } from "./downloader"
+import { findLlamaServerBinary } from "./downloader"
+import { logger } from "../../utils/logger"
+
+const log = logger.child("llama-manager")
+
+export type ServerMode = "TEXT" | "IMAGE" | "AUDIO"
+
+interface ManagedServer {
+  mode: ServerMode
+  port: number
+  process: Subprocess
+
+  modelId: ModelId
+  startedAt: number
+}
+
+class LlamaServerManager {
+  private servers = new Map<ServerMode, ManagedServer>()
+  private logs = new Map<ServerMode, string[]>()
+
+  async start(mode: ServerMode, modelId: ModelId): Promise<ManagedServer> {
+    const existing = this.servers.get(mode)
+    if (existing) {
+      if (existing.process.killed) {
+        this.servers.delete(mode)
+      } else {
+        return existing
+      }
+    }
+
+    // Solo 1 modo a la vez para evitar Out of Memory (VRAM compartida)
+    this.stopAll()
+    await Bun.sleep(1000) // Dar tiempo a liberar la VRAM y puertos
+
+    const port = this.getPortForMode(mode)
+    // NO auto-descargar: verificar que el binario ya exista
+    const binaryPath = await findLlamaServerBinary()
+    if (!binaryPath) {
+      throw new Error(
+        "llama-server no está instalado. Ve a Configuración > LLM Local y haz clic en 'Instalar' primero."
+      )
+    }
+    const config = getModelConfig(modelId, port)
+
+    if ((mode === "IMAGE" || mode === "AUDIO") && !config.mmprojPath) {
+      throw new Error(`El modo ${mode} requiere el proyector de visión (mmproj). Por favor, descárgalo primero.`)
+    }
+
+    const args = buildLlamaServerArgs(config, mode)
+
+    log.info(`Iniciando llama-server para modo ${mode} en puerto ${port}...`)
+    
+    const proc = Bun.spawn([binaryPath, ...args], {
+      stdout: "pipe",
+      stderr: "pipe",
+      env: {
+        ...process.env,
+        LD_LIBRARY_PATH: `${require("path").dirname(binaryPath)}:${process.env.LD_LIBRARY_PATH || ""}`,
+        GGML_VULKAN_CHECK_RESULTS: "0",
+        GGML_VULKAN_DEBUG: "0",
+      },
+    })
+
+    const server: ManagedServer = {
+      mode,
+      port,
+      process: proc,
+      modelId,
+      startedAt: Date.now(),
+    }
+
+    this.servers.set(mode, server)
+    this.logs.set(mode, [])
+
+    // Capturar logs
+    this.captureLogs(mode, proc)
+
+    // Esperar a que el servidor esté listo (health check)
+    const ready = await this.waitForReady(port)
+    if (!ready) {
+      this.stop(mode)
+      throw new Error(`Servidor ${mode} no respondió en puerto ${port} tras iniciar.`)
+    }
+
+    return server
+  }
+
+  stop(mode: ServerMode): void {
+    const server = this.servers.get(mode)
+    if (server) {
+      server.process.kill()
+      this.servers.delete(mode)
+      log.info(`Servidor ${mode} detenido.`)
+    }
+  }
+
+  stopAll(): void {
+    for (const mode of this.servers.keys()) {
+      this.stop(mode)
+    }
+  }
+
+  getStatus() {
+    const status: any[] = []
+    for (const [mode, server] of this.servers.entries()) {
+      status.push({
+        mode,
+        port: server.port,
+        modelId: server.modelId,
+        uptime: Math.floor((Date.now() - server.startedAt) / 1000),
+        pid: server.process.pid,
+      })
+    }
+    return status
+  }
+
+  getLogs(mode: ServerMode): string[] {
+    return this.logs.get(mode) || []
+  }
+
+  private getPortForMode(mode: ServerMode): number {
+    switch (mode) {
+      case "TEXT": return 8081
+      case "IMAGE": return 8082
+      case "AUDIO": return 8083
+      default: return 8081
+    }
+  }
+
+  private async waitForReady(port: number, retries = 20): Promise<boolean> {
+    for (let i = 0; i < retries; i++) {
+      try {
+        const res = await fetch(`http://localhost:${port}/health`, {
+          signal: AbortSignal.timeout(500),
+        })
+        if (res.ok) return true
+      } catch {
+        // next retry
+      }
+      await Bun.sleep(500)
+    }
+    return false
+  }
+
+  private async captureLogs(mode: ServerMode, proc: Subprocess) {
+    if (!proc.stderr || typeof proc.stderr === "number") {
+      log.warn(`No se pudo capturar logs para ${mode}: stderr no es un stream.`)
+      return
+    }
+
+    const reader = proc.stderr.getReader()
+    const decoder = new TextDecoder()
+    const logs = this.logs.get(mode)!
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+        const text = decoder.decode(value, { stream: true })
+        const lines = text.split("\n")
+        for (const line of lines) {
+          if (line.trim()) {
+            logs.push(line.trim())
+            if (logs.length > 500) logs.shift()
+            // Logear errores críticos al logger principal
+            if (line.includes("error") || line.includes("FAILED")) {
+              log.error(`[${mode}] ${line.trim()}`)
+            }
+          }
+        }
+      }
+    } catch (e) {
+      log.error(`Error capturando logs de ${mode}: ${e}`)
+    }
+  }
+}
+
+export const llamaManager = new LlamaServerManager()

package/packages/core/src/gateway/llm-local/models.ts

@@ -0,0 +1,149 @@
+/**
+ * Hive Local LLM — Model Utils
+ * Gestión de rutas y configuración de modelos
+ */
+
+
+import { existsSync } from "fs"
+import { MODELS_DIR, getModelPath, type ModelId } from "./downloader"
+
+export interface ModelConfig {
+  modelPath: string
+  mmprojPath?: string
+  ctxSize: number
+  ngl: number
+  threads: number
+  batchSize: number
+  ubatchSize: number
+  cacheTypeK: string
+  cacheTypeV: string
+  flashAttn: boolean
+  host: string
+  port: number
+  jinja: boolean
+}
+
+const DEFAULT_CONFIG: Omit<ModelConfig, "modelPath" | "mmprojPath" | "port"> = {
+  ctxSize: 16000,
+  ngl: 999,
+  threads: 16,
+  batchSize: 2048,
+  ubatchSize: 512,
+  cacheTypeK: "f16",
+  cacheTypeV: "f16",
+  flashAttn: true,
+  host: "0.0.0.0",
+  jinja: true,
+}
+
+export function getModelConfig(modelId: ModelId, port: number = 8081): ModelConfig {
+  const modelPath = getModelPath(modelId)
+
+  if (!existsSync(modelPath)) {
+    throw new Error(`Modelo no descargado: ${modelId}. Ejecuta downloadModel("${modelId}") primero.`)
+  }
+
+  const mmprojPath = getModelPath("mmproj")
+  const hasMMProj = existsSync(mmprojPath)
+
+  return {
+    modelPath,
+    mmprojPath: hasMMProj ? mmprojPath : undefined,
+    port,
+    ...DEFAULT_CONFIG,
+  }
+}
+
+/** Construye los argumentos de línea de comando para llama-server */
+export function buildLlamaServerArgs(config: ModelConfig, mode: string): string[] {
+  const args: string[] = [
+    "-m", config.modelPath,
+    "--host", config.host,
+    "--port", String(config.port),
+    "-c", String(config.ctxSize),
+    "-ngl", String(config.ngl),
+    "-t", String(config.threads),
+    "-b", String(config.batchSize),
+    "-ub", String(config.ubatchSize),
+    "--cache-type-k", config.cacheTypeK,
+    "--cache-type-v", config.cacheTypeV,
+  ]
+
+  // Solo añadir mmproj si estamos en modo IMAGE para evitar errores de arquitectura en modo texto
+  if (config.mmprojPath && (mode === "IMAGE" || mode === "AUDIO")) {
+    args.push("--mmproj", config.mmprojPath)
+  }
+
+  if (config.flashAttn) {
+    args.push("--flash-attn", "on")
+  }
+
+  if (config.jinja) {
+    args.push("--jinja")
+  }
+
+  return args
+}
+
+/** Construye los argumentos de línea de comando para hive-cli (legacy) */
+export function buildHiveCLIArgs(config: ModelConfig, options: {
+  prompt?: string
+  imagePath?: string
+  audioPath?: string
+  interactive?: boolean
+  nPredict?: number
+}): string[] {
+  const args: string[] = [
+    "-m", config.modelPath,
+    "--mmproj", config.mmprojPath,
+    "-c", String(config.ctxSize),
+    "-ngl", String(config.ngl),
+    "-t", String(config.threads),
+    "-b", String(config.batchSize),
+    "-ub", String(config.ubatchSize),
+    "--cache-type-k", config.cacheTypeK,
+    "--cache-type-v", config.cacheTypeV,
+  ]
+
+  if (config.flashAttn) {
+    args.push("--flash-attn", "on")
+  }
+
+  if (options.imagePath && existsSync(options.imagePath)) {
+    args.push("--image", options.imagePath)
+  }
+
+  if (options.audioPath && existsSync(options.audioPath)) {
+    args.push("--audio", options.audioPath)
+  }
+
+  if (options.prompt) {
+    args.push("-p", options.prompt)
+  }
+
+  if (options.nPredict !== undefined) {
+    args.push("-n", String(options.nPredict))
+  }
+
+  if (options.interactive && !options.prompt) {
+    args.push("-i")
+  }
+
+  return args
+}
+
+/** Determina el modelo recomendado según el modo */
+export function getRecommendedModel(mode: "text" | "image" | "audio" | "all"): ModelId {
+  switch (mode) {
+    case "text":
+      return "e2b_Q4_K_XL"
+    case "image":
+      return "e2b_Q4_K_XL"
+    case "audio":
+      return "e2b_Q4_K_XL"
+    case "all":
+      return "e4b_Q4_K_XL"
+    default:
+      return "e2b_Q4_K_XL"
+  }
+}

package/packages/core/src/gateway/llm-local/server.ts

@@ -0,0 +1,179 @@
+/**
+ * Hive Local LLM — WebSocket Server
+ 
+ */
+
+import type { ServerWebSocket } from "bun"
+import { existsSync } from "fs"
+import { llamaManager, type ServerMode } from "./manager"
+import type { ModelId } from "./downloader"
+
+interface WSData {
+  sessionId: string
+}
+
+interface GenerateRequest {
+  type: "generate"
+  prompt: string
+  model: ModelId
+  imagePath?: string
+  audioPath?: string
+  nPredict?: number
+}
+
+interface DownloadRequest {
+  type: "download"
+  model: ModelId
+}
+
+export type LLMMessage = GenerateRequest | DownloadRequest
+
+const sessions = new Map<string, ServerWebSocket<WSData>>()
+
+export async function handleLLMWebSocket(
+  ws: ServerWebSocket<WSData>,
+  message: string
+): Promise<void> {
+  let req: LLMMessage
+  try {
+    req = JSON.parse(message)
+  } catch {
+    ws.send(JSON.stringify({ type: "error", message: "JSON inválido" }))
+    return
+  }
+
+  if (req.type === "download") {
+    await handleDownload(ws, req)
+    return
+  }
+
+  if (req.type === "generate") {
+    await handleGenerate(ws, req)
+    return
+  }
+
+  ws.send(JSON.stringify({ type: "error", message: `Tipo desconocido: ${(req as any).type}` }))
+}
+
+async function handleDownload(
+  ws: ServerWebSocket<WSData>,
+  req: DownloadRequest
+): Promise<void> {
+  const { downloadModel, isModelDownloaded } = await import("./downloader")
+
+  if (isModelDownloaded(req.model)) {
+    ws.send(JSON.stringify({ type: "download_progress", model: req.model, percent: 100, done: true }))
+    return
+  }
+
+  try {
+    await downloadModel(req.model, (downloaded, total) => {
+      const percent = total > 0 ? Math.round((downloaded / total) * 100) : 0
+      ws.send(JSON.stringify({
+        type: "download_progress",
+        model: req.model,
+        percent,
+        downloaded,
+        total,
+        done: false,
+      }))
+    })
+
+    ws.send(JSON.stringify({ type: "download_progress", model: req.model, percent: 100, done: true }))
+  } catch (err) {
+    ws.send(JSON.stringify({
+      type: "error",
+      message: err instanceof Error ? err.message : "Error descargando modelo",
+    }))
+  }
+}
+
+async function handleGenerate(
+  ws: ServerWebSocket<WSData>,
+  req: GenerateRequest
+): Promise<void> {
+  try {
+    // Determinar modo (por ahora simplificado a TEXT, pero podríamos soportar IMAGE/AUDIO si el req lo pide)
+    const mode: ServerMode = req.imagePath ? "IMAGE" : (req.audioPath ? "AUDIO" : "TEXT")
+
+    // Asegurar que el servidor esté corriendo
+    const server = await llamaManager.start(mode, req.model)
+
+    ws.send(JSON.stringify({ type: "status", message: `Generando vía llama-server (${mode})...` }))
+
+    // Llamar a la API de llama-server (formato OpenAI)
+    const response = await fetch(`http://localhost:${server.port}/v1/chat/completions`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: req.model,
+        messages: [{ role: "user", content: req.prompt }],
+        stream: true,
+        max_tokens: req.nPredict || 512,
+      })
+    })
+
+    if (!response.ok) {
+      throw new Error(`llama-server respondió ${response.status}: ${await response.text()}`)
+    }
+
+    const reader = response.body?.getReader()
+    if (!reader) throw new Error("No se pudo obtener el reader de la respuesta")
+
+    const decoder = new TextDecoder()
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+
+        const chunk = decoder.decode(value, { stream: true })
+        const lines = chunk.split("\n")
+
+        for (const line of lines) {
+          const trimmed = line.trim()
+          if (!trimmed || !trimmed.startsWith("data: ")) continue
+
+          const dataStr = trimmed.slice(6)
+          if (dataStr === "[DONE]") break
+
+          try {
+            const data = JSON.parse(dataStr)
+            const token = data.choices[0]?.delta?.content
+            if (token) {
+              ws.send(JSON.stringify({ type: "token", text: token }))
+            }
+          } catch { /* ignore parse errors in chunks */ }
+        }
+      }
+    } finally {
+      reader.releaseLock()
+    }
+
+    ws.send(JSON.stringify({ type: "done" }))
+  } catch (err) {
+    ws.send(JSON.stringify({
+      type: "error",
+      message: err instanceof Error ? err.message : "Error en generación",
+    }))
+  }
+}
+
+/** HTTP handler para status de modelos */
+export async function handleLLMStatus(): Promise<Response> {
+  const { listLocalModels, isModelDownloaded } = await import("./downloader")
+  const { detectGPU } = await import("./detector")
+
+  const gpu = await detectGPU()
+  const models = listLocalModels()
+
+  return Response.json({
+    ok: true,
+    gpu: {
+      backend: gpu.backend,
+      deviceName: gpu.deviceName,
+      platform: gpu.platform,
+    },
+    models,
+  })
+}

package/packages/core/src/gateway/resolver.ts

@@ -0,0 +1,108 @@
+import { getDb } from "../storage/sqlite"
+
+export interface ResolveContextResult {
+  userId: string
+  agentId: string
+  isNewUser: boolean
+}
+
+export interface ResolveContextOptions {
+  channel: string
+  channelUserId: string
+}
+
+export function resolveContext(options: ResolveContextOptions): ResolveContextResult {
+  const { channel, channelUserId } = options
+  const db = getDb()
+
+  const identity = db
+    .query<any, [string, string]>(
+      "SELECT user_id FROM user_identities WHERE channel = ? AND channel_user_id = ?"
+    )
+    .get(channel, channelUserId)
+
+  let userId: string
+  let isNewUser = false
+
+  if (identity) {
+    userId = identity.user_id
+  } else {
+    // Sistema mono-usuario: reutilizar el usuario del onboarding
+    const existingUser = db
+      .query<any, []>("SELECT id FROM users ORDER BY created_at ASC LIMIT 1")
+      .get() as { id: string } | undefined
+
+    if (!existingUser) {
+      throw new Error("No user found in database. Please run the onboarding process first.")
+    }
+
+    userId = existingUser.id
+
+    // Vincular este canal al usuario existente (auto-link en el primer mensaje)
+    // INSERT OR REPLACE: si ya existe una fila (user_id, channel), actualiza channel_user_id
+    // con el valor real del canal (e.g. chat ID numérico de Telegram).
+    db.query(
+      "INSERT OR REPLACE INTO user_identities (user_id, channel, channel_user_id, linked_at) VALUES (?, ?, ?, ?)"
+    ).run(userId, channel, channelUserId, Math.floor(Date.now() / 1000))
+  }
+
+  const coordinatorAgent = db
+    .query<any, []>("SELECT id FROM agents WHERE role = 'coordinator' LIMIT 1")
+    .get()
+
+  const agentId = coordinatorAgent?.id || "bee"
+
+  return { userId, agentId, isNewUser }
+}
+
+export function getDefaultAgentId(): string {
+  const db = getDb()
+  const coordinatorAgent = db
+    .query<any, []>("SELECT id FROM agents WHERE role = 'coordinator' LIMIT 1")
+    .get()
+
+  return coordinatorAgent?.id || "bee"
+}
+
+export function getUserById(userId: string): any {
+  const db = getDb()
+  return db.query<any, [string]>("SELECT * FROM users WHERE id = ?").get(userId)
+}
+
+export function updateUserProfile(userId: string, updates: {
+  name?: string
+  language?: string
+  timezone?: string
+  occupation?: string
+  notes?: string
+}): void {
+  const db = getDb()
+  const setClauses: string[] = []
+  const values: any[] = []
+
+  if (updates.name !== undefined) {
+    setClauses.push("name = ?")
+    values.push(updates.name)
+  }
+  if (updates.language !== undefined) {
+    setClauses.push("language = ?")
+    values.push(updates.language)
+  }
+  if (updates.timezone !== undefined) {
+    setClauses.push("timezone = ?")
+    values.push(updates.timezone)
+  }
+  if (updates.occupation !== undefined) {
+    setClauses.push("occupation = ?")
+    values.push(updates.occupation)
+  }
+  if (updates.notes !== undefined) {
+    setClauses.push("notes = ?")
+    values.push(updates.notes)
+  }
+
+  if (setClauses.length > 0) {
+    values.push(userId)
+    db.query(`UPDATE users SET ${setClauses.join(", ")} WHERE id = ?`).run(...values)
+  }
+}