utn-mcp 0.8.1 → 0.8.3

package/README.md

@@ -19,6 +19,7 @@ El agente recorre el aula como lo harías vos: entra al curso, mira los foros y
 | `aula_list_courses` | Lista tus cursos. Es el punto de partida. |
 | `aula_open` | Entra a un curso, un módulo, un foro o una discusión. Cada respuesta trae las direcciones de lo que hay adentro y de un nivel más arriba, así el agente navega sin perderse. |
 | `aula_read_file` | Lee un archivo del aula, por partes cuando es largo. |
+| `aula_study_pack` | Une en un solo PDF con índice los apuntes que elijas de una materia (un 'machacado'), guardado en tu compu. Solo en modo local. |
 | `aula_get_site_info` | Datos de tu usuario y de tu regional en el aula virtual. |
 | `aula_forum_post` | Abre un hilo en un foro o responde en una discusión. |
 | `aula_forum_edit_post` | Edita una publicación tuya. |
@@ -120,7 +121,7 @@ utn-mcp login
 y en la config del cliente usás `"command": "utn-mcp"` sin argumentos.
 
 ### Regionales
-La regional se elige al iniciar sesión, de una lista con las regionales de la UTN. Buenos Aires (FRBA), Córdoba (FRC), Resistencia (FRRE) y Tucumán (FRT) ya están probadas. También está el aula de la Tecnicatura en Programación a distancia del SIED (TUP). El login se adapta solo: si el aula entra por SSO, sea un Keycloak propio (FRBA) u Office 365 (Haedo, FRH, y San Nicolás, FRSN), usa el SSO; si no, el login directo de Moodle. Con Office 365 todavía no se pueden completar cuentas que piden segundo factor (MFA).
+La regional se elige al iniciar sesión, de una lista con las regionales de la UTN. Buenos Aires (FRBA), Córdoba (FRC), Resistencia (FRRE) y Tucumán (FRT) ya están probadas. También está el aula de la Tecnicatura en Programación a distancia del SIED (TUP). El login se adapta solo: si el aula entra por SSO, sea un Keycloak propio (FRBA) u Office 365 (Haedo, FRH, y San Nicolás, FRSN), usa el SSO; si no, el login directo de Moodle. Si tu cuenta de Office 365 pide segundo factor (MFA), el login te pregunta con qué método seguir y te pide el código o que apruebes en el celular. Como el servidor renueva la sesión sin vos delante, con MFA te va a pedir que vuelvas a iniciar sesión cuando venza (dura semanas).
 
 La lista puede traer regionales que nadie probó todavía: su aula tiene habilitado el servicio que usa UTN-MCP, así que casi seguro anda. En un servidor hosteado, la primera persona que entra con una de esas la deja verificada para el resto. Las que no tienen el servicio habilitado aparecen como "todavía sin soporte": se pueden elegir, pero el login avisa que por ahora no se puede usar y no manda la contraseña.
 
@@ -160,9 +161,10 @@ La configuración va en variables de entorno o en un `.env` en la carpeta desde
 | `UTN_MCP_ACCESS_URL`, `UTN_MCP_ACCESS_SECRET` | Servicio que decide quién puede entrar. | — |
 | `UTN_MCP_ALLOWED_EMAILS` | Emails o dominios (`@frba.utn.edu.ar`) habilitados, separados por coma, si no hay `UTN_MCP_ACCESS_URL`. | Entra cualquiera con usuario de la UTN |
 | `UTN_MCP_REDIRECT_ALLOW` | Hosts (`app.ejemplo.com`) o esquemas (`miapp:`) extra, separados por coma, a los que puede volver el login de OAuth. Loopback, Claude, ChatGPT, VS Code y Cursor pasan siempre. Cualquier otro host HTTPS (un agente propio, por ejemplo) se acepta, pero el login avisa a dónde vuelve y el alumno tiene que marcar que lo conecta bajo su responsabilidad: es la defensa contra alguien que use tu página de login para quedarse con su sesión. Los hosts de esta lista pasan sin aviso. | — |
-| `UTN_MCP_ADMIN_SECRET` | Habilita la API de `/admin` para un panel de cuentas tuyo: `POST /admin/usuarios` (todos los usuarios con sus apps), `/admin/clientes` y `/admin/clientes/revocar` (las apps de un usuario, por email), `/admin/regionales` (las regionales con su soporte) y `/admin/verificar` (entra al aula con usuario y contraseña, como el login de OAuth, y le guarda la sesión). | — |
+| `UTN_MCP_ADMIN_SECRET` | Habilita la API de `/admin` para un panel de cuentas tuyo: `POST /admin/usuarios` (todos los usuarios con sus apps), `/admin/clientes` y `/admin/clientes/revocar` (las apps de un usuario, por email), `/admin/regionales` (las regionales con su soporte) y `/admin/verificar` (entra al aula con usuario y contraseña, como el login de OAuth, y le guarda la sesión; si Microsoft pide segundo factor, devuelve el paso y se sigue con `/admin/segundo-factor`). | — |
 | `UTN_MCP_LOGIN_URL` | Página donde el usuario renueva su sesión del aula; el agente se la pasa. | `<UTN_MCP_PUBLIC_URL>/login` |
 | `UTN_MCP_DB`, `UTN_MCP_KEY` | Base de sesiones y su clave de cifrado (32 bytes en base64). | En la carpeta de config |
