handmux 0.23.0 → 0.25.0

package/src/asr/iflySign.js

@@ -1,16 +0,0 @@
-import { createHmac } from 'node:crypto';
-
-// Build a fully-signed iFlytek IAT v2 WebSocket URL. The secret (apiSecret) is used only here on the
-// server — the browser receives only the resulting URL (HMAC output, not the key). `host`/`date` are
-// injectable so this is deterministic and unit-testable; production passes host='iat-api.xfyun.cn'
-// and date=new Date().toUTCString() (RFC1123 GMT, iFlytek allows ±300s skew).
-export function buildIatSignedUrl({ appId, apiKey, apiSecret, host = 'iat-api.xfyun.cn', date }) {
-  const requestLine = 'GET /v2/iat HTTP/1.1';
-  const signatureOrigin = `host: ${host}\ndate: ${date}\n${requestLine}`;
-  const signature = createHmac('sha256', apiSecret).update(signatureOrigin).digest('base64');
-  const authorizationOrigin =
-    `api_key="${apiKey}", algorithm="hmac-sha256", headers="host date request-line", signature="${signature}"`;
-  const authorization = Buffer.from(authorizationOrigin, 'utf8').toString('base64');
-  const qs = new URLSearchParams({ authorization, date, host });
-  return { url: `wss://${host}/v2/iat?${qs.toString()}`, appId };
-}

package/src/auth.js

@@ -1,30 +0,0 @@
-import crypto from 'node:crypto';
-
-export function loadToken(env = process.env) {
-  let token = env.HANDMUX_TOKEN;
-  if (!token) {
-    token = crypto.randomBytes(24).toString('base64url');
-    console.log(`[handmux] no HANDMUX_TOKEN set; generated token: ${token}`);
-  }
-  return token;
-}
-
-const sha = (s) => crypto.createHash('sha256').update(String(s)).digest();
-
-export function tokenEquals(a, b) {
-  return crypto.timingSafeEqual(sha(a), sha(b));
-}
-
-export function bearerFrom(header) {
-  if (!header) return null;
-  const m = /^Bearer (.+)$/.exec(header);
-  return m ? m[1] : null;
-}
-
-export function expressAuth(token) {
-  return (req, res, next) => {
-    const provided = bearerFrom(req.get('authorization'));
-    if (provided && tokenEquals(provided, token)) return next();
-    res.status(401).json({ error: 'unauthorized' });
-  };
-}

package/src/browser/bootstrap.js

@@ -1,68 +0,0 @@
-import { randomBytes } from 'node:crypto';
-
-const BOOTSTRAP_PREFIX = '/_browser-bootstrap/';
-
-function normalizedOrigin(raw) {
-  const url = new URL(raw);
-  if (url.protocol !== 'http:' && url.protocol !== 'https:') throw new Error('browser bootstrap origin must use http or https');
-  return url.origin;
-}
-
-export function isBrowserBootstrapPath(pathname) {
-  return String(pathname || '').startsWith(BOOTSTRAP_PREFIX);
-}
-
-export function createBrowserBootstrapStore({
-  randomToken = () => randomBytes(24).toString('base64url'),
-  now = Date.now,
-  ttlMs = 60_000,
-} = {}) {
-  const tickets = new Map();
-
-  const prune = () => {
-    const current = now();
-    for (const [token, entry] of tickets) if (entry.expiresAt <= current) tickets.delete(token);
-  };
-
-  return {
-    issue({ url, origin, deviceId, preserveMethod = false, redirectStatus = 302 }) {
-      prune();
-      const expectedOrigin = normalizedOrigin(origin);
-      const target = new URL(url);
-      if (target.origin !== expectedOrigin || !target.pathname.split('/')[1]?.startsWith('_browser-')) {
-        throw new Error('browser bootstrap target must be a session on its public origin');
-      }
-      const token = randomToken();
-      tickets.set(token, {
-        url: target.toString(),
-        origin: expectedOrigin,
-        deviceId,
-        preserveMethod,
-        redirectStatus,
-        expiresAt: now() + ttlMs,
-      });
-      return new URL(`${BOOTSTRAP_PREFIX}${encodeURIComponent(token)}`, expectedOrigin).toString();
-    },
-
-    consume(pathname, origin) {
-      prune();
-      if (!isBrowserBootstrapPath(pathname)) return null;
-      let token;
-      try { token = decodeURIComponent(String(pathname).slice(BOOTSTRAP_PREFIX.length)); } catch { return null; }
-      const entry = tickets.get(token);
-      let requestedOrigin;
-      try { requestedOrigin = normalizedOrigin(origin); } catch { return null; }
-      if (!entry || entry.origin !== requestedOrigin) return null;
-      tickets.delete(token);
-      const consumed = {
-        url: entry.url,
-        deviceId: entry.deviceId,
-      };
-      if (entry.preserveMethod) {
-        consumed.preserveMethod = true;
-        consumed.redirectStatus = entry.redirectStatus;
-      }
-      return consumed;
-    },
-  };
-}

