utn-mcp 0.8.2 → 0.9.0

package/build/server.js

@@ -1,14 +1,33 @@
 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.
  */
-export function createServer(aula, files) {
+export async function createServer(aula, files) {
     const server = new McpServer({
         name: "UTN-MCP",
-        version: "0.8.2",
+        version: "0.9.0",
     });
     registerAulaVirtualTools(server, aula, files);
+    if (files.local) {
+        // 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);
+            if (system)
+                registerAutogestionTools(server, new LocalAutogestionSession(system, regional.id));
+        }
+        catch (e) {
+            logger.warn(e.message);
+        }
+    }
     return server;
 }

package/build/shared/documents/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Lectura de archivos para el modelo: un documento se parte en unidades (páginas, diapositivas,
+ * fragmentos) que se piden de a una, así quien lee decide cuánto entra en una respuesta.
+ */
+export type Part = {
+    title?: string;
+    text: string;
+} | {
+    title?: string;
+    image: Uint8Array;
+    mimeType: string;
+};
+export interface ParsedDocument {
+    format: string;
+    /** Cómo se llama cada parte: "página", "diapositiva", "fragmento"... */
+    unit: string;
+    total: number;
+    /** Numerada desde 1. */
+    part(n: number): Promise<Part>;
+    close(): Promise<void>;
+}
+export declare class UnsupportedFormat extends Error {
+    readonly format: string;
+    constructor(format: string);
+}
+/** Tamaño de cada fragmento cuando un texto largo viene de una sola pieza (un docx, un html). */
+export declare const CHUNK_SIZE = 15000;
+/** Reconoce el formato por los primeros bytes; el nombre solo se usa para los de texto plano. */
+export declare function openDocument(bytes: Uint8Array, name: string): Promise<ParsedDocument>;
+/** Un documento que ya está entero en memoria. */
+export declare function inMemory(format: string, unit: string, parts: Part[]): ParsedDocument;
+/** Corta un texto largo en pedazos de hasta `max` caracteres, prefiriendo cortar en un salto de línea. */
+export declare function splitText(text: string, max?: number): string[];

package/build/shared/documents/merge.d.ts

@@ -0,0 +1,32 @@
+/** Un PDF a unir, con el nombre con que aparece en el índice. */
+export interface MergeInput {
+    title: string;
+    bytes: Uint8Array;
+}
+export interface MergedFile {
+    /** El índice del archivo en la lista de entrada, para reconocerlo después. */
+    index: number;
+    title: string;
+    /** Página del PDF unido en la que empieza, numerada desde 1 (contando el índice). */
+    startPage: number;
+    pages: number;
+}
+export interface SkippedFile {
+    index: number;
+    title: string;
+    reason: string;
+}
+/**
+ * Une PDFs en uno solo, con un índice clickeable al principio: cada entrada abre la página
+ * donde empieza ese material, y cada página de contenido tiene arriba un enlace "Volver al
+ * índice" (en una franja agregada, sin tapar nada). El que no se puede abrir (roto o con
+ * clave) se salta y queda en `skipped`: pdf-lib no desencripta, así que un PDF con clave
+ * entraría con páginas rotas. El índice se arma al final, cuando se sabe qué archivos
+ * entraron, y se inserta al frente.
+ */
+export declare function mergePdfs(files: MergeInput[], documentTitle?: string): Promise<{
+    bytes: Uint8Array;
+    pages: number;
+    merged: MergedFile[];
+    skipped: SkippedFile[];
+}>;

package/build/shared/documents/merge.js

