test-proxy-recorder 0.1.0 → 0.1.2

package/dist/ProxyServer.js

@@ -1,464 +0,0 @@
-import fs from 'node:fs/promises';
-import http from 'node:http';
-import httpProxy from 'http-proxy';
-import { WebSocket, WebSocketServer } from 'ws';
-import { CONTROL_ENDPOINT, DEFAULT_TIMEOUT_MS, HTTP_STATUS_BAD_GATEWAY, HTTP_STATUS_BAD_REQUEST, HTTP_STATUS_NOT_FOUND, HTTP_STATUS_OK, } from './constants.js';
-import { Modes, } from './types.js';
-import { getRecordingPath, loadRecordingSession, saveRecordingSession, } from './utils/fileUtils.js';
-import { readRequestBody, sendJsonResponse } from './utils/httpHelpers.js';
-import { generateRequestKey } from './utils/requestKeyGenerator.js';
-export class ProxyServer {
-    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.createProxyServer({
-            secure: false,
-            changeOrigin: true,
-        });
-        this.setupProxyEventHandlers();
-    }
-    async init() {
-        await fs.mkdir(this.recordingsDir, { recursive: true });
-    }
-    listen(port) {
-        const server = http.createServer((req, res) => {
-            this.handleRequest(req, res);
-        });
-        // Handle WebSocket upgrade requests
-        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.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) {
-        // Save current session before switching
-        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: 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 {
-            // Transparent mode - just proxy through
-            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: new Date().toISOString(),
-            key,
-        };
-        if (this.currentSession) {
-            this.currentSession.websocketRecordings.push(wsRecording);
-        }
-        // Create WebSocket connection to backend
-        const backendWsUrl = `${target.replace('http', 'ws')}${url}`;
-        const backendWs = new WebSocket(backendWsUrl);
-        // Create WebSocket server for client
-        const wss = new WebSocketServer({ noServer: true });
-        // Wait for backend connection before accepting client
-        backendWs.on('open', () => {
-            console.log(`WebSocket recording: connected to backend ${backendWsUrl}`);
-            wss.handleUpgrade(req, clientSocket, head, (clientWs) => {
-                // Forward messages from client to backend
-                clientWs.on('message', (data) => {
-                    const message = data.toString();
-                    // Record client message
-                    wsRecording.messages.push({
-                        direction: 'client-to-server',
-                        data: message,
-                        timestamp: new Date().toISOString(),
-                    });
-                    // Forward to backend if connected
-                    if (backendWs.readyState === WebSocket.OPEN) {
-                        backendWs.send(message);
-                    }
-                    this.saveCurrentSession().catch((error) => {
-                        console.error('Failed to save WebSocket recording:', error);
-                    });
-                });
-                // Forward messages from backend to client
-                backendWs.on('message', (data) => {
-                    const message = data.toString();
-                    // Record server message
-                    wsRecording.messages.push({
-                        direction: 'server-to-client',
-                        data: message,
-                        timestamp: new Date().toISOString(),
-                    });
-                    // Forward to client
-                    if (clientWs.readyState === WebSocket.OPEN) {
-                        clientWs.send(message);
-                    }
-                    this.saveCurrentSession().catch((error) => {
-                        console.error('Failed to save WebSocket recording:', error);
-                    });
-                });
-                // Handle errors
-                clientWs.on('error', (err) => {
-                    console.error('Client WebSocket error:', err);
-                });
-                backendWs.on('error', (err) => {
-                    console.error('Backend WebSocket error:', err);
-                });
-                // Handle close
-                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;
-            }
-            // Create WebSocket server for replay
-            const wss = new WebSocketServer({ noServer: true });
-            // Fake upgrade request with proper headers
-            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) => {
-                console.log(`Replaying WebSocket: ${url}`);
-                // Replay server-to-client messages
-                const serverMessages = wsRecording.messages.filter((m) => m.direction === 'server-to-client');
-                let messageIndex = 0;
-                // Handle client messages and send corresponding server responses
-                ws.on('message', (data) => {
-                    const clientMessage = data.toString();
-                    console.log(`Replay: Client sent: ${clientMessage}`);
-                    // Send next server message if available
-                    if (messageIndex < serverMessages.length) {
-                        setTimeout(() => {
-                            if (ws.readyState === WebSocket.OPEN) {
-                                ws.send(serverMessages[messageIndex].data);
-                                console.log(`Replay: Sent server message ${messageIndex}`);
-                                messageIndex++;
-                            }
-                        }, 10);
-                    }
-                });
-                // Send initial server messages (those sent before any client message)
-                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.readyState === WebSocket.OPEN) {
-                                ws.send(msg.data);
-                                console.log(`Replay: Sent initial server message: ${msg.data}`);
-                                messageIndex++;
-                                initialMessagesSent++;
-                            }
-                        }, 10 * (initialMessagesSent + 1));
-                    }
-                }
-                ws.on('error', (err) => {
-                    console.error('Replay WebSocket error:', err);
-                });
-                ws.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}`);
-    }
-}
-//# sourceMappingURL=ProxyServer.js.map

package/dist/cli.d.ts

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-export interface CliOptions {
-    targets: string[];
-    port: number;
-    recordingsDir: string;
-}
-export declare function parseCliArgs(): CliOptions;
-//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AASA,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,YAAY,IAAI,UAAU,CA6CzC"}

package/dist/cli.js

@@ -1,32 +0,0 @@
-#!/usr/bin/env node
-import path from 'node:path';
-import { Command } from 'commander';
-const DEFAULT_PORT = 8000;
-const DEFAULT_RECORDINGS_DIR = './recordings';
-export function parseCliArgs() {
-    const program = new Command();
-    program
-        .name('dev-proxy')
-        .description('Development proxy server with recording and replay capabilities')
-        .argument('<targets...>', 'Target API service URLs (e.g., http://localhost:3000)')
-        .option('-p, --port <number>', 'Port number for the proxy server', String(DEFAULT_PORT))
-        .option('-r, --recordings-dir <path>', 'Directory to store recordings (relative to CWD)', DEFAULT_RECORDINGS_DIR)
-        .action(() => {
-        // Action handled after parse
-    });
-    program.parse();
-    const targets = program.args;
-    const options = program.opts();
-    const port = Number.parseInt(options.port, 10);
-    if (Number.isNaN(port) || port < 1025 || port > 65_535) {
-        console.error('Error: Invalid port number. Must be between 1 and 65535');
-        process.exit(1);
-    }
-    if (targets.length === 0) {
-        program.help();
-    }
-    // Resolve recordings directory relative to the current working directory (where the command is run)
-    const recordingsDir = path.resolve(process.cwd(), options.recordingsDir);
-    return { targets, port, recordingsDir };
-}
-//# sourceMappingURL=cli.js.map

package/dist/constants.d.ts

@@ -1,7 +0,0 @@
-export declare const DEFAULT_TIMEOUT_MS: number;
-export declare const HTTP_STATUS_BAD_GATEWAY = 502;
-export declare const HTTP_STATUS_OK = 200;
-export declare const HTTP_STATUS_BAD_REQUEST = 400;
-export declare const HTTP_STATUS_NOT_FOUND = 404;
-export declare const CONTROL_ENDPOINT = "/__control";
-//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,QAAa,CAAC;AAC7C,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAC3C,eAAO,MAAM,cAAc,MAAM,CAAC;AAClC,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAC3C,eAAO,MAAM,qBAAqB,MAAM,CAAC;AACzC,eAAO,MAAM,gBAAgB,eAAe,CAAC"}

package/dist/constants.js

@@ -1,7 +0,0 @@
-export const DEFAULT_TIMEOUT_MS = 120 * 1000;
-export const HTTP_STATUS_BAD_GATEWAY = 502;
-export const HTTP_STATUS_OK = 200;
-export const HTTP_STATUS_BAD_REQUEST = 400;
-export const HTTP_STATUS_NOT_FOUND = 404;
-export const CONTROL_ENDPOINT = '/__control';
-//# sourceMappingURL=constants.js.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EACV,cAAc,EACd,IAAI,EACJ,SAAS,EACT,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,SAAS,CAAC;AAGjB,YAAY,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,YAAY,EACZ,cAAc,EACd,WAAW,EACX,SAAS,GACV,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -1,3 +0,0 @@
-export { ProxyServer } from './ProxyServer';
-export { generateSessionId, playwrightProxy, setProxyMode, startRecording, startReplay, stopProxy, } from './playwright';
-//# sourceMappingURL=index.js.map

package/dist/playwright/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/playwright/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAKjD,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG,QAAQ,GAAG,aAAa,CAAC;AAE/D,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;AAQzD;;;;;GAKG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,SAAS,EACf,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC,CA+Bf;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,CAEtE;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,kBAAkB,GAC3B,OAAO,CAAC,IAAI,CAAC,CAGf;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAG7E;AAED;;;GAGG;AACH,wBAAsB,SAAS,CAAC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAG3E;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe;IAC1B;;;;OAIG;qBACoB,kBAAkB,QAAQ,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAM1E;;;OAGG;oBACmB,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;CAIzD,CAAC"}

package/dist/playwright/index.js

@@ -1,92 +0,0 @@
-const INTERNAL_API_URL = process.env.INTERNAL_API_URL || 'http://localhost:8100';
-/**
- * Set the proxy mode for a given session
- * @param mode - The proxy mode to set (recording, replay, transparent)
- * @param sessionId - Unique identifier for the session
- * @param timeout - Optional timeout in milliseconds
- */
-export async function setProxyMode(mode, sessionId, timeout) {
-    if (!INTERNAL_API_URL) {
-        console.warn('INTERNAL_API_URL not set, proxy mode not changed');
-        return;
-    }
-    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;
-    }
-}
-/**
- * Generate a session ID from test info
- * @param testInfo - Playwright test info object
- */
-export function generateSessionId(testInfo) {
-    return testInfo.title.toLowerCase().replaceAll(/\s+/g, '-');
-}
-/**
- * Start recording for a test
- * @param testInfo - Playwright test info object
- */
-export async function startRecording(testInfo) {
-    const sessionId = generateSessionId(testInfo);
-    await setProxyMode('recording', sessionId);
-}
-/**
- * Start replay for a test
- * @param testInfo - Playwright test info object
- */
-export async function startReplay(testInfo) {
-    const sessionId = generateSessionId(testInfo);
-    await setProxyMode('replay', sessionId);
-}
-/**
- * Stop recording/replay and return to transparent mode
- * @param testInfo - Playwright test info object
- */
-export async function stopProxy(testInfo) {
-    const sessionId = generateSessionId(testInfo);
-    await setProxyMode('transparent', sessionId);
-}
-/**
- * Playwright test fixture helper for managing proxy mode
- * Use this in beforeEach/afterEach hooks
- */
-export 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
-     */
-    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);
-    },
-};
-//# sourceMappingURL=index.js.map

package/dist/proxy.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=proxy.d.ts.map

package/dist/proxy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../src/proxy.ts"],"names":[],"mappings":""}