@browserless.io/browserless 2.37.0 → 2.37.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browserless.io/browserless",
-  "version": "2.37.0",
+  "version": "2.37.1",
   "license": "SSPL",
   "description": "The browserless platform",
   "author": "browserless.io",
@@ -21,6 +21,7 @@
     "build:schemas": "node scripts/build-schemas.js",
     "build:openapi": "node scripts/build-open-api.js",
     "build:ts": "tsc",
+    "build:tests": "npm run build:ts && npm run build:function && npm run install:debugger",
     "clean": "node scripts/clean.js",
     "dev": "npm run build:dev && env-cmd -f .env node build",
     "install:adblock": "node scripts/install-adblock.js",
@@ -30,7 +31,7 @@
     "lint": "cross-env ESLINT_USE_FLAT_CONFIG=false eslint . --ext .ts --fix",
     "prepack": "npm run build:dev",
     "prettier": "prettier '{src,functions,scripts,bin,external,.github}/**/*.{js,ts,json,yml,yaml,md}' --log-level error --write",
-    "test": "npm run build:ts && cross-env DEBUG=quiet mocha",
+    "test": "npm run build:tests && cross-env DEBUG=quiet mocha",
     "coverage": "npm run build:ts && c8 --reporter=text --reporter=html --reporter=lcov cross-env DEBUG=quiet mocha",
     "start": "env-cmd -f .env node build"
   },
@@ -65,11 +66,11 @@
     "playwright-1.53": "npm:playwright-core@1.53.2",
     "playwright-1.54": "npm:playwright-core@1.54.2",
     "playwright-core": "1.55.1",
-    "puppeteer-core": "24.22.3",
+    "puppeteer-core": "24.23.0",
     "puppeteer-extra": "^3.3.6",
     "puppeteer-extra-plugin-stealth": "^2.11.2",
     "queue": "^7.0.0",
-    "systeminformation": "^5.27.10",
+    "systeminformation": "^5.27.11",
     "tar-fs": "^3.1.1"
   },
   "optionalDependencies": {
@@ -79,27 +80,27 @@
     "@types/http-proxy": "^1.17.16",
     "@types/micromatch": "^4.0.9",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^24.5.2",
+    "@types/node": "^24.7.0",
     "@types/sinon": "^17.0.4",
-    "@typescript-eslint/eslint-plugin": "^8.44.1",
-    "@typescript-eslint/parser": "^8.44.1",
+    "@typescript-eslint/eslint-plugin": "^8.46.0",
+    "@typescript-eslint/parser": "^8.46.0",
     "assert": "^2.0.0",
     "c8": "^10.1.3",
     "chai": "^6.2.0",
-    "cross-env": "^10.0.0",
+    "cross-env": "^10.1.0",
     "env-cmd": "^11.0.0",
     "esbuild": "^0.25.10",
     "esbuild-plugin-polyfill-node": "^0.3.0",
-    "eslint": "^9.36.0",
+    "eslint": "^9.37.0",
     "extract-zip": "^2.0.1",
     "gunzip-maybe": "^1.4.2",
-    "marked": "^16.3.0",
-    "mocha": "^11.7.2",
+    "marked": "^16.4.0",
+    "mocha": "^11.7.4",
     "move-file": "^3.1.0",
     "prettier": "^3.6.2",
     "sinon": "^21.0.0",
     "ts-node": "^10.9.2",
-    "typescript": "^5.8.3",
+    "typescript": "^5.9.3",
     "typescript-json-schema": "^0.65.1"
   },
   "playwrightVersions": {

package/scripts/install-debugger.js

@@ -6,7 +6,7 @@ import os from 'os';
 
 import { deleteAsync } from 'del';
 import gunzip from 'gunzip-maybe';
-import { moveFile } from 'move-file';
+import { cp } from 'fs/promises';
 import tar from 'tar-fs';
 
 const registryURL = 'https://registry.npmjs.org/@browserless.io/debugger/';
@@ -52,7 +52,7 @@ const getLatestVersion = async () => {
     process.exit(1);
   });
 
