@telebort/question-banks-cli 1.0.0

package/dist/index.js

@@ -0,0 +1,1097 @@
+import { Command } from 'commander';
+import pc from 'picocolors';
+import open from 'open';
+import { homedir } from 'os';
+import { join } from 'path';
+import ora from 'ora';
+import Table from 'cli-table3';
+import { z } from 'zod';
+import { promises } from 'fs';
+import { formatDistanceToNow } from 'date-fns';
+import { createInterface } from 'readline';
+
+// src/index.ts
+var CONFIG_DIR = join(homedir(), ".question-banks");
+var PATHS = {
+  configDir: CONFIG_DIR,
+  tokensFile: join(CONFIG_DIR, "tokens.json"),
+  configFile: join(CONFIG_DIR, "config.json"),
+  cacheDir: join(CONFIG_DIR, "cache")
+};
+var API_BASE_URL = process.env.QUESTION_BANKS_API_URL ?? "https://exit-tickets-cli-api.vercel.app/api";
+var ENDPOINTS = {
+  // Auth
+  deviceCode: "/auth/device-code",
+  token: "/auth/token",
+  refresh: "/auth/refresh",
+  // Account
+  me: "/account/me",
+  usage: "/account/usage",
+  billingPortal: "/account/billing-portal",
+  // API Keys
+  apiKeys: "/api-keys",
+  apiKeyById: (id) => `/api-keys/${id}`,
+  rotateKey: (id) => `/api-keys/${id}/rotate`,
+  // Validation
+  validate: "/v1/validate"
+};
+var colors = {
+  // Text styles
+  bold: pc.bold,
+  dim: pc.dim,
+  italic: pc.italic,
+  underline: pc.underline,
+  // Colors
+  red: pc.red,
+  green: pc.green,
+  yellow: pc.yellow,
+  blue: pc.blue,
+  cyan: pc.cyan,
+  magenta: pc.magenta,
+  white: pc.white,
+  gray: pc.gray,
+  // Semantic colors
+  success: pc.green,
+  error: pc.red,
+  warning: pc.yellow,
+  info: pc.cyan,
+  muted: pc.dim,
+  // Composite styles
+  errorBold: (text) => pc.bold(pc.red(text)),
+  successBold: (text) => pc.bold(pc.green(text)),
+  warningBold: (text) => pc.bold(pc.yellow(text))
+};
+var symbols = {
+  success: colors.green("\u2713"),
+  error: colors.red("\u2717"),
+  warning: colors.yellow("\u26A0"),
+  info: colors.cyan("\u2139"),
+  arrow: colors.cyan("\u2192"),
+  bullet: colors.dim("\u2022")
+};
+function spinner(text) {
+  const spin = ora({
+    text,
+    spinner: "dots",
+    color: "cyan"
+  }).start();
+  return {
+    stop: () => spin.stop(),
+    succeed: (text2) => spin.succeed(text2),
+    fail: (text2) => spin.fail(text2),
+    warn: (text2) => spin.warn(text2),
+    info: (text2) => spin.info(text2),
+    text: (text2) => {
+      spin.text = text2;
+    }
+  };
+}
+var spinners = {
+  authenticating: () => spinner("Authenticating..."),
+  loading: () => spinner("Loading..."),
+  saving: () => spinner("Saving..."),
+  connecting: () => spinner("Connecting to API..."),
+  fetching: () => spinner("Fetching data..."),
+  validating: () => spinner("Validating...")
+};
+function createTable(options = {}) {
+  return new Table({
+    chars: {
+      "top": "\u2500",
+      "top-mid": "\u252C",
+      "top-left": "\u250C",
+      "top-right": "\u2510",
+      "bottom": "\u2500",
+      "bottom-mid": "\u2534",
+      "bottom-left": "\u2514",
+      "bottom-right": "\u2518",
+      "left": "\u2502",
+      "left-mid": "\u251C",
+      "mid": "\u2500",
+      "mid-mid": "\u253C",
+      "right": "\u2502",
+      "right-mid": "\u2524",
+      "middle": "\u2502"
+    },
+    style: {
+      "padding-left": 1,
+      "padding-right": 1,
+      head: options.style?.head ?? ["cyan"],
+      border: options.style?.border ?? ["dim"]
+    },
+    head: options.head,
+    colWidths: options.colWidths
+  });
+}
+function progressBar(current, total, width = 40) {
+  const percentage = Math.min(current / total, 1);
+  const filled = Math.floor(percentage * width);
+  const empty = width - filled;
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
+  const pct = (percentage * 100).toFixed(1);
+  let colorFn = colors.green;
+  if (percentage >= 0.85) colorFn = colors.red;
+  else if (percentage >= 0.7) colorFn = colors.yellow;
+  return `${colorFn(bar)} ${pct}%`;
+}
+function divider(width = 50) {
+  return colors.dim("\u2500".repeat(width));
+}
+
+// src/utils/error-handler.ts
+var EXIT_CODES = {
+  SUCCESS: 0,
+  GENERAL_ERROR: 1,
+  AUTH_ERROR: 2,
+  VALIDATION_ERROR: 3,
+  NETWORK_ERROR: 4
+};
+var CLIError = class extends Error {
+  constructor(message, code = "GENERAL_ERROR", hint) {
+    super(message);
+    this.code = code;
+    this.hint = hint;
+    this.name = "CLIError";
+  }
+};
+var AuthError = class extends CLIError {
+  constructor(message, hint) {
+    super(message, "AUTH_ERROR", hint);
+    this.name = "AuthError";
+  }
+};
+var ValidationError = class extends CLIError {
+  constructor(message, hint) {
+    super(message, "VALIDATION_ERROR", hint);
+    this.name = "ValidationError";
+  }
+};
+var NetworkError = class extends CLIError {
+  constructor(message, hint) {
+    super(message, "NETWORK_ERROR", hint);
+    this.name = "NetworkError";
+  }
+};
+function formatError(error) {
+  console.error("");
+  console.error(`${symbols.error} ${colors.errorBold("Error:")} ${error.message}`);
+  if (error instanceof CLIError && error.hint) {
+    console.error(`${symbols.info} ${colors.dim("Hint:")} ${error.hint}`);
+  }
+  if (process.env.DEBUG === "true" && error.stack) {
+    console.error("");
+    console.error(colors.dim(error.stack));
+  }
+  console.error("");
+}
+function handleError(error) {
+  if (error instanceof CLIError) {
+    formatError(error);
+    process.exit(EXIT_CODES[error.code]);
+  }
+  if (error instanceof Error) {
+    formatError(error);
+    process.exit(EXIT_CODES.GENERAL_ERROR);
+  }
+  console.error(`${symbols.error} ${colors.errorBold("Unknown error:")}`, error);
+  process.exit(EXIT_CODES.GENERAL_ERROR);
+}
+function setupErrorHandlers() {
+  process.on("uncaughtException", (error) => {
+    console.error("");
+    console.error(`${symbols.error} ${colors.errorBold("Uncaught exception:")}`);
+    formatError(error);
+    process.exit(EXIT_CODES.GENERAL_ERROR);
+  });
+  process.on("unhandledRejection", (reason) => {
+    console.error("");
+    console.error(`${symbols.error} ${colors.errorBold("Unhandled rejection:")}`);
+    if (reason instanceof Error) {
+      formatError(reason);
+    } else {
+      console.error(reason);
+    }
+    process.exit(EXIT_CODES.GENERAL_ERROR);
+  });
+  process.on("SIGINT", () => {
+    console.log("");
+    console.log(colors.yellow("Interrupted"));
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    console.log("");
+    console.log(colors.yellow("Terminated"));
+    process.exit(0);
+  });
+}
+
+// src/api/client.ts
+var ApiClient = class {
+  baseUrl;
+  constructor(baseUrl = API_BASE_URL) {
+    this.baseUrl = baseUrl;
+  }
+  buildUrl(path, params) {
+    const url = new URL(path, this.baseUrl);
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        url.searchParams.set(key, value);
+      });
+    }
+    return url.toString();
+  }
+  async request(method, path, body, options = {}) {
+    const url = this.buildUrl(path, options.params);
+    const timeout = options.timeout ?? 3e4;
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: AbortSignal.timeout(timeout)
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        const error = data;
+        throw new NetworkError(
+          error.message ?? `HTTP ${response.status}`,
+          `Check your network connection or try again later`
+        );
+      }
+      return {
+        data,
+        status: response.status
+      };
+    } catch (error) {
+      if (error instanceof NetworkError) {
+        throw error;
+      }
+      if (error instanceof TypeError && error.message.includes("fetch")) {
+        throw new NetworkError(
+          "Network error: Unable to connect to API",
+          "Check your internet connection"
+        );
+      }
+      if (error instanceof DOMException && error.name === "AbortError") {
+        throw new NetworkError(
+          "Request timed out",
+          "The API is taking too long to respond. Try again later."
+        );
+      }
+      throw error;
+    }
+  }
+  async get(path, options) {
+    return this.request("GET", path, void 0, options);
+  }
+  async post(path, body, options) {
+    return this.request("POST", path, body, options);
+  }
+  async delete(path, options) {
+    return this.request("DELETE", path, void 0, options);
+  }
+  async patch(path, body, options) {
+    return this.request("PATCH", path, body, options);
+  }
+};
+var apiClient = new ApiClient();
+var DeviceCodeResponseSchema = z.object({
+  device_code: z.string(),
+  user_code: z.string(),
+  verification_uri: z.string().url(),
+  verification_uri_complete: z.string().url().optional(),
+  expires_in: z.number(),
+  // seconds
+  interval: z.number()
+  // seconds between polls
+});
+var TokenResponseSchema = z.object({
+  access_token: z.string(),
+  token_type: z.literal("Bearer"),
+  expires_in: z.number(),
+  // seconds
+  refresh_token: z.string(),
+  scope: z.string().optional()
+});
+var StoredTokenSchema = z.object({
+  access_token: z.string(),
+  refresh_token: z.string(),
+  expires_at: z.number()
+  // Unix timestamp (ms)
+});
+z.object({
+  error: z.enum([
+    "authorization_pending",
+    "slow_down",
+    "expired_token",
+    "access_denied"
+  ]),
+  error_description: z.string().optional()
+});
+
+// src/auth/device-flow.ts
+var CLIENT_ID = "question-banks-cli";
+var DeviceFlowAuth = class {
+  async authenticate() {
+    const deviceCode = await this.requestDeviceCode();
+    this.displayUserCode(deviceCode);
+    const opened = await this.openBrowser(deviceCode.verification_uri_complete ?? deviceCode.verification_uri);
+    if (!opened) {
+      console.log(
+        colors.yellow("Could not open browser automatically."),
+        colors.dim("Please visit the URL above manually.")
+      );
+    }
+    console.log("");
+    const spin = spinner("Waiting for authorization...");
+    try {
+      const token = await this.pollForToken(deviceCode);
+      spin.succeed("Authentication complete!");
+      return token;
+    } catch (error) {
+      spin.fail("Authentication failed");
+      throw error;
+    }
+  }
+  async requestDeviceCode() {
+    const { data } = await apiClient.post(ENDPOINTS.deviceCode, {
+      client_id: CLIENT_ID
+    });
+    return DeviceCodeResponseSchema.parse(data);
+  }
+  displayUserCode(deviceCode) {
+    console.log("");
+    console.log(colors.bold("First-time setup required"));
+    console.log("");
+    console.log(`${symbols.arrow} Visit: ${colors.cyan(colors.underline(deviceCode.verification_uri))}`);
+    console.log(`${symbols.arrow} Enter code: ${colors.bold(colors.yellow(deviceCode.user_code))}`);
+    console.log("");
+  }
+  async openBrowser(url) {
+    try {
+      await open(url);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async pollForToken(deviceCode) {
+    const expiresAt = Date.now() + deviceCode.expires_in * 1e3;
+    let interval = deviceCode.interval * 1e3;
+    while (Date.now() < expiresAt) {
+      await this.sleep(interval);
+      try {
+        const { data } = await apiClient.post(ENDPOINTS.token, {
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+          device_code: deviceCode.device_code,
+          client_id: CLIENT_ID
+        });
+        return TokenResponseSchema.parse(data);
+      } catch (error) {
+        if (this.isPollingError(error)) {
+          const errorCode = this.getErrorCode(error);
+          if (errorCode === "authorization_pending") {
+            continue;
+          }
+          if (errorCode === "slow_down") {
+            interval += 1e3;
+            continue;
+          }
+          if (errorCode === "access_denied") {
+            throw new AuthError(
+              "Authorization denied",
+              "You declined the authorization request"
+            );
+          }
+          if (errorCode === "expired_token") {
+            throw new AuthError(
+              "Authorization code expired",
+              "Please try again: question-banks login"
+            );
+          }
+        }
+        throw error;
+      }
+    }
+    throw new AuthError(
+      "Authorization timed out",
+      "Please try again: question-banks login"
+    );
+  }
+  isPollingError(error) {
+    return typeof error === "object" && error !== null && "error" in error && typeof error.error === "string";
+  }
+  getErrorCode(error) {
+    if (this.isPollingError(error)) {
+      return error.error;
+    }
+    return null;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+var deviceFlowAuth = new DeviceFlowAuth();
+var TokenManager = class {
+  cachedToken = null;
+  async save(token) {
+    await promises.mkdir(PATHS.configDir, { recursive: true });
+    const data = {
+      access_token: token.access_token,
+      refresh_token: token.refresh_token,
+      expires_at: Date.now() + token.expires_in * 1e3
+    };
+    await promises.writeFile(
+      PATHS.tokensFile,
+      JSON.stringify(data, null, 2),
+      { mode: 384 }
+      // Read/write for owner only
+    );
+    this.cachedToken = data;
+  }
+  async load() {
+    if (this.cachedToken) return this.cachedToken;
+    try {
+      const content = await promises.readFile(PATHS.tokensFile, "utf-8");
+      const parsed = JSON.parse(content);
+      this.cachedToken = StoredTokenSchema.parse(parsed);
+      return this.cachedToken;
+    } catch {
+      return null;
+    }
+  }
+  async clear() {
+    this.cachedToken = null;
+    try {
+      await promises.unlink(PATHS.tokensFile);
+    } catch {
+    }
+  }
+  async getValidToken() {
+    const token = await this.load();
+    if (!token) {
+      throw new AuthError(
+        "Not authenticated",
+        "Run: question-banks login"
+      );
+    }
+    const bufferMs = 5 * 60 * 1e3;
+    if (Date.now() < token.expires_at - bufferMs) {
+      return token.access_token;
+    }
+    return this.refreshToken(token.refresh_token);
+  }
+  async refreshToken(refreshToken) {
+    try {
+      const { data } = await apiClient.post(
+        ENDPOINTS.refresh,
+        {
+          grant_type: "refresh_token",
+          refresh_token: refreshToken
+        }
+      );
+      await this.save(data);
+      return data.access_token;
+    } catch (error) {
+      await this.clear();
+      throw new AuthError(
+        "Session expired",
+        "Please log in again: question-banks login"
+      );
+    }
+  }
+  async isAuthenticated() {
+    try {
+      await this.getValidToken();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+var tokenManager = new TokenManager();
+
+// src/commands/login.ts
+function loginCommand(program) {
+  program.command("login").description("Authenticate with Question Banks API").action(async () => {
+    try {
+      const isAuthenticated = await tokenManager.isAuthenticated();
+      if (isAuthenticated) {
+        console.log(colors.yellow("Already logged in."));
+        console.log(`Run ${colors.cyan("question-banks logout")} first to switch accounts.`);
+        return;
+      }
+      const token = await deviceFlowAuth.authenticate();
+      await tokenManager.save(token);
+      console.log("");
+      console.log(`${symbols.success} ${colors.successBold("Successfully authenticated!")}`);
+      console.log("");
+      console.log(`Run ${colors.cyan("question-banks whoami")} to verify your account.`);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/logout.ts
+function logoutCommand(program) {
+  program.command("logout").description("Clear local authentication tokens").action(async () => {
+    await tokenManager.clear();
+    console.log(`${symbols.success} ${colors.green("Logged out successfully")}`);
+  });
+}
+
+// src/commands/whoami.ts
+function whoamiCommand(program) {
+  program.command("whoami").description("Display current account information").option("--json", "Output as JSON").action(async (options) => {
+    const spin = spinners.fetching();
+    try {
+      const accessToken = await tokenManager.getValidToken();
+      const { data } = await apiClient.get(ENDPOINTS.me, {
+        headers: { Authorization: `Bearer ${accessToken}` }
+      });
+      spin.stop();
+      if (options.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+      }
+      console.log("");
+      console.log(colors.bold("Account Information"));
+      console.log(divider());
+      console.log("");
+      console.log(`${colors.dim("User:")}        ${data.user.name ?? colors.dim("(not set)")} ${colors.dim(`<${data.user.email}>`)}`);
+      console.log(`${colors.dim("Organization:")} ${data.organization.name} ${colors.dim(`(${data.organization.slug})`)}`);
+      console.log("");
+      console.log(colors.bold("Subscription"));
+      console.log(divider());
+      console.log("");
+      const planColors = {
+        free: colors.dim,
+        standard: colors.cyan,
+        premium: colors.yellow,
+        enterprise: colors.magenta
+      };
+      const planColor = planColors[data.subscription.plan] ?? colors.white;
+      console.log(`${colors.dim("Plan:")}   ${planColor(data.subscription.plan.toUpperCase())}`);
+      const statusColors = {
+        active: colors.green,
+        trialing: colors.cyan,
+        past_due: colors.red,
+        canceled: colors.dim
+      };
+      const statusColor = statusColors[data.subscription.status] ?? colors.white;
+      console.log(`${colors.dim("Status:")} ${statusColor(data.subscription.status)}`);
+      if (data.subscription.monthlyQuota) {
+        console.log(`${colors.dim("Quota:")}  ${data.subscription.monthlyQuota.toLocaleString()} requests/month`);
+      }
+      if (data.subscription.trialEndsAt) {
+        const trialEnd = new Date(data.subscription.trialEndsAt);
+        const now = /* @__PURE__ */ new Date();
+        if (trialEnd > now) {
+          const daysLeft = Math.ceil((trialEnd.getTime() - now.getTime()) / (1e3 * 60 * 60 * 24));
+          console.log(`${colors.dim("Trial:")}  ${colors.cyan(`${daysLeft} days remaining`)}`);
+        }
+      }
+      console.log("");
+    } catch (error) {
+      spin.stop();
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/usage.ts
+function usageCommand(program) {
+  program.command("usage").description("Display API usage statistics").option("--period <YYYY-MM>", "Billing period (default: current)").option("--daily", "Show daily breakdown").option("--json", "Output as JSON").action(async (options) => {
+    const spin = spinners.fetching();
+    try {
+      const accessToken = await tokenManager.getValidToken();
+      const { data } = await apiClient.get(ENDPOINTS.usage, {
+        headers: { Authorization: `Bearer ${accessToken}` },
+        params: options.period ? { period: options.period } : void 0
+      });
+      spin.stop();
+      if (options.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+      }
+      console.log("");
+      console.log(colors.bold(`Usage for ${data.period}`));
+      console.log(divider());
+      console.log("");
+      if (data.isUnlimited) {
+        console.log(`${colors.dim("Quota:")}     ${colors.cyan("Unlimited")}`);
+        console.log(`${colors.dim("Used:")}      ${data.used.toLocaleString()} requests`);
+      } else {
+        console.log(`${colors.dim("Quota:")}     ${data.quota.toLocaleString()} requests`);
+        console.log(`${colors.dim("Used:")}      ${data.used.toLocaleString()} ${colors.dim(`(${(data.used / data.quota * 100).toFixed(1)}%)`)}`);
+        console.log(`${colors.dim("Remaining:")} ${colors.green(data.remaining.toLocaleString())}`);
+        console.log("");
+        console.log(progressBar(data.used, data.quota));
+        const usagePercent = data.used / data.quota * 100;
+        if (usagePercent >= 85) {
+          console.log("");
+          console.log(`${symbols.warning} ${colors.yellow("You are at " + usagePercent.toFixed(0) + "% of your monthly limit.")}`);
+          console.log(`   Consider upgrading: ${colors.cyan("question-banks billing")}`);
+        }
+      }
+      if (Object.keys(data.breakdown).length > 0) {
+        console.log("");
+        console.log(colors.bold("Breakdown by Endpoint"));
+        console.log(divider(30));
+        const table = createTable({
+          head: ["Endpoint", "Requests", "%"],
+          colWidths: [25, 15, 10]
+        });
+        Object.entries(data.breakdown).sort(([, a], [, b]) => b - a).forEach(([endpoint, count]) => {
+          const pct = data.used > 0 ? (count / data.used * 100).toFixed(1) : "0.0";
+          table.push([endpoint, count.toLocaleString(), `${pct}%`]);
+        });
+        console.log(table.toString());
+      }
+      if (options.daily && data.dailyUsage.length > 0) {
+        console.log("");
+        console.log(colors.bold("Daily Usage"));
+        console.log(divider(30));
+        const table = createTable({
+          head: ["Date", "Requests"],
+          colWidths: [15, 15]
+        });
+        data.dailyUsage.slice(-14).reverse().forEach(({ date, count }) => {
+          table.push([date, count.toLocaleString()]);
+        });
+        console.log(table.toString());
+      }
+      console.log("");
+    } catch (error) {
+      spin.stop();
+      handleError(error);
+    }
+  });
+}
+function billingCommand(program) {
+  program.command("billing").description("Open Stripe Customer Portal to manage subscription").option("--url-only", "Print URL instead of opening browser").action(async (options) => {
+    const spin = spinners.loading();
+    spin.text("Generating billing portal URL...");
+    try {
+      const accessToken = await tokenManager.getValidToken();
+      const { data } = await apiClient.post(
+        ENDPOINTS.billingPortal,
+        {},
+        { headers: { Authorization: `Bearer ${accessToken}` } }
+      );
+      spin.stop();
+      if (options.urlOnly) {
+        console.log(data.url);
+        return;
+      }
+      console.log(`${symbols.info} Opening billing portal in your browser...`);
+      try {
+        await open(data.url);
+        console.log(`${symbols.success} ${colors.green("Billing portal opened successfully")}`);
+        console.log("");
+        console.log(colors.dim("In the portal you can:"));
+        console.log(colors.dim("  \u2022 View and download invoices"));
+        console.log(colors.dim("  \u2022 Update payment methods"));
+        console.log(colors.dim("  \u2022 Upgrade or downgrade your plan"));
+        console.log(colors.dim("  \u2022 Cancel subscription"));
+      } catch {
+        console.log(colors.yellow("Could not open browser automatically."));
+        console.log("");
+        console.log("Visit this URL to manage your billing:");
+        console.log(colors.cyan(data.url));
+      }
+      console.log("");
+    } catch (error) {
+      spin.stop();
+      handleError(error);
+    }
+  });
+}
+var OptionFeedbackSchema = z.object({
+  short: z.string(),
+  detailed: z.string(),
+  socraticHint: z.string().optional()
+});
+var OptionSchema = z.object({
+  key: z.string(),
+  // "A", "B", "C", "D"
+  text: z.string().min(1),
+  isCorrect: z.boolean(),
+  misconceptionId: z.string().optional(),
+  feedback: OptionFeedbackSchema.optional()
+});
+var QuestionSchema = z.object({
+  questionId: z.string(),
+  globalId: z.string().optional(),
+  questionNumber: z.number().optional(),
+  questionType: z.string().optional(),
+  questionTypeLabel: z.string().optional(),
+  questionArchetype: z.string().optional(),
+  prompt: z.string().min(1),
+  hasCodeBlock: z.boolean().optional(),
+  codeLanguage: z.string().nullable().optional(),
+  codeContent: z.string().nullable().optional(),
+  misconceptionTargets: z.array(z.any()).optional(),
+  options: z.array(OptionSchema).min(2).max(6),
+  correctAnswer: z.string(),
+  // "A", "B", "C", "D"
+  correctAnswerText: z.string().optional(),
+  metadata: z.any().optional(),
+  version: z.string().optional()
+});
+var LegacyQuestionSchema = z.object({
+  id: z.string(),
+  type: z.string().optional(),
+  question: z.string().min(1),
+  options: z.array(z.string()).min(2).max(6),
+  correctAnswerIndex: z.number().min(0)
+});
+var LessonSchema = z.object({
+  lessonId: z.string(),
+  lessonNumber: z.number(),
+  lessonTitle: z.string(),
+  lessonSlug: z.string().optional(),
+  totalQuestions: z.number().optional(),
+  questions: z.array(QuestionSchema)
+});
+var CourseExportSchema = z.object({
+  courseId: z.string(),
+  courseName: z.string(),
+  courseCode: z.string(),
+  domain: z.string().optional(),
+  tier: z.string().optional(),
+  difficulty: z.number().or(z.string()).optional(),
+  totalLessons: z.number().optional(),
+  totalQuestions: z.number().optional(),
+  sourceFile: z.string().optional(),
+  lessons: z.array(LessonSchema)
+});
+var SimpleQuestionsSchema = z.object({
+  questions: z.array(QuestionSchema.or(LegacyQuestionSchema))
+});
+function validateCommand(program) {
+  program.command("validate <file>").description("Validate a question JSON file (local, no API required)").option("-v, --verbose", "Show detailed validation output").action(async (file, options) => {
+    const spin = spinners.validating();
+    try {
+      try {
+        await promises.access(file);
+      } catch {
+        throw new ValidationError(
+          `File not found: ${file}`,
+          "Make sure the file path is correct"
+        );
+      }
+      const content = await promises.readFile(file, "utf-8");
+      let data;
+      try {
+        data = JSON.parse(content);
+      } catch {
+        throw new ValidationError(
+          "Invalid JSON format",
+          "The file must contain valid JSON"
+        );
+      }
+      const courseResult = CourseExportSchema.safeParse(data);
+      const simpleResult = SimpleQuestionsSchema.safeParse(data);
+      spin.stop();
+      if (courseResult.success) {
+        const course = courseResult.data;
+        let totalQuestions = 0;
+        let lessonCount = course.lessons.length;
+        course.lessons.forEach((lesson) => {
+          totalQuestions += lesson.questions.length;
+        });
+        console.log(`${symbols.success} ${colors.green(`Course validated successfully`)}`);
+        console.log("");
+        console.log(`  ${colors.bold("Course:")} ${course.courseName} (${course.courseCode})`);
+        console.log(`  ${colors.bold("Lessons:")} ${lessonCount}`);
+        console.log(`  ${colors.bold("Questions:")} ${totalQuestions}`);
+        if (options.verbose) {
+          console.log("");
+          course.lessons.forEach((lesson) => {
+            console.log(`  ${colors.green("\u2713")} Lesson ${lesson.lessonNumber}: ${lesson.questions.length} questions`);
+          });
+        }
+        console.log("");
+        return;
+      }
+      if (simpleResult.success) {
+        const count = simpleResult.data.questions.length;
+        console.log(`${symbols.success} ${colors.green(`${count}/${count} questions validated successfully`)}`);
+        if (options.verbose) {
+          console.log("");
+          simpleResult.data.questions.forEach((q, i) => {
+            const id = "questionId" in q ? q.questionId : q.id;
+            console.log(`  ${colors.green("\u2713")} Question ${i + 1}: ${colors.dim(id)}`);
+          });
+        }
+        console.log("");
+        return;
+      }
+      console.log(`${symbols.error} ${colors.red("Validation failed")}`);
+      console.log("");
+      const result = courseResult.error.issues.length <= simpleResult.error.issues.length ? courseResult : simpleResult;
+      const issues = result.error.issues.slice(0, 5);
+      issues.forEach((issue, i) => {
+        const path = issue.path.join(".");
+        console.log(`${colors.red(`Error[E${String(i + 1).padStart(3, "0")}]:`)} ${issue.message}`);
+        console.log(`  ${colors.dim("-->")} ${file}:${colors.yellow(path || "root")}`);
+        if (issue.code === "too_small" && path.includes("options")) {
+          console.log(`  ${colors.dim("Hint:")} Questions need at least 2 options`);
+        }
+        if (issue.code === "invalid_type" && path.includes("correctAnswerIndex")) {
+          console.log(`  ${colors.dim("Hint:")} correctAnswerIndex must be a number (0-based)`);
+        }
+        console.log("");
+      });
+      if (result.error.issues.length > 5) {
+        console.log(colors.dim(`... and ${result.error.issues.length - 5} more errors`));
+        console.log("");
+      }
+      console.log(colors.dim(`Learn more: https://docs.question-banks.dev/validation`));
+      process.exit(1);
+    } catch (error) {
+      spin.stop();
+      handleError(error);
+    }
+  });
+}
+function apiKeysListCommand(parent) {
+  parent.command("list").description("List all API keys").option("--json", "Output as JSON").action(async (options) => {
+    const spin = spinners.fetching();
+    try {
+      const accessToken = await tokenManager.getValidToken();
+      const { data } = await apiClient.get(ENDPOINTS.apiKeys, {
+        headers: { Authorization: `Bearer ${accessToken}` }
+      });
+      spin.stop();
+      if (options.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+      }
+      if (data.keys.length === 0) {
+        console.log("");
+        console.log(colors.yellow("No API keys found."));
+        console.log(`Create one with: ${colors.cyan("question-banks api-keys create")}`);
+        console.log("");
+        return;
+      }
+      const table = createTable({
+        head: ["Name", "Key (partial)", "Mode", "Last Used", "Status"],
+        colWidths: [20, 22, 8, 18, 10]
+      });
+      data.keys.forEach((key) => {
+        const partial = key.publicKey.slice(0, 18) + "...";
+        const lastUsed = key.lastUsedAt ? formatDistanceToNow(new Date(key.lastUsedAt), { addSuffix: true }) : colors.dim("Never");
+        const status = key.isActive ? colors.green("Active") : colors.red("Revoked");
+        const mode = key.mode === "live" ? colors.yellow("live") : colors.dim("test");
+        table.push([
+          key.name || colors.dim("(unnamed)"),
+          partial,
+          mode,
+          lastUsed,
+          status
+        ]);
+      });
+      console.log("");
+      console.log(table.toString());
+      console.log("");
+    } catch (error) {
+      spin.stop();
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/api-keys/create.ts
+function apiKeysCreateCommand(parent) {
+  parent.command("create").description("Create a new API key").option("-n, --name <name>", 'Key name (e.g., "Production API Key")').option("-m, --mode <mode>", "Key mode: test or live", "test").action(async (options) => {
+    try {
+      if (!["test", "live"].includes(options.mode)) {
+        throw new ValidationError(
+          "Invalid mode",
+          'Mode must be "test" or "live"'
+        );
+      }
+      if (options.mode === "live") {
+        console.log("");
+        console.log(`${symbols.warning} ${colors.yellow("Creating a LIVE API key")}`);
+        console.log(colors.dim("Live keys can access production data and count against your quota."));
+        console.log("");
+      }
+      const spin = spinners.saving();
+      spin.text("Creating API key...");
+      const accessToken = await tokenManager.getValidToken();
+      const { data } = await apiClient.post(
+        ENDPOINTS.apiKeys,
+        {
+          name: options.name || null,
+          mode: options.mode
+        },
+        { headers: { Authorization: `Bearer ${accessToken}` } }
+      );
+      spin.succeed("API key created successfully!");
+      console.log("");
+      console.log(divider());
+      console.log("");
+      console.log(colors.bold("Your new API key:"));
+      console.log("");
+      console.log(`  ${colors.cyan(data.secret)}`);
+      console.log("");
+      console.log(divider());
+      console.log("");
+      console.log(`${symbols.warning} ${colors.yellow("Save this key now!")}`);
+      console.log(colors.dim("This is the only time you will see the complete key."));
+      console.log("");
+      console.log(colors.bold("Quick start:"));
+      console.log("");
+      console.log(colors.dim("  // JavaScript/TypeScript"));
+      console.log(`  const client = new ValidationClient({`);
+      console.log(`    apiKey: '${data.secret.slice(0, 20)}...'`);
+      console.log(`  })`);
+      console.log("");
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+async function confirm(message) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(`${message} (y/N) `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+function apiKeysRevokeCommand(parent) {
+  parent.command("revoke <key-id>").description("Revoke an API key").option("-y, --yes", "Skip confirmation prompt").action(async (keyId, options) => {
+    try {
+      if (!options.yes) {
+        console.log("");
+        console.log(`${symbols.warning} ${colors.yellow("This action cannot be undone.")}`);
+        console.log(colors.dim("Any applications using this key will stop working immediately."));
+        console.log("");
+        const confirmed = await confirm("Are you sure you want to revoke this key?");
+        if (!confirmed) {
+          console.log(colors.dim("Cancelled."));
+          return;
+        }
+      }
+      const spin = spinners.saving();
+      spin.text("Revoking API key...");
+      const accessToken = await tokenManager.getValidToken();
+      await apiClient.delete(ENDPOINTS.apiKeyById(keyId), {
+        headers: { Authorization: `Bearer ${accessToken}` }
+      });
+      spin.succeed("API key revoked successfully");
+      console.log("");
+      console.log(colors.dim("The key can no longer be used to access the API."));
+      console.log("");
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/api-keys/rotate.ts
+function apiKeysRotateCommand(parent) {
+  parent.command("rotate <key-id>").description("Rotate an API key (creates new key, old key remains valid for grace period)").option("-g, --grace <duration>", "Grace period for old key (e.g., 24h, 7d)", "24h").action(async (keyId, options) => {
+    try {
+      const gracePeriod = parseGracePeriod(options.grace);
+      if (!gracePeriod) {
+        throw new ValidationError(
+          "Invalid grace period format",
+          "Use formats like: 1h, 24h, 7d, 30d"
+        );
+      }
+      console.log("");
+      console.log(`${symbols.info} ${colors.cyan("Rotating API key...")}`);
+      console.log(colors.dim(`Old key will remain valid for ${options.grace}`));
+      console.log("");
+      const spin = spinners.saving();
+      spin.text("Generating new key...");
+      const accessToken = await tokenManager.getValidToken();
+      const { data } = await apiClient.post(
+        ENDPOINTS.rotateKey(keyId),
+        { gracePeriod },
+        { headers: { Authorization: `Bearer ${accessToken}` } }
+      );
+      spin.succeed("API key rotated successfully!");
+      console.log("");
+      console.log(divider());
+      console.log("");
+      console.log(colors.bold("Your new API key:"));
+      console.log("");
+      console.log(`  ${colors.cyan(data.secret)}`);
+      console.log("");
+      console.log(divider());
+      console.log("");
+      console.log(`${symbols.warning} ${colors.yellow("Save this key now!")}`);
+      console.log(colors.dim("This is the only time you will see the complete key."));
+      console.log("");
+      console.log(`${symbols.info} Old key expires: ${colors.yellow(new Date(data.oldKeyExpiresAt).toLocaleString())}`);
+      console.log(colors.dim("Update your applications before the old key expires."));
+      console.log("");
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+function parseGracePeriod(duration) {
+  const match = duration.match(/^(\d+)(h|d)$/);
+  if (!match) return null;
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  if (unit === "h") return value * 60 * 60 * 1e3;
+  if (unit === "d") return value * 24 * 60 * 60 * 1e3;
+  return null;
+}
+
+// src/index.ts
+var VERSION = "1.0.0";
+function createCLI() {
+  const program = new Command();
+  program.name("question-banks").description("CLI tool for Question Banks API - authentication, API keys, usage, billing").version(VERSION, "-v, --version", "Display version number").helpOption("-h, --help", "Display help information");
+  loginCommand(program);
+  logoutCommand(program);
+  whoamiCommand(program);
+  usageCommand(program);
+  billingCommand(program);
+  validateCommand(program);
+  const apiKeys = program.command("api-keys").description("Manage API keys").alias("keys");
+  apiKeysListCommand(apiKeys);
+  apiKeysCreateCommand(apiKeys);
+  apiKeysRevokeCommand(apiKeys);
+  apiKeysRotateCommand(apiKeys);
+  program.addHelpText("after", `
+${pc.bold("Examples:")}
+  $ question-banks login          ${pc.dim("# Authenticate with Question Banks API")}
+  $ question-banks whoami         ${pc.dim("# Show account information")}
+  $ question-banks usage          ${pc.dim("# Display API usage statistics")}
+  $ question-banks api-keys list  ${pc.dim("# List all API keys")}
+  $ question-banks billing        ${pc.dim("# Open Stripe billing portal")}
+  $ question-banks validate file.json  ${pc.dim("# Validate questions locally")}
+
+${pc.bold("Documentation:")}
+  https://docs.question-banks.dev
+`);
+  return program;
+}
+async function run() {
+  setupErrorHandlers();
+  const program = createCLI();
+  await program.parseAsync(process.argv);
+}
+run();
+
+export { createCLI, run };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map