test-proxy-recorder 0.1.9 → 0.1.10

package/README.md

@@ -102,7 +102,7 @@ Create `e2e/global-teardown.ts`:
 import { setProxyMode } from 'test-proxy-recorder';
 
 async function globalTeardown() {
-  await setProxyMode('transparent');
+  await setProxyMode('transparent').catch(err => { console.error(err) });
 }
 
 export default globalTeardown;
@@ -247,7 +247,7 @@ Create `e2e/global-teardown.ts`:
 import { setProxyMode } from 'test-proxy-recorder';
 
 async function globalTeardown() {
-  await setProxyMode('transparent');
+  await setProxyMode('transparent').catch(err => { console.error(err) });
 }
 
 export default globalTeardown;

package/dist/{index-CG-XcFDa.d.cts → index-CjM3evKb.d.cts}

@@ -28,7 +28,6 @@ interface Recording {
     response?: RecordedResponse;
     timestamp: string;
     key: string;
-    sequence: number;
     recordingId: number;
 }
 interface WebSocketMessage {

package/dist/{index-CG-XcFDa.d.ts → index-CjM3evKb.d.ts}

@@ -28,7 +28,6 @@ interface Recording {
     response?: RecordedResponse;
     timestamp: string;
     key: string;
-    sequence: number;
     recordingId: number;
 }
 interface WebSocketMessage {

package/dist/index.cjs

@@ -98,12 +98,10 @@ var ProxyServer = class {
   proxy;
   currentSession;
   recordingsDir;
-  requestSequenceMap;
-  // Track sequence per request key
-  replaySequenceMap;
-  // Track replay position per request key
   recordingIdCounter;
   // Unique ID for each recording entry
+  replaySessions;
+  // Track multiple concurrent replay sessions by recording ID
   constructor(targets, recordingsDir) {
     this.targets = targets;
     this.currentTargetIndex = 0;
@@ -114,11 +112,11 @@ var ProxyServer = class {
     this.modeTimeout = null;
     this.currentSession = null;
     this.recordingsDir = recordingsDir;
-    this.requestSequenceMap = /* @__PURE__ */ new Map();
-    this.replaySequenceMap = /* @__PURE__ */ new Map();
+    this.replaySessions = /* @__PURE__ */ new Map();
     this.proxy = httpProxy__default.default.createProxyServer({
       secure: false,
-      changeOrigin: true
+      changeOrigin: true,
+      ws: true
     });
     this.setupProxyEventHandlers();
   }
@@ -186,6 +184,43 @@ var ProxyServer = class {
     this.currentTargetIndex = (this.currentTargetIndex + 1) % this.targets.length;
     return target;
   }
+  /**
+   * Extract recording ID from request cookie
+   * Used for concurrent replay session routing
+   * @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;
+  }
+  /**
+   * 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()
+      };
+      this.replaySessions.set(recordingId, session);
+      console.log(
+        `[CONCURRENT REPLAY] Created new session for recording: ${recordingId}`
+      );
+    }
+    return session;
+  }
   parseGetParams(req) {
     const url = new URL(req.url || "", `http://${req.headers.host}`);
     const mode = url.searchParams.get("mode");
@@ -202,16 +237,25 @@ var ProxyServer = class {
       let data;
       if (req.method === "GET") {
         data = this.parseGetParams(req);
-      } else {
+      } else if (req.method === "POST") {
         const body = await readRequestBody(req);
-        console.log("MODE CHANGE (POST)", body);
+        console.log(`MODE CHANGE (${req.method})`, body);
         data = JSON.parse(body);
+      } else {
+        return;
       }
       const { mode, id, timeout: requestTimeout } = data;
       const timeout = requestTimeout ?? DEFAULT_TIMEOUT_MS;
       this.clearModeTimeout();
       await this.switchMode(mode, id);
       this.setupModeTimeout(timeout);
+      if (mode === Modes.replay && id) {
+        res.setHeader(
+          "Set-Cookie",
+          `proxy-recording-id=${encodeURIComponent(id)}; HttpOnly; Path=/; SameSite=Lax`
+        );
+        console.log(`[CONCURRENT REPLAY] Set cookie for recording: ${id}`);
+      }
       sendJsonResponse(res, HTTP_STATUS_OK, {
         success: true,
         mode: this.mode,
@@ -226,14 +270,12 @@ var ProxyServer = class {
     }
   }
   clearModeTimeout() {
-    if (this.modeTimeout) {
-      clearTimeout(this.modeTimeout);
-      this.modeTimeout = null;
-    }
+    clearTimeout(this.modeTimeout || 0);
+    this.modeTimeout = null;
   }
   async switchMode(mode, id) {
-    if (this.currentSession) {
-      console.log("Switching mode, saving current session first");
+    console.log(`Switching to ${mode.toUpperCase()} mode`);
+    if (this.currentSession && this.mode === Modes.record) {
       await this.saveCurrentSession(true);
       console.log("Session saved, continuing with mode switch");
     }
@@ -243,11 +285,17 @@ var ProxyServer = class {
         break;
       }
       case Modes.record: {
+        if (!id) {
+          throw new Error("Record ID is required");
+        }
         this.switchToRecordMode(id);
         break;
       }
       case Modes.replay: {
-        this.switchToReplayMode(id);
+        if (!id) {
+          throw new Error("Replay ID is required");
+        }
+        await this.switchToReplayMode(id);
         break;
       }
       default: {
@@ -264,36 +312,33 @@ var ProxyServer = class {
     console.log("Switched to transparent mode");
   }
   switchToRecordMode(id) {
-    if (!id) {
-      throw new Error("Record ID is required");
-    }
     this.mode = Modes.record;
     this.recordingId = id;
     this.replayId = null;
     this.currentSession = { id, recordings: [], websocketRecordings: [] };
-    this.requestSequenceMap.clear();
     console.log(`Switched to record mode with ID: ${id}`);
   }
-  switchToReplayMode(id) {
-    if (!id) {
-      throw new Error("Replay ID is required");
-    }
+  async switchToReplayMode(id) {
     this.mode = Modes.replay;
     this.replayId = id;
     this.recordingId = null;
     this.currentSession = null;
-    this.replaySequenceMap.clear();
+    const session = this.replaySessions.get(id);
+    if (session) {
+      session.servedRecordingIdsByKey.clear();
+      console.log(`Reset served recordings tracker for session: ${id}`);
+    } else {
+      this.getOrCreateReplaySession(id);
+    }
     console.log(`Switched to replay mode with ID: ${id}`);
   }
   setupModeTimeout(timeout) {
-    if (timeout && timeout > 0) {
-      this.modeTimeout = setTimeout(async () => {
-        console.log("Timeout reached, switching back to transparent mode");
-        await this.saveCurrentSession(true);
-        this.switchToTransparentMode();
-        this.modeTimeout = null;
-      }, timeout);
-    }
+    this.modeTimeout = setTimeout(async () => {
+      console.log("Timeout reached, switching back to transparent mode");
+      await this.saveCurrentSession(true);
+      this.switchToTransparentMode();
+      this.modeTimeout = null;
+    }, timeout);
   }
   async saveCurrentSession(filterIncomplete = false) {
     if (!this.currentSession) {
@@ -319,9 +364,6 @@ var ProxyServer = class {
       return;
     }
     const key = getReqID(req);
-    const currentSequence = this.requestSequenceMap.get(key) || 0;
-    const sequence = currentSequence;
-    this.requestSequenceMap.set(key, currentSequence + 1);
     const recordingId = this.recordingIdCounter++;
     req.__recordingId = recordingId;
     const record = {
@@ -333,13 +375,12 @@ var ProxyServer = class {
       },
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       key,
-      sequence,
       recordingId
     };
     this.currentSession.recordings.push(record);
     console.log(
       // eslint-disable-next-line sonarjs/no-nested-template-literals
-      `saveRequestRecordSync: Saved ${req.method} ${req.url} (key: ${key}, seq: ${sequence}, recordingId: ${recordingId}, body: ${body ? `${body.length} chars` : "null"}, total: ${this.currentSession.recordings.length}, sessionId: ${this.currentSession.id})`
+      `saveRequestRecordSync: Saved ${req.method} ${req.url} (key: ${key}, recordingId: ${recordingId}, body: ${body ? `${body.length} chars` : "null"}, total: ${this.currentSession.recordings.length}, sessionId: ${this.currentSession.id})`
     );
   }
   updateRequestBodySync(req, body) {
@@ -399,7 +440,7 @@ var ProxyServer = class {
         body: body || null
       };
       console.log(
-        `Recorded: ${req.method} ${req.url} (seq: ${record.sequence}, recordingId: ${recordingId})`
+        `Recorded: ${req.method} ${req.url} (recordingId: ${recordingId})`
       );
     });
   }
@@ -429,46 +470,77 @@ var ProxyServer = class {
       body: body || null
     };
     console.log(
-      `recordResponseData: Recorded response for ${req.method} ${req.url} (seq: ${record.sequence}, recordingId: ${recordingId})`
+      `recordResponseData: Recorded response for ${req.method} ${req.url} (recordingId: ${recordingId})`
     );
     return true;
   }
   async handleReplayRequest(req, res) {
+    const recordingId = this.getRecordingIdFromCookie(req) || this.replayId;
+    if (!recordingId) {
+      const corsHeaders = this.getCorsHeaders(req);
+      res.writeHead(HTTP_STATUS_BAD_REQUEST, {
+        "Content-Type": "application/json",
+        ...corsHeaders
+      });
+      res.end(JSON.stringify({ error: "No replay session active" }));
+      return;
+    }
     const key = getReqID(req);
-    const filePath = getRecordingPath(this.recordingsDir, this.replayId);
+    const filePath = getRecordingPath(this.recordingsDir, recordingId);
     try {
-      const session = await loadRecordingSession(filePath);
+      const sessionState = this.getOrCreateReplaySession(recordingId);
+      if (!sessionState.loadedSession) {
+        sessionState.loadedSession = await loadRecordingSession(filePath);
+        console.log(`[REPLAY] Loaded recording session: ${recordingId}`);
+      }
+      const session = sessionState.loadedSession;
+      if (!sessionState.servedRecordingIdsByKey.has(key)) {
+        sessionState.servedRecordingIdsByKey.set(key, /* @__PURE__ */ new Set());
+      }
+      const servedForThisKey = sessionState.servedRecordingIdsByKey.get(key);
       const host = req.headers.host || "unknown";
-      const recordsWithKey = session.recordings.filter((r) => r.key === key && r.response).toSorted((a, b) => a.sequence - b.sequence);
+      const recordsWithKey = session.recordings.filter((r) => r.key === key && r.response).toSorted((a, b) => a.recordingId - b.recordingId);
       if (recordsWithKey.length === 0) {
-        console.warn(
-          `No recording found for ${key} at ${req.method} ${host}${req.url}, returning default response`
+        const errorMsg = `No recording found for ${key} at ${req.method} ${host}${req.url}`;
+        console.error(`[REPLAY ERROR] ${errorMsg} (session: ${recordingId})`);
+        console.error(
+          `[REPLAY ERROR] This request was not made during recording - possible test non-determinism`
         );
-        const defaultResponse = req.method === "GET" ? {
-          data: [],
-          items: [],
-          results: [],
-          updated_at: "0001-01-01T00:00:00Z"
-        } : { success: true };
+        const errorResponse = {
+          error: "No recording found",
+          message: errorMsg,
+          key,
+          sessionId: recordingId
+        };
         const corsHeaders = this.getCorsHeaders(req);
-        res.writeHead(HTTP_STATUS_OK, {
+        res.writeHead(HTTP_STATUS_NOT_FOUND, {
           "Content-Type": "application/json",
           ...corsHeaders
         });
-        res.end(JSON.stringify(defaultResponse));
+        res.end(JSON.stringify(errorResponse));
         return;
       }
-      const usageCount = this.replaySequenceMap.get(key) || 0;
+      const requestCount = servedForThisKey.size + 1;
+      console.log(
+        `[REPLAY REQUEST #${requestCount}] ${req.method} ${req.url} (session: ${recordingId}, total: ${recordsWithKey.length}, served: ${servedForThisKey.size})`
+      );
       let record;
-      if (usageCount < recordsWithKey.length) {
-        record = recordsWithKey[usageCount];
-      } else {
+      for (const rec of recordsWithKey) {
+        if (!servedForThisKey.has(rec.recordingId)) {
+          record = rec;
+          break;
+        }
+      }
+      if (!record) {
+        console.log(
+          `[REPLAY WARNING] All ${recordsWithKey.length} recordings already served for ${key} (session: ${recordingId}), reusing last one`
+        );
         record = recordsWithKey[recordsWithKey.length - 1];
       }
+      servedForThisKey.add(record.recordingId);
       console.log(
-        `Replaying ${req.method} ${req.url} (usage: ${usageCount}, sequence: ${record.sequence}, body_len: ${record.response?.body?.length || 0})`
+        `[REPLAY SERVING] recordingId: ${record.recordingId}, session: ${recordingId}, body_len: ${record.response?.body?.length || 0}`
       );
-      this.replaySequenceMap.set(key, usageCount + 1);
       if (!record.response) {
         throw new Error(
           `No response recorded for this request: ${req.method} ${host}${req.url}`
@@ -534,6 +606,7 @@ var ProxyServer = class {
       this.proxy.web(req, res, { target });
     }
   }
+  // TODO: check if can handle streaming requests
   async bufferAndProxyRequest(req, res, target) {
     const chunks = [];
     req.on("data", (chunk) => {

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import http from 'node:http';
-export { C as ControlRequest, M as Mode, P as PlaywrightTestInfo, R as Recording, a as RecordingSession, W as WebSocketRecording, g as generateSessionId, p as playwrightProxy, s as setProxyMode, b as startRecording, c as startReplay, d as stopProxy } from './index-CG-XcFDa.cjs';
+export { C as ControlRequest, M as Mode, P as PlaywrightTestInfo, R as Recording, a as RecordingSession, W as WebSocketRecording, g as generateSessionId, p as playwrightProxy, s as setProxyMode, b as startRecording, c as startReplay, d as stopProxy } from './index-CjM3evKb.cjs';
 import '@playwright/test';
 
 declare class ProxyServer {
@@ -12,9 +12,8 @@ declare class ProxyServer {
     private proxy;
     private currentSession;
     private recordingsDir;
-    private requestSequenceMap;
-    private replaySequenceMap;
     private recordingIdCounter;
+    private replaySessions;
     constructor(targets: string[], recordingsDir: string);
     init(): Promise<void>;
     listen(port: number): http.Server;
@@ -29,6 +28,19 @@ declare class ProxyServer {
     private getCorsHeaders;
     private addCorsHeaders;
     private getTarget;
+    /**
+     * Extract recording ID from request cookie
+     * Used for concurrent replay session routing
+     * @param req The incoming HTTP request
+     * @returns The recording ID from cookie, or null if not found
+     */
+    private getRecordingIdFromCookie;
+    /**
+     * 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
+     */
+    private getOrCreateReplaySession;
     private parseGetParams;
     private handleControlRequest;
     private clearModeTimeout;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import http from 'node:http';
-export { C as ControlRequest, M as Mode, P as PlaywrightTestInfo, R as Recording, a as RecordingSession, W as WebSocketRecording, g as generateSessionId, p as playwrightProxy, s as setProxyMode, b as startRecording, c as startReplay, d as stopProxy } from './index-CG-XcFDa.js';
+export { C as ControlRequest, M as Mode, P as PlaywrightTestInfo, R as Recording, a as RecordingSession, W as WebSocketRecording, g as generateSessionId, p as playwrightProxy, s as setProxyMode, b as startRecording, c as startReplay, d as stopProxy } from './index-CjM3evKb.js';
 import '@playwright/test';
 
 declare class ProxyServer {
@@ -12,9 +12,8 @@ declare class ProxyServer {
     private proxy;
     private currentSession;
     private recordingsDir;
-    private requestSequenceMap;
-    private replaySequenceMap;
     private recordingIdCounter;
+    private replaySessions;
     constructor(targets: string[], recordingsDir: string);
     init(): Promise<void>;
     listen(port: number): http.Server;
@@ -29,6 +28,19 @@ declare class ProxyServer {
     private getCorsHeaders;
     private addCorsHeaders;
     private getTarget;
+    /**
+     * Extract recording ID from request cookie
+     * Used for concurrent replay session routing
+     * @param req The incoming HTTP request
+     * @returns The recording ID from cookie, or null if not found
+     */
+    private getRecordingIdFromCookie;
+    /**
+     * 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
+     */
+    private getOrCreateReplaySession;
     private parseGetParams;
     private handleControlRequest;
     private clearModeTimeout;

package/dist/index.mjs

@@ -86,12 +86,10 @@ var ProxyServer = class {
   proxy;
   currentSession;
   recordingsDir;
-  requestSequenceMap;
-  // Track sequence per request key
-  replaySequenceMap;
-  // Track replay position per request key
   recordingIdCounter;
   // Unique ID for each recording entry
+  replaySessions;
+  // Track multiple concurrent replay sessions by recording ID
   constructor(targets, recordingsDir) {
     this.targets = targets;
     this.currentTargetIndex = 0;
@@ -102,11 +100,11 @@ var ProxyServer = class {
     this.modeTimeout = null;
     this.currentSession = null;
     this.recordingsDir = recordingsDir;
-    this.requestSequenceMap = /* @__PURE__ */ new Map();
-    this.replaySequenceMap = /* @__PURE__ */ new Map();
+    this.replaySessions = /* @__PURE__ */ new Map();
     this.proxy = httpProxy.createProxyServer({
       secure: false,
-      changeOrigin: true
+      changeOrigin: true,
+      ws: true
     });
     this.setupProxyEventHandlers();
   }
@@ -174,6 +172,43 @@ var ProxyServer = class {
     this.currentTargetIndex = (this.currentTargetIndex + 1) % this.targets.length;
     return target;
   }
+  /**
+   * Extract recording ID from request cookie
+   * Used for concurrent replay session routing
+   * @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;
+  }
+  /**
+   * 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()
+      };
+      this.replaySessions.set(recordingId, session);
+      console.log(
+        `[CONCURRENT REPLAY] Created new session for recording: ${recordingId}`
+      );
+    }
+    return session;
+  }
   parseGetParams(req) {
     const url = new URL(req.url || "", `http://${req.headers.host}`);
     const mode = url.searchParams.get("mode");
@@ -190,16 +225,25 @@ var ProxyServer = class {
       let data;
       if (req.method === "GET") {
         data = this.parseGetParams(req);
-      } else {
+      } else if (req.method === "POST") {
         const body = await readRequestBody(req);
-        console.log("MODE CHANGE (POST)", body);
+        console.log(`MODE CHANGE (${req.method})`, body);
         data = JSON.parse(body);
+      } else {
+        return;
       }
       const { mode, id, timeout: requestTimeout } = data;
       const timeout = requestTimeout ?? DEFAULT_TIMEOUT_MS;
       this.clearModeTimeout();
       await this.switchMode(mode, id);
       this.setupModeTimeout(timeout);
+      if (mode === Modes.replay && id) {
+        res.setHeader(
+          "Set-Cookie",
+          `proxy-recording-id=${encodeURIComponent(id)}; HttpOnly; Path=/; SameSite=Lax`
+        );
+        console.log(`[CONCURRENT REPLAY] Set cookie for recording: ${id}`);
+      }
       sendJsonResponse(res, HTTP_STATUS_OK, {
         success: true,
         mode: this.mode,
@@ -214,14 +258,12 @@ var ProxyServer = class {
     }
   }
   clearModeTimeout() {
-    if (this.modeTimeout) {
-      clearTimeout(this.modeTimeout);
-      this.modeTimeout = null;
-    }
+    clearTimeout(this.modeTimeout || 0);
+    this.modeTimeout = null;
   }
   async switchMode(mode, id) {
-    if (this.currentSession) {
-      console.log("Switching mode, saving current session first");
+    console.log(`Switching to ${mode.toUpperCase()} mode`);
+    if (this.currentSession && this.mode === Modes.record) {
       await this.saveCurrentSession(true);
       console.log("Session saved, continuing with mode switch");
     }
@@ -231,11 +273,17 @@ var ProxyServer = class {
         break;
       }
       case Modes.record: {
+        if (!id) {
+          throw new Error("Record ID is required");
+        }
         this.switchToRecordMode(id);
         break;
       }
       case Modes.replay: {
-        this.switchToReplayMode(id);
+        if (!id) {
+          throw new Error("Replay ID is required");
+        }
+        await this.switchToReplayMode(id);
         break;
       }
       default: {
@@ -252,36 +300,33 @@ var ProxyServer = class {
     console.log("Switched to transparent mode");
   }
   switchToRecordMode(id) {
-    if (!id) {
-      throw new Error("Record ID is required");
-    }
     this.mode = Modes.record;
     this.recordingId = id;
     this.replayId = null;
     this.currentSession = { id, recordings: [], websocketRecordings: [] };
-    this.requestSequenceMap.clear();
     console.log(`Switched to record mode with ID: ${id}`);
   }
-  switchToReplayMode(id) {
-    if (!id) {
-      throw new Error("Replay ID is required");
-    }
+  async switchToReplayMode(id) {
     this.mode = Modes.replay;
     this.replayId = id;
     this.recordingId = null;
     this.currentSession = null;
-    this.replaySequenceMap.clear();
+    const session = this.replaySessions.get(id);
+    if (session) {
+      session.servedRecordingIdsByKey.clear();
+      console.log(`Reset served recordings tracker for session: ${id}`);
+    } else {
+      this.getOrCreateReplaySession(id);
+    }
     console.log(`Switched to replay mode with ID: ${id}`);
   }
   setupModeTimeout(timeout) {
-    if (timeout && timeout > 0) {
-      this.modeTimeout = setTimeout(async () => {
-        console.log("Timeout reached, switching back to transparent mode");
-        await this.saveCurrentSession(true);
-        this.switchToTransparentMode();
-        this.modeTimeout = null;
-      }, timeout);
-    }
+    this.modeTimeout = setTimeout(async () => {
+      console.log("Timeout reached, switching back to transparent mode");
+      await this.saveCurrentSession(true);
+      this.switchToTransparentMode();
+      this.modeTimeout = null;
+    }, timeout);
   }
   async saveCurrentSession(filterIncomplete = false) {
     if (!this.currentSession) {
@@ -307,9 +352,6 @@ var ProxyServer = class {
       return;
     }
     const key = getReqID(req);
-    const currentSequence = this.requestSequenceMap.get(key) || 0;
-    const sequence = currentSequence;
-    this.requestSequenceMap.set(key, currentSequence + 1);
     const recordingId = this.recordingIdCounter++;
     req.__recordingId = recordingId;
     const record = {
@@ -321,13 +363,12 @@ var ProxyServer = class {
       },
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       key,
-      sequence,
       recordingId
     };
     this.currentSession.recordings.push(record);
     console.log(
       // eslint-disable-next-line sonarjs/no-nested-template-literals
-      `saveRequestRecordSync: Saved ${req.method} ${req.url} (key: ${key}, seq: ${sequence}, recordingId: ${recordingId}, body: ${body ? `${body.length} chars` : "null"}, total: ${this.currentSession.recordings.length}, sessionId: ${this.currentSession.id})`
+      `saveRequestRecordSync: Saved ${req.method} ${req.url} (key: ${key}, recordingId: ${recordingId}, body: ${body ? `${body.length} chars` : "null"}, total: ${this.currentSession.recordings.length}, sessionId: ${this.currentSession.id})`
     );
   }
   updateRequestBodySync(req, body) {
@@ -387,7 +428,7 @@ var ProxyServer = class {
         body: body || null
       };
       console.log(
-        `Recorded: ${req.method} ${req.url} (seq: ${record.sequence}, recordingId: ${recordingId})`
+        `Recorded: ${req.method} ${req.url} (recordingId: ${recordingId})`
       );
     });
   }
@@ -417,46 +458,77 @@ var ProxyServer = class {
       body: body || null
     };
     console.log(
-      `recordResponseData: Recorded response for ${req.method} ${req.url} (seq: ${record.sequence}, recordingId: ${recordingId})`
+      `recordResponseData: Recorded response for ${req.method} ${req.url} (recordingId: ${recordingId})`
     );
     return true;
   }
   async handleReplayRequest(req, res) {
+    const recordingId = this.getRecordingIdFromCookie(req) || this.replayId;
+    if (!recordingId) {
+      const corsHeaders = this.getCorsHeaders(req);
+      res.writeHead(HTTP_STATUS_BAD_REQUEST, {
+        "Content-Type": "application/json",
+        ...corsHeaders
+      });
+      res.end(JSON.stringify({ error: "No replay session active" }));
+      return;
+    }
     const key = getReqID(req);
-    const filePath = getRecordingPath(this.recordingsDir, this.replayId);
+    const filePath = getRecordingPath(this.recordingsDir, recordingId);
     try {
-      const session = await loadRecordingSession(filePath);
+      const sessionState = this.getOrCreateReplaySession(recordingId);
+      if (!sessionState.loadedSession) {
+        sessionState.loadedSession = await loadRecordingSession(filePath);
+        console.log(`[REPLAY] Loaded recording session: ${recordingId}`);
+      }
+      const session = sessionState.loadedSession;
+      if (!sessionState.servedRecordingIdsByKey.has(key)) {
+        sessionState.servedRecordingIdsByKey.set(key, /* @__PURE__ */ new Set());
+      }
+      const servedForThisKey = sessionState.servedRecordingIdsByKey.get(key);
       const host = req.headers.host || "unknown";
-      const recordsWithKey = session.recordings.filter((r) => r.key === key && r.response).toSorted((a, b) => a.sequence - b.sequence);
+      const recordsWithKey = session.recordings.filter((r) => r.key === key && r.response).toSorted((a, b) => a.recordingId - b.recordingId);
       if (recordsWithKey.length === 0) {
-        console.warn(
-          `No recording found for ${key} at ${req.method} ${host}${req.url}, returning default response`
+        const errorMsg = `No recording found for ${key} at ${req.method} ${host}${req.url}`;
+        console.error(`[REPLAY ERROR] ${errorMsg} (session: ${recordingId})`);
+        console.error(
+          `[REPLAY ERROR] This request was not made during recording - possible test non-determinism`
         );
-        const defaultResponse = req.method === "GET" ? {
-          data: [],
-          items: [],
-          results: [],
-          updated_at: "0001-01-01T00:00:00Z"
-        } : { success: true };
+        const errorResponse = {
+          error: "No recording found",
+          message: errorMsg,
+          key,
+          sessionId: recordingId
+        };
         const corsHeaders = this.getCorsHeaders(req);
-        res.writeHead(HTTP_STATUS_OK, {
+        res.writeHead(HTTP_STATUS_NOT_FOUND, {
           "Content-Type": "application/json",
           ...corsHeaders
         });
-        res.end(JSON.stringify(defaultResponse));
+        res.end(JSON.stringify(errorResponse));
         return;
       }
-      const usageCount = this.replaySequenceMap.get(key) || 0;
+      const requestCount = servedForThisKey.size + 1;
+      console.log(
+        `[REPLAY REQUEST #${requestCount}] ${req.method} ${req.url} (session: ${recordingId}, total: ${recordsWithKey.length}, served: ${servedForThisKey.size})`
+      );
       let record;
-      if (usageCount < recordsWithKey.length) {
-        record = recordsWithKey[usageCount];
-      } else {
+      for (const rec of recordsWithKey) {
+        if (!servedForThisKey.has(rec.recordingId)) {
+          record = rec;
+          break;
+        }
+      }
+      if (!record) {
+        console.log(
+          `[REPLAY WARNING] All ${recordsWithKey.length} recordings already served for ${key} (session: ${recordingId}), reusing last one`
+        );
         record = recordsWithKey[recordsWithKey.length - 1];
       }
+      servedForThisKey.add(record.recordingId);
       console.log(
-        `Replaying ${req.method} ${req.url} (usage: ${usageCount}, sequence: ${record.sequence}, body_len: ${record.response?.body?.length || 0})`
+        `[REPLAY SERVING] recordingId: ${record.recordingId}, session: ${recordingId}, body_len: ${record.response?.body?.length || 0}`
       );
-      this.replaySequenceMap.set(key, usageCount + 1);
       if (!record.response) {
         throw new Error(
           `No response recorded for this request: ${req.method} ${host}${req.url}`
@@ -522,6 +594,7 @@ var ProxyServer = class {
       this.proxy.web(req, res, { target });
     }
   }
+  // TODO: check if can handle streaming requests
   async bufferAndProxyRequest(req, res, target) {
     const chunks = [];
     req.on("data", (chunk) => {

package/dist/playwright/index.d.cts

@@ -1,3 +1,3 @@
 import '@playwright/test';
-export { P as PlaywrightTestInfo, g as generateSessionId, p as playwrightProxy, s as setProxyMode, b as startRecording, c as startReplay, d as stopProxy } from '../index-CG-XcFDa.cjs';
+export { P as PlaywrightTestInfo, g as generateSessionId, p as playwrightProxy, s as setProxyMode, b as startRecording, c as startReplay, d as stopProxy } from '../index-CjM3evKb.cjs';
 import 'node:http';

package/dist/playwright/index.d.ts

@@ -1,3 +1,3 @@
 import '@playwright/test';
-export { P as PlaywrightTestInfo, g as generateSessionId, p as playwrightProxy, s as setProxyMode, b as startRecording, c as startReplay, d as stopProxy } from '../index-CG-XcFDa.js';
+export { P as PlaywrightTestInfo, g as generateSessionId, p as playwrightProxy, s as setProxyMode, b as startRecording, c as startReplay, d as stopProxy } from '../index-CjM3evKb.js';
 import 'node:http';

package/dist/proxy.js

@@ -120,12 +120,10 @@ var ProxyServer = class {
   proxy;
   currentSession;
   recordingsDir;
-  requestSequenceMap;
-  // Track sequence per request key
-  replaySequenceMap;
-  // Track replay position per request key
   recordingIdCounter;
   // Unique ID for each recording entry
+  replaySessions;
+  // Track multiple concurrent replay sessions by recording ID
   constructor(targets2, recordingsDir2) {
     this.targets = targets2;
     this.currentTargetIndex = 0;
@@ -136,11 +134,11 @@ var ProxyServer = class {
     this.modeTimeout = null;
     this.currentSession = null;
     this.recordingsDir = recordingsDir2;
-    this.requestSequenceMap = /* @__PURE__ */ new Map();
-    this.replaySequenceMap = /* @__PURE__ */ new Map();
+    this.replaySessions = /* @__PURE__ */ new Map();
     this.proxy = httpProxy.createProxyServer({
       secure: false,
-      changeOrigin: true
+      changeOrigin: true,
+      ws: true
     });
     this.setupProxyEventHandlers();
   }
@@ -208,6 +206,43 @@ var ProxyServer = class {
     this.currentTargetIndex = (this.currentTargetIndex + 1) % this.targets.length;
     return target;
   }
+  /**
+   * Extract recording ID from request cookie
+   * Used for concurrent replay session routing
+   * @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;
+  }
+  /**
+   * 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()
+      };
+      this.replaySessions.set(recordingId, session);
+      console.log(
+        `[CONCURRENT REPLAY] Created new session for recording: ${recordingId}`
+      );
+    }
+    return session;
+  }
   parseGetParams(req) {
     const url = new URL(req.url || "", `http://${req.headers.host}`);
     const mode = url.searchParams.get("mode");
@@ -224,16 +259,25 @@ var ProxyServer = class {
       let data;
       if (req.method === "GET") {
         data = this.parseGetParams(req);
-      } else {
+      } else if (req.method === "POST") {
         const body = await readRequestBody(req);
-        console.log("MODE CHANGE (POST)", body);
+        console.log(`MODE CHANGE (${req.method})`, body);
         data = JSON.parse(body);
+      } else {
+        return;
       }
       const { mode, id, timeout: requestTimeout } = data;
       const timeout = requestTimeout ?? DEFAULT_TIMEOUT_MS;
       this.clearModeTimeout();
       await this.switchMode(mode, id);
       this.setupModeTimeout(timeout);
+      if (mode === Modes.replay && id) {
+        res.setHeader(
+          "Set-Cookie",
+          `proxy-recording-id=${encodeURIComponent(id)}; HttpOnly; Path=/; SameSite=Lax`
+        );
+        console.log(`[CONCURRENT REPLAY] Set cookie for recording: ${id}`);
+      }
       sendJsonResponse(res, HTTP_STATUS_OK, {
         success: true,
         mode: this.mode,
@@ -248,14 +292,12 @@ var ProxyServer = class {
     }
   }
   clearModeTimeout() {
-    if (this.modeTimeout) {
-      clearTimeout(this.modeTimeout);
-      this.modeTimeout = null;
-    }
+    clearTimeout(this.modeTimeout || 0);
+    this.modeTimeout = null;
   }
   async switchMode(mode, id) {
-    if (this.currentSession) {
-      console.log("Switching mode, saving current session first");
+    console.log(`Switching to ${mode.toUpperCase()} mode`);
+    if (this.currentSession && this.mode === Modes.record) {
       await this.saveCurrentSession(true);
       console.log("Session saved, continuing with mode switch");
     }
@@ -265,11 +307,17 @@ var ProxyServer = class {
         break;
       }
       case Modes.record: {
+        if (!id) {
+          throw new Error("Record ID is required");
+        }
         this.switchToRecordMode(id);
         break;
       }
       case Modes.replay: {
-        this.switchToReplayMode(id);
+        if (!id) {
+          throw new Error("Replay ID is required");
+        }
+        await this.switchToReplayMode(id);
         break;
       }
       default: {
@@ -286,36 +334,33 @@ var ProxyServer = class {
     console.log("Switched to transparent mode");
   }
   switchToRecordMode(id) {
-    if (!id) {
-      throw new Error("Record ID is required");
-    }
     this.mode = Modes.record;
     this.recordingId = id;
     this.replayId = null;
     this.currentSession = { id, recordings: [], websocketRecordings: [] };
-    this.requestSequenceMap.clear();
     console.log(`Switched to record mode with ID: ${id}`);
   }
-  switchToReplayMode(id) {
-    if (!id) {
-      throw new Error("Replay ID is required");
-    }
+  async switchToReplayMode(id) {
     this.mode = Modes.replay;
     this.replayId = id;
     this.recordingId = null;
     this.currentSession = null;
-    this.replaySequenceMap.clear();
+    const session = this.replaySessions.get(id);
+    if (session) {
+      session.servedRecordingIdsByKey.clear();
+      console.log(`Reset served recordings tracker for session: ${id}`);
+    } else {
+      this.getOrCreateReplaySession(id);
+    }
     console.log(`Switched to replay mode with ID: ${id}`);
   }
   setupModeTimeout(timeout) {
-    if (timeout && timeout > 0) {
-      this.modeTimeout = setTimeout(async () => {
-        console.log("Timeout reached, switching back to transparent mode");
-        await this.saveCurrentSession(true);
-        this.switchToTransparentMode();
-        this.modeTimeout = null;
-      }, timeout);
-    }
+    this.modeTimeout = setTimeout(async () => {
+      console.log("Timeout reached, switching back to transparent mode");
+      await this.saveCurrentSession(true);
+      this.switchToTransparentMode();
+      this.modeTimeout = null;
+    }, timeout);
   }
   async saveCurrentSession(filterIncomplete = false) {
     if (!this.currentSession) {
@@ -341,9 +386,6 @@ var ProxyServer = class {
       return;
     }
     const key = getReqID(req);
-    const currentSequence = this.requestSequenceMap.get(key) || 0;
-    const sequence = currentSequence;
-    this.requestSequenceMap.set(key, currentSequence + 1);
     const recordingId = this.recordingIdCounter++;
     req.__recordingId = recordingId;
     const record = {
@@ -355,13 +397,12 @@ var ProxyServer = class {
       },
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       key,
-      sequence,
       recordingId
     };
     this.currentSession.recordings.push(record);
     console.log(
       // eslint-disable-next-line sonarjs/no-nested-template-literals
-      `saveRequestRecordSync: Saved ${req.method} ${req.url} (key: ${key}, seq: ${sequence}, recordingId: ${recordingId}, body: ${body ? `${body.length} chars` : "null"}, total: ${this.currentSession.recordings.length}, sessionId: ${this.currentSession.id})`
+      `saveRequestRecordSync: Saved ${req.method} ${req.url} (key: ${key}, recordingId: ${recordingId}, body: ${body ? `${body.length} chars` : "null"}, total: ${this.currentSession.recordings.length}, sessionId: ${this.currentSession.id})`
     );
   }
   updateRequestBodySync(req, body) {
@@ -421,7 +462,7 @@ var ProxyServer = class {
         body: body || null
       };
       console.log(
-        `Recorded: ${req.method} ${req.url} (seq: ${record.sequence}, recordingId: ${recordingId})`
+        `Recorded: ${req.method} ${req.url} (recordingId: ${recordingId})`
       );
     });
   }
@@ -451,46 +492,77 @@ var ProxyServer = class {
       body: body || null
     };
     console.log(
-      `recordResponseData: Recorded response for ${req.method} ${req.url} (seq: ${record.sequence}, recordingId: ${recordingId})`
+      `recordResponseData: Recorded response for ${req.method} ${req.url} (recordingId: ${recordingId})`
     );
     return true;
   }
   async handleReplayRequest(req, res) {
+    const recordingId = this.getRecordingIdFromCookie(req) || this.replayId;
+    if (!recordingId) {
+      const corsHeaders = this.getCorsHeaders(req);
+      res.writeHead(HTTP_STATUS_BAD_REQUEST, {
+        "Content-Type": "application/json",
+        ...corsHeaders
+      });
+      res.end(JSON.stringify({ error: "No replay session active" }));
+      return;
+    }
     const key = getReqID(req);
-    const filePath = getRecordingPath(this.recordingsDir, this.replayId);
+    const filePath = getRecordingPath(this.recordingsDir, recordingId);
     try {
-      const session = await loadRecordingSession(filePath);
+      const sessionState = this.getOrCreateReplaySession(recordingId);
+      if (!sessionState.loadedSession) {
+        sessionState.loadedSession = await loadRecordingSession(filePath);
+        console.log(`[REPLAY] Loaded recording session: ${recordingId}`);
+      }
+      const session = sessionState.loadedSession;
+      if (!sessionState.servedRecordingIdsByKey.has(key)) {
+        sessionState.servedRecordingIdsByKey.set(key, /* @__PURE__ */ new Set());
+      }
+      const servedForThisKey = sessionState.servedRecordingIdsByKey.get(key);
       const host = req.headers.host || "unknown";
-      const recordsWithKey = session.recordings.filter((r) => r.key === key && r.response).toSorted((a, b) => a.sequence - b.sequence);
+      const recordsWithKey = session.recordings.filter((r) => r.key === key && r.response).toSorted((a, b) => a.recordingId - b.recordingId);
       if (recordsWithKey.length === 0) {
-        console.warn(
-          `No recording found for ${key} at ${req.method} ${host}${req.url}, returning default response`
+        const errorMsg = `No recording found for ${key} at ${req.method} ${host}${req.url}`;
+        console.error(`[REPLAY ERROR] ${errorMsg} (session: ${recordingId})`);
+        console.error(
+          `[REPLAY ERROR] This request was not made during recording - possible test non-determinism`
         );
-        const defaultResponse = req.method === "GET" ? {
-          data: [],
-          items: [],
-          results: [],
-          updated_at: "0001-01-01T00:00:00Z"
-        } : { success: true };
+        const errorResponse = {
+          error: "No recording found",
+          message: errorMsg,
+          key,
+          sessionId: recordingId
+        };
         const corsHeaders = this.getCorsHeaders(req);
-        res.writeHead(HTTP_STATUS_OK, {
+        res.writeHead(HTTP_STATUS_NOT_FOUND, {
           "Content-Type": "application/json",
           ...corsHeaders
         });
-        res.end(JSON.stringify(defaultResponse));
+        res.end(JSON.stringify(errorResponse));
         return;
       }
-      const usageCount = this.replaySequenceMap.get(key) || 0;
+      const requestCount = servedForThisKey.size + 1;
+      console.log(
+        `[REPLAY REQUEST #${requestCount}] ${req.method} ${req.url} (session: ${recordingId}, total: ${recordsWithKey.length}, served: ${servedForThisKey.size})`
+      );
       let record;
-      if (usageCount < recordsWithKey.length) {
-        record = recordsWithKey[usageCount];
-      } else {
+      for (const rec of recordsWithKey) {
+        if (!servedForThisKey.has(rec.recordingId)) {
+          record = rec;
+          break;
+        }
+      }
+      if (!record) {
+        console.log(
+          `[REPLAY WARNING] All ${recordsWithKey.length} recordings already served for ${key} (session: ${recordingId}), reusing last one`
+        );
         record = recordsWithKey[recordsWithKey.length - 1];
       }
+      servedForThisKey.add(record.recordingId);
       console.log(
-        `Replaying ${req.method} ${req.url} (usage: ${usageCount}, sequence: ${record.sequence}, body_len: ${record.response?.body?.length || 0})`
+        `[REPLAY SERVING] recordingId: ${record.recordingId}, session: ${recordingId}, body_len: ${record.response?.body?.length || 0}`
       );
-      this.replaySequenceMap.set(key, usageCount + 1);
       if (!record.response) {
         throw new Error(
           `No response recorded for this request: ${req.method} ${host}${req.url}`
@@ -556,6 +628,7 @@ var ProxyServer = class {
       this.proxy.web(req, res, { target });
     }
   }
+  // TODO: check if can handle streaming requests
   async bufferAndProxyRequest(req, res, target) {
     const chunks = [];
     req.on("data", (chunk) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "test-proxy-recorder",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "HTTP proxy server for recording and replaying network requests in testing. Works seamlessly with Playwright testing framework.",
   "type": "module",
   "main": "dist/index.mjs",