brightspace-d2l-mcp 1.0.0 → 1.4.0

package/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+## 1.4.0
+
+- Update check. Running a command like `npx brightspace-d2l-mcp setup` on an older version now says which version is out and asks "Update now? (Y/n)". Yes switches to the new version and carries on with the same command. It never asks when an AI app runs the server, in CI, with `--yes`, or when `BRIGHTSPACE_NO_UPDATE_CHECK` is set.
+- Running `npx brightspace-d2l-mcp` with no command in a terminal now shows help instead of silently starting the server. AI apps are unaffected.
+
+## 1.3.0
+
+- Setup closes its window when it finishes on Windows, after a 10 second countdown. Press Enter to close it straight away, type k to keep it open, or pass `--keep-open`. Every command now exits as soon as it is done, so the terminal is never left hanging.
+- New `get_calendar_events` tool. It reads the course calendars for exams, tests, labs, classes and other events instructors post, so you can ask "when is my midterm?". Search by text and look up to 180 days ahead.
+- New `get_whats_new` tool. One catch-up across every course: new announcements, newly marked work you have not opened, unread discussion posts and quizzes you have not tried.
+- New prompts `catch_me_up` and `when_are_my_exams`. `weekly_digest` now includes events and newly marked work.
+- Fixed releases not reaching npm and the MCP Registry. 1.1.0 and 1.2.0 never published because npm refused the upload; the workflow now accepts trusted publishing or an `NPM_TOKEN` secret, explains what to set up when npm refuses, and publishes to the MCP Registry right after npm.
+- New `npm run stats` and a weekly `stats` workflow that report npm downloads, GitHub stars and traffic, registry versions, and how this server compares with other Brightspace MCP servers.
+- Removed the unused write methods from the API client, marked every `get_` tool read only, and added a test that fails if a write request is ever added. Documented how read-only is enforced in SECURITY.md.
+
+## 1.2.0
+
+- New `get_grade_outlook` tool. It shows where you stand in a course, your best and worst possible final grade, and the average you need on the remaining work to reach a target grade ("what do I need on the final to get an 80?").
+- New `export_due_dates_calendar` tool. It builds an .ics file of your unfinished deadlines that opens in Google Calendar, Apple Calendar and Outlook, with a link back to Brightspace and a one day reminder on each event.
+- New built-in MCP prompts for apps that show prompt shortcuts: `what_should_i_do_now`, `plan_my_week`, `weekly_digest`, `grade_target`, `exam_prep`, `summarize_assignment` and `put_deadlines_in_my_calendar`.
+- README, `llms.txt` and package keywords updated so people searching for these features can find them.
+
+## 1.1.0
+
+- New `doctor` command. It checks Node, your saved school, whether Brightspace is reachable, your saved sign-in, your connected AI apps and the latest npm version, and says how to fix each problem.
+- Clearer tool descriptions so AI agents pick the right tool, for example `get_todo` vs `get_upcoming_due_dates` and `get_roster` vs `get_classlist_emails`.
+- Downloads badge, `llms.txt` and README improvements.
+
+## 1.0.0
+
+- First release. 13 read-only tools for due dates with real submission status, grades, assignments, rubrics, course content, announcements, discussions, rosters and syllabi.

package/README.md

@@ -6,15 +6,18 @@
 
 <p align="center">
   <a href="https://www.npmjs.com/package/brightspace-d2l-mcp"><img src="https://img.shields.io/npm/v/brightspace-d2l-mcp?style=flat-square&label=npm&labelColor=1b2033&color=ff6a3d" alt="npm version"></a>
+  <a href="https://www.npmjs.com/package/brightspace-d2l-mcp"><img src="https://img.shields.io/npm/dm/brightspace-d2l-mcp?style=flat-square&label=downloads&labelColor=1b2033&color=ff6a3d" alt="npm downloads per month"></a>
   <a href="https://github.com/AnonymousOnyx22/brightspace-d2l-mcp/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/AnonymousOnyx22/brightspace-d2l-mcp/ci.yml?style=flat-square&label=tests&labelColor=1b2033" alt="tests"></a>
   <img src="https://img.shields.io/badge/node-20%2B-3ddc97?style=flat-square&labelColor=1b2033" alt="Node 20+">
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-9fb4ff?style=flat-square&labelColor=1b2033" alt="MIT license"></a>
 </p>
 
