test-proxy-recorder 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -0,0 +1,597 @@
+'use strict';
+
+var fs = require('fs/promises');
+var http = require('http');
+var httpProxy = require('http-proxy');
+var ws = require('ws');
+var path = require('path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var http__default = /*#__PURE__*/_interopDefault(http);
+var httpProxy__default = /*#__PURE__*/_interopDefault(httpProxy);
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+// src/ProxyServer.ts
+
+// src/constants.ts
+var DEFAULT_TIMEOUT_MS = 120 * 1e3;
+var HTTP_STATUS_BAD_GATEWAY = 502;
+var HTTP_STATUS_OK = 200;
+var HTTP_STATUS_BAD_REQUEST = 400;
+var HTTP_STATUS_NOT_FOUND = 404;
+var CONTROL_ENDPOINT = "/__control";
+
+// src/types.ts
+var Modes = {
+  transparent: "transparent",
+  record: "record",
+  replay: "replay"
+};
+var JSON_INDENT_SPACES = 2;
+function getRecordingPath(recordingsDir, id) {
+  return path__default.default.join(recordingsDir, `${id}.json`);
+}
+async function loadRecordingSession(filePath) {
+  const fileContent = await fs__default.default.readFile(filePath, "utf8");
+  return JSON.parse(fileContent);
+}
+async function saveRecordingSession(recordingsDir, session) {
+  const filePath = getRecordingPath(recordingsDir, session.id);
+  await fs__default.default.writeFile(
+    filePath,
+    JSON.stringify(session, null, JSON_INDENT_SPACES)
+  );
+  console.log(
+    `Saved ${session.recordings.length} HTTP recordings and ${session.websocketRecordings?.length || 0} WebSocket recordings to ${filePath}`
+  );
+}
+
+// src/utils/httpHelpers.ts
+var CONTENT_TYPE_JSON = "application/json";
+async function readRequestBody(req) {
+  let body = "";
+  for await (const chunk of req) {
+    body += chunk.toString();
+  }
+  return body;
+}
+function sendJsonResponse(res, statusCode, data) {
+  res.writeHead(statusCode, { "Content-Type": CONTENT_TYPE_JSON });
+  res.end(JSON.stringify(data));
+}
+
+// src/utils/requestKeyGenerator.ts
+var QUERY_HASH_LENGTH = 8;
+function generateRequestKey(req) {
+  const urlParts = req.url.split("?");
+  const pathname = urlParts[0];
+  const query = urlParts[1] || "";
+  const normalizedPath = normalizePathname(pathname);
+  const queryHash = generateQueryHash(query);
+  return `${req.method}_${normalizedPath}${queryHash}.json`;
+}
+function normalizePathname(pathname) {
+  const normalized = pathname.replaceAll("/", "_").replace(/^_/, "");
+  return normalized || "root";
+}
+function generateQueryHash(query) {
+  if (!query) {
+    return "";
+  }
+  const hash = Buffer.from(query).toString("base64").replaceAll(/[^a-zA-Z0-9]/g, "").slice(0, Math.max(0, QUERY_HASH_LENGTH));
+  return `_${hash}`;
+}
+
+// src/ProxyServer.ts
+var ProxyServer = class {
+  targets;
+  currentTargetIndex;
+  mode;
+  recordingId;
+  replayId;
+  modeTimeout;
+  proxy;
+  currentSession;
+  recordingsDir;
+  constructor(targets, recordingsDir) {
+    this.targets = targets;
+    this.currentTargetIndex = 0;
+    this.mode = Modes.transparent;
+    this.recordingId = null;
+    this.replayId = null;
+    this.modeTimeout = null;
+    this.currentSession = null;
+    this.recordingsDir = recordingsDir;
+    this.proxy = httpProxy__default.default.createProxyServer({
+      secure: false,
+      changeOrigin: true
+    });
+    this.setupProxyEventHandlers();
+  }
+  async init() {
+    await fs__default.default.mkdir(this.recordingsDir, { recursive: true });
+  }
+  listen(port) {
+    const server = http__default.default.createServer((req, res) => {
+      this.handleRequest(req, res);
+    });
+    server.on("upgrade", (req, socket, head) => {
+      this.handleUpgrade(req, socket, head);
+    });
+    server.listen(port, () => {
+      this.logServerStartup(port);
+    });
+    return server;
+  }
+  setupProxyEventHandlers() {
+    this.proxy.on("error", this.handleProxyError.bind(this));
+    this.proxy.on("proxyRes", this.handleProxyResponse.bind(this));
+  }
+  handleProxyError(err, _req, res) {
+    console.error("Proxy error:", err);
+    if (!(res instanceof http__default.default.ServerResponse)) {
+      return;
+    }
+    if (!res.headersSent) {
+      res.writeHead(HTTP_STATUS_BAD_GATEWAY, {
+        "Content-Type": "application/json"
+      });
+    }
+    res.end(JSON.stringify({ error: "Proxy error", message: err.message }));
+  }
+  handleProxyResponse(proxyRes, req) {
+    if (this.mode === Modes.record && this.recordingId) {
+      this.recordResponse(req, proxyRes);
+    }
+  }
+  getTarget() {
+    const target = this.targets[this.currentTargetIndex];
+    this.currentTargetIndex = (this.currentTargetIndex + 1) % this.targets.length;
+    return target;
+  }
+  async handleControlRequest(req, res) {
+    try {
+      const body = await readRequestBody(req);
+      console.log("MODE CHANGE", body);
+      const data = JSON.parse(body);
+      const { mode, id, timeout: requestTimeout } = data;
+      const timeout = requestTimeout ?? DEFAULT_TIMEOUT_MS;
+      this.clearModeTimeout();
+      await this.switchMode(mode, id);
+      this.setupModeTimeout(timeout);
+      sendJsonResponse(res, HTTP_STATUS_OK, {
+        success: true,
+        mode: this.mode,
+        id: this.recordingId || this.replayId,
+        timeout
+      });
+    } catch (error) {
+      console.error("Control request error:", error);
+      sendJsonResponse(res, HTTP_STATUS_BAD_REQUEST, {
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  }
+  clearModeTimeout() {
+    if (this.modeTimeout) {
+      clearTimeout(this.modeTimeout);
+      this.modeTimeout = null;
+    }
+  }
+  async switchMode(mode, id) {
+    if (this.currentSession) {
+      console.log("Switching mode, saving current session first");
+      await this.saveCurrentSession();
+      console.log("Session saved, continuing with mode switch");
+    }
+    switch (mode) {
+      case Modes.transparent: {
+        this.switchToTransparentMode();
+        break;
+      }
+      case Modes.record: {
+        this.switchToRecordMode(id);
+        break;
+      }
+      case Modes.replay: {
+        this.switchToReplayMode(id);
+        break;
+      }
+      default: {
+        throw new Error("Invalid mode. Use: transparent, record, or replay");
+      }
+    }
+  }
+  switchToTransparentMode() {
+    this.mode = Modes.transparent;
+    this.recordingId = null;
+    this.replayId = null;
+    this.currentSession = null;
+    console.log("Switched to transparent mode");
+  }
+  switchToRecordMode(id) {
+    if (!id) {
+      throw new Error("Record ID is required");
+    }
+    this.mode = Modes.record;
+    this.recordingId = id;
+    this.replayId = null;
+    this.currentSession = { id, recordings: [], websocketRecordings: [] };
+    console.log(`Switched to record mode with ID: ${id}`);
+  }
+  switchToReplayMode(id) {
+    if (!id) {
+      throw new Error("Replay ID is required");
+    }
+    this.mode = Modes.replay;
+    this.replayId = id;
+    this.recordingId = null;
+    this.currentSession = null;
+    console.log(`Switched to replay mode with ID: ${id}`);
+  }
+  setupModeTimeout(timeout) {
+    if (timeout && timeout > 0) {
+      this.modeTimeout = setTimeout(async () => {
+        console.log("Timeout reached, switching back to transparent mode");
+        await this.saveCurrentSession();
+        this.switchToTransparentMode();
+        this.modeTimeout = null;
+      }, timeout);
+    }
+  }
+  async saveCurrentSession() {
+    if (!this.currentSession) {
+      console.log("No current session to save");
+      return;
+    }
+    if (this.currentSession.recordings.length === 0 && this.currentSession.websocketRecordings.length === 0) {
+      console.log("Session has no recordings, skipping save");
+      return;
+    }
+    console.log(
+      `Saving session with ${this.currentSession.recordings.length} HTTP and ${this.currentSession.websocketRecordings.length} WebSocket recordings`
+    );
+    await saveRecordingSession(this.recordingsDir, this.currentSession);
+  }
+  async saveRequestRecord(req, body) {
+    if (!this.currentSession) {
+      return;
+    }
+    const key = generateRequestKey(req);
+    const record = {
+      request: {
+        method: req.method,
+        url: req.url,
+        headers: req.headers,
+        body: body || null
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      key
+    };
+    this.currentSession.recordings.push(record);
+  }
+  async recordResponse(req, proxyRes) {
+    if (!this.currentSession) {
+      return;
+    }
+    const key = generateRequestKey(req);
+    const record = this.currentSession.recordings.find((r) => r.key === key);
+    if (!record) {
+      console.error("Request record not found for response:", key);
+      return;
+    }
+    const chunks = [];
+    proxyRes.on("data", (chunk) => {
+      chunks.push(chunk);
+    });
+    proxyRes.on("end", async () => {
+      const body = Buffer.concat(chunks).toString("utf8");
+      record.response = {
+        statusCode: proxyRes.statusCode,
+        headers: proxyRes.headers,
+        body: body || null
+      };
+      await this.saveCurrentSession();
+      console.log(`Recorded: ${req.method} ${req.url}`);
+    });
+  }
+  async handleReplayRequest(req, res) {
+    const key = generateRequestKey(req);
+    const filePath = getRecordingPath(this.recordingsDir, this.replayId);
+    try {
+      const session = await loadRecordingSession(filePath);
+      const record = session.recordings.find((r) => r.key === key);
+      if (!record) {
+        throw new Error(`No recording found for ${key}`);
+      }
+      if (!record.response) {
+        throw new Error("No response recorded for this request");
+      }
+      const { statusCode, headers, body } = record.response;
+      res.writeHead(statusCode, headers);
+      res.end(body);
+      console.log(`Replayed: ${req.method} ${req.url}`);
+    } catch (error) {
+      this.handleReplayError(res, error, key, filePath);
+    }
+  }
+  handleReplayError(res, err, key, filePath) {
+    const isFileNotFound = err instanceof Error && "code" in err && err.code === "ENOENT";
+    console.error("Replay error:", err);
+    sendJsonResponse(res, HTTP_STATUS_NOT_FOUND, {
+      error: isFileNotFound ? "Recording file not found" : "Recording not found",
+      message: err instanceof Error ? err.message : "Unknown error",
+      key,
+      filePath
+    });
+  }
+  async handleRequest(req, res) {
+    if (req.url === CONTROL_ENDPOINT) {
+      return this.handleControlRequest(req, res);
+    }
+    if (this.mode === Modes.replay) {
+      return this.handleReplayRequest(req, res);
+    }
+    await this.handleProxyRequest(req, res);
+  }
+  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);
+    }
+    this.proxy.web(req, res, { target });
+  }
+  async bufferRequestForRecord(req) {
+    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);
+    });
+  }
+  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}`);
+    if (this.mode === Modes.record) {
+      this.handleRecordWebSocket(req, socket, head, target);
+    } else {
+      this.proxy.ws(req, socket, head, { target });
+    }
+  }
+  handleRecordWebSocket(req, clientSocket, head, target) {
+    const url = req.url || "/";
+    const key = `WS_${url.replaceAll("/", "_")}`;
+    const wsRecording = {
+      url,
+      messages: [],
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      key
+    };
+    if (this.currentSession) {
+      this.currentSession.websocketRecordings.push(wsRecording);
+    }
+    const backendWsUrl = `${target.replace("http", "ws")}${url}`;
+    const backendWs = new ws.WebSocket(backendWsUrl);
+    const wss = new ws.WebSocketServer({ noServer: true });
+    backendWs.on("open", () => {
+      console.log(`WebSocket recording: connected to backend ${backendWsUrl}`);
+      wss.handleUpgrade(req, clientSocket, head, (clientWs) => {
+        clientWs.on("message", (data) => {
+          const message = data.toString();
+          wsRecording.messages.push({
+            direction: "client-to-server",
+            data: message,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          if (backendWs.readyState === ws.WebSocket.OPEN) {
+            backendWs.send(message);
+          }
+          this.saveCurrentSession().catch((error) => {
+            console.error("Failed to save WebSocket recording:", error);
+          });
+        });
+        backendWs.on("message", (data) => {
+          const message = data.toString();
+          wsRecording.messages.push({
+            direction: "server-to-client",
+            data: message,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          if (clientWs.readyState === ws.WebSocket.OPEN) {
+            clientWs.send(message);
+          }
+          this.saveCurrentSession().catch((error) => {
+            console.error("Failed to save WebSocket recording:", error);
+          });
+        });
+        clientWs.on("error", (err) => {
+          console.error("Client WebSocket error:", err);
+        });
+        backendWs.on("error", (err) => {
+          console.error("Backend WebSocket error:", err);
+        });
+        clientWs.on("close", () => {
+          backendWs.close();
+          console.log("Client WebSocket closed");
+        });
+        backendWs.on("close", () => {
+          clientWs.close();
+          console.log("Backend WebSocket closed");
+        });
+      });
+    });
+    backendWs.on("error", (err) => {
+      console.error("Backend WebSocket connection error:", err);
+      clientSocket.write("HTTP/1.1 502 Bad Gateway\r\n\r\n");
+      clientSocket.destroy();
+    });
+    wss.on("error", (err) => {
+      console.error("WebSocket server error:", err);
+    });
+  }
+  handleReplayWebSocket(req, socket) {
+    const url = req.url || "/";
+    const key = `WS_${url.replaceAll("/", "_")}`;
+    const filePath = getRecordingPath(this.recordingsDir, this.replayId);
+    loadRecordingSession(filePath).then((session) => {
+      const wsRecording = session.websocketRecordings.find(
+        (r) => r.key === key
+      );
+      if (!wsRecording) {
+        socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
+        socket.destroy();
+        console.log(`No WebSocket recording found for ${key}`);
+        return;
+      }
+      const wss = new ws.WebSocketServer({ noServer: true });
+      const fakeReq = Object.assign(req, {
+        headers: {
+          ...req.headers,
+          "sec-websocket-key": req.headers["sec-websocket-key"] || "replay-key",
+          "sec-websocket-version": "13"
+        }
+      });
+      wss.handleUpgrade(fakeReq, socket, Buffer.alloc(0), (ws$1) => {
+        console.log(`Replaying WebSocket: ${url}`);
+        const serverMessages = wsRecording.messages.filter(
+          (m) => m.direction === "server-to-client"
+        );
+        let messageIndex = 0;
+        ws$1.on("message", (data) => {
+          const clientMessage = data.toString();
+          console.log(`Replay: Client sent: ${clientMessage}`);
+          if (messageIndex < serverMessages.length) {
+            setTimeout(() => {
+              if (ws$1.readyState === ws.WebSocket.OPEN) {
+                ws$1.send(serverMessages[messageIndex].data);
+                console.log(`Replay: Sent server message ${messageIndex}`);
+                messageIndex++;
+              }
+            }, 10);
+          }
+        });
+        let initialMessagesSent = 0;
+        for (let i = 0; i < wsRecording.messages.length; i++) {
+          const msg = wsRecording.messages[i];
+          if (msg.direction === "client-to-server") {
+            break;
+          }
+          if (msg.direction === "server-to-client") {
+            setTimeout(
+              () => {
+                if (ws$1.readyState === ws.WebSocket.OPEN) {
+                  ws$1.send(msg.data);
+                  console.log(
+                    `Replay: Sent initial server message: ${msg.data}`
+                  );
+                  messageIndex++;
+                  initialMessagesSent++;
+                }
+              },
+              10 * (initialMessagesSent + 1)
+            );
+          }
+        }
+        ws$1.on("error", (err) => {
+          console.error("Replay WebSocket error:", err);
+        });
+        ws$1.on("close", () => {
+          console.log("Replay WebSocket closed");
+        });
+      });
+    }).catch((error) => {
+      console.error("Replay error:", error);
+      socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
+      socket.destroy();
+    });
+  }
+  logServerStartup(port) {
+    console.log(`Proxy server running on http://localhost:${port}`);
+    console.log(`Mode: ${this.mode}`);
+    console.log(`Targets: ${this.targets.join(", ")}`);
+    console.log(
+      `Control endpoint: http://localhost:${port}${CONTROL_ENDPOINT}`
+    );
+  }
+};
+
+// src/playwright/index.ts
+var INTERNAL_API_URL = process.env.INTERNAL_API_URL || "http://localhost:8100";
+async function setProxyMode(mode, sessionId, timeout) {
+  try {
+    const body = {
+      mode,
+      id: sessionId,
+      ...timeout && { timeout }
+    };
+    const response = await fetch(`${INTERNAL_API_URL}/__control`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      console.error(`Failed to set proxy mode to ${mode}:`, text);
+      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;
+  }
+}
+function generateSessionId(testInfo) {
+  return testInfo.title.toLowerCase().replaceAll(/\s+/g, "-");
+}
+async function startRecording(testInfo) {
+  const sessionId = generateSessionId(testInfo);
+  await setProxyMode("recording", sessionId);
+}
+async function startReplay(testInfo) {
+  const sessionId = generateSessionId(testInfo);
+  await setProxyMode("replay", sessionId);
+}
+async function stopProxy(testInfo) {
+  const sessionId = generateSessionId(testInfo);
+  await setProxyMode("transparent", sessionId);
+}
+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
+   */
+  async before(testInfo, mode) {
+    const sessionId = generateSessionId(testInfo);
+    console.log("Proxy setup:", { mode, sessionId });
+    await setProxyMode(mode, sessionId);
+  },
+  /**
+   * Cleanup after test - returns to transparent mode
+   * @param testInfo - Playwright test info object
+   */
+  async after(testInfo) {
+    const sessionId = generateSessionId(testInfo);
+    await setProxyMode("transparent", sessionId);
+  }
+};
+
+exports.ProxyServer = ProxyServer;
+exports.generateSessionId = generateSessionId;
+exports.playwrightProxy = playwrightProxy;
+exports.setProxyMode = setProxyMode;
+exports.startRecording = startRecording;
+exports.startReplay = startReplay;
+exports.stopProxy = stopProxy;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.d.cts