+| `UTN_MCP_PACK_MAX_FILES`, `UTN_MCP_PACK_MAX_MB`, `UTN_MCP_PACK_MAX_FINAL_MB` | Topes del compilado de estudio (`aula_study_pack`, solo modo local): archivos por pack, MB de descarga total y MB del PDF final, que se arma entero en memoria. | 150, 300 y 30 |
 
 Con Docker, detrás de un reverse proxy con HTTPS en la misma máquina (red host, para que el rate limit del login vea la IP real):
 ```bash

package/build/aula-virtual/client/client.js

@@ -27,6 +27,27 @@ export function getCourseSections(session, courseId, cmid) {
     }
     return callWs(session, "core_course_get_contents", params);
 }
+/**
+ * Los archivos de las secciones y módulos visibles del curso, en el orden en que aparecen en el aula.
+ * Los mismos filtros de visibilidad que el mapa del curso de format/navigate.
+ */
+export async function getCourseFiles(session, courseId) {
+    const sections = await getCourseSections(session, courseId);
+    const entries = [];
+    for (const section of sections) {
+        if (section.uservisible === false)
+            continue;
+        for (const module of section.modules) {
+            if (!module.uservisible)
+                continue;
+            for (const content of module.contents ?? []) {
+                if (content.type === "file")
+                    entries.push({ section: section.name, module: module.name, file: content });
+            }
+        }
+    }
+    return entries;
+}
 // --- Foros ---
 /** Cuántas discusiones trae una página del índice de un foro. */
 export const PAGE_SIZE = 50;

package/build/aula-virtual/client/link.js

@@ -6,9 +6,10 @@ import { AULA_PLATFORM } from "./stored-session.js";
  * guarda la sesión (el token). La contraseña se usa solo acá: no se guarda en ningún lado.
  * Lo usan `utn-mcp login --http`, el login por OAuth de la versión hosteada y `/admin/verificar`.
  * `regional` tiene que venir con su soporte en este servidor (`availableRegionals` con las verificadas).
+ * `secondFactor` contesta el MFA de Microsoft si la cuenta lo pide.
  */
-export async function linkAulaAccount(store, regional, credentials) {
-    const token = await fetchToken(regional, credentials);
+export async function linkAulaAccount(store, regional, credentials, secondFactor) {
+    const token = await fetchToken(regional, credentials, secondFactor);
     // El token recién emitido: si falla, no hay con qué renovarlo.
     const fresh = {
         getRegional: async () => regional,

package/build/aula-virtual/client/local-session.js

@@ -31,12 +31,12 @@ export class LocalSession {
         });
         return this.refreshing;
     }
-    /** Obtiene un token nuevo y lo guarda. */
-    async login(regional, credentials) {
+    /** Obtiene un token nuevo y lo guarda. Sin `secondFactor` (al renovar solo), una cuenta con MFA no entra. */
+    async login(regional, credentials, secondFactor) {
         if (!credentials)
             throw new LoginRequiredError();
         logger.info(`Obteniendo token del aula virtual de ${regional.name}...`);
-        const token = await fetchToken(regional, credentials);
+        const token = await fetchToken(regional, credentials, secondFactor);
         await this.write({ token, obtainedAt: new Date().toISOString(), regional: regional.id });
         return token;
     }

package/build/aula-virtual/client/moodle-api.js

@@ -34,23 +34,47 @@ export async function callWs(session, wsfunction, params = {}) {
 /**
  * Baja un archivo de `webservice/pluginfile.php` con el token; lo renueva una vez si venció.
  * Los errores llegan como JSON (`{ error, errorcode }`) en lugar del archivo.
+ * Los redirects se siguen a mano y SOLO al propio aula y a rutas de archivos (pluginfile):
+ * un pluginfile legítimo no redirige afuera, así que cualquier otro destino se rechaza.
  */
 export async function fetchFile(session, url, maxBytes) {
     let token = await session.getToken();
-    for (let attempt = 0;; attempt++) {
-        const withToken = new URL(url);
+    const { baseUrl } = await session.getRegional();
+    const aulaOrigin = new URL(baseUrl).origin;
+    let current = url;
+    let redirects = 0;
+    // Aparte de los redirects: uno antes del token vencido no tiene que gastar la renovación.
+    let refreshed = false;
+    for (;;) {
+        const withToken = new URL(current);
         withToken.searchParams.set("token", token);
         let res;
         try {
-            res = await fetch(withToken, { signal: AbortSignal.timeout(60_000) });
+            res = await fetch(withToken, { signal: AbortSignal.timeout(60_000), redirect: "manual" });
         }
         catch (e) {
             throw new MoodleError(`No se pudo bajar el archivo: ${e.message}`);
         }
+        if (res.status >= 300 && res.status < 400) {
+            const location = res.headers.get("location");
+            const next = location ? new URL(location, current) : null;
+            redirects++;
+            if (redirects > 3 ||
+                !next ||
+                next.username ||
+                next.password ||
+                next.origin !== aulaOrigin ||
+                !next.pathname.includes("pluginfile.php")) {
+                throw new MoodleError(`El aula redirigió la descarga a una dirección no permitida (${location ?? "sin destino"})`);
+            }
+            current = next;
+            continue;
+        }
         const contentType = res.headers.get("content-type");
         if (contentType?.startsWith("application/json")) {
             const data = (await res.json());
-            if (attempt === 0 && data.errorcode && TOKEN_ERRORS.has(data.errorcode)) {
+            if (!refreshed && data.errorcode && TOKEN_ERRORS.has(data.errorcode)) {
+                refreshed = true;
                 token = await session.refreshToken();
                 continue;
             }

package/build/aula-virtual/client/sso-login.js

@@ -1,4 +1,5 @@
 import { randomInt } from "node:crypto";
+import { setTimeout as sleep } from "node:timers/promises";
 import { CookieJar } from "tough-cookie";
 import { UnsupportedRegionalError } from "./regionals.js";
 import { MoodleError } from "./moodle-api.js";
@@ -38,8 +39,10 @@ const PROVIDERS = {
  *   plugin de mobile launch, que puede estar deshabilitado); si falla, flujo de launch.php.
  * Las cookies se usan solo durante el login y se descartan: las sesiones de Moodle y del SSO duran
  * horas y el token, semanas, así que no sirven para renovarlo.
+ * `secondFactor` contesta el MFA de Microsoft; sin él (las renovaciones solas), una cuenta con MFA da
+ * `MfaRequiredError`.
  */
-export async function fetchToken(regional, credentials) {
+export async function fetchToken(regional, credentials, secondFactor) {
     if (regional.support === "unsupported")
         throw new UnsupportedRegionalError(regional);
     const { baseUrl, sso } = regional;
@@ -55,14 +58,14 @@ export async function fetchToken(regional, credentials) {
     let landing = await follow(jar, launchUrl);
     if ("token" in landing)
         return landing.token;
-    const provider = sso && PROVIDERS[sso.provider];
-    const ssoHref = provider && landing.html.match(provider.link)?.[1];
-    if (sso && provider && ssoHref) {
+    const ssoProvider = sso ? PROVIDERS[sso.provider] : undefined;
+    const ssoHref = ssoProvider && landing.html.match(ssoProvider.link)?.[1];
+    if (sso && ssoProvider && ssoHref) {
         landing = await follow(jar, new URL(decodeHtml(ssoHref), landing.url).toString());
         if ("token" in landing)
             return landing.token;
         if (new URL(landing.url).host === sso.host) {
-            landing = await provider.submit(jar, landing, credentials);
+            landing = await ssoProvider.submit(jar, landing, credentials, secondFactor);
             if ("token" in landing)
                 return landing.token;
             if (new URL(landing.url).host === sso.host) {
@@ -70,7 +73,7 @@ export async function fetchToken(regional, credentials) {
                 const viaTokenPhp = await tryTokenPhp(baseUrl, credentials);
                 if (viaTokenPhp)
                     return viaTokenPhp;
-                throw new InvalidCredentialsError(provider.loginError(landing.html));
+                throw new InvalidCredentialsError(ssoProvider.loginError(landing.html));
             }
         }
     }
@@ -100,21 +103,44 @@ export async function fetchToken(regional, credentials) {
     }
     throw unexpected(landing.url);
 }
-export class MfaRequiredError extends Error {
-    constructor(reason) {
-        super("Tu cuenta de Microsoft pide un segundo factor (código, app o similar), que UTN-MCP todavía no puede " +
-            "completar solo." + (reason ? ` Microsoft dijo: ${reason}` : ""));
+/** La cuenta pide MFA y no hay quién lo conteste: pasa al renovar solo, sin el usuario delante. */
+export class MfaRequiredError extends LoginRequiredError {
+    constructor() {
+        super("Tu cuenta de Microsoft pide un segundo factor (MFA), que solo se completa al iniciar sesión: " +
+            "corré `utn-mcp login`.");
         this.name = "MfaRequiredError";
     }
 }
-/** Cantidad máxima de pasos de Microsoft entre la contraseña y la vuelta al aula (KMSI y similares). */
-const MAX_MICROSOFT_STEPS = 6;
+/** El segundo factor no se pudo completar; el mensaje dice por qué y se le puede mostrar al usuario. */
+export class MfaError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "MfaError";
+    }
+}
+/** Los `authMethodId` que se completan sin navegador: los demás (FIDO, Windows Hello) necesitan uno. */
+const MFA_METHODS = {
+    PhoneAppNotification: { kind: "approve", label: "Notificación de Microsoft Authenticator" },
+    CompanionAppsNotification: { kind: "approve", label: "Notificación de Microsoft Authenticator" },
+    PhoneAppOTP: { kind: "code", label: "Código de Microsoft Authenticator" },
+    OneWaySMS: { kind: "code", label: "Código por SMS" },
+    TwoWayVoiceMobile: { kind: "approve", label: "Llamada al celular" },
+    TwoWayVoiceAlternateMobile: { kind: "approve", label: "Llamada al celular alternativo" },
+    TwoWayVoiceOffice: { kind: "approve", label: "Llamada al teléfono de la oficina" },
+};
+/** Intentos de código antes de cortar: Microsoft también bloquea después de varios. */
+const MAX_CODE_ATTEMPTS = 3;
+/** Cada cuánto se pregunta si ya se aprobó, en milisegundos, y cuántas veces (un minuto en total). */
+const APPROVE_POLL_MS = 2_000;
+const APPROVE_POLLS = 30;
+/** Cantidad máxima de pasos de Microsoft entre la contraseña y la vuelta al aula (MFA, KMSI y similares). */
+const MAX_MICROSOFT_STEPS = 8;
 /**
  * Formulario de Office 365 (Microsoft Entra ID). No es un `<form>`: los datos están en el `$Config` de
- * la página. Después de la contraseña puede venir "¿Mantener la sesión iniciada?" antes del formulario
- * que vuelve al aula con el `code`. No completa MFA ni logins federados (ADFS).
+ * la página. Después de la contraseña pueden venir el segundo factor y "¿Mantener la sesión iniciada?"
+ * antes del formulario que vuelve al aula con el `code`. No completa logins federados (ADFS).
  */
-async function submitMicrosoftForm(jar, page, { username, password }) {
+async function submitMicrosoftForm(jar, page, { username, password }, secondFactor) {
     const ssoHost = new URL(page.url).host;
     const cfg = parseAadConfig(page.html);
     if (!cfg?.urlPost || !cfg.sFT) {
@@ -144,8 +170,12 @@ async function submitMicrosoftForm(jar, page, { username, password }) {
             return follow(jar, action, { method: "POST", body: new URLSearchParams(form.inputs) });
         }
         const step = parseAadConfig(landing.html);
-        if (step?.arrUserProofs?.length)
-            throw new MfaRequiredError(step.strServiceExceptionMessage);
+        if (step?.arrUserProofs?.length) {
+            if (!secondFactor)
+                throw new MfaRequiredError();
+            landing = await completeMfa(jar, landing, step, username, secondFactor);
+            continue;
+        }
         if (step?.sErrorCode)
             return landing;
         if (step?.urlPost) {
@@ -169,6 +199,103 @@ async function submitMicrosoftForm(jar, page, { username, password }) {
     }
     throw new Error("Demasiados pasos en el login de Microsoft.");
 }
+/**
+ * El segundo factor de Microsoft, con los mismos endpoints que usa su página: `BeginAuth` lo arranca
+ * (manda la notificación, el SMS o la llamada), `EndAuth` lo verifica (con el código, o preguntando si
+ * ya se aprobó) y `ProcessAuth` sigue el login, que vuelve a la página siguiente (KMSI o el aula).
+ */
+async function completeMfa(jar, page, cfg, username, secondFactor) {
+    const proofs = cfg.arrUserProofs ?? [];
+    const methods = proofs.flatMap(({ authMethodId: id, display }) => {
+        const known = id ? MFA_METHODS[id] : undefined;
+        return id && known ? [{ id, kind: known.kind, label: display ? `${known.label} · ${display}` : known.label }] : [];
+    });
+    if (!methods.length) {
+        const ids = proofs.map((p) => p.authMethodId).join(", ");
+        throw new MfaError(`Tu cuenta de Microsoft solo tiene métodos de segundo factor que necesitan el navegador (${ids}). ` +
+            "Agregá Microsoft Authenticator o un teléfono en https://mysignins.microsoft.com/security-info y volvé a intentar.");
+    }
+    if (!cfg.urlBeginAuth || !cfg.urlEndAuth || !cfg.urlPost) {
+        throw new Error("No se encontró el formulario del segundo factor de Microsoft; puede que haya cambiado.");
+    }
+    const preferred = proofs.find((p) => p.isDefault)?.authMethodId;
+    methods.sort((a, b) => Number(b.id === preferred) - Number(a.id === preferred));
+    const chosenId = methods.length > 1 ? await secondFactor({ step: "choose", methods }) : methods[0].id;
+    const method = methods.find((m) => m.id === chosenId);
+    if (!method)
+        throw new MfaError("Ese método de segundo factor no está entre los de tu cuenta.");
+    const sasUrl = (url) => new URL(url, page.url).toString();
+    const begin = await postSas(jar, sasUrl(cfg.urlBeginAuth), {
+        AuthMethodId: method.id,
+        Method: "BeginAuth",
+        ctx: cfg.sCtx ?? "",
+        flowToken: cfg.sFT ?? "",
+    });
+    if (!begin.Success)
+        throw new MfaError(`Microsoft no pudo arrancar el segundo factor (${begin.Message || begin.ResultValue}).`);
+    const endAuth = (extra) => postSas(jar, sasUrl(cfg.urlEndAuth), {
+        Method: "EndAuth",
+        AuthMethodId: method.id,
+        SessionId: begin.SessionId,
+        FlowToken: begin.FlowToken,
+        Ctx: begin.Ctx,
+        ...extra,
+    });
+    let end;
+    let otc = "";
+    if (method.kind === "code") {
+        for (let attempt = 0; attempt < MAX_CODE_ATTEMPTS && !end?.Success; attempt++) {
+            otc = (await secondFactor({ step: "code", method, retry: attempt > 0 })).replace(/\s/g, "");
+            end = await endAuth({ AdditionalAuthData: otc, PollCount: 1 });
+            if (!end.Success && !/incorrect|wrongcode/i.test(end.ResultValue ?? ""))
+                break;
+        }
+    }
+    else {
+        await secondFactor({ step: "approve", method, number: begin.Entropy || undefined });
+        for (let poll = 1; poll <= APPROVE_POLLS; poll++) {
+            end = await endAuth({ PollCount: poll });
+            if (end.Success || end.ResultValue !== "AuthenticationPending")
+                break;
+            await sleep(APPROVE_POLL_MS);
+        }
+    }
+    if (!end?.Success) {
+        const reason = end?.ResultValue === "AuthenticationPending" ? "no llegó la aprobación a tiempo" : end?.Message || end?.ResultValue;
+        throw new MfaError(`Microsoft no aceptó el segundo factor (${reason}). Volvé a iniciar sesión para probar de nuevo.`);
+    }
+    return follow(jar, sasUrl(cfg.urlPost), {
+        method: "POST",
+        body: new URLSearchParams({
+            request: end.Ctx ?? begin.Ctx ?? "",
+            mfaAuthMethod: method.id,
+            flowToken: end.FlowToken ?? begin.FlowToken ?? "",
+            canary: cfg.canary ?? "",
+            otc,
+            login: username,
+            hideSmsInMfaProofs: "false",
+        }),
+    });
+}
+/** POST JSON a `SAS/BeginAuth` o `SAS/EndAuth`, con las cookies del login. */
+async function postSas(jar, url, body) {
+    const cookie = await jar.getCookieString(url);
+    const res = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json", accept: "application/json", ...(cookie ? { cookie } : {}) },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(TIMEOUT_MS),
+    });
+    for (const setCookie of res.headers.getSetCookie()) {
+        await jar.setCookie(setCookie, url, { ignoreError: true });
+    }
+    try {
+        return (await res.json());
+    }
+    catch {
+        throw new Error(`Respuesta inesperada del segundo factor de Microsoft (${res.status}).`);
+    }
+}
 /** El motivo del rechazo en una página de Microsoft (ej. AADSTS50126: usuario o contraseña incorrectos). */
 function microsoftLoginError(html) {
     const cfg = parseAadConfig(html);

package/build/aula-virtual/client/stored-session.js

@@ -1,6 +1,6 @@
 import { loadCredentials } from "./credentials.js";
 import { defaultRegional, findRegional } from "./regionals.js";
-import { fetchToken, LoginRequiredError } from "./sso-login.js";
+import { fetchToken, LoginRequiredError, MfaRequiredError } from "./sso-login.js";
 /** Con qué nombre guarda el aula su sesión en el store. */
 export const AULA_PLATFORM = "aula";
 /**
@@ -47,7 +47,9 @@ export class StoredAulaSession {
             (credentials.regional ?? defaultRegional().id) === regional.id;
         if (!credentials || !sameUser)
             throw this.loginRequired("La sesión del aula venció.");
-        const token = await fetchToken(regional, credentials);
+        const token = await fetchToken(regional, credentials).catch((e) => {
+            throw e instanceof MfaRequiredError ? this.loginRequired("Tu cuenta de Microsoft pide un segundo factor (MFA).") : e;
+        });
         // Sin `...stored`: las sesiones guardadas antes traen cookies, que ya no se usan.
         const data = { username: stored.username, token };
         await this.store.saveSession(this.userId, AULA_PLATFORM, JSON.stringify(data));

package/build/aula-virtual/format/address.js

@@ -1,3 +1,14 @@
+/**
+ * Direcciones de navegación del aula: un path que el modelo recibe en una respuesta
+ * y devuelve tal cual para entrar ahí. No hay estado en el servidor; la dirección
+ * dice todo lo necesario, y el padre se deduce del texto (eso es el "volver").
+ */
+export const AddressLevel = {
+    Root: "root",
+    Course: "course",
+    Module: "module",
+    Discussion: "discussion",
+};
 export const ROOT = "/";
 export const courseAddr = (courseId) => `/curso/${courseId}`;
 export const moduleAddr = (courseId, cmid) => `/curso/${courseId}/mod/${cmid}`;

package/build/aula-virtual/format/files.js

@@ -7,7 +7,7 @@ const BUDGET_CHARS = 30_000;
 /** Lo que cuesta una página como imagen (~1.600 tokens), medido en caracteres de texto. */
 const IMAGE_COST_CHARS = 6_000;
 /** El más grande que hay hoy en los cursos pesa 12 MB. */
-const MAX_BYTES = 30 * 1024 * 1024;
+export 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
@@ -32,7 +32,7 @@ export function userFacingUrl(fileurl) {
  * Acepta cualquiera de las dos formas y devuelve la del web service. Solo archivos del aula del
  * usuario (`baseUrl`): con cualquier otra URL estaríamos mandando su token a donde diga el modelo.
  */
-function downloadUrl(baseUrl, url) {
+export function downloadUrl(baseUrl, url) {
     let u;
     try {
         u = new URL(url);

package/build/aula-virtual/format/study-pack.js

@@ -0,0 +1,199 @@
+import { createHash } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { mergePdfs } from "../../shared/documents/merge.js";
+import { exportsDir } from "../../shared/paths.js";
+import { getCourseFiles, getUserCourses } from "../client/client.js";
+import { parseAddress } from "./address.js";
+import { downloadUrl, MAX_BYTES } from "./files.js";
+import { fetchFile } from "../client/moodle-api.js";
+/**
+ * Topes de tamaño por pack: pdf-lib junta todo el resultado en memoria, así que sin tope total un
+ * curso enorme podría colgar la compu donde corre el servidor. Lo que queda afuera por un tope se
+ * lista en `omitidos` con el motivo, para pedir el resto en otro pack.
+ * Una variable de entorno con basura NO puede desactivar el tope: si no es un número válido,
+ * vuelve al default.
+ */
+const capFromEnv = (raw, fallback) => {
+    const n = Number(raw ?? fallback);
+    return Number.isFinite(n) && n > 0 ? n : fallback;
+};
+const MAX_PACK_FILES = capFromEnv(process.env.UTN_MCP_PACK_MAX_FILES, 150);
+const MAX_PACK_BYTES = capFromEnv(process.env.UTN_MCP_PACK_MAX_MB, 300) * 1024 * 1024;
+/** Máximo del PDF final: se estima con los tamaños de entrada para cortar antes de bajar todo. */
+const MAX_FINAL_MB = capFromEnv(process.env.UTN_MCP_PACK_MAX_FINAL_MB, 30);
+const MAX_FINAL_BYTES = MAX_FINAL_MB * 1024 * 1024;
+const isPdf = (e) => e.file.mimetype === "application/pdf" || e.file.filename.toLowerCase().endsWith(".pdf");
+/** Los caracteres que no sirven para un nombre de archivo se cambian por "-". */
+const safeFileName = (name) => name.replace(/[^\p{L}\p{N}._-]+/gu, "-").replace(/^-+|-+$/g, "");
+/**
+ * Escribe el pack sin pisar packs anteriores: nombre con fecha-hora y, si ya existe (dos packs
+ * en el mismo segundo), un sufijo -2, -3... La escritura es atómica por nombre (bandera "wx").
+ */
+export async function writePackFile(dir, courseName, bytes) {
+    const now = new Date();
+    const pad = (n) => String(n).padStart(2, "0");
+    const stamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+    const base = join(dir, `${safeFileName(courseName)}-apuntes-${stamp}`);
+    for (let n = 1; n <= 100; n++) {
+        const candidate = n === 1 ? `${base}.pdf` : `${base}-${n}.pdf`;
+        try {
+            await writeFile(candidate, bytes, { flag: "wx" });
+            return candidate;
+        }
+        catch (e) {
+            if (e.code !== "EEXIST")
+                throw e;
+        }
+    }
+    throw new Error(`No se pudo guardar el pack: ya existen 100 archivos para "${base}".`);
+}
+/**
+ * Baja PDF de un curso y los une en un solo archivo con índice, guardado en exportsDir().
+ * Con `archivos` une solo las URL pedidas (tal como las devuelve aula_open, validadas con
+ * `downloadUrl` como en aula_read_file); sin `archivos`, todos los PDF del curso. El pack sigue
+ * el orden del aula, no el de la lista, para que el índice acompañe las unidades. Los duplicados
+ * exactos se descartan al armar, porque ahí se bajan igual. Todo lo omitido queda listado en
+ * `omitidos` con el motivo; en el atajo sin `archivos`, los archivos que no son PDF solo se
+ * cuentan en `archivosNoPdf` en vez de listarse uno por uno.
+ */
+export async function buildStudyPack(session, rawAddress, archivos) {
+    const address = parseAddress(rawAddress);
+    if (address.level !== "course") {
+        throw new Error(`Para armar el pack pasá la dirección de un curso entero ("/curso/{courseId}", de aula_list_courses), no "${rawAddress}".`);
+    }
+    const { baseUrl } = await session.getRegional();
+    const course = (await getUserCourses(session)).find((c) => c.id === address.courseId);
+    const entries = await getCourseFiles(session, address.courseId);
+    let selected;
+    const omitted = [];
+    if (archivos) {
+        // Cada URL pedida se valida igual que en aula_read_file: solo archivos del aula del usuario.
+        const requested = new Set(archivos.map((u) => downloadUrl(baseUrl, u).href));
+        const byUrl = new Map(entries.map((e) => [downloadUrl(baseUrl, e.file.fileurl).href, e]));
+        const unknown = [...requested].filter((u) => !byUrl.has(u));
+        if (unknown.length) {
+            throw new Error(`Estas URL no son de archivos del curso (salen de aula_open sobre "${rawAddress}"):\n` +
+                unknown.map((u) => `- ${u}`).join("\n"));
+        }
+        // El orden lo manda el aula, no la lista: el índice sigue las unidades.
+        selected = entries.filter((e) => requested.has(downloadUrl(baseUrl, e.file.fileurl).href));
+        for (const e of selected.filter((x) => !isPdf(x))) {
+            omitted.push({ nombre: e.file.filename, seccion: e.section, motivo: "no es un PDF" });
+        }
+    }
+    else {
+        selected = entries;
+    }
+    const pdfs = selected.filter(isPdf);
+    const archivosNoPdf = archivos ? 0 : selected.length - pdfs.length;
+    if (!pdfs.length) {
+        throw new Error(archivos
+            ? "Ninguna de las URL pedidas es un PDF: la tool une únicamente PDF."
+            : "El curso no tiene ningún PDF en sus secciones visibles.");
+    }
+    const capMotivo = `se alcanzó el tope del pack (${MAX_PACK_FILES} archivos / ${MAX_PACK_BYTES / 1024 / 1024} MB)`;
+    const inputs = [];
+    const kept = [];
+    const seen = new Map(); // hash -> nombre del primero con ese contenido
+    let totalBytes = 0;
+    let finalLleno = false;
+    for (const entry of pdfs) {
+        const name = entry.file.filename;
+        if (finalLleno) {
+            omitted.push({
+                nombre: name,
+                seccion: entry.section,
+                motivo: `el PDF final llegó al tope de ${MAX_FINAL_MB} MB (estimado con los tamaños de entrada)`,
+            });
+            continue;
+        }
+        if (inputs.length >= MAX_PACK_FILES || totalBytes + (entry.file.filesize ?? 0) > MAX_PACK_BYTES) {
+            omitted.push({ nombre: name, seccion: entry.section, motivo: capMotivo });
+            continue;
+        }
+        let bytes;
+        try {
+            bytes = (await fetchFile(session, downloadUrl(baseUrl, entry.file.fileurl), MAX_BYTES)).bytes;
+        }
+        catch (e) {
+            omitted.push({ nombre: name, seccion: entry.section, motivo: e.message });
+            continue;
+        }
+        const hash = createHash("sha256").update(bytes).digest("hex");
+        const original = seen.get(hash);
+        if (original) {
+            omitted.push({ nombre: name, seccion: entry.section, motivo: `es idéntico a "${original}"` });
+            continue;
+        }
+        // El tamaño real se conoce recién ahora (Moodle a veces no lo anuncia): tope post-descarga.
+        if (totalBytes + bytes.length > MAX_PACK_BYTES) {
+            omitted.push({ nombre: name, seccion: entry.section, motivo: capMotivo });
+            continue;
+        }
+        // Corte temprano del tope del PDF final, estimado con los tamaños de entrada: lo que ya
+        // no puede entrar no se baja de más ni tira abajo el pack entero al final.
+        if (totalBytes + bytes.length > MAX_FINAL_BYTES) {
+            finalLleno = true;
+            omitted.push({
+                nombre: name,
+                seccion: entry.section,
+                motivo: `el PDF final llegó al tope de ${MAX_FINAL_MB} MB (estimado con los tamaños de entrada)`,
+            });
+            continue;
+        }
+        seen.set(hash, name);
+        inputs.push({ title: name, bytes });
+        kept.push(entry);
+        totalBytes += bytes.length;
+    }
+    // En el índice va el módulo, que se lee mejor que el archivo; si el módulo aporta más de un
+    // archivo, también el archivo, para que las entradas no queden repetidas.
+    const perModule = new Map();
+    const moduleKey = (e) => `${e.section}\n${e.module}`;
+    for (const e of kept)
+        perModule.set(moduleKey(e), (perModule.get(moduleKey(e)) ?? 0) + 1);
+    kept.forEach((e, i) => {
+        inputs[i].title = perModule.get(moduleKey(e)) > 1 ? `${e.module}: ${e.file.filename}` : e.module;
+    });
+    const courseName = course?.shortname ?? `curso-${address.courseId}`;
+    const dir = exportsDir();
+    // La estimación puede quedar corta (el índice y los enlaces agregan páginas): si el unido
+    // supera el tope igual, salen los últimos materiales hasta que entre, en vez de tirar todo
+    // el trabajo de descarga.
+    let pack = await mergePdfs(inputs, `Apuntes de ${course?.fullname ?? courseName}`);
+    while (pack.bytes.length > MAX_FINAL_BYTES && inputs.length > 1) {
+        inputs.pop();
+        const entry = kept.pop();
+        omitted.push({
+            nombre: entry.file.filename,
+            seccion: entry.section,
+            motivo: `el PDF final superó el tope de ${MAX_FINAL_MB} MB al unir`,
+        });
+        pack = await mergePdfs(inputs, `Apuntes de ${course?.fullname ?? courseName}`);
+    }
+    if (pack.bytes.length > MAX_FINAL_BYTES) {
+        const mb = Math.round((pack.bytes.length / 1024 / 1024) * 10) / 10;
+        throw new Error(`El PDF final pesa ${mb} MB, más del máximo (${MAX_FINAL_MB} MB): no se guardó. ` +
+            "Pedí el pack con `archivos`, eligiendo solo los PDF que necesitás.");
+    }
+    for (const s of pack.skipped) {
+        omitted.push({ nombre: kept[s.index].file.filename, seccion: kept[s.index].section, motivo: s.reason });
+    }
+    await mkdir(dir, { recursive: true });
+    const path = await writePackFile(dir, courseName, pack.bytes);
+    return {
+        archivo: path,
+        curso: course?.fullname ?? courseName,
+        paginas: pack.pages,
+        materiales: pack.merged.map((m) => ({
+            nombre: kept[m.index].file.filename,
+            seccion: kept[m.index].section,
+            modulo: kept[m.index].module,
+            paginas: m.pages,
+            empiezaEn: m.startPage,
+        })),
+        omitidos: omitted.length ? omitted : undefined,
+        archivosNoPdf: archivosNoPdf || undefined,
+    };
+}

package/build/aula-virtual/login.js

@@ -22,7 +22,7 @@ export async function runLogin(http) {
     if (http)
         accessToken = await loginToStore(regional, credentials);
     else
-        await new LocalSession().login(regional, credentials);
+        await new LocalSession().login(regional, credentials, askSecondFactor);
     // Se guardan recién después de comprobar que el aula las aceptó.
     if (await saveCredentials(credentials)) {
         logger.info("Credenciales guardadas en el keychain del sistema.");
@@ -50,9 +50,21 @@ async function askRegional() {
     const labels = regionals.map((r) => r.name + SUPPORT_LABEL[r.support]);
     return regionals[await askChoice("Regional:", labels, Math.max(initial, 0))];
 }
+/** Contesta por la terminal el segundo factor de Microsoft, si la cuenta lo pide. */
+const askSecondFactor = async (prompt) => {
+    if (prompt.step === "choose") {
+        const labels = prompt.methods.map((m) => m.label);
+        return prompt.methods[await askChoice("Microsoft pide un segundo factor:", labels)].id;
+    }
+    if (prompt.step === "code") {
+        return ask(prompt.retry ? "El código no era correcto. Probá de nuevo: " : `${prompt.method.label}: `);
+    }
+    const number = prompt.number ? ` y tocá el número ${prompt.number}` : "";
+    return ask(`Aprobá el inicio de sesión en el celular (${prompt.method.label})${number}. Después apretá Enter. `);
+};
 /** Crea el usuario si no existe, guarda su sesión del aula y le emite un token que no vence. */
 async function loginToStore(regional, credentials) {
     const store = await SqliteStore.open();
-    const { userId } = await linkAulaAccount(store, regional, credentials);
+    const { userId } = await linkAulaAccount(store, regional, credentials, askSecondFactor);
     return store.issueToken(userId, { kind: "access", clientId: "local" });
 }