utn-mcp 0.6.9 → 0.8.0

package/build/oauth/admin.js

@@ -0,0 +1,110 @@
+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 } 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";
+/** 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;
+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();
+/**
+ * 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 function mountAdmin(app, store, secret) {
+    const json = express.json({ limit: "4kb" });
+    const verifyLimiter = new RateLimiter(VERIFY_ATTEMPTS, VERIFY_WINDOW_MS);
+    const requireSecret = (req, res, next) => {
+        const got = Buffer.from(req.headers.authorization ?? "");
+        const want = Buffer.from(`Bearer ${secret}`);
+        if (got.length === want.length && timingSafeEqual(got, want))
+            return next();
+        res.status(401).json({ error: "No autorizado." });
+    };
+    /** El usuario, su regional, cuándo se renovó su sesión del aula y sus apps conectadas. */
+    async function summary(user) {
+        const [clients, aulaAt] = await Promise.all([
+            store.listConnectedClients(user.id),
+            store.sessionUpdatedAt(user.id, AULA_PLATFORM),
+        ]);
+        return {
+            usuario: user.utnUsername,
+            regional: user.regional,
+            sesionAula: aulaAt ? isoDate(aulaAt) : undefined,
+            clientes: clients.map((c) => ({
+                id: c.clientId,
+                nombre: c.clientName ?? (c.clientId === "local" ? "Token de utn-mcp login" : "App sin nombre"),
+                ultimoUso: isoDate(c.lastTokenAt),
+            })),
+        };
+    }
+    /** `{ email }` → el resumen de ese usuario. */
+    app.post("/admin/clientes", requireSecret, json, async (req, res) => {
+        const email = typeof req.body?.email === "string" ? req.body.email : "";
+        const user = email ? await store.findUserByEmail(email) : null;
+        res.json(user ? await summary(user) : { clientes: [] });
+    });
+    /** Todos los usuarios con su resumen, para el panel de quien administra el servidor. */
+    app.post("/admin/usuarios", requireSecret, async (_req, res) => {
+        const users = await store.listUsers();
+        const usuarios = await Promise.all(users.map(async (u) => ({ email: u.email || undefined, alta: isoDate(u.createdAt), ...(await summary(u)) })));
+        res.json({ usuarios });
+    });
+    /** `{ email, cliente }` → borra los tokens de esa app: tiene que volver a conectarse. */
+    app.post("/admin/clientes/revocar", requireSecret, json, async (req, res) => {
+        const email = typeof req.body?.email === "string" ? req.body.email : "";
+        const clientId = typeof req.body?.cliente === "string" ? req.body.cliente : "";
+        const user = email ? await store.findUserByEmail(email) : null;
+        if (!user || !clientId)
+            return void res.status(404).json({ error: "No existe ese usuario o esa app." });
+        await store.revokeClient(user.id, clientId);
+        res.json({ revocado: true });
+    });
+    /** Las regionales que se pueden elegir, con su soporte en este servidor. */
+    app.post("/admin/regionales", requireSecret, async (_req, res) => {
+        const regionales = availableRegionals(await store.listVerifiedRegionals()).map((r) => ({
+            id: r.id,
+            nombre: r.name,
+            soporte: SUPPORT[r.support],
+        }));
+        res.json({ regionales });
+    });
+    /**
+     * `{ 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 }`; si
+     * no entra, `{ error, motivo }`.
+     */
+    app.post("/admin/verificar", requireSecret, json, async (req, res) => {
+        const id = typeof req.body?.regional === "string" ? req.body.regional : "";
+        const username = typeof req.body?.usuario === "string" ? req.body.usuario.trim() : "";
+        const password = typeof req.body?.contrasena === "string" ? req.body.contrasena : "";
+        const regional = availableRegionals(await store.listVerifiedRegionals()).find((r) => r.id === id);
+        if (!regional || !username || !password) {
+            return void res.status(400).json({ error: "pedido", motivo: "Faltan la regional, el usuario o la contraseña." });
+        }
+        if (regional.support === "unsupported") {
+            return void res.status(422).json({ error: "sin_soporte", motivo: `Todavía no hay soporte para ${regional.name}.` });
+        }
+        if (!verifyLimiter.allow(`${regional.id}:${username.toLowerCase()}`)) {
+            return void res.status(429).json({ error: "intentos", motivo: "Demasiados intentos. Esperá unos minutos." });
+        }
+        try {
+            const account = await linkAulaAccount(store, regional, { username, password });
+            logger.info(`Admin: ${account.username} (${regional.id}) vinculó su aula.`);
+            res.json({ usuario: account.username, nombre: account.fullname, email: account.email ?? undefined });
+        }
+        catch (e) {
+            if (e instanceof InvalidCredentialsError) {
+                return void res.status(401).json({ error: "credenciales", motivo: "El aula rechazó el usuario o la contraseña." });
+            }
+            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}.` });
+        }
+    });
+}

package/build/oauth/expiring.js

@@ -0,0 +1,57 @@
+import { randomBytes } from "node:crypto";
+/**
+ * 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 class Expiring {
+    ttlMs;
+    items = new Map();
+    /** `ttlMs` en milisegundos. */
+    constructor(ttlMs) {
+        this.ttlMs = ttlMs;
+    }
+    add(value) {
+        this.sweep();
+        const id = randomBytes(24).toString("base64url");
+        this.items.set(id, { value, expiresAt: Date.now() + this.ttlMs });
+        return id;
+    }
+    get(id) {
+        this.sweep();
+        return this.items.get(id)?.value;
+    }
+    /** Lo devuelve y lo borra: un code se canjea una sola vez. */
+    take(id) {
+        const value = this.get(id);
+        this.items.delete(id);
+        return value;
+    }
+    sweep() {
+        const now = Date.now();
+        for (const [id, item] of this.items)
+            if (item.expiresAt <= now)
+                this.items.delete(id);
+    }
+}
+/** Cuenta intentos por clave (la IP) en una ventana fija. */
+export class RateLimiter {
+    max;
+    windowMs;
+    hits = new Map();
+    /** `windowMs` en milisegundos. */
+    constructor(max, windowMs) {
+        this.max = max;
+        this.windowMs = windowMs;
+    }
+    allow(key) {
+        const now = Date.now();
+        for (const [k, hit] of this.hits)
+            if (hit.resetAt <= now)
+                this.hits.delete(k);
+        const hit = this.hits.get(key) ?? { count: 0, resetAt: now + this.windowMs };
+        hit.count++;
+        this.hits.set(key, hit);
+        return hit.count <= this.max;
+    }
+}

package/build/oauth/redirects.js

@@ -0,0 +1,60 @@
+/** Los callbacks de los clientes MCP conocidos (Claude, ChatGPT, Grok, Gemini, VS Code web) y los esquemas de editores. */
+const DEFAULT_HOSTS = [
+    "claude.ai",
+    "claude.com",
+    "chatgpt.com",
+    "chat.openai.com",
+    "grok.com",
+    "gemini.google.com",
+    "vscode.dev",
+    "insiders.vscode.dev",
+];
+const DEFAULT_SCHEMES = ["cursor:", "vscode:", "vscode-insiders:", "windsurf:"];
+/** En loopback la redirección queda en la compu del usuario: ahí escuchan los clientes de escritorio. */
+const LOOPBACK = ["localhost", "127.0.0.1", "[::1]"];
+/**
+ * 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 function redirectAllowlistFromEnv(env = process.env) {
+    const extra = (env.UTN_MCP_REDIRECT_ALLOW ?? "").split(",").map((e) => e.trim().toLowerCase()).filter(Boolean);
+    return {
+        hosts: new Set([...DEFAULT_HOSTS, ...extra.filter((e) => !e.endsWith(":"))]),
+        schemes: new Set([...DEFAULT_SCHEMES, ...extra.filter((e) => e.endsWith(":"))]),
+    };
+}
+/**
+ * `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 function redirectTrust(uri, allow) {
+    if (typeof uri !== "string")
+        return "rejected";
+    let url;
+    try {
+        url = new URL(uri);
+    }
+    catch {
+        return "rejected";
+    }
+    if (url.hash || url.username || url.password)
+        return "rejected";
+    if (url.protocol === "http:" || url.protocol === "https:") {
+        if (LOOPBACK.includes(url.hostname))
+            return "trusted";
+        if (url.protocol === "http:")
+            return "rejected";
+        return allow.hosts.has(url.hostname) ? "trusted" : "unknown";
+    }
+    return allow.schemes.has(url.protocol) ? "trusted" : "rejected";
+}
+/** Cómo se le nombra al usuario el destino. */
+export function describeRedirect(uri) {
+    const url = new URL(uri);
+    if (LOOPBACK.includes(url.hostname))
+        return "una app en tu compu";
+    if (url.protocol === "https:")
+        return url.hostname;
+    return `la app ${url.protocol.slice(0, -1)}`;
+}

package/build/oauth/server.js

@@ -0,0 +1,341 @@
+import { createHash, randomUUID } from "node:crypto";
+import express from "express";
+import { buildOAuthProtectedResourceMetadata, checkResourceAllowed, getOAuthProtectedResourceMetadataUrl, } from "@modelcontextprotocol/server";
+import { linkAulaAccount } from "../aula-virtual/client/link.js";
+import { availableRegionals, defaultRegional } from "../aula-virtual/client/regionals.js";
+import { InvalidCredentialsError } from "../aula-virtual/client/sso-login.js";
+import { logger } from "../shared/logger.js";
+import { escapeHtml, page } from "../shared/pages.js";
+import { Expiring, RateLimiter } from "./expiring.js";
+import { describeRedirect, redirectTrust } from "./redirects.js";
+/** Duración del access token, en segundos: una baja de acceso se aplica a más tardar en este tiempo. */
+const ACCESS_TTL = 60 * 60;
+/** Duración del refresh token, en segundos. Rota en cada uso. */
+const REFRESH_TTL = 30 * 24 * 60 * 60;
+/** Cuánto vive un code sin canjear, en milisegundos. */
+const CODE_TTL_MS = 60_000;
+/** Cuánto tiene el usuario para completar el login, en milisegundos. */
+const PENDING_TTL_MS = 10 * 60_000;
+/** Intentos de login por IP cada 15 minutos: que el servidor no sirva para probar contraseñas contra el SSO. */
+const LOGIN_ATTEMPTS = 10;
+const LOGIN_WINDOW_MS = 15 * 60_000;
+/** Registros de clientes por IP cada hora. */
+const REGISTER_ATTEMPTS = 20;
+const REGISTER_WINDOW_MS = 60 * 60_000;
+/**
+ * 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 function mountOAuth(app, { issuer, store, access, sameOrigin, redirects }) {
+    const resource = `${issuer}/mcp`;
+    const metadata = {
+        issuer,
+        authorization_endpoint: `${issuer}/authorize`,
+        token_endpoint: `${issuer}/token`,
+        registration_endpoint: `${issuer}/register`,
+        revocation_endpoint: `${issuer}/revoke`,
+        response_types_supported: ["code"],
+        grant_types_supported: ["authorization_code", "refresh_token"],
+        code_challenge_methods_supported: ["S256"],
+        token_endpoint_auth_methods_supported: ["none"],
+        revocation_endpoint_auth_methods_supported: ["none"],
+    };
+    // Valida el issuer al arrancar (HTTPS salvo en localhost) en lugar de en el primer request.
+    const resourceMetadata = buildOAuthProtectedResourceMetadata({
+        oauthMetadata: metadata,
+        resourceServerUrl: new URL(resource),
+        resourceName: "UTN-MCP",
+    });
+    const pending = new Expiring(PENDING_TTL_MS);
+    const codes = new Expiring(CODE_TTL_MS);
+    const limiter = new RateLimiter(LOGIN_ATTEMPTS, LOGIN_WINDOW_MS);
+    const registerLimiter = new RateLimiter(REGISTER_ATTEMPTS, REGISTER_WINDOW_MS);
+    const form = express.urlencoded({ extended: false, limit: "16kb" });
+    const regionals = async () => availableRegionals(await store.listVerifiedRegionals());
+    app.get("/.well-known/oauth-authorization-server", cors, (_req, res) => void res.json(metadata));
+    app.get(["/.well-known/oauth-protected-resource", "/.well-known/oauth-protected-resource/mcp"], cors, (_req, res) => void res.json(resourceMetadata));
+    app.options(["/register", "/token", "/revoke"], cors, (_req, res) => void res.sendStatus(204));
+    app.post("/register", cors, express.json({ limit: "16kb" }), async (req, res) => {
+        if (!registerLimiter.allow(req.ip ?? "desconocida")) {
+            return void oauthError(res, 429, "too_many_requests", "Demasiados registros desde esta IP. Probá en una hora.");
+        }
+        const body = (req.body ?? {});
+        const uris = Array.isArray(body.redirect_uris) ? body.redirect_uris : [];
+        if (!uris.length || uris.some((u) => redirectTrust(u, redirects) === "rejected")) {
+            // Queda en el log para poder habilitar el esquema de una app nueva con UTN_MCP_REDIRECT_ALLOW.
+            logger.warn(`OAuth /register rechazado: ${JSON.stringify(uris).slice(0, 300)}`);
+            return void oauthError(res, 400, "invalid_redirect_uri", "Las redirect_uri tienen que ser HTTPS, de loopback o de una app habilitada en este servidor " +
+                "(UTN_MCP_REDIRECT_ALLOW), y sin fragmento.");
+        }
+        const client = {
+            clientId: randomUUID(),
+            clientName: typeof body.client_name === "string" ? body.client_name.slice(0, 100) : null,
+            redirectUris: uris,
+        };
+        await store.saveClient(client);
+        res.status(201).json({
+            client_id: client.clientId,
+            client_id_issued_at: Math.floor(Date.now() / 1000),
+            client_name: client.clientName ?? undefined,
+            redirect_uris: client.redirectUris,
+            grant_types: ["authorization_code", "refresh_token"],
+            response_types: ["code"],
+            token_endpoint_auth_method: "none",
+        });
+    });
+    app.get("/authorize", async (req, res) => {
+        const q = req.query;
+        const client = q.client_id ? await store.findClient(q.client_id) : null;
+        // Sin cliente o redirect_uri válidos no se redirige a ningún lado: el error lo ve el usuario.
+        if (!client)
+            return void errorPage(res, 400, "Cliente desconocido", "Este cliente no está registrado. Volvé a conectarlo desde tu app.");
+        if (!q.redirect_uri || !client.redirectUris.includes(q.redirect_uri)) {
+            return void errorPage(res, 400, "Redirección inválida", "La redirect_uri no es la que registró el cliente.");
+        }
+        const trust = redirectTrust(q.redirect_uri, redirects);
+        if (trust === "rejected") {
+            return void errorPage(res, 400, "App no habilitada", "Esta app vuelve a una dirección que este servidor no acepta.");
+        }
+        const fail = (error, description) => redirectWith(res, q.redirect_uri, { error, error_description: description, state: q.state });
+        if (q.response_type !== "code")
+            return void fail("unsupported_response_type", "Solo se acepta response_type=code.");
+        if (!q.code_challenge || q.code_challenge_method !== "S256") {
+            return void fail("invalid_request", "PKCE es obligatorio, con code_challenge_method=S256.");
+        }
+        if (q.resource && !checkResourceAllowed({ requestedResource: q.resource, configuredResource: resource })) {
+            return void fail("invalid_target", `El único recurso de este servidor es ${resource}.`);
+        }
+        const id = pending.add({
+            clientId: client.clientId,
+            clientName: client.clientName,
+            redirectUri: q.redirect_uri,
+            unknownRedirect: trust === "unknown",
+            codeChallenge: q.code_challenge,
+            state: q.state,
+            resource: q.resource,
+        });
+        res.type("html").send(loginPage({
+            action: "/authorize",
+            regionals: await regionals(),
+            pendingId: id,
+            clientName: client.clientName,
+            redirectUri: q.redirect_uri,
+            unknownRedirect: trust === "unknown",
+        }));
+    });
+    app.post("/authorize", sameOrigin, form, async (req, res) => {
+        const id = String(req.body?.pedido ?? "");
+        const request = pending.get(id);
+        if (!request)
+            return void errorPage(res, 400, "Pedido vencido", "Pasó demasiado tiempo. Volvé a conectar desde tu app.");
+        const list = await regionals();
+        const retry = (error) => res.type("html").send(loginPage({
+            action: "/authorize",
+            regionals: list,
+            pendingId: id,
+            clientName: request.clientName,
+            redirectUri: request.redirectUri,
+            unknownRedirect: request.unknownRedirect,
+            regional: req.body?.regional,
+            error,
+        }));
+        if (request.unknownRedirect && req.body?.acepto !== "si") {
+            return void retry("Para conectar una app que no es un cliente conocido tenés que aceptar el aviso.");
+        }
+        const account = await login(req, list, retry);
+        if (!account)
+            return;
+        const decision = await access({ regional: account.regional.id, username: account.username, email: account.email });
+        if (!decision.allowed)
+            return void deniedPage(res, decision.reason, decision.url);
+        pending.take(id);
+        const code = codes.add({
+            userId: account.userId,
+            clientId: request.clientId,
+            redirectUri: request.redirectUri,
+            codeChallenge: request.codeChallenge,
+        });
+        logger.info(`OAuth: ${account.username} (${account.regional.id}) autorizó a ${request.clientName ?? request.clientId}.`);
+        redirectWith(res, request.redirectUri, { code, state: request.state, iss: issuer });
+    });
+    app.post("/token", cors, form, express.json({ limit: "16kb" }), async (req, res) => {
+        const body = (req.body ?? {});
+        try {
+            if (body.grant_type === "authorization_code") {
+                const code = body.code ? codes.take(body.code) : undefined;
+                if (!code)
+                    return void oauthError(res, 400, "invalid_grant", "El code no existe, venció o ya se usó.");
+                if (body.client_id && body.client_id !== code.clientId) {
+                    return void oauthError(res, 400, "invalid_grant", "El code es de otro cliente.");
+                }
+                if (body.redirect_uri && body.redirect_uri !== code.redirectUri) {
+                    return void oauthError(res, 400, "invalid_grant", "La redirect_uri no coincide con la del pedido.");
+                }
+                if (!body.code_verifier || pkceChallenge(body.code_verifier) !== code.codeChallenge) {
+                    return void oauthError(res, 400, "invalid_grant", "El code_verifier no corresponde al code_challenge.");
+                }
+                return void res.json(await issueTokens(store, code.userId, code.clientId));
+            }
+            if (body.grant_type === "refresh_token") {
+                const found = body.refresh_token ? await store.findToken(body.refresh_token, "refresh") : null;
+                if (!found)
+                    return void oauthError(res, 400, "invalid_grant", "El refresh token no existe, venció o fue revocado.");
+                const clientId = found.clientId ?? body.client_id ?? "desconocido";
+                if (body.client_id && found.clientId && body.client_id !== found.clientId) {
+                    return void oauthError(res, 400, "invalid_grant", "El refresh token es de otro cliente.");
+                }
+                await store.revokeToken(body.refresh_token);
+                // El acceso se vuelve a mirar en cada refresh: si la cuenta se dio de baja, acá se corta.
+                const user = await store.findUser(found.userId);
+                if (!user)
+                    return void oauthError(res, 400, "invalid_grant", "El usuario ya no existe.");
+                const decision = await access({ regional: user.regional, username: user.utnUsername, email: user.email });
+                if (!decision.allowed)
+                    return void oauthError(res, 400, "invalid_grant", decision.reason);
+                return void res.json(await issueTokens(store, user.id, clientId));
+            }
+            oauthError(res, 400, "unsupported_grant_type", "Solo authorization_code y refresh_token.");
+        }
+        catch (e) {
+            logger.error(`OAuth /token: ${e.message}`);
+            oauthError(res, 500, "server_error", "Error interno al emitir el token.");
+        }
+    });
+    app.post("/revoke", cors, form, express.json({ limit: "16kb" }), async (req, res) => {
+        const token = req.body?.token;
+        if (token)
+            await store.revokeToken(token);
+        // RFC 7009: se contesta 200 aunque el token no exista.
+        res.sendStatus(200);
+    });
+    // Volver a iniciar sesión cuando vence la sesión del aula: no emite tokens, solo renueva la sesión.
+    app.get("/login", async (_req, res) => void res.type("html").send(loginPage({ action: "/login", regionals: await regionals() })));
+    app.post("/login", sameOrigin, form, async (req, res) => {
+        const list = await regionals();
+        const account = await login(req, list, (error) => res.type("html").send(loginPage({
+            action: "/login",
+            regionals: list,
+            regional: req.body?.regional,
+            error,
+        })));
+        if (!account)
+            return;
+        logger.info(`OAuth: ${account.username} (${account.regional.id}) renovó su sesión del aula.`);
+        res.type("html").send(page("Listo", "<p>Ya renovamos tu sesión del aula. Volvé al chat y pedile al agente que reintente.</p>"));
+    });
+    /** Entra al aula con lo que mandó el formulario; si falla, vuelve a mostrarlo con el error. */
+    async function login(req, list, retry) {
+        if (!limiter.allow(req.ip ?? "desconocida")) {
+            retry("Demasiados intentos. Esperá unos minutos y probá de nuevo.");
+            return null;
+        }
+        const username = String(req.body?.usuario ?? "").trim();
+        const password = String(req.body?.contrasena ?? "");
+        if (!username || !password) {
+            retry("Completá usuario y contraseña.");
+            return null;
+        }
+        const regional = list.find((r) => r.id === String(req.body?.regional ?? ""));
+        if (!regional) {
+            retry("Elegí tu regional de la lista.");
+            return null;
+        }
+        if (regional.support === "unsupported") {
+            retry(`Todavía no hay soporte para ${regional.name}: su aula todavía no funciona con UTN-MCP.`);
+            return null;
+        }
+        try {
+            return await linkAulaAccount(store, regional, { username, password });
+        }
+        catch (e) {
+            if (e instanceof InvalidCredentialsError)
+                retry("La UTN rechazó el usuario o la contraseña.");
+            else if (regional.support === "candidate") {
+                // Nadie la había usado acá: lo más probable es que todavía no ande, no que esté caída.
+                logger.warn(`Regional ${regional.id} sin verificar, falló el login de ${username}: ${e.message}`);
+                retry(`No pudimos usar el aula de ${regional.name}: puede que todavía no ande con UTN-MCP.`);
+            }
+            else {
+                logger.error(`Login de ${username} (${regional.id}): ${e.message}`);
+                retry("No pudimos entrar al aula. Puede que esté caída: probá de nuevo en unos minutos.");
+            }
+            return null;
+        }
+    }
+    return getOAuthProtectedResourceMetadataUrl(new URL(resource));
+}
+async function issueTokens(store, userId, clientId) {
+    const accessToken = await store.issueToken(userId, { kind: "access", clientId, ttlSeconds: ACCESS_TTL });
+    const refreshToken = await store.issueToken(userId, { kind: "refresh", clientId, ttlSeconds: REFRESH_TTL });
+    return { access_token: accessToken, token_type: "Bearer", expires_in: ACCESS_TTL, refresh_token: refreshToken };
+}
+const pkceChallenge = (verifier) => createHash("sha256").update(verifier).digest("base64url");
+/** Los endpoints que llaman los clientes desde el navegador (como el MCP Inspector) aceptan cualquier origen. */
+export const cors = (_req, res, next) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "content-type, authorization, mcp-protocol-version, mcp-session-id, last-event-id");
+    // Sin exponerlos, el navegador no deja leer el 401 que arranca el OAuth ni la sesión del transporte.
+    res.setHeader("Access-Control-Expose-Headers", "www-authenticate, mcp-session-id");
+    // Un día, en segundos: el navegador no repite el preflight en cada request.
+    res.setHeader("Access-Control-Max-Age", "86400");
+    next();
+};
+function redirectWith(res, base, params) {
+    const url = new URL(base);
+    for (const [k, v] of Object.entries(params))
+        if (v !== undefined)
+            url.searchParams.set(k, v);
+    res.redirect(302, url.toString());
+}
+function oauthError(res, status, error, description) {
+    res.status(status).json({ error, error_description: description });
+}
+function errorPage(res, status, title, message) {
+    res.status(status).type("html").send(page(title, `<p>${escapeHtml(message)}</p>`));
+}
+function deniedPage(res, reason, url) {
+    const link = url ? `<p><a href="${escapeHtml(url)}">${escapeHtml(url)}</a></p>` : "";
+    res.status(403).type("html").send(page("Sin acceso", `<p>${escapeHtml(reason)}</p>${link}`));
+}
+function loginPage(o) {
+    const where = o.redirectUri ? `<strong>${escapeHtml(describeRedirect(o.redirectUri))}</strong>` : "";
+    const destination = where && !o.unknownRedirect ? ` Al terminar vas a volver a ${where}: si no es la app que estás conectando, no sigas.` : "";
+    const warning = o.unknownRedirect
+        ? `<div class=aviso><p><strong>Esta app no es un cliente conocido.</strong> Al terminar vas a volver a ${where}, ` +
+            "y desde ahí van a poder usar tu aula en tu nombre: leer tus cursos y mensajes, entregar tareas y escribir " +
+            "mensajes. Si alguien te pasó este link y no estás conectando un agente tuyo o de alguien en quien confiás, " +
+            "no sigas: puede ser un intento de robarte la sesión.</p></div>"
+        : "";
+    const consent = o.unknownRedirect
+        ? `<label class=acepto><input type="checkbox" name="acepto" value="si" required><span>Entiendo el riesgo y ` +
+            `conecto esta app bajo mi responsabilidad. Quien administra este servidor no se hace responsable de lo que ` +
+            `${where} haga con mi aula ni con mi sesión.</span></label>`
+        : "";
+    const intro = o.pendingId
+        ? `<p>${escapeHtml(o.clientName ?? "Una app")} quiere usar UTN-MCP con tu Aula Virtual. Entrá con tu usuario de la UTN para conectarla.${destination}</p>`
+        : "<p>Tu sesión del aula venció. Entrá con tu usuario de la UTN para renovarla.</p>";
+    const error = o.error ? `<p class=error>${escapeHtml(o.error)}</p>` : "";
+    const hidden = o.pendingId ? `<input type="hidden" name="pedido" value="${escapeHtml(o.pendingId)}">` : "";
+    const selected = o.regional || defaultRegional().id;
+    const option = (r) => `<option value="${escapeHtml(r.id)}"${r.id === selected ? " selected" : ""}>${escapeHtml(r.name)}</option>`;
+    const group = (label, support) => {
+        const items = o.regionals.filter((r) => r.support === support);
+        return items.length ? `<optgroup label="${escapeHtml(label)}">${items.map(option).join("")}</optgroup>` : "";
+    };
+    const options = group("Regionales", "verified") +
+        group("Agregar mi regional (primera vez acá)", "candidate") +
+        group("Todavía sin soporte", "unsupported");
+    return page("Entrar con la UTN", intro +
+        warning +
+        error +
+        `<form method="post" action="${o.action}">${hidden}` +
+        `<label>Regional<select name="regional" required>${options}</select></label>` +
+        `<label>Usuario<input name="usuario" autocomplete="username" autocapitalize="none" required></label>` +
+        `<label>Contraseña<input name="contrasena" type="password" autocomplete="current-password" required></label>` +
+        consent +
+        `<button type="submit">Entrar</button></form>` +
+        "<p class=nota>La contraseña se usa una sola vez para entrar al aula y no se guarda. " +
+        'El código es abierto: <a href="https://github.com/nialvape/utn-mcp">github.com/nialvape/utn-mcp</a>.</p>', o.pendingId ? "Conectar app · Aula Virtual" : "Renovar sesión · Aula Virtual");
+}

