@skrr-ai/cli 0.1.114 → 0.1.116

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/recoveryCode.js

@@ -1,213 +1,135 @@
 "use strict";
-/**
- * recoveryCode.ts — 1Password-style printable account-recovery code format.
- *
- * Format: 11 groups × 5 base32 chars = 55 chars, encoding 32 bytes (256 bits).
- * Example: W7K2J-X9P3M-R6Y4Q-T8N2A-C5VWB-D3FHK-M4LPZ-Q6RSX-Y2JGE-B7NHC-E9KWF
- *
- * Properties:
- *   (a) 11 groups × 5 chars = 55 chars total (encodes 32 bytes exactly,
- *       padded to 56 base32 chars → 55 significant chars + 1 trailing
- *       partial group from the 256-bit boundary math)
- *   (b) H15 — strict alphabet: no confusable-char substitution (0/1/8/9 are
- *       never in valid output; silent mapping shrinks key space and masks
- *       brute-force telemetry). Whitespace and dashes stripped; mixed-case
- *       tolerated. Any character outside A-Z2-7 after normalization is
- *       rejected with code INVALID_RECOVERY_CODE_ALPHABET.
- *   (c) No checksum — intentional, matches 1Password/Happy format;
- *       user discovers a typo immediately on failed redemption
- *
- * RFC 4648 base32 alphabet: A–Z, 2–7.
- * No npm deps — Node.js built-ins only, same philosophy as pkce.ts.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatRecoveryCode = formatRecoveryCode;
-exports.parseRecoveryCode = parseRecoveryCode;
-exports.normalizeRecoveryCode = normalizeRecoveryCode;
-exports.isValidRecoveryCode = isValidRecoveryCode;
-const BASE32_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
-/** Number of base32 characters needed to encode 32 bytes.
- *  256 bits / 5 bits-per-char = 51.2 → ceil = 52 significant chars.
- *  But we split into 11×5=55 groups, so the last group is padded.
- *  We always produce exactly 55 output chars (some trailing bits zeroed). */
-const TOTAL_CHARS = 55; // 11 groups × 5 chars
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var recoveryCode_exports = {};
+__export(recoveryCode_exports, {
+  formatRecoveryCode: () => formatRecoveryCode,
+  isValidRecoveryCode: () => isValidRecoveryCode,
+  normalizeRecoveryCode: () => normalizeRecoveryCode,
+  parseRecoveryCode: () => parseRecoveryCode
+});
+module.exports = __toCommonJS(recoveryCode_exports);
+const BASE32_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+const TOTAL_CHARS = 55;
 const GROUP_COUNT = 11;
 const GROUP_SIZE = 5;
 const DECODED_BYTE_LENGTH = 32;
-// Build a reverse-lookup table: char → 5-bit value (for fast decode).
-const CHAR_TO_VALUE = new Uint8Array(128).fill(0xff);
+const CHAR_TO_VALUE = new Uint8Array(128).fill(255);
 for (let i = 0; i < BASE32_ALPHABET.length; i++) {
-    CHAR_TO_VALUE[BASE32_ALPHABET.charCodeAt(i)] = i;
+  CHAR_TO_VALUE[BASE32_ALPHABET.charCodeAt(i)] = i;
 }
