@johpaz/hive-agents 0.0.35 → 0.0.36

package/packages/core/src/gateway/tts/src/models.ts

@@ -0,0 +1,50 @@
+/**
+ * Hive TTS — Índice de modelos disponibles
+ * Modelos en español desde HuggingFace
+ */
+
+export interface TTSModel {
+  id: string
+  name: string
+  language: string
+  quality: "low" | "medium" | "high"
+  size: string
+  modelUrl: string
+  configUrl: string
+}
+
+const HF_BASE = "https://huggingface.co/spaces/HirCoir/Piper-TTS-Spanish/resolve/main"
+
+export const TTS_MODELS: TTSModel[] = [
+  {
+    id: "es_MX-claude-14947-epoch-high",
+    name: "Claude (México)",
+    language: "es-MX",
+    quality: "high",
+    size: "63.1 MB",
+    modelUrl: `${HF_BASE}/es_MX-claude-14947-epoch-high.onnx`,
+    configUrl: `${HF_BASE}/es_MX-claude-14947-epoch-high.onnx.json`,
+  },
+  {
+    id: "es_MX-cortana-19669-epoch-high",
+    name: "Cortana (México)",
+    language: "es-MX",
+    quality: "high",
+    size: "63.1 MB",
+    modelUrl: `${HF_BASE}/es_MX-cortana-19669-epoch-high.onnx`,
+    configUrl: `${HF_BASE}/es_MX-cortana-19669-epoch-high.onnx.json`,
+  },
+  {
+    id: "es_MX-gevy-10196-epoch-high",
+    name: "Gevy (México)",
+    language: "es-MX",
+    quality: "high",
+    size: "63.1 MB",
+    modelUrl: `${HF_BASE}/es_MX-gevy-10196-epoch-high.onnx`,
+    configUrl: `${HF_BASE}/es_MX-gevy-10196-epoch-high.onnx.json`,
+  },
+]
+
+export function getModelById(id: string): TTSModel | undefined {
+  return TTS_MODELS.find((m) => m.id === id)
+}

package/packages/core/src/gateway/tts/src/server.ts

