utn-mcp 0.6.7 → 0.7.0

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,25 @@
 import { ask, askHidden } from "../shared/input.js";
 import { logger } from "../shared/logger.js";
+import { SqliteStore } from "../shared/store/sqlite-store.js";
 import { saveCredentials } from "./client/credentials.js";
+import { linkAulaAccount } from "./client/link.js";
 import { LocalSession } from "./client/local-session.js";
 /**
  * `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 +27,17 @@ 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 store = await SqliteStore.open();
+    const { userId } = await linkAulaAccount(store, credentials);
+    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,150 @@
 import express from "express";
-import { createMcpHandler } from "@modelcontextprotocol/server";
-import { localhostHostValidation, localhostOriginValidation, toNodeHandler } from "@modelcontextprotocol/node";
+import { Readable } from "node:stream";
+import { bearerAuthChallengeResponse, createMcpHandler, OAuthError, OAuthErrorCode, verifyBearerToken, } from "@modelcontextprotocol/server";
+import { hostHeaderValidation, originValidation, toNodeHandler } from "@modelcontextprotocol/node";
+import { mountAdmin } from "./oauth/admin.js";
+import { mountOAuth } from "./oauth/server.js";
 import { logger } from "./shared/logger.js";
+import { escapeHtml, page } from "./shared/pages.js";
+import { MAX_UPLOAD_BYTES, formatSize } from "./shared/uploads.js";
 const asMiddleware = (guard) => (req, res, next) => {
     if (guard(req, res))
         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 },
+            };
+        },
+    };
+}
+const LOOPBACK = ["localhost", "127.0.0.1", "[::1]"];
+/** El factory recibe en `ctx.authInfo` el token ya validado, con el usuario; de ahí arma su sesión. */
+export function startHttpServer(factory, options, store, inbox) {
+    const { host, port, publicUrl, access, adminSecret } = options;
     const handler = createMcpHandler(factory, { onerror: (e) => logger.error(e.message) });
+    const verifier = storeVerifier(store);
     const app = express();
-    app.use(asMiddleware(localhostHostValidation()));
-    app.use(asMiddleware(localhostOriginValidation()));
+    // Detrás de un reverse proxy en la misma máquina: la IP del cliente (para el rate limit) viene en X-Forwarded-For.
+    app.set("trust proxy", "loopback");
+    // Contra DNS rebinding: solo se aceptan los hosts de esta máquina y el de la URL pública.
+    const allowed = publicUrl ? [...LOOPBACK, new URL(publicUrl).hostname] : LOOPBACK;
+    if (!publicUrl && !LOOPBACK.includes(host)) {
+        logger.warn(`Escuchando en ${host} sin UTN_MCP_PUBLIC_URL: se rechazan los requests que no lleguen como localhost.`);
+    }
+    app.use(asMiddleware(hostHeaderValidation(allowed)));
+    // Origin solo donde un navegador ajeno no tiene nada que hacer; los endpoints de OAuth tienen CORS abierto.
+    const sameOrigin = asMiddleware(originValidation(allowed));
+    const resourceMetadataUrl = mountOAuth(app, {
+        issuer: publicUrl ?? `http://127.0.0.1:${port}`,
+        store,
+        access,
+        sameOrigin,
+    });
+    if (adminSecret)
+        mountAdmin(app, store, adminSecret);
+    const requireToken = async (req, res, next) => {
+        try {
+            // toNodeHandler le pasa `req.auth` al handler como `authInfo`.
+            req.auth = await verifyBearerToken(req.headers.authorization, { verifier });
+            next();
+        }
+        catch (e) {
+            // El 401 dice dónde está la metadata: de ahí el cliente arranca el OAuth.
+            const challenge = bearerAuthChallengeResponse(e, { resourceMetadataUrl });
+            res.status(challenge.status);
+            challenge.headers.forEach((value, name) => res.setHeader(name, value));
+            res.send(await challenge.text());
+        }
+    };
     // Sin express.json(): el handler lee el body por su cuenta.
-    app.all("/mcp", toNodeHandler(handler));
-    app.listen(port, "127.0.0.1", () => {
-        logger.info(`Servidor MCP escuchando en http://127.0.0.1:${port}/mcp`);
+    app.all("/mcp", sameOrigin, requireToken, toNodeHandler(handler));
+    // Sin bearer: el id del link es el secreto, y lo abre un navegador o un `curl` que no lo tienen.
+    app.get("/subir/:id", sameOrigin, (req, res) => {
+        const upload = inbox.get(String(req.params.id));
+        if (!upload)
+            return void res.status(404).type("html").send(page("Link vencido", EXPIRED));
+        res.type("html").send(page(upload.title, uploadForm(upload.limits)));
     });
+    app.post("/subir/:id", sameOrigin, (req, res) => receiveUpload(inbox, req, res));
+    app.listen(port, host, () => {
+        logger.info(`Servidor MCP escuchando en http://${host}:${port}/mcp`);
+        if (publicUrl)
+            logger.info(`Publicado en ${publicUrl}/mcp`);
+    });
+}
+/** Recibe el multipart del formulario o de `curl -F archivos=@...`. Al navegador le contesta HTML; al resto, JSON. */
+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>");
 }

package/build/index.js

@@ -1,20 +1,36 @@
 #!/usr/bin/env node
+import { existsSync } from "node:fs";
 import { parseArgs } from "node:util";
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
 import { LocalSession } from "./aula-virtual/client/local-session.js";
+import { StoredAulaSession } from "./aula-virtual/client/stored-session.js";
 import { runLogin } from "./aula-virtual/login.js";
-import { startHttpServer } from "./http.js";
+import { startHttpServer, userIdOf } from "./http.js";
+import { accessPolicyFromEnv } from "./oauth/access.js";
 import { createServer } from "./server.js";
 import { logger } from "./shared/logger.js";
+import { SqliteStore } from "./shared/store/sqlite-store.js";
+import { UploadInbox } from "./shared/uploads.js";
 const USAGE = `Uso:
   utn-mcp                 servidor MCP por STDIO (lo lanza el cliente)
-  utn-mcp --http [--port N]  servidor MCP por HTTP en 127.0.0.1 (por defecto 3000)
-  utn-mcp login           guardar credenciales de la UTN y obtener el primer token`;
+  utn-mcp --http [--host H] [--port N]  servidor MCP por HTTP (por defecto 127.0.0.1:3000)
+  utn-mcp login           guardar credenciales de la UTN y obtener el primer token
+  utn-mcp login --http    lo mismo, para el modo HTTP: guarda la sesión y emite el token del cliente
+
+Si hay un .env en la carpeta actual, se lee al arrancar (ver .env.example).`;
+/** Lee el `.env` de la carpeta actual, si hay. Lo que ya está definido en el entorno no se pisa. */
+function loadDotenv() {
+    if (existsSync(".env"))
+        process.loadEnvFile(".env");
+}
 async function main() {
+    loadDotenv();
     const { values, positionals } = parseArgs({
         allowPositionals: true,
         options: {
             http: { type: "boolean", default: false },
+            // Por defecto solo desde esta máquina; hosteado, `0.0.0.0` detrás del reverse proxy.
+            host: { type: "string", default: process.env.HOST ?? "127.0.0.1" },
             port: { type: "string", default: process.env.PORT ?? "3000" },
             help: { type: "boolean", short: "h", default: false },
         },
@@ -24,17 +40,37 @@ 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 publicUrl = process.env.UTN_MCP_PUBLIC_URL?.replace(/\/+$/, "") || undefined;
+        const baseUrl = publicUrl ?? `http://127.0.0.1:${port}`;
+        // La página de `/login` del propio servidor, salvo que el que hostea prefiera mandar a otra.
+        const loginUrl = process.env.UTN_MCP_LOGIN_URL || `${baseUrl}/login`;
+        const store = await SqliteStore.open();
+        const inbox = new UploadInbox(baseUrl);
+        const factory = (ctx) => {
+            const userId = userIdOf(ctx.authInfo);
+            const aula = new StoredAulaSession(store, userId, loginUrl);
+            return createServer(aula, { local: false, inbox, owner: String(userId) });
+        };
+        const options = {
+            host: values.host,
+            port,
+            publicUrl,
+            access: accessPolicyFromEnv(),
+            adminSecret: process.env.UTN_MCP_ADMIN_SECRET || undefined,
+        };
+        startHttpServer(factory, options, 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");
     }
 }