utn-mcp 0.8.3 → 0.9.1

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

@@ -0,0 +1,86 @@
+import type { AulaSession } from "../client/session.js";
+import type { ChoiceOption, CourseModule } from "../client/types.js";
+/** La entrega del usuario (o la de su grupo): qué acepta la tarea, qué subió y la devolución si la hay. */
+export declare function viewSubmission(session: AulaSession, courseId: number, module: CourseModule): Promise<{
+    estado: string;
+    grupal: true | undefined;
+    modificada: string | undefined;
+    abre: string | undefined;
+    vence: string | undefined;
+    prorroga: string | undefined;
+    cierreDefinitivo: string | undefined;
+    acepta: ({
+        tipo: string;
+        maximo: number | undefined;
+        tamanioMaximo: number | undefined;
+        extensiones: string | undefined;
+        limitePalabras?: undefined;
+    } | {
+        maximo?: undefined;
+        tamanioMaximo?: undefined;
+        extensiones?: undefined;
+        tipo: string;
+        limitePalabras: number | undefined;
+    })[] | undefined;
+    requiereConfirmarEnvio: true | undefined;
+    requiereDeclaracion: true | undefined;
+    declaracion: string | undefined;
+    puedeEditar: boolean;
+    puedeEnviar: true | undefined;
+    bloqueada: true | undefined;
+    devolucion: {
+        calificacion: string | undefined;
+        fecha: string | null;
+        archivos: {
+            nombre: string;
+            ruta: string | undefined;
+            tamanio: number;
+            mimetype: string | undefined;
+            modificado: string | null;
+            url: string;
+        }[] | undefined;
+        texto: string | undefined;
+    } | undefined;
+    archivos: {
+        nombre: string;
+        ruta: string | undefined;
+        tamanio: number;
+        mimetype: string | undefined;
+        modificado: string | null;
+        url: string;
+    }[] | undefined;
+    texto: string | undefined;
+}>;
+export declare function viewChoice(session: AulaSession, courseId: number, module: CourseModule): Promise<{
+    multiple: true | undefined;
+    puedeCambiar: boolean | undefined;
+    abre: string | undefined;
+    cierra: string | undefined;
+    opciones: {
+        id: number;
+        texto: string | undefined;
+        elegida: true | undefined;
+        deshabilitada: true | undefined;
+        cupo: number | undefined;
+        anotados: number | undefined;
+    }[];
+}>;
+/** El plugin no expone si deja cambiar o elegir varios grupos: eso lo dice la descripción o el error al elegir. */
+export declare function viewChoicegroup(session: AulaSession, module: CourseModule): Promise<{
+    opciones: {
+        id: number;
+        texto: string | undefined;
+        elegida: true | undefined;
+        deshabilitada: true | undefined;
+        cupo: number | undefined;
+        anotados: number | undefined;
+    }[];
+}>;
+export declare function toOption(o: ChoiceOption): {
+    id: number;
+    texto: string | undefined;
+    elegida: true | undefined;
+    deshabilitada: true | undefined;
+    cupo: number | undefined;
+    anotados: number | undefined;
+};

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

@@ -0,0 +1,36 @@
+/**
+ * Direcciones de navegación del aula: un path que el modelo recibe en una respuesta
+ * y devuelve tal cual para entrar ahí. No hay estado en el servidor; la dirección
+ * dice todo lo necesario, y el padre se deduce del texto (eso es el "volver").
+ */
+export declare const AddressLevel: {
+    readonly Root: "root";
+    readonly Course: "course";
+    readonly Module: "module";
+    readonly Discussion: "discussion";
+};
+export type AddressLevel = (typeof AddressLevel)[keyof typeof AddressLevel];
+export type Address = {
+    level: "root";
+} | {
+    level: "course";
+    courseId: number;
+} | {
+    level: "module";
+    courseId: number;
+    cmid: number;
+} | {
+    level: "discussion";
+    courseId: number;
+    cmid: number;
+    discussionId: number;
+};
+export declare const ROOT = "/";
+export declare const courseAddr: (courseId: number) => string;
+export declare const moduleAddr: (courseId: number, cmid: number) => string;
+export declare const discussionAddr: (courseId: number, cmid: number, discussionId: number) => string;
+export declare function parseAddress(raw: string): Address;
+/** La dirección en texto, tal como la ve el modelo. */
+export declare function formatAddress(address: Address): string;
+/** La dirección de un nivel más arriba, o null si ya estamos en la raíz. */
+export declare function parentOf(address: Address): string | null;

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