-  await moveFile(untarDir, debuggerDir);
+  await cp(untarDir, debuggerDir, { recursive: true });
   await deleteAsync(tmp, { force: true });
 })().catch((error) => {
   console.error(`An error occurred: ${error.message}`);

package/src/browsers/index.ts

@@ -542,6 +542,16 @@ export class BrowserManager {
       ...routerOptions,
       ...parsedLaunchOptions,
     };
+    const proxyServerParam = req.parsed.searchParams.get('--proxy-server');
+    if (proxyServerParam) {
+      const existingArgs = launchOptions.args || [];
+      const filteredArgs = existingArgs.filter(
+        (arg) => !arg.includes('--proxy-server='),
+      );
+      launchOptions.args = [...filteredArgs, `--proxy-server=${proxyServerParam}`];
+    }
+
+
 
     const manualUserDataDir =
       launchOptions.args
@@ -566,6 +576,16 @@ export class BrowserManager {
       arg.includes('--proxy-server='),
     );
 
+    /**
+     * Handle deprecated launch options
+     */
+    if (Object.hasOwn(launchOptions, 'ignoreHTTPSErrors')) {
+      if (!Object.hasOwn(launchOptions, 'acceptInsecureCerts')) {
+        (launchOptions as CDPLaunchOptions).acceptInsecureCerts = (launchOptions as CDPLaunchOptions).ignoreHTTPSErrors;
+      }
+      delete (launchOptions as CDPLaunchOptions).ignoreHTTPSErrors;
+    }
+
     /**
      * If it is a playwright request
      */

package/src/routes/chrome/tests/content.spec.ts

@@ -373,4 +373,28 @@ describe('/chrome/content API', function () {
       expect(res.status).to.equal(200);
     });
   });
+
+  it('can accept insecure certs', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const body = {
+      gotoOptions: {
+        waitUntil: `networkidle2`,
+      },
+      url: 'https://self-signed.badssl.com',
+    };
+
+    await fetch('http://localhost:3000/chrome/content?token=browserless&launch={"acceptInsecureCerts":true}', {
+      body: JSON.stringify(body),
+      headers: {
+        'content-type': 'application/json',
+      },
+      method: 'POST',
+    }).then(async (res) => {
+      expect(res.status).to.equal(200);
+    });
+  });
 });

package/src/routes/chrome/tests/json.spec.ts

@@ -0,0 +1,134 @@
+import { Browserless, Config, Metrics } from '@browserless.io/browserless';
+import { expect } from 'chai';
+
+describe('/json/ API', function () {
+  let browserless: Browserless;
+
+  const start = ({
+    config = new Config(),
+    metrics = new Metrics(),
+  }: { config?: Config; metrics?: Metrics } = {}) => {
+    browserless = new Browserless({ config, metrics });
+    return browserless.start();
+  };
+
+  afterEach(async () => {
+    await browserless.stop();
+  });
+
+  it('allows requests to /json/version', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch(
+      'http://localhost:3000/json/version?token=browserless',
+    );
+    const resJSON = await res.json();
+
+    [
+      'Browser',
+      'Protocol-Version',
+      'User-Agent',
+      'V8-Version',
+      'WebKit-Version',
+      'webSocketDebuggerUrl',
+      'Debugger-Version',
+    ].forEach((k) => expect(resJSON).to.haveOwnProperty(k));
+  });
+
+  it('rejects unauthorized requests to /json/version', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch(
+      'http://localhost:3000/json/version?token=imabadboi',
+    );
+    expect(res.status).to.equal(401);
+  });
+
+  it('rejects unauthorized requests to /json/list', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch('http://localhost:3000/json/list?token=imabadboi');
+    expect(res.status).to.equal(401);
+  });
+
+  it('allows requests to /json/protocol', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch(
+      'http://localhost:3000/json/protocol?token=browserless',
+    );
+    expect(res.status).to.equal(200);
+    const resJSON = await res.json();
+    expect(resJSON).to.be.an('object');
+    expect(resJSON).to.haveOwnProperty('version');
+    expect(resJSON).to.haveOwnProperty('domains');
+  });
+
+  it('rejects unauthorized requests to /json/protocol', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch(
+      'http://localhost:3000/json/protocol?token=imabadboi',
+    );
+    expect(res.status).to.equal(401);
+  });
+
+  it('allows requests to PUT /json/new', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch(
+      'http://localhost:3000/json/new?token=browserless',
+      {
+        method: 'PUT',
+      },
+    );
+    expect(res.status).to.equal(200);
+    const resJSON = await res.json();
+
+    const keys = [
+      'description',
+      'devtoolsFrontendUrl',
+      'id',
+      'title',
+      'type',
+      'url',
+      'webSocketDebuggerUrl',
+    ];
+    keys.forEach((k) => expect(resJSON).to.haveOwnProperty(k));
+
+    expect(resJSON.type).to.equal('page');
+    expect(resJSON.title).to.equal('New Tab');
+    expect(resJSON.url).to.equal('about:blank');
+    expect(resJSON.description).to.equal('');
+  });
+
+  it('rejects unauthorized requests to PUT /json/new', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch('http://localhost:3000/json/new?token=imabadboi', {
+      method: 'PUT',
+    });
+    expect(res.status).to.equal(401);
+  });
+});