@@ -0,0 +1,197 @@
+import { PDFArray, PDFDocument, PDFName, StandardFonts, degrees, rgb } from "pdf-lib";
+/** Filas del índice que entran en una página A4 con letra de 11pt. */
+const INDEX_ROWS_PER_PAGE = 40;
+/**
+ * Alto de la franja que se AGREGA arriba de cada página de contenido para el enlace de
+ * vuelta al índice: la página queda un poco más alta, así el enlace nunca tapa el material.
+ */
+const BACK_STRIP = 18;
+const BACK_LABEL = "Volver al índice";
+/**
+ * Agrega a `page` un enlace rectangular (anotación Link sin borde) que muestra `dest` entera.
+ */
+function addPageLink(out, page, rect, dest) {
+    const link = out.context.register(out.context.obj({
+        Type: "Annot",
+        Subtype: "Link",
+        Rect: rect,
+        Border: [0, 0, 0],
+        Dest: [dest.ref, "Fit"],
+    }));
+    let annots = page.node.lookupMaybe(PDFName.of("Annots"), PDFArray);
+    if (!annots) {
+        annots = out.context.obj([]);
+        page.node.set(PDFName.of("Annots"), annots);
+    }
+    annots.push(link);
+}
+/**
+ * Une PDFs en uno solo, con un índice clickeable al principio: cada entrada abre la página
+ * donde empieza ese material, y cada página de contenido tiene arriba un enlace "Volver al
+ * índice" (en una franja agregada, sin tapar nada). El que no se puede abrir (roto o con
+ * clave) se salta y queda en `skipped`: pdf-lib no desencripta, así que un PDF con clave
+ * entraría con páginas rotas. El índice se arma al final, cuando se sabe qué archivos
+ * entraron, y se inserta al frente.
+ */
+export async function mergePdfs(files, documentTitle) {
+    const out = await PDFDocument.create();
+    if (documentTitle)
+        out.setTitle(documentTitle);
+    const merged = [];
+    /** En qué página empieza cada uno sin contar el índice, que todavía no se sabe cuánto ocupa. */
+    const contentStarts = [];
+    const skipped = [];
+    for (let index = 0; index < files.length; index++) {
+        const file = files[index];
+        let src;
+        try {
+            // ignoreEncryption solo para que `load` no rechace el archivo: así lo listamos
+            // en `skipped` con el motivo en vez de romper todo el pack.
+            src = await PDFDocument.load(file.bytes, { ignoreEncryption: true });
+        }
+        catch {
+            skipped.push({ index, title: file.title, reason: "no se pudo abrir (está roto)" });
+            continue;
+        }
+        if (src.isEncrypted) {
+            skipped.push({ index, title: file.title, reason: "tiene clave" });
+            continue;
+        }
+        let pages;
+        try {
+            pages = await out.copyPages(src, src.getPageIndices());
+        }
+        catch {
+            // Abre bien pero tiene objetos que no se pueden copiar: se salta como los rotos.
+            skipped.push({ index, title: file.title, reason: "no se pudieron copiar sus páginas" });
+            continue;
+        }
+        if (!pages.length) {
+            skipped.push({ index, title: file.title, reason: "no tiene páginas" });
+            continue;
+        }
+        contentStarts.push(out.getPageCount() + 1);
+        for (const page of pages)
+            out.addPage(page);
+        merged.push({ index, title: file.title, pages: pages.length });
+    }
+    if (!merged.length)
+        throw new Error("No se pudo unir ninguno de los PDF.");
+    const indexPages = Math.ceil(merged.length / INDEX_ROWS_PER_PAGE);
+    const withStart = merged.map((m, i) => ({ ...m, startPage: contentStarts[i] + indexPages }));
+    const font = await out.embedFont(StandardFonts.Helvetica);
+    await writeIndex(out, withStart, indexPages, font);
+    addBackLinks(out, indexPages, font);
+    const bytes = await out.save();
+    return { bytes, pages: out.getPageCount(), merged: withStart, skipped };
+}
+/** Escribe las páginas del índice y las inserta al frente, con cada renglón enlazado a su material. */
+async function writeIndex(out, merged, indexPages, font) {
+    const bold = await out.embedFont(StandardFonts.HelveticaBold);
+    const pageSize = [595, 842]; // A4
+    const margin = 50;
+    const lineHeight = 16;
+    const pages = [];
+    for (let n = 0; n < indexPages; n++) {
+        const page = out.insertPage(n, pageSize);
+        page.drawText(winAnsi("Índice"), { x: margin, y: pageSize[1] - margin, size: 16, font: bold });
+        pages.push(page);
+    }
+    merged.forEach((row, i) => {
+        const page = pages[Math.floor(i / INDEX_ROWS_PER_PAGE)];
+        const y = pageSize[1] - margin - lineHeight * (2 + (i % INDEX_ROWS_PER_PAGE));
+        const pageNo = String(row.startPage);
+        page.drawText(pageNo, { x: margin + 30 - font.widthOfTextAtSize(pageNo, 11), y, size: 11, font });
+        page.drawText(truncate(winAnsi(row.title), font, 11, pageSize[0] - margin * 2 - 40), {
+            x: margin + 40,
+            y,
+            size: 11,
+            font,
+        });
+        addPageLink(out, page, [margin, y - 4, pageSize[0] - margin, y + 11], out.getPage(row.startPage - 1));
+    });
+}
+/**
+ * Agrega a cada página de contenido una franja vacía con "Volver al índice" enlazado a la
+ * primera página del índice. La franja AGRANDA la página por el borde que queda arriba al
+ * leerla (arriba sin rotación; a la izquierda, abajo o a la derecha según la rotación de la
+ * página) y el texto se dibuja ya rotado: se lee horizontal en cualquier orientación y, al
+ * ser espacio agregado, nunca tapa el material. Toda la franja es clickeable.
+ */
+function addBackLinks(out, indexPages, font) {
+    const firstIndexPage = out.getPage(0);
+    const size = 9;
+    const color = rgb(0.1, 0.3, 0.7);
+    const textWidth = font.widthOfTextAtSize(BACK_LABEL, size);
+    const total = out.getPageCount();
+    for (let i = indexPages; i < total; i++) {
+        const page = out.getPage(i);
+        // Los dos box se leen ANTES de escribir: sin CropBox propio, getCropBox devuelve el
+        // MediaBox, y leerlo después de agrandarlo agrandaría el CropBox dos veces.
+        const media = page.getMediaBox();
+        const crop = page.getCropBox();
+        const { x: X, y: Y, width: w, height: h } = media;
+        const rotation = (((page.getRotation().angle % 360) + 360) % 360);
+        // Posición del texto y dirección del subrayado según el borde por donde crece la página.
+        let textX, textY, lineStart, lineEnd;
+        let strip;
+        let rotate;
+        switch (rotation) {
+            case 90:
+                // Al leerla rotada 90° el borde izquierdo queda arriba: la franja crece a la izquierda.
+                page.setMediaBox(X - BACK_STRIP, Y, w + BACK_STRIP, h);
+                page.setCropBox(crop.x - BACK_STRIP, crop.y, crop.width + BACK_STRIP, crop.height);
+                strip = [X - BACK_STRIP, Y, X, Y + h];
+                rotate = degrees(90);
+                textX = X - BACK_STRIP + 5 + size;
+                textY = Y + h - 30 - textWidth;
+                lineStart = { x: textX + 1.5, y: textY };
+                lineEnd = { x: textX + 1.5, y: textY + textWidth };
+                break;
+            case 180:
+                page.setMediaBox(X, Y - BACK_STRIP, w, h + BACK_STRIP);
+                page.setCropBox(crop.x, crop.y - BACK_STRIP, crop.width, crop.height + BACK_STRIP);
+                strip = [X, Y - BACK_STRIP, X + w, Y];
+                rotate = degrees(180);
+                textX = X + 30 + textWidth;
+                textY = Y - BACK_STRIP + 5 + size;
+                lineStart = { x: textX, y: textY + 1.5 };
+                lineEnd = { x: textX - textWidth, y: textY + 1.5 };
+                break;
+            case 270:
+                page.setMediaBox(X, Y, w + BACK_STRIP, h);
+                page.setCropBox(crop.x, crop.y, crop.width + BACK_STRIP, crop.height);
+                strip = [X + w, Y, X + w + BACK_STRIP, Y + h];
+                rotate = degrees(270);
+                textX = X + w + BACK_STRIP - 5 - size;
+                textY = Y + 30 + textWidth;
+                lineStart = { x: textX - 1.5, y: textY };
+                lineEnd = { x: textX - 1.5, y: textY - textWidth };
+                break;
+            default:
+                page.setMediaBox(X, Y, w, h + BACK_STRIP);
+                page.setCropBox(crop.x, crop.y, crop.width, crop.height + BACK_STRIP);
+                strip = [X, Y + h, X + w, Y + h + BACK_STRIP];
+                rotate = degrees(0);
+                textX = X + w - 30 - textWidth;
+                textY = Y + h + 5;
+                lineStart = { x: textX, y: textY - 1.5 };
+                lineEnd = { x: textX + textWidth, y: textY - 1.5 };
+                break;
+        }
+        page.drawText(BACK_LABEL, { x: textX, y: textY, size, font, color, rotate });
+        page.drawLine({ start: lineStart, end: lineEnd, thickness: 0.5, color });
+        addPageLink(out, page, strip, firstIndexPage);
+    }
+}
+/** Lo que la letra base del PDF sabe dibujar (WinAnsi); lo demás se cambia por "?". */
+const winAnsi = (text) => text.replace(/[^\x20-\x7E\xA0-\xFF\u2013\u2014\u2018\u2019\u201C\u201D\u2022\u2026]/g, "?");
+/** Recorta el título para que entre en el renglón, con "…" si se cortó. */
+function truncate(text, font, size, maxWidth) {
+    if (font.widthOfTextAtSize(text, size) <= maxWidth)
+        return text;
+    let cut = text;
+    while (cut && font.widthOfTextAtSize(cut + "…", size) > maxWidth)
+        cut = cut.slice(0, -1);
+    return cut + "…";
+}

