test-proxy-recorder 0.1.3 → 0.1.4

package/dist/{index-DfFpm8mB.d.cts → index-De4mgziH.d.cts}

@@ -28,6 +28,7 @@ interface Recording {
     response?: RecordedResponse;
     timestamp: string;
     key: string;
+    sequence: number;
 }
 interface WebSocketMessage {
     direction: 'client-to-server' | 'server-to-client';
@@ -53,7 +54,7 @@ type PlaywrightTestInfo = Pick<TestInfo, 'title'>;
  * @param sessionId - Unique identifier for the session
  * @param timeout - Optional timeout in milliseconds
  */
-declare function setProxyMode(mode: Mode, sessionId: string, timeout?: number): Promise<void>;
+declare function setProxyMode(mode: Mode, sessionId?: string, timeout?: number): Promise<void>;
 /**
  * Generate a session ID from test info
  * @param testInfo - Playwright test info object

package/dist/{index-DfFpm8mB.d.ts → index-De4mgziH.d.ts}

@@ -28,6 +28,7 @@ interface Recording {
     response?: RecordedResponse;
     timestamp: string;
     key: string;
+    sequence: number;
 }
 interface WebSocketMessage {
     direction: 'client-to-server' | 'server-to-client';
@@ -53,7 +54,7 @@ type PlaywrightTestInfo = Pick<TestInfo, 'title'>;
  * @param sessionId - Unique identifier for the session
  * @param timeout - Optional timeout in milliseconds
  */
-declare function setProxyMode(mode: Mode, sessionId: string, timeout?: number): Promise<void>;
+declare function setProxyMode(mode: Mode, sessionId?: string, timeout?: number): Promise<void>;
 /**
  * Generate a session ID from test info
  * @param testInfo - Playwright test info object

package/dist/index.cjs

@@ -2,6 +2,7 @@
 
 var fs = require('fs/promises');
 var http = require('http');
+var https = require('https');
 var httpProxy = require('http-proxy');
 var ws = require('ws');
 var path = require('path');
@@ -11,6 +12,7 @@ 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 httpProxy__default = /*#__PURE__*/_interopDefault(httpProxy);
 var path__default = /*#__PURE__*/_interopDefault(path);
 var filenamify__default = /*#__PURE__*/_interopDefault(filenamify);
@@ -93,6 +95,10 @@ var ProxyServer = class {
   proxy;
   currentSession;
   recordingsDir;
+  requestSequenceMap;
+  // Track sequence per request key
+  replaySequenceMap;
+  // Track replay position per request key
   constructor(targets, recordingsDir) {
     this.targets = targets;
     this.currentTargetIndex = 0;
@@ -102,6 +108,8 @@ var ProxyServer = class {
     this.modeTimeout = null;
     this.currentSession = null;
     this.recordingsDir = recordingsDir;
+    this.requestSequenceMap = /* @__PURE__ */ new Map();
+    this.replaySequenceMap = /* @__PURE__ */ new Map();
     this.proxy = httpProxy__default.default.createProxyServer({
       secure: false,
       changeOrigin: true
@@ -140,10 +148,19 @@ var ProxyServer = class {
     res.end(JSON.stringify({ error: "Proxy error", message: err.message }));
   }
   handleProxyResponse(proxyRes, req) {
+    this.addCorsHeaders(proxyRes, req);
     if (this.mode === Modes.record && this.recordingId) {
       this.recordResponse(req, proxyRes);
     }
   }
+  addCorsHeaders(proxyRes, req) {
+    const origin = req.headers.origin;
+    proxyRes.headers["access-control-allow-origin"] = origin || "*";
+    proxyRes.headers["access-control-allow-credentials"] = "true";
+    proxyRes.headers["access-control-allow-headers"] = req.headers["access-control-request-headers"] || "Origin, X-Requested-With, Content-Type, Accept, Authorization";
+    proxyRes.headers["access-control-allow-methods"] = "GET, POST, PUT, DELETE, PATCH, OPTIONS";
+    proxyRes.headers["access-control-expose-headers"] = "*";
+  }
   getTarget() {
     const target = this.targets[this.currentTargetIndex];
     this.currentTargetIndex = (this.currentTargetIndex + 1) % this.targets.length;
@@ -218,6 +235,7 @@ var ProxyServer = class {
     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) {
@@ -228,6 +246,7 @@ var ProxyServer = class {
     this.replayId = id;
     this.recordingId = null;
     this.currentSession = null;
+    this.replaySequenceMap.clear();
     console.log(`Switched to replay mode with ID: ${id}`);
   }
   setupModeTimeout(timeout) {
@@ -259,6 +278,8 @@ var ProxyServer = class {
       return;
     }
     const key = getReqID(req);
+    const currentSequence = this.requestSequenceMap.get(key) || 0;
+    this.requestSequenceMap.set(key, currentSequence + 1);
     const record = {
       request: {
         method: req.method,
@@ -267,7 +288,8 @@ var ProxyServer = class {
         body: body || null
       },
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      key
+      key,
+      sequence: currentSequence
     };
     this.currentSession.recordings.push(record);
   }
@@ -276,7 +298,9 @@ var ProxyServer = class {
       return;
     }
     const key = getReqID(req);
-    const record = this.currentSession.recordings.find((r) => r.key === key);
+    const record = this.currentSession.recordings.findLast(
+      (r) => r.key === key && !r.response
+    );
     if (!record) {
       console.error("Request record not found for response:", key);
       return;
@@ -301,17 +325,31 @@ var ProxyServer = class {
     const filePath = getRecordingPath(this.recordingsDir, this.replayId);
     try {
       const session = await loadRecordingSession(filePath);
-      const record = session.recordings.find((r) => r.key === key);
+      const currentSequence = this.replaySequenceMap.get(key) || 0;
+      const record = session.recordings.find(
+        (r) => r.key === key && r.sequence === currentSequence
+      );
       if (!record) {
-        throw new Error(`No recording found for ${key}`);
+        throw new Error(
+          `No recording found for ${key} with sequence ${currentSequence}`
+        );
       }
       if (!record.response) {
         throw new Error("No response recorded for this request");
       }
+      this.replaySequenceMap.set(key, currentSequence + 1);
       const { statusCode, headers, body } = record.response;
-      res.writeHead(statusCode, headers);
+      const origin = req.headers.origin;
+      const responseHeaders = {
+        ...headers,
+        "access-control-allow-origin": origin || "*",
+        "access-control-allow-credentials": "true"
+      };
+      res.writeHead(statusCode, responseHeaders);
       res.end(body);
-      console.log(`Replayed: ${req.method} ${req.url}`);
+      console.log(
+        `Replayed: ${req.method} ${req.url} (sequence: ${currentSequence})`
+      );
     } catch (error) {
       this.handleReplayError(res, error, key, filePath);
     }
@@ -327,6 +365,9 @@ var ProxyServer = class {
     });
   }
   async handleRequest(req, res) {
+    if (req.method === "OPTIONS") {
+      return this.handleCorsPreflightRequest(req, res);
+    }
     if (req.url === CONTROL_ENDPOINT) {
       return this.handleControlRequest(req, res);
     }
@@ -335,23 +376,63 @@ var ProxyServer = class {
     }
     await this.handleProxyRequest(req, res);
   }
+  handleCorsPreflightRequest(req, res) {
+    const origin = req.headers.origin;
+    res.writeHead(HTTP_STATUS_OK, {
+      "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",
+      "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+      "Access-Control-Max-Age": "86400"
+      // 24 hours
+    });
+    res.end();
+  }
   async handleProxyRequest(req, res) {
     const target = this.getTarget();
     console.log(`[${this.mode}] ${req.method} ${req.url} -> ${target}`);
     if (this.mode === Modes.record) {
-      await this.bufferRequestForRecord(req);
+      await this.bufferAndProxyRequest(req, res, target);
+    } else {
+      this.proxy.web(req, res, { target });
     }
-    this.proxy.web(req, res, { target });
   }
-  async bufferRequestForRecord(req) {
+  async bufferAndProxyRequest(req, res, target) {
     const chunks = [];
     req.on("data", (chunk) => {
       chunks.push(chunk);
     });
-    req.on("end", async () => {
-      const body = Buffer.concat(chunks).toString("utf8");
-      await this.saveRequestRecord(req, body);
+    await new Promise((resolve) => {
+      req.on("end", () => resolve());
     });
+    const body = Buffer.concat(chunks).toString("utf8");
+    await this.saveRequestRecord(req, body);
+    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);
+        this.recordResponse(req, proxyRes);
+        res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
+        proxyRes.pipe(res);
+      }
+    );
+    proxyReq.on("error", (err) => {
+      this.handleProxyError(err, req, res);
+    });
+    if (chunks.length > 0) {
+      proxyReq.write(Buffer.concat(chunks));
+    }
+    proxyReq.end();
   }
   handleUpgrade(req, socket, head) {
     if (this.mode === Modes.replay) {

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-DfFpm8mB.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-De4mgziH.cjs';
 import '@playwright/test';
 
 declare class ProxyServer {
@@ -12,12 +12,15 @@ declare class ProxyServer {
     private proxy;
     private currentSession;
     private recordingsDir;
+    private requestSequenceMap;
+    private replaySequenceMap;
     constructor(targets: string[], recordingsDir: string);
     init(): Promise<void>;
     listen(port: number): http.Server;
     private setupProxyEventHandlers;
     private handleProxyError;
     private handleProxyResponse;
+    private addCorsHeaders;
     private getTarget;
     private handleControlRequest;
     private clearModeTimeout;
@@ -32,8 +35,9 @@ declare class ProxyServer {
     private handleReplayRequest;
     private handleReplayError;
     private handleRequest;
+    private handleCorsPreflightRequest;
     private handleProxyRequest;
-    private bufferRequestForRecord;
+    private bufferAndProxyRequest;
     private handleUpgrade;
     private handleRecordWebSocket;
     private handleReplayWebSocket;

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-DfFpm8mB.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-De4mgziH.js';
 import '@playwright/test';
 
 declare class ProxyServer {
@@ -12,12 +12,15 @@ declare class ProxyServer {
     private proxy;
     private currentSession;
     private recordingsDir;
+    private requestSequenceMap;
+    private replaySequenceMap;
     constructor(targets: string[], recordingsDir: string);
     init(): Promise<void>;
     listen(port: number): http.Server;
     private setupProxyEventHandlers;
     private handleProxyError;
     private handleProxyResponse;
+    private addCorsHeaders;
     private getTarget;
     private handleControlRequest;
     private clearModeTimeout;
@@ -32,8 +35,9 @@ declare class ProxyServer {
     private handleReplayRequest;
     private handleReplayError;
     private handleRequest;
+    private handleCorsPreflightRequest;
     private handleProxyRequest;
-    private bufferRequestForRecord;
+    private bufferAndProxyRequest;
     private handleUpgrade;
     private handleRecordWebSocket;
     private handleReplayWebSocket;

package/dist/index.mjs

@@ -1,5 +1,6 @@
 import fs from 'fs/promises';
 import http from 'http';
+import https from 'https';
 import httpProxy from 'http-proxy';
 import { WebSocket, WebSocketServer } from 'ws';
 import path from 'path';
@@ -83,6 +84,10 @@ var ProxyServer = class {
   proxy;
   currentSession;
   recordingsDir;
+  requestSequenceMap;
+  // Track sequence per request key
+  replaySequenceMap;
+  // Track replay position per request key
   constructor(targets, recordingsDir) {
     this.targets = targets;
     this.currentTargetIndex = 0;
@@ -92,6 +97,8 @@ var ProxyServer = class {
     this.modeTimeout = null;
     this.currentSession = null;
     this.recordingsDir = recordingsDir;
+    this.requestSequenceMap = /* @__PURE__ */ new Map();
+    this.replaySequenceMap = /* @__PURE__ */ new Map();
     this.proxy = httpProxy.createProxyServer({
       secure: false,
       changeOrigin: true
@@ -130,10 +137,19 @@ var ProxyServer = class {
     res.end(JSON.stringify({ error: "Proxy error", message: err.message }));
   }
   handleProxyResponse(proxyRes, req) {
+    this.addCorsHeaders(proxyRes, req);
     if (this.mode === Modes.record && this.recordingId) {
       this.recordResponse(req, proxyRes);
     }
   }
+  addCorsHeaders(proxyRes, req) {
+    const origin = req.headers.origin;
+    proxyRes.headers["access-control-allow-origin"] = origin || "*";
+    proxyRes.headers["access-control-allow-credentials"] = "true";
+    proxyRes.headers["access-control-allow-headers"] = req.headers["access-control-request-headers"] || "Origin, X-Requested-With, Content-Type, Accept, Authorization";
+    proxyRes.headers["access-control-allow-methods"] = "GET, POST, PUT, DELETE, PATCH, OPTIONS";
+    proxyRes.headers["access-control-expose-headers"] = "*";
+  }
   getTarget() {
     const target = this.targets[this.currentTargetIndex];
     this.currentTargetIndex = (this.currentTargetIndex + 1) % this.targets.length;
@@ -208,6 +224,7 @@ var ProxyServer = class {
     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) {
@@ -218,6 +235,7 @@ var ProxyServer = class {
     this.replayId = id;
     this.recordingId = null;
     this.currentSession = null;
+    this.replaySequenceMap.clear();
     console.log(`Switched to replay mode with ID: ${id}`);
   }
   setupModeTimeout(timeout) {
@@ -249,6 +267,8 @@ var ProxyServer = class {
       return;
     }
     const key = getReqID(req);
+    const currentSequence = this.requestSequenceMap.get(key) || 0;
+    this.requestSequenceMap.set(key, currentSequence + 1);
     const record = {
       request: {
         method: req.method,
@@ -257,7 +277,8 @@ var ProxyServer = class {
         body: body || null
       },
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      key
+      key,
+      sequence: currentSequence
     };
     this.currentSession.recordings.push(record);
   }
@@ -266,7 +287,9 @@ var ProxyServer = class {
       return;
     }
     const key = getReqID(req);
-    const record = this.currentSession.recordings.find((r) => r.key === key);
+    const record = this.currentSession.recordings.findLast(
+      (r) => r.key === key && !r.response
+    );
     if (!record) {
       console.error("Request record not found for response:", key);
       return;
@@ -291,17 +314,31 @@ var ProxyServer = class {
     const filePath = getRecordingPath(this.recordingsDir, this.replayId);
     try {
       const session = await loadRecordingSession(filePath);
-      const record = session.recordings.find((r) => r.key === key);
+      const currentSequence = this.replaySequenceMap.get(key) || 0;
+      const record = session.recordings.find(
+        (r) => r.key === key && r.sequence === currentSequence
+      );
       if (!record) {
-        throw new Error(`No recording found for ${key}`);
+        throw new Error(
+          `No recording found for ${key} with sequence ${currentSequence}`
+        );
       }
       if (!record.response) {
         throw new Error("No response recorded for this request");
       }
+      this.replaySequenceMap.set(key, currentSequence + 1);
       const { statusCode, headers, body } = record.response;
-      res.writeHead(statusCode, headers);
+      const origin = req.headers.origin;
+      const responseHeaders = {
+        ...headers,
+        "access-control-allow-origin": origin || "*",
+        "access-control-allow-credentials": "true"
+      };
+      res.writeHead(statusCode, responseHeaders);
       res.end(body);
-      console.log(`Replayed: ${req.method} ${req.url}`);
+      console.log(
+        `Replayed: ${req.method} ${req.url} (sequence: ${currentSequence})`
+      );
     } catch (error) {
       this.handleReplayError(res, error, key, filePath);
     }
@@ -317,6 +354,9 @@ var ProxyServer = class {
     });
   }
   async handleRequest(req, res) {
+    if (req.method === "OPTIONS") {
+      return this.handleCorsPreflightRequest(req, res);
+    }
     if (req.url === CONTROL_ENDPOINT) {
       return this.handleControlRequest(req, res);
     }
@@ -325,23 +365,63 @@ var ProxyServer = class {
     }
     await this.handleProxyRequest(req, res);
   }
+  handleCorsPreflightRequest(req, res) {
+    const origin = req.headers.origin;
+    res.writeHead(HTTP_STATUS_OK, {
+      "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",
+      "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+      "Access-Control-Max-Age": "86400"
+      // 24 hours
+    });
+    res.end();
+  }
   async handleProxyRequest(req, res) {
     const target = this.getTarget();
     console.log(`[${this.mode}] ${req.method} ${req.url} -> ${target}`);
     if (this.mode === Modes.record) {
-      await this.bufferRequestForRecord(req);
+      await this.bufferAndProxyRequest(req, res, target);
+    } else {
+      this.proxy.web(req, res, { target });
     }
-    this.proxy.web(req, res, { target });
   }
-  async bufferRequestForRecord(req) {
+  async bufferAndProxyRequest(req, res, target) {
     const chunks = [];
     req.on("data", (chunk) => {
       chunks.push(chunk);
     });
-    req.on("end", async () => {
-      const body = Buffer.concat(chunks).toString("utf8");
-      await this.saveRequestRecord(req, body);
+    await new Promise((resolve) => {
+      req.on("end", () => resolve());
     });
+    const body = Buffer.concat(chunks).toString("utf8");
+    await this.saveRequestRecord(req, body);
+    const targetUrl = new URL(target);
+    const isHttps = targetUrl.protocol === "https:";
+    const requestModule = isHttps ? https : http;
+    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);
+        this.recordResponse(req, proxyRes);
+        res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
+        proxyRes.pipe(res);
+      }
+    );
+    proxyReq.on("error", (err) => {
+      this.handleProxyError(err, req, res);
+    });
+    if (chunks.length > 0) {
+      proxyReq.write(Buffer.concat(chunks));
+    }
+    proxyReq.end();
   }
   handleUpgrade(req, socket, head) {
     if (this.mode === Modes.replay) {

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-DfFpm8mB.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-De4mgziH.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-DfFpm8mB.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-De4mgziH.js';
 import 'node:http';

package/dist/proxy.js

@@ -2,6 +2,7 @@ import path from 'path';
 import { Command } from 'commander';
 import fs from 'fs/promises';
 import http from 'http';
+import https from 'https';
 import httpProxy from 'http-proxy';
 import { WebSocket, WebSocketServer } from 'ws';
 import filenamify from 'filenamify';
@@ -117,6 +118,10 @@ var ProxyServer = class {
   proxy;
   currentSession;
   recordingsDir;
+  requestSequenceMap;
+  // Track sequence per request key
+  replaySequenceMap;
+  // Track replay position per request key
   constructor(targets2, recordingsDir2) {
     this.targets = targets2;
     this.currentTargetIndex = 0;
@@ -126,6 +131,8 @@ var ProxyServer = class {
     this.modeTimeout = null;
     this.currentSession = null;
     this.recordingsDir = recordingsDir2;
+    this.requestSequenceMap = /* @__PURE__ */ new Map();
+    this.replaySequenceMap = /* @__PURE__ */ new Map();
     this.proxy = httpProxy.createProxyServer({
       secure: false,
       changeOrigin: true
@@ -164,10 +171,19 @@ var ProxyServer = class {
     res.end(JSON.stringify({ error: "Proxy error", message: err.message }));
   }
   handleProxyResponse(proxyRes, req) {
+    this.addCorsHeaders(proxyRes, req);
     if (this.mode === Modes.record && this.recordingId) {
       this.recordResponse(req, proxyRes);
     }
   }
+  addCorsHeaders(proxyRes, req) {
+    const origin = req.headers.origin;
+    proxyRes.headers["access-control-allow-origin"] = origin || "*";
+    proxyRes.headers["access-control-allow-credentials"] = "true";
+    proxyRes.headers["access-control-allow-headers"] = req.headers["access-control-request-headers"] || "Origin, X-Requested-With, Content-Type, Accept, Authorization";
+    proxyRes.headers["access-control-allow-methods"] = "GET, POST, PUT, DELETE, PATCH, OPTIONS";
+    proxyRes.headers["access-control-expose-headers"] = "*";
+  }
   getTarget() {
     const target = this.targets[this.currentTargetIndex];
     this.currentTargetIndex = (this.currentTargetIndex + 1) % this.targets.length;
@@ -242,6 +258,7 @@ var ProxyServer = class {
     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) {
@@ -252,6 +269,7 @@ var ProxyServer = class {
     this.replayId = id;
     this.recordingId = null;
     this.currentSession = null;
+    this.replaySequenceMap.clear();
     console.log(`Switched to replay mode with ID: ${id}`);
   }
   setupModeTimeout(timeout) {
@@ -283,6 +301,8 @@ var ProxyServer = class {
       return;
     }
     const key = getReqID(req);
+    const currentSequence = this.requestSequenceMap.get(key) || 0;
+    this.requestSequenceMap.set(key, currentSequence + 1);
     const record = {
       request: {
         method: req.method,
@@ -291,7 +311,8 @@ var ProxyServer = class {
         body: body || null
       },
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      key
+      key,
+      sequence: currentSequence
     };
     this.currentSession.recordings.push(record);
   }
@@ -300,7 +321,9 @@ var ProxyServer = class {
       return;
     }
     const key = getReqID(req);
-    const record = this.currentSession.recordings.find((r) => r.key === key);
+    const record = this.currentSession.recordings.findLast(
+      (r) => r.key === key && !r.response
+    );
     if (!record) {
       console.error("Request record not found for response:", key);
       return;
@@ -325,17 +348,31 @@ var ProxyServer = class {
     const filePath = getRecordingPath(this.recordingsDir, this.replayId);
     try {
       const session = await loadRecordingSession(filePath);
-      const record = session.recordings.find((r) => r.key === key);
+      const currentSequence = this.replaySequenceMap.get(key) || 0;
+      const record = session.recordings.find(
+        (r) => r.key === key && r.sequence === currentSequence
+      );
       if (!record) {
-        throw new Error(`No recording found for ${key}`);
+        throw new Error(
+          `No recording found for ${key} with sequence ${currentSequence}`
+        );
       }
       if (!record.response) {
         throw new Error("No response recorded for this request");
       }
+      this.replaySequenceMap.set(key, currentSequence + 1);
       const { statusCode, headers, body } = record.response;
-      res.writeHead(statusCode, headers);
+      const origin = req.headers.origin;
+      const responseHeaders = {
+        ...headers,
+        "access-control-allow-origin": origin || "*",
+        "access-control-allow-credentials": "true"
+      };
+      res.writeHead(statusCode, responseHeaders);
       res.end(body);
-      console.log(`Replayed: ${req.method} ${req.url}`);
+      console.log(
+        `Replayed: ${req.method} ${req.url} (sequence: ${currentSequence})`
+      );
     } catch (error) {
       this.handleReplayError(res, error, key, filePath);
     }
@@ -351,6 +388,9 @@ var ProxyServer = class {
     });
   }
   async handleRequest(req, res) {
+    if (req.method === "OPTIONS") {
+      return this.handleCorsPreflightRequest(req, res);
+    }
     if (req.url === CONTROL_ENDPOINT) {
       return this.handleControlRequest(req, res);
     }
@@ -359,23 +399,63 @@ var ProxyServer = class {
     }
     await this.handleProxyRequest(req, res);
   }
+  handleCorsPreflightRequest(req, res) {
+    const origin = req.headers.origin;
+    res.writeHead(HTTP_STATUS_OK, {
+      "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",
+      "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+      "Access-Control-Max-Age": "86400"
+      // 24 hours
+    });
+    res.end();
+  }
   async handleProxyRequest(req, res) {
     const target = this.getTarget();
     console.log(`[${this.mode}] ${req.method} ${req.url} -> ${target}`);
     if (this.mode === Modes.record) {
-      await this.bufferRequestForRecord(req);
+      await this.bufferAndProxyRequest(req, res, target);
+    } else {
+      this.proxy.web(req, res, { target });
     }
-    this.proxy.web(req, res, { target });
   }
-  async bufferRequestForRecord(req) {
+  async bufferAndProxyRequest(req, res, target) {
     const chunks = [];
     req.on("data", (chunk) => {
       chunks.push(chunk);
     });
-    req.on("end", async () => {
-      const body = Buffer.concat(chunks).toString("utf8");
-      await this.saveRequestRecord(req, body);
+    await new Promise((resolve) => {
+      req.on("end", () => resolve());
     });
+    const body = Buffer.concat(chunks).toString("utf8");
+    await this.saveRequestRecord(req, body);
+    const targetUrl = new URL(target);
+    const isHttps = targetUrl.protocol === "https:";
+    const requestModule = isHttps ? https : http;
+    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);
+        this.recordResponse(req, proxyRes);
+        res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
+        proxyRes.pipe(res);
+      }
+    );
+    proxyReq.on("error", (err) => {
+      this.handleProxyError(err, req, res);
+    });
+    if (chunks.length > 0) {
+      proxyReq.write(Buffer.concat(chunks));
+    }
+    proxyReq.end();
   }
   handleUpgrade(req, socket, head) {
     if (this.mode === Modes.replay) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "test-proxy-recorder",
-  "version": "0.1.3",
+  "version": "0.1.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",