@browserless.io/browserless 2.31.1 → 2.32.0

package/build/routes/edge/http/screenshot.post.body.json

@@ -566,14 +566,14 @@
                 "length": {
                   "type": "number"
                 },
-                "__@toStringTag@494201": {
+                "__@toStringTag@496068": {
                   "type": "string",
                   "const": "Uint8Array"
                 }
               },
               "required": [
                 "BYTES_PER_ELEMENT",
-                "__@toStringTag@494201",
+                "__@toStringTag@496068",
                 "buffer",
                 "byteLength",
                 "byteOffset",
@@ -608,13 +608,13 @@
         "byteLength": {
           "type": "number"
         },
-        "__@toStringTag@494201": {
+        "__@toStringTag@496068": {
           "type": "string"
         }
       },
       "additionalProperties": false,
       "required": [
-        "__@toStringTag@494201",
+        "__@toStringTag@496068",
         "byteLength"
       ]
     },
@@ -624,18 +624,18 @@
         "byteLength": {
           "type": "number"
         },
-        "__@species@494239": {
+        "__@species@504967": {
           "$ref": "#/definitions/SharedArrayBuffer"
         },
-        "__@toStringTag@494201": {
+        "__@toStringTag@496068": {
           "type": "string",
           "const": "SharedArrayBuffer"
         }
       },
       "additionalProperties": false,
       "required": [
-        "__@species@494239",
-        "__@toStringTag@494201",
+        "__@species@504967",
+        "__@toStringTag@496068",
         "byteLength"
       ]
     },

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

@@ -67,6 +67,20 @@ describe('Management APIs', function () {
             expect(r.status).to.equal(204);
             expect(r.headers.get('access-control-allow-origin')).to.equal('https://abc.example.com');
         });