@@ -0,0 +1,11 @@
+import type { MoodleFile } from "../client/types.js";
+/** Los timestamps de Moodle (segundos) en ISO; 0 o vacío es "sin fecha". */
+export declare const isoDate: (seconds: number | null | undefined) => string | null;
+export declare function toFile(f: MoodleFile): {
+    nombre: string;
+    ruta: string | undefined;
+    tamanio: number;
+    mimetype: string | undefined;
+    modificado: string | null;
+    url: string;
+};

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

@@ -0,0 +1,32 @@
+import { type Part } from "../../shared/documents/index.js";
+import type { AulaSession } from "../client/session.js";
+/** El más grande que hay hoy en los cursos pesa 12 MB. */
+export declare const MAX_BYTES: number;
+/**
+ * Moodle devuelve las URLs del web service, que piden token. Al usuario le sirve la misma ruta sin
+ * `/webservice`, que se abre con la sesión de su navegador. Es la única que mostramos: el token no
+ * sale nunca del servidor. `fileurl` viene de Moodle: ya es del aula del usuario.
+ */
+export declare function userFacingUrl(fileurl: string): string;
+/**
+ * Acepta cualquiera de las dos formas y devuelve la del web service. Solo archivos del aula del
+ * usuario (`baseUrl`): con cualquier otra URL estaríamos mandando su token a donde diga el modelo.
+ */
+export declare function downloadUrl(baseUrl: string, url: string): URL;
+/** Lo que ve el modelo de una lectura (las claves van en castellano) más las partes leídas. */
+export interface FileRead {
+    archivo: string;
+    formato: string;
+    unidad: string;
+    total: number;
+    desde: number;
+    hasta: number;
+    /** El `desde` para pedir lo que sigue; no está si ya se leyó todo. */
+    siguiente?: number;
+    urlParaUsuario: string;
+    parts: (Part & {
+        number: number;
+    })[];
+}
+/** Baja un archivo del aula y devuelve desde la parte `from` tantas como entren en el presupuesto. */
+export declare function readAulaFile(session: AulaSession, url: string, from?: number): Promise<FileRead>;

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

