test-proxy-recorder 0.1.10 → 0.2.0

package/README.md

@@ -99,10 +99,10 @@ This marks recording files as binary, which causes long mock files to be collaps
 Create `e2e/global-teardown.ts`:
 
 ```typescript
-import { setProxyMode } from 'test-proxy-recorder';
+import { playwrightProxy } from 'test-proxy-recorder';
 
 async function globalTeardown() {
-  await setProxyMode('transparent').catch(err => { console.error(err) });
+  await playwrightProxy.teardown();
 }
 
 export default globalTeardown;
@@ -128,15 +128,17 @@ Create `e2e/example.spec.ts`:
 import { test, expect } from '@playwright/test';
 import { playwrightProxy } from 'test-proxy-recorder';
 
+// Setup afterEach hook to reset proxy after each test
+test.afterEach(async ({ page: _page }, testInfo) => {
+  await playwrightProxy.after(testInfo);
+});
+
 test('example test with proxy', async ({ page }, testInfo) => {
   // Set proxy mode: 'record' to capture, 'replay' to use recordings
   await playwrightProxy.before(testInfo, 'replay');
 
   await page.goto('/');
   await expect(page.getByText('Welcome')).toBeVisible();
-
-  // Always cleanup after test
-  await playwrightProxy.after(testInfo);
 });
 ```
 
@@ -186,27 +188,38 @@ test-proxy-recorder http://localhost:8000 http://localhost:9000 --port 8100
 
 ### Basic Test Structure
 
-Every test using the proxy should follow this pattern:
+Every test file using the proxy should follow this pattern:
 
 ```typescript
 import { test } from '@playwright/test';
 import { playwrightProxy } from 'test-proxy-recorder';
 
+// Setup afterEach hook once per test file
+test.afterEach(async ({ page: _page }, testInfo) => {
+  await playwrightProxy.after(testInfo);
+});
+
 test('test name', async ({ page }, testInfo) => {
   // 1. Set mode BEFORE test actions
   await playwrightProxy.before(testInfo, 'replay');
 
   // 2. Test code
   await page.goto('/page');
-
-  // 3. Reset mode AFTER test completes
-  await playwrightProxy.after(testInfo);
+  // Test assertions...
 });
 ```
 
 ### Recording vs Replay
 
 ```typescript
+import { test } from '@playwright/test';
+import { playwrightProxy } from 'test-proxy-recorder';
+
+// Setup afterEach hook to automatically cleanup after each test
+test.afterEach(async ({ page: _page }, testInfo) => {
+  await playwrightProxy.after(testInfo);
+});
+
 // Recording mode - captures API responses
 test('create user', async ({ page }, testInfo) => {
   await playwrightProxy.before(testInfo, 'record');
@@ -214,8 +227,6 @@ test('create user', async ({ page }, testInfo) => {
   await page.goto('/users/new');
   await page.fill('[name="username"]', 'testuser');
   await page.click('button[type="submit"]');
-
-  await playwrightProxy.after(testInfo);
 });
 
 // Replay mode - uses recorded responses
@@ -225,8 +236,6 @@ test('create user', async ({ page }, testInfo) => {
   await page.goto('/users/new');
   await page.fill('[name="username"]', 'testuser');
   await page.click('button[type="submit"]');
-
-  await playwrightProxy.after(testInfo);
 });
 ```
 
@@ -244,10 +253,10 @@ Recording files are auto-generated from test names:
 Create `e2e/global-teardown.ts`:
 
 ```typescript
-import { setProxyMode } from 'test-proxy-recorder';
+import { playwrightProxy } from 'test-proxy-recorder';
 
 async function globalTeardown() {
-  await setProxyMode('transparent').catch(err => { console.error(err) });
+  await playwrightProxy.teardown();
 }
 
 export default globalTeardown;
@@ -412,8 +421,13 @@ const playwrightProxy = {
     timeout?: number
   ): Promise<void>;
 
-  // Reset to transparent mode after test
+  // Reset replay session and return to transparent mode after test
+  // Resets sequence counters to ensure next replay starts fresh
   async after(testInfo: TestInfo): Promise<void>;
+
+  // Global teardown - switches proxy to transparent mode
+  // Use in Playwright's globalTeardown configuration
+  async teardown(): Promise<void>;
 };
 
 // Direct mode control
@@ -438,6 +452,8 @@ async function setProxyMode(
 }
 ```
 
