utn-mcp 0.2.1 → 0.6.9

package/build/aula-virtual/tools.js

@@ -1,8 +1,10 @@
 import * as z from "zod";
 import { getSiteInfo } from "./client/client.js";
-import { RAIZ } from "./address.js";
-import { leerArchivo } from "./files.js";
-import { open } from "./navigate.js";
+import { addCalendarEvent, answerChoice, deleteForumPost, editForumPost, postToForum, sendMessage, } from "./format/actions.js";
+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) }],
@@ -11,8 +13,13 @@ const failure = (e) => ({
     content: [{ type: "text", text: `Error: ${e.message}` }],
     isError: true,
 });
-export function registerAulaVirtualTools(server, session) {
-    server.registerTool("aula_get_site_info", { description: "Datos del usuario logueado en el aula virtual de la UTN FRBA y del sitio Moodle." }, async () => {
+/** 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, 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,
+    }, async () => {
         try {
             const { sitename, fullname, username, userid, release } = await getSiteInfo(session);
             return json({ sitename, fullname, username, userid, release });
@@ -24,9 +31,10 @@ export function registerAulaVirtualTools(server, session) {
     server.registerTool("aula_list_courses", {
         description: "Lista los cursos (materias) en los que está inscripto el usuario. Es el punto de entrada: " +
             "cada curso viene con su `direccion`, que se le pasa a aula_open para entrar.",
+        annotations: READ_ONLY,
     }, async () => {
         try {
-            return json(await open(session, RAIZ));
+            return json(await open(session, ROOT));
         }
         catch (e) {
             return failure(e);
@@ -36,6 +44,11 @@ export function registerAulaVirtualTools(server, session) {
         description: "Entra a una dirección del aula virtual y devuelve lo que hay ahí: un curso con sus secciones " +
             "y módulos, un módulo con sus archivos y fechas, un foro con el índice de sus discusiones, o " +
             "una discusión con sus mensajes completos.\n\n" +
+            "Según el tipo de módulo trae además: en una tarea (assign), `entrega` con el estado, el " +
+            "vencimiento, lo que se subió y la devolución con la nota; en una elección (choice) o " +
+            "selección de grupos (choicegroup), `eleccion` con las opciones y sus ids; en un foro, " +
+            "`puedeAbrirHilo`; en una discusión, el `id`, el `autorId` y las `acciones` permitidas de " +
+            "cada publicación. Es lo que piden las tools que escriben en el aula.\n\n" +
             "No hace falta armar la dirección: cada respuesta trae las direcciones de lo que hay adentro " +
             "(`direccion`) y la de un nivel más arriba (`padre`), así que se navega pasando de vuelta una " +
             "de esas. Para empezar, usar aula_list_courses o la dirección \"/\".\n\n" +
@@ -57,6 +70,7 @@ export function registerAulaVirtualTools(server, session) {
                 .describe("Solo para foros: página del índice de discusiones, de 50 en 50. La respuesta avisa " +
                 "con `hayMasDiscusiones` cuando hay otra."),
         }),
+        annotations: READ_ONLY,
     }, async ({ direccion, pagina }) => {
         try {
             return json(await open(session, direccion, pagina));
@@ -82,20 +96,21 @@ export function registerAulaVirtualTools(server, session) {
                 .optional()
                 .describe("Número de página, diapositiva o fragmento desde el cual leer. Por defecto, 1."),
         }),
+        annotations: READ_ONLY,
     }, async ({ url, desde }) => {
         try {
-            const { partes, ...lectura } = await leerArchivo(session, url, desde);
-            const etiqueta = (n, titulo) => `--- ${lectura.unidad} ${n} de ${lectura.total}${titulo ? ` (${titulo})` : ""} ---`;
+            const { parts, ...fileRead } = await readAulaFile(session, url, desde);
+            const label = (n, title) => `--- ${fileRead.unidad} ${n} de ${fileRead.total}${title ? ` (${title})` : ""} ---`;
             return {
                 content: [
-                    { type: "text", text: JSON.stringify(lectura) },
-                    ...partes.flatMap((p) => "texto" in p
-                        ? [{ type: "text", text: `${etiqueta(p.numero, p.titulo)}\n${p.texto}` }]
+                    { type: "text", text: JSON.stringify(fileRead) },
+                    ...parts.flatMap((p) => "text" in p
+                        ? [{ type: "text", text: `${label(p.number, p.title)}\n${p.text}` }]
                         : [
-                            { type: "text", text: etiqueta(p.numero, p.titulo) },
+                            { type: "text", text: label(p.number, p.title) },
                             {
                                 type: "image",
-                                data: Buffer.from(p.imagen).toString("base64"),
+                                data: Buffer.from(p.image).toString("base64"),
                                 mimeType: p.mimeType,
                             },
                         ]),
@@ -106,4 +121,267 @@ export function registerAulaVirtualTools(server, session) {
             return failure(e);
         }
     });
+    // --- Escritura: lo que sigue cambia algo en el aula, y casi todo queda a la vista de otras personas. ---
+    const CONFIRM_FIRST = "\n\nAntes de llamarla, mostrale al usuario exactamente lo que se va a hacer y esperá que confirme.";
+    server.registerTool("aula_forum_post", {
+        description: "Publica en un foro del aula virtual. Con la `direccion` de un foro abre un hilo nuevo (hace " +
+            "falta `asunto`); con la de una discusión responde en ella, a la publicación `respuestaA` o, " +
+            "si no se indica, a la primera.\n\n" +
+            "Lo que se publica lo ven docentes y compañeros, y a muchos les llega por mail. Antes de abrir " +
+            "un hilo, mirá `puedeAbrirHilo` del foro; antes de responder, que la publicación tenga " +
+            '"responder" en `acciones`.' +
+            CONFIRM_FIRST,
+        inputSchema: z.object({
+            direccion: z
+                .string()
+                .describe('Dirección de un foro o de una discusión. Ej: "/curso/691/mod/34831" o ' +
+                '"/curso/691/mod/34831/disc/416676".'),
+            mensaje: z
+                .string()
+                .min(1)
+                .describe("Texto del mensaje, en texto plano. Una línea en blanco separa párrafos. " +
+                'Ej: "Hola, ¿el parcial incluye la unidad 4?"'),
+            asunto: z
+                .string()
+                .optional()
+                .describe('Obligatorio para abrir un hilo. En una respuesta, por defecto "Re: <asunto>". ' +
+                'Ej: "Consulta sobre el parcial".'),
+            respuestaA: z
+                .number()
+                .int()
+                .optional()
+                .describe("Solo al responder: `id` de la publicación a la que se responde, de aula_open. Ej: 768118."),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async ({ direccion, mensaje, asunto, respuestaA }) => {
+        try {
+            return json(await postToForum(session, direccion, mensaje, asunto, respuestaA));
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
+    server.registerTool("aula_forum_edit_post", {
+        description: "Edita una publicación propia de un foro y reemplaza el mensaje completo. Solo se puede si la " +
+            'publicación tiene "editar" en `acciones`: Moodle deja editar por un rato después de publicar.' +
+            CONFIRM_FIRST,
+        inputSchema: z.object({
+            direccion: z
+                .string()
+                .describe('Dirección de la discusión donde está la publicación. Ej: "/curso/691/mod/34831/disc/416676".'),
+            id: z.number().int().describe("`id` de la publicación, de aula_open. Ej: 768118."),
+            mensaje: z
+                .string()
+                .min(1)
+                .describe('El mensaje nuevo completo, en texto plano; reemplaza al anterior. Ej: "Ya lo resolví, gracias."'),
+            asunto: z
+                .string()
+                .optional()
+                .describe('Asunto nuevo. Si no se pasa, queda el que tenía. Ej: "Consulta sobre el parcial (resuelta)".'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+    }, async ({ direccion, id, mensaje, asunto }) => {
+        try {
+            return json(await editForumPost(session, direccion, id, mensaje, asunto));
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
+    server.registerTool("aula_forum_delete_post", {
+        description: "Borra una publicación propia de un foro. No se puede deshacer. Solo se puede si tiene " +
+            '"borrar" en `acciones`. Si es la primera publicación de la discusión, se borra la discusión ' +
+            "entera." +
+            CONFIRM_FIRST,
+        inputSchema: z.object({
+            direccion: z
+                .string()
+                .describe('Dirección de la discusión donde está la publicación. Ej: "/curso/691/mod/34831/disc/416676".'),
+            id: z.number().int().describe("`id` de la publicación, de aula_open. Ej: 768118."),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+    }, async ({ direccion, id }) => {
+        try {
+            return json(await deleteForumPost(session, direccion, id));
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
+    server.registerTool("aula_choice_answer", {
+        description: 'Responde una elección (choice: encuestas rápidas como "¿venís al parcial?") o una selección ' +
+            "de grupos (choicegroup: anotarse en un grupo o comisión). Deja elegidas exactamente las " +
+            "`opciones` pasadas y reemplaza la respuesta anterior; con una lista vacía la borra.\n\n" +
+            "Las opciones salen de `eleccion` al abrir el módulo con aula_open. Muchas no dejan cambiar " +
+            "la respuesta una vez dada (`puedeCambiar: false`), y las opciones `deshabilitada` están " +
+            "completas. Devuelve cómo quedó la elección." +
+            CONFIRM_FIRST,
+        inputSchema: z.object({
+            direccion: z.string().describe('Dirección del módulo. Ej: "/curso/29487/mod/1729113".'),
+            opciones: z
+                .array(z.number().int())
+                .describe("`id` de las opciones a elegir. Ej: [31076]. Varias solo si la actividad lo permite."),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    }, async ({ direccion, opciones }) => {
+        try {
+            return json(await answerChoice(session, direccion, opciones));
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
+    server.registerTool("aula_send_message", {
+        description: "Manda un mensaje privado por la mensajería del aula virtual a otro usuario, docente o " +
+            "compañero. El `usuarioId` sale del `autorId` de un foro o una discusión abiertos con " +
+            "aula_open: no lo inventes ni lo deduzcas del nombre. La respuesta trae el nombre del " +
+            "destinatario." +
+            CONFIRM_FIRST +
+            " Incluí a quién va dirigido.",
+        inputSchema: z.object({
+            usuarioId: z.number().int().describe("Id del destinatario, del `autorId` de aula_open. Ej: 1066."),
+            mensaje: z
+                .string()
+                .min(1)
+                .describe('Texto del mensaje, en texto plano. Ej: "Profe, ¿puedo rendir el recuperatorio el viernes?"'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async ({ usuarioId, mensaje }) => {
+        try {
+            return json(await sendMessage(session, usuarioId, mensaje));
+        }
+        catch (e) {
+            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 " +
+            "notificaciones del usuario. La fecha va con zona horaria; en Argentina es -03:00.",
+        inputSchema: z.object({
+            nombre: z.string().min(1).describe('Título del evento. Ej: "Parcial de Física II".'),
+            inicio: z
+                .string()
+                .describe('Fecha y hora en ISO 8601 con zona horaria. Ej: "2026-10-14T18:00:00-03:00".'),
+            duracionMinutos: z
+                .number()
+                .int()
+                .min(0)
+                .optional()
+                .describe("Duración en minutos. Por defecto, sin duración. Ej: 120."),
+            descripcion: z.string().optional().describe('Detalle, en texto plano. Ej: "Aula 312, unidades 1 a 4".'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    }, async ({ nombre, inicio, duracionMinutos, descripcion }) => {
+        try {
+            return json(await addCalendarEvent(session, {
+                name: nombre,
+                start: inicio,
+                durationMinutes: duracionMinutos,
+                description: descripcion,
+            }));
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
 }

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.2.1",
+        version: "0.6.9",
     });
-    registerAulaVirtualTools(server, aula);
+    registerAulaVirtualTools(server, aula, files);
     return server;
 }