utn-mcp 0.1.0 → 0.2.1

package/build/http.js

@@ -6,11 +6,6 @@ const asMiddleware = (guard) => (req, res, next) => {
     if (guard(req, res))
         next();
 };
-/**
- * Entrada HTTP local: solo escucha en 127.0.0.1 y rechaza Host/Origin que no sean
- * localhost, para que una página web no pueda usar tu sesión de la UTN (DNS rebinding).
- * El modo hosteado va a reutilizar el mismo `factory`, con OAuth y una sesión por usuario.
- */
 export function startHttpServer(factory, port) {
     const handler = createMcpHandler(factory, { onerror: (e) => logger.error(e.message) });
     const app = express();

package/build/server.js

@@ -4,7 +4,7 @@ import { registerAulaVirtualTools } from "./aula-virtual/tools.js";
 export function createServer(aula) {
     const server = new McpServer({
         name: "UTN-MCP",
-        version: "0.1.0",
+        version: "0.2.1",
     });
     registerAulaVirtualTools(server, aula);
     return server;

package/build/shared/documents/index.js

@@ -0,0 +1,68 @@
+import { htmlToText } from "../html.js";
+import { abrirOffice, formatoOffice } from "./office.js";
+import { abrirPdf } from "./pdf.js";
+export class FormatoNoSoportado extends Error {
+    formato;
+    constructor(formato) {
+        super(`No sé leer archivos ${formato}.`);
+        this.formato = formato;
+        this.name = "FormatoNoSoportado";
+    }
+}
+/** Tamaño de cada fragmento cuando un texto largo viene de una sola pieza (un docx, un html). */
+export const FRAGMENTO = 15_000;
+const IMAGENES = [
+    [[0x89, 0x50, 0x4e, 0x47], "image/png"],
+    [[0xff, 0xd8, 0xff], "image/jpeg"],
+    [[0x47, 0x49, 0x46, 0x38], "image/gif"],
+];
+const empieza = (bytes, firma) => firma.every((b, i) => bytes[i] === b);
+/** Reconoce el formato por los primeros bytes; el nombre solo se usa para los de texto plano. */
+export async function abrirDocumento(bytes, nombre) {
+    if (empieza(bytes, [0x25, 0x50, 0x44, 0x46]))
+        return abrirPdf(bytes);
+    for (const [firma, mimeType] of IMAGENES) {
+        if (empieza(bytes, firma))
+            return deTexto("imagen", "imagen", [{ imagen: bytes, mimeType }]);
+    }
+    if (empieza(bytes, [0x50, 0x4b, 0x03, 0x04])) {
+        const formato = formatoOffice(bytes);
+        if (!formato)
+            throw new FormatoNoSoportado("comprimidos (.zip)");
+        return abrirOffice(bytes, formato);
+    }
+    if (empieza(bytes, [0xd0, 0xcf, 0x11, 0xe0])) {
+        throw new FormatoNoSoportado("de Office viejo (.doc, .xls, .ppt, .pps)");
+    }
+    const extension = nombre.toLowerCase().match(/\.(\w+)$/)?.[1] ?? "";
+    if (["txt", "csv", "md", "html", "htm"].includes(extension)) {
+        const texto = new TextDecoder().decode(bytes);
+        const plano = extension.startsWith("htm") ? htmlToText(texto) : texto;
+        return deTexto(extension, "fragmento", fragmentar(plano).map((t) => ({ texto: t })));
+    }
+    throw new FormatoNoSoportado(extension ? `.${extension}` : "de este tipo");
+}
+/** Un documento que ya está entero en memoria. */
+export function deTexto(formato, unidad, partes) {
+    return {
+        formato,
+        unidad,
+        total: partes.length,
+        parte: async (n) => partes[n - 1],
+        cerrar: async () => { },
+    };
+}
+/** Corta un texto largo en pedazos de hasta `max` caracteres, prefiriendo cortar en un salto de línea. */
+export function fragmentar(texto, max = FRAGMENTO) {
+    const fragmentos = [];
+    let resto = texto.trim();
+    while (resto.length > max) {
+        const corte = resto.lastIndexOf("\n", max);
+        const fin = corte > max / 2 ? corte : max;
+        fragmentos.push(resto.slice(0, fin).trim());
+        resto = resto.slice(fin).trim();
+    }
+    if (resto || fragmentos.length === 0)
+        fragmentos.push(resto);
+    return fragmentos;
+}

package/build/shared/documents/office.js

@@ -0,0 +1,118 @@
+import { deTexto, fragmentar } from "./index.js";
+import { leerEntrada, listarZip } from "./zip.js";
+/** Tope por entrada descomprimida: un XML de texto de más que esto es un zip malicioso o no es un documento. */
+const MAX_ENTRADA = 50 * 1024 * 1024;
+const MARCAS = {
+    docx: "word/document.xml",
+    pptx: "ppt/presentation.xml",
+    xlsx: "xl/workbook.xml",
+};
+/** Mira la lista de entradas del zip sin descomprimir nada. */
+export function formatoOffice(bytes) {
+    const nombres = new Set(listarZip(bytes).map((e) => e.nombre));
+    return Object.keys(MARCAS).find((f) => nombres.has(MARCAS[f])) ?? null;
+}
+export function abrirOffice(bytes, formato) {
+    const texto = new TextDecoder();
+    const zip = Object.fromEntries(listarZip(bytes)
+        .filter((e) => necesaria(formato, e.nombre))
+        .map((e) => [e.nombre, texto.decode(leerEntrada(bytes, e, MAX_ENTRADA))]));
+    switch (formato) {
+        case "docx":
+            return deTexto("docx", "fragmento", fragmentar(xmlTexto(leer(zip, "word/document.xml"), "w")).map((texto) => ({ texto })));
+        case "pptx":
+            return deTexto("pptx", "diapositiva", Object.keys(zip)
+                .filter((p) => /^ppt\/slides\/slide\d+\.xml$/.test(p))
+                .sort((a, b) => numero(a) - numero(b))
+                .map((p) => ({ texto: xmlTexto(leer(zip, p), "a") || "(diapositiva sin texto)" })));
+        case "xlsx":
+            return deTexto("xlsx", "fragmento", hojas(zip).flatMap(({ nombre, texto }) => {
+                const partes = fragmentar(texto);
+                return partes.map((t, i) => ({
+                    titulo: partes.length > 1 ? `hoja "${nombre}" (${i + 1}/${partes.length})` : `hoja "${nombre}"`,
+                    texto: t,
+                }));
+            }));
+    }
+}
+function necesaria(formato, nombre) {
+    switch (formato) {
+        case "docx":
+            return nombre === "word/document.xml";
+        case "pptx":
+            return /^ppt\/slides\/slide\d+\.xml$/.test(nombre);
+        case "xlsx":
+            return nombre === "xl/workbook.xml" || nombre === "xl/sharedStrings.xml" ||
+                nombre === "xl/_rels/workbook.xml.rels" || nombre.startsWith("xl/worksheets/");
+    }
+}
+const leer = (zip, ruta) => zip[ruta] ?? "";
+const numero = (ruta) => Number(ruta.match(/(\d+)\.xml$/)?.[1]);
+const ENTIDADES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+const decodificar = (s) => s.replace(/&(#x[0-9a-f]+|#\d+|\w+);/gi, (m, e) => e[0] !== "#" ? (ENTIDADES[e] ?? m) : String.fromCodePoint(e[1].toLowerCase() === "x" ? parseInt(e.slice(2), 16) : Number(e.slice(1))));
+/**
+ * Texto de un XML de Word (`w`) o PowerPoint (`a`), recorriendo los tags en orden: texto de los nodos
+ * de texto, salto de línea al cerrar un párrafo, y las tablas como filas con celdas separadas por " | ".
+ */
+function xmlTexto(xml, ns) {
+    let out = "";
+    let enTexto = false;
+    let enCelda = 0;
+    for (const [, cierre, tag, , autocierre, chars] of xml.matchAll(/<(\/?)([\w:]+)((?:[^>"]|"[^"]*")*?)(\/?)>|([^<]+)/g)) {
+        if (chars !== undefined) {
+            if (enTexto)
+                out += decodificar(chars);
+        }
+        else if (tag === `${ns}:t`) {
+            enTexto = !cierre && !autocierre;
+        }
+        else if (tag === `${ns}:tc` && !autocierre) {
+            enCelda += cierre ? -1 : 1;
+            if (cierre)
+                out += " | ";
+        }
+        else if (tag === `${ns}:tr` && cierre) {
+            out += "\n";
+        }
+        else if (tag === `${ns}:p` && cierre) {
+            out += enCelda ? " " : "\n";
+        }
+        else if (tag === `${ns}:tab`) {
+            out += " ";
+        }
+        else if (tag === `${ns}:br`) {
+            out += enCelda ? " " : "\n";
+        }
+    }
+    return out
+        .split("\n")
+        .map((l) => l.replace(/\s+/g, " ").replace(/\s*\|\s*$/, "").trim())
+        .filter((l, i, todas) => l !== "|" && (l !== "" || todas[i - 1] !== ""))
+        .join("\n")
+        .trim();
+}
+/** Cada hoja como filas de celdas separadas por tabs, en el orden del libro. */
+function hojas(zip) {
+    const compartidas = [...leer(zip, "xl/sharedStrings.xml").matchAll(/<si>([\s\S]*?)<\/si>/g)].map((m) => decodificar([...m[1].matchAll(/<t[^>]*>([\s\S]*?)<\/t>/g)].map((t) => t[1]).join("")));
+    const rels = Object.fromEntries([...leer(zip, "xl/_rels/workbook.xml.rels").matchAll(/<Relationship [^>]*>/g)].map(([tag]) => [
+        tag.match(/Id="([^"]+)"/)?.[1],
+        tag.match(/Target="([^"]+)"/)?.[1],
+    ]));
+    return [...leer(zip, "xl/workbook.xml").matchAll(/<sheet [^>]*>/g)].map(([tag]) => {
+        const nombre = decodificar(tag.match(/name="([^"]*)"/)?.[1] ?? "");
+        const destino = rels[tag.match(/r:id="([^"]+)"/)?.[1] ?? ""] ?? "";
+        const ruta = destino.replace(/^\//, "").replace(/^(xl\/)?/, "xl/");
+        const filas = [...leer(zip, ruta).matchAll(/<row[^>]*>([\s\S]*?)<\/row>/g)].map((fila) => [...fila[1].matchAll(/<c ([^>]*?)(?:\/>|>([\s\S]*?)<\/c>)/g)]
+            .map(([, attrs, cuerpo = ""]) => {
+            const tipo = attrs.match(/\bt="(\w+)"/)?.[1];
+            if (tipo === "s")
+                return compartidas[Number(cuerpo.match(/<v>(\d+)<\/v>/)?.[1])] ?? "";
+            if (tipo === "inlineStr")
+                return decodificar(cuerpo.match(/<t[^>]*>([\s\S]*?)<\/t>/)?.[1] ?? "");
+            return decodificar(cuerpo.match(/<v>([\s\S]*?)<\/v>/)?.[1] ?? "");
+        })
+            .join("\t")
+            .replace(/\t+$/, ""));
+        return { nombre, texto: filas.filter(Boolean).join("\n") || "(hoja vacía)" };
+    });
+}

package/build/shared/documents/pdf.js

@@ -0,0 +1,164 @@
+import { pngGris } from "./png.js";
+/**
+ * pdf.js no es una dependencia: scripts/vendor-pdfjs.mjs copia a vendor/pdfjs los pocos archivos que
+ * usamos. Está a la misma altura desde src/ y desde build/, así que la ruta sirve en dev y publicado.
+ */
+const VENDOR = new URL("../../../vendor/pdfjs/", import.meta.url);
+/** Al arrancar en Node, pdf.js avisa que le falta canvas para renderizar. No renderizamos: son ruido en el log. */
+const AVISOS_DE_CANVAS = /@napi-rs\/canvas|Cannot polyfill/;
+let pdfjsCargado;
+/** Se carga recién al primer PDF: son 3 MB que el servidor no necesita para arrancar. */
+function pdfjs() {
+    pdfjsCargado ??= (async () => {
+        const warn = console.warn;
+        console.warn = (...args) => {
+            if (!AVISOS_DE_CANVAS.test(String(args[0])))
+                warn(...args);
+        };
+        try {
+            return (await import(new URL("pdf.mjs", VENDOR).href));
+        }
+        finally {
+            console.warn = warn;
+        }
+    })();
+    return pdfjsCargado;
+}
+/** Menos texto que esto en una página la tratamos como escaneada. */
+const MIN_TEXTO = 20;
+/** Lado largo de la imagen de una página: el tamaño que Claude procesa sin reescalar. */
+const LADO_IMAGEN = 1568;
+/** Muestras por eje y por píxel al reducir la imagen; suaviza los bordes y mejora la lectura. */
+const MUESTREO = 2;
+export async function abrirPdf(bytes) {
+    const lib = await pdfjs();
+    const carga = lib.getDocument({
+        data: bytes,
+        verbosity: 0,
+        isOffscreenCanvasSupported: false,
+        // Directo a los decodificadores JS de vendor/pdfjs/wasm: en Node los .wasm no cargan igual.
+        useWasm: false,
+        wasmUrl: new URL("wasm/", VENDOR).href,
+    });
+    const pdf = await carga.promise;
+    return {
+        formato: "pdf",
+        unidad: "página",
+        total: pdf.numPages,
+        parte: async (n) => leerPagina(lib, await pdf.getPage(n)),
+        cerrar: () => carga.destroy(),
+    };
+}
+async function leerPagina(lib, pagina) {
+    const contenido = await pagina.getTextContent();
+    let texto = "";
+    for (const item of contenido.items) {
+        if (!("str" in item))
+            continue;
+        texto += item.str + (item.hasEOL ? "\n" : "");
+    }
+    texto = texto.replace(/[ \t]+/g, " ").replace(/ ?\n ?/g, "\n").trim();
+    if (texto.length >= MIN_TEXTO)
+        return { texto };
+    const escaneo = await rasterizarImagenes(lib, pagina);
+    if (escaneo)
+        return { titulo: "escaneada, como imagen", imagen: escaneo, mimeType: "image/png" };
+    return { texto: texto || "(página sin texto)" };
+}
+/**
+ * Reconstruye la página dibujando solo sus imágenes, con la posición y rotación con que el PDF
+ * las ubica. Una página escaneada es eso: una imagen. Así se evita un renderizador completo, que
+ * en Node necesita un canvas nativo.
+ */
+async function rasterizarImagenes({ OPS, Util }, pagina) {
+    const base = pagina.getViewport({ scale: 1 });
+    const vista = pagina.getViewport({ scale: LADO_IMAGEN / Math.max(base.width, base.height) });
+    const ancho = Math.round(vista.width);
+    const alto = Math.round(vista.height);
+    const lienzo = new Uint8Array(ancho * alto).fill(255);
+    const ops = await pagina.getOperatorList();
+    let ctm = [1, 0, 0, 1, 0, 0];
+    const pila = [];
+    let pintadas = 0;
+    for (let i = 0; i < ops.fnArray.length; i++) {
+        const args = ops.argsArray[i];
+        switch (ops.fnArray[i]) {
+            case OPS.save:
+                pila.push(ctm);
+                break;
+            case OPS.restore:
+                ctm = pila.pop() ?? ctm;
+                break;
+            case OPS.transform:
+                ctm = Util.transform(ctm, args);
+                break;
+            case OPS.paintFormXObjectBegin:
+                pila.push(ctm);
+                if (args[0])
+                    ctm = Util.transform(ctm, args[0]);
+                break;
+            case OPS.paintFormXObjectEnd:
+                ctm = pila.pop() ?? ctm;
+                break;
+            case OPS.paintImageXObject:
+            case OPS.paintInlineImageXObject: {
+                const imagen = typeof args[0] === "string" ? await new Promise((res) => pagina.objs.get(args[0], res)) : args[0];
+                if (imagen?.data && pintar(lienzo, ancho, alto, imagen, Util.transform(vista.transform, ctm))) {
+                    pintadas++;
+                }
+                break;
+            }
+        }
+    }
+    return pintadas ? pngGris(ancho, alto, lienzo) : null;
+}
+/**
+ * Pinta una imagen en el lienzo. La imagen ocupa el cuadrado unitario transformado por `m`; por cada
+ * píxel del lienzo se busca el píxel de origen con la transformación inversa, así cualquier rotación
+ * o espejado sale bien sin casos especiales.
+ */
+function pintar(lienzo, ancho, alto, img, m) {
+    const [a, b, c, d, e, f] = m;
+    const det = a * d - b * c;
+    if (!det)
+        return false;
+    const inv = [d / det, -b / det, -c / det, a / det, (c * f - d * e) / det, (b * e - a * f) / det];
+    const xs = [e, a + e, c + e, a + c + e];
+    const ys = [f, b + f, d + f, b + d + f];
+    const x0 = Math.max(0, Math.floor(Math.min(...xs)));
+    const x1 = Math.min(ancho, Math.ceil(Math.max(...xs)));
+    const y0 = Math.max(0, Math.floor(Math.min(...ys)));
+    const y1 = Math.min(alto, Math.ceil(Math.max(...ys)));
+    const { width: w, height: h, kind } = img;
+    const data = img.data;
+    const bytesPorFila = (w + 7) >> 3;
+    const canales = kind === 2 ? 3 : 4;
+    const gris = (col, fila) => {
+        if (kind === 1)
+            return ((data[fila * bytesPorFila + (col >> 3)] >> (7 - (col & 7))) & 1) * 255;
+        const i = (fila * w + col) * canales;
+        return data[i] * 0.3 + data[i + 1] * 0.59 + data[i + 2] * 0.11;
+    };
+    for (let y = y0; y < y1; y++) {
+        for (let x = x0; x < x1; x++) {
+            let suma = 0;
+            let n = 0;
+            for (let sy = 0; sy < MUESTREO; sy++) {
+                for (let sx = 0; sx < MUESTREO; sx++) {
+                    const px = x + (sx + 0.5) / MUESTREO;
+                    const py = y + (sy + 0.5) / MUESTREO;
+                    const u = inv[0] * px + inv[2] * py + inv[4];
+                    const v = inv[1] * px + inv[3] * py + inv[5];
+                    if (u < 0 || u >= 1 || v < 0 || v >= 1)
+                        continue;
+                    // En el espacio de la imagen v crece hacia arriba; las filas de datos, hacia abajo.
+                    suma += gris(Math.floor(u * w), Math.floor((1 - v) * h));
+                    n++;
+                }
+            }
+            if (n)
+                lienzo[y * ancho + x] = suma / n;
+        }
+    }
+    return true;
+}

package/build/shared/documents/png.js

@@ -0,0 +1,51 @@
+import { deflateSync } from "node:zlib";
+/** PNG en escala de grises, 8 bits. Alcanza para páginas escaneadas y evita una dependencia de imágenes. */
+export function pngGris(ancho, alto, pixeles) {
+    // Cada fila va precedida por el byte de filtro (0 = sin filtro).
+    const filas = new Uint8Array(alto * (ancho + 1));
+    for (let y = 0; y < alto; y++)
+        filas.set(pixeles.subarray(y * ancho, (y + 1) * ancho), y * (ancho + 1) + 1);
+    const ihdr = new Uint8Array(13);
+    const vista = new DataView(ihdr.buffer);
+    vista.setUint32(0, ancho);
+    vista.setUint32(4, alto);
+    ihdr[8] = 8; // bits por canal
+    ihdr[9] = 0; // escala de grises
+    return concat([
+        new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
+        chunk("IHDR", ihdr),
+        chunk("IDAT", deflateSync(filas, { level: 6 })),
+        chunk("IEND", new Uint8Array()),
+    ]);
+}
+function chunk(tipo, datos) {
+    const out = new Uint8Array(12 + datos.length);
+    const vista = new DataView(out.buffer);
+    vista.setUint32(0, datos.length);
+    for (let i = 0; i < 4; i++)
+        out[4 + i] = tipo.charCodeAt(i);
+    out.set(datos, 8);
+    vista.setUint32(8 + datos.length, crc32(out.subarray(4, 8 + datos.length)));
+    return out;
+}
+const TABLA_CRC = Int32Array.from({ length: 256 }, (_, n) => {
+    let c = n;
+    for (let k = 0; k < 8; k++)
+        c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    return c;
+});
+function crc32(bytes) {
+    let c = -1;
+    for (const b of bytes)
+        c = TABLA_CRC[(c ^ b) & 0xff] ^ (c >>> 8);
+    return ~c >>> 0;
+}
+function concat(partes) {
+    const out = new Uint8Array(partes.reduce((n, p) => n + p.length, 0));
+    let i = 0;
+    for (const p of partes) {
+        out.set(p, i);
+        i += p.length;
+    }
+    return out;
+}

package/build/shared/documents/zip.js

@@ -0,0 +1,72 @@
+import { inflateRawSync } from "node:zlib";
+const FIN_DIRECTORIO = 0x06054b50;
+const DIRECTORIO = 0x02014b50;
+const ENCABEZADO_LOCAL = 0x04034b50;
+const SIN_COMPRESION = 0;
+const DEFLATE = 8;
+class ZipInvalido extends Error {
+    constructor(detalle) {
+        super(`El archivo no es un zip válido: ${detalle}.`);
+        this.name = "ZipInvalido";
+    }
+}
+export function listarZip(bytes) {
+    const vista = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    // El fin del directorio está al final, seguido de un comentario opcional de hasta 64 KB.
+    let fin = -1;
+    for (let i = bytes.length - 22; i >= Math.max(0, bytes.length - 22 - 0xffff); i--) {
+        if (vista.getUint32(i, true) === FIN_DIRECTORIO) {
+            fin = i;
+            break;
+        }
+    }
+    if (fin < 0)
+        throw new ZipInvalido("no tiene índice");
+    const cantidad = vista.getUint16(fin + 10, true);
+    let p = vista.getUint32(fin + 16, true);
+    if (cantidad === 0xffff || p === 0xffffffff)
+        throw new ZipInvalido("usa zip64");
+    const entradas = [];
+    const nombres = new TextDecoder();
+    for (let i = 0; i < cantidad; i++) {
+        if (p + 46 > bytes.length || vista.getUint32(p, true) !== DIRECTORIO)
+            throw new ZipInvalido("índice corrupto");
+        const largoNombre = vista.getUint16(p + 28, true);
+        entradas.push({
+            nombre: nombres.decode(bytes.subarray(p + 46, p + 46 + largoNombre)),
+            metodo: vista.getUint16(p + 10, true),
+            comprimido: vista.getUint32(p + 20, true),
+            tamanio: vista.getUint32(p + 24, true),
+            offset: vista.getUint32(p + 42, true),
+        });
+        p += 46 + largoNombre + vista.getUint16(p + 30, true) + vista.getUint16(p + 32, true);
+    }
+    return entradas;
+}
+/**
+ * Descomprime una entrada. `max` corta aunque el índice mienta sobre el tamaño: un zip chico que se
+ * infla a gigas es un ataque conocido.
+ */
+export function leerEntrada(bytes, entrada, max) {
+    if (entrada.tamanio > max)
+        throw new ZipInvalido(`"${entrada.nombre}" descomprimido pesa demasiado`);
+    const vista = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const p = entrada.offset;
+    if (vista.getUint32(p, true) !== ENCABEZADO_LOCAL)
+        throw new ZipInvalido(`falta el encabezado de "${entrada.nombre}"`);
+    const inicio = p + 30 + vista.getUint16(p + 26, true) + vista.getUint16(p + 28, true);
+    const datos = bytes.subarray(inicio, inicio + entrada.comprimido);
+    switch (entrada.metodo) {
+        case SIN_COMPRESION:
+            return datos;
+        case DEFLATE:
+            try {
+                return inflateRawSync(datos, { maxOutputLength: max });
+            }
+            catch (e) {
+                throw new ZipInvalido(`no se pudo descomprimir "${entrada.nombre}" (${e.message})`);
+            }
+        default:
+            throw new ZipInvalido(`"${entrada.nombre}" usa una compresión no soportada (${entrada.metodo})`);
+    }
+}

package/build/shared/html.js

@@ -0,0 +1,19 @@
+const ENTITIES = { nbsp: " ", amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+/** HTML de Moodle a texto plano: alcanza para que el modelo lo lea, no es un parser. */
+export function htmlToText(html) {
+    if (!html)
+        return "";
+    return html
+        .replace(/<(script|style)[\s\S]*?<\/\1>/gi, "")
+        .replace(/<br\s*\/?>|<\/(p|div|li|h\d|tr)>/gi, "\n")
+        .replace(/<[^>]+>/g, "")
+        .replace(/&(#\d+|[a-z]+);/gi, (m, e) => e.startsWith("#") ? String.fromCodePoint(Number(e.slice(1))) : (ENTITIES[e.toLowerCase()] ?? m))
+        .replace(/[ \t ]+/g, " ")
+        .replace(/\s*\n\s*/g, "\n")
+        .trim();
+}
+/** Como htmlToText pero recortado: para índices, donde solo hace falta decidir si entrar. */
+export function htmlToSnippet(html, max = 200) {
+    const texto = htmlToText(html);
+    return texto.length > max ? `${texto.slice(0, max).trimEnd()}…` : texto;
+}

package/package.json

@@ -1,18 +1,20 @@
 {
   "name": "utn-mcp",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Este es el Model Context Protocol server NO OFICIAL de la UTN para buscar informacion o archivos en el aula virtual.",
   "main": "build/index.js",
   "bin": {
     "utn-mcp": "build/index.js"
   },
   "files": [
-    "build"
+    "build",
+    "vendor"
   ],
   "scripts": {
     "prebuild": "node -e \"require('fs').rmSync('build',{recursive:true,force:true})\"",
     "build": "tsc",
     "prepublishOnly": "npm run build",
+    "prepare": "node scripts/vendor-pdfjs.mjs",
     "start": "node build/index.js",
     "dev": "tsx src/index.ts",
     "test": "echo \"Error: no test specified\" && exit 1",
@@ -34,7 +36,7 @@
   "bugs": {
     "url": "https://github.com/nialvape/utn-mcp/issues"
   },
-  "homepage": "https://github.com/nialvape/utn-mcp#readme",
+  "homepage": "https://utnmcp.com.ar",
   "dependencies": {
     "@modelcontextprotocol/node": "^2.1.1",
     "@modelcontextprotocol/server": "^2.3.0",
@@ -46,6 +48,7 @@
   "devDependencies": {
     "@types/express": "^5.0.6",
     "@types/node": "^26.6.4",
+    "pdfjs-dist": "^6.4.299",
     "tsx": "^4.23.15",
     "typescript": "^7.0.2"
   },