@@ -0,0 +1,88 @@
+import http from 'node:http';
+export { PlaywrightTestInfo, ProxyMode, generateSessionId, playwrightProxy, setProxyMode, startRecording, startReplay, stopProxy } from './playwright/index.cjs';
+import '@playwright/test';
+
+declare class ProxyServer {
+    private targets;
+    private currentTargetIndex;
+    private mode;
+    private recordingId;
+    private replayId;
+    private modeTimeout;
+    private proxy;
+    private currentSession;
+    private recordingsDir;
+    constructor(targets: string[], recordingsDir: string);
+    init(): Promise<void>;
+    listen(port: number): http.Server;
+    private setupProxyEventHandlers;
+    private handleProxyError;
+    private handleProxyResponse;
+    private getTarget;
+    private handleControlRequest;
+    private clearModeTimeout;
+    private switchMode;
+    private switchToTransparentMode;
+    private switchToRecordMode;
+    private switchToReplayMode;
+    private setupModeTimeout;
+    private saveCurrentSession;
+    private saveRequestRecord;
+    private recordResponse;
+    private handleReplayRequest;
+    private handleReplayError;
+    private handleRequest;
+    private handleProxyRequest;
+    private bufferRequestForRecord;
+    private handleUpgrade;
+    private handleRecordWebSocket;
+    private handleReplayWebSocket;
+    private logServerStartup;
+}
+
+declare const Modes: {
+    readonly transparent: "transparent";
+    readonly record: "record";
+    readonly replay: "replay";
+};
+type Mode = (typeof Modes)[keyof typeof Modes];
+interface ControlRequest {
+    mode: Mode;
+    id?: string;
+    timeout?: number;
+}
+interface RecordedRequest {
+    method: string;
+    url: string;
+    headers: http.IncomingHttpHeaders;
+    body: string | null;
+}
+interface RecordedResponse {
+    statusCode: number;
+    headers: http.IncomingHttpHeaders;
+    body: string | null;
+}
+interface Recording {
+    request: RecordedRequest;
+    response?: RecordedResponse;
+    timestamp: string;
+    key: string;
+}
+interface WebSocketMessage {
+    direction: 'client-to-server' | 'server-to-client';
+    data: string;
+    timestamp: string;
+}
+interface WebSocketRecording {
+    url: string;
+    messages: WebSocketMessage[];
+    timestamp: string;
+    key: string;
+}
+interface RecordingSession {
+    id: string;
+    recordings: Recording[];
+    websocketRecordings: WebSocketRecording[];
+}
+
+export { type ControlRequest, type Mode, ProxyServer, type Recording, type RecordingSession, type WebSocketRecording };