utn-mcp 0.7.0 → 0.8.1

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

@@ -0,0 +1,112 @@
+/** Office 365: cada regional tiene su tenant, pero el login es siempre en este host. */
+const MICROSOFT_SSO = { provider: "microsoft", host: "login.microsoftonline.com" };
+/**
+ * El soporte de las que no son `verified` sale de `tool_mobile_get_public_config`, que Moodle contesta
+ * sin login (octubre de 2026). Falta Villa María (FRVM): no encontramos su aula.
+ */
+const REGIONALS = [
+    { id: "fra", name: "Avellaneda (FRA)", baseUrl: "https://www.utnfravirtual.org.ar", support: "candidate" },
+    { id: "frbb", name: "Bahía Blanca (FRBB)", baseUrl: "https://aulavirtual.frbb.utn.edu.ar", support: "candidate" },
+    {
+        id: "frba",
+        name: "Buenos Aires (FRBA)",
+        baseUrl: "https://aulasvirtuales.frba.utn.edu.ar",
+        sso: { provider: "keycloak", host: "auth.frba.utn.edu.ar" },
+        support: "verified",
+    },
+    { id: "frch", name: "Chubut (FRCh)", baseUrl: "https://frch.cvg.utn.edu.ar", support: "candidate" },
+    { id: "frcu", name: "Concepción del Uruguay (FRCU)", baseUrl: "https://virtual.frcu.utn.edu.ar", support: "candidate" },
+    { id: "frcon", name: "Concordia (FRCon)", baseUrl: "https://frcon.cvg.utn.edu.ar", support: "candidate" },
+    { id: "frc", name: "Córdoba (FRC)", baseUrl: "https://uv.frc.utn.edu.ar", support: "verified" },
+    { id: "frd", name: "Delta (FRD)", baseUrl: "https://frd.cvg.utn.edu.ar", support: "candidate" },
+    { id: "frgp", name: "General Pacheco (FRGP)", baseUrl: "https://frgp.cvg.utn.edu.ar", support: "candidate" },
+    { id: "frh", name: "Haedo (FRH)", baseUrl: "https://frh.cvg.utn.edu.ar", sso: MICROSOFT_SSO, support: "candidate" },
+    { id: "frlp", name: "La Plata (FRLP)", baseUrl: "https://frlp.cvg.utn.edu.ar", support: "candidate" },
+    { id: "frlr", name: "La Rioja (FRLR)", baseUrl: "https://frlr.cvg.utn.edu.ar", support: "candidate" },
+    // Tiene también frmdp.cvg.utn.edu.ar, pero ese entra con Office 365 y no tiene el mobile web service
+    // habilitado, así que no puede emitir token aunque se resuelva el login.
+    { id: "frmdp", name: "Mar del Plata (FRMDP)", baseUrl: "https://campus.mdp.utn.edu.ar", support: "candidate" },
+    // Sin el servicio habilitado.
+    { id: "frm", name: "Mendoza (FRM)", baseUrl: "https://campusvirtual.frm.utn.edu.ar", support: "unsupported" },
+    { id: "frn", name: "Neuquén (FRN)", baseUrl: "https://frn.cvg.utn.edu.ar", support: "candidate" },
+    { id: "frp", name: "Paraná (FRP)", baseUrl: "https://frp.cvg.utn.edu.ar", support: "candidate" },
+    { id: "frra", name: "Rafaela (FRRa)", baseUrl: "https://frra.cvg.utn.edu.ar", support: "candidate" },
+    { id: "frrq", name: "Reconquista (FRRq)", baseUrl: "https://frrq.cvg.utn.edu.ar", support: "candidate" },
+    { id: "frre", name: "Resistencia (FRRE)", baseUrl: "https://frre.cvg.utn.edu.ar", support: "verified" },
+    { id: "frro", name: "Rosario (FRRo)", baseUrl: "https://frro.cvg.utn.edu.ar", support: "candidate" },
+    { id: "frsfco", name: "San Francisco (FRSFco)", baseUrl: "https://frsfco.cvg.utn.edu.ar", support: "candidate" },
+    { id: "frsn", name: "San Nicolás (FRSN)", baseUrl: "https://frsn.cvg.utn.edu.ar", sso: MICROSOFT_SSO, support: "candidate" },
+    { id: "frsr", name: "San Rafael (FRSR)", baseUrl: "https://campus.frsr.utn.edu.ar/moodle", support: "candidate" },
+    { id: "frsc", name: "Santa Cruz (FRSC)", baseUrl: "https://frsc.cvg.utn.edu.ar", support: "candidate" },
+    { id: "frsf", name: "Santa Fe (FRSF)", baseUrl: "https://campusvirtual.frsf.utn.edu.ar", support: "candidate" },
+    // Sin el servicio habilitado.
+    { id: "frtdf", name: "Tierra del Fuego (FRTDF)", baseUrl: "https://cvg.frtdf.utn.edu.ar", support: "unsupported" },
+    { id: "frtl", name: "Trenque Lauquen (FRTL)", baseUrl: "https://frtl.cvg.utn.edu.ar", support: "candidate" },
+    { id: "frt", name: "Tucumán (FRT)", baseUrl: "https://frt.cvg.utn.edu.ar", support: "verified" },
+    // No es una regional sino el aula de la Tecnicatura en Programación a distancia del SIED.
+    { id: "tup", name: "Tecnicatura en Programación (SIED)", baseUrl: "https://tup.sied.utn.edu.ar", support: "verified" },
+    // Sin el servicio habilitado.
+    { id: "frvt", name: "Venado Tuerto (FRVT)", baseUrl: "https://frvt.cvg.utn.edu.ar", support: "unsupported" },
+];
+const DEFAULT_REGIONAL = "frba";
+/** `UTN_REGIONAL` no está en el registro: sin cortar acá, las credenciales irían al SSO de FRBA. */
+export class UnknownRegionalError extends Error {
+    name = "UnknownRegionalError";
+    constructor(regional) {
+        super(`"${regional}" no es una regional conocida. Las válidas son: ${availableRegionals().map((r) => r.id).join(", ")}. ` +
+            "Si tu campus no está en la lista, borrá UTN_REGIONAL y definí UTN_AULA_BASE_URL con la URL del aula " +
+            "(y UTN_SSO_HOST si entra por SSO: el host del Keycloak, o login.microsoftonline.com si es Office 365).");
+    }
+}
+/** Su aula no tiene el servicio habilitado o entra por un SSO que no sabemos usar: ni se intenta entrar. */
+export class UnsupportedRegionalError extends Error {
+    regional;
+    name = "UnsupportedRegionalError";
+    constructor(regional) {
+        super(`Todavía no hay soporte para ${regional.name}: su aula no tiene habilitado el servicio que usa ` +
+            "UTN-MCP o entra por un login que todavía no sabemos usar.");
+        this.regional = regional;
+    }
+}
+/** El aula de UTN_AULA_BASE_URL, para un campus que no está en el registro. */
+function customRegional() {
+    const raw = process.env.UTN_AULA_BASE_URL?.trim();
+    if (!raw)
+        return undefined;
+    const baseUrl = raw.replace(/\/+$/, "");
+    const host = new URL(baseUrl).host;
+    const ssoHost = process.env.UTN_SSO_HOST?.trim();
+    const sso = !ssoHost
+        ? undefined
+        : ssoHost === MICROSOFT_SSO.host
+            ? MICROSOFT_SSO
+            : { provider: "keycloak", host: ssoHost };
+    return { id: host, name: host, baseUrl, sso, support: "verified" };
+}
+/**
+ * Las que se pueden elegir al iniciar sesión: el catálogo y, si está definida, la de UTN_AULA_BASE_URL.
+ * `verifiedIds` son las `candidate` que ya se verificaron en el servidor (las guarda el store).
+ */
+export function availableRegionals(verifiedIds = []) {
+    const verified = new Set(verifiedIds);
+    const custom = customRegional();
+    return [...REGIONALS, ...(custom ? [custom] : [])].map((r) => r.support === "candidate" && verified.has(r.id) ? { ...r, support: "verified" } : r);
+}
+/** La regional con ese id; si no está entre las disponibles, `UnknownRegionalError`. */
+export function findRegional(id) {
+    const wanted = id.trim().toLowerCase();
+    const found = availableRegionals().find((r) => r.id === wanted);
+    if (!found)
+        throw new UnknownRegionalError(id);
+    return found;
+}
+/**
+ * La que viene elegida si nadie dice otra: la de UTN_REGIONAL; si no, la de UTN_AULA_BASE_URL; si no,
+ * FRBA. Es la de quien usa UTN_USER/UTN_PASS sin `utn-mcp login`, y la opción por defecto al elegir.
+ */
+export function defaultRegional() {
+    const fromEnv = process.env.UTN_REGIONAL?.trim();
+    if (fromEnv)
+        return findRegional(fromEnv);
+    return customRegional() ?? findRegional(DEFAULT_REGIONAL);
+}

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

