anonli 1.0.0

package/dist/index.js

@@ -0,0 +1,3442 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/types/config.ts
+var DEFAULT_CONFIG;
+var init_config = __esm({
+  "src/types/config.ts"() {
+    "use strict";
+    DEFAULT_CONFIG = {
+      baseUrl: "https://anon.li"
+    };
+  }
+});
+
+// src/lib/config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+function getConfigPath() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  const base = xdg || path.join(os.homedir(), ".config");
+  return path.join(base, "anonli.json");
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const config = { ...DEFAULT_CONFIG, ...parsed };
+    if (!config.baseUrl) {
+      config.baseUrl = DEFAULT_CONFIG.baseUrl;
+    }
+    return config;
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function saveConfig(config) {
+  const configPath = getConfigPath();
+  const dir = path.dirname(configPath);
+  fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", {
+    mode: 384
+  });
+}
+function getApiKey() {
+  return process.env.ANONLI_API_KEY || loadConfig().apiKey;
+}
+function getBaseUrl() {
+  return process.env.ANONLI_BASE_URL || loadConfig().baseUrl;
+}
+function setApiKey(key) {
+  const config = loadConfig();
+  config.apiKey = key;
+  saveConfig(config);
+}
+function removeApiKey() {
+  const config = loadConfig();
+  delete config.apiKey;
+  delete config.userEmail;
+  delete config.userName;
+  saveConfig(config);
+}
+function setUserInfo(email, name) {
+  const config = loadConfig();
+  config.userEmail = email;
+  config.userName = name;
+  saveConfig(config);
+}
+function getUserInfo() {
+  const config = loadConfig();
+  if (!config.userEmail) return null;
+  return { email: config.userEmail, name: config.userName ?? null };
+}
+function maskApiKey(key) {
+  if (key.length <= 8) return "****";
+  return key.slice(0, 6) + "..." + key.slice(-4);
+}
+var init_config2 = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// src/lib/errors.ts
+var EXIT_ERROR, EXIT_AUTH, EXIT_RATE_LIMIT, EXIT_PLAN_LIMIT, EXIT_NOT_FOUND, CliError, AuthError, ApiError, RateLimitError, PlanLimitError;
+var init_errors = __esm({
+  "src/lib/errors.ts"() {
+    "use strict";
+    EXIT_ERROR = 1;
+    EXIT_AUTH = 2;
+    EXIT_RATE_LIMIT = 3;
+    EXIT_PLAN_LIMIT = 4;
+    EXIT_NOT_FOUND = 5;
+    CliError = class extends Error {
+      constructor(message, exitCode = EXIT_ERROR) {
+        super(message);
+        this.exitCode = exitCode;
+        this.name = "CliError";
+      }
+    };
+    AuthError = class extends CliError {
+      constructor(message = "Not authenticated. Run `anonli login` first.") {
+        super(message, EXIT_AUTH);
+        this.name = "AuthError";
+      }
+    };
+    ApiError = class extends CliError {
+      statusCode;
+      code;
+      requestId;
+      constructor(message, statusCode, code, requestId) {
+        const exitCode = statusCode === 404 ? EXIT_NOT_FOUND : statusCode === 429 ? EXIT_RATE_LIMIT : statusCode === 402 || statusCode === 403 ? EXIT_PLAN_LIMIT : EXIT_ERROR;
+        super(message, exitCode);
+        this.name = "ApiError";
+        this.statusCode = statusCode;
+        this.code = code;
+        this.requestId = requestId;
+      }
+    };
+    RateLimitError = class extends ApiError {
+      constructor(message, resetAt) {
+        super(message, 429, "RATE_LIMITED");
+        this.resetAt = resetAt;
+        this.name = "RateLimitError";
+      }
+    };
+    PlanLimitError = class extends CliError {
+      constructor(message, suggestion) {
+        super(message, EXIT_PLAN_LIMIT);
+        this.suggestion = suggestion;
+        this.name = "PlanLimitError";
+      }
+    };
+  }
+});
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports, module) {
+    module.exports = {
+      name: "anonli",
+      version: "1.0.0",
+      description: "anon.li CLI - encrypted file drops and anonymous email aliases",
+      type: "module",
+      license: "AGPL-3.0",
+      author: "anon.li",
+      homepage: "https://anon.li",
+      repository: {
+        type: "git",
+        url: "https://github.com/anondotli/cli"
+      },
+      bugs: {
+        url: "https://github.com/anondotli/cli/issues"
+      },
+      keywords: [
+        "cli",
+        "encrypted",
+        "file-sharing",
+        "email",
+        "alias",
+        "privacy",
+        "private",
+        "anonymous",
+        "e2ee"
+      ],
+      bin: {
+        anonli: "./bin/anonli.js"
+      },
+      files: [
+        "bin",
+        "dist"
+      ],
+      scripts: {
+        build: "tsup",
+        dev: "tsup --watch",
+        typecheck: "tsc --noEmit",
+        prepublishOnly: "npm run build"
+      },
+      dependencies: {
+        boxen: "^8.0.1",
+        chalk: "^5.6.2",
+        "cli-progress": "^3.12.0",
+        "cli-table3": "^0.6.5",
+        commander: "^13.1.0",
+        figures: "^6.1.0",
+        "hash-wasm": "^4.12.0",
+        "mime-types": "^2.1.35",
+        ora: "^8.2.0",
+        semver: "^7.7.4",
+        "terminal-link": "^3.0.0"
+      },
+      devDependencies: {
+        "@types/cli-progress": "^3.11.6",
+        "@types/mime-types": "^2.1.4",
+        "@types/node": "^22.19.15",
+        "@types/semver": "^7.7.1",
+        tsup: "^8.5.1",
+        typescript: "^5.9.3"
+      },
+      engines: {
+        node: ">=18"
+      }
+    };
+  }
+});
+
+// src/lib/constants.ts
+var MB, GB, MAX_CHUNKS_PER_FILE, MIN_CHUNK_SIZE, FILE_SIZE_THRESHOLD_1GB, ARGON2_MEMORY, ARGON2_TIME, ARGON2_PARALLELISM, ARGON2_HASH_LENGTH, AUTH_TAG_SIZE, IV_LENGTH, SALT_LENGTH, CLI_VERSION, MAX_RETRIES, RETRY_BASE_DELAY;
+var init_constants = __esm({
+  "src/lib/constants.ts"() {
+    "use strict";
+    MB = 1024 * 1024;
+    GB = 1024 * MB;
+    MAX_CHUNKS_PER_FILE = 100;
+    MIN_CHUNK_SIZE = 50 * MB;
+    FILE_SIZE_THRESHOLD_1GB = 1 * GB;
+    ARGON2_MEMORY = 65536;
+    ARGON2_TIME = 3;
+    ARGON2_PARALLELISM = 1;
+    ARGON2_HASH_LENGTH = 32;
+    AUTH_TAG_SIZE = 16;
+    IV_LENGTH = 12;
+    SALT_LENGTH = 32;
+    CLI_VERSION = require_package().version;
+    MAX_RETRIES = 3;
+    RETRY_BASE_DELAY = 1e3;
+  }
+});
+
+// src/lib/api.ts
+var api_exports = {};
+__export(api_exports, {
+  apiDelete: () => apiDelete,
+  apiFetch: () => apiFetch,
+  apiGet: () => apiGet,
+  apiGetList: () => apiGetList,
+  apiPatch: () => apiPatch,
+  apiPost: () => apiPost,
+  apiRawFetch: () => apiRawFetch,
+  extractRateLimit: () => extractRateLimit,
+  requireAuth: () => requireAuth
+});
+function getHeaders() {
+  const apiKey = getApiKey();
+  const headers = {
+    "Content-Type": "application/json",
+    "User-Agent": `anonli-cli/${CLI_VERSION}`
+  };
+  if (apiKey) {
+    headers["Authorization"] = `Bearer ${apiKey}`;
+  }
+  return headers;
+}
+function extractRateLimit(res) {
+  const limit = res.headers.get("X-RateLimit-Limit");
+  const remaining = res.headers.get("X-RateLimit-Remaining");
+  const reset = res.headers.get("X-RateLimit-Reset");
+  if (limit && remaining && reset) {
+    return {
+      limit: parseInt(limit, 10),
+      remaining: parseInt(remaining, 10),
+      reset: parseInt(reset, 10)
+    };
+  }
+  return void 0;
+}
+async function handleError(res) {
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+  }
+  if (res.status === 401) {
+    const rawMsg = (body && "error" in body && typeof body.error === "string" ? body.error : body?.error?.message) || "Unauthorized";
+    throw new AuthError(CODE_MESSAGES["UNAUTHORIZED"] ?? rawMsg);
+  }
+  if (res.status === 429) {
+    const resetHeader = res.headers.get("X-RateLimit-Reset");
+    const resetDate = resetHeader ? new Date(parseInt(resetHeader, 10)) : new Date(Date.now() + 6e4);
+    throw new RateLimitError(
+      body?.error?.message || "Rate limit exceeded",
+      resetDate
+    );
+  }
+  const apiCode = body?.error?.code;
+  const rawMessage = (body && "error" in body && typeof body.error === "object" ? body.error.message : body?.error) || `Request failed with status ${res.status}`;
+  const message = apiCode && CODE_MESSAGES[apiCode] || rawMessage;
+  throw new ApiError(
+    message,
+    res.status,
+    apiCode,
+    body?.meta?.request_id
+  );
+}
+async function fetchWithRetry(url, options, retries = MAX_RETRIES) {
+  let lastError = null;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      const res = await fetch(url, options);
+      if (res.status >= 400 && res.status < 500) {
+        return res;
+      }
+      if (res.status >= 500 && attempt < retries) {
+        await delay(RETRY_BASE_DELAY * Math.pow(2, attempt));
+        continue;
+      }
+      return res;
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (lastError.name === "AbortError") {
+        throw lastError;
+      }
+      if (attempt < retries) {
+        await delay(RETRY_BASE_DELAY * Math.pow(2, attempt));
+        continue;
+      }
+    }
+  }
+  throw lastError || new Error("Request failed after retries");
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function apiGet(path4, retry = true) {
+  const url = `${getBaseUrl()}${path4}`;
+  const res = retry ? await fetchWithRetry(url, { method: "GET", headers: getHeaders() }) : await fetch(url, { method: "GET", headers: getHeaders() });
+  if (!res.ok) await handleError(res);
+  const rateLimit = extractRateLimit(res);
+  const json = await res.json();
+  return { data: json.data, rateLimit };
+}
+async function apiGetList(path4) {
+  const url = `${getBaseUrl()}${path4}`;
+  const res = await fetchWithRetry(url, {
+    method: "GET",
+    headers: getHeaders()
+  });
+  if (!res.ok) await handleError(res);
+  const rateLimit = extractRateLimit(res);
+  const json = await res.json();
+  return {
+    data: json.data,
+    total: json.meta.total,
+    rateLimit,
+    meta: json.meta
+  };
+}
+async function apiPost(path4, body) {
+  const url = `${getBaseUrl()}${path4}`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: getHeaders(),
+    body: body !== void 0 ? JSON.stringify(body) : void 0
+  });
+  if (!res.ok) await handleError(res);
+  const rateLimit = extractRateLimit(res);
+  const json = await res.json();
+  return { data: json.data, rateLimit };
+}
+async function apiPatch(path4, body) {
+  const url = `${getBaseUrl()}${path4}`;
+  const res = await fetch(url, {
+    method: "PATCH",
+    headers: getHeaders(),
+    body: body !== void 0 ? JSON.stringify(body) : void 0
+  });
+  if (!res.ok) await handleError(res);
+  const rateLimit = extractRateLimit(res);
+  const json = await res.json();
+  return { data: json.data, rateLimit };
+}
+async function apiDelete(path4) {
+  const url = `${getBaseUrl()}${path4}`;
+  const res = await fetch(url, {
+    method: "DELETE",
+    headers: getHeaders()
+  });
+  if (!res.ok) await handleError(res);
+  return { rateLimit: extractRateLimit(res) };
+}
+async function apiRawFetch(url, options) {
+  return fetch(url, options);
+}
+async function apiFetch(path4, options = {}) {
+  const url = `${getBaseUrl()}${path4}`;
+  return fetch(url, {
+    ...options,
+    headers: {
+      ...getHeaders(),
+      ...options.headers
+    }
+  });
+}
+function requireAuth() {
+  if (!getApiKey()) {
+    throw new AuthError();
+  }
+}
+var CODE_MESSAGES;
+var init_api = __esm({
+  "src/lib/api.ts"() {
+    "use strict";
+    init_config2();
+    init_errors();
+    init_constants();
+    CODE_MESSAGES = {
+      NOT_FOUND: "Resource not found \u2014 it may have expired or been deleted",
+      QUOTA_EXCEEDED: "Storage limit reached \u2014 upgrade at anon.li/dashboard",
+      FORBIDDEN: "This feature requires a paid plan \u2014 see `anonli subscribe`",
+      UNAUTHORIZED: "Invalid or expired API key \u2014 run `anonli login` to re-authenticate"
+    };
+  }
+});
+
+// src/index.ts
+import { Command as Command26 } from "commander";
+
+// src/commands/login.ts
+import { Command } from "commander";
+
+// src/lib/auth.ts
+init_config2();
+init_api();
+
+// src/lib/ui.ts
+import chalk2 from "chalk";
+import ora from "ora";
+import cliProgress from "cli-progress";
+import figures from "figures";
+import boxen from "boxen";
+import Table from "cli-table3";
+import terminalLink from "terminal-link";
+import readline from "readline";
+
+// src/lib/theme.ts
+import chalk from "chalk";
+if (process.env.NO_COLOR !== void 0 || process.env.TERM === "dumb") {
+  chalk.level = 0;
+}
+var blue = chalk.hex("#6366F1");
+var brandColor = Object.assign(
+  (str) => blue(str),
+  { multiline: (str) => str.split("\n").map((line) => blue(line)).join("\n") }
+);
+var c = {
+  // Status
+  success: chalk.hex("#10B981"),
+  error: chalk.hex("#EF4444"),
+  warning: chalk.hex("#F59E0B"),
+  info: chalk.hex("#8B5CF6"),
+  // Text hierarchy
+  primary: chalk.hex("#F8FAFC"),
+  secondary: chalk.hex("#94A3B8"),
+  muted: chalk.hex("#64748B"),
+  subtle: chalk.hex("#475569"),
+  // Accents
+  accent: chalk.hex("#A78BFA"),
+  link: chalk.hex("#22D3EE"),
+  gold: chalk.hex("#FBBF24"),
+  // Borders
+  border: chalk.hex("#334155")
+};
+
+// src/lib/brand.ts
+init_config2();
+var LOGO = `
+   __ _ _ __   ___  _ __   | (_)
+  / _\` | '_ \\ / _ \\| '_ \\  | | |
+ | (_| | | | | (_) | | | |_| | |
+  \\__,_|_| |_|\\___/|_| |_(_)_|_|`;
+function printBanner(version) {
+  const logo = brandColor.multiline(LOGO.slice(1));
+  const tagline = c.secondary(" Encrypted drops & anonymous aliases") + c.muted(` v${version}`);
+  let greeting = "";
+  if (getApiKey()) {
+    const info2 = getUserInfo();
+    if (info2) {
+      const displayName = info2.name ? info2.name.split(" ")[0] : info2.email.split("@")[0];
+      greeting = "\n " + c.secondary("Welcome back, ") + c.primary(displayName) + c.secondary("!");
+    }
+  }
+  return `
+${logo}
+${tagline}${greeting}
+`;
+}
+function printHeader(commandName) {
+  const name = brandColor("anon.li");
+  const arrow = c.muted(" > ");
+  const cmd = c.primary(commandName);
+  const divider = c.subtle("\u2500".repeat(48));
+  return `${name}${arrow}${cmd}
+${divider}`;
+}
+function getCommandPath(cmd) {
+  const parts = [];
+  let current = cmd;
+  while (current) {
+    if (current.parent) {
+      parts.unshift(current.name());
+    }
+    current = current.parent;
+  }
+  return parts.join(" ");
+}
+function createHelpConfig(version) {
+  return {
+    formatHelp(cmd, helper) {
+      const isRoot = !cmd.parent;
+      let output = "";
+      if (isRoot) {
+        output += printBanner(version) + "\n";
+      } else {
+        output += printHeader(getCommandPath(cmd)) + "\n\n";
+      }
+      const desc = helper.commandDescription(cmd);
+      if (desc && !isRoot) {
+        output += `  ${c.secondary(desc)}
+
+`;
+      }
+      const usage = helper.commandUsage(cmd);
+      output += `  ${c.muted("Usage")}
+`;
+      output += `    ${c.subtle("$")} ${c.primary(usage)}
+`;
+      const args = helper.visibleArguments(cmd);
+      if (args.length > 0) {
+        const termLen = helper.longestArgumentTermLength(cmd, helper);
+        output += `
+  ${c.muted("Arguments")}
+`;
+        for (const arg of args) {
+          const term = helper.argumentTerm(arg);
+          const desc2 = helper.argumentDescription(arg);
+          output += `    ${c.accent(term.padEnd(termLen + 2))}  ${c.secondary(desc2)}
+`;
+        }
+      }
+      const cmds = helper.visibleCommands(cmd).filter(
+        (sub) => sub.name() !== "help"
+      );
+      if (cmds.length > 0) {
+        let maxLen = 0;
+        const items = cmds.map((sub) => {
+          const term = helper.subcommandTerm(sub);
+          if (term.length > maxLen) maxLen = term.length;
+          return { term, desc: helper.subcommandDescription(sub) };
+        });
+        output += `
+  ${c.muted("Commands")}
+`;
+        for (const { term, desc: desc2 } of items) {
+          output += `    ${c.accent(term.padEnd(maxLen + 2))}  ${c.secondary(desc2)}
+`;
+        }
+      }
+      const opts = helper.visibleOptions(cmd);
+      if (opts.length > 0) {
+        const termLen = helper.longestOptionTermLength(cmd, helper);
+        output += `
+  ${c.muted("Options")}
+`;
+        for (const opt of opts) {
+          const term = helper.optionTerm(opt);
+          const desc2 = helper.optionDescription(opt);
+          output += `    ${c.accent(term.padEnd(termLen + 2))}  ${c.secondary(desc2)}
+`;
+        }
+      }
+      output += "\n";
+      return output;
+    }
+  };
+}
+
+// src/lib/ui.ts
+var _quiet = false;
+function setQuiet(val) {
+  _quiet = val;
+}
+function outputJson(data) {
+  process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+}
+function spinner(text) {
+  return ora({
+    text: c.secondary(text),
+    color: "magenta",
+    isSilent: _quiet
+  }).start();
+}
+function success(message) {
+  if (_quiet) return;
+  console.log(c.success(figures.tick) + " " + c.primary(message));
+}
+function error(message) {
+  console.error(c.error(figures.cross) + " " + c.primary(message));
+}
+function warn(message) {
+  if (_quiet) return;
+  console.log(c.warning(figures.warning) + " " + c.secondary(message));
+}
+function info(message) {
+  if (_quiet) return;
+  console.log(c.info(figures.info) + " " + c.secondary(message));
+}
+function dim(text) {
+  return c.muted(text);
+}
+function bold(text) {
+  return c.primary(chalk2.bold(text));
+}
+function link(url) {
+  return terminalLink(c.link(url), url, {
+    fallback: () => c.link(url)
+  });
+}
+function header(title) {
+  if (_quiet) return;
+  console.log(printHeader(title));
+}
+function spacer() {
+  if (_quiet) return;
+  console.log();
+}
+function keyValue(label, value, indent = 2) {
+  if (_quiet) return;
+  const pad = " ".repeat(indent);
+  console.log(`${pad}${c.secondary(label + ":")}  ${c.primary(value)}`);
+}
+function sectionTitle(title) {
+  if (_quiet) return;
+  console.log(c.secondary(chalk2.bold(title)));
+}
+function successBox(title, content) {
+  if (_quiet) return;
+  console.log(
+    boxen(content, {
+      title: c.success(figures.tick + " " + title),
+      titleAlignment: "left",
+      borderStyle: "round",
+      borderColor: "#10B981",
+      padding: { top: 0, bottom: 0, left: 1, right: 1 },
+      margin: { top: 1, bottom: 0, left: 0, right: 0 }
+    })
+  );
+}
+function errorBox(title, message, suggestion) {
+  let content = c.primary(message);
+  if (suggestion) {
+    content += "\n" + c.muted(suggestion);
+  }
+  console.log(
+    boxen(content, {
+      title: c.error(figures.cross + " " + title),
+      titleAlignment: "left",
+      borderStyle: "round",
+      borderColor: "#EF4444",
+      padding: { top: 0, bottom: 0, left: 1, right: 1 },
+      margin: { top: 1, bottom: 0, left: 0, right: 0 }
+    })
+  );
+}
+function box(content, opts) {
+  if (_quiet) return;
+  console.log(
+    boxen(content, {
+      title: opts?.title,
+      titleAlignment: "left",
+      borderStyle: "round",
+      borderColor: opts?.borderColor || "#334155",
+      padding: { top: 0, bottom: 0, left: 1, right: 1 },
+      margin: { top: 1, bottom: 0, left: 0, right: 0 }
+    })
+  );
+}
+function confirm(prompt2) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const styled = `${c.warning(figures.warning)} ${c.primary(prompt2)} ${c.muted("[y/N]")} `;
+    rl.question(styled, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y");
+    });
+  });
+}
+function prompt(question, opts) {
+  const styled = `${c.info(figures.pointer)} ${c.primary(question)} `;
+  if (!opts?.mask) {
+    return new Promise((resolve) => {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      rl.question(styled, (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    });
+  }
+  return new Promise((resolve) => {
+    process.stdout.write(styled);
+    const stdin = process.stdin;
+    if (!stdin.isTTY) {
+      const rl = readline.createInterface({ input: stdin });
+      rl.once("line", (line) => {
+        rl.close();
+        console.log();
+        resolve(line.trim());
+      });
+      return;
+    }
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    let input = "";
+    const onData = (data) => {
+      for (const ch of data) {
+        if (ch === "\r" || ch === "\n") {
+          stdin.setRawMode(wasRaw);
+          stdin.removeListener("data", onData);
+          stdin.pause();
+          console.log();
+          resolve(input.trim());
+          return;
+        } else if (ch === "") {
+          stdin.setRawMode(wasRaw);
+          stdin.removeListener("data", onData);
+          stdin.pause();
+          console.log();
+          process.exit(0);
+          return;
+        } else if (ch === "\x7F" || ch === "\b") {
+          if (input.length > 0) {
+            input = input.slice(0, -1);
+            process.stdout.write("\b \b");
+          }
+        } else if (ch.charCodeAt(0) >= 32) {
+          input += ch;
+          process.stdout.write(c.muted("*"));
+        }
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+function usageBar(used, limit, width = 12) {
+  if (limit === 0) {
+    return used > 0 ? c.error("\u2593".repeat(width)) : c.subtle("\u2591".repeat(width));
+  }
+  const ratio = Math.min(used / limit, 1);
+  const filled = Math.round(ratio * width);
+  const empty = width - filled;
+  let colorFn = c.success;
+  if (used > limit) colorFn = c.error;
+  else if (ratio >= 0.9) colorFn = c.warning;
+  else if (ratio >= 0.7) colorFn = c.warning;
+  return colorFn("\u2593".repeat(filled)) + c.subtle("\u2591".repeat(empty));
+}
+function usageRow(label, used, limit, opts) {
+  if (_quiet) return;
+  const labelWidth = opts?.labelWidth ?? 14;
+  const barWidth = opts?.barWidth ?? 12;
+  const pad = "  ";
+  const paddedLabel = c.secondary((label + ":").padEnd(labelWidth));
+  if (limit === void 0) {
+    console.log(`${pad}${paddedLabel} ${c.primary(String(used))}`);
+    return;
+  }
+  const bar = usageBar(used, limit, barWidth);
+  const count = `${used}/${limit}`;
+  const overLimit = used > limit;
+  const countStr = overLimit ? c.error(count) : c.primary(count);
+  const warnStr = overLimit ? " " + c.warning("\u25B2") : "";
+  console.log(`${pad}${paddedLabel} ${bar}  ${countStr}${warnStr}`);
+}
+function storageRow(label, used, limit, opts) {
+  if (_quiet) return;
+  const labelWidth = opts?.labelWidth ?? 14;
+  const barWidth = opts?.barWidth ?? 12;
+  const pad = "  ";
+  const paddedLabel = c.secondary((label + ":").padEnd(labelWidth));
+  const bar = usageBar(used, limit, barWidth);
+  console.log(
+    `${pad}${paddedLabel} ${bar}  ${c.primary(formatBytes(used))}${c.muted("/")}${c.primary(formatBytes(limit))}`
+  );
+}
+function statusBadge(label, variant) {
+  if (variant === "active") {
+    return c.success("\u25CF") + " " + c.success(label);
+  }
+  return c.error("\u25CB") + " " + c.error(label);
+}
+function tierBadge(tier, product) {
+  const t = tier.toLowerCase();
+  const productLabel = product ? ` (${product.charAt(0).toUpperCase() + product.slice(1)})` : "";
+  if (t === "pro") return c.gold(chalk2.bold("PRO")) + c.muted(productLabel);
+  if (t === "plus") return c.accent(chalk2.bold("PLUS")) + c.muted(productLabel);
+  return c.muted("Free");
+}
+function progressBar(total, label) {
+  const bar = new cliProgress.SingleBar(
+    {
+      format: `  ${c.secondary(label)} ${chalk2.hex("#8B5CF6")("{bar}")} ${c.primary("{percentage}%")} ${c.subtle("\u2503")} ${c.muted("{value}/{total}")}`,
+      barCompleteChar: "\u2501",
+      barIncompleteChar: chalk2.hex("#334155")("\u2501"),
+      hideCursor: true,
+      noTTYOutput: _quiet
+    },
+    cliProgress.Presets.shades_classic
+  );
+  bar.start(total, 0);
+  return bar;
+}
+function showRateLimit(rateLimit) {
+  if (!rateLimit || _quiet) return;
+  console.log(
+    c.subtle(
+      `  ${figures.bullet} API: ${rateLimit.remaining}/${rateLimit.limit} requests remaining`
+    )
+  );
+}
+function table(headers, rows) {
+  if (_quiet) return;
+  const t = new Table({
+    head: headers.map((h) => c.secondary(chalk2.bold(h))),
+    chars: {
+      top: c.subtle("\u2500"),
+      "top-mid": c.subtle("\u252C"),
+      "top-left": c.subtle("\u256D"),
+      "top-right": c.subtle("\u256E"),
+      bottom: c.subtle("\u2500"),
+      "bottom-mid": c.subtle("\u2534"),
+      "bottom-left": c.subtle("\u2570"),
+      "bottom-right": c.subtle("\u256F"),
+      left: c.subtle("\u2502"),
+      "left-mid": c.subtle("\u251C"),
+      mid: c.subtle("\u2500"),
+      "mid-mid": c.subtle("\u253C"),
+      right: c.subtle("\u2502"),
+      "right-mid": c.subtle("\u2524"),
+      middle: c.subtle("\u2502")
+    },
+    style: {
+      head: [],
+      border: [],
+      "padding-left": 1,
+      "padding-right": 1
+    }
+  });
+  for (const row of rows) {
+    t.push(row);
+  }
+  console.log(t.toString());
+}
+function updateNotice(current, latest) {
+  if (_quiet) return;
+  const content = [
+    `${c.muted("Current:")} ${c.primary(current)}  ${c.muted("\u2192")}  ${c.muted("Latest:")} ${c.success(latest)}`,
+    "",
+    `${c.secondary("Run")} ${c.accent("anonli update")} ${c.secondary("to upgrade")}`
+  ].join("\n");
+  console.log(
+    boxen(content, {
+      title: c.warning(figures.warning + " Update Available"),
+      titleAlignment: "left",
+      borderStyle: "round",
+      borderColor: "#F59E0B",
+      padding: { top: 0, bottom: 0, left: 1, right: 1 },
+      margin: { top: 1, bottom: 0, left: 0, right: 0 }
+    })
+  );
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}
+function formatDate(iso) {
+  return new Date(iso).toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+}
+function formatDays(days) {
+  if (days === 1) return "24 hours";
+  return `${days} days`;
+}
+function alignedKeyValue(label, value, labelWidth = 18, indent = 2) {
+  if (_quiet) return;
+  const pad = " ".repeat(indent);
+  const paddedLabel = (label + ":").padEnd(labelWidth);
+  console.log(`${pad}${c.secondary(paddedLabel)} ${c.primary(value)}`);
+}
+
+// src/lib/auth.ts
+async function runAuthFlow(token) {
+  let apiKey = token;
+  if (!apiKey) {
+    info(
+      `Get your API key from ${link("https://anon.li/dashboard/settings/api")}`
+    );
+    spacer();
+    apiKey = await prompt("API key:", { mask: true });
+  }
+  if (!apiKey) {
+    error("No API key provided.");
+    return false;
+  }
+  if (!apiKey.startsWith("ak_")) {
+    errorBox(
+      "Invalid Key",
+      'API keys start with "ak_".',
+      "Get your key at https://anon.li/dashboard/settings/api"
+    );
+    return false;
+  }
+  const spin = spinner("Validating API key...");
+  try {
+    setApiKey(apiKey);
+    const result = await apiGet("/api/v1/me");
+    spin.stop();
+    setUserInfo(result.data.email, result.data.name);
+    const badge = tierBadge(result.data.tier, result.data.product);
+    successBox(
+      "Authenticated",
+      `Logged in as ${c.accent(result.data.email)} ${badge}`
+    );
+    showRateLimit(result.rateLimit);
+    return true;
+  } catch (err) {
+    removeApiKey();
+    spin.stop();
+    errorBox(
+      "Authentication Failed",
+      err instanceof Error ? err.message : "Invalid API key.",
+      "Get your key at https://anon.li/dashboard/settings/api"
+    );
+    return false;
+  }
+}
+
+// src/commands/login.ts
+init_config2();
+var loginCommand = new Command("login").description("Authenticate with your API key").option("--token <key>", "API key (or enter interactively)").action(async (options) => {
+  if (getApiKey()) {
+    errorBox(
+      "Already Logged In",
+      "You are already authenticated.",
+      "Run `anonli logout` first, then try again."
+    );
+    process.exit(1);
+  }
+  const success2 = await runAuthFlow(options.token);
+  if (!success2) {
+    process.exit(1);
+  }
+});
+
+// src/commands/logout.ts
+init_config2();
+import { Command as Command2 } from "commander";
+var logoutCommand = new Command2("logout").description("Remove stored API key").action(() => {
+  if (!getApiKey()) {
+    info("Not currently authenticated.");
+    return;
+  }
+  removeApiKey();
+  success("Logged out. API key removed.");
+});
+
+// src/commands/whoami.ts
+init_api();
+init_config2();
+import { Command as Command3 } from "commander";
+var whoamiCommand = new Command3("whoami").description("Show current user info").option("--json", "Output raw JSON").action(async (options) => {
+  requireAuth();
+  const spin = spinner("Fetching account info...");
+  try {
+    const result = await apiGet("/api/v1/me");
+    spin.stop();
+    const d = result.data;
+    setUserInfo(d.email, d.name);
+    if (options.json) {
+      outputJson(d);
+      return;
+    }
+    header(d.email);
+    const badge = tierBadge(d.tier, d.product);
+    console.log(
+      `  ${badge} ${c.muted("\xB7")} ${c.secondary("Joined")} ${c.primary(formatDate(d.created_at))}`
+    );
+    spacer();
+    sectionTitle("Alias");
+    usageRow("Random", d.aliases.random.used, d.aliases.random.limit);
+    usageRow("Custom", d.aliases.custom.used, d.aliases.custom.limit);
+    usageRow("Recipients", d.recipients.used, d.recipients.limit);
+    usageRow("Domains", d.domains.used, d.domains.limit);
+    spacer();
+    sectionTitle("Drop");
+    usageRow("Active", d.drops.count);
+    storageRow("Storage", parseInt(d.storage.used), parseInt(d.storage.limit));
+    alignedKeyValue("Max File", formatBytes(d.limits.max_file_size), 14);
+    alignedKeyValue("Expiry", formatDays(d.limits.max_expiry_days), 14);
+    spacer();
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to fetch account info.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/drop.ts
+import { Command as Command11 } from "commander";
+
+// src/commands/drop-upload.ts
+init_api();
+import { Command as Command4 } from "commander";
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+
+// src/lib/limits.ts
+init_api();
+init_errors();
+var FEATURE_MAP = {
+  noBranding: { label: "Hide branding", tier: "Pro" },
+  downloadNotifications: { label: "Download notifications", tier: "Pro" },
+  customKey: { label: "Password protection", tier: "Plus" }
+};
+async function fetchPlanInfo() {
+  const { data } = await apiGet("/api/v1/me");
+  return data;
+}
+function assertFeature(features, featureKey, flagName) {
+  if (features[featureKey]) return;
+  const info2 = FEATURE_MAP[featureKey];
+  const label = info2?.label ?? featureKey;
+  const tier = info2?.tier ?? "a paid";
+  throw new PlanLimitError(
+    `${label} (${flagName}) requires a ${tier} plan.`,
+    `Upgrade with: anonli subscribe`
+  );
+}
+function assertCountLimit(resourceName, used, limit) {
+  if (limit === 0) {
+    throw new PlanLimitError(
+      `${capitalize(resourceName)} is not available on your plan.`,
+      `Upgrade with: anonli subscribe`
+    );
+  }
+  if (used >= limit) {
+    throw new PlanLimitError(
+      `${capitalize(resourceName)} limit reached (${used}/${limit}).`,
+      `Upgrade with: anonli subscribe`
+    );
+  }
+}
+function assertStorageLimit(totalUploadSize, storageUsed, storageLimit) {
+  const used = BigInt(storageUsed);
+  const limit = BigInt(storageLimit);
+  const upload = BigInt(totalUploadSize);
+  if (used + upload > limit) {
+    const available = limit > used ? Number(limit - used) : 0;
+    throw new PlanLimitError(
+      `Upload size (${formatBytes(totalUploadSize)}) exceeds available storage (${formatBytes(available)} of ${formatBytes(Number(limit))} remaining).`,
+      `Upgrade with: anonli subscribe`
+    );
+  }
+}
+function warnExpiryCap(requestedDays, maxDays) {
+  if (requestedDays > maxDays) {
+    warn(
+      `Expiry capped to ${maxDays} days on your plan (requested ${requestedDays}).`
+    );
+    return maxDays;
+  }
+  return requestedDays;
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+// src/commands/drop-upload.ts
+init_config2();
+
+// src/lib/crypto.ts
+init_constants();
+import { webcrypto } from "crypto";
+import { argon2id } from "hash-wasm";
+var subtle = webcrypto.subtle;
+var getRandomValues = webcrypto.getRandomValues.bind(webcrypto);
+var ALGORITHM = { name: "AES-GCM", length: 256 };
+async function generateKey() {
+  const key = await subtle.generateKey(ALGORITHM, true, [
+    "encrypt",
+    "decrypt"
+  ]);
+  const exported = await subtle.exportKey("raw", key);
+  return arrayBufferToBase64Url(exported);
+}
+async function importKey(keyString) {
+  const keyData = base64UrlToArrayBuffer(keyString);
+  return subtle.importKey("raw", keyData, ALGORITHM, true, [
+    "encrypt",
+    "decrypt"
+  ]);
+}
+async function createEncryptionContext() {
+  const keyString = await generateKey();
+  const key = await importKey(keyString);
+  const ivString = generateBaseIv();
+  const baseIv = new Uint8Array(base64UrlToArrayBuffer(ivString));
+  return { key, keyString, baseIv, ivString };
+}
+async function encryptChunk(chunk, key, baseIv, chunkIndex) {
+  const iv = generateChunkIv(baseIv, chunkIndex);
+  return subtle.encrypt({ name: "AES-GCM", iv: getView(iv) }, key, chunk);
+}
+async function decryptChunk(encryptedChunk, key, baseIv, chunkIndex) {
+  const iv = generateChunkIv(baseIv, chunkIndex);
+  return subtle.decrypt(
+    { name: "AES-GCM", iv: getView(iv) },
+    key,
+    encryptedChunk
+  );
+}
+async function encryptFilename(filename, key, iv) {
+  const encoder = new TextEncoder();
+  const filenameBuffer = encoder.encode(filename);
+  const filenameIv = generateChunkIv(iv, 4294967295);
+  const encrypted = await subtle.encrypt(
+    { name: "AES-GCM", iv: getView(filenameIv) },
+    key,
+    filenameBuffer
+  );
+  return arrayBufferToBase64Url(encrypted);
+}
+async function decryptFilename(encryptedFilename, key, iv) {
+  const encrypted = base64UrlToArrayBuffer(encryptedFilename);
+  const filenameIv = generateChunkIv(iv, 4294967295);
+  const decrypted = await subtle.decrypt(
+    { name: "AES-GCM", iv: getView(filenameIv) },
+    key,
+    encrypted
+  );
+  return new TextDecoder().decode(decrypted);
+}
+async function encryptKeyWithPassword(keyString, password) {
+  const salt = generateSalt();
+  const wrappingKey = await deriveKeyFromPassword(password, salt);
+  const iv = generateBaseIv();
+  const ivBuffer = new Uint8Array(base64UrlToArrayBuffer(iv));
+  const encoder = new TextEncoder();
+  const keyData = encoder.encode(keyString);
+  const encrypted = await subtle.encrypt(
+    { name: "AES-GCM", iv: ivBuffer },
+    wrappingKey,
+    keyData
+  );
+  return {
+    encryptedKey: arrayBufferToBase64Url(encrypted),
+    iv,
+    salt
+  };
+}
+async function decryptKeyWithPassword(encryptedKey, password, salt, iv) {
+  const wrappingKey = await deriveKeyFromPassword(password, salt);
+  const ivBuffer = new Uint8Array(base64UrlToArrayBuffer(iv));
+  const encryptedData = base64UrlToArrayBuffer(encryptedKey);
+  const decrypted = await subtle.decrypt(
+    { name: "AES-GCM", iv: ivBuffer },
+    wrappingKey,
+    encryptedData
+  );
+  return new TextDecoder().decode(decrypted);
+}
+function getChunkParams(fileSize) {
+  if (fileSize <= MIN_CHUNK_SIZE) {
+    return { chunkSize: fileSize || 1, chunkCount: 1 };
+  }
+  const chunksNeeded = Math.ceil(fileSize / MIN_CHUNK_SIZE);
+  if (chunksNeeded <= MAX_CHUNKS_PER_FILE) {
+    return {
+      chunkSize: Math.ceil(fileSize / chunksNeeded),
+      chunkCount: chunksNeeded
+    };
+  } else {
+    return {
+      chunkSize: Math.ceil(fileSize / MAX_CHUNKS_PER_FILE),
+      chunkCount: MAX_CHUNKS_PER_FILE
+    };
+  }
+}
+function calculateEncryptedSize(originalSize, chunkSize) {
+  const chunkCount = Math.ceil(originalSize / chunkSize);
+  return originalSize + chunkCount * AUTH_TAG_SIZE;
+}
+function getConcurrency(fileSize) {
+  return fileSize < FILE_SIZE_THRESHOLD_1GB ? 3 : 5;
+}
+function generateChunkIv(baseIv, chunkIndex) {
+  const iv = new Uint8Array(IV_LENGTH);
+  iv.set(baseIv.slice(0, 8));
+  const view = new DataView(iv.buffer);
+  view.setUint32(8, chunkIndex, false);
+  return iv;
+}
+function generateBaseIv() {
+  const iv = getRandomValues(new Uint8Array(IV_LENGTH));
+  return arrayBufferToBase64Url(iv);
+}
+function generateSalt() {
+  const salt = getRandomValues(new Uint8Array(SALT_LENGTH));
+  return arrayBufferToBase64Url(salt);
+}
+async function deriveKeyFromPassword(password, salt) {
+  const saltBytes = new Uint8Array(base64UrlToArrayBuffer(salt));
+  const hash = await argon2id({
+    password,
+    salt: saltBytes,
+    memorySize: ARGON2_MEMORY,
+    iterations: ARGON2_TIME,
+    parallelism: ARGON2_PARALLELISM,
+    hashLength: ARGON2_HASH_LENGTH,
+    outputType: "binary"
+  });
+  return subtle.importKey(
+    "raw",
+    hash,
+    ALGORITHM,
+    true,
+    ["encrypt", "decrypt"]
+  );
+}
+function getView(arr) {
+  if (arr instanceof ArrayBuffer) return arr;
+  return arr.buffer.slice(
+    arr.byteOffset,
+    arr.byteOffset + arr.byteLength
+  );
+}
+function arrayBufferToBase64Url(buffer) {
+  const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+  return Buffer.from(bytes).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64UrlToArrayBuffer(base64url) {
+  let base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
+  while (base64.length % 4) {
+    base64 += "=";
+  }
+  const buf = Buffer.from(base64, "base64");
+  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+}
+
+// src/commands/drop-upload.ts
+import { lookup } from "mime-types";
+function collectFiles(inputPath) {
+  const stat = fs2.statSync(inputPath);
+  if (stat.isFile()) {
+    return [
+      {
+        absolutePath: inputPath,
+        relativeName: path2.basename(inputPath),
+        size: stat.size
+      }
+    ];
+  }
+  if (stat.isDirectory()) {
+    const entries = [];
+    const walk = (dir, prefix) => {
+      for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path2.join(dir, entry.name);
+        const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.isFile()) {
+          entries.push({
+            absolutePath: fullPath,
+            relativeName: relPath,
+            size: fs2.statSync(fullPath).size
+          });
+        } else if (entry.isDirectory()) {
+          walk(fullPath, relPath);
+        }
+      }
+    };
+    walk(inputPath, "");
+    return entries;
+  }
+  throw new Error(`${inputPath} is not a file or directory`);
+}
+function checkPasswordStrength(password) {
+  if (password.length < 12) {
+    warn(`Password is short (${password.length} chars). At least 12 characters recommended.`);
+    return;
+  }
+  const uniqueChars = new Set(password).size;
+  const entropy = password.length * Math.log2(Math.max(uniqueChars, 2));
+  if (entropy < 40) {
+    warn("Password may be weak (low entropy). Consider a longer, more varied passphrase.");
+  }
+}
+var dropUploadCommand = new Command4("upload").argument("[path]", "File or folder to upload (omit to read from stdin)").description("Create an encrypted drop").option("-t, --title <title>", "Drop title").option("-m, --message <message>", "Drop message").option("-e, --expiry <days>", "Expiry in days", parseInt).option("-n, --max-downloads <n>", "Max download count", parseInt).option("-p, --password <password>", "Password-protect the drop").option("--name <filename>", "Filename when reading from stdin").option("--hide-branding", "Hide anon.li branding on download page").option("--notify", "Send email notification when files are downloaded").action(async (inputPath, options) => {
+  requireAuth();
+  let files;
+  let stdinTmpFile;
+  if (!inputPath) {
+    if (process.stdin.isTTY) {
+      error("No path provided. Provide a file/folder path, or pipe data via stdin.");
+      process.exit(1);
+    }
+    if (!options.name) {
+      error("--name <filename> is required when uploading from stdin.");
+      process.exit(1);
+    }
+    const spin = spinner("Reading from stdin...");
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    const data = Buffer.concat(chunks);
+    spin.stop();
+    stdinTmpFile = path2.join(os2.tmpdir(), `anonli-stdin-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    fs2.writeFileSync(stdinTmpFile, data, { mode: 384 });
+    files = [{
+      absolutePath: stdinTmpFile,
+      relativeName: options.name,
+      size: data.length,
+      tmpFile: true
+    }];
+  } else {
+    const resolved = path2.resolve(inputPath);
+    if (!fs2.existsSync(resolved)) {
+      error(`Path not found: ${resolved}`);
+      process.exit(1);
+    }
+    files = collectFiles(resolved);
+  }
+  if (files.length === 0) {
+    error("No files found.");
+    process.exit(1);
+  }
+  const totalSize = files.reduce((sum, f) => sum + f.size, 0);
+  info(
+    `${files.length} file(s), ${formatBytes(totalSize)} total`
+  );
+  if (options.password) {
+    checkPasswordStrength(options.password);
+  }
+  const limitSpin = spinner("Checking plan limits...");
+  const plan = await fetchPlanInfo();
+  limitSpin.stop();
+  if (options.hideBranding) {
+    assertFeature(plan.features, "noBranding", "--hide-branding");
+  }
+  if (options.notify) {
+    assertFeature(plan.features, "downloadNotifications", "--notify");
+  }
+  if (options.password) {
+    assertFeature(plan.features, "customKey", "--password");
+  }
+  assertStorageLimit(totalSize, plan.storage.used, plan.storage.limit);
+  if (options.expiry) {
+    options.expiry = warnExpiryCap(options.expiry, plan.limits.max_expiry_days);
+  }
+  try {
+    const ctx = await createEncryptionContext();
+    const { key, keyString, baseIv, ivString } = ctx;
+    let customKey = false;
+    let salt;
+    let customKeyData;
+    let customKeyIv;
+    if (options.password) {
+      const protection = await encryptKeyWithPassword(
+        keyString,
+        options.password
+      );
+      customKey = true;
+      salt = protection.salt;
+      customKeyData = protection.encryptedKey;
+      customKeyIv = protection.iv;
+    }
+    let encryptedTitle;
+    let encryptedMessage;
+    if (options.title) {
+      encryptedTitle = await encryptFilename(
+        options.title,
+        key,
+        baseIv
+      );
+    }
+    if (options.message) {
+      encryptedMessage = await encryptFilename(
+        options.message,
+        key,
+        baseIv
+      );
+    }
+    const createSpin = spinner("Creating drop...");
+    const createRes = await apiFetch("/api/v1/drop", {
+      method: "POST",
+      body: JSON.stringify({
+        iv: ivString,
+        fileCount: files.length,
+        ...encryptedTitle && { encryptedTitle },
+        ...encryptedMessage && { encryptedMessage },
+        ...options.expiry && { expiry: options.expiry },
+        ...options.maxDownloads && { maxDownloads: options.maxDownloads },
+        ...options.hideBranding && { hideBranding: true },
+        ...options.notify && { notifyOnDownload: true },
+        ...customKey && {
+          customKey: true,
+          salt,
+          customKeyData,
+          customKeyIv
+        }
+      })
+    });
+    if (!createRes.ok) {
+      const err = await createRes.json().catch(() => ({}));
+      createSpin.fail("Failed to create drop");
+      error(
+        err?.error?.message || err?.error || "Unknown error"
+      );
+      process.exit(1);
+    }
+    const createData = await createRes.json();
+    const { drop_id: dropId, session_token: sessionToken } = createData.data;
+    createSpin.succeed(`Drop created: ${dropId}`);
+    const fileChunkRecords = [];
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      const { chunkSize, chunkCount } = getChunkParams(file.size);
+      const encryptedSize = calculateEncryptedSize(
+        file.size,
+        chunkSize
+      );
+      const encryptedName = await encryptFilename(
+        file.relativeName,
+        key,
+        baseIv
+      );
+      const addRes = await apiFetch(`/api/v1/drop/${dropId}/file`, {
+        method: "POST",
+        body: JSON.stringify({
+          size: encryptedSize,
+          encryptedName,
+          iv: ivString,
+          mimeType: lookup(file.absolutePath) || "application/octet-stream",
+          chunkCount,
+          chunkSize,
+          ...sessionToken && { sessionToken }
+        })
+      });
+      if (!addRes.ok) {
+        const err = await addRes.json().catch(() => ({}));
+        error(
+          `Failed to add file ${file.relativeName}: ${err?.error || "Unknown error"}`
+        );
+        process.exit(1);
+      }
+      const addData = await addRes.json();
+      const { fileId, uploadUrls } = addData;
+      const bar = progressBar(
+        chunkCount,
+        `${files.length > 1 ? `[${i + 1}/${files.length}] ` : ""}${file.relativeName}`
+      );
+      const chunks = [];
+      const concurrency = getConcurrency(file.size);
+      const fd = fs2.openSync(file.absolutePath, "r");
+      try {
+        let nextChunk = 0;
+        async function processChunk(chunkIndex) {
+          const start = chunkIndex * chunkSize;
+          const end = Math.min(start + chunkSize, file.size);
+          const length = end - start;
+          const buffer = Buffer.alloc(length);
+          fs2.readSync(fd, buffer, 0, length, start);
+          const encrypted = await encryptChunk(
+            buffer.buffer.slice(
+              buffer.byteOffset,
+              buffer.byteOffset + buffer.byteLength
+            ),
+            key,
+            baseIv,
+            chunkIndex
+          );
+          const presignedUrl = uploadUrls[String(chunkIndex + 1)];
+          let url = presignedUrl;
+          const headers = {};
+          if (url.includes("/relay/") && url.includes("?")) {
+            const splitIndex = url.indexOf("?");
+            const baseUrl2 = url.slice(0, splitIndex);
+            const query = url.slice(splitIndex + 1);
+            url = baseUrl2;
+            headers["X-Relay-Query"] = query;
+          }
+          const uploadRes = await apiRawFetch(url, {
+            method: "PUT",
+            headers,
+            body: new Uint8Array(encrypted)
+          });
+          if (!uploadRes.ok) {
+            throw new Error(
+              `Failed to upload chunk ${chunkIndex} of ${file.relativeName}`
+            );
+          }
+          const etag = uploadRes.headers.get("ETag") || "";
+          chunks.push({ chunkIndex, etag });
+          bar.increment();
+        }
+        let firstError = null;
+        const running = [];
+        while (nextChunk < chunkCount && !firstError) {
+          while (running.length < concurrency && nextChunk < chunkCount && !firstError) {
+            const idx = nextChunk++;
+            const p = processChunk(idx).then(() => {
+              running.splice(running.indexOf(p), 1);
+            }).catch((err) => {
+              firstError = err instanceof Error ? err : new Error(String(err));
+              running.splice(running.indexOf(p), 1);
+            });
+            running.push(p);
+          }
+          if (running.length > 0) {
+            await Promise.race(running);
+          }
+        }
+        if (running.length > 0) {
+          await Promise.allSettled(running);
+        }
+        if (firstError) {
+          throw firstError;
+        }
+      } finally {
+        fs2.closeSync(fd);
+      }
+      bar.stop();
+      chunks.sort((a, b) => a.chunkIndex - b.chunkIndex);
+      fileChunkRecords.push({ fileId, chunks });
+    }
+    const finishSpin = spinner("Finalizing drop...");
+    const finishRes = await apiFetch(
+      `/api/v1/drop/${dropId}?action=finish`,
+      {
+        method: "PATCH",
+        body: JSON.stringify({
+          files: fileChunkRecords,
+          ...sessionToken && { sessionToken }
+        })
+      }
+    );
+    if (!finishRes.ok) {
+      const err = await finishRes.json().catch(() => ({}));
+      finishSpin.fail("Failed to finalize drop");
+      error(
+        err?.error || "Unknown error"
+      );
+      process.exit(1);
+    }
+    finishSpin.stop();
+    const baseUrl = getBaseUrl();
+    const shareUrl = customKey ? `${baseUrl}/d/${dropId}` : `${baseUrl}/d/${dropId}#${keyString}`;
+    const boxLines = [
+      `${c.secondary("URL:")}   ${link(shareUrl)}`,
+      `${c.secondary("Files:")} ${c.primary(String(files.length))}`,
+      `${c.secondary("Size:")}  ${c.primary(formatBytes(totalSize))}`
+    ];
+    if (options.expiry) {
+      boxLines.push(`${c.secondary("Expiry:")} ${c.primary(String(options.expiry))} days`);
+    }
+    if (options.maxDownloads) {
+      boxLines.push(`${c.secondary("Max downloads:")} ${c.primary(String(options.maxDownloads))}`);
+    }
+    if (options.hideBranding) {
+      boxLines.push(`${c.secondary("Branding:")} ${c.muted("hidden")}`);
+    }
+    if (options.notify) {
+      boxLines.push(`${c.secondary("Notifications:")} ${c.accent("enabled")}`);
+    }
+    successBox("Drop Created", boxLines.join("\n"));
+    spacer();
+    if (!customKey) {
+      warn(
+        "Save this URL \u2014 the key after # is required to decrypt."
+      );
+    } else {
+      info("Password-protected. Share the URL and password separately.");
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : "Upload failed");
+    process.exit(1);
+  } finally {
+    if (stdinTmpFile) {
+      try {
+        fs2.unlinkSync(stdinTmpFile);
+      } catch {
+      }
+    }
+  }
+});
+
+// src/commands/drop-list.ts
+init_api();
+import { Command as Command5 } from "commander";
+var dropListCommand = new Command5("list").alias("ls").description("List your drops").option("--limit <n>", "Number of drops to fetch", parseInt).option("--offset <n>", "Offset for pagination", parseInt).option("--expired", "Show only expired drops").option("--disabled", "Show only disabled drops").option("--enabled", "Show only enabled drops").option("--sort <field>", "Sort by: created, expiry, size, downloads", "created").option("--order <dir>", "Sort direction: asc, desc", "desc").option("--json", "Output raw JSON").action(async (options) => {
+  requireAuth();
+  const spin = spinner("Fetching drops...");
+  try {
+    const limit = options.limit ?? 50;
+    const offset = options.offset ?? 0;
+    const result = await apiGetList(
+      `/api/v1/drop?limit=${limit}&offset=${offset}`
+    );
+    spin.stop();
+    if (options.json) {
+      outputJson(result.data);
+      return;
+    }
+    let data = result.data;
+    const now = /* @__PURE__ */ new Date();
+    if (options.expired) {
+      data = data.filter((d) => d.expires_at && new Date(d.expires_at) < now);
+    }
+    if (options.disabled) {
+      data = data.filter((d) => d.disabled);
+    }
+    if (options.enabled) {
+      data = data.filter((d) => !d.disabled);
+    }
+    if (options.sort) {
+      data = [...data].sort((a, b) => {
+        let cmp = 0;
+        switch (options.sort) {
+          case "expiry":
+            cmp = (a.expires_at ?? "").localeCompare(b.expires_at ?? "");
+            break;
+          case "size":
+            cmp = parseInt(a.totalSize || "0") - parseInt(b.totalSize || "0");
+            break;
+          case "downloads":
+            cmp = a.downloads - b.downloads;
+            break;
+          default:
+            cmp = a.created_at.localeCompare(b.created_at);
+        }
+        return options.order === "asc" ? cmp : -cmp;
+      });
+    }
+    if (data.length === 0) {
+      box(
+        `${c.secondary("No drops found.")}
+${c.muted("Create one with")} ${c.accent("anonli drop upload <file>")}`,
+        { title: c.info("Drops") }
+      );
+      return;
+    }
+    table(
+      ["ID", "Status", "Files", "Size", "Downloads", "Expires", "Created"],
+      data.map((d) => [
+        d.id,
+        d.disabled ? statusBadge("Disabled", "inactive") : statusBadge("Active", "active"),
+        String(d.fileCount),
+        formatBytes(parseInt(d.totalSize || "0")),
+        d.maxDownloads ? `${d.downloads}/${d.maxDownloads}` : String(d.downloads),
+        d.expires_at ? formatDate(d.expires_at) : dim("never"),
+        formatDate(d.created_at)
+      ])
+    );
+    const storage = result.meta?.storage;
+    if (storage) {
+      console.log(
+        dim(
+          `
+  Storage: ${formatBytes(parseInt(storage.used))}/${formatBytes(parseInt(storage.limit))}`
+        )
+      );
+    }
+    console.log(dim(`  ${result.total} drop(s) total${data.length < result.data.length ? `, ${data.length} shown after filter` : ""}`));
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to list drops.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/drop-delete.ts
+init_api();
+import { Command as Command6 } from "commander";
+
+// src/lib/drop-url.ts
+function parseDropIdentifier(input) {
+  try {
+    const parsed = new URL(input);
+    const pathParts = parsed.pathname.split("/").filter(Boolean);
+    const dIndex = pathParts.indexOf("d");
+    if (dIndex === -1 || !pathParts[dIndex + 1]) {
+      throw new Error("Invalid URL format");
+    }
+    return {
+      dropId: pathParts[dIndex + 1],
+      key: parsed.hash.slice(1) || null
+    };
+  } catch {
+    return { dropId: input, key: null };
+  }
+}
+
+// src/commands/drop-delete.ts
+var dropDeleteCommand = new Command6("delete").alias("rm").description("Delete a drop").argument("<target>", "Drop URL or drop ID").option("-f, --force", "Skip confirmation").action(async (target, options) => {
+  const { dropId } = parseDropIdentifier(target);
+  requireAuth();
+  if (!options.force) {
+    const confirmed = await confirm(
+      `Delete drop ${bold(dropId)}? This cannot be undone.`
+    );
+    if (!confirmed) {
+      info("Cancelled.");
+      return;
+    }
+  }
+  const spin = spinner("Deleting drop...");
+  try {
+    const result = await apiDelete(`/api/v1/drop/${dropId}`);
+    spin.succeed(`Deleted drop ${dropId}`);
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to delete drop.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/drop-download.ts
+import { Command as Command7 } from "commander";
+import fs3 from "fs";
+import path3 from "path";
+init_constants();
+init_errors();
+init_config2();
+function sanitizeFilename(name) {
+  return name.replace(/\.\.[/\\]/g, "").replace(/\0/g, "").replace(/[<>:"/\\|?*\x00-\x1f]/g, "_").slice(0, 200) || "unnamed_file";
+}
+function resolveOutputPath(dir, safeName, overwrite, skip) {
+  const outPath = path3.join(dir, safeName);
+  if (!fs3.existsSync(outPath)) return outPath;
+  if (overwrite) return outPath;
+  if (skip) {
+    info(`Skipping ${safeName} (already exists)`);
+    return null;
+  }
+  const ext = path3.extname(safeName);
+  const base = path3.basename(safeName, ext);
+  for (let n = 1; n <= 1e3; n++) {
+    const candidate = path3.join(dir, `${base}.${n}${ext}`);
+    if (!fs3.existsSync(candidate)) return candidate;
+  }
+  throw new Error(`Cannot find available filename for ${safeName}`);
+}
+var dropDownloadCommand = new Command7("download").alias("dl").description("Download and decrypt a drop").argument("<target>", "Drop URL or drop ID").option("-o, --output <dir>", "Output directory", ".").option("-k, --key <key>", "Decryption key (required when using a drop ID)").option("-p, --password <password>", "Password for protected drops").option("--overwrite", "Overwrite existing files without prompting").option("--skip", "Skip files that already exist").action(async (target, options) => {
+  const { dropId, key: urlKey } = parseDropIdentifier(target);
+  let keyString = options.key || urlKey;
+  const spin = spinner("Fetching drop metadata...");
+  try {
+    const baseUrl = getBaseUrl();
+    const metaRes = await fetch(`${baseUrl}/api/v1/drop/${dropId}`);
+    if (!metaRes.ok) {
+      spin.fail("Drop not found or unavailable.");
+      process.exit(metaRes.status === 404 ? EXIT_NOT_FOUND : 1);
+    }
+    const drop = await metaRes.json();
+    spin.succeed(
+      `Drop found: ${drop.files.length} file(s)`
+    );
+    if (drop.customKey && !keyString) {
+      if (!drop.customKeyData || !drop.customKeyIv || !drop.salt) {
+        error("Drop requires a password but key data is missing.");
+        process.exit(1);
+      }
+      const password = options.password || await prompt("Password:", { mask: true });
+      try {
+        keyString = await decryptKeyWithPassword(
+          drop.customKeyData,
+          password,
+          drop.salt,
+          drop.customKeyIv
+        );
+      } catch {
+        errorBox("Decryption Failed", "Incorrect password.");
+        process.exit(1);
+      }
+    }
+    if (!keyString) {
+      errorBox(
+        "Missing Key",
+        "No decryption key provided. Use a URL with #<key> or pass --key <key>."
+      );
+      process.exit(1);
+      return;
+    }
+    const key = await importKey(keyString);
+    const iv = new Uint8Array(
+      base64UrlToArrayBuffer(drop.iv)
+    );
+    const outDir = path3.resolve(options.output);
+    fs3.mkdirSync(outDir, { recursive: true });
+    let downloadedCount = 0;
+    for (const file of drop.files) {
+      let filename;
+      try {
+        filename = await decryptFilename(
+          file.encryptedName,
+          key,
+          iv
+        );
+      } catch {
+        warn(`Could not decrypt filename for file ${file.id.slice(0, 8)} \u2014 using fallback name`);
+        filename = `file_${file.id}`;
+      }
+      const encryptedSize = parseInt(file.size);
+      const chunkSize = file.chunkSize || MIN_CHUNK_SIZE;
+      const chunkCount = file.chunkCount || Math.ceil(encryptedSize / (chunkSize + AUTH_TAG_SIZE));
+      const encryptedChunkSize = chunkSize + AUTH_TAG_SIZE;
+      const expectedDecryptedSize = encryptedSize - chunkCount * AUTH_TAG_SIZE;
+      const safeName = sanitizeFilename(filename);
+      fs3.mkdirSync(path3.dirname(path3.join(outDir, safeName)), { recursive: true });
+      const outPath = resolveOutputPath(outDir, safeName, options.overwrite ?? false, options.skip ?? false);
+      if (outPath === null) continue;
+      const partPath = `${outPath}.anonli-dl`;
+      let resumeFromChunk = 0;
+      let resumeFromByte = 0;
+      if (!options.overwrite && fs3.existsSync(partPath)) {
+        const partSize = fs3.statSync(partPath).size;
+        resumeFromChunk = Math.floor(partSize / chunkSize);
+        resumeFromByte = resumeFromChunk * encryptedChunkSize;
+        if (resumeFromChunk > 0) {
+          info(`Resuming ${filename} from chunk ${resumeFromChunk}/${chunkCount}`);
+        }
+      }
+      info(`Downloading ${c.accent(filename)} (${formatBytes(expectedDecryptedSize)})`);
+      const downloadUrl = `${baseUrl}/api/v1/drop/${dropId}/file/${file.id}`;
+      const fetchHeaders = {};
+      if (resumeFromByte > 0) {
+        fetchHeaders["Range"] = `bytes=${resumeFromByte}-`;
+      }
+      const response = await fetch(downloadUrl, { headers: fetchHeaders });
+      if (!response.ok && response.status !== 206) {
+        error(`Failed to download ${filename}: ${response.statusText}`);
+        continue;
+      }
+      if (resumeFromChunk > 0 && response.status === 200) {
+        warn("Server doesn't support resume \u2014 restarting from beginning.");
+        resumeFromChunk = 0;
+        resumeFromByte = 0;
+      }
+      if (!response.body) {
+        error(`No response body for ${filename}`);
+        continue;
+      }
+      const contentLength = parseInt(response.headers.get("Content-Length") || "0");
+      let totalBytesReceived = 0;
+      const writeStream = fs3.createWriteStream(partPath, {
+        flags: resumeFromChunk > 0 ? "a" : "w"
+      });
+      const reader = response.body.getReader();
+      let buffer = new Uint8Array(0);
+      let chunkIndex = resumeFromChunk;
+      let totalDecryptedBytes = resumeFromChunk * chunkSize;
+      const bar = progressBar(chunkCount, filename);
+      if (resumeFromChunk > 0) bar.update(resumeFromChunk);
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (value) {
+            const newBuffer = new Uint8Array(buffer.length + value.length);
+            newBuffer.set(buffer);
+            newBuffer.set(value, buffer.length);
+            buffer = newBuffer;
+            totalBytesReceived += value.length;
+          }
+          while (buffer.length >= encryptedChunkSize) {
+            const encryptedChunk = buffer.slice(0, encryptedChunkSize);
+            buffer = buffer.slice(encryptedChunkSize);
+            const decrypted = await decryptChunk(
+              encryptedChunk.buffer.slice(
+                encryptedChunk.byteOffset,
+                encryptedChunk.byteOffset + encryptedChunk.byteLength
+              ),
+              key,
+              iv,
+              chunkIndex
+            );
+            writeStream.write(Buffer.from(decrypted));
+            totalDecryptedBytes += decrypted.byteLength;
+            chunkIndex++;
+            if (chunkCount > 0) {
+              bar.update(Math.min(chunkIndex, chunkCount));
+            }
+          }
+          if (done) {
+            if (buffer.length > 0) {
+              const decrypted = await decryptChunk(
+                buffer.buffer.slice(
+                  buffer.byteOffset,
+                  buffer.byteOffset + buffer.byteLength
+                ),
+                key,
+                iv,
+                chunkIndex
+              );
+              writeStream.write(Buffer.from(decrypted));
+              totalDecryptedBytes += decrypted.byteLength;
+            }
+            break;
+          }
+        }
+        await new Promise((resolve, reject) => {
+          writeStream.end((err) => {
+            if (err) reject(err);
+            else resolve();
+          });
+        });
+        bar.update(chunkCount);
+        bar.stop();
+        if (contentLength > 0 && totalBytesReceived !== contentLength) {
+          warn(
+            `Content-Length mismatch for ${filename}: expected ${contentLength} bytes, received ${totalBytesReceived} bytes`
+          );
+        }
+        if (expectedDecryptedSize > 0 && totalDecryptedBytes !== expectedDecryptedSize) {
+          warn(
+            `Size mismatch for ${filename}: expected ${formatBytes(expectedDecryptedSize)}, got ${formatBytes(totalDecryptedBytes)}`
+          );
+        }
+        fs3.renameSync(partPath, outPath);
+        downloadedCount++;
+      } catch (err) {
+        bar.stop();
+        writeStream.destroy();
+        error(`Failed to decrypt ${filename}: ${err instanceof Error ? err.message : "Unknown error"}`);
+      }
+    }
+    successBox(
+      "Download Complete",
+      `${c.primary(String(downloadedCount))} ${c.secondary("file(s) decrypted to")} ${c.accent(path3.resolve(outDir))}`
+    );
+  } catch (err) {
+    error(
+      err instanceof Error ? err.message : "Download failed"
+    );
+    process.exit(1);
+  }
+});
+
+// src/commands/drop-toggle.ts
+init_api();
+import { Command as Command8 } from "commander";
+var dropToggleCommand = new Command8("toggle").description("Toggle a drop's enabled/disabled state").argument("<target>", "Drop URL or drop ID").action(async (target) => {
+  const { dropId } = parseDropIdentifier(target);
+  requireAuth();
+  const spin = spinner("Toggling drop...");
+  try {
+    const result = await apiPatch(
+      `/api/v1/drop/${dropId}?action=toggle`
+    );
+    if (result.data.disabled) {
+      spin.succeed(`Drop ${dropId} is now ${statusBadge("disabled", "inactive")}`);
+    } else {
+      spin.succeed(`Drop ${dropId} is now ${statusBadge("enabled", "active")}`);
+    }
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to toggle drop.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/drop-info.ts
+import { Command as Command9 } from "commander";
+init_errors();
+init_config2();
+var dropInfoCommand = new Command9("info").alias("get").description("View drop details").argument("<target>", "Drop URL or drop ID").option("-k, --key <key>", "Decryption key (to reveal filenames)").option("-p, --password <password>", "Password for protected drops").option("--json", "Output raw JSON").action(async (target, options) => {
+  const { dropId, key: urlKey } = parseDropIdentifier(target);
+  let keyString = options.key || urlKey;
+  const spin = spinner("Fetching drop info...");
+  try {
+    const baseUrl = getBaseUrl();
+    const res = await fetch(`${baseUrl}/api/v1/drop/${dropId}`);
+    if (!res.ok) {
+      spin.fail("Drop not found or unavailable.");
+      process.exit(res.status === 404 ? EXIT_NOT_FOUND : 1);
+    }
+    const drop = await res.json();
+    spin.stop();
+    if (options.json) {
+      outputJson(drop);
+      return;
+    }
+    if (drop.customKey && !keyString) {
+      if (drop.customKeyData && drop.customKeyIv && drop.salt) {
+        const password = options.password || await prompt("Password:", { mask: true });
+        try {
+          keyString = await decryptKeyWithPassword(
+            drop.customKeyData,
+            password,
+            drop.salt,
+            drop.customKeyIv
+          );
+        } catch {
+          warn("Incorrect password \u2014 showing file IDs instead of names.");
+        }
+      }
+    }
+    let cryptoKey = null;
+    let iv = null;
+    if (keyString) {
+      try {
+        cryptoKey = await importKey(keyString);
+        iv = new Uint8Array(base64UrlToArrayBuffer(drop.iv));
+      } catch {
+        warn("Invalid decryption key \u2014 showing file IDs instead of names.");
+      }
+    }
+    header("Drop Info");
+    spacer();
+    keyValue("ID", drop.id);
+    keyValue("Files", String(drop.files.length));
+    keyValue("Downloads", String(drop.downloads));
+    if (drop.maxDownloads) {
+      keyValue("Max Downloads", String(drop.maxDownloads));
+    }
+    if (drop.expiresAt) {
+      keyValue("Expires", formatDate(drop.expiresAt));
+    }
+    keyValue("Created", formatDate(drop.createdAt));
+    keyValue("Password Protected", drop.customKey ? "Yes" : "No");
+    keyValue("Hide Branding", drop.hideBranding ? "Yes" : "No");
+    if (drop.files.length > 0) {
+      spacer();
+      sectionTitle("Files");
+      const canDecrypt = cryptoKey !== null && iv !== null;
+      const headers = ["#", canDecrypt ? "Name" : "ID", "Size", "Type"];
+      const rows = [];
+      for (let i = 0; i < drop.files.length; i++) {
+        const file = drop.files[i];
+        let nameOrId;
+        if (cryptoKey && iv) {
+          try {
+            nameOrId = await decryptFilename(file.encryptedName, cryptoKey, iv);
+          } catch {
+            nameOrId = file.id.slice(0, 8) + "...";
+          }
+        } else {
+          nameOrId = file.id.slice(0, 8) + "...";
+        }
+        rows.push([
+          String(i + 1),
+          nameOrId,
+          formatBytes(parseInt(file.size)),
+          file.mimeType || "unknown"
+        ]);
+      }
+      table(headers, rows);
+    }
+    spacer();
+    info(`View: ${link(`${baseUrl}/d/${dropId}`)}`);
+  } catch (err) {
+    spin.fail("Failed to fetch drop info.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/drop-share.ts
+import { Command as Command10 } from "commander";
+init_config2();
+var dropShareCommand = new Command10("share").description("Reconstruct the share URL for a drop (requires the original key)").argument("<id>", "Drop ID").option("-k, --key <key>", "Decryption key (the part after # in the original URL)").action((id, options) => {
+  const baseUrl = getBaseUrl();
+  if (!options.key) {
+    errorBox(
+      "Key Required",
+      "The decryption key is required to reconstruct the share URL.",
+      "Use: anonli drop share <id> --key <key>"
+    );
+    process.exit(1);
+  }
+  const shareUrl = `${baseUrl}/d/${id}#${options.key}`;
+  successBox(
+    "Share URL",
+    `${c.secondary("URL:")} ${link(shareUrl)}`
+  );
+  console.log(shareUrl);
+});
+
+// src/commands/drop.ts
+var dropCommand = new Command11("drop").description("Encrypted file drops").addCommand(dropUploadCommand).addCommand(dropListCommand).addCommand(dropDeleteCommand).addCommand(dropDownloadCommand).addCommand(dropToggleCommand).addCommand(dropInfoCommand).addCommand(dropShareCommand);
+
+// src/commands/alias.ts
+import { Command as Command18 } from "commander";
+
+// src/commands/alias-new.ts
+init_api();
+import { Command as Command12 } from "commander";
+var ALIAS_LOCAL_PART_RE = /^[a-z0-9][a-z0-9._+\-]{0,61}[a-z0-9]$|^[a-z0-9]$/i;
+function validateLocalPart(localPart) {
+  if (!ALIAS_LOCAL_PART_RE.test(localPart)) {
+    error(
+      `Invalid alias local part: "${localPart}". Must start and end with a letter or digit, and contain only letters, digits, dots, underscores, plus, or hyphens (max 63 chars).`
+    );
+    process.exit(1);
+  }
+}
+var aliasNewCommand = new Command12("new").alias("create").description("Create a new alias (default: random)").option("-r, --random", "Generate random alias (default)").option("-c, --custom <name>", "Custom local part").option("-d, --domain <domain>", "Domain (default: anon.li)").option("-l, --label <text>", "Description/label for the alias").option("--recipient <email>", "Recipient email to forward to").action(async (options) => {
+  requireAuth();
+  const domain = options.domain || "anon.li";
+  const isCustom = !!options.custom;
+  if (isCustom) {
+    validateLocalPart(options.custom);
+  }
+  const limitSpin = spinner("Checking plan limits...");
+  const plan = await fetchPlanInfo();
+  limitSpin.stop();
+  if (isCustom) {
+    assertCountLimit("custom alias", plan.aliases.custom.used, plan.aliases.custom.limit);
+  } else {
+    assertCountLimit("random alias", plan.aliases.random.used, plan.aliases.random.limit);
+  }
+  const spin = spinner("Creating alias...");
+  try {
+    let result;
+    const body = {
+      domain,
+      ...options.label && { description: options.label },
+      ...options.recipient && { recipient_email: options.recipient }
+    };
+    if (isCustom) {
+      result = await apiPost("/api/v1/alias", {
+        ...body,
+        format: "custom",
+        local_part: options.custom
+      });
+    } else {
+      result = await apiPost("/api/v1/alias?generate=true", body);
+    }
+    spin.succeed(`Created: ${c.accent(result.data.email)}`);
+    if (options.recipient) {
+      info(`Forwards to: ${c.primary(options.recipient)}`);
+    }
+    if (result.data.description) {
+      info(`Label: ${result.data.description}`);
+    }
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to create alias.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/alias-list.ts
+init_api();
+import { Command as Command13 } from "commander";
+var aliasListCommand = new Command13("list").alias("ls").description("List all aliases").option("--limit <n>", "Number of aliases to fetch", parseInt).option("--offset <n>", "Offset for pagination", parseInt).option("--active", "Show only active aliases").option("--inactive", "Show only inactive aliases").option("--search <term>", "Filter by email address").option("--json", "Output raw JSON").action(async (options) => {
+  requireAuth();
+  const spin = spinner("Fetching aliases...");
+  try {
+    const limit = options.limit ?? 50;
+    const offset = options.offset ?? 0;
+    const result = await apiGetList(`/api/v1/alias?limit=${limit}&offset=${offset}`);
+    spin.stop();
+    if (options.json) {
+      outputJson(result.data);
+      return;
+    }
+    let data = result.data;
+    if (options.active) {
+      data = data.filter((a) => a.active);
+    }
+    if (options.inactive) {
+      data = data.filter((a) => !a.active);
+    }
+    if (options.search) {
+      const term = options.search.toLowerCase();
+      data = data.filter((a) => a.email.toLowerCase().includes(term));
+    }
+    if (data.length === 0) {
+      box(
+        `${c.secondary("No aliases found.")}
+${c.muted("Create one with")} ${c.accent("anonli alias new")}`,
+        { title: c.info("Aliases") }
+      );
+      return;
+    }
+    table(
+      ["Email", "ID", "Status", "Created"],
+      data.map((a) => [
+        a.email,
+        a.id.slice(0, 8) + "...",
+        a.active ? statusBadge("Active", "active") : statusBadge("Inactive", "inactive"),
+        formatDate(a.created_at)
+      ])
+    );
+    console.log(dim(
+      `
+  ${result.total} alias(es) total${data.length < result.data.length ? `, ${data.length} shown after filter` : ""}`
+    ));
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to list aliases.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/alias-delete.ts
+init_api();
+import { Command as Command14 } from "commander";
+var aliasDeleteCommand = new Command14("delete").alias("rm").description("Delete an alias").argument("<id>", "Alias ID or email").option("-f, --force", "Skip confirmation").action(async (id, options) => {
+  requireAuth();
+  if (!options.force) {
+    const confirmed = await confirm(
+      `Delete alias ${bold(id)}?`
+    );
+    if (!confirmed) {
+      info("Cancelled.");
+      return;
+    }
+  }
+  const spin = spinner("Deleting alias...");
+  try {
+    const result = await apiDelete(`/api/v1/alias/${encodeURIComponent(id)}`);
+    spin.succeed(`Deleted alias ${id}`);
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to delete alias.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/alias-toggle.ts
+init_api();
+import { Command as Command15 } from "commander";
+var aliasToggleCommand = new Command15("toggle").description("Toggle alias active/inactive").argument("<id>", "Alias ID or email").action(async (id) => {
+  requireAuth();
+  const spin = spinner("Toggling alias...");
+  try {
+    const current = await apiGet(
+      `/api/v1/alias/${encodeURIComponent(id)}`
+    );
+    const result = await apiPatch(
+      `/api/v1/alias/${encodeURIComponent(id)}`,
+      { active: !current.data.active }
+    );
+    const badge = result.data.active ? statusBadge("Active", "active") : statusBadge("Inactive", "inactive");
+    spin.succeed(`Alias ${id} is now ${badge}`);
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to toggle alias.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/alias-update.ts
+init_api();
+import { Command as Command16 } from "commander";
+var aliasUpdateCommand = new Command16("update").alias("edit").description("Update an alias").argument("<id>", "Alias ID or email").option("--enable", "Enable the alias").option("--disable", "Disable the alias").option("-l, --label <text>", "Update description/label").action(async (aliasId, options) => {
+  requireAuth();
+  if (!options.enable && !options.disable && !options.label) {
+    error("Provide at least one option: --enable, --disable, or --label");
+    process.exit(1);
+  }
+  if (options.enable && options.disable) {
+    error("Cannot use both --enable and --disable");
+    process.exit(1);
+  }
+  const spin = spinner("Updating alias...");
+  try {
+    const body = {};
+    if (options.enable) {
+      body.active = true;
+    } else if (options.disable) {
+      body.active = false;
+    }
+    if (options.label !== void 0) {
+      body.description = options.label;
+    }
+    const result = await apiPatch(
+      `/api/v1/alias/${encodeURIComponent(aliasId)}`,
+      body
+    );
+    spin.stop();
+    const status = result.data.active ? statusBadge("Active", "active") : statusBadge("Inactive", "inactive");
+    successBox(
+      "Alias Updated",
+      `${c.accent(result.data.email)} is now ${status}`
+    );
+    if (result.data.description) {
+      info(`Label: ${result.data.description}`);
+    }
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to update alias.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/alias-stats.ts
+init_api();
+import { Command as Command17 } from "commander";
+var aliasStatsCommand = new Command17("stats").description("Show forwarding statistics for an alias").argument("[alias-id]", "Alias ID (omit to show summary across all aliases)").option("--all", "Show summary across all aliases").option("--json", "Output raw JSON").action(async (aliasId, options) => {
+  requireAuth();
+  if (aliasId && !options.all) {
+    const spin = spinner("Fetching alias stats...");
+    try {
+      const result = await apiGet(
+        `/api/v1/alias/${encodeURIComponent(aliasId)}`
+      );
+      spin.stop();
+      const a = result.data;
+      if (options.json) {
+        outputJson(a);
+        return;
+      }
+      header(`Alias: ${a.email}`);
+      spacer();
+      keyValue("ID", a.id);
+      keyValue("Status", a.active ? "Active" : "Inactive");
+      keyValue("Forwarded", String(a.forwarded ?? 0));
+      keyValue("Blocked", String(a.blocked ?? 0));
+      keyValue("Last Seen", a.last_seen ? formatDate(a.last_seen) : "Never");
+      keyValue("Created", formatDate(a.created_at));
+      showRateLimit(result.rateLimit);
+    } catch (err) {
+      spin.fail("Failed to fetch alias stats.");
+      error(err instanceof Error ? err.message : "Unknown error");
+      process.exit(1);
+    }
+  } else {
+    const spin = spinner("Fetching all aliases...");
+    try {
+      const result = await apiGetList("/api/v1/alias?limit=100");
+      spin.stop();
+      const data = result.data;
+      if (options.json) {
+        const summary = {
+          total: data.length,
+          active: data.filter((a) => a.active).length,
+          totalForwarded: data.reduce((s, a) => s + (a.forwarded ?? 0), 0),
+          totalBlocked: data.reduce((s, a) => s + (a.blocked ?? 0), 0),
+          aliases: data.map((a) => ({
+            id: a.id,
+            email: a.email,
+            forwarded: a.forwarded ?? 0,
+            blocked: a.blocked ?? 0,
+            last_seen: a.last_seen ?? null
+          }))
+        };
+        outputJson(summary);
+        return;
+      }
+      const totalForwarded = data.reduce((s, a) => s + (a.forwarded ?? 0), 0);
+      const totalBlocked = data.reduce((s, a) => s + (a.blocked ?? 0), 0);
+      header("Alias Statistics Summary");
+      spacer();
+      keyValue("Total Aliases", String(data.length));
+      keyValue("Active", String(data.filter((a) => a.active).length));
+      keyValue("Total Forwarded", String(totalForwarded));
+      keyValue("Total Blocked", String(totalBlocked));
+      spacer();
+      if (data.length > 0) {
+        sectionTitle("Per-Alias Breakdown");
+        table(
+          ["Email", "Forwarded", "Blocked", "Last Seen"],
+          data.map((a) => [
+            a.email,
+            String(a.forwarded ?? 0),
+            String(a.blocked ?? 0),
+            a.last_seen ? formatDate(a.last_seen) : dim("never")
+          ])
+        );
+      }
+      showRateLimit(result.rateLimit);
+    } catch (err) {
+      spin.fail("Failed to fetch alias stats.");
+      error(err instanceof Error ? err.message : "Unknown error");
+      process.exit(1);
+    }
+  }
+});
+
+// src/commands/alias.ts
+var aliasCommand = new Command18("alias").description("Manage email aliases").addCommand(aliasNewCommand).addCommand(aliasListCommand).addCommand(aliasDeleteCommand).addCommand(aliasToggleCommand).addCommand(aliasUpdateCommand).addCommand(aliasStatsCommand);
+
+// src/commands/recipient.ts
+init_api();
+import { Command as Command19 } from "commander";
+var recipientCommand = new Command19("recipient").alias("recipients").description("Manage email recipients");
+recipientCommand.command("list").alias("ls").description("List all recipients").option("--json", "Output raw JSON").action(async (options) => {
+  requireAuth();
+  const spin = spinner("Fetching recipients...");
+  try {
+    const result = await apiGetList("/api/v1/recipient");
+    spin.stop();
+    if (options.json) {
+      outputJson(result.data);
+      return;
+    }
+    if (result.data.length === 0) {
+      box(
+        `${c.secondary("No recipients yet.")}
+${c.muted("Add one with")} ${c.accent("anonli recipient add <email>")}`,
+        { title: c.info("Recipients") }
+      );
+      return;
+    }
+    table(
+      ["Email", "Status", "Default", "PGP", "Aliases", "Created"],
+      result.data.map((r) => [
+        r.email,
+        r.verified ? statusBadge("verified", "active") : statusBadge("pending", "inactive"),
+        r.is_default ? c.accent("\u2713") : "",
+        r.pgp_fingerprint ? c.accent("\u2713") : "",
+        String(r.alias_count || 0),
+        formatDate(r.created_at)
+      ])
+    );
+    console.log(dim(`  ${result.total} recipient(s) total`));
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to list recipients.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+recipientCommand.command("add <email>").description("Add a new recipient").action(async (email) => {
+  requireAuth();
+  const limitSpin = spinner("Checking plan limits...");
+  const plan = await fetchPlanInfo();
+  limitSpin.stop();
+  assertCountLimit("recipient", plan.recipients.used, plan.recipients.limit);
+  const spin = spinner("Adding recipient...");
+  try {
+    const result = await apiPost("/api/v1/recipient", { email });
+    spin.succeed(`Added: ${c.accent(result.data.email)}`);
+    info("Verification email sent. Check your inbox.");
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to add recipient.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+recipientCommand.command("delete <id>").alias("rm").description("Delete a recipient").option("-f, --force", "Skip confirmation").action(async (id, options) => {
+  requireAuth();
+  if (!options.force) {
+    const confirmed = await confirm(`Delete recipient ${id}?`);
+    if (!confirmed) {
+      info("Cancelled.");
+      return;
+    }
+  }
+  const spin = spinner("Deleting recipient...");
+  try {
+    const result = await apiDelete(`/api/v1/recipient/${encodeURIComponent(id)}`);
+    spin.succeed("Recipient deleted.");
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to delete recipient.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+recipientCommand.command("default <id>").description("Set a recipient as default").action(async (id) => {
+  requireAuth();
+  const spin = spinner("Setting default...");
+  try {
+    const result = await apiPatch(
+      `/api/v1/recipient/${encodeURIComponent(id)}`,
+      { is_default: true }
+    );
+    spin.succeed(`${c.accent(result.data.email)} is now your default recipient.`);
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to set default.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+recipientCommand.command("verify <id>").description("Resend verification email").action(async (id) => {
+  requireAuth();
+  const spin = spinner("Sending verification email...");
+  try {
+    const result = await apiPost(`/api/v1/recipient/${encodeURIComponent(id)}/verify`);
+    spin.succeed("Verification email sent.");
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to send verification.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+var pgpCommand = recipientCommand.command("pgp").description("Manage PGP keys for recipients");
+pgpCommand.command("set <id>").description("Set PGP public key for a recipient").option("-k, --key <file>", "Path to PGP public key file").option("-n, --name <name>", "Name/label for the key").option("-f, --force", "Skip confirmation when replacing existing key").action(async (id, options) => {
+  requireAuth();
+  if (!options.key) {
+    error("--key <file> is required");
+    process.exit(1);
+  }
+  const fs4 = await import("fs");
+  const path4 = await import("path");
+  const keyPath = path4.resolve(options.key);
+  if (!fs4.existsSync(keyPath)) {
+    error(`File not found: ${keyPath}`);
+    process.exit(1);
+  }
+  const keyFileStat = fs4.statSync(keyPath);
+  if (keyFileStat.size > 20 * 1024) {
+    error(`PGP key file is too large (${formatBytes(keyFileStat.size)}). Maximum allowed size is 20 KB.`);
+    process.exit(1);
+  }
+  const publicKey = fs4.readFileSync(keyPath, "utf-8");
+  if (!options.force) {
+    try {
+      const existing = await apiGet(`/api/v1/recipient/${encodeURIComponent(id)}`);
+      if (existing.data.pgp_fingerprint) {
+        const confirmed = await confirm(
+          `Recipient already has a PGP key (${existing.data.pgp_fingerprint.slice(0, 16)}...). Replace it?`
+        );
+        if (!confirmed) {
+          info("Cancelled.");
+          return;
+        }
+      }
+    } catch {
+    }
+  }
+  const spin = spinner("Setting PGP key...");
+  try {
+    const { apiFetch: apiFetch2, extractRateLimit: extractRateLimit2 } = await Promise.resolve().then(() => (init_api(), api_exports));
+    const res = await apiFetch2(`/api/v1/recipient/${encodeURIComponent(id)}/pgp`, {
+      method: "PUT",
+      body: JSON.stringify({
+        public_key: publicKey,
+        name: options.name
+      })
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err?.error?.message || "Failed to set PGP key");
+    }
+    const rateLimit = extractRateLimit2(res);
+    const data = await res.json();
+    spin.succeed("PGP key set successfully.");
+    if (data.data?.pgp_fingerprint) {
+      info(`Fingerprint: ${data.data.pgp_fingerprint}`);
+    }
+    showRateLimit(rateLimit);
+  } catch (err) {
+    spin.fail("Failed to set PGP key.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+pgpCommand.command("remove <id>").alias("rm").description("Remove PGP key from a recipient").action(async (id) => {
+  requireAuth();
+  const spin = spinner("Removing PGP key...");
+  try {
+    const result = await apiDelete(`/api/v1/recipient/${encodeURIComponent(id)}/pgp`);
+    spin.succeed("PGP key removed.");
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to remove PGP key.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/domain.ts
+init_api();
+import { Command as Command20 } from "commander";
+var domainCommand = new Command20("domain").alias("domains").description("Manage custom domains");
+domainCommand.command("list").alias("ls").description("List all domains").option("--json", "Output raw JSON").action(async (options) => {
+  requireAuth();
+  const spin = spinner("Fetching domains...");
+  try {
+    const result = await apiGetList("/api/v1/domain");
+    spin.stop();
+    if (options.json) {
+      outputJson(result.data);
+      return;
+    }
+    if (result.data.length === 0) {
+      box(
+        `${c.secondary("No custom domains yet.")}
+${c.muted("Add one with")} ${c.accent("anonli domain add <domain>")}`,
+        { title: c.info("Domains") }
+      );
+      return;
+    }
+    table(
+      ["Domain", "Status", "MX", "SPF", "DKIM", "Created"],
+      result.data.map((d) => [
+        d.domain,
+        d.verified ? statusBadge("verified", "active") : statusBadge("pending", "inactive"),
+        d.mx_verified ? c.accent("\u2713") : c.error("\u2717"),
+        d.spf_verified ? c.accent("\u2713") : c.error("\u2717"),
+        d.dkim_verified ? c.accent("\u2713") : c.error("\u2717"),
+        formatDate(d.created_at)
+      ])
+    );
+    console.log(dim(`  ${result.total} domain(s) total`));
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to list domains.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+var FQDN_RE = /^(?:[a-z0-9](?:[a-z0-9\-]{0,61}[a-z0-9])?\.)+[a-z]{2,}$/i;
+domainCommand.command("add <domain>").description("Add a custom domain").action(async (domain) => {
+  requireAuth();
+  if (!FQDN_RE.test(domain)) {
+    error(`Invalid domain: "${domain}". Please enter a valid fully-qualified domain name (e.g. mail.example.com).`);
+    process.exit(1);
+  }
+  const limitSpin = spinner("Checking plan limits...");
+  const plan = await fetchPlanInfo();
+  limitSpin.stop();
+  assertCountLimit("domain", plan.domains.used, plan.domains.limit);
+  const spin = spinner("Adding domain...");
+  try {
+    const result = await apiPost("/api/v1/domain", {
+      domain: domain.toLowerCase()
+    });
+    spin.succeed(`Added: ${c.accent(result.data.domain)}`);
+    spacer();
+    sectionTitle("DNS Records to Configure");
+    spacer();
+    console.log(c.secondary("1. Ownership TXT record:"));
+    console.log(`   Host: ${c.accent(result.data.domain)}`);
+    console.log(`   Value: ${c.primary(`anon.li=${result.data.verification_token}`)}`);
+    spacer();
+    console.log(c.secondary("2. MX record:"));
+    console.log(`   Host: ${c.accent(result.data.domain)}`);
+    console.log(`   Value: ${c.primary("mx.anon.li")} (priority 10)`);
+    spacer();
+    console.log(c.secondary("3. SPF TXT record:"));
+    console.log(`   Host: ${c.accent(result.data.domain)}`);
+    console.log(`   Value: ${c.primary("v=spf1 include:anon.li ~all")}`);
+    spacer();
+    if (result.data.dkim_selector && result.data.dkim_public_key) {
+      const cleanKey = result.data.dkim_public_key.replace(/-----BEGIN PUBLIC KEY-----/g, "").replace(/-----END PUBLIC KEY-----/g, "").replace(/[\n\r\s]/g, "");
+      console.log(c.secondary("4. DKIM TXT record:"));
+      console.log(`   Host: ${c.accent(`${result.data.dkim_selector}._domainkey.${result.data.domain}`)}`);
+      console.log(`   Value: ${c.primary(`v=DKIM1; k=rsa; p=${cleanKey}`)}`);
+      spacer();
+    }
+    info(`Run ${c.accent(`anonli domain verify ${result.data.id}`)} after configuring DNS.`);
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to add domain.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+domainCommand.command("verify <id>").description("Verify domain DNS records").action(async (id) => {
+  requireAuth();
+  const spin = spinner("Checking DNS records...");
+  try {
+    const result = await apiPost(`/api/v1/domain/${encodeURIComponent(id)}/verify`);
+    spin.stop();
+    const d = result.data;
+    const statusIcon = (ok) => ok ? c.accent("\u2713") : c.error("\u2717");
+    header("DNS Verification Results");
+    spacer();
+    console.log(`  Ownership: ${statusIcon(d.ownership_verified)}`);
+    console.log(`  MX:        ${statusIcon(d.mx_verified)}`);
+    console.log(`  SPF:       ${statusIcon(d.spf_verified)}`);
+    console.log(`  DKIM:      ${statusIcon(d.dkim_verified)}`);
+    spacer();
+    if (d.verified) {
+      successBox("Domain Verified", "All DNS records are correctly configured.");
+    } else {
+      warn("Some DNS records are missing or incorrect. Check your DNS configuration.");
+    }
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to verify domain.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+domainCommand.command("info <id>").alias("get").description("Show domain details and DNS records").action(async (id) => {
+  requireAuth();
+  const spin = spinner("Fetching domain...");
+  try {
+    const result = await apiGet(
+      `/api/v1/domain/${encodeURIComponent(id)}`
+    );
+    spin.stop();
+    const d = result.data;
+    header(`Domain: ${d.domain}`);
+    spacer();
+    keyValue("ID", d.id);
+    keyValue("Status", d.verified ? "Verified" : "Pending");
+    keyValue("Ownership", d.ownership_verified ? "\u2713" : "\u2717");
+    keyValue("MX", d.mx_verified ? "\u2713" : "\u2717");
+    keyValue("SPF", d.spf_verified ? "\u2713" : "\u2717");
+    keyValue("DKIM", d.dkim_verified ? "\u2713" : "\u2717");
+    keyValue("Created", formatDate(d.created_at));
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to fetch domain.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+domainCommand.command("delete <id>").alias("rm").description("Delete a domain").option("-f, --force", "Skip confirmation").action(async (id, options) => {
+  requireAuth();
+  if (!options.force) {
+    const confirmed = await confirm(
+      `Delete domain ${id}? This will also delete all aliases on this domain.`
+    );
+    if (!confirmed) {
+      info("Cancelled.");
+      return;
+    }
+  }
+  const spin = spinner("Deleting domain...");
+  try {
+    const result = await apiDelete(`/api/v1/domain/${encodeURIComponent(id)}`);
+    spin.succeed("Domain deleted.");
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to delete domain.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+domainCommand.command("dkim <id>").description("Regenerate DKIM keys").action(async (id) => {
+  requireAuth();
+  const spin = spinner("Regenerating DKIM keys...");
+  try {
+    const result = await apiPost(`/api/v1/domain/${encodeURIComponent(id)}/dkim`);
+    spin.succeed("DKIM keys regenerated.");
+    spacer();
+    const rec = result.data.dkim_record;
+    console.log(c.secondary("Update your DKIM TXT record:"));
+    console.log(`  Host:  ${c.accent(rec.host)}`);
+    console.log(`  Value: ${c.primary(rec.value)}`);
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to regenerate DKIM keys.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/apikey.ts
+init_api();
+import { Command as Command21 } from "commander";
+var apikeyCommand = new Command21("apikey").alias("api-key").description("Manage API keys");
+apikeyCommand.command("list").alias("ls").description("List all API keys").option("--json", "Output raw JSON").action(async (options) => {
+  requireAuth();
+  const spin = spinner("Fetching API keys...");
+  try {
+    const result = await apiGetList("/api/v1/api-key");
+    spin.stop();
+    if (options.json) {
+      outputJson(result.data);
+      return;
+    }
+    if (result.data.length === 0) {
+      box(
+        `${c.secondary("No API keys yet.")}
+${c.muted("Create one with")} ${c.accent("anonli apikey create")}`,
+        { title: c.info("API Keys") }
+      );
+      return;
+    }
+    table(
+      ["Prefix", "Label", "Created"],
+      result.data.map((k) => [
+        c.accent(k.key_prefix + "..."),
+        k.label || dim("(none)"),
+        formatDate(k.created_at)
+      ])
+    );
+    console.log(dim(`  ${result.total} API key(s) total`));
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to list API keys.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+apikeyCommand.command("create").alias("new").description("Create a new API key").option("-l, --label <label>", "Label for the key").action(async (options) => {
+  requireAuth();
+  const spin = spinner("Creating API key...");
+  try {
+    const result = await apiPost("/api/v1/api-key", {
+      label: options.label
+    });
+    spin.stop();
+    successBox(
+      "API Key Created",
+      `${c.warning("Save this key now - it won't be shown again!")}
+
+${c.accent(result.data.key)}`
+    );
+    if (result.data.label) {
+      info(`Label: ${result.data.label}`);
+    }
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to create API key.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+apikeyCommand.command("delete <id>").alias("rm").description("Delete an API key").option("-f, --force", "Skip confirmation").action(async (id, options) => {
+  requireAuth();
+  if (!options.force) {
+    const confirmed = await confirm(`Delete API key ${id}?`);
+    if (!confirmed) {
+      info("Cancelled.");
+      return;
+    }
+  }
+  const spin = spinner("Deleting API key...");
+  try {
+    const result = await apiDelete(`/api/v1/api-key/${encodeURIComponent(id)}`);
+    spin.succeed("API key deleted.");
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to delete API key.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/config-cmd.ts
+init_config2();
+import { Command as Command22 } from "commander";
+import figures2 from "figures";
+var configCommand = new Command22("config").description("View or update CLI configuration").argument("[action]", "get, set, or validate").argument("[key]", "Config key (e.g. baseUrl)").argument("[value]", "Value to set").action(async (action, key, value) => {
+  const config = loadConfig();
+  if (!action || action === "get") {
+    sectionTitle("Configuration");
+    keyValue(
+      "apiKey",
+      config.apiKey ? maskApiKey(config.apiKey) : dim("(not set)")
+    );
+    keyValue("baseUrl", config.baseUrl);
+    return;
+  }
+  if (action === "validate") {
+    header("Config Validation");
+    spacer();
+    const apiKey = getApiKey();
+    const baseUrl = getBaseUrl();
+    const keyOk = !!apiKey && apiKey.startsWith("ak_") && apiKey.length > 10;
+    console.log(
+      `  ${keyOk ? c.success(figures2.tick) : c.error(figures2.cross)} API key: ${apiKey ? maskApiKey(apiKey) : c.error("not set")}`
+    );
+    let urlOk = false;
+    try {
+      new URL(baseUrl);
+      urlOk = true;
+    } catch {
+    }
+    console.log(
+      `  ${urlOk ? c.success(figures2.tick) : c.error(figures2.cross)} Base URL: ${baseUrl}`
+    );
+    if (keyOk && urlOk) {
+      const spin = spinner("Checking API connectivity...");
+      try {
+        const res = await fetch(`${baseUrl}/api/v1/me`, {
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json"
+          }
+        });
+        if (res.ok) {
+          const data = await res.json();
+          spin.succeed(`Authenticated as ${c.accent(data.data?.email ?? "unknown")}`);
+        } else if (res.status === 401) {
+          spin.fail("API key is invalid or expired \u2014 run `anonli login` to re-authenticate");
+          process.exit(1);
+        } else {
+          spin.fail(`API returned unexpected status: ${res.status}`);
+          process.exit(1);
+        }
+      } catch (err) {
+        spin.fail(`Cannot reach ${baseUrl}: ${err instanceof Error ? err.message : "network error"}`);
+        process.exit(1);
+      }
+    } else {
+      const issues = [];
+      if (!keyOk) issues.push("API key missing or invalid format");
+      if (!urlOk) issues.push("Base URL is not a valid URL");
+      spacer();
+      errorBox("Config Invalid", issues.join("\n"), "Run `anonli login` to set up authentication.");
+      process.exit(1);
+    }
+    return;
+  }
+  if (action === "set") {
+    if (!key || !value) {
+      error("Usage: anonli config set <key> <value>");
+      process.exit(1);
+    }
+    if (key === "baseUrl") {
+      try {
+        new URL(value);
+      } catch {
+        error("Invalid URL format.");
+        process.exit(1);
+      }
+      config.baseUrl = value;
+      saveConfig(config);
+      success(`Set baseUrl to ${value}`);
+    } else if (key === "apiKey") {
+      error(
+        'Use "anonli login" to set your API key.'
+      );
+      process.exit(1);
+    } else {
+      error(`Unknown config key: ${key}`);
+      process.exit(1);
+    }
+    return;
+  }
+  error(`Unknown action: ${action}. Use "get", "set", or "validate".`);
+  process.exit(1);
+});
+
+// src/commands/update.ts
+import { Command as Command23 } from "commander";
+import { execSync } from "child_process";
+var updateCommand = new Command23("update").description("Update anonli to the latest version").action(() => {
+  const spin = spinner("Updating anonli...");
+  try {
+    let cmd;
+    try {
+      execSync("bun --version", { stdio: "ignore" });
+      cmd = "bun install -g anonli@latest";
+    } catch {
+      cmd = "npm install -g anonli@latest";
+    }
+    execSync(cmd, { stdio: "inherit" });
+    spin.stop();
+    try {
+      const newVersion = execSync("anonli --version", { encoding: "utf8" }).trim();
+      successBox("Updated", `anonli is now up to date.
+Installed version: ${newVersion}`);
+    } catch {
+      successBox("Updated", "anonli was updated. Run `anonli --version` to confirm.");
+    }
+  } catch (err) {
+    spin.stop();
+    errorBox(
+      "Update Failed",
+      err instanceof Error ? err.message : "Failed to update.",
+      "Try: npm install -g anonli@latest"
+    );
+    process.exit(1);
+  }
+});
+
+// src/commands/subscribe.ts
+init_api();
+import { Command as Command24 } from "commander";
+import { execFile } from "child_process";
+var PRICING = {
+  bundle: {
+    name: "Bundle",
+    description: "Alias + Drop combined",
+    plus: { monthly: "$6/mo", yearly: "$60/yr" },
+    pro: { monthly: "$12/mo", yearly: "$120/yr" }
+  },
+  alias: {
+    name: "Alias",
+    description: "Anonymous email forwarding",
+    plus: { monthly: "$3/mo", yearly: "$30/yr" },
+    pro: { monthly: "$6/mo", yearly: "$60/yr" }
+  },
+  drop: {
+    name: "Drop",
+    description: "Encrypted file sharing",
+    plus: { monthly: "$3/mo", yearly: "$30/yr" },
+    pro: { monthly: "$6/mo", yearly: "$60/yr" }
+  }
+};
+function openUrl(url) {
+  const platform = process.platform;
+  let cmd;
+  let args;
+  if (platform === "darwin") {
+    cmd = "open";
+    args = [url];
+  } else if (platform === "win32") {
+    cmd = "cmd";
+    args = ["/c", "start", "", url];
+  } else {
+    cmd = "xdg-open";
+    args = [url];
+  }
+  execFile(cmd, args, (err) => {
+    if (err) {
+      warn(`Could not open browser automatically. Visit this URL manually:
+  ${url}`);
+    }
+  });
+}
+function showPricingTable() {
+  header("Plans & Pricing");
+  spacer();
+  const headers = ["Product", "Tier", "Monthly", "Yearly"];
+  const rows = [];
+  for (const [key, product] of Object.entries(PRICING)) {
+    rows.push([
+      `${c.accent(product.name)} ${c.muted(`(${key})`)}`,
+      c.accent("Plus"),
+      product.plus.monthly,
+      `${product.plus.yearly} ${c.success("(save up to 25%)")}`
+    ]);
+    rows.push([
+      "",
+      c.gold("Pro"),
+      product.pro.monthly,
+      `${product.pro.yearly} ${c.success("(save up to 25%)")}`
+    ]);
+  }
+  table(headers, rows);
+  spacer();
+  info("Subscribe with:");
+  console.log(c.muted("  anonli subscribe --product bundle --tier plus --frequency monthly"));
+  console.log(c.muted("  anonli subscribe --product alias --tier pro --frequency yearly"));
+  console.log(c.muted("  anonli subscribe --product drop --tier plus --frequency yearly --promo CODE"));
+}
+var subscribeCommand = new Command24("subscribe").description("Subscribe to a paid plan").option("--product <product>", "Product: bundle, alias, or drop").option("--tier <tier>", "Tier: plus or pro").option("--frequency <frequency>", "Billing: monthly or yearly").option("--promo <code>", "Promotion code").option("--no-open", "Don't open checkout URL in browser").action(async (options) => {
+  if (!options.product && !options.tier && !options.frequency) {
+    showPricingTable();
+    return;
+  }
+  if (!options.product || !options.tier || !options.frequency) {
+    errorBox(
+      "Missing Options",
+      "All three options are required: --product, --tier, --frequency",
+      "Run 'anonli subscribe' without options to see available plans."
+    );
+    process.exit(1);
+  }
+  const validProducts = ["bundle", "alias", "drop"];
+  const validTiers = ["plus", "pro"];
+  const validFrequencies = ["monthly", "yearly"];
+  if (!validProducts.includes(options.product)) {
+    error(`Invalid product: ${options.product}. Must be one of: ${validProducts.join(", ")}`);
+    process.exit(1);
+  }
+  if (!validTiers.includes(options.tier)) {
+    error(`Invalid tier: ${options.tier}. Must be one of: ${validTiers.join(", ")}`);
+    process.exit(1);
+  }
+  if (!validFrequencies.includes(options.frequency)) {
+    error(`Invalid frequency: ${options.frequency}. Must be one of: ${validFrequencies.join(", ")}`);
+    process.exit(1);
+  }
+  requireAuth();
+  const spin = spinner("Creating checkout session...");
+  try {
+    const body = {
+      product: options.product,
+      tier: options.tier,
+      frequency: options.frequency
+    };
+    if (options.promo) {
+      body.promoCode = options.promo;
+    }
+    const result = await apiPost("/api/v1/checkout", body);
+    spin.stop();
+    const url = result.data.url;
+    successBox(
+      "Checkout Ready",
+      `${c.secondary("Complete your subscription in the browser:")}
+${link(url)}`
+    );
+    if (options.open !== false) {
+      openUrl(url);
+      info("Opening checkout in your default browser...");
+    }
+    showRateLimit(result.rateLimit);
+  } catch (err) {
+    spin.fail("Failed to create checkout session.");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/completions.ts
+import { Command as Command25 } from "commander";
+var BASH_COMPLETION = `# anonli bash completion
+# Add to ~/.bashrc: source <(anonli completions bash)
+_anonli_completions() {
+  local cur prev words cword
+  _init_completion 2>/dev/null || {
+    COMPREPLY=()
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  }
+
+  local commands="login logout whoami drop alias recipient domain apikey config update subscribe completions"
+  local drop_cmds="upload list info download delete toggle share"
+  local alias_cmds="new list delete toggle update stats"
+  local recipient_cmds="list add delete default verify pgp"
+  local domain_cmds="list add verify info delete dkim"
+  local apikey_cmds="list create delete"
+  local config_cmds="get set validate"
+
+  case "\${COMP_WORDS[1]}" in
+    drop)
+      COMPREPLY=($(compgen -W "\${drop_cmds}" -- "\${cur}"))
+      ;;
+    alias)
+      COMPREPLY=($(compgen -W "\${alias_cmds}" -- "\${cur}"))
+      ;;
+    recipient|recipients)
+      COMPREPLY=($(compgen -W "\${recipient_cmds}" -- "\${cur}"))
+      ;;
+    domain|domains)
+      COMPREPLY=($(compgen -W "\${domain_cmds}" -- "\${cur}"))
+      ;;
+    apikey|api-key)
+      COMPREPLY=($(compgen -W "\${apikey_cmds}" -- "\${cur}"))
+      ;;
+    config)
+      COMPREPLY=($(compgen -W "\${config_cmds}" -- "\${cur}"))
+      ;;
+    *)
+      COMPREPLY=($(compgen -W "\${commands}" -- "\${cur}"))
+      ;;
+  esac
+}
+complete -F _anonli_completions anonli
+`;
+var ZSH_COMPLETION = `# anonli zsh completion
+# Add to ~/.zshrc: source <(anonli completions zsh)
+_anonli() {
+  local state
+  typeset -A opt_args
+
+  _arguments \\
+    '1: :->command' \\
+    '*: :->args'
+
+  case $state in
+    command)
+      local commands=(
+        'login:Authenticate with your API key'
+        'logout:Remove stored credentials'
+        'whoami:Show current user info'
+        'drop:Encrypted file drops'
+        'alias:Manage email aliases'
+        'recipient:Manage email recipients'
+        'domain:Manage custom domains'
+        'apikey:Manage API keys'
+        'config:View or update CLI configuration'
+        'update:Update anonli to latest version'
+        'subscribe:Subscribe to a paid plan'
+        'completions:Generate shell completion script'
+      )
+      _describe 'command' commands
+      ;;
+    args)
+      case $words[2] in
+        drop)
+          local drop_cmds=(
+            'upload:Create an encrypted drop'
+            'list:List your drops'
+            'info:View drop details'
+            'download:Download and decrypt a drop'
+            'delete:Delete a drop'
+            'toggle:Toggle enabled/disabled state'
+            'share:Reconstruct a share URL'
+          )
+          _describe 'drop command' drop_cmds
+          ;;
+        alias)
+          local alias_cmds=(
+            'new:Create a new alias'
+            'list:List all aliases'
+            'delete:Delete an alias'
+            'toggle:Toggle alias active state'
+            'update:Update alias settings'
+            'stats:Show forwarding statistics'
+          )
+          _describe 'alias command' alias_cmds
+          ;;
+        config)
+          local config_cmds=('get:Show config' 'set:Update config value' 'validate:Check config health')
+          _describe 'config command' config_cmds
+          ;;
+      esac
+      ;;
+  esac
+}
+compdef _anonli anonli
+`;
+var FISH_COMPLETION = `# anonli fish completion
+# Add to ~/.config/fish/completions/anonli.fish or run: anonli completions fish | source
+
+# Disable file completions by default
+complete -c anonli -f
+
+# Main commands
+complete -c anonli -n '__fish_use_subcommand' -a login -d 'Authenticate with your API key'
+complete -c anonli -n '__fish_use_subcommand' -a logout -d 'Remove stored credentials'
+complete -c anonli -n '__fish_use_subcommand' -a whoami -d 'Show current user info'
+complete -c anonli -n '__fish_use_subcommand' -a drop -d 'Encrypted file drops'
+complete -c anonli -n '__fish_use_subcommand' -a alias -d 'Manage email aliases'
+complete -c anonli -n '__fish_use_subcommand' -a recipient -d 'Manage email recipients'
+complete -c anonli -n '__fish_use_subcommand' -a domain -d 'Manage custom domains'
+complete -c anonli -n '__fish_use_subcommand' -a apikey -d 'Manage API keys'
+complete -c anonli -n '__fish_use_subcommand' -a config -d 'View or update CLI configuration'
+complete -c anonli -n '__fish_use_subcommand' -a update -d 'Update anonli to latest version'
+complete -c anonli -n '__fish_use_subcommand' -a subscribe -d 'Subscribe to a paid plan'
+complete -c anonli -n '__fish_use_subcommand' -a completions -d 'Generate shell completion script'
+
+# Quiet flag
+complete -c anonli -s q -l quiet -d 'Suppress non-essential output'
+
+# drop subcommands
+complete -c anonli -n '__fish_seen_subcommand_from drop' -a upload -d 'Create an encrypted drop'
+complete -c anonli -n '__fish_seen_subcommand_from drop' -a list -d 'List your drops'
+complete -c anonli -n '__fish_seen_subcommand_from drop' -a info -d 'View drop details'
+complete -c anonli -n '__fish_seen_subcommand_from drop' -a download -d 'Download and decrypt a drop'
+complete -c anonli -n '__fish_seen_subcommand_from drop' -a delete -d 'Delete a drop'
+complete -c anonli -n '__fish_seen_subcommand_from drop' -a toggle -d 'Toggle enabled/disabled state'
+complete -c anonli -n '__fish_seen_subcommand_from drop' -a share -d 'Reconstruct a share URL'
+
+# alias subcommands
+complete -c anonli -n '__fish_seen_subcommand_from alias' -a new -d 'Create a new alias'
+complete -c anonli -n '__fish_seen_subcommand_from alias' -a list -d 'List all aliases'
+complete -c anonli -n '__fish_seen_subcommand_from alias' -a delete -d 'Delete an alias'
+complete -c anonli -n '__fish_seen_subcommand_from alias' -a toggle -d 'Toggle alias active state'
+complete -c anonli -n '__fish_seen_subcommand_from alias' -a update -d 'Update alias settings'
+complete -c anonli -n '__fish_seen_subcommand_from alias' -a stats -d 'Show forwarding statistics'
+
+# config subcommands
+complete -c anonli -n '__fish_seen_subcommand_from config' -a get -d 'Show current config'
+complete -c anonli -n '__fish_seen_subcommand_from config' -a set -d 'Update a config value'
+complete -c anonli -n '__fish_seen_subcommand_from config' -a validate -d 'Check config health'
+
+# completions shells
+complete -c anonli -n '__fish_seen_subcommand_from completions' -a bash -d 'Bash completion script'
+complete -c anonli -n '__fish_seen_subcommand_from completions' -a zsh -d 'Zsh completion script'
+complete -c anonli -n '__fish_seen_subcommand_from completions' -a fish -d 'Fish completion script'
+`;
+var completionsCommand = new Command25("completions").description("Generate shell completion script").argument("<shell>", "Shell type: bash, zsh, or fish").addHelpText("after", `
+Examples:
+  # bash \u2014 add to ~/.bashrc
+  source <(anonli completions bash)
+
+  # zsh \u2014 add to ~/.zshrc
+  source <(anonli completions zsh)
+
+  # fish \u2014 save to completions directory
+  anonli completions fish > ~/.config/fish/completions/anonli.fish`).action((shell) => {
+  switch (shell.toLowerCase()) {
+    case "bash":
+      process.stdout.write(BASH_COMPLETION);
+      break;
+    case "zsh":
+      process.stdout.write(ZSH_COMPLETION);
+      break;
+    case "fish":
+      process.stdout.write(FISH_COMPLETION);
+      break;
+    default:
+      error(`Unknown shell: ${shell}. Supported shells: bash, zsh, fish`);
+      process.exit(1);
+  }
+});
+
+// src/lib/version-check.ts
+init_config2();
+import semver from "semver";
+var CACHE_DURATION_MS = 24 * 60 * 60 * 1e3;
+async function checkForUpdates(currentVersion) {
+  if (process.env.ANONLI_NO_UPDATE_CHECK) return;
+  const config = loadConfig();
+  if (config.lastVersionCheck && config.latestVersion && Date.now() - config.lastVersionCheck < CACHE_DURATION_MS) {
+    printUpdateNotice(currentVersion, config.latestVersion);
+    return;
+  }
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3e3);
+    const res = await fetch("https://registry.npmjs.org/anonli/latest", {
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (!res.ok) return;
+    const data = await res.json();
+    const latestVersion = data.version;
+    config.lastVersionCheck = Date.now();
+    config.latestVersion = latestVersion;
+    saveConfig(config);
+    printUpdateNotice(currentVersion, latestVersion);
+  } catch {
+  }
+}
+function printUpdateNotice(current, latest) {
+  if (semver.gt(latest, current)) {
+    updateNotice(current, latest);
+  }
+}
+
+// src/index.ts
+init_errors();
+init_constants();
+init_config2();
+var VERSION = CLI_VERSION;
+var helpConfig = createHelpConfig(VERSION);
+var program = new Command26().name("anonli").description("anon.li CLI - encrypted file drops & anonymous email aliases").version(VERSION, "-v, --version").option("-q, --quiet", "Suppress all non-essential output (spinners, tables, boxes)").configureHelp(helpConfig);
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(whoamiCommand);
+program.addCommand(dropCommand);
+program.addCommand(aliasCommand);
+program.addCommand(recipientCommand);
+program.addCommand(domainCommand);
+program.addCommand(apikeyCommand);
+program.addCommand(configCommand);
+program.addCommand(updateCommand);
+program.addCommand(subscribeCommand);
+program.addCommand(completionsCommand);
+program.exitOverride();
+function propagateSettings(cmd) {
+  for (const sub of cmd.commands) {
+    sub.configureHelp(helpConfig);
+    sub.exitOverride();
+    propagateSettings(sub);
+  }
+}
+propagateSettings(program);
+var AUTH_EXEMPT = /* @__PURE__ */ new Set([
+  "login",
+  "logout",
+  "config",
+  "update",
+  "completions",
+  "drop info",
+  "drop get",
+  "drop download",
+  "drop dl",
+  "drop share"
+]);
+program.hook("preAction", async (thisCommand, actionCommand) => {
+  const rootOpts = program.opts();
+  if (rootOpts.quiet) {
+    setQuiet(true);
+  }
+  const parts = [];
+  let cmd = actionCommand;
+  while (cmd && cmd !== program) {
+    parts.unshift(cmd.name());
+    cmd = cmd.parent;
+  }
+  const commandPath = parts.join(" ");
+  if (AUTH_EXEMPT.has(commandPath)) return;
+  if (getApiKey()) return;
+  if (!process.stdin.isTTY) {
+    throw new AuthError(
+      "Not authenticated. Set ANONLI_API_KEY or run `anonli login` interactively."
+    );
+  }
+  warn("Authentication required. Let's set up your API key.");
+  spacer();
+  const success2 = await runAuthFlow();
+  if (!success2) {
+    throw new AuthError("Authentication failed.");
+  }
+  spacer();
+});
+program.hook("postAction", async () => {
+  await checkForUpdates(VERSION).catch(() => {
+  });
+});
+async function main() {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err) {
+    if (err instanceof PlanLimitError) {
+      errorBox("Plan Limit", err.message, err.suggestion);
+      process.exit(err.exitCode);
+    }
+    if (err instanceof AuthError) {
+      error(err.message);
+      process.exit(err.exitCode);
+    }
+    if (err instanceof CliError) {
+      process.exit(err.exitCode);
+    }
+    const code = err?.code;
+    if (typeof code === "string" && code.startsWith("commander.")) {
+      process.exit(0);
+    }
+    if (err instanceof Error) {
+      console.error(`Error: ${err.message}`);
+    }
+    process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=index.js.map