@johpaz/hive-agents 0.0.35 → 0.0.37

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

@@ -0,0 +1,271 @@
+import { existsSync, readdirSync } from "fs"
+import { join } from "path"
+import { homedir } from "os"
+import { installLlamaServer, downloadModel, listLocalModels, BIN_DIR, MODELS_DIR } from "../llm-local/downloader"
+import { llamaManager, type ServerMode } from "../llm-local/manager"
+import { getRecommendedModel } from "../llm-local/models"
+import { detectGPU } from "../llm-local/detector"
+// lmmManager se encarga de los procesos
+
+// Datos de LLM en HIVE_HOME/llm/
+const LLM_ROOT =
+  process.env.HIVE_LLM_ROOT ??
+  join(process.env.HIVE_HOME ?? join(homedir(), ".hive"), "llm-local")
+
+const BIN_DIR_PATH = join(LLM_ROOT, "bin")
+const MODELS_DIR_PATH = join(LLM_ROOT, "models")
+
+let installing = false
+let installLogs: string[] = []
+let downloadingModelId: string | null = null
+
+async function getInstalledStatus() {
+  const { LLAMA_CPP_DEFAULT_VER } = await import("../llm-local/detector")
+  const gpu = await detectGPU()
+  const ext = process.platform === "win32" ? ".exe" : ""
+  const binaryPath = join(BIN_DIR_PATH, `llama-${LLAMA_CPP_DEFAULT_VER}/llama-server${ext}`)
+  const binaryExists = existsSync(binaryPath)
+  const models = listLocalModels()
+  const anyModelExists = models.some(m => m.downloaded)
+  
+  const activeServers = llamaManager.getStatus()
+  const running = activeServers.length > 0
+  
+  return {
+    gpu,
+    binaryExists,
+    anyModelExists,
+    installed: binaryExists && anyModelExists,
+    running,
+    activeServers,
+    models
+  }
+}
+
+// Ya no usamos isRunning con fetch directo aquí, sino vía manager
+
+export async function handleGetLocalLLMStatus(
+  req: Request,
+  addCors: (r: Response, req: Request) => Response
+): Promise<Response> {
+  const status = await getInstalledStatus()
+  return addCors(
+    Response.json({ 
+      ...status,
+      installing,
+      downloadingModelId
+    }),
+    req
+  )
+}
+
+export async function handleGetLocalLLMLogs(
+  req: Request,
+  addCors: (r: Response, req: Request) => Response
+): Promise<Response> {
+  const mode = new URL(req.url).searchParams.get("mode") as ServerMode || "TEXT"
+  
+  // Return an SSE stream instead of a normal JSON response
+  const stream = new ReadableStream({
+    start(controller) {
+      const sendEvent = (data: any) => {
+        controller.enqueue(new TextEncoder().encode(`data: ${JSON.stringify(data)}\n\n`))
+      }
+      
+      // Send initial state
+      sendEvent({ logs: installLogs.slice(-100), serverLogs: llamaManager.getLogs(mode).slice(-100), llmRoot: LLM_ROOT })
+
+      // Create an interval to push new logs (or use EventEmitter if available)
+      let lastInstallLogCount = installLogs.length
+      let lastServerLogCount = llamaManager.getLogs(mode).length
+
+      const interval = setInterval(() => {
+        const currentInstallLogs = installLogs
+        const currentServerLogs = llamaManager.getLogs(mode)
+        
+        let hasChanges = false
+        const payload: any = {}
+        
+        if (currentInstallLogs.length > lastInstallLogCount) {
+          payload.logs = currentInstallLogs.slice(lastInstallLogCount)
+          lastInstallLogCount = currentInstallLogs.length
+          hasChanges = true
+        }
+        
+        if (currentServerLogs.length > lastServerLogCount) {
+          payload.serverLogs = currentServerLogs.slice(lastServerLogCount)
+          lastServerLogCount = currentServerLogs.length
+          hasChanges = true
+        }
+
+        if (hasChanges) {
+          sendEvent(payload)
+        }
+      }, 500) // Push changes every 500ms
+
+      req.signal.addEventListener("abort", () => {
+        clearInterval(interval)
+        controller.close()
+      })
+    }
+  })
+
+  const response = new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive"
+    }
+  })
+  
+  return addCors(response, req)
+}
+
+export async function handleInstallLocalLLM(
+  req: Request,
+  addCors: (r: Response, req: Request) => Response
+): Promise<Response> {
+  if (installing) {
+    return addCors(Response.json({ started: false, reason: "Ya hay una instalación en curso" }), req)
+  }
+
+  installing = true
+  installLogs = [`[${new Date().toISOString()}] Iniciando configuración de Local LLM...`]
+  installLogs.push(`  LLM_ROOT: ${LLM_ROOT}`)
+
+  // Background installation (solo binario, NO modelos)
+  ;(async () => {
+    try {
+      installLogs.push("Detectando GPU...")
+      const gpu = await detectGPU()
+      installLogs.push(`GPU detectada: ${gpu.deviceName || 'CPU'} (${gpu.backend})`)
+      
+      installLogs.push("Instalando llama-server oficial...")
+      await installLlamaServer()
+      installLogs.push(`[${new Date().toISOString()}] ✓ llama-server instalado`)
+      installLogs.push(`[${new Date().toISOString()}] Ahora descarga un modelo desde la sección de modelos para empezar a usar el LLM local.`)
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      installLogs.push(`[error] Falló la instalación: ${msg}`)
+      console.error(`[llm-local install] Error:`, err)
+    } finally {
+      installing = false
+    }
+  })()
+
+  return addCors(Response.json({ started: true }), req)
+}
+
+export async function handleDownloadLLMModel(
+  req: Request,
+  addCors: (r: Response, req: Request) => Response
+): Promise<Response> {
+  let body: { modelId?: any }
+  try {
+    body = await req.json()
+  } catch {
+    return addCors(Response.json({ error: "Body JSON inválido" }, { status: 400 }), req)
+  }
+
+  const { modelId } = body
+  if (!modelId) {
+    return addCors(Response.json({ error: "modelId requerido" }, { status: 400 }), req)
+  }
+
+  if (downloadingModelId) {
+    return addCors(Response.json({ error: "Ya hay una descarga en curso" }, { status: 409 }), req)
+  }
+
+  downloadingModelId = modelId
+  installLogs.push(`[${new Date().toISOString()}] Iniciando descarga de modelo: ${modelId}`)
+
+  // Background download
+  ;(async () => {
+    try {
+      await downloadModel(modelId, (d, t) => {
+        // Opcional: Podríamos emitir eventos por WS si quisiéramos progreso real en UI
+      })
+      installLogs.push(`✓ Modelo ${modelId} descargado exitosamente`)
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      installLogs.push(`[error] Error descargando ${modelId}: ${msg}`)
+    } finally {
+      downloadingModelId = null
+    }
+  })()
+
+  return addCors(Response.json({ started: true }), req)
+}
+
+export async function handleStartLocalLLM(
+  req: Request,
+  addCors: (r: Response, req: Request) => Response
+): Promise<Response> {
+  let body: { mode?: ServerMode; modelId?: string } = {}
+  try {
+    body = await req.json()
+  } catch { /* ignore if no body */ }
+
+  const mode = body.mode || "TEXT"
+  const modelId = body.modelId || getRecommendedModel(mode.toLowerCase() as any)
+
+  const status = await getInstalledStatus()
+  if (!status.installed && !status.binaryExists) {
+     return addCors(
+      Response.json({ started: false, reason: "LLM no está instalado (binario faltante)." }, { status: 400 }),
+      req
+    )
+  }
+
+  try {
+    installLogs.push(`[llm-server] Iniciando servidor en modo ${mode} con modelo ${modelId}...`)
+    await llamaManager.start(mode, modelId as any)
+    installLogs.push(`[llm-server] Servidor ${mode} iniciado correctamente.`)
+    return addCors(Response.json({ started: true, mode }), req)
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    installLogs.push(`[error] Servidor LLM falló al iniciar: ${msg}`)
+    return addCors(Response.json({ started: false, reason: msg }), req)
+  }
+}
+
+export async function handleStopLocalLLM(
+  req: Request,
+  addCors: (r: Response, req: Request) => Response
+): Promise<Response> {
+  let body: { mode?: ServerMode } = {}
+  try {
+    body = await req.json()
+  } catch { /* ignore */ }
+
+  if (body.mode) {
+    llamaManager.stop(body.mode)
+  } else {
+    llamaManager.stopAll()
+  }
+  
+  return addCors(Response.json({ stopped: true }), req)
+}
+
+/**
+ * Verifica el estado del LLM local al iniciar el gateway.
+ * NO auto-inicia el servidor ni descarga nada — el usuario debe hacerlo manualmente.
+ */
+export async function initializeLocalLLM() {
+  try {
+    const status = await getInstalledStatus()
+    if (status.binaryExists) {
+      console.log(`[llm-local] ✓ Binario llama-server encontrado.`)
+      if (status.anyModelExists) {
+        console.log(`[llm-local] ✓ Modelos disponibles: ${status.models.filter(m => m.downloaded).map(m => m.id).join(", ")}`)
+        console.log(`[llm-local] ℹ️ Servidor NO auto-iniciado. Usa la UI para iniciar cuando lo necesites.`)
+      } else {
+        console.log(`[llm-local] ⚠️ No hay modelos descargados. Descarga uno desde la UI.`)
+      }
+    } else {
+      console.log(`[llm-local] ℹ️ llama-server no instalado. Instálalo desde la UI si deseas usar LLM local.`)
+    }
+  } catch (err) {
+    console.error(`[llm-local] Error verificando estado: ${err instanceof Error ? err.message : String(err)}`)
+  }
+}

