utn-mcp 0.7.0 → 0.8.1

package/build/aula-virtual/login.js

@@ -1,31 +1,34 @@
-import { ask, askHidden } from "../shared/input.js";
+import { ask, askChoice, 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";
+import { availableRegionals, defaultRegional } from "./client/regionals.js";
 /**
- * `utn-mcp login`: pide usuario y contraseña una vez, los guarda en el keychain
+ * `utn-mcp login`: pide la regional, 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(http) {
-    const username = (await ask("Usuario institucional de la UTN: ")).trim();
+    const regional = await askRegional();
+    const prompt = regional.sso?.provider === "microsoft" ? "Mail de Office 365: " : "Usuario de la UTN: ";
+    const username = (await ask(prompt)).trim();
     if (!username)
         throw new Error("Falta el usuario.");
     const password = await askHidden("Contraseña: ");
-    const credentials = { username, password };
+    const credentials = { username, password, regional: regional.id };
     let accessToken = null;
     if (http)
-        accessToken = await loginToStore(credentials);
+        accessToken = await loginToStore(regional, credentials);
     else
-        await new LocalSession().login(credentials);
-    // Se guardan recién después de comprobar que el SSO las aceptó.
+        await new LocalSession().login(regional, credentials);
+    // Se guardan recién después de comprobar que el aula las aceptó.
     if (await saveCredentials(credentials)) {
         logger.info("Credenciales guardadas en el keychain del sistema.");
     }
     else {
-        logger.warn("No hay keychain disponible: para renovar sin intervención definí UTN_USER y UTN_PASS.");
+        logger.warn("No hay keychain disponible: para renovar sin intervención definí UTN_USER, UTN_PASS y UTN_REGIONAL.");
     }
     if (accessToken) {
         logger.info("Listo. Configurá tu cliente MCP con este header; no se vuelve a mostrar:\n\n" +
@@ -35,9 +38,21 @@ export async function runLogin(http) {
         logger.info("Listo: ya podés usar el servidor MCP.");
     }
 }
+const SUPPORT_LABEL = {
+    verified: "",
+    candidate: " · sin probar todavía",
+    unsupported: " · todavía sin soporte",
+};
+/** Arranca marcada la de UTN_REGIONAL (o FRBA). */
+async function askRegional() {
+    const regionals = availableRegionals();
+    const initial = regionals.findIndex((r) => r.id === defaultRegional().id);
+    const labels = regionals.map((r) => r.name + SUPPORT_LABEL[r.support]);
+    return regionals[await askChoice("Regional:", labels, Math.max(initial, 0))];
+}
 /** Crea el usuario si no existe, guarda su sesión del aula y le emite un token que no vence. */
-async function loginToStore(credentials) {
+async function loginToStore(regional, credentials) {
     const store = await SqliteStore.open();
-    const { userId } = await linkAulaAccount(store, credentials);
+    const { userId } = await linkAulaAccount(store, regional, credentials);
     return store.issueToken(userId, { kind: "access", clientId: "local" });
 }

package/build/aula-virtual/tools.js

@@ -17,12 +17,16 @@ const failure = (e) => ({
 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.",
+        description: "Datos del usuario logueado y del sitio Moodle de su aula virtual. `regional` es la regional de la UTN " +
+            "de esa aula (por ejemplo, \"Tucumán (FRT)\"): usala para hablarle de su facultad.",
         annotations: READ_ONLY,
     }, async () => {
         try {
-            const { sitename, fullname, username, userid, release } = await getSiteInfo(session);
-            return json({ sitename, fullname, username, userid, release });
+            const [{ sitename, fullname, username, userid, release }, regional] = await Promise.all([
+                getSiteInfo(session),
+                session.getRegional(),
+            ]);
+            return json({ regional: regional.name, sitename, fullname, username, userid, release });
         }
         catch (e) {
             return failure(e);
@@ -271,7 +275,8 @@ export function registerAulaVirtualTools(server, session, files) {
                 '`-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. " +
+                "Subir al link no entrega nada. Cada link acepta una sola subida: si hay que cambiar los " +
+                "archivos, pedí otro link. " +
                 "`acepta` trae los límites de la tarea.",
             inputSchema: z.object({
                 direccion: z
@@ -299,7 +304,8 @@ export function registerAulaVirtualTools(server, session, files) {
                 '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"].'),
+                'Ej: ["https://<aula>/pluginfile.php/123/assignsubmission_file/submission_files/456/TP3.pdf"], ' +
+                "con el dominio del aula tal como viene en la `url`."),
         texto: z
             .string()
             .optional()

package/build/http.js

@@ -3,7 +3,7 @@ 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 { cors, 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";
@@ -43,12 +43,14 @@ function storeVerifier(store) {
 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 { host, port, publicUrl, access, redirects, adminSecret } = options;
     const handler = createMcpHandler(factory, { onerror: (e) => logger.error(e.message) });
     const verifier = storeVerifier(store);
     const app = express();
     // 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");
+    app.disable("x-powered-by");
+    app.use(securityHeaders(publicUrl?.startsWith("https://") ?? false));
     // 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)) {
@@ -62,6 +64,7 @@ export function startHttpServer(factory, options, store, inbox) {
         store,
         access,
         sameOrigin,
+        redirects,
     });
     if (adminSecret)
         mountAdmin(app, store, adminSecret);
@@ -79,13 +82,20 @@ export function startHttpServer(factory, options, store, inbox) {
             res.send(await challenge.text());
         }
     };
+    // Publicado, /mcp acepta cualquier origen: se autentica con el bearer, que el navegador no manda solo
+    // (no hay cookies), así que una página ajena no lo puede usar en nombre de nadie. Hay clientes que lo
+    // llaman desde su web, como Grok. En local sigue el chequeo de Origin, contra DNS rebinding.
+    const mcpOrigin = publicUrl ? cors : sameOrigin;
+    app.options("/mcp", mcpOrigin, (_req, res) => void res.sendStatus(204));
     // Sin express.json(): el handler lee el body por su cuenta.
-    app.all("/mcp", sameOrigin, requireToken, toNodeHandler(handler));
+    app.all("/mcp", mcpOrigin, 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));
+        if (upload.files)
+            return void res.status(409).type("html").send(page("Link ya usado", USED));
         res.type("html").send(page(upload.title, uploadForm(upload.limits)));
     });
     app.post("/subir/:id", sameOrigin, (req, res) => receiveUpload(inbox, req, res));
@@ -102,17 +112,21 @@ async function receiveUpload(inbox, req, res) {
         ? 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))
+    const upload = inbox.get(id);
+    if (!upload)
         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)}.`);
-    }
+    if (upload.files)
+        return void fail(409, "Este link ya se usó. Pedile al agente uno nuevo.");
+    const tooBig = `La subida pasa el máximo de ${formatSize(MAX_UPLOAD_BYTES)}.`;
+    if (Number(req.headers["content-length"]) > MAX_UPLOAD_BYTES)
+        return void fail(413, tooBig);
+    const body = limitBytes(Readable.toWeb(req), 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),
+            body: body.stream,
             duplex: "half",
         });
         const form = await request.formData();
@@ -131,10 +145,44 @@ async function receiveUpload(inbox, req, res) {
         }
     }
     catch (e) {
-        fail(400, e.message);
+        if (body.exceeded()) {
+            fail(413, tooBig);
+            req.destroy();
+        }
+        else {
+            fail(400, e.message);
+        }
     }
 }
+function limitBytes(source, maxBytes) {
+    let total = 0;
+    const stream = source.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            total += chunk.length;
+            if (total > maxBytes)
+                controller.error(new Error("La subida es demasiado grande."));
+            else
+                controller.enqueue(chunk);
+        },
+    }));
+    return { stream, exceeded: () => total > maxBytes };
+}
+function securityHeaders(https) {
+    return (_req, res, next) => {
+        res.setHeader("Content-Security-Policy", "default-src 'none'; style-src 'unsafe-inline'; img-src 'self' data:; frame-ancestors 'none'; base-uri 'none'");
+        res.setHeader("X-Frame-Options", "DENY");
+        res.setHeader("X-Content-Type-Options", "nosniff");
+        // `same-origin` y no `no-referrer`: con `no-referrer` el navegador manda `Origin: null` en los POST de
+        // formularios, y el chequeo de Origin rechaza el login.
+        res.setHeader("Referrer-Policy", "same-origin");
+        // Un año, en segundos.
+        if (https)
+            res.setHeader("Strict-Transport-Security", "max-age=31536000");
+        next();
+    };
+}
 const EXPIRED = "<p>Este link de subida venció o ya no existe. Pedile al agente uno nuevo.</p>";
+const USED = "<p>Ya se subieron archivos a este link y no se pueden cambiar. Si te equivocaste, pedile al agente uno nuevo.</p>";
 function uploadForm(limits) {
     const rules = [
         limits.maxFiles ? `hasta ${limits.maxFiles} archivo(s)` : "",

package/build/index.js

@@ -1,30 +1,26 @@
 #!/usr/bin/env node
-import { existsSync } from "node:fs";
+import "./shared/load-env.js";
 import { parseArgs } from "node:util";
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
 import { LocalSession } from "./aula-virtual/client/local-session.js";
+import { defaultRegional } from "./aula-virtual/client/regionals.js";
 import { StoredAulaSession } from "./aula-virtual/client/stored-session.js";
 import { runLogin } from "./aula-virtual/login.js";
 import { startHttpServer, userIdOf } from "./http.js";
 import { accessPolicyFromEnv } from "./oauth/access.js";
+import { redirectAllowlistFromEnv } from "./oauth/redirects.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 [--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
-
+const USAGE = `Uso:
+  utn-mcp                 servidor MCP por STDIO (lo lanza el cliente)
+  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: {
@@ -39,6 +35,8 @@ async function main() {
         console.error(USAGE);
         return;
     }
+    // Una UTN_REGIONAL que no existe corta acá: si no, recién fallaría al primer login o al primer pedido.
+    defaultRegional();
     if (positionals[0] === "login") {
         await runLogin(values.http);
         return;
@@ -63,6 +61,7 @@ async function main() {
             port,
             publicUrl,
             access: accessPolicyFromEnv(),
+            redirects: redirectAllowlistFromEnv(),
             adminSecret: process.env.UTN_MCP_ADMIN_SECRET || undefined,
         };
         startHttpServer(factory, options, store, inbox);

package/build/oauth/access.js

@@ -23,18 +23,18 @@ function listPolicy(raw) {
         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? }`. */
+/** `POST url` con `{ email, usuario, regional }`; 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 }) => {
+    return async ({ regional, 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 }),
+                body: JSON.stringify({ email, usuario: username, regional }),
                 signal: AbortSignal.timeout(ACCESS_TIMEOUT_MS),
             });
             if (!res.ok)

package/build/oauth/admin.js

@@ -1,13 +1,25 @@
 import { timingSafeEqual } from "node:crypto";
 import express from "express";
+import { linkAulaAccount } from "../aula-virtual/client/link.js";
+import { availableRegionals } from "../aula-virtual/client/regionals.js";
+import { InvalidCredentialsError } from "../aula-virtual/client/sso-login.js";
 import { AULA_PLATFORM } from "../aula-virtual/client/stored-session.js";
+import { logger } from "../shared/logger.js";
+import { RateLimiter } from "./expiring.js";
+/** Intentos de `/admin/verificar` por cuenta del aula cada 15 minutos: que no sirva para probar contraseñas. */
+const VERIFY_ATTEMPTS = 5;
+const VERIFY_WINDOW_MS = 15 * 60_000;
+const SUPPORT = { verified: "verificada", candidate: "candidata", unsupported: "sin_soporte" };
+/** Segundos desde epoch, como los guarda el store, a ISO. */
+const isoDate = (seconds) => new Date(seconds * 1000).toISOString();
 /**
- * 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.
+ * API para que otro servicio del que hostea (un panel de cuenta, por ejemplo) liste usuarios, muestre y
+ * desconecte sus apps, consulte las regionales y dé de alta cuentas vinculando su aula. Solo
+ * existe con UTN_MCP_ADMIN_SECRET, que va como `Authorization: Bearer`. Los usuarios se buscan por email.
  */
 export function mountAdmin(app, store, secret) {
     const json = express.json({ limit: "4kb" });
+    const verifyLimiter = new RateLimiter(VERIFY_ATTEMPTS, VERIFY_WINDOW_MS);
     const requireSecret = (req, res, next) => {
         const got = Buffer.from(req.headers.authorization ?? "");
         const want = Buffer.from(`Bearer ${secret}`);
@@ -15,25 +27,34 @@ export function mountAdmin(app, store, secret) {
             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: [] });
+    /** El usuario, su regional, cuándo se renovó su sesión del aula y sus apps conectadas. */
+    async function summary(user) {
         const [clients, aulaAt] = await Promise.all([
             store.listConnectedClients(user.id),
             store.sessionUpdatedAt(user.id, AULA_PLATFORM),
         ]);
-        res.json({
+        return {
             usuario: user.utnUsername,
-            sesionAula: aulaAt ? new Date(aulaAt * 1000).toISOString() : undefined,
+            regional: user.regional,
+            sesionAula: aulaAt ? isoDate(aulaAt) : 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(),
+                ultimoUso: isoDate(c.lastTokenAt),
             })),
-        });
+        };
+    }
+    /** `{ email }` → el resumen de ese usuario. */
+    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;
+        res.json(user ? await summary(user) : { clientes: [] });
+    });
+    /** Todos los usuarios con su resumen, para el panel de quien administra el servidor. */
+    app.post("/admin/usuarios", requireSecret, async (_req, res) => {
+        const users = await store.listUsers();
+        const usuarios = await Promise.all(users.map(async (u) => ({ email: u.email || undefined, alta: isoDate(u.createdAt), ...(await summary(u)) })));
+        res.json({ usuarios });
     });
     /** `{ email, cliente }` → borra los tokens de esa app: tiene que volver a conectarse. */
     app.post("/admin/clientes/revocar", requireSecret, json, async (req, res) => {
@@ -45,4 +66,50 @@ export function mountAdmin(app, store, secret) {
         await store.revokeClient(user.id, clientId);
         res.json({ revocado: true });
     });
+    /** Las regionales que se pueden elegir, con su soporte en este servidor. */
+    app.post("/admin/regionales", requireSecret, async (_req, res) => {
+        const regionales = availableRegionals(await store.listVerifiedRegionals()).map((r) => ({
+            id: r.id,
+            nombre: r.name,
+            soporte: SUPPORT[r.support],
+        }));
+        res.json({ regionales });
+    });
+    /**
+     * `{ regional, usuario, contrasena }` → entra al aula como el login de OAuth: crea el usuario si no
+     * existe y le guarda la sesión, así ya puede usar las tools. Devuelve `{ usuario, nombre, email,
+     * primero? }`, con `primero` si fue el primero en verificar la regional; si no entra, `{ error, motivo }`.
+     */
+    app.post("/admin/verificar", requireSecret, json, async (req, res) => {
+        const id = typeof req.body?.regional === "string" ? req.body.regional : "";
+        const username = typeof req.body?.usuario === "string" ? req.body.usuario.trim() : "";
+        const password = typeof req.body?.contrasena === "string" ? req.body.contrasena : "";
+        const regional = availableRegionals(await store.listVerifiedRegionals()).find((r) => r.id === id);
+        if (!regional || !username || !password) {
+            return void res.status(400).json({ error: "pedido", motivo: "Faltan la regional, el usuario o la contraseña." });
+        }
+        if (regional.support === "unsupported") {
+            return void res.status(422).json({ error: "sin_soporte", motivo: `Todavía no hay soporte para ${regional.name}.` });
+        }
+        if (!verifyLimiter.allow(`${regional.id}:${username.toLowerCase()}`)) {
+            return void res.status(429).json({ error: "intentos", motivo: "Demasiados intentos. Esperá unos minutos." });
+        }
+        try {
+            const account = await linkAulaAccount(store, regional, { username, password });
+            logger.info(`Admin: ${account.username} (${regional.id}) vinculó su aula.`);
+            res.json({
+                usuario: account.username,
+                nombre: account.fullname,
+                email: account.email ?? undefined,
+                primero: account.firstVerifier || undefined,
+            });
+        }
+        catch (e) {
+            if (e instanceof InvalidCredentialsError) {
+                return void res.status(401).json({ error: "credenciales", motivo: "El aula rechazó el usuario o la contraseña." });
+            }
+            logger.warn(`Verificación de ${username} (${regional.id}): ${e.message}`);
+            res.status(502).json({ error: "aula", motivo: `No pudimos entrar al aula de ${regional.name}.` });
+        }
+    });
 }

package/build/oauth/redirects.js

@@ -0,0 +1,60 @@
+/** Los callbacks de los clientes MCP conocidos (Claude, ChatGPT, Grok, Gemini, VS Code web) y los esquemas de editores. */
+const DEFAULT_HOSTS = [
+    "claude.ai",
+    "claude.com",
+    "chatgpt.com",
+    "chat.openai.com",
+    "grok.com",
+    "gemini.google.com",
+    "vscode.dev",
+    "insiders.vscode.dev",
+];
+const DEFAULT_SCHEMES = ["cursor:", "vscode:", "vscode-insiders:", "windsurf:"];
+/** En loopback la redirección queda en la compu del usuario: ahí escuchan los clientes de escritorio. */
+const LOOPBACK = ["localhost", "127.0.0.1", "[::1]"];
+/**
+ * Los conocidos más los de UTN_MCP_REDIRECT_ALLOW, separados por coma: hosts (`app.ejemplo.com`)
+ * o esquemas terminados en dos puntos (`miapp:`).
+ */
+export function redirectAllowlistFromEnv(env = process.env) {
+    const extra = (env.UTN_MCP_REDIRECT_ALLOW ?? "").split(",").map((e) => e.trim().toLowerCase()).filter(Boolean);
+    return {
+        hosts: new Set([...DEFAULT_HOSTS, ...extra.filter((e) => !e.endsWith(":"))]),
+        schemes: new Set([...DEFAULT_SCHEMES, ...extra.filter((e) => e.endsWith(":"))]),
+    };
+}
+/**
+ * `trusted`: loopback, un host HTTPS de la lista o el esquema de una app de la lista.
+ * `unknown`: cualquier otro host HTTPS, como el de un agente propio; se acepta con aviso.
+ * `rejected`: el resto.
+ */
+export function redirectTrust(uri, allow) {
+    if (typeof uri !== "string")
+        return "rejected";
+    let url;
+    try {
+        url = new URL(uri);
+    }
+    catch {
+        return "rejected";
+    }
+    if (url.hash || url.username || url.password)
+        return "rejected";
+    if (url.protocol === "http:" || url.protocol === "https:") {
+        if (LOOPBACK.includes(url.hostname))
+            return "trusted";
+        if (url.protocol === "http:")
+            return "rejected";
+        return allow.hosts.has(url.hostname) ? "trusted" : "unknown";
+    }
+    return allow.schemes.has(url.protocol) ? "trusted" : "rejected";
+}
+/** Cómo se le nombra al usuario el destino. */
+export function describeRedirect(uri) {
+    const url = new URL(uri);
+    if (LOOPBACK.includes(url.hostname))
+        return "una app en tu compu";
+    if (url.protocol === "https:")
+        return url.hostname;
+    return `la app ${url.protocol.slice(0, -1)}`;
+}