@johpaz/hive-sdk 0.0.14 → 0.0.15

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

@@ -0,0 +1,147 @@
+/**
+ * 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/SQLiteStorage.ts";
+import { logger } from "../utils/logger.ts";
+import { decryptConfig } from "../storage/crypto.ts";
+import { syncMCPToolsToDB, syncMCPToolsToFTS, clearMCPToolsFromDB } from "./MCPToolAdapter.ts";
+import type { MCPClientManager } from "../mcp/index.ts";
+
+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,
+          };
+
+          if (server.headers_encrypted && server.headers_iv) {
+            mcpServerConfig.headers = decryptConfig(server.headers_encrypted, server.headers_iv);
+          }
+
+          // 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/index.ts

@@ -0,0 +1,11 @@
+export type { MCPTool, MCPResource, MCPPrompt } from "./MCPClient.ts";
+export { MCPClientManager } from "./MCPClient.ts";
+export type { MCPToolDefinition } from "./MCPToolAdapter.ts";
+export { mcpToolId, syncMCPToolsToDB, syncMCPToolsToFTS, clearMCPToolsFromDB } from "./MCPToolAdapter.ts";
+export type { MCPConfig, MCPServerConfig } from "./config.ts";
+export { setMCPManager, getMCPManager, hasMCPManager } from "./singleton.ts";
+export { startMCPHotReload, stopMCPHotReload } from "./hot-reload.ts";
+export type { LogLevel as MCPLogLevel, LogHandler as MCPLogHandler } from "./logger.ts";
+export { logger as mcpLogger } from "./logger.ts";
+export type { SSETransportConfig, WebSocketTransportConfig, StdioTransportConfig, TransportType, TransportOptions } from "./transports/index.ts";
+export { SSETransport, WebSocketTransport, createTransport } from "./transports/index.ts";

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

@@ -0,0 +1,42 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export type LogHandler = (level: LogLevel, context: string, message: string, data?: Record<string, unknown>) => void;
+
+class Logger {
+  private context: string;
+  private level: LogLevel = "info";
+  private handler: LogHandler | null = null;
+
+  constructor(context: string, handler: LogHandler | null = null) {
+    this.context = context;
+    this.handler = handler;
+  }
+
+  setHandler(handler: LogHandler | null): void {
+    this.handler = handler;
+  }
+
+  private log(level: LogLevel, message: string, data?: Record<string, unknown>): void {
+    if (this.handler) {
+      this.handler(level, this.context, message, data);
+      return;
+    }
+
+    // Silent by default if no handler is set, to avoid standard console pollution.
+    // The consumer (e.g., Hive Agent) should set a handler to bridge these logs.
+  }
+
+  debug(message: string, data?: Record<string, unknown>): void { this.log("debug", message, data); }
+  info(message: string, data?: Record<string, unknown>): void { this.log("info", message, data); }
+  warn(message: string, data?: Record<string, unknown>): void { this.log("warn", message, data); }
+  error(message: string, data?: Record<string, unknown>): void { this.log("error", message, data); }
+
+  child(context: string): Logger {
+    return new Logger(`${this.context}:${context}`, this.handler);
+  }
+
+  setLevel(level: LogLevel): void {
+    this.level = level;
+  }
+}
+
+export const logger = new Logger("mcp");

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 "../mcp/index.ts";
+
+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;
+}

package/packages/core/src/mcp/transports/index.ts

@@ -0,0 +1,67 @@
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+
+// CORRECCIÓN 1 — quitar extensión .ts de los imports
+// Bun resuelve los módulos sin extensión correctamente
+// Con .ts puede fallar en algunos contextos de build/bundle
+import { SSETransport, type SSETransportConfig } from "./sse";
+import { WebSocketTransport, type WebSocketTransportConfig } from "./websocket";
+
+export { SSETransport, type SSETransportConfig };
+export { WebSocketTransport, type WebSocketTransportConfig };
+
+// CORRECCIÓN 2 — exportar StdioTransportConfig
+// Estaba definido pero no exportado — el resto del código no puede importarlo
+export interface StdioTransportConfig {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+export type TransportType = "stdio" | "sse" | "websocket";
+
+export interface TransportOptions {
+  type: TransportType;
+  stdio?: StdioTransportConfig;
+  sse?: SSETransportConfig;
+  websocket?: WebSocketTransportConfig;
+}
+
+export function createTransport(options: TransportOptions): Transport {
+  switch (options.type) {
+    case "stdio": {
+      if (!options.stdio) {
+        throw new Error("stdio config required for stdio transport");
+      }
+      return new StdioClientTransport({
+        command: options.stdio.command,
+        args: options.stdio.args ?? [],
+        env: options.stdio.env ?? (process.env as Record<string, string>),
+      });
+    }
+
+    case "sse": {
+      if (!options.sse) {
+        throw new Error("sse config required for SSE transport");
+      }
+      // CORRECCIÓN 3 — sin cast as unknown as Transport
+      // SSETransport ahora implementa Transport directamente (implements Transport)
+      // el cast doble era señal de que el tipo no estaba bien declarado en la clase
+      return new SSETransport(options.sse);
+    }
+
+    case "websocket": {
+      if (!options.websocket) {
+        throw new Error("websocket config required for WebSocket transport");
+      }
+      // Igual — WebSocketTransport ahora implementa Transport directamente
+      return new WebSocketTransport(options.websocket);
+    }
+
+    default: {
+      // exhaustive check — TypeScript avisa si falta un caso
+      const _exhaustive: never = options.type;
+      throw new Error(`Unknown transport type: ${_exhaustive}`);
+    }
+  }
+}

package/packages/core/src/mcp/transports/sse.ts

@@ -0,0 +1,241 @@
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { logger } from "../logger";
+
+export interface SSETransportConfig {
+  url: string;                        // URL base
+  headers?: Record<string, string>;
+}
+
+export class SSETransport implements Transport {
+  private baseUrl: string;
+  private messagesUrl: string | null = null; // Endpoint recibido del servidor
+
+  private headers: Record<string, string>;
+  private abortController: AbortController | null = null;
+  private cookies: string[] = [];
+  private startResolve: (() => void) | null = null;
+  private startReject: ((err: Error) => void) | null = null;
+  sessionId?: string;
+
+  onmessage: ((message: unknown) => void) | undefined;
+  onerror: ((error: Error) => void) | undefined;
+  onclose: (() => void) | undefined;
+
+  constructor(config: SSETransportConfig) {
+    this.baseUrl = config.url;
+    this.headers = config.headers ?? {};
+  }
+
+  async start(): Promise<void> {
+    this.abortController = new AbortController();
+
+    return new Promise(async (resolve, reject) => {
+      // Timeout fallback: if no endpoint received in 5s, continue anyway
+      const timeout = setTimeout(() => {
+        this.startResolve = null;
+        this.startReject = null;
+        resolve();
+      }, 5000);
+
+      this.startResolve = () => {
+        clearTimeout(timeout);
+        this.startResolve = null;
+        this.startReject = null;
+        resolve();
+      };
+
+      this.startReject = (err) => {
+        clearTimeout(timeout);
+        this.startResolve = null;
+        this.startReject = null;
+        reject(err);
+      };
+
+      try {
+        logger.debug(`[SSE] Connecting to: ${this.baseUrl}`);
+        const response = await fetch(this.baseUrl, {
+          method: "GET",
+          headers: {
+            "Accept": "application/json, text/event-stream",
+            "Cache-Control": "no-cache",
+            ...this.headers,
+          },
+          signal: this.abortController!.signal,
+        });
+
+        if (response.status === 405) {
+          logger.debug(`[SSE] GET not allowed (405), falling back to Streamable HTTP pattern for ${this.baseUrl}`);
+          this.startResolve();
+          return;
+        }
+
+        if (!response.ok) {
+          this.startReject(new Error(`MCP SSE connection failed: ${response.status} ${response.statusText}`));
+          return;
+        }
+
+        this.readSessionId(response);
+
+        if (response.body) {
+          this.startReading(response.body);
+        } else {
+          this.startResolve();
+        }
+      } catch (error: any) {
+        if (error.name !== "AbortError") {
+          this.startReject(error);
+        }
+      }
+    });
+  }
+
+  private readSessionId(response: Response) {
+    const sessionId = response.headers.get("x-session-id") ??
+      response.headers.get("mcp-session-id");
+    if (sessionId) {
+      this.sessionId = sessionId;
+    }
+
+    // Track cookies for session affinity (important for n8n/proxies)
+    const setCookie = response.headers.get("set-cookie");
+    if (setCookie) {
+      // Simple cookie extraction: just keep the keys and values
+      const newCookies = setCookie.split(',').map(c => c.split(';')[0].trim());
+      this.cookies = [...new Set([...this.cookies, ...newCookies])];
+    }
+  }
+
+  private startReading(stream: ReadableStream<Uint8Array>) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    this.processStream(reader, decoder, buffer).catch((error) => {
+      if (this.onerror && error.name !== "AbortError") {
+        this.onerror(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+
+  private async processStream(
+    reader: ReadableStreamDefaultReader<Uint8Array>,
+    decoder: TextDecoder,
+    buffer: string
+  ): Promise<void> {
+    try {
+      let eventType = "message";
+      let eventData = "";
+
+      while (true) {
+        const { done, value } = await reader.read();
+
+        if (done) {
+          return;
+        }
+
+        buffer += decoder.decode(value, { stream: true });
+
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+
+        for (const line of lines) {
+          if (line.startsWith("event: ")) {
+            eventType = line.slice(7).trim();
+          } else if (line.startsWith("data: ")) {
+            const data = line.slice(6);
+            if (data.trim() === "[DONE]") {
+              this.onclose?.();
+              return;
+            }
+            eventData += data + "\n";
+          } else if (line === "") {
+            if (eventData) {
+              eventData = eventData.trim();
+              if (eventType === "endpoint") {
+                try {
+                  this.messagesUrl = new URL(eventData, this.baseUrl).href;
+                  logger.debug(`[SSE] Messages endpoint received: ${this.messagesUrl}`);
+                  this.startResolve?.();
+                } catch (e) {
+                  logger.warn(`[SSE] Failed to parse endpoint: ${eventData}`);
+                }
+              } else if (eventType === "message" || eventType === "") {
+                try {
+                  const parsed = JSON.parse(eventData);
+                  this.onmessage?.(parsed);
+                } catch {
+                  // Ignorar heartbeats o no-JSON
+                }
+              }
+              eventData = "";
+            }
+            eventType = "message";
+          }
+        }
+      }
+    } catch (error: any) {
+      if (error.name !== "AbortError") {
+        this.onerror?.(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+  }
+
+  async close(): Promise<void> {
+    this.abortController?.abort();
+    this.abortController = null;
+    this.sessionId = undefined;
+    this.onclose?.();
+  }
+
+  async send(message: unknown): Promise<void> {
+    if (!this.abortController) {
+      throw new Error("SSE transport not started — llama start() primero");
+    }
+
+    const targetUrl = this.messagesUrl || this.baseUrl;
+    let url = targetUrl;
+
+    if (this.sessionId && !url.includes(`sessionId=${this.sessionId}`)) {
+      url = `${targetUrl}${targetUrl.includes('?') ? '&' : '?'}sessionId=${this.sessionId}`;
+    }
+
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Accept": "application/json, text/event-stream",
+        ...this.headers,
+        ...(this.cookies.length > 0 ? { "Cookie": this.cookies.join('; ') } : {}),
+      },
+      body: JSON.stringify(message),
+      signal: this.abortController.signal,
+    });
+
+    this.readSessionId(response);
+
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(`MCP message failed (${response.status}): ${body || response.statusText}`);
+    }
+
+    const contentType = response.headers.get("content-type") ?? "";
+
+    if (contentType.includes("text/event-stream") && response.body) {
+      this.startReading(response.body);
+    }
+    else if (contentType.includes("application/json")) {
+      const text = await response.text();
+      if (text.trim()) {
+        try {
+          this.onmessage?.(JSON.parse(text));
+        } catch {
+          // ignored
+        }
+      }
+    }
+  }
+}
+
+export function createSSETransport(config: SSETransportConfig): Transport {
+  return new SSETransport(config) as unknown as Transport;
+}

package/packages/core/src/mcp/transports/websocket.ts

@@ -0,0 +1,159 @@
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+
+export interface WebSocketTransportConfig {
+  url: string;
+  headers?: Record<string, string>;
+  reconnect?: boolean;        // reconectar automáticamente si se cae (default: true)
+  reconnectDelay?: number;    // ms entre intentos de reconexión (default: 3000)
+  reconnectMaxAttempts?: number; // máximo de intentos (default: 10)
+}
+
+export class WebSocketTransport implements Transport {
+  private url: string;
+  private ws: WebSocket | null = null;
+  private headers?: Record<string, string>;
+  private intentionallyClosed = false;  // distingue close() manual de caída
+  private reconnectAttempts = 0;
+  private reconnectDelay: number;
+  private reconnectMaxAttempts: number;
+  private shouldReconnect: boolean;
+
+  onmessage: ((message: unknown) => void) | undefined;
+  onerror: ((error: Error) => void) | undefined;
+  onclose: (() => void) | undefined;
+
+  constructor(config: WebSocketTransportConfig) {
+    this.url = config.url;
+    this.headers = config.headers;
+    this.shouldReconnect = config.reconnect ?? true;
+    this.reconnectDelay = config.reconnectDelay ?? 3000;
+    this.reconnectMaxAttempts = config.reconnectMaxAttempts ?? 10;
+  }
+
+  async start(): Promise<void> {
+    this.intentionallyClosed = false;
+    this.reconnectAttempts = 0;
+    return this.connect();
+  }
+
+  private connect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+
+      // CORRECCIÓN 1 — headers en Bun WebSocket
+      // Bun acepta las opciones como segundo argumento cuando no hay subprotocols,
+      // o como objeto con `headers` dentro de un array de subprotocols vacío.
+      // La forma más segura y compatible:
+      const ws = this.headers && Object.keys(this.headers).length > 0
+        ? new WebSocket(this.url, {
+          // @ts-expect-error — Bun extiende la API estándar de WebSocket
+          headers: this.headers,
+        })
+        : new WebSocket(this.url);
+
+      this.ws = ws;
+      let resolved = false;
+
+      ws.onopen = () => {
+        resolved = true;
+        this.reconnectAttempts = 0; // reset contador al conectar exitosamente
+        resolve();
+      };
+
+      ws.onmessage = (event: MessageEvent) => {
+        try {
+          const data = JSON.parse(event.data as string);
+          this.onmessage?.(data);
+        } catch {
+          // Ignorar mensajes no-JSON (ping/pong, heartbeats)
+        }
+      };
+
+      // CORRECCIÓN 2 — separar el error de conexión del error post-conexión
+      ws.onerror = (event: Event) => {
+        const error =
+          (event as ErrorEvent).error ??
+          new Error(`WebSocket error en ${this.url}`);
+
+        if (!resolved) {
+          // Error durante la conexión inicial → rechazar la promesa
+          reject(error);
+        } else {
+          // Error después de conectar → notificar sin rechazar
+          this.onerror?.(error instanceof Error ? error : new Error(String(error)));
+        }
+      };
+
+      // CORRECCIÓN 3 — reconexión automática en cierre inesperado
+      ws.onclose = (event: CloseEvent) => {
+        this.ws = null;
+
+        if (this.intentionallyClosed) {
+          // Cierre manual con close() — notificar y no reconectar
+          this.onclose?.();
+          return;
+        }
+
+        if (!resolved) {
+          // Cierre antes de que se abriera → rechazar la promesa
+          reject(new Error(
+            `WebSocket cerrado antes de conectar — code: ${event.code}, reason: ${event.reason}`
+          ));
+          return;
+        }
+
+        // Cierre inesperado después de conectar
+        if (
+          this.shouldReconnect &&
+          this.reconnectAttempts < this.reconnectMaxAttempts
+        ) {
+          this.reconnectAttempts++;
+          const delay = this.reconnectDelay * this.reconnectAttempts; // backoff lineal
+
+          setTimeout(async () => {
+            try {
+              await this.connect();
+            } catch (err) {
+              this.onerror?.(err instanceof Error ? err : new Error(String(err)));
+              this.onclose?.();
+            }
+          }, delay);
+        } else {
+          // Sin más intentos → notificar cierre definitivo
+          this.onerror?.(new Error(
+            `WebSocket desconectado después de ${this.reconnectAttempts} intentos — ${this.url}`
+          ));
+          this.onclose?.();
+        }
+      };
+    });
+  }
+
+  async close(): Promise<void> {
+    this.intentionallyClosed = true; // marcar como cierre intencional
+    if (this.ws) {
+      // Código 1000 = cierre normal
+      this.ws.close(1000, "Client closed connection");
+      this.ws = null;
+    }
+  }
+
+  async send(message: unknown): Promise<void> {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error(
+        `WebSocket no está conectado — readyState: ${this.ws?.readyState ?? "null"}`
+      );
+    }
+    this.ws.send(JSON.stringify(message));
+  }
+
+  // Útil para health checks desde el MCP client
+  get isConnected(): boolean {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+  }
+}
+
+export function createWebSocketTransport(
+  config: WebSocketTransportConfig
+): Transport {
+  return new WebSocketTransport(config) as unknown as Transport;
+}