@johpaz/hive 1.1.0

package/packages/mcp/src/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/mcp/src/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;
+}

package/packages/skills/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@johpaz/hive-skills",
+  "version": "1.1.0",
+  "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/bundled/agent_management/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: agent_management
+description: "Create and manage specialized agents within the swarm"
+version: 1.0.0
+author: Hive Team
+icon: "🤖"
+category: agents
+permissions:
+  - conversation_manage
+dependencies: []
+tools: [create_agent]
+---
+
+# Agent Management Skill
+
+Esta skill permite expandir las capacidades del enjambre creando nuevos agentes especializados para tareas específicas.
+
+## Herramientas Disponibles
+
+- `create_agent`: Crea un nuevo agente especializado con un propósito y capacidades definidas.
+
+## Mejores Prácticas
+- **Propósito Claro**: Define un propósito específico y conciso al crear un nuevo agente.
+- **Delegación**: Usa nuevos agentes cuando una tarea sea lo suficientemente compleja para requerir un enfoque dedicado.

package/packages/skills/src/bundled/browser_automation/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: browser_automation
+description: "Full control of a web browser for automation and scraping"
+version: 1.0.0
+author: Hive Team
+icon: "🌐"
+category: system
+permissions:
+  - browser_control
+  - conversation_manage
+dependencies: []
+tools: [browser_automation, browser_navigate, browser_fetch, browser_screenshot, browser_click, browser_type]
+---
+
+# Browser Automation Skill
+
+Esta skill permite controlar un navegador real para realizar tareas complejas de automatización, captura de pantalla e interacción con aplicaciones web.
+
+## Herramientas Disponibles
+
+- `browser_navigate`: Navega a una URL específica.
+- `browser_fetch`: Obtiene el contenido HTML o Markdown de la página actual.
+- `browser_screenshot`: Toma una captura de pantalla de la página o de un elemento.
+- `browser_click`: Haz clic en un elemento identificado por un selector CSS.
+- `browser_type`: Escribe texto en un campo de entrada.
+
+## Mejores Prácticas
+- **Esperas**: Asegúrate de que la página haya cargado completamente antes de interactuar.
+- **Selectores**: Usa selectores de CSS robustos e identificables.
+- **Capturas**: Usa capturas de pantalla para verificar el estado visual de una página si hay errores.

package/packages/skills/src/bundled/context_compact/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: context_compact
+description: "Conversation history management and content summarization"
+version: 1.0.0
+author: Hive Team
+icon: "📦"
+category: system
+permissions:
+  - conversation_manage
+dependencies: []
+tools: [context_compact]
+---
+
+# Context Compact Skill
+
+Esta skill gestiona la memoria a corto plazo del agente, resumiendo conversaciones largas para mantener el rendimiento y la relevancia sin perder el hilo de la charla.
+
+## Funcionamiento Automático
+
+A diferencia de otras skills, `context_compact` no proporciona herramientas (tools) manuales para el agente. Es una **capacidad intrínseca del sistema** que se activa automáticamente cuando el historial de mensajes alcanza un umbral crítico de tokens.
+
+El motor de compactación:
+1. Analiza el historial de mensajes cuando excede el límite configurado.
+2. Genera un resumen interactivo de los temas claves.
+3. Preserva las respuestas más recientes y las llamadas a herramientas que aún esperan resultado.
+4. Sustituye los mensajes antiguos por el resumen para liberar espacio en el contexto.
+
+## Interacción del Agente
+
+El agente no necesita invocar ninguna tool para "compactar". Si el sistema detecta saturación, realizará el proceso de forma transparente antes de la siguiente respuesta del modelo.
+
+## Beneficios
+- **Velocidad**: Reduce la latencia de respuesta en conversaciones largas.
+- **Rendimiento**: Menor consumo de tokens de entrada.
+- **Limpieza**: Enfoca la atención del modelo en la tarea actual actual.

package/packages/skills/src/bundled/cron_manager/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: cron_manager
+description: "Schedule and manage automated tasks using cron expressions"
+version: 1.0.0
+author: Hive Team
+icon: "⏰"
+category: system
+permissions:
+  - cron_manage
+dependencies: []
+tools: [cron_manager, cron_add, cron_list, cron_edit, cron_remove]
+---
+
+# Cron Manager Skill
+
+Esta skill permite al agente programar y gestionar tareas automatizadas que se ejecutan periódicamente.
+
+## Herramientas Disponibles
+
+- `cron_add`: Añade una nueva tarea programada.
+- `cron_list`: Lista todas las tareas programadas actualmente.
+- `cron_edit`: Edita una tarea existente (cambia la expresión cron o la tarea).
+- `cron_remove`: Elimina una tarea programada por su ID.
+
+## Formato de Expresión Cron
+
+```
+┌───────────── minuto (0 - 59)
+│ ┌───────────── hora (0 - 23)
+│ │ ┌───────────── día del mes (1 - 31)
+│ │ │ ┌───────────── mes (1 - 12)
+│ │ │ │ ┌───────────── día de la semana (0 - 6) (Domingo = 0)
+│ │ │ │ │
+* * * * *
+```
+
+## Ejemplos de Uso
+
+### Programar un informe diario
+```javascript
+cron_add({ expression: "0 9 * * *", task: "Enviar resumen diario de actividades" })
+```
+
+### Listar tareas para obtener el ID
+```javascript
+cron_list({})
+```
+
+## Mejores Prácticas
+- Usa expresiones cron descriptivas.
+- Verifica siempre que la tarea programada sea clara para evitar ejecuciones inesperadas.
+- Limpia las tareas viejas que ya no sean necesarias.

