utn-mcp 0.6.9 → 0.8.0

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

@@ -1,20 +1,33 @@
-import { CookieJar } from "tough-cookie";
 import { loadCredentials } from "./credentials.js";
+import { defaultRegional, findRegional } from "./regionals.js";
 import { fetchToken, LoginRequiredError } from "./sso-login.js";
 /** Con qué nombre guarda el aula su sesión en el store. */
 export const AULA_PLATFORM = "aula";
 /**
- * Sesión del modo HTTP: la de un usuario del store. Renueva el token con las cookies del SSO y, si
- * ya no alcanzan, con la contraseña del keychain cuando es de este mismo usuario: eso pasa solo en
- * local, porque el servidor hosteado no guarda contraseñas.
+ * Sesión del modo HTTP: la de un usuario del store, en el aula de su regional. Renueva el token con la
+ * contraseña del keychain cuando es de este mismo usuario: eso pasa solo en local, porque el servidor
+ * hosteado no guarda contraseñas. Si no, el usuario vuelve a iniciar sesión.
  */
 export class StoredAulaSession {
     store;
     userId;
+    loginUrl;
     refreshing = null;
-    constructor(store, userId) {
+    regional = null;
+    /** `loginUrl` es la página donde el usuario vuelve a iniciar sesión, si el servidor tiene una. */
+    constructor(store, userId, loginUrl) {
         this.store = store;
         this.userId = userId;
+        this.loginUrl = loginUrl;
+    }
+    /** La del usuario en el store; no cambia mientras dura la sesión, así que se lee una sola vez. */
+    getRegional() {
+        this.regional ??= this.store.findUser(this.userId).then((user) => {
+            if (!user)
+                throw this.loginRequired("No hay usuario para esta sesión.");
+            return findRegional(user.regional);
+        });
+        return this.regional;
     }
     async getToken() {
         return (await this.read()).token;
@@ -26,30 +39,31 @@ export class StoredAulaSession {
         return this.refreshing;
     }
     async renew() {
-        const stored = await this.read();
-        const jar = await CookieJar.deserialize(stored.cookies);
-        // Las del keychain (o UTN_USER/UTN_PASS) son de una sola persona: con otro usuario
-        // entraríamos al aula de ella y guardaríamos su token en la sesión de este.
+        const [stored, regional] = await Promise.all([this.read(), this.getRegional()]);
+        // Las del keychain (o UTN_USER/UTN_PASS) son de una sola persona: con otro usuario (o el mismo
+        // nombre en otra regional) entraríamos al aula de ella y guardaríamos su token en la sesión de este.
         const credentials = await loadCredentials();
-        const own = credentials?.username.trim().toLowerCase() === stored.username ? credentials : null;
-        let token;
-        try {
-            token = await fetchToken(jar, own);
-        }
-        catch (e) {
-            if (e instanceof LoginRequiredError) {
-                throw new LoginRequiredError("La sesión del aula venció: volvé a iniciar sesión (`utn-mcp login --http`).");
-            }
-            throw e;
-        }
-        const data = { ...stored, token, cookies: await jar.serialize() };
+        const sameUser = credentials?.username.trim().toLowerCase() === stored.username &&
+            (credentials.regional ?? defaultRegional().id) === regional.id;
+        if (!credentials || !sameUser)
+            throw this.loginRequired("La sesión del aula venció.");
+        const token = await fetchToken(regional, credentials);
+        // Sin `...stored`: las sesiones guardadas antes traen cookies, que ya no se usan.
+        const data = { username: stored.username, token };
         await this.store.saveSession(this.userId, AULA_PLATFORM, JSON.stringify(data));
         return token;
     }
     async read() {
         const raw = await this.store.loadSession(this.userId, AULA_PLATFORM);
         if (!raw)
-            throw new LoginRequiredError("No hay sesión del aula para este usuario: corré `utn-mcp login --http`.");
+            throw this.loginRequired("No hay sesión del aula para este usuario.");
         return JSON.parse(raw);
     }
+    /** Hosteado, el usuario vuelve a entrar por la página del servidor; sin ella, por el CLI. */
+    loginRequired(reason) {
+        const next = this.loginUrl
+            ? `Pedile al usuario que vuelva a iniciar sesión en ${this.loginUrl} y después reintentá.`
+            : "Volvé a iniciar sesión con `utn-mcp login --http` en la máquina del servidor.";
+        return new LoginRequiredError(`${reason} ${next}`);
+    }
 }

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

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

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

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

package/build/aula-virtual/login.js

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

package/build/aula-virtual/tools.js

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

package/build/http.js

@@ -1,8 +1,11 @@
 import express from "express";
 import { Readable } from "node:stream";
 import { bearerAuthChallengeResponse, createMcpHandler, OAuthError, OAuthErrorCode, verifyBearerToken, } from "@modelcontextprotocol/server";
-import { localhostHostValidation, localhostOriginValidation, toNodeHandler } from "@modelcontextprotocol/node";
+import { hostHeaderValidation, originValidation, toNodeHandler } from "@modelcontextprotocol/node";
+import { mountAdmin } from "./oauth/admin.js";
+import { cors, mountOAuth } from "./oauth/server.js";
 import { logger } from "./shared/logger.js";
+import { escapeHtml, page } from "./shared/pages.js";
 import { MAX_UPLOAD_BYTES, formatSize } from "./shared/uploads.js";
 const asMiddleware = (guard) => (req, res, next) => {
     if (guard(req, res))
@@ -37,10 +40,34 @@ function storeVerifier(store) {
         },
     };
 }
+const LOOPBACK = ["localhost", "127.0.0.1", "[::1]"];
 /** El factory recibe en `ctx.authInfo` el token ya validado, con el usuario; de ahí arma su sesión. */
-export function startHttpServer(factory, port, store, inbox) {
+export function startHttpServer(factory, options, store, inbox) {
+    const { host, port, publicUrl, access, redirects, adminSecret } = options;
     const handler = createMcpHandler(factory, { onerror: (e) => logger.error(e.message) });
     const verifier = storeVerifier(store);
+    const app = express();
+    // Detrás de un reverse proxy en la misma máquina: la IP del cliente (para el rate limit) viene en X-Forwarded-For.
+    app.set("trust proxy", "loopback");
+    app.disable("x-powered-by");
+    app.use(securityHeaders(publicUrl?.startsWith("https://") ?? false));
+    // Contra DNS rebinding: solo se aceptan los hosts de esta máquina y el de la URL pública.
+    const allowed = publicUrl ? [...LOOPBACK, new URL(publicUrl).hostname] : LOOPBACK;
+    if (!publicUrl && !LOOPBACK.includes(host)) {
+        logger.warn(`Escuchando en ${host} sin UTN_MCP_PUBLIC_URL: se rechazan los requests que no lleguen como localhost.`);
+    }
+    app.use(asMiddleware(hostHeaderValidation(allowed)));
+    // Origin solo donde un navegador ajeno no tiene nada que hacer; los endpoints de OAuth tienen CORS abierto.
+    const sameOrigin = asMiddleware(originValidation(allowed));
+    const resourceMetadataUrl = mountOAuth(app, {
+        issuer: publicUrl ?? `http://127.0.0.1:${port}`,
+        store,
+        access,
+        sameOrigin,
+        redirects,
+    });
+    if (adminSecret)
+        mountAdmin(app, store, adminSecret);
     const requireToken = async (req, res, next) => {
         try {
             // toNodeHandler le pasa `req.auth` al handler como `authInfo`.
@@ -48,27 +75,34 @@ export function startHttpServer(factory, port, store, inbox) {
             next();
         }
         catch (e) {
-            const challenge = bearerAuthChallengeResponse(e);
+            // El 401 dice dónde está la metadata: de ahí el cliente arranca el OAuth.
+            const challenge = bearerAuthChallengeResponse(e, { resourceMetadataUrl });
             res.status(challenge.status);
             challenge.headers.forEach((value, name) => res.setHeader(name, value));
             res.send(await challenge.text());
         }
     };
-    const app = express();
-    app.use(asMiddleware(localhostHostValidation()));
-    app.use(asMiddleware(localhostOriginValidation()));
+    // Publicado, /mcp acepta cualquier origen: se autentica con el bearer, que el navegador no manda solo
+    // (no hay cookies), así que una página ajena no lo puede usar en nombre de nadie. Hay clientes que lo
+    // llaman desde su web, como Grok. En local sigue el chequeo de Origin, contra DNS rebinding.
+    const mcpOrigin = publicUrl ? cors : sameOrigin;
+    app.options("/mcp", mcpOrigin, (_req, res) => void res.sendStatus(204));
     // Sin express.json(): el handler lee el body por su cuenta.
-    app.all("/mcp", requireToken, toNodeHandler(handler));
+    app.all("/mcp", mcpOrigin, requireToken, toNodeHandler(handler));
     // Sin bearer: el id del link es el secreto, y lo abre un navegador o un `curl` que no lo tienen.
-    app.get("/subir/:id", (req, res) => {
-        const upload = inbox.get(req.params.id);
+    app.get("/subir/:id", sameOrigin, (req, res) => {
+        const upload = inbox.get(String(req.params.id));
         if (!upload)
             return void res.status(404).type("html").send(page("Link vencido", EXPIRED));
+        if (upload.files)
+            return void res.status(409).type("html").send(page("Link ya usado", USED));
         res.type("html").send(page(upload.title, uploadForm(upload.limits)));
     });
-    app.post("/subir/:id", (req, res) => receiveUpload(inbox, req, res));
-    app.listen(port, "127.0.0.1", () => {
-        logger.info(`Servidor MCP escuchando en http://127.0.0.1:${port}/mcp`);
+    app.post("/subir/:id", sameOrigin, (req, res) => receiveUpload(inbox, req, res));
+    app.listen(port, host, () => {
+        logger.info(`Servidor MCP escuchando en http://${host}:${port}/mcp`);
+        if (publicUrl)
+            logger.info(`Publicado en ${publicUrl}/mcp`);
     });
 }
 /** Recibe el multipart del formulario o de `curl -F archivos=@...`. Al navegador le contesta HTML; al resto, JSON. */
@@ -78,17 +112,21 @@ async function receiveUpload(inbox, req, res) {
         ? res.status(status).type("html").send(page("No se pudo subir", `<p>${escapeHtml(message)}</p>`))
         : res.status(status).json({ error: message });
     const id = String(req.params.id);
-    if (!inbox.get(id))
+    const upload = inbox.get(id);
+    if (!upload)
         return void fail(404, "El link de subida venció o no existe.");
-    if (Number(req.headers["content-length"]) > MAX_UPLOAD_BYTES) {
-        return void fail(413, `La subida pasa el máximo de ${formatSize(MAX_UPLOAD_BYTES)}.`);
-    }
+    if (upload.files)
+        return void fail(409, "Este link ya se usó. Pedile al agente uno nuevo.");
+    const tooBig = `La subida pasa el máximo de ${formatSize(MAX_UPLOAD_BYTES)}.`;
+    if (Number(req.headers["content-length"]) > MAX_UPLOAD_BYTES)
+        return void fail(413, tooBig);
+    const body = limitBytes(Readable.toWeb(req), MAX_UPLOAD_BYTES);
     try {
         // Request de la API web: parsea multipart sin sumar dependencias.
         const request = new Request(`http://localhost${req.url}`, {
             method: "POST",
             headers: req.headers,
-            body: Readable.toWeb(req),
+            body: body.stream,
             duplex: "half",
         });
         const form = await request.formData();
@@ -107,10 +145,44 @@ async function receiveUpload(inbox, req, res) {
         }
     }
     catch (e) {
-        fail(400, e.message);
+        if (body.exceeded()) {
+            fail(413, tooBig);
+            req.destroy();
+        }
+        else {
+            fail(400, e.message);
+        }
     }
 }
+function limitBytes(source, maxBytes) {
+    let total = 0;
+    const stream = source.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            total += chunk.length;
+            if (total > maxBytes)
+                controller.error(new Error("La subida es demasiado grande."));
+            else
+                controller.enqueue(chunk);
+        },
+    }));
+    return { stream, exceeded: () => total > maxBytes };
+}
+function securityHeaders(https) {
+    return (_req, res, next) => {
+        res.setHeader("Content-Security-Policy", "default-src 'none'; style-src 'unsafe-inline'; img-src 'self' data:; frame-ancestors 'none'; base-uri 'none'");
+        res.setHeader("X-Frame-Options", "DENY");
+        res.setHeader("X-Content-Type-Options", "nosniff");
+        // `same-origin` y no `no-referrer`: con `no-referrer` el navegador manda `Origin: null` en los POST de
+        // formularios, y el chequeo de Origin rechaza el login.
+        res.setHeader("Referrer-Policy", "same-origin");
+        // Un año, en segundos.
+        if (https)
+            res.setHeader("Strict-Transport-Security", "max-age=31536000");
+        next();
+    };
+}
 const EXPIRED = "<p>Este link de subida venció o ya no existe. Pedile al agente uno nuevo.</p>";
+const USED = "<p>Ya se subieron archivos a este link y no se pueden cambiar. Si te equivocaste, pedile al agente uno nuevo.</p>";
 function uploadForm(limits) {
     const rules = [
         limits.maxFiles ? `hasta ${limits.maxFiles} archivo(s)` : "",
@@ -124,14 +196,3 @@ function uploadForm(limits) {
         `<button type="submit">Subir</button></form>` +
         "<p class=nota>Subirlos no entrega la tarea: después el agente te confirma y la entrega.</p>");
 }
-/** Página mínima: se abre desde el celu, así que nada más que lo necesario. */
-function page(title, body) {
-    return (`<!doctype html><html lang="es"><head><meta charset="utf-8">` +
-        `<meta name="viewport" content="width=device-width, initial-scale=1"><title>${escapeHtml(title)}</title>` +
-        "<style>body{font-family:system-ui,sans-serif;max-width:32rem;margin:2rem auto;padding:0 1rem;" +
-        "line-height:1.5;color:#1a1a1a;background:#fff}@media(prefers-color-scheme:dark){body{color:#eee;" +
-        "background:#151515}}form{display:flex;flex-direction:column;gap:1rem;margin:1.5rem 0}" +
-        "button{padding:.7rem;font-size:1rem}.nota{opacity:.7;font-size:.9rem}</style></head>" +
-        `<body><h1>${escapeHtml(title)}</h1>${body}</body></html>`);
-}
-const escapeHtml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");

package/build/index.js

@@ -1,24 +1,32 @@
 #!/usr/bin/env node
+import "./shared/load-env.js";
 import { parseArgs } from "node:util";
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
 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 { startHttpServer, userIdOf } from "./http.js";
+import { accessPolicyFromEnv } from "./oauth/access.js";
+import { redirectAllowlistFromEnv } from "./oauth/redirects.js";
 import { createServer } from "./server.js";
 import { logger } from "./shared/logger.js";
 import { SqliteStore } from "./shared/store/sqlite-store.js";
 import { UploadInbox } from "./shared/uploads.js";
 const USAGE = `Uso:
   utn-mcp                 servidor MCP por STDIO (lo lanza el cliente)
-  utn-mcp --http [--port N]  servidor MCP por HTTP en 127.0.0.1 (por defecto 3000)
+  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 --http    lo mismo, para el modo HTTP: guarda la sesión y emite el token del cliente
+
+Si hay un .env en la carpeta actual, se lee al arrancar (ver .env.example).`;
 async function main() {
     const { values, positionals } = parseArgs({
         allowPositionals: true,
         options: {
             http: { type: "boolean", default: false },
+            // Por defecto solo desde esta máquina; hosteado, `0.0.0.0` detrás del reverse proxy.
+            host: { type: "string", default: process.env.HOST ?? "127.0.0.1" },
             port: { type: "string", default: process.env.PORT ?? "3000" },
             help: { type: "boolean", short: "h", default: false },
         },
@@ -27,6 +35,8 @@ async function main() {
         console.error(USAGE);
         return;
     }
+    // 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);
         return;
@@ -35,13 +45,26 @@ async function main() {
         // Cada request trae el token de un usuario del store y se arma con su sesión. Los archivos
         // llegan por links de subida: el servidor puede no estar en la compu de quien entrega.
         const port = Number(values.port);
+        const publicUrl = process.env.UTN_MCP_PUBLIC_URL?.replace(/\/+$/, "") || undefined;
+        const baseUrl = publicUrl ?? `http://127.0.0.1:${port}`;
+        // La página de `/login` del propio servidor, salvo que el que hostea prefiera mandar a otra.
+        const loginUrl = process.env.UTN_MCP_LOGIN_URL || `${baseUrl}/login`;
         const store = await SqliteStore.open();
-        const inbox = new UploadInbox(process.env.UTN_MCP_PUBLIC_URL ?? `http://127.0.0.1:${port}`);
+        const inbox = new UploadInbox(baseUrl);
         const factory = (ctx) => {
             const userId = userIdOf(ctx.authInfo);
-            return createServer(new StoredAulaSession(store, userId), { local: false, inbox, owner: String(userId) });
+            const aula = new StoredAulaSession(store, userId, loginUrl);
+            return createServer(aula, { local: false, inbox, owner: String(userId) });
         };
-        startHttpServer(factory, port, store, inbox);
+        const options = {
+            host: values.host,
+            port,
+            publicUrl,
+            access: accessPolicyFromEnv(),
+            redirects: redirectAllowlistFromEnv(),
+            adminSecret: process.env.UTN_MCP_ADMIN_SECRET || undefined,
+        };
+        startHttpServer(factory, options, store, inbox);
     }
     else {
         // STDIO: un solo usuario, el de la compu, con la misma sesión para todas las conexiones.

package/build/oauth/access.js

@@ -0,0 +1,52 @@
+import { logger } from "../shared/logger.js";
+/** Cuánto esperamos la respuesta de UTN_MCP_ACCESS_URL, en milisegundos. */
+const ACCESS_TIMEOUT_MS = 5_000;
+/**
+ * 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 function accessPolicyFromEnv(env = process.env) {
+    if (env.UTN_MCP_ACCESS_URL)
+        return remotePolicy(env.UTN_MCP_ACCESS_URL, env.UTN_MCP_ACCESS_SECRET);
+    if (env.UTN_MCP_ALLOWED_EMAILS)
+        return listPolicy(env.UTN_MCP_ALLOWED_EMAILS);
+    logger.warn("Sin UTN_MCP_ACCESS_URL ni UTN_MCP_ALLOWED_EMAILS: puede entrar cualquiera con usuario de la UTN.");
+    return async () => ({ allowed: true });
+}
+/** Emails o dominios (`@frba.utn.edu.ar`), separados por coma. */
+function listPolicy(raw) {
+    const entries = raw.split(",").map((e) => e.trim().toLowerCase()).filter(Boolean);
+    return async ({ email }) => {
+        const own = email?.toLowerCase();
+        if (own && entries.some((e) => (e.startsWith("@") ? own.endsWith(e) : own === e)))
+            return { allowed: true };
+        return { allowed: false, reason: "Tu cuenta no está habilitada en este servidor. Pedile acceso a quien lo administra." };
+    };
+}
+/** `POST url` con `{ email, usuario, regional }`; contesta `{ permitido, motivo?, url? }`. */
+function remotePolicy(url, secret) {
+    if (!secret)
+        logger.warn("UTN_MCP_ACCESS_URL sin UTN_MCP_ACCESS_SECRET: el pedido de acceso va sin autenticar.");
+    return async ({ regional, username, email }) => {
+        if (!email)
+            return { allowed: false, reason: "El aula no devolvió tu email, y sin él no podemos verificar tu acceso." };
+        try {
+            const res = await fetch(url, {
+                method: "POST",
+                headers: { "content-type": "application/json", ...(secret ? { authorization: `Bearer ${secret}` } : {}) },
+                body: JSON.stringify({ email, usuario: username, regional }),
+                signal: AbortSignal.timeout(ACCESS_TIMEOUT_MS),
+            });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            const data = (await res.json());
+            if (data.permitido === true)
+                return { allowed: true };
+            return { allowed: false, reason: data.motivo || "Tu cuenta no está habilitada en este servidor.", url: data.url };
+        }
+        catch (e) {
+            logger.error(`No se pudo consultar el acceso de ${email}: ${e.message}`);
+            return { allowed: false, reason: "No pudimos verificar si tenés acceso: probá de nuevo en unos minutos." };
+        }
+    };
+}