@@ -0,0 +1,252 @@
+#!/usr/bin/env bun
+/**
+ * Hive TTS Server
+ * HTTP server local que expone Piper TTS como API REST
+ * Puerto: 5500 (configurable con env TTS_PORT)
+ *
+ * GET  /health   → { ok: true, voice: string, voices: string[] }
+ * POST /tts      → audio/wav binary
+ * GET  /voices   → { voices: string[] }
+ */
+
+import { existsSync, readdirSync, readFileSync } from "fs"
+import { join } from "path"
+import { homedir } from "os"
+import { detectPlatform, getPiperBinaryName, DEFAULT_VOICE } from "./detect.js"
+
+const log = {
+  info: (msg: string) => console.log(`[TTS] ${msg}`),
+  warn: (msg: string) => console.warn(`[TTS] ${msg}`),
+  error: (msg: string) => console.error(`[TTS] ${msg}`),
+}
+
+const TTS_ROOT =
+  process.env.HIVE_TTS_ROOT ??
+  join(process.env.HIVE_HOME ?? join(homedir(), ".hive"), "tts")
+const BIN_DIR = join(TTS_ROOT, "bin")
+const VOICES_DIR = join(TTS_ROOT, "voices")
+const PORT = Number(process.env.TTS_PORT ?? 5500)
+const DEFAULT_VOICE_ENV = process.env.TTS_VOICE ?? DEFAULT_VOICE
+
+function getPiperPath(): string {
+  const platform = detectPlatform()
+  const binaryName = getPiperBinaryName(platform)
+  const binaryPath = join(BIN_DIR, binaryName)
+
+  if (!existsSync(binaryPath)) {
+    throw new Error("Piper no instalado. Ejecuta: bun run src/install.ts")
+  }
+  return binaryPath
+}
+
+function listVoices(): string[] {
+  if (!existsSync(VOICES_DIR)) return []
+  return readdirSync(VOICES_DIR)
+    .filter((f) => f.endsWith(".onnx"))
+    .map((f) => f.replace(".onnx", ""))
+}
+
+async function synthesize(text: string, voice: string): Promise<ArrayBuffer> {
+  const piperPath = getPiperPath()
+  let modelPath = join(VOICES_DIR, `${voice}.onnx`)
+  let configPath = join(VOICES_DIR, `${voice}.onnx.json`)
+
+  if (!existsSync(modelPath)) {
+    console.warn(`[TTS] Voz no encontrada: ${voice}. Usando por defecto: ${DEFAULT_VOICE}`);
+    voice = DEFAULT_VOICE;
+    modelPath = join(VOICES_DIR, `${voice}.onnx`);
+    configPath = join(VOICES_DIR, `${voice}.onnx.json`);
+    
+    if (!existsSync(modelPath)) {
+      throw new Error(`Ni siquiera la voz por defecto se encuentra: ${voice}`);
+    }
+  }
+
+  // Leer configuración del modelo para obtener parámetros de inferencia
+  let lengthScale = 0.95      // Más lento = más natural
+  let noiseScale = 0.6        // Menos variación = más consistente
+  let noiseW = 0.75           // Más suave = menos artefactos
+  let sentenceSilence = 0.2   // Pausa entre frases para naturalidad
+
+  if (existsSync(configPath)) {
+    try {
+      const config = JSON.parse(readFileSync(configPath, "utf-8"))
+      const inference = config.inference || {}
+
+      // Usar valores del modelo con ajustes para mejorar naturalidad
+      lengthScale = (inference.length_scale ?? 1) * 0.95
+      noiseScale = (inference.noise_scale ?? 0.667) * 0.9
+      noiseW = (inference.noise_w ?? 0.8) * 0.95
+    } catch (err) {
+      log.warn(`No se pudo leer configuración del modelo: ${err}`)
+    }
+  }
+
+  // Sobrescribir con variables de entorno si existen
+  lengthScale = Number(process.env.PIPER_LENGTH_SCALE ?? lengthScale)
+  noiseScale = Number(process.env.PIPER_NOISE_SCALE ?? noiseScale)
+  noiseW = Number(process.env.PIPER_NOISE_W ?? noiseW)
+  sentenceSilence = Number(process.env.PIPER_SENTENCE_SILENCE ?? sentenceSilence)
+
+  const args = [
+    piperPath,
+    "--model", modelPath,
+    "--output-raw",
+    "--length_scale", String(lengthScale),
+    "--noise_scale", String(noiseScale),
+    "--noise_w", String(noiseW),
+    "--sentence_silence", String(sentenceSilence),
+  ]
+
+  const proc = Bun.spawn(
+    args,
+    {
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    }
+  )
+
+  proc.stdin.write(new TextEncoder().encode(text))
+  proc.stdin.end()
+
+  const [audioBuffer, exitCode] = await Promise.all([
+    new Response(proc.stdout).arrayBuffer(),
+    proc.exited,
+  ])
+
+  if (exitCode !== 0) {
+    const errText = await new Response(proc.stderr).text()
+    throw new Error(`Piper error (exit ${exitCode}): ${errText}`)
+  }
+
+  // --output-raw devuelve PCM 16-bit LE 22050Hz mono — envolver en WAV header
+  return wrapInWav(audioBuffer, 22050, 1, 16)
+}
+
+function wrapInWav(
+  pcm: ArrayBuffer,
+  sampleRate: number,
+  channels: number,
+  bitsPerSample: number
+): ArrayBuffer {
+  const dataSize = pcm.byteLength
+  const header = new ArrayBuffer(44)
+  const view = new DataView(header)
+
+  const writeStr = (offset: number, str: string) => {
+    for (let i = 0; i < str.length; i++)
+      view.setUint8(offset + i, str.charCodeAt(i))
+  }
+
+  writeStr(0, "RIFF")
+  view.setUint32(4, 36 + dataSize, true)
+  writeStr(8, "WAVE")
+  writeStr(12, "fmt ")
+  view.setUint32(16, 16, true)
+  view.setUint16(20, 1, true) // PCM
+  view.setUint16(22, channels, true)
+  view.setUint32(24, sampleRate, true)
+  view.setUint32(28, (sampleRate * channels * bitsPerSample) / 8, true)
+  view.setUint16(32, (channels * bitsPerSample) / 8, true)
+  view.setUint16(34, bitsPerSample, true)
+  writeStr(36, "data")
+  view.setUint32(40, dataSize, true)
+
+  const wav = new Uint8Array(44 + dataSize)
+  wav.set(new Uint8Array(header), 0)
+  wav.set(new Uint8Array(pcm), 44)
+  return wav.buffer
+}
+
+const CORS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type",
+}
+
+/**
+ * Inicia el servidor TTS en-proceso.
+ * Exportado para que el gateway pueda llamarlo directamente
+ * sin necesidad de spawnar un subproceso externo.
+ */
+export function startTTSServer(opts?: { port?: number }): ReturnType<typeof Bun.serve> {
+  const listenPort = opts?.port ?? PORT
+
+  const server = Bun.serve({
+    port: listenPort,
+    async fetch(req) {
+      const url = new URL(req.url)
+
+      if (req.method === "OPTIONS") {
+        return new Response(null, { status: 204, headers: CORS })
+      }
+
+      if (req.method === "GET" && url.pathname === "/health") {
+        return Response.json(
+          { ok: true, voice: DEFAULT_VOICE_ENV, voices: listVoices() },
+          { headers: CORS }
+        )
+      }
+
+      if (req.method === "GET" && url.pathname === "/voices") {
+        return Response.json({ voices: listVoices() }, { headers: CORS })
+      }
+
+      if (req.method === "POST" && url.pathname === "/tts") {
+        let body: { text?: string; voice?: string }
+        try {
+          body = await req.json()
+        } catch {
+          return Response.json(
+            { error: "Body JSON inválido" },
+            { status: 400, headers: CORS }
+          )
+        }
+
+        const { text, voice = DEFAULT_VOICE_ENV } = body
+
+        if (!text || typeof text !== "string" || text.trim().length === 0) {
+          return Response.json(
+            { error: "Campo 'text' requerido" },
+            { status: 400, headers: CORS }
+          )
+        }
+
+        if (text.length > 2000) {
+          return Response.json(
+            { error: "Texto demasiado largo (máx 2000 chars)" },
+            { status: 400, headers: CORS }
+          )
+        }
+
+        try {
+          const audio = await synthesize(text.trim(), voice)
+          return new Response(audio, {
+            headers: {
+              ...CORS,
+              "Content-Type": "audio/wav",
+              "Content-Length": String(audio.byteLength),
+            },
+          })
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Error interno"
+          return Response.json({ error: message }, { status: 500, headers: CORS })
+        }
+      }
+
+      return Response.json({ error: "Not found" }, { status: 404, headers: CORS })
+    },
+  })
+
+  log.info(`Hive TTS Server escuchando en http://localhost:${listenPort}`)
+  log.info(`Voz por defecto: ${DEFAULT_VOICE_ENV}`)
+  log.info(`Voces disponibles: ${listVoices().join(", ") || "ninguna (ejecuta install.ts primero)"}`)
+  return server
+}
+
+// Ejecución directa: bun run src/server.ts
+// @ts-ignore
+if (import.meta.main) {
+  startTTSServer()
+}