package/src/browser/cookieProfiles.js

@@ -1,403 +0,0 @@
-const MUTATION_METHODS = ['setByServer', 'setByClient', 'setCookies', 'deleteCookies'];
-const DAY = 24 * 60 * 60 * 1000;
-const MAX_TIMER_DELAY = 2_147_483_647;
-
-const noPersistence = {
-  async read() { return null; },
-  async write() {},
-  async remove() {},
-  async readMetadata() { return null; },
-  async writeMetadata() {},
-  async removeMetadata() {},
-  async close() {},
-};
-
-export function createDeviceCookieProfiles({
-  createCookies,
-  onMutation = () => {},
-  persistence = noPersistence,
-  now = Date.now,
-  setTimer = setTimeout,
-  clearTimer = clearTimeout,
-}) {
-  const profiles = new Map();
-  const pending = new Set();
-  let closing = false;
-
-  const track = (operation) => {
-    pending.add(operation);
-    operation.then(() => pending.delete(operation), () => pending.delete(operation));
-    return operation;
-  };
-
-  const profileFor = (deviceId) => {
-    let profile = profiles.get(deviceId);
-    if (!profile) {
-      profile = {
-        cookies: createCookies(),
-        attached: new Set(),
-        persist: false,
-        retentionDays: 30,
-        loaded: false,
-        used: false,
-        active: false,
-        idleSince: null,
-        retentionTimer: null,
-        flushTimer: null,
-        dirty: false,
-        operationPromise: Promise.resolve(),
-        configurePromise: Promise.resolve(),
-        useVersion: 0,
-        retentionEpoch: 0,
-      };
-      profiles.set(deviceId, profile);
-    }
-    return profile;
-  };
-
-  const installCookies = (profile, cookies) => {
-    profile.cookies = cookies;
-    for (const attached of profile.attached) {
-      attached._cookieJar = cookies._cookieJar;
-      attached._pendingSyncCookies = [];
-    }
-  };
-
-  const replaceJar = (profile, serialized) => {
-    profile.cookies.setJar(serialized);
-    for (const cookies of profile.attached) {
-      cookies._cookieJar = profile.cookies._cookieJar;
-      cookies._pendingSyncCookies = [];
-    }
-  };
-
-  const queueOperation = (profile, operation) => {
-    const result = profile.operationPromise.then(operation);
-    profile.operationPromise = result.catch(() => {});
-    return track(result);
-  };
-
-  const queueWrite = (deviceId, profile, serialized = profile.cookies.serializeJar()) => (
-    queueOperation(profile, () => persistence.write(deviceId, serialized))
-  );
-  const queueMetadata = (deviceId, profile) => queueOperation(
-    profile,
-    () => persistence.writeMetadata?.(deviceId, {
-      persist: profile.persist,
-      retentionDays: profile.retentionDays,
-      noLeaseSince: profile.idleSince,
-    }),
-  );
-
-  const flush = async (deviceId) => {
-    const profile = profiles.get(deviceId);
-    if (!profile || !profile.persist) return;
-    if (!profile.dirty) {
-      await profile.operationPromise;
-      return;
-    }
-    if (profile.flushTimer !== null) {
-      clearTimer(profile.flushTimer);
-      profile.flushTimer = null;
-    }
-    profile.dirty = false;
-    try {
-      await queueWrite(deviceId, profile);
-    } catch (error) {
-      profile.dirty = true;
-      throw error;
-    }
-  };
-
-  const markDirty = (deviceId) => {
-    const profile = profileFor(deviceId);
-    profile.used = true;
-    profile.useVersion += 1;
-    onMutation(deviceId);
-    if (!profile.persist) return;
-    profile.dirty = true;
-    if (closing || profile.flushTimer !== null) return;
-    profile.flushTimer = setTimer(() => {
-      profile.flushTimer = null;
-      void flush(deviceId).catch(() => {});
-    }, 500);
-  };
-
-  const clearRetentionTimer = (profile) => {
-    if (profile.retentionTimer === null) return;
-    clearTimer(profile.retentionTimer);
-    profile.retentionTimer = null;
-  };
-
-  const clearExpired = async (deviceId, profile, expectedEpoch, expectedIdleSince) => {
-    clearRetentionTimer(profile);
-    if (profile.dirty) await flush(deviceId);
-    else await profile.operationPromise;
-    if (profile.active
-      || profile.retentionEpoch !== expectedEpoch
-      || profile.idleSince !== expectedIdleSince) return;
-    installCookies(profile, createCookies());
-    profile.used = false;
-    profile.useVersion += 1;
-    profile.idleSince = null;
-    profile.dirty = false;
-    await queueOperation(profile, () => persistence.remove(deviceId));
-  };
-
-  const scheduleRetention = (deviceId, profile) => {
-    clearRetentionTimer(profile);
-    if (closing || profile.active || profile.idleSince === null || profile.retentionDays === null) return null;
-    const remaining = profile.idleSince + profile.retentionDays * DAY - now();
-    if (remaining <= 0) {
-      return track(clearExpired(
-        deviceId,
-        profile,
-        profile.retentionEpoch,
-        profile.idleSince,
-      ));
-    }
-    profile.retentionTimer = setTimer(() => {
-      profile.retentionTimer = null;
-      const operation = scheduleRetention(deviceId, profile);
-      if (operation) void operation.catch(() => {});
-    }, Math.min(remaining, MAX_TIMER_DELAY));
-    return null;
-  };
-
-  const saveCurrent = async (deviceId, profile) => {
-    if (profile.flushTimer !== null) {
-      clearTimer(profile.flushTimer);
-      profile.flushTimer = null;
-    }
-    profile.dirty = false;
-    await queueWrite(deviceId, profile);
-  };
-
-  const configureImpl = async (deviceId, prefs) => {
-    if (typeof prefs?.persist !== 'boolean' || ![1, 7, 30, null].includes(prefs?.retentionDays)) {
-      throw new Error('invalid browser profile preferences');
-    }
-    const profile = profileFor(deviceId);
-    const wasPersisting = profile.persist;
-    profile.retentionEpoch += 1;
-    let warning = null;
-
-    if (prefs.persist && !wasPersisting) {
-      if (!profile.loaded) {
-        const metadata = await persistence.readMetadata?.(deviceId);
-        if (metadata?.persist) profile.idleSince = metadata.noLeaseSince;
-      }
-      profile.persist = true;
-      profile.retentionDays = prefs.retentionDays;
-      if (!profile.loaded && !profile.used) {
-        profile.loaded = true;
-        const useVersion = profile.useVersion;
-        try {
-          const serialized = await persistence.read(deviceId);
-          if (profile.used || profile.useVersion !== useVersion) {
-            await saveCurrent(deviceId, profile);
-          } else if (serialized !== null) {
-            replaceJar(profile, serialized);
-          }
-        } catch {
-          warning = 'profile-recovery-failed';
-          await queueOperation(profile, () => persistence.remove(deviceId));
-          if (profile.used || profile.useVersion !== useVersion) {
-            await saveCurrent(deviceId, profile);
-          } else {
-            installCookies(profile, createCookies());
-            profile.used = false;
-            profile.useVersion += 1;
-          }
-        }
-      } else {
-        profile.loaded = true;
-        await saveCurrent(deviceId, profile);
-      }
-    } else if (!prefs.persist && wasPersisting) {
-      const wasDirty = profile.dirty;
-      if (profile.flushTimer !== null) {
-        clearTimer(profile.flushTimer);
-        profile.flushTimer = null;
-      }
-      profile.dirty = false;
-      try {
-        await queueOperation(profile, () => persistence.remove(deviceId));
-      } catch (error) {
-        profile.dirty ||= wasDirty;
-        const retention = scheduleRetention(deviceId, profile);
-        if (retention) await retention;
-        throw error;
-      }
-      if (profile.flushTimer !== null) {
-        clearTimer(profile.flushTimer);
-        profile.flushTimer = null;
-      }
-      profile.dirty = false;
-      profile.persist = false;
-      profile.retentionDays = prefs.retentionDays;
-      await queueOperation(profile, () => persistence.removeMetadata?.(deviceId));
-    } else {
-      profile.persist = prefs.persist;
-      profile.retentionDays = prefs.retentionDays;
-    }
-
-    if (profile.persist) await queueMetadata(deviceId, profile);
-    const retention = scheduleRetention(deviceId, profile);
-    if (retention) await retention;
-    return { persist: profile.persist, retentionDays: profile.retentionDays, warning };
-  };
-
-  const configure = (deviceId, prefs) => {
-    const profile = profileFor(deviceId);
-    // Preference changes span reads, jar restoration, disk removal, and metadata writes. Serialize that
-    // whole transaction per device; serializing only the individual file operations lets an older enable
-    // finish after a newer disable and silently turn persistence back on.
-    const result = profile.configurePromise.catch(() => {}).then(() => configureImpl(deviceId, prefs));
-    profile.configurePromise = result.catch(() => {});
-    return track(result);
-  };
-
-  const setActive = (deviceId, active) => {
-    const profile = profiles.get(deviceId);
-    if (!profile) return;
-    profile.retentionEpoch += 1;
-    if (active) {
-      profile.active = true;
-      profile.idleSince = null;
-      clearRetentionTimer(profile);
-      if (profile.persist) void queueMetadata(deviceId, profile).catch(() => {});
-      return;
-    }
-    if (profile.active || profile.idleSince === null) profile.idleSince = now();
-    profile.active = false;
-    if (profile.persist) void queueMetadata(deviceId, profile).catch(() => {});
-    const retention = scheduleRetention(deviceId, profile);
-    if (retention) void retention.catch(() => {});
-  };
-
-  const attach = (deviceId, sessionCookies) => {
-    const profile = profileFor(deviceId);
-    if (!profile.cookies?._cookieJar || !sessionCookies?._cookieJar) {
-      throw new Error('browser cookie profile unsupported');
-    }
-    profile.used = true;
-    profile.useVersion += 1;
-    sessionCookies._cookieJar = profile.cookies._cookieJar;
-    sessionCookies._pendingSyncCookies = [];
-    profile.attached.add(sessionCookies);
-
-    const originals = new Map();
-    for (const name of MUTATION_METHODS) {
-      const original = sessionCookies[name];
-      originals.set(name, {
-        hadOwn: Object.prototype.hasOwnProperty.call(sessionCookies, name),
-        value: original,
-      });
-      sessionCookies[name] = (...args) => {
-        const result = original.apply(sessionCookies, args);
-        markDirty(deviceId);
-        return result;
-      };
-    }
-
-    let attached = true;
-    return () => {
-      if (!attached) return;
-      attached = false;
-      profile.attached.delete(sessionCookies);
-      for (const [name, original] of originals) {
-        if (original.hadOwn) sessionCookies[name] = original.value;
-        else delete sessionCookies[name];
-      }
-    };
-  };
-
-  const serialize = (deviceId) => {
-    const profile = profiles.get(deviceId);
-    if (!profile) return null;
-    profile.used = true;
-    profile.useVersion += 1;
-    return profile.cookies.serializeJar();
-  };
-
-  const clear = (deviceId, { url, hostname } = {}) => {
-    const fullClear = !hostname && !url;
-    const profile = profiles.get(deviceId) || (fullClear ? profileFor(deviceId) : null);
-    if (!profile) return { cleared: false };
-    profile.used = true;
-    profile.useVersion += 1;
-    let targetHostname = hostname;
-    if (!targetHostname && url) {
-      try { targetHostname = new URL(url).hostname; } catch { return { cleared: false }; }
-    }
-    if (!targetHostname) {
-      replaceJar(profile, null);
-      onMutation(deviceId);
-      profile.dirty = false;
-      if (profile.flushTimer !== null) {
-        clearTimer(profile.flushTimer);
-        profile.flushTimer = null;
-      }
-      return queueOperation(profile, () => persistence.remove(deviceId))
-        .then(() => ({ cleared: true }));
-    }
-
-    const normalizedHostname = targetHostname.toLowerCase();
-    const internalCookies = profile.cookies._getAllCookiesSync().filter((cookie) => {
-      const domain = cookie.domain?.replace(/^\./, '').toLowerCase();
-      if (!domain) return false;
-      if (cookie.hostOnly) return domain === normalizedHostname;
-      return normalizedHostname === domain || normalizedHostname.endsWith(`.${domain}`);
-    });
-    if (!internalCookies.length) return { cleared: false };
-    const matches = profile.cookies._convertToExternalCookies(internalCookies);
-    for (let index = 0; index < matches.length; index++) {
-      matches[index].expires = internalCookies[index].expires;
-      matches[index].maxAge = internalCookies[index].maxAge;
-      matches[index].sameSite = internalCookies[index].sameSite;
-    }
-    profile.cookies.deleteCookies(matches);
-    markDirty(deviceId);
-    return { cleared: true };
-  };
-
-  const remove = (deviceId) => {
-    const profile = profiles.get(deviceId);
-    if (!profile) return false;
-    clearRetentionTimer(profile);
-    if (profile.flushTimer !== null) clearTimer(profile.flushTimer);
-    profiles.delete(deviceId);
-    if (profile.persist) {
-      queueOperation(profile, () => persistence.remove(deviceId));
-      queueOperation(profile, () => persistence.removeMetadata?.(deviceId));
-    }
-    return true;
-  };
-  const has = (deviceId) => profiles.has(deviceId);
-
-  const close = async () => {
-    closing = true;
-    for (const profile of profiles.values()) clearRetentionTimer(profile);
-    while (true) {
-      const flushes = [];
-      for (const [deviceId, profile] of profiles) {
-        if (profile.dirty) flushes.push(flush(deviceId));
-        else if (profile.flushTimer !== null) {
-          clearTimer(profile.flushTimer);
-          profile.flushTimer = null;
-        }
-      }
-      await Promise.all(flushes);
-      const operations = [...pending];
-      if (!operations.length) break;
-      await Promise.all(operations);
-    }
-    for (const profile of profiles.values()) clearRetentionTimer(profile);
-    await persistence.close();
-  };
-
-  return {
-    attach, serialize, clear, remove, has, configure, setActive, flush, close,
-  };
-}

