utn-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026 Joaquín Peñalva
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,56 @@
+# UTN-MCP — El puente entre tu agente y los sistemas de la Universidad.
+Este es el Model Context Protocol server NO OFICIAL de la UTN. Con él podrás pedirle a tu agente de preferencia (ChatGPT, Claude, etc.) que busque informacion o archivos en el aula virtual.
+
+## Features
+Actualmente solamente tiene dos tools, aula_get_site_info() y aula_list_courses(). Ya se incorporarán más!
+
+## Cómo instalar
+Necesitás [Node.js](https://nodejs.org) 20 o superior. No hace falta clonar el repo ni instalar nada a mano: `npx` descarga el paquete solo.
+
+### 1. Iniciar sesión
+```bash
+npx -y utn-mcp login
+```
+Te pide tu usuario institucional y tu contraseña de la UTN (los mismos de "Usuarios Institucionales" en el aula virtual). Se hace una sola vez: después el servidor renueva la sesión solo.
+
+### 2. Agregarlo a tu cliente
+
+**Claude Code**
+```bash
+claude mcp add utn -- npx -y utn-mcp
+```
+
+**Claude Desktop**: en *Settings → Developer → Edit Config*, agregá dentro de `mcpServers`:
+```json
+"utn": {
+  "command": "npx",
+  "args": ["-y", "utn-mcp"]
+}
+```
+En Windows, si no arranca, usá `"command": "cmd"` y `"args": ["/c", "npx", "-y", "utn-mcp"]`. Después reiniciá Claude Desktop por completo.
+
+**Otros clientes (Cursor, VS Code, etc.)**: cualquier cliente MCP que lance servidores por STDIO sirve con el comando `npx -y utn-mcp`.
+
+### Instalación global (opcional)
+Si preferís tener el comando `utn-mcp` siempre disponible:
+```bash
+npm i -g utn-mcp
+utn-mcp login
+```
+y en la config del cliente usás `"command": "utn-mcp"` sin argumentos.
+
+### Modo HTTP (opcional)
+```bash
+npx -y utn-mcp --http --port 3000
+```
+Levanta el servidor en `http://127.0.0.1:3000/mcp`, solo accesible desde tu propia máquina. Tenés que dejar la terminal abierta mientras lo uses.
+
+## Dónde se guardan tus datos
+Todo queda en tu computadora:
+- **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 y cookies de sesión**: en `%APPDATA%\utn-mcp\session.json` (Windows) o `~/.config/utn-mcp/session.json` (Linux y macOS).
+
+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`.
+
+## Aviso
+Este proyecto no está afiliado ni avalado por la UTN. Usalo bajo tu responsabilidad.

package/build/aula-virtual/client/client.js

@@ -0,0 +1,16 @@
+import { callWs } from "./moodle-api.js";
+export function getSiteInfo(session) {
+    return callWs(session, "core_webservice_get_site_info");
+}
+export async function listCourses(session) {
+    const { userid } = await getSiteInfo(session);
+    const courses = await callWs(session, "core_enrol_get_users_courses", { userid });
+    return courses.map((c) => ({
+        id: c.id,
+        nombre: c.fullname,
+        nombreCorto: c.shortname,
+        visible: c.visible === 1,
+        progreso: c.progress ?? null,
+        ultimoAcceso: c.lastaccess ? new Date(c.lastaccess * 1000).toISOString() : null,
+    }));
+}

package/build/aula-virtual/client/constants.js

@@ -0,0 +1,2 @@
+export const AULA_BASE_URL = "https://aulasvirtuales.frba.utn.edu.ar";
+export const SSO_HOST = "auth.frba.utn.edu.ar";

package/build/aula-virtual/client/credentials.js

@@ -0,0 +1,33 @@
+import { logger } from "../../shared/logger.js";
+const SERVICE = "utn-mcp";
+const ACCOUNT = "aula-virtual";
+// Import dinámico: si el binario nativo o el Secret Service (Linux) no están, seguimos con env vars.
+async function entry() {
+    const { Entry } = await import("@napi-rs/keyring");
+    return new Entry(SERVICE, ACCOUNT);
+}
+/** Primero UTN_USER/UTN_PASS; si no están, el keychain del sistema. */
+export async function loadCredentials() {
+    const { UTN_USER, UTN_PASS } = process.env;
+    if (UTN_USER && UTN_PASS)
+        return { username: UTN_USER, password: UTN_PASS };
+    try {
+        const raw = (await entry()).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 saveCredentials(creds) {
+    try {
+        (await entry()).setPassword(JSON.stringify(creds));
+        return true;
+    }
+    catch (e) {
+        logger.warn("No se pudo guardar en el keychain:", e.message);
+        return false;
+    }
+}

package/build/aula-virtual/client/local-session.js

@@ -0,0 +1,49 @@
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { CookieJar } from "tough-cookie";
+import { sessionFile } from "../../shared/paths.js";
+import { logger } from "../../shared/logger.js";
+import { loadCredentials } from "./credentials.js";
+import { fetchToken } from "./sso-login.js";
+/**
+ * Sesión del modo local: un solo usuario, guardada en disco.
+ * Credenciales en el keychain (o UTN_USER/UTN_PASS); token y cookies del SSO en session.json.
+ */
+export class LocalSession {
+    refreshing = null;
+    async getToken() {
+        return (await this.read()).token ?? this.refreshToken();
+    }
+    /** Una sola renovación en curso aunque varias tools fallen a la vez. */
+    refreshToken() {
+        this.refreshing ??= loadCredentials()
+            .then((creds) => this.login(creds))
+            .finally(() => {
+            this.refreshing = null;
+        });
+        return this.refreshing;
+    }
+    /** Obtiene un token nuevo y lo guarda junto con las cookies del SSO. */
+    async login(credentials) {
+        logger.info("Obteniendo token del aula virtual...");
+        const stored = await this.read();
+        const jar = stored.cookies ? await CookieJar.deserialize(stored.cookies) : new CookieJar();
+        const token = await fetchToken(jar, credentials);
+        await this.write({ token, obtainedAt: new Date().toISOString(), cookies: await jar.serialize() });
+        return token;
+    }
+    async read() {
+        try {
+            return JSON.parse(await readFile(sessionFile(), "utf8"));
+        }
+        catch {
+            return { token: null, obtainedAt: null, cookies: null };
+        }
+    }
+    async write(data) {
+        const file = sessionFile();
+        await mkdir(dirname(file), { recursive: true });
+        await writeFile(file, JSON.stringify(data, null, 2), { mode: 0o600 });
+        await chmod(file, 0o600).catch(() => { }); // no-op en Windows
+    }
+}

package/build/aula-virtual/client/moodle-api.js

@@ -0,0 +1,32 @@
+import { postForm } from "../../shared/http.js";
+import { AULA_BASE_URL } from "./constants.js";
+const WS_URL = `${AULA_BASE_URL}/webservice/rest/server.php`;
+const TOKEN_ERRORS = new Set(["invalidtoken", "expiredtoken"]);
+export class MoodleError extends Error {
+    errorcode;
+    constructor(message, errorcode) {
+        super(message);
+        this.errorcode = errorcode;
+        this.name = "MoodleError";
+    }
+}
+const isException = (data) => typeof data === "object" && data !== null && "exception" in data;
+/** Llama a una función del web service de Moodle; renueva el token una vez si venció. */
+export async function callWs(session, wsfunction, params = {}) {
+    let token = await session.getToken();
+    for (let attempt = 0;; attempt++) {
+        const data = await postForm(WS_URL, {
+            ...params,
+            wstoken: token,
+            wsfunction,
+            moodlewsrestformat: "json",
+        });
+        if (!isException(data))
+            return data;
+        if (attempt === 0 && data.errorcode && TOKEN_ERRORS.has(data.errorcode)) {
+            token = await session.refreshToken();
+            continue;
+        }
+        throw new MoodleError(data.message ?? data.exception, data.errorcode);
+    }
+}

package/build/aula-virtual/client/session.js

@@ -0,0 +1,2 @@
+// para version hosteada y multiples usuarios/sesiones
+export {};

package/build/aula-virtual/client/sso-login.js

@@ -0,0 +1,98 @@
+import { randomInt } from "node:crypto";
+import { AULA_BASE_URL, SSO_HOST } from "./constants.js";
+export class LoginRequiredError extends Error {
+    constructor(message = "Hace falta iniciar sesión: corré `utn-mcp login`.") {
+        super(message);
+        this.name = "LoginRequiredError";
+    }
+}
+export class InvalidCredentialsError extends Error {
+    constructor() {
+        super("El SSO rechazó usuario o contraseña. Corré `utn-mcp login` para actualizarlos.");
+        this.name = "InvalidCredentialsError";
+    }
+}
+const MAX_REDIRECTS = 20;
+const TIMEOUT_MS = 30_000;
+/**
+ * Obtiene un token del web service siguiendo el flujo de launch.php por HTTP:
+ * launch.php → login de Moodle → SSO (Keycloak) → Moodle → launch.php → moodlemobile://token=BASE64.
+ * Las cookies del SSO quedan en `jar`: mientras sigan vivas no hace falta la contraseña.
+ */
+export async function fetchToken(jar, credentials) {
+    const launchUrl = `${AULA_BASE_URL}/admin/tool/mobile/launch.php` +
+        `?service=moodle_mobile_app&passport=${randomInt(1e9)}&urlscheme=moodlemobile`;
+    // 1. Con sesión de Moodle viva, launch.php redirige directo al token.
+    let landing = await follow(jar, launchUrl);
+    if ("token" in landing)
+        return landing.token;
+    // 2. Login de Moodle: el botón "Usuarios Institucionales" lleva al SSO.
+    const oauthUrl = landing.html.match(/href="([^"]*\/auth\/oauth2\/login\.php[^"]*)"/)?.[1];
+    if (!oauthUrl)
+        throw unexpected(landing.url);
+    landing = await follow(jar, decodeHtml(oauthUrl));
+    if ("token" in landing)
+        return landing.token;
+    // 3. Si el SSO no nos recuerda, muestra su formulario: lo completamos.
+    if (new URL(landing.url).host === SSO_HOST) {
+        if (!credentials)
+            throw new LoginRequiredError();
+        landing = await submitSsoForm(jar, landing.html, credentials);
+        if ("token" in landing)
+            return landing.token;
+        if (new URL(landing.url).host === SSO_HOST)
+            throw new InvalidCredentialsError();
+    }
+    // 4. Ya con sesión de Moodle (el SSO nos deja en el dashboard), pedimos el token de nuevo.
+    landing = await follow(jar, launchUrl);
+    if ("token" in landing)
+        return landing.token;
+    throw unexpected(landing.url);
+}
+async function submitSsoForm(jar, html, { username, password }) {
+    // La página de Keycloak trae su config como JSON (kcContext); de ahí sale la URL del form.
+    const action = html.match(/"loginAction"\s*:\s*("(?:[^"\\]|\\.)*")/)?.[1];
+    if (!action)
+        throw new Error("No se encontró el formulario del SSO; puede que haya cambiado.");
+    const body = new URLSearchParams({ username, password, rememberMe: "on", credentialId: "" });
+    return follow(jar, JSON.parse(action), { method: "POST", body });
+}
+/** Hace la request y sigue redirecciones a mano, guardando cookies en cada salto. */
+async function follow(jar, url, init) {
+    for (let i = 0; i < MAX_REDIRECTS; i++) {
+        const cookie = await jar.getCookieString(url);
+        const res = await fetch(url, {
+            ...init,
+            redirect: "manual",
+            headers: cookie ? { cookie } : {},
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+        });
+        for (const setCookie of res.headers.getSetCookie()) {
+            await jar.setCookie(setCookie, url, { ignoreError: true });
+        }
+        const location = res.headers.get("location");
+        if (res.status >= 300 && res.status < 400 && location) {
+            await res.body?.cancel();
+            if (location.startsWith("moodlemobile://"))
+                return { token: decodeLaunchToken(location) };
+            url = new URL(location, url).toString();
+            init = undefined; // tras un redirect, siempre GET
+            continue;
+        }
+        return { url, html: await res.text() };
+    }
+    throw new Error("Demasiadas redirecciones en el login.");
+}
+/** moodlemobile://token=BASE64(siteid:::token[:::privatetoken]) → token */
+export function decodeLaunchToken(url) {
+    const encoded = decodeURIComponent(url.split("token=")[1] ?? "");
+    const parts = Buffer.from(encoded, "base64").toString("utf8").split(":::");
+    if (parts.length < 2 || !parts[1])
+        throw new Error("Formato de token inesperado en launch.php");
+    return parts[1];
+}
+const decodeHtml = (s) => s.replaceAll("&amp;", "&");
+const unexpected = (url) => {
+    const { host, pathname } = new URL(url);
+    return new Error(`Flujo de login inesperado: terminó en ${host}${pathname}`);
+};

package/build/aula-virtual/login.js

@@ -0,0 +1,24 @@
+import { ask, askHidden } from "../shared/input.js";
+import { logger } from "../shared/logger.js";
+import { saveCredentials } from "./client/credentials.js";
+import { LocalSession } from "./client/local-session.js";
+/**
+ * `utn-mcp login`: pide usuario y contraseña una vez, los guarda en el keychain
+ * y obtiene el primer token. Después el servidor renueva solo.
+ */
+export async function runLogin() {
+    const username = await ask("Usuario institucional de la UTN: ");
+    if (!username)
+        throw new Error("Falta el usuario.");
+    const password = await askHidden("Contraseña: ");
+    const credentials = { username, password };
+    await new LocalSession().login(credentials);
+    // Se guardan recién después de comprobar que el SSO las aceptó.
+    if (await saveCredentials(credentials)) {
+        logger.info("Credenciales guardadas en el keychain del sistema.");
+    }
+    else {
+        logger.warn("No hay keychain disponible: para renovar sin intervención definí UTN_USER y UTN_PASS.");
+    }
+    logger.info("Listo: ya podés usar el servidor MCP.");
+}

package/build/aula-virtual/tools.js

@@ -0,0 +1,27 @@
+import { getSiteInfo, listCourses } from "./client/client.js";
+const json = (data) => ({
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+});
+const failure = (e) => ({
+    content: [{ type: "text", text: `Error: ${e.message}` }],
+    isError: true,
+});
+export function registerAulaVirtualTools(server, session) {
+    server.registerTool("aula_get_site_info", { description: "Datos del usuario logueado en el aula virtual de la UTN FRBA y del sitio Moodle." }, async () => {
+        try {
+            const { sitename, fullname, username, userid, release } = await getSiteInfo(session);
+            return json({ sitename, fullname, username, userid, release });
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
+    server.registerTool("aula_list_courses", { description: "Lista los cursos (materias) en los que está inscripto el usuario en el aula virtual." }, async () => {
+        try {
+            return json(await listCourses(session));
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
+}

package/build/aula-virtual/types.js

@@ -0,0 +1,2 @@
+// Respuestas de Moodle, solo con los campos que usamos.
+export {};

package/build/http.js

@@ -0,0 +1,24 @@
+import express from "express";
+import { createMcpHandler } from "@modelcontextprotocol/server";
+import { localhostHostValidation, localhostOriginValidation, toNodeHandler } from "@modelcontextprotocol/node";
+import { logger } from "./shared/logger.js";
+const asMiddleware = (guard) => (req, res, next) => {
+    if (guard(req, res))
+        next();
+};
+/**
+ * Entrada HTTP local: solo escucha en 127.0.0.1 y rechaza Host/Origin que no sean
+ * localhost, para que una página web no pueda usar tu sesión de la UTN (DNS rebinding).
+ * El modo hosteado va a reutilizar el mismo `factory`, con OAuth y una sesión por usuario.
+ */
+export function startHttpServer(factory, port) {
+    const handler = createMcpHandler(factory, { onerror: (e) => logger.error(e.message) });
+    const app = express();
+    app.use(asMiddleware(localhostHostValidation()));
+    app.use(asMiddleware(localhostOriginValidation()));
+    // Sin express.json(): el handler lee el body por su cuenta.
+    app.all("/mcp", toNodeHandler(handler));
+    app.listen(port, "127.0.0.1", () => {
+        logger.info(`Servidor MCP escuchando en http://127.0.0.1:${port}/mcp`);
+    });
+}

