#!/usr/bin/env node
/**
 * shotbot | Node.js CLI for the Shotbot screenshot API.
 *
 * Single-file standalone script. Requires Node.js 18+ (built-in fetch).
 * No third-party dependencies. Run `./shotbot help` for usage.
 *
 * Copyright (c) 2026 Valentin Beck
 * SPDX-License-Identifier: MIT
 */
'use strict';

const fs = require('node:fs');
const path = require('node:path');
const os = require('node:os');
const { URL } = require('node:url');

const VERSION = '0.3.0';
const API_BASE_DEFAULT = 'https://api.shotbot.net';
const POLL_INITIAL_S = 2;
const POLL_INTERVAL_S = 2;
const POLL_TIMEOUT_S = 180;

// ── Bootstrap ────────────────────────────────────────────────────────────────
const _nodeMajor = parseInt(process.versions.node.split('.')[0], 10);
if (!Number.isFinite(_nodeMajor) || _nodeMajor < 18) {
  process.stderr.write(`shotbot: requires Node.js 18+ (got ${process.versions.node})\n`);
  process.exit(2);
}
if (typeof fetch !== 'function') {
  process.stderr.write('shotbot: this Node build is missing the global fetch() (need 18+)\n');
  process.exit(2);
}

// ── Output helpers ───────────────────────────────────────────────────────────
let _colorCache = null;
function useColor() {
  if (_colorCache !== null) return _colorCache;
  if ('NO_COLOR' in process.env) { _colorCache = false; return false; }
  _colorCache = !!process.stdout.isTTY;
  return _colorCache;
}
function clr(s, code) { return useColor() ? `\x1b[${code}m${s}\x1b[0m` : s; }
function note(s = '') { process.stdout.write(s + '\n'); }
function ok(s)   { process.stdout.write(clr('✓', '32') + ' ' + s + '\n'); }
function warn(s) { process.stderr.write(clr('!', '33') + ' ' + s + '\n'); }
function err(s)  { process.stderr.write(clr('✗', '31') + ' ' + s + '\n'); }
function dim(s)  { return clr(s, '2'); }
function bold(s) { return clr(s, '1'); }

// ── Config ───────────────────────────────────────────────────────────────────
function home() {
  const h = os.homedir() || process.env.HOME || process.env.USERPROFILE || '';
  if (!h) { err('cannot determine home directory'); process.exit(2); }
  return h.replace(/[\\/]+$/, '');
}
function configDir()  { return path.join(home(), '.shotbot-node-cli'); }
function configPath() { return path.join(configDir(), 'config.json'); }

function configLoad() {
  try {
    const raw = fs.readFileSync(configPath(), 'utf8');
    const j = JSON.parse(raw);
    return (j && typeof j === 'object' && !Array.isArray(j)) ? j : {};
  } catch {
    return {};
  }
}

function configSave(c) {
  const d = configDir();
  try { fs.mkdirSync(d, { recursive: true, mode: 0o700 }); }
  catch { err(`cannot create config directory: ${d}`); process.exit(2); }
  try { fs.chmodSync(d, 0o700); } catch {}
  const p = configPath();
  try {
    fs.writeFileSync(p, JSON.stringify(c, null, 2) + '\n', { mode: 0o600 });
  } catch { err(`cannot write config file: ${p}`); process.exit(2); }
  try { fs.chmodSync(p, 0o600); } catch {}
}

function apiKey() {
  const env = (process.env.SHOTBOT_API_KEY || '').trim();
  if (env) return env;
  const cfg = configLoad();
  if (cfg.api_key) return String(cfg.api_key);
  return promptForKey();
}

