@lukeguo12210/canvas-cli 0.0.1 → 0.0.2

package/dist/bin/canvas.js

@@ -231,6 +231,38 @@ var CanvasClient = class {
       }
     };
   }
+  async download(url) {
+    const response = await this.fetchImpl(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        Accept: "*/*"
+      }
+    }).catch((error) => {
+      throw new CanvasCliError("CANVAS_NETWORK_ERROR", "Could not reach Canvas.", {
+        retryable: true,
+        cause: error
+      });
+    });
+    if (!response.ok) {
+      throw new CanvasCliError(
+        mapStatusCode(response.status),
+        `Canvas download failed with status ${response.status}.`,
+        { status: response.status, retryable: response.status === 429 || response.status >= 500 }
+      );
+    }
+    return {
+      data: new Uint8Array(await response.arrayBuffer()),
+      contentType: response.headers.get("content-type") ?? void 0,
+      filename: filenameFromContentDisposition(response.headers.get("content-disposition")),
+      meta: {
+        request: {
+          method: "GET",
+          url: redactSecrets(url)
+        }
+      }
+    };
+  }
 };
 function normalizeBaseUrl(input2) {
   const trimmed = input2.trim().replace(/\/+$/, "");
@@ -279,6 +311,17 @@ function mapStatusCode(status) {
   if (status >= 500) return "CANVAS_SERVER_ERROR";
   return "CANVAS_REQUEST_FAILED";
 }
+function filenameFromContentDisposition(header) {
+  if (!header) {
+    return void 0;
+  }
+  const utf8Match = /filename\*=UTF-8''([^;]+)/i.exec(header);
+  if (utf8Match?.[1]) {
+    return decodeURIComponent(utf8Match[1]);
+  }
+  const match = /filename="?([^";]+)"?/i.exec(header);
+  return match?.[1];
+}
 
 // src/core/config-store.ts
 import { mkdir, readFile, rm, writeFile } from "fs/promises";