@@ -0,0 +1,213 @@
+import type { AulaSession } from "../client/session.js";
+import type { CourseModule } from "../client/types.js";
+/**
+ * Entra a una dirección del aula y devuelve su contenido, el padre y las direcciones de lo que hay
+ * adentro. Es el único lugar que decide qué ve el modelo y cuánto texto le cuesta.
+ */
+export declare function open(session: AulaSession, rawAddress: string, page?: number): Promise<{
+    direccion: string;
+    padre: string | null;
+    cursos: {
+        direccion: string;
+        id: number;
+        nombre: string;
+        nombreCorto: string;
+        visible: boolean;
+        progreso: number | null;
+        ultimoAcceso: string | null;
+    }[];
+} | {
+    direccion: string;
+    padre: string | null;
+    secciones: {
+        nombre: string;
+        numero: number;
+        resumen: string | undefined;
+        modulos: {
+            direccion: string;
+            id: number;
+            nombre: string;
+            tipo: string;
+            url: string | undefined;
+            descripcion: string | undefined;
+            restriccion: string | undefined;
+            fechas: {
+                etiqueta: string;
+                fecha: string | null;
+            }[] | undefined;
+            archivos: {
+                nombre: string;
+                ruta: string | undefined;
+                tamanio: number;
+                mimetype: string | undefined;
+                modificado: string | null;
+                url: string;
+            }[] | undefined;
+            enlaces: string[] | undefined;
+        }[];
+    }[];
+} | {
+    direccion: string;
+    padre: string | null;
+    seccion: string;
+    modulo: {
+        direccion: string;
+        id: number;
+        nombre: string;
+        tipo: string;
+        url: string | undefined;
+        descripcion: string | undefined;
+        restriccion: string | undefined;
+        fechas: {
+            etiqueta: string;
+            fecha: string | null;
+        }[] | undefined;
+        archivos: {
+            nombre: string;
+            ruta: string | undefined;
+            tamanio: number;
+            mimetype: string | undefined;
+            modificado: string | null;
+            url: string;
+        }[] | undefined;
+        enlaces: string[] | undefined;
+    };
+} | {
+    direccion: string;
+    padre: string | null;
+    seccion: string;
+    modulo: {
+        direccion: string;
+        id: number;
+        nombre: string;
+        tipo: string;
+        url: string | undefined;
+        descripcion: string | undefined;
+        restriccion: string | undefined;
+        fechas: {
+            etiqueta: string;
+            fecha: string | null;
+        }[] | undefined;
+        archivos: {
+            nombre: string;
+            ruta: string | undefined;
+            tamanio: number;
+            mimetype: string | undefined;
+            modificado: string | null;
+            url: string;
+        }[] | undefined;
+        enlaces: string[] | undefined;
+    };
+    entrega: {
+        estado: string;
+        grupal: true | undefined;
+        modificada: string | undefined;
+        abre: string | undefined;
+        vence: string | undefined;
+        prorroga: string | undefined;
+        cierreDefinitivo: string | undefined;
+        acepta: ({
+            tipo: string;
+            maximo: number | undefined;
+            tamanioMaximo: number | undefined;
+            extensiones: string | undefined;
+            limitePalabras?: undefined;
+        } | {
+            maximo?: undefined;
+            tamanioMaximo?: undefined;
+            extensiones?: undefined;
+            tipo: string;
+            limitePalabras: number | undefined;
+        })[] | undefined;
+        requiereConfirmarEnvio: true | undefined;
+        requiereDeclaracion: true | undefined;
+        declaracion: string | undefined;
+        puedeEditar: boolean;
+        puedeEnviar: true | undefined;
+        bloqueada: true | undefined;
+        devolucion: {
+            calificacion: string | undefined;
+            fecha: string | null;
+            archivos: {
+                nombre: string;
+                ruta: string | undefined;
+                tamanio: number;
+                mimetype: string | undefined;
+                modificado: string | null;
+                url: string;
+            }[] | undefined;
+            texto: string | undefined;
+        } | undefined;
+        archivos: {
+            nombre: string;
+            ruta: string | undefined;
+            tamanio: number;
+            mimetype: string | undefined;
+            modificado: string | null;
+            url: string;
+        }[] | undefined;
+        texto: string | undefined;
+    };
+} | {
+    direccion: string;
+    padre: string | null;
+    seccion: string;
+    modulo: {
+        direccion: string;
+        id: number;
+        nombre: string;
+        tipo: string;
+        url: string | undefined;
+        descripcion: string | undefined;
+        restriccion: string | undefined;
+        fechas: {
+            etiqueta: string;
+            fecha: string | null;
+        }[] | undefined;
+        archivos: {
+            nombre: string;
+            ruta: string | undefined;
+            tamanio: number;
+            mimetype: string | undefined;
+            modificado: string | null;
+            url: string;
+        }[] | undefined;
+        enlaces: string[] | undefined;
+    };
+    eleccion: {
+        opciones: {
+            id: number;
+            texto: string | undefined;
+            elegida: true | undefined;
+            deshabilitada: true | undefined;
+            cupo: number | undefined;
+            anotados: number | undefined;
+        }[];
+    };
+} | {
+    direccion: string;
+    padre: string | null;
+    asunto: string;
+    publicaciones: {
+        autor: string;
+        autorId: number;
+        fecha: string | null;
+        respuestaA: number | undefined;
+        id: number;
+        mensaje: string;
+        adjuntos: {
+            nombre: string;
+            ruta: string | undefined;
+            tamanio: number;
+            mimetype: string | undefined;
+            modificado: string | null;
+            url: string;
+        }[] | undefined;
+        acciones: (string | false)[] | undefined;
+    }[];
+}>;
+/** Ubica un módulo por su cmid y se queda con la sección que lo contiene. */
+export declare function findModule(session: AulaSession, courseId: number, cmid: number): Promise<{
+    sectionName: string;
+    module: CourseModule;
+}>;