// ── Persistent capture defaults ──────────────────────────────────────────────
// Keys allowed in config.json `defaults`. Type drives coercion in `set` and
// validation when merging into the parsed CLI options at capture time.
function defaultKeys() {
  return {
    // All tiers
    'preset':          'string', // og|mobile|youtube_thumbnail|square|reel|pinterest|tablet|desktop|desktop_hd|twitter_header|linkedin_banner|hero_banner
    'frame':           'string', // rounded|shadow|browser_chrome|browser_chrome_dark|mobile|mobile_light|tablet|tablet_light|laptop|polaroid|gradient|shotbot_brand
    'format':          'string', // jpg|png|webp|avif|pdf
    'viewport':        'int',    // 280..3840 (Pro custom; common 360..1920)
    'output-size':     'int',    // 120..1920
    'wait':            'int',    // 0..120
    'ratio':           'string', // 16:9, 4:3, 1:1, ...
    'color-scheme':    'string', // dark|light
    'full-page':       'bool',
    'nojs':            'bool',
    'hidpi':           'bool',
    'reduce-motion':   'bool',   // emulate prefers-reduced-motion: reduce
    // Pro
    'dismiss-cookies': 'string', // accept|reject
    'scroll':          'bool',
    'scroll-offset':   'int',    // 0..30000, scroll N px before capture
    'scroll-to':       'string', // CSS selector, scrollIntoView before capture
    'block-ads':       'bool',
    'crop-height':     'int',
    'selector':        'string',
    'autoplay-videos':     'bool',
    'omit-background':     'bool',
    'emulate-print-media': 'bool',
    'http-auth-user':  'string',
    'http-auth-pass':  'string',
    // PDF (only meaningful when format=pdf)
    'pdf-page-size':   'string', // A4|A3|A5|Letter|Legal|Tabloid
    'pdf-margin':      'int',    // 0..50 mm
    'pdf-scale':       'float',  // 0.10..2.00
    'pdf-landscape':   'bool',
    // CLI ergonomics
    'output':          'string', // path or "true" for cwd-auto-name
    'cdn':             'bool',    // upload to the public CDN (default: private)
    'timeout':         'int',    // poll timeout, seconds
  };
}

const ENUMS = {
  'color-scheme':    ['dark', 'light'],
  'dismiss-cookies': ['accept', 'reject'],
  'format':          ['jpg', 'png', 'webp', 'avif', 'pdf'],
  'pdf-page-size':   ['A4', 'A3', 'A5', 'Letter', 'Legal', 'Tabloid'],
};

function coerce(key, raw, kind) {
  if (kind === 'bool') {
    const v = String(raw).trim().toLowerCase();
    if (['1','true','yes','on'].includes(v)) return true;
    if (['0','false','no','off'].includes(v)) return false;
    err(`invalid boolean for ${key}: '${raw}' (use true|false)`);
    process.exit(2);
  }
  if (kind === 'int') {
    if (!/^-?\d+$/.test(String(raw).trim())) {
      err(`invalid integer for ${key}: '${raw}'`); process.exit(2);
    }
    return parseInt(raw, 10);
  }
  if (kind === 'float') {
    const n = Number(String(raw).trim());
    if (!Number.isFinite(n)) {
      err(`invalid number for ${key}: '${raw}'`); process.exit(2);
    }
    return n;
  }
  // Enum keys: validate against the canonical set defined in capture_options.php.
  if (Object.prototype.hasOwnProperty.call(ENUMS, key) && !ENUMS[key].includes(raw)) {
    err(`invalid value for ${key}: '${raw}' (allowed: ${ENUMS[key].join('|')})`);
    process.exit(2);
  }
  return raw;
}

function applyDefaults(opts) {
  const cfg = configLoad();
  const defaults = (cfg.defaults && typeof cfg.defaults === 'object' && !Array.isArray(cfg.defaults))
    ? cfg.defaults : null;
  if (!defaults) return opts;
  const allowed = defaultKeys();
  for (const [k, v] of Object.entries(defaults)) {
    if (!Object.prototype.hasOwnProperty.call(allowed, k)) continue; // unknown key: ignore silently
    if (Object.prototype.hasOwnProperty.call(opts, k)) continue;     // CLI flag wins
    opts[k] = v;
  }
  return opts;
}

function apiBase() {
  const b = (process.env.SHOTBOT_API_BASE || '').trim();
  return b ? b.replace(/\/+$/, '') : API_BASE_DEFAULT;
}

function promptForKey() {
  note();
  note(bold('No Shotbot API key configured.'));
  note('Get one at ' + clr('https://www.shotbot.net/api-key/', '36'));
  note();
  process.stdout.write('API key: ');
  const buf = Buffer.alloc(4096);
  let n = 0;
  try { n = fs.readSync(0, buf, 0, buf.length, null); }
  catch { err('cannot read from stdin'); process.exit(2); }
  const key = buf.slice(0, n).toString('utf8').replace(/[\r\n]+$/, '').trim();
  if (!key) { err('empty key, aborting'); process.exit(2); }
  if (!/^[0-9A-Za-z]{12}$/.test(key)) {
    warn('key does not match expected format (12 alphanumeric chars), saving anyway');
  }
  const cfg = configLoad();
  cfg.api_key = key;
  configSave(cfg);
  ok(`Saved to ${configPath()} (chmod 600)`);
  note();
  return key;
}