@@ -1,5 +1,7 @@
 import { randomInt } from "node:crypto";
-import { AULA_BASE_URL, SSO_HOST } from "./constants.js";
+import { CookieJar } from "tough-cookie";
+import { UnsupportedRegionalError } from "./regionals.js";
+import { MoodleError } from "./moodle-api.js";
 export class LoginRequiredError extends Error {
     constructor(message = "Hace falta iniciar sesión: corré `utn-mcp login`.") {
         super(message);
@@ -7,56 +9,286 @@ export class LoginRequiredError extends Error {
     }
 }
 export class InvalidCredentialsError extends Error {
-    constructor() {
-        super("El SSO rechazó usuario o contraseña. Corré `utn-mcp login` para actualizarlos.");
+    constructor(reason) {
+        const base = "El aula rechazó usuario o contraseña. Corré `utn-mcp login` para actualizarlos.";
+        super(reason ? `${base} Motivo del aula: ${reason}` : base);
         this.name = "InvalidCredentialsError";
     }
 }
 const MAX_REDIRECTS = 20;
 const TIMEOUT_MS = 30_000;
+const PROVIDERS = {
+    keycloak: {
+        link: /href="([^"]*\/auth\/oauth2\/login\.php[^"]*)"/,
+        submit: submitKeycloakForm,
+        loginError: extractLoginError,
+    },
+    microsoft: {
+        link: /href="([^"]*\/auth\/oidc\/[^"]*)"/,
+        submit: submitMicrosoftForm,
+        loginError: microsoftLoginError,
+    },
+};
 /**
- * Obtiene un token del web service siguiendo el flujo de launch.php por HTTP:
- * launch.php → login de Moodle → SSO (Keycloak) → Moodle → launch.php → moodlemobile://token=BASE64.
- * Las cookies del SSO quedan en `jar`: mientras sigan vivas no hace falta la contraseña.
+ * Obtiene un token del web service. Dos estrategias según la regional:
+ * - Regionales con SSO (Keycloak como FRBA, Office 365 como FRH): flujo de launch.php, que usa la
+ *   sesión del SSO. Si el SSO rechaza las credenciales, `login/token.php`: hay usuarios sin cuenta en
+ *   el SSO.
+ * - Regionales con login directo de Moodle (ej. FRT): primero `login/token.php` (no depende del
+ *   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.
  */
-export async function fetchToken(jar, credentials) {
-    const launchUrl = `${AULA_BASE_URL}/admin/tool/mobile/launch.php` +
+export async function fetchToken(regional, credentials) {
+    if (regional.support === "unsupported")
+        throw new UnsupportedRegionalError(regional);
+    const { baseUrl, sso } = regional;
+    const jar = new CookieJar();
+    // Regionales con login directo: intentamos token.php primero (no depende de launch.php).
+    if (!sso) {
+        const viaTokenPhp = await tryTokenPhp(baseUrl, credentials);
+        if (viaTokenPhp)
+            return viaTokenPhp;
+    }
+    const launchUrl = `${baseUrl}/admin/tool/mobile/launch.php` +
         `?service=moodle_mobile_app&passport=${randomInt(1e9)}&urlscheme=moodlemobile`;
-    // 1. Con sesión de Moodle viva, launch.php redirige directo al token.
     let landing = await follow(jar, launchUrl);
     if ("token" in landing)
         return landing.token;
-    // 2. Login de Moodle: el botón "Usuarios Institucionales" lleva al SSO.
-    const oauthUrl = landing.html.match(/href="([^"]*\/auth\/oauth2\/login\.php[^"]*)"/)?.[1];
-    if (!oauthUrl)
-        throw unexpected(landing.url);
-    landing = await follow(jar, decodeHtml(oauthUrl));
-    if ("token" in landing)
-        return landing.token;
-    // 3. Si el SSO no nos recuerda, muestra su formulario: lo completamos.
-    if (new URL(landing.url).host === SSO_HOST) {
-        if (!credentials)
-            throw new LoginRequiredError();
-        landing = await submitSsoForm(jar, landing.html, credentials);
+    const provider = sso && PROVIDERS[sso.provider];
+    const ssoHref = provider && landing.html.match(provider.link)?.[1];
+    if (sso && provider && 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);
+            if ("token" in landing)
+                return landing.token;
+            if (new URL(landing.url).host === sso.host) {
+                // Aspirantes del ingreso y algunas tecnicaturas no tienen cuenta en el SSO: entran con el login de Moodle.
+                const viaTokenPhp = await tryTokenPhp(baseUrl, credentials);
+                if (viaTokenPhp)
+                    return viaTokenPhp;
+                throw new InvalidCredentialsError(provider.loginError(landing.html));
+            }
+        }
+    }
+    else {
+        const loginPageUrl = `${baseUrl}/login/index.php`;
+        const loginPage = await follow(jar, loginPageUrl);
+        if ("token" in loginPage)
+            return loginPage.token;
+        landing = await submitMoodleLoginForm(jar, loginPage.url, loginPage.html, credentials);
         if ("token" in landing)
             return landing.token;
-        if (new URL(landing.url).host === SSO_HOST)
-            throw new InvalidCredentialsError();
+        const stillOnLogin = landing.url.includes("/login") ||
+            /alert-danger/i.test(landing.html) ||
+            /loginerrors/i.test(landing.html);
+        if (stillOnLogin) {
+            const reason = extractLoginError(landing.html);
+            throw new InvalidCredentialsError(reason);
+        }
     }
-    // 4. Ya con sesión de Moodle (el SSO nos deja en el dashboard), pedimos el token de nuevo.
     landing = await follow(jar, launchUrl);
     if ("token" in landing)
         return landing.token;
+    if (!sso) {
+        const viaTokenPhp = await tryTokenPhp(baseUrl, credentials);
+        if (viaTokenPhp)
+            return viaTokenPhp;
+    }
     throw unexpected(landing.url);
 }
-async function submitSsoForm(jar, html, { username, password }) {
-    // La página de Keycloak trae su config como JSON (kcContext); de ahí sale la URL del form.
+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}` : ""));
+        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;
+/**
+ * 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).
+ */
+async function submitMicrosoftForm(jar, page, { username, password }) {
+    const ssoHost = new URL(page.url).host;
+    const cfg = parseAadConfig(page.html);
+    if (!cfg?.urlPost || !cfg.sFT) {
+        throw new Error("No se encontró el formulario de Microsoft; puede que haya cambiado o que el login sea federado.");
+    }
+    let landing = await follow(jar, new URL(cfg.urlPost, page.url).toString(), {
+        method: "POST",
+        body: new URLSearchParams({
+            login: username,
+            loginfmt: username,
+            passwd: password,
+            type: "11",
+            LoginOptions: "3",
+            flowToken: cfg.sFT,
+            ctx: cfg.sCtx ?? "",
+            canary: cfg.canary ?? "",
+            i13: "0",
+            ps: "2",
+        }),
+    });
+    for (let i = 0; i < MAX_MICROSOFT_STEPS; i++) {
+        if ("token" in landing)
+            return landing;
+        const form = findPostForm(landing.html);
+        const action = form && new URL(form.action, landing.url).toString();
+        if (form && action && new URL(action).host !== ssoHost) {
+            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?.sErrorCode)
+            return landing;
+        if (step?.urlPost) {
+            landing = await follow(jar, new URL(step.urlPost, landing.url).toString(), {
+                method: "POST",
+                body: new URLSearchParams({
+                    LoginOptions: "1",
+                    type: "28",
+                    ctx: step.sCtx ?? "",
+                    flowToken: step.sFT ?? "",
+                    canary: step.canary ?? "",
+                }),
+            });
+            continue;
+        }
+        if (form && action) {
+            landing = await follow(jar, action, { method: "POST", body: new URLSearchParams(form.inputs) });
+            continue;
+        }
+        throw unexpected(landing.url);
+    }
+    throw new Error("Demasiados pasos en el login de Microsoft.");
+}
+/** El motivo del rechazo en una página de Microsoft (ej. AADSTS50126: usuario o contraseña incorrectos). */
+function microsoftLoginError(html) {
+    const cfg = parseAadConfig(html);
+    if (!cfg?.sErrorCode)
+        return undefined;
+    return cfg.strServiceExceptionMessage || `AADSTS${cfg.sErrorCode}`;
+}
+/**
+ * Extrae el objeto `$Config={...}` que Microsoft embebe en sus páginas de login, recorriendo las
+ * llaves a mano (el objeto es grande y una regex no lo acota bien). Devuelve null si no está.
+ */
+function parseAadConfig(html) {
+    const at = html.indexOf("$Config=");
+    if (at < 0)
+        return null;
+    const start = html.indexOf("{", at);
+    if (start < 0)
+        return null;
+    let depth = 0;
+    let inStr = false;
+    let esc = false;
+    for (let i = start; i < html.length; i++) {
+        const c = html[i];
+        if (inStr) {
+            if (esc)
+                esc = false;
+            else if (c === "\\")
+                esc = true;
+            else if (c === '"')
+                inStr = false;
+        }
+        else if (c === '"')
+            inStr = true;
+        else if (c === "{")
+            depth++;
+        else if (c === "}" && --depth === 0) {
+            try {
+                return JSON.parse(html.slice(start, i + 1));
+            }
+            catch {
+                return null;
+            }
+        }
+    }
+    return null;
+}
+/** El primer `<form method="post">` de la página: su `action` y sus inputs ocultos. */
+function findPostForm(html) {
+    const m = html.match(/<form\b[^>]*>([\s\S]*?)<\/form>/i);
+    if (!m || !/method\s*=\s*["']?post/i.test(m[0]))
+        return null;
+    const action = m[0].match(/action\s*=\s*["']([^"']*)["']/i)?.[1];
+    if (!action)
+        return null;
+    const inputs = {};
+    for (const input of m[1].matchAll(/<input\b[^>]*>/gi)) {
+        const name = input[0].match(/name\s*=\s*["']([^"']*)["']/i)?.[1];
+        if (name)
+            inputs[name] = decodeHtml(input[0].match(/value\s*=\s*["']([^"']*)["']/i)?.[1] ?? "");
+    }
+    return { action: decodeHtml(action), inputs };
+}
+/**
+ * Pide el token a /login/token.php (Moodle estándar). Devuelve null si el aula no lo expone
+ * (no contesta JSON), para seguir con launch.php; si contesta con un error, lo propaga.
+ */
+async function tryTokenPhp(baseUrl, credentials) {
+    const res = await fetch(`${baseUrl}/login/token.php`, {
+        method: "POST",
+        headers: { "content-type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+            username: credentials.username,
+            password: credentials.password,
+            service: "moodle_mobile_app",
+        }),
+        signal: AbortSignal.timeout(TIMEOUT_MS),
+    });
+    let data;
+    try {
+        data = await res.json();
+    }
+    catch {
+        return null;
+    }
+    if (data.token)
+        return data.token;
+    if (data.errorcode === "invalidlogin" || /invalid login/i.test(data.error ?? "")) {
+        throw new InvalidCredentialsError(data.error);
+    }
+    // Hay aulas (ej. la TUP) a las que se les rompe un plugin de autenticación con cada login
+    // rechazado: contestan `generalexceptionmessage`, y el formulario web muestra la misma excepción.
+    if (data.errorcode === "generalexceptionmessage") {
+        throw new InvalidCredentialsError(`${data.error} (es un error interno del aula, que en algunas aparece cuando el usuario o la contraseña están mal)`);
+    }
+    // El mismo servicio lo usa launch.php: si token.php lo rechaza, seguir no sirve.
+    throw new MoodleError(`El aula no dio el token (${data.errorcode ?? res.status}): ${data.error ?? "respuesta sin token"}. ` +
+        "Si dice que el servicio web no está disponible, lo tiene que habilitar el admin del aula.", data.errorcode);
+}
+/** Formulario de Keycloak: el `action` viene en el `loginAction` del JSON que arma la página. */
+async function submitKeycloakForm(jar, { html }, { username, password }) {
     const action = html.match(/"loginAction"\s*:\s*("(?:[^"\\]|\\.)*")/)?.[1];
     if (!action)
-        throw new Error("No se encontró el formulario del SSO; puede que haya cambiado.");
+        throw new Error("No se encontró el formulario de Keycloak; puede que haya cambiado.");
     const body = new URLSearchParams({ username, password, rememberMe: "on", credentialId: "" });
     return follow(jar, JSON.parse(action), { method: "POST", body });
 }
+/** Login directo de Moodle (sin SSO): manda usuario y contraseña al formulario de /login/index.php. */
+async function submitMoodleLoginForm(jar, pageUrl, html, { username, password }) {
+    const tokenMatch = html.match(/name="logintoken"\s+value="([^"]*)"/) ||
+        html.match(/value="([^"]*)"\s+name="logintoken"/);
+    const logintoken = tokenMatch?.[1] ?? "";
+    const actionMatch = html.match(/<form[^>]*action="([^"]*)"[^>]*>/i);
+    let action = actionMatch?.[1] ? decodeHtml(actionMatch[1]) : "";
+    if (!action)
+        action = pageUrl;
+    if (!action.startsWith("http"))
+        action = new URL(action, pageUrl).toString();
+    const body = new URLSearchParams({ username, password, logintoken, anchor: "" });
+    return follow(jar, action, { method: "POST", body });
+}
 /** Hace la request y sigue redirecciones a mano, guardando cookies en cada salto. */
 async function follow(jar, url, init) {
     for (let i = 0; i < MAX_REDIRECTS; i++) {
@@ -92,6 +324,24 @@ export function decodeLaunchToken(url) {
     return parts[1];
 }
 const decodeHtml = (s) => s.replaceAll("&amp;", "&");
+/** Extrae el mensaje de error que muestra Moodle/Keycloak en la página de login. */
+function extractLoginError(html) {
+    const patterns = [
+        /alert-danger[^>]*>([\s\S]*?)<\/div>/i,
+        /alert-error[^>]*>([\s\S]*?)<\/div>/i,
+        /class="[^"]*error[^"]*"[^>]*>([\s\S]*?)<\/div>/i,
+        /<div[^>]*id="loginerrormessage"[^>]*>([\s\S]*?)<\/div>/i,
+    ];
+    for (const re of patterns) {
+        const m = html.match(re);
+        if (m?.[1]) {
+            const text = m[1].replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+            if (text)
+                return text;
+        }
+    }
+    return undefined;
+}
 const unexpected = (url) => {
     const { host, pathname } = new URL(url);
     return new Error(`Flujo de login inesperado: terminó en ${host}${pathname}`);

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

@@ -1,24 +1,34 @@
-import { CookieJar } from "tough-cookie";
 import { loadCredentials } from "./credentials.js";
+import { defaultRegional, findRegional } from "./regionals.js";
 import { fetchToken, LoginRequiredError } from "./sso-login.js";
 /** Con qué nombre guarda el aula su sesión en el store. */
 export const AULA_PLATFORM = "aula";
 /**
- * Sesión del modo HTTP: la de un usuario del store. Renueva el token con las cookies del SSO y, si
- * ya no alcanzan, con la contraseña del keychain cuando es de este mismo usuario: eso pasa solo en
- * local, porque el servidor hosteado no guarda contraseñas.
+ * Sesión del modo HTTP: la de un usuario del store, en el aula de su regional. Renueva el token con la
+ * contraseña del keychain cuando es de este mismo usuario: eso pasa solo en local, porque el servidor
+ * hosteado no guarda contraseñas. Si no, el usuario vuelve a iniciar sesión.
  */
 export class StoredAulaSession {
     store;
     userId;
     loginUrl;
     refreshing = null;
+    regional = null;
     /** `loginUrl` es la página donde el usuario vuelve a iniciar sesión, si el servidor tiene una. */
     constructor(store, userId, loginUrl) {
         this.store = store;
         this.userId = userId;
         this.loginUrl = loginUrl;
     }
+    /** La del usuario en el store; no cambia mientras dura la sesión, así que se lee una sola vez. */
+    getRegional() {
+        this.regional ??= this.store.findUser(this.userId).then((user) => {
+            if (!user)
+                throw this.loginRequired("No hay usuario para esta sesión.");
+            return findRegional(user.regional);
+        });
+        return this.regional;
+    }
     async getToken() {
         return (await this.read()).token;
     }
@@ -29,23 +39,17 @@ export class StoredAulaSession {
         return this.refreshing;
     }
     async renew() {
-        const stored = await this.read();
-        const jar = await CookieJar.deserialize(stored.cookies);
-        // Las del keychain (o UTN_USER/UTN_PASS) son de una sola persona: con otro usuario
-        // entraríamos al aula de ella y guardaríamos su token en la sesión de este.
+        const [stored, regional] = await Promise.all([this.read(), this.getRegional()]);
+        // Las del keychain (o UTN_USER/UTN_PASS) son de una sola persona: con otro usuario (o el mismo
+        // nombre en otra regional) entraríamos al aula de ella y guardaríamos su token en la sesión de este.
         const credentials = await loadCredentials();
-        const own = credentials?.username.trim().toLowerCase() === stored.username ? credentials : null;
-        let token;
-        try {
-            token = await fetchToken(jar, own);
-        }
-        catch (e) {
-            if (e instanceof LoginRequiredError) {
-                throw this.loginRequired("La sesión del aula venció.");
-            }
-            throw e;
-        }
-        const data = { ...stored, token, cookies: await jar.serialize() };
+        const sameUser = credentials?.username.trim().toLowerCase() === stored.username &&
+            (credentials.regional ?? defaultRegional().id) === regional.id;
+        if (!credentials || !sameUser)
+            throw this.loginRequired("La sesión del aula venció.");
+        const token = await fetchToken(regional, credentials);
+        // 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));
         return token;
     }

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

@@ -1,6 +1,5 @@
 import { textToHtml } from "../../shared/html.js";
 import { addDiscussion, addDiscussionPost, createUserEvent, deleteChoiceResponses, deleteChoicegroupResponses, deletePost, getChoiceOptions, getChoicegroupOptions, getDiscussionPosts, getMemberName, sendInstantMessage, submitChoiceResponse, submitChoicegroupResponse, updateDiscussionPost, } from "../client/client.js";
-import { AULA_BASE_URL } from "../client/constants.js";
 import { toOption } from "./activities.js";
 import { discussionAddr, formatAddress, parseAddress } from "./address.js";
 import { isoDate } from "./fields.js";
@@ -154,6 +153,6 @@ export async function addCalendarEvent(session, event) {
         inicio: isoDate(timestart),
         fin: timeduration ? isoDate(timestart + timeduration) : undefined,
         // Para que el usuario lo vea en el calendario del aula.
-        url: `${AULA_BASE_URL}/calendar/view.php?view=day&time=${timestart}`,
+        url: `${(await session.getRegional()).baseUrl}/calendar/view.php?view=day&time=${timestart}`,
     };
 }

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

@@ -1,7 +1,5 @@
 import { openDocument, UnsupportedFormat } from "../../shared/documents/index.js";
-import { AULA_BASE_URL } from "../client/constants.js";
 import { fetchFile } from "../client/moodle-api.js";
-const ORIGIN = new URL(AULA_BASE_URL).origin;
 const WS_PATH = "/webservice/pluginfile.php/";
 const WEB_PATH = "/pluginfile.php/";
 /** Cuánto se devuelve por llamada, en caracteres de texto. */
@@ -13,16 +11,28 @@ 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.
+ * sale nunca del servidor. `fileurl` viene de Moodle: ya es del aula del usuario.
  */
 export function userFacingUrl(fileurl) {
-    return fileurl.replace(`${ORIGIN}${WS_PATH}`, `${ORIGIN}${WEB_PATH}`);
+    let u;
+    try {
+        u = new URL(fileurl);
+    }
+    catch {
+        return fileurl;
+    }
+    // Hay aulas en una subruta (`/moodle`): el tramo a cambiar puede no estar al principio.
+    const at = u.pathname.indexOf(WS_PATH);
+    if (at < 0)
+        return fileurl;
+    u.pathname = u.pathname.slice(0, at) + WEB_PATH + u.pathname.slice(at + WS_PATH.length);
+    return u.href;
 }
 /**
- * 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.
+ * 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(url) {
+function downloadUrl(baseUrl, url) {
     let u;
     try {
         u = new URL(url);
@@ -30,10 +40,18 @@ function downloadUrl(url) {
     catch {
         throw new Error(`URL inválida: "${url}". Usá la \`url\` de un archivo tal como la devuelve aula_open.`);
     }