package/packages/core/src/heartbeat/index.ts

@@ -0,0 +1,157 @@
+import type { Config } from "../config/loader.ts";
+import { logger } from "../utils/logger.ts";
+
+export interface HealthStatus {
+  status: "healthy" | "degraded" | "unhealthy";
+  checks: Record<string, {
+    status: "ok" | "warning" | "error";
+    message?: string;
+    latency?: number;
+  }>;
+  uptime: number;
+  lastCheck: Date;
+}
+
+export interface HeartbeatOptions {
+  intervalMs?: number;
+  onHealthChange?: (status: HealthStatus) => void;
+}
+
+type HealthCheck = () => Promise<{
+  status: "ok" | "warning" | "error";
+  message?: string;
+  latency?: number;
+}>;
+
+export class Heartbeat {
+  private intervalMs: number;
+  private checks: Map<string, HealthCheck> = new Map();
+  private intervalId: Timer | null = null;
+  private startTime: Date;
+  private lastStatus: HealthStatus | null = null;
+  private onHealthChange?: (status: HealthStatus) => void;
+  private log = logger.child("heartbeat");
+
+  constructor(_config: Config, options: HeartbeatOptions = {}) {
+    this.intervalMs = options.intervalMs ?? 30000;
+    this.onHealthChange = options.onHealthChange;
+    this.startTime = new Date();
+  }
+
+  registerCheck(name: string, check: HealthCheck): void {
+    this.checks.set(name, check);
+    this.log.debug(`Registered health check: ${name}`);
+  }
+
+  removeCheck(name: string): boolean {
+    return this.checks.delete(name);
+  }
+
+  async runChecks(): Promise<HealthStatus> {
+    const checks: HealthStatus["checks"] = {};
+    let overallStatus: "healthy" | "degraded" | "unhealthy" = "healthy";
+
+    for (const [name, check] of this.checks) {
+      try {
+        const start = Date.now();
+        const result = await check();
+        const latency = Date.now() - start;
+
+        checks[name] = {
+          status: result.status,
+          message: result.message,
+          latency: result.latency ?? latency,
+        };
+
+        if (result.status === "warning" && overallStatus === "healthy") {
+          overallStatus = "degraded";
+        } else if (result.status === "error") {
+          overallStatus = "unhealthy";
+        }
+      } catch (error) {
+        checks[name] = {
+          status: "error",
+          message: (error as Error).message,
+        };
+        overallStatus = "unhealthy";
+      }
+    }
+
+    const status: HealthStatus = {
+      status: overallStatus,
+      checks,
+      uptime: Date.now() - this.startTime.getTime(),
+      lastCheck: new Date(),
+    };
+
+    const prevStatus = this.lastStatus?.status;
+    if (prevStatus && prevStatus !== overallStatus) {
+      this.log.info(`Health status changed: ${prevStatus} -> ${overallStatus}`);
+      this.onHealthChange?.(status);
+    }
+
+    this.lastStatus = status;
+    return status;
+  }
+
+  start(): void {
+    if (this.intervalId) {
+      this.log.warn("Heartbeat already running");
+      return;
+    }
+
+    this.runChecks();
+
+    this.intervalId = setInterval(async () => {
+      await this.runChecks();
+    }, this.intervalMs);
+
+    this.log.info(`Heartbeat started (interval: ${this.intervalMs}ms)`);
+  }
+
+  stop(): void {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+      this.log.info("Heartbeat stopped");
+    }
+  }
+
+  getStatus(): HealthStatus | null {
+    return this.lastStatus;
+  }
+
+  isRunning(): boolean {
+    return this.intervalId !== null;
+  }
+}
+
+export function createHeartbeat(config: Config, options?: HeartbeatOptions): Heartbeat {
+  const heartbeat = new Heartbeat(config, options);
+
+  heartbeat.registerCheck("memory", async () => {
+    const memUsage = process.memoryUsage();
+    const heapUsedMB = Math.round(memUsage.heapUsed / 1024 / 1024);
+    const heapTotalMB = Math.round(memUsage.heapTotal / 1024 / 1024);
+    const ratio = memUsage.heapUsed / memUsage.heapTotal;
+
+    if (ratio > 0.9) {
+      return {
+        status: "error",
+        message: `Memory critically high: ${heapUsedMB}/${heapTotalMB}MB`,
+      };
+    } else if (ratio > 0.75) {
+      return {
+        status: "warning",
+        message: `Memory usage high: ${heapUsedMB}/${heapTotalMB}MB`,
+      };
+    }
+
+    return {
+      status: "ok",
+      message: `${heapUsedMB}/${heapTotalMB}MB used`,
+    };
+  });
+
+  return heartbeat;
+}

