moodle-cli 0.7.0-alpha.3 → 0.7.0-alpha.5

package/dist/moodle.js

@@ -98,7 +98,7 @@ var MoodleAPIError = class extends CliError {
   moodleErrorCode;
   constructor(message, moodleErrorCode) {
     const auth = isLoginErrorCode(moodleErrorCode);
-    const notFound = ["invalidrecord", "invalidcoursemodule"].includes(moodleErrorCode ?? "") || /^HTTP 404\b/.test(message);
+    const notFound = ["invalidrecord", "invalidcoursemodule"].includes(moodleErrorCode ?? "") || /\bHTTP 404\b/.test(message);
     super(auth ? "auth" : notFound ? "not_found" : "upstream", message, auth ? "Run `moodle auth login`." : void 0);
     this.moodleErrorCode = moodleErrorCode;
   }
@@ -898,6 +898,32 @@ function htmlText(value, baseUrl) {
 
 // src/scraper.ts
 import { parse as parse2 } from "node-html-parser";
+function parseMoodleErrorHtml(html) {
+  const root = parse2(html);
+  const messageNode = first(root, [
+    ".errormessage",
+    ".alert-danger .alert-message",
+    "[data-region='error-message']",
+    ".alert-danger[role='alert']",
+    ".alert-danger"
+  ]);
+  if (!messageNode) {
+    return null;
+  }
+  const messageRoot = parse2(messageNode.toString());
+  for (const unwanted of messageRoot.querySelectorAll(
+    "button, .close, .errorcode, .stacktrace, .debuginfo, .backtrace, a.alert-link, a[href*='/error/']"
+  )) {
+    unwanted.remove();
+  }
+  const message = cleanText(messageRoot.textContent);
+  if (!message) {
+    return null;
+  }
+  const errorCodeText = cleanNodeText(root.querySelector(".errorcode"));
+  const errorCode = errorCodeText.match(/^error\s+code\s*:\s*([a-z][a-z0-9_]*)\s*$/iu)?.[1] ?? moodleDocsErrorCode(root);
+  return { message, ...errorCode ? { code: errorCode } : {} };
+}
 function parsePageContext(html, baseUrl) {
   const root = parse2(html);
   const config = parseMoodleConfig(html);
@@ -984,9 +1010,9 @@ function parseCourseSectionNumbers(html, courseId) {
   for (const href of hrefs) {
     const url = parseMaybeUrl(href.replace(/&/gu, "&"), "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);
+    const sectionValue2 = url?.searchParams.get("section");
+    if (id === String(courseId) && sectionValue2 && /^\d+$/.test(sectionValue2)) {
+      const section = Number(sectionValue2);
       if (!sections.includes(section)) {
         sections.push(section);
       }
@@ -1329,6 +1355,16 @@ function selectedGroupName(root, groupId) {
   }
   return "";
 }
+function moodleDocsErrorCode(root) {
+  for (const link2 of root.querySelectorAll("a[href*='/error/']")) {
+    const href = link2.getAttribute("href") ?? "";
+    const code = href.match(/\/error\/[^/]+\/([a-z][a-z0-9_]*)/iu)?.[1];
+    if (code) {
+      return code;
+    }
+  }
+  return void 0;
+}
 function cleanNodeText(node) {
   return cleanText(node?.textContent ?? "");
 }
@@ -1818,7 +1854,7 @@ var MoodleClientCoreApiError = class extends MoodleClientCoreError {
   moodleErrorCode;
   constructor(message, moodleErrorCode) {
     const auth = isLoginErrorCode2(moodleErrorCode);
-    const notFound = ["invalidrecord", "invalidcoursemodule"].includes(moodleErrorCode ?? "") || /^HTTP 404\b/.test(message);
+    const notFound = ["invalidrecord", "invalidcoursemodule"].includes(moodleErrorCode ?? "") || /\bHTTP 404\b/.test(message);
     super(
       auth ? "auth" : notFound ? "not_found" : "upstream",
       message,
@@ -2249,7 +2285,15 @@ var MoodleClientCore = class {
       throw this.errors.api("Session expired", "servicerequireslogin");
     }
     if (!response.ok) {
-      throw this.errors.api(`HTTP ${response.status} loading ${safeUrl(url)}`);
+      const context = `HTTP ${response.status} loading ${safeUrl(url)}`;
+      const contentType3 = response.headers.get("content-type")?.toLowerCase() ?? "";
+      if (contentType3.includes("text/html") || contentType3.includes("application/xhtml+xml")) {
+        const moodleError = await response.text().then(parseMoodleErrorHtml).catch(() => null);
+        if (moodleError) {
+          throw this.errors.api(`${moodleError.message} (${context})`, moodleError.code);
+        }
+      }
+      throw this.errors.api(context);
     }
     return response;
   }
@@ -2625,8 +2669,8 @@ async function probeBaseUrl(baseUrl, options = {}) {
     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 contentType2 = response.headers.get("content-type")?.toLowerCase() ?? "";
-  const looksJson = contentType2.includes("application/json") || body.startsWith("{");
+  const contentType3 = response.headers.get("content-type")?.toLowerCase() ?? "";
+  const looksJson = contentType3.includes("application/json") || body.startsWith("{");
   const looksMoodleTokenError = [
     '"errorcode":"missingparam"',
     '"errorcode":"invalidparameter"',
@@ -2715,84 +2759,163 @@ function isMissingFileError2(error) {
   return isRecord5(error) && error.code === "ENOENT";
 }
 
+// src/terminal-table.ts
+import Table from "tty-table";
+var DEFAULT_WIDTH = 120;
+var MIN_TABLE_WIDTH = 40;
+function renderTerminalTable(columns, rows, options = {}) {
+  const tableWidth = Math.max(MIN_TABLE_WIDTH, options.width ?? process.stdout.columns ?? DEFAULT_WIDTH);
+  const tableColumns = columns.map((column, index) => ({
+    align: "left",
+    alias: sanitizeTerminalText(column.label),
+    headerAlign: "left",
+    value: `column_${index}`
+  }));
+  const data = rows.map((row) => Object.fromEntries(
+    tableColumns.map((column, index) => [column.value, sanitizeTerminalText(row[index] ?? "")])
+  ));
+  const tableOptions = {
+    COLUMNS: tableWidth,
+    compact: true,
+    marginLeft: 0,
+    marginTop: 0,
+    width: String(tableWidth)
+  };
+  const output = Table(tableColumns, data, tableOptions).render();
+  return [options.title ? sanitizeTerminalText(options.title) : "", output].filter(Boolean).join("\n");
+}
+function renderKeyValueTable(rows, options = {}) {
+  const present = rows.filter(([, value]) => value !== "");
+  if (present.length === 0) {
+    return options.title ? `${options.title}
+No details` : "No details";
+  }
+  const columns = [
+    { label: "Field" },
+    { label: "Value" }
+  ];
+  return renderTerminalTable(columns, present, options);
+}
+function sanitizeTerminalText(value) {
+  return value.replace(/\r\n?/gu, "\n").replace(/\t/gu, " ").replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/gu, "");
+}
+
 // src/formatters.ts
 function formatUser(user) {
-  return formatKeyValues([
+  return renderKeyValueTable([
     ["User", user.fullname],
     ["Username", user.username],
     ["User ID", String(user.userid)],
     ["Site", user.sitename],
     ["URL", user.siteurl],
     ["Language", user.lang ?? ""]
-  ]);
+  ], { title: "User" });
 }
 function formatCourses(courses) {
-  return formatColumns([["ID", "Short Name", "Full Name"], ...courses.map((course) => [String(course.id), course.shortname, course.fullname])]);
+  return renderTerminalTable(
+    [
+      { label: "ID" },
+      { label: "Short Name" },
+      { label: "Full Name" }
+    ],
+    courses.map((course) => [String(course.id), course.shortname, course.fullname]),
+    { title: "Enrolled Units" }
+  );
 }
 function formatCourseSections(sections) {
   const lines = ["Course"];
-  for (const section of sections) {
-    lines.push(`  ${section.name || `Section ${section.section}`}${section.visible ? "" : " (hidden)"}`);
+  for (const [sectionIndex, section] of sections.entries()) {
+    const sectionLast = sectionIndex === sections.length - 1;
+    lines.push(`${sectionLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500"} ${section.name || `Section ${section.section}`}${section.visible ? "" : " (hidden)"}`);
     if (!section.activities.length) {
-      lines.push("    No activities");
+      lines.push(`${sectionLast ? "    " : "\u2502   "}\u2514\u2500\u2500 No activities`);
       continue;
     }
-    for (const activity of section.activities) {
-      lines.push(`    ${activity.name}${activity.visible ? "" : " (hidden)"} (${activity.modname})`);
+    for (const [activityIndex, activity] of section.activities.entries()) {
+      const activityPrefix = activityIndex === section.activities.length - 1 ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
+      lines.push(`${sectionLast ? "    " : "\u2502   "}${activityPrefix} ${activity.name}${activity.visible ? "" : " (hidden)"} (${activity.modname})`);
     }
   }
-  return lines.join("\n");
+  return sanitizeTerminalText(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])]);
+  return renderTerminalTable(
+    [
+      { label: "ID" },
+      { label: "Type" },
+      { label: "Name" }
+    ],
+    activities.map((activity) => [String(activity.id), activity.modname, activity.name]),
+    { title: "Activities" }
+  );
 }
 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 : ""
-    ])
-  ]);
+  const columns = [
+    { label: "Due" },
+    { label: "Unit" },
+    { label: "Activity" },
+    { label: "Type" },
+    { label: "Action" }
+  ];
+  const rows = items.length ? items.map((item) => [
+    `${item.overdue ? "Overdue \xB7 " : ""}${formatTimestamp(item.due_at)}`,
+    `${item.course_name}${item.course_progress === void 0 ? "" : ` (${item.course_progress}%)`}`,
+    item.activity_name || item.name,
+    item.modname || item.event_type,
+    item.actionable ? item.action_name : ""
+  ]) : [["No upcoming items", "", "", "", ""]];
+  return renderTerminalTable(columns, rows, { title: "Todo" });
 }
 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");
+  const summary = renderKeyValueTable([
+    ["Notifications", String(alerts.notification_count)],
+    ["Unread notifications", String(alerts.unread_notification_count)],
+    ["Direct messages", String(alerts.direct_message_count)],
+    ["Unread direct messages", String(alerts.unread_direct_message_count)]
+  ], { title: "Alerts" });
+  if (!alerts.notifications.length) return summary;
+  const notifications = renderTerminalTable(
+    [
+      { label: "When" },
+      { label: "Subject" }
+    ],
+    alerts.notifications.map((notification) => [
+      notification.created_pretty || formatTimestamp(notification.created_at),
+      notification.short_subject || notification.subject
+    ]),
+    { title: "Notifications" }
+  );
+  return `${summary}
+
+${notifications}`;
 }
 function formatGrades(grades) {
-  return formatColumns([
-    ["Item", "Grade", "Range", "Percent", "Feedback"],
-    ...grades.items.map((item) => [item.name, item.grade, item.range, item.percentage, item.feedback])
-  ]);
+  return renderTerminalTable(
+    [
+      { label: "Item" },
+      { label: "Grade" },
+      { label: "Range" },
+      { label: "Percent" },
+      { label: "Feedback" }
+    ],
+    grades.items.map((item) => [item.name, item.grade, item.range, item.percentage, item.feedback]),
+    { title: grades.course_name ? `Grades \xB7 ${grades.course_name}` : "Grades" }
+  );
 }
 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);
+  return renderKeyValueTable(rows, { title: "Activity" });
 }
 function formatDownloadReceipt(receipt) {
-  return formatKeyValues([
+  return renderKeyValueTable([
     ["File", receipt.file_path],
     ["Filename", receipt.filename],
     ["Bytes", String(receipt.bytes_written)],
     ["Content type", receipt.content_type],
     ["Source", receipt.source_url],
     ["Final URL", receipt.final_url]
-  ]);
+  ], { title: "Download" });
 }
 function formatForumDiscussion(discussion, options = {}) {
   const lines = [`Discussion: ${discussion.id}`];
@@ -2810,13 +2933,13 @@ function formatForumDiscussion(discussion, options = {}) {
   }
   if (!discussion.posts.length) {
     lines.push("", "No posts");
-    return lines.join("\n");
+    return sanitizeTerminalText(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) : "-")}`);
+    lines.push(`  When: ${post.created_pretty || formatTimestamp(post.time_created)}`);
     if (post.subject) {
       lines.push(`  Subject: ${post.subject}`);
     }
@@ -2835,58 +2958,68 @@ function formatForumDiscussion(discussion, options = {}) {
       lines.push(`  Images: ${post.image_urls.length}`);
     }
   }
-  return lines.join("\n");
+  return sanitizeTerminalText(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");
+  return renderTerminalTable(
+    [
+      { label: "ID" },
+      { label: "Subject" },
+      { label: "Group" },
+      { label: "URL" }
+    ],
+    refs.length ? refs.map((ref) => [String(ref.id), ref.subject, ref.group_name, ref.url]) : [["No discussions", "", "", ""]],
+    { title: `Forum ${forumCmid} \xB7 Discussions` }
+  );
 }
 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");
+  return renderTerminalTable(
+    [
+      { label: "ID" },
+      { label: "Forum" },
+      { label: "Unit" },
+      { label: "URL" }
+    ],
+    forums.length ? forums.map((forum) => [String(forum.id), forum.name, forum.course_name, forum.url]) : [["No forums", "", "", ""]],
+    { title: "Forums" }
+  );
 }
 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");
+  return renderTerminalTable(
+    [
+      { label: "Discussion" },
+      { label: "Post" },
+      { label: "Unit" },
+      { label: "Forum" },
+      { label: "Subject" },
+      { label: "Author" },
+      { label: "Match" },
+      { label: "Snippet" },
+      { label: "URL" }
+    ],
+    hits.length ? hits.map((hit) => [
+      String(hit.discussion_id),
+      String(hit.post_id),
+      hit.course_name,
+      hit.forum_name,
+      hit.discussion_subject,
+      hit.author_name,
+      hit.matched_in,
+      hit.snippet || hit.discussion_subject,
+      hit.url
+    ]) : [["No matches", "", "", "", "", "", "", "", ""]],
+    { title: "Forum Search" }
+  );
 }
 function formatAuthStatus(status) {
-  return formatKeyValues([
+  return renderKeyValueTable([
     ["Site", status.base_url],
     ["Cached session", status.session_cached ? "yes" : "no"],
     ["Cache age", status.cache_age_minutes === null ? "" : `${status.cache_age_minutes} min`],
     ["Session alive", status.session_alive === null ? status.session_cached ? "unknown" : "" : status.session_alive ? "yes" : "no"],
     ["Server timeout in", formatDuration(status.session_time_remaining_seconds)],
     ["Keepalive agent", status.keepalive_installed ? `installed (${status.keepalive_plist_path})` : "not installed"]
-  ]);
+  ], { title: "Authentication" });
 }
 function formatKeepaliveResult(result) {
   switch (result.status) {
@@ -2919,17 +3052,11 @@ 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");
+function formatTimestamp(value) {
+  if (value <= 0) return "-";
+  const date = new Date(value * 1e3);
+  const pad = (part) => String(part).padStart(2, "0");
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
 }
 
 // src/download.ts
@@ -3700,7 +3827,7 @@ function escapeXml(value) {
 }
 
 // src/version.ts
-var VERSION = "0.7.0-alpha.3";
+var VERSION = "0.7.0-alpha.5";
 
 // src/forum.ts
 function parseDiscussionReference(value) {
@@ -3734,11 +3861,11 @@ async function parseForumReference(value, resolveForumCmid) {
     throw new UsageError("FORUM must be a numeric ID or a full forum URL.");
   }
   if (url.pathname.endsWith("/mod/forum/view.php")) {
-    const forumValue = url.searchParams.get("id");
-    if (!forumValue || !/^\d+$/.test(forumValue)) {
+    const forumValue2 = url.searchParams.get("id");
+    if (!forumValue2 || !/^\d+$/.test(forumValue2)) {
       throw new UsageError("Could not find forum module ID in view.php URL (expected ?id=...).");
     }
-    return Number(forumValue);
+    return Number(forumValue2);
   }
   if (url.pathname.endsWith("/mod/forum/discuss.php")) {
     const discussionValue = url.searchParams.get("d");
@@ -3998,11 +4125,12 @@ async function bridgeRemoteMcp(options) {
     }
     if (response.status === 202 || request.id === void 0) return;
     if (!response.ok) {
+      if (await forwardProtocolNegotiationError(options.output, response, request.id)) return;
       await writeRemoteError(options.output, request.id, response.status);
       return;
     }
-    const contentType2 = response.headers.get("content-type")?.toLowerCase() ?? "";
-    if (contentType2.includes("text/event-stream")) {
+    const contentType3 = response.headers.get("content-type")?.toLowerCase() ?? "";
+    if (contentType3.includes("text/event-stream")) {
       const forwarded = await writeSseMessages(options.output, await response.text(), request.id);
       if (forwarded) negotiatedProtocolVersion = initializedProtocolVersion(request) ?? negotiatedProtocolVersion;
       return;
@@ -4077,6 +4205,30 @@ async function writeRemoteError(output, id, status) {
     data: { type: "REMOTE_MCP_ERROR", status }
   }));
 }
+async function forwardProtocolNegotiationError(output, response, id) {
+  if (response.status !== 400 || !response.headers.get("content-type")?.toLowerCase().includes("application/json")) {
+    return false;
+  }
+  try {
+    const payload = await response.json();
+    if (!isRecord7(payload) || payload.jsonrpc !== "2.0" || payload.id !== id || !isRecord7(payload.error)) {
+      return false;
+    }
+    const data = isRecord7(payload.error.data) ? payload.error.data : void 0;
+    const supported = Array.isArray(data?.supported) ? data.supported.filter((version) => typeof version === "string") : [];
+    if (payload.error.code !== -32022 || typeof data?.requested !== "string" || supported.length === 0) {
+      return false;
+    }
+    await writeJson(output, jsonRpcFailure(id, {
+      code: -32022,
+      message: "Unsupported protocol version",
+      data: { supported, requested: data.requested }
+    }));
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function writeJson(output, value) {
   await output.write(`${JSON.stringify(value)}
 `);
@@ -6187,7 +6339,9 @@ ${error.stderr}`)) {
         throw new DeploymentApplyError("INITIAL_WORKER_INVALID", "Wrangler did not return the initialized Worker");
       }
       const productionEndpoint = firstWorkersDevUrl([result.stdout, result.stderr]);