package/src/routes/chromium/tests/content.spec.ts

@@ -399,4 +399,28 @@ describe('/chromium/content API', function () {
       expect(res.status).to.equal(200);
     });
   });
+
+  it('can accept insecure certs', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const body = {
+      gotoOptions: {
+        waitUntil: `networkidle2`,
+      },
+      url: 'https://self-signed.badssl.com',
+    };
+
+    await fetch('http://localhost:3000/chromium/content?token=browserless&launch={"acceptInsecureCerts":true}', {
+      body: JSON.stringify(body),
+      headers: {
+        'content-type': 'application/json',
+      },
+      method: 'POST',
+    }).then(async (res) => {
+      expect(res.status).to.equal(200);
+    });
+  });
 });

package/src/routes/chromium/tests/function.spec.ts

@@ -279,4 +279,37 @@ describe('/chromium/function API', function () {
       expect(res.status).to.equal(200);
     });
   });
+  it('allows --proxy-server query parameter', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+    const body = {
+      code: `export default async function ({ page }) {
+        return Promise.resolve({
+          data: "ok",
+          type: "application/text",
+        });
+      }`,
+      context: {},
+    };
+
+    await fetch(
+      'http://localhost:3000/chromium/function?--proxy-server=test.proxy.com:8080&token=browserless',
+      {
+        body: JSON.stringify(body),
+        headers: {
+          'content-type': 'application/json',
+        },
+        method: 'POST',
+      },
+    ).then(async (res) => {
+      const json = await res.json();
+      expect(json).to.have.property('data');
+      expect(json.data).to.equal('ok');
+      expect(res.status).to.equal(200);
+    });
+  });
+
+
 });

package/src/routes/chromium/tests/json.spec.ts

@@ -0,0 +1,134 @@
+import { Browserless, Config, Metrics } from '@browserless.io/browserless';
+import { expect } from 'chai';
+
+describe('/json/ API', function () {
+  let browserless: Browserless;
+
+  const start = ({
+    config = new Config(),
+    metrics = new Metrics(),
+  }: { config?: Config; metrics?: Metrics } = {}) => {
+    browserless = new Browserless({ config, metrics });
+    return browserless.start();
+  };
+
+  afterEach(async () => {
+    await browserless.stop();
+  });
+
+  it('allows requests to /json/version', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch(
+      'http://localhost:3000/json/version?token=browserless',
+    );
+    const resJSON = await res.json();
+
+    [
+      'Browser',
+      'Protocol-Version',
+      'User-Agent',
+      'V8-Version',
+      'WebKit-Version',
+      'webSocketDebuggerUrl',
+      'Debugger-Version',
+    ].forEach((k) => expect(resJSON).to.haveOwnProperty(k));
+  });
+
+  it('rejects unauthorized requests to /json/version', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch(
+      'http://localhost:3000/json/version?token=imabadboi',
+    );
+    expect(res.status).to.equal(401);
+  });
+
+  it('rejects unauthorized requests to /json/list', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch('http://localhost:3000/json/list?token=imabadboi');
+    expect(res.status).to.equal(401);
+  });
+
+  it('allows requests to /json/protocol', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch(
+      'http://localhost:3000/json/protocol?token=browserless',
+    );
+    expect(res.status).to.equal(200);
+    const resJSON = await res.json();
+    expect(resJSON).to.be.an('object');
+    expect(resJSON).to.haveOwnProperty('version');
+    expect(resJSON).to.haveOwnProperty('domains');
+  });
+
+  it('rejects unauthorized requests to /json/protocol', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch(
+      'http://localhost:3000/json/protocol?token=imabadboi',
+    );
+    expect(res.status).to.equal(401);
+  });
+
+  it('allows requests to PUT /json/new', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch(
+      'http://localhost:3000/json/new?token=browserless',
+      {
+        method: 'PUT',
+      },
+    );
+    expect(res.status).to.equal(200);
+    const resJSON = await res.json();
+
+    const keys = [
+      'description',
+      'devtoolsFrontendUrl',
+      'id',
+      'title',
+      'type',
+      'url',
+      'webSocketDebuggerUrl',
+    ];
+    keys.forEach((k) => expect(resJSON).to.haveOwnProperty(k));
+
+    expect(resJSON.type).to.equal('page');
+    expect(resJSON.title).to.equal('New Tab');
+    expect(resJSON.url).to.equal('about:blank');
+    expect(resJSON.description).to.equal('');
+  });
+
+  it('rejects unauthorized requests to PUT /json/new', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch('http://localhost:3000/json/new?token=imabadboi', {
+      method: 'PUT',
+    });
+    expect(res.status).to.equal(401);
+  });
+});