package/build/aula-virtual/format/study-pack.d.ts

@@ -0,0 +1,33 @@
+import type { AulaSession } from "../client/session.js";
+/**
+ * Escribe el pack sin pisar packs anteriores: nombre con fecha-hora y, si ya existe (dos packs
+ * en el mismo segundo), un sufijo -2, -3... La escritura es atómica por nombre (bandera "wx").
+ */
+export declare function writePackFile(dir: string, courseName: string, bytes: Uint8Array): Promise<string>;
+/**
+ * Baja PDF de un curso y los une en un solo archivo con índice, guardado en exportsDir().
+ * Con `archivos` une solo las URL pedidas (tal como las devuelve aula_open, validadas con
+ * `downloadUrl` como en aula_read_file); sin `archivos`, todos los PDF del curso. El pack sigue
+ * el orden del aula, no el de la lista, para que el índice acompañe las unidades. Los duplicados
+ * exactos se descartan al armar, porque ahí se bajan igual. Todo lo omitido queda listado en
+ * `omitidos` con el motivo; en el atajo sin `archivos`, los archivos que no son PDF solo se
+ * cuentan en `archivosNoPdf` en vez de listarse uno por uno.
+ */
+export declare function buildStudyPack(session: AulaSession, rawAddress: string, archivos?: string[]): Promise<{
+    archivo: string;
+    curso: string;
+    paginas: number;
+    materiales: {
+        nombre: string;
+        seccion: string;
+        modulo: string;
+        paginas: number;
+        empiezaEn: number;
+    }[];
+    omitidos: {
+        nombre: string;
+        seccion: string;
+        motivo: string;
+    }[] | undefined;
+    archivosNoPdf: number | undefined;
+}>;

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

@@ -0,0 +1,40 @@
+import { type FileSource, type UploadInbox } from "../../shared/uploads.js";
+import type { AulaSession } from "../client/session.js";
+export interface SubmissionRequest {
+    /** La lista final de archivos: rutas locales (solo STDIO) o la `url` de uno que ya está en la entrega. */
+    files?: string[];
+    /** Id de un link de subida (solo HTTP): sus archivos se suman a la lista. */
+    upload?: string;
+    /** Texto plano del modelo; reemplaza el texto en línea. */
+    text?: string;
+    /** Confirmar el envío si la tarea usa borradores. */
+    send: boolean;
+    acceptStatement: boolean;
+}
+/** Abre un link para recibir los archivos de una entrega en modo HTTP, con los límites de la tarea. */
+export declare function createUploadLink(session: AulaSession, rawAddress: string, inbox: UploadInbox, owner: string): Promise<{
+    subida: string;
+    url: string;
+    vence: string;
+    acepta: {
+        maximo: number | undefined;
+        tamanioMaximo: number;
+        extensiones: string | undefined;
+    };
+    conTerminal: string;
+}>;
+/**
+ * Deja la entrega con los archivos y el texto pedidos, y la envía si hace falta. Lo que no se pasa
+ * se conserva: Moodle reemplaza cada plugin con lo que recibe, así que se le reenvía lo que ya tenía.
+ */
+export declare function submitAssignment(session: AulaSession, rawAddress: string, request: SubmissionRequest, source: FileSource): Promise<{
+    direccion: string;
+    estado: string;
+    aviso: string | undefined;
+    archivos: {
+        nombre: string;
+        tamanio: number;
+        url: string;
+    }[] | undefined;
+    texto: string | undefined;
+}>;

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

