utn-mcp 0.2.1 → 0.6.9

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

@@ -0,0 +1,52 @@
+export const ROOT = "/";
+export const courseAddr = (courseId) => `/curso/${courseId}`;
+export const moduleAddr = (courseId, cmid) => `/curso/${courseId}/mod/${cmid}`;
+export const discussionAddr = (courseId, cmid, discussionId) => `/curso/${courseId}/mod/${cmid}/disc/${discussionId}`;
+const FORMATS = [
+    "/",
+    "/curso/{courseId}",
+    "/curso/{courseId}/mod/{cmid}",
+    "/curso/{courseId}/mod/{cmid}/disc/{discussionId}",
+].join(", ");
+const PATTERN = /^\/curso\/(\d+)(?:\/mod\/(\d+)(?:\/disc\/(\d+))?)?$/;
+export function parseAddress(raw) {
+    const path = raw.trim().replace(/\/+$/, "") || "/";
+    if (path === "/")
+        return { level: "root" };
+    const m = PATTERN.exec(path);
+    if (!m)
+        throw new Error(`Dirección inválida: "${raw}". Formatos válidos: ${FORMATS}`);
+    const [, course, cmid, disc] = m;
+    const courseId = Number(course);
+    if (!cmid)
+        return { level: "course", courseId };
+    if (!disc)
+        return { level: "module", courseId, cmid: Number(cmid) };
+    return { level: "discussion", courseId, cmid: Number(cmid), discussionId: Number(disc) };
+}
+/** La dirección en texto, tal como la ve el modelo. */
+export function formatAddress(address) {
+    switch (address.level) {
+        case "root":
+            return ROOT;
+        case "course":
+            return courseAddr(address.courseId);
+        case "module":
+            return moduleAddr(address.courseId, address.cmid);
+        case "discussion":
+            return discussionAddr(address.courseId, address.cmid, address.discussionId);
+    }
+}
+/** La dirección de un nivel más arriba, o null si ya estamos en la raíz. */
+export function parentOf(address) {
+    switch (address.level) {
+        case "root":
+            return null;
+        case "course":
+            return ROOT;
+        case "module":
+            return courseAddr(address.courseId);
+        case "discussion":
+            return moduleAddr(address.courseId, address.cmid);
+    }
+}

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

@@ -0,0 +1,14 @@
+import { userFacingUrl } from "./files.js";
+/** Los timestamps de Moodle (segundos) en ISO; 0 o vacío es "sin fecha". */
+export const isoDate = (seconds) => seconds ? new Date(seconds * 1000).toISOString() : null;
+export function toFile(f) {
+    return {
+        nombre: f.filename,
+        ruta: f.filepath || undefined,
+        tamanio: f.filesize,
+        mimetype: f.mimetype,
+        modificado: isoDate(f.timemodified),
+        // Sirve para pasársela al usuario y también para leerlo con aula_read_file.
+        url: userFacingUrl(f.fileurl),
+    };
+}

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

