utn-mcp 0.6.7 → 0.7.0

package/build/oauth/access.js

@@ -0,0 +1,52 @@
+import { logger } from "../shared/logger.js";
+/** Cuánto esperamos la respuesta de UTN_MCP_ACCESS_URL, en milisegundos. */
+const ACCESS_TIMEOUT_MS = 5_000;
+/**
+ * La política sale del entorno: con UTN_MCP_ACCESS_URL decide otro servicio;
+ * con UTN_MCP_ALLOWED_EMAILS, una lista; sin ninguna, entra cualquiera con usuario de la UTN.
+ */
+export function accessPolicyFromEnv(env = process.env) {
+    if (env.UTN_MCP_ACCESS_URL)
+        return remotePolicy(env.UTN_MCP_ACCESS_URL, env.UTN_MCP_ACCESS_SECRET);
+    if (env.UTN_MCP_ALLOWED_EMAILS)
+        return listPolicy(env.UTN_MCP_ALLOWED_EMAILS);
+    logger.warn("Sin UTN_MCP_ACCESS_URL ni UTN_MCP_ALLOWED_EMAILS: puede entrar cualquiera con usuario de la UTN.");
+    return async () => ({ allowed: true });
+}
+/** Emails o dominios (`@frba.utn.edu.ar`), separados por coma. */
+function listPolicy(raw) {
+    const entries = raw.split(",").map((e) => e.trim().toLowerCase()).filter(Boolean);
+    return async ({ email }) => {
+        const own = email?.toLowerCase();
+        if (own && entries.some((e) => (e.startsWith("@") ? own.endsWith(e) : own === e)))
+            return { allowed: true };
+        return { allowed: false, reason: "Tu cuenta no está habilitada en este servidor. Pedile acceso a quien lo administra." };
+    };
+}
+/** `POST url` con `{ email, usuario }`; contesta `{ permitido, motivo?, url? }`. */
+function remotePolicy(url, secret) {
+    if (!secret)
+        logger.warn("UTN_MCP_ACCESS_URL sin UTN_MCP_ACCESS_SECRET: el pedido de acceso va sin autenticar.");
+    return async ({ username, email }) => {
+        if (!email)
+            return { allowed: false, reason: "El aula no devolvió tu email, y sin él no podemos verificar tu acceso." };
+        try {
+            const res = await fetch(url, {
+                method: "POST",
+                headers: { "content-type": "application/json", ...(secret ? { authorization: `Bearer ${secret}` } : {}) },
+                body: JSON.stringify({ email, usuario: username }),
+                signal: AbortSignal.timeout(ACCESS_TIMEOUT_MS),
+            });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            const data = (await res.json());
+            if (data.permitido === true)
+                return { allowed: true };
+            return { allowed: false, reason: data.motivo || "Tu cuenta no está habilitada en este servidor.", url: data.url };
+        }
+        catch (e) {
+            logger.error(`No se pudo consultar el acceso de ${email}: ${e.message}`);
+            return { allowed: false, reason: "No pudimos verificar si tenés acceso: probá de nuevo en unos minutos." };
+        }
+    };
+}

package/build/oauth/admin.js

