@carlelieser/nexus-cli 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,1247 @@
+#!/usr/bin/env node
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import ora from "ora";
+import { platform, homedir, tmpdir } from "node:os";
+import { join, basename, dirname } from "node:path";
+import { mkdtemp, rm, readFile, mkdir, rename, access, writeFile } from "node:fs/promises";
+import { Camoufox } from "camoufox-js";
+import { createWriteStream } from "node:fs";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+class NexusError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+  }
+}
+class AuthError extends NexusError {
+  kind = "auth";
+}
+class ScrapeError extends NexusError {
+  kind = "scrape";
+}
+class DownloadError extends NexusError {
+  kind = "download";
+}
+class NetworkError extends NexusError {
+  kind = "network";
+}
+class ThrottleError extends NexusError {
+  kind = "throttle";
+}
+class CancelError extends NexusError {
+  kind = "cancel";
+}
+function isCancel(e) {
+  return e instanceof CancelError || e instanceof Error && e.name === "AbortError";
+}
+function isNexusError(e) {
+  return e instanceof NexusError;
+}
+function summarize(results) {
+  return {
+    results,
+    succeeded: results.filter((r) => r.ok).length,
+    failed: results.filter((r) => !r.ok).length
+  };
+}
+const DEFAULT_BACKOFF = {
+  baseDelayMs: 2e3,
+  maxDelayMs: 6e4,
+  relaxAfter: 5
+};
+class BackoffPolicy {
+  delayMs = 0;
+  concurrency;
+  cleanStreak = 0;
+  cfg;
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.concurrency = cfg.maxConcurrency;
+  }
+  /** Current inter-mod delay to wait before starting the next member. */
+  get currentDelayMs() {
+    return this.delayMs;
+  }
+  /** Current effective concurrency. */
+  get currentConcurrency() {
+    return this.concurrency;
+  }
+  /** Record a throttle signal (429 / Cloudflare / repeated timeout). */
+  onThrottle() {
+    this.cleanStreak = 0;
+    this.delayMs = this.delayMs === 0 ? this.cfg.baseDelayMs : Math.min(this.delayMs * 2, this.cfg.maxDelayMs);
+    this.concurrency = Math.max(1, this.concurrency - 1);
+  }
+  /** Record a clean success; may relax pacing after enough in a row. */
+  onSuccess() {
+    this.cleanStreak += 1;
+    if (this.cleanStreak < this.cfg.relaxAfter) return;
+    this.cleanStreak = 0;
+    if (this.concurrency < this.cfg.maxConcurrency) {
+      this.concurrency += 1;
+    } else if (this.delayMs > 0) {
+      this.delayMs = Math.floor(this.delayMs / 2);
+      if (this.delayMs < this.cfg.baseDelayMs / 2) this.delayMs = 0;
+    }
+  }
+}
+const defaultSleep$1 = (ms) => new Promise((r) => setTimeout(r, ms));
+function isThrottle(e) {
+  if (e instanceof ThrottleError) return true;
+  const msg = (e instanceof Error ? e.message : String(e)).toLowerCase();
+  return msg.includes("429") || msg.includes("too many requests") || msg.includes("cloudflare") || msg.includes("just a moment") || msg.includes("timeout");
+}
+async function withRetry(fn, opts) {
+  const sleep = opts.sleep ?? defaultSleep$1;
+  let lastErr;
+  for (let attempt = 1; attempt <= opts.attempts; attempt++) {
+    opts.signal?.throwIfAborted();
+    try {
+      return await fn();
+    } catch (e) {
+      if (isCancel(e) || opts.signal?.aborted) throw e;
+      lastErr = e;
+      if (attempt === opts.attempts) break;
+      await sleep(opts.baseDelayMs * 2 ** (attempt - 1));
+    }
+  }
+  throw lastErr;
+}
+const defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function downloadCollection(deps, session, params) {
+  const sleep = params.sleep ?? defaultSleep;
+  params.signal?.throwIfAborted();
+  const req = deps.site.collectionMembersQuery(params.game, params.ref);
+  const json = await session.postJson(req.url, req.body, req.headers);
+  const all = deps.site.parseCollectionMembers(json);
+  const members = params.includeOptional ? all : all.filter((m) => !m.optional);
+  params.onResolved?.(members);
+  const policy = new BackoffPolicy({
+    maxConcurrency: params.concurrency,
+    ...DEFAULT_BACKOFF
+  });
+  const results = [];
+  for (let i = 0; i < members.length; i++) {
+    params.signal?.throwIfAborted();
+    const member = members[i];
+    if (policy.currentDelayMs > 0) {
+      await sleep(policy.currentDelayMs);
+    }
+    params.onStart?.(member, i + 1, members.length);
+    const result = await runOne(deps, session, params, member);
+    results.push(result);
+    if (result.ok) policy.onSuccess();
+    else if (result.throttled) policy.onThrottle();
+    params.onProgress?.(result);
+  }
+  return summarize(results);
+}
+async function runOne(deps, session, params, member) {
+  if (params.dryRun) {
+    return {
+      modId: member.modId,
+      ok: true,
+      files: [member.name ?? `mod ${member.modId} file ${member.fileId}`]
+    };
+  }
+  const target = {
+    url: deps.site.fileDownloadUrl(member.game, member.modId, member.fileId),
+    fileId: member.fileId,
+    category: member.optional ? "optional" : "main",
+    ...member.name ? { fileName: member.name } : {}
+  };
+  try {
+    const path = await withRetry(
+      () => deps.downloader.fetch(target, params.outDir, session, params.onFileProgress, params.signal),
+      {
+        attempts: params.retryAttempts,
+        baseDelayMs: params.retryBaseDelayMs,
+        ...params.sleep ? { sleep: params.sleep } : {},
+        ...params.signal ? { signal: params.signal } : {}
+      }
+    );
+    return { modId: member.modId, ok: true, files: [path] };
+  } catch (e) {
+    if (isCancel(e)) throw e;
+    const message = e instanceof Error ? e.message : String(e);
+    return {
+      modId: member.modId,
+      ok: false,
+      files: [],
+      error: message,
+      throttled: isThrottle(e)
+    };
+  }
+}
+async function downloadMod(deps, session, params) {
+  params.signal?.throwIfAborted();
+  const url = deps.site.modFilesUrl(params.game, params.modId);
+  const landed = await session.goto(url);
+  if (deps.site.isAuthRedirect(landed)) {
+    throw new AuthError("session expired or not authenticated");
+  }
+  const html = await session.html();
+  const all = deps.site.parseDownloadTargets(html);
+  const main = all.filter((t) => t.category === "main");
+  if (main.length === 0) {
+    throw new ScrapeError(`mod ${params.modId} has no main files`);
+  }
+  if (params.dryRun) {
+    return {
+      modId: params.modId,
+      ok: true,
+      files: main.map((t) => t.fileName ?? `file-${t.fileId}`)
+    };
+  }
+  const files = [];
+  for (const target of main) {
+    params.signal?.throwIfAborted();
+    const path = await withRetry(
+      () => deps.downloader.fetch(target, params.outDir, session, params.onFileProgress, params.signal),
+      {
+        attempts: params.retryAttempts,
+        baseDelayMs: params.retryBaseDelayMs,
+        ...params.sleep ? { sleep: params.sleep } : {},
+        ...params.signal ? { signal: params.signal } : {}
+      }
+    );
+    files.push(path);
+  }
+  return { modId: params.modId, ok: true, files };
+}
+async function restoreSession(deps, headful) {
+  const saved = await deps.store.load();
+  if (!saved) {
+    throw new AuthError("no saved session — run `nexus import --from chrome` first");
+  }
+  const session = await deps.browser.launch({ headful });
+  await session.setCookies(saved.cookies);
+  if (!await session.isLoggedIn()) {
+    await session.close();
+    throw new AuthError("session expired — run `nexus import --from chrome` again");
+  }
+  return session;
+}
+const APP = "nexus-cli";
+function configDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg) return join(xdg, APP);
+  switch (platform()) {
+    case "win32":
+      return join(process.env.APPDATA ?? join(homedir(), "AppData", "Roaming"), APP);
+    case "darwin":
+      return join(homedir(), "Library", "Application Support", APP);
+    default:
+      return join(homedir(), ".config", APP);
+  }
+}
+function sessionFile() {
+  return join(configDir(), "session.json");
+}
+function defaultOutDir(game) {
+  return join(process.cwd(), "downloads", game);
+}
+const MOD = /nexusmods\.com\/(?:games\/)?([^/]+)\/mods\/(\d+)/i;
+const COLLECTION = /nexusmods\.com\/games\/([^/]+)\/collections\/([^/?#]+)/i;
+function parseNexusUrl(input) {
+  const collection = COLLECTION.exec(input);
+  if (collection) {
+    return { game: collection[1], collection: collection[2] };
+  }
+  const mod = MOD.exec(input);
+  if (mod) {
+    return { game: mod[1], modId: Number(mod[2]) };
+  }
+  return null;
+}
+const out = {
+  info(msg) {
+    process.stdout.write(`${msg}
+`);
+  },
+  success(msg) {
+    process.stdout.write(`✓ ${msg}
+`);
+  },
+  warn(msg) {
+    process.stderr.write(`! ${msg}
+`);
+  },
+  error(e, verbose) {
+    if (verbose && e instanceof Error && e.stack) {
+      process.stderr.write(`${e.stack}
+`);
+      return;
+    }
+    const prefix = isNexusError(e) ? `${e.kind} error` : "error";
+    const msg = e instanceof Error ? e.message : String(e);
+    process.stderr.write(`✗ ${prefix}: ${msg}
+`);
+  }
+};
+const ACCOUNT_URL = "https://www.nexusmods.com/users/myaccount";
+const SIGN_IN_HOST$1 = "users.nexusmods.com";
+const NEXUS_DOMAIN = ".nexusmods.com";
+const CHALLENGE_TIMEOUT_MS = 25e3;
+const RESOLVE_TIMEOUT_MS = 6e4;
+function isChallenge(response) {
+  return response?.headers()["cf-mitigated"] === "challenge";
+}
+class CamoufoxBrowser {
+  async launch(opts) {
+    const userDataDir = await mkdtemp(join(tmpdir(), "nexus-camoufox-"));
+    const context = await Camoufox({
+      headless: !opts.headful,
+      user_data_dir: userDataDir,
+      humanize: true,
+      // Pin locale to match the imported session's origin. geoip is left OFF:
+      // when it resolved to a different region than the session cookies, the
+      // fingerprint/cookie mismatch triggered a hard Cloudflare challenge.
+      locale: "en-US"
+    });
+    const page = context.pages()[0] ?? await context.newPage();
+    return new CamoufoxSession(context, page, userDataDir);
+  }
+}
+class CamoufoxSession {
+  constructor(context, page, userDataDir) {
+    this.context = context;
+    this.page = page;
+    this.userDataDir = userDataDir;
+  }
+  async goto(url) {
+    await this.navigate(url);
+    return this.page.url();
+  }
+  /**
+   * Navigate to `url` and, if Cloudflare intercepts with a challenge, wait for
+   * Camoufox to auto-solve it. Returns the response for the real page.
+   *
+   * A challenge is identified by the `cf-mitigated: challenge` response header —
+   * a protocol signal, not page markup. When it's absent the response is the
+   * real page and we return at once; when present, Camoufox's auto-solve fires
+   * its own navigation to the real page, which we wait for.
+   */
+  async navigate(url) {
+    let response;
+    try {
+      response = await this.page.goto(url, { waitUntil: "commit" });
+    } catch (e) {
+      throw new NetworkError(`failed to load ${url}`, { cause: e });
+    }
+    const deadline = Date.now() + CHALLENGE_TIMEOUT_MS;
+    while (isChallenge(response) && Date.now() < deadline) {
+      response = await this.page.waitForNavigation({ waitUntil: "commit", timeout: deadline - Date.now() }).catch(() => response);
+    }
+    await this.page.waitForLoadState("domcontentloaded", { timeout: 1e4 }).catch(() => void 0);
+    return response;
+  }
+  async setCookies(cookies) {
+    await this.context.addCookies(
+      cookies.map((c) => ({
+        name: c.name,
+        value: c.value,
+        domain: c.domain || NEXUS_DOMAIN,
+        path: c.path || "/",
+        ...c.expires !== void 0 ? { expires: c.expires } : {},
+        ...c.httpOnly !== void 0 ? { httpOnly: c.httpOnly } : {},
+        ...c.secure !== void 0 ? { secure: c.secure } : {},
+        ...c.sameSite ? { sameSite: c.sameSite } : {}
+      }))
+    );
+  }
+  async isLoggedIn() {
+    try {
+      await this.navigate(ACCOUNT_URL);
+    } catch {
+      return false;
+    }
+    if (new URL(this.page.url()).host === SIGN_IN_HOST$1) return false;
+    const url = this.page.url();
+    return url.includes("/users/") || url.includes("/settings");
+  }
+  async html() {
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        await this.page.waitForLoadState("domcontentloaded", { timeout: 1e4 });
+        return await this.page.content();
+      } catch {
+        await this.page.waitForTimeout(500);
+      }
+    }
+    return this.page.content();
+  }
+  async postJson(url, body, headers = {}) {
+    return this.page.evaluate(
+      async ({ url: url2, body: body2, headers: headers2 }) => {
+        const res = await fetch(url2, {
+          method: "POST",
+          credentials: "include",
+          headers: { "content-type": "application/json", ...headers2 },
+          body: JSON.stringify(body2)
+        });
+        if (!res.ok) throw new Error(`HTTP ${res.status} from ${url2}`);
+        return res.json();
+      },
+      { url, body, headers }
+    );
+  }
+  async resolveUsername() {
+    await this.navigate(ACCOUNT_URL).catch(() => void 0);
+    return this.page.evaluate(() => {
+      const el = document.querySelector("[data-username]") ?? document.querySelector("#login-name, .username");
+      const ds = el?.dataset?.username;
+      if (ds) return ds;
+      const text = el?.textContent?.trim();
+      return text && text.length > 0 ? text : null;
+    }).catch(() => null);
+  }
+  async resolveDownloadUrl(filePageUrl) {
+    try {
+      await this.navigate(filePageUrl);
+      const slowButton = this.page.getByRole("button", { name: /slow download/i });
+      await slowButton.waitFor({ state: "visible", timeout: 3e4 });
+      const respPromise = this.page.waitForResponse((r) => /GenerateDownloadUrl/i.test(r.url()), {
+        timeout: RESOLVE_TIMEOUT_MS
+      });
+      this.page.once("download", (d) => void d.cancel().catch(() => void 0));
+      await slowButton.click();
+      const resp = await respPromise;
+      if (!resp.ok()) {
+        throw new NetworkError(`download resolver returned HTTP ${resp.status()}`);
+      }
+      const cdnUrl = (await resp.json()).url;
+      if (!cdnUrl) throw new NetworkError("resolver returned no download URL");
+      const cookieHeader = (await this.context.cookies()).map((c) => `${c.name}=${c.value}`).join("; ");
+      const userAgent = await this.page.evaluate(() => navigator.userAgent);
+      return { cdnUrl, cookieHeader, userAgent };
+    } catch (e) {
+      if (e instanceof NetworkError) throw e;
+      throw new NetworkError(`failed to resolve download for ${filePageUrl}`, {
+        cause: e
+      });
+    }
+  }
+  async close() {
+    await this.context.close().catch(() => void 0);
+    await rm(this.userDataDir, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+const CHROMIUM_VARIANTS = [
+  "chromium",
+  "brave",
+  "edge",
+  "opera",
+  "opera-gx",
+  "vivaldi",
+  "arc",
+  "whale"
+];
+function isChromiumVariant(key) {
+  return CHROMIUM_VARIANTS.includes(key);
+}
+const DISPLAY = {
+  chrome: "Chrome",
+  chromium: "Chromium",
+  brave: "Brave",
+  edge: "Edge",
+  opera: "Opera",
+  "opera-gx": "Opera GX",
+  vivaldi: "Vivaldi",
+  arc: "Arc",
+  whale: "Whale",
+  firefox: "Firefox",
+  safari: "Safari"
+};
+class BrowserCookieSource {
+  browser;
+  key;
+  constructor(from) {
+    this.key = from.toLowerCase();
+    if (!(this.key in DISPLAY)) {
+      throw new AuthError(
+        `unsupported browser '${from}' (supported: ${Object.keys(DISPLAY).join(", ")})`
+      );
+    }
+    this.browser = DISPLAY[this.key];
+  }
+  async read(domainSuffix) {
+    const strategy = await strategyFor(this.key);
+    let found;
+    try {
+      found = await strategy.queryCookies("%", domainSuffix);
+    } catch (e) {
+      throw new AuthError(`could not read ${this.browser} cookies`, { cause: e });
+    }
+    return found.map(toCookie);
+  }
+}
+async function strategyFor(key) {
+  process.env.DOTENV_CONFIG_QUIET = "true";
+  const gc = await import("@mherod/get-cookie");
+  if (key === "chrome") return new gc.ChromeCookieQueryStrategy();
+  if (key === "firefox") return new gc.FirefoxCookieQueryStrategy();
+  if (key === "safari") return new gc.SafariCookieQueryStrategy();
+  if (isChromiumVariant(key)) return new gc.ChromiumCookieQueryStrategy(key);
+  throw new AuthError(`unsupported browser '${key}'`);
+}
+function toCookie(c) {
+  const cookie = {
+    name: c.name,
+    value: String(c.value),
+    domain: c.domain,
+    path: c.meta?.path ?? "/"
+  };
+  if (c.meta?.secure !== void 0) cookie.secure = c.meta.secure;
+  if (c.meta?.httpOnly !== void 0) cookie.httpOnly = c.meta.httpOnly;
+  const expires = expiryToUnix(c.expiry);
+  if (expires !== void 0) cookie.expires = expires;
+  return cookie;
+}
+function expiryToUnix(expiry) {
+  if (expiry === void 0 || expiry === "Infinity") return void 0;
+  if (expiry instanceof Date) return Math.floor(expiry.getTime() / 1e3);
+  return expiry > 1e12 ? Math.floor(expiry / 1e3) : expiry;
+}
+class FileCookieSource {
+  constructor(path) {
+    this.path = path;
+    this.browser = `file ${path}`;
+  }
+  browser;
+  async read(domainSuffix) {
+    let raw;
+    try {
+      raw = await readFile(this.path, "utf8");
+    } catch (e) {
+      throw new AuthError(`could not read cookie file ${this.path}`, { cause: e });
+    }
+    const cookies = looksLikeJson(raw) ? parseJson(raw, this.path) : parseNetscape(raw);
+    return cookies.filter((c) => hostMatches(c.domain, domainSuffix));
+  }
+}
+function looksLikeJson(raw) {
+  return /^\s*[[{]/.test(raw);
+}
+function parseJson(raw, path) {
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch (e) {
+    throw new AuthError(`cookie file ${path} is not valid JSON`, { cause: e });
+  }
+  const arr = Array.isArray(data) ? data : Array.isArray(data.cookies) ? data.cookies : null;
+  if (!arr) {
+    throw new AuthError(`cookie file ${path} is not a JSON cookie array`);
+  }
+  const cookies = [];
+  for (const entry of arr) {
+    const c = entry;
+    if (!c.name || c.value === void 0 || !c.domain) continue;
+    const expires = c.expirationDate ?? c.expires;
+    cookies.push({
+      name: c.name,
+      value: c.value,
+      domain: c.domain,
+      path: c.path ?? "/",
+      secure: Boolean(c.secure),
+      httpOnly: Boolean(c.httpOnly),
+      sameSite: sameSiteOf(c.sameSite),
+      ...typeof expires === "number" && expires > 0 ? { expires: Math.floor(expires) } : {}
+    });
+  }
+  return cookies;
+}
+function parseNetscape(raw) {
+  const cookies = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#") && !trimmed.startsWith("#HttpOnly_")) continue;
+    const f = trimmed.split("	");
+    if (f.length < 7) continue;
+    let domain = f[0];
+    let httpOnly = false;
+    if (domain.startsWith("#HttpOnly_")) {
+      domain = domain.slice("#HttpOnly_".length);
+      httpOnly = true;
+    }
+    const expires = Number(f[4]);
+    const cookie = {
+      name: f[5],
+      value: f[6],
+      domain,
+      path: f[2] ?? "/",
+      secure: f[3].toUpperCase() === "TRUE",
+      httpOnly,
+      sameSite: "Lax"
+    };
+    if (Number.isFinite(expires) && expires > 0) cookie.expires = expires;
+    cookies.push(cookie);
+  }
+  return cookies;
+}
+function sameSiteOf(v) {
+  switch (v?.toLowerCase()) {
+    case "strict":
+      return "Strict";
+    case "no_restriction":
+    case "none":
+      return "None";
+    default:
+      return "Lax";
+  }
+}
+function hostMatches(domain, suffix) {
+  const host = domain.replace(/^\./, "").toLowerCase();
+  const s = suffix.toLowerCase();
+  return host === s || host.endsWith(`.${s}`);
+}
+class BrowserDownloader {
+  async fetch(target, outDir, session, onProgress, signal) {
+    signal?.throwIfAborted();
+    await mkdir(outDir, { recursive: true });
+    const resolved = await session.resolveDownloadUrl(target.url);
+    const name = filenameFrom(resolved.cdnUrl) ?? fallbackName(target);
+    const finalPath = join(outDir, name);
+    if (await exists(finalPath)) return finalPath;
+    const partPath = `${finalPath}.part`;
+    let res;
+    try {
+      res = await fetch(resolved.cdnUrl, {
+        headers: {
+          cookie: resolved.cookieHeader,
+          "user-agent": resolved.userAgent
+        },
+        ...signal ? { signal } : {}
+      });
+    } catch (e) {
+      if (signal?.aborted) throw e;
+      throw new NetworkError(`failed to fetch file ${target.fileId}`, { cause: e });
+    }
+    if (!res.ok || !res.body) {
+      throw new DownloadError(`download for file ${target.fileId} returned HTTP ${res.status}`);
+    }
+    const totalBytes = Number(res.headers.get("content-length") ?? 0);
+    let receivedBytes = 0;
+    const source = Readable.fromWeb(res.body);
+    source.on("data", (chunk) => {
+      receivedBytes += chunk.length;
+      onProgress?.({ receivedBytes, totalBytes });
+    });
+    try {
+      await pipeline(source, createWriteStream(partPath), signal ? { signal } : {});
+    } catch (e) {
+      await rm(partPath, { force: true });
+      if (signal?.aborted) throw e;
+      throw new DownloadError(`failed writing file ${target.fileId}`, { cause: e });
+    }
+    await rename(partPath, finalPath);
+    return finalPath;
+  }
+}
+function filenameFrom(cdnUrl) {
+  try {
+    const path = new URL(cdnUrl).pathname;
+    const base = decodeURIComponent(basename(path));
+    return base.length > 0 ? sanitize(base) : null;
+  } catch {
+    return null;
+  }
+}
+function fallbackName(target) {
+  if (target.fileName) {
+    const base = sanitize(target.fileName);
+    return /\.[a-z0-9]{2,4}$/i.test(base) ? base : `${base}-${target.fileId}`;
+  }
+  return `file-${target.fileId}`;
+}
+function sanitize(name) {
+  return name.replace(/[/\\?%*:|"<>]/g, "-").replace(/\s+/g, " ").trim();
+}
+async function exists(p) {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+const BASE = "https://www.nexusmods.com";
+const GRAPHQL_URL = "https://api-router.nexusmods.com/graphql";
+const SIGN_IN_HOST = "users.nexusmods.com";
+const COLLECTION_QUERY = `
+  query CollectionRevisionMods($slug: String!, $viewAdultContent: Boolean = true) {
+    collectionRevision(slug: $slug, viewAdultContent: $viewAdultContent) {
+      modFiles {
+        fileId
+        optional
+        file {
+          name
+          sizeInBytes
+          mod {
+            modId
+            name
+            game { domainName }
+          }
+        }
+      }
+    }
+  }`;
+class NexusWebAdapter {
+  modFilesUrl(game, modId) {
+    return `${BASE}/${game}/mods/${modId}?tab=files`;
+  }
+  collectionUrl(game, ref) {
+    return `${BASE}/games/${game}/collections/${ref}/mods`;
+  }
+  collectionMembersQuery(_game, ref) {
+    return {
+      url: GRAPHQL_URL,
+      body: {
+        operationName: "CollectionRevisionMods",
+        query: COLLECTION_QUERY,
+        variables: { slug: ref, viewAdultContent: true }
+      },
+      headers: { "x-graphql-operationname": "CollectionRevisionMods" }
+    };
+  }
+  parseCollectionMembers(json) {
+    const modFiles = json?.data?.collectionRevision?.modFiles;
+    if (!Array.isArray(modFiles)) {
+      throw new ScrapeError("unexpected collection response shape");
+    }
+    const members = [];
+    for (const entry of modFiles) {
+      const mod = entry.file?.mod;
+      const modId = mod?.modId;
+      const game = mod?.game?.domainName;
+      const fileId = entry.fileId;
+      if (!modId || !game || !fileId) continue;
+      const sizeBytes = Number(entry.file?.sizeInBytes);
+      members.push({
+        game,
+        modId,
+        fileId,
+        optional: Boolean(entry.optional),
+        ...entry.file?.name ? { name: entry.file.name } : {},
+        ...Number.isFinite(sizeBytes) && sizeBytes > 0 ? { sizeBytes } : {}
+      });
+    }
+    if (members.length === 0) {
+      throw new ScrapeError("collection has no downloadable files");
+    }
+    return members;
+  }
+  fileDownloadUrl(game, modId, fileId) {
+    return `${BASE}/${game}/mods/${modId}?tab=files&file_id=${fileId}`;
+  }
+  parseDownloadTargets(html) {
+    const base = modBaseUrl(html);
+    const targets = [];
+    for (const segment of segmentByCategory(html)) {
+      const tagRe = /<dt[^>]*id="file-expander-header-(\d+)"[^>]*>/gi;
+      let m;
+      while ((m = tagRe.exec(segment.body)) !== null) {
+        const fileId = Number(m[1]);
+        if (!Number.isFinite(fileId)) continue;
+        const tag = m[0];
+        const name = (/data-name="([^"]*)"/i.exec(tag)?.[1] ?? "").trim();
+        const version = (/data-version="([^"]*)"/i.exec(tag)?.[1] ?? "").trim();
+        const fileName = name ? version ? `${name} ${version}` : name : void 0;
+        targets.push({
+          url: downloadUrl(base, fileId),
+          fileId,
+          category: segment.category,
+          ...fileName ? { fileName } : {}
+        });
+      }
+    }
+    return targets;
+  }
+  isAuthRedirect(landedUrl) {
+    try {
+      return new URL(landedUrl).host === SIGN_IN_HOST;
+    } catch {
+      return false;
+    }
+  }
+}
+function segmentByCategory(html) {
+  const markerRe = (
+    // 1) Live container ids:   id="file-container-main-files"
+    // 2) Legacy text headers:  <h3>Main files</h3> / "Old versions"
+    /id="file-container-(main|optional|old|miscellaneous)-files"|<(?:h[1-6]|div|dt)[^>]*>\s*((?:main|optional|old|miscellaneous)[^<]*?files?|old versions?)\s*<\/(?:h[1-6]|div|dt)>/gi
+  );
+  const marks = [];
+  let m;
+  while ((m = markerRe.exec(html)) !== null) {
+    const category = m[1] ? categoryOf(m[1]) : categoryOf(m[2] ?? "");
+    marks.push({ index: m.index, category });
+  }
+  if (marks.length === 0) {
+    return [{ category: "unknown", body: html }];
+  }
+  const segments = [];
+  for (let i = 0; i < marks.length; i++) {
+    const start = marks[i].index;
+    const end = i + 1 < marks.length ? marks[i + 1].index : html.length;
+    segments.push({ category: marks[i].category, body: html.slice(start, end) });
+  }
+  return segments;
+}
+function categoryOf(label) {
+  const h = label.toLowerCase();
+  if (h.startsWith("main")) return "main";
+  if (h.startsWith("optional")) return "optional";
+  if (h.startsWith("old")) return "old";
+  if (h.startsWith("misc")) return "miscellaneous";
+  return "unknown";
+}
+function modBaseUrl(html) {
+  const og = /property="og:url"\s+content="([^"]+)"/i.exec(html);
+  if (og?.[1]) return og[1].replace(/[?#].*$/, "");
+  const path = /\/[a-z0-9]+\/mods\/\d+/i.exec(html);
+  return path ? `${BASE}${path[0]}` : BASE;
+}
+function downloadUrl(base, fileId) {
+  return `${base}?tab=files&file_id=${fileId}`;
+}
+class FileSessionStore {
+  constructor(path = sessionFile()) {
+    this.path = path;
+  }
+  async save(s) {
+    await mkdir(dirname(this.path), { recursive: true });
+    await writeFile(this.path, JSON.stringify(s, null, 2), { mode: 384 });
+  }
+  async load() {
+    let raw;
+    try {
+      raw = await readFile(this.path, "utf8");
+    } catch (e) {
+      if (e.code === "ENOENT") return null;
+      throw e;
+    }
+    const parsed = JSON.parse(raw);
+    if (!parsed.username || !parsed.cookies) return null;
+    return parsed;
+  }
+  async clear() {
+    await rm(this.path, { force: true });
+  }
+}
+function buildDeps() {
+  return {
+    browser: new CamoufoxBrowser(),
+    store: new FileSessionStore(),
+    site: new NexusWebAdapter(),
+    downloader: new BrowserDownloader()
+  };
+}
+const NEXUS_COOKIE_DOMAIN = "nexusmods.com";
+function cookieSourceFor(browser) {
+  return new BrowserCookieSource(browser);
+}
+function fileCookieSource(path) {
+  return new FileCookieSource(path);
+}
+const RETRY_ATTEMPTS = 3;
+const RETRY_BASE_DELAY_MS = 1e3;
+const downloadCommand = {
+  command: "download [target]",
+  describe: "Download a mod or a collection",
+  builder: (y) => y.positional("target", {
+    type: "string",
+    describe: "A nexusmods.com mod or collection URL (or use --game with --mod/--collection)"
+  }).option("game", {
+    type: "string",
+    describe: "Nexus game domain (e.g. skyrimspecialedition)"
+  }).option("mod", { type: "number", describe: "Numeric mod id" }).option("collection", { type: "string", describe: "Collection slug or id" }).option("out", { type: "string", describe: "Output directory" }).option("concurrency", { type: "number", default: 2 }).option("dry-run", {
+    type: "boolean",
+    default: false,
+    describe: "List what would be downloaded without fetching"
+  }).option("optional", {
+    type: "boolean",
+    default: false,
+    describe: "For collections, also download files marked optional"
+  }).option("headful", {
+    type: "boolean",
+    default: false,
+    describe: "Show the browser window (useful for debugging)"
+  }).conflicts("mod", "collection").check((argv) => {
+    if (typeof argv.target === "string") {
+      const ref = parseNexusUrl(argv.target);
+      if (!ref) {
+        throw new Error(`not a recognised Nexus mod or collection URL: ${argv.target}`);
+      }
+      argv.game = ref.game;
+      if ("modId" in ref) argv.mod = ref.modId;
+      else argv.collection = ref.collection;
+    }
+    if (argv.game === void 0) {
+      throw new Error("provide a Nexus URL, or --game with --mod/--collection");
+    }
+    if (argv.mod === void 0 && argv.collection === void 0) {
+      throw new Error("provide a Nexus URL, or --mod / --collection");
+    }
+    return true;
+  }),
+  handler: async (raw) => {
+    const argv = raw;
+    const outDir = argv.out ?? defaultOutDir(argv.game);
+    const deps = buildDeps();
+    const spinner = ora({ text: "Restoring session…", discardStdin: false }).start();
+    const controller = new AbortController();
+    const onSigint = () => {
+      if (controller.signal.aborted) {
+        spinner.stop();
+        out.warn("forced quit");
+        process.exit(130);
+      }
+      controller.abort(new CancelError("cancelled by user"));
+      spinner.text = "Cancelling… (press Ctrl+C again to force quit)";
+    };
+    process.on("SIGINT", onSigint);
+    let session;
+    try {
+      session = await restoreSession(deps, argv.headful);
+    } catch (e) {
+      spinner.stop();
+      process.removeListener("SIGINT", onSigint);
+      if (isCancel(e) || controller.signal.aborted) {
+        out.warn("cancelled");
+        process.exitCode = 130;
+        return;
+      }
+      out.error(e, argv.verbose);
+      process.exitCode = e instanceof AuthError ? 2 : 1;
+      return;
+    }
+    const runStart = Date.now();
+    const progress = new FileProgress();
+    const global = argv.collection !== void 0 ? new GlobalProgress() : null;
+    const ticker = setInterval(() => {
+      if (argv["dry-run"]) return;
+      spinner.text = composeStatus(progress, global, Date.now() - runStart);
+    }, 1e3);
+    if (typeof ticker.unref === "function") ticker.unref();
+    const signal = controller.signal;
+    try {
+      const report = argv.collection !== void 0 ? await runCollection(
+        deps,
+        session,
+        argv,
+        outDir,
+        spinner,
+        progress,
+        global,
+        runStart,
+        signal
+      ) : await runMod(deps, session, argv, outDir, spinner, progress, runStart, signal);
+      clearInterval(ticker);
+      finish(spinner, report, argv["dry-run"], Date.now() - runStart);
+      process.exitCode = report.failed > 0 ? 1 : 0;
+    } catch (e) {
+      clearInterval(ticker);
+      spinner.stop();
+      if (isCancel(e) || signal.aborted) {
+        out.warn("cancelled — partial downloads removed");
+        process.exitCode = 130;
+      } else {
+        out.error(e, argv.verbose);
+        process.exitCode = e instanceof AuthError ? 2 : 1;
+      }
+    } finally {
+      process.removeListener("SIGINT", onSigint);
+      await session.close();
+    }
+  }
+};
+async function runMod(deps, session, argv, outDir, spinner, progress, runStart, signal) {
+  const verb = argv["dry-run"] ? "Resolving" : "Downloading";
+  progress.start(`${verb} mod ${argv.mod}`);
+  spinner.text = progress.render();
+  const result = await downloadMod(deps, session, {
+    game: argv.game,
+    modId: argv.mod,
+    outDir,
+    dryRun: argv["dry-run"],
+    retryAttempts: RETRY_ATTEMPTS,
+    retryBaseDelayMs: RETRY_BASE_DELAY_MS,
+    signal,
+    onFileProgress: (p) => {
+      progress.update(p.receivedBytes, p.totalBytes);
+      spinner.text = composeStatus(progress, null, Date.now() - runStart);
+    }
+  });
+  progress.done();
+  return summarize([result]);
+}
+async function runCollection(deps, session, argv, outDir, spinner, progress, global, runStart, signal) {
+  spinner.text = "Resolving collection…";
+  return downloadCollection(deps, session, {
+    game: argv.game,
+    ref: argv.collection,
+    outDir,
+    concurrency: argv.concurrency,
+    dryRun: argv["dry-run"],
+    includeOptional: argv.optional,
+    retryAttempts: RETRY_ATTEMPTS,
+    retryBaseDelayMs: RETRY_BASE_DELAY_MS,
+    signal,
+    onResolved: (members) => {
+      global.setTotal(members);
+      global.begin();
+    },
+    onStart: (member, i, total) => {
+      const name = member.name ?? `mod ${member.modId}`;
+      const verb = argv["dry-run"] ? "Resolving" : "Downloading";
+      progress.start(`[${i}/${total}] ${verb} ${name}`);
+      global.startFile(member.sizeBytes ?? 0);
+      spinner.text = composeStatus(progress, global, Date.now() - runStart);
+    },
+    onFileProgress: (p) => {
+      progress.update(p.receivedBytes, p.totalBytes);
+      global.setCurrent(p.receivedBytes);
+      spinner.text = composeStatus(progress, global, Date.now() - runStart);
+    },
+    // Failures persist a line above the spinner.
+    onProgress: (r) => {
+      progress.done();
+      global.completeFile(r.ok);
+      if (!r.ok) {
+        const text = `mod ${r.modId} failed: ${r.error}`;
+        spinner.stopAndPersist({ symbol: "✗", text });
+        spinner.start();
+      }
+    }
+  });
+}
+function finish(spinner, report, dryRun, elapsedMs) {
+  if (dryRun) {
+    spinner.stop();
+    for (const r of report.results) {
+      out.info(`mod ${r.modId}: ${r.files.join(", ") || "(none)"}`);
+    }
+    out.info(`dry run — ${report.succeeded} resolvable, ${report.failed} not`);
+    return;
+  }
+  const took = `in ${clock(elapsedMs / 1e3)}`;
+  if (report.results.length === 1 && report.results[0]?.ok) {
+    const files = report.results[0].files.map((f) => basename(f));
+    spinner.succeed(`Downloaded ${files.join(", ")} ${took}`);
+    return;
+  }
+  const msg = `${report.succeeded} downloaded, ${report.failed} failed ${took}`;
+  if (report.failed > 0) spinner.warn(msg);
+  else spinner.succeed(msg);
+}
+class GlobalProgress {
+  startedAt = Date.now();
+  totalBytes = 0;
+  completedBytes = 0;
+  currentBytes = 0;
+  /** The in-flight file's known size from the API (for skipped files). */
+  currentSize = 0;
+  /** Set the known total from the resolved member list. */
+  setTotal(members) {
+    this.totalBytes = members.reduce((sum, m) => sum + (m.sizeBytes ?? 0), 0);
+  }
+  /** Begin the timer once downloading actually starts. */
+  begin() {
+    this.startedAt = Date.now();
+  }
+  /** Note the file about to download and its known size. */
+  startFile(sizeBytes) {
+    this.currentBytes = 0;
+    this.currentSize = sizeBytes;
+  }
+  /** Update the in-flight file's streamed byte count. */
+  setCurrent(bytes) {
+    this.currentBytes = bytes;
+  }
+  /**
+   * Settle the in-flight file. On success, credit its bytes toward the total —
+   * the streamed amount, or the known size when nothing streamed (a file that
+   * already existed and was skipped). On failure, discard it: a file that
+   * errored out must not count as downloaded.
+   */
+  completeFile(ok) {
+    if (ok) {
+      this.completedBytes += Math.max(this.currentBytes, this.currentSize);
+    }
+    this.currentBytes = 0;
+    this.currentSize = 0;
+  }
+  /**
+   * Render the secondary line:
+   *   total  18%  240 MB/1.3 GB  elapsed 02:15  ETA 48:30
+   * `elapsedMs` is the whole-run elapsed (so both ETAs share one clock source).
+   */
+  render(runElapsedMs) {
+    if (this.totalBytes <= 0) return "";
+    const done = this.completedBytes + this.currentBytes;
+    const elapsedMs = Math.max(Date.now() - this.startedAt, 1);
+    const rate = done / (elapsedMs / 1e3);
+    const pct = Math.floor(done / this.totalBytes * 100);
+    const cols = [
+      "total",
+      `${pct}%`,
+      `${size(done)}/${size(this.totalBytes)}`,
+      `elapsed ${clock(runElapsedMs / 1e3)}`
+    ];
+    if (rate > 0 && done > 0) {
+      cols.push(`ETA ${clock((this.totalBytes - done) / rate)}`);
+    }
+    return cols.join("  ");
+  }
+}
+class FileProgress {
+  startedAt = 0;
+  received = 0;
+  total = 0;
+  label = "";
+  active = false;
+  /** Reset for a new file. `label` is the position + name, e.g. "[3/476] SkyUI". */
+  start(label) {
+    this.startedAt = Date.now();
+    this.received = 0;
+    this.total = 0;
+    this.label = label;
+    this.active = true;
+  }
+  /** Record the latest byte counts (called from the download callback). */
+  update(received, total) {
+    this.received = received;
+    this.total = total;
+    this.active = true;
+  }
+  /** Render the file line against *now* so elapsed/speed/ETA advance live. */
+  render() {
+    if (!this.label) return "";
+    if (!this.active || this.received === 0) return this.label;
+    const elapsedMs = Math.max(Date.now() - this.startedAt, 1);
+    const rate = this.received / (elapsedMs / 1e3);
+    const cols = [this.label];
+    if (this.total > 0) {
+      cols.push(`${Math.floor(this.received / this.total * 100)}%`);
+      cols.push(`${size(this.received)}/${size(this.total)}`);
+    } else {
+      cols.push(size(this.received));
+    }
+    cols.push(`${size(rate)}/s`);
+    if (this.total > 0 && rate > 0) {
+      cols.push(`ETA ${clock((this.total - this.received) / rate)}`);
+    }
+    return cols.join("  ");
+  }
+  /** Mark the file finished so the ticker stops rendering its line. */
+  done() {
+    this.active = false;
+  }
+}
+function composeStatus(progress, global, runElapsedMs) {
+  const fileLine = progress.render();
+  const totalLine = global?.render(runElapsedMs) ?? "";
+  return totalLine ? `${fileLine}
+  ${totalLine}` : fileLine;
+}
+function size(bytes) {
+  if (bytes >= 1073741824) return `${(bytes / 1073741824).toFixed(1)} GB`;
+  if (bytes >= 1048576) return `${(bytes / 1048576).toFixed(1)} MB`;
+  if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${Math.round(bytes)} B`;
+}
+function clock(seconds) {
+  const s = Math.max(0, Math.floor(seconds));
+  const h = Math.floor(s / 3600);
+  const m = Math.floor(s % 3600 / 60);
+  const sec = s % 60;
+  return [h, m, sec].map((n) => String(n).padStart(2, "0")).join(":");
+}
+async function importSession(deps, params) {
+  const cookies = await deps.source.read(params.domainSuffix);
+  if (cookies.length === 0) {
+    throw new AuthError(
+      `no ${params.domainSuffix} cookies found in ${deps.source.browser} — log into Nexus there first`
+    );
+  }
+  let username = "nexus-user";
+  if (params.validate) {
+    const session = await deps.browser.launch({ headful: false });
+    try {
+      await session.setCookies(cookies);
+      if (!await session.isLoggedIn()) {
+        throw new AuthError(`imported ${deps.source.browser} cookies are not logged in to Nexus`);
+      }
+      username = await session.resolveUsername() ?? username;
+    } finally {
+      await session.close();
+    }
+  }
+  const saved = {
+    username,
+    cookies,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await deps.store.save(saved);
+  return saved;
+}
+const importCommand = {
+  command: "import",
+  describe: "Import Nexus cookies from your existing browser session",
+  builder: (y) => y.option("from", {
+    type: "string",
+    default: "chrome",
+    describe: "Browser to import cookies from (chrome, brave, edge, opera, vivaldi, arc, firefox, safari)"
+  }).option("file", {
+    type: "string",
+    describe: "Import from an exported cookie file (cookies.txt or JSON) instead of a browser"
+  }).conflicts("file", "from").option("validate", {
+    type: "boolean",
+    default: true,
+    describe: "Open a headless browser to confirm the cookies are logged in"
+  }),
+  handler: async (raw) => {
+    const argv = raw;
+    const { browser, store } = buildDeps();
+    try {
+      const source = argv.file ? fileCookieSource(argv.file) : cookieSourceFor(argv.from);
+      const session = await importSession(
+        { source, browser, store },
+        { domainSuffix: NEXUS_COOKIE_DOMAIN, validate: argv.validate }
+      );
+      out.success(
+        `imported ${session.cookies.length} cookie(s) from ${source.browser}` + (session.username !== "nexus-user" ? ` for ${session.username}` : "")
+      );
+      process.exitCode = 0;
+    } catch (e) {
+      out.error(e, argv.verbose);
+      process.exitCode = 1;
+    }
+  }
+};
+const logoutCommand = {
+  command: "logout",
+  describe: "Clear the imported session",
+  handler: async () => {
+    const { store } = buildDeps();
+    const existing = await store.load();
+    await store.clear();
+    if (existing) {
+      out.success(`logged out (${existing.username})`);
+    } else {
+      out.info("no session to clear");
+    }
+    process.exitCode = 0;
+  }
+};
+await yargs(hideBin(process.argv)).scriptName("nexus").usage("$0 <command> [options]").option("verbose", {
+  type: "boolean",
+  default: false,
+  describe: "Print full stack traces on error",
+  global: true
+}).command(importCommand).command(logoutCommand).command(downloadCommand).demandCommand(1, "a command is required").strict().help().parseAsync();
+//# sourceMappingURL=index.js.map