brightspace-mcp-server 3.11.13 → 3.11.14

package/README.md

@@ -25,7 +25,7 @@ Works with Claude Desktop, Claude Code, Cursor, ChatGPT Desktop, Windsurf, and a
    ```bash
    npx -y brightspace-mcp-server@latest setup
    ```
-   It asks for your school's Brightspace address, your username and password, and how you normally do two-factor sign-in (phone approval, authenticator code, or a browser window). Your password goes into your computer's own password store (Keychain on Mac, Credential Manager on Windows), never into a file. At the end it connects itself to Claude Desktop, Cursor, Codex, or Claude Code if you have them.
+   It asks for your school's Brightspace address, your username and password, and how you normally do two-factor sign-in (phone approval, authenticator code, or a browser window). Your password goes into your computer's own password store (Keychain on Mac, Credential Manager on Windows), never into a file. At the end it connects itself to Claude Desktop, Cursor, Antigravity, Codex, or Claude Code if you have them. If one of them already has a `brightspace` entry pointing somewhere else (an old local build, a fork), setup shows you that entry and asks before replacing it.
 
    **On a Mac:** when Keychain asks whether `node` may use the saved Brightspace password, choose **Always Allow**, not just Allow. That lets later sign-ins (the `auth` command and questions from your AI app) read it without asking again.
 3. **Restart your AI app and ask it something** — the first question signs you in. If your phone asks you to approve a sign-in, approve it and ask again.

package/build/setup.js

@@ -16,7 +16,7 @@ import { configStoreExists, getConfigStorePath, loadConfigStore, } from "./utils
 import { saveSecureConfig } from "./utils/secure-config.js";
 import { writeFileAtomicSync } from "./utils/atomic-write.js";
 import { AUTH_COMMAND, DOCTOR_COMMAND } from "./utils/commands.js";
-import { cliMcpClients, configureCliMcpClient, isCliAvailable, } from "./utils/mcp-client-cli.js";
+import { classifyRegistration, cliMcpClients, inspectCliMcpClient, isCliAvailable, registerCliMcpClient, serverCommand, } from "./utils/mcp-client-cli.js";
 // ANSI helpers
 const bold = (s) => `\x1b[1m${s}\x1b[0m`;
 const green = (s) => `\x1b[32m${s}\x1b[0m`;
