moodle-cli 0.5.5

package/dist/moodle.js

@@ -0,0 +1,3474 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command, CommanderError } from "commander";
+import { realpathSync } from "fs";
+import { fileURLToPath } from "url";
+
+// src/client.ts
+import { z } from "zod";
+
+// src/constants.ts
+var PACKAGE_NAME = "moodle-cli";
+var NPM_LATEST_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+var GITHUB_RELEASES_URL = "https://github.com/bunizao/moodle-cli/releases/latest";
+var AJAX_SERVICE_PATH = "/lib/ajax/service.php";
+var DASHBOARD_PATH = "/my/";
+var COURSE_PATH = "/course/view.php";
+var ASSIGN_VIEW_PATH = "/mod/assign/view.php";
+var QUIZ_VIEW_PATH = "/mod/quiz/view.php";
+var RESOURCE_VIEW_PATH = "/mod/resource/view.php";
+var URL_VIEW_PATH = "/mod/url/view.php";
+var PAGE_VIEW_PATH = "/mod/page/view.php";
+var FOLDER_VIEW_PATH = "/mod/folder/view.php";
+var FORUM_DISCUSS_PATH = "/mod/forum/discuss.php";
+var FORUM_VIEW_PATH = "/mod/forum/view.php";
+var GRADE_REPORT_INDEX_PATH = "/grade/report/index.php";
+var GRADE_REPORT_OVERVIEW_PATH = "/grade/report/overview/index.php";
+var GRADE_REPORT_PATH = "/grade/report/user/index.php";
+var LOGIN_PATH = "/login/index.php";
+var FUNC_GET_SITE_INFO = "core_webservice_get_site_info";
+var FUNC_GET_COURSES = "core_enrol_get_users_courses";
+var FUNC_GET_COURSES_BY_TIMELINE = "core_course_get_enrolled_courses_by_timeline_classification";
+var FUNC_GET_COURSE_CONTENTS = "core_course_get_contents";
+var FUNC_GET_ACTION_EVENTS = "core_calendar_get_action_events_by_timesort";
+var FUNC_GET_POPUP_NOTIFICATIONS = "message_popup_get_popup_notifications";
+var FUNC_GET_CONVERSATION_COUNTS = "core_message_get_conversation_counts";
+var FUNC_GET_UNREAD_CONVERSATION_COUNTS = "core_message_get_unread_conversation_counts";
+var FUNC_GET_DISCUSSION_POSTS = "mod_forum_get_discussion_posts";
+var CONFIG_FILENAME = "config.yaml";
+var CONFIG_DIR_NAME = ".config/moodle-cli";
+var CACHE_DIR_NAME = ".cache/moodle-cli";
+var SESSION_CACHE_FILENAME = "session.json";
+var DEFAULT_SESSION_CACHE_TTL_MS = 2 * 60 * 60 * 1e3;
+var ENV_MOODLE_SESSION = "MOODLE_SESSION";
+var ENV_MOODLE_BASE_URL = "MOODLE_BASE_URL";
+var MOODLE_SESSION_COOKIE_PREFIX = "MoodleSession";
+var OKTA_AUTH_URL = "https://github.com/bunizao/okta-auth";
+var OKTA_AUTH_INSTALL_COMMAND = "uv tool install okta-auth-cli";
+var OKTA_AUTH_CONFIG_COMMAND = "okta config";
+
+// src/auth.ts
+import { execFile as execFileCallback } from "child_process";
+import { copyFile, mkdtemp, readdir, rm as rm2, stat } from "fs/promises";
+import { homedir as homedir2, tmpdir } from "os";
+import { basename, join as join2 } from "path";
+
+// src/errors.ts
+var CliError = class extends Error {
+  code;
+  exitCode;
+  hint;
+  constructor(message, code = "unexpected_error", exitCode = 1, hint) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.exitCode = exitCode;
+    this.hint = hint;
+  }
+};
+var AuthError = class extends CliError {
+  constructor(message, hint) {
+    super(message, "auth_failed", 2, hint);
+  }
+};
+var ConfigError = class extends CliError {
+  constructor(message, hint) {
+    super(message, "config_error", 2, hint);
+  }
+};
+var UsageError = class extends CliError {
+  constructor(message, hint) {
+    super(message, "usage_error", 3, hint);
+  }
+};
+var NotFoundError = class extends CliError {
+  constructor(message, hint) {
+    super(message, "not_found", 4, hint);
+  }
+};
+var MoodleAPIError = class extends CliError {
+  moodleErrorCode;
+  constructor(message, moodleErrorCode) {
+    super(message, "api_error", 1);
+    this.moodleErrorCode = moodleErrorCode;
+  }
+};
+function isLoginRequiredError(error) {
+  if (!(error instanceof MoodleAPIError)) {
+    return false;
+  }
+  return ["servicerequireslogin", "sitepolicynotagreed"].includes(error.moodleErrorCode ?? "");
+}
+function toCliError(error) {
+  if (error instanceof CliError) {
+    return error;
+  }
+  if (error instanceof Error) {
+    return new CliError(error.message);
+  }
+  return new CliError(String(error));
+}
+
+// src/session-cache.ts
+import { chmod, mkdir, readFile, rm, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var nodeFs = { readFile, writeFile, mkdir, rm, chmod };
+function sessionCachePath(homeDir = homedir()) {
+  return join(homeDir, CACHE_DIR_NAME, SESSION_CACHE_FILENAME);
+}
+function isCachedSessionFresh(session, ttlMs = DEFAULT_SESSION_CACHE_TTL_MS, now = Date.now) {
+  const age = now() - session.savedAt;
+  return age >= 0 && age <= ttlMs;
+}
+async function readCachedSession(baseUrl, options = {}) {
+  if (options.noCache) {
+    return null;
+  }
+  const fs = options.fs ?? nodeFs;
+  const path3 = sessionCachePath(options.homeDir);
+  let raw;
+  try {
+    raw = await fs.readFile(path3, "utf8");
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return null;
+    }
+    throw error;
+  }
+  const session = parseCachedSession(raw);
+  if (!session || !sameBaseUrl(session.baseUrl, baseUrl)) {
+    return null;
+  }
+  const ttlMs = options.ttlMs ?? DEFAULT_SESSION_CACHE_TTL_MS;
+  return isCachedSessionFresh(session, ttlMs, options.now ?? Date.now) ? session : null;
+}
+async function writeCachedSession(session, options = {}) {
+  const fs = options.fs ?? nodeFs;
+  const path3 = sessionCachePath(options.homeDir);
+  await fs.mkdir(dirname(path3), { recursive: true, mode: 448 });
+  await fs.writeFile(path3, `${JSON.stringify(session, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+  await fs.chmod(path3, 384);
+}
+async function deleteCachedSession(baseUrl, options = {}) {
+  const current = await readCachedSession(baseUrl, { ...options, noCache: false, ttlMs: Number.MAX_SAFE_INTEGER });
+  if (!current) {
+    return;
+  }
+  const fs = options.fs ?? nodeFs;
+  try {
+    await fs.rm(sessionCachePath(options.homeDir), { force: true });
+  } catch (error) {
+    if (!isMissingFileError(error)) {
+      throw error;
+    }
+  }
+}
+function parseCachedSession(raw) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!isRecord(value)) {
+    return null;
+  }
+  const session = value;
+  if (typeof session.baseUrl !== "string" || typeof session.cookieName !== "string" || typeof session.cookieValue !== "string" || typeof session.sesskey !== "string" || typeof session.userid !== "number" || typeof session.savedAt !== "number") {
+    return null;
+  }
+  return {
+    baseUrl: session.baseUrl,
+    cookieName: session.cookieName,
+    cookieValue: session.cookieValue,
+    sesskey: session.sesskey,
+    userid: session.userid,
+    savedAt: session.savedAt
+  };
+}
+function sameBaseUrl(left, right) {
+  try {
+    return new URL(left).origin === new URL(right).origin;
+  } catch {
+    return left === right;
+  }
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isMissingFileError(error) {
+  return isRecord(error) && error.code === "ENOENT";
+}
+
+// src/auth.ts
+async function getAuthenticatedSession(baseUrl, options = {}) {
+  const envSession = loadSessionFromEnv(options.env);
+  const validate = options.validateSession ?? validateSessionWithFetch(options);
+  if (envSession) {
+    const context = await validate(baseUrl, envSession);
+    if (!context) {
+      throw new AuthError(
+        `${ENV_MOODLE_SESSION} is set but did not authenticate for ${baseUrl}.`,
+        authFailureHint(baseUrl)
+      );
+    }
+    await refreshSessionCache(baseUrl, envSession, context, options);
+    return { baseUrl, cookie: envSession, ...context, fromCache: false };
+  }
+  const cached = await readCache(baseUrl, options);
+  if (cached) {
+    return cached;
+  }
+  const browserProvider = options.browserCookieProvider ?? defaultBrowserCookieProvider;
+  const browserCookies = matchingMoodleSessionCookies(await browserProvider(baseUrl, options), baseUrl);
+  const browserSession = await firstValidSession(baseUrl, browserCookies, validate);
+  if (browserSession) {
+    await refreshSessionCache(baseUrl, browserSession.cookie, browserSession.context, options);
+    return { baseUrl, cookie: browserSession.cookie, ...browserSession.context, fromCache: false };
+  }
+  const oktaProvider = options.oktaCookieProvider ?? loadSessionsFromOktaCli;
+  const oktaCookies = matchingMoodleSessionCookies(await oktaProvider(baseUrl, options), baseUrl);
+  const oktaSession = await firstValidSession(baseUrl, oktaCookies, validate);
+  if (oktaSession) {
+    await refreshSessionCache(baseUrl, oktaSession.cookie, oktaSession.context, options);
+    return { baseUrl, cookie: oktaSession.cookie, ...oktaSession.context, fromCache: false };
+  }
+  if (!options.oktaCookieProvider && oktaCookies.length) {
+    const refreshed = matchingMoodleSessionCookies(
+      await loadSessionsFromOktaCli(baseUrl, { ...options, oktaCookieProvider: void 0, noCache: true }, true),
+      baseUrl
+    );
+    const refreshedSession = await firstValidSession(baseUrl, refreshed, validate);
+    if (refreshedSession) {
+      await refreshSessionCache(baseUrl, refreshedSession.cookie, refreshedSession.context, options);
+      return { baseUrl, cookie: refreshedSession.cookie, ...refreshedSession.context, fromCache: false };
+    }
+  }
+  throw new AuthError(`No usable MoodleSession found for ${baseUrl}.`, authFailureHint(baseUrl));
+}
+function loadSessionFromEnv(env = process.env) {
+  const value = env[ENV_MOODLE_SESSION]?.trim();
+  return value ? { name: MOODLE_SESSION_COOKIE_PREFIX, value, source: "env" } : null;
+}
+function matchingMoodleSessionCookies(cookies, baseUrl) {
+  const host = new URL(baseUrl).hostname.toLowerCase();
+  const ranked = [];
+  const seen = /* @__PURE__ */ new Set();
+  cookies.forEach((cookie, index) => {
+    if (!cookie.name.startsWith(MOODLE_SESSION_COOKIE_PREFIX) || !cookie.value) {
+      return;
+    }
+    const rank = cookieHostRank(cookie.domain, host);
+    if (rank === null) {
+      return;
+    }
+    const key = `${cookie.name}\0${cookie.value}`;
+    if (seen.has(key)) {
+      return;
+    }
+    seen.add(key);
+    ranked.push({ cookie, rank, index });
+  });
+  return ranked.sort((left, right) => left.rank - right.rank || left.index - right.index).map(({ cookie }) => cookie);
+}
+async function defaultBrowserCookieProvider(baseUrl, options = {}) {
+  const chromiumCookies = await loadChromiumCookies(baseUrl, options);
+  const firefoxCookies = await loadFirefoxCookies(options);
+  return [...chromiumCookies, ...firefoxCookies];
+}
+async function loadSessionsFromOktaCli(baseUrl, options = {}, forceLogin = false) {
+  const execFile = options.execFile ?? defaultExecFile;
+  const executable = await findExecutable("okta", execFile, options.platform);
+  if (!executable) {
+    return [];
+  }
+  const stored = await readOktaCookies(executable, baseUrl, execFile);
+  if (stored.length && !forceLogin) {
+    return stored;
+  }
+  const login = await runOktaJson(executable, ["login", baseUrl], execFile);
+  if (!login) {
+    return stored;
+  }
+  const refreshed = await readOktaCookies(executable, baseUrl, execFile);
+  return refreshed.length ? refreshed : stored;
+}
+function authFailureHint(baseUrl) {
+  return [
+    `Log in to ${loginUrl(baseUrl)} in your browser, then rerun the command.`,
+    `Or set ${ENV_MOODLE_SESSION} to a valid MoodleSession cookie value.`,
+    `For automatic login, install okta-auth: ${OKTA_AUTH_INSTALL_COMMAND}, then run ${OKTA_AUTH_CONFIG_COMMAND}.`,
+    `okta-auth: ${OKTA_AUTH_URL}`
+  ].join("\n");
+}
+function parseSessionContext(html) {
+  const sesskey = firstMatch(html, [
+    /"sesskey"\s*:\s*"([^"]+)"/,
+    /\bsesskey\s*:\s*'([^']+)'/,
+    /name=["']sesskey["'][^>]*value=["']([^"']+)["']/i,
+    /value=["']([^"']+)["'][^>]*name=["']sesskey["']/i
+  ]);
+  if (!sesskey) {
+    return null;
+  }
+  const useridRaw = firstMatch(html, [
+    /"userid"\s*:\s*(\d+)/,
+    /\buserid\s*:\s*(\d+)/,
+    /data-userid=["'](\d+)["']/i
+  ]);
+  return { sesskey: decodeHtml(sesskey), userid: useridRaw ? Number(useridRaw) : 0 };
+}
+function validateSessionWithFetch(options) {
+  return async (baseUrl, cookie) => {
+    const fetcher = options.fetch ?? globalThis.fetch;
+    if (!fetcher) {
+      throw new AuthError("fetch is not available in this runtime.", authFailureHint(baseUrl));
+    }
+    let response;
+    try {
+      response = await fetcher(`${baseUrl}${DASHBOARD_PATH}`, {
+        redirect: "follow",
+        headers: { cookie: `${cookie.name}=${cookie.value}` }
+      });
+    } catch {
+      return null;
+    }
+    if (response.status >= 400 || isLoginRedirect(response.url, baseUrl)) {
+      return null;
+    }
+    const html = await response.text();
+    if (looksLikeLoginPage(html)) {
+      return null;
+    }
+    return parseSessionContext(html);
+  };
+}
+async function loadChromiumCookies(baseUrl, options) {
+  const chrome = await importChromeCookiesSecure();
+  if (!chrome) {
+    return [];
+  }
+  const cookies = [];
+  for (const browser of ["Chrome", "Brave", "Edge"]) {
+    for (const cookieFile of await chromiumCookieFiles(browser, options)) {
+      try {
+        const items = await chrome.getCookiesPromised(baseUrl, "puppeteer", cookieFile);
+        cookies.push(
+          ...items.map((cookie) => ({
+            name: cookie.name,
+            value: cookie.value,
+            domain: cookie.domain,
+            path: cookie.path,
+            source: `${browser}:${basename(cookieFile)}`
+          }))
+        );
+      } catch {
+        continue;
+      }
+    }
+  }
+  return cookies;
+}
+async function loadFirefoxCookies(options) {
+  const execFile = options.execFile ?? defaultExecFile;
+  const sqlite = await findExecutable("sqlite3", execFile, options.platform);
+  if (!sqlite) {
+    return [];
+  }
+  const cookies = [];
+  for (const cookieFile of await firefoxCookieFiles(options)) {
+    const tempDir = await mkdtemp(join2(tmpdir(), "moodle-cli-firefox-"));
+    const tempDb = join2(tempDir, "cookies.sqlite");
+    try {
+      await copyFile(cookieFile, tempDb);
+      const result = await execFile(sqlite, [
+        "-json",
+        tempDb,
+        "select name, value, host as domain, path from moz_cookies where name like 'MoodleSession%';"
+      ]);
+      if (result.exitCode !== 0 || !result.stdout.trim()) {
+        continue;
+      }
+      const rows = JSON.parse(result.stdout);
+      if (!Array.isArray(rows)) {
+        continue;
+      }
+      cookies.push(
+        ...rows.filter(isRecord2).map((row) => ({
+          name: String(row.name ?? ""),
+          value: String(row.value ?? ""),
+          domain: typeof row.domain === "string" ? row.domain : void 0,
+          path: typeof row.path === "string" ? row.path : void 0,
+          source: `Firefox:${basename(cookieFile)}`
+        }))
+      );
+    } catch {
+      continue;
+    } finally {
+      await rm2(tempDir, { recursive: true, force: true });
+    }
+  }
+  return cookies;
+}
+async function chromiumCookieFiles(browser, options) {
+  const files = [];
+  for (const root of chromiumUserDataDirs(browser, options)) {
+    const profiles = await profileDirs(root);
+    for (const profile of profiles) {
+      for (const relative of ["Cookies", "Network/Cookies"]) {
+        const file = join2(root, profile, relative);
+        if (await isFile(file)) {
+          files.push(file);
+        }
+      }
+    }
+  }
+  return files;
+}
+function chromiumUserDataDirs(browser, options) {
+  const home = options.homeDir ?? homedir2();
+  const platform = options.platform ?? process.platform;
+  const dirs = {
+    darwin: {
+      Chrome: ["Library/Application Support/Google/Chrome"],
+      Brave: ["Library/Application Support/BraveSoftware/Brave-Browser"],
+      Edge: ["Library/Application Support/Microsoft Edge"]
+    },
+    linux: {
+      Chrome: [".config/google-chrome", ".var/app/com.google.Chrome/config/google-chrome"],
+      Brave: [".config/BraveSoftware/Brave-Browser", ".var/app/com.brave.Browser/config/BraveSoftware/Brave-Browser"],
+      Edge: [".config/microsoft-edge"]
+    },
+    win32: {
+      Chrome: ["AppData/Local/Google/Chrome/User Data"],
+      Brave: ["AppData/Local/BraveSoftware/Brave-Browser/User Data"],
+      Edge: ["AppData/Local/Microsoft/Edge/User Data"]
+    }
+  };
+  return [...dirs[platform]?.[browser] ?? []].map((part) => join2(home, part));
+}
+async function firefoxCookieFiles(options) {
+  const home = options.homeDir ?? homedir2();
+  const platform = options.platform ?? process.platform;
+  const roots = {
+    darwin: ["Library/Application Support/Firefox/Profiles"],
+    linux: [".mozilla/firefox"],
+    win32: ["AppData/Roaming/Mozilla/Firefox/Profiles"]
+  };
+  const files = [];
+  for (const rootPart of roots[platform] ?? []) {
+    const root = join2(home, rootPart);
+    for (const profile of await profileDirs(root, true)) {
+      const file = join2(root, profile, "cookies.sqlite");
+      if (await isFile(file)) {
+        files.push(file);
+      }
+    }
+  }
+  return files;
+}
+async function profileDirs(root, allowAnyDirectory = false) {
+  let entries;
+  try {
+    entries = await readdir(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => allowAnyDirectory || name === "Default" || name === "Guest Profile" || name.startsWith("Profile "));
+}
+async function isFile(path3) {
+  try {
+    return (await stat(path3)).isFile();
+  } catch {
+    return false;
+  }
+}
+async function importChromeCookiesSecure() {
+  try {
+    const dynamicImport = new Function("specifier", "return import(specifier)");
+    const module = await dynamicImport("chrome-cookies-secure");
+    return module.default ?? module;
+  } catch {
+    return null;
+  }
+}
+async function readOktaCookies(executable, baseUrl, execFile) {
+  const payload = await runOktaJson(executable, ["cookies", baseUrl], execFile);
+  if (!payload) {
+    return [];
+  }
+  const cookies = Array.isArray(payload.cookies) ? payload.cookies : Array.isArray(payload) ? payload : [];
+  return cookies.filter(isRecord2).map((cookie) => ({
+    name: String(cookie.name ?? ""),
+    value: String(cookie.value ?? ""),
+    domain: typeof cookie.domain === "string" ? cookie.domain : void 0,
+    path: typeof cookie.path === "string" ? cookie.path : void 0,
+    source: "okta"
+  }));
+}
+async function runOktaJson(executable, args, execFile) {
+  const result = await execFile(executable, [...args, "--json"]);
+  if (result.exitCode !== 0 || !result.stdout.trim()) {
+    return null;
+  }
+  try {
+    const payload = JSON.parse(result.stdout);
+    return isRecord2(payload) ? payload : null;
+  } catch {
+    return null;
+  }
+}
+async function findExecutable(name, execFile, platform = process.platform) {
+  const command = platform === "win32" ? "where" : "which";
+  const result = await execFile(command, [name]);
+  if (result.exitCode !== 0) {
+    return null;
+  }
+  return result.stdout.split(/\r?\n/, 1)[0]?.trim() || null;
+}
+async function firstValidSession(baseUrl, cookies, validate) {
+  for (const cookie of cookies) {
+    const context = await validate(baseUrl, cookie);
+    if (context) {
+      return { cookie, context };
+    }
+  }
+  return null;
+}
+async function readCache(baseUrl, options) {
+  try {
+    const cached = await readCachedSession(baseUrl, cacheOptions(options));
+    return cached ? cachedSessionToAuth(baseUrl, cached) : null;
+  } catch {
+    return null;
+  }
+}
+async function refreshSessionCache(baseUrl, cookie, context, options) {
+  const session = {
+    baseUrl,
+    cookieName: cookie.name,
+    cookieValue: cookie.value,
+    sesskey: context.sesskey,
+    userid: context.userid,
+    savedAt: (options.now ?? Date.now)()
+  };
+  try {
+    await writeCachedSession(session, cacheOptions(options));
+  } catch {
+    return;
+  }
+}
+function cachedSessionToAuth(baseUrl, cached) {
+  return {
+    baseUrl,
+    cookie: { name: cached.cookieName, value: cached.cookieValue, source: "cache" },
+    sesskey: cached.sesskey,
+    userid: cached.userid,
+    fromCache: true
+  };
+}
+function cacheOptions(options) {
+  return {
+    homeDir: options.homeDir,
+    ttlMs: options.cacheTtlMs,
+    now: options.now,
+    noCache: options.noCache
+  };
+}
+function cookieHostRank(domain, host) {
+  if (!domain) {
+    return 2;
+  }
+  const normalized = domain.replace(/^\./, "").toLowerCase();
+  if (normalized === host) {
+    return 0;
+  }
+  if (host.endsWith(`.${normalized}`)) {
+    return 1;
+  }
+  return null;
+}
+function loginUrl(baseUrl) {
+  return new URL(LOGIN_PATH, `${baseUrl.replace(/\/+$/, "")}/`).toString();
+}
+function isLoginRedirect(responseUrl, baseUrl) {
+  if (!responseUrl) {
+    return false;
+  }
+  const path3 = new URL(responseUrl, baseUrl).pathname;
+  return path3 === LOGIN_PATH || path3.startsWith("/login/");
+}
+function looksLikeLoginPage(html) {
+  return /name=["']username["']/i.test(html) && /name=["']password["']/i.test(html);
+}
+function firstMatch(value, patterns) {
+  for (const pattern of patterns) {
+    const match = value.match(pattern);
+    if (match?.[1]) {
+      return match[1];
+    }
+  }
+  return null;
+}
+function decodeHtml(value) {
+  return value.replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">");
+}
+var defaultExecFile = (file, args) => new Promise((resolve) => {
+  execFileCallback(file, args, { encoding: "utf8" }, (error, stdout, stderr) => {
+    const errorWithCode = error;
+    resolve({
+      stdout: String(stdout ?? ""),
+      stderr: String(stderr ?? ""),
+      exitCode: errorWithCode ? Number(errorWithCode.code) || 1 : 0
+    });
+  });
+});
+function isRecord2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/parsers.ts
+function schema(parser) {
+  return { parse: parser };
+}
+var UserInfoSchema = schema(parseUserInfo);
+var CourseSchema = schema(parseCourse);
+var CoursesSchema = schema(parseCourses);
+var ActivitySchema = schema(parseActivity);
+var SectionSchema = schema(parseSection);
+var CourseContentsSchema = schema(parseCourseContents);
+var TodoItemSchema = schema(parseTodoItem);
+function parseUserInfo(value) {
+  const data = asRecord(value);
+  return {
+    userid: numberValue(data.userid),
+    username: stringValue(data.username),
+    fullname: stringValue(data.fullname),
+    sitename: stringValue(data.sitename),
+    siteurl: stringValue(data.siteurl),
+    lang: stringValue(data.lang)
+  };
+}
+function parseCourse(value, nowSeconds = Math.floor(Date.now() / 1e3)) {
+  const data = asRecord(value);
+  const course = {
+    id: numberValue(data.id),
+    shortname: stringValue(data.shortname),
+    fullname: stringValue(data.fullname),
+    category: numberValue(data.category),
+    visible: booleanValue(data.visible, true),
+    startdate: numberValue(data.startdate)
+  };
+  const enddate = numberValue(data.enddate);
+  if (enddate > nowSeconds) {
+    course.enddate = enddate;
+  }
+  return course;
+}
+function parseCourses(value) {
+  return asArray(value).map((item) => parseCourse(item));
+}
+function parseActivity(value) {
+  const data = asRecord(value);
+  return {
+    id: numberValue(data.id),
+    name: stringValue(data.name),
+    modname: stringValue(data.modname),
+    url: stringValue(data.url),
+    visible: booleanValue(data.visible, true),
+    description: stringValue(data.description)
+  };
+}
+function parseSection(value) {
+  const data = asRecord(value);
+  return {
+    id: numberValue(data.id),
+    name: stringValue(data.name),
+    section: numberValue(data.section),
+    visible: booleanValue(data.visible, true),
+    summary: stringValue(data.summary),
+    activities: asArray(data.modules).map((item) => parseActivity(item))
+  };
+}
+function parseCourseContents(value) {
+  return asArray(value).map((item) => parseSection(item));
+}
+function parseTodoItem(value) {
+  const data = asRecord(value);
+  const course = asRecord(data.course);
+  const action = asRecord(data.action);
+  const progress = course.progress;
+  return {
+    id: numberValue(data.id),
+    name: stringValue(data.name),
+    activity_name: stringValue(data.activityname),
+    modname: stringValue(data.modulename),
+    course_id: numberValue(course.id),
+    course_name: stringValue(course.fullname),
+    due_at: numberValue(data.timesort) || numberValue(data.timestart),
+    overdue: booleanValue(data.overdue),
+    actionable: booleanValue(action.actionable),
+    action_name: stringValue(action.name),
+    action_url: stringValue(action.url),
+    url: stringValue(data.url),
+    event_type: stringValue(data.eventtype),
+    course_progress: typeof progress === "number" ? progress : void 0
+  };
+}
+function parseTodoItems(value) {
+  return asArray(value).map((item) => parseTodoItem(item));
+}
+function parseAlertNotification(value) {
+  const data = asRecord(value);
+  return {
+    id: numberValue(data.id),
+    subject: stringValue(data.subject),
+    short_subject: stringValue(data.shortenedsubject),
+    event_type: stringValue(data.eventtype),
+    component: stringValue(data.component),
+    created_at: numberValue(data.timecreated),
+    created_pretty: stringValue(data.timecreatedpretty),
+    read: booleanValue(data.read),
+    context_url: stringValue(data.contexturl),
+    context_name: stringValue(data.contexturlname)
+  };
+}
+function parseAlertSummary(notificationsData, countsData, unreadCountsData) {
+  const notificationsRecord = asRecord(notificationsData);
+  const counts = asRecord(countsData);
+  const unreadCounts = asRecord(unreadCountsData);
+  const types = asRecord(counts.types);
+  const unreadTypes = asRecord(unreadCounts.types);
+  const notifications = asArray(notificationsRecord.notifications).map((item) => parseAlertNotification(item));
+  return {
+    notifications,
+    notification_count: notifications.length,
+    unread_notification_count: notifications.filter((notification) => !notification.read).length,
+    starred_message_count: numberValue(counts.favourites),
+    direct_message_count: numberValue(types["1"]),
+    group_message_count: numberValue(types["2"]),
+    self_message_count: numberValue(types["3"]),
+    unread_starred_message_count: numberValue(unreadCounts.favourites),
+    unread_direct_message_count: numberValue(unreadTypes["1"]),
+    unread_group_message_count: numberValue(unreadTypes["2"]),
+    unread_self_message_count: numberValue(unreadTypes["3"])
+  };
+}
+function parseForumPostAuthor(value) {
+  const data = asRecord(value);
+  const urls = asRecord(data.urls);
+  return {
+    id: numberValue(data.id),
+    fullname: stringValue(data.fullname),
+    profile_url: stringValue(urls.profile),
+    profile_image_url: stringValue(urls.profileimage)
+  };
+}
+function parseForumPost(value) {
+  const data = asRecord(value);
+  const urls = asRecord(data.urls);
+  return {
+    id: numberValue(data.id),
+    discussion_id: numberValue(data.discussionid),
+    subject: stringValue(data.subject),
+    message_html: stringValue(data.message),
+    message_text: stringValue(data.message).replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim(),
+    image_urls: [],
+    links: [],
+    tables: [],
+    author: parseForumPostAuthor(data.author),
+    parent_id: numberValue(data.parentid),
+    time_created: numberValue(data.timecreated),
+    time_modified: numberValue(data.timemodified),
+    created_pretty: "",
+    unread: booleanValue(data.unread),
+    is_deleted: booleanValue(data.isdeleted),
+    is_private_reply: booleanValue(data.isprivatereply),
+    url: stringValue(urls.view || urls.viewisolated),
+    reply_url: stringValue(urls.reply)
+  };
+}
+function parseForumDiscussion(value, discussionId) {
+  const data = asRecord(value);
+  const posts = asArray(data.posts).map((item) => parseForumPost(item));
+  return {
+    id: discussionId,
+    subject: posts[0]?.subject ?? "",
+    course_id: numberValue(data.courseid),
+    forum_id: numberValue(data.forumid),
+    group_id: numberValue(data.groupid),
+    group_name: stringValue(data.groupname),
+    url: posts[0]?.url ? posts[0].url.split("#", 1)[0] : "",
+    posts
+  };
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function stringValue(value) {
+  return typeof value === "string" ? value : value == null ? "" : String(value);
+}
+function numberValue(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim() !== "" && Number.isFinite(Number(value))) {
+    return Number(value);
+  }
+  return 0;
+}
+function booleanValue(value, defaultValue = false) {
+  if (value === void 0 || value === null) {
+    return defaultValue;
+  }
+  return Boolean(value);
+}
+
+// src/scraper.ts
+import { parse as parse2 } from "node-html-parser";
+
+// src/html-utils.ts
+import { parse } from "node-html-parser";
+function htmlToStructuredContent(html, baseUrl) {
+  if (!html) {
+    return { text: "", image_urls: [], links: [], tables: [] };
+  }
+  const root = parse(html);
+  const image_urls = [];
+  const links = [];
+  const tables = [];
+  for (const br of root.querySelectorAll("br")) {
+    br.replaceWith("\n");
+  }
+  for (const img of root.querySelectorAll("img")) {
+    const src = (img.getAttribute("src") ?? "").trim();
+    if (!src) {
+      img.replaceWith("[image]");
+      continue;
+    }
+    const absolute = resolveUrl(baseUrl, src);
+    image_urls.push(absolute);
+    const label = (img.getAttribute("alt") ?? "").trim() || "image";
+    img.replaceWith(`[${label}] ${absolute}`);
+  }
+  for (const link of root.querySelectorAll("a[href]")) {
+    const href = (link.getAttribute("href") ?? "").trim();
+    if (!href) {
+      continue;
+    }
+    links.push({ text: cleanText(link.textContent), url: resolveUrl(baseUrl, href) });
+  }
+  for (const table of root.querySelectorAll("table")) {
+    const headers = [];
+    const rows = [];
+    for (const row of table.querySelectorAll("tr")) {
+      const headerCells = row.querySelectorAll("th");
+      const dataCells = row.querySelectorAll("td");
+      const cells = headerCells.length ? headerCells : dataCells;
+      if (!cells.length) {
+        continue;
+      }
+      const values = cells.map((cell) => cleanText(cell.textContent));
+      if (headerCells.length && !headers.length && !rows.length) {
+        headers.push(...values);
+      } else {
+        rows.push(values);
+      }
+    }
+    if (headers.length || rows.length) {
+      tables.push({ headers, rows });
+    }
+  }
+  const text = root.textContent.split(/\r?\n/).map((line) => cleanText(line)).filter(Boolean).join("\n");
+  return { text, image_urls, links, tables };
+}
+function cleanText(value) {
+  return decodeHtml2(value ?? "").replace(/\s+/g, " ").trim();
+}
+function resolveUrl(baseUrl, href) {
+  try {
+    return new URL(href, baseUrl).toString();
+  } catch {
+    return href;
+  }
+}
+function decodeHtml2(value) {
+  return value.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+}
+
+// src/scraper.ts
+function parsePageContext(html, baseUrl) {
+  const root = parse2(html);
+  const config = parseMoodleConfig(html);
+  const sesskey = stringValue2(config.sesskey).trim();
+  const userid = numberValue2(config.userId) || numberValue2(root.querySelector("[data-user-id]")?.getAttribute("data-user-id"));
+  if (!sesskey || !userid) {
+    throw new Error("Session appears invalid: could not load authenticated Moodle context");
+  }
+  return {
+    sesskey,
+    user_info: {
+      userid,
+      username: "",
+      fullname: cleanNodeText(root.querySelector(".userfullname")),
+      sitename: extractSitename(root),
+      siteurl: baseUrl,
+      lang: stringValue2(config.language) || root.querySelector("html")?.getAttribute("lang") || ""
+    }
+  };
+}
+function parseCourseContentsHtml(html, baseUrl) {
+  const root = parse2(html);
+  const sections = [];
+  for (const sectionElement of root.querySelectorAll('li[data-for="section"]')) {
+    const sectionId = safeInt(sectionElement.getAttribute("data-id"));
+    const sectionNumber = safeInt(sectionElement.getAttribute("data-number") ?? sectionElement.getAttribute("data-sectionnum"));
+    const positionName = cleanNodeText(sectionElement.querySelector(".course-section-position-name"));
+    const mainName = cleanNodeText(
+      firstDefined([
+        first(sectionElement, ["h1.sectionname", "h2.sectionname", "h3.sectionname"]),
+        sectionElement.querySelector('[data-for="section_title"] a'),
+        sectionElement.querySelector('[data-for="section_title"]')
+      ])
+    );
+    const name = positionName && mainName && positionName !== mainName ? `${positionName} - ${mainName}` : mainName || positionName || `Section ${sectionNumber}`;
+    const visible = !(sectionElement.getAttribute("class") ?? "").split(/\s+/).includes("hidden");
+    const activities = [];
+    const seenActivities = /* @__PURE__ */ new Set();
+    for (const activityElement of sectionElement.querySelectorAll('li[data-for="cmitem"]')) {
+      const id = safeInt(activityElement.getAttribute("data-id"));
+      if (id && seenActivities.has(id)) {
+        continue;
+      }
+      if (id) {
+        seenActivities.add(id);
+      }
+      const classes = (activityElement.getAttribute("class") ?? "").split(/\s+/).filter(Boolean);
+      const modname = classes.find((item) => item.startsWith("modtype_"))?.slice("modtype_".length) ?? "";
+      const name2 = cleanNodeText(
+        firstDefined([
+          activityElement.querySelector(".activityname .instancename"),
+          activityElement.querySelector(".activityname"),
+          activityElement.querySelector("a.aalink")
+        ])
+      );
+      if (!name2) {
+        continue;
+      }
+      const href = activityElement.querySelector(".activityname a, a.aalink, a[href]")?.getAttribute("href") ?? "";
+      activities.push({
+        id,
+        name: name2,
+        modname,
+        url: href ? resolveUrl(baseUrl, href) : "",
+        visible: !classes.some((item) => ["hidden", "stealth", "dimmed"].includes(item)),
+        description: cleanNodeText(first(activityElement, ["[data-region='activity-description']", ".contentafterlink", ".description"]))
+      });
+    }
+    sections.push({
+      id: sectionId,
+      name,
+      section: sectionNumber,
+      visible,
+      summary: cleanNodeText(first(sectionElement, [".summarytext", "[data-for='sectioninfo']"])),
+      activities
+    });
+  }
+  return sections;
+}
+function parseCourseSectionNumbers(html, courseId) {
+  const sections = [];
+  const pattern = /href=["']([^"']*\/course\/view\.php\?[^"']*)["']/g;
+  for (const match of html.matchAll(pattern)) {
+    const url = parseMaybeUrl(match[1], "https://moodle.invalid");
+    const id = url?.searchParams.get("id");
+    const sectionValue = url?.searchParams.get("section");
+    if (id === String(courseId) && sectionValue && /^\d+$/.test(sectionValue)) {
+      const section = Number(sectionValue);
+      if (!sections.includes(section)) {
+        sections.push(section);
+      }
+    }
+  }
+  return sections;
+}
+function parseCourseGradesUrl(html, baseUrl) {
+  const root = parse2(html);
+  const link = root.querySelector('li[data-key="grades"] a[href]') ?? root.querySelector('.secondary-navigation a[href*="mode=grade"]') ?? root.querySelector('.secondary-navigation a[href*="/grade/report/"]') ?? root.querySelector('a[href*="mode=grade"], a[href*="/grade/report/"]');
+  const href = link?.getAttribute("href") ?? "";
+  return href ? resolveUrl(baseUrl, href) : "";
+}
+function parseCourseIdFromPageHtml(html) {
+  const root = parse2(html);
+  for (const link of root.querySelectorAll('a[href*="/course/view.php?id="]')) {
+    const courseId = numberQueryValue(link.getAttribute("href") ?? "", "id");
+    if (courseId !== null) {
+      return courseId;
+    }
+  }
+  return null;
+}
+function hasCourseGradesHtml(html) {
+  return parse2(html).querySelector("table.user-grade") !== null;
+}
+function parseCourseGradesHtml(html, courseId, baseUrl) {
+  const root = parse2(html);
+  const report = {
+    course_id: courseId,
+    course_name: cleanNodeText(root.querySelector("h1")),
+    learner_name: cleanNodeText(
+      firstDefined([
+        root.querySelector(".grade-report-user .page-header-headings h2"),
+        root.querySelector(".page-header-headings h2"),
+        root.querySelector(".grade-report-user h2 a"),
+        root.querySelector("h2 a"),
+        root.querySelector("h2")
+      ])
+    ),
+    total_grade: "",
+    total_range: "",
+    total_percentage: "",
+    items: []
+  };
+  const table = root.querySelector("table.user-grade");
+  if (!table) {
+    return report;
+  }
+  for (const row of table.querySelectorAll("tr")) {
+    const title = cleanNodeText(row.querySelector(".rowtitle"));
+    if (!title || row.querySelector(".toggle-category")) {
+      continue;
+    }
+    if (title === "Course total") {
+      report.total_grade = cleanTableCell(row.querySelector("td.column-grade"));
+      report.total_range = cleanTableCell(row.querySelector("td.column-range"));
+      report.total_percentage = cleanTableCell(row.querySelector("td.column-percentage"));
+      continue;
+    }
+    const link = row.querySelector(".rowtitle a.gradeitemheader, .rowtitle a");
+    if (!link) {
+      continue;
+    }
+    const statusIcon = row.querySelector("td.column-grade i[aria-label], td.column-grade i[title]");
+    const item = {
+      name: title,
+      item_type: cleanText(row.querySelector(".item img.itemicon, .courseitem img.itemicon, img.itemicon")?.getAttribute("alt") ?? ""),
+      grade: cleanTableCell(row.querySelector("td.column-grade")),
+      range: cleanTableCell(row.querySelector("td.column-range")),
+      percentage: cleanTableCell(row.querySelector("td.column-percentage")),
+      weight: cleanTableCell(row.querySelector("td.column-weight")),
+      contribution: cleanTableCell(row.querySelector("td.column-contributiontocoursetotal")),
+      feedback: cleanTableCell(row.querySelector("td.column-feedback")),
+      url: resolveUrl(baseUrl, link.getAttribute("href") ?? ""),
+      status: statusIcon?.getAttribute("aria-label") ?? statusIcon?.getAttribute("title") ?? ""
+    };
+    report.items.push(item);
+  }
+  return report;
+}
+function parseGradeOverviewRows(html, baseUrl) {
+  const rows = {};
+  const table = parse2(html).querySelector("table#overview-grade");
+  if (!table) {
+    return rows;
+  }
+  for (const row of table.querySelectorAll("tbody tr, tr")) {
+    const link = row.querySelector("td a[href]");
+    if (!link) {
+      continue;
+    }
+    const href = resolveUrl(baseUrl, link.getAttribute("href") ?? "");
+    const courseId = numberQueryValue(href, "id");
+    if (courseId === null) {
+      continue;
+    }
+    const cells = row.querySelectorAll("td");
+    rows[courseId] = {
+      course_name: cleanNodeText(link),
+      grade: cleanNodeText(cells[1]),
+      url: href
+    };
+  }
+  return rows;
+}
+function parseAssignmentHtml(html, assignmentId, baseUrl) {
+  return {
+    id: assignmentId,
+    name: pageTitle(html),
+    ...activityContext(html),
+    due_pretty: extractLabeledText(html, "Due:"),
+    submission_status: findTableValue(html, "Submission status"),
+    grading_status: findTableValue(html, "Grading status"),
+    time_remaining: findTableValue(html, "Time remaining"),
+    grade: findTableValue(html, "Grade"),
+    url: `${baseUrl.replace(/\/$/, "")}/mod/assign/view.php?id=${assignmentId}`
+  };
+}
+function parseQuizHtml(html, quizId, baseUrl) {
+  const root = parse2(html);
+  return {
+    id: quizId,
+    name: pageTitle(html),
+    ...activityContext(html),
+    opens_pretty: extractLabeledText(html, "Opens:"),
+    closes_pretty: extractLabeledText(html, "Closes:"),
+    attempts_allowed: cleanText(root.textContent.match(/Attempts allowed:\s*([^\n]+)/i)?.[1] ?? ""),
+    availability: cleanText(root.textContent.match(/This quiz is currently[^\n]+/i)?.[0] ?? ""),
+    grade: findTableValue(html, "Grade"),
+    url: `${baseUrl.replace(/\/$/, "")}/mod/quiz/view.php?id=${quizId}`
+  };
+}
+function parseResourceHtml(html, resourceId, baseUrl) {
+  const root = parse2(html);
+  const link = root.querySelector(".resourceworkaround a[href], .resourcecontent a[href], a.resourceworkaround[href]");
+  return {
+    id: resourceId,
+    name: pageTitle(html),
+    ...activityContext(html),
+    target_name: cleanNodeText(link),
+    target_url: link ? resolveUrl(baseUrl, link.getAttribute("href") ?? "") : "",
+    url: `${baseUrl.replace(/\/$/, "")}/mod/resource/view.php?id=${resourceId}`
+  };
+}
+function parseLinkHtml(html, linkId, baseUrl) {
+  const root = parse2(html);
+  const link = root.querySelector(".urlworkaround a[href], .mod_url-content a[href], .externalurl a[href]");
+  return {
+    id: linkId,
+    name: pageTitle(html),
+    ...activityContext(html),
+    target_url: link?.getAttribute("href") ?? "",
+    url: `${baseUrl.replace(/\/$/, "")}/mod/url/view.php?id=${linkId}`
+  };
+}
+function parsePageHtml(html, pageId, baseUrl) {
+  const root = parse2(html);
+  const content = first(root, [".box.generalbox", ".activity-description", "[data-region='page-content']", "main"]);
+  return {
+    id: pageId,
+    name: pageTitle(html),
+    ...activityContext(html),
+    content_text: content ? htmlToStructuredContent(content.innerHTML, baseUrl).text : "",
+    url: `${baseUrl.replace(/\/$/, "")}/mod/page/view.php?id=${pageId}`
+  };
+}
+function parseFolderHtml(html, folderId, baseUrl) {
+  const root = parse2(html);
+  const files = unique(root.querySelectorAll(".foldertree a[href], .fp-filename-icon a[href]").map((link) => cleanNodeText(link)).filter(Boolean));
+  return {
+    id: folderId,
+    name: pageTitle(html),
+    ...activityContext(html),
+    files,
+    url: `${baseUrl.replace(/\/$/, "")}/mod/folder/view.php?id=${folderId}`
+  };
+}
+function parseForumDiscussionHtml(html, baseUrl, discussionId) {
+  const root = parse2(html);
+  let postElements = root.querySelectorAll("div.forumpost[data-post-id]");
+  if (!postElements.length) {
+    postElements = root.querySelectorAll("article[data-post-id]");
+  }
+  const [groupId, groupName] = parseForumDiscussionGroupHtml(html);
+  const posts = [];
+  for (const element of postElements) {
+    const postId = safeInt(element.getAttribute("data-post-id"));
+    if (!postId) {
+      continue;
+    }
+    const header = first(element, ["header", ".header"]);
+    const subject = cleanNodeText(
+      firstDefined([
+        header ? first(header, ["h3"]) : null,
+        first(element, ["h3", "[data-region='post-title']"])
+      ])
+    );
+    const authorLink = firstDefined([
+      header ? first(header, ['a[href*="/user/"]']) : null,
+      first(element, ['a[href*="/user/"]', 'a[href*="/user/profile.php"]'])
+    ]) ?? null;
+    const messageElement = first(element, [
+      ".post-content-container",
+      ".content",
+      "[data-region='post-content']",
+      "[data-region-content='forum-post-core']"
+    ]);
+    const messageHtml = messageElement?.innerHTML ?? "";
+    const structured = htmlToStructuredContent(messageHtml, baseUrl);
+    posts.push({
+      id: postId,
+      discussion_id: discussionId,
+      subject,
+      message_html: messageHtml,
+      message_text: structured.text,
+      image_urls: structured.image_urls,
+      links: structured.links,
+      tables: structured.tables,
+      author: {
+        id: 0,
+        fullname: cleanNodeText(authorLink),
+        profile_url: authorLink ? resolveUrl(baseUrl, authorLink.getAttribute("href") ?? "") : "",
+        profile_image_url: ""
+      },
+      parent_id: 0,
+      time_created: 0,
+      time_modified: 0,
+      created_pretty: cleanNodeText(header ? first(header, [".date", "time"]) : null),
+      unread: false,
+      is_deleted: false,
+      is_private_reply: false,
+      url: `${baseUrl.replace(/\/$/, "")}/mod/forum/discuss.php?d=${discussionId}#p${postId}`,
+      reply_url: `${baseUrl.replace(/\/$/, "")}/mod/forum/post.php?reply=${postId}#mformforum`
+    });
+  }
+  return {
+    id: discussionId,
+    subject: posts[0]?.subject ?? "",
+    course_id: 0,
+    forum_id: 0,
+    group_id: groupId,
+    group_name: groupName,
+    url: `${baseUrl.replace(/\/$/, "")}/mod/forum/discuss.php?d=${discussionId}`,
+    posts
+  };
+}
+function parseForumViewCmidFromDiscussionHtml(html) {
+  const root = parse2(html);
+  const link = first(root, ['a[href*="/mod/forum/view.php?id="]', 'a[href*="mod/forum/view.php?id="]']);
+  const href = link?.getAttribute("href") ?? "";
+  if (!href) {
+    return null;
+  }
+  const url = parseMaybeUrl(href, "https://moodle.invalid");
+  if (!url || !url.pathname.endsWith("/mod/forum/view.php")) {
+    return null;
+  }
+  return numericQueryValue(url, "id");
+}
+function parseForumDiscussionRefsHtml(html, baseUrl) {
+  const root = parse2(html);
+  const refs = [];
+  const seen = /* @__PURE__ */ new Set();
+  const links = [
+    ...root.querySelectorAll('a[href*="/mod/forum/discuss.php?d="]'),
+    ...root.querySelectorAll('a[href*="mod/forum/discuss.php?d="]'),
+    ...root.querySelectorAll('a[href*="discuss.php?d="]')
+  ];
+  for (const link of links) {
+    const href = link.getAttribute("href") ?? "";
+    const url = parseMaybeUrl(href, baseUrl);
+    if (!url || !url.pathname.endsWith("/mod/forum/discuss.php")) {
+      continue;
+    }
+    const discussionId = numericQueryValue(url, "d");
+    if (!discussionId || seen.has(discussionId)) {
+      continue;
+    }
+    const subject = cleanNodeText(link);
+    if (!subject || ["permalink", "discuss"].includes(subject.toLowerCase())) {
+      continue;
+    }
+    seen.add(discussionId);
+    refs.push({
+      id: discussionId,
+      subject,
+      group_id: 0,
+      group_name: "",
+      url: resolveUrl(baseUrl, href)
+    });
+  }
+  return refs;
+}
+function parseForumGroupsHtml(html) {
+  const root = parse2(html);
+  const select = first(root, ["form#selectgroup select[name='group']", "select[name='group']"]);
+  if (!select) {
+    return [];
+  }
+  const groups = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const option of select.querySelectorAll("option")) {
+    const groupId = safeInt(option.getAttribute("value"));
+    if (!groupId) {
+      continue;
+    }
+    const groupName = cleanNodeText(option);
+    const key = `${groupId}:${groupName}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    groups.push([groupId, groupName]);
+  }
+  return groups;
+}
+function parseForumDiscussionGroupHtml(html) {
+  const root = parse2(html);
+  const groupId = safeInt(root.querySelector("form#mformforum input[name='groupid']")?.getAttribute("value"));
+  return [groupId, selectedGroupName(root, groupId)];
+}
+function selectedGroupName(root, groupId) {
+  if (groupId <= 0) {
+    return "";
+  }
+  for (const selector of ["select[name='groupinfo']", "select[name='group']"]) {
+    const option = root.querySelector(selector)?.querySelector(`option[value='${groupId}']`) ?? null;
+    if (option) {
+      return cleanNodeText(option);
+    }
+  }
+  return "";
+}
+function cleanNodeText(node) {
+  return cleanText(node?.textContent ?? "");
+}
+function first(root, selectors) {
+  for (const selector of selectors) {
+    const match = root.querySelector(selector);
+    if (match) {
+      return match;
+    }
+  }
+  return null;
+}
+function firstDefined(items) {
+  return items.find((item) => item !== null && item !== void 0) ?? null;
+}
+function safeInt(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Math.trunc(value);
+  }
+  if (typeof value === "string" && /^\d+$/.test(value.trim())) {
+    return Number(value.trim());
+  }
+  return 0;
+}
+function parseMaybeUrl(href, baseUrl) {
+  try {
+    return new URL(href, baseUrl);
+  } catch {
+    return null;
+  }
+}
+function numericQueryValue(url, key) {
+  const value = url.searchParams.get(key);
+  if (!value || !/^\d+$/.test(value)) {
+    return null;
+  }
+  return Number(value);
+}
+function parseMoodleConfig(html) {
+  const match = html.match(/M\.cfg\s*=\s*({[\s\S]*?});/);
+  if (!match) {
+    return {};
+  }
+  try {
+    return JSON.parse(match[1]);
+  } catch {
+    return {};
+  }
+}
+function extractSitename(root) {
+  const title = cleanNodeText(root.querySelector("title"));
+  return title.includes("|") ? title.split("|").at(-1)?.trim() ?? title : title;
+}
+function pageTitle(html) {
+  return cleanNodeText(parse2(html).querySelector("h1"));
+}
+function activityContext(html) {
+  const root = parse2(html);
+  const context = { course_id: parseCourseIdFromPageHtml(html) ?? 0, course_name: "", section_name: "" };
+  for (const link of root.querySelectorAll('nav[aria-label="Breadcrumb"] a[href], #page-navbar .breadcrumb a[href], a[href*="/course/view.php?id="]')) {
+    const href = link.getAttribute("href") ?? "";
+    const courseId = numberQueryValue(href, "id");
+    if (courseId !== null) {
+      context.course_id = courseId;
+      context.course_name ||= cleanNodeText(link);
+    }
+    if (numberQueryValue(href, "section") !== null) {
+      context.section_name ||= cleanNodeText(link);
+    }
+  }
+  return context;
+}
+function extractLabeledText(html, label) {
+  const root = parse2(html);
+  for (const node of root.querySelectorAll("strong, b")) {
+    if (cleanNodeText(node) !== label) {
+      continue;
+    }
+    const parent = node.parentNode;
+    return cleanText(parent?.textContent.replace(label, "") ?? "");
+  }
+  return "";
+}
+function findTableValue(html, label) {
+  const root = parse2(html);
+  for (const row of root.querySelectorAll("tr")) {
+    const cells = row.querySelectorAll("th, td");
+    if (cleanNodeText(cells[0]) === label) {
+      return cleanTableCell(cells[1]);
+    }
+  }
+  return "";
+}
+function cleanTableCell(node) {
+  if (!node) {
+    return "";
+  }
+  const clone = parse2(node.toString());
+  for (const unwanted of clone.querySelectorAll(".action-menu, .dropdown, script, style")) {
+    unwanted.remove();
+  }
+  return cleanText(clone.textContent.replace("( Empty )", "(Empty)"));
+}
+function numberQueryValue(href, key) {
+  try {
+    return numericQueryValue(new URL(href, "https://moodle.invalid"), key);
+  } catch {
+    return null;
+  }
+}
+function numberValue2(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim() !== "" && Number.isFinite(Number(value))) {
+    return Number(value);
+  }
+  return 0;
+}
+function stringValue2(value) {
+  return typeof value === "string" ? value : value == null ? "" : String(value);
+}
+function unique(items) {
+  return [...new Set(items)];
+}
+
+// src/client.ts
+var AjaxEnvelopeSchema = z.array(
+  z.object({
+    error: z.boolean().optional(),
+    data: z.unknown().optional(),
+    exception: z.object({
+      message: z.string().optional(),
+      errorcode: z.string().optional()
+    }).passthrough().optional()
+  }).passthrough()
+);
+var MoodleClient = class {
+  baseUrl;
+  fetchImpl;
+  cookie;
+  sesskey;
+  userid;
+  userInfo;
+  cacheOptions;
+  onLoginRequired;
+  retryingLogin = false;
+  forumDiscussions = /* @__PURE__ */ new Map();
+  forumRefs = /* @__PURE__ */ new Map();
+  constructor(baseUrl, options) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    const resolvedOptions = typeof options === "string" ? { cookie: { name: "MoodleSession", value: options } } : options;
+    this.fetchImpl = resolvedOptions.fetchImpl ?? fetch;
+    this.cookie = resolvedOptions.cookie;
+    this.sesskey = resolvedOptions.pageContext?.sesskey ?? null;
+    this.userid = resolvedOptions.pageContext?.user_info.userid ?? null;
+    this.userInfo = resolvedOptions.pageContext?.user_info ?? null;
+    this.cacheOptions = resolvedOptions.cacheOptions;
+    this.onLoginRequired = resolvedOptions.onLoginRequired;
+  }
+  async getSiteInfo() {
+    await this.ensureSession();
+    const data = await this.call(FUNC_GET_SITE_INFO);
+    if (!isRecord3(data) || !("userid" in data)) {
+      if (this.userInfo) {
+        return this.userInfo;
+      }
+      throw new NotFoundError("Session appears invalid: could not retrieve user info");
+    }
+    const info = parseUserInfo(data);
+    this.sesskey = typeof data.sesskey === "string" ? data.sesskey : this.sesskey;
+    this.userid = info.userid;
+    this.userInfo = info;
+    await this.writeCache();
+    return info;
+  }
+  async getCourses() {
+    await this.ensureSession();
+    try {
+      const data = await this.call(FUNC_GET_COURSES, { userid: this.userid });
+      return parseCourses(data);
+    } catch (error) {
+      if (!(error instanceof MoodleAPIError) || error.moodleErrorCode !== "servicenotavailable") {
+        throw error;
+      }
+      return this.getCoursesTimeline();
+    }
+  }
+  async resolveCourseReference(value) {
+    const raw = value.trim();
+    if (/^\d+$/.test(raw)) {
+      return Number(raw);
+    }
+    const courses = await this.getCourses();
+    const matches = courses.filter((course) => queryMatches(course.fullname, raw) || queryMatches(course.shortname, raw));
+    if (matches.length === 1) {
+      return matches[0].id;
+    }
+    if (!matches.length) {
+      throw new NotFoundError(`Could not find a course matching '${raw}'. Run 'moodle courses' to inspect course IDs.`);
+    }
+    throw new NotFoundError(`Course '${raw}' is ambiguous. Matches: ${matches.slice(0, 5).map((course) => `${course.id}:${course.fullname || course.shortname}`).join(", ")}`);
+  }
+  async getCourseContents(courseId) {
+    await this.ensureSession();
+    try {
+      return parseCourseContents(await this.call(FUNC_GET_COURSE_CONTENTS, { courseid: courseId }));
+    } catch (error) {
+      if (!(error instanceof MoodleAPIError) || error.moodleErrorCode !== "servicenotavailable") {
+        throw error;
+      }
+    }
+    const response = await this.get(COURSE_PATH, { id: courseId });
+    return this.scrapeCourseContents(courseId, response);
+  }
+  async getActivities(courseId) {
+    return (await this.getCourseContents(courseId)).flatMap((section) => section.activities);
+  }
+  async getTodo(limit = 20, days) {
+    await this.ensureSession();
+    const now = Math.floor(Date.now() / 1e3);
+    const data = await this.call(FUNC_GET_ACTION_EVENTS, {
+      limitnum: limit,
+      timesortfrom: now,
+      timesortto: days ? now + days * 24 * 60 * 60 : 0,
+      aftereventid: 0,
+      limittononsuspendedevents: true
+    });
+    const events = isRecord3(data) && Array.isArray(data.events) ? data.events : [];
+    return parseTodoItems(events);
+  }
+  async getAlerts(limit = 20) {
+    await this.ensureSession();
+    const [notifications, counts, unread] = await this.callBatchValues([
+      { methodname: FUNC_GET_POPUP_NOTIFICATIONS, args: { useridto: this.userid, limit, offset: 0 } },
+      { methodname: FUNC_GET_CONVERSATION_COUNTS, args: { userid: this.userid } },
+      { methodname: FUNC_GET_UNREAD_CONVERSATION_COUNTS, args: { userid: this.userid } }
+    ]);
+    return parseAlertSummary(notifications, counts, unread);
+  }
+  async getOverview(todoLimit = 5, todoDays, alertsLimit = 5) {
+    await this.ensureSession();
+    const now = Math.floor(Date.now() / 1e3);
+    const results = await this.callBatch([
+      { methodname: FUNC_GET_COURSES, args: { userid: this.userid } },
+      {
+        methodname: FUNC_GET_ACTION_EVENTS,
+        args: {
+          limitnum: todoLimit,
+          timesortfrom: now,
+          timesortto: todoDays ? now + todoDays * 24 * 60 * 60 : 0,
+          aftereventid: 0,
+          limittononsuspendedevents: true
+        }
+      },
+      { methodname: FUNC_GET_POPUP_NOTIFICATIONS, args: { useridto: this.userid, limit: alertsLimit, offset: 0 } },
+      { methodname: FUNC_GET_CONVERSATION_COUNTS, args: { userid: this.userid } },
+      { methodname: FUNC_GET_UNREAD_CONVERSATION_COUNTS, args: { userid: this.userid } }
+    ]);
+    const [coursesData, todoData, notifications, counts, unread] = results;
+    const errors = results.flatMap((result, index) => {
+      if (result.ok) {
+        return [];
+      }
+      const labels = ["courses", "todo", "notifications", "conversation counts", "unread conversation counts"];
+      return [`${labels[index]}: ${result.error.message}`];
+    });
+    const todoPayload = todoData?.ok ? todoData.data : {};
+    return {
+      user: this.userInfo,
+      courses: coursesData?.ok ? parseCourses(coursesData.data) : [],
+      todo: parseTodoItems(isRecord3(todoPayload) && Array.isArray(todoPayload.events) ? todoPayload.events : []),
+      alerts: notifications?.ok && counts?.ok && unread?.ok ? parseAlertSummary(notifications.data, counts.data, unread.data) : void 0,
+      errors
+    };
+  }
+  async getCourseGrades(courseId) {
+    await this.ensureSession();
+    const courseHtml = await this.get(COURSE_PATH, { id: courseId });
+    const candidates = [
+      parseCourseGradesUrl(courseHtml, this.baseUrl),
+      `${this.baseUrl}/course/user.php?mode=grade&id=${courseId}&user=${this.userid}`,
+      `${this.baseUrl}${GRADE_REPORT_OVERVIEW_PATH}`,
+      `${this.baseUrl}${GRADE_REPORT_INDEX_PATH}?id=${courseId}`,
+      `${this.baseUrl}${GRADE_REPORT_PATH}?id=${courseId}`
+    ].filter(Boolean);
+    const seen = /* @__PURE__ */ new Set();
+    let overviewRows = {};
+    for (let index = 0; index < candidates.length; index += 1) {
+      const url = candidates[index];
+      if (seen.has(url)) {
+        continue;
+      }
+      seen.add(url);
+      let html = "";
+      try {
+        html = await this.getAbsolute(url);
+      } catch (error) {
+        if (error instanceof MoodleAPIError && error.message.startsWith("HTTP 404")) {
+          continue;
+        }
+        throw error;
+      }
+      if (hasCourseGradesHtml(html)) {
+        return parseCourseGradesHtml(html, courseId, this.baseUrl);
+      }
+      overviewRows = parseGradeOverviewRows(html, this.baseUrl);
+      const row = overviewRows[courseId];
+      if (row) {
+        if (row.url && !seen.has(row.url)) {
+          candidates.push(row.url);
+          continue;
+        }
+        return {
+          course_id: courseId,
+          course_name: row.course_name,
+          learner_name: "",
+          total_grade: row.grade,
+          total_range: "",
+          total_percentage: "",
+          items: []
+        };
+      }
+    }
+    return {
+      course_id: courseId,
+      course_name: "",
+      learner_name: "",
+      total_grade: "",
+      total_range: "",
+      total_percentage: "",
+      items: []
+    };
+  }
+  async getAssignment(id) {
+    return parseAssignmentHtml(await this.get(ASSIGN_VIEW_PATH, { id }), id, this.baseUrl);
+  }
+  async getQuiz(id) {
+    return parseQuizHtml(await this.get(QUIZ_VIEW_PATH, { id }), id, this.baseUrl);
+  }
+  async getResource(id) {
+    return parseResourceHtml(await this.get(RESOURCE_VIEW_PATH, { id }), id, this.baseUrl);
+  }
+  async getLink(id) {
+    return parseLinkHtml(await this.get(URL_VIEW_PATH, { id }), id, this.baseUrl);
+  }
+  async getPage(id) {
+    return parsePageHtml(await this.get(PAGE_VIEW_PATH, { id }), id, this.baseUrl);
+  }
+  async getFolder(id) {
+    return parseFolderHtml(await this.get(FOLDER_VIEW_PATH, { id }), id, this.baseUrl);
+  }
+  async getForumDiscussion(discussionId) {
+    const cached = this.forumDiscussions.get(discussionId);
+    if (cached) {
+      return cached;
+    }
+    await this.ensureSession();
+    try {
+      const data = await this.call(FUNC_GET_DISCUSSION_POSTS, {
+        discussionid: discussionId,
+        sortby: "created",
+        sortdirection: "ASC",
+        includeinlineattachments: true
+      });
+      const discussion2 = parseForumDiscussion(data, discussionId);
+      if (discussion2.group_id <= 0) {
+        try {
+          const html = await this.get(FORUM_DISCUSS_PATH, { d: discussionId });
+          [discussion2.group_id, discussion2.group_name] = parseForumDiscussionGroupHtml(html);
+        } catch {
+        }
+      }
+      this.forumDiscussions.set(discussionId, discussion2);
+      return discussion2;
+    } catch (error) {
+      if (!(error instanceof MoodleAPIError) || !["servicenotavailable", "accessexception"].includes(error.moodleErrorCode ?? "")) {
+        throw error;
+      }
+    }
+    const discussion = parseForumDiscussionHtml(await this.get(FORUM_DISCUSS_PATH, { d: discussionId }), this.baseUrl, discussionId);
+    this.forumDiscussions.set(discussionId, discussion);
+    return discussion;
+  }
+  async getForumViewCmid(discussionId) {
+    return parseForumViewCmidFromDiscussionHtml(await this.get(FORUM_DISCUSS_PATH, { d: discussionId }));
+  }
+  async resolveCourseIdForUrl(url) {
+    return parseCourseIdFromPageHtml(await this.getAbsolute(url));
+  }
+  async getForumDiscussionRefs(forumCmid) {
+    const cached = this.forumRefs.get(forumCmid);
+    if (cached) {
+      return cached;
+    }
+    const rootHtml = await this.get(FORUM_VIEW_PATH, { id: forumCmid });
+    const groups = parseForumGroupsHtml(rootHtml);
+    const refs = groups.length ? [] : parseForumDiscussionRefsHtml(rootHtml, this.baseUrl);
+    const seen = new Set(refs.map((ref) => ref.id));
+    for (const [groupId, groupName] of groups) {
+      const html = await this.get(FORUM_VIEW_PATH, { id: forumCmid, group: groupId });
+      for (const ref of parseForumDiscussionRefsHtml(html, this.baseUrl)) {
+        if (seen.has(ref.id)) {
+          continue;
+        }
+        ref.group_id = groupId;
+        ref.group_name = groupName;
+        seen.add(ref.id);
+        refs.push(ref);
+      }
+    }
+    this.forumRefs.set(forumCmid, refs);
+    return refs;
+  }
+  async getCourseForums(courseId, courseName = "") {
+    const sections = await this.getCourseContents(courseId);
+    return sections.flatMap(
+      (section) => section.activities.filter((activity) => activity.modname === "forum").map((activity) => ({
+        id: activity.id,
+        name: activity.name,
+        course_id: courseId,
+        course_name: courseName,
+        url: activity.url
+      }))
+    );
+  }
+  async getForums(courseId) {
+    if (courseId !== void 0) {
+      const courseName = (await this.getCourses()).find((course) => course.id === courseId);
+      return this.getCourseForums(courseId, courseName?.fullname || courseName?.shortname || "");
+    }
+    const refs = [];
+    for (const course of await this.getCourses()) {
+      refs.push(...await this.getCourseForums(course.id, course.fullname || course.shortname));
+    }
+    return refs;
+  }
+  async searchForumContent(options) {
+    const query = options.query.trim();
+    if (!query) {
+      return [];
+    }
+    let forums = await this.getForums(options.courseId);
+    if (options.forumCmid !== void 0) {
+      forums = forums.filter((forum) => forum.id === options.forumCmid);
+      if (!forums.length) {
+        forums = [{ id: options.forumCmid, name: "", course_id: 0, course_name: "", url: `${this.baseUrl}${FORUM_VIEW_PATH}?id=${options.forumCmid}` }];
+      }
+    } else if (options.maxForums !== void 0) {
+      forums = forums.slice(0, options.maxForums);
+    }
+    const hits = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const forum of forums) {
+      let refs = await this.getForumDiscussionRefs(forum.id);
+      if (options.maxDiscussionsPerForum !== void 0) {
+        refs = refs.slice(0, options.maxDiscussionsPerForum);
+      }
+      for (const ref of refs) {
+        let discussion = null;
+        let latest = 0;
+        let discussionHasUnread = false;
+        if (options.includePostText !== false || options.unreadOnly || options.sortBy === "recent") {
+          discussion = await this.getForumDiscussion(ref.id);
+          latest = Math.max(0, ...discussion.posts.map((post) => post.time_created));
+          discussionHasUnread = discussion.posts.some((post) => post.unread);
+        }
+        if (options.includePostText === false) {
+          const score = matchScore(ref.subject, query);
+          if (score > 0 && (!options.unreadOnly || discussionHasUnread)) {
+            addHit(hits, seen, 400 + score, makeHit(forum, ref, { matched_in: "discussion_subject", snippet: snippetForText(ref.subject, query), unread: discussionHasUnread, time_created: latest }));
+          }
+          continue;
+        }
+        discussion ??= await this.getForumDiscussion(ref.id);
+        let postMatched = false;
+        for (const post of discussion.posts) {
+          const subjectScore = matchScore(post.subject, query);
+          const bodyScore = matchScore(post.message_text, query);
+          if (subjectScore <= 0 && bodyScore <= 0) {
+            continue;
+          }
+          if (options.unreadOnly && !post.unread) {
+            continue;
+          }
+          postMatched = true;
+          const matched_in = subjectScore >= bodyScore ? "post_subject" : "post_body";
+          const matchedText = matched_in === "post_subject" ? post.subject : post.message_text;
+          addHit(
+            hits,
+            seen,
+            300 + Math.max(subjectScore, bodyScore),
+            makeHit(forum, ref, {
+              group_id: discussion.group_id || ref.group_id,
+              group_name: discussion.group_name || ref.group_name,
+              discussion_subject: discussion.subject || ref.subject,
+              post_id: post.id,
+              author_name: post.author.fullname,
+              matched_in,
+              snippet: snippetForText(matchedText, query),
+              unread: post.unread,
+              time_created: post.time_created,
+              url: post.url || ref.url
+            })
+          );
+        }
+        if (!postMatched) {
+          const score = matchScore(ref.subject, query);
+          if (score > 0 && (!options.unreadOnly || discussionHasUnread)) {
+            addHit(hits, seen, 400 + score, makeHit(forum, ref, { matched_in: "discussion_subject", snippet: snippetForText(ref.subject, query), unread: discussionHasUnread, time_created: latest }));
+          }
+        }
+      }
+    }
+    hits.sort((a, b) => {
+      if (options.sortBy === "recent") {
+        return b[1].time_created - a[1].time_created || b[0] - a[0] || compareHit(a[1], b[1]);
+      }
+      return b[0] - a[0] || compareHit(a[1], b[1]);
+    });
+    return hits.slice(0, options.limit ?? 20).map(([, hit]) => hit);
+  }
+  async callBatch(requests) {
+    await this.ensureSession();
+    return this.callBatchInternal(requests, true);
+  }
+  async call(functionName, args = {}) {
+    const [result] = await this.callBatchValues([{ methodname: functionName, args }]);
+    return result;
+  }
+  async callBatchValues(requests) {
+    const results = await this.callBatchInternal(requests, true);
+    const failed = results.find((result) => !result.ok);
+    if (failed && !failed.ok) {
+      throw failed.error;
+    }
+    return results.map((result) => result.ok ? result.data : void 0);
+  }
+  async callBatchInternal(requests, allowRetry) {
+    const payload = requests.map((request, index) => ({ index, methodname: request.methodname, args: request.args ?? {} }));
+    const response = await this.fetchImpl(`${this.baseUrl}${AJAX_SERVICE_PATH}?sesskey=${encodeURIComponent(this.sesskey ?? "")}&info=${requests.map((request) => request.methodname).join(",")}`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        cookie: `${this.cookie.name}=${this.cookie.value}`
+      },
+      body: JSON.stringify(payload)
+    });
+    if (response.url.includes("/login/") && this.onLoginRequired && allowRetry && !this.retryingLogin) {
+      await this.reauthenticate();
+      return this.callBatchInternal(requests, false);
+    }
+    const body = await response.json();
+    const envelope = AjaxEnvelopeSchema.parse(body);
+    const results = envelope.map((item) => {
+      if (item.error) {
+        return {
+          ok: false,
+          error: new MoodleAPIError(item.exception?.message ?? "Unknown API error", item.exception?.errorcode)
+        };
+      }
+      return { ok: true, data: item.data ?? item };
+    });
+    if (allowRetry && !this.retryingLogin && this.onLoginRequired && results.some((result) => !result.ok && isLoginRequiredError(result.error))) {
+      await this.reauthenticate();
+      return this.callBatchInternal(requests, false);
+    }
+    return results;
+  }
+  async ensureSession() {
+    if (this.sesskey && this.userid) {
+      return;
+    }
+    const html = await this.get(DASHBOARD_PATH);
+    const context = parsePageContext(html, this.baseUrl);
+    this.applyContext(context);
+    await this.writeCache();
+  }
+  async get(pathname, params = {}) {
+    const query = new URLSearchParams(Object.entries(params).map(([key, value]) => [key, String(value)])).toString();
+    return this.getAbsolute(`${this.baseUrl}${pathname}${query ? `?${query}` : ""}`);
+  }
+  async getAbsolute(url) {
+    const response = await this.fetchImpl(url, { headers: { cookie: `${this.cookie.name}=${this.cookie.value}` }, redirect: "follow" });
+    if (response.url.includes("/login/") && this.onLoginRequired && !this.retryingLogin) {
+      await this.reauthenticate();
+      return this.getAbsolute(url);
+    }
+    if (!response.ok) {
+      throw new MoodleAPIError(`HTTP ${response.status} loading ${url}`);
+    }
+    return response.text();
+  }
+  async getCoursesTimeline() {
+    const courses = [];
+    let offset = 0;
+    while (true) {
+      const data = await this.call(FUNC_GET_COURSES_BY_TIMELINE, { classification: "all", limit: 100, offset });
+      if (!isRecord3(data) || !Array.isArray(data.courses) || !data.courses.length) {
+        break;
+      }
+      courses.push(...data.courses);
+      const nextOffset = typeof data.nextoffset === "number" ? data.nextoffset : offset;
+      if (nextOffset <= offset) {
+        break;
+      }
+      offset = nextOffset;
+    }
+    return parseCourses(courses);
+  }
+  async scrapeCourseContents(courseId, rootHtml) {
+    const pages = [rootHtml];
+    for (const section of parseCourseSectionNumbers(rootHtml, courseId)) {
+      if (section !== 0) {
+        pages.push(await this.get(COURSE_PATH, { id: courseId, section }));
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const sections = [];
+    for (const html of pages) {
+      for (const section of parseCourseContentsHtml(html, this.baseUrl)) {
+        const key = section.section || section.id;
+        if (seen.has(key)) {
+          continue;
+        }
+        seen.add(key);
+        sections.push(section);
+      }
+    }
+    return sections;
+  }
+  async reauthenticate() {
+    if (!this.onLoginRequired) {
+      throw new MoodleAPIError("Session expired", "servicerequireslogin");
+    }
+    this.retryingLogin = true;
+    await deleteCachedSession(this.baseUrl, this.cacheOptions);
+    try {
+      const auth = await this.onLoginRequired();
+      this.cookie = auth.cookie;
+      this.applyContext(auth.pageContext);
+      await this.writeCache();
+    } finally {
+      this.retryingLogin = false;
+    }
+  }
+  applyContext(context) {
+    this.sesskey = context.sesskey;
+    this.userid = context.user_info.userid;
+    this.userInfo = context.user_info;
+  }
+  async writeCache() {
+    if (this.cacheOptions && this.sesskey && this.userid) {
+      try {
+        await writeCachedSession({ baseUrl: this.baseUrl, cookieName: this.cookie.name, cookieValue: this.cookie.value, sesskey: this.sesskey, userid: this.userid, savedAt: (this.cacheOptions.now ?? Date.now)() }, this.cacheOptions);
+      } catch {
+        return;
+      }
+    }
+  }
+};
+async function createMoodleClient(baseUrl, options = {}) {
+  const cacheOptions2 = { homeDir: options.homeDir, now: options.now, ttlMs: options.ttlMs };
+  const authOptions = { ...options, fetch: options.fetch ?? options.fetchImpl };
+  if (!options.noCache) {
+    const cached = await readCachedSession(baseUrl, cacheOptions2);
+    if (cached) {
+      return new MoodleClient(baseUrl, {
+        fetchImpl: options.fetchImpl,
+        cookie: { name: cached.cookieName, value: cached.cookieValue },
+        pageContext: {
+          sesskey: cached.sesskey,
+          user_info: { userid: cached.userid, username: "", fullname: "", sitename: "", siteurl: baseUrl, lang: "" }
+        },
+        cacheOptions: cacheOptions2,
+        onLoginRequired: async () => authToClientSession(await getAuthenticatedSession(baseUrl, authOptions))
+      });
+    }
+  }
+  const auth = await getAuthenticatedSession(baseUrl, authOptions);
+  const session = authToClientSession(auth);
+  return new MoodleClient(baseUrl, {
+    fetchImpl: options.fetchImpl,
+    cookie: session.cookie,
+    pageContext: session.pageContext,
+    cacheOptions: cacheOptions2,
+    onLoginRequired: async () => authToClientSession(await getAuthenticatedSession(baseUrl, authOptions))
+  });
+}
+function authToClientSession(auth) {
+  return {
+    cookie: auth.cookie,
+    pageContext: {
+      sesskey: auth.sesskey,
+      user_info: {
+        userid: auth.userid,
+        username: "",
+        fullname: "",
+        sitename: "",
+        siteurl: auth.baseUrl,
+        lang: ""
+      }
+    }
+  };
+}
+function filterDiscussionToPost(discussion, postId) {
+  if (postId === null) {
+    return discussion;
+  }
+  const posts = discussion.posts.filter((post) => post.id === postId);
+  if (!posts.length) {
+    throw new NotFoundError(`Post ${postId} was not found in discussion ${discussion.id}.`);
+  }
+  return { ...discussion, posts };
+}
+function queryMatches(text, query) {
+  const haystack = text.toLowerCase().split(/\s+/).join(" ");
+  const needle = query.toLowerCase().split(/\s+/).join(" ");
+  return needle ? haystack.includes(needle) || needle.split(" ").every((token) => haystack.includes(token)) : true;
+}
+function matchScore(text, query) {
+  const haystack = text.toLowerCase().split(/\s+/).join(" ");
+  const normalized = query.toLowerCase().split(/\s+/).join(" ");
+  const tokens = normalized.split(/\s+/).filter(Boolean);
+  if (!haystack || !normalized) {
+    return 0;
+  }
+  if (haystack.includes(normalized)) {
+    return 100 + normalized.length;
+  }
+  if (tokens.length && tokens.every((token) => haystack.includes(token))) {
+    return 60 + tokens.length;
+  }
+  return 0;
+}
+function snippetForText(text, query, maxLen = 120) {
+  const cleaned = text.split(/\s+/).join(" ").trim();
+  if (!cleaned || cleaned.length <= maxLen) {
+    return cleaned;
+  }
+  const normalized = query.toLowerCase().split(/\s+/).join(" ");
+  const lower = cleaned.toLowerCase();
+  let start = lower.indexOf(normalized);
+  if (start < 0) {
+    start = normalized.split(/\s+/).map((token) => lower.indexOf(token)).find((index) => index >= 0) ?? -1;
+  }
+  if (start < 0) {
+    return `${cleaned.slice(0, maxLen - 1)}...`;
+  }
+  const left = Math.max(0, start - Math.floor(maxLen / 2));
+  const right = Math.min(cleaned.length, left + maxLen);
+  return `${left > 0 ? "..." : ""}${cleaned.slice(left, right)}${right < cleaned.length ? "..." : ""}`;
+}
+function makeHit(forum, ref, override) {
+  return {
+    course_id: forum.course_id,
+    course_name: forum.course_name,
+    forum_id: forum.id,
+    forum_name: forum.name,
+    group_id: ref.group_id,
+    group_name: ref.group_name,
+    discussion_id: ref.id,
+    discussion_subject: ref.subject,
+    post_id: 0,
+    author_name: "",
+    matched_in: "",
+    snippet: "",
+    unread: false,
+    time_created: 0,
+    url: ref.url,
+    ...override
+  };
+}
+function addHit(hits, seen, score, hit) {
+  const key = `${hit.discussion_id}:${hit.post_id}`;
+  if (seen.has(key)) {
+    return;
+  }
+  seen.add(key);
+  hits.push([score, hit]);
+}
+function compareHit(a, b) {
+  return a.course_name.localeCompare(b.course_name) || a.forum_name.localeCompare(b.forum_name) || a.discussion_id - b.discussion_id || a.post_id - b.post_id;
+}
+function isRecord3(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/config.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, join as join3 } from "path";
+import { createInterface } from "readline/promises";
+import YAML from "yaml";
+var nodeFs2 = { readFile: readFile2, writeFile: writeFile2, mkdir: mkdir2 };
+function cwdConfigPath(cwd = process.cwd()) {
+  return join3(cwd, CONFIG_FILENAME);
+}
+function userConfigPath(homeDir = homedir3()) {
+  return join3(homeDir, CONFIG_DIR_NAME, CONFIG_FILENAME);
+}
+function normalizeBaseUrl(value) {
+  const raw = value.trim();
+  if (!raw) {
+    throw new ConfigError("Base URL cannot be empty.");
+  }
+  if (!raw.includes("://")) {
+    throw new ConfigError("Base URL must include the scheme, for example https://school.example.edu");
+  }
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    throw new ConfigError("Base URL must be a valid URL");
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new ConfigError("Base URL must start with http:// or https://");
+  }
+  if (!parsed.hostname) {
+    throw new ConfigError("Base URL must include a hostname");
+  }
+  if (parsed.search || parsed.hash) {
+    throw new ConfigError("Base URL must not include query parameters or fragments");
+  }
+  if (parsed.pathname !== "/" && parsed.pathname !== "") {
+    throw new ConfigError(
+      "Base URL must be the site root, for example https://school.example.edu. Do not include paths like /login/index.php or /my/."
+    );
+  }
+  return parsed.origin;
+}
+async function loadConfig(options = {}) {
+  const env = options.env ?? process.env;
+  if (env[ENV_MOODLE_BASE_URL]) {
+    return { baseUrl: normalizeBaseUrl(env[ENV_MOODLE_BASE_URL]) };
+  }
+  const loaded = await loadExistingConfig(options);
+  if (loaded.config.base_url) {
+    return toMoodleConfig(loaded.config, normalizeBaseUrl(String(loaded.config.base_url)));
+  }
+  if (!isInteractive(options)) {
+    throw new ConfigError(missingBaseUrlMessage(loaded.path, options), "Set MOODLE_BASE_URL or run `moodle` once in an interactive shell.");
+  }
+  const baseUrl = await promptForBaseUrl(options);
+  const targetPath = loaded.path ?? userConfigPath(options.homeDir);
+  await saveConfigFile(targetPath, { ...loaded.config, base_url: baseUrl }, options);
+  return toMoodleConfig(loaded.config, baseUrl);
+}
+async function promptForBaseUrl(options = {}) {
+  const prompt = options.prompt ?? defaultPrompt(options);
+  const output = options.stderr ?? process.stderr;
+  output.write("Configuration required\n");
+  output.write("Moodle base URL is not configured yet.\n");
+  output.write("Required format: https://school.example.edu\n");
+  output.write("Use the site root only. Do not include paths like /login/index.php or /my/.\n");
+  while (true) {
+    let baseUrl;
+    try {
+      baseUrl = normalizeBaseUrl(await prompt("Moodle base URL"));
+    } catch (error) {
+      output.write(`Invalid URL: ${error instanceof Error ? error.message : String(error)}
+`);
+      continue;
+    }
+    const probe = await probeBaseUrl(baseUrl, options);
+    if (probe.ok) {
+      return baseUrl;
+    }
+    output.write(`Validation failed: ${probe.message ?? "site did not look like Moodle"}
+`);
+  }
+}
+async function probeBaseUrl(baseUrl, options = {}) {
+  const fetcher = options.fetch ?? globalThis.fetch;
+  if (!fetcher) {
+    return { ok: false, message: "fetch is not available in this runtime" };
+  }
+  let response;
+  try {
+    response = await fetcher(`${baseUrl}/login/token.php`, { redirect: "follow" });
+  } catch (error) {
+    return { ok: false, message: `Could not reach ${baseUrl}: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  const body = (await response.text()).slice(0, 5e3).toLowerCase();
+  const contentType = response.headers.get("content-type")?.toLowerCase() ?? "";
+  const looksJson = contentType.includes("application/json") || body.startsWith("{");
+  const looksMoodleTokenError = [
+    '"errorcode":"missingparam"',
+    '"errorcode":"invalidparameter"',
+    '"errorcode":"invalidlogin"',
+    "a required parameter (username) was missing"
+  ].some((marker) => body.includes(marker));
+  const looksMoodleHtml = body.includes("moodle") && (body.includes("login") || body.includes("sesskey"));
+  if (response.status >= 400) {
+    return { ok: false, message: `${baseUrl} returned HTTP ${response.status}` };
+  }
+  if (looksJson && looksMoodleTokenError || looksMoodleHtml) {
+    return { ok: true };
+  }
+  return { ok: false, message: `${baseUrl} does not expose the expected Moodle token endpoint` };
+}
+function missingBaseUrlMessage(configPath, options = {}) {
+  const targetPath = configPath ?? userConfigPath(options.homeDir);
+  return [
+    "No base_url configured.",
+    `Add base_url to ${targetPath} or set MOODLE_BASE_URL.`,
+    "Required format:",
+    "  base_url: https://school.example.edu",
+    "Use the site root only. Do not include paths like /login/index.php or /my/."
+  ].join("\n");
+}
+async function loadExistingConfig(options) {
+  for (const path3 of [cwdConfigPath(options.cwd), userConfigPath(options.homeDir)]) {
+    const config = await readConfigFile(path3, options);
+    if (config) {
+      return { config, path: path3 };
+    }
+  }
+  return { config: {}, path: null };
+}
+async function readConfigFile(path3, options) {
+  const fs = options.fs ?? nodeFs2;
+  let raw;
+  try {
+    raw = await fs.readFile(path3, "utf8");
+  } catch (error) {
+    if (isMissingFileError2(error)) {
+      return null;
+    }
+    throw error;
+  }
+  const parsed = YAML.parse(raw) ?? {};
+  if (!isRecord4(parsed)) {
+    throw new ConfigError(`${path3} must contain a YAML object.`);
+  }
+  return parsed;
+}
+async function saveConfigFile(path3, config, options) {
+  const fs = options.fs ?? nodeFs2;
+  await fs.mkdir(dirname2(path3), { recursive: true });
+  await fs.writeFile(path3, YAML.stringify(config, { sortMapEntries: true }), "utf8");
+}
+function toMoodleConfig(config, baseUrl) {
+  const { base_url: _baseUrl, ...rest } = config;
+  return { ...rest, baseUrl };
+}
+function defaultPrompt(options) {
+  return async (label) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: options.stdout ?? process.stdout
+    });
+    try {
+      return await rl.question(`${label} > `);
+    } finally {
+      rl.close();
+    }
+  };
+}
+function isInteractive(options) {
+  return Boolean((options.stdin ?? process.stdin).isTTY);
+}
+function isRecord4(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isMissingFileError2(error) {
+  return isRecord4(error) && error.code === "ENOENT";
+}
+
+// src/formatters.ts
+function formatUser(user) {
+  return formatKeyValues([
+    ["User", user.fullname],
+    ["Username", user.username],
+    ["User ID", String(user.userid)],
+    ["Site", user.sitename],
+    ["URL", user.siteurl],
+    ["Language", user.lang ?? ""]
+  ]);
+}
+function formatCourses(courses) {
+  return formatColumns([["ID", "Short Name", "Full Name"], ...courses.map((course) => [String(course.id), course.shortname, course.fullname])]);
+}
+function formatCourseSections(sections) {
+  const lines = ["Course"];
+  for (const section of sections) {
+    lines.push(`  ${section.name || `Section ${section.section}`}${section.visible ? "" : " (hidden)"}`);
+    if (!section.activities.length) {
+      lines.push("    No activities");
+      continue;
+    }
+    for (const activity of section.activities) {
+      lines.push(`    ${activity.name}${activity.visible ? "" : " (hidden)"} (${activity.modname})`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatActivityList(value) {
+  const activities = Array.isArray(value) && value[0] && "activities" in value[0] ? value.flatMap((section) => section.activities) : value;
+  return formatColumns([["ID", "Type", "Name"], ...activities.map((activity) => [String(activity.id), activity.modname, activity.name])]);
+}
+function formatTodo(items) {
+  if (!items.length) {
+    return "No upcoming items";
+  }
+  return formatColumns([
+    ["Due", "Course", "Activity", "Type", "Action"],
+    ...items.map((item) => [
+      item.due_at ? String(item.due_at) : "-",
+      item.course_name,
+      item.activity_name || item.name,
+      item.modname || item.event_type,
+      item.actionable ? item.action_name : ""
+    ])
+  ]);
+}
+function formatAlerts(alerts) {
+  const lines = [
+    `Notifications: ${alerts.notification_count}`,
+    `Unread notifications: ${alerts.unread_notification_count}`,
+    `Direct messages: ${alerts.direct_message_count}`,
+    `Unread direct messages: ${alerts.unread_direct_message_count}`
+  ];
+  for (const notification of alerts.notifications) {
+    lines.push(`${notification.created_pretty || notification.created_at} ${notification.short_subject || notification.subject}`);
+  }
+  return lines.join("\n");
+}
+function formatGrades(grades) {
+  return formatColumns([
+    ["Item", "Grade", "Range", "Percent", "Feedback"],
+    ...grades.items.map((item) => [item.name, item.grade, item.range, item.percentage, item.feedback])
+  ]);
+}
+function formatActivityDetail(activity) {
+  const rows = Object.entries(activity).filter(([, value]) => value !== "" && value !== void 0 && !(Array.isArray(value) && value.length === 0)).map(([key, value]) => [key, Array.isArray(value) ? value.join("\n") : String(value)]);
+  return formatKeyValues(rows);
+}
+function formatForumDiscussion(discussion, options = {}) {
+  const lines = [`Discussion: ${discussion.id}`];
+  if (discussion.subject) {
+    lines.push(`Subject: ${discussion.subject}`);
+  }
+  if (discussion.url) {
+    lines.push(`URL: ${discussion.url}`);
+  }
+  if (discussion.course_id) {
+    lines.push(`Course ID: ${discussion.course_id}`);
+  }
+  if (discussion.forum_id) {
+    lines.push(`Forum ID: ${discussion.forum_id}`);
+  }
+  if (!discussion.posts.length) {
+    lines.push("", "No posts");
+    return lines.join("\n");
+  }
+  for (const post of discussion.posts) {
+    const marker = options.highlightPostId === post.id ? "*" : "-";
+    lines.push("", `${marker} Post ${post.id}`);
+    lines.push(`  Author: ${post.author.fullname || "-"}`);
+    lines.push(`  When: ${post.created_pretty || (post.time_created ? String(post.time_created) : "-")}`);
+    if (post.subject) {
+      lines.push(`  Subject: ${post.subject}`);
+    }
+    if (post.url) {
+      lines.push(`  URL: ${post.url}`);
+    }
+    if (options.showBody) {
+      if (post.message_text) {
+        lines.push("", post.message_text);
+      }
+      if (post.image_urls.length) {
+        lines.push("", "Images:", ...post.image_urls.map((url) => `- ${url}`));
+      }
+    } else {
+      lines.push(`  Preview: ${preview(post.message_text)}`);
+      lines.push(`  Images: ${post.image_urls.length}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatForumDiscussionRefs(forumCmid, refs) {
+  const lines = [`Forum ${forumCmid}: Discussions`];
+  if (!refs.length) {
+    return `${lines[0]}
+No discussions`;
+  }
+  for (const ref of refs) {
+    lines.push([ref.id, ref.subject, ref.group_name, ref.url].filter(Boolean).join(" | "));
+  }
+  return lines.join("\n");
+}
+function formatForumActivities(forums) {
+  if (!forums.length) {
+    return "Forums\nNo forums";
+  }
+  return [
+    "Forums",
+    ...forums.map((forum) => [forum.id, forum.name, forum.course_name, forum.course_id || "", forum.url].filter(Boolean).join(" | "))
+  ].join("\n");
+}
+function formatForumSearchHits(hits) {
+  if (!hits.length) {
+    return "Forum Search\nNo matches";
+  }
+  return [
+    "Forum Search",
+    ...hits.map(
+      (hit) => [
+        hit.course_name,
+        hit.forum_name,
+        hit.discussion_subject,
+        hit.discussion_id || "",
+        hit.post_id || "",
+        hit.matched_in,
+        hit.author_name,
+        hit.snippet || hit.discussion_subject,
+        hit.url
+      ].filter(Boolean).join(" | ")
+    )
+  ].join("\n");
+}
+function formatForumCheckResults(forumCmid, rows) {
+  const lines = [`Forum ${forumCmid}: Discussion Check (first ${rows.length})`];
+  for (const row of rows) {
+    lines.push(
+      row.ok ? `${row.discussion_id} | Yes | ${row.posts ?? ""} | ${row.images ?? ""} | ${row.subject}` : `${row.discussion_id} | No | ${row.subject} | ${row.error ?? ""}`
+    );
+  }
+  return lines.join("\n");
+}
+function preview(value, maxLen = 100) {
+  const cleaned = value.split(/\s+/).filter(Boolean).join(" ");
+  return cleaned.length <= maxLen ? cleaned : `${cleaned.slice(0, maxLen - 1)}\u2026`;
+}
+function formatKeyValues(rows) {
+  const present = rows.filter(([, value]) => value);
+  const width = Math.max(0, ...present.map(([key]) => key.length));
+  return present.map(([key, value]) => `${key.padEnd(width)}  ${value}`).join("\n");
+}
+function formatColumns(rows) {
+  if (!rows.length) {
+    return "";
+  }
+  const widths = rows[0].map((_, index) => Math.max(...rows.map((row) => (row[index] ?? "").length)));
+  return rows.map((row) => row.map((cell, index) => cell.padEnd(widths[index])).join("  ").trimEnd()).join("\n");
+}
+
+// src/output.ts
+import YAML2 from "yaml";
+function stripEmpty(value) {
+  if (value === null || value === void 0 || value === "") {
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    const items = value.map(stripEmpty).filter((item) => item !== void 0);
+    return items.length ? items : void 0;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).map(([key, child]) => [key, stripEmpty(child)]).filter(([, child]) => child !== void 0);
+    return entries.length ? Object.fromEntries(entries) : void 0;
+  }
+  return value;
+}
+function applyFields(data, fieldsValue) {
+  if (!fieldsValue) {
+    return data;
+  }
+  const requested = fieldsValue.split(",").map((field) => field.trim()).filter(Boolean);
+  if (!requested.length) {
+    throw new UsageError("--fields must include at least one field");
+  }
+  const objects = Array.isArray(data) ? data : [data];
+  const firstObject = objects.find(isPlainObject);
+  if (!firstObject) {
+    throw new UsageError("--fields can only be used with object or object-array output");
+  }
+  const valid = Object.keys(firstObject);
+  const invalid = requested.filter((field) => !valid.includes(field));
+  if (invalid.length) {
+    throw new UsageError(`Unknown field '${invalid[0]}'. Valid fields: ${valid.join(", ")}`);
+  }
+  const pick = (item) => {
+    if (!isPlainObject(item)) {
+      return item;
+    }
+    return Object.fromEntries(requested.map((field) => [field, item[field]]));
+  };
+  return Array.isArray(data) ? data.map(pick) : pick(data);
+}
+function serializeStructured(data, options) {
+  const filtered = applyFields(data, options.fields);
+  const optimized = stripEmpty(filtered);
+  const value = optimized === void 0 ? null : optimized;
+  if (options.format === "yaml") {
+    return YAML2.stringify(value).trimEnd();
+  }
+  return JSON.stringify(value);
+}
+function errorJson(code, message, hint) {
+  return JSON.stringify({ error: true, code, message, ...hint ? { hint } : {} });
+}
+function isPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/skills.ts
+import { spawnSync } from "child_process";
+import { readFileSync, writeFileSync } from "fs";
+import path from "path";
+var SKILL_NAME = "moodle-cli";
+var SKILL_SOURCE = "https://github.com/bunizao/moodle-cli";
+var SKILLS_SPEC_URL = "https://github.com/vercel-labs/skills";
+var SKILL_DESCRIPTION = "Inspect Moodle data from the terminal with the `moodle` CLI. Use when an agent needs courses, deadlines, grades, alerts, activities, or forum discussions. Prefer JSON output for agent workflows.";
+function formatSkillSummary() {
+  return [
+    `Name: ${SKILL_NAME}`,
+    `Description: ${SKILL_DESCRIPTION}`,
+    `Source: ${SKILL_SOURCE}`,
+    `Spec: ${SKILLS_SPEC_URL}`,
+    `Install: npx skills add ${SKILL_SOURCE}`,
+    "CLI alias: moodle skills add (falls back to npm exec)",
+    "Generate: moodle skills generate"
+  ].join("\n");
+}
+function buildSkillsAddCommand(extraArgs = [], launcher = "npx") {
+  if (launcher === "npx") {
+    return ["npx", "skills", "add", SKILL_SOURCE, ...extraArgs];
+  }
+  return ["npm", "exec", "--yes", "--", "skills", "add", SKILL_SOURCE, ...extraArgs];
+}
+function addSkill(extraArgs = [], options = {}) {
+  const runCommand = options.runCommand ?? spawnSync;
+  const commandExists = options.commandExists ?? ((name) => isCommandAvailable(name, runCommand));
+  const command = commandExists("npx") ? buildSkillsAddCommand(extraArgs, "npx") : commandExists("npm") ? buildSkillsAddCommand(extraArgs, "npm") : void 0;
+  if (!command) {
+    throw new Error(`npx or npm is required to install agent skills. Install Node.js, then run npx skills add ${SKILL_SOURCE}.`);
+  }
+  const [program, ...args] = command;
+  const result = runCommand(program, args, { stdio: "inherit" });
+  if (result.error) {
+    throw new Error(`Failed to launch ${command.join(" ")}: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    throw new Error(`${command.join(" ")} exited with status ${result.status ?? "unknown"}.`);
+  }
+  return command;
+}
+function installSkill(extraArgs = [], options = {}) {
+  addSkill(extraArgs, options);
+}
+function extractCommanderCommands(program) {
+  return collectCommandRows(program).map((row) => ({
+    name: row.path.at(-1) ?? "",
+    path: row.path,
+    description: row.description,
+    arguments: row.arguments,
+    flags: row.flags
+  }));
+}
+function generateSkillMarkdown(input) {
+  if (isGenerateOptions(input)) {
+    return renderSkillMarkdown(input.commands, input.template);
+  }
+  const template = readSkillTemplate();
+  return renderSkillMarkdown(extractCommanderCommands(input), template);
+}
+function writeGeneratedSkill(program, target = "SKILL.md") {
+  writeFileSync(target, generateSkillMarkdown(program), "utf8");
+}
+function renderSkillMarkdown(commands, template) {
+  const replacements = {
+    generated_frontmatter: renderFrontmatter(),
+    generated_intent_table: renderIntentTable(),
+    generated_command_reference: renderCommandReference(commands),
+    generated_output_contract: renderOutputContract()
+  };
+  let markdown = template;
+  for (const [key, value] of Object.entries(replacements)) {
+    markdown = markdown.replaceAll(`{{${key}}}`, value.trimEnd());
+  }
+  return `${markdown.trimEnd()}
+`;
+}
+function collectCommandRows(command, parentPath = []) {
+  const isRoot = !command.parent;
+  const commandPath2 = isRoot ? parentPath : [...parentPath, command.name()];
+  const ownRows = isRoot || isHiddenCommand(command) ? [] : [{
+    name: command.name(),
+    path: commandPath2,
+    description: command.description() || "",
+    arguments: readArguments(command),
+    flags: readFlags(command)
+  }];
+  const childRows = command.commands.filter((child) => !isHiddenCommand(child) && child.name() !== "help").flatMap((child) => collectCommandRows(child, commandPath2));
+  return [...ownRows, ...childRows];
+}
+function readArguments(command) {
+  const args = command.registeredArguments ?? command._args ?? [];
+  return args.map((arg) => {
+    const nameValue = typeof arg.name === "function" ? arg.name.call(arg) : arg.name;
+    return {
+      name: String(nameValue ?? ""),
+      required: Boolean(arg.required),
+      variadic: Boolean(arg.variadic)
+    };
+  }).filter((arg) => arg.name);
+}
+function readFlags(command) {
+  return command.options.map((option) => {
+    const value = option;
+    return {
+      name: typeof value.long === "string" ? value.long : findLongFlag(option.flags),
+      alias: typeof value.short === "string" ? value.short : findShortFlag(option.flags),
+      description: option.description ?? "",
+      defaultValue: value.defaultValue,
+      required: Boolean(value.required ?? value.mandatory)
+    };
+  }).filter((flag) => flag.name);
+}
+function renderFrontmatter() {
+  return [
+    "---",
+    `name: ${SKILL_NAME}`,
+    `description: ${SKILL_DESCRIPTION}`,
+    "---"
+  ].join("\n");
+}
+function renderIntentTable() {
+  return renderMarkdownTable(
+    ["User intent", "Command"],
+    [
+      ["Show my profile or account info", "moodle user --json"],
+      ["List my courses", "moodle courses --json"],
+      ["Find nearest deadlines or upcoming actions", "moodle todo --limit 5 --days 14 --json"],
+      ["List alerts or unread notifications", "moodle alerts --limit 10 --json"],
+      ["Show a compact dashboard", "moodle overview --todo-limit 5 --alerts-limit 5 --json"],
+      ["Show activities in a course", "moodle activities COURSE_ID --json"],
+      ["Show course sections", "moodle course COURSE_ID --json"],
+      ["Show grades for a course", "moodle grades COURSE_ID --json"],
+      ["Find the best forum match", "moodle forum find QUERY --json"],
+      ["Open a forum discussion URL or ID", "moodle forum discussion DISCUSSION_OR_URL --json"],
+      ["Check whether the CLI has an update", "moodle update --json"],
+      ["Install this agent skill", "moodle skills add"]
+    ]
+  );
+}
+function renderCommandReference(commands) {
+  const rows = flattenCommands(commands).sort((left, right) => commandPath(left).localeCompare(commandPath(right))).map((command) => [
+    `moodle ${commandPath(command)}`.trim(),
+    command.description ?? "",
+    renderArguments(command.arguments ?? []),
+    renderFlags(command.flags ?? [])
+  ]);
+  return renderMarkdownTable(["Command", "Description", "Arguments", "Flags"], rows);
+}
+function renderOutputContract() {
+  return [
+    "### Output Contract",
+    "",
+    "- `--json` writes JSON to stdout.",
+    "- `--yaml` writes YAML to stdout when supported.",
+    "- `--table` forces human-readable table/tree output.",
+    "- When stdout is not a TTY, commands default to JSON unless `--table` is set.",
+    "- `--fields a,b,c` keeps only listed top-level fields. Arrays apply the field filter to each item.",
+    "- Invalid `--fields` values are usage errors and list valid fields.",
+    '- With JSON output enabled, errors are one JSON line on stderr: `{"error":true,"code":"auth_failed","message":"...","hint":"..."}`.',
+    "",
+    "Exit codes:",
+    "",
+    renderMarkdownTable(
+      ["Code", "Meaning"],
+      [
+        ["0", "Success"],
+        ["1", "Unexpected error"],
+        ["2", "Authentication or configuration error"],
+        ["3", "Usage error"],
+        ["4", "Requested course, activity, forum, or discussion was not found"]
+      ]
+    )
+  ].join("\n");
+}
+function flattenCommands(commands) {
+  return commands.flatMap((command) => [command, ...flattenCommands(command.children ?? [])]);
+}
+function commandPath(command) {
+  return (command.path?.length ? command.path : [command.name]).join(" ");
+}
+function renderArguments(args) {
+  return args.map((arg) => {
+    const name = arg.variadic ? `${arg.name}...` : arg.name;
+    return arg.required ? `<${name}>` : `[${name}]`;
+  }).join(" ");
+}
+function renderFlags(flags) {
+  return flags.map((flag) => {
+    const names = [flag.alias, flag.name].filter(Boolean).join(", ");
+    const defaultValue = formatDefault(flag.defaultValue);
+    const required = flag.required ? "value required" : "";
+    const suffix = [defaultValue, required].filter(Boolean).join("; ");
+    return suffix ? `${names} (${suffix})` : names;
+  }).join("<br>");
+}
+function formatDefault(value) {
+  if (value === void 0 || value === false) {
+    return "";
+  }
+  return `default: ${Array.isArray(value) ? value.join(",") : String(value)}`;
+}
+function renderMarkdownTable(headers, rows) {
+  return [
+    `| ${headers.map(escapeCell).join(" | ")} |`,
+    `| ${headers.map(() => "---").join(" | ")} |`,
+    ...rows.map((row) => `| ${row.map(escapeCell).join(" | ")} |`)
+  ].join("\n");
+}
+function escapeCell(value) {
+  return value.replace(/\|/g, "\\|").replace(/\n/g, "<br>");
+}
+function isCommandAvailable(name, runCommand) {
+  const result = runCommand(name, ["--version"], { stdio: "ignore" });
+  return !result.error && result.status === 0;
+}
+function isHiddenCommand(command) {
+  return Boolean(command.hidden || command._hidden);
+}
+function isGenerateOptions(value) {
+  return "template" in value && "commands" in value;
+}
+function readSkillTemplate() {
+  return readFileSync(path.join(process.cwd(), "src", "skill.template.md"), "utf8");
+}
+function findLongFlag(flags) {
+  return flags.split(/[,\s]+/).find((part) => part.startsWith("--")) ?? "";
+}
+function findShortFlag(flags) {
+  return flags.split(/[,\s]+/).find((part) => /^-[^-]/.test(part));
+}
+
+// src/update.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import path2 from "path";
+var UpdateCheckError = class extends Error {
+  cause;
+  constructor(message, options) {
+    super(message);
+    this.name = "UpdateCheckError";
+    this.cause = options?.cause;
+  }
+};
+async function checkForUpdates(currentVersion, fetchImpl = fetch) {
+  const latestVersion = await fetchLatestVersion(fetchImpl);
+  return {
+    package_name: PACKAGE_NAME,
+    current_version: currentVersion,
+    latest_version: latestVersion,
+    update_available: compareSemver(latestVersion, currentVersion) > 0,
+    upgrade_commands: [
+      `npm install -g ${PACKAGE_NAME}@latest`,
+      `Download a standalone binary: ${GITHUB_RELEASES_URL}`
+    ],
+    npm_url: `https://www.npmjs.com/package/${PACKAGE_NAME}`,
+    release_url: GITHUB_RELEASES_URL
+  };
+}
+async function fetchLatestVersion(fetchImpl = fetch, registryUrl = NPM_LATEST_URL) {
+  let response;
+  try {
+    response = await fetchImpl(registryUrl, { headers: { accept: "application/json" } });
+  } catch (error) {
+    throw new UpdateCheckError(errorMessage(error), { cause: error });
+  }
+  if (!response.ok) {
+    const statusText = response.statusText ? ` ${response.statusText}` : "";
+    throw new UpdateCheckError(`npm registry returned HTTP ${response.status}${statusText}`);
+  }
+  let payload;
+  try {
+    payload = await response.json();
+  } catch (error) {
+    throw new UpdateCheckError("invalid response from npm registry", { cause: error });
+  }
+  const latestVersion = typeof payload === "object" && payload !== null ? payload.version : void 0;
+  if (typeof latestVersion !== "string" || latestVersion.trim() === "") {
+    throw new UpdateCheckError("missing version in npm registry response");
+  }
+  return latestVersion.trim();
+}
+function detectInstallKind(argv1 = process.argv[1]) {
+  return detectInstallMethod({ argv1 }) === "npm" ? "npm" : "binary";
+}
+function detectInstallMethod(context = {}) {
+  const env = context.env ?? process.env;
+  const explicit = env.MOODLE_CLI_INSTALL_METHOD?.toLowerCase();
+  if (explicit === "npm" || explicit === "binary" || explicit === "source") {
+    return explicit;
+  }
+  const argv1 = normalizePath(context.argv1 ?? process.argv[1] ?? "");
+  const execPath = normalizePath(context.execPath ?? process.execPath ?? "");
+  const scriptName = path2.basename(argv1).toLowerCase();
+  const executableName = path2.basename(execPath).toLowerCase();
+  if (argv1.includes("/node_modules/moodle-cli/") || argv1.includes("/node_modules/.bin/")) {
+    return "npm";
+  }
+  if (scriptName === "moodle" || scriptName === "moodle.cmd" || scriptName === "moodle-cli") {
+    return "npm";
+  }
+  if (!argv1 || executableName === "moodle" || executableName === "moodle.exe" || executableName === "moodle-cli") {
+    return "binary";
+  }
+  if (argv1.includes("/src/") || argv1.endsWith("/src/cli.ts")) {
+    return "source";
+  }
+  return "unknown";
+}
+function applySelfUpdate(kind = detectInstallKind(), options = {}) {
+  if (kind !== "npm") {
+    return GITHUB_RELEASES_URL;
+  }
+  const runCommand = options.runCommand ?? spawnSync2;
+  const available = runCommand("npm", ["--version"], { stdio: "ignore" });
+  if (available.error || available.status !== 0) {
+    throw new Error(`npm is required to update ${PACKAGE_NAME}. Download a binary from ${GITHUB_RELEASES_URL}`);
+  }
+  const command = ["npm", "install", "-g", `${PACKAGE_NAME}@latest`];
+  const result = runCommand(command[0], command.slice(1), { stdio: "inherit" });
+  if (result.error) {
+    throw new Error(`Failed to run ${command.join(" ")}: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    throw new Error(`${command.join(" ")} exited with status ${result.status ?? "unknown"}`);
+  }
+  return command.join(" ");
+}
+function compareSemver(left, right) {
+  const a = parseSemver(left);
+  const b = parseSemver(right);
+  for (const key of ["major", "minor", "patch"]) {
+    if (a[key] !== b[key]) {
+      return a[key] > b[key] ? 1 : -1;
+    }
+  }
+  return comparePrerelease(a.prerelease, b.prerelease);
+}
+function parseSemver(value) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(value.trim());
+  if (!match) {
+    throw new UpdateCheckError(`invalid semver '${value}'`);
+  }
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ? match[4].split(".") : []
+  };
+}
+function comparePrerelease(left, right) {
+  if (left.length === 0 && right.length === 0) {
+    return 0;
+  }
+  if (left.length === 0) {
+    return 1;
+  }
+  if (right.length === 0) {
+    return -1;
+  }
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index += 1) {
+    const a = left[index];
+    const b = right[index];
+    if (a === void 0) return -1;
+    if (b === void 0) return 1;
+    if (a === b) continue;
+    const numericA = /^\d+$/.test(a);
+    const numericB = /^\d+$/.test(b);
+    if (numericA && numericB) {
+      return Number(a) > Number(b) ? 1 : -1;
+    }
+    if (numericA) return -1;
+    if (numericB) return 1;
+    return a > b ? 1 : -1;
+  }
+  return 0;
+}
+function normalizePath(value) {
+  return value.replace(/\\/g, "/");
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/version.ts
+var VERSION = "0.5.5";
+
+// src/url-resolver.ts
+function looksLikeUrl(value) {
+  try {
+    const parsed = new URL(value);
+    return Boolean(parsed.protocol && parsed.host);
+  } catch {
+    return false;
+  }
+}
+function resolveTopLevelUrl(baseUrlOrOptions, targetValue, resolveCourseIdForUrlValue) {
+  const objectMode = typeof baseUrlOrOptions !== "string";
+  const baseUrl = objectMode ? baseUrlOrOptions.baseUrl : baseUrlOrOptions;
+  const target = objectMode ? baseUrlOrOptions.target : targetValue ?? "";
+  const resolveCourseIdForUrl = objectMode ? baseUrlOrOptions.resolveCourseIdForUrl : resolveCourseIdForUrlValue;
+  let parsed;
+  try {
+    parsed = new URL(target.trim());
+  } catch {
+    throw new UsageError(`No such command '${target}'.`);
+  }
+  const configuredHost = new URL(baseUrl).host.toLowerCase();
+  if (parsed.host.toLowerCase() !== configuredHost) {
+    throw new UsageError(`URL host '${parsed.host.toLowerCase()}' does not match configured Moodle site '${configuredHost}'.`);
+  }
+  const path3 = parsed.pathname.replace(/\/$/, "");
+  const intParam = (key, label) => {
+    const value = parsed.searchParams.get(key);
+    if (!value || !/^\d+$/.test(value)) {
+      throw new UsageError(`Could not find ${label} in URL query (expected ?${key}=...).`);
+    }
+    return value;
+  };
+  if (path3.endsWith("/mod/forum/discuss.php")) {
+    return objectMode ? { commandName: "forum_discussion", kwargs: { discussion: intParam("d", "discussion ID"), postId: parsed.hash, asJson: false, asYaml: false } } : { commandName: "forum:discussion", args: [intParam("d", "discussion ID"), parsed.hash] };
+  }
+  if (path3.endsWith("/mod/forum/view.php")) {
+    return objectMode ? { commandName: "forum_discussions", kwargs: { forum: intParam("id", "forum module ID"), asJson: false, asYaml: false } } : { commandName: "forum:discussions", args: [intParam("id", "forum module ID")] };
+  }
+  if (path3.endsWith("/mod/assign/view.php")) {
+    const id = intParam("id", "assignment module ID");
+    return objectMode ? { commandName: "assign", kwargs: { assign: id, asJson: false, asYaml: false } } : { commandName: "assign", args: [id] };
+  }
+  if (path3.endsWith("/mod/quiz/view.php")) {
+    const id = intParam("id", "quiz module ID");
+    return objectMode ? { commandName: "quiz", kwargs: { quiz: id, asJson: false, asYaml: false } } : { commandName: "quiz", args: [id] };
+  }
+  if (path3.endsWith("/mod/resource/view.php")) {
+    const id = intParam("id", "resource module ID");
+    return objectMode ? { commandName: "resource", kwargs: { resource: id, asJson: false, asYaml: false } } : { commandName: "resource", args: [id] };
+  }
+  if (path3.endsWith("/mod/url/view.php")) {
+    const id = intParam("id", "link module ID");
+    return objectMode ? { commandName: "link", kwargs: { link: id, asJson: false, asYaml: false } } : { commandName: "link", args: [id] };
+  }
+  if (path3.endsWith("/mod/page/view.php")) {
+    const id = intParam("id", "page module ID");
+    return objectMode ? { commandName: "page", kwargs: { page: id, asJson: false, asYaml: false } } : { commandName: "page", args: [id] };
+  }
+  if (path3.endsWith("/mod/folder/view.php")) {
+    const id = intParam("id", "folder module ID");
+    return objectMode ? { commandName: "folder", kwargs: { folder: id, asJson: false, asYaml: false } } : { commandName: "folder", args: [id] };
+  }
+  if (path3.endsWith("/course/view.php")) {
+    const id = intParam("id", "course ID");
+    return objectMode ? { commandName: "course", kwargs: { course: id, asJson: false, asYaml: false } } : { commandName: "course", args: [id] };
+  }
+  if (path3.endsWith("/course/user.php") && parsed.searchParams.get("mode") === "grade" || path3.includes("/grade/report/")) {
+    const id = intParam("id", "course ID");
+    return objectMode ? { commandName: "grades", kwargs: { course: id, asJson: false, asYaml: false } } : { commandName: "grades", args: [id] };
+  }
+  if (path3.includes("/mod/") && path3.endsWith("/view.php")) {
+    if (!resolveCourseIdForUrl) {
+      throw new UsageError("Could not resolve course ID from the activity page.");
+    }
+    const finish = (courseId2) => {
+      if (!courseId2) {
+        throw new UsageError("Could not resolve course ID from the activity page.");
+      }
+      return objectMode ? { commandName: "course", kwargs: { course: String(courseId2), asJson: false, asYaml: false } } : { commandName: "course", args: [String(courseId2)] };
+    };
+    const courseId = resolveCourseIdForUrl(target);
+    return courseId instanceof Promise ? courseId.then(finish) : finish(courseId);
+  }
+  throw new UsageError("Unsupported Moodle URL. Supported paths: forum, activity, course, and grade report URLs.");
+}
+function parseActivityReference(value, labelOrOptions, expectedPathValue) {
+  const label = typeof labelOrOptions === "string" ? labelOrOptions : labelOrOptions.label;
+  const expectedPath = typeof labelOrOptions === "string" ? expectedPathValue ?? "" : labelOrOptions.path;
+  const raw = value.trim();
+  if (/^\d+$/.test(raw)) {
+    return Number(raw);
+  }
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    throw new UsageError(`${label} must be a numeric ID or a full ${label.toLowerCase()} URL.`);
+  }
+  if (!parsed.pathname.endsWith(expectedPath)) {
+    throw new UsageError(`Unsupported ${label.toLowerCase()} URL. Use a view.php?id=... URL.`);
+  }
+  const id = parsed.searchParams.get("id");
+  if (!id || !/^\d+$/.test(id)) {
+    throw new UsageError(`Could not find ${label.toLowerCase()} module ID in view.php URL (expected ?id=...).`);
+  }
+  return Number(id);
+}
+function parseDiscussionReference(value) {
+  const raw = value.trim();
+  if (/^\d+$/.test(raw)) {
+    return { discussionId: Number(raw), postId: null };
+  }
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    throw new UsageError("DISCUSSION must be a numeric ID or a full discuss.php URL.");
+  }
+  const discussion = parsed.searchParams.get("d");
+  if (!discussion || !/^\d+$/.test(discussion)) {
+    throw new UsageError("Could not find discussion ID in URL query (expected ?d=...).");
+  }
+  const postId = parsed.hash.startsWith("#p") && /^\d+$/.test(parsed.hash.slice(2)) ? Number(parsed.hash.slice(2)) : null;
+  return { discussionId: Number(discussion), postId };
+}
+
+// src/cli.ts
+function buildProgram(io = {}) {
+  const stdout = io.stdout ?? process.stdout;
+  const stderr = io.stderr ?? process.stderr;
+  const program = new Command("moodle");
+  program.version(VERSION);
+  program.description("Terminal-first CLI for Moodle LMS.");
+  program.exitOverride();
+  program.allowUnknownOption(true);
+  program.allowExcessArguments(true);
+  program.configureOutput({
+    writeOut: (text) => stdout.write(text),
+    writeErr: (text) => stderr.write(text)
+  });
+  program.option("-v, --verbose", "Enable debug logging.");
+  program.option("--no-cache", "Bypass session cache reads.");
+  program.argument("[target]", "Supported Moodle URL");
+  const runtime = {
+    client: null,
+    baseUrl: async () => (await loadConfig({ env: io.env, cwd: io.cwd, homeDir: io.homeDir, stdin: io.stdin, fetch: io.fetchImpl })).baseUrl,
+    getClient: async () => {
+      if (!runtime.client) {
+        const baseUrl = await runtime.baseUrl();
+        runtime.client = await createMoodleClient(baseUrl, {
+          env: io.env,
+          fetchImpl: io.fetchImpl,
+          homeDir: io.homeDir,
+          noCache: Boolean(program.opts().cache === false)
+        });
+      }
+      return runtime.client;
+    },
+    output: (data, formatter, options) => {
+      const format = outputFormat(options, stdout);
+      if (format === "table") {
+        stdout.write(`${formatter()}
+`);
+      } else {
+        stdout.write(`${serializeStructured(data, { format, fields: options.fields })}
+`);
+      }
+    }
+  };
+  program.action(async (target, options, command) => {
+    if (!target) {
+      command.help();
+      return;
+    }
+    if (!looksLikeUrl(target)) {
+      throw new UsageError(`No such command '${target}'.`);
+    }
+    await dispatchUrl(runtime, target, { ...parseRootOutputOptions(io.rootArgs ?? []), ...options });
+  });
+  addOutputOptions(program.command("user").description("Show authenticated user info.")).action(async (options) => {
+    const user = await (await runtime.getClient()).getSiteInfo();
+    runtime.output(user, () => formatUser(user), options);
+  });
+  addOutputOptions(program.command("courses").description("List enrolled courses.")).action(async (options) => {
+    const courses = await (await runtime.getClient()).getCourses();
+    runtime.output(courses, () => formatCourses(courses), options);
+  });
+  addOutputOptions(program.command("todo").description("List upcoming actionable timeline items.")).option("--limit <number>", "Maximum number of items.", parsePositiveInt, 20).option("--days <number>", "Only include items due within the next N days.", parsePositiveInt).action(async (options) => {
+    const items = await (await runtime.getClient()).getTodo(options.limit, options.days);
+    runtime.output(items, () => formatTodo(items), options);
+  });
+  addOutputOptions(program.command("alerts").description("List notifications and message counts.")).option("--limit <number>", "Maximum number of notifications.", parsePositiveInt, 20).action(async (options) => {
+    const alerts = await (await runtime.getClient()).getAlerts(options.limit);
+    runtime.output(alerts, () => formatAlerts(alerts), options);
+  });
+  addOutputOptions(program.command("overview").description("Show a compact multi-source overview.")).option("--todo-limit <number>", "Maximum number of todo items.", parsePositiveInt, 5).option("--todo-days <number>", "Only include todo items due within the next N days.", parsePositiveInt).option("--alerts-limit <number>", "Maximum number of notifications.", parsePositiveInt, 5).action(async (options) => {
+    const overview = await (await runtime.getClient()).getOverview(options.todoLimit, options.todoDays, options.alertsLimit);
+    runtime.output(overview, () => `${formatUser(overview.user)}
+
+${formatTodo(overview.todo)}
+
+${overview.alerts ? formatAlerts(overview.alerts) : ""}`, options);
+  });
+  addCourseCommand(program, runtime, "course", "Show course detail with sections.", async (client, courseId) => client.getCourseContents(courseId), formatCourseSections);
+  addCourseCommand(program, runtime, "activities", "List activities in a course.", async (client, courseId) => client.getActivities(courseId), formatActivityList);
+  addOutputOptions(program.command("grades").description("Show grade details for a course.").argument("<course>", "Course ID or unique name")).action(
+    async (course, options) => {
+      const client = await runtime.getClient();
+      const courseId = await client.resolveCourseReference(course);
+      const grades = await client.getCourseGrades(courseId);
+      runtime.output(grades, () => formatGrades(grades), options);
+    }
+  );
+  addActivityCommand(program, runtime, "assign", "Assignment", ASSIGN_VIEW_PATH, (client, id) => client.getAssignment(id));
+  addActivityCommand(program, runtime, "quiz", "Quiz", QUIZ_VIEW_PATH, (client, id) => client.getQuiz(id));
+  addActivityCommand(program, runtime, "resource", "Resource", RESOURCE_VIEW_PATH, (client, id) => client.getResource(id));
+  addActivityCommand(program, runtime, "link", "Link", URL_VIEW_PATH, (client, id) => client.getLink(id));
+  addActivityCommand(program, runtime, "page", "Page", PAGE_VIEW_PATH, (client, id) => client.getPage(id));
+  addActivityCommand(program, runtime, "folder", "Folder", FOLDER_VIEW_PATH, (client, id) => client.getFolder(id));
+  const forum = program.command("forum").description("Forum utilities.");
+  addOutputOptions(forum.command("discussion").description("Show posts in a forum discussion.").argument("<discussion>", "Discussion ID or URL")).option("--post <id>", "Show a specific post ID.", parsePositiveInt).option("--body", "Show full post body.").action(async (discussion, options) => {
+    const parsed = parseDiscussionReference(discussion);
+    const postId = options.post ?? parsed.postId;
+    const thread = filterDiscussionToPost(await (await runtime.getClient()).getForumDiscussion(parsed.discussionId), postId);
+    runtime.output(thread, () => formatForumDiscussion(thread, { showBody: options.body }), options);
+  });
+  addOutputOptions(forum.command("discussions").description("List discussions from a forum.").argument("<forum>", "Forum ID or URL")).option("--limit <number>", "Maximum number of discussions.", parsePositiveInt, 50).option("--query <query>", "Filter discussion titles by query.").action(async (forumRef, options) => {
+    const client = await runtime.getClient();
+    const forumId = await parseForumReference(client, forumRef);
+    let refs = await client.getForumDiscussionRefs(forumId);
+    if (options.query) {
+      refs = refs.filter((ref) => queryMatches2(ref.subject, options.query));
+    }
+    refs = refs.slice(0, options.limit);
+    runtime.output(refs, () => formatForumDiscussionRefs(forumId, refs), options);
+  });
+  addOutputOptions(forum.command("forums").description("List forum activities.").argument("[query]", "Optional forum/course query")).option("--course <course>", "Restrict to a course ID or unique course name match.").option("--limit <number>", "Maximum number of forums.", parsePositiveInt, 50).action(async (query, options) => {
+    const client = await runtime.getClient();
+    const courseId = options.course ? await client.resolveCourseReference(options.course) : void 0;
+    let forums = await client.getForums(courseId);
+    if (query) {
+      forums = forums.filter((forum2) => queryMatches2(forum2.name, query) || queryMatches2(forum2.course_name, query));
+    }
+    forums = forums.slice(0, options.limit);
+    runtime.output(forums, () => formatForumActivities(forums), options);
+  });
+  addForumSearchCommand(forum.command("search").description("Search forum discussion titles and post text."), runtime, 20, false);
+  addForumSearchCommand(forum.command("find").description("Find the best forum match.").option("--list", "Return a shortlist.").option("--body", "Resolve the target body."), runtime, 5, true);
+  addOutputOptions(forum.command("check").description("Validate discussion rendering.").argument("<forum>", "Forum ID or URL")).option("--limit <number>", "Maximum number of discussions.", parsePositiveInt, 20).action(async (forumRef, options) => {
+    const client = await runtime.getClient();
+    const forumId = await parseForumReference(client, forumRef);
+    const refs = (await client.getForumDiscussionRefs(forumId)).slice(0, options.limit);
+    const results = [];
+    for (const ref of refs) {
+      try {
+        const discussion = await client.getForumDiscussion(ref.id);
+        results.push({
+          discussion_id: ref.id,
+          subject: ref.subject,
+          ok: true,
+          posts: discussion.posts.length,
+          images: discussion.posts.reduce((total, post) => total + post.image_urls.length, 0)
+        });
+      } catch (error) {
+        results.push({ discussion_id: ref.id, subject: ref.subject, ok: false, error: error instanceof Error ? error.message : String(error) });
+      }
+    }
+    runtime.output(results, () => formatForumCheckResults(forumId, results), options);
+  });
+  addOutputOptions(program.command("update").description("Check for updates and upgrade the installed CLI.")).option("--check-only", "Only check for updates; do not install.").action(async (options) => {
+    try {
+      const info = await checkForUpdates(VERSION, io.fetchImpl);
+      if (outputFormat(options, stdout) !== "table") {
+        runtime.output(info, () => "", options);
+        return;
+      }
+      if (!info.update_available) {
+        stdout.write(`${info.package_name} is up to date (${info.current_version})
+`);
+        return;
+      }
+      stdout.write(`Update available: ${info.latest_version} (installed: ${info.current_version})
+`);
+      if (options.checkOnly) {
+        stdout.write(`Upgrade with: ${info.upgrade_commands.join(" && ")}
+`);
+        return;
+      }
+      stdout.write(`Updated with: ${applySelfUpdate()}
+`);
+    } catch (error) {
+      stdout.write(`Could not check for updates: ${error instanceof Error ? error.message : String(error)}
+`);
+    }
+  });
+  const skills = program.command("skills").description("Show skill metadata or delegate to the shared skills CLI.");
+  skills.action(() => {
+    stdout.write(`${formatSkillSummary()}
+`);
+  });
+  skills.command("generate").description("Regenerate SKILL.md from the CLI command tree.").action(() => {
+    writeGeneratedSkill(program);
+    stdout.write("Generated SKILL.md\n");
+  });
+  skills.command("add").description("Install the published skill through npx skills add.").allowUnknownOption(true).action((_options, command) => installSkill(command.args));
+  hideCommand(skills.command("install").allowUnknownOption(true)).action((_options, command) => installSkill(command.args));
+  hideCommand(skills.command("i").allowUnknownOption(true)).action((_options, command) => installSkill(command.args));
+  return program;
+}
+async function runCli(argv = process.argv, io = {}) {
+  const stderr = io.stderr ?? process.stderr;
+  const stdout = io.stdout ?? process.stdout;
+  const program = buildProgram({ ...io, rootArgs: argv.slice(2) });
+  try {
+    await program.parseAsync(argv, { from: "node" });
+    return 0;
+  } catch (error) {
+    if (error instanceof CommanderError) {
+      if (error.code === "commander.helpDisplayed" || error.code === "commander.version") {
+        return 0;
+      }
+      const cliError2 = new UsageError(error.message);
+      writeError(cliError2, stderr, wantsJsonFromArgs(argv, stdout));
+      return cliError2.exitCode;
+    }
+    const cliError = toCliError(error);
+    writeError(cliError, stderr, wantsJsonFromArgs(argv, stdout));
+    return cliError.exitCode;
+  }
+}
+async function dispatchUrl(runtime, target, options) {
+  const client = await runtime.getClient();
+  const resolved = await resolveTopLevelUrl(client.baseUrl, target, (url) => client.resolveCourseIdForUrl(url));
+  const [first2] = resolved.args ?? [];
+  if (!first2) {
+    throw new UsageError("Unsupported Moodle URL.");
+  }
+  switch (resolved.commandName) {
+    case "assign": {
+      const item = await client.getAssignment(Number(first2));
+      runtime.output(item, () => formatActivityDetail(item), options);
+      return;
+    }
+    case "quiz": {
+      const item = await client.getQuiz(Number(first2));
+      runtime.output(item, () => formatActivityDetail(item), options);
+      return;
+    }
+    case "resource": {
+      const item = await client.getResource(Number(first2));
+      runtime.output(item, () => formatActivityDetail(item), options);
+      return;
+    }
+    case "link": {
+      const item = await client.getLink(Number(first2));
+      runtime.output(item, () => formatActivityDetail(item), options);
+      return;
+    }
+    case "page": {
+      const item = await client.getPage(Number(first2));
+      runtime.output(item, () => formatActivityDetail(item), options);
+      return;
+    }
+    case "folder": {
+      const item = await client.getFolder(Number(first2));
+      runtime.output(item, () => formatActivityDetail(item), options);
+      return;
+    }
+    case "course": {
+      const sections = await client.getCourseContents(Number(first2));
+      runtime.output(sections, () => formatCourseSections(sections), options);
+      return;
+    }
+    case "grades": {
+      const grades = await client.getCourseGrades(Number(first2));
+      runtime.output(grades, () => formatGrades(grades), options);
+      return;
+    }
+    case "forum:discussion": {
+      const postHash = resolved.args?.[1] ?? "";
+      const postId = postHash.startsWith("#p") ? Number(postHash.slice(2)) : null;
+      const discussion = filterDiscussionToPost(await client.getForumDiscussion(Number(first2)), Number.isFinite(postId) ? postId : null);
+      runtime.output(discussion, () => formatForumDiscussion(discussion), options);
+      return;
+    }
+    case "forum:discussions": {
+      const refs = await client.getForumDiscussionRefs(Number(first2));
+      runtime.output(refs, () => formatForumDiscussionRefs(Number(first2), refs), options);
+      return;
+    }
+    default:
+      throw new UsageError("Unsupported Moodle URL.");
+  }
+}
+function addCourseCommand(program, runtime, name, description, load, format) {
+  addOutputOptions(program.command(name).description(description).argument("<course>", "Course ID or unique name")).action(async (course, options) => {
+    const client = await runtime.getClient();
+    const courseId = await client.resolveCourseReference(course);
+    const value = await load(client, courseId);
+    runtime.output(value, () => format(value), options);
+  });
+}
+function addActivityCommand(program, runtime, name, label, path3, load) {
+  return addOutputOptions(program.command(name).description(`Show ${label.toLowerCase()} details.`).argument(`<${name}>`, `${label} ID or URL`)).action(
+    async (value, options) => {
+      const id = parseActivityReference(value, label, path3);
+      const item = await load(await runtime.getClient(), id);
+      runtime.output(item, () => formatActivityDetail(item), options);
+    }
+  );
+}
+function addForumSearchCommand(command, runtime, defaultLimit, findMode) {
+  addOutputOptions(command.argument("<query>", "Search query")).option("--course <course>", "Restrict to a course ID or unique course name match.").option("--forum <forum>", "Restrict to a forum ID or forum URL.").option("--titles-only", "Only search discussion titles.").option("--unread-only", "Only include unread matches.").option("--recent", "Sort matches by newest activity.").option("--limit-forums <number>", "Maximum number of forums to scan.", parsePositiveInt).option("--limit-discussions <number>", "Maximum number of discussions per forum.", parsePositiveInt).option("--limit <number>", "Maximum number of matches.", parsePositiveInt, defaultLimit).action(async (query, options) => {
+    const client = await runtime.getClient();
+    const courseId = options.course ? await client.resolveCourseReference(options.course) : void 0;
+    const forumCmid = options.forum ? await parseForumReference(client, options.forum) : void 0;
+    const limit = findMode && !options.list ? 1 : options.limit;
+    const hits = await client.searchForumContent({
+      query,
+      limit,
+      courseId,
+      forumCmid,
+      includePostText: !options.titlesOnly,
+      unreadOnly: options.unreadOnly,
+      sortBy: options.recent || findMode ? "recent" : "relevance",
+      maxForums: options.limitForums,
+      maxDiscussionsPerForum: options.limitDiscussions
+    });
+    if (findMode && options.body && hits[0]) {
+      const discussion = filterDiscussionToPost(await client.getForumDiscussion(hits[0].discussion_id), hits[0].post_id || null);
+      runtime.output(discussion, () => formatForumDiscussion(discussion, { showBody: true }), options);
+      return;
+    }
+    const output = findMode && !options.list ? hits[0] ?? null : hits;
+    runtime.output(output, () => formatForumSearchHits(Array.isArray(output) ? output : output ? [output] : []), options);
+  });
+}
+async function parseForumReference(client, value) {
+  const raw = value.trim();
+  if (/^\d+$/.test(raw)) {
+    return Number(raw);
+  }
+  const parsed = new URL(raw);
+  if (parsed.pathname.endsWith("/mod/forum/view.php")) {
+    const id = parsed.searchParams.get("id");
+    if (id && /^\d+$/.test(id)) {
+      return Number(id);
+    }
+  }
+  if (parsed.pathname.endsWith("/mod/forum/discuss.php")) {
+    const id = parsed.searchParams.get("d");
+    if (id && /^\d+$/.test(id)) {
+      const forumId = await client.getForumViewCmid(Number(id));
+      if (forumId) {
+        return forumId;
+      }
+    }
+  }
+  throw new UsageError("Unsupported forum URL. Use a view.php?id=... or discuss.php?d=... URL.");
+}
+function addOutputOptions(command) {
+  return command.option("--json", "Output as JSON.").option("--yaml", "Output as YAML.").option("--table", "Force human output.").option("--fields <fields>", "Keep only listed top-level fields in structured output.");
+}
+function hideCommand(command) {
+  command.hidden = true;
+  return command;
+}
+function outputFormat(options, stdout) {
+  if (options.yaml) {
+    return "yaml";
+  }
+  if (options.json) {
+    return "json";
+  }
+  if (options.table) {
+    return "table";
+  }
+  return "isTTY" in stdout && stdout.isTTY ? "table" : "json";
+}
+function parsePositiveInt(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new UsageError("Expected a positive integer.");
+  }
+  return parsed;
+}
+function writeError(error, stderr, asJson) {
+  if (asJson) {
+    stderr?.write(`${errorJson(error.code, error.message, error.hint)}
+`);
+    return;
+  }
+  stderr?.write(`${labelFor(error)}: ${error.message}
+`);
+  if (error instanceof ConfigError && error.hint) {
+    stderr?.write(`${error.hint}
+`);
+  } else if (error.hint) {
+    stderr?.write(`${error.hint}
+`);
+  }
+  if (error instanceof MoodleAPIError && error.moodleErrorCode) {
+    stderr?.write(`Error code: ${error.moodleErrorCode}
+`);
+  }
+}
+function wantsJsonFromArgs(argv, stdout) {
+  return argv.includes("--json") || !argv.includes("--table") && !("isTTY" in stdout && stdout.isTTY);
+}
+function parseRootOutputOptions(args) {
+  const fieldsIndex = args.findIndex((arg) => arg === "--fields" || arg.startsWith("--fields="));
+  const fieldsArg = fieldsIndex >= 0 ? args[fieldsIndex] : "";
+  const fields = fieldsArg.startsWith("--fields=") ? fieldsArg.slice("--fields=".length) : fieldsIndex >= 0 ? args[fieldsIndex + 1] : void 0;
+  if (fieldsIndex >= 0 && (!fields || fields.startsWith("--"))) {
+    throw new UsageError("--fields requires a value.");
+  }
+  return {
+    json: args.includes("--json"),
+    yaml: args.includes("--yaml"),
+    table: args.includes("--table"),
+    fields
+  };
+}
+function labelFor(error) {
+  if (error.code === "auth_failed") {
+    return "Auth error";
+  }
+  if (error.code === "config_error") {
+    return "Config error";
+  }
+  if (error.code === "usage_error") {
+    return "Usage error";
+  }
+  if (error.code === "not_found") {
+    return "Not found";
+  }
+  return "Error";
+}
+function queryMatches2(text, query) {
+  const haystack = text.toLowerCase().split(/\s+/).join(" ");
+  const needle = query.toLowerCase().split(/\s+/).join(" ");
+  return needle ? haystack.includes(needle) || needle.split(" ").every((token) => haystack.includes(token)) : true;
+}
+var isMain = process.argv[1] ? realpathSync(fileURLToPath(import.meta.url)) === realpathSync(process.argv[1]) : false;
+if (isMain) {
+  runCli().then((code) => {
+    process.exitCode = code;
+  });
+}
+export {
+  buildProgram,
+  runCli
+};