@browserless.io/browserless 2.0.0-beta-1

package/build/browsers/cdp-chromium.js

@@ -0,0 +1,287 @@
+import { ServerError, createLogger, encrypt, liveURLSep, makeExternalURL, noop, once, } from '@browserless.io/browserless';
+import puppeteer from 'puppeteer-core';
+import { EventEmitter } from 'events';
+import StealthPlugin from 'puppeteer-extra-plugin-stealth';
+import { fileURLToPath } from 'url';
+import getPort from 'get-port';
+import httpProxy from 'http-proxy';
+import path from 'path';
+import playwright from 'playwright-core';
+import puppeteerStealth from 'puppeteer-extra';
+puppeteerStealth.use(StealthPlugin());
+export class CDPChromium extends EventEmitter {
+    config;
+    userDataDir;
+    record;
+    blockAds;
+    running = false;
+    browser = null;
+    browserWSEndpoint = null;
+    port;
+    debug = createLogger('browsers:cdp:chromium');
+    proxy = httpProxy.createProxyServer();
+    constructor({ userDataDir, config, record, blockAds, }) {
+        super();
+        this.userDataDir = userDataDir;
+        this.config = config;
+        this.record = record;
+        this.blockAds = blockAds;
+        this.debug(`Starting new browser instance`);
+    }
+    cleanListeners() {
+        this.browser?.removeAllListeners();
+        this.removeAllListeners();
+    }
+    setUpEmbeddedAPI = async (page, id, record) => {
+        const pageId = this.getPageId(page);
+        const liveUrl = this.makeLiveURL(id, pageId);
+        const embeddedAPI = (pageId, liveUrl, record) => {
+            Object.defineProperty(window, 'browserless', {
+                configurable: false,
+                enumerable: false,
+                value: {},
+                writable: false,
+            });
+            Object.defineProperties(window.browserless, {
+                liveUrl: {
+                    configurable: false,
+                    enumerable: false,
+                    value: () => liveUrl,
+                    writable: false,
+                },
+                pageId: {
+                    configurable: false,
+                    enumerable: false,
+                    value: () => pageId,
+                    writable: false,
+                },
+                startRecording: {
+                    configurable: false,
+                    enumerable: false,
+                    value: (params) => new Promise((resolve, reject) => {
+                        if (!record) {
+                            throw new Error(`Must connect with a record query-param set to "true" in order to use recording`);
+                        }
+                        const start = () => window.postMessage({ ...params, id: pageId, type: 'REC_START' }, '*');
+                        const onStart = (event) => {
+                            if (event.data.id !== pageId)
+                                return;
+                            if (event.data.message === 'REC_STARTED') {
+                                window.removeEventListener('message', onStart);
+                                return resolve(undefined);
+                            }
+                            if (event.data.message === 'REC_START_FAIL') {
+                                window.removeEventListener('message', onStart);
+                                return reject(new Error(event.data.error));
+                            }
+                        };
+                        window.addEventListener('message', onStart);
+                        return document.readyState == 'complete'
+                            ? start()
+                            : window.addEventListener('load', start);
+                    }),
+                    writable: false,
+                },
+                stopRecording: {
+                    configurable: false,
+                    enumerable: false,
+                    value: () => new Promise((resolve, reject) => {
+                        if (!record) {
+                            return reject(new Error(`Must connect with a record query-param set to "true" in order to use recording`));
+                        }
+                        const onStop = (event) => {
+                            if (event.data.id !== pageId)
+                                return;
+                            if (event.data.message === 'REC_FILE') {
+                                window.removeEventListener('message', onStop);
+                                return resolve(event.data.file);
+                            }
+                            if (event.data.message === 'REC_STOP_FAIL') {
+                                window.removeEventListener('message', onStop);
+                                return reject(new Error(event.data.error));
+                            }
+                            if (event.data.message === 'REC_NOT_STARTED') {
+                                window.removeEventListener('message', onStop);
+                                return reject(new Error(`Recording hasn't started, did you forget to start it?`));
+                            }
+                        };
+                        window.addEventListener('message', onStop);
+                        return window.postMessage({ id: pageId, type: 'REC_STOP' }, '*');
+                    }),
+                    writable: false,
+                },
+            });
+        };
+        // Setup the browserless embedded API
+        await Promise.all([
+            page.evaluate(embeddedAPI, pageId, liveUrl, record),
+            page.evaluateOnNewDocument(embeddedAPI, pageId, liveUrl, record),
+        ]).catch((err) => this.debug(`Error setting up embedded API:`, err.message));
+    };
+    getPageId = (page) => {
+        // @ts-ignore
+        return page.target()._targetId;
+    };
+    makeLiveURL = (browserId, pageId) => {
+        const serverAddress = this.config.getExternalAddress();
+        const key = this.config.getAESKey();
+        const path = `${browserId}${liveURLSep}${pageId}`;
+        const encoded = encrypt(path, key);
+        const query = `?id=${encoded}`;
+        return makeExternalURL(serverAddress, 'live', query);
+    };
+    onTargetCreated = async (target) => {
+        if (target.type() === 'page') {
+            const page = await target.page().catch((e) => {
+                this.debug(`Error in new page ${e}`);
+                return null;
+            });
+            if (page) {
+                if (!this.config.getAllowFileProtocol()) {
+                    this.debug(`Setting up file:// protocol request rejection`);
+                    page.on('request', async (request) => {
+                        if (request.url().startsWith('file://')) {
+                            this.debug(`File protocol request found in request, terminating`);
+                            page.close().catch(noop);
+                            this.close();
+                        }
+                    });
+                    page.on('response', async (response) => {
+                        if (response.url().startsWith('file://')) {
+                            this.debug(`File protocol request found in response, terminating`);
+                            page.close().catch(noop);
+                            this.close();
+                        }
+                    });
+                }
+                const browserId = this.wsEndpoint()?.split('/').pop();
+                await this.setUpEmbeddedAPI(page, browserId, this.record);
+                this.emit('newPage', page);
+            }
+        }
+    };
+    isRunning = () => this.running;
+    newPage = async () => {
+        if (!this.browser) {
+            throw new ServerError(`Browser hasn't been launched yet!`);
+        }
+        return this.browser.newPage();
+    };
+    close = async () => {
+        if (this.browser) {
+            this.debug(`Closing browser process and all listeners`);
+            this.emit('close');
+            this.cleanListeners();
+            this.browser.removeAllListeners();
+            this.browser.close();
+            this.running = false;
+            this.browser = null;
+            this.browserWSEndpoint = null;
+        }
+    };
+    pages = async () => this.browser?.pages() || [];
+    process = () => this.browser?.process() || null;
+    launch = async (options = {}) => {
+        this.port = await getPort();
+        this.debug(`Got open port ${this.port}`);
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        const finalOptions = {
+            ...options,
+            args: [
+                `--remote-debugging-port=${this.port}`,
+                `--no-sandbox`,
+                ...(options.args || []),
+                this.userDataDir ? `--user-data-dir=${this.userDataDir}` : '',
+            ].filter((_) => !!_),
+            executablePath: playwright.chromium.executablePath(),
+        };
+        if (this.record || this.blockAds) {
+            const requiredExtensionArgs = [];
+            // Necessary to load extensions
+            finalOptions.headless = false;
+            if (this.record) {
+                finalOptions.ignoreDefaultArgs = ['--enable-automation'];
+                requiredExtensionArgs.push('--enable-usermedia-screen-capturing', '--enable-blink-features=GetUserMedia', '--allow-http-screen-capture', '--auto-select-desktop-capture-source=browserless-screencast', '--disable-infobars');
+            }
+            const loadExtensionPaths = [
+                ...(this.record
+                    ? [path.join(__dirname, '..', '..', 'extensions', 'screencast')]
+                    : []),
+                ...(this.blockAds
+                    ? [path.join(__dirname, '..', '..', 'extensions', 'ublock')]
+                    : []),
+            ].join(',');
+            finalOptions.args.push(...requiredExtensionArgs, '--load-extension=' + loadExtensionPaths, '--disable-extensions-except=' + loadExtensionPaths);
+        }
+        const launch = options.stealth
+            ? puppeteerStealth.launch.bind(puppeteerStealth)
+            : puppeteer.launch.bind(puppeteer);
+        this.debug(finalOptions, `Launching CDP Chrome Handler`);
+        this.browser = (await launch(finalOptions));
+        this.browser.on('targetcreated', this.onTargetCreated);
+        this.running = true;
+        this.browserWSEndpoint = this.browser.wsEndpoint();
+        this.debug(`Browser is running on ${this.browserWSEndpoint}`);
+        return this.browser;
+    };
+    wsEndpoint = () => this.browserWSEndpoint;
+    publicWSEndpoint = (token) => {
+        if (!this.browserWSEndpoint) {
+            return null;
+        }
+        const wsURL = new URL(this.browserWSEndpoint);
+        const serverURL = new URL(this.config.getExternalAddress());
+        wsURL.hostname = serverURL.hostname;
+        wsURL.port = serverURL.port;
+        wsURL.protocol = serverURL.protocol === 'https' ? 'wss' : 'ws';
+        if (token) {
+            wsURL.searchParams.set('token', token);
+        }
+        return wsURL.href;
+    };
+    proxyPageWebSocket = async (req, socket, head) => new Promise(async (resolve, reject) => {
+        if (!this.browserWSEndpoint || !this.browser) {
+            throw new ServerError(`No browserWSEndpoint found, did you launch first?`);
+        }
+        socket.once('close', resolve);
+        this.debug(`Proxying ${req.parsed.href} to browser ${this.browserWSEndpoint}`);
+        const [page] = await this.browser.pages();
+        const pageLocation = `/devtools/page/${this.getPageId(page)}`;
+        this.debug(`Proxying ${req.parsed.href} to page "${pageLocation}"`);
+        req.url = pageLocation;
+        this.proxy.ws(req, socket, head, {
+            changeOrigin: true,
+            target: this.browserWSEndpoint,
+        }, (error) => {
+            this.debug(`Error proxying session: ${error}`);
+            this.close();
+            return reject(error);
+        });
+    });
+    proxyWebSocket = async (req, socket, head) => new Promise((resolve, reject) => {
+        if (!this.browserWSEndpoint) {
+            throw new ServerError(`No browserWSEndpoint found, did you launch first?`);
+        }
+        const close = once(() => {
+            this.browser?.off('close', close);
+            this.browser?.process()?.off('close', close);
+            socket.off('close', close);
+            return resolve();
+        });
+        this.browser?.once('close', close);
+        this.browser?.process()?.once('close', close);
+        socket.once('close', close);
+        this.debug(`Proxying ${req.parsed.href} to browser ${this.browserWSEndpoint}`);
+        req.url = '';
+        // Delete headers known to cause issues
+        delete req.headers.origin;
+        this.proxy.ws(req, socket, head, {
+            changeOrigin: true,
+            target: this.browserWSEndpoint,
+        }, (error) => {
+            this.debug(`Error proxying session: ${error}`);
+            this.close();
+            return reject(error);
+        });
+    });
+}

