brightspace-mcp-server 3.4.0 → 3.5.0

package/build/tools/get-course-content.js

@@ -50,12 +50,22 @@ async function buildContentTree(apiClient, courseId, modules, progressMap, typeF
             // Module: fetch children recursively (unless the depth limit is reached)
             let processedChildren = [];
             if (currentDepth < depthLimit) {
-                let children = [];
+                // The parent listing already embeds this module's immediate children
+                // in Structure. The dedicated endpoint is still asked first because it
+                // is the authoritative copy, but a module whose structure call fails —
+                // or answers with something that is not an array — must fall back to
+                // what the parent already handed us. Falling through to an empty list
+                // made a locked or erroring module look like an empty one, and under a
+                // typeFilter it dropped the module from the tree with no trace.
+                let children = null;
                 try {
                     children = await apiClient.get(apiClient.le(courseId, `/content/modules/${item.Id}/structure/`), { ttl: DEFAULT_CACHE_TTLS.courseContent });
                 }
                 catch (e) {
-                    log('DEBUG', `Failed to fetch children for module ${item.Id}: skipping`);
+                    log('DEBUG', `Failed to fetch children for module ${item.Id}: falling back to the embedded structure`);
+                }
+                if (!Array.isArray(children)) {
+                    children = Array.isArray(item.Structure) ? item.Structure : [];
                 }
                 processedChildren = await buildContentTree(apiClient, courseId, children, progressMap, typeFilter, maxDepth, currentDepth + 1);
             }

package/build/tools/get-my-grades.js

@@ -4,6 +4,7 @@
  * Licensed under MIT — see LICENSE file for details.
  */
 import { DEFAULT_CACHE_TTLS } from "../api/index.js";
+import { fetchAllItems } from "../api/paginate.js";
 import { GetMyGradesSchema, } from "./schemas.js";
 import { toolResponse, sanitizeError } from "./tool-helpers.js";
 import { log } from "../utils/logger.js";
@@ -42,11 +43,16 @@ export function registerGetMyGrades(server, apiClient, config) {
                 return toolResponse({ courseId, grades });
             }
             // All courses case
-            // First, fetch enrolled courses
-            const enrollmentPath = apiClient.lp("/enrollments/myenrollments/?orgUnitTypeId=3&isActive=true");
-            const enrollmentResponse = await apiClient.get(enrollmentPath, { ttl: DEFAULT_CACHE_TTLS.enrollments });
+            // First, fetch enrolled courses. isActive=true has to track the
+            // configured policy rather than being pinned on: a user who set
+            // activeOnly:false is asking to see archived courses, and a query that
+            // withholds them leaves applyCourseFilter nothing to let through.
+            const enrollmentPath = apiClient.lp(`/enrollments/myenrollments/?orgUnitTypeId=3${config.courseFilter.activeOnly ? "&isActive=true" : ""}`);
+            // Enrollments arrive one page at a time; follow the bookmark chain so a
+            // long enrollment history does not silently lose its later courses.
+            const enrollmentItems = await fetchAllItems(apiClient, enrollmentPath, { ttl: DEFAULT_CACHE_TTLS.enrollments });
             // Apply course filter
-            const filteredEnrollments = applyCourseFilter(enrollmentResponse.Items.map(item => ({
+            const filteredEnrollments = applyCourseFilter(enrollmentItems.map(item => ({
                 id: item.OrgUnit.Id,
                 name: item.OrgUnit.Name,
                 code: item.OrgUnit.Code,
@@ -90,7 +96,7 @@ export function registerGetMyGrades(server, apiClient, config) {
             const courses = results
                 .filter((r) => r.status === "fulfilled" && r.value !== null)
                 .map((r) => r.value);
-            log("INFO", `get_my_grades: Retrieved grades for ${courses.length} courses (out of ${enrollmentResponse.Items.length} enrolled)`);
+            log("INFO", `get_my_grades: Retrieved grades for ${courses.length} courses (out of ${enrollmentItems.length} enrolled)`);
             return toolResponse({ courses });
         }
         catch (error) {

package/build/tools/get-upcoming-due-dates.js

@@ -4,6 +4,7 @@
  * Licensed under MIT — see LICENSE file for details.
  */
 import { DEFAULT_CACHE_TTLS } from "../api/index.js";
+import { fetchAllItems } from "../api/paginate.js";
 import { GetUpcomingDueDatesSchema, } from "./schemas.js";
 import { toolResponse, sanitizeError } from "./tool-helpers.js";
 import { log } from "../utils/logger.js";
@@ -22,8 +23,13 @@ function unwrapList(raw) {
 async function resolveCourses(apiClient, config, courseId) {
     let items = [];
     try {
-        const response = await apiClient.get(apiClient.lp("/enrollments/myenrollments/?orgUnitTypeId=3&isActive=true"), { ttl: DEFAULT_CACHE_TTLS.enrollments });
-        items = response.Items ?? [];
+        // isActive=true tracks the configured policy rather than being pinned on:
+        // a user who set activeOnly:false is asking to see archived courses, and a
+        // query that withholds them leaves applyCourseFilter nothing to let
+        // through. Enrollments are paged, so follow the bookmark chain — a long
+        // enrollment history would otherwise lose every course past the first page,
+        // and every deadline in those courses with it.
+        items = await fetchAllItems(apiClient, apiClient.lp(`/enrollments/myenrollments/?orgUnitTypeId=3${config.courseFilter.activeOnly ? "&isActive=true" : ""}`), { ttl: DEFAULT_CACHE_TTLS.enrollments });
     }
     catch (error) {
         // Without enrollments there is no course list to walk, so only the explicit
@@ -48,14 +54,18 @@ async function resolveCourses(apiClient, config, courseId) {
 /**
  * Collect every graded, dated discussion topic for one course.
  *
- * Forums carry no due date themselves; it lives on each topic. A forum whose
- * topics fail to load (e.g. no access) is skipped rather than failing the
- * whole course, matching `getForumsOverview` in get-discussions.ts.
+ * Forums carry no due date themselves; it lives on each topic. A hidden forum
+ * hides everything inside it, however visible its topics claim to be, so it is
+ * skipped without asking for its topics at all. A forum whose topics fail to
+ * load (e.g. no access) is skipped rather than failing the whole course,
+ * matching `getForumsOverview` in get-discussions.ts.
  */
 async function fetchDiscussionDueTopics(apiClient, courseId) {
     const forums = await apiClient.get(apiClient.le(courseId, "/discussions/forums/"), { ttl: DEFAULT_CACHE_TTLS.assignments });
     const topics = [];
     for (const forum of unwrapList(forums)) {
+        if (forum.IsHidden === true)
+            continue;
         try {
             const forumTopics = await apiClient.get(apiClient.le(courseId, `/discussions/forums/${forum.ForumId}/topics/`), { ttl: DEFAULT_CACHE_TTLS.assignments });
             topics.push(...unwrapList(forumTopics));

package/build/tools/tool-helpers.js

@@ -59,19 +59,20 @@ export function errorResponse(message) {
 const AUTH_FAILURE_GUIDANCE = {
     busy: "A sign-in is already running in another process. Let it finish, then try again.",
     cooldown: "Automatic sign-in is paused because an MFA prompt went unanswered. " +
-        `Run \`${AUTH_COMMAND}\` in a terminal to retry now and see the number to enter.`,
+        `Run \`${AUTH_COMMAND}\` in a terminal (from your home folder) to retry now and see the number to enter.`,
     unsupported: "This login needs something your AI client cannot supply, usually a code from an "
         + "authenticator app. " +
-        `Run \`${AUTH_COMMAND}\` in a terminal and sign in there.`,
+        `Run \`${AUTH_COMMAND}\` in a terminal (from your home folder) and sign in there.`,
     secureStorage: "The operating system credential store is locked or unavailable, so the saved " +
         "password could not be read. Unlock your keychain or keyring, then try again.",
     transport: "Brightspace could not be reached to sign in. The saved session was kept. " +
         "Check your connection and try again in a few minutes.",
     timeout: "The sign-in did not finish in time, usually a missed MFA prompt. " +
-        `Run \`${AUTH_COMMAND}\` in a terminal to complete it with the number visible.`,
-    failed: `The sign-in did not complete. Run \`${AUTH_COMMAND}\` in a terminal to see why, ` +
+        `Run \`${AUTH_COMMAND}\` in a terminal (from your home folder) to complete it with the number visible.`,
+    failed: `The sign-in did not complete. Run \`${AUTH_COMMAND}\` in a terminal (from your home folder) to see why, ` +
         "or `brightspace-setup` if your saved school or username is wrong.",
-    mfaPending: "A Microsoft Authenticator approval was not completed in time. Try again.",
+    mfaPending: "Approve the sign-in request on your phone (Microsoft Authenticator or Duo), " +
+        "then call this tool again — the sign-in is finishing in the background.",
 };
 /**
  * mfaPending is the one kind whose guidance is partly dynamic: `numberMatch`
@@ -82,7 +83,8 @@ const AUTH_FAILURE_GUIDANCE = {
  */
 function authFailureMessage(error) {
     if (error.kind === "mfaPending" && error.numberMatch) {
-        return `Open Microsoft Authenticator and enter ${error.numberMatch} within 5 minutes, then run this again.`;
+        return `Open Microsoft Authenticator and enter ${error.numberMatch} within 5 minutes, ` +
+            "then call this tool again — the sign-in is finishing in the background.";
     }
     return AUTH_FAILURE_GUIDANCE[error.kind];
 }

package/build/update.js

@@ -7,8 +7,8 @@
  * https://github.com/rohanmuppa/brightspace-mcp-server
  */
 import { execSync } from "node:child_process";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { readFileSync, realpathSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import dotenv from "dotenv";
 dotenv.config({ quiet: true });
@@ -36,18 +36,46 @@ function getVersion() {
     const pkg = JSON.parse(readFileSync(join(projectRoot, "package.json"), "utf-8"));
     return pkg.version || "unknown";
 }
-function main() {
+/** Compare two directories as the filesystem sees them. */
+export function samePath(a, b) {
+    const canonical = (p) => {
+        let full = resolve(p);
+        try {
+            full = realpathSync(full);
+        }
+        catch {
+            // A path that cannot be resolved is compared as written.
+        }
+        return process.platform === "win32" ? full.toLowerCase() : full;
+    };
+    return canonical(a) === canonical(b);
+}
+export function main() {
     console.log("");
     console.log(bold("=== Brightspace MCP Server — Update ==="));
     console.log("");
     // Check if we're in a git repo
+    let toplevel;
     try {
-        run("git rev-parse --is-inside-work-tree", { silent: true });
+        toplevel = run("git rev-parse --show-toplevel", { silent: true });
     }
     catch {
         console.error(red("Error: Not a git repository. Cannot update."));
         console.error("Make sure you cloned this project with git.");
         process.exit(1);
+        return;
+    }
+    // Git answers for the nearest enclosing repository, which for an installed
+    // copy under node_modules is the *user's own* project. Fetching and pulling
+    // origin/main there would rewrite a repository that has nothing to do with
+    // this package, so only a checkout that is itself the repository root is
+    // updated.
+    if (!samePath(toplevel, projectRoot)) {
+        console.error(red("Error: This copy is not a git checkout of brightspace-mcp-server."));
+        console.error(`  It lives in ${projectRoot}, inside the repository at ${toplevel}.`);
+        console.error("  Update an installed copy with npm instead; this command is for a git clone.");
+        process.exit(1);
+        return;
     }
     // Show current version
     const currentVersion = getVersion();
@@ -126,4 +154,9 @@ function main() {
     console.log("  Restart your MCP client to use the latest version.");
     console.log("");
 }
-main();
+// `npm run update` runs this file directly. VITEST is set only by the test
+// runner, which imports the module to exercise main() against a stubbed git;
+// no user environment sets it.
+if (!process.env.VITEST) {
+    main();
+}

package/build/utils/atomic-write.js

@@ -9,12 +9,15 @@ import * as fsSync from "node:fs";
 /**
  * Write a file so that a reader never sees a half-written one.
  *
- * The content is staged to a sibling temp file and then renamed over the
- * target. Rename is atomic on the same filesystem, so a crash, a signal, or
+ * The content is staged to a sibling temp file, flushed, and then renamed over
+ * the target. Rename is atomic on the same filesystem, so a crash, a signal, or
  * a second writer mid-way leaves either the old file or the new one, never a
  * truncated mix. The session store and the config store both hold secrets
  * and are both written by more than one process, which is why they use this.
  *
+ * A staging write that fails takes its temp file with it: the names are random,
+ * so an orphan is never reused and would sit next to the secret it half-wrote.
+ *
  * On Windows a rename can fail transiently while antivirus or an indexer
  * holds the target open, so those errors are retried a few times.
  */
@@ -31,12 +34,22 @@ function isTransient(error) {
 export async function writeFileAtomic(target, data, options = {}) {
     const { mode, renameImpl = (from, to) => fs.rename(from, to), sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), } = options;
     const tmp = tempPathFor(target);
-    await fs.writeFile(tmp, data, mode === undefined ? {} : { mode });
-    // writeFile's mode is subject to the umask; chmod is not.
-    if (mode !== undefined && process.platform !== "win32") {
-        await fs.chmod(tmp, mode);
-    }
     try {
+        const handle = await fs.open(tmp, "wx", mode);
+        try {
+            await handle.writeFile(data);
+            // open's mode is subject to the umask; chmod is not.
+            if (mode !== undefined && process.platform !== "win32") {
+                await handle.chmod(mode);
+            }
+            // Flush before the rename. A rename that reaches disk ahead of the bytes
+            // it points at leaves a truncated file, which is the one outcome this
+            // module exists to rule out.
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
         for (let attempt = 1;; attempt++) {
             try {
                 await renameImpl(tmp, target);
@@ -58,11 +71,18 @@ export async function writeFileAtomic(target, data, options = {}) {
 export function writeFileAtomicSync(target, data, options = {}) {
     const { mode } = options;
     const tmp = tempPathFor(target);
-    fsSync.writeFileSync(tmp, data, mode === undefined ? {} : { mode });
-    if (mode !== undefined && process.platform !== "win32") {
-        fsSync.chmodSync(tmp, mode);
-    }
     try {
+        const fd = fsSync.openSync(tmp, "wx", mode);
+        try {
+            fsSync.writeFileSync(fd, data);
+            if (mode !== undefined && process.platform !== "win32") {
+                fsSync.fchmodSync(fd, mode);
+            }
+            fsSync.fsyncSync(fd);
+        }
+        finally {
+            fsSync.closeSync(fd);
+        }
         for (let attempt = 1;; attempt++) {
             try {
                 fsSync.renameSync(tmp, target);
@@ -77,7 +97,13 @@ export function writeFileAtomicSync(target, data, options = {}) {
         }
     }
     catch (error) {
-        fsSync.rmSync(tmp, { force: true });
+        // Cleanup must not replace the failure the caller needs to see.
+        try {
+            fsSync.rmSync(tmp, { force: true });
+        }
+        catch {
+            // The temp file outliving a failed write is the lesser problem.
+        }
         throw error;
     }
 }

package/build/utils/deep-links.js

@@ -6,8 +6,16 @@
 /**
  * Deep links into the Brightspace web UI.
  *
- * The templates were harvested from live Brightspace markup: they are the same
- * URLs the course pages themselves link to, so they open the item directly.
+ * The dropbox, quiz and gradebook templates were harvested from live
+ * Brightspace markup: they are the same URLs the course pages themselves link
+ * to, so they open the item directly.
+ *
+ * `discussionUrl` was NOT -- it was written from the shape of the others
+ * without live markup to check it against, and no one has confirmed it against
+ * a real tenant since. Treat it as unverified: if a student reports that a
+ * discussion link lands on the wrong page or a "not found", harvest the real
+ * URL from a course's own discussion list and fix the template here rather
+ * than assuming this one is right.
  */
 /** Drop trailing slashes so the templates below join cleanly. */
 function trimBaseUrl(baseUrl) {
@@ -28,7 +36,13 @@ export function quizUrl(baseUrl, courseId, quizId) {
 export function gradebookUrl(baseUrl, courseId) {
     return `${trimBaseUrl(baseUrl)}/d2l/lms/grades/my_grades/main.d2l?ou=${courseId}`;
 }
-/** Link to the thread list of a discussion topic. */
+/**
+ * Link to the thread list of a discussion topic.
+ *
+ * Unverified against a live tenant -- see the note at the top of this file.
+ * The topic's forum id is available at every call site, so if the real
+ * template turns out to need one, it can be threaded through.
+ */
 export function discussionUrl(baseUrl, courseId, topicId) {
     return `${trimBaseUrl(baseUrl)}/d2l/lms/discussions/threadlist.d2l?ou=${courseId}&tId=${topicId}`;
 }

package/build/utils/download-helpers.js

@@ -71,15 +71,21 @@ export async function secureDownload(options) {
         throw new Error(`File size (${size} bytes) exceeds maximum allowed (${MAX_FILE_SIZE} bytes)`);
     }
     log("DEBUG", `secureDownload: file size ${size} bytes (within limit)`);
+    // Validate download path (prevent path traversal) and keep the name it
+    // sanitized. validateDownloadPath used to be called for its throw alone while
+    // the write below still used the raw filename, so a Brightspace-supplied
+    // "../../name.pdf" resolved cleanly through validation and was then written
+    // two directories above targetDir. Everything past this point — type
+    // detection included — uses the name the file actually gets on disk.
+    const validatedPath = validateDownloadPath(targetDir, filename);
+    const safeFilename = path.basename(validatedPath);
+    log("DEBUG", `secureDownload: path validated as ${validatedPath}`);
     // Validate file type via magic bytes
     // The filename decides which legacy Office format a CFB container is.
-    const { mime } = await validateFileType(data, allowedTypes, filename);
+    const { mime } = await validateFileType(data, allowedTypes, safeFilename);
     log("DEBUG", `secureDownload: file type validated as ${mime}`);
-    // Validate download path (prevent path traversal)
-    const validatedPath = validateDownloadPath(targetDir, filename);
-    log("DEBUG", `secureDownload: path validated as ${validatedPath}`);
     // Resolve filename conflicts
-    const resolvedFilename = await resolveFilenameConflict(targetDir, filename);
+    const resolvedFilename = await resolveFilenameConflict(targetDir, safeFilename);
     const finalPath = path.join(targetDir, resolvedFilename);
     log("DEBUG", `secureDownload: resolved filename to ${resolvedFilename}`);
     // Write file to disk

package/build/utils/file-validator.js

@@ -38,6 +38,20 @@ const CFB_EXTENSION_MIMES = {
     ".pot": "application/vnd.ms-powerpoint",
     ".pps": "application/vnd.ms-powerpoint",
 };
+/**
+ * The same dead-allowlist-entry problem as CFB, one format over.
+ *
+ * file-type has no SVG detector: an SVG carrying the usual `<?xml ...?>`
+ * prolog is reported as application/xml, which is not in the allowlist, so
+ * every ordinary .svg download failed and the image/svg+xml entry below was
+ * unreachable. Reconcile against the declared extension exactly as CFB does --
+ * that admits only the format the allowlist already intended and still refuses
+ * every other flavour of XML.
+ */
+const XML_MIME = "application/xml";
+const XML_EXTENSION_MIMES = {
+    ".svg": "image/svg+xml",
+};
 /**
  * Maximum file size for downloads (50 MB).
  * Prevents memory exhaustion from malicious large file requests.
@@ -120,10 +134,26 @@ export function validateDownloadPath(baseDir, filename) {
  * @throws Error if file type not allowed
  */
 export async function validateFileType(buffer, allowedTypes = ALLOWED_MIME_TYPES, filename) {
+    // An empty body is not a text file. It reaches here when a fetch was
+    // truncated or the server answered with nothing, and the UTF-8 fallback
+    // below would otherwise wave it through as text/plain and write a zero-byte
+    // file to disk under whatever name the download was given.
+    if (buffer.length === 0) {
+        throw new DownloadError("undetectableType", "File is empty (0 bytes)");
+    }
     // Try magic byte detection first
     const fileTypeFromBuffer = await getFileTypeFromBuffer();
     const detected = await fileTypeFromBuffer(buffer);
     if (detected) {
+        if (detected.mime === XML_MIME) {
+            const ext = filename ? path.extname(filename).toLowerCase() : "";
+            const resolved = XML_EXTENSION_MIMES[ext];
+            if (resolved && allowedTypes.includes(resolved)) {
+                return { mime: resolved, ext: ext.slice(1) };
+            }
+            // Anything else falls through to the allowlist check, which refuses
+            // application/xml the way it always has.
+        }
         if (detected.mime === CFB_MIME) {
             const ext = filename ? path.extname(filename).toLowerCase() : "";
             const resolved = CFB_EXTENSION_MIMES[ext];
@@ -150,9 +180,19 @@ export async function validateFileType(buffer, allowedTypes = ALLOWED_MIME_TYPES
         if (decoded !== null) {
             const noBom = decoded.charCodeAt(0) === 0xfeff ? decoded.slice(1) : decoded;
             const head = noBom.trimStart().toLowerCase();
-            const isHtml = head.startsWith("<!doctype html") || head.startsWith("<html");
-            const mime = isHtml ? "text/html" : "text/plain";
-            const ext = isHtml ? "html" : "txt";
+            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 };
             }
@@ -178,15 +218,41 @@ export function validateContentId(id) {
     return id;
 }
 /**
- * Validate URL starts with expected D2L base URL.
+ * Validate a URL belongs to the expected D2L origin.
  * Prevents SSRF attacks via user-controlled URLs.
  *
+ * A plain string prefix test is not enough: "https://purdue.brightspace.com"
+ * is a prefix of "https://purdue.brightspace.com.attacker.example/steal", so
+ * an attacker registering a hostname that starts with the school's own passes
+ * it. Compare parsed origins instead, and require any expected path prefix to
+ * end on a "/" so /d2lXXX cannot satisfy a prefix of /d2l.
+ *
  * @param url - URL to validate
  * @param expectedBaseUrl - Expected D2L base URL (e.g., "https://purdue.brightspace.com")
  * @throws Error if URL doesn't match expected base
  */
 export function validateBaseUrl(url, expectedBaseUrl) {
-    if (!url.startsWith(expectedBaseUrl)) {
+    const reject = () => {
         throw new Error(`URL must start with ${expectedBaseUrl}, got: ${url.substring(0, 50)}...`);
+    };
+    let target;
+    let expected;
+    try {
+        target = new URL(url);
+        expected = new URL(expectedBaseUrl);
+    }
+    catch {
+        return reject();
+    }
+    // Opaque origins serialize to "null", so two unrelated file: or data: URLs
+    // would compare equal. Only a real, comparable origin counts.
+    if (target.origin === "null" || target.origin !== expected.origin) {
+        return reject();
+    }
+    const basePath = expected.pathname.replace(/\/+$/, "");
+    if (basePath &&
+        target.pathname !== basePath &&
+        !target.pathname.startsWith(`${basePath}/`)) {
+        return reject();
     }
 }

package/build/utils/html-converter.js

@@ -15,9 +15,75 @@ function getTurndownService() {
             headingStyle: "atx",
             codeBlockStyle: "fenced",
         });
+        // Turndown has no rule for <script>, <style> or <noscript>, so it falls
+        // back to emitting their text: a D2L description carrying an inline
+        // stylesheet or an analytics snippet put raw CSS and JavaScript source
+        // into the markdown the model reads. None of it is content.
+        turndownService.remove(["script", "style", "noscript"]);
+        // Turndown has no table rules either, and its fallback treats every cell
+        // as a standalone block -- a syllabus grading table came out as a flat
+        // run of paragraphs ("Homework", "30%", "Exams", "70%") with nothing
+        // left to say which weight belonged to which item. Emit GFM pipe tables
+        // so the pairing survives into the markdown a model is asked to read.
+        // Rules are registered once here (not at module scope) because the
+        // service itself is now lazily constructed on first use.
+        turndownService.addRule("tableCell", {
+            filter: ["th", "td"],
+            replacement: (content) => ` ${cellText(content)} |`,
+        });
+        turndownService.addRule("tableRow", {
+            filter: "tr",
+            replacement: (content, node) => {
+                const row = `|${content}`;
+                const table = closestTable(node);
+                const rows = table
+                    ? Array.from(table.querySelectorAll("tr")).filter((candidate) => closestTable(candidate) === table)
+                    : [];
+                // GFM needs a delimiter line after the first row, header row or not:
+                // without one the whole block renders as a paragraph and the
+                // columns are lost again.
+                if (rows.length > 0 && rows[0] === node) {
+                    const columns = cellsOf(node).length || 1;
+                    return `\n${row}\n|${" --- |".repeat(columns)}`;
+                }
+                return `\n${row}`;
+            },
+        });
+        turndownService.addRule("tableSection", {
+            filter: ["thead", "tbody", "tfoot"],
+            replacement: (content) => content,
+        });
+        turndownService.addRule("table", {
+            filter: "table",
+            replacement: (content) => {
+                const body = content.trim();
+                return body ? `\n\n${body}\n\n` : "";
+            },
+        });
     }
     return turndownService;
 }
+/** A cell's text, flattened so one table cell stays one table cell. */
+function cellText(content) {
+    return content
+        .replace(/\|/g, "\\|")
+        .replace(/\s*\n+\s*/g, " ")
+        .trim();
+}
+/** The nearest enclosing <table>, so a nested table is scoped to itself. */
+function closestTable(node) {
+    let current = node.parentNode;
+    while (current) {
+        if (current.nodeName === "TABLE")
+            return current;
+        current = current.parentNode;
+    }
+    return null;
+}
+/** Direct <th>/<td> children of a row. */
+function cellsOf(row) {
+    return Array.from(row.childNodes).filter((child) => child.nodeName === "TH" || child.nodeName === "TD");
+}
 /**
  * Convert D2L HTML content to clean markdown.
  * Returns both markdown (for LLM readability) and raw HTML (for fallback).

package/build/utils/logger.js

@@ -19,16 +19,32 @@ export function setLogLevel(level) {
  *
  * Deliberately no blanket uppercase or base32 rule: it would eat course codes
  * like ECE264, which are exactly what a useful log line contains.
+ *
+ * Order matters: the JSON-shaped rules run before the free-text ones, so a
+ * serialized object is redacted by key and the looser rules never see the
+ * value they would otherwise re-match across the quoting.
  */
 function redact(value) {
     // JSON web tokens, wherever they appear
     value = value.replace(/eyJ[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]*)?/g, "eyJ...REDACTED");
     // Redact Bearer tokens
     value = value.replace(/Bearer\s+([A-Za-z0-9._~+/=-]{8})[A-Za-z0-9._~+/=-]*/g, "Bearer $1...REDACTED");
-    // Redact cookie: prefixed tokens
-    value = value.replace(/cookie:([^\s]{8})[^\s]*/g, "cookie:$1...REDACTED");
-    // JSON-serialized header fields: {"Authorization":"..."}, {"Cookie":"..."}
+    // JSON-serialized header fields: {"Authorization":"..."}, {"Cookie":"..."}.
+    // Runs before the raw-header rule below so a serialized object is redacted
+    // as JSON and the raw-header rule cannot then chew through the quoting.
     value = value.replace(/("(?:authorization|cookie|set-cookie)"\s*:\s*")[^"]*(")/gi, "$1...REDACTED$2");
+    // JSON-serialized secret fields: {"password":"..."}, {"accessToken":"..."},
+    // {"refresh_token":"..."}, {"xsrfToken":"..."}. Only string values match, so
+    // a numeric field like "tokenExpiry": 1750000000 is left readable.
+    value = value.replace(/("[^"]*(?:password|passwd|secret|token|credential|api[_-]?key)[^"]*"\s*:\s*")[^"]*(")/gi, "$1...REDACTED$2");
+    // Raw header lines: "Cookie: d2lSessionVal=..." / "Set-Cookie: ...".
+    // The whole remainder of the line goes, because a cookie header carries
+    // every cookie for the host, not just the first pair. Case-insensitive and
+    // tolerant of the space HTTP actually puts after the colon -- without both,
+    // this rule only ever fired on a form no real header takes.
+    value = value.replace(/(^|[\s{[(,;])((?:set-)?cookie)\s*:[ \t]*([^\r\n]+)/gi, (_match, prefix, name, secret) => `${prefix}${name}: ${secret.slice(0, 8)}...REDACTED`);
+    // password=... / secret=... in a query string, form body, or free text.
+    value = value.replace(/\b(password|passwd|secret|api[_-]?key|access[_-]?token|refresh[_-]?token)\b(\s*[=:]\s*)(?:"[^"]*"|'[^']*'|[^\s&;,"']+)/gi, (_match, key, separator) => `${key}${separator}...REDACTED`);
     // Credentials embedded in a URL: scheme://user:pass@host
     value = value.replace(/(\b[a-z][a-z0-9+.-]*:\/\/)[^\s/:@]+:[^\s/@]+@/gi, "$1***:***@");
     // Redact anything that looks like a long token (40+ chars of base64-like)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brightspace-mcp-server",
-  "version": "3.4.0",
+  "version": "3.5.0",
   "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",