utn-mcp 0.8.2 → 0.9.0

package/build/autogestion/client/local-session.d.ts

@@ -0,0 +1,17 @@
+import { type AutogestionConnector, type AutogestionSystem } from "./connector.js";
+import type { AutogestionSession } from "./session.js";
+/**
+ * Sesión del modo local: un solo usuario, el de la compu. Recibe el sistema ya resuelto para la
+ * regional (la misma que eligió para el aula) y loguea el conector con las credenciales del
+ * keychain o las env vars, una vez por sistema y bajo demanda: el primer uso es el que pide login.
+ */
+export declare class LocalAutogestionSession implements AutogestionSession {
+    private readonly system;
+    private readonly regionalId;
+    /** Conectores ya logueados, por sistema: un login alcanza para todas las tools. */
+    private readonly connectors;
+    /** El sistema llega resuelto desde afuera: las plataformas no se conocen entre sí. */
+    constructor(system: AutogestionSystem, regionalId: string);
+    getConnector(): Promise<AutogestionConnector>;
+    private login;
+}

package/build/autogestion/client/local-session.js

@@ -0,0 +1,37 @@
+import { connectorKit, LoginRequiredError } from "./connector.js";
+import { loadAutogestionCredentials } from "./credentials.js";
+/**
+ * Sesión del modo local: un solo usuario, el de la compu. Recibe el sistema ya resuelto para la
+ * regional (la misma que eligió para el aula) y loguea el conector con las credenciales del
+ * keychain o las env vars, una vez por sistema y bajo demanda: el primer uso es el que pide login.
+ */
+export class LocalAutogestionSession {
+    system;
+    regionalId;
+    /** Conectores ya logueados, por sistema: un login alcanza para todas las tools. */
+    connectors = new Map();
+    /** El sistema llega resuelto desde afuera: las plataformas no se conocen entre sí. */
+    constructor(system, regionalId) {
+        this.system = system;
+        this.regionalId = regionalId;
+    }
+    async getConnector() {
+        const system = this.system;
+        let connector = this.connectors.get(system.id);
+        if (!connector) {
+            connector = this.login(system.id, system.create(this.regionalId, connectorKit)).catch((error) => {
+                this.connectors.delete(system.id);
+                throw error;
+            });
+            this.connectors.set(system.id, connector);
+        }
+        return connector;
+    }
+    async login(systemId, connector) {
+        const credentials = await loadAutogestionCredentials(systemId);
+        if (!credentials)
+            throw new LoginRequiredError("la autogestión de tu regional");
+        await connector.login(credentials);
+        return connector;
+    }
+}

package/build/autogestion/client/session.d.ts

@@ -0,0 +1,14 @@
+import type { AutogestionConnector } from "./connector.js";
+/**
+ * La autogestión del usuario. Todo lo que habla con el sistema recibe esto y no sabe de dónde sale:
+ * `LocalAutogestionSession` (STDIO, el usuario de la compu). El modo HTTP todavía no la tiene
+ * resuelta: las credenciales por sistema de cada usuario quedan como decisión de diseño abierta.
+ */
+export interface AutogestionSession {
+    /**
+     * El conector del sistema que usa la regional del usuario, logueado y listo.
+     * Rechaza con LoginRequiredError si faltan las credenciales o con InvalidCredentialsError
+     * si el sistema las rechaza.
+     */
+    getConnector(): Promise<AutogestionConnector>;
+}

package/build/autogestion/client/session.js

@@ -0,0 +1 @@
+export {};

package/build/autogestion/client/types.d.ts