@@ -240,6 +240,9 @@ function isChatGPTInstalled() {
 function getCursorConfigPath() {
     return path.join(os.homedir(), ".cursor", "mcp.json");
 }
+function getAntigravityConfigPath() {
+    return path.join(os.homedir(), ".gemini", "antigravity", "mcp_config.json");
+}
 /**
  * A JSON value we can safely merge a server entry into. An array passes
  * `typeof x === "object"` but drops every added key when it is stringified
@@ -248,6 +251,19 @@ function getCursorConfigPath() {
 function isJsonObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+/** How the client's existing "brightspace" entry compares with ours. */
+export function inspectMcpClient(configPath) {
+    let config;
+    try {
+        config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    }
+    catch {
+        // No file, or one configureMcpClient would replace anyway.
+        return { state: "missing" };
+    }
+    const servers = isJsonObject(config) ? config.mcpServers : undefined;
+    return classifyRegistration(isJsonObject(servers) ? servers.brightspace : undefined);
+}
 export function configureMcpClient(configPath) {
     let config = {};
     // Read existing config if present
@@ -276,17 +292,8 @@ export function configureMcpClient(configPath) {
     const servers = isJsonObject(config.mcpServers) ? config.mcpServers : {};
     config.mcpServers = servers;
     // Add/update brightspace entry
-    // On Windows, npx is a .cmd shim that must be invoked through cmd.exe
-    const isWindows = process.platform === "win32";
-    servers["brightspace"] = isWindows
-        ? {
-            command: "cmd",
-            args: ["/c", "npx", "-y", "brightspace-mcp-server@latest"],
-        }
-        : {
-            command: "npx",
-            args: ["-y", "brightspace-mcp-server@latest"],
-        };
+    const [command, ...args] = serverCommand();
+    servers["brightspace"] = { command, args };
     // Ensure parent directory exists
     const dir = path.dirname(configPath);
     if (!fs.existsSync(dir)) {
@@ -362,6 +369,38 @@ export function buildConfigToSave(existing, answers) {
     return config;
 }
 // ── Auth spawn ─────────────────────────────────────────────────────
+/**
+ * Registers Brightspace in one client, never silently replacing an entry
+ * that points somewhere else: a matching entry is left alone, and a different
+ * one is printed (so it can be restored) and replaced only on a yes.
+ * Resolves true when the client ends up running the expected entry.
+ */
+async function registerWithClient(rl, displayName, existing, write) {
+    if (existing.state === "current") {
+        console.log(green(`  ${displayName} already has Brightspace configured.`));
+        return true;
+    }
+    if (existing.state === "different") {
+        console.log(yellow(`  ${displayName} has "brightspace" pointing at:`));
+        console.log(`    ${existing.current}`);
+        const replace = await ask(rl, `  Replace it with ${serverCommand().join(" ")}? (yes/no): `);
+        if (!/^y(es)?$/i.test(replace)) {
+            console.log(dim(`  Left ${displayName} unchanged.`));
+            return false;
+        }
+    }
+    try {
+        if (write(existing.state === "different")) {
+            console.log(green(`  ${displayName} configured!`));
+            return true;
+        }
+        console.log(yellow(`  Could not configure ${displayName}. See README.md for the manual command.`));
+    }
+    catch (err) {
+        console.log(yellow(`  Could not configure ${displayName}: ${err instanceof Error ? err.message : String(err)}`));
+    }
+    return false;
+}
 function runAuth() {
     const scriptPath = path.resolve(thisDir, "auth-cli.js");
     return new Promise((resolve) => {
@@ -557,15 +596,9 @@ async function main() {
     const claudePath = getClaudeDesktopConfigPath();
     if (claudePath) {
         const configClaude = await ask(rl2, "Would you like to automatically configure Claude Desktop? (yes/no): ");
-        if (/^y(es)?$/i.test(configClaude)) {
-            try {
-                configureMcpClient(claudePath);
-                configuredClients.push("Claude Desktop");
-                console.log(green("  Claude Desktop configured! Restart Claude Desktop to connect."));
-            }
-            catch (err) {
-                console.log(yellow(`  Could not configure Claude Desktop: ${err instanceof Error ? err.message : String(err)}`));
-            }
+        if (/^y(es)?$/i.test(configClaude) &&
+            await registerWithClient(rl2, "Claude Desktop", inspectMcpClient(claudePath), () => configureMcpClient(claudePath))) {
+            configuredClients.push("Claude Desktop");
         }
         console.log("");
     }
@@ -574,15 +607,19 @@ async function main() {
     const cursorExists = fs.existsSync(path.dirname(cursorPath));
     if (cursorExists) {
         const configCursor = await ask(rl2, "Cursor detected. Would you like to configure it too? (yes/no): ");
-        if (/^y(es)?$/i.test(configCursor)) {
-            try {
-                configureMcpClient(cursorPath);
-                configuredClients.push("Cursor");
-                console.log(green("  Cursor configured! Restart Cursor to connect."));
-            }
-            catch (err) {
-                console.log(yellow(`  Could not configure Cursor: ${err instanceof Error ? err.message : String(err)}`));
-            }
+        if (/^y(es)?$/i.test(configCursor) &&
+            await registerWithClient(rl2, "Cursor", inspectMcpClient(cursorPath), () => configureMcpClient(cursorPath))) {
+            configuredClients.push("Cursor");
+        }
+        console.log("");
+    }
+    // ── Antigravity auto-config ──────────────────────────────────────
+    const antigravityPath = getAntigravityConfigPath();
+    if (fs.existsSync(path.dirname(antigravityPath))) {
+        const configAntigravity = await ask(rl2, "Antigravity detected. Would you like to configure it too? (yes/no): ");
+        if (/^y(es)?$/i.test(configAntigravity) &&
+            await registerWithClient(rl2, "Antigravity", inspectMcpClient(antigravityPath), () => configureMcpClient(antigravityPath))) {
+            configuredClients.push("Antigravity");
         }
         console.log("");
     }
@@ -591,18 +628,9 @@ async function main() {
         if (!isCliAvailable(client))
             continue;
         const configureClient = await ask(rl2, `${client.displayName} detected. Configure it automatically? (yes/no): `);
-        if (/^y(es)?$/i.test(configureClient)) {
-            const result = configureCliMcpClient(client);
-            if (result === "failed") {
-                console.log(yellow(`  Could not configure ${client.displayName}. See README.md for the manual command.`));
-            }
-            else {
-                configuredClients.push(client.displayName);
-                const message = result === "already-configured"
-                    ? `  ${client.displayName} already has Brightspace configured.`
-                    : `  ${client.displayName} configured!`;
-                console.log(green(message));
-            }
+        if (/^y(es)?$/i.test(configureClient) &&
+            await registerWithClient(rl2, client.displayName, inspectCliMcpClient(client), (replace) => registerCliMcpClient(client, { replace }))) {
+            configuredClients.push(client.displayName);
         }
         console.log("");
     }

package/build/utils/mcp-client-cli.js

@@ -1,41 +1,111 @@
 import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
 import { PACKAGE_NAME } from "./commands.js";
 function defaultRunCommand(command, args, stdio) {
     const result = spawnSync(command, args, {
-        stdio,
+        stdio: stdio === "pipe" ? ["ignore", "pipe", "ignore"] : stdio,
+        encoding: "utf-8",
         shell: process.platform === "win32",
     });
-    return result.error ? null : result.status;
+    return { status: result.error ? null : result.status, stdout: result.stdout ?? "" };
 }
-export function cliMcpClients(platform = process.platform) {
-    const serverCommand = platform === "win32"
+/** The command every client is registered with. */
+export function serverCommand(platform = process.platform) {
+    // On Windows, npx is a .cmd shim that must be invoked through cmd.exe
+    return platform === "win32"
         ? ["cmd", "/c", "npx", "-y", `${PACKAGE_NAME}@latest`]
         : ["npx", "-y", `${PACKAGE_NAME}@latest`];
+}
+export function classifyRegistration(entry, platform = process.platform) {
+    if (entry === undefined)
+        return { state: "missing" };
+    if (entry === null || typeof entry !== "object") {
+        return { state: "different", current: "(an entry setup could not read)" };
+    }
+    const { command, args } = entry;
+    if (typeof command !== "string") {
+        return { state: "different", current: JSON.stringify(entry) };
+    }
+    const argv = [command, ...(Array.isArray(args) ? args.map(String) : [])];
+    const expected = serverCommand(platform);
+    if (argv.length === expected.length && argv.every((part, i) => part === expected[i])) {
+        return { state: "current" };
+    }
+    return { state: "different", current: argv.join(" ") };
+}
+function readJsonFile(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Codex keeps one global registry; `--json` exposes the entry's command. */
+function readCodexEntry(runCommand) {
+    const lookup = runCommand("codex", ["mcp", "get", "brightspace", "--json"], "pipe");
+    if (lookup.status === 0) {
+        try {
+            const parsed = JSON.parse(lookup.stdout);
+            return parsed.transport ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    // A Codex too old for `--json` still answers the plain lookup.
+    return runCommand("codex", ["mcp", "get", "brightspace"], "ignore").status === 0
+        ? null
+        : undefined;
+}
+/**
+ * Claude Code's `mcp get` resolves local, then project, then user scope from
+ * the current directory, so a project's `.mcp.json` can answer for a user
+ * registration that doesn't exist. Setup registers at user scope, which lives
+ * in the top-level `mcpServers` of `.claude.json`; read that directly.
+ */
+function readClaudeCodeEntry() {
+    const configDir = process.env.CLAUDE_CONFIG_DIR || os.homedir();
+    const config = readJsonFile(path.join(configDir, ".claude.json"));
+    const servers = config?.mcpServers;
+    return servers && typeof servers === "object" ? servers.brightspace : undefined;
+}
+export function cliMcpClients(platform = process.platform) {
+    const command = serverCommand(platform);
     return [
         {
             id: "codex",
             displayName: "Codex Desktop and CLI",
             command: "codex",
-            getArgs: ["mcp", "get", "brightspace"],
-            addArgs: ["mcp", "add", "brightspace", "--", ...serverCommand],
+            addArgs: ["mcp", "add", "brightspace", "--", ...command],
+            removeArgs: ["mcp", "remove", "brightspace"],
+            readEntry: readCodexEntry,
         },
         {
             id: "claude-code",
             displayName: "Claude Code",
             command: "claude",
-            getArgs: ["mcp", "get", "brightspace"],
-            addArgs: ["mcp", "add", "--scope", "user", "brightspace", "--", ...serverCommand],
+            addArgs: ["mcp", "add", "--scope", "user", "brightspace", "--", ...command],
+            removeArgs: ["mcp", "remove", "--scope", "user", "brightspace"],
+            readEntry: readClaudeCodeEntry,
         },
     ];
 }
 export function isCliAvailable(client, runCommand = defaultRunCommand) {
-    return runCommand(client.command, ["--version"], "ignore") === 0;
+    return runCommand(client.command, ["--version"], "ignore").status === 0;
+}
+export function inspectCliMcpClient(client, runCommand = defaultRunCommand) {
+    return classifyRegistration(client.readEntry(runCommand));
 }
-export function configureCliMcpClient(client, runCommand = defaultRunCommand) {
-    if (runCommand(client.command, client.getArgs, "ignore") === 0) {
-        return "already-configured";
+/**
+ * Writes the expected entry. With `replace`, the existing one is removed
+ * first, since `claude mcp add` refuses a name that is already taken.
+ */
+export function registerCliMcpClient(client, { replace }, runCommand = defaultRunCommand) {
+    if (replace && runCommand(client.command, client.removeArgs, "inherit").status !== 0) {
+        return false;
     }
-    return runCommand(client.command, client.addArgs, "inherit") === 0
-        ? "configured"
-        : "failed";
+    return runCommand(client.command, client.addArgs, "inherit").status === 0;
 }

package/package.json

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