@browserless.io/browserless 2.36.0 → 2.37.1

package/extensions/ublocklite/rulesets/strictblock/vie-1.json

@@ -16,7 +16,6 @@
    "adtima-static.zascdn.me",
    "adtimaserver.vn",
    "ae.carnelbawrel.com",
-   "afzamltca.com",
    "aiactiv.io",
    "aj1047.online",
    "aj2393.online",
@@ -45,7 +44,6 @@
    "iads.staticscdn.net",
    "iads.vision",
    "img.yeuketqua.net",
-   "immaculate-suspect.com",
    "js.aiservice.vn",
    "jsc.yodimedia.com",
    "lepidpomps.com",
@@ -63,7 +61,6 @@
    "pub.akadigital.vn",
    "pub.lavamedia.vn",
    "qc.violet.vn",
-   "qcv5.blogtruyenmoi.com",
    "sbbanner.com",
    "sourcetobin.com",
    "ss.yomedia.vn",

package/extensions/ublocklite/rulesets/urlskip/ublock-filters.json

@@ -417,11 +417,15 @@
   ]
  },
  {
-  "re": "^[a-z-]+://(?:[^/?#]+\\.)?click\\.pstmrk\\.it/\\S*?/",
+  "re": "^[a-z-]+://(?:[^/?#]+\\.)?pstmrk\\.it/\\S*?/",
   "steps": [
    "/\\.pstmrk\\.it\\/[23][mst]{0,2}\\/([^\\/?#]+)/",
    "-uricomponent",
    "+https"
+  ],
+  "hostnames": [
+   "click.pstmrk.it",
+   "track.pstmrk.it"
   ]
  },
  {
@@ -1092,6 +1096,32 @@
    "?goto"
   ]
  },
