utn-mcp 0.6.7 → 0.7.0

package/README.md

@@ -1,146 +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_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)
-```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.
-
-## 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 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 });
@@ -73,6 +82,52 @@ export async function getAssignments(session, courseId) {
 export function getSubmissionStatus(session, assignid) {
     return callWs(session, "mod_assign_get_submission_status", { assignid });
 }
+/** Un borrador vacío: el `itemid` que se manda para dejar un área sin archivos. */
+export async function getUnusedDraftItemId(session) {
+    const { itemid } = await callWs(session, "core_files_get_unused_draft_itemid");
+    return itemid;
+}
+/** Moodle no tira excepción cuando no guarda o no envía: lo dice en `warnings`. */
+function throwOnWarnings(warnings, fallback) {
+    if (warnings?.length)
+        throw new MoodleError(warnings.map((w) => w.message).join(" ") || fallback);
+}
+/**
+ * Guarda la entrega. Cada plugin habilitado reemplaza lo que tenía con lo que se le pasa: el de
+ * archivos toma el borrador `filesItemId` entero y el de texto, `text`.
+ */
+export async function saveSubmission(session, assignmentid, data) {
+    const params = { assignmentid };
+    if (data.filesItemId !== undefined)
+        params["plugindata[files_filemanager]"] = data.filesItemId;
+    if (data.text) {
+        params["plugindata[onlinetext_editor][text]"] = data.text.html;
+        params["plugindata[onlinetext_editor][format]"] = data.text.format;
+        params["plugindata[onlinetext_editor][itemid]"] = data.text.itemid;
+    }
+    const warnings = await callWs(session, "mod_assign_save_submission", params);
+    throwOnWarnings(warnings, "Moodle no guardó la entrega.");
+}
+/** Confirma el envío de un borrador. Después ya no se puede editar. */
+export async function submitForGrading(session, assignmentid, acceptStatement) {
+    const warnings = await callWs(session, "mod_assign_submit_for_grading", {
+        assignmentid,
+        acceptsubmissionstatement: acceptStatement ? 1 : 0,
+    });
+    throwOnWarnings(warnings, "Moodle no envió la entrega.");
+}
+/**
+ * Vacía la entrega del usuario (o la de su grupo). Es la única forma de dejarla sin nada:
+ * mod_assign_save_submission rechaza una entrega vacía.
+ */
+export async function removeSubmission(session, assignid) {
+    const { userid } = await getSiteInfo(session);
+    const warnings = await callWs(session, "mod_assign_remove_submission", {
+        userid,
+        assignid,
+    });
+    throwOnWarnings(warnings, "Moodle no quitó la entrega.");
+}
 // --- Elecciones (choice) y selección de grupos (choicegroup) ---
 export async function getChoices(session, courseId) {
     const { choices } = await callWs(session, "mod_choice_get_choices_by_courses", {

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/moodle-api.js

@@ -1,6 +1,7 @@
 import { postForm } from "../../shared/http.js";
 import { AULA_BASE_URL } from "./constants.js";
 const WS_URL = `${AULA_BASE_URL}/webservice/rest/server.php`;
+const UPLOAD_URL = `${AULA_BASE_URL}/webservice/upload.php`;
 const TOKEN_ERRORS = new Set(["invalidtoken", "expiredtoken"]);
 export class MoodleError extends Error {
     errorcode;
@@ -60,6 +61,39 @@ export async function fetchFile(session, url, maxBytes) {
         return { bytes: await readWithLimit(res, maxBytes), contentType };
     }
 }
+/**
+ * Sube archivos al área de borrador del usuario por `webservice/upload.php` y devuelve su `itemid`,
+ * que es lo que piden las funciones que guardan archivos. Todos quedan en el mismo borrador.
+ */
+export async function uploadDraftFiles(session, files) {
+    let token = await session.getToken();
+    for (let attempt = 0;; attempt++) {
+        const form = new FormData();
+        form.set("token", token);
+        form.set("filearea", "draft");
+        form.set("itemid", "0");
+        files.forEach((f, i) => form.set(`file_${i + 1}`, new Blob([new Uint8Array(f.bytes)]), f.name));
+        let res;
+        try {
+            res = await fetch(UPLOAD_URL, { method: "POST", body: form, signal: AbortSignal.timeout(120_000) });
+        }
+        catch (e) {
+            throw new MoodleError(`No se pudo subir el archivo: ${e.message}`);
+        }
+        if (!res.ok)
+            throw new MoodleError(`HTTP ${res.status} al subir el archivo`);
+        // Si sale bien, un registro por archivo; si no, `{ error, errorcode }`.
+        const data = (await res.json());
+        if (Array.isArray(data) && data[0])
+            return data[0].itemid;
+        const err = Array.isArray(data) ? {} : data;
+        if (attempt === 0 && err.errorcode && TOKEN_ERRORS.has(err.errorcode)) {
+            token = await session.refreshToken();
+            continue;
+        }
+        throw new MoodleError(err.error ?? "Moodle no aceptó el archivo.", err.errorcode);
+    }
+}
 /** Lee el cuerpo cortando apenas pasa el límite, sin esperar a bajarlo entero. */
 async function readWithLimit(res, maxBytes) {
     const tooBig = `El archivo pesa más de ${Math.round(maxBytes / 1024 / 1024)} MB; es demasiado para leerlo.`;

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

@@ -1,2 +1 @@
-// para version hosteada y multiples usuarios/sesiones
 export {};

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

@@ -0,0 +1,65 @@
+import { CookieJar } from "tough-cookie";
+import { loadCredentials } from "./credentials.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.
+ */
+export class StoredAulaSession {
+    store;
+    userId;
+    loginUrl;
+    refreshing = 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;
+    }
+    async getToken() {
+        return (await this.read()).token;
+    }
+    refreshToken() {
+        this.refreshing ??= this.renew().finally(() => {
+            this.refreshing = null;
+        });
+        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 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 this.loginRequired("La sesión del aula venció.");
+            }
+            throw e;
+        }
+        const data = { ...stored, token, cookies: await jar.serialize() };
+        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 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/activities.js

@@ -45,6 +45,7 @@ export async function viewSubmission(session, courseId, module) {
         // Con borradores, lo subido no cuenta hasta confirmar el envío.
         requiereConfirmarEnvio: assignment?.submissiondrafts === 1 || undefined,
         requiereDeclaracion: assignment?.requiresubmissionstatement === 1 || undefined,
+        declaracion: (assignment?.requiresubmissionstatement === 1 && htmlToText(assignment.submissionstatement)) || undefined,
         puedeEditar: attempt?.canedit ?? false,
         puedeEnviar: attempt?.cansubmit || undefined,
         bloqueada: attempt?.locked || undefined,