utn-mcp 0.7.0 → 0.8.0

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

@@ -0,0 +1,103 @@
+/**
+ * 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",
+        ssoHost: "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" },
+    // Office 365.
+    { id: "frh", name: "Haedo (FRH)", baseUrl: "https://frh.cvg.utn.edu.ar", support: "unsupported" },
+    { 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 no tiene el servicio habilitado y entra con Office 365.
+    { 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" },
+    // Office 365.
+    { id: "frsn", name: "San Nicolás (FRSN)", baseUrl: "https://frsn.cvg.utn.edu.ar", support: "unsupported" },
+    { 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" },
+    // 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 usa Keycloak).");
+    }
+}
+/** 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;
+    return { id: host, name: host, baseUrl, ssoHost: process.env.UTN_SSO_HOST?.trim() || undefined, 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,135 @@ 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;
 /**
- * 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, ej. FRBA): 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, ssoHost } = regional;
+    const jar = new CookieJar();
+    // Regionales con login directo: intentamos token.php primero (no depende de launch.php).
+    if (!ssoHost) {
+        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);
+    if (oauthUrl) {
+        landing = await follow(jar, decodeHtml(oauthUrl));
+        if ("token" in landing)
+            return landing.token;
+        if (ssoHost && new URL(landing.url).host === ssoHost) {
+            landing = await submitSsoForm(jar, landing.html, credentials);
+            if ("token" in landing)
+                return landing.token;
+            if (ssoHost && new URL(landing.url).host === ssoHost) {
+                // 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(extractLoginError(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 (!ssoHost) {
+        const viaTokenPhp = await tryTokenPhp(baseUrl, credentials);
+        if (viaTokenPhp)
+            return viaTokenPhp;
+    }
     throw unexpected(landing.url);
 }
+/**
+ * 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);
+    }
+    // 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);
+}
 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.
     const action = html.match(/"loginAction"\s*:\s*("(?:[^"\\]|\\.)*")/)?.[1];
     if (!action)
         throw new Error("No se encontró el formulario del SSO; 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 +173,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);

package/build/aula-virtual/login.js

@@ -1,31 +1,33 @@
-import { ask, askHidden } from "../shared/input.js";
+import { ask, askChoice, askHidden } from "../shared/input.js";
 import { logger } from "../shared/logger.js";
 import { SqliteStore } from "../shared/store/sqlite-store.js";
 import { saveCredentials } from "./client/credentials.js";
 import { linkAulaAccount } from "./client/link.js";
 import { LocalSession } from "./client/local-session.js";
+import { availableRegionals, defaultRegional } from "./client/regionals.js";
 /**
- * `utn-mcp login`: pide usuario y contraseña una vez, los guarda en el keychain
+ * `utn-mcp login`: pide la regional, usuario y contraseña una vez, los guarda en el keychain
  * y obtiene el primer token. Después el servidor renueva solo.
  * Con `--http` guarda la sesión en el store y emite el token para el cliente MCP.
  */
 export async function runLogin(http) {
-    const username = (await ask("Usuario institucional de la UTN: ")).trim();
+    const regional = await askRegional();
+    const username = (await ask("Usuario de la UTN: ")).trim();
     if (!username)
         throw new Error("Falta el usuario.");
     const password = await askHidden("Contraseña: ");
-    const credentials = { username, password };
+    const credentials = { username, password, regional: regional.id };
     let accessToken = null;
     if (http)
-        accessToken = await loginToStore(credentials);
+        accessToken = await loginToStore(regional, credentials);
     else
-        await new LocalSession().login(credentials);
-    // Se guardan recién después de comprobar que el SSO las aceptó.
+        await new LocalSession().login(regional, credentials);
+    // 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.");
     }
     else {
-        logger.warn("No hay keychain disponible: para renovar sin intervención definí UTN_USER y UTN_PASS.");
+        logger.warn("No hay keychain disponible: para renovar sin intervención definí UTN_USER, UTN_PASS y UTN_REGIONAL.");
     }
     if (accessToken) {
         logger.info("Listo. Configurá tu cliente MCP con este header; no se vuelve a mostrar:\n\n" +
@@ -35,9 +37,21 @@ export async function runLogin(http) {
         logger.info("Listo: ya podés usar el servidor MCP.");
     }
 }
+const SUPPORT_LABEL = {
+    verified: "",
+    candidate: " · sin probar todavía",
+    unsupported: " · todavía sin soporte",
+};
+/** Arranca marcada la de UTN_REGIONAL (o FRBA). */
+async function askRegional() {
+    const regionals = availableRegionals();
+    const initial = regionals.findIndex((r) => r.id === defaultRegional().id);
+    const labels = regionals.map((r) => r.name + SUPPORT_LABEL[r.support]);
+    return regionals[await askChoice("Regional:", labels, Math.max(initial, 0))];
+}
 /** Crea el usuario si no existe, guarda su sesión del aula y le emite un token que no vence. */
-async function loginToStore(credentials) {
+async function loginToStore(regional, credentials) {
     const store = await SqliteStore.open();
-    const { userId } = await linkAulaAccount(store, credentials);
+    const { userId } = await linkAulaAccount(store, regional, credentials);
     return store.issueToken(userId, { kind: "access", clientId: "local" });
 }

package/build/aula-virtual/tools.js

@@ -17,12 +17,16 @@ const failure = (e) => ({
 const READ_ONLY = { readOnlyHint: true, openWorldHint: false };
 export function registerAulaVirtualTools(server, session, files) {
     server.registerTool("aula_get_site_info", {
-        description: "Datos del usuario logueado en el aula virtual de la UTN FRBA y del sitio Moodle.",
+        description: "Datos del usuario logueado y del sitio Moodle de su aula virtual. `regional` es la regional de la UTN " +
+            "de esa aula (por ejemplo, \"Tucumán (FRT)\"): usala para hablarle de su facultad.",
         annotations: READ_ONLY,
     }, async () => {
         try {
-            const { sitename, fullname, username, userid, release } = await getSiteInfo(session);
-            return json({ sitename, fullname, username, userid, release });
+            const [{ sitename, fullname, username, userid, release }, regional] = await Promise.all([
+                getSiteInfo(session),
+                session.getRegional(),
+            ]);
+            return json({ regional: regional.name, sitename, fullname, username, userid, release });
         }
         catch (e) {
             return failure(e);
@@ -271,7 +275,8 @@ export function registerAulaVirtualTools(server, session, files) {
                 '`-F "archivos=@..."` por archivo, todos en el mismo comando. Responde JSON con lo recibido.\n' +
                 "- Si no, pasale el `url` al usuario: se abre en el navegador, también en el celu, y elige " +
                 "los archivos ahí. Esperá a que te diga que los subió.\n\n" +
-                "Subir al link no entrega nada; una subida nueva al mismo link reemplaza la anterior. " +
+                "Subir al link no entrega nada. Cada link acepta una sola subida: si hay que cambiar los " +
+                "archivos, pedí otro link. " +
                 "`acepta` trae los límites de la tarea.",
             inputSchema: z.object({
                 direccion: z
@@ -299,7 +304,8 @@ export function registerAulaVirtualTools(server, session, files) {
                 'Ej: ["C:\\Users\\ana\\Documents\\TP3.pdf"].'
             : "Lista final de los archivos que ya están en la entrega, por su `url` de aula_open; los " +
                 "de `subida` se suman. Lista vacía: quita los que estaban. " +
-                'Ej: ["https://aulasvirtuales.frba.utn.edu.ar/pluginfile.php/123/assignsubmission_file/submission_files/456/TP3.pdf"].'),
+                'Ej: ["https://<aula>/pluginfile.php/123/assignsubmission_file/submission_files/456/TP3.pdf"], ' +
+                "con el dominio del aula tal como viene en la `url`."),
         texto: z
             .string()
             .optional()