package/src/routes/chromium/tests/scrape.spec.ts

@@ -454,7 +454,9 @@ describe('/chromium/scrape API', function () {
       expect(json.data).to.have.length(3);
 
       const aResults = json.data.find((item: any) => item.selector === 'a');
-      const nonexistentResults = json.data.find((item: any) => item.selector === 'nonexistent-element');
+      const nonexistentResults = json.data.find(
+        (item: any) => item.selector === 'nonexistent-element',
+      );
       const h1Results = json.data.find((item: any) => item.selector === 'h1');
 
       expect(aResults.results).to.be.an('array');

package/src/routes/edge/tests/content.spec.ts

@@ -373,4 +373,28 @@ describe('/edge/content API', function () {
       expect(res.status).to.equal(200);
     });
   });
+
+  it('can accept insecure certs', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const body = {
+      gotoOptions: {
+        waitUntil: `networkidle2`,
+      },
+      url: 'https://self-signed.badssl.com',
+    };
+
+    await fetch('http://localhost:3000/edge/content?token=browserless&launch={"acceptInsecureCerts":true}', {
+      body: JSON.stringify(body),
+      headers: {
+        'content-type': 'application/json',
+      },
+      method: 'POST',
+    }).then(async (res) => {
+      expect(res.status).to.equal(200);
+    });
+  });
 });

package/src/routes/edge/tests/json.spec.ts

@@ -0,0 +1,134 @@
+import { Browserless, Config, Metrics } from '@browserless.io/browserless';
+import { expect } from 'chai';
+
+describe('/json/ API', function () {
+  let browserless: Browserless;
+
+  const start = ({
+    config = new Config(),
+    metrics = new Metrics(),
+  }: { config?: Config; metrics?: Metrics } = {}) => {
+    browserless = new Browserless({ config, metrics });
+    return browserless.start();
+  };
+
+  afterEach(async () => {
+    await browserless.stop();
+  });
+
+  it('allows requests to /json/version', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch(
+      'http://localhost:3000/json/version?token=browserless',
+    );
+    const resJSON = await res.json();
+
+    [
+      'Browser',
+      'Protocol-Version',
+      'User-Agent',
+      'V8-Version',
+      'WebKit-Version',
+      'webSocketDebuggerUrl',
+      'Debugger-Version',
+    ].forEach((k) => expect(resJSON).to.haveOwnProperty(k));
+  });
+
+  it('rejects unauthorized requests to /json/version', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch(
+      'http://localhost:3000/json/version?token=imabadboi',
+    );
+    expect(res.status).to.equal(401);
+  });
+
+  it('rejects unauthorized requests to /json/list', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch('http://localhost:3000/json/list?token=imabadboi');
+    expect(res.status).to.equal(401);
+  });
+
+  it('allows requests to /json/protocol', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch(
+      'http://localhost:3000/json/protocol?token=browserless',
+    );
+    expect(res.status).to.equal(200);
+    const resJSON = await res.json();
+    expect(resJSON).to.be.an('object');
+    expect(resJSON).to.haveOwnProperty('version');
+    expect(resJSON).to.haveOwnProperty('domains');
+  });
+
+  it('rejects unauthorized requests to /json/protocol', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch(
+      'http://localhost:3000/json/protocol?token=imabadboi',
+    );
+    expect(res.status).to.equal(401);
+  });
+
+  it('allows requests to PUT /json/new', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch(
+      'http://localhost:3000/json/new?token=browserless',
+      {
+        method: 'PUT',
+      },
+    );
+    expect(res.status).to.equal(200);
+    const resJSON = await res.json();
+
+    const keys = [
+      'description',
+      'devtoolsFrontendUrl',
+      'id',
+      'title',
+      'type',
+      'url',
+      'webSocketDebuggerUrl',
+    ];
+    keys.forEach((k) => expect(resJSON).to.haveOwnProperty(k));
+
+    expect(resJSON.type).to.equal('page');
+    expect(resJSON.title).to.equal('New Tab');
+    expect(resJSON.url).to.equal('about:blank');
+    expect(resJSON.description).to.equal('');
+  });
+
+  it('rejects unauthorized requests to PUT /json/new', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch('http://localhost:3000/json/new?token=imabadboi', {
+      method: 'PUT',
+    });
+    expect(res.status).to.equal(401);
+  });
+});