@johpaz/hive-sdk 0.4.3 → 0.4.4

package/README.md

@@ -230,4 +230,4 @@ npm view @johpaz/hive-sdk dist-tags   # verificar después del release
 
 ---
 
-*Hive SDK v0.4.3 — MIT*
+*Hive SDK v0.4.4 — MIT*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johpaz/hive-sdk",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "private": false,
   "description": "Hive SDK — The Agent Harness SDK. Build, deploy, and scale AI agent applications with multi-channel support, context engineering, and swarm orchestration.",
   "license": "MIT",
@@ -80,7 +80,7 @@
     "LICENSE"
   ],
   "engines": {
-    "bun": ">=1.4.0"
+    "bun": ">=1.4.2"
   },
   "workspaces": [
     "packages/core",
@@ -115,15 +115,15 @@
     "mammoth": "^1.12.0",
     "ollama": "^0.6.3",
     "openai": "^6.18.0",
-    "pdfjs-dist": "^5.6.205",
+    "pdfjs-dist": "^6.3.289",
     "pptxgenjs": "^4.0.1",
     "qrcode-terminal": "^0.12.0",
     "toon-format-parser": "^1.1.0",
-    "xlsx": "^0.18.5",
+    "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz",
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@types/bun": "^1.3.13",
+    "@types/bun": "^1.4.1",
     "@types/jsonwebtoken": "^9.0.10",
     "typescript": "6.0.2"
   }

package/packages/cli/templates/hive-app/package.json

@@ -12,5 +12,8 @@
   },
   "devDependencies": {
     "@types/bun": "latest"
+  },
+  "engines": {
+    "bun": ">=1.4.2"
   }
 }

package/packages/core/src/config/loader.ts

@@ -1,3 +1,4 @@
+import { resolvePort } from "../utils/port.ts";
 import * as z from "zod";
 import { mkdirSync, existsSync, readFileSync } from "node:fs";
 import * as path from "node:path";
