test-proxy-recorder 0.3.5 → 0.3.8

package/dist/index.cjs

@@ -1,20 +1,20 @@
 'use strict';
 
 var fs = require('fs/promises');
-var http = require('http');
-var https = require('https');
+var http2 = require('http');
 var httpProxy = require('http-proxy');
-var ws = require('ws');
+var https = require('https');
 var crypto = require('crypto');
 var path2 = require('path');
 var filenamify2 = require('filenamify');
+var ws = require('ws');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var fs__default = /*#__PURE__*/_interopDefault(fs);
-var http__default = /*#__PURE__*/_interopDefault(http);
-var https__default = /*#__PURE__*/_interopDefault(https);
+var http2__default = /*#__PURE__*/_interopDefault(http2);
 var httpProxy__default = /*#__PURE__*/_interopDefault(httpProxy);
+var https__default = /*#__PURE__*/_interopDefault(https);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var path2__default = /*#__PURE__*/_interopDefault(path2);
 var filenamify2__default = /*#__PURE__*/_interopDefault(filenamify2);
@@ -28,6 +28,244 @@ var HTTP_STATUS_NOT_FOUND = 404;
 var CONTROL_ENDPOINT = "/__control";
 var RECORDING_ID_HEADER = "x-test-rcrd-id";
 
