@percy/core 1.31.13 → 1.31.14-beta.1

package/README.md

@@ -53,6 +53,7 @@ The following options can also be defined within a Percy config file
   - `requestHeaders` — Request headers used when discovering snapshot assets
   - `authorization` — Basic auth `username` and `password` for protected snapshot assets
   - `disableCache` — Disable asset caching (**default** `false`)
+  - `maxCacheRam` — Cap the asset-discovery cache at this many MB (**default** unset/unbounded). When set, least-recently-used resources are evicted to stay within the cap. MB is decimal (1 MB = 1,000,000 bytes), not binary MiB (1,048,576). The cap measures cache body bytes only; process RSS is typically 1.5–2× the cap due to Node's Buffer slab allocator. Values below 25 MB are clamped to 25 MB with a warn log (the per-resource ceiling is 25 MB, so smaller caps would reject every resource). Also settable via the `--max-cache-ram <MB>` CLI flag or the `PERCY_MAX_CACHE_RAM` env var
   - `userAgent` — Custom user-agent string used when requesting assets
   - `cookies` — Browser cookies to use when requesting assets
   - `networkIdleTimeout` — Milliseconds to wait for the network to idle (**default** `100`)

package/dist/api.js

@@ -259,7 +259,7 @@ export function createPercyServer(percy, port) {
     if (cmd === 'reset') {
       // the reset command will reset testing mode and clear any logs
       percy.testing = {};
-      logger.instance.messages.clear();
+      logger.instance.reset();
     } else if (cmd === 'version') {
       // the version command will update the api version header for testing
       percy.testing.version = body;
@@ -304,7 +304,7 @@ export function createPercyServer(percy, port) {
   }))
   // returns an array of raw logs from the logger
   .route('get', '/test/logs', (req, res) => res.json(200, {
-    logs: Array.from(logger.instance.messages)
+    logs: logger.instance.query(() => true)
   }))
   // serves a very basic html page for testing snapshots
   .route('get', '/test/snapshot', (req, res) => {

package/dist/browser.js

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
+import { execFileSync } from 'child_process';
 import spawn from 'cross-spawn';
 import EventEmitter from 'events';
 import WebSocket from 'ws';
@@ -200,11 +201,36 @@ export class Browser extends EventEmitter {
     /* istanbul ignore next:
      *   difficult to test failure here without mocking private properties */
     if ((_this$process = this.process) !== null && _this$process !== void 0 && _this$process.pid && !this.process.killed) {
-      // always force close the browser process
+      // Force-close the entire browser process tree, not just the lead
+      // pid. Chromium spawns
+      // renderer/utility/zygote children; targeting only the lead pid
+      // (the previous behavior) leaked them on every kill.
+      //
+      // Convention matches Puppeteer / Playwright: shell out to
+      // `taskkill /T /F` on Windows; on POSIX the spawn at line ~266
+      // sets `detached: true` so child.pid === pgid and a negative
+      // pid signals the entire process group.
       try {
-        this.process.kill('SIGKILL');
+        if (process.platform === 'win32') {
+          // Use execFileSync (no shell) so the pid argument is passed
+          // directly without interpolation — defense-in-depth against
+          // any future drift where this.process.pid isn't a clean int.
+          execFileSync('taskkill', ['/pid', String(this.process.pid), '/T', '/F'], {
+            stdio: 'ignore'
+          });
+        } else {
+          process.kill(-this.process.pid, 'SIGKILL');
+        }
       } catch (error) {
-        throw new Error(`Unable to close the browser: ${error.stack}`);
+        // taskkill returns 128 if the process is already gone; the
+        // POSIX branch may also throw ESRCH for the same reason. Fall
+        // back to the lead-pid kill so a missing process doesn't
+        // wedge `_closed`.
+        try {
+          this.process.kill('SIGKILL');
+        } catch (fallbackErr) {
+          throw new Error(`Unable to close the browser: ${error.stack}`);
+        }
       }
     }
 

package/dist/cache/byte-lru.js

@@ -0,0 +1,352 @@
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+// Two-tier cache used by asset discovery:
+//   ByteLRU — byte-budget in-memory LRU; Map insertion order = LRU order.
+//   DiskSpillStore — on-disk overflow tier. RAM evictions spill here; lookups
+//   fall back to disk before refetching from origin.
+// All operations are synchronous; callers (network intercept, ByteLRU.set)
+// cannot yield to the event loop mid-op. Per-entry size is capped at 25MB
+// upstream so disk I/O latency is bounded.
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import crypto from 'crypto';
+const DEFAULT_PER_ENTRY_OVERHEAD = 512;
+export class ByteLRU {
+  #map = new Map();
+  #bytes = 0;
+  #max;
+  #stats = {
+    hits: 0,
+    misses: 0,
+    evictions: 0,
+    peakBytes: 0
+  };
+  onEvict;
+  constructor(maxBytes, {
+    onEvict
+  } = {}) {
+    this.#max = maxBytes;
+    this.onEvict = onEvict;
+  }
+  get(key) {
+    if (!this.#map.has(key)) {
+      this.#stats.misses++;
+      return undefined;
+    }
+    const rec = this.#map.get(key);
+    this.#map.delete(key);
+    this.#map.set(key, rec);
+    this.#stats.hits++;
+    return rec.value;
+  }
+  set(key, value, size) {
+    if (!Number.isFinite(size) || size < 0) return false;
+
+    // Reject oversize BEFORE touching any existing entry — a failed set on an
+    // existing key must not evict the prior (valid) entry.
+    if (this.#max !== undefined && size > this.#max) {
+      if (this.onEvict) this.onEvict(key, 'too-big', value);
+      return false;
+    }
+    if (this.#map.has(key)) {
+      this.#bytes -= this.#map.get(key).size;
+      this.#map.delete(key);
+    }
+    this.#map.set(key, {
+      value,
+      size
+    });
+    this.#bytes += size;
+    if (this.#bytes > this.#stats.peakBytes) this.#stats.peakBytes = this.#bytes;
+    while (this.#max !== undefined && this.#bytes > this.#max) {
+      const oldestKey = this.#map.keys().next().value;
+      const rec = this.#map.get(oldestKey);
+      this.#bytes -= rec.size;
+      this.#map.delete(oldestKey);
+      this.#stats.evictions++;
+      if (this.onEvict) this.onEvict(oldestKey, 'lru', rec.value);
+    }
+    return true;
+  }
+  has(key) {
+    return this.#map.has(key);
+  }
+  delete(key) {
+    if (!this.#map.has(key)) return false;
+    this.#bytes -= this.#map.get(key).size;
+    return this.#map.delete(key);
+  }
+  clear() {
+    this.#map.clear();
+    this.#bytes = 0;
+  }
+  get size() {
+    return this.#map.size;
+  }
+  get calculatedSize() {
+    return this.#bytes;
+  }
+  get stats() {
+    return {
+      ...this.#stats,
+      currentBytes: this.#bytes
+    };
+  }
+}
+
+// Returns the byte length of a resource's content. Buffer.byteLength is used
+// for strings so that multi-byte UTF-8 (CJK, emoji) is counted in bytes, not
+// JS string units, otherwise the cache budget can drift past its cap.
+function contentBytes(content) {
+  if (content == null) return 0;
+  if (Buffer.isBuffer(content)) return content.length;
+  if (typeof content === 'string') return Buffer.byteLength(content);
+  return content.length ?? 0;
+}
+
+// Handles the two Percy cache-entry shapes: single resource, or array of
+// roots captured at multiple widths (see discovery.js parseDomResources).
+export function entrySize(resource, overhead = DEFAULT_PER_ENTRY_OVERHEAD) {
+  if (Array.isArray(resource)) {
+    return resource.reduce((n, r) => n + contentBytes(r === null || r === void 0 ? void 0 : r.content) + overhead, 0);
+  }
+  return contentBytes(resource === null || resource === void 0 ? void 0 : resource.content) + overhead;
+}
+
+// Multi-width root arrays carry per-element binary content. Encode buffers as
+// base64 inside JSON so the whole array survives a disk roundtrip; null and
+// string content pass through as themselves.
+function encodeArrayElement(r) {
+  if (!r) return r;
+  const {
+    content,
+    ...rest
+  } = r;
+  if (content == null) return {
+    ...rest,
+    content: null
+  };
+  if (Buffer.isBuffer(content)) return {
+    ...rest,
+    content: {
+      __buf: content.toString('base64')
+    }
+  };
+  return {
+    ...rest,
+    content: String(content)
+  };
+}
+function decodeArrayElement(r) {
+  if (!r) return r;
+  const {
+    content,
+    ...rest
+  } = r;
+  if (content && typeof content === 'object' && '__buf' in content) {
+    return {
+      ...rest,
+      content: Buffer.from(content.__buf, 'base64')
+    };
+  }
+  return {
+    ...rest,
+    content
+  };
+}
+var _index = /*#__PURE__*/new WeakMap();
+var _bytes = /*#__PURE__*/new WeakMap();
+var _peakBytes = /*#__PURE__*/new WeakMap();
+var _stats = /*#__PURE__*/new WeakMap();
+var _counter = /*#__PURE__*/new WeakMap();
+var _ready = /*#__PURE__*/new WeakMap();
+var _DiskSpillStore_brand = /*#__PURE__*/new WeakSet();
+export class DiskSpillStore {
+  constructor(dir, {
+    log
+  } = {}) {
+    _classPrivateMethodInitSpec(this, _DiskSpillStore_brand);
+    _classPrivateFieldInitSpec(this, _index, new Map());
+    _classPrivateFieldInitSpec(this, _bytes, 0);
+    _classPrivateFieldInitSpec(this, _peakBytes, 0);
+    _classPrivateFieldInitSpec(this, _stats, {
+      spilled: 0,
+      restored: 0,
+      spillFailures: 0,
+      readFailures: 0
+    });
+    _classPrivateFieldInitSpec(this, _counter, 0);
+    _classPrivateFieldInitSpec(this, _ready, false);
+    this.dir = dir;
+    this.log = log;
+    try {
+      // mode 0o700: spilled bytes are origin-fetchable so the threat model is
+      // small, but on shared-tenant CI hosts other users on the same box
+      // shouldn't be able to read them.
+      fs.mkdirSync(dir, {
+        recursive: true,
+        mode: 0o700
+      });
+      _classPrivateFieldSet(_ready, this, true);
+    } catch (err) {
+      var _this$log, _this$log$debug;
+      (_this$log = this.log) === null || _this$log === void 0 || (_this$log$debug = _this$log.debug) === null || _this$log$debug === void 0 || _this$log$debug.call(_this$log, `disk-spill init failed for ${dir}: ${err.message}`);
+    }
+  }
+
+  // Returns true on success; false on any failure so caller falls back to drop.
+  // Overwrites prior spill for the same URL — a fresh discovery write wins.
+  // Two resource shapes are supported: a single resource with a binary
+  // .content, and a multi-width root array (see entrySize for the array
+  // shape). Arrays are JSON-encoded with base64 buffers so the whole array
+  // survives the disk roundtrip.
+  set(url, resource) {
+    var _this$counter;
+    if (!_classPrivateFieldGet(_ready, this)) return false;
+    let bytes;
+    let meta;
+    let isArray = false;
+    if (Array.isArray(resource)) {
+      isArray = true;
+      try {
+        bytes = Buffer.from(JSON.stringify(resource.map(encodeArrayElement)));
+      } catch {
+        return false;
+      }
+    } else {
+      let content = resource === null || resource === void 0 ? void 0 : resource.content;
+      if (content == null) return false;
+      if (!Buffer.isBuffer(content)) {
+        try {
+          content = Buffer.from(content);
+        } catch {
+          return false;
+        }
+      }
+      bytes = content;
+      meta = {
+        ...resource
+      };
+      delete meta.content;
+    }
+
+    // Counter-based filename keeps URL-derived data out of path.join —
+    // avoids any path-traversal surface even though sha256 would be safe.
+    const filepath = path.join(this.dir, String(_classPrivateFieldSet(_counter, this, (_this$counter = _classPrivateFieldGet(_counter, this), ++_this$counter))));
+    try {
+      fs.writeFileSync(filepath, bytes);
+    } catch (err) {
+      var _this$log2, _this$log2$debug;
+      _classPrivateFieldGet(_stats, this).spillFailures++;
+      (_this$log2 = this.log) === null || _this$log2 === void 0 || (_this$log2$debug = _this$log2.debug) === null || _this$log2$debug === void 0 || _this$log2$debug.call(_this$log2, `disk-spill write failed for ${url}: ${err.message}`);
+      return false;
+    }
+    if (_classPrivateFieldGet(_index, this).has(url)) {
+      const prev = _classPrivateFieldGet(_index, this).get(url);
+      _classPrivateFieldSet(_bytes, this, _classPrivateFieldGet(_bytes, this) - prev.size);
+      try {
+        fs.unlinkSync(prev.path);
+      } catch {/* best-effort */}
+    }
+    _classPrivateFieldGet(_index, this).set(url, {
+      path: filepath,
+      size: bytes.length,
+      isArray,
+      meta
+    });
+    _classPrivateFieldSet(_bytes, this, _classPrivateFieldGet(_bytes, this) + bytes.length);
+    if (_classPrivateFieldGet(_bytes, this) > _classPrivateFieldGet(_peakBytes, this)) _classPrivateFieldSet(_peakBytes, this, _classPrivateFieldGet(_bytes, this));
+    _classPrivateFieldGet(_stats, this).spilled++;
+    return true;
+  }
+  get(url) {
+    const entry = _classPrivateFieldGet(_index, this).get(url);
+    if (!entry) return undefined;
+    let raw;
+    try {
+      raw = fs.readFileSync(entry.path);
+    } catch (err) {
+      var _this$log3, _this$log3$debug;
+      _classPrivateFieldGet(_stats, this).readFailures++;
+      (_this$log3 = this.log) === null || _this$log3 === void 0 || (_this$log3$debug = _this$log3.debug) === null || _this$log3$debug === void 0 || _this$log3$debug.call(_this$log3, `disk-spill read failed for ${url}: ${err.message}`);
+      _assertClassBrand(_DiskSpillStore_brand, this, _removeEntry).call(this, url, entry);
+      return undefined;
+    }
+    if (entry.isArray) {
+      let arr;
+      try {
+        arr = JSON.parse(raw.toString('utf8')).map(decodeArrayElement);
+      } catch (err) {
+        var _this$log4, _this$log4$debug;
+        _classPrivateFieldGet(_stats, this).readFailures++;
+        (_this$log4 = this.log) === null || _this$log4 === void 0 || (_this$log4$debug = _this$log4.debug) === null || _this$log4$debug === void 0 || _this$log4$debug.call(_this$log4, `disk-spill array-decode failed for ${url}: ${err.message}`);
+        _assertClassBrand(_DiskSpillStore_brand, this, _removeEntry).call(this, url, entry);
+        return undefined;
+      }
+      _classPrivateFieldGet(_stats, this).restored++;
+      return arr;
+    }
+    _classPrivateFieldGet(_stats, this).restored++;
+    return {
+      ...entry.meta,
+      content: raw
+    };
+  }
+  has(url) {
+    return _classPrivateFieldGet(_index, this).has(url);
+  }
+  delete(url) {
+    const entry = _classPrivateFieldGet(_index, this).get(url);
+    if (!entry) return false;
+    _assertClassBrand(_DiskSpillStore_brand, this, _removeEntry).call(this, url, entry);
+    return true;
+  }
+  destroy() {
+    try {
+      if (_classPrivateFieldGet(_ready, this)) fs.rmSync(this.dir, {
+        recursive: true,
+        force: true
+      });
+    } catch (err) {
+      var _this$log5, _this$log5$debug;
+      (_this$log5 = this.log) === null || _this$log5 === void 0 || (_this$log5$debug = _this$log5.debug) === null || _this$log5$debug === void 0 || _this$log5$debug.call(_this$log5, `disk-spill cleanup failed for ${this.dir}: ${err.message}`);
+    }
+    _classPrivateFieldGet(_index, this).clear();
+    _classPrivateFieldSet(_bytes, this, 0);
+    _classPrivateFieldSet(_ready, this, false);
+  }
+  get size() {
+    return _classPrivateFieldGet(_index, this).size;
+  }
+  get bytes() {
+    return _classPrivateFieldGet(_bytes, this);
+  }
+  get ready() {
+    return _classPrivateFieldGet(_ready, this);
+  }
+  get stats() {
+    return {
+      ..._classPrivateFieldGet(_stats, this),
+      currentBytes: _classPrivateFieldGet(_bytes, this),
+      peakBytes: _classPrivateFieldGet(_peakBytes, this),
+      entries: _classPrivateFieldGet(_index, this).size
+    };
+  }
+}
+function _removeEntry(url, entry) {
+  _classPrivateFieldSet(_bytes, this, _classPrivateFieldGet(_bytes, this) - entry.size);
+  _classPrivateFieldGet(_index, this).delete(url);
+  try {
+    fs.unlinkSync(entry.path);
+  } catch {/* best-effort */}
+}
+export function createSpillDir() {
+  const suffix = `${process.pid}-${crypto.randomBytes(4).toString('hex')}`;
+  return path.join(os.tmpdir(), `percy-cache-${suffix}`);
+}

package/dist/config.js

@@ -422,6 +422,13 @@ export const configSchema = {
       disableCache: {
         type: 'boolean'
       },
+      maxCacheRam: {
+        // 0 has no meaningful semantics — it's neither "unbounded" (use null)
+        // nor "disabled" (use --disable-cache). Reject it at schema time so the
+        // discovery clamp doesn't silently bump it to 25MB.
+        type: ['integer', 'null'],
+        minimum: 1
+      },
       captureMockedServiceWorker: {
         type: 'boolean',
         default: false