@@ -407,7 +408,7 @@ function buildDefaultConfig(): Config {
   return {
     gateway: {
       host: process.env.HIVE_HOST || "127.0.0.1",
-      port: parseInt(process.env.HIVE_PORT || "18790", 10),
+      port: resolvePort(process.env.HIVE_PORT, 18790),
       pidFile: path.join(hiveDir, "gateway.pid"),
       authToken: process.env.HIVE_AUTH_TOKEN || undefined,
       tools: {

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

@@ -96,11 +96,17 @@ export class SSETransport implements Transport {
       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());
+    // Track cookies for session affinity (important for n8n/proxies).
+    //
+    // `getSetCookie()` y no `get("set-cookie")`: Set-Cookie es la única cabecera
+    // que puede repetirse sin combinarse, y `get()` devuelve las repeticiones
+    // unidas con ", " (Bun 1.4 lo alineó con la spec de Fetch). Partir eso por
+    // coma rompe cualquier cookie cuyo valor lleve una —`Expires=Wed, 09 Jun
+    // 2027 10:18:14 GMT` es el caso de todos los días— y dejaba fragmentos como
+    // "09 Jun 2027 10:18:14 GMT" haciéndose pasar por cookies.
+    const setCookies = response.headers.getSetCookie();
+    if (setCookies.length > 0) {
+      const newCookies = setCookies.map(c => c.split(";")[0].trim());
       this.cookies = [...new Set([...this.cookies, ...newCookies])];
     }
   }

package/packages/core/src/scheduler/CronScheduler.ts

@@ -7,9 +7,11 @@
  * El motor de cron es propio (`./cron`), sin dependencias: sólo `setTimeout` e
  * `Intl` del runtime. Antes era `croner`.
  *
- * `Bun.cron()` no sirve como reemplazo —se evaluó contra el runtime 1.4.0—:
+ * `Bun.cron()` no sirve como reemplazo —reevaluado contra el runtime 1.4.2—:
  * acepta sólo 5 campos y rechaza el sexto, no admite una fecha ISO como patrón
- * (que es como se agendan los jobs `one_shot`), ignora la zona horaria, y su
+ * (que es como se agendan los jobs `one_shot`), no toma una zona por job (usa la
+ * local del proceso desde 1.4; antes era UTC, y ese cambio silencioso es
+ * justamente por qué no conviene delegarle la conversión), y su
  * handle no expone la próxima corrida, que es de donde sale `next_run_at` y con
  * lo que se detectan las corridas perdidas al arrancar. Tampoco tiene
  * equivalente de `protect`, `maxRuns`, `interval`, `startAt`/`stopAt` ni

package/packages/core/src/scheduler/cron/job.ts

@@ -8,7 +8,8 @@
  * habría sido migrar la base para no ganar nada.
  *
  * No usa `Bun.cron()`: ese sólo acepta 5 campos, no admite una fecha ISO como
- * patrón —que es como se agendan los jobs `one_shot`—, ignora la zona horaria y
+ * patrón —que es como se agendan los jobs `one_shot`—, no toma una zona por job
+ * (usa la local del proceso desde Bun 1.4; antes era UTC) y
  * su handle no expone la próxima corrida, que es de donde sale `next_run_at` y
  * con lo que el scheduler detecta las corridas perdidas al arrancar. Lo que sí
  * se usa de Bun es el runtime pelado: `setTimeout` e `Intl`.

package/packages/core/src/scheduler/cron/zoned-time.ts

@@ -2,7 +2,8 @@
  * Reloj de pared ↔ instante, en una zona horaria IANA.
  *
  * Es la parte difícil de un cron con zona horaria y la razón por la que no
- * alcanza con `Bun.cron.parse()`, que sólo trabaja en UTC. "Todos los días a
+ * alcanza con `Bun.cron.parse()`, que resuelve en una sola zona —UTC hasta Bun
+ * 1.3, la local del proceso desde 1.4— y nunca en la del job. "Todos los días a
  * las 9" significa las 9 **del reloj de la pared en Bogotá**, y ese instante se
  * corre una hora dos veces al año en las zonas con horario de verano. Calcular
  * el offset una sola vez y sumarlo produce un cron que se desfasa un día al año

package/packages/core/src/tools/office/office-leer-pdf.ts

@@ -10,6 +10,14 @@ import type { Tool } from "../types.ts";
 import { logger } from "../../utils/logger.ts";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  assertBeforeDeadline,
+  MAX_PDF_INPUT_BYTES,
+  MAX_PDF_PAGES_PER_REQUEST,
+  OFFICE_PROCESSING_TIMEOUT_MS,
+  validateOfficeInput,
+} from "./security-limits.ts";
 
 const log = logger.child("office-leer-pdf");
 
@@ -48,61 +56,102 @@ export const officeLeerPdfTool: Tool = {
         return { ok: false, error: `Archivo no encontrado: ${rutaAbsoluta}` };
       }
 
+      const inputError = validateOfficeInput(
+        rutaAbsoluta,
+        MAX_PDF_INPUT_BYTES,
+        "El PDF",
+      );
+      if (inputError) return { ok: false, error: inputError };
+
       const buffer = fs.readFileSync(rutaAbsoluta);
       const uint8Array = new Uint8Array(buffer);
 
-      // Importar pdfjs-dist (compatible con Bun, sin worker)
+      // La build legacy conserva compatibilidad con Bun. PDF.js configura su
+      // propio fake worker en Node/Bun; borrar workerSrc rompe PDF.js 6+.
       const pdfjsLib = await import("pdfjs-dist/legacy/build/pdf.mjs" as any).catch(
         () => import("pdfjs-dist" as any)
       );
 
-      // Desactivar worker para entorno Node/Bun
       const lib = pdfjsLib.default ?? pdfjsLib;
-      if (lib.GlobalWorkerOptions) {
-        lib.GlobalWorkerOptions.workerSrc = "";
-      }
-
-      const doc = await lib.getDocument({ data: uint8Array, disableWorker: true }).promise;
-      const totalPaginas = doc.numPages;
+      const pdfjsPackageUrl = import.meta.resolve("pdfjs-dist/package.json");
+      const loadingTask = lib.getDocument({
+        data: uint8Array,
+        enableScripting: false,
+        isEvalSupported: false,
+        // Bun's process.getBuiltinModule("fs/promises") expects a filesystem
+        // path here; a file:// URL string is not accepted.
+        standardFontDataUrl: fileURLToPath(
+          new URL("./standard_fonts/", pdfjsPackageUrl),
+        ),
+      });
 
-      // Metadata
-      let titulo: string | undefined;
       try {
-        const meta = await doc.getMetadata();
-        titulo = (meta?.info as any)?.Title ?? undefined;
-      } catch {
-        // metadata opcional
+        const deadline = Date.now() + OFFICE_PROCESSING_TIMEOUT_MS;
+        const doc = await loadingTask.promise;
+        const totalPaginas = doc.numPages;
+
+        // Metadata
+        let titulo: string | undefined;
+        try {
+          const meta = await doc.getMetadata();
+          titulo = (meta?.info as any)?.Title ?? undefined;
+        } catch {
+          // metadata opcional
+        }
+
+        const inicio = paginaInicio;
+        if (!Number.isInteger(inicio) || inicio > totalPaginas) {
+          return {
+            ok: false,
+            error: `La página inicial debe estar entre 1 y ${totalPaginas}`,
+          };
+        }
+        if (paginaFin !== undefined && (!Number.isInteger(paginaFin) || paginaFin < inicio)) {
+          return {
+            ok: false,
+            error: "La página final debe ser un entero mayor o igual a la página inicial",
+          };
+        }
+
+        const fin = paginaFin ? Math.min(paginaFin, totalPaginas) : totalPaginas;
+        const paginasSolicitadas = fin - inicio + 1;
+        if (paginasSolicitadas > MAX_PDF_PAGES_PER_REQUEST) {
+          return {
+            ok: false,
+            error: `Se pueden leer como máximo ${MAX_PDF_PAGES_PER_REQUEST} páginas por solicitud`,
+          };
+        }
+
+        const textosPorPagina: Array<{ pagina: number; texto: string }> = [];
+
+        for (let i = inicio; i <= fin; i++) {
+          assertBeforeDeadline(deadline, "La lectura del PDF");
+          const pagina = await doc.getPage(i);
+          const contenido = await pagina.getTextContent();
+          const texto = (contenido.items as any[])
+            .map((item: any) => item.str ?? "")
+            .join(" ")
+            .replace(/\s+/g, " ")
+            .trim();
+          textosPorPagina.push({ pagina: i, texto });
+        }
+
+        const textoCompleto = textosPorPagina.map((p) => p.texto).join("\n\n");
+
+        log.info(`PDF leído: ${totalPaginas} páginas, ${textoCompleto.length} caracteres`);
+
+        return {
+          ok: true,
+          ruta: rutaAbsoluta,
+          totalPaginas,
+          paginasLeidas: paginasSolicitadas,
+          titulo,
+          texto: textoCompleto,
+          paginas: textosPorPagina,
+        };
+      } finally {
+        await loadingTask.destroy();
       }
-
-      const inicio = paginaInicio;
-      const fin = paginaFin ? Math.min(paginaFin, totalPaginas) : totalPaginas;
-
-      const textosPorPagina: Array<{ pagina: number; texto: string }> = [];
-
-      for (let i = inicio; i <= fin; i++) {
-        const pagina = await doc.getPage(i);
-        const contenido = await pagina.getTextContent();
-        const texto = (contenido.items as any[])
-          .map((item: any) => item.str ?? "")
-          .join(" ")
-          .replace(/\s+/g, " ")
-          .trim();
-        textosPorPagina.push({ pagina: i, texto });
-      }
-
-      const textoCompleto = textosPorPagina.map((p) => p.texto).join("\n\n");
-
-      log.info(`PDF leído: ${totalPaginas} páginas, ${textoCompleto.length} caracteres`);
-
-      return {
-        ok: true,
-        ruta: rutaAbsoluta,
-        totalPaginas,
-        paginasLeidas: fin - inicio + 1,
-        titulo,
-        texto: textoCompleto,
-        paginas: textosPorPagina,
-      };
     } catch (error) {
       log.error(`Error leyendo PDF: ${(error as Error).message}`);
       return {

package/packages/core/src/tools/office/office-leer-xlsx.ts

@@ -11,6 +11,14 @@ import { logger } from "../../utils/logger.ts";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { cargarXlsx } from "./xlsx-loader.ts";
+import {
+  assertBeforeDeadline,
+  MAX_XLSX_INPUT_BYTES,
+  MAX_XLSX_ROWS_PER_SHEET,
+  MAX_XLSX_SHEETS,
+  OFFICE_PROCESSING_TIMEOUT_MS,
+  validateOfficeInput,
+} from "./security-limits.ts";
 
 const log = logger.child("office-leer-xlsx");
 
@@ -56,32 +64,43 @@ export const officeLeerXlsxTool: Tool = {
         return { ok: false, error: `Archivo no encontrado: ${rutaAbsoluta}` };
       }
 
+      const inputError = validateOfficeInput(
+        rutaAbsoluta,
+        MAX_XLSX_INPUT_BYTES,
+        "El XLSX",
+      );
+      if (inputError) return { ok: false, error: inputError };
+
       const XLSX = await cargarXlsx();
       const buffer = fs.readFileSync(rutaAbsoluta);
-      const workbook = XLSX.read(buffer, { type: "buffer" });
+      const deadline = Date.now() + OFFICE_PROCESSING_TIMEOUT_MS;
+      const workbook = XLSX.read(buffer, {
+        type: "buffer",
+        sheetRows: MAX_XLSX_ROWS_PER_SHEET + 2,
+        sheets: hojaFiltro,
+      });
 
       const nombresHojas = hojaFiltro
         ? [hojaFiltro]
         : workbook.SheetNames;
 
+      if (nombresHojas.length > MAX_XLSX_SHEETS) {
+        return {
+          ok: false,
+          error: `El XLSX contiene más de ${MAX_XLSX_SHEETS} hojas`,
+        };
+      }
+
       const hojas: Record<string, any[]> = {};
 
       for (const nombreHoja of nombresHojas) {
+        assertBeforeDeadline(deadline, "La lectura del XLSX");
         const hoja = workbook.Sheets[nombreHoja];
         if (!hoja) {
           log.warn(`Hoja '${nombreHoja}' no encontrada en el archivo`);
           continue;
         }
 
-        const opciones: any = {
-          header: incluirEncabezados ? 1 : 1,
-          defval: "",
-        };
-
-        if (rango) {
-          opciones.range = rango;
-        }
-
         if (incluirEncabezados) {
           // La primera fila se usa como encabezados
           hojas[nombreHoja] = XLSX.utils.sheet_to_json(hoja, {
@@ -96,6 +115,13 @@ export const officeLeerXlsxTool: Tool = {
             range: rango,
           });
         }
+
+        if (hojas[nombreHoja].length > MAX_XLSX_ROWS_PER_SHEET) {
+          return {
+            ok: false,
+            error: `La hoja '${nombreHoja}' supera el máximo de 10.000 filas`,
+          };
+        }
       }
 
       const totalFilas = Object.values(hojas).reduce(

package/packages/core/src/tools/office/security-limits.ts

@@ -0,0 +1,28 @@
+import { statSync } from "node:fs";
+
+export const MAX_PDF_INPUT_BYTES = 25 * 1024 * 1024;
+export const MAX_XLSX_INPUT_BYTES = 15 * 1024 * 1024;
+export const MAX_PDF_PAGES_PER_REQUEST = 200;
+export const MAX_XLSX_SHEETS = 50;
+export const MAX_XLSX_ROWS_PER_SHEET = 10_000;
+export const OFFICE_PROCESSING_TIMEOUT_MS = 30_000;
+
+export function validateOfficeInput(
+  filePath: string,
+  maxBytes: number,
+  label: string,
+): string | null {
+  const stat = statSync(filePath);
+  if (!stat.isFile()) return `${label} debe ser un archivo regular`;
+  if (stat.size > maxBytes) {
+    const maxMiB = maxBytes / (1024 * 1024);
+    return `${label} excede el límite de ${maxMiB} MiB`;
+  }
+  return null;
+}
+
+export function assertBeforeDeadline(deadline: number, label: string): void {
+  if (Date.now() > deadline) {
+    throw new Error(`${label} excedió el límite de procesamiento de 30 segundos`);
+  }
+}

package/packages/core/src/utils/port.ts

@@ -0,0 +1,33 @@
+/**
+ * Resolución de puertos desde el entorno.
+ *
+ * Bun 1.4 endureció `Bun.serve`: un puerto fuera de `[0, 65535]` —o `NaN`, que
+ * es lo que devuelve `parseInt("no-es-un-numero")`— ahora lanza `RangeError` en
+ * vez de recortar el valor. Un `HIVE_PORT` mal escrito dejó de degradar y pasó a
+ * tumbar el arranque con una excepción sin capturar:
+ *
+ *     RangeError: The value of "options.port" is out of range.
+ *                 It must be an integer. Received NaN
+ *
+ * Este helper vuelve a la degradación explícita: avisa y sigue con el puerto por
+ * defecto, que para una variable de entorno mal tipeada es el comportamiento
+ * útil. El `0` se deja pasar a propósito: `Bun.serve` lo interpreta como "asigná
+ * un puerto libre" y hay código que se apoya en eso.
+ *
+ * Avisa con `console.warn` y no con el logger del proyecto a propósito: esto lo
+ * usa `config/loader.ts`, y el logger importa `config/loader.ts` para saber
+ * dónde escribir. Importarlo acá cierra el ciclo y rompe con "Cannot access
+ * 'logger' before initialization". Además, cuando se resuelve un puerto el
+ * logger todavía no está configurado.
+ */
+
+export function resolvePort(raw: unknown, fallback: number): number {
+  if (raw === undefined || raw === null || raw === "") return fallback
+
+  const n = typeof raw === "number" ? raw : Number(String(raw).trim())
+  if (!Number.isInteger(n) || n < 0 || n > 65535) {
+    console.warn(`[config] Puerto inválido ${JSON.stringify(raw)}; se usa ${fallback}`)
+    return fallback
+  }
+  return n
+}

package/packages/core/src/voice/index.ts

@@ -1,3 +1,4 @@
+import { resolvePort } from "../utils/port.ts";
 import { col } from "../storage/hive.ts";
 import type { ChannelDoc, ModelDoc } from "../storage/collections.ts";
 import { loadProviderApiKey } from "../storage/crypto.ts";
@@ -281,7 +282,7 @@ class VoiceService {
 
   private async speakWithPiper(text: string, voiceId?: string): Promise<AudioOutput> {
     const cleanText = cleanTextForTTS(text);
-    const port = Number(process.env.TTS_PORT ?? 5500);
+    const port = resolvePort(process.env.TTS_PORT, 5500);
     const res = await fetch(`http://localhost:${port}/tts`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },