@johpaz/hive 1.7.2 → 1.7.3

package/packages/core/src/gateway/helpers/narration.ts

@@ -1,60 +0,0 @@
-// ─── Tool narration map ───────────────────────────────────────────────────────
-// Maps tool name prefixes/exact names to human-readable Spanish narrations.
-// Shown to the user while the agent executes a tool.
-export const TOOL_NARRATIONS: Record<string, string> = {
-  // Web
-  web_search: "Buscando en la web...",
-  web_fetch: "Leyendo página web...",
-  // Files
-  read: "Leyendo archivo...",
-  write: "Escribiendo archivo...",
-  edit: "Editando archivo...",
-  exec: "Ejecutando comando...",
-  // Cron
-  cron_add: "Programando tarea...",
-  cron_list: "Consultando tareas programadas...",
-  cron_remove: "Eliminando tarea programada...",
-  cron_edit: "Actualizando tarea programada...",
-  // Projects
-  project_create: "Creando proyecto...",
-  project_update: "Actualizando proyecto...",
-  project_done: "Marcando proyecto como completado...",
-  project_fail: "Registrando falla en el proyecto...",
-  task_create: "Creando tarea...",
-  task_update: "Actualizando tarea...",
-  // Agents
-  create_agent: "Creando agente worker...",
-  find_agent: "Buscando agente disponible...",
-  archive_agent: "Archivando agente...",
-  // Memory
-  save_note: "Guardando nota...",
-  memory_write: "Guardando en memoria...",
-  memory_read: "Leyendo memoria...",
-  memory_search: "Buscando en memoria...",
-  memory_delete: "Eliminando de memoria...",
-  memory_list: "Listando notas...",
-  // Browser
-  browser_navigate: "Navegando a la página...",
-  browser_click: "Haciendo clic...",
-  browser_type: "Escribiendo en la página...",
-  browser_screenshot: "Tomando captura de pantalla...",
-  browser_extract: "Extrayendo información de la página...",
-  // Canvas
-  canvas_add_node: "Actualizando canvas...",
-  canvas_update: "Actualizando canvas...",
-  // Code Bridge
-  bridge_send: "Enviando tarea al CLI...",
-  bridge_exec: "Ejecutando en el Code Bridge...",
-  // Notify
-  notify: "Enviando notificación...",
-  report_progress: "Reportando progreso...",
-}
-
-export function getNarration(toolName: string): string {
-  if (TOOL_NARRATIONS[toolName]) return TOOL_NARRATIONS[toolName]
-  // Prefix matching for MCP tools like "github__create_pr" → "Ejecutando github..."
-  const prefix = toolName.split("__")[0]
-  if (prefix && prefix !== toolName) return `Ejecutando ${prefix}...`
-  // Fallback
-  return `Ejecutando ${toolName.replace(/_/g, " ")}...`
-}

package/packages/core/src/gateway/helpers/path.ts

@@ -1,13 +0,0 @@
-import * as path from "node:path";
-
-/**
- * Expands a path that starts with ~ to the user's home directory.
- * @param p - The path to expand
- * @returns The expanded path
- */
-export function expandPath(p: string): string {
-  if (p.startsWith("~")) {
-    return path.join(process.env.HOME ?? "", p.slice(1));
-  }
-  return p;
-}

package/packages/core/src/gateway/helpers/redact.ts

@@ -1,61 +0,0 @@
-import type { Config } from "../../config/loader.ts";
-
-/**
- * Redacts a sensitive value by showing only the first 4 characters.
- * @param value - The value to redact
- * @returns The redacted value or a string of bullets if too short
- */
-export function redactValue(value: string): string {
-  if (!value || value.length < 8) return "••••••••";
-  return `${value.slice(0, 4)}••••••••`;
-}
-
-/**
- * Redacts sensitive information from a config object for safe exposure.
- * @param cfg - The config object to redact
- * @returns A new config object with sensitive values redacted
- */
-export function redactConfig(cfg: Config): Record<string, unknown> {
-  const redacted = JSON.parse(JSON.stringify(cfg)) as any;
-
-  // Redact gateway authToken
-  if (redacted.gateway?.authToken) {
-    redacted.gateway.authToken = redactValue(redacted.gateway.authToken);
-  }
-
-  // Redact provider API keys
-  if (redacted.models?.providers) {
-    for (const provider of Object.values(redacted.models.providers) as any[]) {
-      if (provider?.apiKey) provider.apiKey = redactValue(provider.apiKey);
-    }
-  }
-
-  // Redact channel tokens
-  if (redacted.channels) {
-    for (const channel of Object.values(redacted.channels) as any[]) {
-      if (channel?.accounts) {
-        for (const acc of Object.values(channel.accounts) as any[]) {
-          if (acc?.botToken) acc.botToken = redactValue(acc.botToken);
-          if (acc?.appToken) acc.appToken = redactValue(acc.appToken);
-          if (acc?.signingSecret) acc.signingSecret = redactValue(acc.signingSecret);
-        }
-      }
-    }
-  }
-
-  // Redact MCP server headers
-  if (redacted.mcp?.servers) {
-    for (const server of Object.values(redacted.mcp.servers) as any[]) {
-      if (server?.headers) {
-        for (const [k, v] of Object.entries(server.headers)) {
-          const lk = k.toLowerCase();
-          if (lk.includes("auth") || lk.includes("token") || lk.includes("key")) {
-            server.headers[k] = redactValue(v as string);
-          }
-        }
-      }
-    }
-  }
-
-  return redacted;
-}

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