package/src/browser/coordinator.js

@@ -1,47 +0,0 @@
-const DEVICE_ID = /^[A-Za-z0-9_-]{32,128}$/;
-
-function jsonBody(response) {
-  if (!response?.body?.length) return null;
-  try { return JSON.parse(response.body.toString('utf8')); } catch { return null; }
-}
-
-function sendProxy(res, response, generation, stampGeneration) {
-  if (!response) return res.status(503).json({ error: 'browser unavailable' });
-  for (const [name, value] of Object.entries(response.headers || {})) {
-    if (value != null && !['connection', 'content-length', 'transfer-encoding'].includes(name.toLowerCase())) {
-      res.setHeader(name, value);
-    }
-  }
-  if (stampGeneration && response.status >= 200 && response.status < 300) {
-    const payload = jsonBody(response);
-    if (payload) return res.status(response.status).json({ ...payload, generation });
-  }
-  return res.status(response.status).send(response.body);
-}
-
-export function createBrowserCoordinator({
-  proxyRequest,
-  getStatus = () => ({ ready: false, generation: 0 }),
-} = {}) {
-  const handler = async (req, res) => {
-    if (req.method === 'GET' && req.path === '/status') {
-      return res.json(getStatus());
-    }
-    const deviceId = req.get('x-handmux-browser-device');
-    if (!DEVICE_ID.test(deviceId || '')) {
-      return res.status(400).json({ error: 'browser device id required' });
-    }
-    const path = `/api/browser-proxy${req.path}`;
-    const response = await proxyRequest({
-      req,
-      method: req.method,
-      path,
-      body: ['PUT', 'POST', 'PATCH'].includes(req.method) ? req.body : undefined,
-    });
-    const stampGeneration = /^\/leases\/[^/]+(?:\/navigate)?$/.test(req.path)
-      && ['PUT', 'POST'].includes(req.method);
-    return sendProxy(res, response, getStatus().generation, stampGeneration);
-  };
-  handler.close = () => {};
-  return handler;
-}

