@browserless.io/browserless 2.33.0 → 2.34.0

package/build/routes/edge/tests/screenshot.spec.js

@@ -15,7 +15,7 @@ describe('/edge/screenshot API', function () {
         const metrics = new Metrics();
         await start({ config, metrics });
         const body = {
-            url: 'https://example.com',
+            url: 'https://one.one.one.one',
         };
         await fetch('http://localhost:3000/edge/screenshot?token=browserless', {
             body: JSON.stringify(body),
@@ -44,7 +44,7 @@ describe('/edge/screenshot API', function () {
         const metrics = new Metrics();
         await start({ config, metrics });
         const body = {
-            url: 'https://example.com',
+            url: 'https://one.one.one.one',
             viewport: {
                 deviceScaleFactor: 3,
                 height: 100,
@@ -69,7 +69,7 @@ describe('/edge/screenshot API', function () {
         await start({ config, metrics });
         const body = {
             selector: 'h1',
-            url: 'https://example.com',
+            url: 'https://one.one.one.one',
         };
         await fetch('http://localhost:3000/edge/screenshot?token=browserless', {
             body: JSON.stringify(body),
@@ -120,7 +120,7 @@ describe('/edge/screenshot API', function () {
                     },
                 },
             ],
-            url: 'https://example.com',
+            url: 'https://one.one.one.one',
         };
         await fetch('http://localhost:3000/edge/screenshot?token=browserless', {
             body: JSON.stringify(body),
@@ -139,7 +139,7 @@ describe('/edge/screenshot API', function () {
         const metrics = new Metrics();
         await start({ config, metrics });
         const body = {
-            url: 'https://example.com',
+            url: 'https://one.one.one.one',
             waitForFunction: {
                 fn: '() => 5 + 5',
             },
@@ -161,7 +161,7 @@ describe('/edge/screenshot API', function () {
         const metrics = new Metrics();
         await start({ config, metrics });
         const body = {
-            url: 'https://example.com',
+            url: 'https://one.one.one.one',
             waitForFunction: {
                 fn: 'async () => new Promise(resolve => resolve(5))',
             },
@@ -183,7 +183,7 @@ describe('/edge/screenshot API', function () {
         const metrics = new Metrics();
         await start({ config, metrics });
         const body = {
-            url: 'https://example.com',
+            url: 'https://one.one.one.one',
             waitForSelector: {
                 selector: 'h1',
             },
@@ -205,7 +205,7 @@ describe('/edge/screenshot API', function () {
         const metrics = new Metrics();
         await start({ config, metrics });
         const body = {
-            url: 'https://example.com',
+            url: 'https://one.one.one.one',
             waitForTimeout: 500,
         };
         await fetch('http://localhost:3000/edge/screenshot?token=browserless', {
@@ -250,8 +250,8 @@ describe('/edge/screenshot API', function () {
         const metrics = new Metrics();
         await start({ config, metrics });
         const body = {
-            cookies: [{ domain: 'example.com', name: 'foo', value: 'bar' }],
-            url: 'https://example.com',
+            cookies: [{ domain: 'one.one.one.one', name: 'foo', value: 'bar' }],
+            url: 'https://one.one.one.one',
         };
         await fetch('http://localhost:3000/edge/screenshot?token=browserless', {
             body: JSON.stringify(body),
@@ -270,7 +270,7 @@ describe('/edge/screenshot API', function () {
         const metrics = new Metrics();
         await start({ config, metrics });
         const body = {
-            url: 'https://example.com',
+            url: 'https://one.one.one.one',
         };
         await fetch('http://localhost:3000/edge/screenshot?token=browserless&timeout=10', {
             body: JSON.stringify(body),
@@ -290,7 +290,7 @@ describe('/edge/screenshot API', function () {
         const metrics = new Metrics();
         await start({ config, metrics });
         const body = {
-            url: 'https://example.com',
+            url: 'https://one.one.one.one',
         };
         await fetch('http://localhost:3000/edge/screenshot?token=browserless', {
             body: JSON.stringify(body),
@@ -308,7 +308,7 @@ describe('/edge/screenshot API', function () {
         const metrics = new Metrics();
         await start({ config, metrics });
         const body = {
-            url: 'https://example.com',
+            url: 'https://one.one.one.one',
         };
         await fetch('http://localhost:3000/edge/screenshot?token=browserless', {
             body: JSON.stringify(body),
@@ -323,7 +323,7 @@ describe('/edge/screenshot API', function () {
     it('allows requests without token when auth token is not set', async () => {
         await start();
         const body = {
-            url: 'https://example.com',
+            url: 'https://one.one.one.one',
         };
         await fetch('http://localhost:3000/edge/screenshot', {
             body: JSON.stringify(body),

package/build/routes/management/http/kill.get.d.ts

@@ -2,7 +2,7 @@ import { APITags, HTTPManagementRoutes, HTTPRoute, Methods, Request, SystemQuery
 import { ServerResponse } from 'http';
 export type ResponseSchema = string;
 export interface QuerySchema extends SystemQueryParameters {
-    token: string;
+    token?: string;
     browserId?: string;
     trackingId?: string;
 }

package/build/routes/management/http/kill.get.query.json

@@ -36,9 +36,6 @@
     }
   },
   "additionalProperties": false,
-  "required": [
-    "token"
-  ],
   "definitions": {
     "CDPLaunchOptions": {
       "type": "object",

package/build/routes/management/http/pressure.get.d.ts

@@ -60,5 +60,5 @@ export default class PressureGetRoute extends HTTPRoute {
     method: Methods;
     path: HTTPManagementRoutes;
     tags: APITags[];
-    handler(_req: Request, res: ServerResponse): Promise<void>;
+    handler(req: Request, res: ServerResponse): Promise<void>;
 }

package/build/routes/management/http/pressure.get.js

@@ -1,16 +1,20 @@
-import { APITags, BrowserlessRoutes, HTTPManagementRoutes, HTTPRoute, Methods, contentTypes, jsonResponse, } from '@browserless.io/browserless';
+import { APITags, BrowserlessRoutes, HTTPManagementRoutes, HTTPRoute, Methods, contentTypes, dedent, jsonResponse, writeResponse, } from '@browserless.io/browserless';
 export default class PressureGetRoute extends HTTPRoute {
     name = BrowserlessRoutes.PressureGetRoute;
     accepts = [contentTypes.any];
     auth = true;
     browser = null;
     concurrency = false;
-    contentTypes = [contentTypes.json];
-    description = `Returns a JSON body of stats related to the pressure being created on the instance.`;
+    contentTypes = [contentTypes.json, contentTypes.text];
+    description = dedent(`Returns a JSON body of stats related to the pressure being exerted on the instance. This route is dynamic based upon the supplied "Accept" header, and will either return a human-readable message if the "Accept" header is set to "text/plain", or the default JSON body and a 200 HTTP code.
+
+    When Accept is set to "text/plain" a human-readable message is sent back describing the state of the container, and either a "200" code (indicating "ok") or a "503" code (indicating that the service is unavailable due to load).
+
+    If the "Accept" header is set to anything else it will return a JSON body with the same information.`);
     method = Methods.get;
     path = HTTPManagementRoutes.pressure;
     tags = [APITags.management];
-    async handler(_req, res) {
+    async handler(req, res) {
         const monitoring = this.monitoring();
         const config = this.config();
         const limiter = this.limiter();
@@ -53,6 +57,10 @@ export default class PressureGetRoute extends HTTPRoute {
                 running,
             },
         };
+        if (req.headers.accept === contentTypes.text) {
+            const code = response.pressure.isAvailable ? 200 : 503;
+            return writeResponse(res, code, message);
+        }
         return jsonResponse(res, 200, response);
     }
 }

package/build/routes/management/http/sessions.get.d.ts

@@ -1,7 +1,7 @@
 import { APITags, BrowserlessSessionJSON, HTTPManagementRoutes, HTTPRoute, Methods, Request, SystemQueryParameters, contentTypes } from '@browserless.io/browserless';
 import { ServerResponse } from 'http';
 export interface QuerySchema extends SystemQueryParameters {
-    token: string;
+    token?: string;
     trackingId?: string;
 }
 export type ResponseSchema = BrowserlessSessionJSON[];

package/build/routes/management/http/sessions.get.query.json

@@ -33,9 +33,6 @@
     }
   },
   "additionalProperties": false,
-  "required": [
-    "token"
-  ],
   "definitions": {
     "CDPLaunchOptions": {
       "type": "object",

package/build/routes/management/tests/management.spec.js

@@ -14,16 +14,16 @@ describe('Management APIs', function () {
         it('allows Single Origin OPTIONS requests', async () => {
             const config = new Config();
             config.enableCORS(true);
-            config.setCORSOrigin('https://example.com');
+            config.setCORSOrigin('https://one.one.one.one');
             await start({ config });
             const r = await fetch('http://localhost:3000/config?token=6R0W53R135510', {
                 method: 'OPTIONS',
                 headers: {
-                    Origin: 'https://example.com',
+                    Origin: 'https://one.one.one.one',
                 },
             });
             expect(r.status).to.equal(204);
-            expect(r.headers.get('access-control-allow-origin')).to.equal('https://example.com');
+            expect(r.headers.get('access-control-allow-origin')).to.equal('https://one.one.one.one');
         });
         it('allows wildcard orign OPTIONS requests', async () => {
             const config = new Config();
@@ -33,44 +33,44 @@ describe('Management APIs', function () {
             const r = await fetch('http://localhost:3000/config?token=6R0W53R135510', {
                 method: 'OPTIONS',
                 headers: {
-                    Origin: 'https://example.com',
+                    Origin: 'https://one.one.one.one',
                 },
             });
             expect(r.status).to.equal(204);
-            expect(r.headers.get('access-control-allow-origin')).to.equal('https://example.com');
+            expect(r.headers.get('access-control-allow-origin')).to.equal('https://one.one.one.one');
         });
         it('allows glob-matched OPTIONS requests', async () => {
             const config = new Config();
             config.enableCORS(true);
-            config.setCORSOrigin('*.example.com');
+            config.setCORSOrigin('*.one.one.one.one');
             await start({ config });
             const r = await fetch('http://localhost:3000/config?token=6R0W53R135510', {
                 method: 'OPTIONS',
                 headers: {
-                    Origin: 'https://subdomain.example.com',
+                    Origin: 'https://subdomain.one.one.one.one',
                 },
             });
             expect(r.status).to.equal(204);
-            expect(r.headers.get('access-control-allow-origin')).to.equal('https://subdomain.example.com');
+            expect(r.headers.get('access-control-allow-origin')).to.equal('https://subdomain.one.one.one.one');
         });
         it('allows glob-matched OPTIONS requests with OR patterns', async () => {
             const config = new Config();
             config.enableCORS(true);
-            config.setCORSOrigin('https://(abc|xyz).example.com');
+            config.setCORSOrigin('https://(abc|xyz).one.one.one.one');
             await start({ config });
             const r = await fetch('http://localhost:3000/config?token=6R0W53R135510', {
                 method: 'OPTIONS',
                 headers: {
-                    Origin: 'https://abc.example.com',
+                    Origin: 'https://abc.one.one.one.one',
                 },
             });
             expect(r.status).to.equal(204);
-            expect(r.headers.get('access-control-allow-origin')).to.equal('https://abc.example.com');
+            expect(r.headers.get('access-control-allow-origin')).to.equal('https://abc.one.one.one.one');
         });
         it('allows glob-matched OPTIONS requests with OR patterns across two domains', async () => {
             const config = new Config();
             config.enableCORS(true);
-            config.setCORSOrigin('(https://(abc|xyz).example.com|https://deploy-preview-*.netlify.app)');
+            config.setCORSOrigin('(https://(abc|xyz).one.one.one.one|https://deploy-preview-*.netlify.app)');
             await start({ config });
             const r = await fetch('http://localhost:3000/config?token=6R0W53R135510', {
                 method: 'OPTIONS',
@@ -89,7 +89,7 @@ describe('Management APIs', function () {
             const r = await fetch('http://localhost:3000/config?token=6R0W53R135510', {
                 method: 'OPTIONS',
                 headers: {
-                    Origin: 'https://subdomain.example.com',
+                    Origin: 'https://subdomain.one.one.one.one',
                 },
             });
             expect(r.status).to.equal(404);

package/build/server.js

@@ -1,5 +1,5 @@
 import * as http from 'http';
-import { BadRequest, Logger as BlessLogger, NotFound, Timeout, TooManyRequests, Unauthorized, contentTypes, convertPathToURL, isMatch, queryParamsToObject, readBody, shimLegacyRequests, writeResponse, } from '@browserless.io/browserless';
+import { BadRequest, Logger as BlessLogger, NotFound, Timeout, TooManyRequests, Unauthorized, contentTypes, convertPathToURL, isMatch, moveTokenToHeader, queryParamsToObject, readBody, shimLegacyRequests, writeResponse, } from '@browserless.io/browserless';
 import { EventEmitter } from 'events';
 import EnjoiResolver from './shared/utils/enjoi-resolver.js';
 export class HTTPServer extends EventEmitter {
@@ -73,7 +73,8 @@ export class HTTPServer extends EventEmitter {
         });
     }
     async handleRequest(request, res) {
-        this.logger.trace(`Handling inbound HTTP request on "${request.method}: ${request.url}"`);
+        request.url = moveTokenToHeader(request);
+        this.logger.trace(`Handling inbound HTTP request on "${request.method}: ${request.url || ''}"`);
         const req = request;
         const proceed = await this.hooks.before({ req, res });
         req.parsed = convertPathToURL(request.url || '', this.config);
@@ -114,8 +115,11 @@ export class HTTPServer extends EventEmitter {
             return Promise.resolve();
         }
         this.logger.trace(`Found matching HTTP route handler "${route.path}"`);
+        if (route.before && !(await route.before(req, res))) {
+            return;
+        }
         if (route?.auth) {
-            this.logger.trace(`Authorizing HTTP request to "${request.url}"`);
+            this.logger.trace(`Authorizing HTTP request to "${request.url || ''}"`);
             const isPermitted = await this.token.isAuthorized(req, route);
             if (!isPermitted) {
                 return this.onHTTPUnauthorized(req, res);
@@ -182,7 +186,8 @@ export class HTTPServer extends EventEmitter {
             .catch((e) => this.handleErrorRequest(e, res));
     }
     async handleWebSocket(request, socket, head) {
-        this.logger.trace(`Handling inbound WebSocket request on "${request.url}"`);
+        request.url = moveTokenToHeader(request);
+        this.logger.trace(`Handling inbound WebSocket request on "${request.url || ''}"`);
         const req = request;
         const proceed = await this.hooks.before({ head, req, socket });
         req.parsed = convertPathToURL(request.url || '', this.config);
@@ -193,6 +198,9 @@ export class HTTPServer extends EventEmitter {
         const route = await this.router.getRouteForWebSocketRequest(req);
         if (route) {
             this.logger.trace(`Found matching WebSocket route handler "${route.path}"`);
+            if (route.before && !(await route.before(req, socket, head))) {
+                return;
+            }
             if (route?.auth) {
                 this.logger.trace(`Authorizing WebSocket request to "${req.parsed.href}"`);
                 const isPermitted = await this.token.isAuthorized(req, route);

package/build/shared/content.http.js

@@ -1,4 +1,4 @@
-import { APITags, BadRequest, BrowserHTTPRoute, BrowserlessRoutes, ChromiumCDP, HTTPRoutes, Methods, bestAttemptCatch, contentTypes, noop, sleep, waitForEvent as waitForEvt, waitForFunction as waitForFn, writeResponse, } from '@browserless.io/browserless';
+import { APITags, BadRequest, BrowserHTTPRoute, BrowserlessRoutes, ChromiumCDP, HTTPRoutes, Methods, bestAttemptCatch, contentTypes, isBase64Encoded, noop, sleep, waitForEvent as waitForEvt, waitForFunction as waitForFn, writeResponse, } from '@browserless.io/browserless';
 export default class ChromiumContentPostRoute extends BrowserHTTPRoute {
     name = BrowserlessRoutes.ChromiumContentPostRoute;
     accepts = [contentTypes.json];
@@ -59,7 +59,14 @@ export default class ChromiumContentPostRoute extends BrowserHTTPRoute {
                 }
                 const interceptor = requestInterceptors.find((r) => req.url().match(r.pattern));
                 if (interceptor) {
-                    return req.respond(interceptor.response);
+                    return req.respond({
+                        ...interceptor.response,
+                        body: interceptor.response.body
+                            ? isBase64Encoded(interceptor.response.body)
+                                ? Buffer.from(interceptor.response.body, 'base64')
+                                : interceptor.response.body
+                            : undefined,
+                    });
                 }
                 return req.continue();
             });

package/build/shared/pdf.http.js

@@ -1,4 +1,4 @@
-import { APITags, BadRequest, BrowserHTTPRoute, BrowserlessRoutes, ChromiumCDP, HTTPRoutes, Methods, bestAttemptCatch, contentTypes, dedent, noop, sleep, waitForEvent as waitForEvt, waitForFunction as waitForFn, } from '@browserless.io/browserless';
+import { APITags, BadRequest, BrowserHTTPRoute, BrowserlessRoutes, ChromiumCDP, HTTPRoutes, Methods, bestAttemptCatch, contentTypes, dedent, isBase64Encoded, noop, sleep, waitForEvent as waitForEvt, waitForFunction as waitForFn, } from '@browserless.io/browserless';
 export default class ChromiumPDFPostRoute extends BrowserHTTPRoute {
     name = BrowserlessRoutes.ChromiumPDFPostRoute;
     accepts = [contentTypes.json];
@@ -64,7 +64,14 @@ export default class ChromiumPDFPostRoute extends BrowserHTTPRoute {
                 }
                 const interceptor = requestInterceptors.find((r) => req.url().match(r.pattern));
                 if (interceptor) {
-                    return req.respond(interceptor.response);
+                    return req.respond({
+                        ...interceptor.response,
+                        body: interceptor.response.body
+                            ? isBase64Encoded(interceptor.response.body)
+                                ? Buffer.from(interceptor.response.body, 'base64')
+                                : interceptor.response.body
+                            : undefined,
+                    });
                 }
                 return req.continue();
             });

package/build/shared/scrape.http.js

@@ -1,4 +1,4 @@
-import { APITags, BadRequest, BrowserHTTPRoute, BrowserlessRoutes, ChromiumCDP, HTTPRoutes, Methods, Timeout, bestAttemptCatch, contentTypes, debugScreenshotOpts, dedent, jsonResponse, noop, sleep, waitForEvent as waitForEvt, waitForFunction as waitForFn, } from '@browserless.io/browserless';
+import { APITags, BadRequest, BrowserHTTPRoute, BrowserlessRoutes, ChromiumCDP, HTTPRoutes, Methods, Timeout, bestAttemptCatch, contentTypes, debugScreenshotOpts, dedent, isBase64Encoded, jsonResponse, noop, sleep, waitForEvent as waitForEvt, waitForFunction as waitForFn, } from '@browserless.io/browserless';
 const scrape = async (elements) => {
     const wait = (selector, timeout = 30000) => {
         return new Promise((resolve, reject) => {
@@ -127,7 +127,14 @@ export default class ChromiumScrapePostRoute extends BrowserHTTPRoute {
                 }
                 const interceptor = requestInterceptors.find((r) => req.url().match(r.pattern));
                 if (interceptor) {
-                    return req.respond(interceptor.response);
+                    return req.respond({
+                        ...interceptor.response,
+                        body: interceptor.response.body
+                            ? isBase64Encoded(interceptor.response.body)
+                                ? Buffer.from(interceptor.response.body, 'base64')
+                                : interceptor.response.body
+                            : undefined,
+                    });
                 }
                 return req.continue();
             });

package/build/shared/screenshot.http.js

@@ -1,4 +1,4 @@
-import { APITags, BadRequest, BrowserHTTPRoute, BrowserlessRoutes, ChromiumCDP, HTTPRoutes, Methods, bestAttemptCatch, contentTypes, dedent, noop, scrollThroughPage, sleep, waitForEvent as waitForEvt, waitForFunction as waitForFn, } from '@browserless.io/browserless';
+import { APITags, BadRequest, BrowserHTTPRoute, BrowserlessRoutes, ChromiumCDP, HTTPRoutes, Methods, bestAttemptCatch, contentTypes, dedent, isBase64Encoded, noop, scrollThroughPage, sleep, waitForEvent as waitForEvt, waitForFunction as waitForFn, } from '@browserless.io/browserless';
 import Stream from 'stream';
 export default class ScreenshotPost extends BrowserHTTPRoute {
     name = BrowserlessRoutes.ChromiumScreenshotPostRoute;
@@ -67,7 +67,14 @@ export default class ScreenshotPost extends BrowserHTTPRoute {
                 }
                 const interceptor = requestInterceptors.find((r) => req.url().match(r.pattern));
                 if (interceptor) {
-                    return req.respond(interceptor.response);
+                    return req.respond({
+                        ...interceptor.response,
+                        body: interceptor.response.body
+                            ? isBase64Encoded(interceptor.response.body)
+                                ? Buffer.from(interceptor.response.body, 'base64')
+                                : interceptor.response.body
+                            : undefined,
+                    });
                 }
                 return req.continue();
             });

package/build/shim.d.ts

@@ -1,3 +1,8 @@
+import * as http from 'http';
+/**
+ * Obfuscates the ?token parameter by shifting it to a header instead of a query-parameter.
+ */
+export declare function moveTokenToHeader(req: http.IncomingMessage): string;
 /**
  * Given a legacy connect or API call, this shim will
  * re-order the arguments to make them valid in the 2.0

package/build/shim.js

@@ -1,5 +1,18 @@
 import { convertIfBase64, safeParse, } from '@browserless.io/browserless';
 const shimParam = ['headless', 'stealth', 'ignoreDefaultArgs', 'slowMo'];
+/**
+ * Obfuscates the ?token parameter by shifting it to a header instead of a query-parameter.
+ */
+export function moveTokenToHeader(req) {
+    const parsed = new URL(req.url || '', 'http://localhost');
+    const token = parsed.searchParams.get('token');
+    if (token) {
+        parsed.searchParams.delete('token');
+        req.headers.authorization = req.headers.authorization ?? `Bearer ${token}`;
+        req.url = parsed.pathname + parsed.search;
+    }
+    return req.url;
+}
 /**
  * Given a legacy connect or API call, this shim will
  * re-order the arguments to make them valid in the 2.0

package/build/shim.spec.js

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import { shimLegacyRequests } from '@browserless.io/browserless';
+import { shimLegacyRequests, moveTokenToHeader, } from '@browserless.io/browserless';
 describe('Request Shimming', () => {
     describe('headless', () => {
         it('converts headless true', () => {
@@ -125,4 +125,31 @@ describe('Request Shimming', () => {
             expect(decodeURIComponent(shimmed.href)).to.equal(final);
         });
     });
+    describe('token shimming', () => {
+        it('converts token query parameters to an authorization header', () => {
+            const url = 'wss://localhost?token=12345';
+            const shimmed = moveTokenToHeader({
+                url,
+                headers: {},
+            });
+            expect(shimmed).not.to.include('?token=');
+        });
+        it('converts the token to a proper header', () => {
+            const url = 'wss://localhost?token=12345';
+            const request = { url, headers: {} };
+            moveTokenToHeader(request);
+            expect(request.headers.authorization).to.eql('Bearer 12345');
+        });
+        it('does no conversion if an authorization header is already present', () => {
+            const oldAuth = 'Bearer foo-bar';
+            const url = 'wss://localhost?token=12345';
+            const request = {
+                url,
+                headers: { authorization: oldAuth },
+            };
+            const shimmed = moveTokenToHeader(request);
+            expect(shimmed).not.to.include('?token=');
+            expect(request.headers.authorization).to.eql(oldAuth);
+        });
+    });
 });

package/build/types.d.ts

@@ -171,6 +171,12 @@ declare abstract class BasicHTTPRoute extends Route {
      * The allowed methods ("GET", "POST", etc) this route can utilize and match against.
      */
     abstract method: Methods;
+    /**
+     * A function that can run before the requests is parsed and any query or body validation is run.
+     * Useful if you need to alter something about the request to conform it or otherwise. This
+     * hook is ran after any "global" hooks have run.
+     */
+    before?: (req: Request, res: http.ServerResponse) => Promise<boolean>;
 }
 /**
  * A HTTP-based route, with a handler, that can fulfill requests without
@@ -211,6 +217,10 @@ export declare abstract class WebSocketRoute extends Route {
      * Handles an inbound Websocket request, and handles the connection
      */
     abstract handler(req: Request, socket: stream.Duplex, head: Buffer, logger: Logger): Promise<unknown>;
+    /**
+     * Handles an inbound HTTP request, and supplies the Request and Response objects from node's HTTP request event
+     */
+    before?: (req: Request, socket: stream.Duplex, head: Buffer) => Promise<boolean>;
 }
 /**
  * A WebSocket-based route, with a handler, that can fulfill requests
@@ -230,6 +240,10 @@ export declare abstract class BrowserWebsocketRoute extends Route {
      * creation. Useful for injecting behaviors or other functionality.
      */
     onNewPage?: (url: URL, page: Page) => Promise<void>;
+    /**
+     * Handles an inbound HTTP request, and supplies the Request and Response objects from node's HTTP request event
+     */
+    before?: (req: Request, socket: stream.Duplex, head: Buffer) => Promise<boolean>;
 }
 interface BrowserlessLaunch {
     stealth?: boolean;
@@ -392,7 +406,13 @@ export type requestInterceptors = {
      * corresponding responses to use in order to fulfill those requests.
      */
     pattern: string;
-    response: Partial<ResponseForRequest>;
+    response: Partial<Omit<ResponseForRequest, 'body'>> & {
+        /**
+         * A string representation of the body to return. Can be a base64-encoded
+         * string but please omit any leading content-type data (eg "data:image/png;base64,").
+         */
+        body?: string;
+    };
 };
 export interface IResourceLoad {
     cpu: number | null;

package/build/types.js

@@ -101,6 +101,12 @@ class Route {
  * and WebSocketRoute
  */
 class BasicHTTPRoute extends Route {
+    /**
+     * A function that can run before the requests is parsed and any query or body validation is run.
+     * Useful if you need to alter something about the request to conform it or otherwise. This
+     * hook is ran after any "global" hooks have run.
+     */
+    before;
 }
 /**
  * A HTTP-based route, with a handler, that can fulfill requests without
@@ -127,6 +133,10 @@ export class BrowserHTTPRoute extends BasicHTTPRoute {
  */
 export class WebSocketRoute extends Route {
     browser = null;
+    /**
+     * Handles an inbound HTTP request, and supplies the Request and Response objects from node's HTTP request event
+     */
+    before;
 }
 /**
  * A WebSocket-based route, with a handler, that can fulfill requests
@@ -140,6 +150,10 @@ export class BrowserWebsocketRoute extends Route {
      * creation. Useful for injecting behaviors or other functionality.
      */
     onNewPage;
+    /**
+     * Handles an inbound HTTP request, and supplies the Request and Response objects from node's HTTP request event
+     */
+    before;
 }
 export const debugScreenshotOpts = {
     encoding: 'base64',

package/build/utils.d.ts

@@ -80,6 +80,7 @@ export declare const exists: (path: string) => Promise<boolean>;
  * @returns {boolean}
  */
 export declare const fileExists: (path: string) => Promise<boolean>;
+export declare const isBase64Encoded: (item: string) => boolean;
 export declare const convertIfBase64: (item: string) => string;
 export declare const availableBrowsers: Promise<(typeof ChromiumCDP | typeof ChromiumPlaywright | typeof FirefoxPlaywright | typeof WebKitPlaywright)[]>;
 export declare const queryParamsToObject: (params: URLSearchParams) => Record<string, unknown>;

package/build/utils.js

@@ -156,7 +156,7 @@ export const fetchJson = (url, init) => fetch(url, init).then((res) => {
     return res.json();
 });
 export const getTokenFromRequest = (req) => {
-    const authHeader = req.headers['authorization'];
+    const authHeader = req.headers.authorization;
     const tokenParam = req.parsed.searchParams.get('token');
     return tokenParam ?? getAuthHeaderToken(authHeader || '');
 };
@@ -233,7 +233,7 @@ export const generateDataDir = async (sessionId = id(), config) => {
 };
 export const readBody = async (req, maxSize = 10485760) => {
     if (typeof req.body === 'string' &&
-        (isBase64.test(req.body) || req.body.startsWith('{'))) {
+        (isBase64Encoded(req.body) || req.body.startsWith('{'))) {
         return safeParse(convertIfBase64(req.body));
     }
     const body = await readRequestBody(req, maxSize);
@@ -352,7 +352,8 @@ export const fileExists = async (path) => fs
     .then((stat) => stat.isFile())
     .catch(() => false);
 const isBase64 = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
-export const convertIfBase64 = (item) => isBase64.test(item) ? Buffer.from(item, 'base64').toString() : item;
+export const isBase64Encoded = (item) => isBase64.test(item);
+export const convertIfBase64 = (item) => isBase64Encoded(item) ? Buffer.from(item, 'base64').toString() : item;
 export const availableBrowsers = Promise.all([
     exists(playwright.chromium.executablePath()),
     exists(playwright.firefox.executablePath()),