@johpaz/hive 1.1.0

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

@@ -0,0 +1,290 @@
+import type { Config } from "../config/loader";
+import { logger } from "../utils/logger";
+import { getDb, initializeDatabase } from "../storage/sqlite";
+import { loadContextToStore } from "../storage/bun-sqlite-store";
+import { Agent } from "../agent/index";
+import { buildSupervisorGraph } from "../agent/supervisor";
+import { AgentRunner } from "../agent/providers/index";
+import { ChannelManager } from "../channels/manager";
+import { mkdirSync } from "node:fs";
+import * as path from "node:path";
+
+const log = logger.child("gateway:init");
+
+/**
+ * Verifica que exista al menos un usuario en la base de datos
+ */
+export async function verifyDatabaseUsers(): Promise<void> {
+  try {
+    // Initialize database if not already done
+    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();
+    
+    // Obtener configuración del agente coordinador
+    const agentConfig = db.query(`
+      SELECT provider_id, model_id FROM agents
+      WHERE id = ? OR is_coordinator = 1
+      ORDER BY (CASE WHEN id = ? THEN 1 ELSE 0 END) DESC
+      LIMIT 1
+    `).get(process.env.HIVE_AGENT_ID || "", process.env.HIVE_AGENT_ID || "") 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 contexto desde la base de datos (Skills, Ethics, MCP, Tools)
+ */
+export async function initializeContextStore(): Promise<void> {
+  try {
+    const db = getDb();
+    await loadContextToStore(db);
+    log.info("Context store initialized (Skills, Ethics, MCP, Tools)");
+  } catch (error) {
+    log.error(`Failed to initialize context store: ${(error as Error).message}`);
+    throw error;
+  }
+}
+
+/**
+ * Carga las éticas activas desde la base de datos
+ */
+export async function loadEthicsToAgent(agent: Agent): Promise<void> {
+  try {
+    const db = getDb();
+    const ethics = db.query("SELECT content FROM ethics WHERE active = 1 LIMIT 1").get() as 
+      { content: string } | undefined;
+    
+    if (ethics) {
+      agent.setEthics(ethics.content);
+      log.info("Active ethics loaded from DB");
+    }
+  } catch (error) {
+    log.error(`Error loading ethics from DB: ${(error as Error).message}`);
+    // No throw - ethics are not critical
+  }
+}
+
+/**
+ * Inicializa el grafo del supervisor (LangGraph)
+ */
+export async function initializeSupervisorGraph(mcpManager?: any): Promise<void> {
+  try {
+    await buildSupervisorGraph({ mcpManager });
+    log.info("Supervisor graph initialized");
+  } catch (error) {
+    log.warn(`Supervisor graph initialization failed: ${(error as Error).message}`);
+    // No throw - supervisor graph can be rebuilt later
+  }
+}
+
+/**
+ * Inicializa el agente con su configuración
+ */
+export async function initializeAgent(
+  config: Config,
+  workspacePath: string
+): Promise<Agent> {
+  try {
+    const agentId = process.env.HIVE_AGENT_ID || "main";
+    const agent = new Agent({
+      agentId,
+      config,
+      workspacePath,
+    });
+
+    await agent.initialize();
+    log.info(`Agent initialized: ${agent.agentId}`);
+    
+    return agent;
+  } catch (error) {
+    log.error(`Failed to initialize agent: ${(error as Error).message}`);
+    throw error;
+  }
+}
+
+/**
+ * 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: Agent;
+  runner: AgentRunner;
+  channelManager: ChannelManager;
+  provider: string;
+  model: string;
+}
+
+export async function initializeGateway(
+  config: Config,
+  pidFile: string
+): Promise<GatewayInitializationResult> {
+  const errors: Array<{ module: string; error: Error }> = [];
+  
+  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. Inicializar contexto (crítico)
+    await initializeContextStore();
+    
+    // 5. Obtener workspace path
+    const agentList = config.agents?.list ?? [];
+    const defaultAgent = agentList.find((a) => a.default) ?? agentList[0];
+    const workspacePath = path.join(
+      process.env.HOME || "", 
+      defaultAgent?.workspace?.replace("~/", "") || ".hive/workspace"
+    );
+    
+    // 6. Inicializar agente (crítico)
+    const agent = await initializeAgent(config, workspacePath);
+    
+    // 7. Cargar éticas (no crítico)
+    await loadEthicsToAgent(agent);
+    
+    // 8. Inicializar grafo del supervisor (no crítico)
+    const mcpManager = agent.getMCPManager();
+    await initializeSupervisorGraph(mcpManager);
+    
+    // 9. Inicializar LLM runner (crítico)
+    const runner = await initializeLLMRunner(config, provider, model);
+    
+    // 10. 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();

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 is_coordinator = 1 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 is_coordinator = 1 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)
+  }
+}

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

@@ -0,0 +1,124 @@
+import type { Config, Binding } from "../config/loader.ts";
+
+export interface RoutingContext {
+  channel: string;
+  accountId?: string;
+  peerKind?: "direct" | "group";
+  peerId?: string;
+  guildId?: string;
+  teamId?: string;
+  roles?: string[];
+}
+
+export function matchBinding(binding: Binding, ctx: RoutingContext): number {
+  const match = binding.match;
+  let score = 0;
+
+  if (match.peer?.id && match.peer?.kind) {
+    if (ctx.peerId === match.peer.id && ctx.peerKind === match.peer.kind) {
+      score += 1000;
+    } else {
+      return 0;
+    }
+  } else if (match.peer?.id) {
+    if (ctx.peerId === match.peer.id) {
+      score += 900;
+    } else {
+      return 0;
+    }
+  } else if (match.peer?.kind) {
+    if (ctx.peerKind === match.peer.kind) {
+      score += 50;
+    } else {
+      return 0;
+    }
+  }
+
+  if (match.guildId && match.roles && match.roles.length > 0) {
+    if (ctx.guildId === match.guildId && ctx.roles?.some((r) => match.roles?.includes(r))) {
+      score += 800;
+    } else {
+      return 0;
+    }
+  } else if (match.guildId) {
+    if (ctx.guildId === match.guildId) {
+      score += 200;
+    } else {
+      return 0;
+    }
+  }
+
+  if (match.teamId) {
+    if (ctx.teamId === match.teamId) {
+      score += 300;
+    } else {
+      return 0;
+    }
+  }
+
+  if (match.accountId) {
+    if (ctx.accountId === match.accountId) {
+      score += 400;
+    } else {
+      return 0;
+    }
+  }
+
+  if (match.channel) {
+    if (ctx.channel === match.channel) {
+      score += 100;
+    } else {
+      return 0;
+    }
+  }
+
+  return score || 1;
+}
+
+export function resolveAgent(
+  config: Config,
+  ctx: RoutingContext
+): string {
+  const bindings = config.bindings ?? [];
+  
+  if (bindings.length === 0) {
+    return config.agent?.defaultAgentId ?? "main";
+  }
+
+  let bestMatch: { agentId: string; score: number } | null = null;
+
+  for (const binding of bindings) {
+    const score = matchBinding(binding, ctx);
+    if (score > 0 && (!bestMatch || score > bestMatch.score)) {
+      bestMatch = { agentId: binding.agentId, score };
+    }
+  }
+
+  if (bestMatch) {
+    return bestMatch.agentId;
+  }
+
+  return config.agent?.defaultAgentId ?? "main";
+}
+
+export class Router {
+  constructor(private config: Config) {}
+
+  route(ctx: RoutingContext): string {
+    return resolveAgent(this.config, ctx);
+  }
+
+  getAgentWorkspace(agentId: string): string {
+    const agents = this.config.agents?.list ?? [];
+    const agent = agents.find((a) => a.id === agentId);
+    
+    if (agent?.workspace) {
+      return agent.workspace.replace(/^~/, process.env.HOME ?? "");
+    }
+
+    const baseDir = this.config.agent?.baseDir?.replace(/^~/, process.env.HOME ?? "") 
+      ?? `${process.env.HOME}/.hive/agents`;
+    
+    return `${baseDir}/${agentId}/workspace`;
+  }
+}