-<h3 align="center">Connect D2L Brightspace to Claude, ChatGPT, Cursor, Copilot<br>or any AI agent in about a minute.</h3>
+<h3 align="center">Connect D2L Brightspace to Claude, ChatGPT, Cursor and Copilot.<br>It knows what you already handed in, so it only shows what is actually left.</h3>
 
 <p align="center">One command. Sign in the way you always do. No passwords stored.</p>
 
+<p align="center">By Nick, a networking student at Fleming College</p>
+
 <br>
 
 An [MCP (Model Context Protocol)](https://modelcontextprotocol.io) server that gives AI assistants and agents read access to your Brightspace courses: due dates with real submission status, grades, assignments, rubrics, course content, announcements, discussions and class lists. It works at any school that uses D2L Brightspace, including schools with Microsoft, Duo, Okta or Shibboleth single sign-on.
@@ -50,6 +53,10 @@ New to this? The **[step-by-step setup guide](docs/setup.md)** walks through eve
 | 📎 **Assignment files** | "What does the rubric for the project ask for?" |
 | 💬 **Discussions** | "What are people saying in the final project thread?" |
 | 👥 **Class list** | "Who's the TA for my networking course?" |
+| 🎯 **Target grade** | "What do I need on the final to get an 80?" · "Can I still pass?" |
+| 🗓️ **Calendar** | "Put my deadlines in my calendar" |
+| 📝 **Exams** | "When is my midterm?" · "What's on my schedule this week?" |
+| 🔔 **What's new** | "Catch me up" · "Did anything get graded?" |
 
 ### It knows what you've already handed in
 
@@ -66,7 +73,7 @@ This one checks your actual submission for every assignment:
 
 ## Tools
 
-13 read-only MCP tools for D2L Brightspace:
+17 MCP tools for D2L Brightspace. Everything reads from Brightspace and nothing is ever changed there:
 
 | Tool | What it does |
 |---|---|
@@ -83,6 +90,15 @@ This one checks your actual submission for every assignment:
 | `get_roster` | Instructors and TAs with contact info, optionally the full class list |
 | `get_classlist_emails` | Email addresses for everyone in a course |
 | `download_file` | Saves a course file or submission to a folder you choose |
+| `get_grade_outlook` | Where you stand in a course and what you need on the remaining work to hit a target grade |
+| `export_due_dates_calendar` | Builds a calendar file (.ics) of your unfinished deadlines for Google Calendar, Apple Calendar and Outlook |
+| `get_calendar_events` | Exams, tests, labs, classes and other events from your course calendars |
+| `get_whats_new` | Catch-up across every course: new announcements, newly marked work, unread discussions and untried quizzes |
+
+### Built-in prompts
+
+Apps that support MCP prompts show these as one-click shortcuts or slash commands:
+`what_should_i_do_now` · `plan_my_week` · `weekly_digest` · `grade_target` · `exam_prep` · `summarize_assignment` · `put_deadlines_in_my_calendar` · `catch_me_up` · `when_are_my_exams`
 
 ## Works at any Brightspace school
 
@@ -95,6 +111,15 @@ Instead of guessing how your school works, setup opens a **normal browser window
 
 After that it stays signed in quietly in the background. If your school ever asks you to sign in again, the browser window simply pops up and closes by itself when you're done.
 
+## Does my school work?
+
+If your school uses D2L Brightspace, yes. Setup opens a normal browser window so any sign-in works, including Microsoft, Duo, Okta and Shibboleth.
+
+| School | Status |
+|---|---|
+| Fleming College | Tested by the author |
+| Any other D2L school | Should work. Open an issue with yours and I will add it here |
+
 ## Works with your AI app or agent
 
 **Connected automatically by setup:**
@@ -109,14 +134,26 @@ OpenAI Agents SDK · Claude Agent SDK · LangChain / LangGraph · Vercel AI SDK
 It runs over **stdio** for local apps and **streamable HTTP** (`serve --http`) for ChatGPT and hosted agents.
 See **[docs/agents.md](docs/agents.md)** for copy-paste setup for every one of these.
 
+## Install it with your AI
+
+Paste this into Claude Code, Cursor, Windsurf, Copilot or Codex and it will set everything up for you.
+
+```text
+Install brightspace-d2l-mcp for me by following
+https://github.com/AnonymousOnyx22/brightspace-d2l-mcp/blob/main/llms.txt
+```
+
 ## Commands
 
 | Command | What it does |
 |---|---|
-| `npx brightspace-d2l-mcp setup` | Pick your school, sign in, connect your AI apps |
+| `npx brightspace-d2l-mcp setup` | Pick your school, sign in, connect your AI apps. On Windows the window closes by itself when done (`--keep-open` to stop that) |
 | `npx brightspace-d2l-mcp login` | Sign in again |
 | `npx brightspace-d2l-mcp status` | Show your school, whether you're signed in, and connected apps |
+| `npx brightspace-d2l-mcp doctor` | Check Node, your school, sign-in and connected apps, and say how to fix anything wrong |
 | `npx brightspace-d2l-mcp logout` | Delete the saved session |
+
+When a newer version is out, commands ask whether to update first. Set `BRIGHTSPACE_NO_UPDATE_CHECK=1` to turn that off.
 | `npx brightspace-d2l-mcp uninstall` | Remove from all AI apps and delete all local data |
 | `npx brightspace-d2l-mcp serve --http` | Run over HTTP for ChatGPT and HTTP-based agents |
 | `npx brightspace-d2l-mcp config` | Print the MCP config JSON for any other app |
@@ -138,7 +175,7 @@ App ids: `claude-desktop`, `claude-code`, `cursor`, `vscode`, `windsurf`, `codex
 ## Privacy and security
 
 - **Your password is never seen or stored.** You type it into your school's own sign-in page in a real browser.
-- **Read-only.** It can't submit, post, or change anything in Brightspace.
+- **Read-only.** It can't submit, post, or change anything in Brightspace. No tool sends anything but GET requests, the API client has no write methods at all, and a test fails the build if one is ever added. See [how read-only is enforced](SECURITY.md#how-read-only-is-enforced).
 - **Local only.** Everything runs on your computer and talks only to your school's Brightspace. There's no server in between, and no analytics.
 - **Uses the official Brightspace API** with the same access you have in your browser.
 - Your session is saved in `~/.brightspace-d2l-mcp/`, readable only by your user account. `logout` deletes it; `uninstall` deletes everything.
@@ -170,7 +207,7 @@ Claude Desktop rewrites its settings while it's open, so setup offers to restart
 <summary><b>It keeps asking me to sign in</b></summary>
 
 Some schools end sessions every few hours. When that happens a browser window opens so you can sign in again.
-Run `npx brightspace-d2l-mcp status` to check, or `login` to sign in right away.
+Run `npx brightspace-d2l-mcp doctor` to find out what is wrong, `status` for a quick look, or `login` to sign in right away.
 If you'd rather it never opens a window on its own, add `"autoLogin": false` to `~/.brightspace-d2l-mcp/config.json`.
 </details>
 
@@ -230,6 +267,18 @@ No. Brightspace API keys normally require an administrator. This uses your own s
 Yes. You sign in yourself in a real browser window, so any sign-in method your school uses works.
 </details>
 
+<details>
+<summary><b>Can it tell me what I need on my final to reach a grade?</b></summary>
+
+Yes. Ask "what do I need on the final to get an 80 in Calculus?" and `get_grade_outlook` uses the weights Brightspace reports to give your current percentage, your best and worst possible final grade, and the average you need on everything left.
+</details>
+
+<details>
+<summary><b>Can I get my Brightspace due dates in Google Calendar, Apple Calendar or Outlook?</b></summary>
+
+Yes. Ask your AI to put your deadlines in your calendar. `export_due_dates_calendar` makes an .ics file with a link back to Brightspace and a one day reminder on each event, and only includes work you have not handed in.
+</details>
+
 <details>
 <summary><b>Which schools does it work with?</b></summary>
 

package/build/cli/close-window.js

@@ -0,0 +1,58 @@
+import { execFile, spawn } from "node:child_process";
+import * as ui from "./ui.js";
+const SHELLS = new Set(["cmd.exe", "powershell.exe", "pwsh.exe"]);
+/**
+ * The outermost shell above `start`, which owns the console window.
+ * Walks past the cmd.exe /c wrappers that npx.cmd adds, and stops at the first non-shell
+ * above it (explorer.exe, WindowsTerminal.exe, an IDE...).
+ */
+export function outermostShell(processes, start) {
+    let found = null;
+    const seen = new Set();
+    for (let pid = start; processes.has(pid) && !seen.has(pid); pid = processes.get(pid).ppid) {
+        seen.add(pid);
+        const name = processes.get(pid).name.toLowerCase();
+        if (SHELLS.has(name))
+            found = pid;
+        else if (found !== null)
+            break;
+    }
+    return found;
+}
+function windowsProcesses() {
+    const script = "Get-CimInstance Win32_Process | ForEach-Object { \"$($_.ProcessId)`t$($_.ParentProcessId)`t$($_.Name)\" }";
+    return new Promise((resolve) => {
+        execFile("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], { timeout: 15_000, windowsHide: true }, (error, stdout) => {
+            const map = new Map();
+            if (!error) {
+                for (const line of stdout.split(/\r?\n/)) {
+                    const [pid, ppid, name] = line.split("\t");
+                    if (pid && ppid && name)
+                        map.set(Number(pid), { ppid: Number(ppid), name: name.trim() });
+                }
+            }
+            resolve(map);
+        });
+    });
+}
+/** Whether setup should offer to close the window: an interactive Windows console that isn't an editor's built-in terminal. */
+export function canCloseWindow() {
+    return process.platform === "win32" && ui.interactive && process.env.TERM_PROGRAM !== "vscode" && !process.env.BRIGHTSPACE_KEEP_OPEN;
+}
+/**
+ * Counts down, then closes the console window setup is running in.
+ * Enter closes it at once; typing k (keep) leaves it open.
+ */
+export async function closeWindowAfterCountdown(seconds = 10) {
+    const shellPromise = windowsProcesses().then((processes) => outermostShell(processes, process.pid));
+    const answer = await ui.askWithTimeout(ui.dim(`This window closes in ${seconds} seconds. Press Enter to close it now, or type k and Enter to keep it open.`), seconds * 1000);
+    if (answer?.toLowerCase().startsWith("k"))
+        return;
+    const shell = await shellPromise;
+    if (shell === null)
+        return;
+    // taskkill /T ends the shell and everything under it, this process included, which closes the window.
+    spawn("taskkill", ["/PID", String(shell), "/T", "/F"], { detached: true, stdio: "ignore", windowsHide: true }).unref();
+    await new Promise((resolve) => setTimeout(resolve, 3000));
+}
+//# sourceMappingURL=close-window.js.map

package/build/cli/doctor.js

@@ -0,0 +1,148 @@
+import { loadConfig } from "../utils/config.js";
+import { configPath, dataDir, PACKAGE_NAME, SETUP_COMMAND } from "../utils/paths.js";
+import { packageVersion } from "../utils/version.js";
+import { TokenManager } from "../auth/index.js";
+import { detectClients, isConfiguredIn } from "./clients.js";
+import * as ui from "./ui.js";
+const MIN_NODE_MAJOR = 20;
+const NETWORK_TIMEOUT_MS = 8000;
+export function checkNodeVersion(version = process.versions.node) {
+    const major = parseInt(version.split(".")[0] ?? "0", 10);
+    if (major >= MIN_NODE_MAJOR)
+        return { level: "ok", message: `Node.js ${version}` };
+    return {
+        level: "fail",
+        message: `Node.js ${version} is too old (need ${MIN_NODE_MAJOR} or newer)`,
+        fix: "Install the current LTS from https://nodejs.org and open a new terminal.",
+    };
+}
+/** True when `latest` is a higher dotted version than `current`. Ignores pre-release tags. */
+export function isNewerVersion(latest, current) {
+    const parse = (v) => v.split("-")[0].split(".").map((n) => parseInt(n, 10) || 0);
+    const a = parse(latest);
+    const b = parse(current);
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        const diff = (a[i] ?? 0) - (b[i] ?? 0);
+        if (diff !== 0)
+            return diff > 0;
+    }
+    return false;
+}
+async function fetchWithTimeout(url, init = {}) {
+    return fetch(url, { ...init, signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS) });
+}
+export function checkSchool(baseUrl) {
+    if (baseUrl)
+        return { level: "ok", message: `School: ${baseUrl}` };
+    return { level: "fail", message: "No school saved yet", fix: `Run: ${SETUP_COMMAND}` };
+}
+export async function checkConnectivity(baseUrl) {
+    try {
+        const response = await fetchWithTimeout(baseUrl, { method: "HEAD", redirect: "follow" });
+        // Any HTTP answer means the site is reachable. Sign-in redirects and 401s are normal.
+        return { level: "ok", message: `Brightspace is reachable (HTTP ${response.status})` };
+    }
+    catch {
+        return {
+            level: "fail",
+            message: `Can't reach ${baseUrl}`,
+            fix: "Check your internet, VPN or campus network. Some schools only allow on-campus access.",
+        };
+    }
+}
+async function checkSession(baseUrl, tokenTtl) {
+    try {
+        const token = await new TokenManager({ baseUrl, tokenTtl }).getToken();
+        if (token)
+            return { level: "ok", message: "Saved sign-in is valid" };
+        return {
+            level: "warn",
+            message: "Saved sign-in has expired",
+            fix: "It reopens sign-in on your next question. To do it now, run: npx -y brightspace-d2l-mcp@latest login",
+        };
+    }
+    catch (error) {
+        return {
+            level: "warn",
+            message: "Couldn't read the saved sign-in",
+            fix: `Run: npx -y brightspace-d2l-mcp@latest login${error instanceof Error ? ` (${error.message})` : ""}`,
+        };
+    }
+}
+export async function checkLatestVersion(current) {
+    try {
+        const response = await fetchWithTimeout(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`);
+        if (!response.ok)
+            throw new Error(String(response.status));
+        const { version } = (await response.json());
+        if (version && isNewerVersion(version, current)) {
+            return {
+                level: "warn",
+                message: `Version ${current} installed, ${version} is available`,
+                fix: `Using npx with @latest updates itself. Otherwise run: npm install -g ${PACKAGE_NAME}@latest`,
+            };
+        }
+        return { level: "ok", message: `Version ${current} is up to date` };
+    }
+    catch {
+        return { level: "warn", message: `Version ${current} (couldn't check for updates)` };
+    }
+}
+function checkClients() {
+    const clients = detectClients();
+    if (!clients.length) {
+        return [
+            {
+                level: "warn",
+                message: "No supported AI apps found on this computer",
+                fix: `Run ${SETUP_COMMAND} again once one is installed, or use: npx -y ${PACKAGE_NAME}@latest config`,
+            },
+        ];
+    }
+    return clients.map((client) => isConfiguredIn(client)
+        ? { level: "ok", message: `${client.name} is connected` }
+        : { level: "warn", message: `${client.name} isn't connected`, fix: `Run: ${SETUP_COMMAND}` });
+}
+function print(result) {
+    if (result.level === "ok")
+        ui.ok(result.message);
+    else if (result.level === "warn")
+        ui.warn(result.message);
+    else
+        ui.fail(result.message);
+    if (result.fix && result.level !== "ok")
+        ui.info(ui.dim(`   ${result.fix}`));
+}
+/** Runs every check, prints the result and returns 1 if anything failed outright. */
+export async function runDoctor() {
+    const config = loadConfig();
+    const results = [];
+    const add = (...items) => {
+        for (const item of items) {
+            results.push(item);
+            print(item);
+        }
+    };
+    console.log(`\n${ui.bold("brightspace-d2l-mcp doctor")} ${ui.dim(`v${packageVersion()}`)}\n`);
+    add(checkNodeVersion());
+    add(checkSchool(config.baseUrl));
+    if (config.baseUrl) {
+        add(await checkConnectivity(config.baseUrl));
+        add(await checkSession(config.baseUrl, config.tokenTtl));
+    }
+    add(...checkClients());
+    add(await checkLatestVersion(packageVersion()));
+    const failures = results.filter((r) => r.level === "fail").length;
+    const warnings = results.filter((r) => r.level === "warn").length;
+    console.log();
+    if (failures)
+        ui.fail(`${failures} problem${failures === 1 ? "" : "s"} found. Fix the first one above and run doctor again.`);
+    else if (warnings)
+        ui.warn(`No blocking problems, ${warnings} thing${warnings === 1 ? "" : "s"} worth a look.`);
+    else
+        ui.ok("Everything looks good.");
+    ui.info(ui.dim(`Config: ${configPath()}  Data: ${dataDir()}`));
+    console.log();
+    return failures ? 1 : 0;
+}
+//# sourceMappingURL=doctor.js.map

package/build/cli/main.js

@@ -5,6 +5,7 @@ import { packageVersion } from "../utils/version.js";
 import { loginWithBrowser, LoginError, SessionStore, TokenManager } from "../auth/index.js";
 import { APP_IDS, detectClients, isConfiguredIn, removeFromClient, serverEntry } from "./clients.js";
 import { runSetup, printManualConfig } from "./setup.js";
+import { runDoctor } from "./doctor.js";
 import * as ui from "./ui.js";
 function flagValue(args, name) {
     const index = args.indexOf(name);
@@ -21,11 +22,14 @@ export async function runCli(command, args) {
                 yes: args.includes("--yes") || args.includes("-y"),
                 skipLogin: args.includes("--skip-login"),
                 apps: flagValue(args, "--apps")?.split(",").map((s) => s.trim()),
+                keepOpen: args.includes("--keep-open"),
             });
         case "login":
             return login();
         case "status":
             return status();
+        case "doctor":
+            return runDoctor();
         case "logout":
             await new SessionStore().clear();
             fs.rmSync(browserProfileDir(), { recursive: true, force: true });
@@ -148,13 +152,14 @@ ${ui.bold("brightspace-d2l-mcp")} ${ui.dim(`v${packageVersion()}`)}  Brightspace
   ${ui.cyan("setup")}       Pick your school, sign in, and connect your AI apps
   ${ui.cyan("login")}       Sign in again
   ${ui.cyan("status")}      Show your school, session and connected apps
+  ${ui.cyan("doctor")}      Check Node, your school, sign-in and AI apps, and say how to fix problems
   ${ui.cyan("logout")}      Delete the saved session
   ${ui.cyan("uninstall")}   Remove from AI apps and delete all local data
   ${ui.cyan("serve")}       Run the MCP server over stdio (what AI apps launch)
   ${ui.cyan("serve --http")} Run over HTTP for ChatGPT and HTTP agents  [--port 8787] [--host 127.0.0.1] [--no-auth]
   ${ui.cyan("config")}      Print the MCP config JSON for any other app
 
-  Setup options: --school <address>  --yes  --skip-login  --apps ${APP_IDS.join(",")}
+  Setup options: --school <address>  --yes  --skip-login  --keep-open  --apps ${APP_IDS.join(",")}
 `);
     printManualConfig();
     console.log();

package/build/cli/setup.js

@@ -4,8 +4,15 @@ import { loginWithBrowser, LoginError, NoBrowserError, TokenManager } from "../a
 import { SERVER_NAME } from "../utils/paths.js";
 import { resolveSchool } from "./school.js";
 import { addToClient, allowToolsInClaudeCode, detectClients, isClaudeDesktopRunning, quitClaudeDesktop, serverEntry, } from "./clients.js";
+import { canCloseWindow, closeWindowAfterCountdown } from "./close-window.js";
 import * as ui from "./ui.js";
 export async function runSetup(flags) {
+    const code = await setupSteps(flags);
+    if (code === 0 && !flags.keepOpen && canCloseWindow())
+        await closeWindowAfterCountdown();
+    return code;
+}
+async function setupSteps(flags) {
     if (flags.yes)
         ui.setNonInteractive();
     console.log(`\n${ui.bold("Brightspace for your AI apps")} ${ui.dim("· setup takes about a minute")}`);

package/build/cli/ui.js

@@ -28,6 +28,25 @@ export async function ask(question, fallback = "") {
         rl.close();
     }
 }
+/** Like ask, but resolves with null if nothing is entered within timeoutMs. */
+export async function askWithTimeout(question, timeoutMs) {
+    if (!interactive)
+        return null;
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return (await rl.question(`  ${question} `, { signal: controller.signal })).trim();
+    }
+    catch {
+        console.log();
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+        rl.close();
+    }
+}
 export async function confirm(question, defaultYes = true) {
     if (!interactive)
         return defaultYes;

package/build/cli/update-check.js

@@ -0,0 +1,76 @@
+import { spawn } from "node:child_process";
+import { homedir } from "node:os";
+import { PACKAGE_NAME } from "../utils/paths.js";
+import { packageVersion } from "../utils/version.js";
+import { isNewerVersion } from "./doctor.js";
+import * as ui from "./ui.js";
+const CHECK_TIMEOUT_MS = 1500;
+/** Set on the relaunched process so it never asks again. */
+const RELAUNCHED_ENV = "BRIGHTSPACE_UPDATED";
+/** Commands that never prompt: the MCP server itself, and output meant for scripts. */
+const SKIP_COMMANDS = new Set(["serve", "config", "--version", "-v"]);
+export function shouldCheckForUpdate(command, args, env = process.env, tty = process.stdin.isTTY === true && process.stdout.isTTY === true) {
+    if (!tty || SKIP_COMMANDS.has(command))
+        return false;
+    if (args.includes("--yes") || args.includes("-y"))
+        return false;
+    return !env.CI && !env.BRIGHTSPACE_NO_UPDATE_CHECK && !env[RELAUNCHED_ENV];
+}
+async function latestVersion() {
+    try {
+        const response = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, { signal: AbortSignal.timeout(CHECK_TIMEOUT_MS) });
+        if (!response.ok)
+            return null;
+        const { version } = (await response.json());
+        return typeof version === "string" ? version : null;
+    }
+    catch {
+        return null;
+    }
+}
+function quoteForCmd(arg) {
+    return /[\s"&|<>^]/.test(arg) ? `"${arg.replace(/"/g, '\\"')}"` : arg;
+}
+function relaunch(version, command, args) {
+    const windows = process.platform === "win32";
+    const argv = ["-y", `${PACKAGE_NAME}@${version}`, command, ...args];
+    return new Promise((resolve) => {
+        const child = spawn("npx", windows ? argv.map(quoteForCmd) : argv, {
+            stdio: "inherit",
+            shell: windows,
+            // Run outside the current folder, so a project that itself depends on this package can't shadow the new version.
+            cwd: homedir(),
+            env: { ...process.env, [RELAUNCHED_ENV]: "1" },
+        });
+        child.on("error", () => resolve(-1));
+        child.on("exit", (code) => resolve(code ?? 1));
+    });
+}
+/**
+ * Before an interactive command, offers to switch to a newer release.
+ * Returns the exit code of the updated run, or null to carry on with this version.
+ */
+export async function offerUpdate(command, args) {
+    if (!shouldCheckForUpdate(command, args))
+        return null;
+    const current = packageVersion();
+    const latest = await latestVersion();
+    if (!latest || !isNewerVersion(latest, current))
+        return null;
+    console.log(`\n  ${ui.yellow("↑")} ${ui.bold(`brightspace-d2l-mcp v${latest}`)} is out ${ui.dim(`(you have v${current})`)}`);
+    if (!(await ui.confirm("Update now?"))) {
+        ui.info(ui.dim(`Skipped. Run npx -y ${PACKAGE_NAME}@latest ${command} any time to update.`));
+        return null;
+    }
+    ui.info(ui.dim(`Downloading v${latest}...`));
+    const code = await relaunch(latest, command, args);
+    if (code === -1) {
+        ui.warn(`Couldn't start the update. Carrying on with v${current}.`);
+        return null;
+    }
+    if (!process.argv[1]?.includes("_npx")) {
+        ui.info(ui.dim(`To update your installed copy too, run: npm install -g ${PACKAGE_NAME}@latest`));
+    }
+    return code;
+}
+//# sourceMappingURL=update-check.js.map

