blackboard-upc 1.0.4 → 1.0.7

package/CHANGELOG.md

@@ -4,6 +4,54 @@ All notable changes to `blackboard-upc` will be documented here.
 
 ---
 
+## [1.0.7] — 2026-04-12
+
+### Added
+- **Persistent browser context** — el perfil de Playwright se guarda en `~/.blackboard-cli/browser-profile/`; las cookies de Microsoft SSO persisten entre sesiones, eliminando el login manual repetido
+- **Silent auto-refresh** — cuando la sesión expira, la CLI relanza el browser en headless y se re-autentica automáticamente si el SSO de Microsoft sigue activo (sin intervención del usuario)
+- **TTL real del servidor** — la expiración de sesión ya no es hardcoded a 8h; se parsea el campo `expires` del cookie `BbRouter` para usar el timestamp real del servidor (fallback: 3h)
+- `get_assignment_feedback` — muestra nota, comentarios del profesor y archivos de feedback para todas las tareas de un curso
+- `download_feedback_file` *(experimental)* — descarga archivos adjuntados por el profesor a una corrección
+
+### Changed
+- `blackboard login` ahora muestra el tiempo de expiración real (ej. "expira en 2.9h") en vez de "8 horas"
+- `whoami`, `status` y `api` usan `loadOrRefreshSession()` — intentan refresh silencioso antes de pedir login manual
+
+---
+
+## [1.0.6] — 2026-04-12
+
+### Added
+- Soporte completo para quizzes/evaluaciones de Blackboard Ultra:
+  - `get_quiz_questions` — obtiene todas las preguntas, opciones y respuesta actual de un intento; acepta URL directa o IDs separados (`courseId` + `contentId` + `attemptId`)
+  - `save_quiz_answer` — guarda una respuesta individual sin enviar (verdadero/falso o índice de opción)
+  - `submit_quiz` — envía el intento final (siempre pide confirmación)
+- `src/api/quiz.ts` — módulo nuevo con tipos `QuizQuestion`, `QuizInfo`, `QuizAttemptPolicy` y toda la lógica de los endpoints internos de Ultra
+- Verifica intentos restantes antes de cargar preguntas (`getQuizColumnId`)
+
+### Fixed
+- `tsconfig.json` — agrega `"DOM"` a `lib` para que los callbacks de `page.evaluate()` en `login.ts` compilen sin errores
+
+---
+
+## [1.0.5] — 2026-03-31
+
+### Fixed
+- `run.js` ahora prepone el directorio del Node que lo ejecuta al PATH antes de lanzar `tsx`
+- Soluciona el crash en MCP cuando el usuario tiene nvm con Node 16 como default (Playwright requiere >=18)
+
+---
+
+## [1.0.4] — 2026-03-30
+
+### Changed
+- `download_attachment` y `download_file_url` ya no devuelven base64 — guardan el archivo directamente a disco
+- Directorio por defecto: `process.cwd()` (donde el usuario está trabajando), configurable con `outputDir`
+- Pasar `filename` (el `displayName` de `list_attachments`) para guardar con el nombre correcto
+- Respuesta devuelve `{ saved, size, mimeType }` — sin datos en el contexto
+
+---
+
 ## [1.0.3] — 2026-03-30
 
 ### Changed

package/CLAUDE.md

