brightspace-mcp-server 3.11.3 → 3.11.5

package/build/api/client.js

@@ -211,6 +211,10 @@ export class D2LApiClient {
     async initialize() {
         await this.ensureVersions();
     }
+    /** The configured Brightspace origin (scheme, host and port), e.g. `https://purdue.brightspace.com`. */
+    get origin() {
+        return new URL(this.baseUrl).origin;
+    }
     /**
      * Get discovered API versions.
      * @throws Error if no request has discovered them yet
@@ -308,6 +312,13 @@ export class D2LApiClient {
      * read by a read-only tool is not worth an MFA prompt.
      */
     async getPage(path) {
+        // The cookie belongs to this Brightspace alone. A path that would make
+        // `${baseUrl}${path}` name another host (`@evil.example/`, `.evil.example/`,
+        // `//evil.example/`) is refused before the cookie is ever read.
+        if (!this.isSameOriginPath(path)) {
+            log("WARN", "getPage refused a path outside the Brightspace origin");
+            return null;
+        }
         const token = await this.tokenManager.getToken();
         if (!token?.cookieHeader)
             return null;
@@ -322,6 +333,18 @@ export class D2LApiClient {
             throw error;
         }
     }
+    /** True when `path` is a root-relative path that keeps a request on the configured origin. */
+    isSameOriginPath(path) {
+        if (!path.startsWith("/") || path.startsWith("//") || path.includes("\\"))
+            return false;
+        try {
+            const target = new URL(`${this.baseUrl}${path}`);
+            return target.origin === this.origin && !target.username && !target.password;
+        }
+        catch {
+            return false;
+        }
+    }
     /** One HTTP refresh and at most one browser login per caller. */
     async withAuthentication(path, request) {
         let token = await this.tokenManager.getToken();

package/build/tools/attachment-reader.js

@@ -5,6 +5,9 @@
  */
 import { extractPdfText } from "../utils/pdf-extractor.js";
 import { officeDocumentText } from "../utils/zip-extract.js";
+import { readBodyCapped } from "../utils/download-helpers.js";
+import { DownloadError } from "../utils/download-errors.js";
+import { MAX_FILE_SIZE } from "../utils/file-validator.js";
 const KIND_BY_EXTENSION = {
     pdf: "pdf",
     docx: "docx",
@@ -44,8 +47,27 @@ export async function readAttachment(apiClient, sourcePath, attachment, extract,
     const base = describeAttachment(attachment);
     if (!extract)
         return { ...base, text: null, note: "Text extraction was not requested." };
+    // Extraction holds the whole file in memory, so it is capped: refused from
+    // the listed size when that is already over, and cut off mid-read when the
+    // listed size (or Content-Length) understated it.
+    const tooLarge = {
+        ...base,
+        text: null,
+        truncated: false,
+        note: `This file is over the ${MAX_FILE_SIZE / 1024 / 1024}MB text extraction limit. Use download_file with an absolute downloadPath to save it to disk instead.`,
+    };
+    if (attachment.Size > MAX_FILE_SIZE)
+        return tooLarge;
     const response = await apiClient.getRaw(sourcePath);
-    const buffer = Buffer.from(await response.arrayBuffer());
+    let buffer;
+    try {
+        buffer = await readBodyCapped(response, MAX_FILE_SIZE);
+    }
+    catch (error) {
+        if (error instanceof DownloadError && error.kind === "tooLarge")
+            return tooLarge;
+        throw error;
+    }
     let text = null;
     let note;
     switch (base.kind) {

package/build/tools/download-dropbox-submission-file.js

@@ -7,10 +7,16 @@ import { ApiError } from "../api/index.js";
 import { DownloadDropboxSubmissionFileSchema } from "./schemas.js";
 import { toolResponse, sanitizeError, errorResponse } from "./tool-helpers.js";
 import { log } from "../utils/logger.js";
-import { validateContentId, MAX_FILE_SIZE } from "../utils/file-validator.js";
-import { secureDownload } from "../utils/download-helpers.js";
+import { validateContentId, DISK_MAX_FILE_SIZE } from "../utils/file-validator.js";
+import { secureStreamDownload } from "../utils/download-helpers.js";
+import { DownloadError } from "../utils/download-errors.js";
 import path from "node:path";
 import fs from "node:fs/promises";
+/** The refusal for a file over the disk download cap. */
+function tooLargeResponse(bytes) {
+    return errorResponse(`File too large (${Math.round(bytes / 1024 / 1024)}MB). ` +
+        `Maximum allowed: ${DISK_MAX_FILE_SIZE / 1024 / 1024}MB`);
+}
 /**
  * Register download_dropbox_submission_file tool.
  */
@@ -74,9 +80,8 @@ export function registerDownloadDropboxSubmissionFile(server, apiClient) {
                 throw error;
             }
             // Check the size Brightspace reported before downloading anything.
-            if (targetFile.Size > MAX_FILE_SIZE) {
-                return errorResponse(`File too large (${Math.round(targetFile.Size / 1024 / 1024)}MB). ` +
-                    `Maximum allowed: ${MAX_FILE_SIZE / 1024 / 1024}MB`);
+            if (targetFile.Size > DISK_MAX_FILE_SIZE) {
+                return tooLargeResponse(targetFile.Size);
             }
             const downloadApiPath = apiClient.le(courseId, `/dropbox/folders/${folderId}/submissions/${submissionId}/files/${fileId}/download`);
             let response;
@@ -92,27 +97,26 @@ export function registerDownloadDropboxSubmissionFile(server, apiClient) {
                 }
                 throw error;
             }
-            // Check Content-Length before downloading the body (prevent memory exhaustion).
+            // Check Content-Length before reading the body.
             const contentLength = parseInt(response.headers.get("Content-Length") ?? "0", 10);
-            if (contentLength > MAX_FILE_SIZE) {
-                return errorResponse(`File too large (${Math.round(contentLength / 1024 / 1024)}MB). ` +
-                    `Maximum allowed: ${MAX_FILE_SIZE / 1024 / 1024}MB`);
+            if (contentLength > DISK_MAX_FILE_SIZE) {
+                return tooLargeResponse(contentLength);
             }
-            const buffer = Buffer.from(await response.arrayBuffer());
-            // Double-check the actual size once downloaded.
-            if (buffer.length > MAX_FILE_SIZE) {
-                return errorResponse(`File too large (${Math.round(buffer.length / 1024 / 1024)}MB). ` +
-                    `Maximum allowed: ${MAX_FILE_SIZE / 1024 / 1024}MB`);
+            if (!response.body) {
+                throw new DownloadError("undetectableType", "File is empty (0 bytes)");
             }
             const originalFilename = targetFile.FileName;
             const effectiveFilename = customFilename || originalFilename;
-            // secureDownload applies this project's path-containment and
-            // magic-byte file-type checks and resolves filename conflicts,
-            // rather than writing the fetched buffer straight to disk.
-            const result = await secureDownload({
+            // secureStreamDownload streams the body to a temporary file in the
+            // target directory, applies this project's path-containment and
+            // magic-byte file-type checks there, enforces the disk size cap on the
+            // bytes actually received, and resolves filename conflicts; a refused
+            // or failed download leaves nothing behind.
+            const result = await secureStreamDownload({
                 targetDir: downloadPath,
                 filename: effectiveFilename,
-                data: buffer,
+                body: response.body,
+                maxBytes: DISK_MAX_FILE_SIZE,
             });
             log("INFO", `download_dropbox_submission_file: saved ${result.path} (${result.size} bytes, ${result.mime})`);
             return toolResponse({

package/build/tools/download-file.js

@@ -12,20 +12,13 @@ import { checkTopicAvailability } from "./topic-availability.js";
 // go through; importing it here only made it look as though this file
 // validated anything itself. Inline mode never writes to disk, so it calls
 // validateFileType directly to enforce the same magic-byte allowlist.
-import { validateContentId, validateFileType, MAX_FILE_SIZE } from "../utils/file-validator.js";
-import { secureStreamDownload } from "../utils/download-helpers.js";
+import { validateContentId, validateFileType, MAX_FILE_SIZE, DISK_MAX_FILE_SIZE, } from "../utils/file-validator.js";
+import { secureStreamDownload, readBodyCapped } from "../utils/download-helpers.js";
 import { DownloadError } from "../utils/download-errors.js";
 import { extractPdfText } from "../utils/pdf-extractor.js";
 import { officeDocumentText } from "../utils/zip-extract.js";
 import fs from "node:fs/promises";
 import path from "node:path";
-/**
- * Maximum bytes of a file disk mode will save. Disk downloads stream straight
- * to the file, so memory no longer bounds them the way MAX_FILE_SIZE (50 MB)
- * bounds inline mode; this only stops a runaway body filling the disk.
- * Lecture decks and recordings routinely pass 50 MB.
- */
-const DISK_MAX_FILE_SIZE = 2 * 1024 * 1024 * 1024; // 2 GB
 /** The size cap for a download: inline mode buffers the file, disk mode streams it. */
 function maxFileSize(downloadPath) {
     return downloadPath === undefined ? MAX_FILE_SIZE : DISK_MAX_FILE_SIZE;
@@ -35,7 +28,9 @@ function tooLargeResponse(bytes, downloadPath) {
     const hint = downloadPath === undefined
         ? " Provide an absolute downloadPath to save it to disk instead."
         : "";
-    return errorResponse(`File too large (${Math.round(bytes / 1024 / 1024)}MB). Maximum allowed: ${maxFileSize(downloadPath) / 1024 / 1024}MB.${hint}`);
+    // null: the body was cut off at the cap, so its full size is unknown.
+    const size = bytes === null ? "over the limit" : `${Math.round(bytes / 1024 / 1024)}MB`;
+    return errorResponse(`File too large (${size}). Maximum allowed: ${maxFileSize(downloadPath) / 1024 / 1024}MB.${hint}`);
 }
 /**
  * Maximum bytes of a file we'll embed inline in a tool response. Base64
@@ -209,10 +204,17 @@ async function finishDownload(response, originalFilename, downloadPath, customFi
         return tooLargeResponse(contentLength, downloadPath);
     }
     if (downloadPath === undefined) {
-        const buffer = Buffer.from(await response.arrayBuffer());
-        // Double-check actual size
-        if (buffer.length > MAX_FILE_SIZE) {
-            return tooLargeResponse(buffer.length, downloadPath);
+        // Content-Length can be missing or understated, so the read itself is
+        // capped and stops at the limit rather than buffering the whole body.
+        let buffer;
+        try {
+            buffer = await readBodyCapped(response, MAX_FILE_SIZE);
+        }
+        catch (error) {
+            if (error instanceof DownloadError && error.kind === "tooLarge") {
+                return tooLargeResponse(null, downloadPath);
+            }
+            throw error;
         }
         return respondInline(buffer, originalFilename, customFilename);
     }
@@ -245,13 +247,16 @@ async function finishDownload(response, originalFilename, downloadPath, customFi
 export function registerDownloadFile(server, apiClient) {
     server.registerTool("download_file", {
         title: "Download File",
-        description: "Download a file from course content, assignment submissions, or an announcement's attachments. Use this when the user wants a file from Brightspace course content, dropbox submissions, or an announcement (newsId + fileId, from get_announcements). Two response modes: (1) INLINE (default — omit downloadPath): the file comes back directly in the tool response — extracted text for PDFs and Office documents, an image block for jpeg/png/gif/webp, or a short description for anything else — so it can be read immediately without touching any filesystem. This is the right choice in clients like Claude Desktop, whose analysis/sandbox tools cannot see a file the MCP server writes to its own host filesystem. (2) DISK (set downloadPath to an absolute path on the HOST filesystem the MCP server runs on): the file is saved there. Ask the user where to save it before using disk mode — never guess a directory. After identifying the file, suggest a clean readable filename (e.g., 'Lecture 7 - Memory Management.pdf' instead of 'L07_CS251_2026SP_v2.pdf') and pass it as customFilename, or omit it to keep the original. If a content-topic download fails because the file isn't released yet, the response explains why when Brightspace's module/topic metadata supports it (not yet open, ended, locked, or hidden).",
+        description: "Download a file from course content, instructor assignment attachments (source: assignmentAttachment with folderId + fileId), assignment submissions, or an announcement's attachments. Use this when the user wants a file from Brightspace course content, dropbox submissions, or an announcement (newsId + fileId, from get_announcements). Two response modes: (1) INLINE (default — omit downloadPath): the file comes back directly in the tool response — extracted text for PDFs and Office documents, an image block for jpeg/png/gif/webp, or a short description for anything else — so it can be read immediately without touching any filesystem. This is the right choice in clients like Claude Desktop, whose analysis/sandbox tools cannot see a file the MCP server writes to its own host filesystem. (2) DISK (set downloadPath to an absolute path on the HOST filesystem the MCP server runs on): the file is saved there. Ask the user where to save it before using disk mode — never guess a directory. After identifying the file, suggest a clean readable filename (e.g., 'Lecture 7 - Memory Management.pdf' instead of 'L07_CS251_2026SP_v2.pdf') and pass it as customFilename, or omit it to keep the original. If a content-topic download fails because the file isn't released yet, the response explains why when Brightspace's module/topic metadata supports it (not yet open, ended, locked, or hidden).",
         inputSchema: DownloadFileSchema,
     }, async (args) => {
         try {
             log("DEBUG", "download_file tool called", { args });
             // Parse and validate input
-            const { courseId, topicId, folderId, newsId, fileId, downloadPath, customFilename } = DownloadFileSchema.parse(args);
+            const { courseId, topicId, folderId, newsId, fileId, downloadPath, customFilename, source } = DownloadFileSchema.parse(args);
+            if (source !== undefined && (topicId !== undefined || newsId !== undefined || folderId === undefined || fileId === undefined)) {
+                return errorResponse("source requires folderId and fileId and cannot be combined with topicId or newsId.");
+            }
             // Validate courseId
             validateContentId(courseId);
             // downloadPath is optional: omitting it means "return the file
@@ -286,7 +291,7 @@ export function registerDownloadFile(server, apiClient) {
                 // Submission file download
                 validateContentId(folderId);
                 validateContentId(fileId);
-                return await downloadSubmissionFile(apiClient, courseId, folderId, fileId, downloadPath, customFilename);
+                return await (source === "assignmentAttachment" ? downloadAssignmentAttachment : downloadSubmissionFile)(apiClient, courseId, folderId, fileId, downloadPath, customFilename);
             }
             else if (newsId !== undefined && fileId !== undefined) {
                 // Announcement attachment download
@@ -303,6 +308,23 @@ export function registerDownloadFile(server, apiClient) {
         }
     });
 }
+/** Download an instructor-provided handout, independently of student submissions. */
+async function downloadAssignmentAttachment(apiClient, courseId, folderId, fileId, downloadPath, customFilename) {
+    const raw = await apiClient.get(apiClient.le(courseId, "/dropbox/folders/"));
+    const folders = Array.isArray(raw) ? raw : raw?.Objects ?? [];
+    const folder = folders.find((candidate) => candidate.Id === folderId && candidate.IsHidden !== true);
+    if (!folder)
+        return errorResponse(`No visible assignment with id ${folderId} in course ${courseId}.`);
+    const attachments = folder.Attachments ?? [];
+    const file = attachments.find((candidate) => candidate.FileId === fileId);
+    if (!file)
+        return errorResponse(`File ID ${fileId} not found on this assignment. Available files: ${attachments.map((candidate) => `${candidate.FileName} (ID: ${candidate.FileId})`).join(", ")}`);
+    if (file.Size > maxFileSize(downloadPath))
+        return tooLargeResponse(file.Size, downloadPath);
+    const response = await apiClient.getRaw(apiClient.le(courseId, `/dropbox/folders/${folderId}/attachments/${fileId}`));
+    const filename = parseContentDispositionFilename(response.headers.get("Content-Disposition") ?? "") ?? file.FileName;
+    return finishDownload(response, filename, downloadPath, customFilename, "Assignment attachment");
+}
 /**
  * Extract a filename from a Content-Disposition header.
  */

package/build/tools/get-assignment-files.js

@@ -60,6 +60,7 @@ export function registerGetAssignmentFiles(server, apiClient, baseUrl) {
                     });
                 }
                 const file = await readAttachment(apiClient, apiClient.le(courseId, `/dropbox/folders/${folderId}/attachments/${fileId}`), attachment, extractText, maxChars);
+                file.downloadArgs = { courseId, folderId, fileId, source: "assignmentAttachment" };
                 return toolResponse({
                     courseId,
                     folderId,
@@ -76,7 +77,10 @@ export function registerGetAssignmentFiles(server, apiClient, baseUrl) {
                 folderName: folder.Name,
                 dueDate: folder.DueDate,
                 url: baseUrl ? assignmentUrl(baseUrl, courseId, folder.Id) : null,
-                attachments: (folder.Attachments ?? []).map(describeAttachment),
+                attachments: (folder.Attachments ?? []).map((attachment) => ({
+                    ...describeAttachment(attachment),
+                    downloadArgs: { courseId, folderId: folder.Id, fileId: attachment.FileId, source: "assignmentAttachment" },
+                })),
             }));
             log("INFO", `get_assignment_files: ${withFiles.length} assignments with attachments in course ${courseId}`);
             return toolResponse({

package/build/tools/get-syllabus.js

@@ -7,7 +7,9 @@ import { ApiError, DEFAULT_CACHE_TTLS } from "../api/index.js";
 import { GetSyllabusSchema } from "./schemas.js";
 import { toolResponse, sanitizeError, errorResponse } from "./tool-helpers.js";
 import { convertHtmlToMarkdown } from "../utils/html-converter.js";
-import { secureDownload } from "../utils/download-helpers.js";
+import { stripD2lSessionParams } from "../utils/session-params.js";
+import { secureDownload, readBodyCapped } from "../utils/download-helpers.js";
+import { DownloadError } from "../utils/download-errors.js";
 import { MAX_FILE_SIZE } from "../utils/file-validator.js";
 import { extractPdfText } from "../utils/pdf-extractor.js";
 import { log } from "../utils/logger.js";
@@ -32,7 +34,9 @@ function findExternalSyllabusSources(ltiLinks, toc) {
         for (const m of modules) {
             for (const t of m.Topics ?? []) {
                 if (t.Url && LTI_LAUNCH_PATTERN.test(t.Url) && SYLLABUS_PATTERN.test(t.Title)) {
-                    sources.push({ title: t.Title, location: "content", url: t.Url });
+                    // Keep routing params (ou, type, rcode) so the link still opens the
+                    // right tool, but never echo D2L session tokens.
+                    sources.push({ title: t.Title, location: "content", url: stripD2lSessionParams(t.Url) });
                 }
             }
             walk(m.Modules ?? []);
@@ -41,25 +45,63 @@ function findExternalSyllabusSources(ltiLinks, toc) {
     walk(toc);
     return sources;
 }
-/** Fetch a lookup that students may not be permitted to make; failure means "none". */
-async function fetchOrEmpty(fetch, fallback, what) {
+const LOOKUP_LABELS = {
+    "lti-links": "course LTI links",
+    "content-toc": "course content table of contents",
+};
+/**
+ * Run a lookup that students may not be permitted to make. A failure is
+ * reported as unavailable rather than folded into "nothing found", so callers
+ * can tell an empty search from one that could not be completed. Only the
+ * HTTP status is kept; raw error bodies never reach the tool output.
+ */
+async function tryLookup(lookup, fetch) {
     try {
-        return await fetch();
+        return { ok: true, value: await fetch() };
     }
     catch (error) {
-        log("DEBUG", `get_syllabus: could not read ${what}`, error);
-        return fallback;
+        log("DEBUG", `get_syllabus: could not read ${LOOKUP_LABELS[lookup]}`, error);
+        if (error instanceof ApiError) {
+            const forbidden = error.status === 401 || error.status === 403;
+            return {
+                ok: false,
+                unavailable: { lookup, reason: forbidden ? "permission-denied" : "request-failed", status: error.status },
+            };
+        }
+        return { ok: false, unavailable: { lookup, reason: "request-failed" } };
     }
 }
+function describeUnavailable(u) {
+    const why = u.reason === "permission-denied"
+        ? "permission denied"
+        : u.status !== undefined
+            ? `request failed (HTTP ${u.status})`
+            : "request failed (network error)";
+    return `${LOOKUP_LABELS[u.lookup]}: ${why}`;
+}
 async function discoverExternalSyllabusSources(apiClient, courseId) {
-    const [ltiLinks, toc] = await Promise.all([
-        fetchOrEmpty(() => apiClient.get(apiClient.leGlobal(`/lti/link/${courseId}/`), { ttl: DEFAULT_CACHE_TTLS.courseContent }), [], "LTI links"),
-        fetchOrEmpty(() => apiClient.get(apiClient.le(courseId, "/content/toc"), { ttl: DEFAULT_CACHE_TTLS.courseContent }), {}, "content table of contents"),
+    const [lti, toc] = await Promise.all([
+        tryLookup("lti-links", () => apiClient.get(apiClient.leGlobal(`/lti/link/${courseId}/`), { ttl: DEFAULT_CACHE_TTLS.courseContent })),
+        tryLookup("content-toc", () => apiClient.get(apiClient.le(courseId, "/content/toc"), { ttl: DEFAULT_CACHE_TTLS.courseContent })),
     ]);
-    const sources = findExternalSyllabusSources(ltiLinks ?? [], toc?.Modules ?? []);
-    return sources.length > 0
-        ? { externalSyllabusSources: sources, externalSyllabusNote: EXTERNAL_SYLLABUS_NOTE }
-        : {};
+    const ltiLinks = lti.ok ? (Array.isArray(lti.value) ? lti.value : []) : [];
+    const modules = toc.ok ? (toc.value?.Modules ?? []) : [];
+    const sources = findExternalSyllabusSources(ltiLinks, modules);
+    const unavailable = [lti, toc].flatMap((o) => (o.ok ? [] : [o.unavailable]));
+    const fields = {};
+    if (sources.length > 0) {
+        fields.externalSyllabusSources = sources;
+        fields.externalSyllabusNote = EXTERNAL_SYLLABUS_NOTE;
+    }
+    if (unavailable.length > 0) {
+        fields.externalSyllabusDiscovery = {
+            complete: false,
+            unavailable,
+            note: `Could not check every place an external syllabus may be linked (${unavailable.map(describeUnavailable).join("; ")}). ` +
+                "Missing external sources here does not mean the course has no syllabus.",
+        };
+    }
+    return { fields, complete: unavailable.length === 0 };
 }
 /**
  * Register get_syllabus tool
@@ -67,7 +109,7 @@ async function discoverExternalSyllabusSources(apiClient, courseId) {
 export function registerGetSyllabus(server, apiClient) {
     server.registerTool("get_syllabus", {
         title: "Get Course Syllabus",
-        description: "Fetch the syllabus/overview text and optional attachment for a course. Returns the course overview description as markdown. When the syllabus lives in an external LTI tool (e.g. Simple Syllabus), lists those sources in externalSyllabusSources; their contents cannot be read. If downloadPath is provided, also downloads the syllabus attachment (e.g. PDF). IMPORTANT: You MUST ask the user where they want to save the file before calling this tool with a downloadPath.",
+        description: "Fetch the syllabus/overview text and optional attachment for a course. Returns the course overview description as markdown. When the syllabus lives in an external LTI tool (e.g. Simple Syllabus), lists those sources in externalSyllabusSources; their contents cannot be read. If some of those lookups could not be completed (e.g. permission denied), externalSyllabusDiscovery says which, and an empty result is then not proof the course has no syllabus. If downloadPath is provided, also downloads the syllabus attachment (e.g. PDF). IMPORTANT: You MUST ask the user where they want to save the file before calling this tool with a downloadPath.",
         inputSchema: GetSyllabusSchema,
     }, async (args) => {
         try {
@@ -98,12 +140,15 @@ export function registerGetSyllabus(server, apiClient) {
             }
             catch (error) {
                 if (error instanceof ApiError && error.status === 404) {
+                    const discovery = await discoverExternalSyllabusSources(apiClient, courseId);
                     return toolResponse({
                         courseId,
                         description: null,
                         hasAttachment: false,
-                        message: "No syllabus/overview found for this course.",
-                        ...(await discoverExternalSyllabusSources(apiClient, courseId)),
+                        message: discovery.complete
+                            ? "No syllabus/overview found for this course."
+                            : "No course overview found, but external syllabus discovery was incomplete, so the course may still have a syllabus elsewhere.",
+                        ...discovery.fields,
                     });
                 }
                 throw error;
@@ -132,9 +177,15 @@ export function registerGetSyllabus(server, apiClient) {
                         attachmentFilename = match[1].replace(/['"]/g, "");
                     }
                     // Download body as buffer
-                    attachmentBuffer = Buffer.from(await response.arrayBuffer());
-                    if (attachmentBuffer.length > MAX_FILE_SIZE) {
-                        return errorResponse(`Attachment too large (${Math.round(attachmentBuffer.length / 1024 / 1024)}MB). Maximum allowed: ${MAX_FILE_SIZE / 1024 / 1024}MB`);
+                    // Capped read: Content-Length can be missing or understated.
+                    try {
+                        attachmentBuffer = await readBodyCapped(response, MAX_FILE_SIZE);
+                    }
+                    catch (error) {
+                        if (error instanceof DownloadError && error.kind === "tooLarge") {
+                            return errorResponse(`Attachment too large (over ${MAX_FILE_SIZE / 1024 / 1024}MB). Maximum allowed: ${MAX_FILE_SIZE / 1024 / 1024}MB`);
+                        }
+                        throw error;
                     }
                 }
             }
@@ -201,7 +252,7 @@ export function registerGetSyllabus(server, apiClient) {
             if (download) {
                 result.download = download;
             }
-            Object.assign(result, await discoverExternalSyllabusSources(apiClient, courseId));
+            Object.assign(result, (await discoverExternalSyllabusSources(apiClient, courseId)).fields);
             return toolResponse(result);
         }
         catch (error) {

package/build/tools/get-video-transcript.js

@@ -8,11 +8,12 @@ import { GetVideoTranscriptSchema } from "./schemas.js";
 import { toolResponse, errorResponse, sanitizeError } from "./tool-helpers.js";
 import { cuesToText, paginateText } from "../utils/transcript/captions.js";
 import { detectVideoPlatform, extractKalturaIds, extractYouTubeVideoId, } from "../utils/transcript/platform.js";
-import { isBrightspaceRelativeLink, readLtiLaunchPage } from "../utils/transcript/lti.js";
+import { readLtiLaunchPage, toBrightspacePath } from "../utils/transcript/lti.js";
 import { getKalturaTranscript } from "../utils/transcript/kaltura.js";
 import { getYouTubeTranscript } from "../utils/transcript/youtube.js";
 import { NoTranscriptError, TranscriptFetchError } from "../utils/transcript/errors.js";
 import { log } from "../utils/logger.js";
+import { stripD2lSessionParams } from "../utils/session-params.js";
 const UNSUPPORTED_PLATFORM_LABEL = {
     panopto: "Panopto",
     yuja: "YuJa",
@@ -38,7 +39,7 @@ async function followLtiLaunch(apiClient, path) {
         const html = await apiClient.getPage(next);
         if (html === null)
             return null;
-        const finding = readLtiLaunchPage(html);
+        const finding = readLtiLaunchPage(html, apiClient.origin);
         if (!finding)
             return null;
         if ("videoUrl" in finding)
@@ -53,7 +54,7 @@ async function fetchTranscript(platform, videoUrl, fetchImpl) {
             const ids = extractKalturaIds(videoUrl);
             if (!ids) {
                 return {
-                    failed: `Could not find a Kaltura entry ID and partner ID in this URL: ${videoUrl}`,
+                    failed: `Could not find a Kaltura entry ID and partner ID in this URL: ${stripD2lSessionParams(videoUrl)}`,
                 };
             }
             try {
@@ -74,7 +75,7 @@ async function fetchTranscript(platform, videoUrl, fetchImpl) {
         case "youtube": {
             const videoId = extractYouTubeVideoId(videoUrl);
             if (!videoId) {
-                return { failed: `Could not find a YouTube video ID in this URL: ${videoUrl}` };
+                return { failed: `Could not find a YouTube video ID in this URL: ${stripD2lSessionParams(videoUrl)}` };
             }
             try {
                 return { result: await getYouTubeTranscript(videoId, fetchImpl) };
@@ -97,7 +98,7 @@ async function fetchTranscript(platform, videoUrl, fetchImpl) {
             };
         default:
             return {
-                unsupported: `Could not identify a supported video platform for this URL: ${videoUrl}. ` +
+                unsupported: `Could not identify a supported video platform for this URL: ${stripD2lSessionParams(videoUrl)}. ` +
                     "Open the video in Brightspace directly.",
             };
     }
@@ -134,16 +135,22 @@ export function registerGetVideoTranscript(server, apiClient, fetchImpl = fetch)
             else {
                 return errorResponse("Provide either videoUrl, or both courseId and topicId to look up the video from course content.");
             }
-            if (isBrightspaceRelativeLink(resolvedUrl)) {
-                const launchedUrl = await followLtiLaunch(apiClient, resolvedUrl);
+            // A relative /d2l/ link, or an absolute one on this Brightspace's own
+            // origin, is requested as the user; any other origin never sees the session.
+            const brightspacePath = toBrightspacePath(resolvedUrl, apiClient.origin);
+            if (brightspacePath !== null) {
+                const launchedUrl = await followLtiLaunch(apiClient, brightspacePath);
                 if (!launchedUrl) {
+                    // resolvedUrl (with any session params) was only for the
+                    // authenticated getPage above; public output gets the clean form.
+                    const publicUrl = stripD2lSessionParams(resolvedUrl);
                     return toolResponse({
                         courseId,
                         topicId,
-                        videoUrl: resolvedUrl,
+                        videoUrl: publicUrl,
                         platform: "unknown",
                         hasTranscript: false,
-                        message: `This is a Brightspace LTI link (${resolvedUrl}), and its launch did not reveal which video it opens. ` +
+                        message: `This is a Brightspace LTI link (${publicUrl}), and its launch did not reveal which video it opens. ` +
                             "Some tools only hand over the video after a browser sign-in to the tool itself, which this server " +
                             "can't do. The video platform itself may still be supported. Open it in Brightspace directly.",
                     });
@@ -152,11 +159,12 @@ export function registerGetVideoTranscript(server, apiClient, fetchImpl = fetch)
             }
             const platform = detectVideoPlatform(resolvedUrl);
             const outcome = await fetchTranscript(platform, resolvedUrl, fetchImpl);
+            const publicUrl = stripD2lSessionParams(resolvedUrl);
             if ("unsupported" in outcome) {
                 return toolResponse({
                     courseId,
                     topicId,
-                    videoUrl: resolvedUrl,
+                    videoUrl: publicUrl,
                     platform,
                     hasTranscript: false,
                     message: outcome.unsupported,
@@ -166,7 +174,7 @@ export function registerGetVideoTranscript(server, apiClient, fetchImpl = fetch)
                 return toolResponse({
                     courseId,
                     topicId,
-                    videoUrl: resolvedUrl,
+                    videoUrl: publicUrl,
                     platform,
                     hasTranscript: false,
                     message: outcome.noTranscript,
@@ -178,11 +186,11 @@ export function registerGetVideoTranscript(server, apiClient, fetchImpl = fetch)
             const { result } = outcome;
             const fullText = cuesToText(result.cues);
             const { window, truncated, nextOffset, totalChars } = paginateText(fullText, offset, maxChars);
-            log("INFO", `get_video_transcript: ${platform} transcript for ${resolvedUrl} (${result.cues.length} cues, ${totalChars} chars)`);
+            log("INFO", `get_video_transcript: ${platform} transcript for ${publicUrl} (${result.cues.length} cues, ${totalChars} chars)`);
             return toolResponse({
                 courseId,
                 topicId,
-                videoUrl: resolvedUrl,
+                videoUrl: publicUrl,
                 platform,
                 hasTranscript: true,
                 title: result.title,

package/build/tools/schemas.js

@@ -62,14 +62,16 @@ export const GetClasslistEmailsSchema = z.object({
         .describe("Course ID to get emails for."),
 });
 export const DownloadFileSchema = z.object({
+    source: z.enum(["submission", "assignmentAttachment"]).optional()
+        .describe("For folderId + fileId: assignmentAttachment downloads an instructor-provided handout from get_assignment_files; submission (default) downloads your own submitted file. Do not combine source with topicId or newsId."),
     courseId: z.coerce.number().int().positive()
         .describe("Course ID the file belongs to."),
     topicId: z.coerce.number().int().positive().optional()
         .describe("Content topic ID to download (for course content files)."),
     folderId: z.coerce.number().int().positive().optional()
-        .describe("Dropbox folder ID (for submission/feedback file downloads)."),
+        .describe("Dropbox folder ID. Downloads your submission by default; set source to assignmentAttachment for an instructor-provided handout."),
     fileId: z.coerce.number().int().positive().optional()
-        .describe("Specific file ID within a dropbox submission, or an announcement attachment's file ID (with newsId)."),
+        .describe("Specific file ID within a dropbox submission, instructor assignment attachment (with source: assignmentAttachment), or announcement attachment (with newsId)."),
     newsId: z.coerce.number().int().positive().optional()
         .describe("Announcement (news item) ID whose attachment to download. Requires fileId."),
     downloadPath: z.string().min(1).optional()

package/build/utils/download-helpers.js

@@ -4,7 +4,7 @@
  * Licensed under MIT — see LICENSE file for details.
  */
 import fs from "node:fs/promises";
-import { createWriteStream } from "node:fs";
+import { createWriteStream, constants as fsConstants } from "node:fs";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { Readable, Transform } from "node:stream";
@@ -106,7 +106,7 @@ export async function secureDownload(options) {
  * secureDownload for a response body that is streamed to disk rather than
  * held in memory, so a file's size is bounded by `maxBytes` instead of by
  * MAX_FILE_SIZE. The body is written to a hidden temporary file in targetDir,
- * type-checked there, and only then renamed to its final name; a refused or
+ * type-checked there, and only then published under its final name; a refused or
  * failed download leaves nothing behind.
  *
  * @throws DownloadError("tooLarge") once the body passes maxBytes
@@ -130,14 +130,72 @@ export async function secureStreamDownload(options) {
     try {
         await pipeline(Readable.fromWeb(body), limit, createWriteStream(partialPath, { flags: "wx" }));
         const { mime } = await validateFileTypeOfFile(partialPath, undefined, safeFilename);
-        const resolvedFilename = await resolveFilenameConflict(targetDir, safeFilename);
-        const finalPath = path.join(targetDir, resolvedFilename);
-        await fs.rename(partialPath, finalPath);
+        const finalPath = await publishExclusively(partialPath, targetDir, safeFilename);
         log("INFO", `Downloaded file to ${finalPath} (${size} bytes, ${mime})`);
         return { path: finalPath, size, mime };
     }
-    catch (error) {
+    finally {
         await fs.rm(partialPath, { force: true });
-        throw error;
     }
 }
+/**
+ * Give a finished temporary file its final name without ever replacing an
+ * existing file. resolveFilenameConflict only reports a name that was free a
+ * moment ago, and rename() overwrites, so two concurrent downloads of the same
+ * name could both pick it and the later rename silently replaced the earlier
+ * file. link() and COPYFILE_EXCL fail with EEXIST instead, and we try the next
+ * free name. The caller removes the temporary file.
+ */
+async function publishExclusively(partialPath, targetDir, filename) {
+    for (let attempt = 0; attempt <= 100; attempt++) {
+        const finalPath = path.join(targetDir, await resolveFilenameConflict(targetDir, filename));
+        try {
+            try {
+                await fs.link(partialPath, finalPath);
+            }
+            catch (error) {
+                // Some filesystems (FAT/exFAT drives, certain network shares) have no
+                // hard links; copy instead, still refusing to overwrite.
+                const code = error.code;
+                if (code !== "EPERM" && code !== "ENOTSUP" && code !== "ENOSYS")
+                    throw error;
+                await fs.copyFile(partialPath, finalPath, fsConstants.COPYFILE_EXCL);
+            }
+            return finalPath;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+    }
+    throw new Error("Could not resolve filename conflict after 100 attempts");
+}
+/**
+ * Read a response body into memory, refusing to hold more than `maxBytes`.
+ *
+ * response.arrayBuffer() buffers whatever the server sends, so a missing or
+ * understated Content-Length let an arbitrarily large body be allocated before
+ * any size check ran. This counts the bytes actually received and cancels the
+ * stream as soon as they pass the cap.
+ *
+ * @throws DownloadError("tooLarge") once the body passes maxBytes
+ */
+export async function readBodyCapped(response, maxBytes) {
+    if (!response.body)
+        return Buffer.alloc(0);
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        size += value.byteLength;
+        if (size > maxBytes) {
+            await reader.cancel().catch(() => { });
+            throw new DownloadError("tooLarge", `File exceeds ${maxBytes} bytes`);
+        }
+        chunks.push(value);
+    }
+    return Buffer.concat(chunks, size);
+}

package/build/utils/file-validator.js

@@ -3,6 +3,7 @@
  * Copyright (c) 2026 Rohan Muppa. All rights reserved.
  * Licensed under MIT — see LICENSE file for details.
  */
+import { createReadStream } from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import sanitizeFilename from "sanitize-filename";
@@ -58,6 +59,14 @@ const XML_EXTENSION_MIMES = {
  * Prevents memory exhaustion from malicious large file requests.
  */
 export const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50 MB
+/**
+ * Maximum bytes of a file a disk-mode download will save. Disk downloads
+ * stream straight to the file, so memory no longer bounds them the way
+ * MAX_FILE_SIZE bounds buffered downloads; this only stops a runaway body
+ * filling the disk. Lecture decks, recordings and submitted decks routinely
+ * pass 50 MB.
+ */
+export const DISK_MAX_FILE_SIZE = 2 * 1024 * 1024 * 1024; // 2 GB
 /**
  * Allowlist of MIME types safe for download.
  * Prevents execution of potentially malicious file types (executables, scripts).
@@ -157,8 +166,9 @@ export async function validateFileType(buffer, allowedTypes = ALLOWED_MIME_TYPES
 /**
  * validateFileType for a file already on disk, so a download streamed there
  * is never read back into memory whole. Magic bytes are read from the file
- * itself; only a file with none, the text fallback's case, is read in, and
- * only when it is within MAX_FILE_SIZE.
+ * itself; a file with none, the text fallback's case, is streamed through the
+ * same UTF-8 and NUL checks a chunk at a time, so plain text, CSV and JSON
+ * are held to the disk download limit rather than to MAX_FILE_SIZE.
  */
 export async function validateFileTypeOfFile(filePath, allowedTypes = ALLOWED_MIME_TYPES, filename) {
     const { size } = await fs.stat(filePath);
@@ -169,10 +179,7 @@ export async function validateFileTypeOfFile(filePath, allowedTypes = ALLOWED_MI
     const detected = await fileTypeFromFile(filePath);
     if (detected)
         return allowDetectedType(detected, allowedTypes, filename);
-    if (size > MAX_FILE_SIZE) {
-        throw new DownloadError("undetectableType", "Could not determine file type or type not allowed");
-    }
-    return allowTextType(await fs.readFile(filePath), allowedTypes);
+    return allowTextTypeOfFile(filePath, allowedTypes);
 }
 /** The allowlist decision for a type file-type recognised from magic bytes. */
 function allowDetectedType(detected, allowedTypes, filename) {
@@ -211,28 +218,69 @@ function allowTextType(buffer, allowedTypes) {
         catch {
             // Invalid UTF-8 — treat as binary.
         }
-        if (decoded !== null) {
-            const noBom = decoded.charCodeAt(0) === 0xfeff ? decoded.slice(1) : decoded;
-            const head = noBom.trimStart().toLowerCase();
-            let mime = "text/plain";
-            let ext = "txt";
-            if (head.startsWith("<!doctype html") || head.startsWith("<html")) {
-                mime = "text/html";
-                ext = "html";
-            }
-            else if (head.startsWith("<svg") || head.startsWith("<!doctype svg")) {
-                // An SVG without the XML prolog reaches the fallback instead of being
-                // detected. Naming it text/plain told the caller the wrong type for a
-                // file the allowlist has an entry for.
-                mime = "image/svg+xml";
-                ext = "svg";
-            }
-            if (allowedTypes.includes(mime)) {
-                return { mime, ext };
+        if (decoded !== null)
+            return allowTextHead(decoded, allowedTypes);
+    }
+    throw undetectableText();
+}
+/**
+ * allowTextType for a file on disk, read a chunk at a time so memory stays
+ * bounded however large the file is. The decoder runs in streaming mode, so a
+ * multi-byte character split across chunks is still decoded, and only enough
+ * of the leading text to sniff HTML and SVG is kept.
+ */
+async function allowTextTypeOfFile(filePath, allowedTypes) {
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    let head = "";
+    try {
+        for await (const chunk of createReadStream(filePath)) {
+            const bytes = chunk;
+            if (bytes.includes(0))
+                throw undetectableText();
+            const text = decoder.decode(bytes, { stream: true });
+            if (head.length < TEXT_HEAD_CHARS) {
+                // Leading whitespace is dropped by the sniff anyway; trimming it here
+                // keeps a file of nothing but whitespace from growing `head` unbounded.
+                head = (head + text.slice(0, TEXT_HEAD_CHARS)).trimStart();
             }
         }
+        head += decoder.decode();
+    }
+    catch (error) {
+        if (error instanceof DownloadError)
+            throw error;
+        if (error instanceof TypeError)
+            throw undetectableText(); // Invalid UTF-8.
+        throw error;
+    }
+    return allowTextHead(head, allowedTypes);
+}
+/** Enough leading characters to recognise every prefix allowTextHead tests. */
+const TEXT_HEAD_CHARS = 64;
+/** Name decoded text by its leading characters and apply the allowlist. */
+function allowTextHead(decoded, allowedTypes) {
+    const noBom = decoded.charCodeAt(0) === 0xfeff ? decoded.slice(1) : decoded;
+    const head = noBom.trimStart().toLowerCase();
+    let mime = "text/plain";
+    let ext = "txt";
+    if (head.startsWith("<!doctype html") || head.startsWith("<html")) {
+        mime = "text/html";
+        ext = "html";
+    }
+    else if (head.startsWith("<svg") || head.startsWith("<!doctype svg")) {
+        // An SVG without the XML prolog reaches the fallback instead of being
+        // detected. Naming it text/plain told the caller the wrong type for a
+        // file the allowlist has an entry for.
+        mime = "image/svg+xml";
+        ext = "svg";
     }
-    throw new DownloadError("undetectableType", "Could not determine file type or type not allowed");
+    if (allowedTypes.includes(mime)) {
+        return { mime, ext };
+    }
+    throw undetectableText();
+}
+function undetectableText() {
+    return new DownloadError("undetectableType", "Could not determine file type or type not allowed");
 }
 /**
  * Validate content ID is a positive integer.

package/build/utils/html-converter.js

@@ -4,6 +4,7 @@
  * Licensed under MIT — see LICENSE file for details.
  */
 import { createRequire } from "node:module";
+import { stripD2lSessionParams } from "./session-params.js";
 // turndown is CJS and costs ~50ms to import; defer it to first use via
 // createRequire so callers keep a synchronous API instead of turning async.
 const require = createRequire(import.meta.url);
@@ -74,7 +75,7 @@ function getTurndownService() {
                 // keep whatever text was inside it.
                 if (isUnsafeHref(href))
                     return content;
-                const cleaned = stripSessionParams(href).replace(/([()])/g, "\\$1");
+                const cleaned = stripD2lSessionParams(href).replace(/([()])/g, "\\$1");
                 const title = node.getAttribute("title");
                 const titlePart = title ? ` "${title.replace(/"/g, '\\"')}"` : "";
                 return `[${content}](${cleaned}${titlePart})`;
@@ -85,7 +86,7 @@ function getTurndownService() {
             replacement: (_content, node) => {
                 const el = node;
                 const alt = el.getAttribute("alt") ?? "";
-                const src = stripSessionParams(el.getAttribute("src") ?? "");
+                const src = stripD2lSessionParams(el.getAttribute("src") ?? "");
                 const title = el.getAttribute("title");
                 const titlePart = title ? ` "${title}"` : "";
                 return src ? `![${alt}](${src}${titlePart})` : "";
@@ -94,32 +95,6 @@ function getTurndownService() {
     }
     return turndownService;
 }
-const SESSION_QUERY_PARAMS = new Set(["d2lsessionval", "d2lsecuresessionval", "_"]);
-/**
- * Strip D2L's per-session query params (`d2lSessionVal`, `d2lSecureSessionVal`,
- * and the `_` cache-buster) from a URL. Everything else about the URL --
- * scheme, path, other params -- is left untouched, including a relative href,
- * which is returned as-is apart from this filtering.
- */
-function stripSessionParams(url) {
-    const queryStart = url.indexOf("?");
-    if (queryStart < 0)
-        return url;
-    const earlyHash = url.indexOf("#");
-    if (earlyHash >= 0 && earlyHash < queryStart) {
-        // The "?" falls inside the fragment (e.g. "#frag?x=1"), not a real query
-        // string -- nothing to strip, and treating it as one would mangle the
-        // fragment.
-        return url;
-    }
-    const hashStart = url.indexOf("#", queryStart);
-    const query = url.slice(queryStart + 1, hashStart < 0 ? undefined : hashStart);
-    const hash = hashStart < 0 ? "" : url.slice(hashStart);
-    const kept = query
-        .split("&")
-        .filter((param) => param !== "" && !SESSION_QUERY_PARAMS.has(param.split("=")[0].toLowerCase()));
-    return url.slice(0, queryStart) + (kept.length > 0 ? `?${kept.join("&")}` : "") + hash;
-}
 /** True for `javascript:`/`data:` hrefs -- never a legitimate content link. */
 function isUnsafeHref(href) {
     return /^\s*(javascript|data):/i.test(href);

package/build/utils/session-params.js

@@ -0,0 +1,34 @@
+/**
+ * Purdue Brightspace MCP Server
+ * Copyright (c) 2026 Rohan Muppa. All rights reserved.
+ * Licensed under MIT — see LICENSE file for details.
+ */
+/** D2L's per-session query params, matched case-insensitively by name. */
+const SESSION_QUERY_PARAMS = new Set(["d2lsessionval", "d2lsecuresessionval", "_"]);
+/**
+ * Strip D2L's per-session query params (`d2lSessionVal`, `d2lSecureSessionVal`,
+ * and the `_` cache-buster) from a URL before it is shown to the model or user.
+ * Everything else about the URL -- scheme, path, routing params such as
+ * `ou`/`type`/`rcode`, the fragment -- is left untouched, and a relative URL
+ * stays relative. Use the original URL for any authenticated request; this is
+ * only for public output.
+ */
+export function stripD2lSessionParams(url) {
+    const queryStart = url.indexOf("?");
+    if (queryStart < 0)
+        return url;
+    const earlyHash = url.indexOf("#");
+    if (earlyHash >= 0 && earlyHash < queryStart) {
+        // The "?" falls inside the fragment (e.g. "#frag?x=1"), not a real query
+        // string -- nothing to strip, and treating it as one would mangle the
+        // fragment.
+        return url;
+    }
+    const hashStart = url.indexOf("#", queryStart);
+    const query = url.slice(queryStart + 1, hashStart < 0 ? undefined : hashStart);
+    const hash = hashStart < 0 ? "" : url.slice(hashStart);
+    const kept = query
+        .split("&")
+        .filter((param) => param !== "" && !SESSION_QUERY_PARAMS.has(param.split("=")[0].toLowerCase()));
+    return url.slice(0, queryStart) + (kept.length > 0 ? `?${kept.join("&")}` : "") + hash;
+}

package/build/utils/transcript/lti.js

@@ -16,6 +16,40 @@ import { detectVideoPlatform, extractKalturaIds, extractYouTubeVideoId } from ".
 export function isBrightspaceRelativeLink(url) {
     return url.startsWith("/d2l/");
 }
+/**
+ * The path and query of a link into the user's own Brightspace, or null for
+ * anything else. A relative `/d2l/` link qualifies, and so does an absolute
+ * URL whose origin is exactly the configured Brightspace origin and whose
+ * path starts with `/d2l/`, so both take the same authenticated route. A URL
+ * on any other origin (a lookalike host, an http: downgrade, a different
+ * port, a protocol-relative `//host/...`, or one carrying userinfo) is never
+ * a Brightspace link: the session must not travel there.
+ */
+export function toBrightspacePath(url, origin) {
+    const trimmed = url.trim();
+    let expectedOrigin;
+    try {
+        expectedOrigin = new URL(origin ?? "https://brightspace.invalid").origin;
+    }
+    catch {
+        return null;
+    }
+    const relative = isBrightspaceRelativeLink(trimmed);
+    if (!relative && (!origin || !/^https?:\/\//i.test(trimmed)))
+        return null;
+    let parsed;
+    try {
+        parsed = new URL(trimmed, expectedOrigin);
+    }
+    catch {
+        return null;
+    }
+    if (parsed.origin !== expectedOrigin || parsed.username || parsed.password)
+        return null;
+    if (!parsed.pathname.startsWith("/d2l/"))
+        return null;
+    return `${parsed.pathname}${parsed.search}`;
+}
 function decodeEntities(value) {
     return value
         .replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCodePoint(parseInt(hex, 16)))
@@ -68,7 +102,13 @@ function asVideoUrl(candidate, consumerKey) {
     withPartner.searchParams.set("wid", `_${consumerKey}`);
     return namesVideo(withPartner.href) ? withPartner.href : null;
 }
-export function readLtiLaunchPage(html) {
+/**
+ * Read an LTI launch page for the video it opens, or for the one Brightspace
+ * page it frames. Pass the Brightspace `origin` so an absolute link back into
+ * the same Brightspace counts as a page to follow; without it only relative
+ * `/d2l/` links do.
+ */
+export function readLtiLaunchPage(html, origin) {
     const inputs = tagAttributes(html, "input");
     const consumerKey = inputs.find(input => input.get("name") === "oauth_consumer_key")?.get("value");
     const candidates = [
@@ -81,6 +121,10 @@ export function readLtiLaunchPage(html) {
         if (videoUrl)
             return { videoUrl };
     }
-    const nextPath = candidates.find(isBrightspaceRelativeLink);
-    return nextPath ? { nextPath } : null;
+    for (const candidate of candidates) {
+        const nextPath = toBrightspacePath(candidate, origin);
+        if (nextPath)
+            return { nextPath };
+    }
+    return null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brightspace-mcp-server",
-  "version": "3.11.3",
+  "version": "3.11.5",
   "mcpName": "io.github.RohanMuppa/brightspace",
   "description": "MCP server for Brightspace (D2L). Check grades, due dates, assignments, announcements, syllabus, rosters and more via Claude, ChatGPT, Cursor, Windsurf, or any MCP client.",
   "type": "module",