utn-mcp 0.8.1 → 0.8.3

package/build/aula-virtual/tools.js

@@ -3,6 +3,7 @@ import { getSiteInfo } from "./client/client.js";
 import { addCalendarEvent, answerChoice, deleteForumPost, editForumPost, postToForum, sendMessage, } from "./format/actions.js";
 import { ROOT } from "./format/address.js";
 import { readAulaFile } from "./format/files.js";
+import { buildStudyPack } from "./format/study-pack.js";
 import { open } from "./format/navigate.js";
 import { createUploadLink, submitAssignment } from "./format/submission.js";
 // JSON compacto: indentar estas respuestas cuesta ~25% más de contexto y no se lee mejor.
@@ -125,6 +126,45 @@ export function registerAulaVirtualTools(server, session, files) {
             return failure(e);
         }
     });
+    // El pack se guarda en el disco: solo en STDIO, donde el servidor corre en la compu del usuario.
+    if (files.local) {
+        server.registerTool("aula_study_pack", {
+            description: "Une PDF del aula en un solo compilado de estudio con índice clickeable (cada " +
+                "entrada abre la página donde empieza ese material, y cada página tiene arriba " +
+                "un enlace para volver), guardado en la compu del usuario. Une ÚNICAMENTE PDF; " +
+                "si una URL pedida no es PDF, queda en `omitidos` con el motivo.\n\n" +
+                "Conviene llamar antes a aula_open del curso: devuelve cada módulo con sus " +
+                "archivos (nombre, url, sección y tipo) y permite elegir los apuntes sin bajar " +
+                "nada. Es un compilado íntegro, no un resumen.\n\n" +
+                "Hay topes por memoria: 150 archivos, 300 MB de descarga total y 30 MB el PDF " +
+                "final (estimado con los tamaños de entrada, para no bajar archivos de más). Lo " +
+                "que no entra queda en `omitidos` con el motivo: se pide el resto en otro pack. " +
+                "La respuesta trae la ruta en `archivo` y `materiales` con sección, módulo, " +
+                "páginas y página de inicio de cada uno.\n\n" +
+                "La `direccion` del curso sale de aula_list_courses. Para leer o pasarle al " +
+                "usuario archivos que no son PDF, usá aula_open y aula_read_file.",
+            inputSchema: z.object({
+                direccion: z
+                    .string()
+                    .describe('Dirección del curso, de aula_list_courses. Ej: "/curso/691".'),
+                archivos: z
+                    .array(z.string())
+                    .optional()
+                    .describe("URL de los PDF a unir, tal como las devuelve aula_open del curso (conviene " +
+                    "llamarlo antes y elegir: cada archivo trae nombre, sección y tipo). El pack " +
+                    "sigue el orden del aula, no el de esta lista. Sin `archivos`, une todos los " +
+                    "PDF del curso."),
+            }),
+            annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false },
+        }, async ({ direccion, archivos }) => {
+            try {
+                return json(await buildStudyPack(session, direccion, archivos));
+            }
+            catch (e) {
+                return failure(e);
+            }
+        });
+    }
     // --- Escritura: lo que sigue cambia algo en el aula, y casi todo queda a la vista de otras personas. ---
     const CONFIRM_FIRST = "\n\nAntes de llamarla, mostrale al usuario exactamente lo que se va a hacer y esperá que confirme.";
     server.registerTool("aula_forum_post", {

package/build/oauth/admin.js

@@ -2,13 +2,16 @@ import { timingSafeEqual } from "node:crypto";
 import express from "express";
 import { linkAulaAccount } from "../aula-virtual/client/link.js";
 import { availableRegionals } from "../aula-virtual/client/regionals.js";
-import { InvalidCredentialsError } from "../aula-virtual/client/sso-login.js";
+import { InvalidCredentialsError, MfaError } from "../aula-virtual/client/sso-login.js";
 import { AULA_PLATFORM } from "../aula-virtual/client/stored-session.js";
 import { logger } from "../shared/logger.js";
-import { RateLimiter } from "./expiring.js";
+import { Expiring, RateLimiter } from "./expiring.js";
+import { PendingLogin } from "./pending-login.js";
 /** Intentos de `/admin/verificar` por cuenta del aula cada 15 minutos: que no sirva para probar contraseñas. */
 const VERIFY_ATTEMPTS = 5;
 const VERIFY_WINDOW_MS = 15 * 60_000;
+/** Cuánto tiene el usuario para completar el segundo factor, en milisegundos: lo mismo que en el login de OAuth. */
+const SECOND_FACTOR_TTL_MS = 10 * 60_000;
 const SUPPORT = { verified: "verificada", candidate: "candidata", unsupported: "sin_soporte" };
 /** Segundos desde epoch, como los guarda el store, a ISO. */
 const isoDate = (seconds) => new Date(seconds * 1000).toISOString();
@@ -20,6 +23,7 @@ const isoDate = (seconds) => new Date(seconds * 1000).toISOString();
 export function mountAdmin(app, store, secret) {
     const json = express.json({ limit: "4kb" });
     const verifyLimiter = new RateLimiter(VERIFY_ATTEMPTS, VERIFY_WINDOW_MS);
+    const secondFactors = new Expiring(SECOND_FACTOR_TTL_MS);
     const requireSecret = (req, res, next) => {
         const got = Buffer.from(req.headers.authorization ?? "");
         const want = Buffer.from(`Bearer ${secret}`);
@@ -79,6 +83,7 @@ export function mountAdmin(app, store, secret) {
      * `{ regional, usuario, contrasena }` → entra al aula como el login de OAuth: crea el usuario si no
      * existe y le guarda la sesión, así ya puede usar las tools. Devuelve `{ usuario, nombre, email,
      * primero? }`, con `primero` si fue el primero en verificar la regional; si no entra, `{ error, motivo }`.
+     * Si Microsoft pide MFA, devuelve `{ segundoFactor }` y el login sigue con `/admin/segundo-factor`.
      */
     app.post("/admin/verificar", requireSecret, json, async (req, res) => {
         const id = typeof req.body?.regional === "string" ? req.body.regional : "";
@@ -94,8 +99,33 @@ export function mountAdmin(app, store, secret) {
         if (!verifyLimiter.allow(`${regional.id}:${username.toLowerCase()}`)) {
             return void res.status(429).json({ error: "intentos", motivo: "Demasiados intentos. Esperá unos minutos." });
         }
+        const flow = new PendingLogin((secondFactor) => linkAulaAccount(store, regional, { username, password }, secondFactor));
+        await advance(res, { flow, regional, username });
+    });
+    /**
+     * `{ login, respuesta }` → contesta lo que pidió el segundo factor: el `id` del método, el código o
+     * cualquier cosa cuando el usuario ya aprobó. Devuelve lo mismo que `/admin/verificar`.
+     */
+    app.post("/admin/segundo-factor", requireSecret, json, async (req, res) => {
+        const id = typeof req.body?.login === "string" ? req.body.login : "";
+        const verification = id ? secondFactors.get(id) : undefined;
+        if (!verification) {
+            return void res.status(410).json({ error: "vencido", motivo: "Pasó demasiado tiempo. Volvé a iniciar sesión." });
+        }
+        verification.flow.answer(typeof req.body?.respuesta === "string" ? req.body.respuesta : "");
+        await advance(res, verification, id);
+    });
+    /** Sigue el login hasta que termina o pide el segundo factor; `id` es el de uno que ya estaba esperando. */
+    async function advance(res, verification, id) {
+        const { flow, regional, username } = verification;
         try {
-            const account = await linkAulaAccount(store, regional, { username, password });
+            const step = await flow.next();
+            if ("prompt" in step) {
+                return void res.json({ segundoFactor: secondFactorJson(id ?? secondFactors.add(verification), step.prompt) });
+            }
+            if (id)
+                secondFactors.take(id);
+            const account = step.done;
             logger.info(`Admin: ${account.username} (${regional.id}) vinculó su aula.`);
             res.json({
                 usuario: account.username,
@@ -105,11 +135,28 @@ export function mountAdmin(app, store, secret) {
             });
         }
         catch (e) {
+            if (id)
+                secondFactors.take(id);
             if (e instanceof InvalidCredentialsError) {
                 return void res.status(401).json({ error: "credenciales", motivo: "El aula rechazó el usuario o la contraseña." });
             }
+            if (e instanceof MfaError)
+                return void res.status(422).json({ error: "mfa", motivo: e.message });
             logger.warn(`Verificación de ${username} (${regional.id}): ${e.message}`);
             res.status(502).json({ error: "aula", motivo: `No pudimos entrar al aula de ${regional.name}.` });
         }
-    });
+    }
+}
+/**
+ * Lo que pide el segundo factor, para que el panel se lo muestre al usuario. `login` es el id con el que
+ * se contesta; `paso` es "elegir" (con `metodos`), "codigo" (con `reintento` si el anterior estaba mal)
+ * o "aprobar" (con `numero` si Authenticator pide tipearlo).
+ */
+function secondFactorJson(login, prompt) {
+    if (prompt.step === "choose") {
+        return { login, paso: "elegir", metodos: prompt.methods.map((m) => ({ id: m.id, nombre: m.label })) };
+    }
+    if (prompt.step === "code")
+        return { login, paso: "codigo", metodo: prompt.method.label, reintento: prompt.retry || undefined };
+    return { login, paso: "aprobar", metodo: prompt.method.label, numero: prompt.number };
 }

package/build/oauth/pending-login.js

@@ -0,0 +1,33 @@
+/**
+ * Un login que queda esperando el segundo factor entre un request y otro: corre en segundo plano y,
+ * cuando le pregunta algo al usuario, `next` lo devuelve para mostrárselo en una página; `answer` le
+ * pasa lo que el usuario contestó en el request siguiente.
+ */
+export class PendingLogin {
+    run;
+    waiting = null;
+    listeners = [];
+    constructor(start) {
+        this.run = start((prompt) => new Promise((resolve) => {
+            this.waiting = { prompt, resolve };
+            for (const listener of this.listeners.splice(0))
+                listener(prompt);
+        }));
+        this.run.catch(() => { });
+    }
+    /** Espera a que el login termine o le pregunte algo al usuario. */
+    next() {
+        if (this.waiting)
+            return Promise.resolve({ prompt: this.waiting.prompt });
+        return Promise.race([
+            this.run.then((done) => ({ done })),
+            new Promise((resolve) => this.listeners.push((prompt) => resolve({ prompt }))),
+        ]);
+    }
+    /** Contesta lo que está preguntando; si no pregunta nada (un formulario mandado dos veces), no hace nada. */
+    answer(value) {
+        const waiting = this.waiting;
+        this.waiting = null;
+        waiting?.resolve(value);
+    }
+}

package/build/oauth/server.js

@@ -3,10 +3,11 @@ import express from "express";
 import { buildOAuthProtectedResourceMetadata, checkResourceAllowed, getOAuthProtectedResourceMetadataUrl, } from "@modelcontextprotocol/server";
 import { linkAulaAccount } from "../aula-virtual/client/link.js";
 import { availableRegionals, defaultRegional } from "../aula-virtual/client/regionals.js";
-import { InvalidCredentialsError } from "../aula-virtual/client/sso-login.js";
+import { InvalidCredentialsError, MfaError } from "../aula-virtual/client/sso-login.js";
 import { logger } from "../shared/logger.js";
 import { escapeHtml, page } from "../shared/pages.js";
 import { Expiring, RateLimiter } from "./expiring.js";
+import { PendingLogin } from "./pending-login.js";
 import { describeRedirect, redirectTrust } from "./redirects.js";
 /** Duración del access token, en segundos: una baja de acceso se aplica a más tardar en este tiempo. */
 const ACCESS_TTL = 60 * 60;
@@ -49,6 +50,7 @@ export function mountOAuth(app, { issuer, store, access, sameOrigin, redirects }
     });
     const pending = new Expiring(PENDING_TTL_MS);
     const codes = new Expiring(CODE_TTL_MS);
+    const secondFactors = new Expiring(PENDING_TTL_MS);
     const limiter = new RateLimiter(LOGIN_ATTEMPTS, LOGIN_WINDOW_MS);
     const registerLimiter = new RateLimiter(REGISTER_ATTEMPTS, REGISTER_WINDOW_MS);
     const form = express.urlencoded({ extended: false, limit: "16kb" });
@@ -130,7 +132,7 @@ export function mountOAuth(app, { issuer, store, access, sameOrigin, redirects }
         if (!request)
             return void errorPage(res, 400, "Pedido vencido", "Pasó demasiado tiempo. Volvé a conectar desde tu app.");
         const list = await regionals();
-        const retry = (error) => res.type("html").send(loginPage({
+        const retry = (res, error) => res.type("html").send(loginPage({
             action: "/authorize",
             regionals: list,
             pendingId: id,
@@ -141,23 +143,24 @@ export function mountOAuth(app, { issuer, store, access, sameOrigin, redirects }
             error,
         }));
         if (request.unknownRedirect && req.body?.acepto !== "si") {
-            return void retry("Para conectar una app que no es un cliente conocido tenés que aceptar el aviso.");
+            return void retry(res, "Para conectar una app que no es un cliente conocido tenés que aceptar el aviso.");
         }
-        const account = await login(req, list, retry);
-        if (!account)
-            return;
-        const decision = await access({ regional: account.regional.id, username: account.username, email: account.email });
-        if (!decision.allowed)
-            return void deniedPage(res, decision.reason, decision.url);
-        pending.take(id);
-        const code = codes.add({
-            userId: account.userId,
-            clientId: request.clientId,
-            redirectUri: request.redirectUri,
-            codeChallenge: request.codeChallenge,
+        await login(req, res, list, retry, async (res, account) => {
+            const decision = await access({ regional: account.regional.id, username: account.username, email: account.email });
+            if (!decision.allowed)
+                return void deniedPage(res, decision.reason, decision.url);
+            if (!pending.take(id)) {
+                return void errorPage(res, 400, "Pedido vencido", "Pasó demasiado tiempo. Volvé a conectar desde tu app.");
+            }
+            const code = codes.add({
+                userId: account.userId,
+                clientId: request.clientId,
+                redirectUri: request.redirectUri,
+                codeChallenge: request.codeChallenge,
+            });
+            logger.info(`OAuth: ${account.username} (${account.regional.id}) autorizó a ${request.clientName ?? request.clientId}.`);
+            redirectWith(res, request.redirectUri, { code, state: request.state, iss: issuer });
         });
-        logger.info(`OAuth: ${account.username} (${account.regional.id}) autorizó a ${request.clientName ?? request.clientId}.`);
-        redirectWith(res, request.redirectUri, { code, state: request.state, iss: issuer });
     });
     app.post("/token", cors, form, express.json({ limit: "16kb" }), async (req, res) => {
         const body = (req.body ?? {});
@@ -213,54 +216,74 @@ export function mountOAuth(app, { issuer, store, access, sameOrigin, redirects }
     app.get("/login", async (_req, res) => void res.type("html").send(loginPage({ action: "/login", regionals: await regionals() })));
     app.post("/login", sameOrigin, form, async (req, res) => {
         const list = await regionals();
-        const account = await login(req, list, (error) => res.type("html").send(loginPage({
+        const retry = (res, error) => res.type("html").send(loginPage({
             action: "/login",
             regionals: list,
             regional: req.body?.regional,
             error,
-        })));
-        if (!account)
-            return;
-        logger.info(`OAuth: ${account.username} (${account.regional.id}) renovó su sesión del aula.`);
-        res.type("html").send(page("Listo", "<p>Ya renovamos tu sesión del aula. Volvé al chat y pedile al agente que reintente.</p>"));
+        }));
+        await login(req, res, list, retry, async (res, account) => {
+            logger.info(`OAuth: ${account.username} (${account.regional.id}) renovó su sesión del aula.`);
+            res.type("html").send(page("Listo", "<p>Ya renovamos tu sesión del aula. Volvé al chat y pedile al agente que reintente.</p>"));
+        });
+    });
+    app.post("/segundo-factor", sameOrigin, form, async (req, res) => {
+        const id = String(req.body?.login ?? "");
+        const utnLogin = secondFactors.get(id);
+        if (!utnLogin)
+            return void errorPage(res, 400, "Login vencido", "Pasó demasiado tiempo. Volvé a iniciar sesión.");
+        utnLogin.flow.answer(String(req.body?.respuesta ?? ""));
+        await advance(res, utnLogin, id);
     });
     /** Entra al aula con lo que mandó el formulario; si falla, vuelve a mostrarlo con el error. */
-    async function login(req, list, retry) {
+    async function login(req, res, list, retry, finish) {
         if (!limiter.allow(req.ip ?? "desconocida")) {
-            retry("Demasiados intentos. Esperá unos minutos y probá de nuevo.");
-            return null;
+            return retry(res, "Demasiados intentos. Esperá unos minutos y probá de nuevo.");
         }
         const username = String(req.body?.usuario ?? "").trim();
         const password = String(req.body?.contrasena ?? "");
-        if (!username || !password) {
-            retry("Completá usuario y contraseña.");
-            return null;
-        }
+        if (!username || !password)
+            return retry(res, "Completá usuario y contraseña.");
         const regional = list.find((r) => r.id === String(req.body?.regional ?? ""));
-        if (!regional) {
-            retry("Elegí tu regional de la lista.");
-            return null;
-        }
+        if (!regional)
+            return retry(res, "Elegí tu regional de la lista.");
         if (regional.support === "unsupported") {
-            retry(`Todavía no hay soporte para ${regional.name}: su aula todavía no funciona con UTN-MCP.`);
-            return null;
+            return retry(res, `Todavía no hay soporte para ${regional.name}: su aula todavía no funciona con UTN-MCP.`);
         }
+        const flow = new PendingLogin((secondFactor) => linkAulaAccount(store, regional, { username, password }, secondFactor));
+        await advance(res, { flow, regional, username, retry, finish });
+    }
+    /**
+     * Sigue el login hasta que termina o pide el segundo factor: entonces muestra la página para
+     * contestarlo y lo guarda hasta la respuesta. `id` es el de un login que ya estaba esperando.
+     */
+    async function advance(res, utnLogin, id) {
+        const { flow, regional, username, retry, finish } = utnLogin;
         try {
-            return await linkAulaAccount(store, regional, { username, password });
+            const step = await flow.next();
+            if ("prompt" in step) {
+                return void res.type("html").send(secondFactorPage(id ?? secondFactors.add(utnLogin), step.prompt));
+            }
+            if (id)
+                secondFactors.take(id);
+            await finish(res, step.done);
         }
         catch (e) {
+            if (id)
+                secondFactors.take(id);
             if (e instanceof InvalidCredentialsError)
-                retry("La UTN rechazó el usuario o la contraseña.");
+                retry(res, "La UTN rechazó el usuario o la contraseña.");
+            else if (e instanceof MfaError)
+                retry(res, e.message);
             else if (regional.support === "candidate") {
                 // Nadie la había usado acá: lo más probable es que todavía no ande, no que esté caída.
                 logger.warn(`Regional ${regional.id} sin verificar, falló el login de ${username}: ${e.message}`);
-                retry(`No pudimos usar el aula de ${regional.name}: puede que todavía no ande con UTN-MCP.`);
+                retry(res, `No pudimos usar el aula de ${regional.name}: puede que todavía no ande con UTN-MCP.`);
             }
             else {
                 logger.error(`Login de ${username} (${regional.id}): ${e.message}`);
-                retry("No pudimos entrar al aula. Puede que esté caída: probá de nuevo en unos minutos.");
+                retry(res, "No pudimos entrar al aula. Puede que esté caída: probá de nuevo en unos minutos.");
             }
-            return null;
         }
     }
     return getOAuthProtectedResourceMetadataUrl(new URL(resource));
@@ -299,6 +322,28 @@ function deniedPage(res, reason, url) {
     const link = url ? `<p><a href="${escapeHtml(url)}">${escapeHtml(url)}</a></p>` : "";
     res.status(403).type("html").send(page("Sin acceso", `<p>${escapeHtml(reason)}</p>${link}`));
 }
+/** La página del segundo factor de Microsoft: elegir el método, tipear el código o avisar que ya se aprobó. */
+function secondFactorPage(id, prompt) {
+    const hidden = `<input type="hidden" name="login" value="${escapeHtml(id)}">`;
+    const formWith = (fields, button) => `<form method="post" action="/segundo-factor">${hidden}${fields}<button type="submit">${button}</button></form>`;
+    if (prompt.step === "choose") {
+        const options = prompt.methods
+            .map((m, i) => `<label class=acepto><input type="radio" name="respuesta" value="${escapeHtml(m.id)}"${i === 0 ? " checked" : ""}>` +
+            `<span>${escapeHtml(m.label)}</span></label>`)
+            .join("");
+        return page("Segundo factor", "<p>Tu cuenta de Microsoft pide un segundo factor. ¿Con cuál seguís?</p>" + formWith(options, "Seguir"));
+    }
+    if (prompt.step === "code") {
+        const error = prompt.retry ? "<p class=error>El código no era correcto. Probá de nuevo.</p>" : "";
+        const field = `<label>${escapeHtml(prompt.method.label)}<input name="respuesta" inputmode="numeric" ` +
+            `autocomplete="one-time-code" autocapitalize="none" required></label>`;
+        return page("Segundo factor", error + formWith(field, "Verificar"));
+    }
+    const number = prompt.number ? `<p>Cuando te lo pida, tocá este número:</p><p class=numero>${prompt.number}</p>` : "";
+    return page("Segundo factor", `<p>Aprobá el inicio de sesión en el celular (${escapeHtml(prompt.method.label)}).</p>` +
+        number +
+        formWith(`<input type="hidden" name="respuesta" value="ok">`, "Ya aprobé"));
+}
 function loginPage(o) {
     const where = o.redirectUri ? `<strong>${escapeHtml(describeRedirect(o.redirectUri))}</strong>` : "";
     const destination = where && !o.unknownRedirect ? ` Al terminar vas a volver a ${where}: si no es la app que estás conectando, no sigas.` : "";

package/build/server.js

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

package/build/shared/documents/merge.js

@@ -0,0 +1,197 @@
+import { PDFArray, PDFDocument, PDFName, StandardFonts, degrees, rgb } from "pdf-lib";
+/** Filas del índice que entran en una página A4 con letra de 11pt. */
+const INDEX_ROWS_PER_PAGE = 40;
+/**
+ * Alto de la franja que se AGREGA arriba de cada página de contenido para el enlace de
+ * vuelta al índice: la página queda un poco más alta, así el enlace nunca tapa el material.
+ */
+const BACK_STRIP = 18;
+const BACK_LABEL = "Volver al índice";
+/**
+ * Agrega a `page` un enlace rectangular (anotación Link sin borde) que muestra `dest` entera.
+ */
+function addPageLink(out, page, rect, dest) {
+    const link = out.context.register(out.context.obj({
+        Type: "Annot",
+        Subtype: "Link",
+        Rect: rect,
+        Border: [0, 0, 0],
+        Dest: [dest.ref, "Fit"],
+    }));
+    let annots = page.node.lookupMaybe(PDFName.of("Annots"), PDFArray);
+    if (!annots) {
+        annots = out.context.obj([]);
+        page.node.set(PDFName.of("Annots"), annots);
+    }
+    annots.push(link);
+}
+/**
+ * Une PDFs en uno solo, con un índice clickeable al principio: cada entrada abre la página
+ * donde empieza ese material, y cada página de contenido tiene arriba un enlace "Volver al
+ * índice" (en una franja agregada, sin tapar nada). El que no se puede abrir (roto o con
+ * clave) se salta y queda en `skipped`: pdf-lib no desencripta, así que un PDF con clave
+ * entraría con páginas rotas. El índice se arma al final, cuando se sabe qué archivos
+ * entraron, y se inserta al frente.
+ */
+export async function mergePdfs(files, documentTitle) {
+    const out = await PDFDocument.create();
+    if (documentTitle)
+        out.setTitle(documentTitle);
+    const merged = [];
+    /** En qué página empieza cada uno sin contar el índice, que todavía no se sabe cuánto ocupa. */
+    const contentStarts = [];
+    const skipped = [];
+    for (let index = 0; index < files.length; index++) {
+        const file = files[index];
+        let src;
+        try {
+            // ignoreEncryption solo para que `load` no rechace el archivo: así lo listamos
+            // en `skipped` con el motivo en vez de romper todo el pack.
+            src = await PDFDocument.load(file.bytes, { ignoreEncryption: true });
+        }
+        catch {
+            skipped.push({ index, title: file.title, reason: "no se pudo abrir (está roto)" });
+            continue;
+        }
+        if (src.isEncrypted) {
+            skipped.push({ index, title: file.title, reason: "tiene clave" });
+            continue;
+        }
+        let pages;
+        try {
+            pages = await out.copyPages(src, src.getPageIndices());
+        }
+        catch {
+            // Abre bien pero tiene objetos que no se pueden copiar: se salta como los rotos.
+            skipped.push({ index, title: file.title, reason: "no se pudieron copiar sus páginas" });
+            continue;
+        }
+        if (!pages.length) {
+            skipped.push({ index, title: file.title, reason: "no tiene páginas" });
+            continue;
+        }
+        contentStarts.push(out.getPageCount() + 1);
+        for (const page of pages)
+            out.addPage(page);
+        merged.push({ index, title: file.title, pages: pages.length });
+    }
+    if (!merged.length)
+        throw new Error("No se pudo unir ninguno de los PDF.");
+    const indexPages = Math.ceil(merged.length / INDEX_ROWS_PER_PAGE);
+    const withStart = merged.map((m, i) => ({ ...m, startPage: contentStarts[i] + indexPages }));
+    const font = await out.embedFont(StandardFonts.Helvetica);
+    await writeIndex(out, withStart, indexPages, font);
+    addBackLinks(out, indexPages, font);
+    const bytes = await out.save();
+    return { bytes, pages: out.getPageCount(), merged: withStart, skipped };
+}
+/** Escribe las páginas del índice y las inserta al frente, con cada renglón enlazado a su material. */
+async function writeIndex(out, merged, indexPages, font) {
+    const bold = await out.embedFont(StandardFonts.HelveticaBold);
+    const pageSize = [595, 842]; // A4
+    const margin = 50;
+    const lineHeight = 16;
+    const pages = [];
+    for (let n = 0; n < indexPages; n++) {
+        const page = out.insertPage(n, pageSize);
+        page.drawText(winAnsi("Índice"), { x: margin, y: pageSize[1] - margin, size: 16, font: bold });
+        pages.push(page);
+    }
+    merged.forEach((row, i) => {
+        const page = pages[Math.floor(i / INDEX_ROWS_PER_PAGE)];
+        const y = pageSize[1] - margin - lineHeight * (2 + (i % INDEX_ROWS_PER_PAGE));
+        const pageNo = String(row.startPage);
+        page.drawText(pageNo, { x: margin + 30 - font.widthOfTextAtSize(pageNo, 11), y, size: 11, font });
+        page.drawText(truncate(winAnsi(row.title), font, 11, pageSize[0] - margin * 2 - 40), {
+            x: margin + 40,
+            y,
+            size: 11,
+            font,
+        });
+        addPageLink(out, page, [margin, y - 4, pageSize[0] - margin, y + 11], out.getPage(row.startPage - 1));
+    });
+}
+/**
+ * Agrega a cada página de contenido una franja vacía con "Volver al índice" enlazado a la
+ * primera página del índice. La franja AGRANDA la página por el borde que queda arriba al
+ * leerla (arriba sin rotación; a la izquierda, abajo o a la derecha según la rotación de la
+ * página) y el texto se dibuja ya rotado: se lee horizontal en cualquier orientación y, al
+ * ser espacio agregado, nunca tapa el material. Toda la franja es clickeable.
+ */
+function addBackLinks(out, indexPages, font) {
+    const firstIndexPage = out.getPage(0);
+    const size = 9;
+    const color = rgb(0.1, 0.3, 0.7);
+    const textWidth = font.widthOfTextAtSize(BACK_LABEL, size);
+    const total = out.getPageCount();
+    for (let i = indexPages; i < total; i++) {
+        const page = out.getPage(i);
+        // Los dos box se leen ANTES de escribir: sin CropBox propio, getCropBox devuelve el
+        // MediaBox, y leerlo después de agrandarlo agrandaría el CropBox dos veces.
+        const media = page.getMediaBox();
+        const crop = page.getCropBox();
+        const { x: X, y: Y, width: w, height: h } = media;
+        const rotation = (((page.getRotation().angle % 360) + 360) % 360);
+        // Posición del texto y dirección del subrayado según el borde por donde crece la página.
+        let textX, textY, lineStart, lineEnd;
+        let strip;
+        let rotate;
+        switch (rotation) {
+            case 90:
+                // Al leerla rotada 90° el borde izquierdo queda arriba: la franja crece a la izquierda.
+                page.setMediaBox(X - BACK_STRIP, Y, w + BACK_STRIP, h);
+                page.setCropBox(crop.x - BACK_STRIP, crop.y, crop.width + BACK_STRIP, crop.height);
+                strip = [X - BACK_STRIP, Y, X, Y + h];
+                rotate = degrees(90);
+                textX = X - BACK_STRIP + 5 + size;
+                textY = Y + h - 30 - textWidth;
+                lineStart = { x: textX + 1.5, y: textY };
+                lineEnd = { x: textX + 1.5, y: textY + textWidth };
+                break;
+            case 180:
+                page.setMediaBox(X, Y - BACK_STRIP, w, h + BACK_STRIP);
+                page.setCropBox(crop.x, crop.y - BACK_STRIP, crop.width, crop.height + BACK_STRIP);
+                strip = [X, Y - BACK_STRIP, X + w, Y];
+                rotate = degrees(180);
+                textX = X + 30 + textWidth;
+                textY = Y - BACK_STRIP + 5 + size;
+                lineStart = { x: textX, y: textY + 1.5 };
+                lineEnd = { x: textX - textWidth, y: textY + 1.5 };
+                break;
+            case 270:
+                page.setMediaBox(X, Y, w + BACK_STRIP, h);
+                page.setCropBox(crop.x, crop.y, crop.width + BACK_STRIP, crop.height);
+                strip = [X + w, Y, X + w + BACK_STRIP, Y + h];
+                rotate = degrees(270);
+                textX = X + w + BACK_STRIP - 5 - size;
+                textY = Y + 30 + textWidth;
+                lineStart = { x: textX - 1.5, y: textY };
+                lineEnd = { x: textX - 1.5, y: textY - textWidth };
+                break;
+            default:
+                page.setMediaBox(X, Y, w, h + BACK_STRIP);
+                page.setCropBox(crop.x, crop.y, crop.width, crop.height + BACK_STRIP);
+                strip = [X, Y + h, X + w, Y + h + BACK_STRIP];
+                rotate = degrees(0);
+                textX = X + w - 30 - textWidth;
+                textY = Y + h + 5;
+                lineStart = { x: textX, y: textY - 1.5 };
+                lineEnd = { x: textX + textWidth, y: textY - 1.5 };
+                break;
+        }
+        page.drawText(BACK_LABEL, { x: textX, y: textY, size, font, color, rotate });
+        page.drawLine({ start: lineStart, end: lineEnd, thickness: 0.5, color });
+        addPageLink(out, page, strip, firstIndexPage);
+    }
+}
+/** Lo que la letra base del PDF sabe dibujar (WinAnsi); lo demás se cambia por "?". */
+const winAnsi = (text) => text.replace(/[^\x20-\x7E\xA0-\xFF\u2013\u2014\u2018\u2019\u201C\u201D\u2022\u2026]/g, "?");
+/** Recorta el título para que entre en el renglón, con "…" si se cortó. */
+function truncate(text, font, size, maxWidth) {
+    if (font.widthOfTextAtSize(text, size) <= maxWidth)
+        return text;
+    let cut = text;
+    while (cut && font.widthOfTextAtSize(cut + "…", size) > maxWidth)
+        cut = cut.slice(0, -1);
+    return cut + "…";
+}

package/build/shared/pages.js

@@ -41,7 +41,8 @@ button:hover{background:var(--accent)}
 .aviso{border:1px solid var(--err);padding:0 1rem;margin:1rem 0}
 label.acepto{flex-direction:row;align-items:flex-start;gap:.6rem;font:13px/1.5 ui-sans-serif,system-ui,sans-serif;
 text-transform:none;letter-spacing:normal;color:var(--ink)}
-input[type=checkbox]{padding:0;margin:.2rem 0 0;accent-color:var(--accent)}
+input[type=checkbox],input[type=radio]{padding:0;margin:.2rem 0 0;accent-color:var(--accent)}
+.numero{margin:1rem 0;font:600 2.5rem/1 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;text-align:center}
 ul{padding-left:1.2rem}
 ::selection{background:var(--accent);color:var(--paper)}
 `.replace(/\n/g, "");

package/build/shared/paths.js

@@ -15,3 +15,7 @@ export const sessionFile = () => join(configDir(), "session.json");
 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");
+/** Dónde quedan los archivos que arma el servidor (packs de estudio): UTN_MCP_EXPORTS o exports/ en la configuración. */
+export function exportsDir() {
+    return process.env.UTN_MCP_EXPORTS ?? join(configDir(), "exports");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "utn-mcp",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "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": {
@@ -42,6 +42,7 @@
     "@modelcontextprotocol/server": "^2.3.0",
     "@napi-rs/keyring": "^2.1.0",
     "express": "^5.2.1",
+    "pdf-lib": "^1.17.1",
     "tough-cookie": "^6.0.2",
     "zod": "^4.6.5"
   },