brightspace-d2l-mcp 1.0.0

package/build/auth/token-mint.js

@@ -0,0 +1,75 @@
+import { packageVersion } from "../utils/version.js";
+import { log } from "../utils/logger.js";
+const EXPIRED_MARKER = "/d2l/login?sessionExpired=1";
+const USER_AGENT = `brightspace-d2l-mcp/${packageVersion()}`;
+const DEFAULT_TIMEOUT_MS = 15000;
+const transport = (detail) => ({
+    ok: false,
+    reason: "transport",
+    detail,
+});
+function expiredRedirect(location, tokenUrl) {
+    if (!location)
+        return false;
+    try {
+        const target = new URL(location, tokenUrl);
+        return target.origin === new URL(tokenUrl).origin &&
+            target.pathname === "/d2l/login" && target.searchParams.get("sessionExpired") === "1";
+    }
+    catch {
+        return false;
+    }
+}
+export async function mintAccessToken({ baseUrl, cookieHeader, csrfToken, fetchImpl = fetch, timeoutMs = DEFAULT_TIMEOUT_MS, }) {
+    const url = `${baseUrl.replace(/\/+$/, "")}/d2l/lp/auth/oauth2/token`;
+    let status;
+    let body;
+    let location;
+    try {
+        const response = await fetchImpl(url, {
+            method: "POST",
+            headers: {
+                "content-type": "application/x-www-form-urlencoded",
+                cookie: cookieHeader,
+                "x-csrf-token": csrfToken,
+                "User-Agent": USER_AGENT,
+            },
+            body: "scope=*:*:*",
+            signal: AbortSignal.timeout(timeoutMs),
+            redirect: "manual",
+        });
+        status = response.status;
+        body = await response.text();
+        location = response.headers?.get("location") ?? null;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return transport(message);
+    }
+    if (status >= 500 || status === 429)
+        return transport(`HTTP ${status}`);
+    let payload = null;
+    try {
+        payload = JSON.parse(body);
+    }
+    catch {
+        // The known expired-session response is an HTML login redirect.
+    }
+    if (status === 401 || (!payload && body.includes(EXPIRED_MARKER)) ||
+        expiredRedirect(location, url)) {
+        log("DEBUG", "The token mint answered with the session-expired stub");
+        return { ok: false, reason: "sessionExpired" };
+    }
+    if (status < 200 || status >= 300) {
+        return transport(`HTTP ${status}`);
+    }
+    if (!payload) {
+        return transport("the token mint returned an unparseable body");
+    }
+    const accessToken = payload.access_token;
+    if (typeof accessToken !== "string" || accessToken.length === 0) {
+        return transport("the token mint returned no access_token");
+    }
+    return { ok: true, accessToken };
+}
+//# sourceMappingURL=token-mint.js.map

package/build/cli/clients.js