// ── HTTP ─────────────────────────────────────────────────────────────────────
function truthy(v) {
  if (v === undefined || v === null || v === false) return false;
  if (v === '' || v === 0 || v === '0') return false;
  return true;
}

async function http(method, urlPath, body) {
  const url = apiBase() + urlPath;
  const headers = {
    'Accept': 'application/json',
    'User-Agent': `shotbot-node-cli/${VERSION}`,
  };
  const init = { method, headers };
  if (method === 'POST') {
    headers['Content-Type'] = 'application/json';
    init.body = JSON.stringify(body || {});
  }
  let resp;
  const ctrl = new AbortController();
  const t = setTimeout(() => ctrl.abort(), 60000);
  try {
    resp = await fetch(url, { ...init, signal: ctrl.signal });
  } catch (e) {
    err(`network error: ${e && e.message ? e.message : e}`); process.exit(3);
  } finally { clearTimeout(t); }
  const raw = await resp.text();
  let j = null;
  try {
    const parsed = JSON.parse(raw);
    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) j = parsed;
  } catch {}
  return { code: resp.status, json: j, raw };
}

async function download(url, dest) {
  let resp;
  const ctrl = new AbortController();
  const t = setTimeout(() => ctrl.abort(), 120000);
  try {
    resp = await fetch(url, {
      headers: { 'User-Agent': `shotbot-node-cli/${VERSION}` },
      redirect: 'follow',
      signal: ctrl.signal,
    });
  } catch (e) {
    try { fs.unlinkSync(dest); } catch {}
    err(`download failed: ${e && e.message ? e.message : e}`); process.exit(3);
  } finally { clearTimeout(t); }
  if (resp.status !== 200) {
    try { fs.unlinkSync(dest); } catch {}
    err(`download failed (HTTP ${resp.status})`); process.exit(3);
  }
  let buf;
  try { buf = Buffer.from(await resp.arrayBuffer()); }
  catch (e) { err(`download failed: ${e && e.message ? e.message : e}`); process.exit(3); }
  try { fs.writeFileSync(dest, buf); }
  catch { err(`cannot open ${dest} for writing`); process.exit(2); }
  try { return fs.statSync(dest).size; } catch { return 0; }
}

// ── Args parser ──────────────────────────────────────────────────────────────
function parseArgs(argv) {
  const rest = argv.slice(2); // drop node + script
  let cmd = '';
  if (rest.length && !rest[0].startsWith('-')) cmd = rest.shift();
  const opts = {};
  const pos = [];
  let i = 0;
  while (i < rest.length) {
    const a = rest[i];
    if (a.startsWith('--')) {
      const tail = a.slice(2);
      const eq = tail.indexOf('=');
      if (eq >= 0) {
        opts[tail.slice(0, eq)] = tail.slice(eq + 1);
      } else {
        const nxt = i + 1 < rest.length ? rest[i + 1] : undefined;
        if (nxt !== undefined && !nxt.startsWith('-')) {
          opts[tail] = nxt; i++;
        } else {
          opts[tail] = true;
        }
      }
    } else if (a.startsWith('-') && a.length > 1) {
      opts[a.slice(1)] = true;
    } else {
      pos.push(a);
    }
    i++;
  }
  return { cmd, opts, pos };
}