package/build/browsers/index.d.ts

@@ -0,0 +1,26 @@
+import { BrowserHTTPRoute, BrowserInstance, BrowserWebsocketRoute, BrowserlessSession, BrowserlessSessionJSON, Config, Request } from '@browserless.io/browserless';
+export declare class BrowserManager {
+    private config;
+    private browsers;
+    private launching;
+    private timers;
+    private debug;
+    constructor(config: Config);
+    private removeUserDataDir;
+    /**
+     * Generates a directory for the user-data-dir contents to be saved in. Uses
+     * the provided sessionId, or creates one when omitted,
+     * and appends it to the name of the directory. If the
+     * directory already exists then no action is taken, verified by run `stat`
+     *
+     * @param sessionId The ID of the session
+     * @returns Promise<string> of the fully-qualified path of the directory
+     */
+    private generateDataDir;
+    private generateSessionJson;
+    close: (browser: BrowserInstance, session: BrowserlessSession) => Promise<void>;
+    getAllSessions: (req: Request) => Promise<BrowserlessSessionJSON[]>;
+    complete: (browser: BrowserInstance) => Promise<void>;
+    getBrowserForRequest: (req: Request, router: BrowserHTTPRoute | BrowserWebsocketRoute) => Promise<BrowserInstance>;
+    stop: () => Promise<void>;
+}

