utn-mcp 0.6.7 → 0.6.9

package/README.md

@@ -23,6 +23,8 @@ El agente recorre el aula como lo harías vos: entra al curso, mira los foros y
 | `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. |
@@ -118,15 +120,23 @@ 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`.
 

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

@@ -73,6 +73,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/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,55 @@
+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;
+    refreshing = null;
+    constructor(store, userId) {
+        this.store = store;
+        this.userId = userId;
+    }
+    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 new LoginRequiredError("La sesión del aula venció: volvé a iniciar sesión (`utn-mcp login --http`).");
+            }
+            throw e;
+        }
+        const data = { ...stored, token, cookies: await jar.serialize() };
+        await this.store.saveSession(this.userId, AULA_PLATFORM, JSON.stringify(data));
+        return token;
+    }
+    async read() {
+        const raw = await this.store.loadSession(this.userId, AULA_PLATFORM);
+        if (!raw)
+            throw new LoginRequiredError("No hay sesión del aula para este usuario: corré `utn-mcp login --http`.");
+        return JSON.parse(raw);
+    }
+}

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,

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

@@ -0,0 +1,214 @@
+import { readFile, stat } from "node:fs/promises";
+import { basename, isAbsolute } from "node:path";
+import { htmlToText, textToHtml } from "../../shared/html.js";
+import { checkFiles, formatSize, } from "../../shared/uploads.js";
+import { getAssignments, getSubmissionStatus, getUnusedDraftItemId, removeSubmission, saveSubmission, submitForGrading, } from "../client/client.js";
+import { fetchFile, uploadDraftFiles } from "../client/moodle-api.js";
+import { viewSubmission } from "./activities.js";
+import { parseAddress } from "./address.js";
+import { userFacingUrl } from "./files.js";
+import { findModule } from "./navigate.js";
+/** El máximo por archivo que deja subir el aula (`usermaxuploadfilesize` del sitio, 20 MB). */
+const SITE_MAX_BYTES = 20 * 1024 * 1024;
+/** La tarea con su configuración y el intento actual del usuario, o un error que dice por qué no. */
+async function openAssignment(session, rawAddress) {
+    const address = parseAddress(rawAddress);
+    if (address.level !== "module")
+        throw new Error(`"${rawAddress}" no es la dirección de un módulo.`);
+    const { module } = await findModule(session, address.courseId, address.cmid);
+    if (module.modname !== "assign") {
+        throw new Error(`"${rawAddress}" es un módulo de tipo ${module.modname}; solo se entregan tareas (assign).`);
+    }
+    const [assignments, status] = await Promise.all([
+        getAssignments(session, address.courseId),
+        getSubmissionStatus(session, module.instance),
+    ]);
+    const assignment = assignments.find((a) => a.cmid === module.id);
+    const attempt = status.lastattempt;
+    if (!assignment || !attempt)
+        throw new Error(`No se pudo leer la configuración de la tarea ${rawAddress}.`);
+    const config = (plugin, name) => assignment.configs.find((c) => c.subtype === "assignsubmission" && c.plugin === plugin && c.name === name)
+        ?.value;
+    const limits = {
+        maxFiles: Number(config("file", "maxfilesubmissions")) || undefined,
+        maxBytes: Number(config("file", "maxsubmissionsizebytes")) || SITE_MAX_BYTES,
+        extensions: extensions(config("file", "filetypeslist") || ""),
+    };
+    return {
+        address,
+        module,
+        assignment,
+        attempt,
+        config,
+        limits,
+        acceptsFiles: config("file", "enabled") === "1",
+        acceptsText: config("onlinetext", "enabled") === "1",
+        submission: attempt.teamsubmission ?? attempt.submission,
+    };
+}
+const CLOSED = "La tarea no acepta cambios: ya está enviada, venció, está bloqueada o todavía no abre. " +
+    "Abrila con aula_open para ver el estado y las fechas.";
+/** Abre un link para recibir los archivos de una entrega en modo HTTP, con los límites de la tarea. */
+export async function createUploadLink(session, rawAddress, inbox, owner) {
+    const { module, attempt, acceptsFiles, limits } = await openAssignment(session, rawAddress);
+    if (!acceptsFiles)
+        throw new Error("Esta tarea no acepta archivos.");
+    if (!attempt.canedit)
+        throw new Error(CLOSED);
+    const { id, url, expiresAt } = inbox.open(owner, `Entrega: ${module.name}`, limits);
+    return {
+        subida: id,
+        url,
+        vence: expiresAt,
+        acepta: {
+            maximo: limits.maxFiles,
+            tamanioMaximo: limits.maxBytes,
+            extensiones: limits.extensions?.join(", "),
+        },
+        conTerminal: `curl -F "archivos=@/ruta/al/archivo.pdf" ${url}`,
+    };
+}
+/**
+ * Deja la entrega con los archivos y el texto pedidos, y la envía si hace falta. Lo que no se pasa
+ * se conserva: Moodle reemplaza cada plugin con lo que recibe, así que se le reenvía lo que ya tenía.
+ */
+export async function submitAssignment(session, rawAddress, request, source) {
+    const { address, module, assignment, attempt, config, limits, acceptsFiles, acceptsText, submission } = await openAssignment(session, rawAddress);
+    const usesDrafts = assignment.submissiondrafts === 1;
+    const fileChanges = request.files !== undefined || request.upload !== undefined;
+    const changes = fileChanges || request.text !== undefined;
+    // Todo lo que se puede validar va antes de tocar nada, para no dejar la entrega a medias.
+    if (!changes && !(usesDrafts && request.send)) {
+        throw new Error("Pasá archivos, `texto` o los dos: no hay nada para entregar.");
+    }
+    if (changes && !attempt.canedit)
+        throw new Error(CLOSED);
+    if (fileChanges && !acceptsFiles)
+        throw new Error("Esta tarea no acepta archivos.");
+    if (request.text !== undefined && !acceptsText)
+        throw new Error("Esta tarea no acepta texto en línea.");
+    const confirm = usesDrafts && request.send;
+    if (confirm && assignment.requiresubmissionstatement === 1 && !request.acceptStatement) {
+        throw new Error("Para enviarla hay que aceptar esta declaración: «" +
+            htmlToText(assignment.submissionstatement) +
+            "». Mostrásela al usuario y, si la acepta, volvé a llamar con `aceptoDeclaracion: true`.");
+    }
+    if (changes) {
+        const files = acceptsFiles ? await collectFiles(session, request, submittedFiles(submission), source) : [];
+        checkFiles(files, limits);
+        const text = acceptsText
+            ? currentOrNewText(submission, request.text, Number(config("onlinetext", "wordlimit")))
+            : null;
+        if (!files.length && !htmlToText(text?.html)) {
+            await removeSubmission(session, assignment.id);
+        }
+        else {
+            await saveSubmission(session, assignment.id, {
+                filesItemId: acceptsFiles
+                    ? files.length
+                        ? await uploadDraftFiles(session, files)
+                        : await getUnusedDraftItemId(session)
+                    : undefined,
+                text: text ? { ...text, itemid: await getUnusedDraftItemId(session) } : undefined,
+            });
+        }
+        if (request.upload && !source.local)
+            source.inbox.close(request.upload);
+    }
+    if (confirm)
+        await submitForGrading(session, assignment.id, request.acceptStatement);
+    const after = await viewSubmission(session, address.courseId, module);
+    return {
+        direccion: rawAddress,
+        estado: after.estado,
+        // Con borradores y sin confirmar, lo subido no cuenta todavía.
+        aviso: usesDrafts && !request.send && after.estado === "borrador"
+            ? "Quedó como borrador: no cuenta como entregada hasta confirmar el envío."
+            : undefined,
+        archivos: after.archivos?.map(({ nombre, tamanio, url }) => ({ nombre, tamanio, url })),
+        texto: after.texto,
+    };
+}
+function submittedFiles(submission) {
+    return (submission?.plugins ?? [])
+        .filter((p) => p.type === "file")
+        .flatMap((p) => p.fileareas?.flatMap((a) => a.files ?? []) ?? []);
+}
+/**
+ * Junta los bytes de la lista final: los de `files` (o los que ya estaban, si no se pasa) más los de
+ * la subida. Los que ya estaban hay que volver a subirlos porque el borrador reemplaza el área entera.
+ */
+async function collectFiles(session, request, current, source) {
+    const entries = request.files ?? current.map((f) => userFacingUrl(f.fileurl));
+    const collected = [];
+    for (const entry of entries) {
+        const existing = current.find((f) => userFacingUrl(f.fileurl) === entry || f.fileurl === entry);
+        collected.push(existing
+            ? {
+                name: existing.filename,
+                bytes: (await fetchFile(session, new URL(existing.fileurl), SITE_MAX_BYTES)).bytes,
+            }
+            : await readLocal(entry, source));
+    }
+    if (request.upload !== undefined) {
+        if (source.local)
+            throw new Error("`subida` es del modo HTTP; acá los archivos van como ruta en `archivos`.");
+        collected.push(...source.inbox.take(request.upload, source.owner));
+    }
+    return collected;
+}
+async function readLocal(path, source) {
+    if (/^https?:\/\//i.test(path)) {
+        throw new Error(`"${path}" no es un archivo de esta entrega. Las URLs sirven solo para conservar archivos ` +
+            "que ya están subidos (las `url` de `entrega.archivos` en aula_open).");
+    }
+    if (!source.local) {
+        throw new Error(`"${path}" no es un archivo de esta entrega, y este servidor no lee archivos de tu dispositivo: ` +
+            "los nuevos se suben con aula_assign_upload_link y se pasan con `subida`.");
+    }
+    if (!isAbsolute(path))
+        throw new Error(`Pasá la ruta absoluta del archivo; "${path}" es relativa.`);
+    let size;
+    try {
+        const info = await stat(path);
+        if (!info.isFile())
+            throw new Error(`"${path}" no es un archivo.`);
+        size = info.size;
+    }
+    catch (e) {
+        if (e.code === "ENOENT")
+            throw new Error(`No existe el archivo "${path}".`);
+        throw e;
+    }
+    // El límite de la tarea lo chequea checkFiles; esto solo evita cargar en memoria algo que no puede entrar.
+    if (size > SITE_MAX_BYTES) {
+        throw new Error(`"${basename(path)}" pesa ${formatSize(size)} y el aula acepta hasta ${formatSize(SITE_MAX_BYTES)} por archivo.`);
+    }
+    return { name: basename(path), bytes: new Uint8Array(await readFile(path)) };
+}
+/**
+ * Moodle valida los tipos en el formulario web, no en el web service: si no lo chequeamos, un .docx
+ * entra en una tarea que pide PDF. Los grupos de tipos ("document", "image") no se pueden resolver
+ * sin la tabla de Moodle, así que con un grupo en la lista no se restringe.
+ */
+function extensions(types) {
+    const list = types
+        .split(/[\s,;]+/)
+        .map((t) => t.trim().toLowerCase())
+        .filter(Boolean);
+    return list.length && list.every((t) => t.startsWith(".")) ? list : undefined;
+}
+/** El texto nuevo en HTML, o el que ya estaba para no borrarlo al guardar solo archivos. */
+function currentOrNewText(submission, text, wordLimit) {
+    if (text === undefined) {
+        const field = submission?.plugins
+            ?.find((p) => p.type === "onlinetext")
+            ?.editorfields?.find((e) => e.name === "onlinetext");
+        return { html: field?.text ?? "", format: field?.format ?? 1 };
+    }
+    const words = text.split(/\s+/).filter(Boolean).length;
+    if (wordLimit && words > wordLimit) {
+        throw new Error(`El texto tiene ${words} palabras y la tarea acepta hasta ${wordLimit}.`);
+    }
+    return { html: text.trim() ? textToHtml(text) : "", format: 1 };
+}