package/build/shared/documents/office.d.ts

@@ -0,0 +1,9 @@
+import { type ParsedDocument } from "./index.js";
+/**
+ * docx, pptx y xlsx son zips de XML. Sacar el texto es leer unos pocos XML; no hace falta
+ * una librería de Office para eso.
+ */
+export type OfficeFormat = "docx" | "pptx" | "xlsx";
+/** Mira la lista de entradas del zip sin descomprimir nada. */
+export declare function detectOfficeFormat(bytes: Uint8Array): OfficeFormat | null;
+export declare function openOffice(bytes: Uint8Array, format: OfficeFormat): ParsedDocument;

package/build/shared/documents/pdf.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedDocument } from "./index.js";
+export declare function openPdf(bytes: Uint8Array): Promise<ParsedDocument>;

package/build/shared/documents/png.d.ts

@@ -0,0 +1,2 @@
+/** PNG en escala de grises, 8 bits. Alcanza para páginas escaneadas y evita una dependencia de imágenes. */
+export declare function grayscalePng(width: number, height: number, pixels: Uint8Array): Uint8Array;

package/build/shared/documents/zip.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Lector mínimo de zip, lo justo para docx/pptx/xlsx: lee el índice (directorio central) del final
+ * del archivo y descomprime las entradas pedidas. Sin zip64 ni cifrado, que Office no usa.
+ */
+export interface ZipEntry {
+    name: string;
+    method: number;
+    compressedSize: number;
+    size: number;
+    /** Dónde empieza el encabezado local de la entrada. */
+    offset: number;
+}
+export declare function listZip(bytes: Uint8Array): ZipEntry[];
+/**
+ * Descomprime una entrada. `max` corta aunque el índice mienta sobre el tamaño: un zip chico que se
+ * infla a gigas es un ataque conocido.
+ */
+export declare function readEntry(bytes: Uint8Array, entry: ZipEntry, max: number): Uint8Array;