@@ -0,0 +1,48 @@
+import { timingSafeEqual } from "node:crypto";
+import express from "express";
+import { AULA_PLATFORM } from "../aula-virtual/client/stored-session.js";
+/**
+ * API para que otro servicio del que hostea (un panel de cuenta, por ejemplo) muestre y desconecte las
+ * apps de un usuario. Solo existe con UTN_MCP_ADMIN_SECRET, que va como `Authorization: Bearer`.
+ * Los usuarios se buscan por email institucional.
+ */
+export function mountAdmin(app, store, secret) {
+    const json = express.json({ limit: "4kb" });
+    const requireSecret = (req, res, next) => {
+        const got = Buffer.from(req.headers.authorization ?? "");
+        const want = Buffer.from(`Bearer ${secret}`);
+        if (got.length === want.length && timingSafeEqual(got, want))
+            return next();
+        res.status(401).json({ error: "No autorizado." });
+    };
+    /** `{ email }` → el usuario, cuándo se renovó su sesión del aula y sus apps conectadas. */
+    app.post("/admin/clientes", requireSecret, json, async (req, res) => {
+        const email = typeof req.body?.email === "string" ? req.body.email : "";
+        const user = email ? await store.findUserByEmail(email) : null;
+        if (!user)
+            return void res.json({ clientes: [] });
+        const [clients, aulaAt] = await Promise.all([
+            store.listConnectedClients(user.id),
+            store.sessionUpdatedAt(user.id, AULA_PLATFORM),
+        ]);
+        res.json({
+            usuario: user.utnUsername,
+            sesionAula: aulaAt ? new Date(aulaAt * 1000).toISOString() : undefined,
+            clientes: clients.map((c) => ({
+                id: c.clientId,
+                nombre: c.clientName ?? (c.clientId === "local" ? "Token de utn-mcp login" : "App sin nombre"),
+                ultimoUso: new Date(c.lastTokenAt * 1000).toISOString(),
+            })),
+        });
+    });
+    /** `{ email, cliente }` → borra los tokens de esa app: tiene que volver a conectarse. */
+    app.post("/admin/clientes/revocar", requireSecret, json, async (req, res) => {
+        const email = typeof req.body?.email === "string" ? req.body.email : "";
+        const clientId = typeof req.body?.cliente === "string" ? req.body.cliente : "";
+        const user = email ? await store.findUserByEmail(email) : null;
+        if (!user || !clientId)
+            return void res.status(404).json({ error: "No existe ese usuario o esa app." });
+        await store.revokeClient(user.id, clientId);
+        res.json({ revocado: true });
+    });
+}

package/build/oauth/expiring.js

@@ -0,0 +1,57 @@
+import { randomBytes } from "node:crypto";
+/**
+ * Valores que viven en memoria hasta que se usan o vencen: los pedidos de `/authorize` mientras el
+ * usuario completa el login y los codes hasta que el cliente los canjea. Si el servidor se reinicia,
+ * se pierden y el cliente vuelve a empezar el OAuth, que es lo que haría igual con un code vencido.
+ */
+export class Expiring {
+    ttlMs;
+    items = new Map();
+    /** `ttlMs` en milisegundos. */
+    constructor(ttlMs) {
+        this.ttlMs = ttlMs;
+    }
+    add(value) {
+        this.sweep();
+        const id = randomBytes(24).toString("base64url");
+        this.items.set(id, { value, expiresAt: Date.now() + this.ttlMs });
+        return id;
+    }
+    get(id) {
+        this.sweep();
+        return this.items.get(id)?.value;
+    }
+    /** Lo devuelve y lo borra: un code se canjea una sola vez. */
+    take(id) {
+        const value = this.get(id);
+        this.items.delete(id);
+        return value;
+    }
+    sweep() {
+        const now = Date.now();
+        for (const [id, item] of this.items)
+            if (item.expiresAt <= now)
+                this.items.delete(id);
+    }
+}
+/** Cuenta intentos por clave (la IP) en una ventana fija. */
+export class RateLimiter {
+    max;
+    windowMs;
+    hits = new Map();
+    /** `windowMs` en milisegundos. */
+    constructor(max, windowMs) {
+        this.max = max;
+        this.windowMs = windowMs;
+    }
+    allow(key) {
+        const now = Date.now();
+        for (const [k, hit] of this.hits)
+            if (hit.resetAt <= now)
+                this.hits.delete(k);
+        const hit = this.hits.get(key) ?? { count: 0, resetAt: now + this.windowMs };
+        hit.count++;
+        this.hits.set(key, hit);
+        return hit.count <= this.max;
+    }
+}

package/build/oauth/server.js