package/packages/core/src/index.ts

@@ -0,0 +1,56 @@
+// Gateway
+export * from "./gateway/index.ts";
+export * from "./gateway/server.ts";
+
+// Agent (core functionality)
+export * from "./agent/service.ts";
+export * from "./agent/agent-loop.ts";
+export * from "./agent/context-compiler.ts";
+export * from "./agent/prompt-builder.ts";
+export * from "./agent/conversation-store.ts";
+export * from "./agent/tool-selector.ts";
+export * from "./agent/skill-selector.ts";
+export * from "./agent/playbook-selector.ts";
+export * from "./agent/llm-client.ts";
+
+// Channels
+export * from "./channels/index.ts";
+export * from "./channels/manager.ts";
+export * from "./channels/base.ts";
+export * from "./channels/telegram.ts";
+export * from "./channels/discord.ts";
+export * from "./channels/whatsapp.ts";
+export * from "./channels/slack.ts";
+export * from "./channels/webchat.ts";
+
+// Storage
+export * from "./storage/sqlite.ts";
+export * from "./storage/schema.ts";
+export * from "./storage/seed.ts";
+export * from "./storage/crypto.ts";
+export * from "./storage/onboarding.ts";
+
+// Tools (main index)
+export { createAllTools, createToolsByCategory } from "./tools/index.ts";
+export type { Tool, ToolResult } from "./tools/types.ts";
+export * from "./tool-runtime/index.ts";
+
+// Config
+export * from "./config/index.ts";
+
+// Utils
+export * from "./utils/logger.ts";
+export { retry } from "./utils/retry.ts";
+
+// Other core modules
+export * from "./security/index.ts";
+export * from "./heartbeat/index.ts";
+export * from "./events/event-bus.ts";
+export * from "./events/agent-bus.ts";
+export * from "./state/store.ts";
+export * from "./resilience/circuit-breaker.ts";
+export * from "./plugins/index.ts";
+export * from "./canvas/index.ts";
+
+// Re-export native-tools types
+export type { Tool as NativeTool, ToolResult as NativeToolResult } from "./agent/native-tools.ts";