// ── Commands ─────────────────────────────────────────────────────────────────
function cmdHelp() {
  const cfg = configPath();
  process.stdout.write(`
  shotbot v${VERSION}  Node.js CLI for the Shotbot screenshot API

  USAGE
    shotbot <command> [options]

  COMMANDS
    capture                Capture a single URL (see CAPTURE OPTIONS).
    status                 Show account plan, credits, quota and in-flight captures.
    set <key> [value]      Set a persistent default for \`capture\` (see DEFAULTS).
                           Booleans accept true/false/yes/no/1/0; bare \`set <key>\`
                           on a boolean is shorthand for \`set <key> true\`.
    unset <key>            Remove a persistent default.
    defaults               List currently-set persistent defaults.
    defaults --keys        List every key you can \`set\` and its type.
    config                 Print the path to the config file.
    reset                  Re-prompt for the API key (overwrites the stored one).
    version                Print the version and exit.
    help                   Print this help.

  CAPTURE OPTIONS  (free tier)
    --url=URL              Required. The page to capture (http/https).
    --preset=NAME          Named output bundle: og, mobile, youtube_thumbnail,
                           square, reel, pinterest, tablet (free); desktop,
                           desktop_hd, twitter_header, linkedin_banner,
                           hero_banner (Pro).
                           Fills viewport/output-size/crop-height in one go.
    --frame=NAME           Decorative frame around the image: rounded, shadow,
                           browser_chrome, browser_chrome_dark, mobile,
                           mobile_light, tablet, tablet_light, laptop, polaroid,
                           gradient, shotbot_brand.
                           Free accounts get a "shotbot.fr" mark | clean with Pro.
    --format=FMT           jpg | png | webp | avif | pdf           (default: jpg)
    --viewport=N           Viewport width, common 360..1920; Pro 280..3840 (default: 1280)
    --output-size=N        Resize the result. 120..1920 px (default: same as viewport)
    --wait=N               Seconds to wait after page load 0..120  (default: 5)
    --ratio=R              16:9, 4:3, 1:1, 9:16, etc.              (default: 16:9)
    --full-page            Capture the full scrollable page (max 30000 px).
    --nojs                 Disable JavaScript before navigation.
    --color-scheme=dark|light  Force prefers-color-scheme (matches API field).
    --hidpi                Render at 2x device pixel ratio.
    --reduce-motion        Emulate prefers-reduced-motion: reduce (well-built
                           sites skip animations | cleaner captures).

  CAPTURE OPTIONS  (Pro)
    --dismiss-cookies=accept|reject   Auto-handle cookie consent banners.
    --scroll                          Scroll the page before capture
                                      (triggers lazy-loaded images).
    --scroll-offset=N                 Scroll down N px before capture (0..30000).
    --scroll-to=CSS                   Scroll the matched element into view before
                                      capture (mutually exclusive with --scroll-offset).
    --block-ads                       Block ad-network requests.
    --crop-height=N                   Crop the result to N px tall (10..20000),
                                      overrides --ratio, implies full-page.
    --selector=CSS                    Capture only the matched DOM element.
    --autoplay-videos                 Allow unmuted <video autoplay> to start
                                      without a user gesture.
    --omit-background                 Transparent backdrop (PNG/WebP/AVIF only;
                                      JPG flattens to black).
    --emulate-print-media             Render with the page's print stylesheet.
    --http-auth-user=U
    --http-auth-pass=P                HTTP Basic Auth credentials.

  CAPTURE OPTIONS  (PDF only - when --format=pdf)
    --pdf-page-size=SIZE   A4 | A3 | A5 | Letter | Legal | Tabloid (default: A4)
    --pdf-margin=N         Page margin in mm 0..50                  (default: 10)
    --pdf-scale=F          Rendering scale 0.10..2.00               (default: 1.00)
    --pdf-landscape        Landscape orientation.

  CLI OPTIONS
    By default a capture is private and saved to the current directory as
    ./HOST-TOKEN.FMT. Use --output to choose where, --cdn for a public URL,
    or --json for machine output (the last two do not save a file).
    --output[=PATH]        Choose where to save (default: cwd, auto-named):
                             --output                 -> ./HOST-TOKEN.FMT (cwd, auto-named)
                             --output=DIR/            -> save into DIR/ (auto-named)
                             --output=path/file.jpg   -> save to that exact path
    --cdn                  Upload to the public CDN and return a permanent URL
                           (no local file is saved). Without it, captures stay
                           private (not on the CDN) and auto-expire server-side.
    --json                 Print the full API response as JSON (no file saved).
    --timeout=N            Max seconds to wait for the capture      (default: 180)

  DEFAULTS
    \`shotbot set <key> [value]\` stores a default in the config file. Any default
    is applied to every \`capture\` call; per-call flags always override.

    Settable keys (run \`shotbot defaults --keys\` for the full list):
      Free tier:
        format          (string)   viewport        (int)   output-size  (int)
        wait            (int)      ratio           (string)
        color-scheme    (dark|light)               full-page (bool)
        nojs            (bool)     hidpi           (bool)   reduce-motion (bool)
      Pro:
        dismiss-cookies (accept|reject)            scroll    (bool)
        block-ads       (bool)     crop-height     (int)
        selector        (string)   autoplay-videos (bool)
        omit-background (bool)     emulate-print-media (bool)
        http-auth-user / http-auth-pass (string)
      PDF:
        pdf-page-size   (A4|A3|A5|Letter|Legal|Tabloid)
        pdf-margin      (int)      pdf-scale       (float) pdf-landscape (bool)
      CLI:
        output          (string)   cdn             (bool)  timeout      (int)

    Examples:
      shotbot set full-page                     # always full-page
      shotbot set output ./shots/               # always save into ./shots/
      shotbot set cdn true                      # always publish to the public CDN
      shotbot set viewport 1440                 # always render at 1440 px
      shotbot set format webp                   # always webp
      shotbot set color-scheme dark             # always emulate prefers-color-scheme: dark
      shotbot defaults                          # show what's stored
      shotbot unset full-page                   # forget that default

    Note: captures are private by default and saved to the current directory.
    They are never published on the CDN unless you pass \`--cdn\` (or \`set cdn
    true\`), which returns a permanent public URL instead of saving a file.

  ENVIRONMENT
    SHOTBOT_API_KEY        Override the stored API key.
    SHOTBOT_API_BASE       Override the API base URL (default: https://api.shotbot.net).
    NO_COLOR               Disable ANSI color output.

  CONFIG FILE
    ${cfg}
    Stores: api_key (string), defaults (object). Chmod 600.

  EXIT CODES
    0  success                       4  API returned an error response
    2  bad invocation / config       5  waitlisted (quota exhausted)
    3  network error                 6  capture failed server-side
                                     7  polling timeout

  EXAMPLES
    shotbot capture --url=https://example.com
    shotbot capture --url=https://example.com --format=webp --viewport=1440
    shotbot capture --url=https://example.com --full-page --output=shot.jpg
    shotbot capture --url=https://example.com --json | jq .
`);
}