+        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)');
+            await start({ config });
+            const r = await fetch('http://localhost:3000/config?token=6R0W53R135510', {
+                method: 'OPTIONS',
+                headers: {
+                    Origin: 'https://deploy-preview-123--funky-monkey-12345.netlify.app',
+                },
+            });
+            expect(r.status).to.equal(204);
+            expect(r.headers.get('access-control-allow-origin')).to.equal('https://deploy-preview-123--funky-monkey-12345.netlify.app');
+        });
         it('should 404 when the origin does not match the CORS origin pattern', async () => {
             const config = new Config();
             config.enableCORS(true);

package/build/server.js

@@ -1,8 +1,7 @@
 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 { EventEmitter } from 'events';
-// @ts-ignore
-import Enjoi from 'enjoi';
+import EnjoiResolver from './shared/utils/enjoi-resolver.js';
 export class HTTPServer extends EventEmitter {
     config;
     metrics;
@@ -136,7 +135,7 @@ export class HTTPServer extends EventEmitter {
         if (route.querySchema) {
             this.logger.trace(`Validating route query-params with QUERY schema`);
             try {
-                const schema = Enjoi.schema(route.querySchema);
+                const schema = EnjoiResolver.schema(route.querySchema);
                 const valid = schema.validate(req.queryParams, {
                     abortEarly: false,
                 });
@@ -158,7 +157,7 @@ export class HTTPServer extends EventEmitter {
         if (route.bodySchema) {
             this.logger.trace(`Validating route payload with BODY schema`);
             try {
-                const schema = Enjoi.schema(route.bodySchema);
+                const schema = EnjoiResolver.schema(route.bodySchema);
                 const valid = schema.validate(body, { abortEarly: false });
                 if (valid.error) {
                     const errorDetails = valid.error.details
@@ -204,7 +203,7 @@ export class HTTPServer extends EventEmitter {
             if (route.querySchema) {
                 this.logger.trace(`Validating route query-params with QUERY schema`);
                 try {
-                    const schema = Enjoi.schema(route.querySchema);
+                    const schema = EnjoiResolver.schema(route.querySchema);
                     const valid = schema.validate(req.queryParams, {
                         abortEarly: false,
                     });

package/build/shared/utils/enjoi-resolver.d.ts

@@ -0,0 +1,77 @@
+interface SchemaResolverOptions {
+    subSchemas?: Record<string, any>;
+    refineType?: (type: string, format?: string) => string;
+    refineSchema?: (joiSchema: any, jsonSchema: any) => any;
+    strictMode?: boolean;
+    useDefaults?: boolean;
+    extensions?: any[];
+}
+interface JSONSchema {
+    type?: string | string[];
+    $ref?: string;
+    properties?: Record<string, any>;
+    format?: string;
+    enum?: any[];
+    anyOf?: any[];
+    allOf?: any[];
+    oneOf?: any[];
+    not?: any;
+    default?: any;
+    required?: string[];
+    additionalProperties?: boolean | any;
+    minProperties?: number;
+    maxProperties?: number;
+    items?: any;
+    ordered?: any;
+    additionalItems?: boolean;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    multipleOf?: number;
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+    [key: string]: any;
+}
+declare class SchemaResolver {
+    private root;
+    private subSchemas?;
+    private refineType?;
+    private refineSchema?;
+    private strictMode?;
+    private walkedSchemas;
+    private useDefaults?;
+    private joi;
+    constructor(root: any, { subSchemas, refineType, refineSchema, strictMode, useDefaults, extensions, }?: SchemaResolverOptions);
+    resolve(schema?: any, ancestors?: string[]): any;
+    resolveReference(value: string): any;
+    resolveType(schema: JSONSchema, ancestors: string[]): any;
+    resolveOneOf(schema: JSONSchema, ancestors: string[]): any;
+    resolveAnyOf(schema: JSONSchema, ancestors: string[]): any;
+    resolveAllOf(schema: JSONSchema, ancestors: string[]): any;
+    resolveNot(schema: JSONSchema, ancestors: string[]): any;
+    resolveLink(schema: any): any;
+    object(schema: JSONSchema, ancestors: string[]): any;
+    array(schema: JSONSchema, ancestors: string[]): any;
+    number(schema: JSONSchema): any;
+    string(schema: JSONSchema): any;
+    regularString(schema: JSONSchema, joischema: any): any;
+    binary(schema: JSONSchema): any;
+}
+/**
+ * Enjoi-compatible API
+ * Creates a Joi schema from a JSON Schema
+ * @param jsonSchema - The JSON schema to convert
+ * @param options - Optional configuration for schema resolution
+ * @returns Joi schema with validate method
+ */
+declare function schema(jsonSchema: any, options?: SchemaResolverOptions): any;
+export { SchemaResolver, schema };
+declare const _default: {
+    schema: typeof schema;
+};
+export default _default;

package/build/shared/utils/enjoi-resolver.js

@@ -0,0 +1,399 @@
+/* global WeakMap */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-unused-expressions */
+import * as Bourne from '@hapi/bourne';
+import * as Hoek from '@hapi/hoek';
+import Joi from 'joi';
+// Modern replacements for deprecated Node.js util functions
+const isArray = Array.isArray;
+const isObject = (value) => value && typeof value === 'object' && value.constructor === Object;
+const isNumber = (value) => typeof value === 'number';
+const isUndefined = (value) => value === undefined;
+function randomString(length) {
+    return Math.round(Math.pow(36, length + 1) - Math.random() * Math.pow(36, length))
+        .toString(36)
+        .slice(1);
+}
+class SchemaResolver {
+    root;
+    subSchemas;
+    refineType;
+    refineSchema;
+    strictMode;
+    walkedSchemas;
+    useDefaults;
+    joi;
+    constructor(root, { subSchemas, refineType, refineSchema, strictMode, useDefaults, extensions = [], } = {}) {
+        this.root = root;
+        this.subSchemas = subSchemas;
+        this.refineType = refineType;
+        this.refineSchema = refineSchema;
+        this.strictMode = strictMode;
+        this.walkedSchemas = new WeakMap(); // map of schemas iterated thus far to the generated id they were given
+        this.useDefaults = useDefaults;
+        this.joi = Joi.extend({
+            type: 'object',
+            base: Joi.object(),
+            coerce: {
+                from: 'string',
+                // @ts-ignore - Type compatibility issue with Joi coerce method
+                method(value) {
+                    if (typeof value !== 'string' ||
+                        (value[0] !== '{' && !/^\s*\{/.test(value))) {
+                        return;
+                    }
+                    try {
+                        return { value: Bourne.parse(value) };
+                    }
+                    catch (_) {
+                        return;
+                    } // eslint-disable-line no-empty
+                },
+            },
+        }, {
+            type: 'array',
+            base: Joi.array(),
+            coerce: {
+                from: 'string',
+                method(value) {
+                    if (typeof value !== 'string' ||
+                        (value[0] !== '[' && !/^\s*\[/.test(value))) {
+                        return;
+                    }
+                    try {
+                        return { value: Bourne.parse(value) };
+                    }
+                    catch (_) {
+                        return;
+                    } // eslint-disable-line no-empty
+                },
+            },
+        }, ...extensions);
+    }
+    resolve(schema = this.root, ancestors = []) {
+        let resolvedSchema;
+        let generatedId = this.walkedSchemas.get(schema);
+        if (generatedId && ancestors.lastIndexOf(generatedId) > -1) {
+            // resolve cyclic schema by using joi reference via generated unique ids
+            return this.resolveLink(schema);
+        }
+        else if (typeof schema === 'object') {
+            generatedId = randomString(10);
+            this.walkedSchemas.set(schema, generatedId);
+        }
+        if (typeof schema === 'string') {
+            // If schema is itself a string, interpret it as a type
+            resolvedSchema = this.resolveType({ type: schema }, ancestors);
+        }
+        else if (schema.$ref) {
+            resolvedSchema = this.resolve(this.resolveReference(schema.$ref), ancestors.concat(generatedId || ''));
+        }
+        else {
+            const partialSchemas = [];
+            if (schema.type) {
+                partialSchemas.push(this.resolveType(schema, ancestors.concat(generatedId || '')));
+            }
+            else if (schema.properties) {
+                // if no type is specified, just properties
+                partialSchemas.push(this.object(schema, ancestors.concat(generatedId || '')));
+            }
+            else if (schema.format) {
+                // if no type is specified, just format
+                partialSchemas.push(this.string(schema));
+            }
+            else if (schema.enum) {
+                // If no type is specified, just enum
+                partialSchemas.push(this.joi.any().valid(...schema.enum));
+            }
+            if (schema.anyOf) {
+                partialSchemas.push(this.resolveAnyOf(schema, ancestors.concat(generatedId || '')));
+            }
+            if (schema.allOf) {
+                partialSchemas.push(this.resolveAllOf(schema, ancestors.concat(generatedId || '')));
+            }
+            if (schema.oneOf) {
+                partialSchemas.push(this.resolveOneOf(schema, ancestors.concat(generatedId || '')));
+            }
+            if (schema.not) {
+                partialSchemas.push(this.resolveNot(schema, ancestors.concat(generatedId || '')));
+            }
+            if (partialSchemas.length === 0) {
+                //Fall through to whatever.
+                //eslint-disable-next-line no-console
+                console.warn("WARNING: schema missing a 'type' or '$ref' or 'enum': \n%s", JSON.stringify(schema, null, 2));
+                //TODO: Handle better
+                partialSchemas.push(this.joi.any());
+            }
+            resolvedSchema =
+                partialSchemas.length === 1
+                    ? partialSchemas[0]
+                    : this.joi.alternatives(partialSchemas).match('all');
+        }
+        if (generatedId) {
+            // we have finished resolving the schema, now attach the id generated earlier
+            resolvedSchema = resolvedSchema.id(this.walkedSchemas.get(schema));
+        }
+        if (this.refineSchema) {
+            resolvedSchema = this.refineSchema(resolvedSchema, schema);
+        }
+        if (this.useDefaults && schema.default !== undefined) {
+            resolvedSchema = resolvedSchema.default(schema.default);
+        }
+        return resolvedSchema;
+    }
+    resolveReference(value) {
+        let refschema;
+        const id = value.substr(0, value.indexOf('#') + 1);
+        const path = value.substr(value.indexOf('#') + 1);
+        if (id && this.subSchemas) {
+            refschema =
+                this.subSchemas[id] || this.subSchemas[id.substr(0, id.length - 1)];
+        }
+        if (!refschema) {
+            refschema = this.root;
+        }
+        Hoek.assert(refschema, 'Can not find schema reference: ' + value + '.');
+        let fragment = refschema;
+        const paths = path.split('/');
+        for (let i = 1; i < paths.length && fragment; i++) {
+            fragment = typeof fragment === 'object' && fragment[paths[i]];
+        }
+        return fragment;
+    }
+    resolveType(schema, ancestors) {
+        let joischema;
+        const typeDefinitionMap = {
+            description: 'description',
+            title: 'label',
+            default: 'default',
+        };
+        const joitype = (type, format) => {
+            let joischema;
+            if (this.refineType) {
+                type = this.refineType(type, format);
+            }
+            switch (type) {
+                case 'array':
+                    joischema = this.array(schema, ancestors);
+                    break;
+                case 'boolean':
+                    joischema = this.joi.boolean();
+                    break;
+                case 'integer':
+                case 'number':
+                    joischema = this.number(schema);
+                    break;
+                case 'object':
+                    joischema = this.object(schema, ancestors);
+                    break;
+                case 'string':
+                    joischema = this.string(schema);
+                    break;
+                case 'null':
+                    joischema = this.joi.any().valid(null);
+                    break;
+                default:
+                    joischema = this.joi.types()[type];
+            }
+            Hoek.assert(joischema, 'Could not resolve type: ' + schema.type + '.');
+            return this.strictMode === true ? joischema.strict(true) : joischema;
+        };
+        if (isArray(schema.type)) {
+            const schemas = [];
+            for (let i = 0; i < schema.type.length; i++) {
+                schemas.push(joitype(schema.type[i], schema.format));
+            }
+            joischema = this.joi.alternatives(schemas);
+        }
+        else {
+            joischema = joitype(schema.type, schema.format);
+        }
+        Object.keys(typeDefinitionMap).forEach((key) => {
+            if (schema[key] !== undefined) {
+                joischema = joischema[typeDefinitionMap[key]](schema[key]);
+            }
+        });
+        return joischema;
+    }
+    resolveOneOf(schema, ancestors) {
+        Hoek.assert(isArray(schema.oneOf), 'Expected oneOf to be an array.');
+        return this.joi
+            .alternatives(schema.oneOf.map((subSchema) => this.resolve(subSchema, ancestors)))
+            .match('one');
+    }
+    resolveAnyOf(schema, ancestors) {
+        Hoek.assert(isArray(schema.anyOf), 'Expected anyOf to be an array.');
+        return this.joi
+            .alternatives(schema.anyOf.map((subSchema) => this.resolve(subSchema, ancestors)))
+            .match('any');
+    }
+    resolveAllOf(schema, ancestors) {
+        Hoek.assert(isArray(schema.allOf), 'Expected allOf to be an array.');
+        return this.joi
+            .alternatives(schema.allOf.map((subSchema) => this.resolve(subSchema, ancestors)))
+            .match('all');
+    }
+    resolveNot(schema, ancestors) {
+        Hoek.assert(isObject(schema.not), 'Expected Not to be an object.');
+        return this.joi.alternatives().conditional('.', {
+            not: this.resolve(schema.not, ancestors),
+            then: this.joi.any(),
+            otherwise: this.joi.any().forbidden(),
+        });
+    }
+    resolveLink(schema) {
+        return this.joi.link().ref(`#${this.walkedSchemas.get(schema)}`);
+    }
+    object(schema, ancestors) {
+        const resolveproperties = () => {
+            const schemas = {};
+            if (!isObject(schema.properties)) {
+                return;
+            }
+            Object.keys(schema.properties).forEach((key) => {
+                const property = schema.properties[key];
+                let joischema = this.resolve(property, ancestors);
+                if (schema.required && schema.required.indexOf(key) !== -1) {
+                    joischema = joischema.required();
+                }
+                schemas[key] = joischema;
+            });
+            return schemas;
+        };
+        let joischema = this.joi.object(resolveproperties());
+        if (isObject(schema.additionalProperties)) {
+            joischema = joischema.pattern(/^/, this.resolve(schema.additionalProperties, ancestors));
+        }
+        else {
+            joischema = joischema.unknown(schema.additionalProperties !== false);
+        }
+        isNumber(schema.minProperties) &&
+            (joischema = joischema.min(schema.minProperties));
+        isNumber(schema.maxProperties) &&
+            (joischema = joischema.max(schema.maxProperties));
+        return joischema;
+    }
+    array(schema, ancestors) {
+        let joischema = this.joi.array();
+        let items;
+        const resolveAsArray = (value) => {
+            if (isArray(value)) {
+                // found an array, thus its _per type_
+                return value.map((v) => this.resolve(v, ancestors));
+            }
+            // it's a single entity, so just resolve it normally
+            return [this.resolve(value, ancestors)];
+        };
+        if (schema.items) {
+            items = resolveAsArray(schema.items);
+            joischema = joischema.items(...items);
+        }
+        else if (schema.ordered) {
+            items = resolveAsArray(schema.ordered);
+            joischema = joischema.ordered(...items);
+        }
+        if (items && schema.additionalItems === false) {
+            joischema = joischema.max(items.length);
+        }
+        isNumber(schema.minItems) && (joischema = joischema.min(schema.minItems));
+        isNumber(schema.maxItems) && (joischema = joischema.max(schema.maxItems));
+        if (schema.uniqueItems) {
+            joischema = joischema.unique();
+        }
+        return joischema;
+    }
+    number(schema) {
+        let joischema = this.joi.number();
+        if (schema.type === 'integer') {
+            joischema = joischema.integer();
+        }
+        isNumber(schema.minimum) && (joischema = joischema.min(schema.minimum));
+        isNumber(schema.maximum) && (joischema = joischema.max(schema.maximum));
+        isNumber(schema.exclusiveMinimum) &&
+            (joischema = joischema.greater(schema.exclusiveMinimum));
+        isNumber(schema.exclusiveMaximum) &&
+            (joischema = joischema.less(schema.exclusiveMaximum));
+        isNumber(schema.multipleOf) &&
+            schema.multipleOf !== 0 &&
+            (joischema = joischema.multiple(schema.multipleOf));
+        return joischema;
+    }
+    string(schema) {
+        let joischema = this.joi.string();
+        const dateRegex = '(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])';
+        const timeRegex = '([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(.[0-9]+)?(Z|(\\+|-)([01][0-9]|2[0-3]):([0-5][0-9]))';
+        const dateTimeRegex = dateRegex + 'T' + timeRegex;
+        if (schema.enum) {
+            return this.joi.string().valid(...schema.enum);
+        }
+        switch (schema.format) {
+            case 'date':
+                return joischema.regex(new RegExp('^' + dateRegex + '$', 'i'), 'JsonSchema date format');
+            case 'time':
+                return joischema.regex(new RegExp('^' + timeRegex + '$', 'i'), 'JsonSchema time format');
+            case 'date-time':
+                return joischema.regex(new RegExp('^' + dateTimeRegex + '$', 'i'), 'JsonSchema date-time format');
+            case 'binary':
+                joischema = this.binary(schema);
+                break;
+            case 'email':
+                return joischema.email();
+            case 'hostname':
+                return joischema.hostname();
+            case 'ipv4':
+                return joischema.ip({
+                    version: ['ipv4'],
+                });
+            case 'ipv6':
+                return joischema.ip({
+                    version: ['ipv6'],
+                });
+            case 'uri':
+                return joischema.uri();
+            case 'byte':
+                joischema = joischema.base64();
+                break;
+            case 'uuid':
+                return joischema.guid({ version: ['uuidv4'] });
+            case 'guid':
+                return joischema.guid();
+        }
+        return this.regularString(schema, joischema);
+    }
+    regularString(schema, joischema) {
+        schema.pattern && (joischema = joischema.regex(new RegExp(schema.pattern)));
+        if (isUndefined(schema.minLength)) {
+            schema.minLength = 0;
+            if (!schema.pattern && !schema.format) {
+                joischema = joischema.allow('');
+            }
+        }
+        else if (schema.minLength === 0) {
+            joischema = joischema.allow('');
+        }
+        isNumber(schema.minLength) && (joischema = joischema.min(schema.minLength));
+        isNumber(schema.maxLength) && (joischema = joischema.max(schema.maxLength));
+        return joischema;
+    }
+    binary(schema) {
+        let joischema = this.joi.binary();
+        isNumber(schema.minLength) && (joischema = joischema.min(schema.minLength));
+        isNumber(schema.maxLength) && (joischema = joischema.max(schema.maxLength));
+        return joischema;
+    }
+}
+/**
+ * Enjoi-compatible API
+ * Creates a Joi schema from a JSON Schema
+ * @param jsonSchema - The JSON schema to convert
+ * @param options - Optional configuration for schema resolution
+ * @returns Joi schema with validate method
+ */
+function schema(jsonSchema, options) {
+    const resolver = new SchemaResolver(jsonSchema, options);
+    return resolver.resolve();
+}
+// Export both the class and the compatible API
+export { SchemaResolver, schema };
+export default { schema };

package/docker/base/Dockerfile

@@ -6,7 +6,7 @@ ARG DEBIAN_FRONTEND=noninteractive
 ARG TZ=America/Los_Angeles
 ARG BLESS_USER_ID=999
 ARG APP_DIR=/usr/src/app
-ARG NODE_VERSION=v22.11.0
+ARG NODE_VERSION=v24.2.0
 
 ENV NODE_VERSION=$NODE_VERSION
 ENV NVM_DIR /usr/src/.nvm
@@ -54,7 +54,7 @@ RUN apt-get update && apt-get install -y \
   wget \
   xvfb
 
-RUN curl -sL https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.3/install.sh | bash &&\
+RUN curl -sL https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash &&\
   . $NVM_DIR/nvm.sh &&\
   nvm install $NODE_VERSION
 

package/extensions/ublocklite/README.md

@@ -7,8 +7,10 @@ The following assumes a linux environment.
 1. Open Bash console
 2. `git clone  https://github.com/gorhill/uBlock.git`
 3. `cd uBlock`
-4. `make mv3-[platform]`, where `[platform]` is either `chromium`, `edge`, `firefox`, or `safari`
-5. This will fully build uBO Lite, and during the process filter lists will be downloaded from their respective remote servers
+4. `git submodule init`
+5. `git submodule update`
+6. `make mv3-[platform]`, where `[platform]` is either `chromium`, `edge`, `firefox`, or `safari`
+7. This will fully build uBO Lite, and during the process filter lists will be downloaded from their respective remote servers
 
 Upon completion of the script, the resulting extension package will become present in: