@browserless.io/browserless 2.0.0-beta-1

package/LICENSE

@@ -0,0 +1,6 @@
+# License
+
+This work is dual-licensed under the MongoDB Server-Side Public License OR the browserless commercial license.
+You can choose between one of them if you use this work.
+
+`SPDX-License-Identifier: SSPL-1.0 OR Browserless Commercial License`

package/README.md

@@ -0,0 +1,132 @@
+![browserless.io logo](/assets/logo.png)
+
+![Docker Pulls](https://img.shields.io/docker/pulls/browserless/chrome)
+![GitHub package.json version (subfolder of monorepo)](https://img.shields.io/github/package-json/v/browserless/chrome)
+![Chrome CI](https://github.com/browserless/chrome/actions/workflows/docker-chromium.yml/badge.svg)
+![Firefox CI](https://github.com/browserless/chrome/actions/workflows/docker-firefox.yml/badge.svg)
+![Webkit CI](https://github.com/browserless/chrome/actions/workflows/docker-webkit.yml/badge.svg)
+![Multi CI](https://github.com/browserless/chrome/actions/workflows/docker-multi.yml/badge.svg)
+
+
+> [Looking for v1.x.x of browserless? Check it out here](https://github.com/browserless/chrome/tree/v1).
+> NOTE: Version 1 is the version we currently still have running on browserless' hosted services.
+
+browserless is a web-based service that allows for remote clients to connect and execute headless work; all inside of docker. It supports new libraries like Puppeteer and Playwright, aiming to replace antiquated or in-house systems. We also bundle numerous handy REST-based APIs for doing more common actions like data collection, PDF generation and more.
+
+We also take care of other common issues such as missing system-fonts, missing external libraries, and performance improvements. We even handle edge-cases like downloading files, managing sessions, and have a full documentation site built into the project which includes Open API docs.
+
+If you've been struggling to get a browser up and running docker, or scaling out your headless workloads, then browserless was built for you.
+# Table of Contents
+
+1. [Features](#features)
+2. [How it works](#how-it-works)
+3. [Docker](#docker)
+4. [Hosting](#hosting-providers)
+5. [Puppeteer](#puppeteer)
+6. [Playwright](#playwright)
+7. [Licensing](#licensing)
+8. [Changelog](https://github.com/browserless/chrome/blob/master/CHANGELOG.md)
+
+## External links
+
+1. [Full documentation site](https://www.browserless.io/docs/start)
+2. [Live Debugger (using browserless.io)](https://chrome.browserless.io/)
+3. [Docker](https://github.com/browserless/chrome/pkgs/container/basic)
+4. [Slack](https://join.slack.com/t/browserless/shared_invite/enQtMzA3OTMwNjA3MzY1LTRmMWU5NjQ0MTQ2YTE2YmU3MzdjNmVlMmU4MThjM2UxODNmNzNlZjVkY2U2NjdkMzYyNTgyZTBiMmE3Nzg0MzY)
+
+# Features
+
+- Parallelism and request-queueing are built-in + configurable.
+- Fonts and emoji's working out-of-the-box.
+- Debug Viewer for actively viewing/debugging running sessions.
+- An interactive puppeteer debugger, so you can see what the headless browser is doing and use its DevTools.
+- Works with most headless libraries.
+- Configurable session timers and health-checks to keep things running smoothly.
+- Error tolerant: if Chrome dies it won't.
+- [Support for running and development on Apple's M1 machines](#building-for-arm64-apple-m1-machines)
+
+# How it works
+
+browserless listens for both incoming websocket requests, generally issued by most libraries, as well as pre-build REST APIs to do common functions (PDF generation, images and so on). When a websocket connects to browserless it starts Chrome and proxies your request into it. Once the session is done then it closes and awaits for more connections. Some libraries use Chrome's HTTP endpoints, like `/json` to inspect debug-able targets, which browserless also supports.
+
+You still execute the script itself which gives you total control over what library you want to choose and when to do upgrades. This also comes with the benefit of keep your code proprietary and able to run on numerous platforms. We simply take care of all the browser-aspects and offer a management layer on top of the browser.
+
+# Docker
+
+> See more options on our [full documentation site](https://www.browserless.io/docs/docker-quickstart).
+
+1. `docker run -p 3000:3000 ghcr.io/browserless/chrome`
+2. Visit `http://localhost:3000/docs` to see the documentation site.
+3. See more at our [docker package](https://github.com/browserless/chrome/pkgs/container/basic).
+
+# Hosting Providers
+
+We offer a first-class hosted product located [here](https://browserless.io). Alternatively you can host this image on just about any major platform that offers hosting for docker. Our hosted service takes care of all the machine provisioning, notifications, dashboards and monitoring plus more:
+
+- Easily upgrade and toggle between versions at the press of a button. No managing repositories and other code artifacts.
+- Never need to update or pull anything from docker. There's literally zero software to install to get started.
+- Scale your consumption up or down with different plans. We support up to thousands of concurrent sessions at a given time.
+
+If you're interested in using this image for commercial aspects, then please read the below section on licensing.
+
+# Puppeteer
+
+Puppeteer allows you to specify a remote location for chrome via the `browserWSEndpoint` option. Setting this for browserless is a single line of code change.
+
+**Before**
+```js
+const browser = await puppeteer.launch();
+```
+
+**After**
+```js
+const browser = await puppeteer.connect({ browserWSEndpoint: 'ws://localhost:3000' });
+```
+
+# Playwright
+
+We support running with playwright via their remote connection method on the `chromium` interface. Since playwright is very similar to puppeteer, even launch arguments and other things "just work":
+
+**Before**
+```js
+const browser = await pw.chromium.launch();
+```
+
+**After**
+```js
+const browser = await pw.chromium.connect('ws://localhost:3000/playwright/chromium');
+
+// OR
+const browser = await pw.chromium.connectOverCDP('ws://localhost:3000');
+```
+
+After that, the rest of your code remains the same with no other changes required.
+
+# Usage with other libraries
+
+Most libraries allow you to specify a remote instance of Chrome to interact with. They are either looking for a websocket endpoint, a host and port, or some address. Browserless supports these by default, however if you're having issues please make an issue in this project and we'll try and work with the library authors to get them integrated with browserless. Please note that in V2 we no longer support selenium or webdriver integrations.
+
+You can find a much larger list of supported libraries [on our documentation site](https://www.browserless.io/docs/puppeteer-library).
+
+# Motivations
+
+Running Chrome on lambda or on your own is a fantastic idea but in practice is quite challenging in production. You're met with pretty tough cloud limits, possibly building Chrome yourself, and then dealing with odd invocation issues should everything else go ok. A lot of issues in various repositories are due to just challenges of getting Chrome running smoothly in AWS (see [here](https://github.com/GoogleChrome/puppeteer/issues?q=is%3Aissue+is%3Aopen+sort%3Acomments-desc)). You can see for yourself by going to nearly any library and sorting issues by most commented.
+
+Getting Chrome running well in docker is also a challenge as there's quiet a few packages you need in order to get Chrome running. Once that's done then there's still missing fonts, getting libraries to work with it, and having limitations on service reliability. This is also ignoring CVEs, access-controls, and scaling strategies.
+
+All of these issues prompted us to build a first-class image and workflow for interacting with Chrome in a more streamlined way. With browserless you never have to worry about fonts, extra packages, library support, security, or anything else. It just works reliably like any other modern web service. On top of that it comes with a prescribed approach on how you interact with Chrome, which is through socket connections (similar to a database or any other external appliance). What this means is that you get the ability to drive Chrome remotely without having to do updates/releases to the thing that runs Chrome since it's divorced from your application.
+
+# Licensing
+
+SPDX-License-Identifier: SSPL-1.0 OR Browserless Commercial License.
+
+If you want to use browserless to build commercial sites, applications, or in a continuous-integration system that's closed-source then you'll need to purchase a commercial license. This allows you to keep your software proprietary whilst still using browserless. [You can purchase a commercial license here](https://www.browserless.io/contact). A commercial license grants you:
+
+- Priority support on issues and features.
+- On-premise running as well as running on public cloud providers for commercial/CI purposes for proprietary systems.
+- Ability to modify the source (forking) for your own purposes.
+- A new admin user-interface.
+
+Not only does it grant you a license to run such a critical piece of infrastructure, but you are also supporting further innovation in this space and our ability to contribute to it.
+
+If you are creating an open source application under a license compatible with the Server Side License 1.0, you may use browserless under those terms.

package/bin/browserless.js

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+/* eslint-disable no-undef */
+'use strict';
+import { Browserless } from '@browserless.io/browserless';
+import buildOpenAPI from '../scripts/build-open-api.js';
+import buildSchemas from '../scripts/build-schemas.js';
+
+import debug from 'debug';
+import { fileURLToPath } from 'url';
+import fs from 'fs/promises';
+import path from 'path';
+import { spawn } from 'child_process';
+
+const log = debug('browserless:sdk:log');
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const cmd = process.argv[2];
+const cwd = process.cwd();
+const allowedCMDs = ['build', 'dev', 'docker', 'start'];
+const srcDir = path.join(cwd, 'build');
+
+if (!allowedCMDs.includes(cmd)) {
+  throw new Error(
+    `Unknown command of "${cmd}". Is your @browserless.io/browserless package up to date?`,
+  );
+}
+
+const importClassOverride = async (files, className) => {
+  const classModuleFile = files.find((f) =>
+    path.parse(f).name.endsWith(className),
+  );
+
+  if (!classModuleFile) {
+    return;
+  }
+
+  const classModuleFullFilePath = path.join(srcDir, classModuleFile);
+
+  if (!classModuleFile) {
+    return;
+  }
+  log(`Importing module override "${classModuleFullFilePath}"`);
+  return (await import(classModuleFullFilePath)).default;
+};
+
+const buildTypeScript = async () =>
+  new Promise((resolve, reject) => {
+    spawn('npx', ['tsc', '--outDir', 'build'], {
+      cwd,
+      stdio: 'inherit',
+    }).once('close', (code) => {
+      if (code === 0) {
+        return resolve();
+      }
+      return reject(
+        `Error in building TypeScript, see output for more details`,
+      );
+    });
+  });
+
+const getSourceFiles = async () => {
+  const files = await fs.readdir(srcDir);
+  const [httpRoutes, webSocketRoutes] = files.reduce(
+    ([httpRoutes, webSocketRoutes], file) => {
+      const parsed = path.parse(file);
+      if (parsed.name.endsWith('http')) {
+        httpRoutes.push(path.join(srcDir, file));
+      }
+
+      if (parsed.name.endsWith('ws')) {
+        webSocketRoutes.push(path.join(srcDir, file));
+      }
+
+      return [httpRoutes, webSocketRoutes];
+    },
+    [[], []],
+  );
+
+  return {
+    files,
+    httpRoutes,
+    webSocketRoutes,
+  };
+};
+
+/**
+ * Build
+ * Responsible for compiling TypeScript, generating routes meta-data
+ * and validation. Doesn't start the HTTP server.
+ */
+const build = async () => {
+  log(`Compiling TypeScript`);
+  await buildTypeScript();
+
+  log(`Building custom routes`);
+  const { files, httpRoutes, webSocketRoutes } = await getSourceFiles();
+
+  log(`Building route runtime schema validation`);
+  await buildSchemas(
+    httpRoutes.map((f) => f.replace('.js', '.d.ts')),
+    webSocketRoutes.map((f) => f.replace('.js', '.d.ts')),
+  );
+
+  log(`Generating OpenAPI JSON file`);
+  await buildOpenAPI(httpRoutes, webSocketRoutes);
+
+  log(`All built assets complete`);
+
+  return {
+    files,
+    httpRoutes,
+    webSocketRoutes,
+  };
+};
+
+const start = async (dev = false) => {
+  const { httpRoutes, webSocketRoutes, files } = dev
+    ? await build()
+    : await getSourceFiles();
+
+  log(`Importing all class overrides if present`);
+  const [
+    browserManager,
+    config,
+    fileSystem,
+    limiter,
+    metrics,
+    monitoring,
+    webhooks,
+  ] = await Promise.all([
+    importClassOverride(files, 'browser-manager'),
+    importClassOverride(files, 'config'),
+    importClassOverride(files, 'file-system'),
+    importClassOverride(files, 'limiter'),
+    importClassOverride(files, 'metrics'),
+    importClassOverride(files, 'monitoring'),
+    importClassOverride(files, 'webhooks'),
+  ]);
+
+  log(`Starting Browserless`);
+  const browserless = new Browserless({
+    browserManager,
+    config,
+    fileSystem,
+    limiter,
+    metrics,
+    monitoring,
+    webhooks,
+  });
+
+  httpRoutes.forEach((r) => browserless.addHTTPRoute(r));
+  webSocketRoutes.forEach((r) => browserless.addWebSocketRoute(r));
+
+  log(`Starting Browserless HTTP Service`);
+  browserless.start();
+
+  log(`Binding signal interruption handlers and uncaught errors`);
+  process
+    .on('unhandledRejection', async (reason, promise) => {
+      console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+    })
+    .once('uncaughtException', async (err, origin) => {
+      console.error('Unhandled exception at:', origin, 'error:', err);
+      await browserless.stop();
+      process.exit(1);
+    })
+    .once('SIGTERM', async () => {
+      debug(`SIGTERM received, saving and closing down`);
+      await browserless.stop();
+      process.exit(0);
+    })
+    .once('SIGINT', async () => {
+      debug(`SIGINT received, saving and closing down`);
+      await browserless.stop();
+      process.exit(0);
+    })
+    .once('SIGHUP', async () => {
+      debug(`SIGHUP received, saving and closing down`);
+      await browserless.stop();
+      process.exit(0);
+    })
+    .once('SIGUSR2', async () => {
+      debug(`SIGUSR2 received, saving and closing down`);
+      await browserless.stop();
+      process.exit(0);
+    })
+    .once('exit', () => {
+      debug(`Process is finished, exiting`);
+      process.exit(0);
+    });
+};
+
+const buildDocker = async () => {
+  const from = process.argv[3] ?? 'ghcr.io/browserless/multi';
+  const version = process.argv[4] ?? 'latest';
+  const finalDockerPath = path.join(cwd, 'build', 'Dockerfile');
+
+  const dockerContents = (
+    await fs.readFile(path.join(__dirname, '..', 'docker', 'sdk', 'Dockerfile'))
+  ).toString();
+
+  log(`Creating Dockerfile in "${finalDockerPath}"`);
+  await fs.writeFile(
+    path.join(cwd, 'build', 'Dockerfile'),
+    dockerContents,
+  );
+
+  log(`Building docker image from repo: "${from}:${version}"`);
+};
+
+switch (cmd) {
+  case 'start':
+    start(false);
+    break;
+
+  case 'dev':
+    start(true);
+    break;
+
+  case 'build':
+    build();
+    break;
+
+  case 'docker':
+    buildDocker();
+    break;
+}

package/browser.json

@@ -0,0 +1,7 @@
+{
+  "Browser": "HeadlessChrome/120.0.6099.28",
+  "Protocol-Version": "1.3",
+  "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) HeadlessChrome/120.0.6099.28 Safari/537.36",
+  "WebKit-Version": "537.36 (@f4095e9665f7d7a2531edefcea119d45d899d95b)",
+  "webSocketDebuggerUrl": "ws://localhost:3000"
+}

package/build/browserless.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { BrowserManager, Config, FileSystem, HTTPServer, Limiter, Metrics, Monitoring, WebHooks } from '@browserless.io/browserless';
+export declare class Browserless {
+    private config;
+    private monitoring;
+    private metrics;
+    private fileSystem;
+    private browserManager;
+    private limiter;
+    private webhooks;
+    private debug;
+    webSocketRouteFiles: string[];
+    httpRouteFiles: string[];
+    server?: HTTPServer;
+    metricsSaveInterval: number;
+    metricsSaveIntervalID?: NodeJS.Timer;
+    constructor({ browserManager, config, monitoring, limiter, metrics, fileSystem, webhooks, }?: {
+        browserManager?: BrowserManager;
+        config?: Config;
+        fileSystem?: FileSystem;
+        limiter?: Limiter;
+        metrics?: Metrics;
+        monitoring?: Monitoring;
+        webhooks?: WebHooks;
+    });
+    private saveMetrics;
+    setMetricsSaveInterval: (interval: number) => void;
+    addHTTPRoute(httpRouteFilePath: string): void;
+    addWebSocketRoute(webSocketRouteFilePath: string): void;
+    setPort(port: number): void;
+    stop(): Promise<[void | undefined]>;
+    start(): Promise<void>;
+}

package/build/browserless.js

@@ -0,0 +1,146 @@
+import * as path from 'path';
+import { BrowserManager, Config, FileSystem, HTTPServer, Limiter, Metrics, Monitoring, WebHooks, availableBrowsers, createLogger, getRouteFiles, makeExternalURL, printLogo, safeParse, } from '@browserless.io/browserless';
+import { readFile } from 'fs/promises';
+import { userInfo } from 'os';
+const routeSchemas = ['body', 'query'];
+export class Browserless {
+    config;
+    monitoring;
+    metrics;
+    fileSystem;
+    browserManager;
+    limiter;
+    webhooks;
+    debug = createLogger('index');
+    webSocketRouteFiles = [];
+    httpRouteFiles = [];
+    server;
+    metricsSaveInterval = 5 * 60 * 1000;
+    metricsSaveIntervalID;
+    constructor({ browserManager, config, monitoring, limiter, metrics, fileSystem, webhooks, } = {}) {
+        this.config = config || new Config();
+        this.metrics = metrics || new Metrics();
+        this.webhooks = webhooks || new WebHooks(this.config);
+        this.browserManager = browserManager || new BrowserManager(this.config);
+        this.monitoring = monitoring || new Monitoring(this.config);
+        this.fileSystem = fileSystem || new FileSystem(this.config);
+        this.limiter =
+            limiter ||
+                new Limiter(this.config, this.metrics, this.monitoring, this.webhooks);
+    }
+    saveMetrics = async () => {
+        const metricsPath = this.config.getMetricsJSONPath();
+        const { cpu, memory } = await this.monitoring.getMachineStats();
+        const metrics = await this.metrics.get();
+        const aggregatedStats = {
+            ...metrics,
+            cpu,
+            memory,
+        };
+        this.metrics.reset();
+        this.debug(`Current period usage: ${JSON.stringify({
+            date: aggregatedStats.date,
+            error: aggregatedStats.error,
+            maxConcurrent: aggregatedStats.maxConcurrent,
+            maxTime: aggregatedStats.maxTime,
+            meanTime: aggregatedStats.meanTime,
+            minTime: aggregatedStats.minTime,
+            rejected: aggregatedStats.rejected,
+            successful: aggregatedStats.successful,
+            timedout: aggregatedStats.timedout,
+            totalTime: aggregatedStats.totalTime,
+            units: aggregatedStats.units,
+        })}`);
+        if (metricsPath) {
+            this.debug(`Saving metrics to "${metricsPath}"`);
+            this.fileSystem.append(metricsPath, JSON.stringify(aggregatedStats));
+        }
+    };
+    setMetricsSaveInterval = (interval) => {
+        if (interval <= 0) {
+            return console.warn(`Interval value of "${interval}" must be greater than 1. Ignoring`);
+        }
+        clearInterval(this.metricsSaveInterval);
+        this.metricsSaveInterval = interval;
+        this.metricsSaveIntervalID = setInterval(this.saveMetrics, this.metricsSaveInterval);
+    };
+    addHTTPRoute(httpRouteFilePath) {
+        this.httpRouteFiles.push(httpRouteFilePath);
+    }
+    addWebSocketRoute(webSocketRouteFilePath) {
+        this.webSocketRouteFiles.push(webSocketRouteFilePath);
+    }
+    setPort(port) {
+        if (this.server) {
+            throw new Error(`Server is already instantiated and bound to port ${this.config.getPort()}`);
+        }
+        this.config.setPort(port);
+    }
+    async stop() {
+        clearInterval(this.metricsSaveIntervalID);
+        return Promise.all([this.server?.stop()]);
+    }
+    async start() {
+        const httpRoutes = [];
+        const wsRoutes = [];
+        const [[httpRouteFiles, wsRouteFiles], installedBrowsers] = await Promise.all([getRouteFiles(this.config), availableBrowsers]);
+        const docsLink = makeExternalURL(this.config.getExternalAddress(), '/docs');
+        this.debug(printLogo(docsLink));
+        this.debug(`Running as user "${userInfo().username}"`);
+        this.debug('Starting import of HTTP Routes');
+        for (const httpRoute of [...httpRouteFiles, ...this.httpRouteFiles]) {
+            if (httpRoute.endsWith('js')) {
+                const { name } = path.parse(httpRoute);
+                const [bodySchema, querySchema] = await Promise.all(routeSchemas.map(async (schemaType) => {
+                    const schemaPath = path.parse(httpRoute);
+                    schemaPath.base = `${schemaPath.name}.${schemaType}.json`;
+                    return await readFile(path.format(schemaPath), 'utf-8').catch(() => '');
+                }));
+                const routeImport = `${this.config.getIsWin() ? 'file:///' : ''}${httpRoute}`;
+                const logger = createLogger(`http:${name}`);
+                const { default: route } = await import(routeImport + `?cb=${Date.now()}`);
+                route.bodySchema = safeParse(bodySchema);
+                route.querySchema = safeParse(querySchema);
+                route._config = () => this.config;
+                route._metrics = () => this.metrics;
+                route._monitor = () => this.monitoring;
+                route._fileSystem = () => this.fileSystem;
+                route._debug = () => logger;
+                httpRoutes.push(route);
+            }
+        }
+        this.debug('Starting import of WebSocket Routes');
+        for (const wsRoute of [...wsRouteFiles, ...this.webSocketRouteFiles]) {
+            if (wsRoute.endsWith('js')) {
+                const { name } = path.parse(wsRoute);
+                const [, querySchema] = await Promise.all(routeSchemas.map(async (schemaType) => {
+                    const schemaPath = path.parse(wsRoute);
+                    schemaPath.base = `${schemaPath.name}.${schemaType}.json`;
+                    return await readFile(path.format(schemaPath), 'utf-8').catch(() => '');
+                }));
+                const wsImport = `${this.config.getIsWin() ? 'file:///' : ''}${wsRoute}`;
+                const logger = createLogger(`ws:${name}`);
+                const { default: route, } = await import(wsImport + `?cb=${Date.now()}`);
+                route.querySchema = safeParse(querySchema);
+                route._config = () => this.config;
+                route._metrics = () => this.metrics;
+                route._monitor = () => this.monitoring;
+                route._fileSystem = () => this.fileSystem;
+                route._debug = () => logger;
+                wsRoutes.push(route);
+            }
+        }
+        // Validate that browsers are installed and route paths are unique
+        [...httpRoutes, ...wsRoutes].forEach((route) => {
+            if (route.browser &&
+                !installedBrowsers.some((b) => b.name === route.browser.name)) {
+                throw new Error(`Couldn't load route "${route.path}" due to missing browser of "${route.browser.name}"`);
+            }
+        });
+        this.debug(`Imported and validated all route files, starting up server.`);
+        this.server = new HTTPServer(this.config, this.metrics, this.browserManager, this.limiter, httpRoutes, wsRoutes);
+        await this.server.start();
+        this.debug(`Starting metrics collection.`);
+        this.metricsSaveIntervalID = setInterval(() => this.saveMetrics(), this.metricsSaveInterval);
+    }
+}

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

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { CDPLaunchOptions, Config, Request } from '@browserless.io/browserless';
+import { Browser, Page } from 'puppeteer-core';
+import { Duplex } from 'stream';
+import { EventEmitter } from 'events';
+export declare class CDPChromium extends EventEmitter {
+    private config;
+    private userDataDir;
+    private record;
+    private blockAds;
+    private running;
+    private browser;
+    private browserWSEndpoint;
+    private port?;
+    private debug;
+    private proxy;
+    constructor({ userDataDir, config, record, blockAds, }: {
+        blockAds: boolean;
+        config: Config;
+        record: boolean;
+        userDataDir: CDPChromium['userDataDir'];
+    });
+    private cleanListeners;
+    private setUpEmbeddedAPI;
+    getPageId: (page: Page) => string;
+    makeLiveURL: (browserId: string, pageId: string) => string;
+    private onTargetCreated;
+    isRunning: () => boolean;
+    newPage: () => Promise<Page>;
+    close: () => Promise<void>;
+    pages: () => Promise<Page[]>;
+    process: () => import("child_process").ChildProcess | null;
+    launch: (options?: CDPLaunchOptions) => Promise<Browser>;
+    wsEndpoint: () => string | null;
+    publicWSEndpoint: (token: string) => string | null;
+    proxyPageWebSocket: (req: Request, socket: Duplex, head: Buffer) => Promise<void>;
+    proxyWebSocket: (req: Request, socket: Duplex, head: Buffer) => Promise<void>;
+}