-      return productionEndpoint ? { ...worker, productionEndpoint } : worker;
+      const initialized = productionEndpoint ? { ...worker, productionEndpoint } : worker;
+      await pinExpectedHosts(input.configPath, input.workerName, initialized.productionEndpoint);
+      return initialized;
     } catch (error) {
       const worker = await this.inspect(input.accountId, input.workerName).catch(() => null);
       if (worker || result) {
@@ -6285,6 +6439,7 @@ var NodeReleaseMaterializer = class {
     await copyFile(this.options.workerBundlePath, workerFile);
     const wranglerConfigPath = join7(artifactDirectory, "wrangler.json");
     const secretsFilePath = join7(artifactDirectory, "secrets.json");
+    const expectedHosts = endpointHosts(plan.intent.workerName, plan.existing?.productionEndpoint);
     const config = {
       $schema: "node_modules/wrangler/config-schema.json",
       name: plan.intent.workerName,
@@ -6292,7 +6447,10 @@ var NodeReleaseMaterializer = class {
       main: `./${basename(workerFile)}`,
       compatibility_date: this.options.compatibilityDate,
       preview_urls: true,
-      vars: { MOODLE_ORIGIN: plan.intent.moodleOrigin },
+      vars: {
+        MOODLE_ORIGIN: plan.intent.moodleOrigin,
+        ...expectedHosts.length ? { EXPECTED_HOSTS: expectedHosts.join(",") } : {}
+      },
       durable_objects: {
         bindings: [{ name: "SESSION_BROKER", class_name: "SessionBroker" }]
       },
@@ -6544,6 +6702,35 @@ function ownershipId(accountId, workerName) {
 function endpointUrl(endpoint, path4) {
   return `${endpoint.replace(/\/$/u, "")}${path4}`;
 }
+async function pinExpectedHosts(configPath, workerName, productionEndpoint) {
+  let config;
+  try {
+    config = JSON.parse(await readFile6(configPath, "utf8"));
+  } catch {
+    throw new DeploymentApplyError("RELEASE_CONFIG_INVALID", "The generated Wrangler configuration is invalid");
+  }
+  if (!isRecord8(config) || !isRecord8(config.vars)) {
+    throw new DeploymentApplyError("RELEASE_CONFIG_INVALID", "The generated Wrangler configuration is invalid");
+  }
+  const hosts = endpointHosts(workerName, productionEndpoint);
+  if (!hosts.length) {
+    throw new DeploymentApplyError("MISSING_ENDPOINT", "The Worker production endpoint is invalid");
+  }
+  config.vars.EXPECTED_HOSTS = hosts.join(",");
+  await writeFile7(configPath, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+}
+function endpointHosts(workerName, endpoint) {
+  if (!endpoint) return [];
+  try {
+    const productionHost = new URL(endpoint).host.toLowerCase();
+    const workerPrefix = `${workerName.toLowerCase()}.`;
+    const previewHost = productionHost.startsWith(workerPrefix) ? `moodle-cli-candidate-${productionHost}` : void 0;
+    return [productionHost, ...previewHost ? [previewHost] : []];
+  } catch {
+    return [];
+  }
+}
 function isRetryableSessionUpload(status) {
   return status === 401 || isRetryableWorkerPropagation(status);
 }
@@ -6688,6 +6875,8 @@ function isMissing4(error) {
 }
 
 // src/mcp/gateway.ts
+import { parse as parse4 } from "node-html-parser";
+var MAX_MCP_FILE_BYTES = 16 * 1024 * 1024;
 var MoodleGatewayError = class extends Error {
   code;
   constructor(code, message) {
@@ -6723,9 +6912,212 @@ function createMoodleGateway(client) {
       return limit === void 0 ? forums : forums.slice(0, limit);
     },
     searchForums: ({ forumId, ...input }) => client.searchForumContent({ ...input, forumCmid: forumId }),
-    getThread: ({ discussionId }) => client.getForumDiscussion(discussionId)
+    getThread: ({ discussionId }) => client.getForumDiscussion(discussionId),
+    async getFile({ source }) {
+      let target = await resolveFileTarget(client, source);
+      let response = await client.requestAbsolute(target.url);
+      if (isHtml(response)) {
+        const html = await response.text();
+        if (looksLikeLoginPage3(html)) throw fileAuthenticationRequired();
+        const links = resourceLinks2(html, target.url);
+        if (links.length !== 1) {
+          const code = links.length ? "MOODLE_FILE_SOURCE_AMBIGUOUS" : "MOODLE_FILE_NOT_FOUND";
+          throw new MoodleGatewayError(code, "The Moodle resource did not resolve to exactly one file.");
+        }
+        const resolved = await resolveFileTarget(client, links[0].url);
+        target = { ...resolved, name: target.name || links[0].name || resolved.name };
+        response = await client.requestAbsolute(target.url);
+        if (isHtml(response)) {
+          if (looksLikeLoginPage3(await response.text())) throw fileAuthenticationRequired();
+          throw new MoodleGatewayError("MOODLE_FILE_NOT_FOUND", "Moodle did not return a downloadable file.");
+        }
+      }
+      const contentLength = Number(response.headers.get("content-length"));
+      if (Number.isFinite(contentLength) && contentLength > MAX_MCP_FILE_BYTES) {
+        throw fileTooLarge();
+      }
+      const content = await readBoundedBody(response, MAX_MCP_FILE_BYTES);
+      const name = safeFilename(contentDispositionFilename2(response.headers.get("content-disposition"))) ?? safeFilename(target.name) ?? safeFilename(urlFilename2(response.url || target.url));
+      if (!name) {
+        throw new MoodleGatewayError("MOODLE_FILE_NAME_MISSING", "Moodle did not provide a safe filename.");
+      }
+      return {
+        name,
+        mimeType: contentType2(response),
+        bytes: content.byteLength,
+        uri: publicFileUrl(response.url || target.url),
+        blob: encodeBase64(content)
+      };
+    }
   };
 }
+async function resolveFileTarget(client, rawSource) {
+  const source = String(rawSource).trim();
+  if (/^\d+$/u.test(source)) {
+    const activityId = Number(source);
+    if (!Number.isSafeInteger(activityId) || activityId < 1) throw invalidFileSource();
+    return validateFileTarget(client, await fileFromActivity(client, activityId));
+  }
+  let url;
+  try {
+    url = new URL(source);
+  } catch {
+    throw invalidFileSource();
+  }
+  const site = new URL(client.baseUrl);
+  const sitePath = site.pathname.replace(/\/$/u, "");
+  if (url.origin !== site.origin) throw invalidFileSource();
+  if (url.pathname === `${sitePath}/mod/resource/view.php`) {
+    const activityId = Number(url.searchParams.get("id"));
+    if (!Number.isSafeInteger(activityId) || activityId < 1) throw invalidFileSource();
+    return validateFileTarget(client, await fileFromActivity(client, activityId));
+  }
+  if (!url.pathname.startsWith(`${sitePath}/pluginfile.php/`)) throw invalidFileSource();
+  return { url: url.toString(), name: urlFilename2(url.toString()) };
+}
+function validateFileTarget(client, target) {
+  let url;
+  try {
+    url = new URL(target.url);
+  } catch {
+    throw invalidFileSource();
+  }
+  const site = new URL(client.baseUrl);
+  const sitePath = site.pathname.replace(/\/$/u, "");
+  const supportedPath = url.pathname === `${sitePath}/mod/resource/view.php` || url.pathname.startsWith(`${sitePath}/pluginfile.php/`);
+  if (url.origin !== site.origin || !supportedPath) throw invalidFileSource();
+  return target;
+}
+async function fileFromActivity(client, activityId) {
+  const activity = await client.getActivity(activityId);
+  if (activity.type !== "resource" || !("file_entries" in activity) || !Array.isArray(activity.file_entries)) {
+    throw new MoodleGatewayError(
+      "MOODLE_FILE_SOURCE_INVALID",
+      `Activity ${activityId} is not a downloadable resource.`
+    );
+  }
+  if (activity.file_entries.length !== 1) {
+    if (activity.file_entries.length === 0) {
+      const resource = activity;
+      const url = resource.target_url || resource.url;
+      if (url) return { url, name: resource.target_name || void 0 };
+    }
+    throw new MoodleGatewayError(
+      "MOODLE_FILE_SOURCE_AMBIGUOUS",
+      `Activity ${activityId} did not resolve to exactly one file. Inspect file_entries and request one URL.`
+    );
+  }
+  const [entry] = activity.file_entries;
+  return { url: entry.url, name: entry.name };
+}
+function resourceLinks2(html, baseUrl) {
+  const root = parse4(html);
+  const entries = root.querySelectorAll(".resourceworkaround a[href], .resourcecontent a[href], a.resourceworkaround[href]").map((link2) => ({
+    name: link2.textContent.trim(),
+    url: new URL(link2.getAttribute("href") ?? "", baseUrl).toString()
+  })).filter((entry) => entry.url !== baseUrl);
+  return entries.filter((entry, index) => entries.findIndex((candidate) => candidate.url === entry.url) === index);
+}
+async function readBoundedBody(response, maxBytes) {
+  if (!response.body) return new Uint8Array();
+  const reader = response.body.getReader();
+  const chunks2 = [];
+  let bytes = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    bytes += value.byteLength;
+    if (bytes > maxBytes) {
+      await reader.cancel().catch(() => void 0);
+      throw fileTooLarge();
+    }
+    chunks2.push(value);
+  }
+  const content = new Uint8Array(bytes);
+  let offset = 0;
+  for (const chunk of chunks2) {
+    content.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return content;
+}
+function invalidFileSource() {
+  return new MoodleGatewayError(
+    "MOODLE_FILE_SOURCE_INVALID",
+    "Use a positive resource activity ID, a same-site resource URL, or a same-site pluginfile URL."
+  );
+}
+function fileTooLarge() {
+  return new MoodleGatewayError(
+    "MOODLE_FILE_TOO_LARGE",
+    `Moodle files returned through MCP cannot exceed ${MAX_MCP_FILE_BYTES / 1024 / 1024} MiB.`
+  );
+}
+function fileAuthenticationRequired() {
+  return new MoodleGatewayError(
+    "MOODLE_AUTH_REQUIRED",
+    "Moodle returned a login page instead of the requested file."
+  );
+}
+function isHtml(response) {
+  if (/\battachment\b/iu.test(response.headers.get("content-disposition") ?? "")) return false;
+  const type = response.headers.get("content-type")?.toLowerCase() ?? "";
+  return type.includes("text/html") || type.includes("application/xhtml+xml");
+}
+function looksLikeLoginPage3(html) {
+  const root = parse4(html);
+  return root.querySelector('form[action*="/login/"], input[name="password"], #page-login-index') !== null || /<title>\s*(?:log in|login)/iu.test(html);
+}
+function contentType2(response) {
+  return response.headers.get("content-type")?.split(";", 1)[0]?.trim() || "application/octet-stream";
+}
+function contentDispositionFilename2(value) {
+  if (!value) return void 0;
+  const extended = value.match(/filename\*\s*=\s*([^;]+)/iu)?.[1]?.trim().replace(/^"|"$/gu, "");
+  if (extended) {
+    const encoded = extended.replace(/^[^']*'[^']*'/u, "");
+    try {
+      return decodeURIComponent(encoded);
+    } catch {
+      return encoded;
+    }
+  }
+  const quoted = value.match(/filename\s*=\s*"((?:\\.|[^"])*)"/iu)?.[1];
+  if (quoted !== void 0) return quoted.replace(/\\([\\"])/gu, "$1");
+  return value.match(/filename\s*=\s*([^;]+)/iu)?.[1]?.trim();
+}
+function urlFilename2(value) {
+  try {
+    const encoded = new URL(value).pathname.split("/").at(-1) ?? "";
+    try {
+      return decodeURIComponent(encoded);
+    } catch {
+      return encoded;
+    }
+  } catch {
+    return void 0;
+  }
+}
+function safeFilename(value) {
+  const name = value?.split(/[\\/]/u).at(-1)?.replace(/[\u0000-\u001f\u007f]/gu, "").trim();
+  return name && name !== "." && name !== ".." ? name : void 0;
+}
+function publicFileUrl(value) {
+  const url = new URL(value);
+  url.username = "";
+  url.password = "";
+  for (const key of [...url.searchParams.keys()]) {
+    if (key !== "forcedownload" && key !== "download") url.searchParams.delete(key);
+  }
+  return url.toString();
+}
+function encodeBase64(content) {
+  let binary = "";
+  for (let offset = 0; offset < content.byteLength; offset += 32768) {
+    binary += String.fromCharCode(...content.subarray(offset, offset + 32768));
+  }
+  return btoa(binary);
+}
 
 // src/mcp/server.ts
 import { z as z3, ZodError } from "zod";
@@ -6738,14 +7130,122 @@ var READ_ONLY_ANNOTATIONS = {
 };
 var emptyInput = z3.object({}).strict();
 var positiveId = z3.number().int().positive();
-var objectOutput = z3.looseObject({});
-var listOutput = z3.array(objectOutput);
+var integer = z3.number().int();
+var userValue = z3.looseObject({
+  userid: integer,
+  username: z3.string(),
+  fullname: z3.string(),
+  sitename: z3.string(),
+  siteurl: z3.string(),
+  lang: z3.string().optional()
+});
+var courseValue = z3.looseObject({
+  id: integer,
+  shortname: z3.string(),
+  fullname: z3.string(),
+  category: z3.number().int(),
+  visible: z3.boolean(),
+  startdate: z3.number(),
+  enddate: z3.number().optional()
+});
+var activityValue = z3.looseObject({
+  id: integer,
+  name: z3.string(),
+  modname: z3.string(),
+  url: z3.string(),
+  visible: z3.boolean(),
+  description: z3.string()
+});
+var fileEntryValue = z3.looseObject({
+  name: z3.string(),
+  url: z3.string(),
+  requires_authentication: z3.boolean()
+});
+var activityDetailValue = z3.looseObject({
+  id: positiveId,
+  name: z3.string(),
+  type: z3.string(),
+  url: z3.string().optional(),
+  target_name: z3.string().optional(),
+  target_url: z3.string().optional(),
+  file_entries: z3.array(fileEntryValue).optional()
+});
+var sectionValue = z3.looseObject({
+  id: z3.number().int(),
+  name: z3.string(),
+  section: z3.number().int(),
+  visible: z3.boolean(),
+  summary: z3.string(),
+  activities: z3.array(activityValue)
+});
+var todoValue = z3.looseObject({
+  id: z3.number().int(),
+  name: z3.string(),
+  course_id: z3.number().int(),
+  course_name: z3.string(),
+  due_at: z3.number(),
+  url: z3.string()
+});
+var gradeItemValue = z3.looseObject({
+  name: z3.string(),
+  item_type: z3.string(),
+  grade: z3.string(),
+  range: z3.string(),
+  percentage: z3.string(),
+  feedback: z3.string(),
+  url: z3.string()
+});
+var gradesValue = z3.looseObject({
+  course_id: integer,
+  course_name: z3.string(),
+  learner_name: z3.string(),
+  total_grade: z3.string(),
+  total_range: z3.string(),
+  total_percentage: z3.string(),
+  items: z3.array(gradeItemValue)
+});
+var forumValue = z3.looseObject({
+  id: integer,
+  name: z3.string(),
+  course_id: integer,
+  course_name: z3.string(),
+  url: z3.string()
+});
+var forumSearchValue = z3.looseObject({
+  course_id: integer,
+  course_name: z3.string(),
+  forum_id: integer,
+  forum_name: z3.string(),
+  discussion_id: integer,
+  discussion_subject: z3.string(),
+  post_id: integer,
+  snippet: z3.string(),
+  url: z3.string()
+});
+var forumPostValue = z3.looseObject({
+  id: integer,
+  discussion_id: integer,
+  subject: z3.string(),
+  message_text: z3.string(),
+  author: z3.looseObject({ id: integer, fullname: z3.string() }),
+  url: z3.string()
+});
+var threadValue = z3.looseObject({
+  id: integer,
+  subject: z3.string(),
+  course_id: integer,
+  forum_id: integer,
+  group_id: z3.number().int(),
+  group_name: z3.string(),
+  url: z3.string(),
+  posts: z3.array(forumPostValue)
+});
 var TOOL_REGISTRATIONS = [
   {
     name: "get_user",
     description: "Get the authenticated Moodle user and site.",
     input: emptyInput,
-    output: z3.object({ user: objectOutput })
+    output: z3.object({ user: userValue })
   },
   {
     name: "get_overview",
@@ -6755,19 +7255,31 @@ var TOOL_REGISTRATIONS = [
       todoDays: z3.number().int().min(1).max(365).optional(),
       alertsLimit: z3.number().int().min(1).max(100).optional().default(5)
     }).strict(),
-    output: z3.object({ overview: objectOutput })
+    output: z3.object({
+      overview: z3.looseObject({
+        user: userValue,
+        courses: z3.array(courseValue),
+        todo: z3.array(todoValue),
+        errors: z3.array(z3.string())
+      })
+    })
   },
   {
     name: "list_courses",
     description: "List the authenticated user's Moodle courses.",
     input: z3.object({ limit: z3.number().int().min(1).max(200).optional().default(100) }).strict(),
-    output: z3.object({ courses: listOutput })
+    output: z3.object({ courses: z3.array(courseValue) })
   },
   {
     name: "get_course",
     description: "Get one Moodle course and its sections.",
     input: z3.object({ courseId: positiveId }).strict(),
-    output: z3.object({ course: objectOutput })
+    output: z3.object({
+      course: z3.looseObject({
+        course: courseValue,
+        sections: z3.array(sectionValue)
+      })
+    })
   },
   {
     name: "list_activities",
@@ -6776,19 +7288,19 @@ var TOOL_REGISTRATIONS = [
       courseId: positiveId,
       limit: z3.number().int().min(1).max(200).optional().default(100)
     }).strict(),
-    output: z3.object({ activities: listOutput })
+    output: z3.object({ activities: z3.array(activityValue) })
   },
   {
     name: "get_activity",
     description: "Get the supported details for one Moodle activity.",
     input: z3.object({ activityId: positiveId }).strict(),
-    output: z3.object({ activity: objectOutput })
+    output: z3.object({ activity: activityDetailValue })
   },
   {
     name: "get_grades",
     description: "Get the authenticated user's grades for one Moodle course.",
     input: z3.object({ courseId: positiveId }).strict(),
-    output: z3.object({ grades: objectOutput })
+    output: z3.object({ grades: gradesValue })
   },
   {
     name: "list_forums",
@@ -6797,7 +7309,7 @@ var TOOL_REGISTRATIONS = [
       courseId: positiveId.optional(),
       limit: z3.number().int().min(1).max(100).optional().default(50)
     }).strict(),
-    output: z3.object({ forums: listOutput })
+    output: z3.object({ forums: z3.array(forumValue) })
   },
   {
     name: "search_forums",
@@ -6813,13 +7325,28 @@ var TOOL_REGISTRATIONS = [
       maxForums: z3.number().int().min(1).max(50).optional(),
       maxDiscussionsPerForum: z3.number().int().min(1).max(100).optional()
     }).strict(),
-    output: z3.object({ results: listOutput })
+    output: z3.object({ results: z3.array(forumSearchValue) })
   },
   {
     name: "get_thread",
     description: "Get one Moodle forum discussion and its posts.",
     input: z3.object({ discussionId: positiveId }).strict(),
-    output: z3.object({ thread: objectOutput })
+    output: z3.object({ thread: threadValue })
+  },
+  {
+    name: "get_file",
+    description: "Fetch one authenticated Moodle file and return its content directly (maximum 16 MiB).",
+    input: z3.object({
+      source: z3.union([positiveId, z3.string().trim().min(1).max(2048)])
+    }).strict(),
+    output: z3.object({
+      file: z3.object({
+        name: z3.string(),
+        mime_type: z3.string(),
+        bytes: z3.number().int().nonnegative(),
+        uri: z3.string()
+      })
+    })
   }
 ];
 var TOOL_CATALOG = TOOL_REGISTRATIONS.map(({ name, description, input, output }) => ({
@@ -6887,12 +7414,11 @@ function createMoodleMcpServer(gateway, options = {}) {
         }
         if (error instanceof UnsupportedProtocolVersionError) {
           return jsonRpcFailure(id, {
-            code: -32602,
-            message: error.message,
+            code: -32022,
+            message: "Unsupported protocol version",
             data: {
-              type: "UNSUPPORTED_PROTOCOL_VERSION",
-              protocolVersion: error.protocolVersion,
-              supportedVersions: [...error.supportedVersions]
+              supported: [...error.supportedVersions],
+              requested: error.protocolVersion
             }
           });
         }
@@ -6940,7 +7466,7 @@ async function callTool(gateway, params) {
     const payload = await runGatewayTool(gateway, name, input);
     const structuredContent = registration.output.parse(wrapToolOutput(name, payload));
     return {
-      content: [{ type: "text", text: summarizeToolOutput(name, payload) }],
+      content: toolContent(name, payload),
       structuredContent,
       resultType: "complete",
       _meta: RESULT_META
@@ -7001,6 +7527,8 @@ async function runGatewayTool(gateway, name, input) {
       });
     case "get_thread":
       return gateway.getThread({ discussionId: numberValue3(input.discussionId) });
+    case "get_file":
+      return gateway.getFile({ source: fileSource(input.source) });
     default:
       throw new McpCallError("TOOL_NOT_FOUND", `Unknown Moodle tool: ${name}`);
   }
@@ -7018,8 +7546,33 @@ function wrapToolOutput(name, payload) {
     search_forums: "results",
     get_thread: "thread"
   };
+  if (name === "get_file" && isMoodleFile(payload)) {
+    return {
+      file: {
+        name: payload.name,
+        mime_type: payload.mimeType,
+        bytes: payload.bytes,
+        uri: payload.uri
+      }
+    };
+  }
   return { [keys[name] ?? "result"]: payload };
 }
+function toolContent(name, payload) {
+  const text = { type: "text", text: summarizeToolOutput(name, payload) };
+  if (name !== "get_file" || !isMoodleFile(payload)) return [text];
+  return [
+    text,
+    {
+      type: "resource",
+      resource: {
+        uri: payload.uri,
+        mimeType: payload.mimeType,
+        blob: payload.blob
+      }
+    }
+  ];
+}
 function summarizeToolOutput(name, payload) {
   if (Array.isArray(payload)) {
     const labels = {
@@ -7051,6 +7604,9 @@ function summarizeToolOutput(name, payload) {
   if (name === "get_thread" && isRecord9(payload)) {
     return `Loaded forum thread ${stringValue4(payload.subject) || numberValue3(payload.id)}.`;
   }
+  if (name === "get_file" && isMoodleFile(payload)) {
+    return `Loaded Moodle file ${payload.name} (${payload.bytes} bytes).`;
+  }
   return "Moodle request completed.";
 }
 function mapMoodleError(error) {
@@ -7086,6 +7642,9 @@ function optionalNumber(value) {
 function stringValue4(value) {
   return typeof value === "string" ? value : "";
 }
+function fileSource(value) {
+  return typeof value === "number" || typeof value === "string" ? value : "";
+}
 function booleanValue2(value) {
   return value === true;
 }
@@ -7095,6 +7654,9 @@ function enumValue(value, values) {
 function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isMoodleFile(value) {
+  return isRecord9(value) && typeof value.name === "string" && typeof value.mimeType === "string" && typeof value.bytes === "number" && typeof value.uri === "string" && typeof value.blob === "string";
+}
 
 // src/mcp/stdio.ts
 async function serveMoodleMcpStdio(server, options) {