@@ -24,9 +24,25 @@ If you get `Not authenticated`, ask the user to run `blackboard login`.
 6. list_attachments <courseId> <contentId>→ find downloadable files
 ```
 
+### Quiz workflow
+
+```
+1. list_contents <courseId>              → find the quiz contentId
+2. get_quiz_questions <url|ids>          → load questions + options + attempt policy
+3. save_quiz_answer (per question)       → save each answer individually
+4. submit_quiz (confirm first!)          → finalize and submit the attempt
+```
+
+### Feedback workflow
+
+```
+1. get_assignment_feedback <courseId>    → scores + instructor comments + feedback files for all assignments
+2. download_feedback_file <ids>          → download an annotated file the professor attached to the grade
+```
+
 ## Agent behavior rules
 
-- **Always confirm before submitting** (`submit_attempt`). Show the user what will be submitted and ask for confirmation. Never submit silently.
+- **Always confirm before submitting** (`submit_attempt`, `submit_quiz`). Show the user what will be submitted and ask for confirmation. Never submit silently.
 - **Show grades in context** — when showing grades, also show the assignment name, max score, and due date if available.
 - **Navigate content recursively** — if the user asks for materials, explore subfolders using `list_contents` with `parentId`.
 - **Use `raw_api` for anything not covered** — the Blackboard REST API is extensive. If there's no specific tool, use `raw_api` with the correct endpoint.
@@ -65,6 +81,12 @@ GET /learn/api/public/v1/courses/{courseId}/contents/{id}/attachments/{id}/downl
 | `list_attempts` | Submission history |
 | `get_grades` | Full grade report for a course |
 | `list_attachments` | Files in a content item |
-| `download_attachment` | Download file (base64) |
+| `download_attachment` | Download file to disk |
+| `download_file_url` | Download a bbcswebdav URL directly |
 | `submit_attempt` | Submit assignment (confirm first!) |
+| `get_assignment_feedback` | Scores + instructor comments + feedback files for all assignments in a course |
+| `download_feedback_file` | **[EXPERIMENTAL]** Download a file the professor attached to a graded attempt |
+| `get_quiz_questions` | Load quiz questions + options from an attempt (URL or IDs) |
+| `save_quiz_answer` | Save one answer without submitting |
+| `submit_quiz` | Finalize and submit a quiz attempt (confirm first!) |
 | `raw_api` | Any other Blackboard endpoint |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blackboard-upc",
-  "version": "1.0.4",
+  "version": "1.0.7",
   "description": "CLI no oficial para UPC Aula Virtual (Blackboard Learn) — acceso desde la terminal y MCP para Claude",
   "main": "run.js",
   "bin": {

package/run.js

@@ -4,5 +4,7 @@ const { spawnSync } = require('child_process');
 const path = require('path');
 const tsx = path.join(__dirname, 'node_modules', '.bin', 'tsx');
 const entry = path.join(__dirname, 'src', 'index.ts');
-const result = spawnSync(tsx, [entry, ...process.argv.slice(2)], { stdio: 'inherit' });
+const nodeDir = path.dirname(process.execPath);
+const env = { ...process.env, PATH: `${nodeDir}${path.delimiter}${process.env.PATH}` };
+const result = spawnSync(tsx, [entry, ...process.argv.slice(2)], { stdio: 'inherit', env });
 process.exit(result.status ?? 0);

package/src/api/assignments.ts

@@ -33,6 +33,17 @@ export interface Attempt {
   modified?: string;
   attemptDate?: string;
   files?: Array<{ id: string; fileName: string; mimeType: string }>;
+  // Instructor feedback fields
+  instructorFeedback?: string;
+  feedback?: string;
+}
+
+export interface AttemptFile {
+  id: string;
+  name: string;
+  mimeType?: string;
+  size?: number;
+  href?: string;
 }
 
 export interface SubmitAttemptBody {
@@ -122,6 +133,18 @@ export async function submitAttempt(
   return r.data;
 }
 
+export async function getAttemptFiles(
+  client: AxiosInstance,
+  courseId: string,
+  columnId: string,
+  attemptId: string
+): Promise<AttemptFile[]> {
+  const r = await client.get(
+    `/learn/api/public/v2/courses/${courseId}/gradebook/columns/${columnId}/attempts/${attemptId}/files`
+  );
+  return r.data.results ?? [];
+}
+
 export async function getMyGrade(
   client: AxiosInstance,
   courseId: string,

package/src/api/quiz.ts

@@ -0,0 +1,363 @@
+/**
+ * Quiz / Assessment support for Blackboard Ultra.
+ *
+ * All endpoints discovered by intercepting the Ultra SPA network traffic:
+ *
+ *  GET  /learn/api/v1/courses/{courseId}/gradebook/attempts/{attemptId}
+ *       ?columnId={columnId}&expand=toolAttemptDetail,alignedGoals
+ *       → Returns full question data in toolAttemptDetail["resource/x-bb-assessment"].questionAttempts
+ *
+ *  PATCH /learn/api/v1/courses/{courseId}/gradebook/attempts/{attemptId}/assessment/answers/{questionAttemptId}
+ *       → Saves a single answer (eitherOr or multipleanswer)
+ *
+ *  PATCH /learn/api/v1/courses/{courseId}/gradebook/attempts/{attemptId}
+ *       ?autoSubmitted=false&expand=attemptReceipt.lateSubmission
+ *       → Final submit
+ */
+
+import type { AxiosInstance } from 'axios';
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export interface QuizOption {
+  id: string;
+  text: string;
+  index: number;
+}
+
+export type QuizQuestionType = 'eitherOr' | 'multipleanswer' | 'presentation' | string;
+
+export interface QuizQuestion {
+  /** Question attempt ID — used as the URL segment for saving answers */
+  questionAttemptId: string;
+  /** Question definition ID */
+  questionId: string;
+  /** Position within the quiz (1-based visible number) */
+  position: number;
+  /** 'eitherOr' = true/false, 'multipleanswer' = MC, 'presentation' = text only */
+  type: QuizQuestionType;
+  /** Plain text of the question (HTML stripped) */
+  text: string;
+  points: number;
+  /** Answer options (present for eitherOr and multipleanswer) */
+  options?: QuizOption[];
+  /** Currently saved answer:
+   *   - eitherOr:       true | false | null
+   *   - multipleanswer: boolean[] (one per option, in options order)
+   */
+  currentAnswer?: boolean | boolean[] | null;
+  /** Raw question object from API (needed when saving eitherOr answers) */
+  _raw: any;
+}
+
+export interface QuizInfo {
+  attemptId: string;
+  courseId: string;
+  columnId: string;
+  title: string;
+  status: string;
+  totalPoints: number;
+  questions: QuizQuestion[];
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function stripHtml(html: string): string {
+  return html
+    .replace(/<!--[^>]*-->/g, '')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/&nbsp;/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function parseQuestionAttempt(qa: any, idx: number): QuizQuestion {
+  const q = qa.question || {};
+  const text = stripHtml(q.questionText?.rawText || q.questionText?.displayText || '');
+
+  let options: QuizOption[] | undefined;
+
+  if (qa.questionType === 'eitherOr') {
+    // True/False — always two options
+    options = [
+      { id: 'true', text: 'Verdadero', index: 0 },
+      { id: 'false', text: 'Falso', index: 1 },
+    ];
+  } else if (qa.questionType === 'multipleanswer' && Array.isArray(q.answers)) {
+    options = q.answers.map((a: any, i: number) => ({
+      id: a.id,
+      text: stripHtml(a.answerText?.rawText || a.answerText?.displayText || ''),
+      index: i,
+    }));
+  }
+
+  return {
+    questionAttemptId: qa.id,
+    questionId: qa.questionId || q.id,
+    position: qa.visibleQuestionNumber ?? idx + 1,
+    type: qa.questionType,
+    text,
+    points: q.points ?? 0,
+    options,
+    currentAnswer: qa.givenAnswer ?? null,
+    _raw: qa,
+  };
+}
+
+// ── Get quiz questions ────────────────────────────────────────────────────────
+
+/**
+ * Fetch all questions for a quiz attempt via the internal Blackboard API.
+ *
+ * @param courseId  e.g. _529533_1
+ * @param columnId  Gradebook column ID — from content item contentHandler.gradeColumnId
+ * @param attemptId e.g. _94898825_1
+ */
+export async function getQuizQuestions(
+  client: AxiosInstance,
+  courseId: string,
+  columnId: string,
+  attemptId: string
+): Promise<QuizInfo> {
+  const r = await client.get(
+    `/learn/api/v1/courses/${courseId}/gradebook/attempts/${attemptId}`,
+    { params: { columnId, expand: 'toolAttemptDetail,alignedGoals' } }
+  );
+
+  const data = r.data;
+  const detail = data.toolAttemptDetail?.['resource/x-bb-assessment'];
+
+  if (!detail) {
+    throw new Error(
+      `No toolAttemptDetail found for attempt ${attemptId}. ` +
+      `Make sure the columnId (${columnId}) and courseId are correct.`
+    );
+  }
+
+  const rawQuestions: any[] = detail.questionAttempts || [];
+  // Filter out presentation-only questions (no points, no interaction)
+  const answerableQuestions = rawQuestions.filter(
+    (qa) => qa.questionType !== 'presentation'
+  );
+
+  const questions = answerableQuestions.map(parseQuestionAttempt);
+
+  return {
+    attemptId,
+    courseId,
+    columnId,
+    title: detail.assessment?.title || 'Quiz',
+    status: detail.status || data.status || 'IN_PROGRESS',
+    totalPoints: detail.possiblePoints || detail.assessment?.totalPoints || 0,
+    questions,
+  };
+}
+
+// ── Save a single answer ──────────────────────────────────────────────────────
+
+/**
+ * Save one answer for a quiz question.
+ *
+ * @param courseId          Course ID
+ * @param attemptId         Quiz attempt ID
+ * @param question          The question object from getQuizQuestions
+ * @param answer
+ *   - eitherOr:       boolean  (true = Verdadero, false = Falso)
+ *   - multipleanswer: number   (0-based index of the selected option)
+ *                    OR boolean[] (one per option)
+ */
+export async function saveQuizAnswer(
+  client: AxiosInstance,
+  courseId: string,
+  attemptId: string,
+  question: QuizQuestion,
+  answer: boolean | number | boolean[]
+): Promise<any> {
+  const url = `/learn/api/v1/courses/${courseId}/gradebook/attempts/${attemptId}/assessment/answers/${question.questionAttemptId}`;
+
+  let body: any;
+
+  if (question.type === 'eitherOr') {
+    const givenAnswer = typeof answer === 'boolean' ? answer : Boolean(answer);
+    body = {
+      questionType: 'eitherOr',
+      givenAnswer,
+      question: question._raw.question,
+    };
+  } else if (question.type === 'multipleanswer') {
+    const optionCount = question.options?.length ?? 0;
+    let givenAnswer: boolean[];
+
+    if (Array.isArray(answer)) {
+      givenAnswer = answer as boolean[];
+    } else {
+      // Convert index to boolean array
+      const idx = typeof answer === 'number' ? answer : 0;
+      givenAnswer = Array.from({ length: optionCount }, (_, i) => i === idx);
+    }
+
+    body = {
+      questionType: 'multipleanswer',
+      givenAnswer,
+      lookupOrder: question._raw.lookupOrder || [],
+      order: question._raw.order || [],
+      question: question._raw.question,
+    };
+  } else {
+    throw new Error(`Unsupported question type: ${question.type}`);
+  }
+
+  const r = await client.patch(url, body);
+  return r.data;
+}
+
+// ── Submit the quiz attempt ────────────────────────────────────────────────────
+
+/**
+ * Finalize and submit a quiz attempt.
+ * ALWAYS ask the user to confirm before calling this.
+ */
+export async function submitQuizAttempt(
+  client: AxiosInstance,
+  courseId: string,
+  attemptId: string
+): Promise<any> {
+  const url = `/learn/api/v1/courses/${courseId}/gradebook/attempts/${attemptId}`;
+  const r = await client.patch(url, {
+    toolAttemptDetail: { 'resource/x-bb-assessment': { type: 'Test' } },
+    status: 'NEEDS_GRADING',
+    studentSubmission: null,
+  }, {
+    params: {
+      autoSubmitted: 'false',
+      expand: 'attemptReceipt.lateSubmission',
+    },
+  });
+  return r.data;
+}
+
+// ── Get quiz column ID + attempt limits ───────────────────────────────────────
+
+export interface QuizAttemptPolicy {
+  columnId: string;
+  assessmentId: string;
+  title: string;
+  /** Max attempts allowed. 0 = unlimited. */
+  attemptsAllowed: number;
+  /** Attempts left for this student. -1 = unlimited, 0 = none left. */
+  attemptsLeft: number;
+  /** Human-readable summary, e.g. "Ilimitados" or "2 de 3 restantes" */
+  attemptSummary: string;
+  /** true = safe to proceed, false = no attempts left */
+  canAttempt: boolean;
+}
+
+/**
+ * Resolve the gradebook column ID for a quiz content item AND fetch
+ * the attempt policy (max attempts + attempts left) for the current user.
+ */
+export async function getQuizColumnId(
+  client: AxiosInstance,
+  courseId: string,
+  contentId: string,
+  userId?: string
+): Promise<QuizAttemptPolicy> {
+  // 1. Content item → columnId + assessmentId
+  const contentR = await client.get(
+    `/learn/api/public/v1/courses/${courseId}/contents/${contentId}`
+  );
+  const content = contentR.data;
+  const handler = content.contentHandler;
+
+  if (!handler?.gradeColumnId) {
+    throw new Error(
+      `Content item ${contentId} does not have a gradeColumnId. ` +
+      `Is it a quiz (resource/x-bb-asmt-test-link)?`
+    );
+  }
+
+  const columnId: string = handler.gradeColumnId;
+  const assessmentId: string = handler.assessmentId;
+  const title: string = content.title || 'Quiz';
+
+  // 2. Gradebook column → attemptsAllowed (0 = unlimited)
+  const colR = await client.get(
+    `/learn/api/public/v2/courses/${courseId}/gradebook/columns/${columnId}`
+  );
+  const attemptsAllowed: number = colR.data?.grading?.attemptsAllowed ?? 0;
+
+  // 3. Student grade → attemptsLeft (-1 = unlimited)
+  let attemptsLeft = -1;
+  if (userId) {
+    try {
+      const gradeR = await client.get(
+        `/learn/api/v1/courses/${courseId}/gradebook/columns/${columnId}/grades`,
+        { params: { expand: 'attemptsLeft', userId } }
+      );
+      const grade = gradeR.data?.results?.[0];
+      if (grade?.attemptsLeft !== undefined) {
+        attemptsLeft = grade.attemptsLeft;
+      }
+    } catch {
+      // non-fatal: fall back to attemptsAllowed logic
+    }
+  }
+
+  // 4. Derive human-readable summary and canAttempt flag
+  const unlimited = attemptsAllowed === 0 || attemptsLeft === -1;
+  const canAttempt = unlimited || attemptsLeft > 0;
+
+  let attemptSummary: string;
+  if (unlimited) {
+    attemptSummary = 'Ilimitados';
+  } else if (attemptsLeft === 0) {
+    attemptSummary = `Sin intentos restantes (máximo: ${attemptsAllowed})`;
+  } else {
+    const used = attemptsAllowed - attemptsLeft;
+    attemptSummary = `${attemptsLeft} de ${attemptsAllowed} restantes (${used} enviados)`;
+  }
+
+  return {
+    columnId,
+    assessmentId,
+    title,
+    attemptsAllowed,
+    attemptsLeft,
+    attemptSummary,
+    canAttempt,
+  };
+}
+
+// ── Parse URL helper ──────────────────────────────────────────────────────────
+
+/**
+ * Parse a Blackboard Ultra quiz URL into its component IDs.
+ *
+ * Handles:
+ *   /ultra/stream/assessment/{contentId}/overview/attempt/{attemptId}?courseId={courseId}
+ *   /ultra/stream/assessment/{contentId}/take/attempt/{attemptId}?courseId={courseId}
+ */
+export function parseQuizUrl(urlStr: string): {
+  contentId?: string;
+  attemptId?: string;
+  courseId?: string;
+} {
+  try {
+    const u = new URL(
+      urlStr.startsWith('http')
+        ? urlStr
+        : `https://aulavirtual.upc.edu.pe${urlStr}`
+    );
+    const parts = u.pathname.split('/');
+    const assessmentIdx = parts.indexOf('assessment');
+    const attemptIdx = parts.indexOf('attempt');
+
+    return {
+      contentId: assessmentIdx >= 0 ? parts[assessmentIdx + 1] : undefined,
+      attemptId: attemptIdx >= 0 ? parts[attemptIdx + 1] : undefined,
+      courseId: u.searchParams.get('courseId') ?? undefined,
+    };
+  } catch {
+    return {};
+  }
+}