+**Note**: Switching to replay mode automatically resets session counters (clears served recordings tracker), allowing replay from the beginning.
+
 **Response**:
 
 ```typescript

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

@@ -28,6 +28,7 @@ interface Recording {
     response?: RecordedResponse;
     timestamp: string;
     key: string;
+    sequence?: number;
     recordingId: number;
 }
 interface WebSocketMessage {
@@ -88,13 +89,20 @@ declare const playwrightProxy: {
      * Setup before test - sets the proxy mode
      * @param testInfo - Playwright test info object
      * @param mode - The proxy mode to use for this test
+     * @param timeout - Optional timeout in milliseconds
      */
-    before(testInfo: PlaywrightTestInfo, mode: Mode): Promise<void>;
+    before(testInfo: PlaywrightTestInfo, mode: Mode, timeout?: number): Promise<void>;
     /**
-     * Cleanup after test - returns to transparent mode
+     * Cleanup after test - resets replay session by re-entering replay mode
+     * switchToReplayMode automatically clears sequence counters
      * @param testInfo - Playwright test info object
      */
     after(testInfo: PlaywrightTestInfo): Promise<void>;
+    /**
+     * Global teardown - switches proxy to transparent mode
+     * Use this in Playwright's globalTeardown to ensure clean state
+     */
+    teardown(): Promise<void>;
 };
 
 export { type ControlRequest as C, type Mode as M, type PlaywrightTestInfo as P, type Recording as R, type WebSocketRecording as W, type RecordingSession as a, startRecording as b, startReplay as c, stopProxy as d, generateSessionId as g, playwrightProxy as p, setProxyMode as s };

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

@@ -28,6 +28,7 @@ interface Recording {
     response?: RecordedResponse;
     timestamp: string;
     key: string;
+    sequence?: number;
     recordingId: number;
 }
 interface WebSocketMessage {
@@ -88,13 +89,20 @@ declare const playwrightProxy: {
      * Setup before test - sets the proxy mode
      * @param testInfo - Playwright test info object
      * @param mode - The proxy mode to use for this test
+     * @param timeout - Optional timeout in milliseconds
      */
-    before(testInfo: PlaywrightTestInfo, mode: Mode): Promise<void>;
+    before(testInfo: PlaywrightTestInfo, mode: Mode, timeout?: number): Promise<void>;
     /**
-     * Cleanup after test - returns to transparent mode
+     * Cleanup after test - resets replay session by re-entering replay mode
+     * switchToReplayMode automatically clears sequence counters
      * @param testInfo - Playwright test info object
      */
     after(testInfo: PlaywrightTestInfo): Promise<void>;
+    /**
+     * Global teardown - switches proxy to transparent mode
+     * Use this in Playwright's globalTeardown to ensure clean state
+     */
+    teardown(): Promise<void>;
 };
 
 export { type ControlRequest as C, type Mode as M, type PlaywrightTestInfo as P, type Recording as R, type WebSocketRecording as W, type RecordingSession as a, startRecording as b, startReplay as c, stopProxy as d, generateSessionId as g, playwrightProxy as p, setProxyMode as s };

package/dist/index.cjs

@@ -5,9 +5,9 @@ var http = require('http');
 var https = require('https');
 var httpProxy = require('http-proxy');
 var ws = require('ws');
-var path = require('path');
 var crypto = require('crypto');
-var filenamify = require('filenamify');
+var path = require('path');
+var filenamify2 = require('filenamify');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -15,9 +15,9 @@ 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 crypto__default = /*#__PURE__*/_interopDefault(crypto);
-var filenamify__default = /*#__PURE__*/_interopDefault(filenamify);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var filenamify2__default = /*#__PURE__*/_interopDefault(filenamify2);
 
 // src/ProxyServer.ts
 
@@ -36,23 +36,53 @@ var Modes = {
   replay: "replay"
 };
 var JSON_INDENT_SPACES = 2;
+var EXTENSION = ".mock.json";
+var MAX_FILENAME_LENGTH = 255 - EXTENSION.length;
+var HASH_LENGTH = 8;
+function generateHash(str) {
+  return crypto__default.default.createHash("shake256", { outputLength: HASH_LENGTH / 2 }).update(str).digest("hex");
+}
 function getRecordingPath(recordingsDir, id) {
-  return path__default.default.join(recordingsDir, `${id}.mock.json`);
+  let processedId = id.replaceAll("/", "__");
+  if (processedId.length > MAX_FILENAME_LENGTH) {
+    const hash = generateHash(id);
+    const maxBaseLength = MAX_FILENAME_LENGTH - HASH_LENGTH - 1;
+    processedId = `${processedId.slice(0, maxBaseLength)}_${hash}`;
+  }
+  const sanitizedId = filenamify2__default.default(processedId, {
+    replacement: "_",
+    maxLength: 255
+    // Set explicit max to prevent filenamify's default truncation
+  });
+  return path__default.default.join(recordingsDir, `${sanitizedId}${EXTENSION}`);
 }
 async function loadRecordingSession(filePath) {
   const fileContent = await fs__default.default.readFile(filePath, "utf8");
   return JSON.parse(fileContent);
 }
+function processRecordings(recordings) {
+  const keySequenceMap = /* @__PURE__ */ new Map();
+  return recordings.map((recording) => {
+    const key = recording.key;
+    const currentSeq = keySequenceMap.get(key) || 0;
+    keySequenceMap.set(key, currentSeq + 1);
+    return { ...recording, sequence: currentSeq };
+  });
+}
 async function saveRecordingSession(recordingsDir, session) {
   const filePath = getRecordingPath(recordingsDir, session.id);
-  const dirPath = path__default.default.dirname(filePath);
-  await fs__default.default.mkdir(dirPath, { recursive: true });
+  await fs__default.default.mkdir(recordingsDir, { recursive: true });
+  const processedRecordings = processRecordings(session.recordings);
+  const processedSession = {
+    ...session,
+    recordings: processedRecordings
+  };
   await fs__default.default.writeFile(
     filePath,
-    JSON.stringify(session, null, JSON_INDENT_SPACES)
+    JSON.stringify(processedSession, null, JSON_INDENT_SPACES)
   );
   console.log(
-    `Saved ${session.recordings.length} HTTP recordings and ${session.websocketRecordings?.length || 0} WebSocket recordings to ${filePath}`
+    `Saved ${processedRecordings.length} HTTP recordings and ${session.websocketRecordings?.length || 0} WebSocket recordings to ${filePath}`
   );
 }
 function getReqID(req) {
@@ -60,10 +90,10 @@ function getReqID(req) {
   const pathname = urlParts[0];
   const query = urlParts[1] || "";
   const pathPart = pathname === "/" ? "root" : pathname.slice(1);
-  const normalizedPath = filenamify__default.default(pathPart, { replacement: "_" });
+  const normalizedPath = filenamify2__default.default(pathPart, { replacement: "_" });
   const queryHash = generateQueryHash(query);
   const filename = `${req.method}_${normalizedPath}${queryHash}.json`;
-  return filenamify__default.default(filename, { replacement: "_" });
+  return filenamify2__default.default(filename, { replacement: "_" });
 }
 function generateQueryHash(query) {
   if (!query) {
@@ -499,7 +529,11 @@ var ProxyServer = class {
       }
       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.recordingId - b.recordingId);
+      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;
+      });
       if (recordsWithKey.length === 0) {
         const errorMsg = `No recording found for ${key} at ${req.method} ${host}${req.url}`;
         console.error(`[REPLAY ERROR] ${errorMsg} (session: ${recordingId})`);
@@ -522,7 +556,7 @@ var ProxyServer = class {
       }
       const requestCount = servedForThisKey.size + 1;
       console.log(
-        `[REPLAY REQUEST #${requestCount}] ${req.method} ${req.url} (session: ${recordingId}, total: ${recordsWithKey.length}, served: ${servedForThisKey.size})`
+        `[replay request #${requestCount}] ${req.method} ${req.url} (session: ${recordingId}, total: ${recordsWithKey.length}, served: ${servedForThisKey.size})`
       );
       let record;
       for (const rec of recordsWithKey) {
@@ -539,7 +573,7 @@ var ProxyServer = class {
       }
       servedForThisKey.add(record.recordingId);
       console.log(
-        `[REPLAY SERVING] recordingId: ${record.recordingId}, session: ${recordingId}, body_len: ${record.response?.body?.length || 0}`
+        `[replay serving] recordingId: ${record.recordingId}, session: ${recordingId}, body_len: ${record.response?.body?.length || 0}`
       );
       if (!record.response) {
         throw new Error(
@@ -923,19 +957,27 @@ var playwrightProxy = {
    * Setup before test - sets the proxy mode
    * @param testInfo - Playwright test info object
    * @param mode - The proxy mode to use for this test
+   * @param timeout - Optional timeout in milliseconds
    */
-  async before(testInfo, mode) {
+  async before(testInfo, mode, timeout) {
     const sessionId = generateSessionId(testInfo);
-    console.log("Proxy setup:", { mode, sessionId });
-    await setProxyMode(mode, sessionId);
+    await setProxyMode(mode, sessionId, timeout);
   },
   /**
-   * Cleanup after test - returns to transparent mode
+   * Cleanup after test - resets replay session by re-entering replay mode
+   * switchToReplayMode automatically clears sequence counters
    * @param testInfo - Playwright test info object
    */
   async after(testInfo) {
     const sessionId = generateSessionId(testInfo);
-    await setProxyMode(Modes.transparent, sessionId);
+    await setProxyMode(Modes.replay, sessionId);
+  },
+  /**
+   * Global teardown - switches proxy to transparent mode
+   * Use this in Playwright's globalTeardown to ensure clean state
+   */
+  async teardown() {
+    await setProxyMode(Modes.transparent);
   }
 };
 

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-CjM3evKb.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-nmNRt1WE.cjs';
 import '@playwright/test';
 
 declare class ProxyServer {

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-CjM3evKb.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-nmNRt1WE.js';
 import '@playwright/test';
 
 declare class ProxyServer {

package/dist/index.mjs

@@ -3,9 +3,9 @@ import http from 'http';
 import https from 'https';
 import httpProxy from 'http-proxy';
 import { WebSocket, WebSocketServer } from 'ws';
-import path from 'path';
 import crypto from 'crypto';
-import filenamify from 'filenamify';
+import path from 'path';
+import filenamify2 from 'filenamify';
 
 // src/ProxyServer.ts
 
@@ -24,23 +24,53 @@ var Modes = {
   replay: "replay"
 };
 var JSON_INDENT_SPACES = 2;
+var EXTENSION = ".mock.json";
+var MAX_FILENAME_LENGTH = 255 - EXTENSION.length;
+var HASH_LENGTH = 8;
+function generateHash(str) {
+  return crypto.createHash("shake256", { outputLength: HASH_LENGTH / 2 }).update(str).digest("hex");
+}
 function getRecordingPath(recordingsDir, id) {
-  return path.join(recordingsDir, `${id}.mock.json`);
+  let processedId = id.replaceAll("/", "__");
+  if (processedId.length > MAX_FILENAME_LENGTH) {
+    const hash = generateHash(id);
+    const maxBaseLength = MAX_FILENAME_LENGTH - HASH_LENGTH - 1;
+    processedId = `${processedId.slice(0, maxBaseLength)}_${hash}`;
+  }
+  const sanitizedId = filenamify2(processedId, {
+    replacement: "_",
+    maxLength: 255
+    // Set explicit max to prevent filenamify's default truncation
+  });
+  return path.join(recordingsDir, `${sanitizedId}${EXTENSION}`);
 }
 async function loadRecordingSession(filePath) {
   const fileContent = await fs.readFile(filePath, "utf8");
   return JSON.parse(fileContent);
 }
+function processRecordings(recordings) {
+  const keySequenceMap = /* @__PURE__ */ new Map();
+  return recordings.map((recording) => {
+    const key = recording.key;
+    const currentSeq = keySequenceMap.get(key) || 0;
+    keySequenceMap.set(key, currentSeq + 1);
+    return { ...recording, sequence: currentSeq };
+  });
+}
 async function saveRecordingSession(recordingsDir, session) {
   const filePath = getRecordingPath(recordingsDir, session.id);
-  const dirPath = path.dirname(filePath);
-  await fs.mkdir(dirPath, { recursive: true });
+  await fs.mkdir(recordingsDir, { recursive: true });
+  const processedRecordings = processRecordings(session.recordings);
+  const processedSession = {
+    ...session,
+    recordings: processedRecordings
+  };
   await fs.writeFile(
     filePath,
-    JSON.stringify(session, null, JSON_INDENT_SPACES)
+    JSON.stringify(processedSession, null, JSON_INDENT_SPACES)
   );
   console.log(
-    `Saved ${session.recordings.length} HTTP recordings and ${session.websocketRecordings?.length || 0} WebSocket recordings to ${filePath}`
+    `Saved ${processedRecordings.length} HTTP recordings and ${session.websocketRecordings?.length || 0} WebSocket recordings to ${filePath}`
   );
 }
 function getReqID(req) {
@@ -48,10 +78,10 @@ function getReqID(req) {
   const pathname = urlParts[0];
   const query = urlParts[1] || "";
   const pathPart = pathname === "/" ? "root" : pathname.slice(1);
-  const normalizedPath = filenamify(pathPart, { replacement: "_" });
+  const normalizedPath = filenamify2(pathPart, { replacement: "_" });
   const queryHash = generateQueryHash(query);
   const filename = `${req.method}_${normalizedPath}${queryHash}.json`;
-  return filenamify(filename, { replacement: "_" });
+  return filenamify2(filename, { replacement: "_" });
 }
 function generateQueryHash(query) {
   if (!query) {
@@ -487,7 +517,11 @@ var ProxyServer = class {
       }
       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.recordingId - b.recordingId);
+      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;
+      });
       if (recordsWithKey.length === 0) {
         const errorMsg = `No recording found for ${key} at ${req.method} ${host}${req.url}`;
         console.error(`[REPLAY ERROR] ${errorMsg} (session: ${recordingId})`);
@@ -510,7 +544,7 @@ var ProxyServer = class {
       }
       const requestCount = servedForThisKey.size + 1;
       console.log(
-        `[REPLAY REQUEST #${requestCount}] ${req.method} ${req.url} (session: ${recordingId}, total: ${recordsWithKey.length}, served: ${servedForThisKey.size})`
+        `[replay request #${requestCount}] ${req.method} ${req.url} (session: ${recordingId}, total: ${recordsWithKey.length}, served: ${servedForThisKey.size})`
       );
       let record;
       for (const rec of recordsWithKey) {
@@ -527,7 +561,7 @@ var ProxyServer = class {
       }
       servedForThisKey.add(record.recordingId);
       console.log(
-        `[REPLAY SERVING] recordingId: ${record.recordingId}, session: ${recordingId}, body_len: ${record.response?.body?.length || 0}`
+        `[replay serving] recordingId: ${record.recordingId}, session: ${recordingId}, body_len: ${record.response?.body?.length || 0}`
       );
       if (!record.response) {
         throw new Error(
@@ -911,19 +945,27 @@ var playwrightProxy = {
    * Setup before test - sets the proxy mode
    * @param testInfo - Playwright test info object
    * @param mode - The proxy mode to use for this test
+   * @param timeout - Optional timeout in milliseconds
    */
-  async before(testInfo, mode) {
+  async before(testInfo, mode, timeout) {
     const sessionId = generateSessionId(testInfo);
-    console.log("Proxy setup:", { mode, sessionId });
-    await setProxyMode(mode, sessionId);
+    await setProxyMode(mode, sessionId, timeout);
   },
   /**
-   * Cleanup after test - returns to transparent mode
+   * Cleanup after test - resets replay session by re-entering replay mode
+   * switchToReplayMode automatically clears sequence counters
    * @param testInfo - Playwright test info object
    */
   async after(testInfo) {
     const sessionId = generateSessionId(testInfo);
-    await setProxyMode(Modes.transparent, sessionId);
+    await setProxyMode(Modes.replay, sessionId);
+  },
+  /**
+   * Global teardown - switches proxy to transparent mode
+   * Use this in Playwright's globalTeardown to ensure clean state
+   */
+  async teardown() {
+    await setProxyMode(Modes.transparent);
   }
 };
 

package/dist/playwright/index.cjs

@@ -89,19 +89,27 @@ var playwrightProxy = {
    * Setup before test - sets the proxy mode
    * @param testInfo - Playwright test info object
    * @param mode - The proxy mode to use for this test
+   * @param timeout - Optional timeout in milliseconds
    */
-  async before(testInfo, mode) {
+  async before(testInfo, mode, timeout) {
     const sessionId = generateSessionId(testInfo);
-    console.log("Proxy setup:", { mode, sessionId });
-    await setProxyMode(mode, sessionId);
+    await setProxyMode(mode, sessionId, timeout);
   },
   /**
-   * Cleanup after test - returns to transparent mode
+   * Cleanup after test - resets replay session by re-entering replay mode
+   * switchToReplayMode automatically clears sequence counters
    * @param testInfo - Playwright test info object
    */
   async after(testInfo) {
     const sessionId = generateSessionId(testInfo);
-    await setProxyMode(Modes.transparent, sessionId);
+    await setProxyMode(Modes.replay, sessionId);
+  },
+  /**
+   * Global teardown - switches proxy to transparent mode
+   * Use this in Playwright's globalTeardown to ensure clean state
+   */
+  async teardown() {
+    await setProxyMode(Modes.transparent);
   }
 };
 

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

package/dist/playwright/index.mjs

@@ -87,19 +87,27 @@ var playwrightProxy = {
    * Setup before test - sets the proxy mode
    * @param testInfo - Playwright test info object
    * @param mode - The proxy mode to use for this test
+   * @param timeout - Optional timeout in milliseconds
    */
-  async before(testInfo, mode) {
+  async before(testInfo, mode, timeout) {
     const sessionId = generateSessionId(testInfo);
-    console.log("Proxy setup:", { mode, sessionId });
-    await setProxyMode(mode, sessionId);
+    await setProxyMode(mode, sessionId, timeout);
   },
   /**
-   * Cleanup after test - returns to transparent mode
+   * Cleanup after test - resets replay session by re-entering replay mode
+   * switchToReplayMode automatically clears sequence counters
    * @param testInfo - Playwright test info object
    */
   async after(testInfo) {
     const sessionId = generateSessionId(testInfo);
-    await setProxyMode(Modes.transparent, sessionId);
+    await setProxyMode(Modes.replay, sessionId);
+  },
+  /**
+   * Global teardown - switches proxy to transparent mode
+   * Use this in Playwright's globalTeardown to ensure clean state
+   */
+  async teardown() {
+    await setProxyMode(Modes.transparent);
   }
 };
 

package/dist/proxy.js

@@ -1,4 +1,4 @@
-import path2 from 'path';
+import path from 'path';
 import { Command } from 'commander';
 import fs from 'fs/promises';
 import http from 'http';
@@ -6,7 +6,7 @@ import https from 'https';
 import httpProxy from 'http-proxy';
 import { WebSocket, WebSocketServer } from 'ws';
 import crypto from 'crypto';
-import filenamify from 'filenamify';
+import filenamify2 from 'filenamify';
 
 // src/cli.ts
 var DEFAULT_PORT = 8e3;
@@ -39,7 +39,7 @@ function parseCliArgs() {
   if (targets2.length === 0) {
     program.help();
   }
-  const recordingsDir2 = path2.resolve(process.cwd(), options.recordingsDir);
+  const recordingsDir2 = path.resolve(process.cwd(), options.recordingsDir);
   return { targets: targets2, port: port2, recordingsDir: recordingsDir2 };
 }
 
@@ -58,23 +58,53 @@ var Modes = {
   replay: "replay"
 };
 var JSON_INDENT_SPACES = 2;
+var EXTENSION = ".mock.json";
+var MAX_FILENAME_LENGTH = 255 - EXTENSION.length;
+var HASH_LENGTH = 8;
+function generateHash(str) {
+  return crypto.createHash("shake256", { outputLength: HASH_LENGTH / 2 }).update(str).digest("hex");
+}
 function getRecordingPath(recordingsDir2, id) {
-  return path2.join(recordingsDir2, `${id}.mock.json`);
+  let processedId = id.replaceAll("/", "__");
+  if (processedId.length > MAX_FILENAME_LENGTH) {
+    const hash = generateHash(id);
+    const maxBaseLength = MAX_FILENAME_LENGTH - HASH_LENGTH - 1;
+    processedId = `${processedId.slice(0, maxBaseLength)}_${hash}`;
+  }
+  const sanitizedId = filenamify2(processedId, {
+    replacement: "_",
+    maxLength: 255
+    // Set explicit max to prevent filenamify's default truncation
+  });
+  return path.join(recordingsDir2, `${sanitizedId}${EXTENSION}`);
 }
 async function loadRecordingSession(filePath) {
   const fileContent = await fs.readFile(filePath, "utf8");
   return JSON.parse(fileContent);
 }
+function processRecordings(recordings) {
+  const keySequenceMap = /* @__PURE__ */ new Map();
+  return recordings.map((recording) => {
+    const key = recording.key;
+    const currentSeq = keySequenceMap.get(key) || 0;
+    keySequenceMap.set(key, currentSeq + 1);
+    return { ...recording, sequence: currentSeq };
+  });
+}
 async function saveRecordingSession(recordingsDir2, session) {
   const filePath = getRecordingPath(recordingsDir2, session.id);
-  const dirPath = path2.dirname(filePath);
-  await fs.mkdir(dirPath, { recursive: true });
+  await fs.mkdir(recordingsDir2, { recursive: true });
+  const processedRecordings = processRecordings(session.recordings);
+  const processedSession = {
+    ...session,
+    recordings: processedRecordings
+  };
   await fs.writeFile(
     filePath,
-    JSON.stringify(session, null, JSON_INDENT_SPACES)
+    JSON.stringify(processedSession, null, JSON_INDENT_SPACES)
   );
   console.log(
-    `Saved ${session.recordings.length} HTTP recordings and ${session.websocketRecordings?.length || 0} WebSocket recordings to ${filePath}`
+    `Saved ${processedRecordings.length} HTTP recordings and ${session.websocketRecordings?.length || 0} WebSocket recordings to ${filePath}`
   );
 }
 function getReqID(req) {
@@ -82,10 +112,10 @@ function getReqID(req) {
   const pathname = urlParts[0];
   const query = urlParts[1] || "";
   const pathPart = pathname === "/" ? "root" : pathname.slice(1);
-  const normalizedPath = filenamify(pathPart, { replacement: "_" });
+  const normalizedPath = filenamify2(pathPart, { replacement: "_" });
   const queryHash = generateQueryHash(query);
   const filename = `${req.method}_${normalizedPath}${queryHash}.json`;
-  return filenamify(filename, { replacement: "_" });
+  return filenamify2(filename, { replacement: "_" });
 }
 function generateQueryHash(query) {
   if (!query) {
@@ -521,7 +551,11 @@ var ProxyServer = class {
       }
       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.recordingId - b.recordingId);
+      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;
+      });
       if (recordsWithKey.length === 0) {
         const errorMsg = `No recording found for ${key} at ${req.method} ${host}${req.url}`;
         console.error(`[REPLAY ERROR] ${errorMsg} (session: ${recordingId})`);
@@ -544,7 +578,7 @@ var ProxyServer = class {
       }
       const requestCount = servedForThisKey.size + 1;
       console.log(
-        `[REPLAY REQUEST #${requestCount}] ${req.method} ${req.url} (session: ${recordingId}, total: ${recordsWithKey.length}, served: ${servedForThisKey.size})`
+        `[replay request #${requestCount}] ${req.method} ${req.url} (session: ${recordingId}, total: ${recordsWithKey.length}, served: ${servedForThisKey.size})`
       );
       let record;
       for (const rec of recordsWithKey) {
@@ -561,7 +595,7 @@ var ProxyServer = class {
       }
       servedForThisKey.add(record.recordingId);
       console.log(
-        `[REPLAY SERVING] recordingId: ${record.recordingId}, session: ${recordingId}, body_len: ${record.response?.body?.length || 0}`
+        `[replay serving] recordingId: ${record.recordingId}, session: ${recordingId}, body_len: ${record.response?.body?.length || 0}`
       );
       if (!record.response) {
         throw new Error(

package/package.json

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