package/build/index.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import { LocalSession } from "./aula-virtual/client/local-session.js";
+import { runLogin } from "./aula-virtual/login.js";
+import { startHttpServer } from "./http.js";
+import { createServer } from "./server.js";
+import { logger } from "./shared/logger.js";
+const USAGE = `Uso:
+  utn-mcp                 servidor MCP por STDIO (lo lanza el cliente)
+  utn-mcp --http [--port N]  servidor MCP por HTTP en 127.0.0.1 (por defecto 3000)
+  utn-mcp login           guardar credenciales de la UTN y obtener el primer token`;
+async function main() {
+    const { values, positionals } = parseArgs({
+        allowPositionals: true,
+        options: {
+            http: { type: "boolean", default: false },
+            port: { type: "string", default: process.env.PORT ?? "3000" },
+            help: { type: "boolean", short: "h", default: false },
+        },
+    });
+    if (values.help) {
+        console.error(USAGE);
+        return;
+    }
+    if (positionals[0] === "login") {
+        await runLogin();
+        return;
+    }
+    // Modo local: un solo usuario, la misma sesión para todas las conexiones.
+    const aula = new LocalSession();
+    const factory = () => createServer(aula);
+    if (values.http) {
+        startHttpServer(factory, Number(values.port));
+    }
+    else {
+        serveStdio(factory, { onerror: (e) => logger.error(e.message) });
+        logger.info("Servidor MCP iniciado en STDIO");
+    }
+}
+main().catch((e) => {
+    logger.error(e.message);
+    process.exit(1);
+});