+ {
+  "re": "^[a-z-]+://(?:[^/?#]+\\.)?sourceforge\\.net/software/link\\?\\S*?__oadest=http",
+  "steps": [
+   "/__oadest=(http[^#&]+)/",
+   "-uricomponent"
+  ]
+ },
+ {
+  "re": "^[a-z-]+://(?:[^/?#]+\\.)?5ch\\.net/jump/to\\?url=http",
+  "steps": [
+   "?url"
+  ]
+ },
+ {
+  "re": "^[a-z-]+://(?:[^/?#]+\\.)?adj\\.st/\\S*?(?:[^%.0-9a-z_-]|$)url=http",
+  "steps": [
+   "?url"
+  ]
+ },
+ {
+  "re": "^[a-z-]+://(?:[^/?#]+\\.)?lit\\.link/redirects/link-ad\\?redirecturl=ahr0c",
+  "steps": [
+   "?redirectUrl",
+   "-base64"
+  ]
+ },
  {
   "re": "/vp/player/to/\\?u=http",
   "steps": [

package/extensions/ublocklite/web_accessible_resources/google-ima.js

@@ -18,6 +18,7 @@
  * 
  * Related issue:
  * - https://github.com/uBlockOrigin/uBlock-issues/issues/2158
+ * - https://github.com/uBlockOrigin/uAssets/issues/30134
  * 
 **/
  
@@ -388,21 +389,23 @@ if (!window.google || !window.google.ima || !window.google.ima.VERSION) {
     getVersion() {
       return VERSION;
     }
-    requestAds(/*r, c*/) {
+    requestAds(_r, _c) {
       // If autoplay is disabled and the page is trying to autoplay a tracking
       // ad, then IMA fails with an error, and the page is expected to request
       // ads again later when the user clicks to play.
       CheckCanAutoplay().then(
         () => {
           const { ADS_MANAGER_LOADED } = AdsManagerLoadedEvent.Type;
-          this._dispatch(new ima.AdsManagerLoadedEvent(ADS_MANAGER_LOADED));
+          this._dispatch(new ima.AdsManagerLoadedEvent(ADS_MANAGER_LOADED, _r, _c));
         },
         () => {
           const e = new ima.AdError(
             "adPlayError",
             1205,
             1205,
-            "The browser prevented playback initiated without user interaction."
+            "The browser prevented playback initiated without user interaction.",
+            _r,
+            _c
           );
           this._dispatch(new ima.AdErrorEvent(e));
         }
@@ -638,10 +641,12 @@ if (!window.google || !window.google.ima || !window.google.ima.VERSION) {
   }
 
   class AdError {
-    constructor(type, code, vast, message) {
+    constructor(type, code, vast, message, request, context) {
       this.errorCode = code;
       this.message = message;
       this.type = type;
+      this.adsRequest = request;
+      this.userRequestContext = context;
       this.vastErrorCode = vast;
     }
     getErrorCode() {
@@ -738,7 +743,7 @@ if (!window.google || !window.google.ima || !window.google.ima.VERSION) {
       return this.error;
     }
     getUserRequestContext() {
-      return {};
+      return this.error?.userRequestContext || {};
     }
   }
   AdErrorEvent.Type = {
@@ -748,8 +753,10 @@ if (!window.google || !window.google.ima || !window.google.ima.VERSION) {
   const manager = new AdsManager();
 
   class AdsManagerLoadedEvent {
-    constructor(type) {
+    constructor(type, request, context) {
       this.type = type;
+      this.adsRequest = request;
+      this.userRequestContext = context;
     }
     getAdsManager(c, settings) {
       if (settings && settings.enablePreloading) {
@@ -758,7 +765,7 @@ if (!window.google || !window.google.ima || !window.google.ima.VERSION) {
       return manager;
     }
     getUserRequestContext() {
-      return {};
+      return this.userRequestContext || {};
     }
   }
   AdsManagerLoadedEvent.Type = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browserless.io/browserless",
-  "version": "2.36.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"
   },
@@ -64,12 +65,12 @@
     "playwright-1.52": "npm:playwright-core@1.52.0",
     "playwright-1.53": "npm:playwright-core@1.53.2",
     "playwright-1.54": "npm:playwright-core@1.54.2",
-    "playwright-core": "1.55.0",
-    "puppeteer-core": "24.22.0",
+    "playwright-core": "1.55.1",
+    "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.0",
-    "@typescript-eslint/parser": "^8.42.0",
+    "@typescript-eslint/eslint-plugin": "^8.46.0",
+    "@typescript-eslint/parser": "^8.46.0",
     "assert": "^2.0.0",
     "c8": "^10.1.3",
-    "chai": "^6.0.1",
-    "cross-env": "^10.0.0",
+    "chai": "^6.2.0",
+    "cross-env": "^10.1.0",
     "env-cmd": "^11.0.0",
     "esbuild": "^0.25.10",
     "esbuild-plugin-polyfill-node": "^0.3.0",
-    "eslint": "^9.35.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

@@ -40,6 +40,7 @@ import micromatch from 'micromatch';
 import path from 'path';
 
 export class BrowserManager {
+  protected reconnectionPatterns = ['/devtools/browser', '/function/connect'];
   protected browsers: Map<BrowserInstance, BrowserlessSession> = new Map();
   protected timers: Map<string, NodeJS.Timeout> = new Map();
   protected log = new Logger('browser-manager');
@@ -461,12 +462,12 @@ export class BrowserManager {
     let parsedLaunchOptions: BrowserServerOptions | CDPLaunchOptions;
 
     // Handle browser re-connects here
-    if (req.parsed.pathname.includes('/devtools/browser')) {
+    if (
+      this.reconnectionPatterns.some((p) => req.parsed.pathname.includes(p))
+    ) {
       const sessions = Array.from(this.browsers);
       const id = req.parsed.pathname.split('/').pop() as string;
-      const found = sessions.find(([b]) =>
-        b.wsEndpoint()?.includes(req.parsed.pathname),
-      );
+      const found = sessions.find(([b]) => b.wsEndpoint()?.includes(id));
 
       if (found) {
         const [browser, session] = found;
@@ -541,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
@@ -565,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/http.ts

@@ -88,12 +88,13 @@ export enum WebsocketRoutes {
   '/' = '?(/)',
   browser = '/devtools/browser/*',
   chrome = '/chrome?(/)',
-  edge = '/edge?(/)',
   chromePlaywright = '/chrome/playwright?(/)',
-  edgePlaywright = '/edge/playwright?(/)',
   chromium = '/chromium?(/)',
   chromiumPlaywright = '/chromium/playwright?(/)',
+  edge = '/edge?(/)',
+  edgePlaywright = '/edge/playwright?(/)',
   firefoxPlaywright = '/firefox/playwright?(/)',
+  functionClientConnect = '/function/connect/*',
   page = '/devtools/page/*',
   playwrightChrome = '/playwright/chrome?(/)',
   playwrightChromium = '/playwright/chromium?(/)',

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/chrome/tests/kill-sessions.spec.ts

@@ -23,9 +23,6 @@ describe('/kill API', function () {
     const browser1 = await puppeteer.connect({
       browserWSEndpoint: `ws://localhost:3000/chrome?token=6R0W53R135510`,
     });
-    const browser2 = await puppeteer.connect({
-      browserWSEndpoint: `ws://localhost:3000/chrome?token=6R0W53R135510`,
-    });
 
     await fetch('http://localhost:3000/kill/all?token=6R0W53R135510').then(
       async (res) => {
@@ -39,14 +36,7 @@ describe('/kill API', function () {
     } catch (e) {
       errorThrown1 = e;
     }
-    let errorThrown2;
-    try {
-      await browser2.newPage();
-    } catch (e) {
-      errorThrown2 = e;
-    }
     expect((errorThrown1 as Error).message).contains('closed');
-    expect((errorThrown2 as Error).message).contains('closed');
   });
 
   it('Kill session by browserId', async () => {

package/src/routes/chrome/ws/function-connect.ts

@@ -0,0 +1,12 @@
+import { BrowserlessRoutes, ChromeCDP } from '@browserless.io/browserless';
+import {
+  default as FunctionConnect,
+  QuerySchema,
+} from '../../../shared/function-connect.ws.js';
+
+export default class ChromeFunctionConnectWebSocketRoute extends FunctionConnect {
+  name = BrowserlessRoutes.ChromeFunctionConnectWebSocketRoute;
+  browser = ChromeCDP;
+}
+
+export { QuerySchema };

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);
+    });
+  });
+
+
 });