@@ -380,7 +423,7 @@ async function promptHidden(prompt) {
       io.close();
     }
   }
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const stdin = process.stdin;
     const onData = (char) => {
       const value = char.toString("utf8");
@@ -389,7 +432,7 @@ async function promptHidden(prompt) {
         stdin.pause();
         stdin.off("data", onData);
         process.stdout.write("\n");
-        resolve(buffer.trim());
+        resolve2(buffer.trim());
         return;
       }
       if (value === "") {
@@ -687,40 +730,6 @@ async function validateToken(client) {
   }
 }
 
-// src/commands/config.ts
-async function handleConfigCommand(argv, options) {
-  const [subcommand] = argv;
-  if (subcommand !== "show") {
-    await writeOutput(
-      {
-        ok: false,
-        error: {
-          code: "UNKNOWN_COMMAND",
-          message: `Unknown config command: ${argv.join(" ")}`,
-          retryable: false
-        }
-      },
-      options
-    );
-    return 1;
-  }
-  const config = await new ConfigStore().readRedacted();
-  await writeOutput(
-    {
-      ok: true,
-      data: config ?? {
-        configured: false,
-        message: "No Canvas config found. Run canvas auth login."
-      },
-      meta: {
-        command: "config show"
-      }
-    },
-    options
-  );
-  return 0;
-}
-
 // src/commands/shared.ts
 async function activeCanvas() {
   const profile = await new ConfigStore().activeProfile();
@@ -739,9 +748,24 @@ function flagValue(argv, flag) {
   }
   return argv[index + 1];
 }
+function requiredFlag(argv, flag, usage) {
+  const value = flagValue(argv, flag);
+  if (!value) {
+    throw new Error(usage);
+  }
+  return value;
+}
 function hasFlag(argv, flag) {
   return argv.includes(flag);
 }
+function csvFlag(argv, flag) {
+  const raw = flagValue(argv, flag);
+  if (!raw) {
+    return void 0;
+  }
+  const values = raw.split(",").map((value) => value.trim()).filter(Boolean);
+  return values.length > 0 ? values : void 0;
+}
 function pageOptions(argv) {
   const pageLimitRaw = flagValue(argv, "--page-limit");
   return {
@@ -767,7 +791,15 @@ function positionalArgs(argv) {
     "--enrollment-state",
     "--state",
     "--include",
-    "--params"
+    "--params",
+    "--bucket",
+    "--search",
+    "--order-by",
+    "--sort",
+    "--file-id",
+    "--folder-id",
+    "--group-id",
+    "--content-type"
   ]);
   const values = [];
   for (let index = 0; index < argv.length; index += 1) {
@@ -783,6 +815,313 @@ function positionalArgs(argv) {
   return values;
 }
 
+// src/commands/api.ts
+async function handleApiCommand(argv, options) {
+  const [subcommand] = argv;
+  try {
+    if (subcommand === "get") {
+      return await apiGet(argv.slice(1), options);
+    }
+    await writeOutput(
+      {
+        ok: false,
+        error: {
+          code: "UNKNOWN_COMMAND",
+          message: `Unknown api command: ${argv.join(" ")}`,
+          retryable: false
+        }
+      },
+      options
+    );
+    return 1;
+  } catch (error) {
+    await writeOutput(toErrorEnvelope(error), options);
+    return 1;
+  }
+}
+async function apiGet(argv, options) {
+  const path2 = positionalArgs(argv)[0];
+  if (!path2) {
+    throw new Error("Usage: canvas api get /api/v1/<path> [--params '<json>'] [--page-all]");
+  }
+  if (!path2.startsWith("/api/v1/")) {
+    throw new CanvasCliError("INVALID_API_PATH", "Raw API paths must start with /api/v1/.");
+  }
+  const params = parseParams(flagValue(argv, "--params"));
+  const { client, profile } = await activeCanvas();
+  const response = await client.get(path2, {
+    query: params,
+    ...pageOptions(argv)
+  });
+  await writeOutput(
+    {
+      ok: true,
+      data: response.data,
+      meta: { ...response.meta, baseUrl: profile.baseUrl }
+    },
+    options
+  );
+  return 0;
+}
+function parseParams(raw) {
+  if (!raw) {
+    return {};
+  }
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new CanvasCliError("INVALID_PARAMS", "--params must be a JSON object.");
+  }
+  const params = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (value === null) {
+      continue;
+    }
+    if (isQueryValue(value)) {
+      params[key] = value;
+      continue;
+    }
+    throw new CanvasCliError(
+      "INVALID_PARAMS",
+      `Unsupported query value for ${key}. Use string, number, boolean, or arrays of those.`
+    );
+  }
+  return params;
+}
+function isQueryValue(value) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.every(
+      (item) => typeof item === "string" || typeof item === "number" || typeof item === "boolean"
+    );
+  }
+  return value === void 0;
+}
+
+// src/commands/assignments.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { join } from "path";
+async function handleAssignmentsCommand(argv, options) {
+  const [subcommand] = argv;
+  try {
+    if (subcommand === "list") {
+      return await listAssignments(argv.slice(1), options);
+    }
+    if (subcommand === "show") {
+      return await showAssignment(argv.slice(1), options);
+    }
+    if (subcommand === "export") {
+      return await exportAssignment(argv.slice(1), options);
+    }
+    await writeOutput(
+      {
+        ok: false,
+        error: {
+          code: "UNKNOWN_COMMAND",
+          message: `Unknown assignments command: ${argv.join(" ")}`,
+          retryable: false
+        }
+      },
+      options
+    );
+    return 1;
+  } catch (error) {
+    await writeOutput(toErrorEnvelope(error), options);
+    return 1;
+  }
+}
+async function listAssignments(argv, options) {
+  const courseId = requiredFlag(
+    argv,
+    "--course-id",
+    "Usage: canvas assignments list --course-id <course-id>"
+  );
+  const { client, profile } = await activeCanvas();
+  const response = await client.get(
+    `/api/v1/courses/${courseId}/assignments`,
+    {
+      query: assignmentListQuery(argv),
+      ...pageOptions(argv)
+    }
+  );
+  await writeOutput(
+    {
+      ok: true,
+      data: response.data.map(normalizeAssignment),
+      meta: { ...response.meta, baseUrl: profile.baseUrl }
+    },
+    options
+  );
+  return 0;
+}
+async function showAssignment(argv, options) {
+  const courseId = requiredFlag(
+    argv,
+    "--course-id",
+    "Usage: canvas assignments show --course-id <course-id> --assignment-id <assignment-id>"
+  );
+  const assignmentId = flagValue(argv, "--assignment-id") ?? positionalArgs(argv)[0] ?? missing("Usage: canvas assignments show --course-id <course-id> --assignment-id <assignment-id>");
+  const { client, profile } = await activeCanvas();
+  const response = await client.get(
+    `/api/v1/courses/${courseId}/assignments/${assignmentId}`,
+    { query: assignmentShowQuery(argv) }
+  );
+  await writeOutput(
+    {
+      ok: true,
+      data: normalizeAssignment(response.data),
+      meta: { ...response.meta, baseUrl: profile.baseUrl }
+    },
+    options
+  );
+  return 0;
+}
+async function exportAssignment(argv, options) {
+  const courseId = requiredFlag(
+    argv,
+    "--course-id",
+    "Usage: canvas assignments export --course-id <course-id> --assignment-id <assignment-id> --out <dir>"
+  );
+  const assignmentId = flagValue(argv, "--assignment-id") ?? positionalArgs(argv)[0] ?? missing("Usage: canvas assignments export --course-id <course-id> --assignment-id <assignment-id> --out <dir>");
+  const outDir = requiredFlag(
+    argv,
+    "--out",
+    "Usage: canvas assignments export --course-id <course-id> --assignment-id <assignment-id> --out <dir>"
+  );
+  const { client, profile } = await activeCanvas();
+  const response = await client.get(
+    `/api/v1/courses/${courseId}/assignments/${assignmentId}`,
+    { query: { "include[]": ["all_dates", "description", "submission"] } }
+  );
+  const assignment = normalizeAssignment(response.data);
+  await mkdir2(outDir, { recursive: true });
+  const jsonPath = join(outDir, `assignment-${assignment.id}.json`);
+  const markdownPath = join(outDir, `assignment-${assignment.id}.md`);
+  await writeFile2(jsonPath, `${JSON.stringify(assignment, null, 2)}
+`, "utf8");
+  await writeFile2(markdownPath, assignmentMarkdown(assignment), "utf8");
+  await writeOutput(
+    {
+      ok: true,
+      data: {
+        assignment,
+        written: [
+          { path: jsonPath, kind: "assignment-json" },
+          { path: markdownPath, kind: "assignment-markdown" }
+        ]
+      },
+      meta: { baseUrl: profile.baseUrl }
+    },
+    options
+  );
+  return 0;
+}
+function assignmentListQuery(argv) {
+  return {
+    bucket: flagValue(argv, "--bucket"),
+    search_term: flagValue(argv, "--search"),
+    order_by: flagValue(argv, "--order-by"),
+    "include[]": csvFlag(argv, "--include"),
+    per_page: flagValue(argv, "--page-size")
+  };
+}
+function assignmentShowQuery(argv) {
+  return {
+    "include[]": csvFlag(argv, "--include") ?? ["all_dates", "description"]
+  };
+}
+function normalizeAssignment(assignment) {
+  return {
+    id: String(assignment.id),
+    name: assignment.name,
+    description: assignment.description,
+    dueAt: assignment.due_at,
+    unlockAt: assignment.unlock_at,
+    lockAt: assignment.lock_at,
+    pointsPossible: assignment.points_possible,
+    gradingType: assignment.grading_type,
+    submissionTypes: assignment.submission_types,
+    allowedExtensions: assignment.allowed_extensions,
+    htmlUrl: assignment.html_url,
+    assignmentGroupId: assignment.assignment_group_id === void 0 ? void 0 : String(assignment.assignment_group_id),
+    position: assignment.position,
+    published: assignment.published,
+    muted: assignment.muted,
+    hasSubmittedSubmissions: assignment.has_submitted_submissions,
+    lockedForUser: assignment.locked_for_user,
+    lockExplanation: assignment.lock_explanation,
+    needsGradingCount: assignment.needs_grading_count,
+    allDates: assignment.all_dates,
+    externalToolTagAttributes: assignment.external_tool_tag_attributes,
+    rubric: assignment.rubric,
+    attachments: assignment.attachments?.map(normalizeAttachment)
+  };
+}
+function normalizeAttachment(attachment) {
+  return {
+    id: String(attachment.id),
+    displayName: attachment.display_name,
+    filename: attachment.filename,
+    contentType: attachment.content_type,
+    url: attachment.url,
+    size: attachment.size
+  };
+}
+function assignmentMarkdown(assignment) {
+  const lines = [
+    `# ${assignment.name ?? `Assignment ${assignment.id}`}`,
+    "",
+    `- id: ${assignment.id}`,
+    `- due: ${assignment.dueAt ?? "none"}`,
+    `- points: ${assignment.pointsPossible ?? "none"}`,
+    `- html: ${assignment.htmlUrl ?? "none"}`,
+    "",
+    "## Description",
+    "",
+    assignment.description ?? ""
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function missing(message) {
+  throw new Error(message);
+}
+
+// src/commands/config.ts
+async function handleConfigCommand(argv, options) {
+  const [subcommand] = argv;
+  if (subcommand !== "show") {
+    await writeOutput(
+      {
+        ok: false,
+        error: {
+          code: "UNKNOWN_COMMAND",
+          message: `Unknown config command: ${argv.join(" ")}`,
+          retryable: false
+        }
+      },
+      options
+    );
+    return 1;
+  }
+  const config = await new ConfigStore().readRedacted();
+  await writeOutput(
+    {
+      ok: true,
+      data: config ?? {
+        configured: false,
+        message: "No Canvas config found. Run canvas auth login."
+      },
+      meta: {
+        command: "config show"
+      }
+    },
+    options
+  );
+  return 0;
+}
+
 // src/commands/courses.ts
 async function handleCoursesCommand(argv, options) {
   const [subcommand] = argv;
@@ -975,37 +1314,681 @@ function normalizeCourse(course) {
   };
 }
 
-// src/commands/me.ts
-async function handleMeCommand(options) {
+// src/commands/files.ts
+import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
+import { basename, resolve } from "path";
+async function handleFilesCommand(argv, options) {
+  const [subcommand] = argv;
   try {
-    const profile = await new ConfigStore().activeProfile();
-    const client = new CanvasClient({
-      baseUrl: profile.baseUrl,
-      token: profile.token
-    });
-    const response = await client.get("/api/v1/users/self/profile");
+    if (subcommand === "list") {
+      return await listFiles(argv.slice(1), options);
+    }
+    if (subcommand === "show") {
+      return await showFile(argv.slice(1), options);
+    }
+    if (subcommand === "download") {
+      return await downloadFile(argv.slice(1), options);
+    }
+    if (subcommand === "download-linked") {
+      return await downloadLinkedFiles(argv.slice(1), options);
+    }
     await writeOutput(
       {
-        ok: true,
-        data: response.data,
-        meta: {
-          ...response.meta,
-          baseUrl: profile.baseUrl
+        ok: false,
+        error: {
+          code: "UNKNOWN_COMMAND",
+          message: `Unknown files command: ${argv.join(" ")}`,
+          retryable: false
         }
       },
       options
     );
-    return 0;
+    return 1;
   } catch (error) {
     await writeOutput(toErrorEnvelope(error), options);
     return 1;
   }
 }
-
-// src/commands/tabs.ts
-async function handleTabsCommand(argv, options) {
+async function handleFoldersCommand(argv, options) {
   const [subcommand] = argv;
-  if (subcommand !== "list") {
+  try {
+    if (subcommand === "list") {
+      return await listFolders(argv.slice(1), options);
+    }
+    if (subcommand === "path") {
+      return await folderPath(argv.slice(1), options);
+    }
+    await writeOutput(
+      {
+        ok: false,
+        error: {
+          code: "UNKNOWN_COMMAND",
+          message: `Unknown folders command: ${argv.join(" ")}`,
+          retryable: false
+        }
+      },
+      options
+    );
+    return 1;
+  } catch (error) {
+    await writeOutput(toErrorEnvelope(error), options);
+    return 1;
+  }
+}
+async function listFiles(argv, options) {
+  const path2 = filesListPath(argv);
+  const { client, profile } = await activeCanvas();
+  const response = await client.get(path2, {
+    query: filesListQuery(argv),
+    ...pageOptions(argv)
+  });
+  await writeOutput(
+    {
+      ok: true,
+      data: response.data.map(normalizeFile),
+      meta: { ...response.meta, baseUrl: profile.baseUrl }
+    },
+    options
+  );
+  return 0;
+}
+async function showFile(argv, options) {
+  const fileId = flagValue(argv, "--file-id") ?? positionalArgs(argv)[0] ?? missing2("Usage: canvas files show <file-id>");
+  const { client, profile } = await activeCanvas();
+  const response = await client.get(`/api/v1/files/${fileId}`, {
+    query: { "include[]": csvFlag(argv, "--include") }
+  });
+  await writeOutput(
+    {
+      ok: true,
+      data: normalizeFile(response.data),
+      meta: { ...response.meta, baseUrl: profile.baseUrl }
+    },
+    options
+  );
+  return 0;
+}
+async function downloadFile(argv, options) {
+  const fileId = flagValue(argv, "--file-id") ?? positionalArgs(argv)[0] ?? missing2("Usage: canvas files download <file-id> --out <dir>");
+  const outDir = requiredFlag(argv, "--out", "Usage: canvas files download <file-id> --out <dir>");
+  const { client, profile } = await activeCanvas();
+  const fileResponse = await client.get(`/api/v1/files/${fileId}`);
+  const file = normalizeFile(fileResponse.data);
+  if (!file.url) {
+    throw new CanvasCliError("FILE_URL_UNAVAILABLE", "Canvas did not return a download URL for this file.");
+  }
+  const download = await client.download(file.url);
+  const filename = safeFilename(download.filename ?? file.displayName ?? file.filename ?? `file-${file.id}`);
+  const filePath = safeJoin(outDir, filename);
+  await mkdir3(outDir, { recursive: true });
+  await writeFile3(filePath, download.data);
+  await writeOutput(
+    {
+      ok: true,
+      data: {
+        file,
+        written: {
+          path: filePath,
+          bytes: download.data.byteLength,
+          contentType: download.contentType
+        }
+      },
+      meta: { baseUrl: profile.baseUrl, download: download.meta }
+    },
+    options
+  );
+  return 0;
+}
+async function downloadLinkedFiles(argv, options) {
+  const courseId = requiredFlag(
+    argv,
+    "--course-id",
+    "Usage: canvas files download-linked --course-id <course-id> --out <dir>"
+  );
+  const outDir = requiredFlag(
+    argv,
+    "--out",
+    "Usage: canvas files download-linked --course-id <course-id> --out <dir>"
+  );
+  const { client, profile } = await activeCanvas();
+  const [moduleItems, assignments] = await Promise.all([
+    client.get(
+      `/api/v1/courses/${courseId}/modules/items`,
+      { query: { per_page: 100 }, pageAll: true }
+    ).catch(() => ({ data: [] })),
+    client.get(`/api/v1/courses/${courseId}/assignments`, {
+      query: { "include[]": ["description"], per_page: 100 },
+      pageAll: true
+    }).catch(() => ({ data: [] }))
+  ]);
+  const ids = /* @__PURE__ */ new Set();
+  for (const item of moduleItems.data) {
+    if (item.type === "File" && item.content_id !== void 0) {
+      ids.add(String(item.content_id));
+    }
+  }
+  for (const assignment of assignments.data) {
+    for (const attachment of assignment.attachments ?? []) {
+      ids.add(String(attachment.id));
+    }
+  }
+  const written = [];
+  for (const id of ids) {
+    try {
+      const fileResponse = await client.get(`/api/v1/files/${id}`);
+      const file = normalizeFile(fileResponse.data);
+      if (!file.url) {
+        written.push({ id, error: "FILE_URL_UNAVAILABLE" });
+        continue;
+      }
+      const download = await client.download(file.url);
+      const filename = safeFilename(download.filename ?? file.displayName ?? file.filename ?? `file-${id}`);
+      const filePath = safeJoin(outDir, filename);
+      await mkdir3(outDir, { recursive: true });
+      await writeFile3(filePath, download.data);
+      written.push({ id, path: filePath });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      written.push({ id, error: message });
+    }
+  }
+  await writeOutput(
+    {
+      ok: true,
+      data: { count: ids.size, written },
+      meta: { baseUrl: profile.baseUrl }
+    },
+    options
+  );
+  return 0;
+}
+async function listFolders(argv, options) {
+  const courseId = requiredFlag(
+    argv,
+    "--course-id",
+    "Usage: canvas folders list --course-id <course-id>"
+  );
+  const { client, profile } = await activeCanvas();
+  const response = await client.get(`/api/v1/courses/${courseId}/folders`, {
+    query: { per_page: flagValue(argv, "--page-size") },
+    ...pageOptions(argv)
+  });
+  await writeOutput(
+    {
+      ok: true,
+      data: response.data.map(normalizeFolder),
+      meta: { ...response.meta, baseUrl: profile.baseUrl }
+    },
+    options
+  );
+  return 0;
+}
+async function folderPath(argv, options) {
+  const courseId = requiredFlag(
+    argv,
+    "--course-id",
+    "Usage: canvas folders path --course-id <course-id> --path <path>"
+  );
+  const folderPathValue = requiredFlag(
+    argv,
+    "--path",
+    "Usage: canvas folders path --course-id <course-id> --path <path>"
+  );
+  const { client, profile } = await activeCanvas();
+  const encodedPath = folderPathValue.split("/").filter(Boolean).map(encodeURIComponent).join("/");
+  const response = await client.get(
+    `/api/v1/courses/${courseId}/folders/by_path/${encodedPath}`
+  );
+  await writeOutput(
+    {
+      ok: true,
+      data: response.data.map(normalizeFolder),
+      meta: { ...response.meta, baseUrl: profile.baseUrl }
+    },
+    options
+  );
+  return 0;
+}
+function filesListPath(argv) {
+  const groupId = flagValue(argv, "--group-id");
+  if (groupId) {
+    return `/api/v1/groups/${groupId}/files`;
+  }
+  const folderId = flagValue(argv, "--folder-id");
+  if (folderId) {
+    return `/api/v1/folders/${folderId}/files`;
+  }
+  const courseId = requiredFlag(argv, "--course-id", "Usage: canvas files list --course-id <course-id>");
+  return `/api/v1/courses/${courseId}/files`;
+}
+function filesListQuery(argv) {
+  return {
+    search_term: flagValue(argv, "--search"),
+    sort: flagValue(argv, "--sort"),
+    "content_types[]": csvFlag(argv, "--content-type"),
+    "include[]": csvFlag(argv, "--include"),
+    per_page: flagValue(argv, "--page-size")
+  };
+}
+function normalizeFile(file) {
+  return {
+    id: String(file.id),
+    uuid: file.uuid,
+    folderId: file.folder_id === void 0 ? void 0 : String(file.folder_id),
+    displayName: file.display_name,
+    filename: file.filename,
+    contentType: file.content_type,
+    url: file.url,
+    size: file.size,
+    createdAt: file.created_at,
+    updatedAt: file.updated_at,
+    modifiedAt: file.modified_at,
+    unlockAt: file.unlock_at,
+    locked: file.locked,
+    hidden: file.hidden,
+    lockedForUser: file.locked_for_user,
+    lockExplanation: file.lock_explanation,
+    thumbnailUrl: file.thumbnail_url,
+    previewUrl: file.preview_url,
+    mimeClass: file.mime_class
+  };
+}
+function normalizeFolder(folder) {
+  return {
+    id: String(folder.id),
+    name: folder.name,
+    fullName: folder.full_name,
+    contextId: folder.context_id === void 0 ? void 0 : String(folder.context_id),
+    contextType: folder.context_type,
+    parentFolderId: folder.parent_folder_id === void 0 ? void 0 : String(folder.parent_folder_id),
+    filesCount: folder.files_count,
+    foldersCount: folder.folders_count,
+    position: folder.position,
+    locked: folder.locked,
+    hidden: folder.hidden,
+    lockedForUser: folder.locked_for_user,
+    forSubmissions: folder.for_submissions
+  };
+}
+function safeFilename(input2) {
+  const name = basename(input2).replace(/[/:\\]/g, "_").trim();
+  return name || "canvas-file";
+}
+function safeJoin(outDir, filename) {
+  const base = resolve(outDir);
+  const target = resolve(base, filename);
+  if (!target.startsWith(`${base}/`) && target !== base) {
+    throw new CanvasCliError("INVALID_OUTPUT_PATH", "Refusing to write outside the output directory.");
+  }
+  return target;
+}
+function missing2(message) {
+  throw new Error(message);
+}
+
+// src/commands/me.ts
+async function handleMeCommand(options) {
+  try {
+    const profile = await new ConfigStore().activeProfile();
+    const client = new CanvasClient({
+      baseUrl: profile.baseUrl,
+      token: profile.token
+    });
+    const response = await client.get("/api/v1/users/self/profile");
+    await writeOutput(
+      {
+        ok: true,
+        data: response.data,
+        meta: {
+          ...response.meta,
+          baseUrl: profile.baseUrl
+        }
+      },
+      options
+    );
+    return 0;
+  } catch (error) {
+    await writeOutput(toErrorEnvelope(error), options);
+    return 1;
+  }
+}
+
+// src/commands/modules.ts
+import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
+import { join as join3 } from "path";
+async function handleModulesCommand(argv, options) {
+  const [subcommand] = argv;
+  try {
+    if (subcommand === "list") {
+      return await listModules(argv.slice(1), options);
+    }
+    if (subcommand === "items") {
+      return await listModuleItems(argv.slice(1), options);
+    }
+    if (subcommand === "item") {
+      return await showModuleItem(argv.slice(1), options);
+    }
+    if (subcommand === "export") {
+      return await exportModule(argv.slice(1), options);
+    }
+    await writeOutput(
+      {
+        ok: false,
+        error: {
+          code: "UNKNOWN_COMMAND",
+          message: `Unknown modules command: ${argv.join(" ")}`,
+          retryable: false
+        }
+      },
+      options
+    );
+    return 1;
+  } catch (error) {
+    await writeOutput(toErrorEnvelope(error), options);
+    return 1;
+  }
+}
+async function listModules(argv, options) {
+  const courseId = requiredFlag(argv, "--course-id", "Usage: canvas modules list --course-id <course-id>");
+  const { client, profile } = await activeCanvas();
+  const response = await client.get(`/api/v1/courses/${courseId}/modules`, {
+    query: moduleListQuery(argv),
+    ...pageOptions(argv)
+  });
+  await writeOutput(
+    {
+      ok: true,
+      data: response.data.map(normalizeModule),
+      meta: { ...response.meta, baseUrl: profile.baseUrl }
+    },
+    options
+  );
+  return 0;
+}
+async function listModuleItems(argv, options) {
+  const courseId = requiredFlag(
+    argv,
+    "--course-id",
+    "Usage: canvas modules items --course-id <course-id> --module-id <module-id>"
+  );
+  const moduleId = requiredFlag(
+    argv,
+    "--module-id",
+    "Usage: canvas modules items --course-id <course-id> --module-id <module-id>"
+  );
+  const { client, profile } = await activeCanvas();
+  const response = await client.get(
+    `/api/v1/courses/${courseId}/modules/${moduleId}/items`,
+    {
+      query: moduleItemsQuery(argv),
+      ...pageOptions(argv)
+    }
+  );
+  await writeOutput(
+    {
+      ok: true,
+      data: response.data.map(normalizeModuleItem),
+      meta: { ...response.meta, baseUrl: profile.baseUrl }
+    },
+    options
+  );
+  return 0;
+}
+async function showModuleItem(argv, options) {
+  const courseId = requiredFlag(
+    argv,
+    "--course-id",
+    "Usage: canvas modules item --course-id <course-id> --module-id <module-id> --item-id <item-id>"
+  );
+  const moduleId = requiredFlag(
+    argv,
+    "--module-id",
+    "Usage: canvas modules item --course-id <course-id> --module-id <module-id> --item-id <item-id>"
+  );
+  const itemId = flagValue(argv, "--item-id") ?? positionalArgs(argv)[0] ?? missing3("Usage: canvas modules item --course-id <course-id> --module-id <module-id> --item-id <item-id>");
+  const { client, profile } = await activeCanvas();
+  const response = await client.get(
+    `/api/v1/courses/${courseId}/modules/${moduleId}/items/${itemId}`,
+    { query: moduleItemsQuery(argv) }
+  );
+  await writeOutput(
+    {
+      ok: true,
+      data: normalizeModuleItem(response.data),
+      meta: { ...response.meta, baseUrl: profile.baseUrl }
+    },
+    options
+  );
+  return 0;
+}
+async function exportModule(argv, options) {
+  const courseId = requiredFlag(
+    argv,
+    "--course-id",
+    "Usage: canvas modules export --course-id <course-id> --module-id <module-id> --out <dir>"
+  );
+  const moduleId = requiredFlag(
+    argv,
+    "--module-id",
+    "Usage: canvas modules export --course-id <course-id> --module-id <module-id> --out <dir>"
+  );
+  const outDir = requiredFlag(
+    argv,
+    "--out",
+    "Usage: canvas modules export --course-id <course-id> --module-id <module-id> --out <dir>"
+  );
+  const { client, profile } = await activeCanvas();
+  const [moduleResponse, itemsResponse] = await Promise.all([
+    client.get(`/api/v1/courses/${courseId}/modules/${moduleId}`),
+    client.get(`/api/v1/courses/${courseId}/modules/${moduleId}/items`, {
+      query: { "include[]": ["content_details"], per_page: 100 },
+      pageAll: true
+    })
+  ]);
+  const moduleData = normalizeModule({ ...moduleResponse.data, items: itemsResponse.data });
+  await mkdir4(outDir, { recursive: true });
+  const filePath = join3(outDir, `module-${moduleData.id}.json`);
+  await writeFile4(filePath, `${JSON.stringify(moduleData, null, 2)}
+`, "utf8");
+  await writeOutput(
+    {
+      ok: true,
+      data: { module: moduleData, written: [{ path: filePath, kind: "module-json" }] },
+      meta: { baseUrl: profile.baseUrl }
+    },
+    options
+  );
+  return 0;
+}
+function moduleListQuery(argv) {
+  return {
+    "include[]": csvFlag(argv, "--include"),
+    per_page: flagValue(argv, "--page-size")
+  };
+}
+function moduleItemsQuery(argv) {
+  return {
+    "include[]": csvFlag(argv, "--include"),
+    per_page: flagValue(argv, "--page-size")
+  };
+}
+function normalizeModule(module) {
+  return {
+    id: String(module.id),
+    name: module.name,
+    position: module.position,
+    state: module.state,
+    unlockAt: module.unlock_at,
+    completedAt: module.completed_at,
+    requireSequentialProgress: module.require_sequential_progress,
+    publishFinalGrade: module.publish_final_grade,
+    prerequisiteModuleIds: module.prerequisite_module_ids?.map(String),
+    itemsCount: module.items_count,
+    itemsUrl: module.items_url,
+    items: module.items?.map(normalizeModuleItem)
+  };
+}
+function normalizeModuleItem(item) {
+  return {
+    id: String(item.id),
+    moduleId: item.module_id === void 0 ? void 0 : String(item.module_id),
+    title: item.title,
+    type: item.type,
+    contentId: item.content_id === void 0 ? void 0 : String(item.content_id),
+    position: item.position,
+    indent: item.indent,
+    pageUrl: item.page_url,
+    externalUrl: item.external_url,
+    htmlUrl: item.html_url,
+    apiUrl: item.url,
+    newTab: item.new_tab,
+    completionRequirement: item.completion_requirement,
+    contentDetails: item.content_details
+  };
+}
+function missing3(message) {
+  throw new Error(message);
+}
+
+// src/commands/pages.ts
+import { mkdir as mkdir5, writeFile as writeFile5 } from "fs/promises";
+import { join as join4 } from "path";
+async function handlePagesCommand(argv, options) {
+  const [subcommand] = argv;
+  try {
+    if (subcommand === "list") {
+      return await listPages(argv.slice(1), options);
+    }
+    if (subcommand === "show") {
+      return await showPage(argv.slice(1), options);
+    }
+    if (subcommand === "export") {
+      return await exportPage(argv.slice(1), options);
+    }
+    await writeOutput(
+      {
+        ok: false,
+        error: {
+          code: "UNKNOWN_COMMAND",
+          message: `Unknown pages command: ${argv.join(" ")}`,
+          retryable: false
+        }
+      },
+      options
+    );
+    return 1;
+  } catch (error) {
+    await writeOutput(toErrorEnvelope(error), options);
+    return 1;
+  }
+}
+async function listPages(argv, options) {
+  const courseId = requiredFlag(argv, "--course-id", "Usage: canvas pages list --course-id <course-id>");
+  const { client, profile } = await activeCanvas();
+  const response = await client.get(`/api/v1/courses/${courseId}/pages`, {
+    query: pagesListQuery(argv),
+    ...pageOptions(argv)
+  });
+  await writeOutput(
+    {
+      ok: true,
+      data: response.data.map(normalizePage),
+      meta: { ...response.meta, baseUrl: profile.baseUrl }
+    },
+    options
+  );
+  return 0;
+}
+async function showPage(argv, options) {
+  const courseId = requiredFlag(argv, "--course-id", "Usage: canvas pages show --course-id <course-id> --page <url>");
+  const pageUrl = flagValue(argv, "--page") ?? positionalArgs(argv)[0] ?? missing4("Usage: canvas pages show --course-id <course-id> --page <url>");
+  const { client, profile } = await activeCanvas();
+  const response = await client.get(
+    `/api/v1/courses/${courseId}/pages/${encodeURIComponent(pageUrl)}`
+  );
+  await writeOutput(
+    {
+      ok: true,
+      data: normalizePage(response.data),
+      meta: { ...response.meta, baseUrl: profile.baseUrl }
+    },
+    options
+  );
+  return 0;
+}
+async function exportPage(argv, options) {
+  const courseId = requiredFlag(
+    argv,
+    "--course-id",
+    "Usage: canvas pages export --course-id <course-id> --page <url> --out <dir>"
+  );
+  const pageUrl = flagValue(argv, "--page") ?? positionalArgs(argv)[0] ?? missing4("Usage: canvas pages export --course-id <course-id> --page <url> --out <dir>");
+  const outDir = requiredFlag(argv, "--out", "Usage: canvas pages export --course-id <course-id> --page <url> --out <dir>");
+  const { client, profile } = await activeCanvas();
+  const response = await client.get(
+    `/api/v1/courses/${courseId}/pages/${encodeURIComponent(pageUrl)}`
+  );
+  const page = normalizePage(response.data);
+  await mkdir5(outDir, { recursive: true });
+  const jsonPath = join4(outDir, `${page.url}.json`);
+  const htmlPath = join4(outDir, `${page.url}.html`);
+  await writeFile5(jsonPath, `${JSON.stringify(page, null, 2)}
+`, "utf8");
+  await writeFile5(htmlPath, page.body ?? "", "utf8");
+  await writeOutput(
+    {
+      ok: true,
+      data: {
+        page,
+        written: [
+          { path: jsonPath, kind: "page-json" },
+          { path: htmlPath, kind: "page-html" }
+        ]
+      },
+      meta: { baseUrl: profile.baseUrl }
+    },
+    options
+  );
+  return 0;
+}
+function pagesListQuery(argv) {
+  return {
+    sort: flagValue(argv, "--sort"),
+    search_term: flagValue(argv, "--search"),
+    per_page: flagValue(argv, "--page-size")
+  };
+}
+function normalizePage(page) {
+  return {
+    id: page.page_id === void 0 ? void 0 : String(page.page_id),
+    url: page.url,
+    title: page.title,
+    createdAt: page.created_at,
+    updatedAt: page.updated_at,
+    editingRoles: page.editing_roles,
+    lastEditedBy: page.last_edited_by,
+    body: page.body,
+    published: page.published,
+    hideFromStudents: page.hide_from_students,
+    frontPage: page.front_page,
+    htmlUrl: page.html_url,
+    lockedForUser: page.locked_for_user,
+    lockInfo: page.lock_info,
+    lockExplanation: page.lock_explanation
+  };
+}
+function missing4(message) {
+  throw new Error(message);
+}
+
+// src/commands/review.ts
+import { mkdir as mkdir6, writeFile as writeFile6 } from "fs/promises";
+import { join as join5 } from "path";
+
+// src/commands/tabs.ts
+async function handleTabsCommand(argv, options) {
+  const [subcommand] = argv;
+  if (subcommand !== "list") {
     await writeOutput(
       {
         ok: false,
@@ -1056,8 +2039,122 @@ function normalizeTab(tab) {
   };
 }
 
+// src/commands/review.ts
+async function handleReviewCommand(argv, options) {
+  const [subcommand] = argv;
+  try {
+    if (subcommand === "pack") {
+      return await reviewPack(argv.slice(1), options);
+    }
+    await writeOutput(
+      {
+        ok: false,
+        error: {
+          code: "UNKNOWN_COMMAND",
+          message: `Unknown review command: ${argv.join(" ")}`,
+          retryable: false
+        }
+      },
+      options
+    );
+    return 1;
+  } catch (error) {
+    await writeOutput(toErrorEnvelope(error), options);
+    return 1;
+  }
+}
+async function reviewPack(argv, options) {
+  const courseId = requiredFlag(
+    argv,
+    "--course-id",
+    "Usage: canvas review pack --course-id <course-id> --out <dir>"
+  );
+  const outDir = requiredFlag(argv, "--out", "Usage: canvas review pack --course-id <course-id> --out <dir>");
+  const includeAllFiles = hasFlag(argv, "--include-all-files");
+  const { client, profile } = await activeCanvas();
+  const [course, tabs, modules, assignments, pages, files] = await Promise.all([
+    client.get(`/api/v1/courses/${courseId}`, {
+      query: { "include[]": ["term", "course_image"] }
+    }),
+    client.get(`/api/v1/courses/${courseId}/tabs`).catch(() => ({ data: [] })),
+    client.get(`/api/v1/courses/${courseId}/modules`, {
+      query: { "include[]": ["items", "content_details"], per_page: 100 },
+      pageAll: true
+    }).catch(() => ({ data: [] })),
+    client.get(`/api/v1/courses/${courseId}/assignments`, {
+      query: { per_page: 100 },
+      pageAll: true
+    }).catch(() => ({ data: [] })),
+    client.get(`/api/v1/courses/${courseId}/pages`, {
+      query: { per_page: 100 },
+      pageAll: true
+    }).catch(() => ({ data: [] })),
+    includeAllFiles ? client.get(`/api/v1/courses/${courseId}/files`, {
+      query: { per_page: 100 },
+      pageAll: true
+    }).catch(() => ({ data: [] })) : Promise.resolve({ data: [] })
+  ]);
+  const pack = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    baseUrl: profile.baseUrl,
+    course: normalizeCourse(course.data),
+    tabs: tabs.data.map(normalizeTab),
+    modules: modules.data.map(normalizeModule),
+    assignments: assignments.data.map(normalizeAssignment),
+    pages: pages.data.map(normalizePage),
+    files: files.data.map(normalizeFile),
+    notes: [
+      "This review pack preserves Canvas IDs and visible course structure.",
+      includeAllFiles ? "All visible course files metadata was included; file bytes are not downloaded by this command yet." : "All-files metadata is omitted by default. Re-run with --include-all-files to include visible file metadata."
+    ]
+  };
+  await mkdir6(outDir, { recursive: true });
+  const manifestPath = join5(outDir, "manifest.json");
+  const coursePath = join5(outDir, "course.json");
+  const modulesPath = join5(outDir, "modules.json");
+  const assignmentsPath = join5(outDir, "assignments.json");
+  const pagesPath = join5(outDir, "pages.json");
+  await Promise.all([
+    writeFile6(manifestPath, `${JSON.stringify(pack, null, 2)}
+`, "utf8"),
+    writeFile6(coursePath, `${JSON.stringify(pack.course, null, 2)}
+`, "utf8"),
+    writeFile6(modulesPath, `${JSON.stringify(pack.modules, null, 2)}
+`, "utf8"),
+    writeFile6(assignmentsPath, `${JSON.stringify(pack.assignments, null, 2)}
+`, "utf8"),
+    writeFile6(pagesPath, `${JSON.stringify(pack.pages, null, 2)}
+`, "utf8")
+  ]);
+  await writeOutput(
+    {
+      ok: true,
+      data: {
+        course: pack.course,
+        counts: {
+          tabs: pack.tabs.length,
+          modules: pack.modules.length,
+          assignments: pack.assignments.length,
+          pages: pack.pages.length,
+          files: pack.files.length
+        },
+        written: [
+          { path: manifestPath, kind: "manifest" },
+          { path: coursePath, kind: "course-json" },
+          { path: modulesPath, kind: "modules-json" },
+          { path: assignmentsPath, kind: "assignments-json" },
+          { path: pagesPath, kind: "pages-json" }
+        ]
+      },
+      meta: { baseUrl: profile.baseUrl }
+    },
+    options
+  );
+  return 0;
+}
+
 // src/bin/canvas.ts
-var VERSION = "0.0.0";
+var VERSION = "0.0.2";
 function helpText() {
   return `canvas \u2014 Canvas LMS CLI for students and agents.
 
@@ -1070,9 +2167,17 @@ COMMANDS:
   auth logout       Remove local Canvas auth config
   config show       Show redacted local config
   me                Show current Canvas user profile
-  context show      Show cached post-login context
   courses list      List active Canvas courses
+  courses overview  Summarize course setup
+  tabs list         List course tabs
+  modules list      List course modules
+  modules items     List module items
+  assignments list  List course assignments
+  pages list        List course pages
+  files list        List course files
+  folders list      List course folders
   review pack       Create a local course review pack
+  api get           Raw read-only Canvas API GET
   version           Print CLI version
 
 FLAGS:
@@ -1080,7 +2185,8 @@ FLAGS:
   --format <fmt>    Output format: json | pretty | table | ndjson
 
 MVP STATUS:
-  Auth/config/me/courses/tabs are in progress. Review commands are planned next.
+  Read-only student commands are available for auth, courses, tabs, modules,
+  assignments, pages, files, folders, review packs, and raw GET.
 `;
 }
 async function main(argv) {
@@ -1116,6 +2222,27 @@ async function main(argv) {
   if (command === "tabs") {
     return handleTabsCommand(parsed.argv.slice(1), { format: parsed.format });
   }
+  if (command === "modules") {
+    return handleModulesCommand(parsed.argv.slice(1), { format: parsed.format });
+  }
+  if (command === "assignments") {
+    return handleAssignmentsCommand(parsed.argv.slice(1), { format: parsed.format });
+  }
+  if (command === "pages") {
+    return handlePagesCommand(parsed.argv.slice(1), { format: parsed.format });
+  }
+  if (command === "files") {
+    return handleFilesCommand(parsed.argv.slice(1), { format: parsed.format });
+  }
+  if (command === "folders") {
+    return handleFoldersCommand(parsed.argv.slice(1), { format: parsed.format });
+  }
+  if (command === "review") {
+    return handleReviewCommand(parsed.argv.slice(1), { format: parsed.format });
+  }
+  if (command === "api") {
+    return handleApiCommand(parsed.argv.slice(1), { format: parsed.format });
+  }
   await writeOutput(
     {
       ok: false,