utn-mcp 0.9.0 → 0.9.1

package/README.md

@@ -29,10 +29,10 @@ El agente recorre el aula como lo harías vos: entra al curso, mira los foros y
 | `aula_choice_answer` | Responde una elección o te anota en un grupo. |
 | `aula_send_message` | Manda un mensaje privado a un docente o compañero. |
 | `aula_calendar_add_event` | Agrega un recordatorio a tu calendario del aula. |
-| `autogestion_cursando_ahora` | Las materias que estás cursando ahora según la autogestión, con comisión, aula y horarios cuando el sistema los publica. Incluye electivas. Requiere `utn-mcp login autogestion`. Aparece solo en modo local y si tu regional tiene un conector instalado. |
-| `autogestion_estado_academico` | Tu estado académico según la autogestión de tu regional: cada materia con su estado, plan, nota y fecha. Requiere `utn-mcp login autogestion`. Aparece solo en modo local y si tu regional tiene un conector instalado. |
-| `autogestion_correlatividades` | Las correlatividades de tu carrera según la autogestión, para cursar y para rendir, en vez de datos fijos del repo. Requiere `utn-mcp login autogestion`. Aparece solo en modo local y si tu regional tiene un conector instalado. |
-| `autogestion_examenes` | Tu historial de finales según la autogestión: fecha, materia, nota o estado, plan y código. Requiere `utn-mcp login autogestion`. Aparece solo en modo local y si tu regional tiene un conector instalado. |
+| `autogestion_cursando_ahora` | Las materias que estás cursando ahora según la autogestión, con comisión, aula y horarios cuando el sistema los publica. Incluye electivas. Aparece solo si tu regional tiene un conector de autogestión. |
+| `autogestion_estado_academico` | Tu estado académico según la autogestión de tu regional: cada materia con su estado, plan, nota y fecha. Aparece solo si tu regional tiene un conector de autogestión. |
+| `autogestion_correlatividades` | Las correlatividades de tu carrera según la autogestión, para cursar y para rendir, en vez de datos fijos del repo. Aparece solo si tu regional tiene un conector de autogestión. |
+| `autogestion_examenes` | Tu historial de finales según la autogestión: fecha, materia, nota o estado, plan y código. Aparece solo si tu regional tiene un conector de autogestión. |
 
 Al abrir una tarea, `aula_open` muestra si la entregaste, cuándo vence y la devolución con la nota. Las tools que escriben le piden al agente que te muestre lo que va a hacer y espere tu confirmación.
 
@@ -143,7 +143,7 @@ Si tu regional usa el Sysacad clásico, al terminar `login` te pregunta si quer
 ```bash
 npx -y utn-mcp login autogestion
 ```