function cmdVersion() { process.stdout.write(VERSION + '\n'); }
function cmdConfig()  { process.stdout.write(configPath() + '\n'); }

function cmdReset() {
  const cfg = configLoad();
  delete cfg.api_key;
  configSave(cfg);
  ok('API key cleared.');
  promptForKey();
}

function cmdSet(pos) {
  if (pos.length < 1) {
    err('usage: shotbot set <key> [value]');
    note(dim('list keys: ') + bold('shotbot defaults --keys'));
    process.exit(2);
  }
  const key = pos[0];
  const allowed = defaultKeys();
  if (!Object.prototype.hasOwnProperty.call(allowed, key)) {
    err(`unknown key '${key}'`);
    note(dim('valid keys: ') + Object.keys(allowed).join(', '));
    process.exit(2);
  }
  const kind = allowed[key];
  let value;
  if (pos.length < 2) {
    if (kind !== 'bool') {
      err(`'${key}' is a ${kind}, value required: shotbot set ${key} <value>`);
      process.exit(2);
    }
    value = true;
  } else {
    value = coerce(key, String(pos[1]), kind);
  }
  const cfg = configLoad();
  if (!cfg.defaults || typeof cfg.defaults !== 'object' || Array.isArray(cfg.defaults)) {
    cfg.defaults = {};
  }
  cfg.defaults[key] = value;
  configSave(cfg);
  const shown = (typeof value === 'boolean') ? (value ? 'true' : 'false') : String(value);
  ok(`default ${key} = ${shown}`);
}

function cmdUnset(pos) {
  if (pos.length < 1) { err('usage: shotbot unset <key>'); process.exit(2); }
  const key = pos[0];
  const cfg = configLoad();
  const defaults = (cfg.defaults && typeof cfg.defaults === 'object' && !Array.isArray(cfg.defaults))
    ? cfg.defaults : null;
  if (!defaults || !Object.prototype.hasOwnProperty.call(defaults, key)) {
    warn(`no default set for '${key}'`); return;
  }
  delete defaults[key];
  if (Object.keys(defaults).length === 0) delete cfg.defaults;
  else cfg.defaults = defaults;
  configSave(cfg);
  ok(`cleared default ${key}`);
}

function cmdDefaults(opts) {
  if (truthy(opts.keys)) {
    for (const [k, t] of Object.entries(defaultKeys())) note(`  ${k} ${dim(`(${t})`)}`);
    return;
  }
  const cfg = configLoad();
  const d = (cfg.defaults && typeof cfg.defaults === 'object' && !Array.isArray(cfg.defaults))
    ? cfg.defaults : {};
  if (Object.keys(d).length === 0) {
    note('no persistent defaults set.');
    note(dim('try: ') + bold('shotbot set full-page true'));
    return;
  }
  note(bold('persistent defaults') + dim(` (in ${configPath()})`));
  for (const [k, v] of Object.entries(d)) {
    const shown = (typeof v === 'boolean') ? (v ? 'true' : 'false') : String(v);
    note(`  ${k}${dim(' = ')}${shown}`);
  }
}