@@ -0,0 +1,49 @@
+/** Una materia del estado académico, con lo que el sistema informa de ella. */
+export interface EstadoMateria {
+    materia: string;
+    estado?: string;
+    plan?: string;
+    anio?: string;
+    nota?: string;
+    fecha?: string;
+    /** Celdas que no entraron en una columna conocida: no se tira información. */
+    extra?: string[];
+}
+/** Una materia con las correlativas que exige, tal como las publica la autogestión. */
+export interface CorrelatividadMateria {
+    materia: string;
+    /** Texto de la columna de correlativas, tal cual viene: "Puede cursar", "No aprobó X", etc. */
+    correlativas: string;
+    plan?: string;
+    anio?: string;
+    extra?: string[];
+}
+/**
+ * Correlatividades de la carrera según la autogestión, separadas como las publica el sistema:
+ * `cursar` siempre; `rendir` cuando el sistema la tiene en otra página (Sysacad sí, verificado
+ * con cuenta real oct 2026). Es la fuente dinámica de las correlatividades en lugar de datos
+ * fijos del repo.
+ */
+export interface Correlatividades {
+    cursar: CorrelatividadMateria[];
+    rendir?: CorrelatividadMateria[];
+}
+export interface NotasParcialesMateria {
+    materia: string;
+    anio?: string;
+    comision?: string;
+    aula?: string;
+    horarios?: string;
+    notas?: string;
+    inasistencias?: string;
+    obs?: string;
+    cursando: boolean;
+}
+export interface ExamenMateria {
+    materia: string;
+    fecha?: string;
+    nota?: string;
+    especialidad?: string;
+    plan?: string;
+    codigo?: string;
+}

package/build/autogestion/client/types.js

@@ -0,0 +1 @@
+export {};

package/build/autogestion/format/correlatividades.d.ts

@@ -0,0 +1,4 @@
+import type { AutogestionSession } from "../client/session.js";
+import type { Correlatividades } from "../client/types.js";
+/** Correlatividades de cursar y, si el conector la publica, de rendir. */
+export declare function getCorrelatividades(session: AutogestionSession): Promise<Correlatividades>;

package/build/autogestion/format/correlatividades.js

@@ -0,0 +1,4 @@
+/** Correlatividades de cursar y, si el conector la publica, de rendir. */
+export async function getCorrelatividades(session) {
+    return (await session.getConnector()).correlatividades();
+}

package/build/autogestion/format/estado-academico.d.ts

@@ -0,0 +1,4 @@
+import type { AutogestionSession } from "../client/session.js";
+import type { EstadoMateria } from "../client/types.js";
+/** Estado académico del alumno en su autogestión, delegado al conector de su regional. */
+export declare function getEstadoAcademico(session: AutogestionSession): Promise<EstadoMateria[]>;

package/build/autogestion/format/estado-academico.js

@@ -0,0 +1,4 @@
+/** Estado académico del alumno en su autogestión, delegado al conector de su regional. */
+export async function getEstadoAcademico(session) {
+    return (await session.getConnector()).estadoAcademico();
+}

package/build/autogestion/format/examenes.d.ts

@@ -0,0 +1,3 @@
+import type { AutogestionSession } from "../client/session.js";
+import type { ExamenMateria } from "../client/types.js";
+export declare function getExamenes(session: AutogestionSession): Promise<ExamenMateria[]>;

package/build/autogestion/format/examenes.js

@@ -0,0 +1,8 @@
+import { HttpError } from "../../shared/http.js";
+export async function getExamenes(session) {
+    const connector = await session.getConnector();
+    if (!connector.examenes) {
+        throw new HttpError("El sistema de autogestión de tu regional todavía no tiene conector para el historial de exámenes.");
+    }
+    return connector.examenes();
+}

package/build/autogestion/format/notas-parciales.d.ts

@@ -0,0 +1,3 @@
+import type { AutogestionSession } from "../client/session.js";
+import type { NotasParcialesMateria } from "../client/types.js";
+export declare function getCursandoAhora(session: AutogestionSession): Promise<NotasParcialesMateria[]>;

package/build/autogestion/format/notas-parciales.js

@@ -0,0 +1,8 @@
+import { HttpError } from "../../shared/http.js";
+export async function getCursandoAhora(session) {
+    const connector = await session.getConnector();
+    if (!connector.notasParciales) {
+        throw new HttpError("El sistema de autogestión de tu regional todavía no tiene conector para la cursada actual.");
+    }
+    return (await connector.notasParciales()).filter((m) => m.cursando);
+}