package/packages/skills/src/bundled/file_manager/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: file_manager
+description: "Read, write, and manage files in the workspace"
+version: 1.0.0
+author: Hive Team
+icon: "📁"
+category: tools
+permissions:
+  - filesystem_read
+  - filesystem_write
+dependencies: []
+tools: [file_manager, read, write, edit, fs_read, fs_write, fs_list, fs_mkdir, fs_delete, fs_copy, fs_move, project_read, project_write, project_list, workspace_read, workspace_write, workspace_patch, workspace_append]
+---
+
+# File Manager Skill
+
+Esta skill permite al agente gestionar archivos y directorios en el espacio de trabajo, incluyendo herramientas específicas para proyectos y configuración del sistema.
+
+## Herramientas Disponibles
+
+### Gestión de Archivos (Básico)
+- `read`: Lee el contenido de un archivo (con soporte para `offset` y `limit`).
+- `write`: Crea o sobrescribe un archivo.
+- `edit`: Realiza ediciones específicas reemplazando cadenas de texto.
+
+### Sistema de Archivos Avanzado (`fs_*`)
+- `fs_read`: Lee un archivo del sistema de archivos.
+- `fs_write`: Escribe contenido en un archivo.
+- `fs_list`: Lista el contenido de un directorio (soporta recursividad).
+- `fs_mkdir`: Crea directorios.
+- `fs_delete`: Elimina archivos o directorios.
+- `fs_copy`: Copia archivos.
+- `fs_move`: Mueve o renombra archivos.
+
+### Gestión de Proyecto (`project_*`)
+- `project_read`: Lee archivos relativos a la ruta del proyecto.
+- `project_write`: Escribe archivos en el proyecto.
+- `project_edit`: Edita secciones de archivos del proyecto.
+- `project_list`: Explora la estructura del proyecto.
+- `project_glob`: Busca archivos usando patrones glob (ej: `**/*.ts`).
+- `project_exists`: Verifica la existencia de archivos/directorios.
+
+### Espacio de Trabajo (`workspace_*`)
+- `workspace_read`: Consulta archivos de identidad (`soul`), usuario (`user`) o ética (`ethics`).
+- `workspace_write`: Reescribe archivos de configuración.
+- `workspace_patch`: Modifica secciones específicas de archivos Markdown.
+- `workspace_append`: Añade información a secciones existentes.
+
+## Ejemplo de Uso
+
+### Lectura de Archivo con Líneas
+```javascript
+read({ path: "src/main.ts", offset: 1, limit: 100 })
+```
+
+### Búsqueda de Archivos
+```javascript
+project_glob({ pattern: "packages/**/*.json" })
+```
+
+### Actualización de Perfil de Usuario
+```javascript
+workspace_patch({ 
+  file: "user", 
+  section: "Preferencias", 
+  newContent: "Tema: oscuro", 
+  reason: "Usuario cambió preferencia" 
+})
+```
+
+## Mejores Prácticas
+
+- **Lectura Previa**: Siempre lee un archivo antes de editarlo para entender su estructura.
+- **Paginación**: Usa `offset` y `limit` en archivos grandes para evitar saturar el contexto.
+- **Rutas Relativas**: Prefiere herramientas de `project` para manipular archivos del código fuente.
+- **Workspace**: Usa `workspace_patch` en lugar de `workspace_write` para cambios pequeños.

package/packages/skills/src/bundled/http_client/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: http_client
+description: "Fetch web content and interact with external APIs"
+version: 1.0.0
+author: Hive Team
+icon: "🌐"
+category: tools
+permissions:
+  - internet_access
+dependencies: []
+tools: [http_client, web_fetch]
+---
+
+# HTTP Client Skill
+
+Esta skill permite al agente descargar contenido de la web o interactuar con APIs externas.
+
+## Herramientas Disponibles
+
+- `web_fetch`: Descarga el contenido de una URL (HTML convertido a Markdown para fácil lectura por el agente).
+
+## Mejores Prácticas
+- **Validación**: Verifica siempre que la URL sea correcta y segura.
+- **Sintetización**: Extrae solo la información relevante del contenido descargado para no exceder el límite de contexto.