package/build/server.js

@@ -7,7 +7,7 @@ import { registerAulaVirtualTools } from "./aula-virtual/tools.js";
 export function createServer(aula, files) {
     const server = new McpServer({
         name: "UTN-MCP",
-        version: "0.6.9",
+        version: "0.8.0",
     });
     registerAulaVirtualTools(server, aula, files);
     return server;

package/build/shared/input.js

@@ -9,6 +9,66 @@ export async function ask(question) {
         rl.close();
     }
 }
+/**
+ * Elige una de `options` con las flechas (o su número) y Enter; devuelve el índice. Sin terminal
+ * interactiva (stdin redirigido) muestra la lista numerada y pide el número. Enter solo elige `initial`.
+ */
+export async function askChoice(question, options, initial = 0) {
+    if (!stdin.isTTY) {
+        const list = options.map((o, i) => `  ${i + 1}. ${o}`).join("\n");
+        const answer = await ask(`${question}\n${list}\nElegí una [${initial + 1}]: `);
+        if (!answer)
+            return initial;
+        const index = Number(answer) - 1;
+        if (!options[index])
+            throw new Error(`"${answer}" no es una opción: elegí un número del 1 al ${options.length}.`);
+        return index;
+    }
+    return new Promise((resolve, reject) => {
+        let selected = initial;
+        // Reescribe la lista en el lugar: sube tantas líneas como opciones y borra cada una.
+        const render = (redraw) => {
+            if (redraw)
+                stderr.write(`\x1b[${options.length}A`);
+            for (const [i, o] of options.entries())
+                stderr.write(`\x1b[2K${i === selected ? "❯" : " "} ${o}\n`);
+        };
+        const onData = (chunk) => {
+            if (chunk === "\u0003") {
+                done();
+                reject(new Error("Cancelado"));
+                return;
+            }
+            if (chunk === "\r" || chunk === "\n") {
+                done();
+                stderr.write(`\x1b[${options.length + 1}A\x1b[J${question} ${options[selected]}\n`);
+                resolve(selected);
+                return;
+            }
+            if (chunk === "\x1b[A")
+                selected = (selected - 1 + options.length) % options.length;
+            else if (chunk === "\x1b[B")
+                selected = (selected + 1) % options.length;
+            else if (options[Number(chunk) - 1])
+                selected = Number(chunk) - 1;
+            else
+                return;
+            render(true);
+        };
+        const done = () => {
+            stdin.off("data", onData);
+            stdin.setRawMode(false);
+            stdin.pause();
+            stderr.write("\x1b[?25h"); // vuelve a mostrar el cursor
+        };
+        stderr.write(`\x1b[?25l${question} (flechas y Enter)\n`);
+        render(false);
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.setEncoding("utf8");
+        stdin.on("data", onData);
+    });
+}
 export function askHidden(question) {
     if (!stdin.isTTY)
         return ask(question);

package/build/shared/load-env.js

@@ -0,0 +1,5 @@
+import { existsSync } from "node:fs";
+// Se evalúa antes que el resto de los módulos: así las variables del `.env` (como UTN_REGIONAL)
+// están definidas desde que arranca el proceso.
+if (existsSync(".env"))
+    process.loadEnvFile(".env");