package/src/auth/login.ts

@@ -1,12 +1,19 @@
 import { chromium } from 'playwright';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
 import type { Session, Cookie } from '../types/index.js';
 import { saveSession } from './session.js';
 
 const BASE_URL = 'https://aulavirtual.upc.edu.pe';
 const SAML_URL = `${BASE_URL}/auth-saml/saml/login?apId=_4893_1&redirectUrl=${encodeURIComponent(`${BASE_URL}/ultra`)}`;
 
-// Session duration: 8 hours
-const SESSION_TTL_MS = 8 * 60 * 60 * 1000;
+const SESSION_TTL_FALLBACK_MS = 3 * 60 * 60 * 1000; // 3h — matches BbRouter timeout:10800
+const PROFILE_DIR = path.join(os.homedir(), '.blackboard-cli', 'browser-profile');
+
+const USER_AGENT =
+  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 ' +
+  '(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
 
 export interface LoginOptions {
   headless?: boolean;
@@ -15,14 +22,50 @@ export interface LoginOptions {
   timeout?: number;
 }
 
+export class SilentLoginFailed extends Error {
+  constructor(reason: string) {
+    super(`Silent re-login failed: ${reason}`);
+    this.name = 'SilentLoginFailed';
+  }
+}
+
+function extractBbRouterExpiry(cookies: Cookie[]): number {
+  const bb = cookies.find(c => c.name === 'BbRouter');
+  if (bb) {
+    const m = bb.value.match(/expires:(\d+)/);
+    if (m) {
+      const ms = parseInt(m[1], 10) * 1000;
+      const now = Date.now();
+      // Sanity check: must be a future timestamp within 24 hours
+      if (ms > now && ms < now + 24 * 60 * 60 * 1000) return ms;
+    }
+  }
+  return Date.now() + SESSION_TTL_FALLBACK_MS;
+}
+
+function extractXsrf(cookies: Cookie[]): string {
+  const bb = cookies.find(c => c.name === 'BbRouter');
+  if (bb) {
+    const m = bb.value.match(/xsrf:([a-f0-9-]+)/);
+    if (m) return m[1];
+  }
+  return '';
+}
+
+function ensureProfileDir(): void {
+  if (!fs.existsSync(PROFILE_DIR)) {
+    fs.mkdirSync(PROFILE_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
 export async function login(opts: LoginOptions = {}): Promise<Session> {
   const { headless = false, timeout = 120_000 } = opts;
 
-  const browser = await chromium.launch({ headless });
-  const context = await browser.newContext({
-    userAgent:
-      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 ' +
-      '(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+  ensureProfileDir();
+
+  const context = await chromium.launchPersistentContext(PROFILE_DIR, {
+    headless,
+    userAgent: USER_AGENT,
   });
 
   const page = await context.newPage();
@@ -31,28 +74,36 @@ export async function login(opts: LoginOptions = {}): Promise<Session> {
     console.log('Navigating to UPC Aula Virtual...');
     await page.goto(SAML_URL, { waitUntil: 'networkidle', timeout });
 
-    // Wait for Microsoft login page
-    await page.waitForURL(/login\.microsoftonline\.com/, { timeout: 30_000 });
-
-    if (opts.username) {
-      await page.fill('input[type="email"], input[name="loginfmt"]', opts.username);
-      await page.click('input[type="submit"], button[type="submit"]');
-      await page.waitForTimeout(1500);
+    // With persistent context, Microsoft SSO may auto-complete without showing the login page
+    let needsInteractiveLogin = false;
+    try {
+      await page.waitForURL(/login\.microsoftonline\.com/, { timeout: 8_000 });
+      needsInteractiveLogin = true;
+    } catch {
+      // SSO cookies still valid — SAML redirect auto-completing
     }
 
-    if (opts.password) {
-      await page.waitForSelector('input[type="password"], input[name="passwd"]', { timeout: 15_000 });
-      await page.fill('input[type="password"], input[name="passwd"]', opts.password);
-      await page.click('input[type="submit"], button[type="submit"]');
-      await page.waitForTimeout(1500);
-    }
+    if (needsInteractiveLogin) {
+      if (opts.username) {
+        await page.fill('input[type="email"], input[name="loginfmt"]', opts.username);
+        await page.click('input[type="submit"], button[type="submit"]');
+        await page.waitForTimeout(1500);
+      }
 
-    // Handle "Stay signed in?" prompt
-    try {
-      await page.waitForSelector('#idBtn_Back, #KmsiCheckboxField', { timeout: 8_000 });
-      const noBtn = page.locator('#idBtn_Back');
-      if (await noBtn.isVisible()) await noBtn.click();
-    } catch {}
+      if (opts.password) {
+        await page.waitForSelector('input[type="password"], input[name="passwd"]', { timeout: 15_000 });
+        await page.fill('input[type="password"], input[name="passwd"]', opts.password);
+        await page.click('input[type="submit"], button[type="submit"]');
+        await page.waitForTimeout(1500);
+      }
+
+      // Handle "Stay signed in?" prompt
+      try {
+        await page.waitForSelector('#idBtn_Back, #KmsiCheckboxField', { timeout: 8_000 });
+        const noBtn = page.locator('#idBtn_Back');
+        if (await noBtn.isVisible()) await noBtn.click();
+      } catch {}
+    }
 
     // Wait for redirect back to aulavirtual.upc.edu.pe/ultra
     console.log('Waiting for authentication to complete...');
@@ -75,37 +126,23 @@ export async function login(opts: LoginOptions = {}): Promise<Session> {
       sameSite: c.sameSite,
     }));
 
-    // Extract XSRF token from page
-    const xsrfToken = await page.evaluate(() => {
-      // Try various sources
-      const metaXsrf = document.querySelector<HTMLMetaElement>(
-        'meta[name="blackboard.platform.security.NonceUtil.nonce"]'
-      )?.content;
-      if (metaXsrf) return metaXsrf;
-
-      // Try from cookies
-      const allCookies = document.cookie.split(';').reduce<Record<string, string>>((acc, c) => {
-        const [k, v] = c.trim().split('=');
-        acc[k] = v;
-        return acc;
-      }, {});
-      return allCookies['XSRF-TOKEN'] || '';
-    });
+    // Extract XSRF token from BbRouter cookie
+    let nonce = extractXsrf(cookies);
 
-    // Get nonce from a page that has it
-    let nonce = xsrfToken;
+    // Fallback: try meta tag in the page
     if (!nonce) {
-      const loginResp = await page.goto(`${BASE_URL}/webapps/login/`, { waitUntil: 'domcontentloaded' });
-      if (loginResp) {
-        nonce = await page.evaluate(() => {
-          return (
-            document.querySelector<HTMLInputElement>(
-              'input[name="blackboard.platform.security.NonceUtil.nonce.ajax"]'
-            )?.value || ''
-          );
-        });
-        await page.goBack();
-      }
+      nonce = await page.evaluate(() => {
+        const metaXsrf = document.querySelector<HTMLMetaElement>(
+          'meta[name="blackboard.platform.security.NonceUtil.nonce"]'
+        )?.content;
+        if (metaXsrf) return metaXsrf;
+        const allCookies = document.cookie.split(';').reduce<Record<string, string>>((acc, c) => {
+          const [k, v] = c.trim().split('=');
+          acc[k] = v;
+          return acc;
+        }, {});
+        return allCookies['XSRF-TOKEN'] || '';
+      });
     }
 
     // Get current user info via direct HTTP call with captured cookies
@@ -126,7 +163,7 @@ export async function login(opts: LoginOptions = {}): Promise<Session> {
       xsrfToken: nonce,
       userId: userData?.id,
       userName: userData?.userName,
-      expiresAt: Date.now() + SESSION_TTL_MS,
+      expiresAt: extractBbRouterExpiry(cookies),
     };
 
     saveSession(session);
@@ -134,6 +171,64 @@ export async function login(opts: LoginOptions = {}): Promise<Session> {
 
     return session;
   } finally {
-    await browser.close();
+    await context.close();
+  }
+}
+
+export async function silentRelogin(previousSession?: Session | null): Promise<Session> {
+  if (!fs.existsSync(PROFILE_DIR)) {
+    throw new SilentLoginFailed('No browser profile — run blackboard login first');
+  }
+
+  let context;
+  try {
+    context = await chromium.launchPersistentContext(PROFILE_DIR, {
+      headless: true,
+      userAgent: USER_AGENT,
+    });
+  } catch (err: any) {
+    throw new SilentLoginFailed(`Could not open browser profile: ${err.message}`);
+  }
+
+  const page = await context.newPage();
+
+  try {
+    await page.goto(SAML_URL, { waitUntil: 'commit', timeout: 20_000 });
+
+    // If SSO cookies are still valid, this redirect completes automatically
+    await page.waitForURL(/aulavirtual\.upc\.edu\.pe\/ultra/, { timeout: 15_000 });
+    await page.waitForLoadState('networkidle', { timeout: 10_000 });
+
+    const rawCookies = await context.cookies();
+    const cookies: Cookie[] = rawCookies.map((c) => ({
+      name: c.name,
+      value: c.value,
+      domain: c.domain,
+      path: c.path,
+      expires: c.expires,
+      httpOnly: c.httpOnly,
+      secure: c.secure,
+      sameSite: c.sameSite,
+    }));
+
+    if (!cookies.some(c => c.name === 'JSESSIONID' || c.name === 'BbRouter')) {
+      throw new SilentLoginFailed('Redirect succeeded but session cookies are missing');
+    }
+
+    const session: Session = {
+      cookies,
+      xsrfToken: extractXsrf(cookies),
+      userId: previousSession?.userId,
+      userName: previousSession?.userName,
+      expiresAt: extractBbRouterExpiry(cookies),
+    };
+
+    saveSession(session);
+    return session;
+  } catch (err: any) {
+    if (err instanceof SilentLoginFailed) throw err;
+    throw new SilentLoginFailed(err.message ?? 'Timed out — SSO session likely expired');
+  } finally {
+    await context.close();
   }
 }

package/src/auth/session.ts

@@ -42,3 +42,25 @@ export function isSessionValid(session: Session | null): boolean {
     session.cookies.some(c => c.name === 'BbRouter');
   return hasCriticalCookies;
 }
+
+export async function loadOrRefreshSession(): Promise<Session | null> {
+  // 1. Session still valid — return directly
+  const session = loadSession();
+  if (session !== null) return session;
+
+  // 2. Session expired — read raw file to preserve userId/userName for silent refresh
+  let expiredSession: Session | null = null;
+  try {
+    const raw = fs.readFileSync(SESSION_FILE, 'utf-8');
+    expiredSession = JSON.parse(raw);
+  } catch {}
+
+  // Dynamic import to avoid circular dependency (login.ts imports from session.ts)
+  const { silentRelogin, SilentLoginFailed } = await import('./login.js');
+  try {
+    return await silentRelogin(expiredSession);
+  } catch (err) {
+    if (err instanceof SilentLoginFailed) return null; // SSO expired — caller must prompt for login
+    throw err;
+  }
+}

package/src/commands/login.ts

@@ -3,7 +3,7 @@ import inquirer from 'inquirer';
 import chalk from 'chalk';
 import ora from 'ora';
 import { login } from '../auth/login.js';
-import { loadSession, clearSession, isSessionValid } from '../auth/session.js';
+import { loadSession, loadOrRefreshSession, clearSession, isSessionValid } from '../auth/session.js';
 import { ok, fail, warn, whatNext } from '../ui/theme.js';
 
 export function loginCommand(program: Command) {
@@ -34,7 +34,9 @@ export function loginCommand(program: Command) {
           password: opts.password,
         });
 
-        console.log(ok(`Sesión guardada — expira en 8 horas`));
+        const remainingMin = Math.round((session.expiresAt - Date.now()) / 60_000);
+        const remainingHr  = (remainingMin / 60).toFixed(1);
+        console.log(ok(`Sesión guardada — expira en ${remainingHr}h`));
         if (session.userName) console.log(chalk.gray(`  Usuario: ${session.userName}`));
         if (session.userId)   console.log(chalk.gray(`  ID:      ${session.userId}`));
         whatNext();
@@ -56,7 +58,7 @@ export function loginCommand(program: Command) {
     .command('whoami')
     .description('Show current logged-in user')
     .action(async () => {
-      const session = loadSession();
+      const session = await loadOrRefreshSession();
       if (!isSessionValid(session)) {
         console.log(chalk.red('Not logged in. Run: blackboard login'));
         process.exit(1);

package/src/index.ts

@@ -6,7 +6,7 @@ import { coursesCommand } from './commands/courses.js';
 import { apiDocsCommand } from './commands/api-docs.js';
 import { downloadCommand } from './commands/download.js';
 import { assignmentsCommand } from './commands/assignments.js';
-import { loadSession, isSessionValid } from './auth/session.js';
+import { loadSession, loadOrRefreshSession, isSessionValid } from './auth/session.js';
 import { createClient } from './api/client.js';
 import { getMe, getSystemVersion } from './api/courses.js';
 import { BANNER, ok, fail, hint } from './ui/theme.js';
@@ -16,7 +16,7 @@ const program = new Command();
 program
   .name('blackboard')
   .description('CLI no oficial para UPC Aula Virtual (Blackboard Learn)')
-  .version('1.0.0')
+  .version('1.0.7')
   .addHelpText('beforeAll', BANNER);
 
 // Auth commands
@@ -31,7 +31,7 @@ program
   .description('Estado de sesión y versión del servidor')
   .option('--json', 'Output raw JSON')
   .action(async (opts) => {
-    const session = loadSession();
+    const session = await loadOrRefreshSession();
     const valid = isSessionValid(session);
 
     const sysVersion = await getSystemVersion(
@@ -75,7 +75,7 @@ program
   .option('-b, --body <json>', 'Cuerpo JSON para POST/PUT')
   .option('-q, --query <params>', 'Query params (ej: "limit=10&offset=0")')
   .action(async (method: string, apiPath: string, opts) => {
-    const session = loadSession();
+    const session = await loadOrRefreshSession();
     if (!isSessionValid(session)) {
       console.error(JSON.stringify({ error: 'Not authenticated. Run: blackboard login' }));
       process.exit(1);

package/src/mcp/server.ts

@@ -3,7 +3,7 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { z } from 'zod';
 import fs from 'fs';
 import path from 'path';
-import { loadSession, isSessionValid } from '../auth/session.js';
+import { loadOrRefreshSession, isSessionValid } from '../auth/session.js';
 import { createClient } from '../api/client.js';
 import {
   getMe,
@@ -15,10 +15,18 @@ import {
   getGradeColumns,
   getSystemVersion,
 } from '../api/courses.js';
-import { listAssignments, listAttempts, submitAttempt, uploadFile } from '../api/assignments.js';
+import { listAssignments, listAttempts, submitAttempt, uploadFile, getAttemptFiles } from '../api/assignments.js';
+import {
+  getQuizQuestions,
+  saveQuizAnswer,
+  submitQuizAttempt,
+  getQuizColumnId,
+  parseQuizUrl,
+  type QuizQuestion,
+} from '../api/quiz.js';
 
-function getClient() {
-  const session = loadSession();
+async function getClient() {
+  const session = await loadOrRefreshSession();
   if (!isSessionValid(session)) {
     throw new Error('Not authenticated. Ask the user to run: blackboard login');
   }
@@ -33,21 +41,21 @@ export async function startMcpServer() {
 
   // ── whoami ─────────────────────────────────────────────────────────────────
   server.registerTool('whoami', { description: 'Get the currently authenticated UPC student info' }, async () => {
-    const { client } = getClient();
+    const { client } = await getClient();
     const me = await getMe(client);
     return { content: [{ type: 'text', text: JSON.stringify(me, null, 2) }] };
   });
 
   // ── system_version ─────────────────────────────────────────────────────────
   server.registerTool('system_version', { description: 'Get Blackboard Learn server version' }, async () => {
-    const { client } = getClient();
+    const { client } = await getClient();
     const v = await getSystemVersion(client);
     return { content: [{ type: 'text', text: JSON.stringify(v, null, 2) }] };
   });
 
   // ── list_courses ────────────────────────────────────────────────────────────
   server.registerTool('list_courses', { description: 'List all enrolled courses for the current student' }, async () => {
-    const { client, session } = getClient();
+    const { client, session } = await getClient();
     let userId = session.userId;
     if (!userId) { const me = await getMe(client); userId = me.id; }
     const data = await getMyCourses(client, userId!, { limit: 50 });
@@ -62,7 +70,7 @@ export async function startMcpServer() {
       inputSchema: { courseId: z.string().describe('Blackboard course ID like _529580_1') },
     },
     async ({ courseId }) => {
-      const { client } = getClient();
+      const { client } = await getClient();
       const data = await getCourse(client, courseId);
       return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
     }
@@ -79,7 +87,7 @@ export async function startMcpServer() {
       },
     },
     async ({ courseId, parentId }) => {
-      const { client } = getClient();
+      const { client } = await getClient();
       const data = await getCourseContents(client, courseId, parentId);
       return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
     }
@@ -93,7 +101,7 @@ export async function startMcpServer() {
       inputSchema: { courseId: z.string().describe('Blackboard course ID') },
     },
     async ({ courseId }) => {
-      const { client } = getClient();
+      const { client } = await getClient();
       const data = await getCourseAnnouncements(client, courseId);
       return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
     }
@@ -107,7 +115,7 @@ export async function startMcpServer() {
       inputSchema: { courseId: z.string().describe('Blackboard course ID') },
     },
     async ({ courseId }) => {
-      const { client } = getClient();
+      const { client } = await getClient();
       const data = await listAssignments(client, courseId);
       return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
     }
@@ -124,7 +132,7 @@ export async function startMcpServer() {
       },
     },
     async ({ courseId, columnId }) => {
-      const { client } = getClient();
+      const { client } = await getClient();
       const data = await listAttempts(client, courseId, columnId);
       return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
     }
@@ -138,7 +146,7 @@ export async function startMcpServer() {
       inputSchema: { courseId: z.string().describe('Blackboard course ID') },
     },
     async ({ courseId }) => {
-      const { client, session } = getClient();
+      const { client, session } = await getClient();
       let userId = session.userId;
       if (!userId) { const me = await getMe(client); userId = me.id; }
       const [columns, grades] = await Promise.all([
@@ -168,7 +176,7 @@ export async function startMcpServer() {
       },
     },
     async ({ courseId, contentId, attachmentId, filename, outputDir }) => {
-      const { client } = getClient();
+      const { client } = await getClient();
 
       const url = attachmentId.startsWith('http')
         ? attachmentId
@@ -208,7 +216,7 @@ export async function startMcpServer() {
       },
     },
     async ({ courseId, contentId }) => {
-      const { client } = getClient();
+      const { client } = await getClient();
 
       // Try standard REST attachments endpoint first (works for x-bb-file)
       try {
@@ -271,7 +279,7 @@ export async function startMcpServer() {
       },
     },
     async ({ url, filename, outputDir }) => {
-      const { client } = getClient();
+      const { client } = await getClient();
       const r = await client.get(url, { responseType: 'arraybuffer', headers: { Accept: '*/*' } });
 
       const contentDisposition = r.headers['content-disposition'] as string | undefined;
@@ -308,7 +316,7 @@ export async function startMcpServer() {
       },
     },
     async ({ courseId, columnId, studentComments, studentSubmission }) => {
-      const { client } = getClient();
+      const { client } = await getClient();
       const attempt = await submitAttempt(client, courseId, columnId, {
         studentComments,
         studentSubmission,
@@ -318,6 +326,228 @@ export async function startMcpServer() {
     }
   );
 
+  // ── get_quiz_questions ──────────────────────────────────────────────────────
+  server.registerTool(
+    'get_quiz_questions',
+    {
+      description:
+        'Fetch all questions and answer options from a Blackboard Ultra quiz attempt. ' +
+        'Provide either a full quiz URL, or courseId + contentId + attemptId. ' +
+        'Returns each question with its type, text, options, and current saved answer.',
+      inputSchema: {
+        url: z
+          .string()
+          .optional()
+          .describe(
+            'Full Ultra quiz URL, e.g. https://aulavirtual.upc.edu.pe/ultra/stream/assessment/_69146765_1/overview/attempt/_94898825_1?courseId=_529533_1'
+          ),
+        courseId: z.string().optional().describe('Course ID (e.g. _529533_1) — required if url not given'),
+        contentId: z.string().optional().describe('Quiz content item ID (e.g. _69146765_1) — required if url not given'),
+        attemptId: z.string().optional().describe('Attempt ID (e.g. _94898825_1) — required if url not given'),
+      },
+    },
+    async ({ url, courseId, contentId, attemptId }) => {
+      const { client, session } = await getClient();
+
+      // Resolve IDs from URL or direct params
+      let resolvedCourseId = courseId;
+      let resolvedContentId = contentId;
+      let resolvedAttemptId = attemptId;
+
+      if (url) {
+        const parsed = parseQuizUrl(url);
+        resolvedCourseId = resolvedCourseId || parsed.courseId;
+        resolvedContentId = resolvedContentId || parsed.contentId;
+        resolvedAttemptId = resolvedAttemptId || parsed.attemptId;
+      }
+
+      if (!resolvedCourseId || !resolvedContentId || !resolvedAttemptId) {
+        throw new Error(
+          'Provide either a full quiz URL or all three of: courseId, contentId, attemptId'
+        );
+      }
+
+      // Get columnId + attempt policy — reuse session already obtained above
+      const policy = await getQuizColumnId(client, resolvedCourseId, resolvedContentId, session.userId);
+
+      if (!policy.canAttempt) {
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              error: 'NO_ATTEMPTS_LEFT',
+              message: `No quedan intentos para este cuestionario. ${policy.attemptSummary}`,
+              policy,
+            }, null, 2),
+          }],
+        };
+      }
+
+      const info = await getQuizQuestions(client, resolvedCourseId, policy.columnId, resolvedAttemptId);
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({ attemptPolicy: policy, ...info }, null, 2),
+        }],
+      };
+    }
+  );
+
+  // ── save_quiz_answer ────────────────────────────────────────────────────────
+  server.registerTool(
+    'save_quiz_answer',
+    {
+      description:
+        'Save a single answer for a quiz question (does NOT submit — use submit_quiz to finalize). ' +
+        'question is the full question object from get_quiz_questions. ' +
+        'answer: boolean for true/false, or 0-based index number for multiple-choice.',
+      inputSchema: {
+        courseId: z.string().describe('Course ID'),
+        attemptId: z.string().describe('Quiz attempt ID (e.g. _94898825_1)'),
+        question: z.string().describe('JSON string of the question object from get_quiz_questions'),
+        answer: z.union([z.boolean(), z.number()]).describe(
+          'For true/false: true or false. For multiple-choice: 0-based index of selected option.'
+        ),
+      },
+    },
+    async ({ courseId, attemptId, question: questionJson, answer }) => {
+      const { client } = await getClient();
+      const question: QuizQuestion = JSON.parse(questionJson);
+      const result = await saveQuizAnswer(client, courseId, attemptId, question, answer as boolean | number);
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+
+  // ── submit_quiz ─────────────────────────────────────────────────────────────
+  server.registerTool(
+    'submit_quiz',
+    {
+      description:
+        'Finalize and submit a quiz attempt. ALWAYS confirm with the user before calling this. ' +
+        'All individual answers should be saved first via save_quiz_answer.',
+      inputSchema: {
+        courseId: z.string().describe('Course ID'),
+        attemptId: z.string().describe('Quiz attempt ID to submit'),
+      },
+    },
+    async ({ courseId, attemptId }) => {
+      const { client } = await getClient();
+      const result = await submitQuizAttempt(client, courseId, attemptId);
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+
+  // ── get_assignment_feedback ─────────────────────────────────────────────────
+  server.registerTool(
+    'get_assignment_feedback',
+    {
+      description:
+        'Get professor feedback and scores for all assignments in a course. ' +
+        'For each graded submission, shows score, instructor comments, and any feedback files attached by the professor.',
+      inputSchema: { courseId: z.string().describe('Blackboard course ID') },
+    },
+    async ({ courseId }) => {
+      const { client, session } = await getClient();
+
+      const assignments = await listAssignments(client, courseId);
+
+      const results = await Promise.all(
+        assignments.map(async (col) => {
+          try {
+            const attempts = await listAttempts(client, courseId, col.id);
+            if (!attempts.length) {
+              return { assignment: col.name, columnId: col.id, status: 'no_attempts' };
+            }
+
+            // Most recent attempt first
+            const latest = attempts.sort((a, b) =>
+              (b.attemptDate ?? b.modified ?? '').localeCompare(a.attemptDate ?? a.modified ?? '')
+            )[0];
+
+            // Try to get feedback files (professor may have attached annotated docs)
+            let feedbackFiles: any[] = [];
+            try {
+              feedbackFiles = await getAttemptFiles(client, courseId, col.id, latest.id);
+            } catch {}
+
+            return {
+              assignment: col.name,
+              columnId: col.id,
+              contentId: col.contentId,
+              due: col.grading?.due,
+              maxScore: col.score?.possible,
+              attempt: {
+                id: latest.id,
+                status: latest.status,
+                score: latest.score,
+                grade: latest.displayGrade?.text,
+                submittedAt: latest.attemptDate ?? latest.modified,
+                // Professor feedback — field name varies by BB version
+                instructorFeedback:
+                  latest.text ?? latest.instructorFeedback ?? latest.feedback ?? null,
+                studentComments: latest.studentComments ?? null,
+                feedbackFiles: feedbackFiles.map((f) => ({
+                  id: f.id,
+                  name: f.name,
+                  mimeType: f.mimeType,
+                  size: f.size,
+                })),
+              },
+            };
+          } catch {
+            return { assignment: col.name, columnId: col.id, status: 'error_fetching' };
+          }
+        })
+      );
+
+      return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
+    }
+  );
+
+  // ── download_feedback_file ───────────────────────────────────────────────────
+  server.registerTool(
+    'download_feedback_file',
+    {
+      description:
+        '[EXPERIMENTAL] Download a feedback file that a professor attached to a graded attempt. ' +
+        'Use the fileId from get_assignment_feedback → attempt.feedbackFiles. ' +
+        'The download endpoint may not be available on all Blackboard versions.',
+      inputSchema: {
+        courseId: z.string().describe('Blackboard course ID'),
+        columnId: z.string().describe('Gradebook column (assignment) ID'),
+        attemptId: z.string().describe('Attempt ID from get_assignment_feedback'),
+        fileId: z.string().describe('File ID from get_assignment_feedback → attempt.feedbackFiles'),
+        filename: z.string().optional().describe('Filename to save as (defaults to the name from feedbackFiles)'),
+        outputDir: z.string().optional().describe('Directory to save the file (default: current working directory)'),
+      },
+    },
+    async ({ courseId, columnId, attemptId, fileId, filename, outputDir }) => {
+      const { client } = await getClient();
+
+      const url = `/learn/api/public/v2/courses/${courseId}/gradebook/columns/${columnId}/attempts/${attemptId}/files/${fileId}/download`;
+      const r = await client.get(url, { responseType: 'arraybuffer', headers: { Accept: '*/*' } });
+
+      const contentDisposition = r.headers['content-disposition'] as string | undefined;
+      const detectedName = contentDisposition
+        ? (contentDisposition.match(/filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/))?.[1]?.replace(/['"]/g, '').trim()
+        : undefined;
+      const finalName = filename ?? detectedName ?? `feedback_${fileId}`;
+
+      const dir = path.resolve(outputDir ?? process.cwd());
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      const dest = path.join(dir, finalName);
+      fs.writeFileSync(dest, Buffer.from(r.data));
+
+      const mimeType = (r.headers['content-type'] as string | undefined) ?? 'application/octet-stream';
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({ saved: dest, size: r.data.byteLength, mimeType }, null, 2),
+        }],
+      };
+    }
+  );
+
   // ── raw_api ─────────────────────────────────────────────────────────────────
   server.registerTool(
     'raw_api',
@@ -331,7 +561,7 @@ export async function startMcpServer() {
       },
     },
     async ({ method, path, query, body }) => {
-      const { client } = getClient();
+      const { client } = await getClient();
       const params = query ? Object.fromEntries(new URLSearchParams(query)) : undefined;
       const data = body ? JSON.parse(body) : undefined;
       const r = await client.request({ method: method.toLowerCase() as any, url: path, params, data });

package/tsconfig.json

@@ -2,7 +2,7 @@
   "compilerOptions": {
     "target": "ES2022",
     "module": "commonjs",
-    "lib": ["ES2022"],
+    "lib": ["ES2022", "DOM"],
     "outDir": "dist",
     "rootDir": "src",
     "strict": true,