@@ -1,5 +0,0 @@
-import { loadConfig } from "../config/loader.ts";
-import { startGateway } from "./server.ts";
-import { logger } from "../utils/logger.ts";
-
-export { loadConfig, startGateway, logger };

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

@@ -1,332 +0,0 @@
-import type { Config } from "../config/loader";
-import { logger } from "../utils/logger";
-import { getDb, initializeDatabase, getDbPathLazy } from "../storage/sqlite";
-import { buildAgentLoop } from "../agent/agent-loop";
-import { AgentRunner } from "../agent/providers/index";
-import { ChannelManager } from "../channels/manager";
-import { syncToolsToFTS, syncSkillsToFTS, syncPlaybookToFTS } from "../agent/context-compiler";
-import { AgentService, createAgentService } from "../agent/service";
-import { mkdirSync, existsSync } from "node:fs";
-import * as path from "node:path";
-import { resolveAgentId } from "../storage/onboarding";
-import { createMCPManager, type MCPClientManager } from "@johpaz/hive-mcp";
-import { setMCPManager } from "../mcp/singleton";
-import { startMCPHotReload } from "../mcp/hot-reload";
-
-const log = logger.child("gateway:init");
-
-/**
- * Verifica que exista al menos un usuario en la base de datos
- */
-export async function verifyDatabaseUsers(): Promise<void> {
-  // Setup mode: no DB yet — skip verification, gateway starts to serve the web setup
-  if (!existsSync(getDbPathLazy())) {
-    log.info("Setup mode: no database found — gateway will serve web setup at /setup");
-    return;
-  }
-
-  try {
-    initializeDatabase();
-
-    const db = getDb();
-    const userCount = db.query("SELECT COUNT(*) as count FROM users").get() as { count: number };
-
-    if (userCount.count === 0) {
-      const error = new Error("No users found in the database. A valid user is required to start the Hive Gateway.");
-      log.error(error.message);
-      log.error("Please run the onboarding process or manually insert a user.");
-      throw error;
-    }
-
-    log.info(`Database verified: ${userCount.count} user(s) found`);
-  } catch (error) {
-    log.error(`Database verification failed: ${(error as Error).message}`);
-    throw error;
-  }
-}
-
-/**
- * Escribe el archivo PID del proceso
- */
-export async function writePidFile(pidFile: string): Promise<void> {
-  try {
-    const dir = path.dirname(pidFile);
-    mkdirSync(dir, { recursive: true });
-    await Bun.write(pidFile, process.pid.toString());
-    log.info(`PID file written: ${pidFile}`);
-  } catch (error) {
-    log.warn(`Could not write PID file: ${(error as Error).message}`);
-    // No throw - PID file is not critical
-  }
-}
-
-/**
- * Carga la configuración del agente desde la base de datos
- * @returns Provider y modelo configurados
- */
-export async function loadAgentConfigFromDB(
-  config: Config
-): Promise<{ provider: string; model: string }> {
-  const defaultProvider = "gemini";
-  const defaultModel = "gemini-2.5-flash";
-
-  try {
-    const db = getDb();
-
-    // Get coordinator agent ID from database
-    const coordinatorAgentId = resolveAgentId(null);
-
-    // Obtener configuración del agente coordinador
-    const agentConfig = db.query(`
-      SELECT provider_id, model_id FROM agents
-      WHERE id = ? OR role = 'coordinator'
-      ORDER BY (CASE WHEN id = ? THEN 1 ELSE 0 END) DESC
-      LIMIT 1
-    `).get(coordinatorAgentId || "", coordinatorAgentId || "") as
-      { provider_id: string | null; model_id: string | null } | undefined;
-
-    let provider = agentConfig?.provider_id || defaultProvider;
-    let model = agentConfig?.model_id || defaultModel;
-
-    // Cargar API keys de los providers desde la DB
-    const providers = db.query(`
-      SELECT id, name, api_key_encrypted, api_key_iv, base_url
-      FROM providers
-      WHERE active = 1 AND api_key_encrypted IS NOT NULL
-    `).all() as Array<{
-      id: string;
-      name: string;
-      api_key_encrypted: string;
-      api_key_iv: string;
-      base_url: string | null
-    }>;
-
-    if (providers.length > 0) {
-      config.models = config.models || {};
-      config.models.providers = config.models.providers || {};
-
-      const { decryptApiKey } = await import("../storage/crypto");
-
-      for (const p of providers) {
-        const apiKey = await decryptApiKey(p.api_key_encrypted, p.api_key_iv);
-
-        config.models.providers[p.name] = {
-          apiKey,
-          baseUrl: p.base_url || undefined,
-          defaultModel: model,
-          availableModels: [],
-          maxRetries: 3,
-          timeoutMs: 30000,
-        } as any;
-      }
-
-      log.info(`Loaded ${providers.length} provider(s) from DB with API keys`);
-    }
-
-    log.info(`Agent config loaded from DB: ${provider}/${model}`);
-    return { provider, model };
-
-  } catch (error) {
-    log.debug(`Could not read agent config from DB, using defaults: ${defaultProvider}/${defaultModel}`);
-    return { provider: defaultProvider, model: defaultModel };
-  }
-}
-
-/**
- * Inicializa el agent loop
- */
-export async function initializeAgentLoop(mcpManager?: any): Promise<void> {
-  try {
-    await buildAgentLoop({ mcpManager });
-    log.info("Agent loop initialized");
-  } catch (error) {
-    log.warn(`Agent loop initialization failed: ${(error as Error).message}`);
-    // No throw - agent loop can be rebuilt later
-  }
-}
-
-/**
- * Inicializa el runner de LLM
- */
-export async function initializeLLMRunner(
-  config: Config,
-  provider: string,
-  model: string
-): Promise<AgentRunner> {
-  try {
-    const runner = new AgentRunner(config);
-    log.info(`LLM runner initialized: ${provider}/${model}`);
-    return runner;
-  } catch (error) {
-    log.error(`Failed to initialize LLM runner: ${(error as Error).message}`);
-    throw error;
-  }
-}
-
-/**
- * Inicializa el manager de canales
- */
-export async function initializeChannelManager(
-  config: Config
-): Promise<ChannelManager> {
-  try {
-    const channelManager = new ChannelManager(config);
-    await channelManager.initialize();
-    await channelManager.startAll();
-    log.info("Channel manager initialized and started");
-    return channelManager;
-  } catch (error) {
-    log.error(`Failed to initialize channel manager: ${(error as Error).message}`);
-    throw error;
-  }
-}
-
-/**
- * Función principal de inicialización que orquesta todos los módulos
- */
-export interface GatewayInitializationResult {
-  agent: AgentService;
-  runner: AgentRunner;
-  channelManager: ChannelManager;
-  provider: string;
-  model: string;
-}
-
-export async function initializeGateway(
-  config: Config,
-  pidFile: string
-): Promise<GatewayInitializationResult> {
-  // Setup mode: no DB file, OR DB exists but has no users (e.g. interrupted first run)
-  const isSetupMode = (): boolean => {
-    if (!existsSync(getDbPathLazy())) return true;
-    try {
-      initializeDatabase();
-      const count = (getDb().query("SELECT COUNT(*) as count FROM users").get() as { count: number }).count;
-      return count === 0;
-    } catch {
-      return true;
-    }
-  };
-
-  if (isSetupMode()) {
-    log.info("Setup mode: skipping full initialization — only setup routes will be available");
-    await writePidFile(pidFile);
-    // Return stubs; server.ts checks isSetupMode() before using these
-    return {
-      agent: null as any,
-      runner: null as any,
-      channelManager: null as any,
-      provider: "",
-      model: "",
-    };
-  }
-
-  try {
-    // 1. Verificar base de datos (crítico)
-    await verifyDatabaseUsers();
-
-    // 2. Escribir archivo PID (no crítico)
-    await writePidFile(pidFile);
-
-    // 3. Cargar configuración del agente desde DB
-    const { provider, model } = await loadAgentConfigFromDB(config);
-
-    // 4. Sync FTS5 indexes (tools + skills + playbook)
-    log.info("[initialize] Syncing FTS5 indexes (asynchronous & transactional)...")
-    try {
-      await Promise.all([
-        syncToolsToFTS(),
-        syncSkillsToFTS(),
-        syncPlaybookToFTS()
-      ]);
-      log.info("[initialize] ✅ FTS5 indexes synced (tools, skills, playbook)")
-    } catch (err) {
-      log.error(`[initialize] FTS5 sync failed during startup: ${(err as Error).message}`);
-      // Consider if we should throw or continue. For now, continue but log error.
-    }
-
-    // 5. Crear AgentService (reemplaza la clase Agent legacy)
-    const agent = createAgentService();
-    await agent.initialize();
-
-    // 6. Inicializar MCP Manager y agent loop
-    // MCP se inicializa con los servidores de la config + DB
-    let mcpManager: MCPClientManager | null = null;
-    
-    // Load MCP servers from DB and merge with config
-    const db = getDb();
-    const dbServers = db.query(`SELECT * FROM mcp_servers WHERE enabled = 1`).all() as Record<string, any>[];
-    
-    const mcpServersFromDB: Record<string, any> = {};
-    for (const server of dbServers) {
-      try {
-        const mcpServerConfig: any = {
-          transport: server.transport,
-          command: server.command,
-          args: server.args ? JSON.parse(server.args) : [],
-          url: server.url,
-          enabled: true,
-        };
-        
-        // Decrypt headers if present
-        if (server.headers_encrypted && server.headers_iv) {
-          const { decryptConfig } = await import("../storage/crypto");
-          mcpServerConfig.headers = decryptConfig(server.headers_encrypted, server.headers_iv);
-        }
-        
-        mcpServersFromDB[server.id || server.name] = mcpServerConfig;
-      } catch (error) {
-        log.warn(`Failed to load MCP server ${server.name} from DB: ${(error as Error).message}`);
-      }
-    }
-    
-    // Merge config MCP servers with DB servers
-    const configMcpServers = config.mcp?.servers || {};
-    const mergedMcpServers = { ...configMcpServers, ...mcpServersFromDB };
-    
-    if (Object.keys(mergedMcpServers).length > 0) {
-      try {
-        mcpManager = createMCPManager({
-          ...config.mcp,
-          servers: mergedMcpServers,
-        });
-        await mcpManager.initialize();
-        setMCPManager(mcpManager); // Save to singleton for global access
-        log.info(`MCP Manager initialized with ${Object.keys(mergedMcpServers).length} server(s) from config + DB`);
-        
-        // Start hot reload watcher for dynamic server changes
-        startMCPHotReload(mcpManager);
-        log.info("MCP Hot Reload started - new servers will auto-connect");
-      } catch (error) {
-        log.warn(`MCP Manager initialization failed: ${(error as Error).message}`);
-      }
-    } else {
-      log.info("No MCP servers found in config or DB");
-      // Initialize empty MCP Manager for hot reload to work
-      try {
-        mcpManager = createMCPManager({ servers: {} });
-        await mcpManager.initialize();
-        setMCPManager(mcpManager);
-        startMCPHotReload(mcpManager);
-        log.info("MCP Hot Reload started - waiting for first server");
-      } catch (error) {
-        log.warn(`Empty MCP Manager initialization failed: ${(error as Error).message}`);
-      }
-    }
-    
-    // Inicializar agent loop con MCP Manager
-    await initializeAgentLoop(mcpManager || undefined);
-
-    // 7. Inicializar LLM runner (crítico)
-    const runner = await initializeLLMRunner(config, provider, model);
-
-    // 8. Inicializar channel manager (crítico)
-    const channelManager = await initializeChannelManager(config);
-
-    return { agent, runner, channelManager, provider, model };
-
-  } catch (error) {
-    log.error(`Gateway initialization failed: ${(error as Error).message}`);
-    throw error;
-  }
-}