-/**
- * Convert raw bytes to a base32 string (no padding chars, no dashes).
- * Produces exactly TOTAL_CHARS characters for 32-byte input.
- */
 function bytesToBase32(bytes) {
-    const result = [];
-    let buffer = 0;
-    let bufferBits = 0;
-    for (const byte of bytes) {
-        buffer = (buffer << 8) | byte;
-        bufferBits += 8;
-        while (bufferBits >= 5) {
-            bufferBits -= 5;
-            result.push(BASE32_ALPHABET[(buffer >> bufferBits) & 0x1f]);
-        }
+  const result = [];
+  let buffer = 0;
+  let bufferBits = 0;
+  for (const byte of bytes) {
+    buffer = buffer << 8 | byte;
+    bufferBits += 8;
+    while (bufferBits >= 5) {
+      bufferBits -= 5;
+      result.push(BASE32_ALPHABET[buffer >> bufferBits & 31]);
     }
-    // Flush remaining bits — pad with zero bits on the right.
-    if (bufferBits > 0) {
-        result.push(BASE32_ALPHABET[(buffer << (5 - bufferBits)) & 0x1f]);
-    }
-    // Extend to TOTAL_CHARS by repeating the last char (deterministic, lossless
-    // since parseRecoveryCode only uses the first 32 decoded bytes).
-    while (result.length < TOTAL_CHARS) {
-        result.push(BASE32_ALPHABET[0]); // 'A' = zero padding
-    }
-    return result.slice(0, TOTAL_CHARS).join('');
+  }
+  if (bufferBits > 0) {
+    result.push(BASE32_ALPHABET[buffer << 5 - bufferBits & 31]);
+  }
+  while (result.length < TOTAL_CHARS) {
+    result.push(BASE32_ALPHABET[0]);
+  }
+  return result.slice(0, TOTAL_CHARS).join("");
 }
-/**
- * Convert a base32 string (stripped of dashes/whitespace) back to bytes.
- * Returns exactly as many bytes as the bits allow; callers validate length.
- */
 function base32ToBytes(chars) {
-    const bytes = [];
-    let buffer = 0;
-    let bufferBits = 0;
-    for (let i = 0; i < chars.length; i++) {
-        const code = chars.charCodeAt(i);
-        const value = code < 128 ? CHAR_TO_VALUE[code] : 0xff;
-        if (value === 0xff) {
-            throw new Error(`Invalid base32 character: '${chars[i]}'`);
-        }
-        buffer = (buffer << 5) | value;
-        bufferBits += 5;
-        if (bufferBits >= 8) {
-            bufferBits -= 8;
-            bytes.push((buffer >> bufferBits) & 0xff);
-        }
+  const bytes = [];
+  let buffer = 0;
+  let bufferBits = 0;
+  for (let i = 0; i < chars.length; i++) {
+    const code = chars.charCodeAt(i);
+    const value = code < 128 ? CHAR_TO_VALUE[code] : 255;
+    if (value === 255) {
+      throw new Error(`Invalid base32 character: '${chars[i]}'`);
+    }
+    buffer = buffer << 5 | value;
+    bufferBits += 5;
+    if (bufferBits >= 8) {
+      bufferBits -= 8;
+      bytes.push(buffer >> bufferBits & 255);
     }
-    return Buffer.from(bytes);
+  }
+  return Buffer.from(bytes);
 }
-/**
- * Strip formatting (whitespace + dashes) and uppercase.
- *
- * H15 — strict alphabet. The previous confusable-char substitution map
- * (0→O, 1→I, 8→B, 9→G) is removed. Digits 0/1/8/9 are never emitted by
- * formatRecoveryCode; accepting them silently shrinks the effective key
- * space and makes brute-force attempts indistinguishable from alphabet
- * errors in telemetry. Any character outside A-Z2-7 after normalization
- * is rejected; callers receive a structured error with code
- * INVALID_RECOVERY_CODE_ALPHABET so they can surface a clear UX hint
- * without leaking which validation step failed at the server surface.
- *
- * Returns the cleaned, uppercased string (no whitespace, no dashes).
- * Throws with `code: 'INVALID_RECOVERY_CODE_ALPHABET'` on any illegal char.
- */
 function normalizeRaw(input) {
-    const upper = input.toUpperCase().replace(/[\s-]/g, '');
-    for (let i = 0; i < upper.length; i++) {
-        const ch = upper[i];
-        const code = ch.charCodeAt(0);
-        if (code >= 128 || CHAR_TO_VALUE[code] === 0xff) {
-            const err = new Error('Recovery codes only contain letters A-Z and digits 2-7. Copy from where you stored it.');
-            err.code = 'INVALID_RECOVERY_CODE_ALPHABET';
-            throw err;
-        }
+  const upper = input.toUpperCase().replace(/[\s-]/g, "");
+  for (let i = 0; i < upper.length; i++) {
+    const ch = upper[i];
+    const code = ch.charCodeAt(0);
+    if (code >= 128 || CHAR_TO_VALUE[code] === 255) {
+      const err = new Error("Recovery codes only contain letters A-Z and digits 2-7. Copy from where you stored it.");
+      err.code = "INVALID_RECOVERY_CODE_ALPHABET";
+      throw err;
     }
-    return upper;
+  }
+  return upper;
 }
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-/**
- * Format 32 raw bytes as a printable recovery code.
- *
- * @param bytes — exactly 32 bytes of entropy
- * @returns "AAAAA-BBBBB-CCCCC-...-KKKKK" (55 chars + 10 dashes = 65 chars)
- * @throws if input is not 32 bytes
- */
 function formatRecoveryCode(bytes) {
-    if (bytes.length !== DECODED_BYTE_LENGTH) {
-        throw new Error(`formatRecoveryCode: expected ${DECODED_BYTE_LENGTH} bytes, got ${bytes.length}`);
-    }
-    const input = bytes instanceof Buffer ? new Uint8Array(bytes) : bytes;
-    const base32 = bytesToBase32(input);
-    // Split into groups of GROUP_SIZE and join with dashes.
-    const groups = [];
-    for (let i = 0; i < GROUP_COUNT; i++) {
-        groups.push(base32.slice(i * GROUP_SIZE, (i + 1) * GROUP_SIZE));
-    }
-    return groups.join('-');
+  if (bytes.length !== DECODED_BYTE_LENGTH) {
+    throw new Error(`formatRecoveryCode: expected ${DECODED_BYTE_LENGTH} bytes, got ${bytes.length}`);
+  }
+  const input = bytes instanceof Buffer ? new Uint8Array(bytes) : bytes;
+  const base32 = bytesToBase32(input);
+  const groups = [];
+  for (let i = 0; i < GROUP_COUNT; i++) {
+    groups.push(base32.slice(i * GROUP_SIZE, (i + 1) * GROUP_SIZE));
+  }
+  return groups.join("-");
 }
-/**
- * Parse a formatted (or loosely-typed) recovery code back to its 32 raw bytes.
- *
- * Tolerant of:
- *   - whitespace (spaces, newlines, tabs)
- *   - dashes (group separators in the printed format)
- *   - lowercase
- *
- * H15 — strict alphabet: confusable-char substitution (0/1/8/9) is NOT
- * applied. Any character outside A-Z2-7 after stripping whitespace/dashes
- * and uppercasing throws with code INVALID_RECOVERY_CODE_ALPHABET.
- *
- * M3 — exact-length check: after normalization the cleaned string must be
- * exactly TOTAL_CHARS (55) characters. Shorter inputs would produce fewer
- * than 32 meaningful decoded bytes; longer inputs indicate a malformed or
- * concatenated code. Both are rejected.
- *
- * @throws with a descriptive message on invalid characters or wrong length
- */
 function parseRecoveryCode(formatted) {
-    if (!formatted || formatted.trim().length === 0) {
-        throw new Error('parseRecoveryCode: input is empty');
-    }
-    // normalizeRaw throws with code INVALID_RECOVERY_CODE_ALPHABET on any
-    // character outside A-Z2-7 (after uppercase + whitespace/dash strip).
-    const cleaned = normalizeRaw(formatted);
-    if (cleaned.length === 0) {
-        throw new Error('parseRecoveryCode: no valid characters found after normalization');
-    }
-    // M3 — reject malformed pad-suffix: require exactly TOTAL_CHARS base32
-    // chars. The canonical format always produces exactly 55 chars (11×5);
-    // any deviation means the input is truncated, extended, or corrupted.
-    if (cleaned.length !== TOTAL_CHARS) {
-        throw new Error(`parseRecoveryCode: expected ${TOTAL_CHARS} base32 chars, got ${cleaned.length} — ` +
-            `input likely has wrong length`);
-    }
-    const decoded = base32ToBytes(cleaned);
-    // 55 base32 chars × 5 bits = 275 bits = 34 bytes + 3 trailing bits.
-    // The format intentionally pads to 55 chars (11×5) for visual grouping;
-    // the last 1–3 bytes are trailing zero-padding from the encoder and must
-    // be dropped. With the exact-length check above, decoded.length is always
-    // ≥ DECODED_BYTE_LENGTH here, but guard defensively.
-    if (decoded.length < DECODED_BYTE_LENGTH) {
-        throw new Error(`parseRecoveryCode: expected ${DECODED_BYTE_LENGTH} decoded bytes, got ${decoded.length} — ` +
-            `input likely has wrong length (got ${cleaned.length} base32 chars, expected ${TOTAL_CHARS})`);
-    }
-    return decoded.slice(0, DECODED_BYTE_LENGTH);
+  if (!formatted || formatted.trim().length === 0) {
+    throw new Error("parseRecoveryCode: input is empty");
+  }
+  const cleaned = normalizeRaw(formatted);
+  if (cleaned.length === 0) {
+    throw new Error("parseRecoveryCode: no valid characters found after normalization");
+  }
+  if (cleaned.length !== TOTAL_CHARS) {
+    throw new Error(`parseRecoveryCode: expected ${TOTAL_CHARS} base32 chars, got ${cleaned.length} \u2014 input likely has wrong length`);
+  }
+  const decoded = base32ToBytes(cleaned);
+  if (decoded.length < DECODED_BYTE_LENGTH) {
+    throw new Error(`parseRecoveryCode: expected ${DECODED_BYTE_LENGTH} decoded bytes, got ${decoded.length} \u2014 input likely has wrong length (got ${cleaned.length} base32 chars, expected ${TOTAL_CHARS})`);
+  }
+  return decoded.slice(0, DECODED_BYTE_LENGTH);
 }
-/**
- * Normalize any input form to the canonical 11-group display format.
- * Applies the same confusable-char + whitespace tolerance as parseRecoveryCode.
- *
- * @throws the same errors as parseRecoveryCode on invalid input
- */
 function normalizeRecoveryCode(input) {
-    const bytes = parseRecoveryCode(input);
-    return formatRecoveryCode(bytes);
+  const bytes = parseRecoveryCode(input);
+  return formatRecoveryCode(bytes);
 }
-/**
- * Non-throwing validity check.
- * Returns true iff the input can be successfully parsed as a 32-byte recovery code.
- */
 function isValidRecoveryCode(input) {
-    try {
-        parseRecoveryCode(input);
-        return true;
-    }
-    catch {
-        return false;
-    }
+  try {
+    parseRecoveryCode(input);
+    return true;
+  } catch {
+    return false;
+  }
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatRecoveryCode,
+  isValidRecoveryCode,
+  normalizeRecoveryCode,
+  parseRecoveryCode
+});