@johpaz/hive-agents 0.0.34 → 0.0.36

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

@@ -0,0 +1,4 @@
+export { TOOL_NARRATIONS, getNarration } from "./narration.ts";
+export { expandPath } from "./path.ts";
+export { CORS_ORIGINS, addCorsHeaders } from "./cors.ts";
+export { redactValue, redactConfig } from "./redact.ts";

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

@@ -0,0 +1,57 @@
+// ─── 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.create": "Programando tarea...",
+  "cron.list": "Consultando tareas programadas...",
+  "cron.update": "Actualizando tarea programada...",
+  "cron.delete": "Eliminando tarea programada...",
+  "cron.pause": "Pausando tarea programada...",
+  "cron.resume": "Reanudando tarea programada...",
+  "cron.trigger": "Ejecutando tarea ahora...",
+  "cron.history": "Consultando historial...",
+  // 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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,363 @@
+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 { syncMCPToolsToFTS } from "../mcp/tool-sync";
+import { AgentService, createAgentService } from "../agent/service";
+import { mkdirSync, existsSync } from "node:fs";
+import * as path from "node:path";
+import { resolveAgentId, runStartupMigrations } from "../storage/onboarding";
+import { createMCPManager, type MCPClientManager } from "@johpaz/hive-agents-mcp";
+import { setMCPManager } from "../mcp/singleton";
+import { startMCPHotReload } from "../mcp/hot-reload";
+import { loadMcpHeaders } from "../storage/crypto";
+import { initializeBrowserService } from "../tools/web/browser-service";
+import { activateBrowserTools } from "../storage/onboarding";
+
+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, base_url FROM providers WHERE active = 1
+    `).all() as Array<{ id: string; name: string; base_url: string | null }>;
+
+    if (providers.length > 0) {
+      config.models = config.models || {};
+      config.models.providers = config.models.providers || {};
+
+      const { loadProviderApiKey } = await import("../storage/crypto");
+
+      for (const p of providers) {
+        const apiKey = await loadProviderApiKey(p.id);
+
+        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: 0 usuarios (initializeDatabase() ya fue llamado antes en server.ts)
+  let setupMode = false;
+  try {
+    const count = (getDb().query("SELECT COUNT(*) as count FROM users").get() as { count: number }).count;
+    setupMode = count === 0;
+  } catch {
+    setupMode = true;
+  }
+
+  if (setupMode) {
+    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);
+
+    // 3a. Startup migrations (idempotent, version-keyed)
+    runStartupMigrations();
+
+    // 3b. Migrate AES-encrypted secrets → OS keychain (one-shot, idempotent)
+    const { migrateEncryptedSecretsToKeychain } = await import("../storage/migrate");
+    await migrateEncryptedSecretsToKeychain();
+
+    // 3. Cargar configuración del agente desde DB
+    const { provider, model } = await loadAgentConfigFromDB(config);
+
+    // 4. Sync FTS5 indexes (tools + skills + playbook + mcp_tools)
+    log.info("[initialize] Syncing FTS5 indexes (asynchronous & transactional)...")
+    try {
+      await Promise.all([
+        syncToolsToFTS(),
+        syncSkillsToFTS(),
+        syncPlaybookToFTS(),
+        syncMCPToolsToFTS()
+      ]);
+      log.info("[initialize] ✅ FTS5 indexes synced (tools, skills, playbook, mcp_tools)")
+    } 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();
+
+    // 5b. Initialize Browser Service (Chrome via Bun.WebView nativo)
+    let browserAvailable = false;
+
+    try {
+      log.info("Detecting browser (lazy launch — will open on first agent use)...");
+
+      const browserService = initializeBrowserService(config);
+      browserAvailable = await browserService.start();
+
+      if (browserAvailable) {
+        activateBrowserTools();
+      } else {
+        log.warn("⚠️  No se encontró Chrome/Chromium - browser tools desactivadas");
+        log.warn("   Linux: sudo dnf install chromium  |  macOS: brew install --cask google-chrome");
+      }
+    } catch (error) {
+      log.warn(`Browser Service initialization skipped: ${(error as Error).message}`);
+    }
+
+    // 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,
+        };
+        
+        // Load headers from keychain (modern), fall back to legacy AES
+        const keychainHeaders = await loadMcpHeaders(server.id || server.name);
+        if (Object.keys(keychainHeaders).length > 0) {
+          mcpServerConfig.headers = keychainHeaders;
+        } else if (server.headers_encrypted && server.headers_iv) {
+          const { legacyDecryptAES } = await import("../storage/crypto");
+          mcpServerConfig.headers = legacyDecryptAES(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,
+        });
+        const mcpLog = logger.child("mcp");
+        mcpManager.setLogHandler((level, context, message) => {
+          mcpLog[level](`[${context}] ${message}`);
+        });
+        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: {} });
+        const mcpLog2 = logger.child("mcp");
+        mcpManager.setLogHandler((level, context, message) => {
+          mcpLog2[level](`[${context}] ${message}`);
+        });
+        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

@@ -0,0 +1,169 @@
+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();