async function cmdStatus(opts) {
  const key = apiKey();
  const r = await http('GET', '/account?key=' + encodeURIComponent(key));
  if (r.code === 401) {
    err('invalid API key  (run ' + bold('shotbot reset') + ' to update it)');
    process.exit(2);
  }
  if (r.code !== 200 || !r.json) {
    err('request failed: ' + (r.json?.error ?? `HTTP ${r.code}`));
    process.exit(3);
  }
  if (truthy(opts.json)) {
    process.stdout.write(JSON.stringify(r.json, null, 2) + '\n');
    return;
  }
  const d = r.json;
  const COL = 14;
  const lbl = s => dim(s.padEnd(COL));

  let planStr = d.plan;
  if (d.plan === 'pro' && d.pro_until) {
    const dt = new Date(d.pro_until * 1000).toISOString().slice(0, 10);
    planStr = bold('pro') + dim('  (until ' + dt + ')');
  }
  const quotaStr = d.quota_total > 0
    ? `${d.quota_used} / ${d.quota_total}  ${dim('(' + d.quota_remaining + ' remaining)')}`
    : dim('—');
  const creditStr = d.credit > 0 ? String(d.credit) : dim('0');
  const inflightStr = `${d.inflight} / ${d.inflight_cap}`;

  note('');
  note(lbl('plan')       + planStr);
  note(lbl('credits')    + creditStr);
  note(lbl('quota')      + quotaStr);
  note(lbl('in flight')  + inflightStr);
  note('');
}