-    const path = u.pathname.startsWith(WS_PATH) ? u.pathname : u.pathname.startsWith(WEB_PATH) ? WS_PATH + u.pathname.slice(WEB_PATH.length) : null;
-    if (u.origin !== ORIGIN || !path) {
-        throw new Error(`Solo se pueden leer archivos del aula virtual (${ORIGIN}${WEB_PATH}...).`);
+    const root = new URL(baseUrl);
+    const prefix = root.pathname.replace(/\/+$/, "");
+    const rest = u.pathname.startsWith(prefix + WS_PATH)
+        ? u.pathname.slice(prefix.length + WS_PATH.length)
+        : u.pathname.startsWith(prefix + WEB_PATH)
+            ? u.pathname.slice(prefix.length + WEB_PATH.length)
+            : null;
+    // `origin` ignora `usuario@`: con eso `fetch` rechaza la URL y su error, con el token ya puesto, llega al modelo.
+    if (u.origin !== root.origin || u.username || u.password || rest === null) {
+        throw new Error(`Solo se pueden leer archivos del aula virtual (${root.origin}${prefix}${WEB_PATH}...).`);
     }
+    const path = prefix + WS_PATH + rest;
     u.pathname = path;
     u.searchParams.delete("token");
     u.searchParams.delete("wstoken");
@@ -41,7 +59,8 @@ function downloadUrl(url) {
 }
 /** Baja un archivo del aula y devuelve desde la parte `from` tantas como entren en el presupuesto. */
 export async function readAulaFile(session, url, from = 1) {
-    const download = downloadUrl(url);
+    const { baseUrl } = await session.getRegional();
+    const download = downloadUrl(baseUrl, url);
     const fileName = decodeURIComponent(download.pathname.split("/").pop() ?? "");
     const forUser = userFacingUrl(download.href);
     const { bytes } = await fetchFile(session, download, MAX_BYTES);