package/build/shared/html.d.ts

@@ -0,0 +1,6 @@
+/** HTML de Moodle a texto plano: alcanza para que el modelo lo lea, no es un parser. */
+export declare function htmlToText(html: string | undefined): string;
+/** Como htmlToText pero recortado: para índices, donde solo hace falta decidir si entrar. */
+export declare function htmlToSnippet(html: string | undefined, max?: number): string;
+/** Texto plano del modelo a HTML para Moodle: escapa, y cada línea en blanco separa un párrafo. */
+export declare function textToHtml(text: string): string;

package/build/shared/html.js

@@ -1,4 +1,10 @@
-const ENTITIES = { nbsp: " ", amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+// Las con tildes/eñe son las que usan Sysacad y el aula para el español.
+const ENTITIES = {
+    nbsp: " ", amp: "&", lt: "<", gt: ">", quot: '"', apos: "'",
+    aacute: "á", eacute: "é", iacute: "í", oacute: "ó", uacute: "ú", uuml: "ü",
+    Aacute: "Á", Eacute: "É", Iacute: "Í", Oacute: "Ó", Uacute: "Ú", Uuml: "Ü",
+    ntilde: "ñ", Ntilde: "Ñ", iexcl: "¡", iquest: "¿", deg: "°", ordm: "º", ordf: "ª",
+};
 /** HTML de Moodle a texto plano: alcanza para que el modelo lo lea, no es un parser. */
 export function htmlToText(html) {
     if (!html)

package/build/shared/http.d.ts

@@ -0,0 +1,6 @@
+export declare class HttpError extends Error {
+    readonly status?: number | undefined;
+    constructor(message: string, status?: number | undefined);
+}
+/** POST application/x-www-form-urlencoded y parseo JSON, con timeout. */
+export declare function postForm<T>(url: string, params: Record<string, string | number>, timeoutMs?: number): Promise<T>;

package/build/shared/input.d.ts

@@ -0,0 +1,7 @@
+export declare function ask(question: string): Promise<string>;
+/**
+ * Elige una de `options` con las flechas (o su número) y Enter; devuelve el índice. Sin terminal
+ * interactiva (stdin redirigido) muestra la lista numerada y pide el número. Enter solo elige `initial`.
+ */
+export declare function askChoice(question: string, options: string[], initial?: number): Promise<number>;
+export declare function askHidden(question: string): Promise<string>;

package/build/shared/load-env.d.ts

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

package/build/shared/logger.d.ts

@@ -0,0 +1,5 @@
+export declare const logger: {
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+};

package/build/shared/pages.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Página mínima con el estilo del sitio del proyecto: se abre desde el celu, así que nada más que lo necesario.
+ * `kicker` es la etiqueta chica arriba del título.
+ */
+export declare function page(title: string, body: string, kicker?: string): string;
+export declare const escapeHtml: (s: string) => string;

package/build/shared/paths.d.ts

@@ -0,0 +1,10 @@
+/** Carpeta de configuración: UTN_MCP_HOME, %APPDATA% en Windows, o XDG/~/.config en Linux y macOS. */
+export declare function configDir(): string;
+/** Token de Moodle del modo local. */
+export declare const sessionFile: () => string;
+/** Base de usuarios, tokens y sesiones del modo HTTP: UTN_MCP_DB o un SQLite en la carpeta de configuración. */
+export declare const storeFile: () => string;
+/** Clave con la que se cifran las sesiones en la base, si no viene en UTN_MCP_KEY. */
+export declare const storeKeyFile: () => string;
+/** Dónde quedan los archivos que arma el servidor (packs de estudio): UTN_MCP_EXPORTS o exports/ en la configuración. */
+export declare function exportsDir(): string;

package/build/shared/paths.js

@@ -15,3 +15,7 @@ export const sessionFile = () => join(configDir(), "session.json");
 export const storeFile = () => process.env.UTN_MCP_DB ?? join(configDir(), "utn-mcp.db");
 /** Clave con la que se cifran las sesiones en la base, si no viene en UTN_MCP_KEY. */
 export const storeKeyFile = () => join(configDir(), "store.key");
+/** Dónde quedan los archivos que arma el servidor (packs de estudio): UTN_MCP_EXPORTS o exports/ en la configuración. */
+export function exportsDir() {
+    return process.env.UTN_MCP_EXPORTS ?? join(configDir(), "exports");
+}

package/build/shared/store/session-store.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Dónde viven los usuarios del modo HTTP, sus tokens y sus sesiones en cada plataforma. El servidor
+ * MCP lee (y guarda la sesión cuando la renueva); los usuarios y tokens los crea otro proceso: el
+ * login por OAuth de la versión hosteada o `utn-mcp login --http` en local.
+ */
+export interface SessionStore {
+    /**
+     * Id del usuario con ese nombre en esa regional; lo crea si no existe. Con `email`, se lo actualiza.
+     * Dos regionales pueden tener el mismo nombre de usuario para personas distintas.
+     */
+    findOrCreateUser(regional: string, utnUsername: string, email?: string): Promise<number>;
+    findUser(userId: number): Promise<StoredUser | null>;
+    findUserByEmail(email: string): Promise<StoredUser | null>;
+    /** Todos los usuarios, los más nuevos primero. */
+    listUsers(): Promise<ListedUser[]>;
+    /**
+     * Emite un token para el usuario y devuelve el valor en claro: se muestra una sola vez, en la base
+     * queda solo el hash. Sin `ttlSeconds` no vence (el token fijo del modo local).
+     */
+    issueToken(userId: number, options: {
+        kind: TokenKind;
+        clientId?: string;
+        ttlSeconds?: number;
+    }): Promise<string>;
+    /** El token si es de ese tipo y está vigente; si no, null. */
+    findToken(token: string, kind: TokenKind): Promise<IssuedToken | null>;
+    revokeToken(token: string): Promise<void>;
+    /** La sesión del usuario en una plataforma, tal como la guardó: cada plataforma decide su forma. */
+    loadSession(userId: number, platform: string): Promise<string | null>;
+    saveSession(userId: number, platform: string, data: string): Promise<void>;
+    /** Cuándo se guardó por última vez la sesión, en segundos desde epoch; null si no hay. */
+    sessionUpdatedAt(userId: number, platform: string): Promise<number | null>;
+    /** Las regionales que alguien ya usó en este servidor sin que estuvieran verificadas en el catálogo. */
+    listVerifiedRegionals(): Promise<string[]>;
+    /** true si esta llamada la verificó: nadie lo había hecho antes. */
+    markRegionalVerified(regional: string): Promise<boolean>;
+    /** Clientes OAuth registrados por registro dinámico (RFC 7591). */
+    saveClient(client: RegisteredClient): Promise<void>;
+    findClient(clientId: string): Promise<RegisteredClient | null>;
+    /** Los clientes que todavía tienen un token vigente del usuario: las apps que tiene conectadas. */
+    listConnectedClients(userId: number): Promise<ConnectedClient[]>;
+    /** Borra todos los tokens del usuario para ese cliente: la app queda desconectada. */
+    revokeClient(userId: number, clientId: string): Promise<void>;
+}
+export interface ConnectedClient {
+    clientId: string;
+    /** El que mandó la app al registrarse; null para el token fijo de `utn-mcp login --http`. */
+    clientName: string | null;
+    /** Cuándo se emitió su token más nuevo, en segundos desde epoch: los refresh rotan con el uso. */
+    lastTokenAt: number;
+}
+export interface StoredUser {
+    id: number;
+    /** El id de su regional (`frba`, `frt`...): su aula y, junto con el nombre, su identidad. */
+    regional: string;
+    utnUsername: string;
+    /** El institucional, el que se usa para decidir el acceso; null en usuarios de antes de guardarlo. */
+    email: string | null;
+}
+export interface ListedUser extends StoredUser {
+    /** Cuándo entró por primera vez, en segundos desde epoch. */
+    createdAt: number;
+}
+/** Un cliente público: no tiene secreto, se autentica con PKCE. */
+export interface RegisteredClient {
+    clientId: string;
+    clientName: string | null;
+    redirectUris: string[];
+}
+/** `access` va en cada request al MCP; `refresh` solo sirve para pedir un `access` nuevo. */
+export type TokenKind = "access" | "refresh";
+export interface IssuedToken {
+    userId: number;
+    clientId: string | null;
+    /** En segundos desde epoch; null si no vence. */
+    expiresAt: number | null;
+}

package/build/shared/store/sqlite-store.d.ts

@@ -0,0 +1,36 @@
+import type { ConnectedClient, IssuedToken, ListedUser, RegisteredClient, SessionStore, StoredUser, TokenKind } from "./session-store.js";
+/**
+ * El SessionStore sobre SQLite. Las sesiones van cifradas con AES-256-GCM: tienen el token de Moodle,
+ * que alcanza para entrar al aula como el usuario. Los tokens se guardan
+ * hasheados, así que una copia de la base no sirve para usar el servidor.
+ */
+export declare class SqliteStore implements SessionStore {
+    private readonly db;
+    private readonly key;
+    private constructor();
+    /** `node:sqlite` llega con Node 22.13; se importa acá para que el modo STDIO siga andando en Node 20. */
+    static open(path?: string): Promise<SqliteStore>;
+    findOrCreateUser(regional: string, utnUsername: string, email?: string): Promise<number>;
+    findUserByEmail(email: string): Promise<StoredUser | null>;
+    listUsers(): Promise<ListedUser[]>;
+    findUser(userId: number): Promise<StoredUser | null>;
+    issueToken(userId: number, options: {
+        kind: TokenKind;
+        clientId?: string;
+        ttlSeconds?: number;
+    }): Promise<string>;
+    findToken(token: string, kind: TokenKind): Promise<IssuedToken | null>;
+    revokeToken(token: string): Promise<void>;
+    loadSession(userId: number, platform: string): Promise<string | null>;
+    saveSession(userId: number, platform: string, data: string): Promise<void>;
+    listVerifiedRegionals(): Promise<string[]>;
+    markRegionalVerified(regional: string): Promise<boolean>;
+    saveClient(client: RegisteredClient): Promise<void>;
+    findClient(clientId: string): Promise<RegisteredClient | null>;
+    sessionUpdatedAt(userId: number, platform: string): Promise<number | null>;
+    listConnectedClients(userId: number): Promise<ConnectedClient[]>;
+    revokeClient(userId: number, clientId: string): Promise<void>;
+    /** iv + tag + texto cifrado, en un solo blob. */
+    private encrypt;
+    private decrypt;
+}

package/build/shared/uploads.d.ts

@@ -0,0 +1,62 @@
+export interface UploadedFile {
+    name: string;
+    bytes: Uint8Array;
+}
+/** Lo que acepta una subida; lo pone la plataforma que la abre. */
+export interface UploadLimits {
+    maxFiles?: number;
+    /** Por archivo. */
+    maxBytes: number;
+    /** En minúscula y con punto (".pdf"); sin lista, cualquiera. */
+    extensions?: string[];
+}
+/**
+ * De dónde saca el servidor los archivos que el usuario quiere subir a una plataforma: en STDIO, del
+ * disco, que es el suyo; en HTTP, de una subida, porque el servidor puede estar en otra máquina.
+ * `owner` es el usuario de la request: una subida solo la puede usar quien la abrió.
+ */
+export type FileSource = {
+    local: true;
+} | {
+    local: false;
+    inbox: UploadInbox;
+    owner: string;
+};
+interface Upload {
+    owner: string;
+    title: string;
+    limits: UploadLimits;
+    /** null mientras no se subió nada. */
+    files: UploadedFile[] | null;
+    expiresAt: number;
+}
+/** Tope de una subida entera, en bytes: los archivos quedan en memoria hasta que se entregan. */
+export declare const MAX_UPLOAD_BYTES: number;
+/**
+ * Links de un solo uso para recibir archivos por HTTP: los sube el agente con `curl` si tiene
+ * terminal, o el usuario desde el navegador. Los archivos quedan en memoria hasta que una tool los
+ * toma o el link vence; si el servidor se reinicia, se pierden y hay que pedir otro link.
+ */
+export declare class UploadInbox {
+    private readonly baseUrl;
+    private readonly uploads;
+    constructor(baseUrl: string);
+    open(owner: string, title: string, limits: UploadLimits): {
+        id: string;
+        url: string;
+        expiresAt: string;
+    };
+    /** La subida para mostrar su formulario, o undefined si no existe o venció. */
+    get(id: string): Pick<Upload, "title" | "limits" | "files"> | undefined;
+    /** Guarda los archivos de una subida; cada link acepta una sola. */
+    receive(id: string, files: UploadedFile[]): void;
+    /** Los archivos que se subieron, para entregarlos. No los borra: si la entrega falla, se reintenta. */
+    take(id: string, owner: string): UploadedFile[];
+    close(id: string): void;
+    private sweep;
+}
+/** Cantidad, tamaño, tipo y nombres repetidos, que Moodle no acepta. */
+export declare function checkFiles(files: UploadedFile[], limits: UploadLimits): void;
+/** Tamaño para personas: en KB por debajo del mega, para que un archivo chico no diga "0.0 MB". */
+export declare const formatSize: (bytes: number) => string;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "utn-mcp",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "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": {
@@ -42,6 +42,7 @@
     "@modelcontextprotocol/server": "^2.3.0",
     "@napi-rs/keyring": "^2.1.0",
     "express": "^5.2.1",
+    "pdf-lib": "^1.17.1",
     "tough-cookie": "^6.0.2",
     "zod": "^4.6.5"
   },
@@ -54,5 +55,12 @@
   },
   "engines": {
     "node": ">=20"
+  },
+  "exports": {
+    ".": "./build/index.js",
+    "./autogestion": {
+      "types": "./build/autogestion/client/connector.d.ts",
+      "default": "./build/autogestion/client/connector.js"
+    }
   }
 }