async function cmdCapture(opts) {
  opts = applyDefaults(opts);

  const url = opts.url;
  if (typeof url !== 'string' || !url) {
    err('missing required --url');
    note('try: ' + dim('shotbot capture --url=https://example.com'));
    process.exit(2);
  }
  if (!/^https?:\/\//i.test(url)) {
    err('--url must start with http:// or https://'); process.exit(2);
  }

  const body = { key: apiKey(), url };

  // Captures are private by default: not published on static.shotbot.net,
  // retrieved on demand from the API and auto-expired. Pass --cdn to opt into
  // a permanent public CDN URL instead.
  body.private = !opts.cdn;

  if (truthy(opts.preset))           body.preset         = String(opts.preset);
  if (truthy(opts.frame))            body.frame          = String(opts.frame);
  if (truthy(opts.format))           body.format         = String(opts.format);
  if (truthy(opts.viewport))         body.viewport_width = parseInt(opts.viewport, 10);
  if (truthy(opts['output-size']))   body.output_size    = parseInt(opts['output-size'], 10);
  if (truthy(opts.ratio))            body.ratio          = String(opts.ratio);
  if (Object.prototype.hasOwnProperty.call(opts, 'wait')) body.wait_time = parseInt(opts.wait, 10);
  if (truthy(opts['full-page']))     body.fullpage       = true;
  if (truthy(opts.nojs))             body.nojs           = true;
  if (truthy(opts.hidpi))            body.hidpi          = true;
  if (truthy(opts['color-scheme'])) {
    const cs = String(opts['color-scheme']);
    if (!['dark','light'].includes(cs)) {
      err(`--color-scheme must be 'dark' or 'light' (got '${cs}')`); process.exit(2);
    }
    body.color_scheme = cs;
  }
  if (truthy(opts['dismiss-cookies'])) {
    const d = String(opts['dismiss-cookies']);
    if (!['accept','reject'].includes(d)) {
      err(`--dismiss-cookies must be 'accept' or 'reject' (got '${d}')`); process.exit(2);
    }
    body.dismiss_cookies = d;
  }
  if (truthy(opts.scroll))           body.scroll_before_capture = true;
  if (opts['scroll-offset'] != null) body.scroll_offset_px = parseInt(opts['scroll-offset'], 10);
  if (truthy(opts['scroll-to']))     body.scroll_to     = String(opts['scroll-to']);
  if (truthy(opts['block-ads']))     body.block_ads     = true;
  if (truthy(opts['crop-height']))   body.crop_height   = parseInt(opts['crop-height'], 10);
  if (truthy(opts.selector))         body.selector      = String(opts.selector);
  if (truthy(opts['autoplay-videos']))     body.autoplay_videos     = true;
  if (truthy(opts['reduce-motion']))       body.prefers_reduced_motion = true;
  if (truthy(opts['omit-background']))     body.omit_background     = true;
  if (truthy(opts['emulate-print-media'])) body.emulate_print_media = true;
  if (truthy(opts['http-auth-user'])) {
    body.http_auth = {
      user: String(opts['http-auth-user']),
      pass: String(opts['http-auth-pass'] || ''),
    };
  }
  // PDF options (silently ignored by API when format != pdf)
  if (truthy(opts['pdf-page-size'])) body.pdf_page_size = String(opts['pdf-page-size']);
  if (Object.prototype.hasOwnProperty.call(opts, 'pdf-margin'))
    body.pdf_margin_mm = parseInt(opts['pdf-margin'], 10);
  if (Object.prototype.hasOwnProperty.call(opts, 'pdf-scale'))
    body.pdf_scale = parseFloat(opts['pdf-scale']);
  if (truthy(opts['pdf-landscape'])) body.pdf_landscape = true;

  const timeout   = parseInt(opts.timeout || POLL_TIMEOUT_S, 10);
  const jsonOnly  = truthy(opts.json);
  // CLI default: save to the current directory (auto-named) unless the user
  // asked for a public CDN URL (--cdn) or machine-readable JSON (--json).
  // Captures are private and expire, so a local file is the durable artifact.
  let outputArg = Object.prototype.hasOwnProperty.call(opts, 'output') ? opts.output : null;
  if (outputArg === null && !jsonOnly && !opts.cdn) outputArg = true;

  // Pre-validate explicit directory targets (so we don't waste a capture).
  if (typeof outputArg === 'string' && outputArg &&
      (outputArg.endsWith('/') || outputArg.endsWith('\\'))) {
    const d = outputArg.replace(/[\/\\]+$/, '') || '.';
    let isDir = false;
    try { isDir = fs.statSync(d).isDirectory(); } catch {}
    if (!isDir) { err(`output directory does not exist: ${d}`); process.exit(2); }
  }

  if (!jsonOnly) {
    note(dim('→') + ' POST ' + apiBase() + '/capture');
    note('  ' + dim('url:    ') + url);
    note('  ' + dim('format: ') + (body.format || 'jpg')
       + dim(' · viewport: ') + (body.viewport_width || 1280)
       + dim(' · wait: ') + (body.wait_time != null ? body.wait_time : 5) + 's');
  }

  const r = await http('POST', '/capture', body);
  const j = r.json;

  if (r.code >= 400 || !j) {
    const msg = (j && (j.error || j.message || j.detail)) || `HTTP ${r.code}`;
    err('API error: ' + msg);
    if (r.code === 401) note(dim('hint: ') + 'run ' + bold('shotbot reset') + ' to update your API key');
    else if (r.code === 403) {
      if (j && Array.isArray(j.fields) && j.fields.includes('url'))
        note(dim('hint: ') + 'the URL contains a custom TCP port — upgrade to Pro to use it, see ' + clr('https://www.shotbot.net/pro/', '36'));
      else
        note(dim('hint: ') + 'this option may require a Pro account, see ' + clr('https://www.shotbot.net/pro/', '36'));
    }
    if (jsonOnly) note(r.raw);
    process.exit(4);
  }

  const status = j.status || '';
  if (status === 'waitlisted') {
    if (jsonOnly) { process.stdout.write(JSON.stringify(j) + '\n'); process.exit(5); }
    warn('waitlisted: ' + (j.detail || 'quota exhausted'));
    process.exit(5);
  }
  if (!('token' in j)) {
    err('unexpected response (no token)');
    if (jsonOnly) note(r.raw);
    process.exit(4);
  }

  const token = String(j.token);
  const eta   = parseInt(j.eta_seconds || 5, 10);
  const dedup = !!j.deduplicated;
  const jid   = j.job_id != null ? parseInt(j.job_id, 10) : null;

  if (!jsonOnly) {
    note(dim('  job:    ') + token + (jid != null ? dim(` #${jid}`) : '') + (dedup ? dim(' (deduplicated)') : ''));
    note(dim('  eta:    ') + '~' + eta + 's');
    note();
  }

  // Poll
  const start  = Date.now();
  const first  = Math.max(POLL_INITIAL_S, Math.min(eta, 8));
  const frames = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'];
  let tick = 0;
  await sleep(first * 1000);
  // eslint-disable-next-line no-constant-condition
  while (true) {
    const r2 = await http('GET', '/capture/' + encodeURIComponent(token));
    const s = r2.json;
    if (r2.code >= 400 || !s) {
      if (!jsonOnly && useColor()) process.stdout.write('\r\x1b[K');
      err(`status check failed (HTTP ${r2.code})`);
      if (jsonOnly) note(r2.raw);
      process.exit(4);
    }
    const st = s.status || '';
    if (st === 'done') {
      if (!jsonOnly && useColor()) process.stdout.write('\r\x1b[K');
      if (jsonOnly) { process.stdout.write(JSON.stringify(s) + '\n'); return; }
      const img      = s.image    || '';
      const dlUrl    = s.download || '';
      const willSave = outputArg !== null && (dlUrl || img);
      const elapsed  = Math.round((Date.now() - start) / 1000);
      ok(`captured in ${elapsed}s`);
      if (s.meta_page_title)  note(dim('  title:  ') + String(s.meta_page_title));
      if (s.meta_http_status) note(dim('  status: ') + String(s.meta_http_status));
      // Skip the (expiring) private URL when we're saving a local file | the
      // saved path below is what the user wants.
      if (dlUrl && !willSave)  note(dim('  private:') + ' ' + clr(dlUrl, '36') + dim(' (expires)'));
      else if (img)            note(dim('  image:  ') + clr(img, '36'));
      if (s.preview)          note(dim('  preview:') + ' ' + clr(String(s.preview), '36'));
      if (willSave) {
        const finalPath = resolveOutputPath(outputArg, url, token, body.format || 'jpg');
        const bytes = await download(dlUrl || img, finalPath);
        ok(`saved ${finalPath}` + dim(` (${humanBytes(bytes)})`));
      }
      return;
    }
    if (st === 'failed') {
      if (!jsonOnly && useColor()) process.stdout.write('\r\x1b[K');
      const code = s.error_code || 'unknown';
      if (jsonOnly) { process.stdout.write(JSON.stringify(s) + '\n'); process.exit(6); }
      err('capture failed: ' + code);
      if (s.image) note(dim('  partial:') + ' ' + clr(String(s.image), '36'));
      process.exit(6);
    }
    if ((Date.now() - start) / 1000 > timeout) {
      if (!jsonOnly && useColor()) process.stdout.write('\r\x1b[K');
      err(`timed out after ${timeout}s (job ${token} still ${st})`);
      note(dim('hint: ') + 'check later with ' + bold(`curl ${apiBase()}/capture/${token}`));
      process.exit(7);
    }
    if (!jsonOnly && useColor()) {
      const f = frames[tick++ % frames.length];
      const elapsedS = Math.round((Date.now() - start) / 1000);
      process.stdout.write('\r' + clr(f, '36') + ' ' + st + dim(` · ${elapsedS}s elapsed`));
    }
    await sleep(POLL_INTERVAL_S * 1000);
  }
}