@@ -0,0 +1,344 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { execFileSync, spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { PACKAGE_NAME, SERVER_NAME } from "../utils/paths.js";
+export const APP_IDS = [
+    "claude-desktop",
+    "claude-code",
+    "cursor",
+    "vscode",
+    "windsurf",
+    "codex",
+    "gemini-cli",
+    "cline",
+    "roo-code",
+    "opencode",
+    "zed",
+    "lm-studio",
+    "kiro",
+];
+const home = os.homedir();
+const isWindows = process.platform === "win32";
+const isMac = process.platform === "darwin";
+const exists = (p) => {
+    try {
+        fs.accessSync(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * How AI apps should launch this server: via npx from a published install so it
+ * stays up to date, or the exact file from a local checkout.
+ */
+export function serverEntry() {
+    const entryFile = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "index.js");
+    const fromNpx = /[\\/]_npx[\\/]/.test(entryFile) || process.env.BRIGHTSPACE_MCP_USE_NPX === "1";
+    if (!fromNpx)
+        return { command: process.execPath, args: [entryFile] };
+    return isWindows
+        ? { command: "cmd", args: ["/c", "npx", "-y", `${PACKAGE_NAME}@latest`] }
+        : { command: "npx", args: ["-y", `${PACKAGE_NAME}@latest`] };
+}
+const appData = process.env.APPDATA ?? path.join(home, "AppData", "Roaming");
+const localAppData = process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local");
+const xdgConfig = process.env.XDG_CONFIG_HOME ?? path.join(home, ".config");
+/** Per-OS application support directory (where Electron apps keep settings). */
+function appSupport(name) {
+    if (isWindows)
+        return path.join(appData, name);
+    if (isMac)
+        return path.join(home, "Library", "Application Support", name);
+    return path.join(xdgConfig, name);
+}
+function claudeDesktopFiles() {
+    const files = [];
+    const classic = appSupport("Claude");
+    if (exists(classic))
+        files.push(path.join(classic, "claude_desktop_config.json"));
+    if (isWindows) {
+        // The Microsoft Store build is sandboxed and reads its own copy.
+        try {
+            for (const dir of fs.readdirSync(path.join(localAppData, "Packages"))) {
+                if (!dir.startsWith("Claude_"))
+                    continue;
+                const roaming = path.join(localAppData, "Packages", dir, "LocalCache", "Roaming", "Claude");
+                if (exists(roaming))
+                    files.push(path.join(roaming, "claude_desktop_config.json"));
+            }
+        }
+        catch {
+            // No Store apps.
+        }
+    }
+    return files;
+}
+/** VS Code extension settings, for VS Code and its forks. */
+function extensionSettingsFiles(extensionId, file) {
+    return ["Code", "Cursor", "Windsurf", "VSCodium"]
+        .map((editor) => path.join(appSupport(editor), "User", "globalStorage", extensionId, "settings"))
+        .filter(exists)
+        .map((dir) => path.join(dir, file));
+}
+/** Every supported client found on this machine. */
+export function detectClients() {
+    const found = [];
+    const add = (target, present) => {
+        if (present && target.files.length)
+            found.push(target);
+    };
+    add({ id: "claude-desktop", name: "Claude Desktop", files: claudeDesktopFiles(), format: "json", keyPath: ["mcpServers"], mustBeClosed: true }, true);
+    add({
+        id: "claude-code",
+        name: "Claude Code",
+        files: [path.join(home, ".claude.json")],
+        format: "json",
+        keyPath: ["mcpServers"],
+        shape: (e) => ({ type: "stdio", ...e }),
+    }, exists(path.join(home, ".claude.json")) || exists(path.join(home, ".claude")));
+    add({ id: "cursor", name: "Cursor", files: [path.join(home, ".cursor", "mcp.json")], format: "json", keyPath: ["mcpServers"] }, exists(path.join(home, ".cursor")));
+    add({
+        id: "vscode",
+        name: "VS Code (Copilot)",
+        files: [path.join(appSupport("Code"), "User", "mcp.json")],
+        format: "json",
+        keyPath: ["servers"],
+        shape: (e) => ({ type: "stdio", ...e }),
+    }, exists(path.join(appSupport("Code"), "User")));
+    add({
+        id: "windsurf",
+        name: "Windsurf",
+        files: [path.join(home, ".codeium", "windsurf", "mcp_config.json")],
+        format: "json",
+        keyPath: ["mcpServers"],
+    }, exists(path.join(home, ".codeium", "windsurf")));
+    add({
+        id: "codex",
+        name: "OpenAI Codex",
+        files: [path.join(process.env.CODEX_HOME ?? path.join(home, ".codex"), "config.toml")],
+        format: "toml",
+        keyPath: ["mcp_servers"],
+    }, exists(process.env.CODEX_HOME ?? path.join(home, ".codex")));
+    add({ id: "gemini-cli", name: "Gemini CLI", files: [path.join(home, ".gemini", "settings.json")], format: "json", keyPath: ["mcpServers"] }, exists(path.join(home, ".gemini")));
+    add({
+        id: "cline",
+        name: "Cline",
+        files: extensionSettingsFiles("saoudrizwan.claude-dev", "cline_mcp_settings.json"),
+        format: "json",
+        keyPath: ["mcpServers"],
+    }, true);
+    add({
+        id: "roo-code",
+        name: "Roo Code",
+        files: extensionSettingsFiles("rooveterinaryinc.roo-cline", "mcp_settings.json"),
+        format: "json",
+        keyPath: ["mcpServers"],
+    }, true);
+    add({
+        id: "opencode",
+        name: "OpenCode",
+        files: [path.join(xdgConfig, "opencode", "opencode.json")],
+        format: "json",
+        keyPath: ["mcp"],
+        shape: (e) => ({ type: "local", command: [e.command, ...e.args], enabled: true }),
+    }, exists(path.join(xdgConfig, "opencode")));
+    add({
+        id: "zed",
+        name: "Zed",
+        files: [path.join(isMac || !isWindows ? path.join(xdgConfig, "zed") : path.join(appData, "Zed"), "settings.json")],
+        format: "json",
+        keyPath: ["context_servers"],
+        shape: (e) => ({ source: "custom", ...e }),
+    }, exists(isMac || !isWindows ? path.join(xdgConfig, "zed") : path.join(appData, "Zed")));
+    add({ id: "lm-studio", name: "LM Studio", files: [path.join(home, ".lmstudio", "mcp.json")], format: "json", keyPath: ["mcpServers"] }, exists(path.join(home, ".lmstudio")));
+    add({ id: "kiro", name: "Kiro", files: [path.join(home, ".kiro", "settings", "mcp.json")], format: "json", keyPath: ["mcpServers"] }, exists(path.join(home, ".kiro")));
+    return found;
+}
+function readJson(file) {
+    if (!exists(file))
+        return {};
+    const text = fs.readFileSync(file, "utf8");
+    if (!text.trim())
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error(`${file} has comments or isn't plain JSON, so it wasn't changed. Add the server by hand (run \`npx ${PACKAGE_NAME} config\`).`);
+    }
+}
+function backupOnce(file) {
+    if (exists(file) && !exists(`${file}.bak`))
+        fs.copyFileSync(file, `${file}.bak`);
+}
+function writeText(file, text) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    backupOnce(file);
+    const temp = `${file}.tmp-${process.pid}`;
+    fs.writeFileSync(temp, text);
+    fs.renameSync(temp, file);
+}
+function writeJson(file, data) {
+    writeText(file, JSON.stringify(data, null, 2) + "\n");
+}
+function serverMap(config, keyPath, create) {
+    let node = config;
+    for (const key of keyPath) {
+        if (typeof node[key] !== "object" || node[key] === null) {
+            if (!create)
+                return undefined;
+            node[key] = {};
+        }
+        node = node[key];
+    }
+    return node;
+}
+// Codex keeps MCP servers in TOML tables: [mcp_servers.<name>]
+const tomlString = (s) => JSON.stringify(s);
+function tomlBlock(entry) {
+    const lines = [
+        `[mcp_servers.${SERVER_NAME}]`,
+        `command = ${tomlString(entry.command)}`,
+        `args = [${entry.args.map(tomlString).join(", ")}]`,
+    ];
+    if (entry.env && Object.keys(entry.env).length) {
+        lines.push(`env = { ${Object.entries(entry.env).map(([k, v]) => `${k} = ${tomlString(v)}`).join(", ")} }`);
+    }
+    return lines.join("\n") + "\n";
+}
+function withoutTomlBlock(text) {
+    const header = new RegExp(`^\\[mcp_servers\\.(?:${SERVER_NAME}|"${SERVER_NAME}")\\]\\s*$`, "m");
+    const match = header.exec(text);
+    if (!match)
+        return { text, removed: false };
+    const rest = text.slice(match.index + match[0].length);
+    const next = rest.search(/^\s*\[/m);
+    const end = next === -1 ? text.length : match.index + match[0].length + next;
+    return { text: (text.slice(0, match.index) + text.slice(end)).replace(/\n{3,}/g, "\n\n"), removed: true };
+}
+export function addToClient(client, entry = serverEntry()) {
+    for (const file of client.files) {
+        if (client.format === "toml") {
+            const current = exists(file) ? withoutTomlBlock(fs.readFileSync(file, "utf8")).text.trimEnd() : "";
+            writeText(file, `${current ? `${current}\n\n` : ""}${tomlBlock(entry)}`);
+            continue;
+        }
+        const config = readJson(file);
+        serverMap(config, client.keyPath, true)[SERVER_NAME] = client.shape ? client.shape(entry) : entry;
+        writeJson(file, config);
+    }
+}
+export function removeFromClient(client) {
+    let removed = false;
+    for (const file of client.files) {
+        if (!exists(file))
+            continue;
+        if (client.format === "toml") {
+            const result = withoutTomlBlock(fs.readFileSync(file, "utf8"));
+            if (result.removed) {
+                writeText(file, result.text);
+                removed = true;
+            }
+            continue;
+        }
+        const config = readJson(file);
+        const servers = serverMap(config, client.keyPath, false);
+        if (servers && SERVER_NAME in servers) {
+            delete servers[SERVER_NAME];
+            writeJson(file, config);
+            removed = true;
+        }
+    }
+    return removed;
+}
+export function isConfiguredIn(client) {
+    return client.files.some((file) => {
+        try {
+            if (client.format === "toml")
+                return exists(file) && withoutTomlBlock(fs.readFileSync(file, "utf8")).removed;
+            return SERVER_NAME in (serverMap(readJson(file), client.keyPath, false) ?? {});
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** Lets Claude Code use every Brightspace tool without asking each time. */
+export function allowToolsInClaudeCode() {
+    const file = path.join(home, ".claude", "settings.json");
+    const settings = readJson(file);
+    const permissions = settings.permissions ?? {};
+    const rule = `mcp__${SERVER_NAME}`;
+    if (permissions.allow?.includes(rule))
+        return;
+    permissions.allow = [...(permissions.allow ?? []), rule];
+    settings.permissions = permissions;
+    writeJson(file, settings);
+}
+function desktopProcesses() {
+    try {
+        if (isWindows) {
+            const out = execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command",
+                "Get-Process claude -ErrorAction SilentlyContinue | Where-Object { $_.Path -and ($_.Path -like '*\\WindowsApps\\Claude_*' -or $_.Path -like '*\\AnthropicClaude\\*') } | ForEach-Object { \"$($_.Id)|$($_.Path)\" }"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 15_000 });
+            return out.split(/\r?\n/).filter(Boolean).map((line) => {
+                const [pid, exe] = line.split("|");
+                return { pid: Number(pid), exe };
+            });
+        }
+        if (isMac) {
+            const out = execFileSync("pgrep", ["-x", "Claude"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+            return out.split("\n").filter(Boolean).map((pid) => ({ pid: Number(pid), exe: "/Applications/Claude.app" }));
+        }
+    }
+    catch {
+        // Not running.
+    }
+    return [];
+}
+export function isClaudeDesktopRunning() {
+    return desktopProcesses().length > 0;
+}
+/** Quits Claude Desktop. Returns a function that starts it again. */
+export async function quitClaudeDesktop() {
+    const running = desktopProcesses();
+    const storeExe = running.find((p) => p.exe.includes("\\WindowsApps\\Claude_"))?.exe;
+    const classicExe = running.find((p) => p.exe.includes("AnthropicClaude"))?.exe;
+    if (isMac) {
+        try {
+            execFileSync("osascript", ["-e", 'quit app "Claude"'], { stdio: "ignore", timeout: 15_000 });
+        }
+        catch {
+            // Checked below.
+        }
+    }
+    else {
+        for (const p of running) {
+            try {
+                process.kill(p.pid);
+            }
+            catch {
+                // Already gone.
+            }
+        }
+    }
+    for (let i = 0; i < 30 && isClaudeDesktopRunning(); i++)
+        await new Promise((r) => setTimeout(r, 500));
+    return () => {
+        const detached = { detached: true, stdio: "ignore" };
+        if (isMac) {
+            spawn("open", ["-a", "Claude"], detached).unref();
+        }
+        else if (storeExe) {
+            const family = storeExe.match(/WindowsApps\\(Claude)_[^_\\]+_[^_\\]+__([a-z0-9]+)/i);
+            spawn("explorer.exe", [family ? `shell:AppsFolder\\${family[1]}_${family[2]}!Claude` : storeExe], detached).unref();
+        }
+        else if (classicExe) {
+            spawn(classicExe, [], detached).unref();
+        }
+    };
+}
+//# sourceMappingURL=clients.js.map

package/build/cli/main.js

@@ -0,0 +1,162 @@
+import * as fs from "node:fs";
+import { loadConfig } from "../utils/config.js";
+import { browserProfileDir, dataDir, LOGIN_COMMAND, savedCookiesPath, SETUP_COMMAND } from "../utils/paths.js";
+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 * as ui from "./ui.js";
+function flagValue(args, name) {
+    const index = args.indexOf(name);
+    if (index >= 0)
+        return args[index + 1];
+    const inline = args.find((a) => a.startsWith(`${name}=`));
+    return inline?.slice(name.length + 1);
+}
+export async function runCli(command, args) {
+    switch (command) {
+        case "setup":
+            return runSetup({
+                school: flagValue(args, "--school"),
+                yes: args.includes("--yes") || args.includes("-y"),
+                skipLogin: args.includes("--skip-login"),
+                apps: flagValue(args, "--apps")?.split(",").map((s) => s.trim()),
+            });
+        case "login":
+            return login();
+        case "status":
+            return status();
+        case "logout":
+            await new SessionStore().clear();
+            fs.rmSync(browserProfileDir(), { recursive: true, force: true });
+            fs.rmSync(savedCookiesPath(), { force: true });
+            ui.ok("Signed out. The saved session and browser profile were deleted.");
+            return 0;
+        case "uninstall":
+            return uninstall(args.includes("--yes") || args.includes("-y"));
+        case "serve":
+            return serve(args);
+        case "config":
+            console.log(JSON.stringify({ mcpServers: { brightspace: serverEntry() } }, null, 2));
+            return 0;
+        case "--version":
+        case "-v":
+            console.log(packageVersion());
+            return 0;
+        default:
+            printHelp();
+            return 0;
+    }
+}
+async function login() {
+    const config = loadConfig();
+    if (!config.baseUrl) {
+        ui.fail(`No school set up yet. Run: ${SETUP_COMMAND}`);
+        return 1;
+    }
+    ui.info(`Opening ${ui.bold(config.baseUrl)} in a browser window. Sign in there.`);
+    try {
+        const { token, displayName } = await loginWithBrowser({
+            baseUrl: config.baseUrl,
+            mode: "interactive",
+            tokenTtlSeconds: config.tokenTtl,
+            onStatus: (m) => ui.info(ui.dim(m)),
+        });
+        await new TokenManager({ baseUrl: config.baseUrl }).setToken(token);
+        ui.ok(displayName ? `Signed in as ${ui.bold(displayName)}` : "Signed in");
+        return 0;
+    }
+    catch (error) {
+        ui.fail(error instanceof Error ? error.message : String(error));
+        return error instanceof LoginError && error.kind === "cancelled" ? 2 : 1;
+    }
+}
+async function status() {
+    const config = loadConfig();
+    console.log(`\n${ui.bold("brightspace-d2l-mcp")} ${ui.dim(`v${packageVersion()}`)}`);
+    if (!config.baseUrl) {
+        ui.fail(`Not set up. Run: ${SETUP_COMMAND}`);
+        return 1;
+    }
+    ui.ok(`School: ${config.baseUrl}`);
+    const tokenManager = new TokenManager({ baseUrl: config.baseUrl, tokenTtl: config.tokenTtl });
+    try {
+        const token = await tokenManager.getToken();
+        if (token)
+            ui.ok("Session: signed in");
+        else
+            ui.warn(`Session: expired. It will reopen sign-in when needed, or run: ${LOGIN_COMMAND}`);
+    }
+    catch {
+        ui.warn("Session: couldn't check right now (network).");
+    }
+    const clients = detectClients();
+    if (!clients.length)
+        ui.warn("No supported AI apps found.");
+    for (const client of clients) {
+        if (isConfiguredIn(client))
+            ui.ok(`${client.name}: connected`);
+        else
+            ui.info(`${ui.dim("-")} ${client.name}: not connected ${ui.dim(`(run ${SETUP_COMMAND})`)}`);
+    }
+    console.log();
+    return 0;
+}
+async function serve(args) {
+    const { startServer, startHttpServer } = await import("../server.js");
+    if (!args.includes("--http")) {
+        await startServer();
+        return 0;
+    }
+    const port = Number(flagValue(args, "--port") ?? process.env.PORT ?? 8787);
+    const host = flagValue(args, "--host") ?? "127.0.0.1";
+    const noAuth = args.includes("--no-auth");
+    try {
+        const { url } = await startHttpServer({ port, host, noAuth });
+        console.log(`\n${ui.bold("Brightspace MCP server")} ${ui.dim("(streamable HTTP)")}`);
+        ui.ok(`Listening: ${ui.cyan(url)}`);
+        if (!noAuth) {
+            ui.info(ui.dim("The last part of that URL is your access token. Keep it private."));
+            ui.info(ui.dim("Clients that support headers can use /mcp with  Authorization: Bearer <token>."));
+        }
+        ui.info(ui.dim("Press Ctrl+C to stop."));
+        await new Promise(() => { });
+        return 0;
+    }
+    catch (error) {
+        ui.fail(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}
+async function uninstall(yes) {
+    if (yes)
+        ui.setNonInteractive();
+    if (!(await ui.confirm("Remove Brightspace from your AI apps and delete its saved data?", false)) && !yes)
+        return 0;
+    for (const client of detectClients()) {
+        if (removeFromClient(client))
+            ui.ok(`Removed from ${client.name}`);
+    }
+    fs.rmSync(dataDir(), { recursive: true, force: true });
+    ui.ok(`Deleted ${dataDir()}`);
+    return 0;
+}
+function printHelp() {
+    console.log(`
+${ui.bold("brightspace-d2l-mcp")} ${ui.dim(`v${packageVersion()}`)}  Brightspace (D2L) for Claude, Cursor and other AI apps
+
+  ${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("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(",")}
+`);
+    printManualConfig();
+    console.log();
+}
+//# sourceMappingURL=main.js.map

package/build/cli/school.js

@@ -0,0 +1,74 @@
+import { normalizeSchoolUrl } from "../utils/config.js";
+function otherPlatform(headers) {
+    if (headers.get("x-blackboard-product"))
+        return "Blackboard";
+    if (headers.get("x-canvas-meta") || headers.get("x-canvas-user-id") !== null)
+        return "Canvas";
+    if ([...headers.keys()].some((k) => k.startsWith("x-moodle")))
+        return "Moodle";
+    return null;
+}
+// Brightspace lists its API versions publicly, which makes it easy to recognize.
+async function probe(origin) {
+    try {
+        const response = await fetch(`${origin}/d2l/api/versions/`, { signal: AbortSignal.timeout(10_000), redirect: "manual" });
+        const platform = otherPlatform(response.headers);
+        if (!response.ok)
+            return { result: "no", platform };
+        const body = (await response.json());
+        const isBrightspace = Array.isArray(body) && body.some((p) => p?.ProductCode === "lp");
+        return { result: isBrightspace ? "yes" : "no", platform };
+    }
+    catch (error) {
+        return { result: error?.name === "SyntaxError" ? "no" : "unreachable", platform: null };
+    }
+}
+const IDENTITY_PROVIDER_HOSTS = [
+    "login.microsoftonline.com",
+    "okta.com",
+    "duosecurity.com",
+    "accounts.google.com",
+    "adfs",
+    "sts.",
+    "shibboleth",
+    "idp.",
+    "cas.",
+];
+export async function resolveSchool(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return { ok: false, reason: "Nothing was entered." };
+    // A short name like "yourschool" could be either of the hostnames D2L hands out.
+    const candidates = /^[a-z0-9-]+$/i.test(trimmed)
+        ? [`https://${trimmed}.brightspace.com`, `https://${trimmed}.desire2learn.com`]
+        : [normalizeSchoolUrl(trimmed)].filter((u) => !!u);
+    if (candidates.length === 0)
+        return { ok: false, reason: "That doesn't look like a web address." };
+    let unreachable = false;
+    let platform = null;
+    for (const origin of candidates) {
+        const probed = await probe(origin);
+        if (probed.result === "yes")
+            return { ok: true, baseUrl: origin };
+        if (probed.result === "unreachable")
+            unreachable = true;
+        platform ??= probed.platform;
+    }
+    const host = new URL(candidates[0]).hostname;
+    if (platform) {
+        return { ok: false, reason: `${host} runs ${platform}, not Brightspace (D2L). This tool only works with Brightspace.` };
+    }
+    if (IDENTITY_PROVIDER_HOSTS.some((idp) => host.includes(idp))) {
+        return {
+            ok: false,
+            reason: "That's your school's sign-in page, not Brightspace. Sign in first, then copy the address of your Brightspace home page.",
+        };
+    }
+    return {
+        ok: false,
+        reason: unreachable
+            ? `Couldn't reach ${host}. Check the address and your internet connection.`
+            : `${host} isn't a Brightspace site. Open Brightspace in your browser and copy the address from the address bar.`,
+    };
+}
+//# sourceMappingURL=school.js.map