utn-mcp 0.8.3 → 0.9.1

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

@@ -0,0 +1,19 @@
+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;
+/** El package.json del conector instalado, o null si no está. */
+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.
+ */
+export declare function installConnector(entry: CatalogEntry): Promise<void>;

package/build/autogestion/client/install.js

@@ -0,0 +1,91 @@
+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 { 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);
+/** 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;
+    }
+}
+/**
+ * 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;
+/**
+ * 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,18 @@
+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, 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 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/session.js

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

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/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/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/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>;