package/src/browser/hammerheadCompat.js

@@ -1,86 +0,0 @@
-import { createRequire } from 'node:module';
-
-const require = createRequire(import.meta.url);
-const PATCHED = Symbol.for('handmux.hammerhead.websocket-upgrade-socket');
-const RESPONDER_PATCHED = Symbol.for('handmux.hammerhead.websocket-mock-response');
-const REQUEST_INFO_PATCHED = Symbol.for('handmux.hammerhead.request-info-frame-nature');
-
-export function patchHammerheadDestinationRequest(DestinationRequest) {
-  const prototype = DestinationRequest?.prototype;
-  const original = prototype?._onUpgrade;
-  if (typeof original !== 'function' || original.length !== 3) {
-    throw new Error('unsupported Hammerhead DestinationRequest._onUpgrade signature');
-  }
-  if (original[PATCHED]) return false;
-
-  function onUpgrade(response, socket, head) {
-    if (response) response.socket ??= socket;
-    return original.call(this, response, socket, head);
-  }
-  Object.defineProperty(onUpgrade, PATCHED, { value: true });
-  prototype._onUpgrade = onUpgrade;
-  return true;
-}
-
-export function patchHammerheadWebSocketResponder(websocket, headerTransforms) {
-  const original = websocket?.respondOnWebSocket;
-  if (typeof original !== 'function') {
-    throw new Error('unsupported Hammerhead WebSocket responder');
-  }
-  if (original[RESPONDER_PATCHED]) return false;
-
-  function respondOnWebSocket(ctx) {
-    if (ctx?.destRes?.socket) return original(ctx);
-    const response = ctx?.res;
-    const destination = ctx?.destRes;
-    if (!destination || typeof response?.end !== 'function') return original(ctx);
-
-    const headers = headerTransforms.forResponse(ctx);
-    const missingUpgradeSocket = destination.statusCode === 101;
-    const statusCode = missingUpgradeSocket ? 502 : destination.statusCode || 502;
-    const statusMessage = missingUpgradeSocket ? 'Bad Gateway' : destination.statusMessage || 'Bad Gateway';
-    const lines = [`HTTP/${destination.httpVersion || '1.1'} ${statusCode} ${statusMessage}`];
-    for (const [name, value] of Object.entries(headers)) {
-      if (Array.isArray(value)) value.forEach((item) => lines.push(`${name}: ${item}`));
-      else if (value != null) lines.push(`${name}: ${value}`);
-    }
-    if (!Object.keys(headers).some((name) => name.toLowerCase() === 'connection')) {
-      lines.push('connection: close');
-    }
-    response.end(`${lines.join('\r\n')}\r\n\r\n`);
-    return undefined;
-  }
-  Object.defineProperty(respondOnWebSocket, RESPONDER_PATCHED, { value: true });
-  websocket.respondOnWebSocket = respondOnWebSocket;
-  return true;
-}
-
-export function patchHammerheadRequestInfo(RequestInfo) {
-  const original = RequestInfo?.from;
-  if (typeof original !== 'function') {
-    throw new Error('unsupported Hammerhead RequestInfo.from');
-  }
-  if (original[REQUEST_INFO_PATCHED]) return false;
-
-  function from(ctx) {
-    const info = original.call(this, ctx);
-    info.isIframe = !!ctx?.isIframe;
-    return info;
-  }
-  Object.defineProperty(from, REQUEST_INFO_PATCHED, { value: true });
-  RequestInfo.from = from;
-  return true;
-}
-
-export function installHammerheadWebSocketUpgradeCompat() {
-  const DestinationRequest = require('testcafe-hammerhead/lib/request-pipeline/destination-request');
-  const websocket = require('testcafe-hammerhead/lib/request-pipeline/websocket');
-  const headerTransforms = require('testcafe-hammerhead/lib/request-pipeline/header-transforms');
-  const { RequestInfo } = require(
-    'testcafe-hammerhead/lib/request-pipeline/request-hooks/events/info',
-  );
-  const destinationPatched = patchHammerheadDestinationRequest(DestinationRequest);
-  const responderPatched = patchHammerheadWebSocketResponder(websocket, headerTransforms);
-  const requestInfoPatched = patchHammerheadRequestInfo(RequestInfo);
-  return destinationPatched || responderPatched || requestInfoPatched;
-}