-Con Sysacad conectado aparecen las tools `autogestion_*`: tu estado académico, lo que estás cursando, tus finales y las correlatividades de tu carrera. Por ahora son solo de lectura y funcionan solo con el servidor instalado en tu computadora.
+Con Sysacad conectado aparecen las tools `autogestion_*`: tu estado académico, lo que estás cursando, tus finales y las correlatividades de tu carrera. Por ahora son solo de lectura.
 
 Lo usan Bahía Blanca, Chubut, Concordia, Delta, General Pacheco, Haedo, La Rioja, Mar del Plata, Neuquén, Paraná, Reconquista, Santa Fe, San Francisco, San Nicolás, San Rafael, Tucumán, Tierra del Fuego y Venado Tuerto. En Tucumán anduvo con una versión anterior del conector; esta todavía no se probó con una cuenta real: si lo probás, contanos en un [issue](https://github.com/nialvape/utn-mcp/issues) si funcionó. En algunas el usuario no es el legajo tal cual (en Delta va sin el "23-", por ejemplo); el login te dice qué escribir. Avellaneda y Rosario quedan afuera porque su Sysacad pide un captcha o un desafío del navegador, y Rafaela, Santa Cruz y Trenque Lauquen porque no tienen HTTPS válido y la contraseña viajaría expuesta.
 
@@ -163,6 +163,8 @@ En este modo el servidor no lee archivos de tu disco: para entregar, el agente p
 ### Hostearlo para otros
 En modo HTTP el servidor también es servidor de autorización OAuth: un cliente MCP (Claude, ChatGPT) que se conecta a `https://tu-dominio/mcp` recibe un 401, descubre el OAuth y abre una página donde el alumno elige su regional y entra con su usuario de la UTN. Cada alumno usa el aula de su regional, aunque sean de regionales distintas. Ese login vincula su aula: la contraseña se usa una sola vez para sacar el token de Moodle y **no se guarda**. Cuando la sesión del aula vence, el agente le pasa el link de `/login` para renovarla, sin reconectar el cliente.
 
+La autogestión (Sysacad) funciona igual para cada alumno, según su regional. Al arrancar, el servidor instala los conectores del catálogo en `connectors/` de su carpeta de datos. La primera vez que el agente la necesita, le pasa al alumno un link a `/autogestion/...` para que entre con su legajo y contraseña de Sysacad desde el navegador: la contraseña nunca pasa por el chat. Como con el aula, la contraseña se usa una sola vez y **no se guarda**: queda cifrada en la base solo la sesión de Sysacad. Cuando Sysacad la vence (unos minutos sin usarla), el agente le vuelve a pasar el link.
+
 Quién puede entrar lo decidís vos: con `UTN_MCP_ALLOWED_EMAILS` (una lista), o con `UTN_MCP_ACCESS_URL`, que apunta a un servicio tuyo. El servidor le hace `POST` con `{ "email", "usuario", "regional" }` y el header `Authorization: Bearer <UTN_MCP_ACCESS_SECRET>`, y espera `{ "permitido": true }` o `{ "permitido": false, "motivo": "...", "url": "..." }`. Se consulta al conectar y en cada renovación del token (cada hora), así que una baja se aplica sola.
 
 La configuración va en variables de entorno o en un `.env` en la carpeta desde donde lo corrés (copiá [`.env.example`](https://github.com/nialvape/utn-mcp/blob/main/.env.example)):
@@ -193,11 +195,11 @@ Instalado en tu computadora, todo queda ahí:
 - **Usuario y contraseña**: en el gestor de credenciales del sistema (Windows Credential Manager, Keychain en macOS, Secret Service en Linux).
 - **Token del aula virtual**: en `%APPDATA%\utn-mcp\session.json` (Windows) o `~/.config/utn-mcp/session.json` (Linux y macOS).
 - **Conector de autogestión**: en `connectors/`, dentro de esa misma carpeta. El legajo y la contraseña de Sysacad van al gestor de credenciales, aparte de los del aula.
-- **En modo HTTP**: la contraseña no se guarda; la sesión va cifrada en `utn-mcp.db`, en la misma carpeta, con la clave de `store.key` (o la de `UTN_MCP_KEY`). Del token del cliente solo se guarda el hash.
+- **En modo HTTP**: la contraseña no se guarda; la sesión va cifrada en `utn-mcp.db`, en la misma carpeta, con la clave de `store.key` (o la de `UTN_MCP_KEY`). Del token del cliente solo se guarda el hash. Con la de Sysacad pasa lo mismo: no se guarda, y su sesión va cifrada en la misma base.
 
 En Linux sin gestor de credenciales (servidores, Docker, WSL) podés definir las variables de entorno `UTN_USER` y `UTN_PASS` en lugar de usar `login`. Para Sysacad son `SYSACAD_ASP_USER` y `SYSACAD_ASP_PASS`.
 
-Si usás un servidor hosteado por otra persona, tu sesión del aula la guarda ese servidor (cifrada, y sin tu contraseña): revisá su política de privacidad.
+Si usás un servidor hosteado por otra persona, tus sesiones del aula y de Sysacad las guarda ese servidor (cifradas, y sin tus contraseñas): revisá su política de privacidad.
 
 ## Desarrollo
 ```bash

package/build/autogestion/client/catalog.js

@@ -9,9 +9,9 @@ export const CATALOG = [
         id: "sysacad-asp",
         name: "Sysacad",
         package: "utn-mcp-sysacad-asp",
-        version: "0.1.0",
-        tarball: `${RELEASES}/sysacad-asp-v0.1.0/utn-mcp-sysacad-asp-0.1.0.tgz`,
-        integrity: "sha512-dFiMVUwQJdLHmrKD6BZnUgn5EU73pzAzSBEEQyCA4P2eXOI6QeTRLnmGW//K1hmFJXl74Ax10VQrpVweY6+1Gw==",
+        version: "0.2.0",
+        tarball: `${RELEASES}/sysacad-asp-v0.2.0/utn-mcp-sysacad-asp-0.2.0.tgz`,
+        integrity: "sha512-p4j2fTpE3ZqSvcDQ3Rr6L32dOGNFut0GzyHBVpTpg8mqXrx4Un6CqkiJZG+eznQy+Risko+pcnPhWm+GIJ8haw==",
         // FRT anduvo con cuenta real (oct 2026) con la versión anterior, que posteaba directo a `menuAlumno.asp`;
         // esta lee el formulario y todavía no entró nadie con ella.
         regionales: Object.fromEntries(SYSACAD_ASP_REGIONALS.map((id) => [id, "candidate"])),

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

@@ -19,6 +19,16 @@ export interface AutogestionConnector {
     notasParciales?(): Promise<NotasParcialesMateria[]>;
     /** Historial de exámenes finales, si el sistema lo publica; no todos los conectores lo tienen. */
     examenes?(): Promise<ExamenMateria[]>;
+    /**
+     * La sesión del sistema sin la contraseña (cookies, ids de sesión), para guardarla cifrada y retomarla
+     * en otro request. Sin esto, el conector sirve solo en local: el modo HTTP no guarda contraseñas.
+     */
+    exportSession?(): string;
+    /**
+     * Retoma una sesión de `exportSession`. Sin la contraseña no puede volver a entrar solo: si la sesión
+     * venció, las llamadas rechazan con `LoginRequiredError`.
+     */
+    restoreSession?(data: string): void;
 }
 /** Credenciales de un sistema de autogestión. En Sysacad `username` es el legajo. */
 export interface AutogestionCredentials {

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

@@ -1,4 +1,4 @@
-import type { CatalogEntry } from "./catalog.js";
+import { type CatalogEntry } from "./catalog.js";
 /** Donde quedan los conectores instalados, uno por carpeta con el nombre de su paquete. */
 export declare const connectorsDir: () => string;
 export declare const connectorDir: (entry: CatalogEntry) => string;
@@ -7,6 +7,11 @@ export declare function installedManifest(entry: CatalogEntry): Promise<{
     version?: string;
     main?: string;
 } | null>;
+/**
+ * Para el modo HTTP, que atiende usuarios de cualquier regional: instala los conectores del catálogo que
+ * falten o hayan quedado viejos. Uno que no se puede bajar no frena el servidor: queda sin esas tools.
+ */
+export declare function installCatalog(): Promise<void>;
 /**
  * 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.

package/build/autogestion/client/install.js

@@ -3,7 +3,9 @@ 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 { logger } from "../../shared/logger.js";
 import { configDir } from "../../shared/paths.js";
+import { CATALOG } from "./catalog.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);
@@ -16,6 +18,23 @@ export async function installedManifest(entry) {
         return null;
     }
 }
+/**
+ * Para el modo HTTP, que atiende usuarios de cualquier regional: instala los conectores del catálogo que
+ * falten o hayan quedado viejos. Uno que no se puede bajar no frena el servidor: queda sin esas tools.
+ */
+export async function installCatalog() {
+    for (const entry of CATALOG) {
+        if ((await installedManifest(entry))?.version === entry.version)
+            continue;
+        try {
+            await installConnector(entry);
+            logger.info(`Conector de ${entry.name} ${entry.version} instalado.`);
+        }
+        catch (e) {
+            logger.warn(`No se pudo instalar el conector de ${entry.name}: ${e.message}`);
+        }
+    }
+}
 /** Bloques del formato tar: encabezado y datos van de a 512 bytes. */
 const TAR_BLOCK = 512;
 /**

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

@@ -1,14 +1,18 @@
-import type { AutogestionConnector } from "./connector.js";
+import type { AutogestionConnector, AutogestionSystem } 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.
+ * `LocalAutogestionSession` (STDIO, el usuario de la compu, credenciales del keychain) o la hosteada
+ * (HTTP, el usuario entra desde un link y la contraseña no se guarda).
  */
 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.
+     * Rechaza con un error que dice cómo iniciar sesión si todavía no se puede.
      */
     getConnector(): Promise<AutogestionConnector>;
 }
+/** Los conectores disponibles y cómo armar la sesión de un usuario: lo que recibe `createServer`. */
+export interface AutogestionAccess {
+    systems: AutogestionSystem[];
+    sessionFor(system: AutogestionSystem, regionalId: string): AutogestionSession;
+}

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

@@ -0,0 +1,42 @@
+import type { SessionStore } from "../../shared/store/session-store.js";
+import { type AutogestionConnector, type AutogestionCredentials, type AutogestionSystem } from "./connector.js";
+import type { AutogestionAccess } from "./session.js";
+/** Con qué nombre guarda la autogestión su sesión en el store. */
+export declare const AUTOGESTION_PLATFORM = "autogestion";
+/** Un link abierto para que el usuario entre a su autogestión desde el navegador. */
+export interface PendingLink {
+    userId: number;
+    regionalId: string;
+    system: AutogestionSystem;
+}
+/** Falta entrar a la autogestión: el mensaje trae el link para el usuario. */
+export declare class AutogestionLinkRequiredError extends Error {
+    constructor(systemName: string, url: string, reason?: string);
+}
+/**
+ * La autogestión del modo HTTP, para todos los usuarios del servidor. Igual que el aula: la contraseña se
+ * usa una sola vez, en la página del link, y no se guarda; en el store queda cifrada la sesión del
+ * sistema (cookies), que el conector exporta. Cuando el sistema la vence, el usuario vuelve a entrar.
+ */
+export declare class StoredAutogestion {
+    private readonly baseUrl;
+    private readonly store;
+    /** Los links viven en memoria: si el servidor se reinicia, el agente pide otro. */
+    private readonly links;
+    /** Solo los conectores que pueden exportar su sesión: los otros necesitarían guardar la contraseña. */
+    readonly systems: AutogestionSystem[];
+    constructor(baseUrl: string, store: SessionStore, systems: AutogestionSystem[]);
+    /** Lo que recibe `createServer` para un usuario. */
+    forUser(userId: number): AutogestionAccess;
+    /** El conector del usuario con su sesión guardada, o null si no hay una de ese sistema. */
+    restore(userId: number, system: AutogestionSystem, regionalId: string): Promise<AutogestionConnector | null>;
+    /** Guarda la sesión del conector (cifrada, como todo el store); las cookies pueden cambiar en cada pedido. */
+    save(userId: number, connector: AutogestionConnector): Promise<void>;
+    /** El store no borra sesiones: una vacía es "no hay". */
+    forget(userId: number): Promise<void>;
+    /** Un link para que el usuario entre; los que se abrieron antes siguen valiendo hasta que vencen o se usa uno. */
+    openLink(userId: number, system: AutogestionSystem, regionalId: string): string;
+    link(id: string): PendingLink | undefined;
+    /** Entra con lo que el usuario escribió en la página del link y guarda la sesión; la contraseña se descarta. */
+    complete(id: string, credentials: AutogestionCredentials): Promise<PendingLink>;
+}

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

@@ -0,0 +1,126 @@
+import { Expiring } from "../../shared/expiring.js";
+import { connectorKit, InvalidCredentialsError, LoginRequiredError, } from "./connector.js";
+/** Con qué nombre guarda la autogestión su sesión en el store. */
+export const AUTOGESTION_PLATFORM = "autogestion";
+/** Cuánto dura un link para entrar, en milisegundos. */
+const LINK_TTL_MS = 30 * 60 * 1000;
+/** Falta entrar a la autogestión: el mensaje trae el link para el usuario. */
+export class AutogestionLinkRequiredError extends Error {
+    constructor(systemName, url, reason) {
+        super(`${reason ? `${reason} ` : ""}Falta iniciar sesión en ${systemName}. Pasale al usuario este link para que entre ` +
+            `con su legajo y contraseña de ${systemName} (vence en 30 minutos): ${url} . Cuando te avise que entró, ` +
+            "reintentá. La contraseña no pasa por el chat: no se la pidas.");
+        this.name = "AutogestionLinkRequiredError";
+    }
+}
+/**
+ * La autogestión del modo HTTP, para todos los usuarios del servidor. Igual que el aula: la contraseña se
+ * usa una sola vez, en la página del link, y no se guarda; en el store queda cifrada la sesión del
+ * sistema (cookies), que el conector exporta. Cuando el sistema la vence, el usuario vuelve a entrar.
+ */
+export class StoredAutogestion {
+    baseUrl;
+    store;
+    /** Los links viven en memoria: si el servidor se reinicia, el agente pide otro. */
+    links = new Expiring(LINK_TTL_MS);
+    /** Solo los conectores que pueden exportar su sesión: los otros necesitarían guardar la contraseña. */
+    systems;
+    constructor(baseUrl, store, systems) {
+        this.baseUrl = baseUrl;
+        this.store = store;
+        this.systems = systems.filter((system) => {
+            const connector = system.create(system.regionales[0], connectorKit);
+            return typeof connector.exportSession === "function" && typeof connector.restoreSession === "function";
+        });
+    }
+    /** Lo que recibe `createServer` para un usuario. */
+    forUser(userId) {
+        return {
+            systems: this.systems,
+            sessionFor: (system, regionalId) => new StoredAutogestionSession(this, userId, system, regionalId),
+        };
+    }
+    /** El conector del usuario con su sesión guardada, o null si no hay una de ese sistema. */
+    async restore(userId, system, regionalId) {
+        const raw = await this.store.loadSession(userId, AUTOGESTION_PLATFORM);
+        if (!raw)
+            return null;
+        const data = JSON.parse(raw);
+        if (data.systemId !== system.id)
+            return null;
+        const connector = system.create(regionalId, connectorKit);
+        connector.restoreSession(data.session);
+        return connector;
+    }
+    /** Guarda la sesión del conector (cifrada, como todo el store); las cookies pueden cambiar en cada pedido. */
+    async save(userId, connector) {
+        const data = { systemId: connector.systemId, session: connector.exportSession() };
+        await this.store.saveSession(userId, AUTOGESTION_PLATFORM, JSON.stringify(data));
+    }
+    /** El store no borra sesiones: una vacía es "no hay". */
+    async forget(userId) {
+        await this.store.saveSession(userId, AUTOGESTION_PLATFORM, "");
+    }
+    /** Un link para que el usuario entre; los que se abrieron antes siguen valiendo hasta que vencen o se usa uno. */
+    openLink(userId, system, regionalId) {
+        return `${this.baseUrl}/autogestion/${this.links.add({ userId, regionalId, system })}`;
+    }
+    link(id) {
+        return this.links.get(id);
+    }
+    /** Entra con lo que el usuario escribió en la página del link y guarda la sesión; la contraseña se descarta. */
+    async complete(id, credentials) {
+        const link = this.link(id);
+        if (!link)
+            throw new Error("El link venció o ya se usó. Pedile al agente uno nuevo.");
+        const connector = link.system.create(link.regionalId, connectorKit);
+        await connector.login(credentials);
+        await this.save(link.userId, connector);
+        this.links.take(id);
+        return link;
+    }
+}
+/** La sesión de un usuario en un request: el conector con la sesión guardada o, si no hay, el link para entrar. */
+class StoredAutogestionSession {
+    stored;
+    userId;
+    system;
+    regionalId;
+    constructor(stored, userId, system, regionalId) {
+        this.stored = stored;
+        this.userId = userId;
+        this.system = system;
+        this.regionalId = regionalId;
+    }
+    async getConnector() {
+        const connector = await this.stored.restore(this.userId, this.system, this.regionalId);
+        if (!connector)
+            throw this.linkRequired();
+        // Después de cada pedido se guarda la sesión, por si el sistema rotó las cookies. Si la venció, se
+        // descarta y se pide entrar de nuevo: los mensajes del conector hablan del login por CLI, que acá no existe.
+        const guard = async (call) => {
+            try {
+                const result = await call();
+                await this.stored.save(this.userId, connector);
+                return result;
+            }
+            catch (e) {
+                if (!(e instanceof InvalidCredentialsError || e instanceof LoginRequiredError))
+                    throw e;
+                await this.stored.forget(this.userId);
+                throw this.linkRequired(`La sesión de ${this.system.name} venció.`);
+            }
+        };
+        return {
+            systemId: connector.systemId,
+            login: (credentials) => connector.login(credentials),
+            estadoAcademico: () => guard(() => connector.estadoAcademico()),
+            correlatividades: () => guard(() => connector.correlatividades()),
+            notasParciales: connector.notasParciales && (() => guard(() => connector.notasParciales())),
+            examenes: connector.examenes && (() => guard(() => connector.examenes())),
+        };
+    }
+    linkRequired(reason) {
+        return new AutogestionLinkRequiredError(this.system.name, this.stored.openLink(this.userId, this.system, this.regionalId), reason);
+    }
+}

package/build/autogestion/link-page.d.ts

@@ -0,0 +1,7 @@
+import { type Express, type RequestHandler } from "express";
+import type { StoredAutogestion } from "./client/stored-session.js";
+/**
+ * `/autogestion/:id`: la página del link que el agente le pasa al usuario para entrar a su autogestión
+ * en modo HTTP. Sin bearer, como `/subir`: el id del link es el secreto y lo abre un navegador.
+ */
+export declare function mountAutogestionLink(app: Express, stored: StoredAutogestion, sameOrigin: RequestHandler): void;

package/build/autogestion/link-page.js

@@ -0,0 +1,62 @@
+import express from "express";
+import { RateLimiter } from "../shared/expiring.js";
+import { logger } from "../shared/logger.js";
+import { escapeHtml, page } from "../shared/pages.js";
+import { InvalidCredentialsError } from "./client/connector.js";
+/** Intentos de login por IP cada 15 minutos (en milisegundos): cada uno es un login contra el sistema de la regional. */
+const MAX_ATTEMPTS = 10;
+const ATTEMPTS_WINDOW_MS = 15 * 60 * 1000;
+/**
+ * `/autogestion/:id`: la página del link que el agente le pasa al usuario para entrar a su autogestión
+ * en modo HTTP. Sin bearer, como `/subir`: el id del link es el secreto y lo abre un navegador.
+ */
+export function mountAutogestionLink(app, stored, sameOrigin) {
+    const form = express.urlencoded({ extended: false, limit: "16kb" });
+    const limiter = new RateLimiter(MAX_ATTEMPTS, ATTEMPTS_WINDOW_MS);
+    app.get("/autogestion/:id", sameOrigin, (req, res) => {
+        const link = stored.link(String(req.params.id));
+        if (!link)
+            return void expired(res);
+        res.type("html").send(linkPage(link));
+    });
+    app.post("/autogestion/:id", sameOrigin, form, async (req, res) => {
+        const id = String(req.params.id);
+        const link = stored.link(id);
+        if (!link)
+            return void expired(res);
+        const retry = (error) => void res.type("html").send(linkPage(link, error));
+        if (!limiter.allow(req.ip ?? "desconocida"))
+            return retry("Demasiados intentos. Esperá unos minutos y probá de nuevo.");
+        const username = String(req.body?.usuario ?? "").trim();
+        const password = String(req.body?.contrasena ?? "");
+        if (!username || !password)
+            return retry("Completá legajo y contraseña.");
+        try {
+            await stored.complete(id, { username, password });
+        }
+        catch (e) {
+            if (e instanceof InvalidCredentialsError)
+                return retry(`${link.system.name} rechazó el legajo o la contraseña.`);
+            logger.warn(`Autogestión: ${e.message}`);
+            return retry(e.message);
+        }
+        res.type("html").send(page("Listo", `<p>Entraste a ${escapeHtml(link.system.name)}. Volvé al chat y pedile al agente que reintente.</p>`));
+    });
+}
+function expired(res) {
+    res.status(404).type("html").send(page("Link vencido", "<p>Este link venció o ya se usó. Pedile al agente uno nuevo.</p>"));
+}
+function linkPage(link, error) {
+    const name = escapeHtml(link.system.name);
+    const hint = link.system.usernameHint?.(link.regionalId);
+    return page(`Entrar a ${link.system.name}`, `<p>Tu agente necesita entrar a ${name} para leer tu información académica. Usá el legajo y la contraseña ` +
+        `de ${name}, que no siempre son los del aula virtual.</p>` +
+        (error ? `<p class=error>${escapeHtml(error)}</p>` : "") +
+        '<form method="post">' +
+        `<label>Legajo${hint ? ` (${escapeHtml(hint)})` : ""}<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 y no se guarda: queda guardada, cifrada, " +
+        `solo la sesión de ${name}. Cuando ${name} la vence, te va a pedir que entres de nuevo. ` +
+        'El código es abierto: <a href="https://github.com/nialvape/utn-mcp">github.com/nialvape/utn-mcp</a>.</p>', "Autogestión");
+}

package/build/autogestion/tools.js

@@ -10,15 +10,16 @@ const failure = (e) => ({
     content: [{ type: "text", text: `Error: ${e.message}` }],
     isError: true,
 });
+/** Igual para todas: el login es distinto en local (CLI) y en HTTP (link), así que lo explica el error. */
+const LOGIN_NOTE = " Si todavía no entró a su autogestión, el error dice cómo hacerlo; seguilo. Las credenciales son las del " +
+    "sistema de autogestión, que no siempre son las del aula virtual.";
 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.",
+            "sistema permite saberlas." + LOGIN_NOTE,
         annotations: { readOnlyHint: true, openWorldHint: false },
     }, async () => {
         try {
@@ -31,7 +32,7 @@ export function registerAutogestionTools(server, session) {
     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.",
+            "del estado académico." + LOGIN_NOTE,
         annotations: { readOnlyHint: true, openWorldHint: false },
     }, async () => {
         try {
@@ -45,7 +46,7 @@ export function registerAutogestionTools(server, session) {
         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.",
+            "muestra." + LOGIN_NOTE,
         annotations: { readOnlyHint: true, openWorldHint: false },
     }, async () => {
         try {
@@ -59,8 +60,7 @@ export function registerAutogestionTools(server, session) {
         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.",
+            "correlatividades: usala en lugar de suponer datos de un plan fijo." + LOGIN_NOTE,
         annotations: { readOnlyHint: true, openWorldHint: false },
     }, async () => {
         try {

package/build/http.d.ts

@@ -1,4 +1,5 @@
 import { type AuthInfo, type McpServerFactory } from "@modelcontextprotocol/server";
+import type { StoredAutogestion } from "./autogestion/client/stored-session.js";
 import type { AccessPolicy } from "./oauth/access.js";
 import type { RedirectAllowlist } from "./oauth/redirects.js";
 import type { SessionStore } from "./shared/store/session-store.js";
@@ -18,5 +19,8 @@ export interface HttpOptions {
     /** 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;
+/**
+ * El factory recibe en `ctx.authInfo` el token ya validado, con el usuario; de ahí arma su sesión.
+ * `autogestion` sirve la página donde cada usuario entra a la autogestión de su regional.
+ */
+export declare function startHttpServer(factory: McpServerFactory, options: HttpOptions, store: SessionStore, inbox: UploadInbox, autogestion: StoredAutogestion): void;

package/build/http.js

@@ -2,6 +2,7 @@ import express from "express";
 import { Readable } from "node:stream";
 import { bearerAuthChallengeResponse, createMcpHandler, OAuthError, OAuthErrorCode, verifyBearerToken, } from "@modelcontextprotocol/server";
 import { hostHeaderValidation, originValidation, toNodeHandler } from "@modelcontextprotocol/node";
+import { mountAutogestionLink } from "./autogestion/link-page.js";
 import { mountAdmin } from "./oauth/admin.js";
 import { cors, mountOAuth } from "./oauth/server.js";
 import { logger } from "./shared/logger.js";
@@ -41,8 +42,11 @@ 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) {
+/**
+ * El factory recibe en `ctx.authInfo` el token ya validado, con el usuario; de ahí arma su sesión.
+ * `autogestion` sirve la página donde cada usuario entra a la autogestión de su regional.
+ */
+export function startHttpServer(factory, options, store, inbox, autogestion) {
     const { host, port, publicUrl, access, redirects, adminSecret } = options;
     const handler = createMcpHandler(factory, { onerror: (e) => logger.error(e.message) });
     const verifier = storeVerifier(store);
@@ -99,6 +103,7 @@ export function startHttpServer(factory, options, store, inbox) {
         res.type("html").send(page(upload.title, uploadForm(upload.limits)));
     });
     app.post("/subir/:id", sameOrigin, (req, res) => receiveUpload(inbox, req, res));
+    mountAutogestionLink(app, autogestion, sameOrigin);
     app.listen(port, host, () => {
         logger.info(`Servidor MCP escuchando en http://${host}:${port}/mcp`);
         if (publicUrl)

package/build/index.js

@@ -6,6 +6,10 @@ 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 { installCatalog } from "./autogestion/client/install.js";
+import { loadInstalledSystems } from "./autogestion/client/installed-systems.js";
+import { LocalAutogestionSession } from "./autogestion/client/local-session.js";
+import { StoredAutogestion } from "./autogestion/client/stored-session.js";
 import { offerAutogestionLogin, runAutogestionLogin } from "./autogestion/login.js";
 import { startHttpServer, userIdOf } from "./http.js";
 import { accessPolicyFromEnv } from "./oauth/access.js";
@@ -45,7 +49,7 @@ async function main() {
         }
         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.
+            // En HTTP cada usuario entra a su autogestión desde el link que le pasa el agente.
             if (!values.http)
                 await offerAutogestionLogin((await new LocalSession().getRegional()).id);
         }
@@ -61,10 +65,13 @@ async function main() {
         const loginUrl = process.env.UTN_MCP_LOGIN_URL || `${baseUrl}/login`;
         const store = await SqliteStore.open();
         const inbox = new UploadInbox(baseUrl);
+        // Atiende a usuarios de cualquier regional: se instalan todos los conectores del catálogo.
+        await installCatalog();
+        const autogestion = new StoredAutogestion(baseUrl, store, await loadSystems());
         const factory = (ctx) => {
             const userId = userIdOf(ctx.authInfo);
             const aula = new StoredAulaSession(store, userId, loginUrl);
-            return createServer(aula, { local: false, inbox, owner: String(userId) });
+            return createServer(aula, { local: false, inbox, owner: String(userId) }, autogestion.forUser(userId));
         };
         const options = {
             host: values.host,
@@ -74,15 +81,29 @@ async function main() {
             redirects: redirectAllowlistFromEnv(),
             adminSecret: process.env.UTN_MCP_ADMIN_SECRET || undefined,
         };
-        startHttpServer(factory, options, store, inbox);
+        startHttpServer(factory, options, store, inbox, autogestion);
     }
     else {
         // STDIO: un solo usuario, el de la compu, con la misma sesión para todas las conexiones.
         const aula = new LocalSession();
-        serveStdio(() => createServer(aula, { local: true }), { onerror: (e) => logger.error(e.message) });
+        const autogestion = {
+            systems: await loadSystems(),
+            sessionFor: (system, regionalId) => new LocalAutogestionSession(system, regionalId),
+        };
+        serveStdio(() => createServer(aula, { local: true }, autogestion), { onerror: (e) => logger.error(e.message) });
         logger.info("Servidor MCP iniciado en STDIO");
     }
 }
+/** Los conectores de autogestión instalados. Uno roto no puede dejar sin aula virtual: si falla, se sigue sin ellos. */
+async function loadSystems() {
+    try {
+        return await loadInstalledSystems();
+    }
+    catch (e) {
+        logger.warn(e.message);
+        return [];
+    }
+}
 main().catch((e) => {
     logger.error(e.message);
     process.exit(1);

package/build/oauth/admin.js

@@ -5,7 +5,7 @@ import { availableRegionals } from "../aula-virtual/client/regionals.js";
 import { InvalidCredentialsError, MfaError } from "../aula-virtual/client/sso-login.js";
 import { AULA_PLATFORM } from "../aula-virtual/client/stored-session.js";
 import { logger } from "../shared/logger.js";
-import { Expiring, RateLimiter } from "./expiring.js";
+import { Expiring, RateLimiter } from "../shared/expiring.js";
 import { PendingLogin } from "./pending-login.js";
 /** Intentos de `/admin/verificar` por cuenta del aula cada 15 minutos: que no sirva para probar contraseñas. */
 const VERIFY_ATTEMPTS = 5;

package/build/oauth/server.js

@@ -6,7 +6,7 @@ import { availableRegionals, defaultRegional } from "../aula-virtual/client/regi
 import { InvalidCredentialsError, MfaError } 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";
+import { Expiring, RateLimiter } from "../shared/expiring.js";
 import { PendingLogin } from "./pending-login.js";
 import { describeRedirect, redirectTrust } from "./redirects.js";
 /** Duración del access token, en segundos: una baja de acceso se aplica a más tardar en este tiempo. */

package/build/server.d.ts

@@ -1,9 +1,11 @@
 import { McpServer } from "@modelcontextprotocol/server";
 import type { AulaSession } from "./aula-virtual/client/session.js";
+import type { AutogestionAccess } from "./autogestion/client/session.js";
 import type { FileSource } from "./shared/uploads.js";
 /**
  * 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.
- * Es async porque, en local, resuelve la regional y los conectores instalados antes de registrar la autogestión.
+ * `autogestion`: los conectores cargados y la sesión del usuario; sus tools aparecen solo si uno cubre su regional.
+ * Es async porque resuelve la regional del usuario antes de registrar la autogestión.
  */
-export declare function createServer(aula: AulaSession, files: FileSource): Promise<McpServer>;
+export declare function createServer(aula: AulaSession, files: FileSource, autogestion?: AutogestionAccess): Promise<McpServer>;

package/build/server.js

@@ -1,29 +1,27 @@
 import { McpServer } from "@modelcontextprotocol/server";
 import { registerAulaVirtualTools } from "./aula-virtual/tools.js";
-import { loadInstalledSystems } from "./autogestion/client/installed-systems.js";
-import { LocalAutogestionSession } from "./autogestion/client/local-session.js";
 import { systemForRegional } from "./autogestion/client/connector.js";
 import { registerAutogestionTools } from "./autogestion/tools.js";
 import { logger } from "./shared/logger.js";
 /**
  * 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.
- * Es async porque, en local, resuelve la regional y los conectores instalados antes de registrar la autogestión.
+ * `autogestion`: los conectores cargados y la sesión del usuario; sus tools aparecen solo si uno cubre su regional.
+ * Es async porque resuelve la regional del usuario antes de registrar la autogestión.
  */
-export async function createServer(aula, files) {
+export async function createServer(aula, files, autogestion) {
     const server = new McpServer({
         name: "UTN-MCP",
-        version: "0.9.0",
+        version: "0.9.1",
     });
     registerAulaVirtualTools(server, aula, files);
-    if (files.local) {
+    if (autogestion?.systems.length) {
         // Un conector roto no puede dejar sin aula virtual: si falla, seguimos sin las tools de autogestión.
         try {
             const regional = await aula.getRegional();
-            const systems = await loadInstalledSystems();
-            const system = systemForRegional(regional.id, systems);
+            const system = systemForRegional(regional.id, autogestion.systems);
             if (system)
-                registerAutogestionTools(server, new LocalAutogestionSession(system, regional.id));
+                registerAutogestionTools(server, autogestion.sessionFor(system, regional.id));
         }
         catch (e) {
             logger.warn(e.message);

package/build/{oauth → shared}/expiring.d.ts

@@ -1,7 +1,8 @@
 /**
- * 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.
+ * Valores que viven en memoria hasta que se usan o vencen, con un id aleatorio que sirve de secreto: los
+ * pedidos de `/authorize` mientras el usuario completa el login, los codes del OAuth hasta que el cliente
+ * los canjea o los links para entrar a la autogestión. Si el servidor se reinicia, se pierden y hay que
+ * volver a empezar, que es lo que pasaría igual con uno vencido.
  */
 export declare class Expiring<T> {
     private readonly ttlMs;

package/build/{oauth → shared}/expiring.js

@@ -1,8 +1,9 @@
 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.
+ * Valores que viven en memoria hasta que se usan o vencen, con un id aleatorio que sirve de secreto: los
+ * pedidos de `/authorize` mientras el usuario completa el login, los codes del OAuth hasta que el cliente
+ * los canjea o los links para entrar a la autogestión. Si el servidor se reinicia, se pierden y hay que
+ * volver a empezar, que es lo que pasaría igual con uno vencido.
  */
 export class Expiring {
     ttlMs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "utn-mcp",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Este es el Model Context Protocol server NO OFICIAL de la UTN para buscar informacion o archivos en el aula virtual.",
   "main": "build/index.js",
   "bin": {