utn-mcp 0.6.9 → 0.7.0

package/README.md

@@ -1,156 +1,180 @@
-# UTN-MCP — El puente entre tu agente y los sistemas de la Universidad.
-Este es el Model Context Protocol server NO OFICIAL de la UTN. Con él podrás pedirle a tu agente de preferencia (ChatGPT, Claude, etc.) que busque informacion o archivos en el aula virtual.
-
-## Qué podés pedirle
-- *"¿Cuándo es el recuperatorio del primer parcial de Álgebra?"*
-- *"¿Qué avisó la profesora de Física esta semana?"*
-- *"Resumime la guía de la unidad 3 de Sistemas Operativos."*
-- *"Pasame el link para bajar el apunte de calorimetría."*
-- *"¿Qué nota me pusieron en el TP1 y qué me corrigieron?"*
-- *"Preguntá en el foro de consultas si el parcial incluye la unidad 4."*
-- *"Anotame en el grupo 6."*
-- *"Agendame el recuperatorio del 14 a las 18."*
-
-El agente recorre el aula como lo harías vos: entra al curso, mira los foros y abre los archivos que hagan falta.
-
-## Tools
-| Tool | Qué hace |
-|---|---|
-| `aula_list_courses` | Lista tus cursos. Es el punto de partida. |
-| `aula_open` | Entra a un curso, un módulo, un foro o una discusión. Cada respuesta trae las direcciones de lo que hay adentro y de un nivel más arriba, así el agente navega sin perderse. |
-| `aula_read_file` | Lee un archivo del aula, por partes cuando es largo. |
-| `aula_get_site_info` | Datos de tu usuario en el aula virtual. |
-| `aula_forum_post` | Abre un hilo en un foro o responde en una discusión. |
-| `aula_forum_edit_post` | Edita una publicación tuya. |
-| `aula_forum_delete_post` | Borra una publicación tuya. |
-| `aula_assign_submit` | Entrega una tarea: sube archivos de tu compu, escribe el texto en línea y confirma el envío. |
-| `aula_assign_upload_link` | Solo en modo HTTP: un link para subir los archivos de una entrega, que usa el agente con `curl` o vos desde el navegador. |
-| `aula_choice_answer` | Responde una elección o te anota en un grupo. |
-| `aula_send_message` | Manda un mensaje privado a un docente o compañero. |
-| `aula_calendar_add_event` | Agrega un recordatorio a tu calendario del aula. |
-
-Al abrir una tarea, `aula_open` muestra si la entregaste, cuándo vence y la devolución con la nota. Las tools que escriben le piden al agente que te muestre lo que va a hacer y espere tu confirmación.
-
-### Archivos que puede leer
-- **PDF**: el texto, página por página. Los **escaneados** se mandan como imagen de cada página, y el agente los lee igual.
-- **Word (.docx), PowerPoint (.pptx) y Excel (.xlsx)**: el texto, con las tablas fila por fila.
-- **Imágenes** (PNG, JPG, GIF) y texto plano.
-
-Los formatos viejos de Office (.doc, .ppt, .pps), los comprimidos (.zip, .rar) y los videos no se leen. En ese caso el agente te pasa el link para que lo bajes.
-
-### Links de descarga
-Cada archivo viene con un link del aula virtual que podés abrir en tu navegador. Funciona con tu sesión del aula (si no estás logueado te manda al login) y **nunca incluye tu token**: ese queda siempre en tu computadora.
-
-## Cómo instalar
-Necesitás [Node.js](https://nodejs.org) 20 o superior. No hace falta clonar el repo ni instalar nada a mano: `npx` descarga el paquete solo.
-
-### 1. Iniciar sesión
-```bash
-npx -y utn-mcp login
-```
-Te pide tu usuario institucional y tu contraseña de la UTN (los mismos de "Usuarios Institucionales" en el aula virtual). Se hace una sola vez: después el servidor renueva la sesión solo.
-
-### 2. Agregarlo a tu cliente
-
-**Claude Code**
-```bash
-claude mcp add utn -- npx -y utn-mcp
-```
-
-**Claude Desktop**: en *Settings → Developer → Edit Config*, agregá dentro de `mcpServers`:
-```json
-"utn": {
-  "command": "npx",
-  "args": ["-y", "utn-mcp"]
-}
-```
-En Windows, si no arranca, usá `"command": "cmd"` y `"args": ["/c", "npx", "-y", "utn-mcp"]`. Después reiniciá Claude Desktop por completo.
-
-**Codex**
-```bash
-codex mcp add utn -- npx -y utn-mcp
-```
-
-**Gemini CLI**
-```bash
-gemini mcp add utn npx -y utn-mcp
-```
-
-**OpenClaw**
-```bash
-openclaw mcp add utn --command npx --arg -y --arg utn-mcp
-```
-
-**Hermes**: en `~/.hermes/config.yaml`:
-```yaml
-mcp_servers:
-  utn:
-    command: "npx"
-    args: ["-y", "utn-mcp"]
-```
-
-**Cursor**: en `~/.cursor/mcp.json`:
-```json
-{
-  "mcpServers": {
-    "utn": { "command": "npx", "args": ["-y", "utn-mcp"] }
-  }
-}
-```
-
-**VS Code**: en `.vscode/mcp.json` (o con *MCP: Add Server* desde la paleta de comandos):
-```json
-{
-  "servers": {
-    "utn": { "type": "stdio", "command": "npx", "args": ["-y", "utn-mcp"] }
-  }
-}
-```
-
-**ChatGPT**: todavía no. ChatGPT sólo se conecta a servidores MCP remotos por HTTPS, y utn-mcp corre en tu computadora. Va a funcionar con la versión hosteada.
-
-**Otros clientes (Windsurf, opencode, etc.)**: cualquier cliente MCP que lance servidores por STDIO sirve con el comando `npx -y utn-mcp`.
-
-### Instalación global (opcional)
-Si preferís tener el comando `utn-mcp` siempre disponible:
-```bash
-npm i -g utn-mcp
-utn-mcp login
-```
-y en la config del cliente usás `"command": "utn-mcp"` sin argumentos.
-
-### Modo HTTP (opcional)
-Necesita Node 22.13 o más nuevo. Primero, una vez:
-```bash
-npx -y utn-mcp login --http
-```
-Te muestra un token: configurá tu cliente MCP para que mande el header `Authorization: Bearer <token>`. Después:
-```bash
-npx -y utn-mcp --http --port 3000
-```
-Levanta el servidor en `http://127.0.0.1:3000/mcp`, solo accesible desde tu propia máquina. Tenés que dejar la terminal abierta mientras lo uses.
-
-En este modo el servidor no lee archivos de tu disco: para entregar, el agente pide un link con `aula_assign_upload_link` y sube ahí los archivos con `curl` si tiene terminal, o te pasa el link para que los elijas desde el navegador. Si el servidor se publica detrás de otra dirección, definí `UTN_MCP_PUBLIC_URL` para que los links la usen.
-
-## Dónde se guardan tus datos
-Todo queda en tu computadora:
-- **Usuario y contraseña**: en el gestor de credenciales del sistema (Windows Credential Manager, Keychain en macOS, Secret Service en Linux).
-- **Token del aula virtual y cookies de sesión**: en `%APPDATA%\utn-mcp\session.json` (Windows) o `~/.config/utn-mcp/session.json` (Linux y macOS).
-- **En modo HTTP**: la sesión va cifrada en `utn-mcp.db`, en la misma carpeta, con la clave de `store.key` (o la de `UTN_MCP_KEY`). Del token del cliente solo se guarda el hash.
-
-En Linux sin gestor de credenciales (servidores, Docker, WSL) podés definir las variables de entorno `UTN_USER` y `UTN_PASS` en lugar de usar `login`.
-
-## Desarrollo
-```bash
-git clone https://github.com/nialvape/utn-mcp.git
-cd utn-mcp
-npm install
-npm run login   # una vez
-npm run dev     # servidor por STDIO desde src/, con tsx
-npm run build   # compila a build/
-```
-
-pdf.js no es una dependencia del paquete publicado. Está como `devDependency`, y `npm install` corre el script `prepare`, que copia a `vendor/pdfjs/` solo los archivos que usa el servidor (~4 MB). Así, quien instala `utn-mcp` no baja pdf.js entero ni su canvas nativo opcional (~37 MB). Si instalaste con `--ignore-scripts`, generalo a mano con `npm run prepare`.
-
-## Aviso
-Este proyecto no está afiliado ni avalado por la UTN. Usalo bajo tu responsabilidad.
+# UTN-MCP — El puente entre tu agente y los sistemas de la Universidad.
+Este es el Model Context Protocol server NO OFICIAL de la UTN. Con él podrás pedirle a tu agente de preferencia (ChatGPT, Claude, etc.) que busque informacion o archivos en el aula virtual.
+
+## Qué podés pedirle
+- *"¿Cuándo es el recuperatorio del primer parcial de Álgebra?"*
+- *"¿Qué avisó la profesora de Física esta semana?"*
+- *"Resumime la guía de la unidad 3 de Sistemas Operativos."*
+- *"Pasame el link para bajar el apunte de calorimetría."*
+- *"¿Qué nota me pusieron en el TP1 y qué me corrigieron?"*
+- *"Preguntá en el foro de consultas si el parcial incluye la unidad 4."*
+- *"Anotame en el grupo 6."*
+- *"Agendame el recuperatorio del 14 a las 18."*
+
+El agente recorre el aula como lo harías vos: entra al curso, mira los foros y abre los archivos que hagan falta.
+
+## Tools
+| Tool | Qué hace |
+|---|---|
+| `aula_list_courses` | Lista tus cursos. Es el punto de partida. |
+| `aula_open` | Entra a un curso, un módulo, un foro o una discusión. Cada respuesta trae las direcciones de lo que hay adentro y de un nivel más arriba, así el agente navega sin perderse. |
+| `aula_read_file` | Lee un archivo del aula, por partes cuando es largo. |
+| `aula_get_site_info` | Datos de tu usuario en el aula virtual. |
+| `aula_forum_post` | Abre un hilo en un foro o responde en una discusión. |
+| `aula_forum_edit_post` | Edita una publicación tuya. |
+| `aula_forum_delete_post` | Borra una publicación tuya. |
+| `aula_assign_submit` | Entrega una tarea: sube archivos de tu compu, escribe el texto en línea y confirma el envío. |
+| `aula_assign_upload_link` | Solo en modo HTTP: un link para subir los archivos de una entrega, que usa el agente con `curl` o vos desde el navegador. |
+| `aula_choice_answer` | Responde una elección o te anota en un grupo. |
+| `aula_send_message` | Manda un mensaje privado a un docente o compañero. |
+| `aula_calendar_add_event` | Agrega un recordatorio a tu calendario del aula. |
+
+Al abrir una tarea, `aula_open` muestra si la entregaste, cuándo vence y la devolución con la nota. Las tools que escriben le piden al agente que te muestre lo que va a hacer y espere tu confirmación.
+
+### Archivos que puede leer
+- **PDF**: el texto, página por página. Los **escaneados** se mandan como imagen de cada página, y el agente los lee igual.
+- **Word (.docx), PowerPoint (.pptx) y Excel (.xlsx)**: el texto, con las tablas fila por fila.
+- **Imágenes** (PNG, JPG, GIF) y texto plano.
+
+Los formatos viejos de Office (.doc, .ppt, .pps), los comprimidos (.zip, .rar) y los videos no se leen. En ese caso el agente te pasa el link para que lo bajes.
+
+### Links de descarga
+Cada archivo viene con un link del aula virtual que podés abrir en tu navegador. Funciona con tu sesión del aula (si no estás logueado te manda al login) y **nunca incluye tu token**: ese queda siempre en tu computadora.
+
+## Cómo instalar
+Necesitás [Node.js](https://nodejs.org) 20 o superior. No hace falta clonar el repo ni instalar nada a mano: `npx` descarga el paquete solo.
+
+### 1. Iniciar sesión
+```bash
+npx -y utn-mcp login
+```
+Te pide tu usuario institucional y tu contraseña de la UTN (los mismos de "Usuarios Institucionales" en el aula virtual). Se hace una sola vez: después el servidor renueva la sesión solo.
+
+### 2. Agregarlo a tu cliente
+
+**Claude Code**
+```bash
+claude mcp add utn -- npx -y utn-mcp
+```
+
+**Claude Desktop**: en *Settings → Developer → Edit Config*, agregá dentro de `mcpServers`:
+```json
+"utn": {
+  "command": "npx",
+  "args": ["-y", "utn-mcp"]
+}
+```
+En Windows, si no arranca, usá `"command": "cmd"` y `"args": ["/c", "npx", "-y", "utn-mcp"]`. Después reiniciá Claude Desktop por completo.
+
+**Codex**
+```bash
+codex mcp add utn -- npx -y utn-mcp
+```
+
+**Gemini CLI**
+```bash
+gemini mcp add utn npx -y utn-mcp
+```
+
+**OpenClaw**
+```bash
+openclaw mcp add utn --command npx --arg -y --arg utn-mcp
+```
+
+**Hermes**: en `~/.hermes/config.yaml`:
+```yaml
+mcp_servers:
+  utn:
+    command: "npx"
+    args: ["-y", "utn-mcp"]
+```
+
+**Cursor**: en `~/.cursor/mcp.json`:
+```json
+{
+  "mcpServers": {
+    "utn": { "command": "npx", "args": ["-y", "utn-mcp"] }
+  }
+}
+```
+
+**VS Code**: en `.vscode/mcp.json` (o con *MCP: Add Server* desde la paleta de comandos):
+```json
+{
+  "servers": {
+    "utn": { "type": "stdio", "command": "npx", "args": ["-y", "utn-mcp"] }
+  }
+}
+```
+
+**ChatGPT**: todavía no. ChatGPT sólo se conecta a servidores MCP remotos por HTTPS, y utn-mcp corre en tu computadora. Va a funcionar con la versión hosteada.
+
+**Otros clientes (Windsurf, opencode, etc.)**: cualquier cliente MCP que lance servidores por STDIO sirve con el comando `npx -y utn-mcp`.
+
+### Instalación global (opcional)
+Si preferís tener el comando `utn-mcp` siempre disponible:
+```bash
+npm i -g utn-mcp
+utn-mcp login
+```
+y en la config del cliente usás `"command": "utn-mcp"` sin argumentos.
+
+### Modo HTTP (opcional)
+Necesita Node 22.13 o más nuevo. Primero, una vez:
+```bash
+npx -y utn-mcp login --http
+```
+Te muestra un token: configurá tu cliente MCP para que mande el header `Authorization: Bearer <token>`. Después:
+```bash
+npx -y utn-mcp --http --port 3000
+```
+Levanta el servidor en `http://127.0.0.1:3000/mcp`, solo accesible desde tu propia máquina. Tenés que dejar la terminal abierta mientras lo uses.
+
+En este modo el servidor no lee archivos de tu disco: para entregar, el agente pide un link con `aula_assign_upload_link` y sube ahí los archivos con `curl` si tiene terminal, o te pasa el link para que los elijas desde el navegador.
+
+### Hostearlo para otros
+En modo HTTP el servidor también es servidor de autorización OAuth: un cliente MCP (Claude, ChatGPT) que se conecta a `https://tu-dominio/mcp` recibe un 401, descubre el OAuth y abre una página donde el alumno entra con su usuario de la UTN. Ese login vincula su aula: la contraseña se usa una sola vez para sacar el token de Moodle y **no se guarda**. Cuando la sesión del aula vence, el agente le pasa el link de `/login` para renovarla, sin reconectar el cliente.
+
+Quién puede entrar lo decidís vos: con `UTN_MCP_ALLOWED_EMAILS` (una lista), o con `UTN_MCP_ACCESS_URL`, que apunta a un servicio tuyo. El servidor le hace `POST` con `{ "email", "usuario" }` y el header `Authorization: Bearer <UTN_MCP_ACCESS_SECRET>`, y espera `{ "permitido": true }` o `{ "permitido": false, "motivo": "...", "url": "..." }`. Se consulta al conectar y en cada renovación del token (cada hora), así que una baja se aplica sola.
+
+La configuración va en variables de entorno o en un `.env` en la carpeta desde donde lo corrés (copiá [`.env.example`](.env.example)):
+
+| Variable | Para qué | Por defecto |
+|---|---|---|
+| `HOST`, `PORT` | Dónde escucha. | `127.0.0.1`, `3000` |
+| `UTN_MCP_PUBLIC_URL` | Dirección pública (`https://mcp.tu-dominio.com`). Es el issuer del OAuth, la base de los links de subida y el único host, además de localhost, que se acepta en `Host` y `Origin`. | `http://127.0.0.1:<PORT>` |
+| `UTN_MCP_ACCESS_URL`, `UTN_MCP_ACCESS_SECRET` | Servicio que decide quién puede entrar. | — |
+| `UTN_MCP_ALLOWED_EMAILS` | Emails o dominios (`@frba.utn.edu.ar`) habilitados, separados por coma, si no hay `UTN_MCP_ACCESS_URL`. | Entra cualquiera con usuario de la UTN |
+| `UTN_MCP_ADMIN_SECRET` | Habilita `POST /admin/clientes` y `/admin/clientes/revocar`, para que un panel tuyo liste y desconecte las apps de cada usuario (por email). | — |
+| `UTN_MCP_LOGIN_URL` | Página donde el usuario renueva su sesión del aula; el agente se la pasa. | `<UTN_MCP_PUBLIC_URL>/login` |
+| `UTN_MCP_DB`, `UTN_MCP_KEY` | Base de sesiones y su clave de cifrado (32 bytes en base64). | En la carpeta de config |
+
+Con Docker, detrás de un reverse proxy con HTTPS en la misma máquina (red host, para que el rate limit del login vea la IP real):
+```bash
+docker build -t utn-mcp .
+docker run -d --name utn-mcp --network host --restart unless-stopped   -e HOST=127.0.0.1 -e PORT=8100 -e UTN_MCP_PUBLIC_URL=https://tu-dominio   -e UTN_MCP_KEY=$(openssl rand -base64 32) -v utn-mcp-data:/data utn-mcp
+```
+Guardá esa `UTN_MCP_KEY`: sin ella no se pueden descifrar las sesiones guardadas.
+
+## Dónde se guardan tus datos
+Todo queda en tu computadora:
+- **Usuario y contraseña**: en el gestor de credenciales del sistema (Windows Credential Manager, Keychain en macOS, Secret Service en Linux).
+- **Token del aula virtual y cookies de sesión**: en `%APPDATA%\utn-mcp\session.json` (Windows) o `~/.config/utn-mcp/session.json` (Linux y macOS).
+- **En modo HTTP**: la contraseña no se guarda; la sesión va cifrada en `utn-mcp.db`, en la misma carpeta, con la clave de `store.key` (o la de `UTN_MCP_KEY`). Del token del cliente solo se guarda el hash.
+
+En Linux sin gestor de credenciales (servidores, Docker, WSL) podés definir las variables de entorno `UTN_USER` y `UTN_PASS` en lugar de usar `login`.
+
+## Desarrollo
+```bash
+git clone https://github.com/nialvape/utn-mcp.git
+cd utn-mcp
+npm install
+npm run login   # una vez
+npm run dev     # servidor por STDIO desde src/, con tsx
+npm run build   # compila a build/
+```
+
+pdf.js no es una dependencia del paquete publicado. Está como `devDependency`, y `npm install` corre el script `prepare`, que copia a `vendor/pdfjs/` solo los archivos que usa el servidor (~4 MB). Así, quien instala `utn-mcp` no baja pdf.js entero ni su canvas nativo opcional (~37 MB). Si instalaste con `--ignore-scripts`, generalo a mano con `npm run prepare`.
+
+## Aviso
+Este proyecto no está afiliado ni avalado por la UTN. Usalo bajo tu responsabilidad.

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

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

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

@@ -0,0 +1,27 @@
+import { CookieJar } from "tough-cookie";
+import { getOwnUser } from "./client.js";
+import { fetchToken } from "./sso-login.js";
+import { AULA_PLATFORM } from "./stored-session.js";
+/**
+ * Entra al aula con usuario y contraseña, crea el usuario del store si no existe y le guarda la
+ * sesión (token y cookies del SSO). La contraseña se usa solo acá: no se guarda en ningún lado.
+ * Lo usan `utn-mcp login --http` y el login por OAuth de la versión hosteada.
+ */
+export async function linkAulaAccount(store, credentials) {
+    const jar = new CookieJar();
+    const token = await fetchToken(jar, credentials);
+    // El token recién emitido: si falla, no hay con qué renovarlo.
+    const fresh = {
+        getToken: async () => token,
+        refreshToken: async () => {
+            throw new Error("El aula rechazó el token recién emitido.");
+        },
+    };
+    const own = await getOwnUser(fresh);
+    // El de Moodle, en minúscula, igual que en `users`: es con lo que se compara al renovar.
+    const username = own.username.toLowerCase();
+    const userId = await store.findOrCreateUser(username, own.email ?? undefined);
+    const data = { username, token, cookies: await jar.serialize() };
+    await store.saveSession(userId, AULA_PLATFORM, JSON.stringify(data));
+    return { userId, username, email: own.email };
+}

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

@@ -11,10 +11,13 @@ export const AULA_PLATFORM = "aula";
 export class StoredAulaSession {
     store;
     userId;
+    loginUrl;
     refreshing = null;
-    constructor(store, userId) {
+    /** `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;
     }
     async getToken() {
         return (await this.read()).token;
@@ -38,7 +41,7 @@ export class StoredAulaSession {
         }
         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 this.loginRequired("La sesión del aula venció.");
             }
             throw e;
         }
@@ -49,7 +52,14 @@ export class StoredAulaSession {
     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/login.js

@@ -1,11 +1,9 @@
-import { CookieJar } from "tough-cookie";
 import { ask, 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";
 /**
  * `utn-mcp login`: pide usuario y contraseña una vez, los guarda en el keychain
  * y obtiene el primer token. Después el servidor renueva solo.
@@ -39,12 +37,7 @@ export async function runLogin(http) {
 }
 /** 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);
     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, credentials);
     return store.issueToken(userId, { kind: "access", clientId: "local" });
 }

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 { 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,31 @@ 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, 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");
+    // 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,
+    });
+    if (adminSecret)
+        mountAdmin(app, store, adminSecret);
     const requireToken = async (req, res, next) => {
         try {
             // toNodeHandler le pasa `req.auth` al handler como `authInfo`.
@@ -48,27 +72,27 @@ 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()));
     // Sin express.json(): el handler lee el body por su cuenta.
-    app.all("/mcp", requireToken, toNodeHandler(handler));
+    app.all("/mcp", sameOrigin, 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));
         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. */
@@ -124,14 +148,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,36 @@
 #!/usr/bin/env node
+import { existsSync } from "node:fs";
 import { parseArgs } from "node:util";
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
 import { LocalSession } from "./aula-virtual/client/local-session.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 { 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 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`;
+const USAGE = `Uso:
+  utn-mcp                 servidor MCP por STDIO (lo lanza el cliente)
+  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
+
+Si hay un .env en la carpeta actual, se lee al arrancar (ver .env.example).`;
+/** Lee el `.env` de la carpeta actual, si hay. Lo que ya está definido en el entorno no se pisa. */
+function loadDotenv() {
+    if (existsSync(".env"))
+        process.loadEnvFile(".env");
+}
 async function main() {
+    loadDotenv();
     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 },
         },
@@ -35,13 +47,25 @@ 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) });
+        };
+        const options = {
+            host: values.host,
+            port,
+            publicUrl,
+            access: accessPolicyFromEnv(),
+            adminSecret: process.env.UTN_MCP_ADMIN_SECRET || undefined,
         };
