@browserless.io/browserless 2.0.0-beta-1 → 2.0.0-beta-2

package/build/routes/management/http/metrics-get.js

@@ -7,7 +7,7 @@ const route = {
     contentTypes: [contentTypes.json],
     description: `Gets total metric details from the time the server started.`,
     handler: async (_req, res) => {
-        const { _fileSystem, _config } = route;
+        const { getFileSystem: _fileSystem, getConfig: _config } = route;
         if (!_fileSystem || !_config) {
             throw new ServerError(`Couldn't locate the file-system or config module`);
         }

package/build/routes/management/http/metrics-total-get.js

@@ -8,7 +8,7 @@ const route = {
     contentTypes: [contentTypes.json],
     description: `Gets total metric details summed from the time the server started.`,
     handler: async (_req, res) => {
-        const { _fileSystem, _config } = route;
+        const { getFileSystem: _fileSystem, getConfig: _config } = route;
         if (!_fileSystem || !_config) {
             throw new ServerError(`Couldn't locate the file-system or config module`);
         }

package/build/routes/management/http/sessions-get.js

@@ -6,12 +6,12 @@ const route = {
     concurrency: false,
     contentTypes: [contentTypes.json],
     description: `Lists all currently running sessions and relevant meta-data excluding potentially open pages.`,
-    handler: async (req, res) => {
-        const { _browserManager: browserManager } = route;
+    handler: async (_req, res) => {
+        const { getBrowserManager: browserManager } = route;
         if (!browserManager) {
             throw new BadRequest(`Couldn't load browsers running`);
         }
-        const response = await browserManager().getAllSessions(req);
+        const response = await browserManager().getAllSessions();
         return jsonResponse(res, 200, response);
     },
     method: Methods.get,

package/build/routes/management/http/static-get.js

@@ -28,7 +28,7 @@ const route = {
     contentTypes: [contentTypes.any],
     description: `Serves static files inside of this "static" directory. Content-types will vary depending on the type of file being returned.`,
     handler: async (req, res) => {
-        const { _config: getConfig } = route;
+        const { getConfig: getConfig } = route;
         const { pathname } = req.parsed;
         const fileCache = pathMap.get(pathname);
         if (fileCache) {

package/build/server.d.ts

@@ -1,4 +1,10 @@
-import { BrowserHTTPRoute, BrowserManager, BrowserWebsocketRoute, Config, HTTPRoute, Limiter, Metrics, WebSocketRoute } from '@browserless.io/browserless';
+/// <reference types="node" />
+/// <reference types="debug" />
+/// <reference types="node" />
+/// <reference types="node" />
+import * as http from 'http';
+import * as stream from 'stream';
+import { Config, Metrics, Request, Response, Router, Token } from '@browserless.io/browserless';
 export interface HTTPServerOptions {
     concurrent: number;
     host: string;
@@ -7,32 +13,21 @@ export interface HTTPServerOptions {
     timeout: number;
 }
 export declare class HTTPServer {
-    private config;
-    private metrics;
-    private browserManager;
-    private limiter;
-    private httpRoutes;
-    private webSocketRoutes;
-    private server;
-    private port;
-    private host?;
-    private log;
-    private verbose;
-    constructor(config: Config, metrics: Metrics, browserManager: BrowserManager, limiter: Limiter, httpRoutes: Array<HTTPRoute | BrowserHTTPRoute>, webSocketRoutes: Array<WebSocketRoute | BrowserWebsocketRoute>);
-    private onQueueFullHTTP;
-    private onQueueFullWebSocket;
-    private onHTTPTimeout;
-    private onWebsocketTimeout;
-    private onHTTPUnauthorized;
-    private onWebsocketUnauthorized;
-    private wrapHTTPHandler;
-    private wrapWebSocketHandler;
-    private getTimeout;
-    private registerHTTPRoute;
-    private registerWebSocketRoute;
+    protected config: Config;
+    protected metrics: Metrics;
+    protected token: Token;
+    protected router: Router;
+    protected server: http.Server;
+    protected port: number;
+    protected host?: string;
+    protected log: import("debug").Debugger;
+    protected verbose: import("debug").Debugger;
+    constructor(config: Config, metrics: Metrics, token: Token, router: Router);
+    protected onHTTPUnauthorized: (_req: Request, res: Response) => void;
+    protected onWebsocketUnauthorized: (_req: Request, socket: stream.Duplex) => void;
     start(): Promise<void>;
     stop(): Promise<void>;
-    private tearDown;
-    private handleRequest;
-    private handleWebSocket;
+    protected tearDown(): void;
+    protected handleRequest: (request: http.IncomingMessage, res: http.ServerResponse) => Promise<void | http.ServerResponse<http.IncomingMessage>>;
+    protected handleWebSocket: (request: http.IncomingMessage, socket: stream.Duplex, head: Buffer) => Promise<void>;
 }

package/build/server.js

@@ -1,49 +1,26 @@
 import * as http from 'http';
-import { BadRequest, HTTPManagementRoutes, NotFound, Timeout, TooManyRequests, Unauthorized, beforeRequest, contentTypes, convertPathToURL, createLogger, isAuthorized, isConnected, queryParamsToObject, readBody, shimLegacyRequests, writeResponse, } from '@browserless.io/browserless';
+import { BadRequest, NotFound, Timeout, TooManyRequests, Unauthorized, beforeRequest, contentTypes, convertPathToURL, createLogger, queryParamsToObject, readBody, shimLegacyRequests, writeResponse, } from '@browserless.io/browserless';
 // @ts-ignore
 import Enjoi from 'enjoi';
-import micromatch from 'micromatch';
 export class HTTPServer {
     config;
     metrics;
-    browserManager;
-    limiter;
-    httpRoutes;
-    webSocketRoutes;
+    token;
+    router;
     server = http.createServer();
     port;
     host;
     log = createLogger('server');
     verbose = createLogger('server:verbose');
-    constructor(config, metrics, browserManager, limiter, httpRoutes, webSocketRoutes) {
+    constructor(config, metrics, token, router) {
         this.config = config;
         this.metrics = metrics;
-        this.browserManager = browserManager;
-        this.limiter = limiter;
-        this.httpRoutes = httpRoutes;
-        this.webSocketRoutes = webSocketRoutes;
+        this.token = token;
+        this.router = router;
         this.host = config.getHost();
         this.port = config.getPort();
-        this.httpRoutes = httpRoutes.map((r) => this.registerHTTPRoute(r));
-        this.webSocketRoutes = webSocketRoutes.map((r) => this.registerWebSocketRoute(r));
         this.log(`Server instantiated with host "${this.host}" on port "${this.port}" using token "${this.config.getToken()}"`);
     }
-    onQueueFullHTTP = (_req, res) => {
-        this.log(`Queue is full, sending 429 response`);
-        return writeResponse(res, 429, 'Too many requests');
-    };
-    onQueueFullWebSocket = (_req, socket) => {
-        this.log(`Queue is full, sending 429 response`);
-        return writeResponse(socket, 429, 'Too many requests');
-    };
-    onHTTPTimeout = (_req, res) => {
-        this.log(`HTTP job has timedout, sending 429 response`);
-        return writeResponse(res, 408, 'Request has timed out');
-    };
-    onWebsocketTimeout = (_req, socket) => {
-        this.log(`Websocket job has timedout, sending 429 response`);
-        return writeResponse(socket, 408, 'Request has timed out');
-    };
     onHTTPUnauthorized = (_req, res) => {
         this.log(`HTTP request is not properly authorized, responding with 401`);
         this.metrics.addUnauthorized();
@@ -54,87 +31,6 @@ export class HTTPServer {
         this.metrics.addUnauthorized();
         return writeResponse(socket, 401, 'Bad or missing authentication.');
     };
-    wrapHTTPHandler = (route, handler) => async (req, res) => {
-        if (!isConnected(res)) {
-            this.log(`HTTP Request has closed prior to running`);
-            return Promise.resolve();
-        }
-        if (route.browser) {
-            const browser = await this.browserManager.getBrowserForRequest(req, route);
-            if (!isConnected(res)) {
-                this.log(`HTTP Request has closed prior to running`);
-                this.browserManager.complete(browser);
-                return Promise.resolve();
-            }
-            if (!browser) {
-                return writeResponse(res, 500, `Error loading the browser.`);
-            }
-            if (!isConnected(res)) {
-                this.log(`HTTP Request has closed prior to running`);
-                return Promise.resolve();
-            }
-            try {
-                this.verbose(`Running found HTTP handler.`);
-                return await handler(req, res, browser);
-            }
-            finally {
-                this.verbose(`HTTP Request handler has finished.`);
-                this.browserManager.complete(browser);
-            }
-        }
-        return handler(req, res);
-    };
-    wrapWebSocketHandler = (route, handler) => async (req, socket, head) => {
-        if (!isConnected(socket)) {
-            this.log(`WebSocket Request has closed prior to running`);
-            return Promise.resolve();
-        }
-        if (route.browser) {
-            const browser = await this.browserManager.getBrowserForRequest(req, route);
-            if (!isConnected(socket)) {
-                this.log(`WebSocket Request has closed prior to running`);
-                this.browserManager.complete(browser);
-                return Promise.resolve();
-            }
-            if (!browser) {
-                return writeResponse(socket, 500, `Error loading the browser.`);
-            }
-            try {
-                this.verbose(`Running found WebSocket handler.`);
-                await handler(req, socket, head, browser);
-            }
-            finally {
-                this.verbose(`WebSocket Request handler has finished.`);
-                this.browserManager.complete(browser);
-            }
-            return;
-        }
-        return handler(req, socket, head);
-    };
-    getTimeout(req) {
-        const timer = req.parsed.searchParams.get('timeout');
-        return timer ? +timer : undefined;
-    }
-    registerHTTPRoute(route) {
-        this.verbose(`Registering HTTP ${route.method.toUpperCase()} ${route.path}`);
-        route._browserManager = () => this.browserManager;
-        const bound = route.handler.bind(route);
-        const wrapped = this.wrapHTTPHandler(route, bound);
-        route.handler = route.concurrency
-            ? this.limiter.limit(wrapped, this.onQueueFullHTTP, this.onHTTPTimeout, this.getTimeout)
-            : wrapped;
-        return route;
-    }
-    registerWebSocketRoute(route) {
-        this.verbose(`Registering WebSocket "${route.path}"`);
-        route._browserManager = () => this.browserManager;
-        const bound = route.handler.bind(route);
-        const wrapped = this.wrapWebSocketHandler(route, bound);
-        route.handler = route.concurrency
-            ? this.limiter.limit(wrapped, this.onQueueFullWebSocket, this.onWebsocketTimeout, this.getTimeout)
-            : wrapped;
-        return route;
-    }
     async start() {
         this.log(`HTTP Server is starting`);
         this.server.on('request', this.handleRequest);
@@ -156,14 +52,12 @@ export class HTTPServer {
     async stop() {
         this.log(`HTTP Server is shutting down`);
         await new Promise((r) => this.server.close(r));
-        await Promise.all([this.tearDown(), this.browserManager.stop()]);
+        await Promise.all([this.tearDown(), this.router.teardown()]);
         this.log(`HTTP Server shutdown complete`);
     }
     tearDown() {
         this.log(`Tearing down all listeners and internal routes`);
         this.server && this.server.removeAllListeners();
-        this.httpRoutes = [];
-        this.webSocketRoutes = [];
         // @ts-ignore garbage collect this reference
         this.server = null;
     }
@@ -175,7 +69,6 @@ export class HTTPServer {
         shimLegacyRequests(req.parsed);
         if (!proceed)
             return;
-        const staticHandler = this.httpRoutes.find((route) => route.path === HTTPManagementRoutes.static);
         if (this.config.getAllowCORS()) {
             Object.entries(this.config.getCORSHeaders()).forEach(([header, value]) => res.setHeader(header, value));
             if (req.method === 'OPTIONS') {
@@ -191,24 +84,16 @@ export class HTTPServer {
             req.body = req.parsed.searchParams.get('body');
             req.parsed.searchParams.delete('body');
         }
-        const accepts = (req.headers['accept']?.toLowerCase() || '*/*').split(',');
-        const contentType = req.headers['content-type']?.toLowerCase();
-        const found = this.httpRoutes.find((r) => micromatch.isMatch(req.parsed.pathname, r.path) &&
-            r.method === req.method?.toLocaleLowerCase() &&
-            (accepts.some((a) => a.startsWith('*/*')) ||
-                r.contentTypes.some((contentType) => accepts.includes(contentType))) &&
-            ((!contentType && r.accepts.includes(contentTypes.any)) ||
-                r.accepts.includes(contentType))) || (req.method?.toLowerCase() === 'get' ? staticHandler : null);
-        if (!found) {
+        const route = await this.router.getRouteForHTTPRequest(req);
+        if (!route) {
             this.log(`No matching WebSocket route handler for "${req.parsed.href}"`);
             writeResponse(res, 404, 'Not Found');
             return Promise.resolve();
         }
-        this.verbose(`Found matching HTTP route handler "${found.path}"`);
-        if (found?.auth) {
+        this.verbose(`Found matching HTTP route handler "${route.path}"`);
+        if (route?.auth) {
             this.verbose(`Authorizing HTTP request to "${request.url}"`);
-            const tokens = this.config.getToken();
-            const isPermitted = isAuthorized(req, found, tokens);
+            const isPermitted = await this.token.isAuthorized(req, route);
             if (!isPermitted) {
                 return this.onHTTPUnauthorized(req, res);
             }
@@ -217,17 +102,17 @@ export class HTTPServer {
         req.body = body;
         req.queryParams = queryParamsToObject(req.parsed.searchParams);
         if (((req.headers['content-type']?.includes(contentTypes.json) ||
-            (found.accepts.length === 1 &&
-                found.accepts.includes(contentTypes.json))) &&
+            (route.accepts.length === 1 &&
+                route.accepts.includes(contentTypes.json))) &&
             typeof body !== 'object') ||
             body === null) {
             writeResponse(res, 400, `Couldn't parse JSON body`);
             return Promise.resolve();
         }
-        if (found.querySchema) {
+        if (route.querySchema) {
             this.verbose(`Validating route query-params with QUERY schema`);
             try {
-                const schema = Enjoi.schema(found.querySchema);
+                const schema = Enjoi.schema(route.querySchema);
                 const valid = schema.validate(req.queryParams, {
                     abortEarly: false,
                 });
@@ -246,10 +131,10 @@ export class HTTPServer {
                 return Promise.resolve();
             }
         }
-        if (found.bodySchema) {
+        if (route.bodySchema) {
             this.verbose(`Validating route payload with BODY schema`);
             try {
-                const schema = Enjoi.schema(found.bodySchema);
+                const schema = Enjoi.schema(route.bodySchema);
                 const valid = schema.validate(body, { abortEarly: false });
                 if (valid.error) {
                     const errorDetails = valid.error.details
@@ -266,9 +151,7 @@ export class HTTPServer {
                 return Promise.resolve();
             }
         }
-        // #wrapHTTPHandler will take care of applying the extra browser
-        // argument for this to to work properly
-        return found
+        return route
             .handler(req, res)
             .then(() => {
             this.verbose('HTTP connection complete');
@@ -289,7 +172,7 @@ export class HTTPServer {
             if (e instanceof Timeout) {
                 return writeResponse(res, 408, e.message);
             }
-            this.log(`Error handling request at "${found.path}": ${e}`);
+            this.log(`Error handling request at "${route.path}": ${e}`);
             return writeResponse(res, 500, e.toString());
         });
     };
@@ -301,22 +184,21 @@ export class HTTPServer {
         shimLegacyRequests(req.parsed);
         if (!proceed)
             return;
-        const { pathname } = req.parsed;
         req.queryParams = queryParamsToObject(req.parsed.searchParams);
-        const found = this.webSocketRoutes.find((r) => micromatch.isMatch(pathname, r.path));
-        if (found) {
-            this.verbose(`Found matching WebSocket route handler "${found.path}"`);
-            if (found?.auth) {
+        const route = await this.router.getRouteForWebSocketRequest(req);
+        if (route) {
+            this.verbose(`Found matching WebSocket route handler "${route.path}"`);
+            if (route?.auth) {
                 this.verbose(`Authorizing WebSocket request to "${req.parsed.href}"`);
-                const isPermitted = isAuthorized(req, found, this.config.getToken());
+                const isPermitted = await this.token.isAuthorized(req, route);
                 if (!isPermitted) {
                     return this.onWebsocketUnauthorized(req, socket);
                 }
             }
-            if (found.querySchema) {
+            if (route.querySchema) {
                 this.verbose(`Validating route query-params with QUERY schema`);
                 try {
-                    const schema = Enjoi.schema(found.querySchema);
+                    const schema = Enjoi.schema(route.querySchema);
                     const valid = schema.validate(req.queryParams, {
                         abortEarly: false,
                     });
@@ -335,9 +217,7 @@ export class HTTPServer {
                     return Promise.resolve();
                 }
             }
-            // #wrapWebSocketHandler will take care of applying the extra browser
-            // argument for this to to work properly
-            return found
+            return route
                 .handler(req, socket, head)
                 .then(() => {
                 this.verbose('Websocket connection complete');
@@ -355,7 +235,7 @@ export class HTTPServer {
                 if (e instanceof TooManyRequests) {
                     return writeResponse(socket, 429, e.message);
                 }
-                this.log(`Error handling request at "${found.path}": ${e}\n${e.stack}`);
+                this.log(`Error handling request at "${route.path}": ${e}\n${e.stack}`);
                 return writeResponse(socket, 500, e.message);
             });
         }

package/build/token.d.ts

@@ -0,0 +1,6 @@
+import { BrowserHTTPRoute, BrowserWebsocketRoute, Config, HTTPRoute, Request, WebSocketRoute } from '@browserless.io/browserless';
+export declare class Token {
+    protected config: Config;
+    constructor(config: Config);
+    isAuthorized: (req: Request, route: BrowserHTTPRoute | BrowserWebsocketRoute | HTTPRoute | WebSocketRoute) => Promise<boolean>;
+}

package/build/token.js

@@ -0,0 +1,21 @@
+import { getTokenFromRequest, } from '@browserless.io/browserless';
+export class Token {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    isAuthorized = async (req, route) => {
+        const token = this.config.getToken();
+        if (token === null) {
+            return true;
+        }
+        if (route.auth !== true) {
+            return true;
+        }
+        const requestToken = getTokenFromRequest(req);
+        if (!requestToken) {
+            return false;
+        }
+        return (Array.isArray(token) ? token : [token]).includes(requestToken);
+    };
+}

package/build/types.d.ts

@@ -4,7 +4,7 @@
 /// <reference types="debug" />
 import * as http from 'http';
 import * as stream from 'stream';
-import { APITags, BrowserManager, CDPChromium, Config, FileSystem, HTTPManagementRoutes, HTTPRoutes, Methods, Metrics, Monitoring, PlaywrightChromium, PlaywrightFirefox, PlaywrightWebkit, Request, WebsocketRoutes, contentTypes } from '@browserless.io/browserless';
+import { APITags, Browserless, CDPChromium, Config, HTTPManagementRoutes, HTTPRoutes, Methods, Metrics, PlaywrightChromium, PlaywrightFirefox, PlaywrightWebkit, Request, WebsocketRoutes, contentTypes } from '@browserless.io/browserless';
 import { HTTPRequest, Page, ResponseForRequest, ScreenshotOptions } from 'puppeteer-core';
 export interface BeforeRequest {
     head?: Buffer;
@@ -42,43 +42,87 @@ export interface BrowserJSON {
     'V8-Version': string;
     'WebKit-Version': string;
 }
+/**
+ * The default launch options or a function, accepting
+ * the request object, that produces the launch options.
+ */
 type defaultLaunchOptions = CDPLaunchOptions | BrowserlessLaunch | ((req: Request) => CDPLaunchOptions | BrowserlessLaunch);
 interface Route {
-    _browserManager?: () => BrowserManager;
-    _config?: () => Config;
-    _debug?: () => debug.Debugger;
-    _fileSystem?: () => FileSystem;
-    _metrics?: () => Metrics;
-    _monitor?: () => Monitoring;
     /**
-     * Whether the route requires a token to access.
+     * A boolean, or a function that returns a boolean, on
+     * whether the route requires an API token to access.
      */
     auth: boolean | ((req: Request) => Promise<boolean>);
     /**
      * The schematic of the submitted BODY (typically)
-     * an object when the route is json-based.
+     * an object when the route is json-based. This is generated
+     * automatically if your route defines a BodySchema type.
      */
     bodySchema?: unknown;
     /**
      * Whether the route should be bound by the global
-     * concurrency limit
+     * concurrency limit defined in your configuration.
      */
     concurrency: boolean;
     /**
-     * Description of the route and what it does
+     * Description of the route and what it does. This description
+     * is then used in the embedded documentation site.
      */
     description: string;
     /**
-     * The HTTP path that this route handles
+     * Helper function to load the browser-manager instance. Defined
+     * and injected by browserless after initialization.
+     * @returns BrowserManager
+     */
+    getBrowserManager?: () => Browserless['browserManager'];
+    /**
+     * Helper function that loads the config module. Defined and injected by
+     * browserless after initialization.
+     * @returns Config
+     */
+    getConfig?: () => Browserless['config'];
+    /**
+     * Helper function that loads the debug module, useful
+     * for logging messages scoped to the routes path. Defined
+     * and injected by browserless after initialization.
+     * @returns Debug
+     */
+    getDebug?: () => debug.Debugger;
+    /**
+     * Helper function that loads the file-system module
+     * for interacting with file-systems. Defined and injected by
+     * browserless after initialization.
+     * @returns FileSystem
+     */
+    getFileSystem?: () => Browserless['fileSystem'];
+    /**
+     * Helper function that loads the metrics module for
+     * collecting and aggregating statistics. Defined and injected by
+     * browserless after initialization.
+     * @returns Metrics
+     */
+    getMetrics?: () => Browserless['metrics'];
+    /**
+     * Helper function that loads the monitoring module useful
+     * for monitoring system health. Defined and injected by
+     * browserless after initialization.
+     * @returns Monitor
+     */
+    getMonitoring?: () => Browserless['monitoring'];
+    /**
+     * The HTTP path that this route handles, eg '/my-route'
      */
     path: HTTPRoutes | WebsocketRoutes | HTTPManagementRoutes | string;
     /**
      * The query parameters accepted by the route, defined in
-     * an object format.
+     * an object format. This is auto-generated for you if your
+     * route defines and exports a QuerySchema type.
      */
     querySchema?: unknown;
     /**
-     * The structure of the routes response when successful
+     * The structure of the routes response when successful. This
+     * is auto-generated for you if your route defines a ResponseSchema
+     * type and exports it in your route.
      */
     responseSchema?: unknown;
     /**
@@ -87,6 +131,11 @@ interface Route {
      */
     tags: APITags[];
 }
+/**
+ * A primitive HTTP-based route that doesn't require a
+ * browser in order to fulfill requests. Used by downstream HTTPRoute
+ * and WebSocketRoute
+ */
 interface BasicHTTPRoute extends Route {
     /**
      * The allowed Content-Types that this route can read and handle.
@@ -105,6 +154,10 @@ interface BasicHTTPRoute extends Route {
      */
     method: Methods;
 }
+/**
+ * A HTTP-based route, with a handler, that can fulfill requests without
+ * a browser required.
+ */
 export interface HTTPRoute extends BasicHTTPRoute {
     browser: null;
     /**
@@ -112,6 +165,11 @@ export interface HTTPRoute extends BasicHTTPRoute {
      */
     handler: (req: Request, res: http.ServerResponse) => Promise<unknown>;
 }
+/**
+ * A HTTP-based route, with a handler, that can fulfill requests but
+ * requires a browser in order to do so. Handler will then be called
+ * with a 3rd argument of the browser class specified.
+ */
 export interface BrowserHTTPRoute extends BasicHTTPRoute {
     browser: BrowserClasses;
     defaultLaunchOptions?: defaultLaunchOptions;
@@ -122,6 +180,10 @@ export interface BrowserHTTPRoute extends BasicHTTPRoute {
     handler: (req: Request, res: http.ServerResponse, browser: BrowserInstance) => Promise<unknown>;
     onNewPage?: undefined;
 }
+/**
+ * A WebSocket-based route, with a handler, that can fulfill requests
+ * that do not require a browser in order to operate.
+ */
 export interface WebSocketRoute extends Route {
     browser: null;
     /**
@@ -129,6 +191,11 @@ export interface WebSocketRoute extends Route {
      */
     handler: (req: Request, socket: stream.Duplex, head: Buffer) => Promise<unknown>;
 }
+/**
+ * A WebSocket-based route, with a handler, that can fulfill requests
+ * that need a browser. Handler is called with an additional argument of
+ * browser (the browser class required to run the route).
+ */
 export interface BrowserWebsocketRoute extends Route {
     browser: BrowserClasses;
     defaultLaunchOptions?: defaultLaunchOptions;
@@ -137,6 +204,10 @@ export interface BrowserWebsocketRoute extends Route {
      * with the prior set browser being injected.
      */
     handler(req: Request, socket: stream.Duplex, head: Buffer, browser: BrowserInstance): Promise<unknown>;
+    /**
+     * An optional function to automatically set up or handle new page
+     * creation. Useful for injecting behaviors or other functionality.
+     */
     onNewPage?: (url: URL, page: Page) => Promise<void>;
 }
 interface BrowserlessLaunch {

package/build/utils.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
-import { BrowserHTTPRoute, BrowserWebsocketRoute, CDPChromium, Config, HTTPRoute, PlaywrightChromium, PlaywrightFirefox, PlaywrightWebkit, Request, WaitForEventOptions, WaitForFunctionOptions, WebSocketRoute, codes, contentTypes } from '@browserless.io/browserless';
+import { CDPChromium, Config, PlaywrightChromium, PlaywrightFirefox, PlaywrightWebkit, Request, WaitForEventOptions, WaitForFunctionOptions, codes, contentTypes } from '@browserless.io/browserless';
 import { CDPSession } from 'playwright-core';
 import { Duplex } from 'stream';
 import { Page } from 'puppeteer-core';
@@ -19,7 +19,6 @@ export declare const writeResponse: (writeable: Duplex | ServerResponse, httpCod
 export declare const jsonResponse: (response: ServerResponse, httpCode?: keyof typeof codes, json?: unknown, allowNull?: boolean) => void;
 export declare const fetchJson: (url: string, init?: RequestInit | undefined) => Promise<unknown>;
 export declare const getTokenFromRequest: (req: Request) => string | null;
-export declare const isAuthorized: (req: Request, route: BrowserHTTPRoute | BrowserWebsocketRoute | HTTPRoute | WebSocketRoute, token: string | string[] | null) => boolean;
 export declare const readRequestBody: (req: Request) => Promise<string>;
 export declare const safeParse: (maybeJson: string) => unknown | null;
 export declare const removeNullStringify: (json: unknown, allowNull?: boolean) => string;

package/build/utils.js

@@ -118,19 +118,6 @@ export const getTokenFromRequest = (req) => {
     const tokenParam = req.parsed.searchParams.get('token');
     return tokenParam ?? getAuthHeaderToken(authHeader || '');
 };
-export const isAuthorized = (req, route, token) => {
-    if (token === null) {
-        return true;
-    }
-    if (route.auth === false) {
-        return true;
-    }
-    const requestToken = getTokenFromRequest(req);
-    if (!requestToken) {
-        return false;
-    }
-    return (Array.isArray(token) ? token : [token]).includes(requestToken);
-};
 // NOTE, if proxying request elsewhere, you must re-stream the body again
 export const readRequestBody = async (req) => {
     return new Promise((resolve) => {

package/build/webhooks.d.ts

@@ -1,8 +1,8 @@
 import { Config } from '@browserless.io/browserless';
 export declare class WebHooks {
-    private config;
+    protected config: Config;
     constructor(config: Config);
-    private callURL;
+    protected callURL(url: string | null): Promise<void | Response> | undefined;
     callFailedHealthURL(): Promise<void | Response> | undefined;
     callQueueAlertURL(): Promise<void | Response> | undefined;
     callRejectAlertURL(): Promise<void | Response> | undefined;