utn-mcp 0.2.0 → 0.6.7

package/build/shared/documents/zip.js

@@ -1,72 +1,73 @@
 import { inflateRawSync } from "node:zlib";
-const FIN_DIRECTORIO = 0x06054b50;
-const DIRECTORIO = 0x02014b50;
-const ENCABEZADO_LOCAL = 0x04034b50;
-const SIN_COMPRESION = 0;
+const END_OF_CENTRAL_DIRECTORY = 0x06054b50;
+const CENTRAL_DIRECTORY_ENTRY = 0x02014b50;
+const LOCAL_HEADER = 0x04034b50;
+const STORED = 0;
 const DEFLATE = 8;
-class ZipInvalido extends Error {
-    constructor(detalle) {
-        super(`El archivo no es un zip válido: ${detalle}.`);
-        this.name = "ZipInvalido";
+class InvalidZip extends Error {
+    constructor(detail) {
+        super(`El archivo no es un zip válido: ${detail}.`);
+        this.name = "InvalidZip";
     }
 }
-export function listarZip(bytes) {
-    const vista = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+export function listZip(bytes) {
+    const view = 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;
+    let end = -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;
+        if (view.getUint32(i, true) === END_OF_CENTRAL_DIRECTORY) {
+            end = 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),
+    if (end < 0)
+        throw new InvalidZip("no tiene índice");
+    const count = view.getUint16(end + 10, true);
+    let p = view.getUint32(end + 16, true);
+    if (count === 0xffff || p === 0xffffffff)
+        throw new InvalidZip("usa zip64");
+    const entries = [];
+    const decoder = new TextDecoder();
+    for (let i = 0; i < count; i++) {
+        if (p + 46 > bytes.length || view.getUint32(p, true) !== CENTRAL_DIRECTORY_ENTRY) {
+            throw new InvalidZip("índice corrupto");
+        }
+        const nameLength = view.getUint16(p + 28, true);
+        entries.push({
+            name: decoder.decode(bytes.subarray(p + 46, p + 46 + nameLength)),
+            method: view.getUint16(p + 10, true),
+            compressedSize: view.getUint32(p + 20, true),
+            size: view.getUint32(p + 24, true),
+            offset: view.getUint32(p + 42, true),
         });
-        p += 46 + largoNombre + vista.getUint16(p + 30, true) + vista.getUint16(p + 32, true);
+        p += 46 + nameLength + view.getUint16(p + 30, true) + view.getUint16(p + 32, true);
     }
-    return entradas;
+    return entries;
 }
 /**
  * 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;
+export function readEntry(bytes, entry, max) {
+    if (entry.size > max)
+        throw new InvalidZip(`"${entry.name}" descomprimido pesa demasiado`);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const p = entry.offset;
+    if (view.getUint32(p, true) !== LOCAL_HEADER)
+        throw new InvalidZip(`falta el encabezado de "${entry.name}"`);
+    const start = p + 30 + view.getUint16(p + 26, true) + view.getUint16(p + 28, true);
+    const data = bytes.subarray(start, start + entry.compressedSize);
+    switch (entry.method) {
+        case STORED:
+            return data;
         case DEFLATE:
             try {
-                return inflateRawSync(datos, { maxOutputLength: max });
+                return inflateRawSync(data, { maxOutputLength: max });
             }
             catch (e) {
-                throw new ZipInvalido(`no se pudo descomprimir "${entrada.nombre}" (${e.message})`);
+                throw new InvalidZip(`no se pudo descomprimir "${entry.name}" (${e.message})`);
             }
         default:
-            throw new ZipInvalido(`"${entrada.nombre}" usa una compresión no soportada (${entrada.metodo})`);
+            throw new InvalidZip(`"${entry.name}" usa una compresión no soportada (${entry.method})`);
     }
 }

package/build/shared/html.js

@@ -14,6 +14,19 @@ export function htmlToText(html) {
 }
 /** 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;
+    const text = htmlToText(html);
+    return text.length > max ? `${text.slice(0, max).trimEnd()}…` : text;
+}
+/** Texto plano del modelo a HTML para Moodle: escapa, y cada línea en blanco separa un párrafo. */
+export function textToHtml(text) {
+    const escaped = text
+        .trim()
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+    return escaped
+        .split(/\n\s*\n/)
+        .map((p) => `<p>${p.replace(/\n/g, "<br>")}</p>`)
+        .join("");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "utn-mcp",
-  "version": "0.2.0",
+  "version": "0.6.7",
   "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": {
@@ -36,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",

package/build/aula-virtual/address.js

@@ -1,39 +0,0 @@
-export const RAIZ = "/";
-export const cursoAddr = (courseId) => `/curso/${courseId}`;
-export const moduloAddr = (courseId, cmid) => `/curso/${courseId}/mod/${cmid}`;
-export const discusionAddr = (courseId, cmid, discussionId) => `/curso/${courseId}/mod/${cmid}/disc/${discussionId}`;
-const FORMATOS = [
-    "/",
-    "/curso/{courseId}",
-    "/curso/{courseId}/mod/{cmid}",
-    "/curso/{courseId}/mod/{cmid}/disc/{discussionId}",
-].join(", ");
-const PATRON = /^\/curso\/(\d+)(?:\/mod\/(\d+)(?:\/disc\/(\d+))?)?$/;
-export function parseAddress(raw) {
-    const path = raw.trim().replace(/\/+$/, "") || "/";
-    if (path === "/")
-        return { nivel: "raiz" };
-    const m = PATRON.exec(path);
-    if (!m)
-        throw new Error(`Dirección inválida: "${raw}". Formatos válidos: ${FORMATOS}`);
-    const [, curso, cmid, disc] = m;
-    const courseId = Number(curso);
-    if (!cmid)
-        return { nivel: "curso", courseId };
-    if (!disc)
-        return { nivel: "modulo", courseId, cmid: Number(cmid) };
-    return { nivel: "discusion", courseId, cmid: Number(cmid), discussionId: Number(disc) };
-}
-/** La dirección de un nivel más arriba, o null si ya estamos en la raíz. */
-export function padre(address) {
-    switch (address.nivel) {
-        case "raiz":
-            return null;
-        case "curso":
-            return RAIZ;
-        case "modulo":
-            return cursoAddr(address.courseId);
-        case "discusion":
-            return moduloAddr(address.courseId, address.cmid);
-    }
-}

package/build/aula-virtual/files.js

@@ -1,89 +0,0 @@
-import { abrirDocumento, FormatoNoSoportado } from "../shared/documents/index.js";
-import { AULA_BASE_URL } from "./client/constants.js";
-import { fetchFile } from "./client/moodle-api.js";
-const ORIGEN = new URL(AULA_BASE_URL).origin;
-const RUTA_WS = "/webservice/pluginfile.php/";
-const RUTA_WEB = "/pluginfile.php/";
-/** Cuánto se devuelve por llamada, en caracteres de texto. */
-const PRESUPUESTO = 30_000;
-/** Lo que cuesta una página como imagen (~1.600 tokens), medido en caracteres de texto. */
-const COSTO_IMAGEN = 6_000;
-/** El más grande que hay hoy en los cursos pesa 12 MB. */
-const MAX_BYTES = 30 * 1024 * 1024;
-/**
- * Moodle devuelve las URLs del web service, que piden token. Al usuario le sirve la misma ruta sin
- * `/webservice`, que se abre con la sesión de su navegador. Es la única que mostramos: el token no
- * sale nunca del servidor.
- */
-export function urlParaUsuario(fileurl) {
-    return fileurl.replace(`${ORIGEN}${RUTA_WS}`, `${ORIGEN}${RUTA_WEB}`);
-}
-/**
- * Acepta cualquiera de las dos formas y devuelve la del web service. Solo archivos del aula: con
- * cualquier otra URL estaríamos mandando el token del usuario a donde diga el modelo.
- */
-function urlDeDescarga(url) {
-    let u;
-    try {
-        u = new URL(url);
-    }
-    catch {
-        throw new Error(`URL inválida: "${url}". Usá la \`url\` de un archivo tal como la devuelve aula_open.`);
-    }
-    const ruta = u.pathname.startsWith(RUTA_WS) ? u.pathname : u.pathname.startsWith(RUTA_WEB) ? RUTA_WS + u.pathname.slice(RUTA_WEB.length) : null;
-    if (u.origin !== ORIGEN || !ruta) {
-        throw new Error(`Solo se pueden leer archivos del aula virtual (${ORIGEN}${RUTA_WEB}...).`);
-    }
-    u.pathname = ruta;
-    u.searchParams.delete("token");
-    u.searchParams.delete("wstoken");
-    return u;
-}
-/** Baja un archivo del aula y devuelve desde la parte `desde` tantas como entren en el presupuesto. */
-export async function leerArchivo(session, url, desde = 1) {
-    const descarga = urlDeDescarga(url);
-    const archivo = decodeURIComponent(descarga.pathname.split("/").pop() ?? "");
-    const paraUsuario = urlParaUsuario(descarga.href);
-    const { bytes } = await fetchFile(session, descarga, MAX_BYTES);
-    let documento;
-    try {
-        documento = await abrirDocumento(bytes, archivo);
-    }
-    catch (e) {
-        if (e instanceof FormatoNoSoportado) {
-            throw new Error(`${e.message} El usuario lo puede bajar desde ${paraUsuario}`);
-        }
-        throw e;
-    }
-    try {
-        if (desde > documento.total) {
-            throw new Error(`"${archivo}" termina en ${documento.unidad} ${documento.total}; se pidió desde ${desde}.`);
-        }
-        const partes = [];
-        let gastado = 0;
-        let n = desde;
-        for (; n <= documento.total; n++) {
-            const parte = await documento.parte(n);
-            const costo = "texto" in parte ? parte.texto.length : COSTO_IMAGEN;
-            // Siempre al menos una parte, aunque sola se pase del presupuesto.
-            if (partes.length > 0 && gastado + costo > PRESUPUESTO)
-                break;
-            partes.push({ ...parte, numero: n });
-            gastado += costo;
-        }
-        return {
-            archivo,
-            formato: documento.formato,
-            unidad: documento.unidad,
-            total: documento.total,
-            desde,
-            hasta: n - 1,
-            siguiente: n <= documento.total ? n : undefined,
-            urlParaUsuario: paraUsuario,
-            partes,
-        };
-    }
-    finally {
-        await documento.cerrar();
-    }
-}

package/build/aula-virtual/navigate.js

@@ -1,144 +0,0 @@
-import { htmlToSnippet, htmlToText } from "../shared/html.js";
-import { cursoAddr, discusionAddr, moduloAddr, padre, parseAddress, RAIZ } from "./address.js";
-import { getCourseSections, getDiscussionPosts, getForumDiscussions, getUserCourses, POR_PAGINA, } from "./client/client.js";
-import { urlParaUsuario } from "./files.js";
-const isoDate = (seconds) => (seconds ? new Date(seconds * 1000).toISOString() : null);
-/**
- * Entra a una dirección del aula y devuelve su contenido, el padre y las direcciones de lo que hay
- * adentro. Es el único lugar que decide qué ve el modelo y cuánto texto le cuesta.
- */
-export async function open(session, direccion, pagina = 0) {
-    const address = parseAddress(direccion);
-    const base = { direccion: formatear(address), padre: padre(address) };
-    switch (address.nivel) {
-        case "raiz":
-            return { ...base, cursos: await verCursos(session) };
-        case "curso":
-            return { ...base, secciones: await verCurso(session, address.courseId) };
-        case "modulo":
-            return { ...base, ...(await verModulo(session, address, pagina)) };
-        case "discusion":
-            return { ...base, ...(await verDiscusion(session, address.discussionId)) };
-    }
-}
-function formatear(address) {
-    switch (address.nivel) {
-        case "raiz":
-            return RAIZ;
-        case "curso":
-            return cursoAddr(address.courseId);
-        case "modulo":
-            return moduloAddr(address.courseId, address.cmid);
-        case "discusion":
-            return discusionAddr(address.courseId, address.cmid, address.discussionId);
-    }
-}
-async function verCursos(session) {
-    const courses = await getUserCourses(session);
-    return courses.map((c) => ({
-        direccion: cursoAddr(c.id),
-        id: c.id,
-        nombre: c.fullname,
-        nombreCorto: c.shortname,
-        visible: c.visible === 1,
-        progreso: c.progress ?? null,
-        ultimoAcceso: isoDate(c.lastaccess),
-    }));
-}
-/** El mapa del curso: secciones y módulos, con las descripciones recortadas. */
-async function verCurso(session, courseId) {
-    const sections = await getCourseSections(session, courseId);
-    return sections
-        .filter((s) => s.uservisible !== false)
-        .map((s) => ({
-        nombre: s.name,
-        numero: s.section,
-        resumen: htmlToText(s.summary) || undefined,
-        modulos: s.modules.filter((m) => m.uservisible).map((m) => toModule(m, courseId, true)),
-    }))
-        .filter((s) => s.resumen || s.modulos.length > 0);
-}
-async function verModulo(session, address, pagina) {
-    const { seccion, module } = await buscarModulo(session, address.courseId, address.cmid);
-    const modulo = toModule(module, address.courseId);
-    if (module.modname !== "forum")
-        return { seccion, modulo };
-    // Un foro es un índice: asuntos y un fragmento de cada uno. El mensaje completo sale al abrir la discusión.
-    const { discussions } = await getForumDiscussions(session, module.instance, pagina);
-    return {
-        seccion,
-        modulo,
-        discusiones: discussions.map((d) => ({
-            direccion: discusionAddr(address.courseId, address.cmid, d.discussion),
-            asunto: d.subject,
-            autor: d.userfullname,
-            fecha: isoDate(d.created),
-            ultimaActividad: isoDate(d.timemodified),
-            respuestas: d.numreplies,
-            fijada: d.pinned || undefined,
-            adjuntos: d.attachment || undefined,
-            resumen: htmlToSnippet(d.message),
-        })),
-        pagina,
-        hayMasDiscusiones: discussions.length === POR_PAGINA || undefined,
-    };
-}
-async function verDiscusion(session, discussionId) {
-    const { posts } = await getDiscussionPosts(session, discussionId);
-    const visibles = posts.filter((p) => !p.isdeleted);
-    return {
-        asunto: visibles[0]?.subject,
-        publicaciones: visibles.map((p) => ({
-            autor: p.author.fullname,
-            fecha: isoDate(p.timecreated),
-            respuestaA: p.parentid ?? undefined,
-            id: p.id,
-            mensaje: htmlToText(p.message),
-            adjuntos: p.attachments.length ? p.attachments.map(toFile) : undefined,
-        })),
-    };
-}
-/** Ubica un módulo por su cmid y se queda con la sección que lo contiene. */
-async function buscarModulo(session, courseId, cmid) {
-    const sections = await getCourseSections(session, courseId, cmid);
-    for (const section of sections) {
-        const module = section.modules.find((m) => m.id === cmid);
-        if (!module)
-            continue;
-        if (!module.uservisible)
-            throw new Error(`No tenés acceso al módulo ${cmid}.`);
-        return { seccion: section.name, module };
-    }
-    throw new Error(`No existe el módulo ${cmid} en el curso ${courseId}.`);
-}
-/** `resumido` recorta la descripción: en el mapa del curso alcanza para decidir si entrar. */
-function toModule(m, courseId, resumido = false) {
-    const contents = m.contents ?? [];
-    const archivos = contents.filter((c) => c.type === "file");
-    const enlaces = contents.filter((c) => c.type === "url");
-    return {
-        direccion: moduloAddr(courseId, m.id),
-        id: m.id,
-        nombre: m.name,
-        tipo: m.modname,
-        url: m.url,
-        descripcion: (resumido ? htmlToSnippet(m.description) : htmlToText(m.description)) || undefined,
-        restriccion: htmlToText(m.availabilityinfo) || undefined,
-        fechas: m.dates?.length
-            ? m.dates.map((d) => ({ etiqueta: d.label, fecha: isoDate(d.timestamp) }))
-            : undefined,
-        archivos: archivos.length ? archivos.map(toFile) : undefined,
-        enlaces: enlaces.length ? enlaces.map((l) => l.fileurl) : undefined,
-    };
-}
-function toFile(f) {
-    return {
-        nombre: f.filename,
-        ruta: f.filepath || undefined,
-        tamanio: f.filesize,
-        mimetype: f.mimetype,
-        modificado: isoDate(f.timemodified),
-        // Sirve para pasársela al usuario y también para leerlo con aula_read_file.
-        url: urlParaUsuario(f.fileurl),
-    };
-}