-        startHttpServer(factory, port, store, inbox);
+        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 }`; 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 ({ 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 }),
+                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." };
+        }
+    };
+}

package/build/oauth/admin.js

@@ -0,0 +1,48 @@
+import { timingSafeEqual } from "node:crypto";
+import express from "express";
+import { AULA_PLATFORM } from "../aula-virtual/client/stored-session.js";
+/**
+ * API para que otro servicio del que hostea (un panel de cuenta, por ejemplo) muestre y desconecte las
+ * apps de un usuario. Solo existe con UTN_MCP_ADMIN_SECRET, que va como `Authorization: Bearer`.
+ * Los usuarios se buscan por email institucional.
+ */
+export function mountAdmin(app, store, secret) {
+    const json = express.json({ limit: "4kb" });
+    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." });
+    };
+    /** `{ email }` → el usuario, cuándo se renovó su sesión del aula y sus apps conectadas. */
+    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;
+        if (!user)
+            return void res.json({ clientes: [] });
+        const [clients, aulaAt] = await Promise.all([
+            store.listConnectedClients(user.id),
+            store.sessionUpdatedAt(user.id, AULA_PLATFORM),
+        ]);
+        res.json({
+            usuario: user.utnUsername,
+            sesionAula: aulaAt ? new Date(aulaAt * 1000).toISOString() : undefined,
+            clientes: clients.map((c) => ({
+                id: c.clientId,
+                nombre: c.clientName ?? (c.clientId === "local" ? "Token de utn-mcp login" : "App sin nombre"),
+                ultimoUso: new Date(c.lastTokenAt * 1000).toISOString(),
+            })),
+        });
+    });
+    /** `{ 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 });
+    });
+}

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/server.js