@@ -0,0 +1,89 @@
+import { openDocument, UnsupportedFormat } from "../../shared/documents/index.js";
+import { AULA_BASE_URL } from "../client/constants.js";
+import { fetchFile } from "../client/moodle-api.js";
+const ORIGIN = new URL(AULA_BASE_URL).origin;
+const WS_PATH = "/webservice/pluginfile.php/";
+const WEB_PATH = "/pluginfile.php/";
+/** Cuánto se devuelve por llamada, en caracteres de texto. */
+const BUDGET_CHARS = 30_000;
+/** Lo que cuesta una página como imagen (~1.600 tokens), medido en caracteres de texto. */
+const IMAGE_COST_CHARS = 6_000;
+/** El más grande que hay hoy en los cursos pesa 12 MB. */
+const MAX_BYTES = 30 * 1024 * 1024;
+/**
+ * Moodle devuelve las URLs del web service, que piden token. Al usuario le sirve la misma ruta sin
+ * `/webservice`, que se abre con la sesión de su navegador. Es la única que mostramos: el token no
+ * sale nunca del servidor.
+ */
+export function userFacingUrl(fileurl) {
+    return fileurl.replace(`${ORIGIN}${WS_PATH}`, `${ORIGIN}${WEB_PATH}`);
+}
+/**
+ * Acepta cualquiera de las dos formas y devuelve la del web service. Solo archivos del aula: con
+ * cualquier otra URL estaríamos mandando el token del usuario a donde diga el modelo.
+ */
+function downloadUrl(url) {
+    let u;
+    try {
+        u = new URL(url);
+    }
+    catch {
+        throw new Error(`URL inválida: "${url}". Usá la \`url\` de un archivo tal como la devuelve aula_open.`);
+    }
+    const path = u.pathname.startsWith(WS_PATH) ? u.pathname : u.pathname.startsWith(WEB_PATH) ? WS_PATH + u.pathname.slice(WEB_PATH.length) : null;
+    if (u.origin !== ORIGIN || !path) {
+        throw new Error(`Solo se pueden leer archivos del aula virtual (${ORIGIN}${WEB_PATH}...).`);
+    }
+    u.pathname = path;
+    u.searchParams.delete("token");
+    u.searchParams.delete("wstoken");
+    return u;
+}
+/** Baja un archivo del aula y devuelve desde la parte `from` tantas como entren en el presupuesto. */
+export async function readAulaFile(session, url, from = 1) {
+    const download = downloadUrl(url);
+    const fileName = decodeURIComponent(download.pathname.split("/").pop() ?? "");
+    const forUser = userFacingUrl(download.href);
+    const { bytes } = await fetchFile(session, download, MAX_BYTES);
+    let doc;
+    try {
+        doc = await openDocument(bytes, fileName);
+    }
+    catch (e) {
+        if (e instanceof UnsupportedFormat) {
+            throw new Error(`${e.message} El usuario lo puede bajar desde ${forUser}`);
+        }
+        throw e;
+    }
+    try {
+        if (from > doc.total) {
+            throw new Error(`"${fileName}" termina en ${doc.unit} ${doc.total}; se pidió desde ${from}.`);
+        }
+        const parts = [];
+        let spent = 0;
+        let n = from;
+        for (; n <= doc.total; n++) {
+            const part = await doc.part(n);
+            const cost = "text" in part ? part.text.length : IMAGE_COST_CHARS;
+            // Siempre al menos una parte, aunque sola se pase del presupuesto.
+            if (parts.length > 0 && spent + cost > BUDGET_CHARS)
+                break;
+            parts.push({ ...part, number: n });
+            spent += cost;
+        }
+        return {
+            archivo: fileName,
+            formato: doc.format,
+            unidad: doc.unit,
+            total: doc.total,
+            desde: from,
+            hasta: n - 1,
+            siguiente: n <= doc.total ? n : undefined,
+            urlParaUsuario: forUser,
+            parts,
+        };
+    }
+    finally {
+        await doc.close();
+    }
+}

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

