utn-mcp 0.2.1 → 0.6.9

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/build/shared/paths.js

@@ -11,3 +11,7 @@ export function configDir() {
 }
 /** Token de Moodle + cookies del SSO del modo local. */
 export const sessionFile = () => join(configDir(), "session.json");
+/** Base de usuarios, tokens y sesiones del modo HTTP: UTN_MCP_DB o un SQLite en la carpeta de configuración. */
+export const storeFile = () => process.env.UTN_MCP_DB ?? join(configDir(), "utn-mcp.db");
+/** Clave con la que se cifran las sesiones en la base, si no viene en UTN_MCP_KEY. */
+export const storeKeyFile = () => join(configDir(), "store.key");

package/build/shared/store/session-store.js

@@ -0,0 +1 @@
+export {};

package/build/shared/store/sqlite-store.js

@@ -0,0 +1,145 @@
+import { createCipheriv, createDecipheriv, createHash, randomBytes } from "node:crypto";
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { storeFile, storeKeyFile } from "../paths.js";
+const SCHEMA = `
+    CREATE TABLE IF NOT EXISTS users (
+        id INTEGER PRIMARY KEY,
+        utn_username TEXT NOT NULL UNIQUE,
+        created_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS tokens (
+        hash TEXT PRIMARY KEY,
+        user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+        kind TEXT NOT NULL CHECK (kind IN ('access', 'refresh')),
+        client_id TEXT,
+        expires_at INTEGER,
+        created_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS tokens_user ON tokens(user_id);
+    CREATE TABLE IF NOT EXISTS platform_sessions (
+        user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+        platform TEXT NOT NULL,
+        data BLOB NOT NULL,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (user_id, platform)
+    );
+`;
+/** Bytes de la clave AES-256. */
+const KEY_BYTES = 32;
+/** Bytes del IV de AES-GCM. */
+const IV_BYTES = 12;
+/** Bytes del tag de autenticación de AES-GCM. */
+const TAG_BYTES = 16;
+const now = () => Math.floor(Date.now() / 1000);
+const hashToken = (token) => createHash("sha256").update(token).digest("hex");
+/**
+ * El SessionStore sobre SQLite. Las sesiones van cifradas con AES-256-GCM: tienen el token de Moodle
+ * y las cookies del SSO, que alcanzan para entrar al aula como el usuario. Los tokens se guardan
+ * hasheados, así que una copia de la base no sirve para usar el servidor.
+ */
+export class SqliteStore {
+    db;
+    key;
+    constructor(db, key) {
+        this.db = db;
+        this.key = key;
+    }
+    /** `node:sqlite` llega con Node 22.13; se importa acá para que el modo STDIO siga andando en Node 20. */
+    static async open(path = storeFile()) {
+        let sqlite;
+        try {
+            sqlite = await import("node:sqlite");
+        }
+        catch {
+            throw new Error(`El modo HTTP necesita Node 22.13 o más nuevo; tenés ${process.version}.`);
+        }
+        await mkdir(dirname(path), { recursive: true });
+        const db = new sqlite.DatabaseSync(path);
+        // WAL: el login escribe mientras el servidor lee, desde otro proceso.
+        db.exec("PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON; PRAGMA busy_timeout = 5000;");
+        db.exec(SCHEMA);
+        return new SqliteStore(db, await loadKey());
+    }
+    async findOrCreateUser(utnUsername) {
+        const username = utnUsername.trim().toLowerCase();
+        this.db
+            .prepare("INSERT INTO users (utn_username, created_at) VALUES (?, ?) ON CONFLICT DO NOTHING")
+            .run(username, now());
+        const row = this.db.prepare("SELECT id FROM users WHERE utn_username = ?").get(username);
+        return row.id;
+    }
+    async issueToken(userId, options) {
+        const token = randomBytes(32).toString("base64url");
+        const createdAt = now();
+        this.db
+            .prepare("INSERT INTO tokens (hash, user_id, kind, client_id, expires_at, created_at) VALUES (?, ?, ?, ?, ?, ?)")
+            .run(hashToken(token), userId, options.kind, options.clientId ?? null, options.ttlSeconds ? createdAt + options.ttlSeconds : null, createdAt);
+        return token;
+    }
+    async findToken(token, kind) {
+        const row = this.db
+            .prepare("SELECT user_id, client_id, expires_at FROM tokens " +
+            "WHERE hash = ? AND kind = ? AND (expires_at IS NULL OR expires_at > ?)")
+            .get(hashToken(token), kind, now());
+        return row ? { userId: row.user_id, clientId: row.client_id, expiresAt: row.expires_at } : null;
+    }
+    async revokeToken(token) {
+        this.db.prepare("DELETE FROM tokens WHERE hash = ?").run(hashToken(token));
+    }
+    async loadSession(userId, platform) {
+        const row = this.db
+            .prepare("SELECT data FROM platform_sessions WHERE user_id = ? AND platform = ?")
+            .get(userId, platform);
+        return row ? this.decrypt(row.data) : null;
+    }
+    async saveSession(userId, platform, data) {
+        this.db
+            .prepare("INSERT INTO platform_sessions (user_id, platform, data, updated_at) VALUES (?, ?, ?, ?) " +
+            "ON CONFLICT (user_id, platform) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at")
+            .run(userId, platform, this.encrypt(data), now());
+    }
+    /** iv + tag + texto cifrado, en un solo blob. */
+    encrypt(plain) {
+        const iv = randomBytes(IV_BYTES);
+        const cipher = createCipheriv("aes-256-gcm", this.key, iv);
+        const body = Buffer.concat([cipher.update(plain, "utf8"), cipher.final()]);
+        return Buffer.concat([iv, cipher.getAuthTag(), body]);
+    }
+    decrypt(blob) {
+        const buf = Buffer.from(blob);
+        const decipher = createDecipheriv("aes-256-gcm", this.key, buf.subarray(0, IV_BYTES));
+        decipher.setAuthTag(buf.subarray(IV_BYTES, IV_BYTES + TAG_BYTES));
+        try {
+            return Buffer.concat([decipher.update(buf.subarray(IV_BYTES + TAG_BYTES)), decipher.final()]).toString("utf8");
+        }
+        catch {
+            throw new Error("No se pudo descifrar la sesión: la clave (UTN_MCP_KEY o store.key) no es la que la cifró.");
+        }
+    }
+}
+/**
+ * UTN_MCP_KEY (32 bytes en base64) en el servidor hosteado, donde la clave no tiene que estar en el
+ * mismo disco que la base. En local, si no está, se genera una en la carpeta de configuración.
+ */
+async function loadKey() {
+    const fromEnv = process.env.UTN_MCP_KEY;
+    if (fromEnv) {
+        const key = Buffer.from(fromEnv, "base64");
+        if (key.length !== KEY_BYTES)
+            throw new Error(`UTN_MCP_KEY tiene que ser de ${KEY_BYTES} bytes en base64.`);
+        return key;
+    }
+    const file = storeKeyFile();
+    try {
+        return Buffer.from((await readFile(file, "utf8")).trim(), "base64");
+    }
+    catch {
+        const key = randomBytes(KEY_BYTES);
+        await mkdir(dirname(file), { recursive: true });
+        // `wx`: si otro proceso la creó recién, no la pisamos.
+        await writeFile(file, key.toString("base64"), { mode: 0o600, flag: "wx" }).catch(() => { });
+        await chmod(file, 0o600).catch(() => { }); // no-op en Windows
+        return Buffer.from((await readFile(file, "utf8")).trim(), "base64");
+    }
+}

