utn-mcp 0.6.9 → 0.8.0

package/README.md

@@ -1,5 +1,5 @@
 # UTN-MCP — El puente entre tu agente y los sistemas de la Universidad.
-Este es el Model Context Protocol server NO OFICIAL de la UTN. Con él podrás pedirle a tu agente de preferencia (ChatGPT, Claude, etc.) que busque informacion o archivos en el aula virtual.
+Este es el Model Context Protocol server NO OFICIAL de la UTN. Con él podés pedirle a tu agente de preferencia (Claude, ChatGPT, etc.) que busque información y lea los apuntes del aula virtual y, con tu confirmación, que publique en los foros o entregue tareas. Corre en tu computadora o como servidor HTTP con OAuth, para usarlo desde cualquier lado.
 
 ## Qué podés pedirle
 - *"¿Cuándo es el recuperatorio del primer parcial de Álgebra?"*
@@ -19,7 +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_get_site_info` | Datos de tu usuario en el aula virtual. |
+| `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. |
 | `aula_forum_delete_post` | Borra una publicación tuya. |
@@ -48,7 +48,7 @@ Necesitás [Node.js](https://nodejs.org) 20 o superior. No hace falta clonar el
 ```bash
 npx -y utn-mcp login
 ```
-Te pide tu usuario institucional y tu contraseña de la UTN (los mismos de "Usuarios Institucionales" en el aula virtual). Se hace una sola vez: después el servidor renueva la sesión solo.
+Te pide tu regional, tu usuario y tu contraseña: los mismos con los que entrás al aula virtual. Si no tenés usuario institucional (por ejemplo, en el curso de ingreso), usá el que te dieron para el aula. Se hace una sola vez: después el servidor renueva la sesión solo.
 
 ### 2. Agregarlo a tu cliente
 
@@ -107,7 +107,7 @@ mcp_servers:
 }
 ```
 
-**ChatGPT**: todavía no. ChatGPT sólo se conecta a servidores MCP remotos por HTTPS, y utn-mcp corre en tu computadora. Va a funcionar con la versión hosteada.
+**ChatGPT**: solo se conecta a servidores MCP remotos por HTTPS, así que necesita un servidor en modo HTTP publicado en internet (ver [Hostearlo para otros](#hostearlo-para-otros)). Se agrega como conector desde *Configuración → Apps y conectores*, con el modo desarrollador activado. Los conectores propios están desde el plan Pro, y ahí solo con las herramientas de lectura; para usar también las de escritura (foros, mensajes, entregas) hace falta Business o superior.
 
 **Otros clientes (Windsurf, opencode, etc.)**: cualquier cliente MCP que lance servidores por STDIO sirve con el comando `npx -y utn-mcp`.
 
@@ -119,6 +119,20 @@ 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), Resistencia (FRRE) y Tucumán (FRT) ya están probadas. El login se adapta solo: si el aula entra por SSO (Keycloak), como FRBA, usa el SSO; si no, el login directo de Moodle.
+
+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.
+
+Si tu campus no está en la lista, abrí un [issue](https://github.com/nialvape/utn-mcp/issues) con la URL de su aula virtual para sumarlo. Mientras tanto, podés usarlo definiendo en un `.env` en la carpeta desde donde corrés `utn-mcp` (o en el entorno):
+```bash
+UTN_AULA_BASE_URL=https://tu-campus.utn.edu.ar
+# UTN_SSO_HOST=auth.tu-campus.utn.edu.ar  # solo si usa Keycloak
+```
+Aparece como una opción más al iniciar sesión.
+
+`UTN_REGIONAL` (por ejemplo, `UTN_REGIONAL=frt`) elige la que viene marcada por defecto, y es la que se usa si en lugar de `login` definís `UTN_USER` y `UTN_PASS`.
+
 ### Modo HTTP (opcional)
 Necesita Node 22.13 o más nuevo. Primero, una vez:
 ```bash