package/build/autogestion/login.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `utn-mcp login autogestion`: instala el conector de la regional si falta o quedó viejo, pide legajo
+ * y contraseña, los prueba contra el sistema y recién ahí los guarda en el keychain. La misma regional
+ * que se usa para el aula decide qué sistema de autogestión toca.
+ */
+export declare function runAutogestionLogin(regionalId: string): Promise<void>;
+/**
+ * Después del login del aula: si la regional tiene un conector en el catálogo, ofrece conectarlo.
+ * Un error acá no deshace el login del aula, que ya quedó guardado.
+ */
+export declare function offerAutogestionLogin(regionalId: string): Promise<void>;

package/build/autogestion/login.js

@@ -0,0 +1,59 @@
+import { ask, askChoice, askHidden } from "../shared/input.js";
+import { logger } from "../shared/logger.js";
+import { catalogEntryForRegional } from "./client/catalog.js";
+import { connectorKit, systemForRegional, UnsupportedRegionalError } from "./client/connector.js";
+import { saveAutogestionCredentials } from "./client/credentials.js";
+import { installConnector, installedManifest } from "./client/install.js";
+import { loadInstalledSystems } from "./client/installed-systems.js";
+/**
+ * `utn-mcp login autogestion`: instala el conector de la regional si falta o quedó viejo, pide legajo
+ * y contraseña, los prueba contra el sistema y recién ahí los guarda en el keychain. La misma regional
+ * que se usa para el aula decide qué sistema de autogestión toca.
+ */
+export async function runAutogestionLogin(regionalId) {
+    const entry = catalogEntryForRegional(regionalId);
+    if (entry && (await installedManifest(entry))?.version !== entry.version) {
+        logger.info(`Bajando el conector de ${entry.name}...`);
+        await installConnector(entry);
+    }
+    const system = systemForRegional(regionalId, await loadInstalledSystems());
+    if (!system)
+        throw new UnsupportedRegionalError(regionalId);
+    if (entry?.regionales[regionalId] === "candidate") {
+        logger.info(`El conector de ${system.name} todavía no se probó en tu regional: si algo no anda, contalo en ` +
+            "https://github.com/nialvape/utn-mcp/issues.");
+    }
+    const hint = system.usernameHint?.(regionalId);
+    const username = (await ask(`Legajo o usuario de ${system.name}${hint ? ` (${hint})` : ""}: `)).trim();
+    if (!username)
+        throw new Error("Falta el usuario.");
+    const password = await askHidden("Contraseña: ");
+    // Se guardan recién después de comprobar que el sistema las aceptó.
+    const connector = system.create(regionalId, connectorKit);
+    await connector.login({ username, password });
+    if (await saveAutogestionCredentials(system.id, { username, password })) {
+        logger.info("Credenciales guardadas en el keychain del sistema.");
+    }
+    else {
+        logger.warn("No hay keychain disponible: definí las variables de entorno del sistema (ver README).");
+    }
+    logger.info(`Listo: ${system.name} conectado.`);
+}
+/**
+ * Después del login del aula: si la regional tiene un conector en el catálogo, ofrece conectarlo.
+ * Un error acá no deshace el login del aula, que ya quedó guardado.
+ */
+export async function offerAutogestionLogin(regionalId) {
+    const entry = catalogEntryForRegional(regionalId);
+    if (!entry)
+        return;
+    const options = ["Sí", "No, después con `utn-mcp login autogestion`"];
+    if ((await askChoice(`¿Conectar también ${entry.name} (estado académico, correlativas, finales)?`, options)) !== 0)
+        return;
+    try {
+        await runAutogestionLogin(regionalId);
+    }
+    catch (e) {
+        logger.warn(`${e.message}\nEl aula quedó conectada; ${entry.name} se puede conectar después con \`utn-mcp login autogestion\`.`);
+    }
+}

package/build/autogestion/tools.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/server";
+import type { AutogestionSession } from "./client/session.js";
+export declare function registerAutogestionTools(server: McpServer, session: AutogestionSession): void;

package/build/autogestion/tools.js