@@ -0,0 +1,6 @@
+/**
+ * `utn-mcp login`: pide la regional, usuario y contraseña una vez, los guarda en el keychain
+ * y obtiene el primer token. Después el servidor renueva solo.
+ * Con `--http` guarda la sesión en el store y emite el token para el cliente MCP.
+ */
+export declare function runLogin(http: boolean): Promise<void>;

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

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/server";
+import type { FileSource } from "../shared/uploads.js";
+import type { AulaSession } from "./client/session.js";
+export declare function registerAulaVirtualTools(server: McpServer, session: AulaSession, files: FileSource): void;

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

@@ -0,0 +1,20 @@
+/** Qué se sabe del conector en una regional: `verified` = alguien entró con una cuenta real; `candidate` = falta esa prueba. */
+export type SystemSupport = "verified" | "candidate";
+/**
+ * Un conector que `utn-mcp login` sabe instalar: el `.tgz` de `npm pack` adjunto a un release del repo.
+ * La URL fija la versión y `integrity` el contenido exacto: cargar un paquete es ejecutar su código,
+ * así que solo se instala lo que nombra este catálogo, nunca un nombre que venga del usuario o del entorno.
+ */
+export interface CatalogEntry {
+    id: string;
+    name: string;
+    package: string;
+    version: string;
+    tarball: string;
+    /** sha512 del `.tgz` en base64, como el campo `integrity` de npm. */
+    integrity: string;
+    /** Las regionales que atiende y su soporte, para ofrecerlo en el login antes de bajar nada. */
+    regionales: Record<string, SystemSupport>;
+}
+export declare const CATALOG: CatalogEntry[];
+export declare function catalogEntryForRegional(regionalId: string): CatalogEntry | null;

package/build/autogestion/client/catalog.js

@@ -0,0 +1,22 @@
+const RELEASES = "https://github.com/nialvape/utn-mcp/releases/download";
+/** Las mismas regionales que `ASP_REGIONALS` del paquete; las que quedaron afuera dicen por qué ahí. */
+const SYSACAD_ASP_REGIONALS = [
+    "frbb", "frch", "frcon", "frd", "frgp", "frh", "frlr", "frmdp", "frn",
+    "frp", "frrq", "frsf", "frsfco", "frsn", "frsr", "frt", "frtdf", "frvt",
+];
+export const CATALOG = [
+    {
+        id: "sysacad-asp",
+        name: "Sysacad",
+        package: "utn-mcp-sysacad-asp",
+        version: "0.2.0",
+        tarball: `${RELEASES}/sysacad-asp-v0.2.0/utn-mcp-sysacad-asp-0.2.0.tgz`,
+        integrity: "sha512-p4j2fTpE3ZqSvcDQ3Rr6L32dOGNFut0GzyHBVpTpg8mqXrx4Un6CqkiJZG+eznQy+Risko+pcnPhWm+GIJ8haw==",
+        // FRT anduvo con cuenta real (oct 2026) con la versión anterior, que posteaba directo a `menuAlumno.asp`;
+        // esta lee el formulario y todavía no entró nadie con ella.
+        regionales: Object.fromEntries(SYSACAD_ASP_REGIONALS.map((id) => [id, "candidate"])),
+    },
+];
+export function catalogEntryForRegional(regionalId) {
+    return CATALOG.find((entry) => regionalId in entry.regionales) ?? null;
+}

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