@@ -0,0 +1,272 @@
+import { createHash, randomUUID } from "node:crypto";
+import express from "express";
+import { buildOAuthProtectedResourceMetadata, checkResourceAllowed, getOAuthProtectedResourceMetadataUrl, } from "@modelcontextprotocol/server";
+import { linkAulaAccount } from "../aula-virtual/client/link.js";
+import { InvalidCredentialsError } from "../aula-virtual/client/sso-login.js";
+import { logger } from "../shared/logger.js";
+import { escapeHtml, page } from "../shared/pages.js";
+import { Expiring, RateLimiter } from "./expiring.js";
+/** Duración del access token, en segundos: una baja de acceso se aplica a más tardar en este tiempo. */
+const ACCESS_TTL = 60 * 60;
+/** Duración del refresh token, en segundos. Rota en cada uso. */
+const REFRESH_TTL = 30 * 24 * 60 * 60;
+/** Cuánto vive un code sin canjear, en milisegundos. */
+const CODE_TTL_MS = 60_000;
+/** Cuánto tiene el usuario para completar el login, en milisegundos. */
+const PENDING_TTL_MS = 10 * 60_000;
+/** Intentos de login por IP cada 15 minutos: que el servidor no sirva para probar contraseñas contra el SSO. */
+const LOGIN_ATTEMPTS = 10;
+const LOGIN_WINDOW_MS = 15 * 60_000;
+/** Esquemas de redirect_uri que nunca aceptamos. */
+const FORBIDDEN_SCHEMES = new Set(["javascript:", "data:", "file:", "vbscript:"]);
+/**
+ * Servidor de autorización OAuth 2.1 para los clientes MCP: registro dinámico, PKCE obligatorio y
+ * clientes públicos. El usuario se identifica con la UTN, y ese mismo login vincula su aula: la
+ * contraseña se usa una vez y no se guarda. Devuelve la URL de la metadata del recurso, que va en el 401.
+ */
+export function mountOAuth(app, { issuer, store, access, sameOrigin }) {
+    const resource = `${issuer}/mcp`;
+    const metadata = {
+        issuer,
+        authorization_endpoint: `${issuer}/authorize`,
+        token_endpoint: `${issuer}/token`,
+        registration_endpoint: `${issuer}/register`,
+        revocation_endpoint: `${issuer}/revoke`,
+        response_types_supported: ["code"],
+        grant_types_supported: ["authorization_code", "refresh_token"],
+        code_challenge_methods_supported: ["S256"],
+        token_endpoint_auth_methods_supported: ["none"],
+        revocation_endpoint_auth_methods_supported: ["none"],
+    };
+    // Valida el issuer al arrancar (HTTPS salvo en localhost) en lugar de en el primer request.
+    const resourceMetadata = buildOAuthProtectedResourceMetadata({
+        oauthMetadata: metadata,
+        resourceServerUrl: new URL(resource),
+        resourceName: "UTN-MCP",
+    });
+    const pending = new Expiring(PENDING_TTL_MS);
+    const codes = new Expiring(CODE_TTL_MS);
+    const limiter = new RateLimiter(LOGIN_ATTEMPTS, LOGIN_WINDOW_MS);
+    const form = express.urlencoded({ extended: false, limit: "16kb" });
+    app.get("/.well-known/oauth-authorization-server", cors, (_req, res) => void res.json(metadata));
+    app.get(["/.well-known/oauth-protected-resource", "/.well-known/oauth-protected-resource/mcp"], cors, (_req, res) => void res.json(resourceMetadata));
+    app.options(["/register", "/token", "/revoke"], cors, (_req, res) => void res.sendStatus(204));
+    app.post("/register", cors, express.json({ limit: "16kb" }), async (req, res) => {
+        const body = (req.body ?? {});
+        const uris = Array.isArray(body.redirect_uris) ? body.redirect_uris : [];
+        if (!uris.length || !uris.every(isAllowedRedirect)) {
+            return void oauthError(res, 400, "invalid_redirect_uri", "Mandá al menos una redirect_uri válida.");
+        }
+        const client = {
+            clientId: randomUUID(),
+            clientName: typeof body.client_name === "string" ? body.client_name.slice(0, 100) : null,
+            redirectUris: uris,
+        };
+        await store.saveClient(client);
+        res.status(201).json({
+            client_id: client.clientId,
+            client_id_issued_at: Math.floor(Date.now() / 1000),
+            client_name: client.clientName ?? undefined,
+            redirect_uris: client.redirectUris,
+            grant_types: ["authorization_code", "refresh_token"],
+            response_types: ["code"],
+            token_endpoint_auth_method: "none",
+        });
+    });
+    app.get("/authorize", async (req, res) => {
+        const q = req.query;
+        const client = q.client_id ? await store.findClient(q.client_id) : null;
+        // Sin cliente o redirect_uri válidos no se redirige a ningún lado: el error lo ve el usuario.
+        if (!client)
+            return void errorPage(res, 400, "Cliente desconocido", "Este cliente no está registrado. Volvé a conectarlo desde tu app.");
+        if (!q.redirect_uri || !client.redirectUris.includes(q.redirect_uri)) {
+            return void errorPage(res, 400, "Redirección inválida", "La redirect_uri no es la que registró el cliente.");
+        }
+        const fail = (error, description) => redirectWith(res, q.redirect_uri, { error, error_description: description, state: q.state });
+        if (q.response_type !== "code")
+            return void fail("unsupported_response_type", "Solo se acepta response_type=code.");
+        if (!q.code_challenge || q.code_challenge_method !== "S256") {
+            return void fail("invalid_request", "PKCE es obligatorio, con code_challenge_method=S256.");
+        }
+        if (q.resource && !checkResourceAllowed({ requestedResource: q.resource, configuredResource: resource })) {
+            return void fail("invalid_target", `El único recurso de este servidor es ${resource}.`);
+        }
+        const id = pending.add({
+            clientId: client.clientId,
+            clientName: client.clientName,
+            redirectUri: q.redirect_uri,
+            codeChallenge: q.code_challenge,
+            state: q.state,
+            resource: q.resource,
+        });
+        res.type("html").send(loginPage({ action: "/authorize", pendingId: id, clientName: client.clientName }));
+    });
+    app.post("/authorize", sameOrigin, form, async (req, res) => {
+        const id = String(req.body?.pedido ?? "");
+        const request = pending.get(id);
+        if (!request)
+            return void errorPage(res, 400, "Pedido vencido", "Pasó demasiado tiempo. Volvé a conectar desde tu app.");
+        const retry = (error) => res.type("html").send(loginPage({ action: "/authorize", pendingId: id, clientName: request.clientName, error }));
+        const account = await login(req, retry);
+        if (!account)
+            return;
+        const decision = await access({ username: account.username, email: account.email });
+        if (!decision.allowed)
+            return void deniedPage(res, decision.reason, decision.url);
+        pending.take(id);
+        const code = codes.add({
+            userId: account.userId,
+            clientId: request.clientId,
+            redirectUri: request.redirectUri,
+            codeChallenge: request.codeChallenge,
+        });
+        logger.info(`OAuth: ${account.username} autorizó a ${request.clientName ?? request.clientId}.`);
+        redirectWith(res, request.redirectUri, { code, state: request.state, iss: issuer });
+    });
+    app.post("/token", cors, form, express.json({ limit: "16kb" }), async (req, res) => {
+        const body = (req.body ?? {});
+        try {
+            if (body.grant_type === "authorization_code") {
+                const code = body.code ? codes.take(body.code) : undefined;
+                if (!code)
+                    return void oauthError(res, 400, "invalid_grant", "El code no existe, venció o ya se usó.");
+                if (body.client_id && body.client_id !== code.clientId) {
+                    return void oauthError(res, 400, "invalid_grant", "El code es de otro cliente.");
+                }
+                if (body.redirect_uri && body.redirect_uri !== code.redirectUri) {
+                    return void oauthError(res, 400, "invalid_grant", "La redirect_uri no coincide con la del pedido.");
+                }
+                if (!body.code_verifier || pkceChallenge(body.code_verifier) !== code.codeChallenge) {
+                    return void oauthError(res, 400, "invalid_grant", "El code_verifier no corresponde al code_challenge.");
+                }
+                return void res.json(await issueTokens(store, code.userId, code.clientId));
+            }
+            if (body.grant_type === "refresh_token") {
+                const found = body.refresh_token ? await store.findToken(body.refresh_token, "refresh") : null;
+                if (!found)
+                    return void oauthError(res, 400, "invalid_grant", "El refresh token no existe, venció o fue revocado.");
+                const clientId = found.clientId ?? body.client_id ?? "desconocido";
+                if (body.client_id && found.clientId && body.client_id !== found.clientId) {
+                    return void oauthError(res, 400, "invalid_grant", "El refresh token es de otro cliente.");
+                }
+                await store.revokeToken(body.refresh_token);
+                // El acceso se vuelve a mirar en cada refresh: si la cuenta se dio de baja, acá se corta.
+                const user = await store.findUser(found.userId);
+                if (!user)
+                    return void oauthError(res, 400, "invalid_grant", "El usuario ya no existe.");
+                const decision = await access({ username: user.utnUsername, email: user.email });
+                if (!decision.allowed)
+                    return void oauthError(res, 400, "invalid_grant", decision.reason);
+                return void res.json(await issueTokens(store, user.id, clientId));
+            }
+            oauthError(res, 400, "unsupported_grant_type", "Solo authorization_code y refresh_token.");
+        }
+        catch (e) {
+            logger.error(`OAuth /token: ${e.message}`);
+            oauthError(res, 500, "server_error", "Error interno al emitir el token.");
+        }
+    });
+    app.post("/revoke", cors, form, express.json({ limit: "16kb" }), async (req, res) => {
+        const token = req.body?.token;
+        if (token)
+            await store.revokeToken(token);
+        // RFC 7009: se contesta 200 aunque el token no exista.
+        res.sendStatus(200);
+    });
+    // Volver a iniciar sesión cuando vence la sesión del aula: no emite tokens, solo renueva la sesión.
+    app.get("/login", (_req, res) => void res.type("html").send(loginPage({ action: "/login" })));
+    app.post("/login", sameOrigin, form, async (req, res) => {
+        const account = await login(req, (error) => res.type("html").send(loginPage({ action: "/login", error })));
+        if (!account)
+            return;
+        logger.info(`OAuth: ${account.username} renovó su sesión del aula.`);
+        res.type("html").send(page("Listo", "<p>Ya renovamos tu sesión del aula. Volvé al chat y pedile al agente que reintente.</p>"));
+    });
+    /** Entra al aula con lo que mandó el formulario; si falla, vuelve a mostrarlo con el error. */
+    async function login(req, retry) {
+        if (!limiter.allow(req.ip ?? "desconocida")) {
+            retry("Demasiados intentos. Esperá unos minutos y probá de nuevo.");
+            return null;
+        }
+        const username = String(req.body?.usuario ?? "").trim();
+        const password = String(req.body?.contrasena ?? "");
+        if (!username || !password) {
+            retry("Completá usuario y contraseña.");
+            return null;
+        }
+        try {
+            return await linkAulaAccount(store, { username, password });
+        }
+        catch (e) {
+            if (e instanceof InvalidCredentialsError)
+                retry("La UTN rechazó el usuario o la contraseña.");
+            else {
+                logger.error(`Login de ${username}: ${e.message}`);
+                retry("No pudimos entrar al aula. Puede que esté caída: probá de nuevo en unos minutos.");
+            }
+            return null;
+        }
+    }
+    return getOAuthProtectedResourceMetadataUrl(new URL(resource));
+}
+async function issueTokens(store, userId, clientId) {
+    const accessToken = await store.issueToken(userId, { kind: "access", clientId, ttlSeconds: ACCESS_TTL });
+    const refreshToken = await store.issueToken(userId, { kind: "refresh", clientId, ttlSeconds: REFRESH_TTL });
+    return { access_token: accessToken, token_type: "Bearer", expires_in: ACCESS_TTL, refresh_token: refreshToken };
+}
+const pkceChallenge = (verifier) => createHash("sha256").update(verifier).digest("base64url");
+/** HTTPS, http solo en loopback (clientes de escritorio) o un esquema propio de una app (`cursor://`). */
+function isAllowedRedirect(uri) {
+    if (typeof uri !== "string")
+        return false;
+    try {
+        const url = new URL(uri);
+        if (FORBIDDEN_SCHEMES.has(url.protocol) || url.hash)
+            return false;
+        if (url.protocol === "http:")
+            return ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Los endpoints que llaman los clientes desde el navegador (como el MCP Inspector) aceptan cualquier origen. */
+const cors = (_req, res, next) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "content-type, authorization, mcp-protocol-version");
+    next();
+};
+function redirectWith(res, base, params) {
+    const url = new URL(base);
+    for (const [k, v] of Object.entries(params))
+        if (v !== undefined)
+            url.searchParams.set(k, v);
+    res.redirect(302, url.toString());
+}
+function oauthError(res, status, error, description) {
+    res.status(status).json({ error, error_description: description });
+}
+function errorPage(res, status, title, message) {
+    res.status(status).type("html").send(page(title, `<p>${escapeHtml(message)}</p>`));
+}
+function deniedPage(res, reason, url) {
+    const link = url ? `<p><a href="${escapeHtml(url)}">${escapeHtml(url)}</a></p>` : "";
+    res.status(403).type("html").send(page("Sin acceso", `<p>${escapeHtml(reason)}</p>${link}`));
+}
+function loginPage(o) {
+    const intro = o.pendingId
+        ? `<p>${escapeHtml(o.clientName ?? "Una app")} quiere usar UTN-MCP con tu Aula Virtual. Entrá con tu usuario de la UTN para conectarla.</p>`
+        : "<p>Tu sesión del aula venció. Entrá con tu usuario de la UTN para renovarla.</p>";
+    const error = o.error ? `<p class=error>${escapeHtml(o.error)}</p>` : "";
+    const hidden = o.pendingId ? `<input type="hidden" name="pedido" value="${escapeHtml(o.pendingId)}">` : "";
+    return page("Entrar con la UTN", intro +
+        error +
+        `<form method="post" action="${o.action}">${hidden}` +
+        `<label>Usuario<input name="usuario" autocomplete="username" autocapitalize="none" required></label>` +
+        `<label>Contraseña<input name="contrasena" type="password" autocomplete="current-password" required></label>` +
+        `<button type="submit">Entrar</button></form>` +
+        "<p class=nota>La contraseña se usa una sola vez para entrar al aula y no se guarda. " +
+        'El código es abierto: <a href="https://github.com/nialvape/utn-mcp">github.com/nialvape/utn-mcp</a>.</p>', o.pendingId ? "Conectar app · Aula Virtual" : "Renovar sesión · Aula Virtual");
+}

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