package/build/index.js

@@ -1,9 +1,18 @@
 #!/usr/bin/env node
-const CLI_COMMANDS = new Set(["setup", "login", "status", "logout", "uninstall", "serve", "config", "help", "--help", "-h", "--version", "-v"]);
-const command = process.argv[2];
+const CLI_COMMANDS = new Set(["setup", "login", "status", "doctor", "logout", "uninstall", "serve", "config", "help", "--help", "-h", "--version", "-v"]);
+// AI apps launch the server with piped stdio. A person typing the bare command in a terminal gets help instead of a silent server.
+const command = process.argv[2] ?? (process.stdin.isTTY ? "help" : undefined);
 if (command && CLI_COMMANDS.has(command)) {
     const { runCli } = await import("./cli/main.js");
-    process.exitCode = await runCli(command, process.argv.slice(3));
+    const { offerUpdate } = await import("./cli/update-check.js");
+    const args = process.argv.slice(3);
+    const code = (await offerUpdate(command, args)) ?? (await runCli(command, args));
+    // Exit as soon as a command finishes. A browser or timer left behind would otherwise keep the terminal busy.
+    // `serve` only returns once its stdio server is running, so it keeps the process alive.
+    if (command === "serve")
+        process.exitCode = code;
+    else
+        process.stdout.write("", () => process.exit(code));
 }
 else {
     const { startServer } = await import("./server.js");

package/build/prompts.js

@@ -0,0 +1,77 @@
+import { z } from "zod";
+function userMessage(text) {
+    return { messages: [{ role: "user", content: { type: "text", text } }] };
+}
+/**
+ * Ready-made starting points that show up as slash commands or prompt pickers in apps that support MCP prompts.
+ * Each one just tells the AI which tools to use and what a good answer looks like.
+ */
+export function registerPrompts(server) {
+    server.registerPrompt("what_should_i_do_now", {
+        title: "What should I work on right now?",
+        description: "Prioritized list of what is left to do, soonest deadline first, skipping anything already handed in.",
+    }, () => userMessage("Call get_todo and tell me what to work on right now. Start with what is due soonest, mention anything overdue " +
+        "that can still be submitted, and skip everything I already handed in. Keep it short, with due dates in my local time."));
+    server.registerPrompt("plan_my_week", {
+        title: "Plan my week",
+        description: "Turns the next seven days of deadlines into a day by day plan.",
+    }, () => userMessage("Call get_todo with daysAhead 7 and build me a day by day plan for this week. Put the heaviest or earliest work first, " +
+        "spread the rest so no day is overloaded, and flag anything that opens late or needs a quiz check. " +
+        "Only include work I have not submitted."));
+    server.registerPrompt("weekly_digest", {
+        title: "Weekly digest",
+        description: "Deadlines, new announcements and recent grades in one summary.",
+    }, () => userMessage("Give me a weekly digest. Use get_todo for what is due, get_whats_new for announcements and newly marked work from the last 7 days, " +
+        "get_calendar_events for exams and events this week, and get_my_grades for the marks themselves. " +
+        "Group it as Due, Events, News and Grades, and keep each part to a few lines."));
+    server.registerPrompt("grade_target", {
+        title: "What do I need to hit my target grade?",
+        description: "Works out the score needed on the remaining work in a course to reach a target.",
+        argsSchema: {
+            course: z.string().optional().describe("Course name or code"),
+            target: z.string().optional().describe("Target grade as a percentage, for example 80"),
+        },
+    }, ({ course, target }) => userMessage(`Use get_my_courses to find ${course ? `my course "${course}"` : "the course I mean (ask me if it is unclear)"}, ` +
+        `then call get_grade_outlook${target ? ` with targetPercent ${target}` : ""}. ` +
+        "Tell me where I stand now, the best and worst final grade I could still get, and the average I need on what is left. " +
+        "If the course has no weights, read get_syllabus to find them."));
+    server.registerPrompt("exam_prep", {
+        title: "Prepare for an exam",
+        description: "Pulls together the syllabus, course content and announcements for one course to build a study plan.",
+        argsSchema: {
+            course: z.string().optional().describe("Course name or code"),
+            examDate: z.string().optional().describe("When the exam is, for example 'next Friday'"),
+        },
+    }, ({ course, examDate }) => userMessage(`Help me prepare for an exam in ${course ? `"${course}"` : "my course (ask which one if unclear)"}${examDate ? `, ${examDate}` : ""}. ` +
+        "Find the course with get_my_courses, then read get_syllabus, get_course_content and get_announcements for what the exam covers. " +
+        "Build a study plan that works back from the exam date, lists the topics and the materials to review for each, " +
+        "and checks get_todo so the plan does not clash with other deadlines."));
+    server.registerPrompt("summarize_assignment", {
+        title: "Summarize an assignment",
+        description: "Reads the instructions and rubric for an assignment and explains what is actually being asked.",
+        argsSchema: {
+            assignment: z.string().optional().describe("Assignment name"),
+            course: z.string().optional().describe("Course name or code"),
+        },
+    }, ({ assignment, course }) => userMessage(`Explain ${assignment ? `the assignment "${assignment}"` : "my next assignment"}${course ? ` in "${course}"` : ""}. ` +
+        "Use get_assignments to find it, then get_assignment_files to read the instructions and rubric. " +
+        "Give me the deliverables, the deadline, how it is marked and a short checklist to work through."));
+    server.registerPrompt("put_deadlines_in_my_calendar", {
+        title: "Put my deadlines in my calendar",
+        description: "Exports upcoming unfinished work as a calendar file.",
+    }, () => userMessage("Call export_due_dates_calendar for the next 30 days and give me the .ics file so I can add my deadlines to my calendar. " +
+        "If you can create calendar events directly with another tool, offer that instead."));
+    server.registerPrompt("catch_me_up", {
+        title: "Catch me up",
+        description: "What changed since you last looked: new announcements, newly marked work, unread discussions.",
+    }, () => userMessage("Call get_whats_new and catch me up. Lead with newly marked work (unread feedback) and use get_my_grades to tell me the marks, " +
+        "then summarize new announcements in a line each, then mention unread discussions and quizzes I have not tried. " +
+        "Skip courses with nothing new."));
+    server.registerPrompt("when_are_my_exams", {
+        title: "When are my exams?",
+        description: "Finds exams, tests and midterms on the course calendars and in announcements.",
+    }, () => userMessage("Find my upcoming exams, tests, midterms and finals. Call get_calendar_events with daysAhead 120, then check " +
+        "get_announcements and get_syllabus for any exam dates that are not on the calendar. List each with course, date, time and location, " +
+        "soonest first, and say where you found it."));
+}
+//# sourceMappingURL=prompts.js.map