@@ -0,0 +1,143 @@
+import { htmlToSnippet, htmlToText } from "../../shared/html.js";
+import { courseAddr, discussionAddr, formatAddress, moduleAddr, parentOf, parseAddress, } from "./address.js";
+import { canAddDiscussion, getCourseSections, getDiscussionPosts, getForumDiscussions, getUserCourses, PAGE_SIZE, } from "../client/client.js";
+import { viewChoice, viewChoicegroup, viewSubmission } from "./activities.js";
+import { isoDate, toFile } from "./fields.js";
+/**
+ * Entra a una dirección del aula y devuelve su contenido, el padre y las direcciones de lo que hay
+ * adentro. Es el único lugar que decide qué ve el modelo y cuánto texto le cuesta.
+ */
+export async function open(session, rawAddress, page = 0) {
+    const address = parseAddress(rawAddress);
+    const base = { direccion: formatAddress(address), padre: parentOf(address) };
+    switch (address.level) {
+        case "root":
+            return { ...base, cursos: await viewCourses(session) };
+        case "course":
+            return { ...base, secciones: await viewCourse(session, address.courseId) };
+        case "module":
+            return { ...base, ...(await viewModule(session, address, page)) };
+        case "discussion":
+            return { ...base, ...(await viewDiscussion(session, address.discussionId)) };
+    }
+}
+async function viewCourses(session) {
+    const courses = await getUserCourses(session);
+    return courses.map((c) => ({
+        direccion: courseAddr(c.id),
+        id: c.id,
+        nombre: c.fullname,
+        nombreCorto: c.shortname,
+        visible: c.visible === 1,
+        progreso: c.progress ?? null,
+        ultimoAcceso: isoDate(c.lastaccess),
+    }));
+}
+/** El mapa del curso: secciones y módulos, con las descripciones recortadas. */
+async function viewCourse(session, courseId) {
+    const sections = await getCourseSections(session, courseId);
+    return sections
+        .filter((s) => s.uservisible !== false)
+        .map((s) => ({
+        nombre: s.name,
+        numero: s.section,
+        resumen: htmlToText(s.summary) || undefined,
+        modulos: s.modules.filter((m) => m.uservisible).map((m) => toModule(m, courseId, true)),
+    }))
+        .filter((s) => s.resumen || s.modulos.length > 0);
+}
+async function viewModule(session, address, page) {
+    const { sectionName, module } = await findModule(session, address.courseId, address.cmid);
+    const base = { seccion: sectionName, modulo: toModule(module, address.courseId) };
+    switch (module.modname) {
+        case "forum":
+            return { ...base, ...(await viewForum(session, address, module.instance, page)) };
+        case "assign":
+            return { ...base, entrega: await viewSubmission(session, address.courseId, module) };
+        case "choice":
+            return { ...base, eleccion: await viewChoice(session, address.courseId, module) };
+        case "choicegroup":
+            return { ...base, eleccion: await viewChoicegroup(session, module) };
+        default:
+            return base;
+    }
+}
+/** Un foro es un índice: asuntos y un fragmento de cada uno. El mensaje completo sale al abrir la discusión. */
+async function viewForum(session, address, forumid, page) {
+    const [{ discussions }, canStartDiscussion] = await Promise.all([
+        getForumDiscussions(session, forumid, page),
+        canAddDiscussion(session, forumid),
+    ]);
+    return {
+        puedeAbrirHilo: canStartDiscussion,
+        discusiones: discussions.map((d) => ({
+            direccion: discussionAddr(address.courseId, address.cmid, d.discussion),
+            asunto: d.subject,
+            autor: d.userfullname,
+            autorId: d.userid,
+            fecha: isoDate(d.created),
+            ultimaActividad: isoDate(d.timemodified),
+            respuestas: d.numreplies,
+            fijada: d.pinned || undefined,
+            adjuntos: d.attachment || undefined,
+            resumen: htmlToSnippet(d.message),
+        })),
+        pagina: page,
+        hayMasDiscusiones: discussions.length === PAGE_SIZE || undefined,
+    };
+}
+async function viewDiscussion(session, discussionId) {
+    const { posts } = await getDiscussionPosts(session, discussionId);
+    const visible = posts.filter((p) => !p.isdeleted);
+    return {
+        asunto: visible[0]?.subject,
+        publicaciones: visible.map((p) => ({
+            autor: p.author.fullname,
+            autorId: p.author.id,
+            fecha: isoDate(p.timecreated),
+            respuestaA: p.parentid ?? undefined,
+            id: p.id,
+            mensaje: htmlToText(p.message),
+            adjuntos: p.attachments.length ? p.attachments.map(toFile) : undefined,
+            // Lo que el usuario puede hacer con cada publicación, para no intentar lo que Moodle va a rechazar.
+            acciones: allowedActions(p.capabilities),
+        })),
+    };
+}
+function allowedActions(c) {
+    const allowed = [c.reply && "responder", c.edit && "editar", c.delete && "borrar"].filter(Boolean);
+    return allowed.length ? allowed : undefined;
+}
+/** Ubica un módulo por su cmid y se queda con la sección que lo contiene. */
+export async function findModule(session, courseId, cmid) {
+    const sections = await getCourseSections(session, courseId, cmid);
+    for (const section of sections) {
+        const module = section.modules.find((m) => m.id === cmid);
+        if (!module)
+            continue;
+        if (!module.uservisible)
+            throw new Error(`No tenés acceso al módulo ${cmid}.`);
+        return { sectionName: section.name, module };
+    }
+    throw new Error(`No existe el módulo ${cmid} en el curso ${courseId}.`);
+}
+/** `summarized` recorta la descripción: en el mapa del curso alcanza para decidir si entrar. */
+function toModule(m, courseId, summarized = false) {
+    const contents = m.contents ?? [];
+    const files = contents.filter((c) => c.type === "file");
+    const links = contents.filter((c) => c.type === "url");
+    return {
+        direccion: moduleAddr(courseId, m.id),
+        id: m.id,
+        nombre: m.name,
+        tipo: m.modname,
+        url: m.url,
+        descripcion: (summarized ? htmlToSnippet(m.description) : htmlToText(m.description)) || undefined,
+        restriccion: htmlToText(m.availabilityinfo) || undefined,
+        fechas: m.dates?.length
+            ? m.dates.map((d) => ({ etiqueta: d.label, fecha: isoDate(d.timestamp) }))
+            : undefined,
+        archivos: files.length ? files.map(toFile) : undefined,
+        enlaces: links.length ? links.map((l) => l.fileurl) : 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" });
 }