brightspace-mcp-server 5.1.33 → 5.1.36

package/build/auth/auth-runner.js

@@ -225,7 +225,7 @@ function descendantPids(parentPid) {
 function forceStop(pid) {
     if (process.platform === "win32") {
         try {
-            execFileSync("taskkill", ["/pid", String(pid), "/t", "/f"], { stdio: "ignore", timeout: 5000 });
+            execFileSync("taskkill", ["/pid", String(pid), "/t", "/f"], { stdio: "ignore", timeout: 5000, windowsHide: true });
         }
         catch { /* Already exited. */ }
         return;
@@ -900,7 +900,7 @@ export class AuthRunner {
                 try {
                     if (child.pid && process.platform === "win32") {
                         execFileSync("taskkill", ["/pid", String(child.pid), "/t", "/f"], {
-                            stdio: "ignore", timeout: 5000,
+                            stdio: "ignore", timeout: 5000, windowsHide: true,
                         });
                     }
                     else if (child.pid) {

package/build/auth/session-store.js

@@ -10,7 +10,7 @@ import * as os from "node:os";
 import { SessionStoreError } from "../utils/errors.js";
 import { acquireProcessLock, AuthenticationInProgressError } from "./auth-lock.js";
 import { hasSessionEncryptionKey, NativeCredentialStoreError } from "./credential-store.js";
-import { decrypt, readEncryptedRecord, saveEncryptedRecord, trashFile } from "./encrypted-store.js";
+import { decrypt, readEncryptedRecord, saveEncryptedRecord } from "./encrypted-store.js";
 const DEFAULT_SESSION_DIR = path.join(os.homedir(), ".d2l-session");
 /** The saved access token, relative to its session directory. */
 export const SESSION_FILE = "session.json";
@@ -223,6 +223,11 @@ export class SessionStore {
             this.storeError("load", error);
         }
     }
+    /**
+     * Delete the saved session once it reads back. Not moved to Trash: nothing
+     * restores a session, and on Windows Trash's console helper opens a terminal
+     * window from the shared runtime, which has no console to run it in.
+     */
     async clear() {
         try {
             await this.withWriteLock(async () => {
@@ -230,7 +235,7 @@ export class SessionStore {
                 if (!current)
                     return;
                 await this.decode(current);
-                await trashFile(this.sessionFilePath, this.options);
+                await fs.rm(this.sessionFilePath, { force: true });
             });
         }
         catch (error) {
@@ -281,7 +286,7 @@ export class SessionStore {
             return await this.withWriteLock(async () => {
                 if (!equalToken(await this.loadUnlocked(), expected))
                     return false;
-                await trashFile(this.sessionFilePath, this.options);
+                await fs.rm(this.sessionFilePath, { force: true });
                 return true;
             });
         }

package/build/index.js

@@ -138,7 +138,7 @@ else {
             const { resolveHttpPort, resolveHttpToken, startHttpServer } = await import("./http-server.js");
             const running = await startHttpServer({ runtime, token: resolveHttpToken(), port: resolveHttpPort() });
             stopServing = running.close;
-            log("INFO", `Brightspace MCP Server by Rohan Muppa — shared HTTP server listening on ${running.url} (26 tools, 4 prompts registered)`);
+            log("INFO", `Brightspace MCP Server by Rohan Muppa — shared HTTP server listening on ${running.url} (28 tools, 4 prompts registered)`);
             log("INFO", "Leave this running; every MCP client on this computer connects to that URL. Press Ctrl+C to stop.");
         }
         catch (error) {

package/build/server.js

@@ -9,7 +9,7 @@ import { D2LApiClient } from "./api/index.js";
 import { trackToolActivity } from "./utils/dev-activity.js";
 import { log } from "./utils/logger.js";
 import { envCredentialRejectedMessage, ENV_COOKIE_REJECTED } from "./utils/commands.js";
-import { registerGetMyCourses, registerGetUpcomingDueDates, registerGetCalendarEvents, registerGetMyGrades, registerGetAnnouncements, registerGetAssignments, registerGetAssignmentRubric, registerGetAssignmentFiles, registerGetAnnouncementFiles, registerGetCourseContent, registerDownloadFile, COURSE_FILE_NEEDS_COOKIE, registerGetClasslistEmails, registerGetRoster, registerGetMyGroups, registerGetSyllabus, registerGetDiscussions, registerGetVideoTranscript, registerGetServerInfo, registerSearchCourse, registerSignOut, registerSignIn, registerGetDropboxFolders, registerGetDropboxSubmissions, registerGetDropboxUserSubmissions, registerGetDropboxFeedback, registerGetRubricsForObject, registerDownloadDropboxSubmissionFile, acceptOmittedArguments, relayMfaChallenges, currentMfaAnnouncer, } from "./tools/index.js";
+import { registerGetMyCourses, registerGetUpcomingDueDates, registerGetCalendarEvents, registerGetMyGrades, registerGetAnnouncements, registerGetAssignments, registerGetAssignmentRubric, registerGetAssignmentFiles, registerGetAnnouncementFiles, registerGetCourseContent, registerDownloadFile, COURSE_FILE_NEEDS_COOKIE, registerGetClasslistEmails, registerGetRoster, registerGetMyGroups, registerGetAvailableGroups, registerGetSyllabus, registerGetDiscussions, registerGetVideoTranscript, registerGetServerInfo, registerSearchCourse, registerSignOut, registerSignIn, registerGetDropboxFolders, registerGetDropboxSubmissions, registerGetDropboxUserSubmissions, registerGetDropboxFeedback, registerGetRubricsForObject, registerDownloadDropboxSubmissionFile, acceptOmittedArguments, relayMfaChallenges, currentMfaAnnouncer, } from "./tools/index.js";
 import { registerWeeklyBriefingPrompt, registerGradeAuditPrompt, registerStudyPlannerPrompt, registerCourseSummaryPrompt, } from "./prompts/index.js";
 /**
  * Build the shared runtime. Nothing here reaches Brightspace: API versions
@@ -88,6 +88,7 @@ export function createMcpServer(runtime) {
     registerGetClasslistEmails(server, apiClient);
     registerGetRoster(server, apiClient);
     registerGetMyGroups(server, apiClient);
+    registerGetAvailableGroups(server, apiClient, config);
     registerGetSyllabus(server, apiClient);
     registerGetDiscussions(server, apiClient, config.baseUrl);
     registerGetVideoTranscript(server, apiClient);
@@ -102,7 +103,7 @@ export function createMcpServer(runtime) {
     registerGetDropboxFeedback(server, apiClient);
     registerGetRubricsForObject(server, apiClient);
     registerDownloadDropboxSubmissionFile(server, apiClient);
-    log("DEBUG", "MCP tools registered (26 tools)");
+    log("DEBUG", "MCP tools registered (28 tools)");
     // Register MCP prompts — surfaced in clients (e.g. Claude Desktop) as a
     // picker, distinct from tools. Each one is a canned user message that
     // names our own tools by name, so a client with no idea what to ask

package/build/tools/get-available-groups.js

@@ -0,0 +1,166 @@
+/**
+ * Purdue Brightspace MCP Server
+ * Copyright (c) 2026 Rohan Muppa. All rights reserved.
+ * Licensed under MIT — see LICENSE file for details.
+ */
+import { DEFAULT_CACHE_TTLS } from "../api/index.js";
+import { ApiError } from "../api/errors.js";
+import { GetAvailableGroupsSchema } from "./schemas.js";
+import { toolResponse, toolResponseWithNotice, sanitizeError, isAuthUnavailable, authPendingNotice } from "./tool-helpers.js";
+import { fetchCurrentUserId } from "./group-membership.js";
+import { resolveCourses } from "./resolve-courses.js";
+import { log } from "../utils/logger.js";
+/** D2L's GRPENROLL_T values whose groups students pick themselves. */
+const SELF_ENROLLMENT_STYLES = new Set([3, 4, 5]);
+/** Without a courseId, courses that started longer ago than this are skipped unless includeOlder is set. */
+const RECENT_COURSE_MS = 365 * 24 * 60 * 60 * 1000;
+const inaccessible = (error) => error instanceof ApiError && (error.status === 403 || error.status === 404);
+const text = (value) => value?.Text?.trim() || undefined;
+/**
+ * Brightspace shows a category on the "Available Groups" page while its
+ * sign-up window is open; a missing start or expiry date leaves that side open.
+ */
+function signUpOpen(category, now) {
+    if (!SELF_ENROLLMENT_STYLES.has(category.EnrollmentStyle))
+        return false;
+    const start = category.SelfEnrollmentStartDate ? Date.parse(category.SelfEnrollmentStartDate) : -Infinity;
+    const end = category.SelfEnrollmentExpiryDate ? Date.parse(category.SelfEnrollmentExpiryDate) : Infinity;
+    return start <= now && now <= end;
+}
+async function fetchCourseGroups(apiClient, course, myId, now) {
+    const result = { courseId: course.id, courseName: course.name, categories: [], alreadyInGroup: [] };
+    let categories;
+    try {
+        categories = await apiClient.get(apiClient.lp(`/${course.id}/groupcategories/`), { ttl: DEFAULT_CACHE_TTLS.roster });
+    }
+    catch (error) {
+        if (inaccessible(error))
+            return result;
+        throw error;
+    }
+    const unread = [];
+    for (const category of categories.filter((c) => signUpOpen(c, now))) {
+        let groups;
+        try {
+            groups = await apiClient.get(apiClient.lp(`/${course.id}/groupcategories/${category.GroupCategoryId}/groups/`), { ttl: DEFAULT_CACHE_TTLS.roster });
+        }
+        catch (error) {
+            if (inaccessible(error)) {
+                unread.push(category.Name);
+                continue;
+            }
+            throw error;
+        }
+        // Self-enrollment allows one group per category, as on the Available Groups page.
+        const mine = groups.find((g) => g.Enrollments?.some((id) => Number(id) === myId));
+        if (mine) {
+            result.alreadyInGroup.push({ categoryId: category.GroupCategoryId, name: category.Name, groupName: mine.Name });
+            continue;
+        }
+        const max = category.MaxUsersPerGroup ?? null;
+        const showDescriptions = category.DescriptionsVisibleToEnrolees !== false;
+        const open = groups
+            .map((g) => {
+            const members = g.Enrollments?.length ?? 0;
+            const description = showDescriptions ? text(g.Description) : undefined;
+            return {
+                groupId: g.GroupId,
+                name: g.Name,
+                members,
+                spotsLeft: max === null ? null : Math.max(0, max - members),
+                ...(description ? { description } : {}),
+            };
+        })
+            .filter((g) => g.spotsLeft === null || g.spotsLeft > 0);
+        if (open.length === 0)
+            continue;
+        const description = text(category.Description);
+        result.categories.push({
+            categoryId: category.GroupCategoryId,
+            name: category.Name,
+            ...(description ? { description } : {}),
+            signUpCloses: category.SelfEnrollmentExpiryDate ?? null,
+            maxPerGroup: max,
+            groups: open,
+        });
+    }
+    if (unread.length > 0)
+        result.unreadCategories = unread;
+    return result;
+}
+/**
+ * Register get_available_groups tool
+ */
+export function registerGetAvailableGroups(server, apiClient, config) {
+    server.registerTool("get_available_groups", {
+        title: "Get Available Groups",
+        annotations: { readOnlyHint: true },
+        description: "List the groups the current user can still join themselves (self-enrollment), with spots left " +
+            "and when sign-up closes. Use this when a student asks which project or lab groups are open. " +
+            "This tool only reads; joining happens in Brightspace under Groups > Available Groups.",
+        inputSchema: GetAvailableGroupsSchema,
+    }, async (args) => {
+        try {
+            log("DEBUG", "get_available_groups tool called", { args });
+            const { courseId, includeOlder } = GetAvailableGroupsSchema.parse(args);
+            const now = Date.now();
+            const myId = await fetchCurrentUserId(apiClient);
+            const enrolled = await resolveCourses(apiClient, config, courseId);
+            // Some schools give courses a start date but never an end date and never
+            // close them, so every past course still counts as active and its old
+            // sign-ups without an expiry still look open. The start date is the only
+            // signal of which courses are current.
+            const courses = courseId || includeOlder ? enrolled : enrolled.filter((course) => {
+                const start = course.startDate ? Date.parse(course.startDate) : NaN;
+                return Number.isFinite(start) && start >= now - RECENT_COURSE_MS;
+            });
+            const olderSkipped = enrolled.length - courses.length;
+            const results = await Promise.allSettled(courses.map((course) => fetchCourseGroups(apiClient, course, myId, now)));
+            const pendingCourseIds = [];
+            const failedCourseIds = [];
+            let firstAuthError = null;
+            const found = results.flatMap((result, i) => {
+                if (result.status === "fulfilled")
+                    return [result.value];
+                if (isAuthUnavailable(result.reason)) {
+                    if (courseId)
+                        throw result.reason;
+                    pendingCourseIds.push(courses[i].id);
+                    firstAuthError ??= result.reason;
+                }
+                else {
+                    if (courseId)
+                        throw result.reason;
+                    failedCourseIds.push(courses[i].id);
+                    log("DEBUG", "get_available_groups: skipping course after fetch failure", result.reason);
+                }
+                return [];
+            });
+            // A course with nothing open is left out so the list stays about choices.
+            const withChoices = found.filter((c) => c.categories.length > 0 || c.alreadyInGroup.length > 0 || c.unreadCategories);
+            const openGroups = withChoices.reduce((n, c) => n + c.categories.reduce((m, cat) => m + cat.groups.length, 0), 0);
+            log("INFO", `get_available_groups: ${openGroups} open groups across ${courses.length} course(s)`);
+            const notes = [];
+            if (withChoices.length === 0)
+                notes.push("No group sign-ups are open in these courses right now.");
+            if (olderSkipped > 0) {
+                notes.push(`Checked the courses that started in the last 12 months; pass includeOlder: true to also check the other ${olderSkipped}.`);
+            }
+            if (failedCourseIds.length > 0) {
+                notes.push(`Couldn't read groups for course(s) ${failedCourseIds.join(", ")}, so open sign-ups there aren't listed.`);
+            }
+            const data = {
+                coursesChecked: courses.length,
+                courses: withChoices,
+                ...(notes.length > 0 ? { note: notes.join(" ") } : {}),
+                ...(pendingCourseIds.length > 0 ? { authPending: true, unavailableCourseIds: pendingCourseIds } : {}),
+            };
+            return pendingCourseIds.length > 0
+                ? toolResponseWithNotice(data, authPendingNotice(firstAuthError))
+                : toolResponse(data);
+        }
+        catch (error) {
+            return sanitizeError(error);
+        }
+    });
+}

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

@@ -5,7 +5,7 @@
  */
 import { DEFAULT_CACHE_TTLS } from "../api/index.js";
 import { GetCourseContentSchema } from "./schemas.js";
-import { toolResponse, sanitizeError } from "./tool-helpers.js";
+import { toolResponse, sanitizeError, isAuthUnavailable } from "./tool-helpers.js";
 import { convertHtmlToMarkdown } from "../utils/html-converter.js";
 import { matchesModifiedSince } from "../utils/modified-since.js";
 import { log } from "../utils/logger.js";
@@ -44,18 +44,37 @@ export async function fetchRootContent(apiClient, courseId) {
     return apiClient.get(apiClient.le(courseId, '/content/root/'), { ttl: DEFAULT_CACHE_TTLS.courseContent });
 }
 /**
- * Fetch a single module's structure, or null when the dedicated endpoint
- * fails (locked module, transient error) so the caller can fall back to
- * whatever structure the parent listing already embedded.
+ * Fetch a single module's structure, or say why it couldn't be read (locked
+ * module, transient error, an answer that is not a list) so the caller can
+ * fall back to whatever structure the parent listing already embedded. A
+ * pending or expired sign-in is rethrown: it fails every module the same way,
+ * and must fail the call so the user is told to sign in, not shown a course
+ * whose every module looks empty.
  */
 export async function fetchModuleStructure(apiClient, courseId, moduleId) {
+    let structure;
     try {
-        return await apiClient.get(apiClient.le(courseId, `/content/modules/${moduleId}/structure/`), { ttl: DEFAULT_CACHE_TTLS.courseContent });
+        structure = await apiClient.get(apiClient.le(courseId, `/content/modules/${moduleId}/structure/`), { ttl: DEFAULT_CACHE_TTLS.courseContent });
     }
-    catch (e) {
-        log('DEBUG', `Failed to fetch children for module ${moduleId}: falling back to the embedded structure`);
-        return null;
+    catch (error) {
+        if (isAuthUnavailable(error))
+            throw error;
+        log('DEBUG', `Failed to fetch children for module ${moduleId}: falling back to the embedded structure`, error);
+        const status = typeof error?.status === 'number' ? error.status : null;
+        return {
+            status,
+            reason: status === 403
+                ? "Brightspace refused this account's request for this module's contents. It may hold items; open the module in a browser to see what this account can read."
+                : `Couldn't read this module's contents${status !== null ? ` (Brightspace answered ${status})` : ''}. It may hold items; try again.`,
+        };
     }
+    if (Array.isArray(structure))
+        return structure;
+    log('DEBUG', `Module ${moduleId} structure was not a list: falling back to the embedded structure`);
+    return {
+        status: null,
+        reason: "Brightspace answered with something other than a list of this module's contents. It may hold items; try again.",
+    };
 }
 /**
  * How deep the tree builder will descend when the caller names no maxDepth.
@@ -92,6 +111,7 @@ export async function buildContentTree(apiClient, courseId, modules, progressMap
         if (item.Type === 0) {
             // Module: fetch children recursively (unless the depth limit is reached)
             let processedChildren = [];
+            let childrenUnavailable;
             if (currentDepth < depthLimit) {
                 // The parent listing already embeds this module's immediate children
                 // in Structure. The dedicated endpoint is still asked first because it
@@ -100,17 +120,30 @@ export async function buildContentTree(apiClient, courseId, modules, progressMap
                 // 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 = await fetchModuleStructure(apiClient, courseId, item.Id);
-                if (!Array.isArray(children)) {
-                    children = Array.isArray(item.Structure) ? item.Structure : [];
+                // When neither copy is readable, the module's children are reported
+                // as null with a reason, never as [], so it can't pass for an empty
+                // module, and the module is kept under any typeFilter because nothing
+                // says it holds no matching items.
+                const structure = await fetchModuleStructure(apiClient, courseId, item.Id);
+                let children = null;
+                if (Array.isArray(structure)) {
+                    children = structure;
+                }
+                else if (Array.isArray(item.Structure)) {
+                    children = item.Structure;
+                }
+                else {
+                    childrenUnavailable = structure;
+                }
+                if (children) {
+                    processedChildren = await buildContentTree(apiClient, courseId, children, progressMap, typeFilter, maxDepth, currentDepth + 1, availability, now);
                 }
-                processedChildren = await buildContentTree(apiClient, courseId, children, progressMap, typeFilter, maxDepth, currentDepth + 1, availability, now);
             }
             else if (currentDepth >= MAX_CONTENT_DEPTH) {
                 log('DEBUG', `Content depth ceiling of ${MAX_CONTENT_DEPTH} reached at module ${item.Id}: not descending further`);
             }
             // Only include module if it has matching children (or filter is 'all')
-            if (typeFilter === 'all' || processedChildren.length > 0) {
+            if (typeFilter === 'all' || processedChildren.length > 0 || childrenUnavailable) {
                 const courseFiles = item.Description?.Html ? extractCourseFilePaths(item.Description.Html, courseId, apiClient.origin) : [];
                 tree.push({
                     type: 'module',
@@ -125,7 +158,8 @@ export async function buildContentTree(apiClient, courseId, modules, progressMap
                     ...(item.IsLocked ? { isLocked: item.IsLocked } : {}),
                     ...availabilityFields(availability),
                     lastModified: item.LastModifiedDate ?? null,
-                    children: processedChildren,
+                    ...(childrenUnavailable ? { childrenUnavailable } : {}),
+                    children: childrenUnavailable ? null : processedChildren,
                 });
             }
         }
@@ -186,6 +220,12 @@ function filterTreeByModifiedSince(tree, cutoff) {
             }
         }
         else if (item.type === 'module') {
+            // A module whose children couldn't be read stays in, children null:
+            // nothing says none of them changed since the cutoff.
+            if (item.childrenUnavailable) {
+                result.push(item);
+                continue;
+            }
             const filteredChildren = filterTreeByModifiedSince(item.children ?? [], cutoff);
             const moduleMatches = matchesModifiedSince(item.lastModified, cutoff);
             if (moduleMatches || filteredChildren.length > 0) {
@@ -225,6 +265,21 @@ function countModules(tree) {
     }
     return count;
 }
+/**
+ * Count modules whose children couldn't be read (for the notice).
+ */
+export function countUnreadableModules(tree) {
+    let count = 0;
+    for (const item of tree) {
+        if (item.type === 'module') {
+            if (item.childrenUnavailable)
+                count++;
+            if (item.children)
+                count += countUnreadableModules(item.children);
+        }
+    }
+    return count;
+}
 /**
  * Register get_course_content tool
  */
@@ -276,7 +331,8 @@ export function registerGetCourseContent(server, apiClient) {
             }
             const topicCount = countTopics(contentTree);
             const moduleCount = countModules(contentTree);
-            log("INFO", `get_course_content: Retrieved ${moduleCount} modules and ${topicCount} topics for course ${courseId} (filter: ${typeFilter})`);
+            const unreadable = countUnreadableModules(contentTree);
+            log("INFO", `get_course_content: Retrieved ${moduleCount} modules and ${topicCount} topics for course ${courseId} (filter: ${typeFilter})${unreadable > 0 ? `, ${unreadable} module(s) unreadable` : ""}`);
             return toolResponse({
                 courseId,
                 typeFilter,
@@ -284,6 +340,13 @@ export function registerGetCourseContent(server, apiClient) {
                 topicCount,
                 moduleCount,
                 ...(modifiedSince ? { modifiedSince, returned: topicCount, filteredOut } : {}),
+                ...(unreadable > 0
+                    ? {
+                        notice: `The contents of ${unreadable} module(s) couldn't be read; they have children null and a ` +
+                            "childrenUnavailable reason. topicCount leaves out whatever they hold. Do not report " +
+                            "those modules as empty.",
+                    }
+                    : {}),
             });
         }
         catch (error) {

package/build/tools/get-discussions.js

@@ -5,7 +5,7 @@
  */
 import { DEFAULT_CACHE_TTLS } from "../api/index.js";
 import { GetDiscussionsSchema } from "./schemas.js";
-import { toolResponse, sanitizeError, errorResponse } from "./tool-helpers.js";
+import { toolResponse, sanitizeError, errorResponse, isAuthUnavailable } from "./tool-helpers.js";
 import { convertHtmlToMarkdown } from "../utils/html-converter.js";
 import { log } from "../utils/logger.js";
 import { discussionUrl } from "../utils/deep-links.js";
@@ -62,6 +62,21 @@ export function registerGetDiscussions(server, apiClient, baseUrl) {
         }
     });
 }
+/**
+ * Describe a failed per-item read, or rethrow it when the session itself is
+ * unusable. A pending or expired sign-in fails every item the same way, and
+ * must fail the call so the user is told to sign in, not shown a course
+ * whose every forum looks empty.
+ */
+function subListUnavailable(error, operation, what) {
+    if (isAuthUnavailable(error))
+        throw error;
+    const status = typeof error?.status === "number" ? error.status : null;
+    const reason = status === 403
+        ? `Brightspace refused this account's request for the ${what}. They may exist; open the discussion in a browser to see what this account can read.`
+        : `Couldn't read the ${what}${status !== null ? ` (Brightspace answered ${status})` : ""}. They may exist; try again.`;
+    return { operation, status, reason };
+}
 /**
  * Get all forums for a course with their topics (no posts).
  */
@@ -69,18 +84,17 @@ async function getForumsOverview(apiClient, courseId) {
     const forums = await fetchForums(apiClient, courseId);
     const result = [];
     for (const forum of forums) {
-        // Fetch topics for each forum
-        let topics = [];
+        // Fetch topics for each forum. A failed read is reported as null with a
+        // reason, never as [], so it can't pass for a forum with no topics.
+        let topics;
+        let topicsUnavailable;
         try {
             topics = await fetchForumTopics(apiClient, courseId, forum.ForumId);
         }
         catch (error) {
-            if (error?.status === 403) {
-                log("DEBUG", `No access to topics for forum ${forum.ForumId}, skipping`);
-            }
-            else {
-                log("DEBUG", `Failed to fetch topics for forum ${forum.ForumId}`, error);
-            }
+            topicsUnavailable = subListUnavailable(error, "listTopics", "topics");
+            log("INFO", `get_discussions: Topics for forum ${forum.ForumId} unavailable`, error);
+            topics = null;
         }
         result.push({
             forumId: forum.ForumId,
@@ -88,7 +102,8 @@ async function getForumsOverview(apiClient, courseId) {
             description: forum.Description?.Text ?? null,
             isLocked: forum.IsLocked,
             isHidden: forum.IsHidden,
-            topics: topics.map((t) => ({
+            ...(topicsUnavailable ? { topicsUnavailable } : {}),
+            topics: topics?.map((t) => ({
                 topicId: t.TopicId,
                 forumId: t.ForumId,
                 name: t.Name,
@@ -98,7 +113,7 @@ async function getForumsOverview(apiClient, courseId) {
                 isHidden: t.IsHidden,
                 mustPostToParticipate: t.MustPostToParticipate,
                 scoreOutOf: t.ScoreOutOf,
-            })),
+            })) ?? null,
         });
     }
     log("INFO", `get_discussions: Retrieved ${forums.length} forums for course ${courseId}`);
@@ -125,22 +140,21 @@ async function getForumDetail(apiClient, courseId, forumId) {
     // Fetch posts for each topic
     const topicsWithPosts = [];
     for (const topic of topics) {
-        let posts = [];
+        // A failed posts read is reported as null with a reason, never as an
+        // empty thread, matching the single-topic view.
+        let formatted;
+        let postsUnavailable;
         try {
             const postsPath = apiClient.le(courseId, `/discussions/forums/${forumId}/topics/${topic.TopicId}/posts/`);
-            posts = await apiClient.get(postsPath, {
+            formatted = formatPosts(await apiClient.get(postsPath, {
                 ttl: DEFAULT_CACHE_TTLS.announcements,
-            });
+            }));
         }
         catch (error) {
-            if (error?.status === 403) {
-                log("DEBUG", `No access to posts for topic ${topic.TopicId}, skipping`);
-            }
-            else {
-                log("DEBUG", `Failed to fetch posts for topic ${topic.TopicId}`, error);
-            }
+            postsUnavailable = subListUnavailable(error, "listPosts", "posts");
+            log("INFO", `get_discussions: Posts for topic ${topic.TopicId} unavailable`, error);
+            formatted = null;
         }
-        const formatted = formatPosts(posts);
         topicsWithPosts.push({
             topicId: topic.TopicId,
             name: topic.Name,
@@ -151,8 +165,9 @@ async function getForumDetail(apiClient, courseId, forumId) {
             isLocked: topic.IsLocked,
             mustPostToParticipate: topic.MustPostToParticipate,
             scoreOutOf: topic.ScoreOutOf,
-            postCount: formatted.length,
+            postCount: formatted?.length ?? null,
             posts: formatted,
+            ...(postsUnavailable ? { postsUnavailable } : {}),
         });
     }
     log("INFO", `get_discussions: Retrieved forum ${forumId} with ${topics.length} topics for course ${courseId}`);

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

@@ -5,10 +5,28 @@
  */
 import { ApiError } from "../api/errors.js";
 import { GetMyGroupsSchema } from "./schemas.js";
-import { toolResponse, sanitizeError } from "./tool-helpers.js";
+import { toolResponse, sanitizeError, isAuthUnavailable } from "./tool-helpers.js";
 import { fetchClasslistUsers } from "./get-roster.js";
 import { log } from "../utils/logger.js";
 import { fetchMyGroupMemberships } from "./group-membership.js";
+import { decodeEntities } from "../utils/html-attributes.js";
+/**
+ * Names on a group's "View Members" page (group_member_list.d2l), or null when
+ * the page doesn't have the member table. Each data row holds one name in a
+ * single cell; the header row is the only one with a class.
+ */
+export function memberNamesFromPage(html) {
+    const table = /<table\b[^>]*\bd2l-grid\b[^>]*>([\s\S]*?)<\/table>/i.exec(html);
+    if (!table)
+        return null;
+    const names = [];
+    for (const row of table[1].matchAll(/<tr>\s*<td\b[^>]*>([\s\S]*?)<\/td>\s*<\/tr>/gi)) {
+        const name = decodeEntities(row[1].replace(/<[^>]+>/g, "")).replace(/\s+/g, " ").trim();
+        if (name)
+            names.push(name);
+    }
+    return names;
+}
 /** True when a group/category endpoint simply isn't there for this course or user. */
 function isMissingOrForbidden(error) {
     return error instanceof ApiError && (error.status === 403 || error.status === 404);
@@ -76,6 +94,25 @@ export function registerGetMyGroups(server, apiClient) {
                     throw error;
                 }
             }
+            // Students who can't read the classlist can still open each of their
+            // groups' "View Members" page, so read the names from there. The page
+            // carries no user ids, so the names stay a separate list.
+            const pageNames = new Map();
+            if (namesUnavailable) {
+                for (const { group } of matches) {
+                    try {
+                        const html = await apiClient.getPage(`/d2l/lms/group/group_member_list.d2l?ou=${courseId}&groupId=${group.GroupId}`);
+                        const names = html === null ? null : memberNamesFromPage(html);
+                        if (names)
+                            pageNames.set(group.GroupId, names);
+                    }
+                    catch (error) {
+                        if (isAuthUnavailable(error))
+                            throw error;
+                        log("DEBUG", `get_my_groups: Couldn't read the member page for group ${group.GroupId}`, error);
+                    }
+                }
+            }
             const groups = matches.map(({ category, group }) => {
                 const enrollments = group.Enrollments ?? [];
                 const members = enrollments.map((userId) => ({
@@ -89,15 +126,19 @@ export function registerGetMyGroups(server, apiClient) {
                     groupName: group.Name,
                     ...(group.Code ? { groupCode: group.Code } : {}),
                     members,
+                    ...(pageNames.has(group.GroupId) ? { memberNames: pageNames.get(group.GroupId) } : {}),
                 };
             });
             log("INFO", `get_my_groups: Found ${groups.length} groups for course ${courseId}`);
             // Null names are only meaningful with a reason attached: without one,
             // a caller can't tell "the classlist couldn't be read" from "these
             // members have no names", and may report the group as anonymous.
-            const namesNote = namesUnavailable
-                ? "Couldn't read this course's classlist, so member names are null; only user ids are listed."
-                : undefined;
+            const namesNote = !namesUnavailable ? undefined
+                : pageNames.size === matches.length
+                    ? "Couldn't read this course's classlist, so member names are null; memberNames lists each group's " +
+                        "members from its member page, which doesn't say which name belongs to which user id."
+                    : "Couldn't read this course's classlist, so member names are null; only user ids are listed" +
+                        (pageNames.size > 0 ? ", except where memberNames lists a group's members from its member page." : ".");
             const note = [unreadNote, namesNote].filter(Boolean).join(" ") || undefined;
             return toolResponse({ courseId, groups, ...(note ? { note } : {}) });
         }

package/build/tools/index.js

@@ -18,6 +18,7 @@ export { registerDownloadFile, COURSE_FILE_NEEDS_COOKIE } from "./download-file.
 export { registerGetClasslistEmails } from "./get-classlist-emails.js";
 export { registerGetRoster } from "./get-roster.js";
 export { registerGetMyGroups } from "./get-my-groups.js";
+export { registerGetAvailableGroups } from "./get-available-groups.js";
 export { registerGetSyllabus } from "./get-syllabus.js";
 export { registerGetDiscussions } from "./get-discussions.js";
 export { registerGetVideoTranscript } from "./get-video-transcript.js";

package/build/tools/resolve-courses.js

@@ -33,7 +33,7 @@ export async function resolveCourses(apiClient, config, courseId) {
     }
     if (courseId) {
         const match = items.find((item) => item.OrgUnit.Id === courseId);
-        return [{ id: courseId, name: match?.OrgUnit.Name ?? null }];
+        return [{ id: courseId, name: match?.OrgUnit.Name ?? null, startDate: match?.Access.StartDate ?? null }];
     }
     const filtered = applyCourseFilter(items.map((item) => ({
         id: item.OrgUnit.Id,
@@ -44,5 +44,5 @@ export async function resolveCourses(apiClient, config, courseId) {
         startDate: item.Access.StartDate,
         endDate: item.Access.EndDate,
     })), config.courseFilter);
-    return filtered.map((course) => ({ id: course.id, name: course.name }));
+    return filtered.map((course) => ({ id: course.id, name: course.name, startDate: course.startDate }));
 }

package/build/tools/schemas.js

@@ -160,6 +160,12 @@ export const GetMyGroupsSchema = z.object({
     courseId: z.coerce.number().int().positive()
         .describe("Course ID to list the current user's project/discussion groups for."),
 });
+export const GetAvailableGroupsSchema = z.object({
+    courseId: z.coerce.number().int().positive().optional()
+        .describe("Course ID to list joinable groups for. If omitted, checks courses that started in the last 12 months."),
+    includeOlder: z.boolean().default(false)
+        .describe("Without courseId, also check older and undated courses. Schools that never close a course keep years of finished courses whose sign-ups still look open."),
+});
 export const GetServerInfoSchema = z.object({});
 export const SignOutSchema = z.object({});
 export const SignInSchema = z.object({

package/build/tools/search-course.js

@@ -7,7 +7,7 @@ import { ApiError } from "../api/index.js";
 import { SearchCourseSchema } from "./schemas.js";
 import { toolResponse, sanitizeError, isAuthUnavailable } from "./tool-helpers.js";
 import { log } from "../utils/logger.js";
-import { fetchRootContent, buildContentTree } from "./get-course-content.js";
+import { fetchRootContent, buildContentTree, countUnreadableModules } from "./get-course-content.js";
 import { fetchCourseNews, isPublishedNewsItem, mapNewsItem } from "./get-announcements.js";
 import { fetchForums, fetchForumTopics } from "./get-discussions.js";
 /** A query term matched in the title outranks the same term only in the body. */
@@ -186,6 +186,10 @@ export function registerSearchCourse(server, apiClient) {
                 const rootModules = await fetchRootContent(apiClient, courseId);
                 const tree = await buildContentTree(apiClient, courseId, rootModules, new Map(), "all");
                 entries.push(...flattenContentTree(tree));
+                const unreadable = countUnreadableModules(tree);
+                if (unreadable > 0) {
+                    notes.push(`content inside ${unreadable} module(s) whose contents couldn't be read`);
+                }
             }
             catch (error) {
                 // A pending or refused sign-in is not a source that failed: the

package/package.json

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