@@ -0,0 +1,73 @@
+import { getCorrelatividades } from "./format/correlatividades.js";
+import { getEstadoAcademico } from "./format/estado-academico.js";
+import { getExamenes } from "./format/examenes.js";
+import { getCursandoAhora } from "./format/notas-parciales.js";
+// JSON compacto: indentar estas respuestas cuesta ~25% más de contexto y no se lee mejor.
+const json = (data) => ({
+    content: [{ type: "text", text: JSON.stringify(data) }],
+});
+const failure = (e) => ({
+    content: [{ type: "text", text: `Error: ${e.message}` }],
+    isError: true,
+});
+export function registerAutogestionTools(server, session) {
+    server.registerTool("autogestion_estado_academico", {
+        description: "Estado académico del usuario según la autogestión de su regional: cada materia OBLIGATORIA " +
+            "del plan con su estado (regular, aprobada, libre), plan, nota y fecha. No es el catálogo " +
+            "completo de la carrera: puede incluir electivas aprobadas y no listar materias sin " +
+            "movimientos cargados. Las que se están cursando se marcan como Cursando cuando el " +
+            "sistema permite saberlas. Requiere " +
+            "`utn-mcp login autogestion` una vez; las credenciales son las del sistema de autogestión, " +
+            "que no siempre son las del aula virtual.",
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    }, async () => {
+        try {
+            return json(await getEstadoAcademico(session));
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
+    server.registerTool("autogestion_cursando_ahora", {
+        description: "Materias que el usuario está cursando ahora según la autogestión de su regional, con su " +
+            "comisión, aula y horarios cuando el sistema los publica. Incluye electivas, a diferencia " +
+            "del estado académico. Requiere `utn-mcp login autogestion` una vez.",
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    }, async () => {
+        try {
+            return json(await getCursandoAhora(session));
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
+    server.registerTool("autogestion_examenes", {
+        description: "Historial de exámenes finales del usuario según la autogestión de su regional: fecha, " +
+            "materia, nota o estado del examen cuando todavía no hay nota, plan y código. Puede cubrir " +
+            "también materias rendidas en planes anteriores y electivas que el estado académico no " +
+            "muestra. Requiere `utn-mcp login autogestion` una vez.",
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    }, async () => {
+        try {
+            return json(await getExamenes(session));
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
+    server.registerTool("autogestion_correlatividades", {
+        description: "Correlatividades de la carrera del usuario según la autogestión de su regional, separadas " +
+            "para cursar y para rendir cuando el sistema las distingue: para cada materia, qué exige " +
+            "tener regular o aprobada. Es la fuente dinámica de " +
+            "correlatividades: usala en lugar de suponer datos de un plan fijo. Requiere " +
+            "`utn-mcp login autogestion` una vez.",
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    }, async () => {
+        try {
+            return json(await getCorrelatividades(session));
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
+}

package/build/http.d.ts

@@ -0,0 +1,22 @@
+import { type AuthInfo, type McpServerFactory } from "@modelcontextprotocol/server";
+import type { AccessPolicy } from "./oauth/access.js";
+import type { RedirectAllowlist } from "./oauth/redirects.js";
+import type { SessionStore } from "./shared/store/session-store.js";
+import { type UploadInbox } from "./shared/uploads.js";
+/** El usuario del store dueño del token, en `extra.userId`. */
+export declare function userIdOf(authInfo: AuthInfo | undefined): number;
+/** Dónde escucha el servidor y, si está publicado, desde qué dirección lo ven los clientes. */
+export interface HttpOptions {
+    host: string;
+    port: number;
+    /** Sin barra final, por ejemplo `https://mcp.tu-dominio.com`. */
+    publicUrl?: string;
+    /** Quién puede conectarse por OAuth. */
+    access: AccessPolicy;
+    /** A dónde puede volver el navegador después del login de OAuth. */
+    redirects: RedirectAllowlist;
+    /** Con él se habilita la API de /admin (ver `mountAdmin`). */
+    adminSecret?: string;
+}
+/** El factory recibe en `ctx.authInfo` el token ya validado, con el usuario; de ahí arma su sesión. */
+export declare function startHttpServer(factory: McpServerFactory, options: HttpOptions, store: SessionStore, inbox: UploadInbox): void;

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./shared/load-env.js";

package/build/index.js

@@ -6,6 +6,7 @@ import { LocalSession } from "./aula-virtual/client/local-session.js";
 import { defaultRegional } from "./aula-virtual/client/regionals.js";
 import { StoredAulaSession } from "./aula-virtual/client/stored-session.js";
 import { runLogin } from "./aula-virtual/login.js";
+import { offerAutogestionLogin, runAutogestionLogin } from "./autogestion/login.js";
 import { startHttpServer, userIdOf } from "./http.js";
 import { accessPolicyFromEnv } from "./oauth/access.js";
 import { redirectAllowlistFromEnv } from "./oauth/redirects.js";
@@ -18,6 +19,7 @@ const USAGE = `Uso:
   utn-mcp --http [--host H] [--port N]  servidor MCP por HTTP (por defecto 127.0.0.1:3000)
   utn-mcp login           guardar credenciales de la UTN y obtener el primer token
   utn-mcp login --http    lo mismo, para el modo HTTP: guarda la sesión y emite el token del cliente
+  utn-mcp login autogestion  instalar el conector de la autogestión de tu regional y guardar legajo y contraseña
 
 Si hay un .env en la carpeta actual, se lee al arrancar (ver .env.example).`;
 async function main() {
@@ -38,7 +40,15 @@ async function main() {
     // Una UTN_REGIONAL que no existe corta acá: si no, recién fallaría al primer login o al primer pedido.
     defaultRegional();
     if (positionals[0] === "login") {
-        await runLogin(values.http);
+        if (positionals[1] === "autogestion") {
+            await runAutogestionLogin((await new LocalSession().getRegional()).id);
+        }
+        else {
+            await runLogin(values.http);
+            // La autogestión todavía es solo del modo local: en HTTP no hay dónde pedirle la clave a cada usuario.
+            if (!values.http)
+                await offerAutogestionLogin((await new LocalSession().getRegional()).id);
+        }
         return;
     }
     if (values.http) {

package/build/oauth/access.d.ts

@@ -0,0 +1,18 @@
+export type AccessDecision = {
+    allowed: true;
+} | {
+    allowed: false;
+    reason: string;
+    url?: string;
+};
+/** Quién puede usar el servidor: decide con el usuario que acaba de entrar al aula de su regional. */
+export type AccessPolicy = (user: {
+    regional: string;
+    username: string;
+    email: string | null;
+}) => Promise<AccessDecision>;
+/**
+ * La política sale del entorno: con UTN_MCP_ACCESS_URL decide otro servicio;
+ * con UTN_MCP_ALLOWED_EMAILS, una lista; sin ninguna, entra cualquiera con usuario de la UTN.
+ */
+export declare function accessPolicyFromEnv(env?: NodeJS.ProcessEnv): AccessPolicy;

package/build/oauth/admin.d.ts

@@ -0,0 +1,8 @@
+import { type Express } from "express";
+import type { SessionStore } from "../shared/store/session-store.js";
+/**
+ * API para que otro servicio del que hostea (un panel de cuenta, por ejemplo) liste usuarios, muestre y
+ * desconecte sus apps, consulte las regionales y dé de alta cuentas vinculando su aula. Solo
+ * existe con UTN_MCP_ADMIN_SECRET, que va como `Authorization: Bearer`. Los usuarios se buscan por email.
+ */
+export declare function mountAdmin(app: Express, store: SessionStore, secret: string): void;

package/build/oauth/admin.js

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

package/build/oauth/expiring.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Valores que viven en memoria hasta que se usan o vencen: los pedidos de `/authorize` mientras el
+ * usuario completa el login y los codes hasta que el cliente los canjea. Si el servidor se reinicia,
+ * se pierden y el cliente vuelve a empezar el OAuth, que es lo que haría igual con un code vencido.
+ */
+export declare class Expiring<T> {
+    private readonly ttlMs;
+    private readonly items;
+    /** `ttlMs` en milisegundos. */
+    constructor(ttlMs: number);
+    add(value: T): string;
+    get(id: string): T | undefined;
+    /** Lo devuelve y lo borra: un code se canjea una sola vez. */
+    take(id: string): T | undefined;
+    private sweep;
+}
+/** Cuenta intentos por clave (la IP) en una ventana fija. */
+export declare class RateLimiter {
+    private readonly max;
+    private readonly windowMs;
+    private readonly hits;
+    /** `windowMs` en milisegundos. */
+    constructor(max: number, windowMs: number);
+    allow(key: string): boolean;
+}

package/build/oauth/pending-login.d.ts

@@ -0,0 +1,20 @@
+import type { MfaPrompt, SecondFactor } from "../aula-virtual/client/sso-login.js";
+/**
+ * Un login que queda esperando el segundo factor entre un request y otro: corre en segundo plano y,
+ * cuando le pregunta algo al usuario, `next` lo devuelve para mostrárselo en una página; `answer` le
+ * pasa lo que el usuario contestó en el request siguiente.
+ */
+export declare class PendingLogin<T> {
+    private readonly run;
+    private waiting;
+    private listeners;
+    constructor(start: (secondFactor: SecondFactor) => Promise<T>);
+    /** Espera a que el login termine o le pregunte algo al usuario. */
+    next(): Promise<{
+        done: T;
+    } | {
+        prompt: MfaPrompt;
+    }>;
+    /** Contesta lo que está preguntando; si no pregunta nada (un formulario mandado dos veces), no hace nada. */
+    answer(value: string): void;
+}

package/build/oauth/redirects.d.ts

@@ -0,0 +1,20 @@
+/** A dónde puede volver el navegador después del login. */
+export interface RedirectAllowlist {
+    /** Hostnames a los que se vuelve por HTTPS sin aviso. */
+    hosts: Set<string>;
+    /** Esquemas de apps instaladas, con los dos puntos (`cursor:`). */
+    schemes: Set<string>;
+}
+/**
+ * Los conocidos más los de UTN_MCP_REDIRECT_ALLOW, separados por coma: hosts (`app.ejemplo.com`)
+ * o esquemas terminados en dos puntos (`miapp:`).
+ */
+export declare function redirectAllowlistFromEnv(env?: NodeJS.ProcessEnv): RedirectAllowlist;
+/**
+ * `trusted`: loopback, un host HTTPS de la lista o el esquema de una app de la lista.
+ * `unknown`: cualquier otro host HTTPS, como el de un agente propio; se acepta con aviso.
+ * `rejected`: el resto.
+ */
+export declare function redirectTrust(uri: unknown, allow: RedirectAllowlist): "trusted" | "unknown" | "rejected";
+/** Cómo se le nombra al usuario el destino. */
+export declare function describeRedirect(uri: string): string;

package/build/oauth/server.d.ts

@@ -0,0 +1,22 @@
+import { type Express, type RequestHandler } from "express";
+import type { SessionStore } from "../shared/store/session-store.js";
+import type { AccessPolicy } from "./access.js";
+import { type RedirectAllowlist } from "./redirects.js";
+export interface OAuthOptions {
+    /** URL base del servidor, sin barra final: es el issuer y de ahí salen los endpoints. */
+    issuer: string;
+    store: SessionStore;
+    access: AccessPolicy;
+    /** Rechaza los POST de formularios que vengan de otro origen. */
+    sameOrigin: RequestHandler;
+    /** A dónde puede volver el navegador con el code. */
+    redirects: RedirectAllowlist;
+}
+/**
+ * Servidor de autorización OAuth 2.1 para los clientes MCP: registro dinámico, PKCE obligatorio y
+ * clientes públicos. El usuario se identifica con la UTN, y ese mismo login vincula su aula: la
+ * contraseña se usa una vez y no se guarda. Devuelve la URL de la metadata del recurso, que va en el 401.
+ */
+export declare function mountOAuth(app: Express, { issuer, store, access, sameOrigin, redirects }: OAuthOptions): string;
+/** Los endpoints que llaman los clientes desde el navegador (como el MCP Inspector) aceptan cualquier origen. */
+export declare const cors: RequestHandler;

package/build/server.d.ts

@@ -0,0 +1,9 @@
+import { McpServer } from "@modelcontextprotocol/server";
+import type { AulaSession } from "./aula-virtual/client/session.js";
+import type { FileSource } from "./shared/uploads.js";
+/**
+ * Un servidor MCP para un usuario. Las entradas STDIO y HTTP lo crean por conexión o por request.
+ * `files`: de dónde salen los archivos que el usuario sube a una plataforma.
+ * Es async porque, en local, resuelve la regional y los conectores instalados antes de registrar la autogestión.
+ */
+export declare function createServer(aula: AulaSession, files: FileSource): Promise<McpServer>;