leak-cli 2026.2.17-beta.0 → 2026.2.17

package/scripts/ui.js

@@ -0,0 +1,106 @@
+const ANSI_PREFIX = "\x1b[";
+const ANSI_RESET = `${ANSI_PREFIX}0m`;
+
+const COLOR_CODES = {
+  bold: "1",
+  dim: "2",
+  red: "31",
+  green: "32",
+  yellow: "33",
+  blue: "34",
+  cyan: "36",
+};
+
+export function supportsColor(stream = process.stdout) {
+  const noColorSet = Object.prototype.hasOwnProperty.call(process.env, "NO_COLOR");
+  if (noColorSet) return false;
+  return Boolean(stream?.isTTY);
+}
+
+export function supportsHyperlinks(stream = process.stdout) {
+  const noColorSet = Object.prototype.hasOwnProperty.call(process.env, "NO_COLOR");
+  if (noColorSet) return false;
+  if (!stream?.isTTY) return false;
+  const term = String(process.env.TERM || "").toLowerCase();
+  if (!term || term === "dumb") return false;
+  return true;
+}
+
+function colorize(enabled, code, text) {
+  const value = String(text ?? "");
+  if (!enabled) return value;
+  return `${ANSI_PREFIX}${code}m${value}${ANSI_RESET}`;
+}
+
+function normalizeRows(rows) {
+  return rows
+    .map((row) => {
+      if (!row) return null;
+      if (Array.isArray(row)) return { key: row[0], value: row[1] };
+      return row;
+    })
+    .filter((row) => row && row.value !== undefined && row.value !== null && row.value !== "");
+}
+
+export function createUi(stream = process.stdout) {
+  const enabled = supportsColor(stream);
+  const hyperlinksEnabled = supportsHyperlinks(stream);
+
+  const heading = (text) => colorize(enabled, `${COLOR_CODES.bold};${COLOR_CODES.cyan}`, text);
+  const section = (text) => colorize(enabled, COLOR_CODES.bold, text);
+  const muted = (text) => colorize(enabled, COLOR_CODES.dim, text);
+  const key = (text) => colorize(enabled, COLOR_CODES.cyan, text);
+  const value = (text) => String(text ?? "");
+
+  const ok = (text) => colorize(enabled, COLOR_CODES.green, text);
+  const warn = (text) => colorize(enabled, COLOR_CODES.yellow, text);
+  const error = (text) => colorize(enabled, COLOR_CODES.red, text);
+  const info = (text) => colorize(enabled, COLOR_CODES.blue, text);
+
+  const statusLabel = (kind) => {
+    const normalized = String(kind || "info").toLowerCase();
+    if (normalized === "ok") return ok("[ok]");
+    if (normalized === "warn") return warn("[warn]");
+    if (normalized === "error") return error("[error]");
+    return info("[info]");
+  };
+
+  const statusLine = (kind, text) => `${statusLabel(kind)} ${String(text ?? "")}`;
+
+  const formatRows = (rows, options = {}) => {
+    const { indent = "  ", keySuffix = ":" } = options;
+    const normalized = normalizeRows(rows);
+    const width = normalized.reduce((max, row) => Math.max(max, String(row.key).length), 0);
+    return normalized.map((row) => {
+      const label = `${String(row.key).padEnd(width)}${keySuffix}`;
+      return `${indent}${key(label)} ${value(row.value)}`;
+    });
+  };
+
+  const link = (url, label) => {
+    const href = String(url ?? "").trim();
+    const text = String(label ?? href);
+    if (!href) return text;
+    if (!hyperlinksEnabled) return text;
+    if (!/^https?:\/\//i.test(href)) return text;
+    return `\u001B]8;;${href}\u0007${text}\u001B]8;;\u0007`;
+  };
+
+  return {
+    enabled,
+    hyperlinksEnabled,
+    heading,
+    section,
+    muted,
+    key,
+    value,
+    ok,
+    warn,
+    error,
+    info,
+    statusLabel,
+    statusLine,
+    formatRows,
+    link,
+  };
+}

package/src/access_mode.js

@@ -0,0 +1,51 @@
+export const ACCESS_MODE_VALUES = Object.freeze([
+  "no-download-code-no-payment",
+  "download-code-only-no-payment",
+  "payment-only-no-download-code",
+  "download-code-and-payment",
+]);
+
+export const DEFAULT_ACCESS_MODE = "payment-only-no-download-code";
+
+const ACCESS_MODE_SET = new Set(ACCESS_MODE_VALUES);
+
+export function normalizeAccessMode(value) {
+  return String(value || "").trim().toLowerCase();
+}
+
+export function isValidAccessMode(value) {
+  return ACCESS_MODE_SET.has(normalizeAccessMode(value));
+}
+
+export function resolveAccessMode(value, fallback = DEFAULT_ACCESS_MODE) {
+  const normalized = normalizeAccessMode(value);
+  if (ACCESS_MODE_SET.has(normalized)) return normalized;
+  return fallback;
+}
+
+export function accessModeRequiresDownloadCode(mode) {
+  const normalized = normalizeAccessMode(mode);
+  return (
+    normalized === "download-code-only-no-payment" ||
+    normalized === "download-code-and-payment"
+  );
+}
+
+export function accessModeRequiresPayment(mode) {
+  const normalized = normalizeAccessMode(mode);
+  return (
+    normalized === "payment-only-no-download-code" ||
+    normalized === "download-code-and-payment"
+  );
+}
+
+export function accessModeSummary(mode) {
+  const normalized = normalizeAccessMode(mode);
+  if (normalized === "download-code-and-payment")
+    return "Download code and payment required";
+  if (normalized === "download-code-only-no-payment")
+    return "Download code required; no payment";
+  if (normalized === "payment-only-no-download-code")
+    return "Payment required; no download code";
+  return "No download code; no payment";
+}

package/src/download_code.js

@@ -0,0 +1,91 @@
+import { randomBytes, scrypt as scryptCallback, timingSafeEqual } from "node:crypto";
+import { promisify } from "node:util";
+
+const scrypt = promisify(scryptCallback);
+
+export const DOWNLOAD_CODE_HEADER = "X-LEAK-DOWNLOAD-CODE";
+
+const SCRYPT_PREFIX = "scrypt";
+const SCRYPT_N = 16384;
+const SCRYPT_R = 8;
+const SCRYPT_P = 1;
+const SCRYPT_KEYLEN = 32;
+
+function assertHex(value, label) {
+  if (!/^[0-9a-f]+$/i.test(value) || value.length % 2 !== 0) {
+    throw new Error(`Invalid ${label} encoding`);
+  }
+}
+
+function normalizeCode(value) {
+  return String(value || "").trim();
+}
+
+export function parseDownloadCodeHash(encoded) {
+  const raw = String(encoded || "").trim();
+  const parts = raw.split("$");
+  if (parts.length !== 6) throw new Error("Invalid download code hash format");
+  if (parts[0] !== SCRYPT_PREFIX) throw new Error("Unsupported download code hash format");
+
+  const n = Number(parts[1]);
+  const r = Number(parts[2]);
+  const p = Number(parts[3]);
+  const saltHex = parts[4];
+  const digestHex = parts[5];
+
+  if (!Number.isFinite(n) || n <= 0) throw new Error("Invalid download code hash parameter: N");
+  if (!Number.isFinite(r) || r <= 0) throw new Error("Invalid download code hash parameter: r");
+  if (!Number.isFinite(p) || p <= 0) throw new Error("Invalid download code hash parameter: p");
+  assertHex(saltHex, "salt");
+  assertHex(digestHex, "digest");
+
+  return {
+    n: Math.floor(n),
+    r: Math.floor(r),
+    p: Math.floor(p),
+    salt: Buffer.from(saltHex, "hex"),
+    digest: Buffer.from(digestHex, "hex"),
+  };
+}
+
+export function isValidDownloadCodeHash(encoded) {
+  try {
+    parseDownloadCodeHash(encoded);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function hashDownloadCode(downloadCode) {
+  const normalized = normalizeCode(downloadCode);
+  if (!normalized) throw new Error("Download code cannot be empty");
+
+  const salt = randomBytes(16);
+  const digest = await scrypt(normalized, salt, SCRYPT_KEYLEN, {
+    N: SCRYPT_N,
+    r: SCRYPT_R,
+    p: SCRYPT_P,
+    maxmem: 64 * 1024 * 1024,
+  });
+
+  return `${SCRYPT_PREFIX}$${SCRYPT_N}$${SCRYPT_R}$${SCRYPT_P}$${salt.toString("hex")}$${Buffer.from(digest).toString("hex")}`;
+}
+
+export async function verifyDownloadCode(downloadCode, encodedHash) {
+  const normalized = normalizeCode(downloadCode);
+  if (!normalized) return false;
+
+  const parsed = parseDownloadCodeHash(encodedHash);
+  const actual = Buffer.from(
+    await scrypt(normalized, parsed.salt, parsed.digest.length, {
+      N: parsed.n,
+      r: parsed.r,
+      p: parsed.p,
+      maxmem: 64 * 1024 * 1024,
+    }),
+  );
+
+  if (actual.length !== parsed.digest.length) return false;
+  return timingSafeEqual(actual, parsed.digest);
+}