package/build/browsers/index.js

@@ -0,0 +1,183 @@
+import { BadRequest, CDPChromium, HTTPManagementRoutes, NotFound, ServerError, browserHook, convertIfBase64, createLogger, exists, getTokenFromRequest, id, makeExternalURL, noop, pageHook, parseBooleanParam, } from '@browserless.io/browserless';
+import path, { join } from 'path';
+import { deleteAsync } from 'del';
+import { mkdir } from 'fs/promises';
+export class BrowserManager {
+    config;
+    browsers = new Map();
+    launching = new Map();
+    timers = new Map();
+    debug = createLogger('browser-manager');
+    constructor(config) {
+        this.config = config;
+    }
+    removeUserDataDir = async (userDataDir) => {
+        if (userDataDir && (await exists(userDataDir))) {
+            this.debug(`Deleting data directory "${userDataDir}"`);
+            await deleteAsync(userDataDir, { force: true }).catch((err) => {
+                this.debug(`Error cleaning up user-data-dir "${err}" at ${userDataDir}`);
+            });
+        }
+    };
+    /**
+     * Generates a directory for the user-data-dir contents to be saved in. Uses
+     * the provided sessionId, or creates one when omitted,
+     * and appends it to the name of the directory. If the
+     * directory already exists then no action is taken, verified by run `stat`
+     *
+     * @param sessionId The ID of the session
+     * @returns Promise<string> of the fully-qualified path of the directory
+     */
+    generateDataDir = async (sessionId = id()) => {
+        const baseDirectory = await this.config.getDataDir();
+        const dataDirPath = join(baseDirectory, `browserless-data-dir-${sessionId}`);
+        if (await exists(dataDirPath)) {
+            this.debug(`Data directory already exists, not creating "${dataDirPath}"`);
+            return dataDirPath;
+        }
+        this.debug(`Generating user-data-dir at ${dataDirPath}`);
+        await mkdir(dataDirPath, { recursive: true }).catch((err) => {
+            throw new ServerError(`Error creating data-directory "${dataDirPath}": ${err}`);
+        });
+        return dataDirPath;
+    };
+    generateSessionJson = (browser, session) => {
+        const serverAddress = this.config.getExternalAddress();
+        return {
+            ...session,
+            browser: browser.constructor.name,
+            browserId: browser.wsEndpoint()?.split('/').pop(),
+            initialConnectURL: new URL(session.initialConnectURL, serverAddress).href,
+            killURL: session.id
+                ? makeExternalURL(serverAddress, HTTPManagementRoutes.sessions, session.id)
+                : null,
+            running: browser.isRunning(),
+            timeAliveMs: Date.now() - session.startedOn,
+        };
+    };
+    close = async (browser, session) => {
+        const cleanupACtions = [];
+        this.debug(`${session.numbConnected} Client(s) are currently connected`);
+        this.debug(`Closing browser session`);
+        cleanupACtions.push(() => browser.close());
+        if (session.isTempDataDir) {
+            this.debug(`Deleting "${session.userDataDir}" user-data-dir and session from memory`);
+            this.browsers.delete(browser);
+            cleanupACtions.push(() => this.removeUserDataDir(session.userDataDir));
+        }
+        await Promise.all(cleanupACtions.map((a) => a()));
+    };
+    getAllSessions = async (req) => {
+        const sessions = Array.from(this.browsers);
+        const requestToken = getTokenFromRequest(req);
+        const token = this.config.getToken();
+        if (token && !requestToken) {
+            throw new BadRequest(`Couldn't locate your API token`);
+        }
+        return sessions.map(([browser, session]) => this.generateSessionJson(browser, session));
+    };
+    complete = async (browser) => {
+        const session = this.browsers.get(browser);
+        if (!session) {
+            this.debug(`Couldn't locate session for browser, proceeding with close`);
+            return browser.close();
+        }
+        const { id, resolver } = session;
+        if (id && resolver) {
+            resolver(null);
+            this.launching.delete(id);
+        }
+        --session.numbConnected;
+        this.close(browser, session);
+    };
+    getBrowserForRequest = async (req, router) => {
+        const { browser: Browser } = router;
+        const record = parseBooleanParam(req.parsed.searchParams, 'record', false);
+        const blockAds = parseBooleanParam(req.parsed.searchParams, 'blockAds', false);
+        const decodedLaunchOptions = convertIfBase64(req.parsed.searchParams.get('launch') || '{}');
+        let parsedLaunchOptions;
+        // Handle re-connects here:
+        if (req.parsed.pathname.includes('/devtools/browser')) {
+            const sessions = Array.from(this.browsers);
+            const id = req.parsed.pathname.split('/').pop();
+            const browser = sessions.find(([b]) => b.wsEndpoint()?.includes(req.parsed.pathname));
+            if (browser) {
+                this.debug(`Located browser with ID ${id}`);
+                return browser[0];
+            }
+            throw new NotFound(`Couldn't locate browser "${id}" for request "${req.parsed.pathname}"`);
+        }
+        try {
+            parsedLaunchOptions = JSON.parse(decodedLaunchOptions);
+        }
+        catch (err) {
+            throw new BadRequest(`Error parsing launch-options: ${err}. Launch options must be a JSON or base64-encoded JSON object`);
+        }
+        const requestToken = getTokenFromRequest(req);
+        const token = this.config.getToken();
+        if (token && !requestToken) {
+            throw new ServerError(`Error locating authorization token`);
+        }
+        const routerOptions = typeof router.defaultLaunchOptions === 'function'
+            ? router.defaultLaunchOptions(req)
+            : router.defaultLaunchOptions;
+        const launchOptions = {
+            ...routerOptions,
+            ...parsedLaunchOptions,
+        };
+        const manualUserDataDir = launchOptions.args
+            ?.find((arg) => arg.includes('--user-data-dir='))
+            ?.split('=')[2] || launchOptions.userDataDir;
+        // Always specify a user-data-dir since plugins can "inject" their own
+        // unless it's playwright which takes care of its own data-dirs
+        const userDataDir = manualUserDataDir ||
+            (Browser.name === CDPChromium.name ? await this.generateDataDir() : null);
+        const proxyServerArg = launchOptions.args?.find((arg) => arg.includes('--proxy-server='));
+        if (launchOptions.args &&
+            proxyServerArg &&
+            req.parsed.pathname.startsWith('/playwright')) {
+            launchOptions.proxy = {
+                server: proxyServerArg.split('=')[1],
+            };
+            const argIndex = launchOptions.args.indexOf(proxyServerArg);
+            launchOptions.args.splice(argIndex, 1);
+        }
+        const browser = new Browser({
+            blockAds,
+            config: this.config,
+            record,
+            userDataDir,
+        });
+        const connectionMeta = {
+            id: null,
+            initialConnectURL: path.join(req.parsed.pathname, req.parsed.search) || '',
+            isTempDataDir: !manualUserDataDir,
+            launchOptions,
+            numbConnected: 1,
+            resolver: noop,
+            routePath: router.path,
+            startedOn: Date.now(),
+            ttl: 0,
+            userDataDir,
+        };
+        this.browsers.set(browser, connectionMeta);
+        await browser.launch(launchOptions);
+        await browserHook({ browser, meta: req.parsed });
+        browser.on('newPage', async (page) => {
+            await pageHook({ meta: req.parsed, page });
+            (router.onNewPage || noop)(req.parsed || '', page);
+        });
+        return browser;
+    };
+    stop = async () => {
+        this.debug(`Closing down browser instances`);
+        const sessions = Array.from(this.browsers);
+        await Promise.all(sessions.map(([b]) => b.close()));
+        const timers = Array.from(this.timers);
+        await Promise.all(timers.map(([, timer]) => clearInterval(timer)));
+        this.timers.forEach((t) => clearTimeout(t));
+        this.browsers = new Map();
+        this.timers = new Map();
+        this.debug(`Shutdown complete`);
+    };
+}