@@ -0,0 +1,71 @@
+import { HttpError } from "../../shared/http.js";
+import { htmlToText } from "../../shared/html.js";
+import type { Correlatividades, EstadoMateria, ExamenMateria, NotasParcialesMateria } from "./types.js";
+/**
+ * Un sistema de autogestión académica (Sysacad, SIU Guaraní, etc.) logueado con un usuario.
+ * Cada sistema es un paquete aparte que exporta un `AutogestionSystem`; el core lo instala desde su
+ * catálogo y le pide un conector para la regional del usuario.
+ */
+export interface AutogestionConnector {
+    /** Id del sistema, tal como lo declara el paquete que lo provee. */
+    readonly systemId: string;
+    /** Pide legajo/usuario y contraseña al sistema y deja la sesión lista. */
+    login(credentials: AutogestionCredentials): Promise<void>;
+    /** Materias del estado académico del alumno logueado, ya parseadas. */
+    estadoAcademico(): Promise<EstadoMateria[]>;
+    /** Correlatividades de la carrera del alumno logueado, para cursar y, si el sistema las publica, para rendir. */
+    correlatividades(): Promise<Correlatividades>;
+    /** Cursada actual, si el sistema la publica; no todos los conectores la tienen. */
+    notasParciales?(): Promise<NotasParcialesMateria[]>;
+    /** Historial de exámenes finales, si el sistema lo publica; no todos los conectores lo tienen. */
+    examenes?(): Promise<ExamenMateria[]>;
+    /**
+     * La sesión del sistema sin la contraseña (cookies, ids de sesión), para guardarla cifrada y retomarla
+     * en otro request. Sin esto, el conector sirve solo en local: el modo HTTP no guarda contraseñas.
+     */
+    exportSession?(): string;
+    /**
+     * Retoma una sesión de `exportSession`. Sin la contraseña no puede volver a entrar solo: si la sesión
+     * venció, las llamadas rechazan con `LoginRequiredError`.
+     */
+    restoreSession?(data: string): void;
+}
+/** Credenciales de un sistema de autogestión. En Sysacad `username` es el legajo. */
+export interface AutogestionCredentials {
+    username: string;
+    password: string;
+}
+export declare class LoginRequiredError extends Error {
+    constructor(systemName: string);
+}
+export declare class InvalidCredentialsError extends Error {
+    constructor(systemName: string);
+}
+export declare class UnsupportedRegionalError extends Error {
+    constructor(regionalId: string);
+}
+/**
+ * Lo que el core le presta al conector en `create`. El paquete importa del core solo tipos: instalado
+ * en otra carpeta, un import en tiempo de ejecución cargaría otra copia de `utn-mcp`, con otras clases
+ * de error que el core no reconoce.
+ */
+export declare const connectorKit: {
+    HttpError: typeof HttpError;
+    LoginRequiredError: typeof LoginRequiredError;
+    InvalidCredentialsError: typeof InvalidCredentialsError;
+    htmlToText: typeof htmlToText;
+};
+export type ConnectorKit = typeof connectorKit;
+/** Lo que exporta un paquete de conector: qué regionales atiende y cómo crear el conector de cada una. */
+export interface AutogestionSystem {
+    id: string;
+    name: string;
+    /** Ids de regional como en `regionals.ts` del aula (`frt`, `frd`...). */
+    regionales: string[];
+    /** Ayuda para el usuario de esa regional, si no es el legajo tal cual: "Legajo sin el 23-". */
+    usernameHint?(regionalId: string): string | undefined;
+    create(regionalId: string, kit: ConnectorKit): AutogestionConnector;
+}
+/** El sistema de una regional entre los conectores cargados, o null si ninguno la cubre. */
+export declare function systemForRegional(regionalId: string, systems: AutogestionSystem[]): AutogestionSystem | null;
+export type { CorrelatividadMateria, Correlatividades, EstadoMateria, ExamenMateria, NotasParcialesMateria } from "./types.js";

package/build/autogestion/client/connector.js