package/packages/core/src/gateway/lane-queue.ts

@@ -1,169 +0,0 @@
-export type TaskStatus = "pending" | "running" | "completed" | "failed" | "cancelled";
-
-export interface Task {
-  id: string;
-  sessionId: string;
-  status: TaskStatus;
-  priority: number;
-  createdAt: Date;
-  startedAt?: Date;
-  completedAt?: Date;
-  error?: string;
-  abortController: AbortController;
-}
-
-export interface LaneQueueOptions {
-  maxConcurrency?: number;
-  taskTimeoutMs?: number;
-}
-
-type TaskHandler<T> = (task: Task, signal: AbortSignal) => Promise<T>;
-
-export class LaneQueue {
-  private queues: Map<string, Task[]> = new Map();
-  private running: Map<string, Task> = new Map();
-  private handlers: Map<string, TaskHandler<unknown>> = new Map();
-  private taskIdCounter = 0;
-  private options: Required<LaneQueueOptions>;
-
-  constructor(options: LaneQueueOptions = {}) {
-    this.options = {
-      maxConcurrency: options.maxConcurrency ?? 1,
-      taskTimeoutMs: options.taskTimeoutMs ?? 300000,
-    };
-  }
-
-  private generateTaskId(): string {
-    return `task-${Date.now()}-${++this.taskIdCounter}`;
-  }
-
-  private getQueue(sessionId: string): Task[] {
-    let queue = this.queues.get(sessionId);
-    if (!queue) {
-      queue = [];
-      this.queues.set(sessionId, queue);
-    }
-    return queue;
-  }
-
-  enqueue<T>(
-    sessionId: string,
-    handler: TaskHandler<T>,
-    priority = 0
-  ): Task {
-    const task: Task = {
-      id: this.generateTaskId(),
-      sessionId,
-      status: "pending",
-      priority,
-      createdAt: new Date(),
-      abortController: new AbortController(),
-    };
-
-    this.handlers.set(task.id, handler as TaskHandler<unknown>);
-
-    const queue = this.getQueue(sessionId);
-    queue.push(task);
-    queue.sort((a, b) => b.priority - a.priority);
-
-    this.processQueue(sessionId);
-
-    return task;
-  }
-
-  private async processQueue(sessionId: string): Promise<void> {
-    const running = this.running.get(sessionId);
-    if (running) {
-      return;
-    }
-
-    const queue = this.getQueue(sessionId);
-    if (queue.length === 0) {
-      return;
-    }
-
-    const task = queue.shift();
-    if (!task) return;
-
-    task.status = "running";
-    task.startedAt = new Date();
-    this.running.set(sessionId, task);
-
-    const handler = this.handlers.get(task.id);
-
-    const timeoutId = setTimeout(() => {
-      task.abortController.abort();
-    }, this.options.taskTimeoutMs);
-
-    try {
-      if (handler) {
-        await handler(task, task.abortController.signal);
-      }
-      task.status = "completed";
-      task.completedAt = new Date();
-    } catch (error) {
-      if ((error as Error).name === "AbortError") {
-        task.status = "cancelled";
-      } else {
-        task.status = "failed";
-        task.error = (error as Error).message;
-      }
-      task.completedAt = new Date();
-    } finally {
-      clearTimeout(timeoutId);
-      this.running.delete(sessionId);
-      this.handlers.delete(task.id);
-      
-      if (queue.length > 0) {
-        this.processQueue(sessionId);
-      }
-    }
-  }
-
-  cancel(sessionId: string): boolean {
-    const task = this.running.get(sessionId);
-    if (task) {
-      task.abortController.abort();
-      return true;
-    }
-
-    const queue = this.getQueue(sessionId);
-    const index = queue.findIndex((t) => t.status === "pending");
-    if (index >= 0) {
-      const cancelled = queue.splice(index, 1)[0];
-      if (cancelled) {
-        cancelled.status = "cancelled";
-        cancelled.completedAt = new Date();
-      }
-      return true;
-    }
-
-    return false;
-  }
-
-  getStatus(sessionId: string): {
-    queueLength: number;
-    running?: Task;
-  } {
-    const queue = this.getQueue(sessionId);
-    const running = this.running.get(sessionId);
-
-    return {
-      queueLength: queue.length,
-      running,
-    };
-  }
-
-  isProcessing(sessionId: string): boolean {
-    return this.running.has(sessionId);
-  }
-
-  prune(sessionId: string): void {
-    const queue = this.getQueue(sessionId);
-    if (queue.length === 0 && !this.running.has(sessionId)) {
-      this.queues.delete(sessionId);
-    }
-  }
-}
-
-export const laneQueue = new LaneQueue();