ckweb-cli 0.2.0

package/dist/index.js

@@ -0,0 +1,2345 @@
+#!/usr/bin/env node
+
+// src/lib/env-resolver.ts
+import * as fs from "fs";
+import * as path from "path";
+var ENV_USER_KEY = "CKWEB_API_KEY";
+var ENV_ADMIN_KEY = "CKWEB_ADMIN_API_KEY";
+var ENV_BASE_URL = "CKWEB_API_URL";
+var DOTENV_VALUES = {};
+var DOTENV_FILES = [".env.local", ".env"];
+function parseDotenv(src) {
+  const out = {};
+  for (const rawLine of src.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq).trim();
+    let value = line.slice(eq + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    } else {
+      const hash = value.indexOf(" #");
+      if (hash >= 0) value = value.slice(0, hash).trim();
+    }
+    if (key) out[key] = value;
+  }
+  return out;
+}
+function loadDotenvFiles(cwd = process.cwd()) {
+  for (const file of DOTENV_FILES) {
+    const full = path.join(cwd, file);
+    if (!fs.existsSync(full)) continue;
+    try {
+      const parsed = parseDotenv(fs.readFileSync(full, "utf8"));
+      for (const [k, v] of Object.entries(parsed)) {
+        if (!(k in DOTENV_VALUES)) DOTENV_VALUES[k] = v;
+      }
+    } catch {
+    }
+  }
+}
+function resolveOsEnv(name) {
+  const v = process.env[name];
+  return v !== void 0 && v !== "" ? v : void 0;
+}
+function resolveDotenv(name) {
+  const v = DOTENV_VALUES[name];
+  return v !== void 0 && v !== "" ? v : void 0;
+}
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/lib/errors.ts
+import chalk from "chalk";
+var CliError = class extends Error {
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "CliError";
+  }
+};
+var AuthError = class extends CliError {
+  constructor(message = "Authentication required. Run: ckweb auth login") {
+    super(message, 1);
+    this.name = "AuthError";
+  }
+};
+var ApiError = class extends CliError {
+  constructor(message, statusCode, code) {
+    super(message, 1);
+    this.statusCode = statusCode;
+    this.code = code;
+    this.name = "ApiError";
+  }
+};
+var NetworkError = class extends CliError {
+  constructor(message = "Network error. Check your connection.") {
+    super(message, 1);
+    this.name = "NetworkError";
+  }
+};
+function validateId(id, label = "ID") {
+  if (!/^[\w-]+$/.test(id)) {
+    throw new CliError(`Invalid ${label}: "${id}"`);
+  }
+}
+function handleError(err) {
+  if (err instanceof AuthError) {
+    console.error(chalk.yellow(`Auth: ${err.message}`));
+    process.exit(err.exitCode);
+  }
+  if (err instanceof ApiError) {
+    console.error(chalk.red(`API Error (${err.statusCode}): ${err.message}`));
+    if (err.code) console.error(chalk.dim(`Code: ${err.code}`));
+    process.exit(err.exitCode);
+  }
+  if (err instanceof NetworkError) {
+    console.error(chalk.red(`Network: ${err.message}`));
+    process.exit(err.exitCode);
+  }
+  if (err instanceof CliError) {
+    console.error(chalk.red(err.message));
+    process.exit(err.exitCode);
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(chalk.red(`Error: ${message}`));
+  process.exit(1);
+}
+
+// src/commands/auth.ts
+import chalk3 from "chalk";
+import * as readline from "readline/promises";
+
+// src/lib/config.ts
+import Conf from "conf";
+var DEFAULT_BASE_URL = "https://claudekit.cc/api";
+var USER_KEY_PATTERN = /^ck_live_[a-zA-Z0-9]{32,}$/;
+var ADMIN_KEY_PATTERN = /^ck_admin_[a-zA-Z0-9]{32,}$/;
+function resolveKey(envName, pattern, stored) {
+  const os = resolveOsEnv(envName);
+  if (os && pattern.test(os)) return os;
+  const cfg = stored();
+  if (cfg) return cfg;
+  const dot = resolveDotenv(envName);
+  if (dot && pattern.test(dot)) return dot;
+  return void 0;
+}
+var config = new Conf({
+  projectName: "ckweb-cli",
+  schema: {
+    apiKey: { type: "string" },
+    adminApiKey: { type: "string" },
+    baseUrl: { type: "string" }
+  }
+});
+function getApiKey() {
+  return resolveKey(ENV_USER_KEY, USER_KEY_PATTERN, () => config.get("apiKey"));
+}
+function setApiKey(key) {
+  if (!USER_KEY_PATTERN.test(key)) {
+    throw new Error("Invalid API key format. Expected: ck_live_<32+ chars>");
+  }
+  config.set("apiKey", key);
+}
+function clearApiKey() {
+  config.delete("apiKey");
+}
+function getAdminApiKey() {
+  return resolveKey(ENV_ADMIN_KEY, ADMIN_KEY_PATTERN, () => config.get("adminApiKey"));
+}
+function setAdminApiKey(key) {
+  if (!ADMIN_KEY_PATTERN.test(key)) {
+    throw new Error("Invalid admin API key format. Expected: ck_admin_<32+ chars>");
+  }
+  config.set("adminApiKey", key);
+}
+function clearAdminApiKey() {
+  config.delete("adminApiKey");
+}
+function getBaseUrl() {
+  return resolveOsEnv(ENV_BASE_URL) || config.get("baseUrl") || resolveDotenv(ENV_BASE_URL) || DEFAULT_BASE_URL;
+}
+function maskApiKey(key) {
+  if (key.length < 12) return "****";
+  return `${key.slice(0, 8)}****${key.slice(-4)}`;
+}
+function getConfigPath() {
+  return config.path;
+}
+
+// src/lib/api-client.ts
+var DEFAULT_TIMEOUT = 3e4;
+async function fetchApi(method, path2, options = {}) {
+  const { body, params, timeout = DEFAULT_TIMEOUT, noAuth = false, adminAuth = false } = options;
+  let apiKey;
+  if (!noAuth) {
+    if (adminAuth) {
+      apiKey = getAdminApiKey();
+      if (!apiKey) {
+        throw new AuthError("Admin authentication required. Run: ckweb auth login --admin");
+      }
+    } else {
+      apiKey = getApiKey();
+      if (!apiKey) {
+        throw new AuthError();
+      }
+    }
+  }
+  const baseUrl = getBaseUrl().replace(/\/?$/, "/");
+  const url = new URL(path2.replace(/^\//, ""), baseUrl);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      url.searchParams.set(key, value);
+    }
+  }
+  const headers = {
+    "Content-Type": "application/json",
+    "User-Agent": "ckweb-cli/0.1.0"
+  };
+  if (apiKey) {
+    headers["x-api-key"] = apiKey;
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url.toString(), {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0,
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    const contentType = response.headers.get("content-type") || "";
+    let data;
+    if (contentType.includes("application/json")) {
+      data = await response.json();
+    } else {
+      data = await response.text();
+    }
+    if (!response.ok) {
+      const errorBody = data;
+      const message = errorBody?.error || errorBody?.message || `HTTP ${response.status}`;
+      const code = errorBody?.code;
+      if (response.status === 401 || response.status === 403) {
+        throw new AuthError(message);
+      }
+      throw new ApiError(message, response.status, code);
+    }
+    return data;
+  } catch (err) {
+    clearTimeout(timer);
+    if (err instanceof AuthError || err instanceof ApiError) {
+      throw err;
+    }
+    if (err instanceof DOMException && err.name === "AbortError") {
+      throw new NetworkError(`Request timed out after ${timeout / 1e3}s`);
+    }
+    if (err instanceof TypeError) {
+      throw new NetworkError();
+    }
+    throw err;
+  }
+}
+
+// src/lib/output.ts
+import chalk2 from "chalk";
+function getOutputOpts(cmd) {
+  const opts = cmd.optsWithGlobals();
+  return { json: opts.json, table: opts.table, quiet: opts.quiet };
+}
+function formatOutput(data, options, tableColumns) {
+  if (options.quiet) {
+    printQuiet(data);
+    return;
+  }
+  if (options.json) {
+    printJson(data);
+    return;
+  }
+  if (Array.isArray(data) && tableColumns) {
+    printTable(data, tableColumns);
+    return;
+  }
+  if (options.table && data && typeof data === "object" && !Array.isArray(data)) {
+    const obj = data;
+    const rows = Object.entries(obj).map(([key, value]) => ({
+      key,
+      value: typeof value === "object" ? JSON.stringify(value) : String(value ?? "\u2014")
+    }));
+    printTable(rows, [
+      { key: "key", header: "Field", width: 20 },
+      { key: "value", header: "Value", width: 50 }
+    ]);
+    return;
+  }
+  printJson(data);
+}
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function printTable(rows, columns) {
+  if (rows.length === 0) {
+    console.log(chalk2.dim("No results."));
+    return;
+  }
+  const widths = columns.map((col) => {
+    const headerLen = col.header.length;
+    const maxDataLen = rows.reduce((max, row) => {
+      const val = String(row[col.key] ?? "");
+      return Math.max(max, val.length);
+    }, 0);
+    return col.width || Math.min(Math.max(headerLen, maxDataLen) + 2, 50);
+  });
+  const headerLine = columns.map((col, i) => col.header.padEnd(widths[i])).join("  ");
+  console.log(chalk2.bold(headerLine));
+  console.log(chalk2.dim("\u2500".repeat(headerLine.length)));
+  for (const row of rows) {
+    const line = columns.map((col, i) => {
+      const val = String(row[col.key] ?? "\u2014");
+      return val.length > widths[i] ? val.slice(0, widths[i] - 1) + "\u2026" : val.padEnd(widths[i]);
+    }).join("  ");
+    console.log(line);
+  }
+  console.log(chalk2.dim(`
+${rows.length} result(s)`));
+}
+function printQuiet(data) {
+  if (data === null || data === void 0) return;
+  if (typeof data === "string" || typeof data === "number" || typeof data === "boolean") {
+    console.log(String(data));
+    return;
+  }
+  if (Array.isArray(data)) {
+    console.log(String(data.length));
+    return;
+  }
+  if (typeof data === "object") {
+    const obj = data;
+    const firstKey = Object.keys(obj)[0];
+    if (firstKey) {
+      console.log(String(obj[firstKey]));
+    }
+  }
+}
+function printSuccess(message) {
+  console.log(chalk2.green(`\u2713 ${message}`));
+}
+function printInfo(message) {
+  console.log(chalk2.blue(`\u2139 ${message}`));
+}
+function printWarn(message) {
+  console.log(chalk2.yellow(`\u26A0 ${message}`));
+}
+
+// src/commands/auth.ts
+function ensureAuth() {
+  const key = getApiKey();
+  if (!key) throw new AuthError();
+  return key;
+}
+function ensureAdminAuth() {
+  const key = getAdminApiKey();
+  if (!key) throw new AuthError("Admin authentication required. Run: ckweb auth login --admin");
+  return key;
+}
+async function promptApiKey(isAdmin) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const prefix = isAdmin ? "ck_admin_" : "ck_live_";
+    return (await rl.question(chalk3.cyan(`Enter your API key (${prefix}...): `))).trim();
+  } finally {
+    rl.close();
+  }
+}
+function registerAuthCommand(program2) {
+  const auth = program2.command("auth").description("Manage authentication");
+  auth.command("login").description("Authenticate with your ClaudeKit API key").option("--admin", "Login with admin API key").action(async function() {
+    try {
+      const isAdmin = this.opts().admin === true;
+      const key = await promptApiKey(isAdmin);
+      if (!key) {
+        printWarn("No API key provided.");
+        return;
+      }
+      printInfo("Validating API key...");
+      try {
+        if (isAdmin) {
+          setAdminApiKey(key);
+        } else {
+          setApiKey(key);
+        }
+      } catch {
+        const expected = isAdmin ? "ck_admin_<32+ chars>" : "ck_live_<32+ chars>";
+        printWarn(`Invalid key format. Expected: ${expected}`);
+        return;
+      }
+      try {
+        const result = await fetchApi("POST", "/keys/validate", {
+          adminAuth: isAdmin
+        });
+        if (result.valid) {
+          printSuccess(`Authenticated! Key: ${maskApiKey(key)}`);
+          printInfo(`Config saved to: ${getConfigPath()}`);
+        } else {
+          if (isAdmin) clearAdminApiKey();
+          else clearApiKey();
+          printWarn(result.error || "Invalid API key.");
+        }
+      } catch {
+        if (isAdmin) clearAdminApiKey();
+        else clearApiKey();
+        throw new AuthError("API key validation failed. Check your key and try again.");
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  auth.command("validate").description("Validate stored API key").option("--admin", "Validate admin API key").action(async function() {
+    try {
+      const isAdmin = this.opts().admin === true;
+      const key = isAdmin ? ensureAdminAuth() : ensureAuth();
+      printInfo(`Validating ${isAdmin ? "admin " : ""}key: ${maskApiKey(key)}`);
+      const result = await fetchApi("POST", "/keys/validate", {
+        adminAuth: isAdmin
+      });
+      if (result.valid) {
+        printSuccess("API key is valid.");
+        if (result.userId) console.log(chalk3.dim(`User ID: ${result.userId}`));
+        if (result.rateLimit) console.log(chalk3.dim(`Rate limit: ${result.rateLimit} req/hour`));
+      } else {
+        printWarn(result.error || "API key is invalid or expired.");
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  auth.command("logout").description("Remove stored API key").option("--admin", "Remove admin API key").option("--all", "Remove all stored keys").action(function() {
+    try {
+      const opts = this.opts();
+      if (opts.all) {
+        clearApiKey();
+        clearAdminApiKey();
+        printSuccess("All API keys removed.");
+        return;
+      }
+      if (opts.admin) {
+        if (!getAdminApiKey()) {
+          printInfo("No admin API key stored.");
+          return;
+        }
+        clearAdminApiKey();
+        printSuccess("Admin API key removed.");
+      } else {
+        if (!getApiKey()) {
+          printInfo("No API key stored.");
+          return;
+        }
+        clearApiKey();
+        printSuccess("API key removed.");
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  auth.command("status").description("Show authentication status").action(() => {
+    try {
+      const userKey = getApiKey();
+      const adminKey = getAdminApiKey();
+      const userSource = resolveOsEnv(ENV_USER_KEY) ? `env:${ENV_USER_KEY}` : resolveDotenv(ENV_USER_KEY) ? `.env` : userKey ? "config" : null;
+      const adminSource = resolveOsEnv(ENV_ADMIN_KEY) ? `env:${ENV_ADMIN_KEY}` : resolveDotenv(ENV_ADMIN_KEY) ? `.env` : adminKey ? "config" : null;
+      console.log(chalk3.bold("Authentication Status"));
+      console.log(
+        `  User key:  ${userKey ? chalk3.green(maskApiKey(userKey)) : chalk3.dim("not set")}` + (userSource ? chalk3.dim(`  (from ${userSource})`) : "")
+      );
+      console.log(
+        `  Admin key: ${adminKey ? chalk3.green(maskApiKey(adminKey)) : chalk3.dim("not set")}` + (adminSource ? chalk3.dim(`  (from ${adminSource})`) : "")
+      );
+      console.log(chalk3.dim(`  Config: ${getConfigPath()}`));
+      console.log(chalk3.dim(`  Resolution: OS env > stored config > .env.*`));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/youtube.ts
+var PROXY_BASE = "/proxy/vidcap/v1/youtube";
+var SEARCH_COLUMNS = [
+  { key: "title", header: "Title", width: 40 },
+  { key: "channel", header: "Channel", width: 20 },
+  { key: "videoId", header: "Video ID", width: 14 }
+];
+var COMMENT_COLUMNS = [
+  { key: "author", header: "Author", width: 20 },
+  { key: "text", header: "Comment", width: 50 },
+  { key: "likes", header: "Likes", width: 8 }
+];
+async function youtubeGet(endpoint, params) {
+  return fetchApi("GET", `${PROXY_BASE}/${endpoint}`, { params });
+}
+function registerYoutubeCommand(program2) {
+  const yt = program2.command("youtube").alias("yt").description("YouTube video tools (via VidCap)");
+  yt.command("info").argument("<url>", "YouTube video URL").description("Get video metadata").action(async function(url) {
+    try {
+      ensureAuth();
+      const data = await youtubeGet("info", { url });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  yt.command("caption").argument("<url>", "YouTube video URL").description("Get video transcript/captions").option("-l, --locale <locale>", "Caption language", "en").option("-f, --format <format>", "Output format (json3/vtt/srt)", "vtt").action(async function(url) {
+    try {
+      ensureAuth();
+      const opts = this.opts();
+      const data = await youtubeGet("caption", {
+        url,
+        locale: opts.locale,
+        ext: opts.format
+      });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  yt.command("summary").argument("<url>", "YouTube video URL").description("Get AI-generated video summary").option("-l, --locale <locale>", "Summary language", "en").action(async function(url) {
+    try {
+      ensureAuth();
+      const opts = this.opts();
+      const data = await youtubeGet("summary", { url, locale: opts.locale });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  yt.command("screenshot").argument("<url>", "YouTube video URL").description("Get video screenshot at timestamp").option("-t, --time <seconds>", "Timestamp in seconds", "0").action(async function(url) {
+    try {
+      ensureAuth();
+      const opts = this.opts();
+      const data = await youtubeGet("screenshot", { url, second: opts.time });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  yt.command("search").argument("<query>", "Search query").description("Search YouTube videos").option("-n, --max-results <count>", "Max results", "10").option("--order <order>", "Sort order (relevance/date/rating/viewCount)", "relevance").action(async function(query) {
+    try {
+      ensureAuth();
+      const opts = this.opts();
+      const data = await youtubeGet("search", {
+        query,
+        maxResults: opts.maxResults,
+        order: opts.order
+      });
+      formatOutput(data, getOutputOpts(this), SEARCH_COLUMNS);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  yt.command("comments").argument("<url>", "YouTube video URL").description("Get video comments").option("--order <order>", "Sort order (time/relevance)", "relevance").option("--replies", "Include replies", false).action(async function(url) {
+    try {
+      ensureAuth();
+      const opts = this.opts();
+      const data = await youtubeGet("comments", {
+        url,
+        order: opts.order,
+        includeReplies: String(opts.replies)
+      });
+      formatOutput(data, getOutputOpts(this), COMMENT_COLUMNS);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/web.ts
+import { readFileSync as readFileSync2 } from "fs";
+var PROXY_BASE2 = "/proxy/reviewweb/v1";
+async function webPost(endpoint, body) {
+  return fetchApi("POST", `${PROXY_BASE2}/${endpoint}`, { body });
+}
+function registerWebCommand(program2) {
+  const web = program2.command("web").description("Website analysis tools (via ReviewWeb)");
+  web.command("review").argument("<url>", "Website URL to review").description("Comprehensive website analysis").action(async function(url) {
+    try {
+      ensureAuth();
+      const data = await webPost("review", { url });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  web.command("scrape").argument("<url>", "URL to scrape").description("Extract HTML content from URL").action(async function(url) {
+    try {
+      ensureAuth();
+      const data = await webPost("scrape", { url });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  web.command("extract").argument("<url>", "URL to extract data from").description("Extract structured data using AI").requiredOption("-i, --instructions <text>", "Extraction instructions").requiredOption("-t, --template <json>", "JSON template (string or @filepath)").action(async function(url) {
+    try {
+      ensureAuth();
+      const opts = this.opts();
+      let jsonTemplate = opts.template;
+      if (jsonTemplate.startsWith("@")) {
+        const filePath = jsonTemplate.slice(1);
+        jsonTemplate = readFileSync2(filePath, "utf-8");
+      }
+      try {
+        JSON.parse(jsonTemplate);
+      } catch {
+        console.error("Invalid JSON template. Provide valid JSON or @filepath.");
+        process.exit(1);
+      }
+      const data = await webPost("extract", {
+        url,
+        instructions: opts.instructions,
+        jsonTemplate
+      });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  web.command("convert").argument("<url>", "URL to convert").description("Convert webpage to Markdown").action(async function(url) {
+    try {
+      ensureAuth();
+      const data = await webPost("convert/markdown", { url });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  web.command("summarize").argument("<url>", "URL to summarize").description("AI-generated page summary").action(async function(url) {
+    try {
+      ensureAuth();
+      const data = await webPost("summarize/url", { url });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  web.command("screenshot").argument("<url>", "URL to screenshot").description("Capture webpage screenshot").action(async function(url) {
+    try {
+      ensureAuth();
+      const data = await webPost("screenshot", { url });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/seo.ts
+var PROXY_BASE3 = "/proxy/reviewweb/v1/seo-insights";
+var KEYWORD_COLUMNS = [
+  { key: "keyword", header: "Keyword", width: 30 },
+  { key: "volume", header: "Volume", width: 10 },
+  { key: "competition", header: "Competition", width: 14 }
+];
+async function seoPost(endpoint, body) {
+  return fetchApi("POST", `${PROXY_BASE3}/${endpoint}`, { body });
+}
+function registerSeoCommand(program2) {
+  const seo = program2.command("seo").description("SEO analysis tools");
+  seo.command("keywords").argument("<keyword>", "Seed keyword").description("Get keyword ideas and search volume").option("--country <code>", "Country code", "us").action(async function(keyword) {
+    try {
+      ensureAuth();
+      const opts = this.opts();
+      const data = await seoPost("keyword-ideas", {
+        keyword,
+        country: opts.country
+      });
+      formatOutput(data, getOutputOpts(this), KEYWORD_COLUMNS);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  seo.command("difficulty").argument("<keyword>", "Keyword to check").description("Check keyword ranking difficulty").option("--country <code>", "Country code", "us").action(async function(keyword) {
+    try {
+      ensureAuth();
+      const opts = this.opts();
+      const data = await seoPost("keyword-difficulty", {
+        keyword,
+        country: opts.country
+      });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  seo.command("traffic").argument("<domain>", "Domain or URL to check").description("Check traffic for a domain").option("--country <code>", "Country code").action(async function(domain) {
+    try {
+      ensureAuth();
+      const opts = this.opts();
+      const body = { domainOrUrl: domain };
+      if (opts.country) body.country = opts.country;
+      const data = await seoPost("traffic", body);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  seo.command("backlinks").argument("<domain>", "Domain to check").description("Get backlink analysis").action(async function(domain) {
+    try {
+      ensureAuth();
+      const data = await seoPost("backlinks", { domain });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/orders.ts
+var ORDER_COLUMNS = [
+  { key: "id", header: "ID", width: 12 },
+  { key: "productType", header: "Product", width: 16 },
+  { key: "status", header: "Status", width: 12 },
+  { key: "amount", header: "Amount", width: 10 },
+  { key: "currency", header: "Currency", width: 8 },
+  { key: "createdAt", header: "Created", width: 22 }
+];
+function registerOrdersCommand(program2) {
+  const orders = program2.command("orders").description("Look up orders and purchases");
+  orders.command("get").argument("<id>", "Order ID").description("Get order details").action(async function(id) {
+    try {
+      validateId(id, "order ID");
+      const data = await fetchApi("GET", `/orders/${id}`, { noAuth: true });
+      formatOutput(data, getOutputOpts(this), ORDER_COLUMNS);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  orders.command("status").argument("<id>", "Order ID").description("Check order status").action(async function(id) {
+    try {
+      validateId(id, "order ID");
+      const data = await fetchApi("GET", `/orders/${id}/status`, { noAuth: true });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/referrals.ts
+var PAYOUT_COLUMNS = [
+  { key: "id", header: "ID", width: 12 },
+  { key: "amount", header: "Amount", width: 10 },
+  { key: "currency", header: "Currency", width: 8 },
+  { key: "status", header: "Status", width: 12 },
+  { key: "createdAt", header: "Created", width: 22 }
+];
+function registerReferralsCommand(program2) {
+  const referrals = program2.command("referrals").description("Referral program management");
+  referrals.command("dashboard").description("View your referral dashboard").action(async function() {
+    try {
+      ensureAuth();
+      const data = await fetchApi("GET", "/referrals/dashboard");
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  referrals.command("payout-history").description("View your payout request history").action(async function() {
+    try {
+      ensureAuth();
+      const data = await fetchApi("GET", "/referrals/request-payout");
+      formatOutput(data, getOutputOpts(this), PAYOUT_COLUMNS);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  referrals.command("request-payout").description("Request a referral payout").action(async function() {
+    try {
+      ensureAuth();
+      const data = await fetchApi("POST", "/referrals/request-payout");
+      printSuccess("Payout requested.");
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/blog.ts
+var ARTICLE_COLUMNS = [
+  { key: "id", header: "ID", width: 12 },
+  { key: "title", header: "Title", width: 36 },
+  { key: "status", header: "Status", width: 12 },
+  { key: "createdAt", header: "Created", width: 22 }
+];
+function registerBlogCommand(program2) {
+  const blog = program2.command("blog").description("Browse blog articles");
+  blog.command("list").description("List blog articles").action(async function() {
+    try {
+      const data = await fetchApi("GET", "/blog/articles", { noAuth: true });
+      formatOutput(data, getOutputOpts(this), ARTICLE_COLUMNS);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  blog.command("get").argument("<id>", "Article ID").description("Get article details").action(async function(id) {
+    try {
+      validateId(id, "article ID");
+      const data = await fetchApi("GET", `/blog/articles/${id}`, { noAuth: true });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/health.ts
+import chalk4 from "chalk";
+function registerHealthCommand(program2) {
+  program2.command("health").description("Check ClaudeKit.cc API health").action(async function() {
+    try {
+      const data = await fetchApi("GET", "/health", { noAuth: true });
+      const outputOpts = getOutputOpts(this);
+      if (outputOpts.json || outputOpts.quiet) {
+        formatOutput(data, outputOpts);
+      } else {
+        printSuccess("ClaudeKit.cc API is healthy.");
+        if (data.version) console.log(chalk4.dim(`Version: ${data.version}`));
+        if (data.uptime) console.log(chalk4.dim(`Uptime: ${data.uptime}`));
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/account.ts
+import * as readline2 from "readline/promises";
+function registerAccountCommand(program2) {
+  const account = program2.command("account").description("Account management");
+  account.command("export-data").description("Export your personal data (GDPR)").action(async function() {
+    try {
+      ensureAuth();
+      const data = await fetchApi("GET", "/gdpr/export-data");
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  account.command("delete").description("Delete your account permanently (GDPR)").option("--reason <text>", "Reason for account deletion").action(async function() {
+    try {
+      ensureAuth();
+      const { reason } = this.opts();
+      const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await rl.question(
+        'This action is irreversible. Type "DELETE_MY_ACCOUNT" to confirm: '
+      );
+      rl.close();
+      if (answer.trim() !== "DELETE_MY_ACCOUNT") {
+        printWarn("Cancelled. Account was not deleted.");
+        return;
+      }
+      await fetchApi("POST", "/gdpr/delete-account", {
+        body: { confirmation: "DELETE_MY_ACCOUNT", reason }
+      });
+      printSuccess("Account deletion request submitted.");
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/checkout.ts
+function addCheckoutOptions(cmd) {
+  return cmd.requiredOption("--email <email>", "Customer email").requiredOption("--product <type>", "Product type").option("--name <name>", "Customer name").option("--github <username>", "GitHub username").option("--referral <code>", "Referral code").option("--coupon <code>", "Coupon code");
+}
+function buildCheckoutBody(opts) {
+  return {
+    email: opts.email,
+    name: opts.name,
+    productType: opts.product,
+    githubUsername: opts.github,
+    referralCode: opts.referral,
+    couponCode: opts.coupon
+  };
+}
+function registerCheckoutCommand(program2) {
+  const checkout = program2.command("checkout").description("Create payment checkout");
+  addCheckoutOptions(
+    checkout.command("polar").description("Create a Polar checkout session")
+  ).action(async function() {
+    try {
+      const data = await fetchApi("POST", "/checkout/polar", {
+        noAuth: true,
+        body: buildCheckoutBody(this.opts())
+      });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  addCheckoutOptions(
+    checkout.command("sepay").description("Create a SePay checkout session")
+  ).action(async function() {
+    try {
+      const data = await fetchApi("POST", "/checkout/sepay", {
+        noAuth: true,
+        body: buildCheckoutBody(this.opts())
+      });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/github.ts
+import * as readline3 from "readline/promises";
+function registerGithubCommand(program2) {
+  const github = program2.command("github").description("GitHub repository access");
+  github.command("invite").description("Grant GitHub repository access via license").requiredOption("--license <id>", "License ID").action(async function() {
+    try {
+      ensureAuth();
+      const { license } = this.opts();
+      const data = await fetchApi("POST", "/github/invite", {
+        body: { licenseId: license }
+      });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  github.command("revoke").description("Revoke GitHub repository access via license").requiredOption("--license <id>", "License ID").action(async function() {
+    try {
+      ensureAuth();
+      const { license } = this.opts();
+      const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await rl.question(`Revoke GitHub access for license "${license}"? (y/N): `);
+      rl.close();
+      if (answer.toLowerCase() !== "y") {
+        printWarn("Cancelled.");
+        return;
+      }
+      const data = await fetchApi("POST", "/github/revoke", {
+        body: { licenseId: license }
+      });
+      formatOutput(data, getOutputOpts(this));
+      printSuccess("GitHub access revoked.");
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/loyalty.ts
+function registerLoyaltyCommand(program2) {
+  const loyalty = program2.command("loyalty").description("Loyalty program");
+  loyalty.command("eligibility").description("Check your loyalty program eligibility").action(async function() {
+    try {
+      ensureAuth();
+      const data = await fetchApi("GET", "/loyalty/eligibility");
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/newsletter.ts
+function registerNewsletterCommand(program2) {
+  const newsletter = program2.command("newsletter").description("Newsletter subscription");
+  newsletter.command("subscribe").description("Subscribe an email to the newsletter").requiredOption("--email <email>", "Email address to subscribe").action(async function() {
+    try {
+      const { email } = this.opts();
+      const data = await fetchApi("POST", "/newsletter/subscribe", {
+        noAuth: true,
+        body: { email }
+      });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  newsletter.command("unsubscribe").description("Unsubscribe from the newsletter using a token").requiredOption("--token <token>", "Unsubscribe token from email").action(async function() {
+    try {
+      const { token } = this.opts();
+      const data = await fetchApi("POST", "/newsletter/unsubscribe", {
+        noAuth: true,
+        body: { token }
+      });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/payout.ts
+import * as readline4 from "readline/promises";
+var PAYOUT_PROFILE_COLUMNS = [
+  { key: "id", header: "ID", width: 36 },
+  { key: "paymentMethod", header: "Method", width: 20 },
+  { key: "createdAt", header: "Created At", width: 24 }
+];
+function registerPayoutCommand(program2) {
+  const payout = program2.command("payout").description("Payout profile management");
+  payout.command("profile").description("List your payout profiles").action(async function() {
+    try {
+      ensureAuth();
+      const data = await fetchApi("GET", "/payout/profile");
+      formatOutput(data, getOutputOpts(this), PAYOUT_PROFILE_COLUMNS);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  payout.command("create-profile").description("Create a new payout profile").requiredOption("--method <method>", "Payment method (e.g. bank_transfer, paypal)").requiredOption("--details <json>", "Payment details as JSON string").action(async function() {
+    try {
+      ensureAuth();
+      const { method, details } = this.opts();
+      let paymentDetails;
+      try {
+        paymentDetails = JSON.parse(details);
+      } catch {
+        throw new CliError("--details must be valid JSON.");
+      }
+      const data = await fetchApi("POST", "/payout/profile", {
+        body: { paymentMethod: method, paymentDetails }
+      });
+      formatOutput(data, getOutputOpts(this));
+      printSuccess("Payout profile created.");
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  payout.command("delete-profile").description("Delete a payout profile").requiredOption("--id <id>", "Payout profile ID to delete").action(async function() {
+    try {
+      ensureAuth();
+      const { id } = this.opts();
+      const rl = readline4.createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await rl.question(`Delete payout profile "${id}"? (y/N): `);
+      rl.close();
+      if (answer.toLowerCase() !== "y") {
+        printWarn("Cancelled.");
+        return;
+      }
+      await fetchApi("DELETE", "/payout/profile", { params: { id } });
+      printSuccess("Payout profile deleted.");
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/pricing.ts
+function registerPricingCommand(program2) {
+  const pricing = program2.command("pricing").description("Pricing and promotions");
+  pricing.command("validate-discount <code>").description("Validate a discount code").action(async function(code) {
+    try {
+      const data = await fetchApi("POST", "/discounts/validate", {
+        noAuth: true,
+        body: { code }
+      });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  pricing.command("exchange-rate").description("Get current exchange rate").action(async function() {
+    try {
+      const data = await fetchApi("GET", "/exchange-rate", { noAuth: true });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  pricing.command("early-access").description("Get early access promotion status").action(async function() {
+    try {
+      const data = await fetchApi("GET", "/promotions/early-access", {
+        noAuth: true
+      });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/refunds.ts
+import * as readline5 from "readline/promises";
+function registerRefundsCommand(program2) {
+  const refunds = program2.command("refunds").description("Refund management");
+  refunds.command("request <orderId>").description("Request a refund for an order").requiredOption("--reason <text>", "Reason for refund request").option("--bank-details <json>", "Bank transfer details as JSON string").action(async function(orderId) {
+    try {
+      ensureAuth();
+      validateId(orderId, "orderId");
+      const { reason, bankDetails } = this.opts();
+      let bankTransferDetails;
+      if (bankDetails) {
+        try {
+          bankTransferDetails = JSON.parse(bankDetails);
+        } catch {
+          throw new CliError("--bank-details must be valid JSON.");
+        }
+      }
+      const rl = readline5.createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await rl.question(`Request refund for order "${orderId}"? (y/N): `);
+      rl.close();
+      if (answer.toLowerCase() !== "y") {
+        printWarn("Cancelled.");
+        return;
+      }
+      const data = await fetchApi("POST", "/refunds/request", {
+        body: { orderId, reason, bankTransferDetails }
+      });
+      formatOutput(data, getOutputOpts(this));
+      printSuccess("Refund request submitted.");
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/releases.ts
+var RELEASE_COLUMNS = [
+  { key: "tagName", header: "Tag", width: 20 },
+  { key: "name", header: "Name", width: 40 },
+  { key: "publishedAt", header: "Published At", width: 24 }
+];
+function registerReleasesCommand(program2) {
+  const releases = program2.command("releases").description("Product releases");
+  releases.command("list").description("List product releases").option("--tab <all|engineer|marketing>", "Release tab filter", "all").action(async function() {
+    try {
+      const { tab } = this.opts();
+      const data = await fetchApi("GET", "/releases", {
+        noAuth: true,
+        params: { tab }
+      });
+      formatOutput(data, getOutputOpts(this), RELEASE_COLUMNS);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/stats.ts
+function registerStatsCommand(program2) {
+  const stats = program2.command("stats").description("Platform statistics");
+  stats.command("users").description("Get platform user statistics").action(async function() {
+    try {
+      const data = await fetchApi("GET", "/stats/users", { noAuth: true });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/waitlist.ts
+function registerWaitlistCommand(program2) {
+  const waitlist = program2.command("waitlist").description("Product waitlist");
+  waitlist.command("join").description("Join the marketing waitlist").requiredOption("--email <email>", "Email address to join with").action(async function() {
+    try {
+      const { email } = this.opts();
+      const data = await fetchApi("POST", "/waitlist/marketing", {
+        noAuth: true,
+        body: { email }
+      });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/admin/admin-utils.ts
+import * as readline6 from "readline/promises";
+async function confirm(message) {
+  const rl = readline6.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question(`${message} [y/N] `);
+    return answer.trim().toLowerCase() === "y";
+  } finally {
+    rl.close();
+  }
+}
+
+// src/commands/admin/admin-orders.ts
+var ORDER_COLUMNS2 = [
+  { key: "id", header: "ID", width: 12 },
+  { key: "userEmail", header: "User Email", width: 28 },
+  { key: "productType", header: "Product", width: 16 },
+  { key: "amount", header: "Amount", width: 10 },
+  { key: "currency", header: "Currency", width: 8 },
+  { key: "status", header: "Status", width: 12 },
+  { key: "paymentProvider", header: "Provider", width: 12 },
+  { key: "createdAt", header: "Created", width: 22 }
+];
+function registerAdminOrdersCommand(admin) {
+  const orders = admin.command("orders").description("Admin order management");
+  orders.command("list").description("List all orders").option("--provider <name>", "Filter by payment provider").action(async function() {
+    try {
+      ensureAdminAuth();
+      const opts = this.opts();
+      const params = {};
+      if (opts.provider) params["provider"] = opts.provider;
+      const data = await fetchApi("GET", "/admin/orders", { adminAuth: true, params });
+      formatOutput(data, getOutputOpts(this), ORDER_COLUMNS2);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  orders.command("get <id>").description("Get order details").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "order ID");
+      const data = await fetchApi("GET", `/admin/orders/${id}`, { adminAuth: true });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  orders.command("complete <id>").description("Mark an order as complete").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "order ID");
+      const ok = await confirm(`Complete order ${id}?`);
+      if (!ok) {
+        console.log("Aborted.");
+        return;
+      }
+      const data = await fetchApi("POST", `/admin/orders/${id}/complete`, { adminAuth: true });
+      printSuccess(`Order ${id} marked complete.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  orders.command("refund <id>").description("Refund an order (revokes GitHub access)").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "order ID");
+      const ok = await confirm(`Refund order ${id}? WARNING: this will revoke GitHub access. Continue?`);
+      if (!ok) {
+        console.log("Aborted.");
+        return;
+      }
+      const data = await fetchApi("POST", `/admin/orders/${id}/refund`, { adminAuth: true });
+      printSuccess(`Order ${id} refunded.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  orders.command("refund-keep-access <id>").description("Refund an order but keep GitHub access").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "order ID");
+      const ok = await confirm(`Refund order ${id} (keep access)?`);
+      if (!ok) {
+        console.log("Aborted.");
+        return;
+      }
+      const data = await fetchApi("POST", `/admin/orders/${id}/refund-keep-access`, { adminAuth: true });
+      printSuccess(`Order ${id} refunded (access retained).`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  orders.command("switch-product <id>").description("Switch the product type of an order").requiredOption("--product <engineer_kit|marketing_kit>", "Target product type").option("--reason <text>", "Reason for the switch").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "order ID");
+      const { product, reason } = this.opts();
+      if (!["engineer_kit", "marketing_kit"].includes(product)) {
+        throw new CliError("--product must be one of: engineer_kit, marketing_kit");
+      }
+      const ok = await confirm(`Switch order ${id} to product "${product}"?`);
+      if (!ok) {
+        console.log("Aborted.");
+        return;
+      }
+      const body = { targetProductType: product };
+      if (reason) body["reason"] = reason;
+      const data = await fetchApi("POST", `/admin/orders/${id}/switch-product`, { adminAuth: true, body });
+      printSuccess(`Order ${id} product switched to ${product}.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  orders.command("resend-emails <id>").description("Resend emails for an order").requiredOption("--type <order|welcome|invoice|both>", "Email type to resend").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "order ID");
+      const { type } = this.opts();
+      const data = await fetchApi("POST", `/admin/orders/${id}/resend-emails`, {
+        adminAuth: true,
+        body: { emailType: type }
+      });
+      printSuccess(`Emails (${type}) resent for order ${id}.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  orders.command("export").description("Export orders as CSV").option("--start <date>", "Start date (ISO 8601)").option("--end <date>", "End date (ISO 8601)").option("--search <text>", "Search text").option("--provider <name>", "Filter by payment provider").option("--status <status>", "Filter by status").action(async function() {
+    try {
+      ensureAdminAuth();
+      const opts = this.opts();
+      const params = {};
+      if (opts.start) params["startDate"] = opts.start;
+      if (opts.end) params["endDate"] = opts.end;
+      if (opts.search) params["search"] = opts.search;
+      if (opts.provider) params["provider"] = opts.provider;
+      if (opts.status) params["status"] = opts.status;
+      const csv = await fetchApi("GET", "/admin/orders/export", { adminAuth: true, params });
+      console.log(typeof csv === "string" ? csv : JSON.stringify(csv));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/admin/admin-users.ts
+function registerAdminUsersCommand(admin) {
+  const users = admin.command("users").description("Admin user management");
+  users.command("get <id>").description("Get user details").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "user ID");
+      const data = await fetchApi("GET", `/admin/users/${id}`, { adminAuth: true });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  users.command("update-github <id>").description("Update GitHub username for a user").requiredOption("--username <name>", "New GitHub username").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "user ID");
+      const { username } = this.opts();
+      const data = await fetchApi("PATCH", `/admin/users/${id}/github-username`, {
+        adminAuth: true,
+        body: { githubUsername: username }
+      });
+      printSuccess(`GitHub username updated for user ${id}.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  users.command("update-rates <id>").description("Update commission/discount rates for a user").option("--commission <rate>", "Commission rate (number)").option("--discount <rate>", "Discount rate (number)").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "user ID");
+      const opts = this.opts();
+      if (opts.commission === void 0 && opts.discount === void 0) {
+        throw new CliError("At least one of --commission or --discount is required.");
+      }
+      const body = {};
+      if (opts.commission !== void 0) {
+        const val = Number(opts.commission);
+        if (Number.isNaN(val) || val < 0 || val > 100) throw new CliError("--commission must be a number between 0 and 100");
+        body["commissionRate"] = val;
+      }
+      if (opts.discount !== void 0) {
+        const val = Number(opts.discount);
+        if (Number.isNaN(val) || val < 0 || val > 100) throw new CliError("--discount must be a number between 0 and 100");
+        body["discountRate"] = val;
+      }
+      const data = await fetchApi("PATCH", `/admin/users/${id}/rates`, { adminAuth: true, body });
+      printSuccess(`Rates updated for user ${id}.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  users.command("set-tier <id>").description("Set manual tier for a user (use 'none' to remove)").requiredOption("--tier <tierId>", "Tier ID or 'none' to remove").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "user ID");
+      const { tier } = this.opts();
+      const data = await fetchApi("PATCH", `/admin/users/${id}/tier`, {
+        adminAuth: true,
+        body: { manualTierId: tier === "none" ? null : tier }
+      });
+      printSuccess(`Tier updated for user ${id}.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  users.command("export").description("Export users as CSV").option("--start <date>", "Start date (ISO 8601)").option("--end <date>", "End date (ISO 8601)").option("--search <text>", "Search text").action(async function() {
+    try {
+      ensureAdminAuth();
+      const opts = this.opts();
+      const params = {};
+      if (opts.start) params["startDate"] = opts.start;
+      if (opts.end) params["endDate"] = opts.end;
+      if (opts.search) params["search"] = opts.search;
+      const csv = await fetchApi("GET", "/admin/users/export", { adminAuth: true, params });
+      console.log(typeof csv === "string" ? csv : JSON.stringify(csv));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/admin/admin-referrals.ts
+function registerAdminReferralsCommand(admin) {
+  const referrals = admin.command("referrals").description("Admin referral management");
+  referrals.command("stats").description("Get referral statistics").option("--start <date>", "Start date (ISO 8601)").option("--end <date>", "End date (ISO 8601)").action(async function() {
+    try {
+      ensureAdminAuth();
+      const opts = this.opts();
+      const params = {};
+      if (opts.start) params["startDate"] = opts.start;
+      if (opts.end) params["endDate"] = opts.end;
+      const data = await fetchApi("GET", "/admin/referrals/stats", { adminAuth: true, params });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  referrals.command("tiers-stats").description("Get referral tier statistics").action(async function() {
+    try {
+      ensureAdminAuth();
+      const data = await fetchApi("GET", "/admin/referrals/tiers/stats", { adminAuth: true });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  referrals.command("diagnose").description("Run referral diagnostics").action(async function() {
+    try {
+      ensureAdminAuth();
+      const data = await fetchApi("GET", "/admin/referrals/diagnose", { adminAuth: true });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  referrals.command("export").description("Export referral data as CSV").option("--start <date>", "Start date (ISO 8601)").option("--end <date>", "End date (ISO 8601)").action(async function() {
+    try {
+      ensureAdminAuth();
+      const opts = this.opts();
+      const params = {};
+      if (opts.start) params["startDate"] = opts.start;
+      if (opts.end) params["endDate"] = opts.end;
+      const csv = await fetchApi("GET", "/admin/referrals/export", { adminAuth: true, params });
+      console.log(typeof csv === "string" ? csv : JSON.stringify(csv));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/admin/admin-revenue.ts
+function registerAdminRevenueCommand(admin) {
+  const revenue = admin.command("revenue").description("Admin revenue reporting");
+  revenue.command("stats").description("Get revenue statistics").option("--start <date>", "Start date (ISO 8601)").option("--end <date>", "End date (ISO 8601)").action(async function() {
+    try {
+      ensureAdminAuth();
+      const opts = this.opts();
+      const params = {};
+      if (opts.start) params["startDate"] = opts.start;
+      if (opts.end) params["endDate"] = opts.end;
+      const data = await fetchApi("GET", "/admin/revenue", { adminAuth: true, params });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  revenue.command("export").description("Export revenue data as CSV").option("--start <date>", "Start date (ISO 8601)").option("--end <date>", "End date (ISO 8601)").action(async function() {
+    try {
+      ensureAdminAuth();
+      const opts = this.opts();
+      const params = {};
+      if (opts.start) params["startDate"] = opts.start;
+      if (opts.end) params["endDate"] = opts.end;
+      const csv = await fetchApi("GET", "/admin/revenue/export", { adminAuth: true, params });
+      console.log(typeof csv === "string" ? csv : JSON.stringify(csv));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  revenue.command("maintainer").description("Get maintainer revenue breakdown").requiredOption("--id <cke|ckm>", "Maintainer ID").option("--start <date>", "Start date (ISO 8601)").option("--end <date>", "End date (ISO 8601)").action(async function() {
+    try {
+      ensureAdminAuth();
+      const opts = this.opts();
+      const params = { id: opts.id };
+      if (opts.start) params["startDate"] = opts.start;
+      if (opts.end) params["endDate"] = opts.end;
+      const data = await fetchApi("GET", "/admin/revenue/maintainer", { adminAuth: true, params });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  revenue.command("costs").description("Get monthly costs").option("--month <YYYY-MM>", "Month in YYYY-MM format").action(async function() {
+    try {
+      ensureAdminAuth();
+      const opts = this.opts();
+      const params = {};
+      if (opts.month) params["yearMonth"] = opts.month;
+      const data = await fetchApi("GET", "/admin/revenue/monthly-costs", { adminAuth: true, params });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  revenue.command("add-cost").description("Add a monthly cost entry").requiredOption("--month <YYYY-MM>", "Month in YYYY-MM format").requiredOption("--category <name>", "Cost category").requiredOption("--description <text>", "Cost description").requiredOption("--amount <cents>", "Amount in cents").action(async function() {
+    try {
+      ensureAdminAuth();
+      const opts = this.opts();
+      const amount = Number(opts.amount);
+      if (Number.isNaN(amount)) throw new CliError("--amount must be a valid number");
+      const data = await fetchApi("POST", "/admin/revenue/monthly-costs", {
+        adminAuth: true,
+        body: { yearMonth: opts.month, category: opts.category, description: opts.description, amount }
+      });
+      printSuccess("Monthly cost entry added.");
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  revenue.command("update-cost <id>").description("Update a monthly cost entry").option("--month <YYYY-MM>", "Month in YYYY-MM format").option("--category <name>", "Cost category").option("--description <text>", "Cost description").option("--amount <cents>", "Amount in cents").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "cost ID");
+      const opts = this.opts();
+      const body = {};
+      if (opts.month) body["yearMonth"] = opts.month;
+      if (opts.category) body["category"] = opts.category;
+      if (opts.description) body["description"] = opts.description;
+      if (opts.amount !== void 0) {
+        const amount = Number(opts.amount);
+        if (Number.isNaN(amount)) throw new CliError("--amount must be a valid number");
+        body["amount"] = amount;
+      }
+      const data = await fetchApi("PUT", `/admin/revenue/monthly-costs/${id}`, { adminAuth: true, body });
+      printSuccess(`Cost entry ${id} updated.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  revenue.command("delete-cost <id>").description("Delete a monthly cost entry").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "cost ID");
+      const ok = await confirm(`Delete cost entry ${id}? This cannot be undone.`);
+      if (!ok) {
+        console.log("Aborted.");
+        return;
+      }
+      await fetchApi("DELETE", `/admin/revenue/monthly-costs/${id}`, { adminAuth: true });
+      printSuccess(`Cost entry ${id} deleted.`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  revenue.command("reports").description("Generate revenue reports").option("--maintainer <cke|ckm|all>", "Maintainer ID").option("--month <YYYY-MM>", "Month in YYYY-MM format").option("--skip-email", "Skip sending email").action(async function() {
+    try {
+      ensureAdminAuth();
+      const opts = this.opts();
+      const body = {};
+      if (opts.maintainer) body["maintainerId"] = opts.maintainer;
+      if (opts.month) body["yearMonth"] = opts.month;
+      if (opts.skipEmail) body["skipEmail"] = true;
+      const data = await fetchApi("POST", "/admin/revenue/reports", { adminAuth: true, body });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/admin/admin-payouts.ts
+var PAYOUT_COLUMNS2 = [
+  { key: "id", header: "ID", width: 12 },
+  { key: "userEmail", header: "User Email", width: 28 },
+  { key: "amount", header: "Amount", width: 10 },
+  { key: "currency", header: "Currency", width: 8 },
+  { key: "status", header: "Status", width: 12 },
+  { key: "paymentMethod", header: "Method", width: 14 },
+  { key: "createdAt", header: "Created", width: 22 }
+];
+function registerAdminPayoutsCommand(admin) {
+  const payouts = admin.command("payouts").description("Admin payout management");
+  payouts.command("list").description("List all payout requests").action(async function() {
+    try {
+      ensureAdminAuth();
+      const data = await fetchApi("GET", "/admin/payout-requests", { adminAuth: true });
+      formatOutput(data, getOutputOpts(this), PAYOUT_COLUMNS2);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  payouts.command("update <id>").description("Approve, reject, or complete a payout request").requiredOption("--action <approve|reject|complete>", "Action to perform").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "payout request ID");
+      const { action } = this.opts();
+      const validActions = ["approve", "reject", "complete"];
+      if (!validActions.includes(action)) {
+        throw new CliError(`--action must be one of: ${validActions.join(", ")}`);
+      }
+      const ok = await confirm(`${action} payout request ${id}?`);
+      if (!ok) {
+        console.log("Aborted.");
+        return;
+      }
+      const data = await fetchApi("PATCH", `/admin/payout-requests/${id}`, {
+        adminAuth: true,
+        body: { action }
+      });
+      printSuccess(`Payout request ${id} updated: ${action}.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  payouts.command("export").description("Export payouts as CSV").option("--start <date>", "Start date (ISO 8601)").option("--end <date>", "End date (ISO 8601)").option("--status <status>", "Filter by status").action(async function() {
+    try {
+      ensureAdminAuth();
+      const opts = this.opts();
+      const params = {};
+      if (opts.start) params["startDate"] = opts.start;
+      if (opts.end) params["endDate"] = opts.end;
+      if (opts.status) params["status"] = opts.status;
+      const csv = await fetchApi("GET", "/admin/payouts/export", { adminAuth: true, params });
+      console.log(typeof csv === "string" ? csv : JSON.stringify(csv));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  payouts.command("export-detailed").description("Export detailed payouts as CSV").option("--status <status>", "Filter by status").action(async function() {
+    try {
+      ensureAdminAuth();
+      const opts = this.opts();
+      const params = {};
+      if (opts.status) params["status"] = opts.status;
+      const csv = await fetchApi("GET", "/admin/payouts/export-detailed", { adminAuth: true, params });
+      console.log(typeof csv === "string" ? csv : JSON.stringify(csv));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  payouts.command("request-csv <id>").description("Export a payout request as CSV").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "payout request ID");
+      const csv = await fetchApi("GET", `/admin/payout-requests/${id}/export-csv`, { adminAuth: true });
+      console.log(typeof csv === "string" ? csv : JSON.stringify(csv));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/admin/admin-loyalty.ts
+import * as readline7 from "readline/promises";
+async function confirm2(message) {
+  const rl = readline7.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question(`${message} [y/N] `);
+    return answer.trim().toLowerCase() === "y";
+  } finally {
+    rl.close();
+  }
+}
+function registerAdminLoyaltyCommand(admin) {
+  const loyalty = admin.command("loyalty").description("Admin loyalty program management");
+  loyalty.command("stats").description("Get loyalty program statistics").action(async function() {
+    try {
+      ensureAdminAuth();
+      const data = await fetchApi("GET", "/admin/loyalty/stats", {
+        adminAuth: true
+      });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  loyalty.command("blast-email").description("Send loyalty blast email to eligible users").option("--test", "Run in test mode (no confirmation required)").option("--test-email <email>", "Send test email to this address").option("--batch-size <n>", "Number of emails per batch").action(async function() {
+    try {
+      ensureAdminAuth();
+      const opts = this.opts();
+      const isTest = opts.test === true;
+      if (!isTest) {
+        const ok = await confirm2("Send loyalty blast email to all eligible users?");
+        if (!ok) {
+          console.log("Aborted.");
+          return;
+        }
+      }
+      const body = { testMode: isTest };
+      if (opts.testEmail) body["testEmail"] = opts.testEmail;
+      if (opts.batchSize) body["batchSize"] = Number(opts.batchSize);
+      const data = await fetchApi("POST", "/admin/loyalty/blast-email", {
+        adminAuth: true,
+        body
+      });
+      printSuccess("Loyalty blast email queued.");
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/admin/admin-blog.ts
+import { readFileSync as readFileSync3 } from "fs";
+function resolveContent(opts) {
+  if (opts.file) {
+    try {
+      return readFileSync3(opts.file, "utf-8");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new CliError(`Cannot read file "${opts.file}": ${msg}`);
+    }
+  }
+  return opts.content;
+}
+function registerAdminBlogCommand(admin) {
+  const blog = admin.command("blog").description("Admin blog management");
+  blog.command("create").description("Create a new blog article").requiredOption("--title <title>", "Article title").option("--content <content>", "Article content (inline)").option("--file <filepath>", "Read content from file").action(async function() {
+    try {
+      ensureAdminAuth();
+      const opts = this.opts();
+      const content = resolveContent(opts);
+      const data = await fetchApi("POST", "/blog/articles", {
+        adminAuth: true,
+        body: { title: opts.title, content }
+      });
+      printSuccess("Article created.");
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  blog.command("update <id>").description("Update an existing blog article").option("--title <title>", "New title").option("--content <content>", "New content (inline)").option("--file <filepath>", "Read new content from file").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "article ID");
+      const opts = this.opts();
+      const content = resolveContent(opts);
+      const body = {};
+      if (opts.title) body["title"] = opts.title;
+      if (content !== void 0) body["content"] = content;
+      const data = await fetchApi("PATCH", `/blog/articles/${id}`, {
+        adminAuth: true,
+        body
+      });
+      printSuccess(`Article ${id} updated.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  blog.command("delete <id>").description("Delete a blog article").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "article ID");
+      const ok = await confirm(`Delete article ${id}? This cannot be undone.`);
+      if (!ok) {
+        console.log("Aborted.");
+        return;
+      }
+      await fetchApi("DELETE", `/blog/articles/${id}`, { adminAuth: true });
+      printSuccess(`Article ${id} deleted.`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  blog.command("publish <id>").description("Publish a blog article").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "article ID");
+      const ok = await confirm(`Publish article ${id}?`);
+      if (!ok) {
+        console.log("Aborted.");
+        return;
+      }
+      const data = await fetchApi("POST", `/blog/articles/${id}/publish`, {
+        adminAuth: true
+      });
+      printSuccess(`Article ${id} published.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  blog.command("ai-generate").description("Generate a blog article using AI").requiredOption("--prompt <text>", "Generation prompt").action(async function() {
+    try {
+      ensureAdminAuth();
+      const { prompt } = this.opts();
+      const data = await fetchApi("POST", "/blog/ai/generate", {
+        adminAuth: true,
+        body: { prompt }
+      });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  blog.command("ai-transform").description("Transform text using AI").requiredOption("--text <text>", "Source text to transform").requiredOption("--instruction <text>", "Transformation instruction").action(async function() {
+    try {
+      ensureAdminAuth();
+      const { text, instruction } = this.opts();
+      const data = await fetchApi("POST", "/blog/ai/transform", {
+        adminAuth: true,
+        body: { text, instruction }
+      });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  blog.command("generate-metadata <id>").description("Generate SEO metadata for an article").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "article ID");
+      const data = await fetchApi("POST", "/blog/generate-metadata", {
+        adminAuth: true,
+        body: { articleId: id }
+      });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  blog.command("upload-url").description("Get a presigned URL for blog asset upload").requiredOption("--filename <name>", "File name to upload").requiredOption("--content-type <type>", "MIME type of the file").action(async function() {
+    try {
+      ensureAdminAuth();
+      const opts = this.opts();
+      const data = await fetchApi("POST", "/blog/upload/presigned-url", {
+        adminAuth: true,
+        body: { filename: opts.filename, contentType: opts.contentType }
+      });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  blog.command("export").description("Export blog articles as CSV").option("--start <date>", "Start date (ISO 8601)").option("--end <date>", "End date (ISO 8601)").option("--status <status>", "Filter by status").action(async function() {
+    try {
+      ensureAdminAuth();
+      const opts = this.opts();
+      const params = {};
+      if (opts.start) params["startDate"] = opts.start;
+      if (opts.end) params["endDate"] = opts.end;
+      if (opts.status) params["status"] = opts.status;
+      const csv = await fetchApi("GET", "/admin/blog/export", { adminAuth: true, params });
+      console.log(typeof csv === "string" ? csv : JSON.stringify(csv));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/admin/admin-keys.ts
+import chalk5 from "chalk";
+var KEY_COLUMNS = [
+  { key: "id", header: "ID", width: 12 },
+  { key: "name", header: "Name", width: 20 },
+  { key: "scopes", header: "Scopes", width: 30 },
+  { key: "createdAt", header: "Created", width: 22 }
+];
+function registerAdminKeysCommand(admin) {
+  const keys = admin.command("keys").description("Admin API key management");
+  keys.command("list").description("List all API keys").option("--limit <n>", "Number of results", "50").option("--offset <n>", "Offset for pagination", "0").action(async function() {
+    try {
+      ensureAdminAuth();
+      const opts = this.opts();
+      const limit = Number(opts.limit);
+      const offset = Number(opts.offset);
+      if (Number.isNaN(limit) || limit < 1) throw new Error("--limit must be a positive number");
+      if (Number.isNaN(offset) || offset < 0) throw new Error("--offset must be a non-negative number");
+      const data = await fetchApi("GET", "/admin/keys", {
+        adminAuth: true,
+        params: { limit: String(limit), offset: String(offset) }
+      });
+      formatOutput(data, getOutputOpts(this), KEY_COLUMNS);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  keys.command("create").description("Create a new API key").requiredOption("--name <name>", "Key name").requiredOption("--scopes <scopes>", "Comma-separated list of scopes").action(async function() {
+    try {
+      ensureAdminAuth();
+      const { name, scopes } = this.opts();
+      const data = await fetchApi("POST", "/admin/keys", {
+        adminAuth: true,
+        body: { name, scopes: scopes.split(",").map((s) => s.trim()) }
+      });
+      printSuccess(`API key "${name}" created.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  keys.command("validate").description("Validate the current admin API key").action(async function() {
+    try {
+      ensureAdminAuth();
+      const data = await fetchApi("POST", "/admin/keys/validate", {
+        adminAuth: true
+      });
+      printSuccess("Admin API key is valid.");
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  keys.command("revoke <id>").description("Revoke an API key").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "key ID");
+      const ok = await confirm(`Revoke API key ${id}?`);
+      if (!ok) {
+        console.log("Aborted.");
+        return;
+      }
+      const data = await fetchApi("POST", `/admin/keys/${id}/revoke`, {
+        adminAuth: true
+      });
+      printSuccess(`API key ${id} revoked.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  keys.command("rotate <id>").description("Rotate an API key (generates a new key value)").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "key ID");
+      const ok = await confirm(`Rotate API key ${id}? The old key will be invalidated.`);
+      if (!ok) {
+        console.log("Aborted.");
+        return;
+      }
+      const data = await fetchApi("POST", `/admin/keys/${id}/rotate`, {
+        adminAuth: true
+      });
+      printSuccess(`API key ${id} rotated.`);
+      if (data && typeof data === "object" && "key" in data && data.key) {
+        console.log(chalk5.bold.green(`New key: ${data.key}`));
+        console.log(chalk5.yellow("Store this key securely \u2014 it will not be shown again."));
+      } else {
+        formatOutput(data, getOutputOpts(this));
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/admin/admin-invites.ts
+var INVITE_COLUMNS = [
+  { key: "id", header: "ID", width: 12 },
+  { key: "email", header: "Email", width: 28 },
+  { key: "status", header: "Status", width: 10 },
+  { key: "createdAt", header: "Created", width: 22 }
+];
+function registerAdminInvitesCommand(admin) {
+  const invites = admin.command("invites").description("Admin invite management");
+  invites.command("list").description("List all invites").action(async function() {
+    try {
+      ensureAdminAuth();
+      const data = await fetchApi("GET", "/admin/invites", {
+        adminAuth: true
+      });
+      formatOutput(data, getOutputOpts(this), INVITE_COLUMNS);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  invites.command("create").description("Create a new invite").requiredOption("--email <email>", "Email address to invite").action(async function() {
+    try {
+      ensureAdminAuth();
+      const { email } = this.opts();
+      const data = await fetchApi("POST", "/admin/invites", {
+        adminAuth: true,
+        body: { email }
+      });
+      printSuccess(`Invite sent to ${email}.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  invites.command("get <id>").description("Get invite details").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "invite ID");
+      const data = await fetchApi("GET", `/admin/invites/${id}`, {
+        adminAuth: true
+      });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  invites.command("delete <id>").description("Delete an invite").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "invite ID");
+      const ok = await confirm(`Delete invite ${id}?`);
+      if (!ok) {
+        console.log("Aborted.");
+        return;
+      }
+      const data = await fetchApi("DELETE", `/admin/invites/${id}`, {
+        adminAuth: true
+      });
+      printSuccess(`Invite ${id} deleted.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  invites.command("resend <id>").description("Resend an invite email").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "invite ID");
+      const ok = await confirm(`Resend invite ${id}?`);
+      if (!ok) {
+        console.log("Aborted.");
+        return;
+      }
+      const data = await fetchApi("POST", `/admin/invites/${id}/resend`, {
+        adminAuth: true
+      });
+      printSuccess(`Invite ${id} resent.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  invites.command("accept").description("Accept an invite (public endpoint)").requiredOption("--token <token>", "Invite token").option("--name <name>", "Display name (optional)").action(async function() {
+    try {
+      const { token, name } = this.opts();
+      const body = { token };
+      if (name) body["name"] = name;
+      const data = await fetchApi("POST", "/admin/invites/accept", {
+        noAuth: true,
+        body
+      });
+      printSuccess("Invite accepted.");
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  invites.command("validate").description("Validate an invite token (public endpoint)").requiredOption("--token <token>", "Invite token").action(async function() {
+    try {
+      const { token } = this.opts();
+      const data = await fetchApi("GET", "/admin/invites/validate", {
+        noAuth: true,
+        params: { token }
+      });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/admin/admin-admins.ts
+function registerAdminAdminsCommand(admin) {
+  const admins = admin.command("admins").description("Admin role management");
+  admins.command("list").description("List all admins").action(async function() {
+    try {
+      ensureAdminAuth();
+      const data = await fetchApi("GET", "/admin/admins", {
+        adminAuth: true
+      });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  admins.command("get <id>").description("Get admin details").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "admin ID");
+      const data = await fetchApi("GET", `/admin/admins/${id}`, {
+        adminAuth: true
+      });
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  admins.command("promote <id>").description("Promote a user to admin").option("--grant-all", "Grant all permissions").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "user ID");
+      const opts = this.opts();
+      const ok = await confirm(`Promote user ${id} to admin?`);
+      if (!ok) {
+        console.log("Aborted.");
+        return;
+      }
+      const data = await fetchApi("POST", `/admin/admins/${id}/promote`, {
+        adminAuth: true,
+        body: { grantAllPermissions: opts.grantAll || false }
+      });
+      printSuccess(`User ${id} promoted to admin.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  admins.command("demote <id>").description("Remove admin access from a user").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "admin ID");
+      const ok = await confirm(
+        `Demote admin ${id}? WARNING: this removes all admin access.`
+      );
+      if (!ok) {
+        console.log("Aborted.");
+        return;
+      }
+      const data = await fetchApi("DELETE", `/admin/admins/${id}`, {
+        adminAuth: true
+      });
+      printSuccess(`Admin ${id} demoted.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  admins.command("permissions <id>").description("Update admin permissions").requiredOption("--permissions <json>", "JSON array of permission strings").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "admin ID");
+      const { permissions: permissionsJson } = this.opts();
+      let permissions;
+      try {
+        permissions = JSON.parse(permissionsJson);
+      } catch {
+        throw new CliError(`--permissions must be valid JSON (e.g. '["read","write"]')`);
+      }
+      if (!Array.isArray(permissions)) {
+        throw new CliError("--permissions must be a JSON array");
+      }
+      const data = await fetchApi("PATCH", `/admin/admins/${id}/permissions`, {
+        adminAuth: true,
+        body: { permissions }
+      });
+      printSuccess(`Permissions updated for admin ${id}.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/admin/admin-discounts.ts
+var DISCOUNT_COLUMNS = [
+  { key: "id", header: "ID", width: 12 },
+  { key: "code", header: "Code", width: 20 },
+  { key: "type", header: "Type", width: 12 },
+  { key: "amount", header: "Amount", width: 10 },
+  { key: "status", header: "Status", width: 10 },
+  { key: "createdAt", header: "Created", width: 22 }
+];
+function buildDiscountBody(opts) {
+  const body = {};
+  if (opts.code !== void 0) body["code"] = opts.code;
+  if (opts.type !== void 0) {
+    if (opts.type !== "percentage" && opts.type !== "fixed") {
+      throw new CliError("--type must be 'percentage' or 'fixed'");
+    }
+    body["type"] = opts.type;
+  }
+  if (opts.amount !== void 0) {
+    const val = Number(opts.amount);
+    if (Number.isNaN(val) || val < 0) throw new CliError("--amount must be a non-negative number (cents)");
+    body["amount"] = val;
+  }
+  if (opts.basisPoints !== void 0) {
+    const val = Number(opts.basisPoints);
+    if (Number.isNaN(val) || val < 0) throw new CliError("--basis-points must be a non-negative number");
+    body["basisPoints"] = val;
+  }
+  if (opts.maxRedemptions !== void 0) {
+    const val = Number(opts.maxRedemptions);
+    if (Number.isNaN(val) || val < 1) throw new CliError("--max-redemptions must be a positive integer");
+    body["maxRedemptions"] = val;
+  }
+  if (opts.starts !== void 0) body["startsAt"] = opts.starts;
+  if (opts.ends !== void 0) body["endsAt"] = opts.ends;
+  return body;
+}
+function registerAdminDiscountsCommand(admin) {
+  const discounts = admin.command("discounts").description("Discount management");
+  discounts.command("list").description("List discounts").option("--query <search>", "Search query").option("--page <n>", "Page number", "1").option("--limit <n>", "Results per page", "50").action(async function() {
+    try {
+      ensureAdminAuth();
+      const opts = this.opts();
+      const page = Number(opts.page);
+      const limit = Number(opts.limit);
+      if (Number.isNaN(page) || page < 1) throw new CliError("--page must be a positive integer");
+      if (Number.isNaN(limit) || limit < 1) throw new CliError("--limit must be a positive integer");
+      const params = {
+        page: String(page),
+        limit: String(limit)
+      };
+      if (opts.query) params["query"] = opts.query;
+      const data = await fetchApi("GET", "/admin/discounts", {
+        adminAuth: true,
+        params
+      });
+      formatOutput(data, getOutputOpts(this), DISCOUNT_COLUMNS);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  discounts.command("create").description("Create a discount code").requiredOption("--code <code>", "Discount code").requiredOption("--type <percentage|fixed>", "Discount type").option("--amount <n>", "Amount in cents (fixed type)").option("--basis-points <n>", "Basis points (percentage type)").option("--max-redemptions <n>", "Maximum number of redemptions").option("--starts <date>", "Start date (ISO 8601)").option("--ends <date>", "End date (ISO 8601)").action(async function() {
+    try {
+      ensureAdminAuth();
+      const body = buildDiscountBody(this.opts());
+      const data = await fetchApi("POST", "/admin/discounts", {
+        adminAuth: true,
+        body
+      });
+      printSuccess(`Discount "${body["code"]}" created.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  discounts.command("update <id>").description("Update a discount code").option("--code <code>", "Discount code").option("--type <percentage|fixed>", "Discount type").option("--amount <n>", "Amount in cents (fixed type)").option("--basis-points <n>", "Basis points (percentage type)").option("--max-redemptions <n>", "Maximum number of redemptions").option("--starts <date>", "Start date (ISO 8601)").option("--ends <date>", "End date (ISO 8601)").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "discount ID");
+      const body = buildDiscountBody(this.opts());
+      if (Object.keys(body).length === 0) {
+        throw new CliError("At least one option must be provided to update.");
+      }
+      const data = await fetchApi("PATCH", `/admin/discounts/${id}`, {
+        adminAuth: true,
+        body
+      });
+      printSuccess(`Discount ${id} updated.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  discounts.command("delete <id>").description("Delete a discount code").action(async function(id) {
+    try {
+      ensureAdminAuth();
+      validateId(id, "discount ID");
+      const ok = await confirm(`Delete discount ${id}?`);
+      if (!ok) {
+        console.log("Aborted.");
+        return;
+      }
+      const data = await fetchApi("DELETE", `/admin/discounts/${id}`, {
+        adminAuth: true
+      });
+      printSuccess(`Discount ${id} deleted.`);
+      formatOutput(data, getOutputOpts(this));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  discounts.command("export").description("Export discounts as CSV").option("--start <date>", "Start date filter (ISO 8601)").option("--end <date>", "End date filter (ISO 8601)").option("--status <all|active|expired>", "Filter by status", "all").action(async function() {
+    try {
+      ensureAdminAuth();
+      const opts = this.opts();
+      const params = { status: opts.status };
+      if (opts.start) params["startDate"] = opts.start;
+      if (opts.end) params["endDate"] = opts.end;
+      const data = await fetchApi("GET", "/admin/discounts/export", {
+        adminAuth: true,
+        params
+      });
+      console.log(data);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/admin/admin-tiers.ts
+var TIER_COLUMNS = [
+  { key: "id", header: "ID", width: 12 },
+  { key: "name", header: "Name", width: 16 },
+  { key: "displayName", header: "Display Name", width: 20 },
+  { key: "commissionRate", header: "Commission", width: 10 },
+  { key: "badgeColor", header: "Badge Color", width: 12 }
+];
+function registerAdminTiersCommand(admin) {
+  const tiers = admin.command("tiers").description("Tier management");
+  tiers.command("list").description("List manual referral tiers").action(async function() {
+    try {
+      ensureAdminAuth();
+      const data = await fetchApi("GET", "/admin/tiers/manual", {
+        adminAuth: true
+      });
+      formatOutput(data, getOutputOpts(this), TIER_COLUMNS);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/admin/index.ts
+function registerAdminCommand(program2) {
+  const admin = program2.command("admin").description("Admin operations (requires admin API key)");
+  registerAdminOrdersCommand(admin);
+  registerAdminUsersCommand(admin);
+  registerAdminReferralsCommand(admin);
+  registerAdminRevenueCommand(admin);
+  registerAdminPayoutsCommand(admin);
+  registerAdminLoyaltyCommand(admin);
+  registerAdminBlogCommand(admin);
+  registerAdminKeysCommand(admin);
+  registerAdminInvitesCommand(admin);
+  registerAdminAdminsCommand(admin);
+  registerAdminDiscountsCommand(admin);
+  registerAdminTiersCommand(admin);
+}
+
+// src/index.ts
+loadDotenvFiles();
+var program = new Command();
+program.name("ckweb").description("CLI for interacting with ClaudeKit.cc API").version("0.1.0");
+program.option("--json", "Output as JSON").option("--table", "Output as table").option("--quiet", "Minimal output");
+registerAuthCommand(program);
+registerHealthCommand(program);
+registerOrdersCommand(program);
+registerReferralsCommand(program);
+registerBlogCommand(program);
+registerAccountCommand(program);
+registerCheckoutCommand(program);
+registerGithubCommand(program);
+registerLoyaltyCommand(program);
+registerNewsletterCommand(program);
+registerPayoutCommand(program);
+registerPricingCommand(program);
+registerRefundsCommand(program);
+registerReleasesCommand(program);
+registerStatsCommand(program);
+registerWaitlistCommand(program);
+registerYoutubeCommand(program);
+registerWebCommand(program);
+registerSeoCommand(program);
+registerAdminCommand(program);
+program.addHelpCommand(true);
+try {
+  await program.parseAsync(process.argv);
+} catch (err) {
+  handleError(err);
+}
+//# sourceMappingURL=index.js.map