package/build/server.js

@@ -0,0 +1,11 @@
+import { McpServer } from "@modelcontextprotocol/server";
+import { registerAulaVirtualTools } from "./aula-virtual/tools.js";
+/** Un servidor MCP para un usuario. Las entradas STDIO y HTTP lo crean por conexión o por request. */
+export function createServer(aula) {
+    const server = new McpServer({
+        name: "UTN-MCP",
+        version: "0.1.0",
+    });
+    registerAulaVirtualTools(server, aula);
+    return server;
+}

package/build/shared/http.js

@@ -0,0 +1,31 @@
+export class HttpError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = "HttpError";
+    }
+}
+/** POST application/x-www-form-urlencoded y parseo JSON, con timeout. */
+export async function postForm(url, params, timeoutMs = 30_000) {
+    const body = new URLSearchParams(Object.entries(params).map(([k, v]) => [k, String(v)]));
+    let res;
+    try {
+        res = await fetch(url, {
+            method: "POST",
+            body,
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+    }
+    catch (e) {
+        throw new HttpError(`No se pudo conectar con ${new URL(url).host}: ${e.message}`);
+    }
+    if (!res.ok)
+        throw new HttpError(`HTTP ${res.status} en ${new URL(url).pathname}`, res.status);
+    try {
+        return (await res.json());
+    }
+    catch {
+        throw new HttpError(`Respuesta no JSON en ${new URL(url).pathname}`, res.status);
+    }
+}

package/build/shared/input.js

@@ -0,0 +1,47 @@
+import { stdin, stderr } from "node:process";
+import { createInterface } from "node:readline/promises";
+export async function ask(question) {
+    const rl = createInterface({ input: stdin, output: stderr });
+    try {
+        return (await rl.question(question)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+export function askHidden(question) {
+    if (!stdin.isTTY)
+        return ask(question);
+    return new Promise((resolve, reject) => {
+        stderr.write(question);
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.setEncoding("utf8");
+        let value = "";
+        const onData = (chunk) => {
+            for (const ch of chunk) {
+                if (ch === "\r" || ch === "\n") {
+                    done();
+                    resolve(value);
+                    return;
+                }
+                if (ch === "\u0003") {
+                    done();
+                    reject(new Error("Cancelado"));
+                    return;
+                }
+                if (ch === "\u007f" || ch === "\b")
+                    value = value.slice(0, -1);
+                else
+                    value += ch;
+            }
+        };
+        const done = () => {
+            stdin.off("data", onData);
+            stdin.setRawMode(false);
+            stdin.pause();
+            stderr.write("\n");
+        };
+        stdin.on("data", onData);
+    });
+}

package/build/shared/logger.js

@@ -0,0 +1,6 @@
+// servidor MCP STDIO based
+export const logger = {
+    info: (...args) => console.error("[utn-mcp]", ...args),
+    warn: (...args) => console.error("[utn-mcp] WARN", ...args),
+    error: (...args) => console.error("[utn-mcp] ERROR", ...args),
+};

package/build/shared/paths.js

@@ -0,0 +1,13 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** Carpeta de configuración: UTN_MCP_HOME, %APPDATA% en Windows, o XDG/~/.config en Linux y macOS. */
+export function configDir() {
+    if (process.env.UTN_MCP_HOME)
+        return process.env.UTN_MCP_HOME;
+    if (process.platform === "win32") {
+        return join(process.env.APPDATA ?? join(homedir(), "AppData", "Roaming"), "utn-mcp");
+    }
+    return join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "utn-mcp");
+}
+/** Token de Moodle + cookies del SSO del modo local. */
+export const sessionFile = () => join(configDir(), "session.json");

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "utn-mcp",
+  "version": "0.1.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": {
+    "utn-mcp": "build/index.js"
+  },
+  "files": [
+    "build"
+  ],
+  "scripts": {
+    "prebuild": "node -e \"require('fs').rmSync('build',{recursive:true,force:true})\"",
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node build/index.js",
+    "dev": "tsx src/index.ts",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "login": "tsx src/index.ts login"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nialvape/utn-mcp.git"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "utn",
+    "aula-virtual"
+  ],
+  "author": "Joaquín Peñalva (https://github.com/nialvape)",
+  "license": "ISC",
+  "type": "module",
+  "bugs": {
+    "url": "https://github.com/nialvape/utn-mcp/issues"
+  },
+  "homepage": "https://github.com/nialvape/utn-mcp#readme",
+  "dependencies": {
+    "@modelcontextprotocol/node": "^2.1.1",
+    "@modelcontextprotocol/server": "^2.3.0",
+    "@napi-rs/keyring": "^2.1.0",
+    "express": "^5.2.1",
+    "tough-cookie": "^6.0.2",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.6",
+    "@types/node": "^26.6.4",
+    "tsx": "^4.23.15",
+    "typescript": "^7.0.2"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}