@@ -0,0 +1,272 @@
+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 { 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";
+/** 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;
+/** Esquemas de redirect_uri que nunca aceptamos. */
+const FORBIDDEN_SCHEMES = new Set(["javascript:", "data:", "file:", "vbscript:"]);
+/**
+ * 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 }) {
+    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 form = express.urlencoded({ extended: false, limit: "16kb" });
+    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) => {
+        const body = (req.body ?? {});
+        const uris = Array.isArray(body.redirect_uris) ? body.redirect_uris : [];
+        if (!uris.length || !uris.every(isAllowedRedirect)) {
+            return void oauthError(res, 400, "invalid_redirect_uri", "Mandá al menos una redirect_uri válida.");
+        }
+        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 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,
+            codeChallenge: q.code_challenge,
+            state: q.state,
+            resource: q.resource,
+        });
+        res.type("html").send(loginPage({ action: "/authorize", pendingId: id, clientName: client.clientName }));
+    });
+    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 retry = (error) => res.type("html").send(loginPage({ action: "/authorize", pendingId: id, clientName: request.clientName, error }));
+        const account = await login(req, retry);
+        if (!account)
+            return;
+        const decision = await access({ 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} 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({ 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", (_req, res) => void res.type("html").send(loginPage({ action: "/login" })));
+    app.post("/login", sameOrigin, form, async (req, res) => {
+        const account = await login(req, (error) => res.type("html").send(loginPage({ action: "/login", error })));
+        if (!account)
+            return;
+        logger.info(`OAuth: ${account.username} 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, 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;
+        }
+        try {
+            return await linkAulaAccount(store, { username, password });
+        }
+        catch (e) {
+            if (e instanceof InvalidCredentialsError)
+                retry("La UTN rechazó el usuario o la contraseña.");
+            else {
+                logger.error(`Login de ${username}: ${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");
+/** HTTPS, http solo en loopback (clientes de escritorio) o un esquema propio de una app (`cursor://`). */
+function isAllowedRedirect(uri) {
+    if (typeof uri !== "string")
+        return false;
+    try {
+        const url = new URL(uri);
+        if (FORBIDDEN_SCHEMES.has(url.protocol) || url.hash)
+            return false;
+        if (url.protocol === "http:")
+            return ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Los endpoints que llaman los clientes desde el navegador (como el MCP Inspector) aceptan cualquier origen. */
+const cors = (_req, res, next) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "content-type, authorization, mcp-protocol-version");
+    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 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.</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)}">` : "";
+    return page("Entrar con la UTN", intro +
+        error +
+        `<form method="post" action="${o.action}">${hidden}` +
+        `<label>Usuario<input name="usuario" autocomplete="username" autocapitalize="none" required></label>` +
+        `<label>Contraseña<input name="contrasena" type="password" autocomplete="current-password" required></label>` +
+        `<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.7.0",
     });
     registerAulaVirtualTools(server, aula, files);
     return server;

package/build/shared/pages.js

@@ -0,0 +1,61 @@
+/**
+ * Los colores del sitio del proyecto: papel milimetrado, tinta y un azul de acento. Oscuro salvo que
+ * el sistema pida claro. Sin fuentes externas: la página de login recibe contraseñas.
+ */
+const STYLE = `
+:root{--paper:#0a0b0d;--ink:#e9e7e0;--muted:#8b8a84;--line:rgb(233 231 224/.055);--line-faint:rgb(233 231 224/.025);
+--line-strong:rgb(233 231 224/.16);--accent:#6b93ff;--err:#f87171;--panel:rgb(20 21 24/.6);color-scheme:dark}
+@media(prefers-color-scheme:light){:root{--paper:#f3f2ec;--ink:#121212;--muted:#6d6c66;--line:rgb(18 18 18/.07);
+--line-faint:rgb(18 18 18/.035);--line-strong:rgb(18 18 18/.2);--accent:#1f4fd6;--err:#b91c1c;--panel:rgb(255 255 255/.55);color-scheme:light}}
+*{box-sizing:border-box}
+body{margin:0;min-height:100vh;color:var(--ink);font:15px/1.55 ui-sans-serif,system-ui,-apple-system,"Segoe UI",sans-serif;
+background-color:var(--paper);background-image:linear-gradient(var(--line) 1px,transparent 1px),
+linear-gradient(90deg,var(--line) 1px,transparent 1px),linear-gradient(var(--line-faint) 1px,transparent 1px),
+linear-gradient(90deg,var(--line-faint) 1px,transparent 1px);background-size:80px 80px,80px 80px,16px 16px,16px 16px;
+background-position:-1px -1px}
+.mono,label,button,.kicker,header{font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace}
+header{display:flex;align-items:center;gap:.5rem;height:3.5rem;padding:0 1rem;border-bottom:1px solid var(--line);
+font-size:13px;letter-spacing:-.01em;background:color-mix(in srgb,var(--paper) 75%,transparent)}
+header svg{height:1.5rem;width:auto}
+main{max-width:28rem;margin:3rem auto;padding:0 1rem}
+.card{position:relative;border:1px solid var(--line-strong);background:var(--panel);padding:1.5rem}
+.card::before,.card::after{content:"";position:absolute;width:9px;height:9px;border-color:var(--ink);opacity:.55}
+.card::before{top:-1px;left:-1px;border-top:1px solid;border-left:1px solid}
+.card::after{bottom:-1px;right:-1px;border-bottom:1px solid;border-right:1px solid}
+.kicker{margin:0 0 .5rem;font-size:10px;text-transform:uppercase;letter-spacing:.16em;color:var(--muted)}
+h1{margin:0 0 1rem;font-size:1.5rem;font-weight:600;letter-spacing:-.02em;line-height:1.2}
+p{margin:.75rem 0}
+a{color:var(--accent);text-underline-offset:4px}
+form{display:flex;flex-direction:column;gap:1rem;margin:1.5rem 0}
+label{display:flex;flex-direction:column;gap:.4rem;font-size:10px;text-transform:uppercase;letter-spacing:.16em;color:var(--muted)}
+input{font:inherit;font-size:15px;letter-spacing:normal;text-transform:none;color:var(--ink);background:transparent;
+border:1px solid var(--line-strong);border-radius:0;padding:.65rem .75rem}
+input:focus{outline:none;border-color:var(--accent)}
+input[type=file]{padding:.5rem}
+button{font-size:12px;text-transform:uppercase;letter-spacing:.14em;border:0;border-radius:0;padding:.8rem 1rem;
+background:var(--ink);color:var(--paper);cursor:pointer;transition:background .15s}
+button:hover{background:var(--accent)}
+.nota{font-size:13px;color:var(--muted)}
+.error{border-left:2px solid var(--err);padding-left:.75rem;color:var(--err)}
+ul{padding-left:1.2rem}
+::selection{background:var(--accent);color:var(--paper)}
+`.replace(/\n/g, "");
+/** El emblema del proyecto: el de la UTN con "MCP" en lugar de "UTN". */
+const MARK = '<svg viewBox="0 0 100 132" fill="none" aria-hidden="true"><g stroke="currentColor" stroke-width="11">' +
+    '<path d="M50 0v100M0 50h100"/><path d="M19 0v19a11 11 0 0 0 11 11h40a11 11 0 0 0 11-11V0"/>' +
+    '<path d="M19 100V81a11 11 0 0 1 11-11h40a11 11 0 0 1 11 11v19"/></g>' +
+    '<text x="50" y="131" text-anchor="middle" textLength="72" lengthAdjust="spacingAndGlyphs" ' +
+    'font-family="Arial,Helvetica,sans-serif" font-weight="900" font-size="29" fill="currentColor">MCP</text></svg>';
+/**
+ * Página mínima con el estilo del sitio del proyecto: se abre desde el celu, así que nada más que lo necesario.
+ * `kicker` es la etiqueta chica arriba del título.
+ */
+export function page(title, body, kicker = "UTN-MCP") {
+    return (`<!doctype html><html lang="es"><head><meta charset="utf-8">` +
+        `<meta name="viewport" content="width=device-width, initial-scale=1"><title>${escapeHtml(title)} · UTN-MCP</title>` +
+        `<style>${STYLE}</style></head><body>` +
+        `<header>${MARK}utn·mcp</header>` +
+        `<main><div class="card"><p class="kicker">${escapeHtml(kicker)}</p><h1>${escapeHtml(title)}</h1>${body}</div></main>` +
+        `</body></html>`);
+}
+export const escapeHtml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");

package/build/shared/store/sqlite-store.js

@@ -2,28 +2,35 @@ import { createCipheriv, createDecipheriv, createHash, randomBytes } from "node:
 import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { storeFile, storeKeyFile } from "../paths.js";
-const SCHEMA = `
-    CREATE TABLE IF NOT EXISTS users (
-        id INTEGER PRIMARY KEY,
-        utn_username TEXT NOT NULL UNIQUE,
-        created_at INTEGER NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS tokens (
-        hash TEXT PRIMARY KEY,
-        user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
-        kind TEXT NOT NULL CHECK (kind IN ('access', 'refresh')),
-        client_id TEXT,
-        expires_at INTEGER,
-        created_at INTEGER NOT NULL
-    );
-    CREATE INDEX IF NOT EXISTS tokens_user ON tokens(user_id);
-    CREATE TABLE IF NOT EXISTS platform_sessions (
-        user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
-        platform TEXT NOT NULL,
-        data BLOB NOT NULL,
-        updated_at INTEGER NOT NULL,
-        PRIMARY KEY (user_id, platform)
-    );
+const SCHEMA = `
+    CREATE TABLE IF NOT EXISTS users (
+        id INTEGER PRIMARY KEY,
+        utn_username TEXT NOT NULL UNIQUE,
+        email TEXT,
+        created_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS tokens (
+        hash TEXT PRIMARY KEY,
+        user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+        kind TEXT NOT NULL CHECK (kind IN ('access', 'refresh')),
+        client_id TEXT,
+        expires_at INTEGER,
+        created_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS tokens_user ON tokens(user_id);
+    CREATE TABLE IF NOT EXISTS platform_sessions (
+        user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+        platform TEXT NOT NULL,
+        data BLOB NOT NULL,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (user_id, platform)
+    );
+    CREATE TABLE IF NOT EXISTS oauth_clients (
+        client_id TEXT PRIMARY KEY,
+        client_name TEXT,
+        redirect_uris TEXT NOT NULL,
+        created_at INTEGER NOT NULL
+    );
 `;
 /** Bytes de la clave AES-256. */
 const KEY_BYTES = 32;
@@ -59,16 +66,28 @@ export class SqliteStore {
         // WAL: el login escribe mientras el servidor lee, desde otro proceso.
         db.exec("PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON; PRAGMA busy_timeout = 5000;");
         db.exec(SCHEMA);
+        migrate(db);
         return new SqliteStore(db, await loadKey());
     }
-    async findOrCreateUser(utnUsername) {
+    async findOrCreateUser(utnUsername, email) {
         const username = utnUsername.trim().toLowerCase();
         this.db
             .prepare("INSERT INTO users (utn_username, created_at) VALUES (?, ?) ON CONFLICT DO NOTHING")
             .run(username, now());
+        if (email) {
+            this.db.prepare("UPDATE users SET email = ? WHERE utn_username = ?").run(email.trim().toLowerCase(), username);
+        }
         const row = this.db.prepare("SELECT id FROM users WHERE utn_username = ?").get(username);
         return row.id;
     }
+    async findUserByEmail(email) {
+        const row = this.db.prepare("SELECT id, utn_username, email FROM users WHERE email = ?").get(email.trim().toLowerCase());
+        return row ? { id: row.id, utnUsername: row.utn_username, email: row.email } : null;
+    }
+    async findUser(userId) {
+        const row = this.db.prepare("SELECT id, utn_username, email FROM users WHERE id = ?").get(userId);
+        return row ? { id: row.id, utnUsername: row.utn_username, email: row.email } : null;
+    }
     async issueToken(userId, options) {
         const token = randomBytes(32).toString("base64url");
         const createdAt = now();
@@ -99,6 +118,37 @@ export class SqliteStore {
             "ON CONFLICT (user_id, platform) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at")
             .run(userId, platform, this.encrypt(data), now());
     }
+    async saveClient(client) {
+        this.db
+            .prepare("INSERT INTO oauth_clients (client_id, client_name, redirect_uris, created_at) VALUES (?, ?, ?, ?)")
+            .run(client.clientId, client.clientName, JSON.stringify(client.redirectUris), now());
+    }
+    async findClient(clientId) {
+        const row = this.db
+            .prepare("SELECT client_id, client_name, redirect_uris FROM oauth_clients WHERE client_id = ?")
+            .get(clientId);
+        if (!row)
+            return null;
+        return { clientId: row.client_id, clientName: row.client_name, redirectUris: JSON.parse(row.redirect_uris) };
+    }
+    async sessionUpdatedAt(userId, platform) {
+        const row = this.db
+            .prepare("SELECT updated_at FROM platform_sessions WHERE user_id = ? AND platform = ?")
+            .get(userId, platform);
+        return row?.updated_at ?? null;
+    }
+    async listConnectedClients(userId) {
+        const rows = this.db
+            .prepare("SELECT t.client_id, c.client_name, MAX(t.created_at) AS last_token_at FROM tokens t " +
+            "LEFT JOIN oauth_clients c ON c.client_id = t.client_id " +
+            "WHERE t.user_id = ? AND t.client_id IS NOT NULL AND (t.expires_at IS NULL OR t.expires_at > ?) " +
+            "GROUP BY t.client_id ORDER BY last_token_at DESC")
+            .all(userId, now());
+        return rows.map((r) => ({ clientId: r.client_id, clientName: r.client_name, lastTokenAt: r.last_token_at }));
+    }
+    async revokeClient(userId, clientId) {
+        this.db.prepare("DELETE FROM tokens WHERE user_id = ? AND client_id = ?").run(userId, clientId);
+    }
     /** iv + tag + texto cifrado, en un solo blob. */
     encrypt(plain) {
         const iv = randomBytes(IV_BYTES);
@@ -118,6 +168,12 @@ export class SqliteStore {
         }
     }
 }
+/** Lo que `CREATE TABLE IF NOT EXISTS` no agrega a una base que ya existía. */
+function migrate(db) {
+    const columns = db.prepare("PRAGMA table_info(users)").all();
+    if (!columns.some((c) => c.name === "email"))
+        db.exec("ALTER TABLE users ADD COLUMN email TEXT");
+}
 /**
  * UTN_MCP_KEY (32 bytes en base64) en el servidor hosteado, donde la clave no tiene que estar en el
  * mismo disco que la base. En local, si no está, se genera una en la carpeta de configuración.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "utn-mcp",
-  "version": "0.6.9",
+  "version": "0.7.0",
   "description": "Este es el Model Context Protocol server NO OFICIAL de la UTN para buscar informacion o archivos en el aula virtual.",
   "main": "build/index.js",
   "bin": {