package/build/browsers/playwright-chromium.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { BrowserServerOptions, Config, Request } from '@browserless.io/browserless';
+import playwright, { Page } from 'playwright-core';
+import { Duplex } from 'stream';
+import { EventEmitter } from 'events';
+export declare class PlaywrightChromium extends EventEmitter {
+    private config;
+    private userDataDir;
+    private record;
+    private running;
+    private proxy;
+    private browser;
+    private browserWSEndpoint;
+    private debug;
+    constructor({ config, userDataDir, record, }: {
+        config: Config;
+        record: boolean;
+        userDataDir: PlaywrightChromium['userDataDir'];
+    });
+    private cleanListeners;
+    isRunning: () => boolean;
+    close: () => Promise<void>;
+    pages: () => Promise<[]>;
+    getPageId: () => string;
+    makeLiveURL: () => void;
+    newPage: () => Promise<Page>;
+    launch: (options?: BrowserServerOptions) => Promise<playwright.BrowserServer>;
+    wsEndpoint: () => string | null;
+    publicWSEndpoint: (token: string) => string | null;
+    proxyPageWebSocket: () => Promise<void>;
+    proxyWebSocket: (req: Request, socket: Duplex, head: Buffer) => Promise<void>;
+}

package/build/browsers/playwright-chromium.js