+// src/utils/cors.ts
+function getCorsHeaders(req) {
+  const origin = req.headers.origin;
+  return {
+    "access-control-allow-origin": origin || "*",
+    "access-control-allow-credentials": "true",
+    "access-control-allow-headers": req.headers["access-control-request-headers"] || `Origin, X-Requested-With, Content-Type, Accept, Authorization, ${RECORDING_ID_HEADER}`,
+    "access-control-allow-methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+    "access-control-expose-headers": "*"
+  };
+}
+function addCorsHeaders(proxyRes, req) {
+  Object.assign(proxyRes.headers, getCorsHeaders(req));
+}
+
+// src/httpRecorder.ts
+async function bufferRequestBody(req) {
+  const chunks = [];
+  req.on("data", (chunk) => {
+    chunks.push(chunk);
+  });
+  try {
+    await new Promise((resolveBuffer, rejectBuffer) => {
+      req.on("end", () => resolveBuffer());
+      req.on("error", (err) => rejectBuffer(err));
+      setTimeout(
+        () => rejectBuffer(new Error("Request buffering timeout")),
+        3e4
+      );
+    });
+  } catch (error) {
+    console.error("Error buffering request:", error);
+  }
+  return chunks;
+}
+function handleProxyResponse(proxyRes, context) {
+  const { options, requestBody, resolve } = context;
+  const { req, res, key, recordingId, sequence, onProxyError } = options;
+  addCorsHeaders(proxyRes, req);
+  const responseChunks = [];
+  proxyRes.on("data", (chunk) => {
+    responseChunks.push(chunk);
+  });
+  proxyRes.on("end", () => {
+    try {
+      const responseBody = Buffer.concat(responseChunks);
+      const responseBodyStr = responseBody.toString("utf8");
+      const recording = {
+        request: {
+          method: req.method,
+          url: req.url,
+          headers: req.headers,
+          body: requestBody || null
+        },
+        response: {
+          statusCode: proxyRes.statusCode,
+          headers: proxyRes.headers,
+          body: responseBodyStr || null
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        key,
+        recordingId,
+        sequence
+      };
+      const responseHeaders = {
+        ...proxyRes.headers,
+        ...getCorsHeaders(req)
+      };
+      res.writeHead(proxyRes.statusCode || 200, responseHeaders);
+      res.end(responseBody);
+      console.log(
+        `Recorded: ${req.method} ${req.url} (recordingId: ${recordingId}, sequence: ${sequence})`
+      );
+      resolve(recording);
+    } catch (error) {
+      console.error("Error completing recording:", error);
+      resolve(null);
+    }
+  });
+  proxyRes.on("error", (err) => {
+    console.error("Proxy response error:", err);
+    if (!res.headersSent) {
+      onProxyError(err, req, res);
+    }
+    resolve(null);
+  });
+}
+function proxyWithBufferedBody(options, chunks) {
+  const { req, res, target, onProxyError } = options;
+  const requestBody = Buffer.concat(chunks).toString("utf8");
+  const targetUrl = new URL(target);
+  const isHttps = targetUrl.protocol === "https:";
+  const requestModule = isHttps ? https__default.default : http2__default.default;
+  const defaultPort = isHttps ? 443 : 80;
+  return new Promise((resolve) => {
+    const proxyReq = requestModule.request(
+      {
+        hostname: targetUrl.hostname,
+        port: targetUrl.port || defaultPort,
+        path: req.url,
+        method: req.method,
+        headers: req.headers
+      },
+      (proxyRes) => {
+        handleProxyResponse(proxyRes, { options, requestBody, resolve });
+      }
+    );
+    proxyReq.on("error", (err) => {
+      onProxyError(err, req, res);
+      resolve(null);
+    });
+    if (chunks.length > 0) {
+      proxyReq.write(Buffer.concat(chunks));
+    }
+    proxyReq.end();
+  });
+}
+async function recordAndProxyRequest(options) {
+  const { req, res, onProxyError } = options;
+  try {
+    const chunks = await bufferRequestBody(req);
+    return await proxyWithBufferedBody(options, chunks);
+  } catch (error) {
+    console.error("Error in recordAndProxyRequest:", error);
+    try {
+      onProxyError(error, req, res);
+    } catch (error_) {
+      console.error("Failed to handle proxy error:", error_);
+    }
+    return null;
+  }
+}
+
+// src/replaySessions.ts
+var ReplaySessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  evictionTimer = null;
+  timeoutMs;
+  constructor(timeoutMs) {
+    this.timeoutMs = timeoutMs;
+  }
+  get size() {
+    return this.sessions.size;
+  }
+  keys() {
+    return this.sessions.keys();
+  }
+  /**
+   * Get or create a replay session state for a given recording ID
+   */
+  getOrCreate(recordingId) {
+    let session = this.sessions.get(recordingId);
+    if (session) {
+      session.lastAccessTime = Date.now();
+    } else {
+      session = {
+        recordingId,
+        servedRecordingIdsByKey: /* @__PURE__ */ new Map(),
+        loadedSession: null,
+        lastAccessTime: Date.now(),
+        sortedRecordingsByKey: /* @__PURE__ */ new Map()
+      };
+      this.sessions.set(recordingId, session);
+      this.startEvictionTimer();
+      console.log(
+        `[CONCURRENT REPLAY] Created new session for recording: ${recordingId}`
+      );
+    }
+    return session;
+  }
+  delete(sessionId) {
+    this.sessions.delete(sessionId);
+    if (this.sessions.size === 0) {
+      this.stopEvictionTimer();
+    }
+  }
+  startEvictionTimer() {
+    if (this.evictionTimer) {
+      return;
+    }
+    const CHECK_INTERVAL_MS = 3e4;
+    this.evictionTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [id, session] of this.sessions) {
+        if (now - session.lastAccessTime >= this.timeoutMs) {
+          console.log(
+            `[EVICTION] Evicting idle replay session: ${id} (idle for ${Math.round((now - session.lastAccessTime) / 1e3)}s)`
+          );
+          this.sessions.delete(id);
+        }
+      }
+      if (this.sessions.size === 0) {
+        this.stopEvictionTimer();
+      }
+    }, CHECK_INTERVAL_MS);
+    this.evictionTimer.unref();
+  }
+  stopEvictionTimer() {
+    if (this.evictionTimer) {
+      clearInterval(this.evictionTimer);
+      this.evictionTimer = null;
+    }
+  }
+};
+function getServedTracker(sessionState, key) {
+  if (!sessionState.servedRecordingIdsByKey.has(key)) {
+    sessionState.servedRecordingIdsByKey.set(key, /* @__PURE__ */ new Set());
+  }
+  return sessionState.servedRecordingIdsByKey.get(key);
+}
+function getSortedRecordings(sessionState, key) {
+  if (sessionState.sortedRecordingsByKey.has(key)) {
+    return sessionState.sortedRecordingsByKey.get(key);
+  }
+  const session = sessionState.loadedSession;
+  const sortedRecords = session.recordings.filter((r) => r.key === key && r.response).toSorted((a, b) => {
+    const aSeq = a.sequence !== void 0 ? a.sequence : a.recordingId;
+    const bSeq = b.sequence !== void 0 ? b.sequence : b.recordingId;
+    return aSeq - bSeq;
+  });
+  sessionState.sortedRecordingsByKey.set(key, sortedRecords);
+  return sortedRecords;
+}
+function selectReplayRecord(recordsWithKey, servedForThisKey, key, recordingId) {
+  for (const rec of recordsWithKey) {
+    if (!servedForThisKey.has(rec.recordingId)) {
+      return rec;
+    }
+  }
+  if (recordsWithKey.length > 0) {
+    console.log(
+      `[REPLAY WARNING] All ${recordsWithKey.length} recordings already served for ${key} (session: ${recordingId}), reusing last one`
+    );
+    return recordsWithKey[recordsWithKey.length - 1];
+  }
+  return null;
+}
+
 // src/types.ts
 var Modes = {
   transparent: "transparent",
@@ -129,6 +367,180 @@ function sendJsonResponse(res, statusCode, data) {
   res.end(JSON.stringify(data));
 }
 
+// src/utils/recordingId.ts
+function getRecordingIdFromHeader(req) {
+  const headerValue = req.headers[RECORDING_ID_HEADER];
+  if (!headerValue) {
+    return null;
+  }
+  return Array.isArray(headerValue) ? headerValue[0] : headerValue;
+}
+function getRecordingIdFromCookie(req) {
+  const cookies = req.headers.cookie;
+  if (!cookies) {
+    return null;
+  }
+  const match = cookies.match(/proxy-recording-id=([^;]+)/);
+  return match ? decodeURIComponent(match[1]) : null;
+}
+function getRecordingIdFromRequest(req) {
+  const fromHeader = getRecordingIdFromHeader(req);
+  const fromCookie = getRecordingIdFromCookie(req);
+  return fromHeader ?? fromCookie ?? null;
+}
+function getWsRecordingKey(url) {
+  return `WS_${url.replaceAll("/", "_")}`;
+}
+var WS_INTERNAL_HEADERS = /* @__PURE__ */ new Set([
+  "host",
+  "connection",
+  "upgrade",
+  "sec-websocket-key",
+  "sec-websocket-version",
+  "sec-websocket-extensions"
+]);
+function getRecordableWsHeaders(req) {
+  const headers = {};
+  for (const [name, value] of Object.entries(req.headers)) {
+    if (!WS_INTERNAL_HEADERS.has(name) && value !== void 0) {
+      headers[name] = value;
+    }
+  }
+  return headers;
+}
+function getForwardableWsHeaders(req) {
+  const headers = {};
+  for (const [name, value] of Object.entries(getRecordableWsHeaders(req))) {
+    if (name !== "sec-websocket-protocol" && value !== void 0) {
+      headers[name] = Array.isArray(value) ? value.join(", ") : value;
+    }
+  }
+  return headers;
+}
+function getClientSubprotocols(req) {
+  const header = req.headers["sec-websocket-protocol"];
+  if (!header) {
+    return [];
+  }
+  const raw = Array.isArray(header) ? header.join(",") : header;
+  return raw.split(",").map((p) => p.trim()).filter(Boolean);
+}
+function recordWebSocket(req, clientSocket, head, target, session) {
+  const url = req.url || "/";
+  const wsRecording = {
+    url,
+    messages: [],
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    key: getWsRecordingKey(url),
+    headers: getRecordableWsHeaders(req)
+  };
+  if (session) {
+    session.websocketRecordings.push(wsRecording);
+  }
+  const backendWsUrl = `${target.replace("http", "ws")}${url}`;
+  const backendWs = new ws.WebSocket(backendWsUrl, getClientSubprotocols(req), {
+    headers: getForwardableWsHeaders(req)
+  });
+  const wss = new ws.WebSocketServer({
+    noServer: true,
+    handleProtocols: (protocols) => backendWs.protocol && protocols.has(backendWs.protocol) ? backendWs.protocol : protocols.values().next().value ?? false
+  });
+  backendWs.on("open", () => {
+    console.log(`WebSocket recording: connected to backend ${backendWsUrl}`);
+    if (backendWs.protocol) {
+      wsRecording.protocol = backendWs.protocol;
+    }
+    wss.handleUpgrade(req, clientSocket, head, (clientWs) => {
+      clientWs.on("message", (data) => {
+        const message = data.toString();
+        wsRecording.messages.push({
+          direction: "client-to-server",
+          data: message,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        if (backendWs.readyState === ws.WebSocket.OPEN) {
+          backendWs.send(message);
+        }
+      });
+      backendWs.on("message", (data) => {
+        const message = data.toString();
+        wsRecording.messages.push({
+          direction: "server-to-client",
+          data: message,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        if (clientWs.readyState === ws.WebSocket.OPEN) {
+          clientWs.send(message);
+        }
+      });
+      clientWs.on("error", (err) => {
+        console.error("Client WebSocket error:", err);
+      });
+      backendWs.on("error", (err) => {
+        console.error("Backend WebSocket error:", err);
+      });
+      clientWs.on("close", () => {
+        backendWs.close();
+        console.log("Client WebSocket closed");
+      });
+      backendWs.on("close", () => {
+        clientWs.close();
+        console.log("Backend WebSocket closed");
+      });
+    });
+  });
+  backendWs.on("error", (err) => {
+    console.error("Backend WebSocket connection error:", err);
+    clientSocket.write("HTTP/1.1 502 Bad Gateway\r\n\r\n");
+    clientSocket.destroy();
+  });
+  wss.on("error", (err) => {
+    console.error("WebSocket server error:", err);
+  });
+}
+function replayWebSocket(req, socket, wsRecording, recordingId) {
+  const url = req.url || "/";
+  const wss = new ws.WebSocketServer({
+    noServer: true,
+    handleProtocols: (protocols) => wsRecording.protocol && protocols.has(wsRecording.protocol) ? wsRecording.protocol : protocols.values().next().value ?? false
+  });
+  const fakeReq = Object.assign(req, {
+    headers: {
+      ...req.headers,
+      "sec-websocket-key": req.headers["sec-websocket-key"] || "replay-key",
+      "sec-websocket-version": "13"
+    }
+  });
+  wss.handleUpgrade(fakeReq, socket, Buffer.alloc(0), (ws$1) => {
+    console.log(`Replaying WebSocket: ${url} (session: ${recordingId})`);
+    const messages = wsRecording.messages;
+    let cursor = 0;
+    const flushServerMessages = () => {
+      while (cursor < messages.length && messages[cursor].direction === "server-to-client") {
+        const msg = messages[cursor];
+        cursor++;
+        if (ws$1.readyState === ws.WebSocket.OPEN) {
+          ws$1.send(msg.data);
+        }
+      }
+    };
+    ws$1.on("message", (data) => {
+      console.log(`Replay: Client sent: ${data.toString()}`);
+      if (cursor < messages.length && messages[cursor].direction === "client-to-server") {
+        cursor++;
+      }
+      flushServerMessages();
+    });
+    ws$1.on("error", (err) => {
+      console.error("Replay WebSocket error:", err);
+    });
+    ws$1.on("close", () => {
+      console.log("Replay WebSocket closed");
+    });
+    flushServerMessages();
+  });
+}
+
 // src/ProxyServer.ts
 var ProxyServer = class {
   target;
@@ -146,8 +558,6 @@ var ProxyServer = class {
   // Sequence counter per key (endpoint)
   replaySessions;
   // Track multiple concurrent replay sessions by recording ID
-  sessionEvictionTimer;
-  // Periodic timer to evict idle replay sessions
   recordingPromises;
   // Stack of promises that resolve to completed recordings
   flushPromise;
@@ -163,8 +573,7 @@ var ProxyServer = class {
     this.modeTimeout = null;
     this.currentSession = null;
     this.recordingsDir = recordingsDir;
-    this.replaySessions = /* @__PURE__ */ new Map();
-    this.sessionEvictionTimer = null;
+    this.replaySessions = new ReplaySessionManager(this.timeoutMs);
     this.recordingPromises = [];
     this.flushPromise = null;
     this.proxy = httpProxy__default.default.createProxyServer({
@@ -178,7 +587,7 @@ var ProxyServer = class {
     await fs__default.default.mkdir(this.recordingsDir, { recursive: true });
   }
   listen(port) {
-    const server = http__default.default.createServer((req, res) => {
+    const server = http2__default.default.createServer((req, res) => {
       this.handleRequest(req, res);
     });
     server.on("upgrade", (req, socket, head) => {
@@ -192,15 +601,15 @@ var ProxyServer = class {
   }
   setupProxyEventHandlers() {
     this.proxy.on("error", this.handleProxyError.bind(this));
-    this.proxy.on("proxyRes", this.addCorsHeaders.bind(this));
+    this.proxy.on("proxyRes", addCorsHeaders);
   }
   handleProxyError(err, req, res) {
     console.error("Proxy error:", err);
-    if (!(res instanceof http__default.default.ServerResponse)) {
+    if (!(res instanceof http2__default.default.ServerResponse)) {
       return;
     }
     if (!res.headersSent) {
-      const corsHeaders = this.getCorsHeaders(req);
+      const corsHeaders = getCorsHeaders(req);
       res.writeHead(HTTP_STATUS_BAD_GATEWAY, {
         "Content-Type": "application/json",
         ...corsHeaders
@@ -208,96 +617,12 @@ var ProxyServer = class {
     }
     res.end(JSON.stringify({ error: "Proxy error", message: err.message }));
   }
-  /**
-   * Get CORS headers for a given request
-   * @param req The incoming HTTP request
-   * @returns An object containing CORS headers
-   */
-  getCorsHeaders(req) {
-    const origin = req.headers.origin;
-    return {
-      "access-control-allow-origin": origin || "*",
-      "access-control-allow-credentials": "true",
-      "access-control-allow-headers": req.headers["access-control-request-headers"] || `Origin, X-Requested-With, Content-Type, Accept, Authorization, ${RECORDING_ID_HEADER}`,
-      "access-control-allow-methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
-      "access-control-expose-headers": "*"
-    };
-  }
-  addCorsHeaders(proxyRes, req) {
-    const corsHeaders = this.getCorsHeaders(req);
-    Object.assign(proxyRes.headers, corsHeaders);
-  }
-  /**
-   * Extract recording ID from custom HTTP header
-   * Used for concurrent replay session routing, especially with Next.js
-   * @param req The incoming HTTP request
-   * @returns The recording ID from header, or null if not found
-   */
-  getRecordingIdFromHeader(req) {
-    const headerValue = req.headers[RECORDING_ID_HEADER];
-    if (!headerValue) {
-      return null;
-    }
-    return Array.isArray(headerValue) ? headerValue[0] : headerValue;
-  }
-  /**
-   * Extract recording ID from request cookie
-   * Used for concurrent replay session routing (fallback method)
-   * @param req The incoming HTTP request
-   * @returns The recording ID from cookie, or null if not found
-   */
-  getRecordingIdFromCookie(req) {
-    const cookies = req.headers.cookie;
-    if (!cookies) {
-      return null;
-    }
-    const match = cookies.match(/proxy-recording-id=([^;]+)/);
-    return match ? decodeURIComponent(match[1]) : null;
-  }
-  /**
-   * Extract recording ID from request using custom header (preferred) or cookie (fallback)
-   * @param req The incoming HTTP request
-   * @returns The recording ID, or null if not found
-   */
-  getRecordingIdFromRequest(req) {
-    const fromHeader = this.getRecordingIdFromHeader(req);
-    const fromCookie = this.getRecordingIdFromCookie(req);
-    return fromHeader ?? fromCookie ?? null;
-  }
-  /**
-   * Get or create a replay session state for a given recording ID
-   * @param recordingId The recording ID to get/create session for
-   * @returns The replay session state
-   */
-  getOrCreateReplaySession(recordingId) {
-    let session = this.replaySessions.get(recordingId);
-    if (session) {
-      session.lastAccessTime = Date.now();
-    } else {
-      session = {
-        recordingId,
-        servedRecordingIdsByKey: /* @__PURE__ */ new Map(),
-        loadedSession: null,
-        lastAccessTime: Date.now(),
-        sortedRecordingsByKey: /* @__PURE__ */ new Map()
-      };
-      this.replaySessions.set(recordingId, session);
-      this.startSessionEvictionTimer();
-      console.log(
-        `[CONCURRENT REPLAY] Created new session for recording: ${recordingId}`
-      );
-    }
-    return session;
-  }
   /**
    * Clean up a session - removes it from memory and resets counters
    * @param sessionId The session ID to clean up
    */
   async cleanupSession(sessionId) {
     this.replaySessions.delete(sessionId);
-    if (this.replaySessions.size === 0) {
-      this.stopSessionEvictionTimer();
-    }
     if (this.recordingId === sessionId) {
       await this.saveCurrentSession();
       this.currentSession = null;
@@ -308,33 +633,6 @@ var ProxyServer = class {
     }
     console.log(`[CLEANUP] Session ${sessionId} cleaned up successfully`);
   }
-  startSessionEvictionTimer() {
-    if (this.sessionEvictionTimer) {
-      return;
-    }
-    const CHECK_INTERVAL_MS = 3e4;
-    this.sessionEvictionTimer = setInterval(() => {
-      const now = Date.now();
-      for (const [id, session] of this.replaySessions) {
-        if (now - session.lastAccessTime >= this.timeoutMs) {
-          console.log(
-            `[EVICTION] Evicting idle replay session: ${id} (idle for ${Math.round((now - session.lastAccessTime) / 1e3)}s)`
-          );
-          this.replaySessions.delete(id);
-        }
-      }
-      if (this.replaySessions.size === 0) {
-        this.stopSessionEvictionTimer();
-      }
-    }, CHECK_INTERVAL_MS);
-    this.sessionEvictionTimer.unref();
-  }
-  stopSessionEvictionTimer() {
-    if (this.sessionEvictionTimer) {
-      clearInterval(this.sessionEvictionTimer);
-      this.sessionEvictionTimer = null;
-    }
-  }
   async parseControlBody(req) {
     const body = await readRequestBody(req);
     console.log(`MODE CHANGE (${req.method})`, body);
@@ -458,7 +756,7 @@ var ProxyServer = class {
     this.replayId = id;
     this.recordingId = null;
     this.currentSession = null;
-    const sessionState = this.getOrCreateReplaySession(id);
+    const sessionState = this.replaySessions.getOrCreate(id);
     sessionState.servedRecordingIdsByKey.clear();
     sessionState.sortedRecordingsByKey.clear();
     const filePath = getRecordingPath(this.recordingsDir, id);
@@ -519,7 +817,7 @@ var ProxyServer = class {
     await saveRecordingSession(this.recordingsDir, this.currentSession);
   }
   getRecordingIdOrError(req, res) {
-    const recordingIdFromRequest = this.getRecordingIdFromRequest(req);
+    const recordingIdFromRequest = getRecordingIdFromRequest(req);
     if (recordingIdFromRequest) {
       return recordingIdFromRequest;
     }
@@ -527,7 +825,7 @@ var ProxyServer = class {
       console.warn(
         `[CONCURRENT REPLAY WARNING] Request to ${req.method} ${req.url} is missing ${RECORDING_ID_HEADER} header/cookie. Active sessions: ${[...this.replaySessions.keys()].join(", ")}. this.replayId fallback would be: ${this.replayId} (NOT USING - could be wrong session)`
       );
-      const corsHeaders = this.getCorsHeaders(req);
+      const corsHeaders = getCorsHeaders(req);
       res.writeHead(HTTP_STATUS_BAD_REQUEST, {
         "Content-Type": "application/json",
         ...corsHeaders
@@ -543,7 +841,7 @@ var ProxyServer = class {
     }
     const recordingId = this.replayId;
     if (!recordingId) {
-      const corsHeaders = this.getCorsHeaders(req);
+      const corsHeaders = getCorsHeaders(req);
       res.writeHead(HTTP_STATUS_BAD_REQUEST, {
         "Content-Type": "application/json",
         ...corsHeaders
@@ -556,55 +854,22 @@ var ProxyServer = class {
     );
     return recordingId;
   }
-  getServedTracker(sessionState, key) {
-    if (!sessionState.servedRecordingIdsByKey.has(key)) {
-      sessionState.servedRecordingIdsByKey.set(key, /* @__PURE__ */ new Set());
-    }
-    return sessionState.servedRecordingIdsByKey.get(key);
-  }
-  getSortedRecordings(sessionState, key) {
-    if (sessionState.sortedRecordingsByKey.has(key)) {
-      return sessionState.sortedRecordingsByKey.get(key);
-    }
-    const session = sessionState.loadedSession;
-    const sortedRecords = session.recordings.filter((r) => r.key === key && r.response).toSorted((a, b) => {
-      const aSeq = a.sequence !== void 0 ? a.sequence : a.recordingId;
-      const bSeq = b.sequence !== void 0 ? b.sequence : b.recordingId;
-      return aSeq - bSeq;
-    });
-    sessionState.sortedRecordingsByKey.set(key, sortedRecords);
-    return sortedRecords;
-  }
-  selectReplayRecord(recordsWithKey, servedForThisKey, key, recordingId) {
-    for (const rec of recordsWithKey) {
-      if (!servedForThisKey.has(rec.recordingId)) {
-        return rec;
-      }
-    }
-    if (recordsWithKey.length > 0) {
-      console.log(
-        `[REPLAY WARNING] All ${recordsWithKey.length} recordings already served for ${key} (session: ${recordingId}), reusing last one`
-      );
-      return recordsWithKey[recordsWithKey.length - 1];
-    }
-    return null;
-  }
   async handleReplayRequest(req, res) {
     const recordingId = this.getRecordingIdOrError(req, res);
     if (!recordingId) return;
     const key = getReqID(req);
     const filePath = getRecordingPath(this.recordingsDir, recordingId);
     try {
-      const sessionState = this.getOrCreateReplaySession(recordingId);
+      const sessionState = this.replaySessions.getOrCreate(recordingId);
       if (!sessionState.loadedSession) {
         throw Object.assign(
           new Error(`Recording session file not found: ${filePath}`),
           { code: "ENOENT" }
         );
       }
-      const servedForThisKey = this.getServedTracker(sessionState, key);
+      const servedForThisKey = getServedTracker(sessionState, key);
       const host = req.headers.host || "unknown";
-      const recordsWithKey = this.getSortedRecordings(sessionState, key);
+      const recordsWithKey = getSortedRecordings(sessionState, key);
       if (recordsWithKey.length === 0) {
         const errorMsg = `No recording found for ${key} at ${req.method} ${host}${req.url}`;
         console.error(`[REPLAY ERROR] ${errorMsg} (session: ${recordingId})`);
@@ -617,7 +882,7 @@ var ProxyServer = class {
           key,
           sessionId: recordingId
         };
-        const corsHeaders = this.getCorsHeaders(req);
+        const corsHeaders = getCorsHeaders(req);
         res.writeHead(HTTP_STATUS_NOT_FOUND, {
           "Content-Type": "application/json",
           ...corsHeaders
@@ -629,7 +894,7 @@ var ProxyServer = class {
       console.log(
         `[replay request #${requestCount}] ${req.method} ${req.url} (key: ${key}, session: ${recordingId}, total: ${recordsWithKey.length}, served: ${servedForThisKey.size})`
       );
-      const record = this.selectReplayRecord(
+      const record = selectReplayRecord(
         recordsWithKey,
         servedForThisKey,
         key,
@@ -647,7 +912,7 @@ var ProxyServer = class {
       const { statusCode, headers, body } = record.response;
       const responseHeaders = {
         ...headers,
-        ...this.getCorsHeaders(req)
+        ...getCorsHeaders(req)
       };
       res.writeHead(statusCode, responseHeaders);
       res.end(body);
@@ -658,7 +923,7 @@ var ProxyServer = class {
   handleReplayError(req, res, err, key, filePath) {
     const isFileNotFound = err instanceof Error && "code" in err && err.code === "ENOENT";
     console.error("Replay error:", err);
-    const corsHeaders = this.getCorsHeaders(req);
+    const corsHeaders = getCorsHeaders(req);
     res.writeHead(HTTP_STATUS_NOT_FOUND, {
       "Content-Type": "application/json",
       ...corsHeaders
@@ -686,7 +951,7 @@ var ProxyServer = class {
     await this.handleProxyRequest(req, res);
   }
   handleCorsPreflightRequest(req, res) {
-    const corsHeaders = this.getCorsHeaders(req);
+    const corsHeaders = getCorsHeaders(req);
     res.writeHead(HTTP_STATUS_OK, {
       ...corsHeaders,
       "Access-Control-Max-Age": "86400"
@@ -698,13 +963,12 @@ var ProxyServer = class {
     const target = this.target;
     console.log(`[${this.mode}] ${req.method} ${req.url} -> ${target}`);
     if (this.mode === Modes.record) {
-      await this.recordAndProxyRequest(req, res, target);
+      this.recordAndProxy(req, res, target);
     } else {
       this.proxy.web(req, res, { target });
     }
   }
-  // Note: streaming requests are buffered before proxying; streaming passthrough is not yet implemented
-  async recordAndProxyRequest(req, res, target) {
+  recordAndProxy(req, res, target) {
     if (!this.currentSession) {
       return;
     }
@@ -712,109 +976,17 @@ var ProxyServer = class {
     const recordingId = this.recordingIdCounter++;
     const sequence = this.sequenceCounterByKey.get(key) || 0;
     this.sequenceCounterByKey.set(key, sequence + 1);
-    const recordingPromise = new Promise((resolve) => {
-      (async () => {
-        try {
-          const chunks = [];
-          req.on("data", (chunk) => {
-            chunks.push(chunk);
-          });
-          try {
-            await new Promise((resolveBuffer, rejectBuffer) => {
-              req.on("end", () => resolveBuffer());
-              req.on("error", (err) => rejectBuffer(err));
-              setTimeout(
-                () => rejectBuffer(new Error("Request buffering timeout")),
-                3e4
-              );
-            });
-          } catch (error) {
-            console.error("Error buffering request:", error);
-          }
-          const requestBody = Buffer.concat(chunks).toString("utf8");
-          const targetUrl = new URL(target);
-          const isHttps = targetUrl.protocol === "https:";
-          const requestModule = isHttps ? https__default.default : http__default.default;
-          const defaultPort = isHttps ? 443 : 80;
-          const proxyReq = requestModule.request(
-            {
-              hostname: targetUrl.hostname,
-              port: targetUrl.port || defaultPort,
-              path: req.url,
-              method: req.method,
-              headers: req.headers
-            },
-            (proxyRes) => {
-              this.addCorsHeaders(proxyRes, req);
-              const responseChunks = [];
-              proxyRes.on("data", (chunk) => {
-                responseChunks.push(chunk);
-              });
-              proxyRes.on("end", async () => {
-                try {
-                  const responseBody = Buffer.concat(responseChunks);
-                  const responseBodyStr = responseBody.toString("utf8");
-                  const recording = {
-                    request: {
-                      method: req.method,
-                      url: req.url,
-                      headers: req.headers,
-                      body: requestBody || null
-                    },
-                    response: {
-                      statusCode: proxyRes.statusCode,
-                      headers: proxyRes.headers,
-                      body: responseBodyStr || null
-                    },
-                    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-                    key,
-                    recordingId,
-                    sequence
-                  };
-                  const responseHeaders = {
-                    ...proxyRes.headers,
-                    ...this.getCorsHeaders(req)
-                  };
-                  res.writeHead(proxyRes.statusCode || 200, responseHeaders);
-                  res.end(responseBody);
-                  console.log(
-                    `Recorded: ${req.method} ${req.url} (recordingId: ${recordingId}, sequence: ${sequence})`
-                  );
-                  resolve(recording);
-                } catch (error) {
-                  console.error("Error completing recording:", error);
-                  resolve(null);
-                }
-              });
-              proxyRes.on("error", (err) => {
-                console.error("Proxy response error:", err);
-                if (!res.headersSent) {
-                  this.handleProxyError(err, req, res);
-                }
-                resolve(null);
-              });
-            }
-          );
-          proxyReq.on("error", (err) => {
-            this.handleProxyError(err, req, res);
-            resolve(null);
-          });
-          if (chunks.length > 0) {
-            proxyReq.write(Buffer.concat(chunks));
-          }
-          proxyReq.end();
-        } catch (error) {
-          console.error("Error in recordAndProxyRequest:", error);
-          try {
-            this.handleProxyError(error, req, res);
-          } catch (error_) {
-            console.error("Failed to handle proxy error:", error_);
-          }
-          resolve(null);
-        }
-      })();
-    });
-    this.recordingPromises.push(recordingPromise);
+    this.recordingPromises.push(
+      recordAndProxyRequest({
+        req,
+        res,
+        target,
+        key,
+        recordingId,
+        sequence,
+        onProxyError: this.handleProxyError.bind(this)
+      })
+    );
   }
   handleUpgrade(req, socket, head) {
     if (this.mode === Modes.replay) {
@@ -824,83 +996,46 @@ var ProxyServer = class {
     const target = this.target;
     console.log(`[${this.mode}] WebSocket upgrade ${req.url} -> ${target}`);
     if (this.mode === Modes.record) {
-      this.handleRecordWebSocket(req, socket, head, target);
+      recordWebSocket(req, socket, head, target, this.currentSession);
     } else {
       this.proxy.ws(req, socket, head, { target });
     }
   }
-  handleRecordWebSocket(req, clientSocket, head, target) {
-    const url = req.url || "/";
-    const key = `WS_${url.replaceAll("/", "_")}`;
-    const wsRecording = {
-      url,
-      messages: [],
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      key
-    };
-    if (this.currentSession) {
-      this.currentSession.websocketRecordings.push(wsRecording);
+  /**
+   * Resolve the recording ID for a WebSocket upgrade request.
+   * Mirrors getRecordingIdOrError(): prefer the header/cookie from the request,
+   * fall back to this.replayId only when there is at most one active session.
+   * Browsers cannot set custom headers on WebSocket handshakes from JS, but
+   * Playwright's setExtraHTTPHeaders / cookies still reach the upgrade request.
+   */
+  getWsRecordingId(req) {
+    const fromRequest = getRecordingIdFromRequest(req);
+    if (fromRequest) {
+      return fromRequest;
     }
-    const backendWsUrl = `${target.replace("http", "ws")}${url}`;
-    const backendWs = new ws.WebSocket(backendWsUrl);
-    const wss = new ws.WebSocketServer({ noServer: true });
-    backendWs.on("open", () => {
-      console.log(`WebSocket recording: connected to backend ${backendWsUrl}`);
-      wss.handleUpgrade(req, clientSocket, head, (clientWs) => {
-        clientWs.on("message", (data) => {
-          const message = data.toString();
-          wsRecording.messages.push({
-            direction: "client-to-server",
-            data: message,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          });
-          if (backendWs.readyState === ws.WebSocket.OPEN) {
-            backendWs.send(message);
-          }
-        });
-        backendWs.on("message", (data) => {
-          const message = data.toString();
-          wsRecording.messages.push({
-            direction: "server-to-client",
-            data: message,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          });
-          if (clientWs.readyState === ws.WebSocket.OPEN) {
-            clientWs.send(message);
-          }
-        });
-        clientWs.on("error", (err) => {
-          console.error("Client WebSocket error:", err);
-        });
-        backendWs.on("error", (err) => {
-          console.error("Backend WebSocket error:", err);
-        });
-        clientWs.on("close", () => {
-          backendWs.close();
-          console.log("Client WebSocket closed");
-        });
-        backendWs.on("close", () => {
-          clientWs.close();
-          console.log("Backend WebSocket closed");
-        });
-      });
-    });
-    backendWs.on("error", (err) => {
-      console.error("Backend WebSocket connection error:", err);
-      clientSocket.write("HTTP/1.1 502 Bad Gateway\r\n\r\n");
-      clientSocket.destroy();
-    });
-    wss.on("error", (err) => {
-      console.error("WebSocket server error:", err);
-    });
+    if (this.replaySessions.size > 1) {
+      console.warn(
+        `[CONCURRENT REPLAY WARNING] WebSocket upgrade ${req.url} is missing ${RECORDING_ID_HEADER} header/cookie. Active sessions: ${[...this.replaySessions.keys()].join(", ")}. this.replayId fallback would be: ${this.replayId} (NOT USING - could be wrong session)`
+      );
+      return null;
+    }
+    return this.replayId;
   }
   async handleReplayWebSocket(req, socket) {
-    const url = req.url || "/";
-    const key = `WS_${url.replaceAll("/", "_")}`;
-    const filePath = getRecordingPath(this.recordingsDir, this.replayId);
+    const key = getWsRecordingKey(req.url || "/");
+    const recordingId = this.getWsRecordingId(req);
+    if (!recordingId) {
+      socket.write("HTTP/1.1 400 Bad Request\r\n\r\n");
+      socket.destroy();
+      return;
+    }
     try {
-      const session = await loadRecordingSession(filePath);
-      const wsRecording = session.websocketRecordings.find(
+      const sessionState = this.replaySessions.getOrCreate(recordingId);
+      if (!sessionState.loadedSession) {
+        const filePath = getRecordingPath(this.recordingsDir, recordingId);
+        sessionState.loadedSession = await loadRecordingSession(filePath);
+      }
+      const wsRecording = sessionState.loadedSession.websocketRecordings.find(
         (r) => r.key === key
       );
       if (!wsRecording) {
@@ -909,62 +1044,7 @@ var ProxyServer = class {
         console.log(`No WebSocket recording found for ${key}`);
         return;
       }
-      const wss = new ws.WebSocketServer({ noServer: true });
-      const fakeReq = Object.assign(req, {
-        headers: {
-          ...req.headers,
-          "sec-websocket-key": req.headers["sec-websocket-key"] || "replay-key",
-          "sec-websocket-version": "13"
-        }
-      });
-      wss.handleUpgrade(fakeReq, socket, Buffer.alloc(0), (ws$1) => {
-        console.log(`Replaying WebSocket: ${url}`);
-        const serverMessages = wsRecording.messages.filter(
-          (m) => m.direction === "server-to-client"
-        );
-        let messageIndex = 0;
-        ws$1.on("message", (data) => {
-          const clientMessage = data.toString();
-          console.log(`Replay: Client sent: ${clientMessage}`);
-          if (messageIndex < serverMessages.length) {
-            setTimeout(() => {
-              if (ws$1.readyState === ws.WebSocket.OPEN) {
-                ws$1.send(serverMessages[messageIndex].data);
-                console.log(`Replay: Sent server message ${messageIndex}`);
-                messageIndex++;
-              }
-            }, 10);
-          }
-        });
-        let initialMessagesSent = 0;
-        for (let i = 0; i < wsRecording.messages.length; i++) {
-          const msg = wsRecording.messages[i];
-          if (msg.direction === "client-to-server") {
-            break;
-          }
-          if (msg.direction === "server-to-client") {
-            setTimeout(
-              () => {
-                if (ws$1.readyState === ws.WebSocket.OPEN) {
-                  ws$1.send(msg.data);
-                  console.log(
-                    `Replay: Sent initial server message: ${msg.data}`
-                  );
-                  messageIndex++;
-                  initialMessagesSent++;
-                }
-              },
-              10 * (initialMessagesSent + 1)
-            );
-          }
-        }
-        ws$1.on("error", (err) => {
-          console.error("Replay WebSocket error:", err);
-        });
-        ws$1.on("close", () => {
-          console.log("Replay WebSocket closed");
-        });
-      });
+      replayWebSocket(req, socket, wsRecording, recordingId);
     } catch (error) {
       console.error("Replay error:", error);
       socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
@@ -1139,6 +1219,14 @@ var playwrightProxy = {
     await page.setExtraHTTPHeaders({
       [RECORDING_ID_HEADER]: sessionId
     });
+    const fallbackProxyPort = getProxyPort();
+    await page.context().addCookies([
+      {
+        name: "proxy-recording-id",
+        value: encodeURIComponent(sessionId),
+        url: `http://localhost:${fallbackProxyPort}`
+      }
+    ]);
     await setProxyMode(mode, sessionId, timeout);
     if (clientSideOptions?.url) {
       await setupClientSideRecording(