package/packages/core/src/mcp/hot-reload.ts

@@ -0,0 +1,148 @@
+/**
+ * MCP Hot Reload
+ *
+ * Watches for MCP server changes in DB and updates MCP Manager automatically
+ * 
+ * Architecture: Direct Connection
+ * - MCP servers are tracked in DB (mcp_servers table)
+ * - MCP tools are loaded at runtime from connected servers (not stored in DB)
+ */
+
+import { getDb } from "../storage/sqlite";
+import { logger } from "../utils/logger";
+import { loadMcpHeaders } from "../storage/crypto";
+import { syncMCPToolsToDB, syncMCPToolsToFTS, clearMCPToolsFromDB } from "./tool-sync";
+import type { MCPClientManager } from "@johpaz/hive-agents-mcp";
+
+const log = logger.child("mcp:hot-reload");
+
+let _watchInterval: Timer | null = null;
+let _lastKnownServers = new Set<string>();
+
+/**
+ * Start watching for MCP server changes
+ * Checks every 2 seconds for new/removed servers
+ */
+export function startMCPHotReload(mcpManager: MCPClientManager): void {
+  if (_watchInterval) {
+    log.warn("MCP Hot Reload already running");
+    return;
+  }
+
+  log.info("Starting MCP Hot Reload watcher (2s interval)");
+
+  // Initial sync - sync all currently connected servers
+  syncMCPServers(mcpManager).then(() => {
+    log.info("Initial MCP server sync complete");
+  }).catch(err => {
+    log.error(`Initial MCP server sync failed: ${err.message}`);
+  });
+
+  // Watch for changes
+  _watchInterval = setInterval(() => {
+    syncMCPServers(mcpManager);
+  }, 2000);
+}
+
+/**
+ * Stop watching
+ */
+export function stopMCPHotReload(): void {
+  if (_watchInterval) {
+    clearInterval(_watchInterval);
+    _watchInterval = null;
+    log.info("MCP Hot Reload stopped");
+  }
+}
+
+/**
+ * Sync MCP servers from DB to MCP Manager
+ * Note: Only server status is tracked, tools are loaded at runtime
+ */
+async function syncMCPServers(mcpManager: MCPClientManager): Promise<void> {
+  try {
+    const db = getDb();
+    const dbServers = db.query(`SELECT * FROM mcp_servers WHERE enabled = 1`).all() as Record<string, any>[];
+
+    const currentServerNames = new Set(dbServers.map(s => s.id || s.name));
+
+    // Detect new servers
+    for (const server of dbServers) {
+      const serverName = server.id || server.name;
+
+      if (!_lastKnownServers.has(serverName)) {
+        log.info(`New MCP server detected: ${serverName} - connecting...`);
+
+        try {
+          const mcpServerConfig: any = {
+            transport: server.transport,
+            command: server.command,
+            args: server.args ? JSON.parse(server.args) : [],
+            url: server.url,
+            enabled: true,
+          };
+
+          const mcpHeaders = await loadMcpHeaders(server.id || server.name);
+          if (Object.keys(mcpHeaders).length > 0) {
+            mcpServerConfig.headers = mcpHeaders;
+          }
+
+          // Update MCP Manager config (auto-connects new servers)
+          const currentConfig = (mcpManager as any).config || { servers: {} };
+          await mcpManager.updateConfig({
+            ...currentConfig,
+            servers: {
+              ...currentConfig.servers,
+              [serverName]: mcpServerConfig,
+            },
+          });
+
+          // Wait a bit for connection to establish
+          await new Promise(resolve => setTimeout(resolve, 500));
+
+          // Get tools count and update status
+          const tools = mcpManager.getServerTools(serverName) || [];
+          db.query(`UPDATE mcp_servers SET status = ?, tools_count = ? WHERE id = ?`).run("connected", tools.length, serverName);
+
+          // Persist MCP tool definitions to DB and FTS5
+          // Use server.name (human-readable) for mcpToolId consistency with context-compiler
+          syncMCPToolsToDB(server.id || server.name, server.name || serverName, tools);
+          await syncMCPToolsToFTS();
+
+          log.info(`MCP server ${serverName} connected: ${tools.length} tools available`);
+        } catch (err) {
+          log.error(`Failed to connect MCP server ${serverName}: ${(err as Error).message}`);
+          db.query(`UPDATE mcp_servers SET status = ? WHERE id = ?`).run("error", serverName);
+        }
+      }
+    }
+
+    // Detect removed servers
+    for (const oldServerName of _lastKnownServers) {
+      if (!currentServerNames.has(oldServerName)) {
+        log.info(`MCP server removed: ${oldServerName} - disconnecting...`);
+
+        try {
+          // Remove from MCP Manager
+          const currentConfig = (mcpManager as any).config || { servers: {} };
+          delete currentConfig.servers[oldServerName];
+          await mcpManager.updateConfig(currentConfig);
+
+          // Delete MCP tool definitions from DB and FTS5
+          clearMCPToolsFromDB(oldServerName);
+
+          // Update DB status
+          db.query(`UPDATE mcp_servers SET status = ?, tools_count = 0 WHERE id = ?`).run("disconnected", oldServerName);
+
+          log.info(`MCP server ${oldServerName} disconnected`);
+        } catch (err) {
+          log.error(`Failed to disconnect MCP server ${oldServerName}: ${(err as Error).message}`);
+        }
+      }
+    }
+
+    _lastKnownServers = currentServerNames;
+  } catch (err) {
+    log.error(`MCP server sync failed: ${(err as Error).message}`);
+  }
+}

package/packages/core/src/mcp/singleton.ts

@@ -0,0 +1,21 @@
+/**
+ * MCP Manager Singleton
+ * 
+ * Provides global access to the MCP Manager instance
+ */
+
+import type { MCPClientManager } from "@johpaz/hive-agents-mcp";
+
+let _mcpManager: MCPClientManager | null = null;
+
+export function setMCPManager(m: MCPClientManager): void {
+  _mcpManager = m;
+}
+
+export function getMCPManager(): MCPClientManager | null {
+  return _mcpManager;
+}
+
+export function hasMCPManager(): boolean {
+  return _mcpManager !== null;
+}