package/packages/core/src/gateway/routes/mcp.ts

@@ -0,0 +1,319 @@
+import { getDb } from "../../storage/sqlite.ts"
+import { storeMcpHeaders, loadMcpHeaders, deleteMcpSecrets } from "../../storage/crypto.ts"
+import { logger } from "../../utils/logger.ts"
+
+const mcpLog = logger.child("mcp:api")
+
+export async function handleGetMcpServers(
+  req: Request,
+  addCorsHeaders: (r: Response, req: Request) => Response,
+  mcpManager?: any
+): Promise<Response> {
+  const db = getDb()
+
+  // Get real-time server status from MCP manager
+  const mcpServers = new Map<string, { status: string; tools: any[] }>()
+  if (mcpManager) {
+    try {
+      const servers = mcpManager.listServers?.() || []
+      mcpLog.info(`[GET] MCP Manager returned ${servers.length} servers:`, servers.map((s: any) => `${s.name}:${s.status}`))
+      for (const s of servers) {
+        mcpServers.set(s.name, {
+          status: s.status,
+          tools: s.tools || [],
+        })
+      }
+    } catch (e) {
+      mcpLog.warn(`Failed to get MCP servers: ${(e as Error).message}`)
+    }
+  } else {
+    mcpLog.warn(`[GET] No MCP Manager provided`)
+  }
+
+  // Get all servers from database
+  const dbServers = db.query(`
+    SELECT * FROM mcp_servers ORDER BY name
+  `).all() as Record<string, unknown>[]
+
+  // Combine DB info with real-time status from MCP manager
+  const allServers = await Promise.all(dbServers.map(async s => {
+    // Try to find matching server in MCP Manager (by name or normalized name)
+    const normalizedName = (s.name as string).toLowerCase().replace(/[^a-z0-9-]/g, '-')
+    const mcpServer = mcpServers.get(s.name as string) || mcpServers.get(normalizedName)
+    const isEnabled = s.enabled === 1
+
+    // Redact headers for safe UI display
+    const rawHeaders = await loadMcpHeaders(s.id as string)
+    const headers = Object.keys(rawHeaders).length > 0
+      ? Object.fromEntries(
+          Object.entries(rawHeaders).map(([k, v]) => [
+            k,
+            k.toLowerCase().includes("auth") ||
+              k.toLowerCase().includes("token") ||
+              k.toLowerCase().includes("key")
+              ? `${(v as string).slice(0, 4)}••••••••`
+              : v,
+          ])
+        )
+      : undefined
+
+    return {
+      id: s.id,
+      name: s.name,
+      enabled: isEnabled,
+      status: mcpServer?.status || (isEnabled ? "disconnected" : "disconnected"),
+      config: {
+        transport: s.transport,
+        command: s.command,
+        args: s.args ? JSON.parse(s.args as string) : [],
+        url: s.url,
+        headers,
+        enabled: isEnabled
+      },
+      tools_count: mcpServer?.tools.length || s.tools_count || 0,
+      tools: mcpServer?.tools || [],
+    }
+  }))
+
+  return addCorsHeaders(Response.json(allServers), req)
+}
+
+export async function handleCreateMcpServer(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
+  const body = await req.json().catch(() => ({}))
+  const db = getDb()
+
+  if (!body.name || !body.config) {
+    return addCorsHeaders(new Response("Missing name or config", { status: 400 }), req)
+  }
+
+  mcpLog.info(`Creating MCP server: ${body.name}`)
+
+  // Generate unique ID (name-based for consistency)
+  const serverId = body.name.toLowerCase().replace(/[^a-z0-9-]/g, '-')
+
+  // Save to database
+  db.query(`
+    INSERT INTO mcp_servers(id, name, transport, command, args, url, enabled, builtin, status)
+    VALUES(?, ?, ?, ?, ?, ?, ?, 0, 'disconnected')
+  `).run(
+    serverId,
+    body.name,
+    body.config.transport || "stdio",
+    body.config.command || null,
+    body.config.args ? JSON.stringify(body.config.args) : null,
+    body.config.url || null,
+    body.config.enabled !== false ? 1 : 0
+  )
+
+  if (body.config.headers) {
+    await storeMcpHeaders(serverId, body.config.headers)
+  }
+
+  return addCorsHeaders(Response.json({ success: true, id: serverId }), req)
+}
+
+export async function handleDeleteMcpServer(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
+  const url = new URL(req.url)
+  // Extract server name from path: /api/mcp/servers/{name}
+  const parts = url.pathname.split("/").filter(Boolean)
+  const serverName = parts[parts.length - 1]
+
+  if (!serverName || serverName === "servers") {
+    return addCorsHeaders(Response.json({ success: false, error: "server name required" }), req)
+  }
+
+  // Delete from DB and keychain
+  const row = getDb().query(`SELECT id FROM mcp_servers WHERE id = ? OR name = ?`).get(serverName, serverName) as { id: string } | undefined
+  getDb().query(`DELETE FROM mcp_servers WHERE id = ? OR name = ?`).run(serverName, serverName)
+  if (row?.id) await deleteMcpSecrets(row.id)
+
+  return addCorsHeaders(Response.json({ success: true }), req)
+}
+
+export async function handleGetMcpServerDetail(
+  req: Request,
+  addCorsHeaders: (r: Response, req: Request) => Response,
+  serverId: string
+): Promise<Response> {
+  const db = getDb()
+  const server = db.query(`SELECT * FROM mcp_servers WHERE id = ? OR name = ?`).get(serverId, serverId) as Record<string, unknown> | undefined
+
+  if (!server) {
+    return addCorsHeaders(new Response("Server not found", { status: 404 }), req)
+  }
+
+  // Load headers — unredacted, for editing
+  const rawDetail = await loadMcpHeaders(server.id as string)
+  const headers = Object.keys(rawDetail).length > 0 ? rawDetail as Record<string, string> : undefined
+
+  return addCorsHeaders(Response.json({
+    id: server.id,
+    name: server.name,
+    transport: server.transport,
+    command: server.command ?? null,
+    args: server.args ? JSON.parse(server.args as string) : [],
+    url: server.url ?? null,
+    headers,
+    enabled: server.enabled === 1,
+    builtin: server.builtin === 1,
+    status: server.status,
+    tools_count: server.tools_count ?? 0,
+  }), req)
+}
+
+export async function handleUpdateMcpServer(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
+  const url = new URL(req.url)
+  // Extract server name from path: /api/mcp/servers/{name}
+  const parts = url.pathname.split("/").filter(Boolean)
+  const serverName = parts[parts.length - 1]
+  const body = await req.json().catch(() => ({}))
+  const db = getDb()
+
+  if (!serverName || serverName === "servers") {
+    return addCorsHeaders(new Response("Missing server name", { status: 400 }), req)
+  }
+
+  mcpLog.info(`Updating MCP server: ${serverName}`)
+
+  const updates: string[] = []
+  const params: unknown[] = []
+
+  if (body.transport !== undefined) {
+    updates.push("transport = ?")
+    params.push(body.transport)
+  }
+  if (body.name !== undefined) {
+    updates.push("name = ?")
+    params.push(body.name)
+  }
+  if (body.command !== undefined) {
+    updates.push("command = ?")
+    params.push(body.command)
+  }
+  if (body.args !== undefined) {
+    updates.push("args = ?")
+    params.push(JSON.stringify(body.args))
+  }
+  if (body.url !== undefined) {
+    updates.push("url = ?")
+    params.push(body.url)
+  }
+  if (body.enabled !== undefined) {
+    updates.push("enabled = ?")
+    params.push(body.enabled ? 1 : 0)
+  }
+  if (updates.length > 0) {
+    params.push(serverName)
+    params.push(serverName)
+    db.query(`UPDATE mcp_servers SET ${updates.join(", ")} WHERE id = ? OR name = ?`).run(...params as any[])
+  }
+
+  if (body.headers) {
+    await storeMcpHeaders(serverName, body.headers)
+  }
+
+  return addCorsHeaders(Response.json({ success: true }), req)
+}
+
+export async function handleStartMcpServer(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
+  const url = new URL(req.url)
+  const serverId = url.pathname.split("/").pop()
+
+  if (!serverId) {
+    return addCorsHeaders(Response.json({ success: false, error: "serverId required" }), req)
+  }
+
+  getDb().query(`UPDATE mcp_servers SET enabled = 1 WHERE id = ?`).run(serverId)
+
+  return addCorsHeaders(Response.json({ success: true, serverId, enabled: true }), req)
+}
+
+export async function handleGetMcpServerTools(
+  req: Request,
+  addCorsHeaders: (r: Response, req: Request) => Response,
+  serverName: string,
+  mcpManager?: any
+): Promise<Response> {
+  if (!mcpManager) {
+    return addCorsHeaders(Response.json([]), req)
+  }
+
+  const tools = mcpManager.getServerTools(serverName)
+  return addCorsHeaders(Response.json(tools), req)
+}
+
+export async function handleToggleMcpServer(
+  req: Request,
+  addCorsHeaders: (r: Response, req: Request) => Response,
+  mcpId: string
+): Promise<Response> {
+  const body = await req.json().catch(() => ({}))
+  const { active } = body
+
+  if (active === undefined) {
+    return addCorsHeaders(Response.json({ success: false, error: "Missing active field", message: "Falta el campo 'active'" }, { status: 400 }), req)
+  }
+
+  getDb().query(`UPDATE mcp_servers SET active = ?, enabled = ? WHERE id = ?`).run(active ? 1 : 0, active ? 1 : 0, mcpId)
+
+  return addCorsHeaders(Response.json({ success: true, active, message: active ? "Servidor MCP activado" : "Servidor MCP desactivado" }), req)
+}
+
+export async function handleMcpServerAction(
+  req: Request,
+  addCorsHeaders: (r: Response, req: Request) => Response,
+  serverName: string,
+  action: "connect" | "disconnect",
+  mcpManager?: any
+): Promise<Response> {
+  if (!mcpManager) {
+    return addCorsHeaders(new Response("MCP is disabled", { status: 404 }), req)
+  }
+
+  const db = getDb()
+
+  if (action === "connect") {
+    // Check if server exists and is enabled in DB
+    const dbServer = db.query(`SELECT * FROM mcp_servers WHERE name = ? AND enabled = 1`).get(serverName)
+    if (!dbServer) {
+      return new Response("Server not found or disabled", { status: 400 })
+    }
+
+    await mcpManager.connectServer(serverName)
+
+    // Update tools count after connection
+    const tools = mcpManager.getServerTools(serverName) || []
+    db.query(`UPDATE mcp_servers SET status = ?, tools_count = ? WHERE name = ?`).run("connected", tools.length, serverName)
+
+    return addCorsHeaders(Response.json({ success: true, tools_count: tools.length }), req)
+  }
+
+  if (action === "disconnect") {
+    await mcpManager.disconnectServer(serverName)
+    return addCorsHeaders(Response.json({ success: true }), req)
+  }
+
+  return addCorsHeaders(new Response("Invalid action", { status: 400 }), req)
+}
+
+/**
+ * Get tools for a specific MCP server
+ * Note: Tools are loaded from MCP Manager at runtime, not from DB
+ */
+export async function handleGetMCPServerTools(
+  req: Request,
+  addCorsHeaders: (r: Response, req: Request) => Response,
+  serverId: string,
+  mcpManager?: any
+): Promise<Response> {
+  if (!mcpManager) {
+    return addCorsHeaders(new Response("MCP is disabled", { status: 404 }), req);
+  }
+
+  const tools = mcpManager.getServerTools(serverId) || [];
+
+  return addCorsHeaders(Response.json({ tools }), req);
+}
+
+// Note: handleToggleMCPTool and handleDeleteMCPTool removed
+// MCP tools are not stored in DB - they are loaded at runtime from servers