function resolveOutputPath(opt, urlStr, token, fmt) {
  let host = 'shotbot';
  try {
    const h = new URL(urlStr).hostname;
    if (h) host = h;
  } catch {}
  host = host.replace(/^www\./i, '').replace(/[^a-z0-9.\-]/gi, '_');
  const auto = `${host}-${token.slice(0, 8)}.${fmt}`;

  if (opt === true || opt === '' || opt === null || opt === undefined) {
    return './' + auto;
  }
  const s = String(opt);
  if (s.endsWith('/') || s.endsWith('\\')) {
    const d = s.replace(/[\/\\]+$/, '') || '.';
    return d + '/' + auto;
  }
  try {
    if (fs.statSync(s).isDirectory()) return s.replace(/[\/\\]+$/, '') + '/' + auto;
  } catch {}
  return s;
}

function humanBytes(n) {
  if (n < 1024)        return `${n}B`;
  if (n < 1024 * 1024) return `${Math.round(n / 1024 * 10) / 10}KB`;
  return `${Math.round(n / 1024 / 1024 * 100) / 100}MB`;
}

function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }

// ── Dispatch ─────────────────────────────────────────────────────────────────
async function main() {
  const args = parseArgs(process.argv);
  let { cmd } = args;
  const { opts, pos } = args;

  if (cmd === '' && (truthy(opts.version) || truthy(opts.v))) cmd = 'version';
  if (cmd === '' && (truthy(opts.help) || truthy(opts.h)))    cmd = 'help';
  if (cmd === '') cmd = 'help';

  switch (cmd) {
    case 'capture':                 await cmdCapture(opts); break;
    case 'status':                  await cmdStatus(opts); break;
    case 'config':                  cmdConfig(); break;
    case 'set':                     cmdSet(pos); break;
    case 'unset':                   cmdUnset(pos); break;
    case 'defaults':                cmdDefaults(opts); break;
    case 'reset': case 'reset-key': cmdReset(); break;
    case 'version': case '-v': case '--version': cmdVersion(); break;
    case 'help':    case '-h': case '--help':    cmdHelp(); break;
    default:
      err('unknown command: ' + cmd);
      note(dim('try: ') + bold('shotbot help'));
      process.exit(2);
  }
}

main().catch((e) => {
  err((e && e.message) ? e.message : String(e));
  process.exit(1);
});