utn-mcp 0.8.3 → 0.9.0

package/build/autogestion/client/install.js

@@ -0,0 +1,72 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join } from "node:path";
+import { gunzipSync } from "node:zlib";
+import { HttpError } from "../../shared/http.js";
+import { configDir } from "../../shared/paths.js";
+/** Donde quedan los conectores instalados, uno por carpeta con el nombre de su paquete. */
+export const connectorsDir = () => join(configDir(), "connectors");
+export const connectorDir = (entry) => join(connectorsDir(), entry.package);
+/** El package.json del conector instalado, o null si no está. */
+export async function installedManifest(entry) {
+    try {
+        return JSON.parse(await readFile(join(connectorDir(entry), "package.json"), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** Bloques del formato tar: encabezado y datos van de a 512 bytes. */
+const TAR_BLOCK = 512;
+/**
+ * Baja el `.tgz` del catálogo, comprueba su hash y lo extrae en su carpeta. Sin `npm install`: los
+ * conectores no tienen dependencias, así que alcanza con desempaquetarlos, y no hace falta npm en la máquina.
+ */
+export async function installConnector(entry) {
+    let res;
+    try {
+        res = await fetch(entry.tarball, { signal: AbortSignal.timeout(60_000) });
+    }
+    catch (e) {
+        throw new HttpError(`No se pudo bajar el conector de ${entry.name}: ${e.message}`);
+    }
+    if (!res.ok)
+        throw new HttpError(`HTTP ${res.status} al bajar el conector de ${entry.name} (${entry.tarball}).`, res.status);
+    const tgz = Buffer.from(await res.arrayBuffer());
+    const integrity = `sha512-${createHash("sha512").update(tgz).digest("base64")}`;
+    if (integrity !== entry.integrity) {
+        throw new Error(`El conector de ${entry.name} que se bajó no es el que espera esta versión de utn-mcp: no se instala.`);
+    }
+    const target = connectorDir(entry);
+    const staging = `${target}.tmp-${process.pid}`;
+    await rm(staging, { recursive: true, force: true });
+    await extractPackage(tgz, staging);
+    await rm(target, { recursive: true, force: true });
+    await rename(staging, target);
+}
+/** Extrae los archivos de `package/` de un tarball de `npm pack`; cualquier ruta que salga de ahí se rechaza. */
+async function extractPackage(tgz, dest) {
+    const tar = gunzipSync(tgz);
+    const text = (start, length) => tar.subarray(start, start + length).toString("utf8").replace(/\0.*$/s, "");
+    for (let offset = 0; offset + TAR_BLOCK <= tar.length;) {
+        if (tar.subarray(offset, offset + TAR_BLOCK).every((b) => b === 0))
+            break;
+        const name = text(offset, 100);
+        const prefix = text(offset + 345, 155);
+        const size = parseInt(text(offset + 124, 12).trim() || "0", 8);
+        // "0" o NUL es un archivo común; los demás (carpetas, encabezados pax) no traen nada que escribir.
+        const type = String.fromCharCode(tar[offset + 156]);
+        const path = prefix ? `${prefix}/${name}` : name;
+        const data = offset + TAR_BLOCK;
+        if (type === "0" || type === "\0") {
+            const relative = path.replace(/^package\//, "");
+            if (!path.startsWith("package/") || isAbsolute(relative) || relative.split(/[\\/]/).includes("..")) {
+                throw new Error(`El conector trae una ruta inválida (${path}): no se instala.`);
+            }
+            const file = join(dest, relative);
+            await mkdir(dirname(file), { recursive: true });
+            await writeFile(file, tar.subarray(data, data + size));
+        }
+        offset = data + Math.ceil(size / TAR_BLOCK) * TAR_BLOCK;
+    }
+}

package/build/autogestion/client/installed-systems.d.ts

@@ -0,0 +1,7 @@
+import type { AutogestionSystem } from "./connector.js";
+/**
+ * Los conectores disponibles: los del catálogo que `utn-mcp login` instaló en la carpeta de datos y,
+ * a mano, los paquetes que nombre `UTN_MCP_CONNECTORS`, resueltos desde la carpeta en la que arranca
+ * el proceso. Esa variable es para probar un conector propio: cargarlo ejecuta su código.
+ */
+export declare function loadInstalledSystems(): Promise<AutogestionSystem[]>;

package/build/autogestion/client/installed-systems.js

@@ -0,0 +1,58 @@
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { logger } from "../../shared/logger.js";
+import { CATALOG } from "./catalog.js";
+import { connectorDir, installedManifest } from "./install.js";
+/**
+ * Los conectores disponibles: los del catálogo que `utn-mcp login` instaló en la carpeta de datos y,
+ * a mano, los paquetes que nombre `UTN_MCP_CONNECTORS`, resueltos desde la carpeta en la que arranca
+ * el proceso. Esa variable es para probar un conector propio: cargarlo ejecuta su código.
+ */
+export async function loadInstalledSystems() {
+    const systems = [];
+    for (const entry of CATALOG) {
+        const system = await loadFromCatalog(entry);
+        if (system)
+            systems.push(system);
+    }
+    const manual = process.env.UTN_MCP_CONNECTORS?.split(",").map((name) => name.trim()).filter(Boolean) ?? [];
+    const require = createRequire(join(process.cwd(), "package.json"));
+    for (const name of new Set(manual)) {
+        const system = validSystem(await import(pathToFileURL(require.resolve(name)).href), name);
+        if (systems.some((existing) => existing.id === system.id || existing.regionales.some((id) => system.regionales.includes(id)))) {
+            throw new Error(`El conector ${name} repite un sistema o una regional que ya cubre otro conector.`);
+        }
+        systems.push(system);
+    }
+    return systems;
+}
+/** El conector del catálogo si está instalado y es la versión que espera este core; si no, null. */
+async function loadFromCatalog(entry) {
+    const manifest = await installedManifest(entry);
+    if (!manifest)
+        return null;
+    if (manifest.version !== entry.version) {
+        logger.warn(`El conector de ${entry.name} instalado es la versión ${manifest.version} y esta versión de utn-mcp usa la ` +
+            `${entry.version}: corré \`utn-mcp login autogestion\` para actualizarlo.`);
+        return null;
+    }
+    const system = validSystem(await import(pathToFileURL(join(connectorDir(entry), manifest.main ?? "index.js")).href), entry.package);
+    if (system.id !== entry.id)
+        throw new Error(`El paquete ${entry.package} no es el conector ${entry.id}.`);
+    return system;
+}
+function validSystem(module, source) {
+    const system = module.default;
+    const nonEmpty = (value) => typeof value === "string" && value.trim() !== "";
+    if (!system ||
+        !nonEmpty(system.id) ||
+        !nonEmpty(system.name) ||
+        !Array.isArray(system.regionales) ||
+        system.regionales.length === 0 ||
+        !system.regionales.every(nonEmpty) ||
+        typeof system.create !== "function") {
+        throw new Error(`El paquete ${source} no exporta un conector de autogestión válido.`);
+    }
+    return system;
+}

package/build/autogestion/client/local-session.d.ts

@@ -0,0 +1,17 @@
+import { type AutogestionConnector, type AutogestionSystem } from "./connector.js";
+import type { AutogestionSession } from "./session.js";
+/**
+ * Sesión del modo local: un solo usuario, el de la compu. Recibe el sistema ya resuelto para la
+ * regional (la misma que eligió para el aula) y loguea el conector con las credenciales del
+ * keychain o las env vars, una vez por sistema y bajo demanda: el primer uso es el que pide login.
+ */
+export declare class LocalAutogestionSession implements AutogestionSession {
+    private readonly system;
+    private readonly regionalId;
+    /** Conectores ya logueados, por sistema: un login alcanza para todas las tools. */
+    private readonly connectors;
+    /** El sistema llega resuelto desde afuera: las plataformas no se conocen entre sí. */
+    constructor(system: AutogestionSystem, regionalId: string);
+    getConnector(): Promise<AutogestionConnector>;
+    private login;
+}

package/build/autogestion/client/local-session.js

@@ -0,0 +1,37 @@
+import { connectorKit, LoginRequiredError } from "./connector.js";
+import { loadAutogestionCredentials } from "./credentials.js";
+/**
+ * Sesión del modo local: un solo usuario, el de la compu. Recibe el sistema ya resuelto para la
+ * regional (la misma que eligió para el aula) y loguea el conector con las credenciales del
+ * keychain o las env vars, una vez por sistema y bajo demanda: el primer uso es el que pide login.
+ */
+export class LocalAutogestionSession {
+    system;
+    regionalId;
+    /** Conectores ya logueados, por sistema: un login alcanza para todas las tools. */
+    connectors = new Map();
+    /** El sistema llega resuelto desde afuera: las plataformas no se conocen entre sí. */
+    constructor(system, regionalId) {
+        this.system = system;
+        this.regionalId = regionalId;
+    }
+    async getConnector() {
+        const system = this.system;
+        let connector = this.connectors.get(system.id);
+        if (!connector) {
+            connector = this.login(system.id, system.create(this.regionalId, connectorKit)).catch((error) => {
+                this.connectors.delete(system.id);
+                throw error;
+            });
+            this.connectors.set(system.id, connector);
+        }
+        return connector;
+    }
+    async login(systemId, connector) {
+        const credentials = await loadAutogestionCredentials(systemId);
+        if (!credentials)
+            throw new LoginRequiredError("la autogestión de tu regional");
+        await connector.login(credentials);
+        return connector;
+    }
+}

package/build/autogestion/client/session.d.ts

@@ -0,0 +1,14 @@
+import type { AutogestionConnector } from "./connector.js";
+/**
+ * La autogestión del usuario. Todo lo que habla con el sistema recibe esto y no sabe de dónde sale:
+ * `LocalAutogestionSession` (STDIO, el usuario de la compu). El modo HTTP todavía no la tiene
+ * resuelta: las credenciales por sistema de cada usuario quedan como decisión de diseño abierta.
+ */
+export interface AutogestionSession {
+    /**
+     * El conector del sistema que usa la regional del usuario, logueado y listo.
+     * Rechaza con LoginRequiredError si faltan las credenciales o con InvalidCredentialsError
+     * si el sistema las rechaza.
+     */
+    getConnector(): Promise<AutogestionConnector>;
+}

package/build/autogestion/client/session.js

@@ -0,0 +1 @@
+export {};

package/build/autogestion/client/types.d.ts

@@ -0,0 +1,49 @@
+/** Una materia del estado académico, con lo que el sistema informa de ella. */
+export interface EstadoMateria {
+    materia: string;
+    estado?: string;
+    plan?: string;
+    anio?: string;
+    nota?: string;
+    fecha?: string;
+    /** Celdas que no entraron en una columna conocida: no se tira información. */
+    extra?: string[];
+}
+/** Una materia con las correlativas que exige, tal como las publica la autogestión. */
+export interface CorrelatividadMateria {
+    materia: string;
+    /** Texto de la columna de correlativas, tal cual viene: "Puede cursar", "No aprobó X", etc. */
+    correlativas: string;
+    plan?: string;
+    anio?: string;
+    extra?: string[];
+}
+/**
+ * Correlatividades de la carrera según la autogestión, separadas como las publica el sistema:
+ * `cursar` siempre; `rendir` cuando el sistema la tiene en otra página (Sysacad sí, verificado
+ * con cuenta real oct 2026). Es la fuente dinámica de las correlatividades en lugar de datos
+ * fijos del repo.
+ */
+export interface Correlatividades {
+    cursar: CorrelatividadMateria[];
+    rendir?: CorrelatividadMateria[];
+}
+export interface NotasParcialesMateria {
+    materia: string;
+    anio?: string;
+    comision?: string;
+    aula?: string;
+    horarios?: string;
+    notas?: string;
+    inasistencias?: string;
+    obs?: string;
+    cursando: boolean;
+}
+export interface ExamenMateria {
+    materia: string;
+    fecha?: string;
+    nota?: string;
+    especialidad?: string;
+    plan?: string;
+    codigo?: string;
+}

package/build/autogestion/client/types.js

@@ -0,0 +1 @@
+export {};

package/build/autogestion/format/correlatividades.d.ts

@@ -0,0 +1,4 @@
+import type { AutogestionSession } from "../client/session.js";
+import type { Correlatividades } from "../client/types.js";
+/** Correlatividades de cursar y, si el conector la publica, de rendir. */
+export declare function getCorrelatividades(session: AutogestionSession): Promise<Correlatividades>;

package/build/autogestion/format/correlatividades.js

@@ -0,0 +1,4 @@
+/** Correlatividades de cursar y, si el conector la publica, de rendir. */
+export async function getCorrelatividades(session) {
+    return (await session.getConnector()).correlatividades();
+}

package/build/autogestion/format/estado-academico.d.ts

@@ -0,0 +1,4 @@
+import type { AutogestionSession } from "../client/session.js";
+import type { EstadoMateria } from "../client/types.js";
+/** Estado académico del alumno en su autogestión, delegado al conector de su regional. */
+export declare function getEstadoAcademico(session: AutogestionSession): Promise<EstadoMateria[]>;

package/build/autogestion/format/estado-academico.js

@@ -0,0 +1,4 @@
+/** Estado académico del alumno en su autogestión, delegado al conector de su regional. */
+export async function getEstadoAcademico(session) {
+    return (await session.getConnector()).estadoAcademico();
+}

package/build/autogestion/format/examenes.d.ts

@@ -0,0 +1,3 @@
+import type { AutogestionSession } from "../client/session.js";
+import type { ExamenMateria } from "../client/types.js";
+export declare function getExamenes(session: AutogestionSession): Promise<ExamenMateria[]>;

package/build/autogestion/format/examenes.js

@@ -0,0 +1,8 @@
+import { HttpError } from "../../shared/http.js";
+export async function getExamenes(session) {
+    const connector = await session.getConnector();
+    if (!connector.examenes) {
+        throw new HttpError("El sistema de autogestión de tu regional todavía no tiene conector para el historial de exámenes.");
+    }
+    return connector.examenes();
+}

package/build/autogestion/format/notas-parciales.d.ts

@@ -0,0 +1,3 @@
+import type { AutogestionSession } from "../client/session.js";
+import type { NotasParcialesMateria } from "../client/types.js";
+export declare function getCursandoAhora(session: AutogestionSession): Promise<NotasParcialesMateria[]>;

package/build/autogestion/format/notas-parciales.js

@@ -0,0 +1,8 @@
+import { HttpError } from "../../shared/http.js";
+export async function getCursandoAhora(session) {
+    const connector = await session.getConnector();
+    if (!connector.notasParciales) {
+        throw new HttpError("El sistema de autogestión de tu regional todavía no tiene conector para la cursada actual.");
+    }
+    return (await connector.notasParciales()).filter((m) => m.cursando);
+}

package/build/autogestion/login.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `utn-mcp login autogestion`: instala el conector de la regional si falta o quedó viejo, pide legajo
+ * y contraseña, los prueba contra el sistema y recién ahí los guarda en el keychain. La misma regional
+ * que se usa para el aula decide qué sistema de autogestión toca.
+ */
+export declare function runAutogestionLogin(regionalId: string): Promise<void>;
+/**
+ * Después del login del aula: si la regional tiene un conector en el catálogo, ofrece conectarlo.
+ * Un error acá no deshace el login del aula, que ya quedó guardado.
+ */
+export declare function offerAutogestionLogin(regionalId: string): Promise<void>;

package/build/autogestion/login.js

@@ -0,0 +1,59 @@
+import { ask, askChoice, askHidden } from "../shared/input.js";
+import { logger } from "../shared/logger.js";
+import { catalogEntryForRegional } from "./client/catalog.js";
+import { connectorKit, systemForRegional, UnsupportedRegionalError } from "./client/connector.js";
+import { saveAutogestionCredentials } from "./client/credentials.js";
+import { installConnector, installedManifest } from "./client/install.js";
+import { loadInstalledSystems } from "./client/installed-systems.js";
+/**
+ * `utn-mcp login autogestion`: instala el conector de la regional si falta o quedó viejo, pide legajo
+ * y contraseña, los prueba contra el sistema y recién ahí los guarda en el keychain. La misma regional
+ * que se usa para el aula decide qué sistema de autogestión toca.
+ */
+export async function runAutogestionLogin(regionalId) {
+    const entry = catalogEntryForRegional(regionalId);
+    if (entry && (await installedManifest(entry))?.version !== entry.version) {
+        logger.info(`Bajando el conector de ${entry.name}...`);
+        await installConnector(entry);
+    }
+    const system = systemForRegional(regionalId, await loadInstalledSystems());
+    if (!system)
+        throw new UnsupportedRegionalError(regionalId);
+    if (entry?.regionales[regionalId] === "candidate") {
+        logger.info(`El conector de ${system.name} todavía no se probó en tu regional: si algo no anda, contalo en ` +
+            "https://github.com/nialvape/utn-mcp/issues.");
+    }
+    const hint = system.usernameHint?.(regionalId);
+    const username = (await ask(`Legajo o usuario de ${system.name}${hint ? ` (${hint})` : ""}: `)).trim();
+    if (!username)
+        throw new Error("Falta el usuario.");
+    const password = await askHidden("Contraseña: ");
+    // Se guardan recién después de comprobar que el sistema las aceptó.
+    const connector = system.create(regionalId, connectorKit);
+    await connector.login({ username, password });
+    if (await saveAutogestionCredentials(system.id, { username, password })) {
+        logger.info("Credenciales guardadas en el keychain del sistema.");
+    }
+    else {
+        logger.warn("No hay keychain disponible: definí las variables de entorno del sistema (ver README).");
+    }
+    logger.info(`Listo: ${system.name} conectado.`);
+}
+/**
+ * Después del login del aula: si la regional tiene un conector en el catálogo, ofrece conectarlo.
+ * Un error acá no deshace el login del aula, que ya quedó guardado.
+ */
+export async function offerAutogestionLogin(regionalId) {
+    const entry = catalogEntryForRegional(regionalId);
+    if (!entry)
+        return;
+    const options = ["Sí", "No, después con `utn-mcp login autogestion`"];
+    if ((await askChoice(`¿Conectar también ${entry.name} (estado académico, correlativas, finales)?`, options)) !== 0)
+        return;
+    try {
+        await runAutogestionLogin(regionalId);
+    }
+    catch (e) {
+        logger.warn(`${e.message}\nEl aula quedó conectada; ${entry.name} se puede conectar después con \`utn-mcp login autogestion\`.`);
+    }
+}

package/build/autogestion/tools.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/server";
+import type { AutogestionSession } from "./client/session.js";
+export declare function registerAutogestionTools(server: McpServer, session: AutogestionSession): void;

package/build/autogestion/tools.js

@@ -0,0 +1,73 @@
+import { getCorrelatividades } from "./format/correlatividades.js";
+import { getEstadoAcademico } from "./format/estado-academico.js";
+import { getExamenes } from "./format/examenes.js";
+import { getCursandoAhora } from "./format/notas-parciales.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) }],
+});
+const failure = (e) => ({
+    content: [{ type: "text", text: `Error: ${e.message}` }],
+    isError: true,
+});
+export function registerAutogestionTools(server, session) {
+    server.registerTool("autogestion_estado_academico", {
+        description: "Estado académico del usuario según la autogestión de su regional: cada materia OBLIGATORIA " +
+            "del plan con su estado (regular, aprobada, libre), plan, nota y fecha. No es el catálogo " +
+            "completo de la carrera: puede incluir electivas aprobadas y no listar materias sin " +
+            "movimientos cargados. Las que se están cursando se marcan como Cursando cuando el " +
+            "sistema permite saberlas. Requiere " +
+            "`utn-mcp login autogestion` una vez; las credenciales son las del sistema de autogestión, " +
+            "que no siempre son las del aula virtual.",
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    }, async () => {
+        try {
+            return json(await getEstadoAcademico(session));
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
+    server.registerTool("autogestion_cursando_ahora", {
+        description: "Materias que el usuario está cursando ahora según la autogestión de su regional, con su " +
+            "comisión, aula y horarios cuando el sistema los publica. Incluye electivas, a diferencia " +
+            "del estado académico. Requiere `utn-mcp login autogestion` una vez.",
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    }, async () => {
+        try {
+            return json(await getCursandoAhora(session));
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
+    server.registerTool("autogestion_examenes", {
+        description: "Historial de exámenes finales del usuario según la autogestión de su regional: fecha, " +
+            "materia, nota o estado del examen cuando todavía no hay nota, plan y código. Puede cubrir " +
+            "también materias rendidas en planes anteriores y electivas que el estado académico no " +
+            "muestra. Requiere `utn-mcp login autogestion` una vez.",
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    }, async () => {
+        try {
+            return json(await getExamenes(session));
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
+    server.registerTool("autogestion_correlatividades", {
+        description: "Correlatividades de la carrera del usuario según la autogestión de su regional, separadas " +
+            "para cursar y para rendir cuando el sistema las distingue: para cada materia, qué exige " +
+            "tener regular o aprobada. Es la fuente dinámica de " +
+            "correlatividades: usala en lugar de suponer datos de un plan fijo. Requiere " +
+            "`utn-mcp login autogestion` una vez.",
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    }, async () => {
+        try {
+            return json(await getCorrelatividades(session));
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
+}

package/build/http.d.ts

@@ -0,0 +1,22 @@
+import { type AuthInfo, type McpServerFactory } from "@modelcontextprotocol/server";
+import type { AccessPolicy } from "./oauth/access.js";
+import type { RedirectAllowlist } from "./oauth/redirects.js";
+import type { SessionStore } from "./shared/store/session-store.js";
+import { type UploadInbox } from "./shared/uploads.js";
+/** El usuario del store dueño del token, en `extra.userId`. */
+export declare function userIdOf(authInfo: AuthInfo | undefined): number;
+/** Dónde escucha el servidor y, si está publicado, desde qué dirección lo ven los clientes. */
+export interface HttpOptions {
+    host: string;
+    port: number;
+    /** Sin barra final, por ejemplo `https://mcp.tu-dominio.com`. */
+    publicUrl?: string;
+    /** Quién puede conectarse por OAuth. */
+    access: AccessPolicy;
+    /** A dónde puede volver el navegador después del login de OAuth. */
+    redirects: RedirectAllowlist;
+    /** Con él se habilita la API de /admin (ver `mountAdmin`). */
+    adminSecret?: string;
+}
+/** El factory recibe en `ctx.authInfo` el token ya validado, con el usuario; de ahí arma su sesión. */
+export declare function startHttpServer(factory: McpServerFactory, options: HttpOptions, store: SessionStore, inbox: UploadInbox): void;

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./shared/load-env.js";

package/build/index.js

@@ -6,6 +6,7 @@ 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 { offerAutogestionLogin, runAutogestionLogin } from "./autogestion/login.js";
 import { startHttpServer, userIdOf } from "./http.js";
 import { accessPolicyFromEnv } from "./oauth/access.js";
 import { redirectAllowlistFromEnv } from "./oauth/redirects.js";
@@ -18,6 +19,7 @@ const USAGE = `Uso:
   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
+  utn-mcp login autogestion  instalar el conector de la autogestión de tu regional y guardar legajo y contraseña
 
 Si hay un .env en la carpeta actual, se lee al arrancar (ver .env.example).`;
 async function main() {
@@ -38,7 +40,15 @@ async function main() {
     // 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);
+        if (positionals[1] === "autogestion") {
+            await runAutogestionLogin((await new LocalSession().getRegional()).id);
+        }
+        else {
+            await runLogin(values.http);
+            // La autogestión todavía es solo del modo local: en HTTP no hay dónde pedirle la clave a cada usuario.
+            if (!values.http)
+                await offerAutogestionLogin((await new LocalSession().getRegional()).id);
+        }
         return;
     }
     if (values.http) {

package/build/oauth/access.d.ts

@@ -0,0 +1,18 @@
+export type AccessDecision = {
+    allowed: true;
+} | {
+    allowed: false;
+    reason: string;
+    url?: string;
+};
+/** Quién puede usar el servidor: decide con el usuario que acaba de entrar al aula de su regional. */
+export type AccessPolicy = (user: {
+    regional: string;
+    username: string;
+    email: string | null;
+}) => Promise<AccessDecision>;
+/**
+ * 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 declare function accessPolicyFromEnv(env?: NodeJS.ProcessEnv): AccessPolicy;

package/build/oauth/admin.d.ts

@@ -0,0 +1,8 @@
+import { type Express } from "express";
+import type { SessionStore } from "../shared/store/session-store.js";
+/**
+ * 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 declare function mountAdmin(app: Express, store: SessionStore, secret: string): void;

package/build/oauth/expiring.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 declare class Expiring<T> {
+    private readonly ttlMs;
+    private readonly items;
+    /** `ttlMs` en milisegundos. */
+    constructor(ttlMs: number);
+    add(value: T): string;
+    get(id: string): T | undefined;
+    /** Lo devuelve y lo borra: un code se canjea una sola vez. */
+    take(id: string): T | undefined;
+    private sweep;
+}
+/** Cuenta intentos por clave (la IP) en una ventana fija. */
+export declare class RateLimiter {
+    private readonly max;
+    private readonly windowMs;
+    private readonly hits;
+    /** `windowMs` en milisegundos. */
+    constructor(max: number, windowMs: number);
+    allow(key: string): boolean;
+}

package/build/oauth/pending-login.d.ts

@@ -0,0 +1,20 @@
+import type { MfaPrompt, SecondFactor } from "../aula-virtual/client/sso-login.js";
+/**
+ * Un login que queda esperando el segundo factor entre un request y otro: corre en segundo plano y,
+ * cuando le pregunta algo al usuario, `next` lo devuelve para mostrárselo en una página; `answer` le
+ * pasa lo que el usuario contestó en el request siguiente.
+ */
+export declare class PendingLogin<T> {
+    private readonly run;
+    private waiting;
+    private listeners;
+    constructor(start: (secondFactor: SecondFactor) => Promise<T>);
+    /** Espera a que el login termine o le pregunte algo al usuario. */
+    next(): Promise<{
+        done: T;
+    } | {
+        prompt: MfaPrompt;
+    }>;
+    /** Contesta lo que está preguntando; si no pregunta nada (un formulario mandado dos veces), no hace nada. */
+    answer(value: string): void;
+}

package/build/oauth/redirects.d.ts

@@ -0,0 +1,20 @@
+/** A dónde puede volver el navegador después del login. */
+export interface RedirectAllowlist {
+    /** Hostnames a los que se vuelve por HTTPS sin aviso. */
+    hosts: Set<string>;
+    /** Esquemas de apps instaladas, con los dos puntos (`cursor:`). */
+    schemes: Set<string>;
+}
+/**
+ * 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 declare function redirectAllowlistFromEnv(env?: NodeJS.ProcessEnv): RedirectAllowlist;
+/**
+ * `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 declare function redirectTrust(uri: unknown, allow: RedirectAllowlist): "trusted" | "unknown" | "rejected";
+/** Cómo se le nombra al usuario el destino. */
+export declare function describeRedirect(uri: string): string;