package/src/browser/hammerheadRedirectCompat.js

@@ -1,38 +0,0 @@
-import { createRequire } from 'node:module';
-import { randomBytes } from 'node:crypto';
-
-const require = createRequire(import.meta.url);
-const MARKER = 'x-handmux-browser-rebind';
-const MARKER_SECRET = randomBytes(32).toString('base64url');
-const PATCHED = Symbol.for('handmux.hammerhead.raw-rebind-location');
-
-export function hammerheadRebindHeaders(location) {
-  return { location, [MARKER]: MARKER_SECRET };
-}
-
-export function patchHammerheadRebindLocation(
-  responseTransforms,
-  markerSecret = MARKER_SECRET,
-) {
-  const original = responseTransforms?.location;
-  if (typeof original !== 'function') throw new Error('unsupported Hammerhead location transform');
-  if (original[PATCHED]) return false;
-
-  function location(src, ctx) {
-    if (ctx?.destRes?.headers?.[MARKER] === markerSecret) return src;
-    return original(src, ctx);
-  }
-  Object.defineProperty(location, PATCHED, { value: true });
-  responseTransforms.location = location;
-  responseTransforms[MARKER] = () => undefined;
-  return true;
-}
-
-export function installHammerheadRebindLocationCompat() {
-  const { responseTransforms } = require(
-    'testcafe-hammerhead/lib/request-pipeline/header-transforms/transforms',
-  );
-  return patchHammerheadRebindLocation(responseTransforms, MARKER_SECRET);
-}
-
-export { MARKER as HAMMERHEAD_REBIND_HEADER };