utn-mcp 0.8.3 → 0.9.1

package/README.md

@@ -29,6 +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. 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.
 
@@ -134,6 +138,15 @@ Aparece como una opción más al iniciar sesión.
 
 `UTN_REGIONAL` (por ejemplo, `UTN_REGIONAL=frt`) elige la que viene marcada por defecto, y es la que se usa si en lugar de `login` definís `UTN_USER` y `UTN_PASS`.
 
+### Autogestión (Sysacad)
+Si tu regional usa el Sysacad clásico, al terminar `login` te pregunta si querés conectarlo también. Si decís que sí, baja el conector de Sysacad (no viene con el paquete: si no lo usás, no se baja), te pide tu legajo y tu contraseña de Sysacad, que no siempre son las del aula, los prueba y los guarda en el gestor de credenciales. Para conectarlo después, o cambiar la contraseña:
+```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.
+
+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.
+
 ### Modo HTTP (opcional)
 Necesita Node 22.13 o más nuevo. Primero, una vez:
 ```bash
@@ -150,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)):
@@ -179,11 +194,12 @@ Guardá esa `UTN_MCP_KEY`: sin ella no se pueden descifrar las sesiones guardada
 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).
-- **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.
+- **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. 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`.
+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
@@ -197,5 +213,16 @@ npm run build   # compila a build/
 
 pdf.js no es una dependencia del paquete publicado. Está como `devDependency`, y `npm install` corre el script `prepare`, que copia a `vendor/pdfjs/` solo los archivos que usa el servidor (~4 MB). Así, quien instala `utn-mcp` no baja pdf.js entero ni su canvas nativo opcional (~37 MB). Si instalaste con `--ignore-scripts`, generalo a mano con `npm run prepare`.
 
+### Conectores de autogestión
+Cada sistema de autogestión es un paquete aparte en `packages/` (hoy, `packages/sysacad-asp`). No se publica en npm: `utn-mcp login` baja el `.tgz` adjunto a un release del repo, comprueba que su hash sea el de `src/autogestion/client/catalog.ts` y lo extrae en `connectors/`. El conector implementa `AutogestionSystem` de `src/autogestion/client/connector.ts` y del core importa solo tipos: lo que necesita en tiempo de ejecución (las clases de error, `htmlToText`) se lo pasa el core en `create`.
+
+Para publicar una versión de un conector:
+```bash
+node scripts/pack-connector.mjs sysacad-asp
+```
+Arma el `.tgz` en `build-connectors/` y muestra la URL y el hash que van al catálogo, y el `gh release create` que lo sube.
+
+Para probar un conector sin publicarlo, compilalo, instalalo con `npm install` en la carpeta desde la que corrés `utn-mcp` y nombralo en `UTN_MCP_CONNECTORS` (separados por comas). Cargar un conector ejecuta su código: nombrá solo paquetes en los que confíes.
+
 ## Aviso
 Este proyecto no está afiliado ni avalado por la UTN. Usalo bajo tu responsabilidad.

package/build/aula-virtual/client/client.d.ts

@@ -0,0 +1,97 @@
+import type { AulaSession } from "./session.js";
+import type { Assignment, CourseModuleContent, AssignSubmissionStatus, Choice, ChoiceOption, Course, CourseSection, ForumDiscussion, ForumPost, SiteInfo } from "./types.js";
+export declare function getSiteInfo(session: AulaSession): Promise<SiteInfo>;
+/** El usuario dueño del token, con su email institucional (site_info no lo trae). */
+export declare function getOwnUser(session: AulaSession): Promise<{
+    username: string;
+    fullname: string;
+    email: string | null;
+}>;
+export declare function getUserCourses(session: AulaSession): Promise<Course[]>;
+/**
+ * Secciones del curso con sus módulos. Con `cmid` Moodle devuelve igual todas las secciones
+ * pero solo popula el módulo pedido, así que no hay que traerse el curso entero para abrir una cosa.
+ */
+export declare function getCourseSections(session: AulaSession, courseId: number, cmid?: number): Promise<CourseSection[]>;
+/** Un archivo de un curso, con dónde está: en qué sección y en qué módulo. */
+export interface CourseFileEntry {
+    section: string;
+    module: string;
+    file: CourseModuleContent;
+}
+/**
+ * Los archivos de las secciones y módulos visibles del curso, en el orden en que aparecen en el aula.
+ * Los mismos filtros de visibilidad que el mapa del curso de format/navigate.
+ */
+export declare function getCourseFiles(session: AulaSession, courseId: number): Promise<ReadonlyArray<CourseFileEntry>>;
+/** Cuántas discusiones trae una página del índice de un foro. */
+export declare const PAGE_SIZE = 50;
+/**
+ * Discusiones de un foro, las más recientes primero. Moodle manda el mensaje completo de la
+ * primera publicación de cada una; el que lee decide si lo recorta.
+ */
+export declare function getForumDiscussions(session: AulaSession, forumid: number, page?: number): Promise<{
+    discussions: ForumDiscussion[];
+}>;
+/** Publicaciones de una discusión, incluidas las respuestas. */
+export declare function getDiscussionPosts(session: AulaSession, discussionid: number): Promise<{
+    posts: ForumPost[];
+}>;
+/** Si el usuario puede abrir un hilo en el foro, con el grupo que le toque. */
+export declare function canAddDiscussion(session: AulaSession, forumid: number): Promise<boolean>;
+/** Abre un hilo. Moodle elige solo el grupo del usuario si el foro es por grupos. */
+export declare function addDiscussion(session: AulaSession, forumid: number, subject: string, message: string): Promise<number>;
+/** Responde a una publicación, que puede ser la primera de la discusión. */
+export declare function addDiscussionPost(session: AulaSession, postid: number, subject: string, message: string): Promise<number>;
+/** Edita una publicación propia; con asunto vacío Moodle deja el que tenía. */
+export declare function updateDiscussionPost(session: AulaSession, postid: number, subject: string, message: string): Promise<void>;
+/** Borra una publicación; si es la primera, se va la discusión entera. */
+export declare function deletePost(session: AulaSession, postid: number): Promise<void>;
+/** Las tareas de un curso con su configuración: fechas y qué tipos de entrega aceptan. */
+export declare function getAssignments(session: AulaSession, courseId: number): Promise<Assignment[]>;
+/** Estado de la entrega del usuario y, si ya la corrigieron, la devolución. */
+export declare function getSubmissionStatus(session: AulaSession, assignid: number): Promise<AssignSubmissionStatus>;
+/** Un borrador vacío: el `itemid` que se manda para dejar un área sin archivos. */
+export declare function getUnusedDraftItemId(session: AulaSession): Promise<number>;
+/**
+ * Guarda la entrega. Cada plugin habilitado reemplaza lo que tenía con lo que se le pasa: el de
+ * archivos toma el borrador `filesItemId` entero y el de texto, `text`.
+ */
+export declare function saveSubmission(session: AulaSession, assignmentid: number, data: {
+    filesItemId?: number;
+    text?: {
+        html: string;
+        format: number;
+        itemid: number;
+    };
+}): Promise<void>;
+/** Confirma el envío de un borrador. Después ya no se puede editar. */
+export declare function submitForGrading(session: AulaSession, assignmentid: number, acceptStatement: boolean): Promise<void>;
+/**
+ * Vacía la entrega del usuario (o la de su grupo). Es la única forma de dejarla sin nada:
+ * mod_assign_save_submission rechaza una entrega vacía.
+ */
+export declare function removeSubmission(session: AulaSession, assignid: number): Promise<void>;
+export declare function getChoices(session: AulaSession, courseId: number): Promise<Choice[]>;
+export declare function getChoiceOptions(session: AulaSession, choiceid: number): Promise<ChoiceOption[]>;
+export declare function submitChoiceResponse(session: AulaSession, choiceid: number, optionIds: number[]): Promise<void>;
+export declare function deleteChoiceResponses(session: AulaSession, choiceid: number): Promise<void>;
+export declare function getChoicegroupOptions(session: AulaSession, choicegroupid: number): Promise<ChoiceOption[]>;
+/**
+ * El plugin lee `responses` si la actividad deja un solo grupo y `choicegroup_<id>: "true"` si deja
+ * varios, y la configuración no se puede consultar: mandamos las dos formas y él usa la que le sirve.
+ * Con varios grupos, los que no vienen marcados se quitan.
+ */
+export declare function submitChoicegroupResponse(session: AulaSession, choicegroupid: number, optionIds: number[]): Promise<void>;
+export declare function deleteChoicegroupResponses(session: AulaSession, choicegroupid: number): Promise<void>;
+/** Nombre de otro usuario, visto desde el usuario logueado, o null si no existe. */
+export declare function getMemberName(session: AulaSession, userId: number): Promise<string | null>;
+/** Manda un mensaje privado. Moodle no tira excepción si falla: devuelve `msgid: -1` y el motivo. */
+export declare function sendInstantMessage(session: AulaSession, touserid: number, html: string): Promise<number>;
+/** Crea un evento personal: solo lo ve el usuario. */
+export declare function createUserEvent(session: AulaSession, event: {
+    name: string;
+    description: string;
+    timestart: number;
+    timeduration: number;
+}): Promise<number>;

package/build/aula-virtual/client/credentials.d.ts

@@ -0,0 +1,10 @@
+export interface Credentials {
+    username: string;
+    password: string;
+    /** Falta en UTN_USER/UTN_PASS y en las guardadas antes de elegir la regional al entrar. */
+    regional?: string;
+}
+/** Primero UTN_USER/UTN_PASS; si no están, el keychain del sistema. */
+export declare function loadCredentials(): Promise<Credentials | null>;
+/** Guarda en el keychain. Devuelve false si no hay keychain (ej. Linux sin Secret Service). */
+export declare function saveCredentials(creds: Credentials): Promise<boolean>;

package/build/aula-virtual/client/link.d.ts

@@ -0,0 +1,21 @@
+import type { SessionStore } from "../../shared/store/session-store.js";
+import type { Credentials } from "./credentials.js";
+import type { Regional } from "./regionals.js";
+import { type SecondFactor } from "./sso-login.js";
+export interface LinkedAccount {
+    userId: number;
+    regional: Regional;
+    username: string;
+    fullname: string;
+    email: string | null;
+    /** Este login fue el primero en verificar la regional en este servidor. */
+    firstVerifier: boolean;
+}
+/**
+ * Entra al aula de la regional con usuario y contraseña, crea el usuario del store si no existe y le
+ * guarda la sesión (el token). La contraseña se usa solo acá: no se guarda en ningún lado.
+ * Lo usan `utn-mcp login --http`, el login por OAuth de la versión hosteada y `/admin/verificar`.
+ * `regional` tiene que venir con su soporte en este servidor (`availableRegionals` con las verificadas).
+ * `secondFactor` contesta el MFA de Microsoft si la cuenta lo pide.
+ */
+export declare function linkAulaAccount(store: SessionStore, regional: Regional, credentials: Credentials, secondFactor?: SecondFactor): Promise<LinkedAccount>;

package/build/aula-virtual/client/local-session.d.ts

@@ -0,0 +1,23 @@
+import { type Credentials } from "./credentials.js";
+import { type Regional } from "./regionals.js";
+import type { AulaSession } from "./session.js";
+import { type SecondFactor } from "./sso-login.js";
+/**
+ * Sesión del modo local: un solo usuario, guardada en disco.
+ * Credenciales en el keychain (o UTN_USER/UTN_PASS); el token y la regional en session.json.
+ */
+export declare class LocalSession implements AulaSession {
+    private refreshing;
+    /**
+     * La elegida en `utn-mcp login`: la de session.json o, si se borró, la guardada con las credenciales.
+     * Sin login (UTN_USER/UTN_PASS) o de antes de elegirla, la de UTN_REGIONAL.
+     */
+    getRegional(): Promise<Regional>;
+    getToken(): Promise<string>;
+    /** Una sola renovación en curso aunque varias tools fallen a la vez. */
+    refreshToken(): Promise<string>;
+    /** Obtiene un token nuevo y lo guarda. Sin `secondFactor` (al renovar solo), una cuenta con MFA no entra. */
+    login(regional: Regional, credentials: Credentials | null, secondFactor?: SecondFactor): Promise<string>;
+    private read;
+    private write;
+}

package/build/aula-virtual/client/moodle-api.d.ts

@@ -0,0 +1,25 @@
+import type { AulaSession } from "./session.js";
+export declare class MoodleError extends Error {
+    readonly errorcode?: string | undefined;
+    constructor(message: string, errorcode?: string | undefined);
+}
+/** Llama a una función del web service de Moodle; renueva el token una vez si venció. */
+export declare function callWs<T>(session: AulaSession, wsfunction: string, params?: Record<string, string | number>): Promise<T>;
+/**
+ * Baja un archivo de `webservice/pluginfile.php` con el token; lo renueva una vez si venció.
+ * Los errores llegan como JSON (`{ error, errorcode }`) en lugar del archivo.
+ * Los redirects se siguen a mano y SOLO al propio aula y a rutas de archivos (pluginfile):
+ * un pluginfile legítimo no redirige afuera, así que cualquier otro destino se rechaza.
+ */
+export declare function fetchFile(session: AulaSession, url: URL, maxBytes: number): Promise<{
+    bytes: Uint8Array;
+    contentType: string | null;
+}>;
+/**
+ * Sube archivos al área de borrador del usuario por `webservice/upload.php` y devuelve su `itemid`,
+ * que es lo que piden las funciones que guardan archivos. Todos quedan en el mismo borrador.
+ */
+export declare function uploadDraftFiles(session: AulaSession, files: {
+    name: string;
+    bytes: Uint8Array;
+}[]): Promise<number>;

package/build/aula-virtual/client/regionals.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Qué se sabe de si el MCP anda con el aula de una regional:
+ * - `verified`: alguien ya entró y usó las tools.
+ * - `candidate`: tiene habilitado el servicio `moodle_mobile_app` (y se sabe cómo entra), así que
+ *   casi seguro anda; se verifica con el primer login que funcione.
+ * - `unsupported`: no tiene el servicio habilitado, o entra por un login que todavía no sabemos usar;
+ *   se puede elegir, pero todavía no se puede usar.
+ */
+export type RegionalSupport = "verified" | "candidate" | "unsupported";
+/** Los SSO que sabemos usar: Keycloak propio de la regional u Office 365 (Microsoft Entra ID). */
+export type SsoProviderId = "keycloak" | "microsoft";
+/** El SSO por el que entra el aula: quién valida usuario y contraseña, y en qué host. */
+export interface Sso {
+    provider: SsoProviderId;
+    host: string;
+}
+/** El aula virtual de una regional de la UTN. Sin `sso`, entra con el login directo de Moodle. */
+export interface Regional {
+    id: string;
+    name: string;
+    baseUrl: string;
+    sso?: Sso;
+    support: RegionalSupport;
+}
+/** `UTN_REGIONAL` no está en el registro: sin cortar acá, las credenciales irían al SSO de FRBA. */
+export declare class UnknownRegionalError extends Error {
+    name: string;
+    constructor(regional: string);
+}
+/** Su aula no tiene el servicio habilitado o entra por un SSO que no sabemos usar: ni se intenta entrar. */
+export declare class UnsupportedRegionalError extends Error {
+    readonly regional: Regional;
+    name: string;
+    constructor(regional: Regional);
+}
+/**
+ * Las que se pueden elegir al iniciar sesión: el catálogo y, si está definida, la de UTN_AULA_BASE_URL.
+ * `verifiedIds` son las `candidate` que ya se verificaron en el servidor (las guarda el store).
+ */
+export declare function availableRegionals(verifiedIds?: Iterable<string>): Regional[];
+/** La regional con ese id; si no está entre las disponibles, `UnknownRegionalError`. */
+export declare function findRegional(id: string): Regional;
+/**
+ * La que viene elegida si nadie dice otra: la de UTN_REGIONAL; si no, la de UTN_AULA_BASE_URL; si no,
+ * FRBA. Es la de quien usa UTN_USER/UTN_PASS sin `utn-mcp login`, y la opción por defecto al elegir.
+ */
+export declare function defaultRegional(): Regional;

package/build/aula-virtual/client/session.d.ts

@@ -0,0 +1,12 @@
+import type { Regional } from "./regionals.js";
+/**
+ * El aula y el token de un usuario. Todo lo que habla con el aula recibe esto y no sabe de dónde sale:
+ * `LocalSession` (STDIO, el usuario de la compu) o `StoredAulaSession` (HTTP, un usuario del store).
+ */
+export interface AulaSession {
+    getRegional(): Promise<Regional>;
+    /** Token vigente; si no hay ninguno, obtiene uno. */
+    getToken(): Promise<string>;
+    /** Descarta el token actual y obtiene uno nuevo. */
+    refreshToken(): Promise<string>;
+}

package/build/aula-virtual/client/sso-login.d.ts

@@ -0,0 +1,60 @@
+import type { Credentials } from "./credentials.js";
+import { type Regional } from "./regionals.js";
+export declare class LoginRequiredError extends Error {
+    constructor(message?: string);
+}
+export declare class InvalidCredentialsError extends Error {
+    constructor(reason?: string);
+}
+/**
+ * Obtiene un token del web service. Dos estrategias según la regional:
+ * - Regionales con SSO (Keycloak como FRBA, Office 365 como FRH): flujo de launch.php, que usa la
+ *   sesión del SSO. Si el SSO rechaza las credenciales, `login/token.php`: hay usuarios sin cuenta en
+ *   el SSO.
+ * - Regionales con login directo de Moodle (ej. FRT): primero `login/token.php` (no depende del
+ *   plugin de mobile launch, que puede estar deshabilitado); si falla, flujo de launch.php.
+ * Las cookies se usan solo durante el login y se descartan: las sesiones de Moodle y del SSO duran
+ * horas y el token, semanas, así que no sirven para renovarlo.
+ * `secondFactor` contesta el MFA de Microsoft; sin él (las renovaciones solas), una cuenta con MFA da
+ * `MfaRequiredError`.
+ */
+export declare function fetchToken(regional: Regional, credentials: Credentials, secondFactor?: SecondFactor): Promise<string>;
+/** La cuenta pide MFA y no hay quién lo conteste: pasa al renovar solo, sin el usuario delante. */
+export declare class MfaRequiredError extends LoginRequiredError {
+    constructor();
+}
+/** El segundo factor no se pudo completar; el mensaje dice por qué y se le puede mostrar al usuario. */
+export declare class MfaError extends Error {
+    constructor(message: string);
+}
+/** Un método de segundo factor de la cuenta de Microsoft que sabemos completar. */
+export interface MfaMethod {
+    /** El `authMethodId` de Microsoft (ej. `PhoneAppNotification`, `OneWaySMS`). */
+    id: string;
+    /** "approve": se aprueba en el celular (notificación o llamada); "code": se tipea un código. */
+    kind: "approve" | "code";
+    /** Para mostrarle al usuario, con el teléfono enmascarado si Microsoft lo da (ej. "Código por SMS · +XX XXXXXXXX12"). */
+    label: string;
+}
+/** Lo que el login le pregunta al usuario para completar el segundo factor. */
+export type MfaPrompt = {
+    step: "choose";
+    methods: MfaMethod[];
+} | {
+    step: "code";
+    method: MfaMethod;
+    retry: boolean;
+}
+/** `number` es el que Authenticator pide tipear al aprobar, si lo pide. */
+ | {
+    step: "approve";
+    method: MfaMethod;
+    number?: number;
+};
+/**
+ * Quien contesta el segundo factor: el CLI o la página de login del servidor. Con "choose" devuelve el
+ * `id` del método; con "code", el código; con "approve", cualquier cosa cuando el usuario ya aprobó.
+ */
+export type SecondFactor = (prompt: MfaPrompt) => Promise<string>;
+/** moodlemobile://token=BASE64(siteid:::token[:::privatetoken]) → token */
+export declare function decodeLaunchToken(url: string): string;

package/build/aula-virtual/client/stored-session.d.ts

@@ -0,0 +1,32 @@
+import type { SessionStore } from "../../shared/store/session-store.js";
+import { type Regional } from "./regionals.js";
+import type { AulaSession } from "./session.js";
+/** Con qué nombre guarda el aula su sesión en el store. */
+export declare const AULA_PLATFORM = "aula";
+/** Lo que el aula guarda en el store para un usuario. */
+export interface StoredAulaData {
+    username: string;
+    token: string;
+}
+/**
+ * Sesión del modo HTTP: la de un usuario del store, en el aula de su regional. Renueva el token con la
+ * contraseña del keychain cuando es de este mismo usuario: eso pasa solo en local, porque el servidor
+ * hosteado no guarda contraseñas. Si no, el usuario vuelve a iniciar sesión.
+ */
+export declare class StoredAulaSession implements AulaSession {
+    private readonly store;
+    private readonly userId;
+    private readonly loginUrl?;
+    private refreshing;
+    private regional;
+    /** `loginUrl` es la página donde el usuario vuelve a iniciar sesión, si el servidor tiene una. */
+    constructor(store: SessionStore, userId: number, loginUrl?: string | undefined);
+    /** La del usuario en el store; no cambia mientras dura la sesión, así que se lee una sola vez. */
+    getRegional(): Promise<Regional>;
+    getToken(): Promise<string>;
+    refreshToken(): Promise<string>;
+    private renew;
+    private read;
+    /** Hosteado, el usuario vuelve a entrar por la página del servidor; sin ella, por el CLI. */
+    private loginRequired;
+}

package/build/aula-virtual/client/types.d.ts

@@ -0,0 +1,173 @@
+export interface SiteInfo {
+    sitename: string;
+    username: string;
+    fullname: string;
+    userid: number;
+    release: string;
+    functions: {
+        name: string;
+        version: string;
+    }[];
+}
+export interface Course {
+    id: number;
+    shortname: string;
+    fullname: string;
+    visible: number;
+    progress?: number | null;
+    lastaccess?: number | null;
+}
+export interface CourseModuleContent {
+    type: "file" | "url" | "content";
+    filename: string;
+    filepath: string | null;
+    filesize: number;
+    fileurl: string;
+    timemodified: number | null;
+    mimetype?: string;
+}
+export interface CourseModule {
+    id: number;
+    name: string;
+    modname: string;
+    /** id del plugin, no del módulo: es lo que piden las funciones mod_* (p. ej. forumid). */
+    instance: number;
+    url?: string;
+    description?: string;
+    uservisible: boolean;
+    availabilityinfo?: string;
+    dates?: {
+        label: string;
+        timestamp: number;
+    }[];
+    contents?: CourseModuleContent[];
+}
+export interface CourseSection {
+    id: number;
+    name: string;
+    section: number;
+    summary: string;
+    uservisible?: boolean;
+    modules: CourseModule[];
+}
+export interface ForumDiscussion {
+    /** id de la discusión; es el que pide mod_forum_get_discussion_posts. */
+    discussion: number;
+    subject: string;
+    message: string;
+    userfullname: string;
+    created: number;
+    timemodified: number;
+    numreplies: number;
+    userid: number;
+    pinned: boolean;
+    attachment: boolean;
+}
+export interface ForumPost {
+    id: number;
+    subject: string;
+    /** El asunto que Moodle propone para responderla ("Re: ..."). */
+    replysubject: string;
+    message: string;
+    author: {
+        id: number;
+        fullname: string;
+    };
+    timecreated: number;
+    parentid: number | null;
+    isdeleted: boolean;
+    capabilities: {
+        reply: boolean;
+        edit: boolean;
+        delete: boolean;
+    };
+    attachments: {
+        filename: string;
+        fileurl: string;
+        filesize: number;
+        mimetype?: string;
+    }[];
+}
+export interface MoodleFile {
+    filename: string;
+    filepath?: string | null;
+    filesize: number;
+    fileurl: string;
+    mimetype?: string;
+    timemodified?: number | null;
+}
+/** Un plugin de entrega o de devolución: archivos (`fileareas`) o texto (`editorfields`). */
+export interface AssignPlugin {
+    type: string;
+    name: string;
+    fileareas?: {
+        area: string;
+        files?: MoodleFile[];
+    }[];
+    editorfields?: {
+        name: string;
+        text: string;
+        format: number;
+    }[];
+}
+export interface AssignSubmission {
+    status: "new" | "draft" | "submitted" | "reopened" | string;
+    timemodified: number;
+    plugins?: AssignPlugin[];
+}
+export interface AssignSubmissionStatus {
+    lastattempt?: {
+        submission?: AssignSubmission;
+        /** En las entregas grupales la que cuenta es esta, no la individual. */
+        teamsubmission?: AssignSubmission;
+        locked: boolean;
+        graded: boolean;
+        canedit: boolean;
+        cansubmit: boolean;
+        extensionduedate: number | null;
+        gradingstatus: string;
+    };
+    feedback?: {
+        gradefordisplay?: string;
+        gradeddate?: number;
+        plugins?: AssignPlugin[];
+    };
+}
+export interface Assignment {
+    id: number;
+    cmid: number;
+    duedate: number;
+    cutoffdate: number;
+    allowsubmissionsfromdate: number;
+    /** 1: la entrega queda en borrador hasta que se confirma el envío. */
+    submissiondrafts: number;
+    requiresubmissionstatement: number;
+    /** HTML de la declaración que hay que aceptar al enviar; solo viene si se pide. */
+    submissionstatement?: string;
+    teamsubmission: number;
+    maxattempts: number;
+    configs: {
+        plugin: string;
+        subtype: string;
+        name: string;
+        value: string;
+    }[];
+}
+export interface Choice {
+    id: number;
+    coursemodule: number;
+    allowupdate: boolean;
+    allowmultiple: boolean;
+    timeopen: number;
+    timeclose: number;
+}
+export interface ChoiceOption {
+    id: number;
+    /** En choice es el texto de la opción; en choicegroup viene en `name`. */
+    text?: string;
+    name?: string;
+    maxanswers?: number;
+    countanswers?: number;
+    checked?: boolean;
+    disabled?: boolean;
+}

package/build/aula-virtual/format/actions.d.ts

@@ -0,0 +1,57 @@
+import type { AulaSession } from "../client/session.js";
+/**
+ * Con la dirección de un foro abre un hilo; con la de una discusión responde. Así el modelo no elige
+ * entre dos operaciones: la dirección que ya tiene dice cuál es.
+ */
+export declare function postToForum(session: AulaSession, rawAddress: string, message: string, subject?: string, replyTo?: number): Promise<{
+    publicado: string;
+    direccion: string;
+    id?: undefined;
+    respuestaA?: undefined;
+} | {
+    publicado: string;
+    direccion: string;
+    id: number;
+    respuestaA: number;
+}>;
+export declare function editForumPost(session: AulaSession, rawAddress: string, postId: number, message: string, subject?: string): Promise<{
+    editado: boolean;
+    direccion: string;
+    id: number;
+}>;
+export declare function deleteForumPost(session: AulaSession, rawAddress: string, postId: number): Promise<{
+    borrado: boolean;
+    id: number;
+    discusionBorrada: true | undefined;
+    direccion: string | undefined;
+}>;
+/** Deja elegidas exactamente `optionIds`; vacío borra la respuesta. Devuelve cómo quedó. */
+export declare function answerChoice(session: AulaSession, rawAddress: string, optionIds: number[]): Promise<{
+    elegidas: number[];
+    aviso: string | undefined;
+    opciones: {
+        id: number;
+        texto: string | undefined;
+        elegida: true | undefined;
+        deshabilitada: true | undefined;
+        cupo: number | undefined;
+        anotados: number | undefined;
+    }[];
+}>;
+export declare function sendMessage(session: AulaSession, userId: number, message: string): Promise<{
+    enviado: boolean;
+    para: string;
+}>;
+export declare function addCalendarEvent(session: AulaSession, event: {
+    name: string;
+    start: string;
+    durationMinutes?: number;
+    description?: string;
+}): Promise<{
+    creado: boolean;
+    id: number;
+    nombre: string;
+    inicio: string | null;
+    fin: string | null | undefined;
+    url: string;
+}>;