@@ -0,0 +1,106 @@
+import { ServerError, createLogger, } from '@browserless.io/browserless';
+import playwright from 'playwright-core';
+import { EventEmitter } from 'events';
+import httpProxy from 'http-proxy';
+export class PlaywrightChromium extends EventEmitter {
+    config;
+    userDataDir;
+    record;
+    running = false;
+    proxy = httpProxy.createProxyServer();
+    browser = null;
+    browserWSEndpoint = null;
+    debug = createLogger('browsers:playwright:chromium');
+    constructor({ config, userDataDir, record, }) {
+        super();
+        this.userDataDir = userDataDir;
+        this.config = config;
+        this.record = record;
+        this.debug(`Starting new browser instance`);
+    }
+    cleanListeners() {
+        this.removeAllListeners();
+    }
+    isRunning = () => this.running;
+    close = async () => {
+        if (this.browser) {
+            this.debug(`Closing browser process and all listeners`);
+            this.emit('close');
+            this.cleanListeners();
+            this.browser.close();
+            this.running = false;
+            this.browser = null;
+            this.browserWSEndpoint = null;
+        }
+    };
+    pages = async () => [];
+    getPageId = () => {
+        throw new ServerError(`#getPageId is not yet supported with this browser.`);
+    };
+    makeLiveURL = () => {
+        throw new ServerError(`Live URLs are not yet supported with this browser. In the future this will be at "${this.config.getExternalAddress()}"`);
+    };
+    newPage = async () => {
+        if (!this.browser || !this.browserWSEndpoint) {
+            throw new ServerError(`Browser hasn't been launched yet!`);
+        }
+        const browser = await playwright.chromium.connect(this.browserWSEndpoint);
+        return await browser.newPage();
+    };
+    launch = async (options = {}) => {
+        this.debug(`Launching Chrome Handler`);
+        if (this.record) {
+            throw new ServerError(`Recording is not yet available with this browser`);
+        }
+        this.browser = await playwright.chromium.launchServer({
+            ...options,
+            args: [
+                `--no-sandbox`,
+                ...(options.args || []),
+                this.userDataDir ? `--user-data-dir=${this.userDataDir}` : '',
+            ],
+            executablePath: playwright.chromium.executablePath(),
+        });
+        const browserWSEndpoint = this.browser.wsEndpoint();
+        this.debug(`Browser is running on ${browserWSEndpoint}`);
+        this.running = true;
+        this.browserWSEndpoint = browserWSEndpoint;
+        return this.browser;
+    };
+    wsEndpoint = () => this.browserWSEndpoint;
+    publicWSEndpoint = (token) => {
+        if (!this.browserWSEndpoint) {
+            return null;
+        }
+        const wsURL = new URL(this.browserWSEndpoint);
+        const serverURL = new URL(this.config.getExternalAddress());
+        wsURL.hostname = serverURL.hostname;
+        wsURL.port = serverURL.port;
+        wsURL.protocol = serverURL.protocol === 'https' ? 'wss' : 'ws';
+        if (token) {
+            wsURL.searchParams.set('token', token);
+        }
+        return wsURL.href;
+    };
+    proxyPageWebSocket = async () => {
+        console.warn(`Not yet implemented`);
+    };
+    proxyWebSocket = async (req, socket, head) => new Promise((resolve, reject) => {
+        if (!this.browserWSEndpoint) {
+            throw new ServerError(`No browserWSEndpoint found, did you launch first?`);
+        }
+        socket.once('close', resolve);
+        this.debug(`Proxying ${req.parsed.href} to browser ${this.browserWSEndpoint}`);
+        // Delete headers known to cause issues
+        delete req.headers.origin;
+        req.url = '';
+        this.proxy.ws(req, socket, head, {
+            changeOrigin: true,
+            target: this.browserWSEndpoint,
+        }, (error) => {
+            this.debug(`Error proxying session: ${error}`);
+            this.close();
+            return reject(error);
+        });
+    });
+}

package/build/browsers/playwright-firefox.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { BrowserServerOptions, Config, Request } from '@browserless.io/browserless';
+import playwright, { Page } from 'playwright-core';
+import { Duplex } from 'stream';
+import { EventEmitter } from 'events';
+export declare class PlaywrightFirefox extends EventEmitter {
+    private config;
+    private userDataDir;
+    private record;
+    private running;
+    private proxy;
+    private browser;
+    private browserWSEndpoint;
+    private debug;
+    constructor({ config, userDataDir, record, }: {
+        config: Config;
+        record: boolean;
+        userDataDir: PlaywrightFirefox['userDataDir'];
+    });
+    private cleanListeners;
+    isRunning: () => boolean;
+    close: () => Promise<void>;
+    pages: () => Promise<[]>;
+    getPageId: () => string;
+    makeLiveURL: () => void;
+    newPage: () => Promise<Page>;
+    launch: (options?: BrowserServerOptions) => Promise<playwright.BrowserServer>;
+    wsEndpoint: () => string | null;
+    publicWSEndpoint: (token: string) => string | null;
+    proxyPageWebSocket: () => Promise<void>;
+    proxyWebSocket: (req: Request, socket: Duplex, head: Buffer) => Promise<void>;
+}