test-proxy-recorder 0.3.2 → 0.3.4

package/dist/index.cjs

@@ -131,8 +131,7 @@ function sendJsonResponse(res, statusCode, data) {
 
 // src/ProxyServer.ts
 var ProxyServer = class {
-  targets;
-  currentTargetIndex;
+  target;
   mode;
   recordingId;
   replayId;
@@ -148,9 +147,10 @@ var ProxyServer = class {
   // Track multiple concurrent replay sessions by recording ID
   recordingPromises;
   // Stack of promises that resolve to completed recordings
-  constructor(targets, recordingsDir) {
-    this.targets = targets;
-    this.currentTargetIndex = 0;
+  flushPromise;
+  // Promise for in-progress flush operation
+  constructor(target, recordingsDir) {
+    this.target = target;
     this.mode = Modes.transparent;
     this.recordingId = null;
     this.recordingIdCounter = 0;
@@ -161,6 +161,7 @@ var ProxyServer = class {
     this.recordingsDir = recordingsDir;
     this.replaySessions = /* @__PURE__ */ new Map();
     this.recordingPromises = [];
+    this.flushPromise = null;
     this.proxy = httpProxy__default.default.createProxyServer({
       secure: false,
       changeOrigin: true,
@@ -222,9 +223,7 @@ var ProxyServer = class {
     Object.assign(proxyRes.headers, corsHeaders);
   }
   getTarget() {
-    const target = this.targets[this.currentTargetIndex];
-    this.currentTargetIndex = (this.currentTargetIndex + 1) % this.targets.length;
-    return target;
+    return this.target;
   }
   /**
    * Extract recording ID from custom HTTP header
@@ -283,7 +282,8 @@ var ProxyServer = class {
         recordingId,
         servedRecordingIdsByKey: /* @__PURE__ */ new Map(),
         loadedSession: null,
-        lastAccessTime: Date.now()
+        lastAccessTime: Date.now(),
+        sortedRecordingsByKey: /* @__PURE__ */ new Map()
       };
       this.replaySessions.set(recordingId, session);
       console.log(
@@ -298,17 +298,14 @@ var ProxyServer = class {
    */
   async cleanupSession(sessionId) {
     if (this.replaySessions.has(sessionId)) {
-      console.log(`[CLEANUP] Removing replay session: ${sessionId}`);
       this.replaySessions.delete(sessionId);
     }
     if (this.recordingId === sessionId) {
-      console.log(`[CLEANUP] Saving and clearing active recording session: ${sessionId}`);
       await this.saveCurrentSession();
       this.currentSession = null;
       this.recordingId = null;
     }
     if (this.replayId === sessionId) {
-      console.log(`[CLEANUP] Clearing active replay session: ${sessionId}`);
       this.replayId = null;
     }
     console.log(`[CLEANUP] Session ${sessionId} cleaned up successfully`);
@@ -357,7 +354,9 @@ var ProxyServer = class {
         return;
       }
       if (!mode) {
-        throw new Error("Mode parameter is required when cleanup is not specified");
+        throw new Error(
+          "Mode parameter is required when cleanup is not specified"
+        );
       }
       const timeout = requestTimeout ?? DEFAULT_TIMEOUT_MS;
       this.clearModeTimeout();
@@ -440,12 +439,16 @@ var ProxyServer = class {
     this.replayId = id;
     this.recordingId = null;
     this.currentSession = null;
-    const session = this.replaySessions.get(id);
-    if (session) {
-      session.servedRecordingIdsByKey.clear();
-      console.log(`Reset served recordings tracker for session: ${id}`);
-    } else {
-      this.getOrCreateReplaySession(id);
+    const sessionState = this.getOrCreateReplaySession(id);
+    sessionState.servedRecordingIdsByKey.clear();
+    sessionState.sortedRecordingsByKey.clear();
+    const filePath = getRecordingPath(this.recordingsDir, id);
+    try {
+      sessionState.loadedSession = await loadRecordingSession(filePath);
+      console.log(`[REPLAY] Loaded recording session: ${id}`);
+    } catch (error) {
+      console.error(`[REPLAY ERROR] Failed to load session ${id}:`, error);
+      sessionState.loadedSession = null;
     }
     console.log(`Switched to replay mode with ID: ${id}`);
   }
@@ -459,21 +462,32 @@ var ProxyServer = class {
     }, timeout);
   }
   async flushPendingRecordings() {
+    if (this.flushPromise) {
+      await this.flushPromise;
+      return;
+    }
     if (this.recordingPromises.length === 0) {
       return;
     }
-    const results = await Promise.allSettled(this.recordingPromises);
-    if (this.currentSession) {
-      for (const result of results) {
-        if (result.status === "fulfilled" && result.value) {
-          this.currentSession.recordings.push(result.value);
+    this.flushPromise = (async () => {
+      try {
+        const results = await Promise.allSettled(this.recordingPromises);
+        if (this.currentSession) {
+          for (const result of results) {
+            if (result.status === "fulfilled" && result.value) {
+              this.currentSession.recordings.push(result.value);
+            }
+          }
+          console.log(
+            `Flushed ${results.length} recordings to session (total: ${this.currentSession.recordings.length})`
+          );
         }
+        this.recordingPromises = [];
+      } finally {
+        this.flushPromise = null;
       }
-      console.log(
-        `Flushed ${results.length} recordings to session (total: ${this.currentSession.recordings.length})`
-      );
-    }
-    this.recordingPromises = [];
+    })();
+    await this.flushPromise;
   }
   async saveCurrentSession() {
     if (!this.currentSession) {
@@ -523,20 +537,25 @@ var ProxyServer = class {
     );
     return recordingId;
   }
-  async ensureSessionLoaded(recordingId, filePath) {
-    const sessionState = this.getOrCreateReplaySession(recordingId);
-    if (!sessionState.loadedSession) {
-      sessionState.loadedSession = await loadRecordingSession(filePath);
-      console.log(`[REPLAY] Loaded recording session: ${recordingId}`);
-    }
-    return sessionState;
-  }
   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)) {
@@ -557,18 +576,17 @@ var ProxyServer = class {
     const key = getReqID(req);
     const filePath = getRecordingPath(this.recordingsDir, recordingId);
     try {
-      const sessionState = await this.ensureSessionLoaded(
-        recordingId,
-        filePath
-      );
-      const session = sessionState.loadedSession;
+      const sessionState = this.getOrCreateReplaySession(recordingId);
+      if (!sessionState.loadedSession) {
+        const error = new Error(
+          `Recording session file not found: ${filePath}`
+        );
+        error.code = "ENOENT";
+        throw error;
+      }
       const servedForThisKey = this.getServedTracker(sessionState, key);
       const host = req.headers.host || "unknown";
-      const recordsWithKey = 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;
-      });
+      const recordsWithKey = this.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})`);
@@ -779,7 +797,6 @@ var ProxyServer = class {
       })();
     });
     this.recordingPromises.push(recordingPromise);
-    await recordingPromise;
   }
   handleUpgrade(req, socket, head) {
     if (this.mode === Modes.replay) {
@@ -938,7 +955,7 @@ var ProxyServer = class {
   logServerStartup(port) {
     console.log(`Proxy server running on http://localhost:${port}`);
     console.log(`Mode: ${this.mode}`);
-    console.log(`Targets: ${this.targets.join(", ")}`);
+    console.log(`Target: ${this.target}`);
     console.log(
       `Control endpoint: http://localhost:${port}${CONTROL_ENDPOINT}`
     );
@@ -973,7 +990,6 @@ async function setProxyMode(mode, sessionId, timeout) {
       throw new Error(`Failed to set proxy mode: ${text}`);
     }
     await response.json();
-    console.log(`Proxy mode set to: ${mode} (session: ${sessionId})`);
   } catch (error) {
     console.error(`Error setting proxy mode:`, error);
     throw error;
@@ -997,9 +1013,8 @@ async function cleanupSession(sessionId) {
       throw new Error(`Failed to cleanup session: ${text}`);
     }
     await response.json();
-    console.log(`Session cleaned up: ${sessionId}`);
   } catch (error) {
-    console.error(`Error cleaning up session:`, error);
+    console.error(`Error cleaning up session: ${sessionId}`, error);
     throw error;
   }
 }
@@ -1072,9 +1087,6 @@ async function setupClientSideRecording(page, sessionId, mode, url) {
   const harFileName = sessionId.replaceAll("/", "__");
   const recordingsDir = await getRecordingsDir();
   const harPath = path2__default.default.join(recordingsDir, `${harFileName}.har`);
-  console.log(
-    `[Client-Side Recording] Setting up HAR for session: ${sessionId}, mode: ${mode}, path: ${harPath}`
-  );
   try {
     await page.routeFromHAR(harPath, {
       url,
@@ -1107,41 +1119,27 @@ var playwrightProxy = {
     await page.setExtraHTTPHeaders({
       [RECORDING_ID_HEADER]: sessionId
     });
-    console.log(`[Setup] Setting proxy mode: ${mode}, session: ${sessionId}`);
     await setProxyMode(mode, sessionId, timeout);
-    console.log(`[Setup] Proxy mode set successfully`);
     if (clientSideOptions?.url) {
-      console.log(`[Setup] Setting up client-side recording with pattern: ${clientSideOptions.url}`);
       await setupClientSideRecording(
         page,
         sessionId,
         mode,
         clientSideOptions.url
       );
-      console.log(`[Setup] Client-side recording setup complete`);
     }
     const proxyPort = process.env.TEST_PROXY_RECORDER_PORT || "8100";
     const proxyUrl = `localhost:${proxyPort}`;
-    console.log(`[Setup] Registering proxy route handler for: ${proxyUrl}`);
     await page.route(
       (url) => {
         const urlStr = url.toString();
         const matches = urlStr.includes(proxyUrl);
-        if (matches) {
-          console.log(`[Route Matcher] Matched proxy request: ${urlStr}`);
-        }
         return matches;
       },
       async (route) => {
         try {
-          const url = route.request().url();
-          const method = route.request().method();
           const headers = route.request().headers();
-          const hadHeader = !!headers[RECORDING_ID_HEADER];
           headers[RECORDING_ID_HEADER] = sessionId;
-          console.log(
-            `[Route Intercept] ${method} ${url} (had header: ${hadHeader}, adding session: ${sessionId})`
-          );
           await route.continue({ headers });
         } catch (error) {
           console.error(
@@ -1154,7 +1152,6 @@ var playwrightProxy = {
       { times: Infinity }
       // Ensure the handler applies to all matching requests
     );
-    console.log(`[Setup] Proxy route handler registered`);
     const context = page.context();
     const contextId = context._guid || "default";
     const handlerKey = `cleanup_${contextId}`;
@@ -1162,9 +1159,6 @@ var playwrightProxy = {
       globalThis[handlerKey] = true;
       context.on("close", async () => {
         try {
-          console.log(
-            `[Cleanup] Browser context closed, cleaning up session: ${sessionId}`
-          );
           await cleanupSession(sessionId);
         } catch (error) {
           console.warn(

package/dist/index.d.cts

@@ -4,8 +4,7 @@ export { C as ControlRequest, M as Mode, P as PlaywrightTestInfo, R as Recording
 import '@playwright/test';
 
 declare class ProxyServer {
-    private targets;
-    private currentTargetIndex;
+    private target;
     private mode;
     private recordingId;
     private replayId;
@@ -17,7 +16,8 @@ declare class ProxyServer {
     private sequenceCounterByKey;
     private replaySessions;
     private recordingPromises;
-    constructor(targets: string[], recordingsDir: string);
+    private flushPromise;
+    constructor(target: string, recordingsDir: string);
     init(): Promise<void>;
     listen(port: number): http.Server;
     private setupProxyEventHandlers;
@@ -73,8 +73,8 @@ declare class ProxyServer {
     private flushPendingRecordings;
     private saveCurrentSession;
     private getRecordingIdOrError;
-    private ensureSessionLoaded;
     private getServedTracker;
+    private getSortedRecordings;
     private selectReplayRecord;
     private handleReplayRequest;
     private handleReplayError;

package/dist/index.d.ts

@@ -4,8 +4,7 @@ export { C as ControlRequest, M as Mode, P as PlaywrightTestInfo, R as Recording
 import '@playwright/test';
 
 declare class ProxyServer {
-    private targets;
-    private currentTargetIndex;
+    private target;
     private mode;
     private recordingId;
     private replayId;
@@ -17,7 +16,8 @@ declare class ProxyServer {
     private sequenceCounterByKey;
     private replaySessions;
     private recordingPromises;
-    constructor(targets: string[], recordingsDir: string);
+    private flushPromise;
+    constructor(target: string, recordingsDir: string);
     init(): Promise<void>;
     listen(port: number): http.Server;
     private setupProxyEventHandlers;
@@ -73,8 +73,8 @@ declare class ProxyServer {
     private flushPendingRecordings;
     private saveCurrentSession;
     private getRecordingIdOrError;
-    private ensureSessionLoaded;
     private getServedTracker;
+    private getSortedRecordings;
     private selectReplayRecord;
     private handleReplayRequest;
     private handleReplayError;

package/dist/index.mjs

@@ -119,8 +119,7 @@ function sendJsonResponse(res, statusCode, data) {
 
 // src/ProxyServer.ts
 var ProxyServer = class {
-  targets;
-  currentTargetIndex;
+  target;
   mode;
   recordingId;
   replayId;
@@ -136,9 +135,10 @@ var ProxyServer = class {
   // Track multiple concurrent replay sessions by recording ID
   recordingPromises;
   // Stack of promises that resolve to completed recordings
-  constructor(targets, recordingsDir) {
-    this.targets = targets;
-    this.currentTargetIndex = 0;
+  flushPromise;
+  // Promise for in-progress flush operation
+  constructor(target, recordingsDir) {
+    this.target = target;
     this.mode = Modes.transparent;
     this.recordingId = null;
     this.recordingIdCounter = 0;
@@ -149,6 +149,7 @@ var ProxyServer = class {
     this.recordingsDir = recordingsDir;
     this.replaySessions = /* @__PURE__ */ new Map();
     this.recordingPromises = [];
+    this.flushPromise = null;
     this.proxy = httpProxy.createProxyServer({
       secure: false,
       changeOrigin: true,
@@ -210,9 +211,7 @@ var ProxyServer = class {
     Object.assign(proxyRes.headers, corsHeaders);
   }
   getTarget() {
-    const target = this.targets[this.currentTargetIndex];
-    this.currentTargetIndex = (this.currentTargetIndex + 1) % this.targets.length;
-    return target;
+    return this.target;
   }
   /**
    * Extract recording ID from custom HTTP header
@@ -271,7 +270,8 @@ var ProxyServer = class {
         recordingId,
         servedRecordingIdsByKey: /* @__PURE__ */ new Map(),
         loadedSession: null,
-        lastAccessTime: Date.now()
+        lastAccessTime: Date.now(),
+        sortedRecordingsByKey: /* @__PURE__ */ new Map()
       };
       this.replaySessions.set(recordingId, session);
       console.log(
@@ -286,17 +286,14 @@ var ProxyServer = class {
    */
   async cleanupSession(sessionId) {
     if (this.replaySessions.has(sessionId)) {
-      console.log(`[CLEANUP] Removing replay session: ${sessionId}`);
       this.replaySessions.delete(sessionId);
     }
     if (this.recordingId === sessionId) {
-      console.log(`[CLEANUP] Saving and clearing active recording session: ${sessionId}`);
       await this.saveCurrentSession();
       this.currentSession = null;
       this.recordingId = null;
     }
     if (this.replayId === sessionId) {
-      console.log(`[CLEANUP] Clearing active replay session: ${sessionId}`);
       this.replayId = null;
     }
     console.log(`[CLEANUP] Session ${sessionId} cleaned up successfully`);
@@ -345,7 +342,9 @@ var ProxyServer = class {
         return;
       }
       if (!mode) {
-        throw new Error("Mode parameter is required when cleanup is not specified");
+        throw new Error(
+          "Mode parameter is required when cleanup is not specified"
+        );
       }
       const timeout = requestTimeout ?? DEFAULT_TIMEOUT_MS;
       this.clearModeTimeout();
@@ -428,12 +427,16 @@ var ProxyServer = class {
     this.replayId = id;
     this.recordingId = null;
     this.currentSession = null;
-    const session = this.replaySessions.get(id);
-    if (session) {
-      session.servedRecordingIdsByKey.clear();
-      console.log(`Reset served recordings tracker for session: ${id}`);
-    } else {
-      this.getOrCreateReplaySession(id);
+    const sessionState = this.getOrCreateReplaySession(id);
+    sessionState.servedRecordingIdsByKey.clear();
+    sessionState.sortedRecordingsByKey.clear();
+    const filePath = getRecordingPath(this.recordingsDir, id);
+    try {
+      sessionState.loadedSession = await loadRecordingSession(filePath);
+      console.log(`[REPLAY] Loaded recording session: ${id}`);
+    } catch (error) {
+      console.error(`[REPLAY ERROR] Failed to load session ${id}:`, error);
+      sessionState.loadedSession = null;
     }
     console.log(`Switched to replay mode with ID: ${id}`);
   }
@@ -447,21 +450,32 @@ var ProxyServer = class {
     }, timeout);
   }
   async flushPendingRecordings() {
+    if (this.flushPromise) {
+      await this.flushPromise;
+      return;
+    }
     if (this.recordingPromises.length === 0) {
       return;
     }
-    const results = await Promise.allSettled(this.recordingPromises);
-    if (this.currentSession) {
-      for (const result of results) {
-        if (result.status === "fulfilled" && result.value) {
-          this.currentSession.recordings.push(result.value);
+    this.flushPromise = (async () => {
+      try {
+        const results = await Promise.allSettled(this.recordingPromises);
+        if (this.currentSession) {
+          for (const result of results) {
+            if (result.status === "fulfilled" && result.value) {
+              this.currentSession.recordings.push(result.value);
+            }
+          }
+          console.log(
+            `Flushed ${results.length} recordings to session (total: ${this.currentSession.recordings.length})`
+          );
         }
+        this.recordingPromises = [];
+      } finally {
+        this.flushPromise = null;
       }
-      console.log(
-        `Flushed ${results.length} recordings to session (total: ${this.currentSession.recordings.length})`
-      );
-    }
-    this.recordingPromises = [];
+    })();
+    await this.flushPromise;
   }
   async saveCurrentSession() {
     if (!this.currentSession) {
@@ -511,20 +525,25 @@ var ProxyServer = class {
     );
     return recordingId;
   }
-  async ensureSessionLoaded(recordingId, filePath) {
-    const sessionState = this.getOrCreateReplaySession(recordingId);
-    if (!sessionState.loadedSession) {
-      sessionState.loadedSession = await loadRecordingSession(filePath);
-      console.log(`[REPLAY] Loaded recording session: ${recordingId}`);
-    }
-    return sessionState;
-  }
   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)) {
@@ -545,18 +564,17 @@ var ProxyServer = class {
     const key = getReqID(req);
     const filePath = getRecordingPath(this.recordingsDir, recordingId);
     try {
-      const sessionState = await this.ensureSessionLoaded(
-        recordingId,
-        filePath
-      );
-      const session = sessionState.loadedSession;
+      const sessionState = this.getOrCreateReplaySession(recordingId);
+      if (!sessionState.loadedSession) {
+        const error = new Error(
+          `Recording session file not found: ${filePath}`
+        );
+        error.code = "ENOENT";
+        throw error;
+      }
       const servedForThisKey = this.getServedTracker(sessionState, key);
       const host = req.headers.host || "unknown";
-      const recordsWithKey = 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;
-      });
+      const recordsWithKey = this.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})`);
@@ -767,7 +785,6 @@ var ProxyServer = class {
       })();
     });
     this.recordingPromises.push(recordingPromise);
-    await recordingPromise;
   }
   handleUpgrade(req, socket, head) {
     if (this.mode === Modes.replay) {
@@ -926,7 +943,7 @@ var ProxyServer = class {
   logServerStartup(port) {
     console.log(`Proxy server running on http://localhost:${port}`);
     console.log(`Mode: ${this.mode}`);
-    console.log(`Targets: ${this.targets.join(", ")}`);
+    console.log(`Target: ${this.target}`);
     console.log(
       `Control endpoint: http://localhost:${port}${CONTROL_ENDPOINT}`
     );
@@ -961,7 +978,6 @@ async function setProxyMode(mode, sessionId, timeout) {
       throw new Error(`Failed to set proxy mode: ${text}`);
     }
     await response.json();
-    console.log(`Proxy mode set to: ${mode} (session: ${sessionId})`);
   } catch (error) {
     console.error(`Error setting proxy mode:`, error);
     throw error;
@@ -985,9 +1001,8 @@ async function cleanupSession(sessionId) {
       throw new Error(`Failed to cleanup session: ${text}`);
     }
     await response.json();
-    console.log(`Session cleaned up: ${sessionId}`);
   } catch (error) {
-    console.error(`Error cleaning up session:`, error);
+    console.error(`Error cleaning up session: ${sessionId}`, error);
     throw error;
   }
 }
@@ -1060,9 +1075,6 @@ async function setupClientSideRecording(page, sessionId, mode, url) {
   const harFileName = sessionId.replaceAll("/", "__");
   const recordingsDir = await getRecordingsDir();
   const harPath = path2.join(recordingsDir, `${harFileName}.har`);
-  console.log(
-    `[Client-Side Recording] Setting up HAR for session: ${sessionId}, mode: ${mode}, path: ${harPath}`
-  );
   try {
     await page.routeFromHAR(harPath, {
       url,
@@ -1095,41 +1107,27 @@ var playwrightProxy = {
     await page.setExtraHTTPHeaders({
       [RECORDING_ID_HEADER]: sessionId
     });
-    console.log(`[Setup] Setting proxy mode: ${mode}, session: ${sessionId}`);
     await setProxyMode(mode, sessionId, timeout);
-    console.log(`[Setup] Proxy mode set successfully`);
     if (clientSideOptions?.url) {
-      console.log(`[Setup] Setting up client-side recording with pattern: ${clientSideOptions.url}`);
       await setupClientSideRecording(
         page,
         sessionId,
         mode,
         clientSideOptions.url
       );
-      console.log(`[Setup] Client-side recording setup complete`);
     }
     const proxyPort = process.env.TEST_PROXY_RECORDER_PORT || "8100";
     const proxyUrl = `localhost:${proxyPort}`;
-    console.log(`[Setup] Registering proxy route handler for: ${proxyUrl}`);
     await page.route(
       (url) => {
         const urlStr = url.toString();
         const matches = urlStr.includes(proxyUrl);
-        if (matches) {
-          console.log(`[Route Matcher] Matched proxy request: ${urlStr}`);
-        }
         return matches;
       },
       async (route) => {
         try {
-          const url = route.request().url();
-          const method = route.request().method();
           const headers = route.request().headers();
-          const hadHeader = !!headers[RECORDING_ID_HEADER];
           headers[RECORDING_ID_HEADER] = sessionId;
-          console.log(
-            `[Route Intercept] ${method} ${url} (had header: ${hadHeader}, adding session: ${sessionId})`
-          );
           await route.continue({ headers });
         } catch (error) {
           console.error(
@@ -1142,7 +1140,6 @@ var playwrightProxy = {
       { times: Infinity }
       // Ensure the handler applies to all matching requests
     );
-    console.log(`[Setup] Proxy route handler registered`);
     const context = page.context();
     const contextId = context._guid || "default";
     const handlerKey = `cleanup_${contextId}`;
@@ -1150,9 +1147,6 @@ var playwrightProxy = {
       globalThis[handlerKey] = true;
       context.on("close", async () => {
         try {
-          console.log(
-            `[Cleanup] Browser context closed, cleaning up session: ${sessionId}`
-          );
           await cleanupSession(sessionId);
         } catch (error) {
           console.warn(

package/dist/playwright/index.cjs

@@ -46,7 +46,6 @@ async function setProxyMode(mode, sessionId, timeout) {
       throw new Error(`Failed to set proxy mode: ${text}`);
     }
     await response.json();
-    console.log(`Proxy mode set to: ${mode} (session: ${sessionId})`);
   } catch (error) {
     console.error(`Error setting proxy mode:`, error);
     throw error;
@@ -70,9 +69,8 @@ async function cleanupSession(sessionId) {
       throw new Error(`Failed to cleanup session: ${text}`);
     }
     await response.json();
-    console.log(`Session cleaned up: ${sessionId}`);
   } catch (error) {
-    console.error(`Error cleaning up session:`, error);
+    console.error(`Error cleaning up session: ${sessionId}`, error);
     throw error;
   }
 }
@@ -145,9 +143,6 @@ async function setupClientSideRecording(page, sessionId, mode, url) {
   const harFileName = sessionId.replaceAll("/", "__");
   const recordingsDir = await getRecordingsDir();
   const harPath = path__default.default.join(recordingsDir, `${harFileName}.har`);
-  console.log(
-    `[Client-Side Recording] Setting up HAR for session: ${sessionId}, mode: ${mode}, path: ${harPath}`
-  );
   try {
     await page.routeFromHAR(harPath, {
       url,
@@ -180,41 +175,27 @@ var playwrightProxy = {
     await page.setExtraHTTPHeaders({
       [RECORDING_ID_HEADER]: sessionId
     });
-    console.log(`[Setup] Setting proxy mode: ${mode}, session: ${sessionId}`);
     await setProxyMode(mode, sessionId, timeout);
-    console.log(`[Setup] Proxy mode set successfully`);
     if (clientSideOptions?.url) {
-      console.log(`[Setup] Setting up client-side recording with pattern: ${clientSideOptions.url}`);
       await setupClientSideRecording(
         page,
         sessionId,
         mode,
         clientSideOptions.url
       );
-      console.log(`[Setup] Client-side recording setup complete`);
     }
     const proxyPort = process.env.TEST_PROXY_RECORDER_PORT || "8100";
     const proxyUrl = `localhost:${proxyPort}`;
-    console.log(`[Setup] Registering proxy route handler for: ${proxyUrl}`);
     await page.route(
       (url) => {
         const urlStr = url.toString();
         const matches = urlStr.includes(proxyUrl);
-        if (matches) {
-          console.log(`[Route Matcher] Matched proxy request: ${urlStr}`);
-        }
         return matches;
       },
       async (route) => {
         try {
-          const url = route.request().url();
-          const method = route.request().method();
           const headers = route.request().headers();
-          const hadHeader = !!headers[RECORDING_ID_HEADER];
           headers[RECORDING_ID_HEADER] = sessionId;
-          console.log(
-            `[Route Intercept] ${method} ${url} (had header: ${hadHeader}, adding session: ${sessionId})`
-          );
           await route.continue({ headers });
         } catch (error) {
           console.error(
@@ -227,7 +208,6 @@ var playwrightProxy = {
       { times: Infinity }
       // Ensure the handler applies to all matching requests
     );
-    console.log(`[Setup] Proxy route handler registered`);
     const context = page.context();
     const contextId = context._guid || "default";
     const handlerKey = `cleanup_${contextId}`;
@@ -235,9 +215,6 @@ var playwrightProxy = {
       globalThis[handlerKey] = true;
       context.on("close", async () => {
         try {
-          console.log(
-            `[Cleanup] Browser context closed, cleaning up session: ${sessionId}`
-          );
           await cleanupSession(sessionId);
         } catch (error) {
           console.warn(

package/dist/playwright/index.mjs

@@ -40,7 +40,6 @@ async function setProxyMode(mode, sessionId, timeout) {
       throw new Error(`Failed to set proxy mode: ${text}`);
     }
     await response.json();
-    console.log(`Proxy mode set to: ${mode} (session: ${sessionId})`);
   } catch (error) {
     console.error(`Error setting proxy mode:`, error);
     throw error;
@@ -64,9 +63,8 @@ async function cleanupSession(sessionId) {
       throw new Error(`Failed to cleanup session: ${text}`);
     }
     await response.json();
-    console.log(`Session cleaned up: ${sessionId}`);
   } catch (error) {
-    console.error(`Error cleaning up session:`, error);
+    console.error(`Error cleaning up session: ${sessionId}`, error);
     throw error;
   }
 }
@@ -139,9 +137,6 @@ async function setupClientSideRecording(page, sessionId, mode, url) {
   const harFileName = sessionId.replaceAll("/", "__");
   const recordingsDir = await getRecordingsDir();
   const harPath = path.join(recordingsDir, `${harFileName}.har`);
-  console.log(
-    `[Client-Side Recording] Setting up HAR for session: ${sessionId}, mode: ${mode}, path: ${harPath}`
-  );
   try {
     await page.routeFromHAR(harPath, {
       url,
@@ -174,41 +169,27 @@ var playwrightProxy = {
     await page.setExtraHTTPHeaders({
       [RECORDING_ID_HEADER]: sessionId
     });
-    console.log(`[Setup] Setting proxy mode: ${mode}, session: ${sessionId}`);
     await setProxyMode(mode, sessionId, timeout);
-    console.log(`[Setup] Proxy mode set successfully`);
     if (clientSideOptions?.url) {
-      console.log(`[Setup] Setting up client-side recording with pattern: ${clientSideOptions.url}`);
       await setupClientSideRecording(
         page,
         sessionId,
         mode,
         clientSideOptions.url
       );
-      console.log(`[Setup] Client-side recording setup complete`);
     }
     const proxyPort = process.env.TEST_PROXY_RECORDER_PORT || "8100";
     const proxyUrl = `localhost:${proxyPort}`;
-    console.log(`[Setup] Registering proxy route handler for: ${proxyUrl}`);
     await page.route(
       (url) => {
         const urlStr = url.toString();
         const matches = urlStr.includes(proxyUrl);
-        if (matches) {
-          console.log(`[Route Matcher] Matched proxy request: ${urlStr}`);
-        }
         return matches;
       },
       async (route) => {
         try {
-          const url = route.request().url();
-          const method = route.request().method();
           const headers = route.request().headers();
-          const hadHeader = !!headers[RECORDING_ID_HEADER];
           headers[RECORDING_ID_HEADER] = sessionId;
-          console.log(
-            `[Route Intercept] ${method} ${url} (had header: ${hadHeader}, adding session: ${sessionId})`
-          );
           await route.continue({ headers });
         } catch (error) {
           console.error(
@@ -221,7 +202,6 @@ var playwrightProxy = {
       { times: Infinity }
       // Ensure the handler applies to all matching requests
     );
-    console.log(`[Setup] Proxy route handler registered`);
     const context = page.context();
     const contextId = context._guid || "default";
     const handlerKey = `cleanup_${contextId}`;
@@ -229,9 +209,6 @@ var playwrightProxy = {
       globalThis[handlerKey] = true;
       context.on("close", async () => {
         try {
-          console.log(
-            `[Cleanup] Browser context closed, cleaning up session: ${sessionId}`
-          );
           await cleanupSession(sessionId);
         } catch (error) {
           console.warn(

package/dist/proxy.js

@@ -16,8 +16,8 @@ function parseCliArgs() {
   program.name("dev-proxy").description(
     "Development proxy server with recording and replay capabilities"
   ).argument(
-    "<targets...>",
-    "Target API service URLs (e.g., http://localhost:3000)"
+    "<target>",
+    "Target API service URL (e.g., http://localhost:3000)"
   ).option(
     "-p, --port <number>",
     "Port number for the proxy server",
@@ -29,18 +29,18 @@ function parseCliArgs() {
   ).action(() => {
   });
   program.parse();
-  const targets2 = program.args;
+  const target2 = program.args[0];
   const options = program.opts();
   const port2 = Number.parseInt(options.port, 10);
   if (Number.isNaN(port2) || port2 < 1025 || port2 > 65535) {
     console.error("Error: Invalid port number. Must be between 1 and 65535");
     process.exit(1);
   }
-  if (targets2.length === 0) {
+  if (!target2) {
     program.help();
   }
   const recordingsDir2 = path.resolve(process.cwd(), options.dir);
-  return { targets: targets2, port: port2, recordingsDir: recordingsDir2 };
+  return { target: target2, port: port2, recordingsDir: recordingsDir2 };
 }
 
 // src/constants.ts
@@ -155,8 +155,7 @@ function sendJsonResponse(res, statusCode, data) {
 
 // src/ProxyServer.ts
 var ProxyServer = class {
-  targets;
-  currentTargetIndex;
+  target;
   mode;
   recordingId;
   replayId;
@@ -172,9 +171,10 @@ var ProxyServer = class {
   // Track multiple concurrent replay sessions by recording ID
   recordingPromises;
   // Stack of promises that resolve to completed recordings
-  constructor(targets2, recordingsDir2) {
-    this.targets = targets2;
-    this.currentTargetIndex = 0;
+  flushPromise;
+  // Promise for in-progress flush operation
+  constructor(target2, recordingsDir2) {
+    this.target = target2;
     this.mode = Modes.transparent;
     this.recordingId = null;
     this.recordingIdCounter = 0;
@@ -185,6 +185,7 @@ var ProxyServer = class {
     this.recordingsDir = recordingsDir2;
     this.replaySessions = /* @__PURE__ */ new Map();
     this.recordingPromises = [];
+    this.flushPromise = null;
     this.proxy = httpProxy.createProxyServer({
       secure: false,
       changeOrigin: true,
@@ -246,9 +247,7 @@ var ProxyServer = class {
     Object.assign(proxyRes.headers, corsHeaders);
   }
   getTarget() {
-    const target = this.targets[this.currentTargetIndex];
-    this.currentTargetIndex = (this.currentTargetIndex + 1) % this.targets.length;
-    return target;
+    return this.target;
   }
   /**
    * Extract recording ID from custom HTTP header
@@ -307,7 +306,8 @@ var ProxyServer = class {
         recordingId,
         servedRecordingIdsByKey: /* @__PURE__ */ new Map(),
         loadedSession: null,
-        lastAccessTime: Date.now()
+        lastAccessTime: Date.now(),
+        sortedRecordingsByKey: /* @__PURE__ */ new Map()
       };
       this.replaySessions.set(recordingId, session);
       console.log(
@@ -322,17 +322,14 @@ var ProxyServer = class {
    */
   async cleanupSession(sessionId) {
     if (this.replaySessions.has(sessionId)) {
-      console.log(`[CLEANUP] Removing replay session: ${sessionId}`);
       this.replaySessions.delete(sessionId);
     }
     if (this.recordingId === sessionId) {
-      console.log(`[CLEANUP] Saving and clearing active recording session: ${sessionId}`);
       await this.saveCurrentSession();
       this.currentSession = null;
       this.recordingId = null;
     }
     if (this.replayId === sessionId) {
-      console.log(`[CLEANUP] Clearing active replay session: ${sessionId}`);
       this.replayId = null;
     }
     console.log(`[CLEANUP] Session ${sessionId} cleaned up successfully`);
@@ -381,7 +378,9 @@ var ProxyServer = class {
         return;
       }
       if (!mode) {
-        throw new Error("Mode parameter is required when cleanup is not specified");
+        throw new Error(
+          "Mode parameter is required when cleanup is not specified"
+        );
       }
       const timeout = requestTimeout ?? DEFAULT_TIMEOUT_MS;
       this.clearModeTimeout();
@@ -464,12 +463,16 @@ var ProxyServer = class {
     this.replayId = id;
     this.recordingId = null;
     this.currentSession = null;
-    const session = this.replaySessions.get(id);
-    if (session) {
-      session.servedRecordingIdsByKey.clear();
-      console.log(`Reset served recordings tracker for session: ${id}`);
-    } else {
-      this.getOrCreateReplaySession(id);
+    const sessionState = this.getOrCreateReplaySession(id);
+    sessionState.servedRecordingIdsByKey.clear();
+    sessionState.sortedRecordingsByKey.clear();
+    const filePath = getRecordingPath(this.recordingsDir, id);
+    try {
+      sessionState.loadedSession = await loadRecordingSession(filePath);
+      console.log(`[REPLAY] Loaded recording session: ${id}`);
+    } catch (error) {
+      console.error(`[REPLAY ERROR] Failed to load session ${id}:`, error);
+      sessionState.loadedSession = null;
     }
     console.log(`Switched to replay mode with ID: ${id}`);
   }
@@ -483,21 +486,32 @@ var ProxyServer = class {
     }, timeout);
   }
   async flushPendingRecordings() {
+    if (this.flushPromise) {
+      await this.flushPromise;
+      return;
+    }
     if (this.recordingPromises.length === 0) {
       return;
     }
-    const results = await Promise.allSettled(this.recordingPromises);
-    if (this.currentSession) {
-      for (const result of results) {
-        if (result.status === "fulfilled" && result.value) {
-          this.currentSession.recordings.push(result.value);
+    this.flushPromise = (async () => {
+      try {
+        const results = await Promise.allSettled(this.recordingPromises);
+        if (this.currentSession) {
+          for (const result of results) {
+            if (result.status === "fulfilled" && result.value) {
+              this.currentSession.recordings.push(result.value);
+            }
+          }
+          console.log(
+            `Flushed ${results.length} recordings to session (total: ${this.currentSession.recordings.length})`
+          );
         }
+        this.recordingPromises = [];
+      } finally {
+        this.flushPromise = null;
       }
-      console.log(
-        `Flushed ${results.length} recordings to session (total: ${this.currentSession.recordings.length})`
-      );
-    }
-    this.recordingPromises = [];
+    })();
+    await this.flushPromise;
   }
   async saveCurrentSession() {
     if (!this.currentSession) {
@@ -547,20 +561,25 @@ var ProxyServer = class {
     );
     return recordingId;
   }
-  async ensureSessionLoaded(recordingId, filePath) {
-    const sessionState = this.getOrCreateReplaySession(recordingId);
-    if (!sessionState.loadedSession) {
-      sessionState.loadedSession = await loadRecordingSession(filePath);
-      console.log(`[REPLAY] Loaded recording session: ${recordingId}`);
-    }
-    return sessionState;
-  }
   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)) {
@@ -581,18 +600,17 @@ var ProxyServer = class {
     const key = getReqID(req);
     const filePath = getRecordingPath(this.recordingsDir, recordingId);
     try {
-      const sessionState = await this.ensureSessionLoaded(
-        recordingId,
-        filePath
-      );
-      const session = sessionState.loadedSession;
+      const sessionState = this.getOrCreateReplaySession(recordingId);
+      if (!sessionState.loadedSession) {
+        const error = new Error(
+          `Recording session file not found: ${filePath}`
+        );
+        error.code = "ENOENT";
+        throw error;
+      }
       const servedForThisKey = this.getServedTracker(sessionState, key);
       const host = req.headers.host || "unknown";
-      const recordsWithKey = 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;
-      });
+      const recordsWithKey = this.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})`);
@@ -683,16 +701,16 @@ var ProxyServer = class {
     res.end();
   }
   async handleProxyRequest(req, res) {
-    const target = this.getTarget();
-    console.log(`[${this.mode}] ${req.method} ${req.url} -> ${target}`);
+    const target2 = this.getTarget();
+    console.log(`[${this.mode}] ${req.method} ${req.url} -> ${target2}`);
     if (this.mode === Modes.record) {
-      await this.recordAndProxyRequest(req, res, target);
+      await this.recordAndProxyRequest(req, res, target2);
     } else {
-      this.proxy.web(req, res, { target });
+      this.proxy.web(req, res, { target: target2 });
     }
   }
   // Note: streaming requests are buffered before proxying; streaming passthrough is not yet implemented
-  async recordAndProxyRequest(req, res, target) {
+  async recordAndProxyRequest(req, res, target2) {
     if (!this.currentSession) {
       return;
     }
@@ -720,7 +738,7 @@ var ProxyServer = class {
             console.error("Error buffering request:", error);
           }
           const requestBody = Buffer.concat(chunks).toString("utf8");
-          const targetUrl = new URL(target);
+          const targetUrl = new URL(target2);
           const isHttps = targetUrl.protocol === "https:";
           const requestModule = isHttps ? https : http;
           const defaultPort = isHttps ? 443 : 80;
@@ -803,22 +821,21 @@ var ProxyServer = class {
       })();
     });
     this.recordingPromises.push(recordingPromise);
-    await recordingPromise;
   }
   handleUpgrade(req, socket, head) {
     if (this.mode === Modes.replay) {
       this.handleReplayWebSocket(req, socket);
       return;
     }
-    const target = this.getTarget();
-    console.log(`[${this.mode}] WebSocket upgrade ${req.url} -> ${target}`);
+    const target2 = this.getTarget();
+    console.log(`[${this.mode}] WebSocket upgrade ${req.url} -> ${target2}`);
     if (this.mode === Modes.record) {
-      this.handleRecordWebSocket(req, socket, head, target);
+      this.handleRecordWebSocket(req, socket, head, target2);
     } else {
-      this.proxy.ws(req, socket, head, { target });
+      this.proxy.ws(req, socket, head, { target: target2 });
     }
   }
-  handleRecordWebSocket(req, clientSocket, head, target) {
+  handleRecordWebSocket(req, clientSocket, head, target2) {
     const url = req.url || "/";
     const key = `WS_${url.replaceAll("/", "_")}`;
     const wsRecording = {
@@ -830,7 +847,7 @@ var ProxyServer = class {
     if (this.currentSession) {
       this.currentSession.websocketRecordings.push(wsRecording);
     }
-    const backendWsUrl = `${target.replace("http", "ws")}${url}`;
+    const backendWsUrl = `${target2.replace("http", "ws")}${url}`;
     const backendWs = new WebSocket(backendWsUrl);
     const wss = new WebSocketServer({ noServer: true });
     backendWs.on("open", () => {
@@ -962,7 +979,7 @@ var ProxyServer = class {
   logServerStartup(port2) {
     console.log(`Proxy server running on http://localhost:${port2}`);
     console.log(`Mode: ${this.mode}`);
-    console.log(`Targets: ${this.targets.join(", ")}`);
+    console.log(`Target: ${this.target}`);
     console.log(
       `Control endpoint: http://localhost:${port2}${CONTROL_ENDPOINT}`
     );
@@ -970,8 +987,8 @@ var ProxyServer = class {
 };
 
 // src/proxy.ts
-var { targets, port, recordingsDir } = parseCliArgs();
-var proxy = new ProxyServer(targets, recordingsDir);
+var { target, port, recordingsDir } = parseCliArgs();
+var proxy = new ProxyServer(target, recordingsDir);
 await proxy.init();
 proxy.listen(port);
 console.log(`Recordings will be saved to: ${recordingsDir}`);

package/package.json

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