package/build/shared/pages.js

@@ -0,0 +1,61 @@
+/**
+ * Los colores del sitio del proyecto: papel milimetrado, tinta y un azul de acento. Oscuro salvo que
+ * el sistema pida claro. Sin fuentes externas: la página de login recibe contraseñas.
+ */
+const STYLE = `
+:root{--paper:#0a0b0d;--ink:#e9e7e0;--muted:#8b8a84;--line:rgb(233 231 224/.055);--line-faint:rgb(233 231 224/.025);
+--line-strong:rgb(233 231 224/.16);--accent:#6b93ff;--err:#f87171;--panel:rgb(20 21 24/.6);color-scheme:dark}
+@media(prefers-color-scheme:light){:root{--paper:#f3f2ec;--ink:#121212;--muted:#6d6c66;--line:rgb(18 18 18/.07);
+--line-faint:rgb(18 18 18/.035);--line-strong:rgb(18 18 18/.2);--accent:#1f4fd6;--err:#b91c1c;--panel:rgb(255 255 255/.55);color-scheme:light}}
+*{box-sizing:border-box}
+body{margin:0;min-height:100vh;color:var(--ink);font:15px/1.55 ui-sans-serif,system-ui,-apple-system,"Segoe UI",sans-serif;
+background-color:var(--paper);background-image:linear-gradient(var(--line) 1px,transparent 1px),
+linear-gradient(90deg,var(--line) 1px,transparent 1px),linear-gradient(var(--line-faint) 1px,transparent 1px),
+linear-gradient(90deg,var(--line-faint) 1px,transparent 1px);background-size:80px 80px,80px 80px,16px 16px,16px 16px;
+background-position:-1px -1px}
+.mono,label,button,.kicker,header{font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace}
+header{display:flex;align-items:center;gap:.5rem;height:3.5rem;padding:0 1rem;border-bottom:1px solid var(--line);
+font-size:13px;letter-spacing:-.01em;background:color-mix(in srgb,var(--paper) 75%,transparent)}
+header svg{height:1.5rem;width:auto}
+main{max-width:28rem;margin:3rem auto;padding:0 1rem}
+.card{position:relative;border:1px solid var(--line-strong);background:var(--panel);padding:1.5rem}
+.card::before,.card::after{content:"";position:absolute;width:9px;height:9px;border-color:var(--ink);opacity:.55}
+.card::before{top:-1px;left:-1px;border-top:1px solid;border-left:1px solid}
+.card::after{bottom:-1px;right:-1px;border-bottom:1px solid;border-right:1px solid}
+.kicker{margin:0 0 .5rem;font-size:10px;text-transform:uppercase;letter-spacing:.16em;color:var(--muted)}
+h1{margin:0 0 1rem;font-size:1.5rem;font-weight:600;letter-spacing:-.02em;line-height:1.2}
+p{margin:.75rem 0}
+a{color:var(--accent);text-underline-offset:4px}
+form{display:flex;flex-direction:column;gap:1rem;margin:1.5rem 0}
+label{display:flex;flex-direction:column;gap:.4rem;font-size:10px;text-transform:uppercase;letter-spacing:.16em;color:var(--muted)}
+input{font:inherit;font-size:15px;letter-spacing:normal;text-transform:none;color:var(--ink);background:transparent;
+border:1px solid var(--line-strong);border-radius:0;padding:.65rem .75rem}
+input:focus{outline:none;border-color:var(--accent)}
+input[type=file]{padding:.5rem}
+button{font-size:12px;text-transform:uppercase;letter-spacing:.14em;border:0;border-radius:0;padding:.8rem 1rem;
+background:var(--ink);color:var(--paper);cursor:pointer;transition:background .15s}
+button:hover{background:var(--accent)}
+.nota{font-size:13px;color:var(--muted)}
+.error{border-left:2px solid var(--err);padding-left:.75rem;color:var(--err)}
+ul{padding-left:1.2rem}
+::selection{background:var(--accent);color:var(--paper)}
+`.replace(/\n/g, "");
+/** El emblema del proyecto: el de la UTN con "MCP" en lugar de "UTN". */
+const MARK = '<svg viewBox="0 0 100 132" fill="none" aria-hidden="true"><g stroke="currentColor" stroke-width="11">' +
+    '<path d="M50 0v100M0 50h100"/><path d="M19 0v19a11 11 0 0 0 11 11h40a11 11 0 0 0 11-11V0"/>' +
+    '<path d="M19 100V81a11 11 0 0 1 11-11h40a11 11 0 0 1 11 11v19"/></g>' +
+    '<text x="50" y="131" text-anchor="middle" textLength="72" lengthAdjust="spacingAndGlyphs" ' +
+    'font-family="Arial,Helvetica,sans-serif" font-weight="900" font-size="29" fill="currentColor">MCP</text></svg>';
+/**
+ * Página mínima con el estilo del sitio del proyecto: se abre desde el celu, así que nada más que lo necesario.
+ * `kicker` es la etiqueta chica arriba del título.
+ */
+export function page(title, body, kicker = "UTN-MCP") {
+    return (`<!doctype html><html lang="es"><head><meta charset="utf-8">` +
+        `<meta name="viewport" content="width=device-width, initial-scale=1"><title>${escapeHtml(title)} · UTN-MCP</title>` +
+        `<style>${STYLE}</style></head><body>` +
+        `<header>${MARK}utn·mcp</header>` +
+        `<main><div class="card"><p class="kicker">${escapeHtml(kicker)}</p><h1>${escapeHtml(title)}</h1>${body}</div></main>` +
+        `</body></html>`);
+}
+export const escapeHtml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");

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 {};