@lukeguo12210/canvas-cli 0.0.1

package/dist/bin/canvas.js

@@ -0,0 +1,1160 @@
+#!/usr/bin/env node
+
+// src/core/redaction.ts
+var REDACTED = "[REDACTED]";
+var SECRET_KEY_PATTERN = /(^|[_-])(authorization|access[_-]?token|token|api[_-]?key|secret)$/i;
+var BEARER_PATTERN = /Bearer\s+[A-Za-z0-9._~+/=-]+/gi;
+var QUERY_SECRET_PATTERN = /([?&](?:access_token|token|api_key|verifier|code)=)[^&#\s]+/gi;
+function redactSecrets(value) {
+  if (typeof value === "string") {
+    return redactString(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => redactSecrets(item));
+  }
+  if (value && typeof value === "object") {
+    const output2 = {};
+    for (const [key, nested] of Object.entries(value)) {
+      output2[key] = SECRET_KEY_PATTERN.test(key) ? REDACTED : redactSecrets(nested);
+    }
+    return output2;
+  }
+  return value;
+}
+function redactString(value) {
+  return value.replace(BEARER_PATTERN, `Bearer ${REDACTED}`).replace(QUERY_SECRET_PATTERN, `$1${REDACTED}`);
+}
+
+// src/core/output.ts
+function formatOutput(result, options = {}) {
+  const format = options.format ?? "json";
+  const safeResult = redactSecrets(result);
+  if (format === "json") {
+    return `${JSON.stringify(safeResult, null, 2)}
+`;
+  }
+  if (format === "ndjson") {
+    return `${JSON.stringify(safeResult)}
+`;
+  }
+  if (!safeResult.ok) {
+    const status = safeResult.error.status ? ` (${safeResult.error.status})` : "";
+    return `Error ${safeResult.error.code}${status}: ${safeResult.error.message}
+`;
+  }
+  if (format === "table") {
+    return tableOutput(safeResult.data);
+  }
+  return prettyOutput(safeResult.data);
+}
+async function writeOutput(result, options = {}) {
+  const stream = result.ok ? process.stdout : process.stderr;
+  stream.write(formatOutput(result, options));
+}
+function prettyOutput(data) {
+  if (typeof data === "string") {
+    return `${data}
+`;
+  }
+  return `${JSON.stringify(data, null, 2)}
+`;
+}
+function tableOutput(data) {
+  if (!Array.isArray(data)) {
+    return prettyOutput(data);
+  }
+  if (data.length === 0) {
+    return "\n";
+  }
+  const rows = data.filter((row) => {
+    return row !== null && typeof row === "object" && !Array.isArray(row);
+  });
+  if (rows.length === 0) {
+    return prettyOutput(data);
+  }
+  const columns = Object.keys(rows[0] ?? {});
+  const widths = columns.map(
+    (column) => Math.max(column.length, ...rows.map((row) => String(row[column] ?? "").length))
+  );
+  const line = (values) => `${values.map((value, index) => value.padEnd(widths[index] ?? value.length)).join("  ")}
+`;
+  let output2 = line(columns);
+  output2 += line(widths.map((width) => "-".repeat(width)));
+  for (const row of rows) {
+    output2 += line(columns.map((column) => String(row[column] ?? "")));
+  }
+  return output2;
+}
+
+// src/core/errors.ts
+var CanvasCliError = class extends Error {
+  code;
+  status;
+  retryable;
+  constructor(code, message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "CanvasCliError";
+    this.code = code;
+    this.status = options.status;
+    this.retryable = options.retryable ?? false;
+  }
+};
+function toErrorEnvelope(error) {
+  if (error instanceof CanvasCliError) {
+    return {
+      ok: false,
+      error: {
+        code: error.code,
+        message: error.message,
+        status: error.status,
+        retryable: error.retryable
+      }
+    };
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    ok: false,
+    error: {
+      code: "UNEXPECTED_ERROR",
+      message,
+      retryable: false
+    }
+  };
+}
+
+// src/core/pagination.ts
+function parseLinkHeader(header) {
+  if (!header) {
+    return {};
+  }
+  const links = {};
+  for (const part of splitHeader(header)) {
+    const match = part.match(/^\s*<([^>]+)>\s*;\s*rel="([^"]+)"\s*$/i);
+    if (!match) {
+      continue;
+    }
+    const [, url, rel] = match;
+    if (isLinkRelation(rel)) {
+      links[rel] = url;
+    }
+  }
+  return links;
+}
+function splitHeader(header) {
+  const parts = [];
+  let current = "";
+  let inQuotes = false;
+  for (const char of header) {
+    if (char === '"') {
+      inQuotes = !inQuotes;
+    }
+    if (char === "," && !inQuotes) {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim()) {
+    parts.push(current);
+  }
+  return parts;
+}
+function isLinkRelation(value) {
+  return ["current", "next", "prev", "first", "last"].includes(value);
+}
+
+// src/core/canvas-client.ts
+var CanvasClient = class {
+  baseUrl;
+  token;
+  fetchImpl;
+  constructor(options) {
+    this.baseUrl = normalizeBaseUrl(options.baseUrl);
+    this.token = options.token;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  async get(path2, options = {}) {
+    if (!path2.startsWith("/api/v1/")) {
+      throw new CanvasCliError("INVALID_API_PATH", "Canvas API paths must start with /api/v1/.");
+    }
+    let nextUrl = buildUrl(this.baseUrl, path2, options.query);
+    const pages = [];
+    let pagesFetched = 0;
+    const pageLimit = options.pageLimit ?? 50;
+    let hasNext = false;
+    while (nextUrl) {
+      pagesFetched += 1;
+      if (pagesFetched > pageLimit) {
+        throw new CanvasCliError(
+          "PAGE_LIMIT_EXCEEDED",
+          `Stopped after ${pageLimit} pages. Increase --page-limit if needed.`
+        );
+      }
+      const response = await this.fetchImpl(nextUrl, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          Accept: "application/json+canvas-string-ids"
+        }
+      }).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 request failed with status ${response.status}.`,
+          { status: response.status, retryable: response.status === 429 || response.status >= 500 }
+        );
+      }
+      const data = await response.json();
+      pages.push(data);
+      const links = parseLinkHeader(response.headers.get("link"));
+      hasNext = Boolean(links.next);
+      nextUrl = options.pageAll ? links.next ?? null : null;
+    }
+    const merged = mergePages(pages);
+    return {
+      data: redactSecrets(merged),
+      meta: {
+        request: {
+          method: "GET",
+          path: path2
+        },
+        pagination: {
+          pagesFetched,
+          hasNext
+        }
+      }
+    };
+  }
+};
+function normalizeBaseUrl(input2) {
+  const trimmed = input2.trim().replace(/\/+$/, "");
+  const url = new URL(trimmed);
+  if (url.protocol !== "https:") {
+    throw new CanvasCliError("INVALID_BASE_URL", "Canvas base URL must use https://.");
+  }
+  if (url.pathname.includes("/api/")) {
+    throw new CanvasCliError("INVALID_BASE_URL", "Canvas base URL should not include /api/.");
+  }
+  url.pathname = url.pathname.replace(/\/+$/, "");
+  url.search = "";
+  url.hash = "";
+  return url.toString().replace(/\/+$/, "");
+}
+function buildUrl(baseUrl, path2, query = {}) {
+  const url = new URL(path2, baseUrl);
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        url.searchParams.append(key, String(item));
+      }
+      continue;
+    }
+    url.searchParams.set(key, String(value));
+  }
+  return url.toString();
+}
+function mergePages(pages) {
+  if (pages.length === 1) {
+    return pages[0];
+  }
+  if (pages.every(Array.isArray)) {
+    return pages.flat();
+  }
+  return pages;
+}
+function mapStatusCode(status) {
+  if (status === 401) return "CANVAS_UNAUTHORIZED";
+  if (status === 403) return "CANVAS_FORBIDDEN";
+  if (status === 404) return "CANVAS_NOT_FOUND";
+  if (status === 429) return "CANVAS_RATE_LIMITED";
+  if (status >= 500) return "CANVAS_SERVER_ERROR";
+  return "CANVAS_REQUEST_FAILED";
+}
+
+// src/core/config-store.ts
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { dirname } from "path";
+
+// src/core/paths.ts
+import os from "os";
+import path from "path";
+function canvasHome() {
+  return process.env.CANVAS_HOME || path.join(os.homedir(), ".canvas");
+}
+function configPath() {
+  return path.join(canvasHome(), "config.json");
+}
+
+// src/core/config-store.ts
+var ConfigStore = class {
+  constructor(filePath = configPath()) {
+    this.filePath = filePath;
+  }
+  filePath;
+  async read() {
+    try {
+      const raw = await readFile(this.filePath, "utf8");
+      return JSON.parse(raw);
+    } catch (error) {
+      if (isNotFound(error)) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async write(config) {
+    await mkdir(dirname(this.filePath), { recursive: true, mode: 448 });
+    await writeFile(this.filePath, `${JSON.stringify(config, null, 2)}
+`, {
+      encoding: "utf8",
+      mode: 384
+    });
+  }
+  async remove() {
+    await rm(this.filePath, { force: true });
+  }
+  async readRedacted() {
+    const config = await this.read();
+    return config ? redactSecrets(config) : null;
+  }
+  async activeProfile() {
+    const config = await this.read();
+    if (!config) {
+      throw new CanvasCliError("NO_AUTH_CONFIG", "No Canvas auth config found. Run canvas auth login.");
+    }
+    const profile = config.profiles[config.activeProfile];
+    if (!profile) {
+      throw new CanvasCliError(
+        "NO_ACTIVE_PROFILE",
+        `Active Canvas profile not found: ${config.activeProfile}`
+      );
+    }
+    return profile;
+  }
+};
+function isNotFound(error) {
+  return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
+}
+
+// src/core/browser.ts
+import { spawn } from "child_process";
+async function openBrowser(url) {
+  const command = openCommand(url);
+  const child = spawn(command.command, command.args, {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+}
+function openCommand(url) {
+  if (process.platform === "darwin") {
+    return { command: "open", args: [url] };
+  }
+  if (process.platform === "win32") {
+    return { command: "cmd", args: ["/c", "start", "", url] };
+  }
+  return { command: "xdg-open", args: [url] };
+}
+
+// src/core/prompt.ts
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+function createPrompt() {
+  return createInterface({ input, output });
+}
+async function promptHidden(prompt) {
+  if (!process.stdin.isTTY) {
+    const io = createPrompt();
+    try {
+      return (await io.question(prompt)).trim();
+    } finally {
+      io.close();
+    }
+  }
+  return new Promise((resolve, reject) => {
+    const stdin = process.stdin;
+    const onData = (char) => {
+      const value = char.toString("utf8");
+      if (value === "\n" || value === "\r" || value === "\r\n") {
+        stdin.setRawMode(false);
+        stdin.pause();
+        stdin.off("data", onData);
+        process.stdout.write("\n");
+        resolve(buffer.trim());
+        return;
+      }
+      if (value === "") {
+        stdin.setRawMode(false);
+        stdin.pause();
+        stdin.off("data", onData);
+        process.stdout.write("\n");
+        reject(new Error("Prompt cancelled."));
+        return;
+      }
+      if (value === "\x7F") {
+        buffer = buffer.slice(0, -1);
+        return;
+      }
+      buffer += value;
+    };
+    let buffer = "";
+    process.stdout.write(prompt);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.on("data", onData);
+  });
+}
+
+// src/registry/schools.ts
+var SCHOOLS = [
+  { name: "Brown University", url: "https://canvas.brown.edu" },
+  { name: "Carnegie Mellon University", url: "https://canvas.cmu.edu" },
+  { name: "Columbia University (CourseWorks)", url: "https://courseworks2.columbia.edu" },
+  { name: "Cornell University", url: "https://canvas.cornell.edu" },
+  { name: "Dartmouth College", url: "https://canvas.dartmouth.edu" },
+  { name: "Duke University", url: "https://go.canvas.duke.edu" },
+  { name: "Emory University", url: "https://canvas.emory.edu" },
+  { name: "Georgetown University", url: "https://canvas.georgetown.edu" },
+  { name: "Georgia Institute of Technology", url: "https://canvas.gatech.edu" },
+  { name: "Harvard University", url: "https://canvas.harvard.edu" },
+  { name: "Massachusetts Institute of Technology (MIT)", url: "https://canvas.mit.edu" },
+  { name: "Northeastern University", url: "https://canvas.northeastern.edu" },
+  { name: "Northwestern University", url: "https://canvas.northwestern.edu" },
+  { name: "Ohio State University", url: "https://canvas.osu.edu" },
+  { name: "Pennsylvania State University", url: "https://canvas.psu.edu" },
+  { name: "Princeton University", url: "https://canvas.princeton.edu" },
+  { name: "Rice University", url: "https://canvas.rice.edu" },
+  { name: "Stanford University", url: "https://canvas.stanford.edu" },
+  { name: "Tufts University", url: "https://canvas.tufts.edu" },
+  { name: "University of California, Berkeley (bCourses)", url: "https://bcourses.berkeley.edu" },
+  { name: "University of California, Davis", url: "https://canvas.ucdavis.edu" },
+  { name: "University of California, Irvine", url: "https://canvas.eee.uci.edu" },
+  { name: "University of California, Los Angeles (Bruin Learn)", url: "https://bruinlearn.ucla.edu" },
+  { name: "University of California, San Diego", url: "https://canvas.ucsd.edu" },
+  { name: "University of California, Santa Barbara", url: "https://canvas.ucsb.edu" },
+  { name: "University of California, Santa Cruz", url: "https://canvas.ucsc.edu" },
+  { name: "University of Chicago", url: "https://canvas.uchicago.edu" },
+  { name: "University of Michigan", url: "https://canvas.umich.edu" },
+  { name: "University of North Carolina at Chapel Hill", url: "https://canvas.unc.edu" },
+  { name: "University of Notre Dame", url: "https://canvas.nd.edu" },
+  { name: "University of Pennsylvania", url: "https://canvas.upenn.edu" },
+  { name: "University of Southern California", url: "https://canvas.usc.edu" },
+  { name: "University of Virginia", url: "https://canvas.its.virginia.edu" },
+  { name: "University of Washington", url: "https://canvas.uw.edu" },
+  { name: "Yale University", url: "https://canvas.yale.edu" }
+];
+function searchSchools(query, limit = 10) {
+  const normalized = query.trim().toLowerCase();
+  if (!normalized) {
+    return SCHOOLS.slice(0, limit);
+  }
+  return SCHOOLS.filter((school) => {
+    return school.name.toLowerCase().includes(normalized) || school.url.toLowerCase().includes(normalized);
+  }).slice(0, limit);
+}
+function makeCustomSchool(name, url) {
+  return {
+    name: name.trim() || "Custom Canvas School",
+    url: normalizeBaseUrl(url)
+  };
+}
+
+// src/workflows/context-bootstrap.ts
+async function runPostLoginBootstrap() {
+  return {
+    skipped: true,
+    reason: "Context bootstrap is planned for Phase 4."
+  };
+}
+
+// src/commands/auth.ts
+var TOKEN_PURPOSE = "Hyperknow";
+async function handleAuthCommand(argv, options) {
+  const [subcommand] = argv;
+  if (subcommand === "login") {
+    return authLogin(options);
+  }
+  if (subcommand === "status") {
+    return authStatus(options);
+  }
+  if (subcommand === "logout") {
+    return authLogout(options);
+  }
+  await writeOutput(
+    {
+      ok: false,
+      error: {
+        code: "UNKNOWN_COMMAND",
+        message: `Unknown auth command: ${argv.join(" ")}`,
+        retryable: false
+      }
+    },
+    options
+  );
+  return 1;
+}
+async function authLogin(options) {
+  const io = createPrompt();
+  try {
+    const school = await chooseSchool(io);
+    const settingsUrl = `${school.url}/profile/settings`;
+    process.stdout.write(tokenInstructions(school, settingsUrl));
+    await io.question("Press Enter to open Canvas settings in your browser...");
+    await openBrowser(settingsUrl);
+    process.stdout.write("\nWaiting for your Canvas personal access token.\n");
+    const token = await promptHidden("Paste token: ");
+    if (!token) {
+      throw new CanvasCliError("EMPTY_TOKEN", "No token entered.");
+    }
+    const client = new CanvasClient({ baseUrl: school.url, token });
+    const user = await validateToken(client);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const config = {
+      version: 1,
+      activeProfile: "default",
+      profiles: {
+        default: {
+          schoolName: school.name,
+          baseUrl: school.url,
+          token,
+          createdAt: now,
+          validatedAt: now,
+          user
+        }
+      }
+    };
+    await new ConfigStore().write(config);
+    const bootstrap = await runPostLoginBootstrap();
+    await writeOutput(
+      {
+        ok: true,
+        data: {
+          authenticated: true,
+          school: {
+            name: school.name,
+            baseUrl: school.url
+          },
+          user,
+          contextBootstrap: bootstrap,
+          next: "canvas context show"
+        },
+        meta: {
+          command: "auth login"
+        }
+      },
+      options
+    );
+    return 0;
+  } catch (error) {
+    await writeOutput(toErrorEnvelope(error), options);
+    return 1;
+  } finally {
+    io.close();
+  }
+}
+async function authStatus(options) {
+  const store = new ConfigStore();
+  const config = await store.readRedacted();
+  if (!config) {
+    await writeOutput(
+      {
+        ok: true,
+        data: {
+          authenticated: false,
+          message: "No Canvas auth config found. Run canvas auth login."
+        },
+        meta: {
+          command: "auth status"
+        }
+      },
+      options
+    );
+    return 0;
+  }
+  await writeOutput(
+    {
+      ok: true,
+      data: {
+        authenticated: true,
+        activeProfile: config.activeProfile,
+        profile: config.profiles[config.activeProfile]
+      },
+      meta: {
+        command: "auth status"
+      }
+    },
+    options
+  );
+  return 0;
+}
+async function authLogout(options) {
+  await new ConfigStore().remove();
+  await writeOutput(
+    {
+      ok: true,
+      data: {
+        authenticated: false,
+        message: "Canvas auth config removed."
+      },
+      meta: {
+        command: "auth logout"
+      }
+    },
+    options
+  );
+  return 0;
+}
+async function chooseSchool(io, write = (message) => process.stdout.write(message)) {
+  write("Search for your school, or press Enter to browse the first matches.\n");
+  const query = await io.question("School: ");
+  const matches = searchSchools(query);
+  if (matches.length === 1) {
+    const school2 = matches[0];
+    const answer = (await io.question(`Is this your school: ${school2.name} (${school2.url})? Choose: y/n `)).trim().toLowerCase();
+    if (answer === "y" || answer === "yes") {
+      return {
+        name: school2.name,
+        url: normalizeBaseUrl(school2.url)
+      };
+    }
+    if (answer === "n" || answer === "no") {
+      return promptCustomSchool(io);
+    }
+    throw new CanvasCliError("INVALID_SELECTION", "Please answer y or n.");
+  }
+  for (const [index, school2] of matches.entries()) {
+    write(`${index + 1}. ${school2.name}
+   ${school2.url}
+`);
+  }
+  write(`${matches.length + 1}. Not found? Add your own
+`);
+  const selected = Number.parseInt(await io.question("Choose: "), 10);
+  if (!Number.isFinite(selected) || selected < 1 || selected > matches.length + 1) {
+    throw new CanvasCliError("INVALID_SELECTION", "Invalid school selection.");
+  }
+  if (selected === matches.length + 1) {
+    return promptCustomSchool(io);
+  }
+  const school = matches[selected - 1];
+  return {
+    name: school.name,
+    url: normalizeBaseUrl(school.url)
+  };
+}
+async function promptCustomSchool(io) {
+  const name = await io.question("School display name: ");
+  const url = await io.question("Canvas base URL: ");
+  return makeCustomSchool(name, url);
+}
+function tokenInstructions(school, settingsUrl) {
+  return `
+Canvas token setup for ${school.name}
+
+1. Go to ${settingsUrl}
+2. Click "+ New Access Token"
+3. Enter "${TOKEN_PURPOSE}" as the purpose
+4. Optionally set an expiration date
+5. Click "Generate Token"
+6. Copy the token and paste it back here
+
+`;
+}
+async function validateToken(client) {
+  try {
+    const response = await client.get(
+      "/api/v1/users/self/profile"
+    );
+    return {
+      id: response.data.id,
+      name: response.data.name ?? response.data.short_name
+    };
+  } catch (error) {
+    if (error instanceof CanvasCliError && error.status === 404) {
+      await client.get("/api/v1/courses");
+      return {};
+    }
+    throw error;
+  }
+}
+
+// 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();
+  return {
+    profile,
+    client: new CanvasClient({
+      baseUrl: profile.baseUrl,
+      token: profile.token
+    })
+  };
+}
+function flagValue(argv, flag) {
+  const index = argv.indexOf(flag);
+  if (index === -1) {
+    return void 0;
+  }
+  return argv[index + 1];
+}
+function hasFlag(argv, flag) {
+  return argv.includes(flag);
+}
+function pageOptions(argv) {
+  const pageLimitRaw = flagValue(argv, "--page-limit");
+  return {
+    pageAll: hasFlag(argv, "--page-all"),
+    pageLimit: pageLimitRaw ? Number.parseInt(pageLimitRaw, 10) : void 0
+  };
+}
+function positionalArgs(argv) {
+  const valueFlags = /* @__PURE__ */ new Set([
+    "--course-id",
+    "--module-id",
+    "--item-id",
+    "--assignment-id",
+    "--quiz-id",
+    "--topic-id",
+    "--page",
+    "--path",
+    "--out",
+    "--format",
+    "--page-limit",
+    "--page-size",
+    "--page-delay",
+    "--enrollment-state",
+    "--state",
+    "--include",
+    "--params"
+  ]);
+  const values = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg.startsWith("--")) {
+      if (valueFlags.has(arg)) {
+        index += 1;
+      }
+      continue;
+    }
+    values.push(arg);
+  }
+  return values;
+}
+
+// src/commands/courses.ts
+async function handleCoursesCommand(argv, options) {
+  const [subcommand] = argv;
+  try {
+    if (subcommand === "list") {
+      return await listCourses(argv.slice(1), options);
+    }
+    if (subcommand === "search") {
+      return await searchCourses(argv.slice(1), options);
+    }
+    if (subcommand === "show") {
+      return await showCourse(argv.slice(1), options);
+    }
+    if (subcommand === "overview") {
+      return await overviewCourse(argv.slice(1), options);
+    }
+    await writeOutput(
+      {
+        ok: false,
+        error: {
+          code: "UNKNOWN_COMMAND",
+          message: `Unknown courses command: ${argv.join(" ")}`,
+          retryable: false
+        }
+      },
+      options
+    );
+    return 1;
+  } catch (error) {
+    await writeOutput(toErrorEnvelope(error), options);
+    return 1;
+  }
+}
+async function listCourses(argv, options) {
+  const { client, profile } = await activeCanvas();
+  const response = await client.get("/api/v1/courses", {
+    query: courseListQuery(argv),
+    ...pageOptions(argv)
+  });
+  await writeOutput(
+    {
+      ok: true,
+      data: response.data.map(normalizeCourse),
+      meta: {
+        ...response.meta,
+        baseUrl: profile.baseUrl
+      }
+    },
+    options
+  );
+  return 0;
+}
+async function searchCourses(argv, options) {
+  const query = positionalArgs(argv).join(" ").trim();
+  const { client, profile } = await activeCanvas();
+  const response = await client.get("/api/v1/courses", {
+    query: courseListQuery(["--active"]),
+    pageAll: true
+  });
+  const matches = response.data.map(normalizeCourse).filter((course) => {
+    const haystack = `${course.name ?? ""} ${course.courseCode ?? ""}`.toLowerCase();
+    return haystack.includes(query.toLowerCase());
+  });
+  await writeOutput(
+    {
+      ok: true,
+      data: matches,
+      meta: {
+        ...response.meta,
+        baseUrl: profile.baseUrl,
+        query
+      }
+    },
+    options
+  );
+  return 0;
+}
+async function showCourse(argv, options) {
+  const courseId = positionalArgs(argv)[0];
+  if (!courseId) {
+    throw new Error("Usage: canvas courses show <course-id>");
+  }
+  const { client, profile } = await activeCanvas();
+  const response = await client.get(`/api/v1/courses/${courseId}`, {
+    query: {
+      "include[]": ["term", "course_image", "total_scores", "teachers"]
+    }
+  });
+  await writeOutput(
+    {
+      ok: true,
+      data: normalizeCourse(response.data),
+      meta: {
+        ...response.meta,
+        baseUrl: profile.baseUrl
+      }
+    },
+    options
+  );
+  return 0;
+}
+async function overviewCourse(argv, options) {
+  const courseId = positionalArgs(argv)[0];
+  if (!courseId) {
+    throw new Error("Usage: canvas courses overview <course-id>");
+  }
+  const { client, profile } = await activeCanvas();
+  const [course, tabs, modules, assignments] = await Promise.all([
+    client.get(`/api/v1/courses/${courseId}`, {
+      query: { "include[]": ["term", "course_image"] }
+    }),
+    client.get(
+      `/api/v1/courses/${courseId}/tabs`
+    ),
+    client.get(
+      `/api/v1/courses/${courseId}/modules`,
+      { query: { per_page: 100 } }
+    ),
+    client.get(
+      `/api/v1/courses/${courseId}/assignments`,
+      { query: { bucket: "upcoming", per_page: 20 } }
+    )
+  ]);
+  await writeOutput(
+    {
+      ok: true,
+      data: {
+        course: normalizeCourse(course.data),
+        tabs: tabs.data,
+        setup: {
+          hasModules: modules.data.length > 0,
+          hasAssignments: assignments.data.length > 0,
+          hasFilesTab: tabs.data.some((tab) => tab.id === "files"),
+          isModuleHeavy: modules.data.length > 0
+        },
+        counts: {
+          tabs: tabs.data.length,
+          modules: modules.data.length,
+          upcomingAssignments: assignments.data.length
+        },
+        modules: modules.data.map((module) => ({
+          id: module.id,
+          name: module.name,
+          position: module.position
+        })),
+        upcomingAssignments: assignments.data.map((assignment) => ({
+          id: assignment.id,
+          name: assignment.name,
+          dueAt: assignment.due_at
+        }))
+      },
+      meta: {
+        baseUrl: profile.baseUrl,
+        request: {
+          method: "GET",
+          path: `/api/v1/courses/${courseId}/overview`
+        }
+      }
+    },
+    options
+  );
+  return 0;
+}
+function courseListQuery(argv) {
+  return {
+    enrollment_state: hasFlag(argv, "--active") ? "active" : flagValue(argv, "--enrollment-state"),
+    state: flagValue(argv, "--state"),
+    per_page: flagValue(argv, "--page-size"),
+    "include[]": ["term", "total_scores"]
+  };
+}
+function normalizeCourse(course) {
+  return {
+    id: String(course.id),
+    name: course.name,
+    courseCode: course.course_code,
+    workflowState: course.workflow_state,
+    enrollmentTermId: course.enrollment_term_id,
+    term: course.term ? {
+      id: course.term.id,
+      name: course.term.name,
+      startAt: course.term.start_at,
+      endAt: course.term.end_at
+    } : void 0,
+    enrollments: course.enrollments?.map((enrollment) => ({
+      type: enrollment.type,
+      role: enrollment.role,
+      state: enrollment.enrollment_state
+    }))
+  };
+}
+
+// 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/tabs.ts
+async function handleTabsCommand(argv, options) {
+  const [subcommand] = argv;
+  if (subcommand !== "list") {
+    await writeOutput(
+      {
+        ok: false,
+        error: {
+          code: "UNKNOWN_COMMAND",
+          message: `Unknown tabs command: ${argv.join(" ")}`,
+          retryable: false
+        }
+      },
+      options
+    );
+    return 1;
+  }
+  try {
+    const courseId = flagValue(argv, "--course-id");
+    if (!courseId) {
+      throw new Error("Usage: canvas tabs list --course-id <course-id>");
+    }
+    const { client, profile } = await activeCanvas();
+    const response = await client.get(`/api/v1/courses/${courseId}/tabs`);
+    await writeOutput(
+      {
+        ok: true,
+        data: response.data.map(normalizeTab),
+        meta: {
+          ...response.meta,
+          baseUrl: profile.baseUrl
+        }
+      },
+      options
+    );
+    return 0;
+  } catch (error) {
+    await writeOutput(toErrorEnvelope(error), options);
+    return 1;
+  }
+}
+function normalizeTab(tab) {
+  return {
+    id: tab.id,
+    label: tab.label,
+    type: tab.type,
+    position: tab.position,
+    hidden: tab.hidden,
+    visibility: tab.visibility,
+    htmlUrl: tab.html_url,
+    fullUrl: tab.full_url
+  };
+}
+
+// src/bin/canvas.ts
+var VERSION = "0.0.0";
+function helpText() {
+  return `canvas \u2014 Canvas LMS CLI for students and agents.
+
+USAGE:
+  canvas <command> [options]
+
+COMMANDS:
+  auth login        Interactive Canvas PAT setup
+  auth status       Show redacted auth status
+  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
+  review pack       Create a local course review pack
+  version           Print CLI version
+
+FLAGS:
+  -h, --help        Show help
+  --format <fmt>    Output format: json | pretty | table | ndjson
+
+MVP STATUS:
+  Auth/config/me/courses/tabs are in progress. Review commands are planned next.
+`;
+}
+async function main(argv) {
+  const parsed = parseGlobalOptions(argv);
+  const [command] = parsed.argv;
+  if (!command || command === "--help" || command === "-h" || command === "help") {
+    process.stdout.write(helpText());
+    return 0;
+  }
+  if (command === "version" || command === "--version" || command === "-v") {
+    await writeOutput(
+      {
+        ok: true,
+        data: { version: VERSION },
+        meta: { command: "version" }
+      },
+      { format: parsed.format === "json" ? "json" : "pretty" }
+    );
+    return 0;
+  }
+  if (command === "auth") {
+    return handleAuthCommand(parsed.argv.slice(1), { format: parsed.format });
+  }
+  if (command === "config") {
+    return handleConfigCommand(parsed.argv.slice(1), { format: parsed.format });
+  }
+  if (command === "me") {
+    return handleMeCommand({ format: parsed.format });
+  }
+  if (command === "courses") {
+    return handleCoursesCommand(parsed.argv.slice(1), { format: parsed.format });
+  }
+  if (command === "tabs") {
+    return handleTabsCommand(parsed.argv.slice(1), { format: parsed.format });
+  }
+  await writeOutput(
+    {
+      ok: false,
+      error: {
+        code: "UNKNOWN_COMMAND",
+        message: `Unknown command: ${parsed.argv.join(" ")}`,
+        retryable: false
+      }
+    },
+    { format: parsed.format }
+  );
+  return 1;
+}
+function parseGlobalOptions(argv) {
+  const nextArgv = [];
+  let format = "json";
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--format") {
+      const value = argv[index + 1];
+      if (isOutputFormat(value)) {
+        format = value;
+        index += 1;
+        continue;
+      }
+    }
+    nextArgv.push(arg);
+  }
+  return { argv: nextArgv, format };
+}
+function isOutputFormat(value) {
+  return value === "json" || value === "pretty" || value === "table" || value === "ndjson";
+}
+main(process.argv.slice(2)).then((code) => {
+  process.exitCode = code;
+}).catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`canvas: ${message}
+`);
+  process.exitCode = 1;
+});
+//# sourceMappingURL=canvas.js.map