@johpaz/hive 1.7.2 → 1.7.3

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

@@ -1,241 +0,0 @@
-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/mcp/src/transports/websocket.ts

@@ -1,159 +0,0 @@
-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;
-}

package/packages/skills/package.json

@@ -1,21 +0,0 @@
-{
-  "name": "@johpaz/hive-skills",
-  "version": "1.7.2",
-  "private": true,
-  "description": "Hive Skills — Official bundled skills for Hive",
-  "main": "./src/index.ts",
-  "license": "MIT",
-  "files": [
-    "src/"
-  ],
-  "scripts": {
-    "test": "bun test"
-  },
-  "dependencies": {
-    "js-yaml": "latest"
-  },
-  "devDependencies": {
-    "typescript": "latest",
-    "@types/bun": "latest"
-  }
-}

package/packages/skills/src/index.ts

@@ -1 +0,0 @@
-export * from "./loader.ts";