package/build/aula-virtual/login.js

@@ -1,18 +1,27 @@
+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 { 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.
+ * Con `--http` guarda la sesión en el store y emite el token para el cliente MCP.
  */
-export async function runLogin() {
-    const username = await ask("Usuario institucional de la UTN: ");
+export async function runLogin(http) {
+    const username = (await ask("Usuario institucional de la UTN: ")).trim();
     if (!username)
         throw new Error("Falta el usuario.");
     const password = await askHidden("Contraseña: ");
     const credentials = { username, password };
-    await new LocalSession().login(credentials);
+    let accessToken = null;
+    if (http)
+        accessToken = await loginToStore(credentials);
+    else
+        await new LocalSession().login(credentials);
     // Se guardan recién después de comprobar que el SSO las aceptó.
     if (await saveCredentials(credentials)) {
         logger.info("Credenciales guardadas en el keychain del sistema.");
@@ -20,5 +29,22 @@ export async function runLogin() {
     else {
         logger.warn("No hay keychain disponible: para renovar sin intervención definí UTN_USER y UTN_PASS.");
     }
-    logger.info("Listo: ya podés usar el servidor MCP.");
+    if (accessToken) {
+        logger.info("Listo. Configurá tu cliente MCP con este header; no se vuelve a mostrar:\n\n" +
+            `    Authorization: Bearer ${accessToken}\n`);
+    }
+    else {
+        logger.info("Listo: ya podés usar el servidor MCP.");
+    }
+}
+/** 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));
+    return store.issueToken(userId, { kind: "access", clientId: "local" });
 }

package/build/aula-virtual/tools.js

@@ -4,6 +4,7 @@ import { addCalendarEvent, answerChoice, deleteForumPost, editForumPost, postToF
 import { ROOT } from "./format/address.js";
 import { readAulaFile } from "./format/files.js";
 import { open } from "./format/navigate.js";
+import { createUploadLink, submitAssignment } from "./format/submission.js";
 // JSON compacto: indentar estas respuestas cuesta ~25% más de contexto y no se lee mejor.
 const json = (data) => ({
     content: [{ type: "text", text: JSON.stringify(data) }],
@@ -14,7 +15,7 @@ const failure = (e) => ({
 });
 /** Para que el cliente distinga las tools que leen de las que cambian algo en el aula. */
 const READ_ONLY = { readOnlyHint: true, openWorldHint: false };
-export function registerAulaVirtualTools(server, session) {
+export function registerAulaVirtualTools(server, session, files) {
     server.registerTool("aula_get_site_info", {
         description: "Datos del usuario logueado en el aula virtual de la UTN FRBA y del sitio Moodle.",
         annotations: READ_ONLY,
@@ -253,6 +254,105 @@ export function registerAulaVirtualTools(server, session) {
             return failure(e);
         }
     });
+    // En STDIO el servidor lee el archivo del disco del usuario; en HTTP no puede, porque puede estar en
+    // otra máquina: los archivos llegan por un link de subida, que usa el agente o el usuario.
+    const newFiles = files.local
+        ? "Los archivos nuevos se pasan en `archivos` con su ruta absoluta en la compu del usuario."
+        : "Los archivos nuevos no van en la llamada: primero pedí un link con aula_assign_upload_link, " +
+            "subilos ahí y después pasá su id en `subida`.";
+    if (!files.local) {
+        const { inbox, owner } = files;
+        server.registerTool("aula_assign_upload_link", {
+            description: "Genera un link de un solo uso para subir los archivos de una entrega, que después se " +
+                "entregan con aula_assign_submit pasando el `subida` que devuelve. Vence en 30 minutos.\n\n" +
+                "Cómo subirlos:\n" +
+                "- Si podés ejecutar comandos y tenés el archivo (por ejemplo, uno que el usuario adjuntó o " +
+                "que está en su compu), subilo vos con el comando de `conTerminal`, cambiando la ruta. Va un " +
+                '`-F "archivos=@..."` por archivo, todos en el mismo comando. Responde JSON con lo recibido.\n' +
+                "- Si no, pasale el `url` al usuario: se abre en el navegador, también en el celu, y elige " +
+                "los archivos ahí. Esperá a que te diga que los subió.\n\n" +
+                "Subir al link no entrega nada; una subida nueva al mismo link reemplaza la anterior. " +
+                "`acepta` trae los límites de la tarea.",
+            inputSchema: z.object({
+                direccion: z
+                    .string()
+                    .describe('Dirección de la tarea, de aula_open. Ej: "/curso/29487/mod/1729138".'),
+            }),
+            annotations: { readOnlyHint: true, openWorldHint: false },
+        }, async ({ direccion }) => {
+            try {
+                return json(await createUploadLink(session, direccion, inbox, owner));
+            }
+            catch (e) {
+                return failure(e);
+            }
+        });
+    }
+    const submitSchema = z.object({
+        direccion: z.string().describe('Dirección de la tarea, de aula_open. Ej: "/curso/29487/mod/1729138".'),
+        archivos: z
+            .array(z.string())
+            .optional()
+            .describe(files.local
+            ? "Lista final de archivos. Cada uno es la ruta absoluta de un archivo en la compu del " +
+                "usuario o la `url` de uno que ya está en la entrega. Lista vacía: quita todos. " +
+                'Ej: ["C:\\Users\\ana\\Documents\\TP3.pdf"].'
+            : "Lista final de los archivos que ya están en la entrega, por su `url` de aula_open; los " +
+                "de `subida` se suman. Lista vacía: quita los que estaban. " +
+                'Ej: ["https://aulasvirtuales.frba.utn.edu.ar/pluginfile.php/123/assignsubmission_file/submission_files/456/TP3.pdf"].'),
+        texto: z
+            .string()
+            .optional()
+            .describe("Texto en línea completo, en texto plano; reemplaza al anterior. Una línea en blanco " +
+            'separa párrafos. Ej: "Link al repositorio: https://github.com/ana/tp3"'),
+        enviar: z
+            .boolean()
+            .optional()
+            .describe("Solo en tareas con borradores: confirmar el envío para que cuente como entregada. Por " +
+            "defecto, true. Ej: false para dejarla como borrador."),
+        aceptoDeclaracion: z
+            .boolean()
+            .optional()
+            .describe("true si el usuario aceptó la `declaracion` de la tarea. Solo hace falta si la tarea la pide. Ej: true."),
+    });
+    const httpSubmitSchema = submitSchema.extend({
+        subida: z
+            .string()
+            .optional()
+            .describe("`subida` de aula_assign_upload_link, ya usado: sus archivos se suman a la entrega. " +
+            'Ej: "q3Vx9kP2mW7tR1yZ8nB4cD6fG0hJ5lA".'),
+    });
+    server.registerTool("aula_assign_submit", {
+        description: "Entrega una tarea (assign) del aula virtual: sube archivos, escribe el texto en línea o las " +
+            "dos cosas, según lo que acepte la tarea. Antes, abrila con aula_open: `entrega` dice qué " +
+            "acepta (`acepta`, con tipos, cantidad y tamaño), si `puedeEditar` y lo que ya está subido.\n\n" +
+            newFiles +
+            " `archivos` es la lista final y reemplaza lo anterior: para sumar uno sin perder los otros, " +
+            "incluí la `url` de cada archivo que ya está en la entrega. Si no pasás `archivos`, quedan " +
+            "los que estaban; lo mismo con `texto`.\n\n" +
+            "Si la tarea no usa borradores, guardar ya es entregar. Si los usa (`requiereConfirmarEnvio`), " +
+            "la tool además confirma el envío, salvo con `enviar: false`; una vez enviada, en general no se " +
+            "puede cambiar. Con `declaracion`, el usuario tiene que aceptarla (`aceptoDeclaracion`). " +
+            "Devuelve cómo quedó la entrega." +
+            CONFIRM_FIRST +
+            " Incluí la tarea, los nombres de los archivos y si se confirma el envío.",
+        // `subida` existe solo en HTTP; el cast es para que el handler la vea en los dos modos.
+        inputSchema: (files.local ? submitSchema : httpSubmitSchema),
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+    }, async ({ direccion, archivos, subida, texto, enviar, aceptoDeclaracion }) => {
+        try {
+            return json(await submitAssignment(session, direccion, {
+                files: archivos,
+                upload: subida,
+                text: texto,
+                send: enviar ?? true,
+                acceptStatement: aceptoDeclaracion ?? false,
+            }, files));
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
     server.registerTool("aula_calendar_add_event", {
         description: "Agrega un evento personal al calendario del aula virtual, que solo ve el usuario: por ejemplo " +
             "un recordatorio de un parcial o una entrega. El aula avisa según la configuración de " +

package/build/http.js

@@ -1,19 +1,137 @@
 import express from "express";
-import { createMcpHandler } from "@modelcontextprotocol/server";
+import { Readable } from "node:stream";
+import { bearerAuthChallengeResponse, createMcpHandler, OAuthError, OAuthErrorCode, verifyBearerToken, } from "@modelcontextprotocol/server";
 import { localhostHostValidation, localhostOriginValidation, toNodeHandler } from "@modelcontextprotocol/node";
 import { logger } from "./shared/logger.js";
+import { MAX_UPLOAD_BYTES, formatSize } from "./shared/uploads.js";
 const asMiddleware = (guard) => (req, res, next) => {
     if (guard(req, res))
         next();
 };
-export function startHttpServer(factory, port) {
+/**
+ * El SDK rechaza los tokens sin vencimiento; al token fijo del modo local le ponemos uno lejano.
+ * Segundos desde epoch: 1/1/3000.
+ */
+const NEVER = 32_503_680_000;
+/** El usuario del store dueño del token, en `extra.userId`. */
+export function userIdOf(authInfo) {
+    const userId = authInfo?.extra?.userId;
+    if (typeof userId !== "number")
+        throw new Error("Request sin usuario autenticado.");
+    return userId;
+}
+/** Busca el token en el store: el MCP solo acepta tokens de acceso vigentes. */
+function storeVerifier(store) {
+    return {
+        async verifyAccessToken(token) {
+            const found = await store.findToken(token, "access");
+            if (!found)
+                throw new OAuthError(OAuthErrorCode.InvalidToken, "Token desconocido, vencido o revocado.");
+            return {
+                token,
+                clientId: found.clientId ?? "desconocido",
+                scopes: [],
+                expiresAt: found.expiresAt ?? NEVER,
+                extra: { userId: found.userId },
+            };
+        },
+    };
+}
+/** 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) {
     const handler = createMcpHandler(factory, { onerror: (e) => logger.error(e.message) });
+    const verifier = storeVerifier(store);
+    const requireToken = async (req, res, next) => {
+        try {
+            // toNodeHandler le pasa `req.auth` al handler como `authInfo`.
+            req.auth = await verifyBearerToken(req.headers.authorization, { verifier });
+            next();
+        }
+        catch (e) {
+            const challenge = bearerAuthChallengeResponse(e);
+            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", toNodeHandler(handler));
+    app.all("/mcp", 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);
+        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`);
     });
 }
+/** Recibe el multipart del formulario o de `curl -F archivos=@...`. Al navegador le contesta HTML; al resto, JSON. */
+async function receiveUpload(inbox, req, res) {
+    const browser = req.accepts(["json", "html"]) === "html";
+    const fail = (status, message) => browser
+        ? res.status(status).type("html").send(page("No se pudo subir", `<p>${escapeHtml(message)}</p>`))
+        : res.status(status).json({ error: message });
+    const id = String(req.params.id);
+    if (!inbox.get(id))
+        return void fail(404, "El link de subida venció o no existe.");
+    if (Number(req.headers["content-length"]) > MAX_UPLOAD_BYTES) {
+        return void fail(413, `La subida pasa el máximo de ${formatSize(MAX_UPLOAD_BYTES)}.`);
+    }
+    try {
+        // Request de la API web: parsea multipart sin sumar dependencias.
+        const request = new Request(`http://localhost${req.url}`, {
+            method: "POST",
+            headers: req.headers,
+            body: Readable.toWeb(req),
+            duplex: "half",
+        });
+        const form = await request.formData();
+        const files = await Promise.all(form
+            .getAll("archivos")
+            .filter((v) => typeof v !== "string" && v.size > 0)
+            .map(async (f) => ({ name: f.name, bytes: new Uint8Array(await f.arrayBuffer()) })));
+        inbox.receive(id, files);
+        const received = files.map((f) => ({ nombre: f.name, tamanio: f.bytes.length }));
+        if (browser) {
+            const list = received.map((f) => `<li>${escapeHtml(f.nombre)} (${formatSize(f.tamanio)})</li>`).join("");
+            res.type("html").send(page("Listo", `<ul>${list}</ul><p>Volvé al chat y avisá que ya los subiste.</p>`));
+        }
+        else {
+            res.json({ recibidos: received });
+        }
+    }
+    catch (e) {
+        fail(400, e.message);
+    }
+}
+const EXPIRED = "<p>Este link de subida venció o ya no existe. Pedile al agente uno nuevo.</p>";
+function uploadForm(limits) {
+    const rules = [
+        limits.maxFiles ? `hasta ${limits.maxFiles} archivo(s)` : "",
+        `hasta ${formatSize(limits.maxBytes)} cada uno`,
+        limits.extensions?.length ? `tipos: ${limits.extensions.join(", ")}` : "",
+    ].filter(Boolean);
+    const accept = limits.extensions?.length ? ` accept="${escapeHtml(limits.extensions.join(","))}"` : "";
+    return (`<p>Elegí los archivos para la entrega (${escapeHtml(rules.join(", "))}).</p>` +
+        `<form method="post" enctype="multipart/form-data">` +
+        `<input type="file" name="archivos" multiple required${accept}>` +
+        `<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

@@ -2,14 +2,18 @@
 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 } from "./http.js";
+import { startHttpServer, userIdOf } from "./http.js";
 import { createServer } from "./server.js";
 import { logger } from "./shared/logger.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`;
+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`;
 async function main() {
     const { values, positionals } = parseArgs({
         allowPositionals: true,
@@ -24,17 +28,25 @@ async function main() {
         return;
     }
     if (positionals[0] === "login") {
-        await runLogin();
+        await runLogin(values.http);
         return;
     }
-    // Modo local: un solo usuario, la misma sesión para todas las conexiones.
-    const aula = new LocalSession();
-    const factory = () => createServer(aula);
     if (values.http) {
-        startHttpServer(factory, Number(values.port));
+        // 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 store = await SqliteStore.open();
+        const inbox = new UploadInbox(process.env.UTN_MCP_PUBLIC_URL ?? `http://127.0.0.1:${port}`);
+        const factory = (ctx) => {
+            const userId = userIdOf(ctx.authInfo);
+            return createServer(new StoredAulaSession(store, userId), { local: false, inbox, owner: String(userId) });
+        };
+        startHttpServer(factory, port, store, inbox);
     }
     else {
-        serveStdio(factory, { onerror: (e) => logger.error(e.message) });
+        // STDIO: un solo usuario, el de la compu, con la misma sesión para todas las conexiones.
+        const aula = new LocalSession();
+        serveStdio(() => createServer(aula, { local: true }), { onerror: (e) => logger.error(e.message) });
         logger.info("Servidor MCP iniciado en STDIO");
     }
 }

package/build/server.js

@@ -1,11 +1,14 @@
 import { McpServer } from "@modelcontextprotocol/server";
 import { registerAulaVirtualTools } from "./aula-virtual/tools.js";
-/** Un servidor MCP para un usuario. Las entradas STDIO y HTTP lo crean por conexión o por request. */
-export function createServer(aula) {
+/**
+ * Un servidor MCP para un usuario. Las entradas STDIO y HTTP lo crean por conexión o por request.
+ * `files`: de dónde salen los archivos que el usuario sube a una plataforma.
+ */
+export function createServer(aula, files) {
     const server = new McpServer({
         name: "UTN-MCP",
-        version: "0.6.7",
+        version: "0.6.9",
     });
-    registerAulaVirtualTools(server, aula);
+    registerAulaVirtualTools(server, aula, files);
     return server;
 }

package/build/shared/paths.js

@@ -11,3 +11,7 @@ export function configDir() {
 }
 /** Token de Moodle + cookies del SSO del modo local. */
 export const sessionFile = () => join(configDir(), "session.json");
+/** Base de usuarios, tokens y sesiones del modo HTTP: UTN_MCP_DB o un SQLite en la carpeta de configuración. */
+export const storeFile = () => process.env.UTN_MCP_DB ?? join(configDir(), "utn-mcp.db");
+/** Clave con la que se cifran las sesiones en la base, si no viene en UTN_MCP_KEY. */
+export const storeKeyFile = () => join(configDir(), "store.key");

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

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

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

@@ -0,0 +1,145 @@
+import { createCipheriv, createDecipheriv, createHash, randomBytes } from "node:crypto";
+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)
+    );
+`;
+/** Bytes de la clave AES-256. */
+const KEY_BYTES = 32;
+/** Bytes del IV de AES-GCM. */
+const IV_BYTES = 12;
+/** Bytes del tag de autenticación de AES-GCM. */
+const TAG_BYTES = 16;
+const now = () => Math.floor(Date.now() / 1000);
+const hashToken = (token) => createHash("sha256").update(token).digest("hex");
+/**
+ * El SessionStore sobre SQLite. Las sesiones van cifradas con AES-256-GCM: tienen el token de Moodle
+ * y las cookies del SSO, que alcanzan para entrar al aula como el usuario. Los tokens se guardan
+ * hasheados, así que una copia de la base no sirve para usar el servidor.
+ */
+export class SqliteStore {
+    db;
+    key;
+    constructor(db, key) {
+        this.db = db;
+        this.key = key;
+    }
+    /** `node:sqlite` llega con Node 22.13; se importa acá para que el modo STDIO siga andando en Node 20. */
+    static async open(path = storeFile()) {
+        let sqlite;
+        try {
+            sqlite = await import("node:sqlite");
+        }
+        catch {
+            throw new Error(`El modo HTTP necesita Node 22.13 o más nuevo; tenés ${process.version}.`);
+        }
+        await mkdir(dirname(path), { recursive: true });
+        const db = new sqlite.DatabaseSync(path);
+        // 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);
+        return new SqliteStore(db, await loadKey());
+    }
+    async findOrCreateUser(utnUsername) {
+        const username = utnUsername.trim().toLowerCase();
+        this.db
+            .prepare("INSERT INTO users (utn_username, created_at) VALUES (?, ?) ON CONFLICT DO NOTHING")
+            .run(username, now());
+        const row = this.db.prepare("SELECT id FROM users WHERE utn_username = ?").get(username);
+        return row.id;
+    }
+    async issueToken(userId, options) {
+        const token = randomBytes(32).toString("base64url");
+        const createdAt = now();
+        this.db
+            .prepare("INSERT INTO tokens (hash, user_id, kind, client_id, expires_at, created_at) VALUES (?, ?, ?, ?, ?, ?)")
+            .run(hashToken(token), userId, options.kind, options.clientId ?? null, options.ttlSeconds ? createdAt + options.ttlSeconds : null, createdAt);
+        return token;
+    }
+    async findToken(token, kind) {
+        const row = this.db
+            .prepare("SELECT user_id, client_id, expires_at FROM tokens " +
+            "WHERE hash = ? AND kind = ? AND (expires_at IS NULL OR expires_at > ?)")
+            .get(hashToken(token), kind, now());
+        return row ? { userId: row.user_id, clientId: row.client_id, expiresAt: row.expires_at } : null;
+    }
+    async revokeToken(token) {
+        this.db.prepare("DELETE FROM tokens WHERE hash = ?").run(hashToken(token));
+    }
+    async loadSession(userId, platform) {
+        const row = this.db
+            .prepare("SELECT data FROM platform_sessions WHERE user_id = ? AND platform = ?")
+            .get(userId, platform);
+        return row ? this.decrypt(row.data) : null;
+    }
+    async saveSession(userId, platform, data) {
+        this.db
+            .prepare("INSERT INTO platform_sessions (user_id, platform, data, updated_at) VALUES (?, ?, ?, ?) " +
+            "ON CONFLICT (user_id, platform) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at")
+            .run(userId, platform, this.encrypt(data), now());
+    }
+    /** iv + tag + texto cifrado, en un solo blob. */
+    encrypt(plain) {
+        const iv = randomBytes(IV_BYTES);
+        const cipher = createCipheriv("aes-256-gcm", this.key, iv);
+        const body = Buffer.concat([cipher.update(plain, "utf8"), cipher.final()]);
+        return Buffer.concat([iv, cipher.getAuthTag(), body]);
+    }
+    decrypt(blob) {
+        const buf = Buffer.from(blob);
+        const decipher = createDecipheriv("aes-256-gcm", this.key, buf.subarray(0, IV_BYTES));
+        decipher.setAuthTag(buf.subarray(IV_BYTES, IV_BYTES + TAG_BYTES));
+        try {
+            return Buffer.concat([decipher.update(buf.subarray(IV_BYTES + TAG_BYTES)), decipher.final()]).toString("utf8");
+        }
+        catch {
+            throw new Error("No se pudo descifrar la sesión: la clave (UTN_MCP_KEY o store.key) no es la que la cifró.");
+        }
+    }
+}
+/**
+ * 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.
+ */
+async function loadKey() {
+    const fromEnv = process.env.UTN_MCP_KEY;
+    if (fromEnv) {
+        const key = Buffer.from(fromEnv, "base64");
+        if (key.length !== KEY_BYTES)
+            throw new Error(`UTN_MCP_KEY tiene que ser de ${KEY_BYTES} bytes en base64.`);
+        return key;
+    }
+    const file = storeKeyFile();
+    try {
+        return Buffer.from((await readFile(file, "utf8")).trim(), "base64");
+    }
+    catch {
+        const key = randomBytes(KEY_BYTES);
+        await mkdir(dirname(file), { recursive: true });
+        // `wx`: si otro proceso la creó recién, no la pisamos.
+        await writeFile(file, key.toString("base64"), { mode: 0o600, flag: "wx" }).catch(() => { });
+        await chmod(file, 0o600).catch(() => { }); // no-op en Windows
+        return Buffer.from((await readFile(file, "utf8")).trim(), "base64");
+    }
+}

package/build/shared/uploads.js

@@ -0,0 +1,80 @@
+import { randomBytes } from "node:crypto";
+import { extname } from "node:path";
+/** Cuánto dura un link de subida, en milisegundos. */
+const UPLOAD_TTL_MS = 30 * 60 * 1000;
+/** Tope de una subida entera, en bytes: los archivos quedan en memoria hasta que se entregan. */
+export const MAX_UPLOAD_BYTES = 100 * 1024 * 1024;
+/**
+ * Links de un solo uso para recibir archivos por HTTP: los sube el agente con `curl` si tiene
+ * terminal, o el usuario desde el navegador. Los archivos quedan en memoria hasta que una tool los
+ * toma o el link vence; si el servidor se reinicia, se pierden y hay que pedir otro link.
+ */
+export class UploadInbox {
+    baseUrl;
+    uploads = new Map();
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+    }
+    open(owner, title, limits) {
+        this.sweep();
+        const id = randomBytes(24).toString("base64url");
+        const expiresAt = Date.now() + UPLOAD_TTL_MS;
+        this.uploads.set(id, { owner, title, limits, files: null, expiresAt });
+        return { id, url: `${this.baseUrl}/subir/${id}`, expiresAt: new Date(expiresAt).toISOString() };
+    }
+    /** La subida para mostrar su formulario, o undefined si no existe o venció. */
+    get(id) {
+        this.sweep();
+        return this.uploads.get(id);
+    }
+    /** Guarda los archivos de una subida; una subida nueva al mismo link reemplaza la anterior. */
+    receive(id, files) {
+        const upload = this.uploads.get(id);
+        if (!upload || upload.expiresAt < Date.now())
+            throw new Error("El link de subida venció o no existe.");
+        if (!files.length)
+            throw new Error('No llegó ningún archivo: van en el campo "archivos".');
+        checkFiles(files, upload.limits);
+        upload.files = files;
+    }
+    /** Los archivos que se subieron, para entregarlos. No los borra: si la entrega falla, se reintenta. */
+    take(id, owner) {
+        const upload = this.uploads.get(id);
+        if (!upload || upload.owner !== owner || upload.expiresAt < Date.now()) {
+            throw new Error("La subida venció o no existe: pedí otro link.");
+        }
+        if (!upload.files) {
+            throw new Error("Todavía no se subió nada a ese link: esperá a que se use y volvé a intentar.");
+        }
+        return upload.files;
+    }
+    close(id) {
+        this.uploads.delete(id);
+    }
+    sweep() {
+        const now = Date.now();
+        for (const [id, upload] of this.uploads)
+            if (upload.expiresAt < now)
+                this.uploads.delete(id);
+    }
+}
+/** Cantidad, tamaño, tipo y nombres repetidos, que Moodle no acepta. */
+export function checkFiles(files, limits) {
+    if (limits.maxFiles && files.length > limits.maxFiles) {
+        throw new Error(`Se aceptan hasta ${limits.maxFiles} archivo(s) y llegaron ${files.length}.`);
+    }
+    const seen = new Set();
+    for (const f of files) {
+        if (f.bytes.length > limits.maxBytes) {
+            throw new Error(`"${f.name}" pesa ${formatSize(f.bytes.length)}; el máximo es ${formatSize(limits.maxBytes)} por archivo.`);
+        }
+        if (limits.extensions?.length && !limits.extensions.includes(extname(f.name).toLowerCase())) {
+            throw new Error(`"${f.name}" no es de un tipo aceptado (${limits.extensions.join(", ")}).`);
+        }
+        if (seen.has(f.name))
+            throw new Error(`Hay dos archivos que se llaman "${f.name}"; renombrá uno.`);
+        seen.add(f.name);
+    }
+}
+/** Tamaño para personas: en KB por debajo del mega, para que un archivo chico no diga "0.0 MB". */
+export const formatSize = (bytes) => bytes < 1024 * 1024 ? `${Math.ceil(bytes / 1024)} KB` : `${(bytes / 1024 / 1024).toFixed(1)} MB`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "utn-mcp",
-  "version": "0.6.7",
+  "version": "0.6.9",
   "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": {