@@ -130,16 +144,45 @@ npx -y utn-mcp --http --port 3000
 ```
 Levanta el servidor en `http://127.0.0.1:3000/mcp`, solo accesible desde tu propia máquina. Tenés que dejar la terminal abierta mientras lo uses.
 
-En este modo el servidor no lee archivos de tu disco: para entregar, el agente pide un link con `aula_assign_upload_link` y sube ahí los archivos con `curl` si tiene terminal, o te pasa el link para que los elijas desde el navegador. Si el servidor se publica detrás de otra dirección, definí `UTN_MCP_PUBLIC_URL` para que los links la usen.
+En este modo el servidor no lee archivos de tu disco: para entregar, el agente pide un link con `aula_assign_upload_link` y sube ahí los archivos con `curl` si tiene terminal, o te pasa el link para que los elijas desde el navegador.
+
+### Hostearlo para otros
+En modo HTTP el servidor también es servidor de autorización OAuth: un cliente MCP (Claude, ChatGPT) que se conecta a `https://tu-dominio/mcp` recibe un 401, descubre el OAuth y abre una página donde el alumno elige su regional y entra con su usuario de la UTN. Cada alumno usa el aula de su regional, aunque sean de regionales distintas. Ese login vincula su aula: la contraseña se usa una sola vez para sacar el token de Moodle y **no se guarda**. Cuando la sesión del aula vence, el agente le pasa el link de `/login` para renovarla, sin reconectar el cliente.
+
+Quién puede entrar lo decidís vos: con `UTN_MCP_ALLOWED_EMAILS` (una lista), o con `UTN_MCP_ACCESS_URL`, que apunta a un servicio tuyo. El servidor le hace `POST` con `{ "email", "usuario", "regional" }` y el header `Authorization: Bearer <UTN_MCP_ACCESS_SECRET>`, y espera `{ "permitido": true }` o `{ "permitido": false, "motivo": "...", "url": "..." }`. Se consulta al conectar y en cada renovación del token (cada hora), así que una baja se aplica sola.
+
+La configuración va en variables de entorno o en un `.env` en la carpeta desde donde lo corrés (copiá [`.env.example`](https://github.com/nialvape/utn-mcp/blob/main/.env.example)):
+
+| Variable | Para qué | Por defecto |
+|---|---|---|
+| `HOST`, `PORT` | Dónde escucha. | `127.0.0.1`, `3000` |
+| `UTN_MCP_PUBLIC_URL` | Dirección pública (`https://mcp.tu-dominio.com`). Es el issuer del OAuth, la base de los links de subida y el único host, además de localhost, que se acepta en `Host` y `Origin`. | `http://127.0.0.1:<PORT>` |
+| `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_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 |
+
+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
+docker build -t utn-mcp .
+docker run -d --name utn-mcp --network host --restart unless-stopped \
+  -e HOST=127.0.0.1 -e PORT=8100 -e UTN_MCP_PUBLIC_URL=https://mcp.tu-dominio.com \
+  -e UTN_MCP_KEY=$(openssl rand -base64 32) -v utn-mcp-data:/data utn-mcp
+```
+Guardá esa `UTN_MCP_KEY`: sin ella no se pueden descifrar las sesiones guardadas.
 
 ## Dónde se guardan tus datos
-Todo queda en tu computadora:
+Instalado en tu computadora, todo queda ahí:
 - **Usuario y contraseña**: en el gestor de credenciales del sistema (Windows Credential Manager, Keychain en macOS, Secret Service en Linux).
-- **Token del aula virtual y cookies de sesión**: en `%APPDATA%\utn-mcp\session.json` (Windows) o `~/.config/utn-mcp/session.json` (Linux y macOS).
-- **En modo HTTP**: la sesión va cifrada en `utn-mcp.db`, en la misma carpeta, con la clave de `store.key` (o la de `UTN_MCP_KEY`). Del token del cliente solo se guarda el hash.
+- **Token del aula virtual**: en `%APPDATA%\utn-mcp\session.json` (Windows) o `~/.config/utn-mcp/session.json` (Linux y macOS).
+- **En modo HTTP**: la contraseña no se guarda; la sesión va cifrada en `utn-mcp.db`, en la misma carpeta, con la clave de `store.key` (o la de `UTN_MCP_KEY`). Del token del cliente solo se guarda el hash.
 
 En Linux sin gestor de credenciales (servidores, Docker, WSL) podés definir las variables de entorno `UTN_USER` y `UTN_PASS` en lugar de usar `login`.
 
+Si usás un servidor hosteado por otra persona, tu sesión del aula la guarda ese servidor (cifrada, y sin tu contraseña): revisá su política de privacidad.
+
 ## Desarrollo
 ```bash
 git clone https://github.com/nialvape/utn-mcp.git

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

@@ -2,6 +2,15 @@ import { callWs, MoodleError } from "./moodle-api.js";
 export function getSiteInfo(session) {
     return callWs(session, "core_webservice_get_site_info");
 }
+/** El usuario dueño del token, con su email institucional (site_info no lo trae). */
+export async function getOwnUser(session) {
+    const { userid, username, fullname } = await getSiteInfo(session);
+    const [user] = await callWs(session, "core_user_get_users_by_field", {
+        field: "id",
+        "values[0]": userid,
+    });
+    return { username, fullname, email: user?.email || null };
+}
 export async function getUserCourses(session) {
     const { userid } = await getSiteInfo(session);
     return callWs(session, "core_enrol_get_users_courses", { userid });

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

@@ -0,0 +1,33 @@
+import { getOwnUser, getUserCourses } from "./client.js";
+import { fetchToken } from "./sso-login.js";
+import { AULA_PLATFORM } from "./stored-session.js";
+/**
+ * Entra al aula de la regional con usuario y contraseña, crea el usuario del store si no existe y le
+ * 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).
+ */
+export async function linkAulaAccount(store, regional, credentials) {
+    const token = await fetchToken(regional, credentials);
+    // El token recién emitido: si falla, no hay con qué renovarlo.
+    const fresh = {
+        getRegional: async () => regional,
+        getToken: async () => token,
+        refreshToken: async () => {
+            throw new Error("El aula rechazó el token recién emitido.");
+        },
+    };
+    const own = await getOwnUser(fresh);
+    // La primera vez que alguien entra a una regional sin verificar se prueban también los cursos: si
+    // anda, queda verificada para todos los de este servidor.
+    if (regional.support === "candidate") {
+        await getUserCourses(fresh);
+        await store.markRegionalVerified(regional.id);
+    }
+    // El de Moodle, en minúscula, igual que en `users`: es con lo que se compara al renovar.
+    const username = own.username.toLowerCase();
+    const userId = await store.findOrCreateUser(regional.id, username, own.email ?? undefined);
+    const data = { username, token };
+    await store.saveSession(userId, AULA_PLATFORM, JSON.stringify(data));
+    return { userId, regional, username, fullname: own.fullname, email: own.email };
+}

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

@@ -1,35 +1,43 @@
 import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
-import { CookieJar } from "tough-cookie";
 import { sessionFile } from "../../shared/paths.js";
 import { logger } from "../../shared/logger.js";
 import { loadCredentials } from "./credentials.js";
-import { fetchToken } from "./sso-login.js";
+import { defaultRegional, findRegional } from "./regionals.js";
+import { fetchToken, LoginRequiredError } from "./sso-login.js";
 /**
  * Sesión del modo local: un solo usuario, guardada en disco.
- * Credenciales en el keychain (o UTN_USER/UTN_PASS); token y cookies del SSO en session.json.
+ * Credenciales en el keychain (o UTN_USER/UTN_PASS); el token y la regional en session.json.
  */
 export class LocalSession {
     refreshing = null;
+    /**
+     * La elegida en `utn-mcp login`: la de session.json o, si se borró, la guardada con las credenciales.
+     * Sin login (UTN_USER/UTN_PASS) o de antes de elegirla, la de UTN_REGIONAL.
+     */
+    async getRegional() {
+        const regional = (await this.read()).regional ?? (await loadCredentials())?.regional;
+        return regional ? findRegional(regional) : defaultRegional();
+    }
     async getToken() {
         return (await this.read()).token ?? this.refreshToken();
     }
     /** Una sola renovación en curso aunque varias tools fallen a la vez. */
     refreshToken() {
-        this.refreshing ??= loadCredentials()
-            .then((creds) => this.login(creds))
+        this.refreshing ??= Promise.all([this.getRegional(), loadCredentials()])
+            .then(([regional, creds]) => this.login(regional, creds))
             .finally(() => {
             this.refreshing = null;
         });
         return this.refreshing;
     }
-    /** Obtiene un token nuevo y lo guarda junto con las cookies del SSO. */
-    async login(credentials) {
-        logger.info("Obteniendo token del aula virtual...");
-        const stored = await this.read();
-        const jar = stored.cookies ? await CookieJar.deserialize(stored.cookies) : new CookieJar();
-        const token = await fetchToken(jar, credentials);
-        await this.write({ token, obtainedAt: new Date().toISOString(), cookies: await jar.serialize() });
+    /** Obtiene un token nuevo y lo guarda. */
+    async login(regional, credentials) {
+        if (!credentials)
+            throw new LoginRequiredError();
+        logger.info(`Obteniendo token del aula virtual de ${regional.name}...`);
+        const token = await fetchToken(regional, credentials);
+        await this.write({ token, obtainedAt: new Date().toISOString(), regional: regional.id });
         return token;
     }
     async read() {
@@ -37,7 +45,7 @@ export class LocalSession {
             return JSON.parse(await readFile(sessionFile(), "utf8"));
         }
         catch {
-            return { token: null, obtainedAt: null, cookies: null };
+            return { token: null, obtainedAt: null };
         }
     }
     async write(data) {

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

@@ -1,7 +1,6 @@
 import { postForm } from "../../shared/http.js";
-import { AULA_BASE_URL } from "./constants.js";
-const WS_URL = `${AULA_BASE_URL}/webservice/rest/server.php`;
-const UPLOAD_URL = `${AULA_BASE_URL}/webservice/upload.php`;
+const WS_PATH = "/webservice/rest/server.php";
+const UPLOAD_PATH = "/webservice/upload.php";
 const TOKEN_ERRORS = new Set(["invalidtoken", "expiredtoken"]);
 export class MoodleError extends Error {
     errorcode;
@@ -14,9 +13,10 @@ export class MoodleError extends Error {
 const isException = (data) => typeof data === "object" && data !== null && "exception" in data;
 /** Llama a una función del web service de Moodle; renueva el token una vez si venció. */
 export async function callWs(session, wsfunction, params = {}) {
+    const { baseUrl } = await session.getRegional();
     let token = await session.getToken();
     for (let attempt = 0;; attempt++) {
-        const data = await postForm(WS_URL, {
+        const data = await postForm(baseUrl + WS_PATH, {
             ...params,
             wstoken: token,
             wsfunction,
@@ -66,6 +66,7 @@ export async function fetchFile(session, url, maxBytes) {
  * que es lo que piden las funciones que guardan archivos. Todos quedan en el mismo borrador.
  */
 export async function uploadDraftFiles(session, files) {
+    const { baseUrl } = await session.getRegional();
     let token = await session.getToken();
     for (let attempt = 0;; attempt++) {
         const form = new FormData();
@@ -75,7 +76,7 @@ export async function uploadDraftFiles(session, files) {
         files.forEach((f, i) => form.set(`file_${i + 1}`, new Blob([new Uint8Array(f.bytes)]), f.name));
         let res;
         try {
-            res = await fetch(UPLOAD_URL, { method: "POST", body: form, signal: AbortSignal.timeout(120_000) });
+            res = await fetch(baseUrl + UPLOAD_PATH, { method: "POST", body: form, signal: AbortSignal.timeout(120_000) });
         }
         catch (e) {
             throw new MoodleError(`No se pudo subir el archivo: ${e.message}`);

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