package/build/shared/uploads.js

@@ -0,0 +1,80 @@
+import { randomBytes } from "node:crypto";
+import { extname } from "node:path";
+/** Cuánto dura un link de subida, en milisegundos. */
+const UPLOAD_TTL_MS = 30 * 60 * 1000;
+/** Tope de una subida entera, en bytes: los archivos quedan en memoria hasta que se entregan. */
+export const MAX_UPLOAD_BYTES = 100 * 1024 * 1024;
+/**
+ * Links de un solo uso para recibir archivos por HTTP: los sube el agente con `curl` si tiene
+ * terminal, o el usuario desde el navegador. Los archivos quedan en memoria hasta que una tool los
+ * toma o el link vence; si el servidor se reinicia, se pierden y hay que pedir otro link.
+ */
+export class UploadInbox {
+    baseUrl;
+    uploads = new Map();
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+    }
+    open(owner, title, limits) {
+        this.sweep();
+        const id = randomBytes(24).toString("base64url");
+        const expiresAt = Date.now() + UPLOAD_TTL_MS;
+        this.uploads.set(id, { owner, title, limits, files: null, expiresAt });
+        return { id, url: `${this.baseUrl}/subir/${id}`, expiresAt: new Date(expiresAt).toISOString() };
+    }
+    /** La subida para mostrar su formulario, o undefined si no existe o venció. */
+    get(id) {
+        this.sweep();
+        return this.uploads.get(id);
+    }
+    /** Guarda los archivos de una subida; una subida nueva al mismo link reemplaza la anterior. */
+    receive(id, files) {
+        const upload = this.uploads.get(id);
+        if (!upload || upload.expiresAt < Date.now())
+            throw new Error("El link de subida venció o no existe.");
+        if (!files.length)
+            throw new Error('No llegó ningún archivo: van en el campo "archivos".');
+        checkFiles(files, upload.limits);
+        upload.files = files;
+    }
+    /** Los archivos que se subieron, para entregarlos. No los borra: si la entrega falla, se reintenta. */
+    take(id, owner) {
+        const upload = this.uploads.get(id);
+        if (!upload || upload.owner !== owner || upload.expiresAt < Date.now()) {
+            throw new Error("La subida venció o no existe: pedí otro link.");
+        }
+        if (!upload.files) {
+            throw new Error("Todavía no se subió nada a ese link: esperá a que se use y volvé a intentar.");
+        }
+        return upload.files;
+    }
+    close(id) {
+        this.uploads.delete(id);
+    }
+    sweep() {
+        const now = Date.now();
+        for (const [id, upload] of this.uploads)
+            if (upload.expiresAt < now)
+                this.uploads.delete(id);
+    }
+}
+/** Cantidad, tamaño, tipo y nombres repetidos, que Moodle no acepta. */
+export function checkFiles(files, limits) {
+    if (limits.maxFiles && files.length > limits.maxFiles) {
+        throw new Error(`Se aceptan hasta ${limits.maxFiles} archivo(s) y llegaron ${files.length}.`);
+    }
+    const seen = new Set();
+    for (const f of files) {
+        if (f.bytes.length > limits.maxBytes) {
+            throw new Error(`"${f.name}" pesa ${formatSize(f.bytes.length)}; el máximo es ${formatSize(limits.maxBytes)} por archivo.`);
+        }
+        if (limits.extensions?.length && !limits.extensions.includes(extname(f.name).toLowerCase())) {
+            throw new Error(`"${f.name}" no es de un tipo aceptado (${limits.extensions.join(", ")}).`);
+        }
+        if (seen.has(f.name))
+            throw new Error(`Hay dos archivos que se llaman "${f.name}"; renombrá uno.`);
+        seen.add(f.name);
+    }
+}
+/** Tamaño para personas: en KB por debajo del mega, para que un archivo chico no diga "0.0 MB". */
+export const formatSize = (bytes) => bytes < 1024 * 1024 ? `${Math.ceil(bytes / 1024)} KB` : `${(bytes / 1024 / 1024).toFixed(1)} MB`;

package/package.json

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

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),
-    };
-}