@@ -0,0 +1,31 @@
+import { HttpError } from "../../shared/http.js";
+import { htmlToText } from "../../shared/html.js";
+export class LoginRequiredError extends Error {
+    constructor(systemName) {
+        super(`Falta iniciar sesión en ${systemName}: corré \`utn-mcp login autogestion\` una vez.`);
+        this.name = "LoginRequiredError";
+    }
+}
+export class InvalidCredentialsError extends Error {
+    constructor(systemName) {
+        super(`${systemName} rechazó el usuario o la contraseña. Revisalos con \`utn-mcp login autogestion\`.`);
+        this.name = "InvalidCredentialsError";
+    }
+}
+export class UnsupportedRegionalError extends Error {
+    constructor(regionalId) {
+        super(`La regional ${regionalId.toUpperCase()} todavía no tiene un conector de autogestión. ` +
+            "El aula virtual se puede seguir usando sin autogestión.");
+        this.name = "UnsupportedRegionalError";
+    }
+}
+/**
+ * Lo que el core le presta al conector en `create`. El paquete importa del core solo tipos: instalado
+ * en otra carpeta, un import en tiempo de ejecución cargaría otra copia de `utn-mcp`, con otras clases
+ * de error que el core no reconoce.
+ */
+export const connectorKit = { HttpError, LoginRequiredError, InvalidCredentialsError, htmlToText };
+/** El sistema de una regional entre los conectores cargados, o null si ninguno la cubre. */
+export function systemForRegional(regionalId, systems) {
+    return systems.find((system) => system.regionales.includes(regionalId)) ?? null;
+}

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

@@ -0,0 +1,5 @@
+import type { AutogestionCredentials } from "./connector.js";
+/** Primero <SISTEMA>_USER/<SISTEMA>_PASS (ej. SYSACAD_ASP_USER); si no están, el keychain. */
+export declare function loadAutogestionCredentials(systemId: string): Promise<AutogestionCredentials | null>;
+/** Guarda en el keychain. Devuelve false si no hay keychain (ej. Linux sin Secret Service). */
+export declare function saveAutogestionCredentials(systemId: string, creds: AutogestionCredentials): Promise<boolean>;

package/build/autogestion/client/credentials.js

@@ -0,0 +1,40 @@
+import { logger } from "../../shared/logger.js";
+const SERVICE = "utn-mcp";
+/** Una entrada por sistema: la credencial es por sistema, no por regional. */
+const account = (systemId) => `autogestion-${systemId}`;
+// Import dinámico: si el binario nativo o el Secret Service (Linux) no están, seguimos con env vars.
+async function entry(systemId) {
+    const { Entry } = await import("@napi-rs/keyring");
+    return new Entry(SERVICE, account(systemId));
+}
+function envNames(systemId) {
+    const prefix = systemId.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+    return [`${prefix}_USER`, `${prefix}_PASS`];
+}
+/** Primero <SISTEMA>_USER/<SISTEMA>_PASS (ej. SYSACAD_ASP_USER); si no están, el keychain. */
+export async function loadAutogestionCredentials(systemId) {
+    const [userEnv, passEnv] = envNames(systemId);
+    const username = process.env[userEnv];
+    const password = process.env[passEnv];
+    if (username && password)
+        return { username, password };
+    try {
+        const raw = (await entry(systemId)).getPassword();
+        return raw ? JSON.parse(raw) : null;
+    }
+    catch (e) {
+        logger.warn("Keychain no disponible:", e.message);
+        return null;
+    }
+}
+/** Guarda en el keychain. Devuelve false si no hay keychain (ej. Linux sin Secret Service). */
+export async function saveAutogestionCredentials(systemId, creds) {
+    try {
+        (await entry(systemId)).setPassword(JSON.stringify(creds));
+        return true;
+    }
+    catch (e) {
+        logger.warn("No se pudo guardar en el keychain:", e.message);
+        return false;
+    }
+}