@browserless.io/browserless 2.24.0-beta-5 → 2.24.1

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

@@ -0,0 +1,193 @@
+{
+  "type": "object",
+  "properties": {
+    "token": {
+      "description": "The authorization token",
+      "type": "string"
+    },
+    "browserId": {
+      "type": "string"
+    },
+    "trackingId": {
+      "description": "Custom session identifier",
+      "type": "string"
+    },
+    "blockAds": {
+      "description": "Whether or nor to load ad-blocking extensions for the session.\nThis currently uses uBlock Origin and may cause certain sites\nto not load properly.",
+      "type": "boolean"
+    },
+    "launch": {
+      "description": "Launch options, which can be either an object\nof puppeteer.launch options or playwright.launchServer\noptions, depending on the API. Must be either JSON\nobject, or a base64-encoded JSON object.",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/CDPLaunchOptions"
+        },
+        {
+          "$ref": "#/definitions/BrowserServerOptions"
+        },
+        {
+          "type": "string"
+        }
+      ]
+    },
+    "timeout": {
+      "description": "Override the system-level timeout for this request.\nAccepts a value in milliseconds.",
+      "type": "number"
+    }
+  },
+  "additionalProperties": false,
+  "required": [
+    "token"
+  ],
+  "definitions": {
+    "CDPLaunchOptions": {
+      "type": "object",
+      "properties": {
+        "args": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "defaultViewport": {
+          "type": "object",
+          "properties": {
+            "deviceScaleFactor": {
+              "type": "number"
+            },
+            "hasTouch": {
+              "type": "boolean"
+            },
+            "height": {
+              "type": "number"
+            },
+            "isLandscape": {
+              "type": "boolean"
+            },
+            "isMobile": {
+              "type": "boolean"
+            },
+            "width": {
+              "type": "number"
+            }
+          },
+          "additionalProperties": false,
+          "required": [
+            "height",
+            "width"
+          ]
+        },
+        "devtools": {
+          "type": "boolean"
+        },
+        "dumpio": {
+          "type": "boolean"
+        },
+        "headless": {
+          "enum": [
+            false,
+            "shell",
+            true
+          ]
+        },
+        "ignoreDefaultArgs": {
+          "anyOf": [
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            {
+              "type": "boolean"
+            }
+          ]
+        },
+        "ignoreHTTPSErrors": {
+          "type": "boolean"
+        },
+        "slowMo": {
+          "type": "number"
+        },
+        "stealth": {
+          "type": "boolean"
+        },
+        "timeout": {
+          "type": "number"
+        },
+        "userDataDir": {
+          "type": "string"
+        },
+        "waitForInitialPage": {
+          "type": "boolean"
+        }
+      },
+      "additionalProperties": false
+    },
+    "BrowserServerOptions": {
+      "type": "object",
+      "properties": {
+        "args": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "chromiumSandbox": {
+          "type": "boolean"
+        },
+        "devtools": {
+          "type": "boolean"
+        },
+        "downloadsPath": {
+          "type": "string"
+        },
+        "headless": {
+          "type": "boolean"
+        },
+        "ignoreDefaultArgs": {
+          "anyOf": [
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            {
+              "type": "boolean"
+            }
+          ]
+        },
+        "proxy": {
+          "type": "object",
+          "properties": {
+            "bypass": {
+              "type": "string"
+            },
+            "password": {
+              "type": "string"
+            },
+            "server": {
+              "type": "string"
+            },
+            "username": {
+              "type": "string"
+            }
+          },
+          "additionalProperties": false,
+          "required": [
+            "server"
+          ]
+        },
+        "timeout": {
+          "type": "number"
+        },
+        "tracesDir": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

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

@@ -1,9 +1,10 @@
 import { APITags, BrowserlessRoutes, ChromiumCDP, FirefoxPlaywright, HTTPManagementRoutes, HTTPRoute, Methods, WebKitPlaywright, availableBrowsers, contentTypes, jsonResponse, } from '@browserless.io/browserless';
 import { createRequire } from 'module';
+import path from 'path';
 const semverReg = /(\*|\^|>|=|<|~)/gi;
 const require = createRequire(import.meta.url);
-const blessPackageJSON = require('../../../../package.json');
-const { browsers } = require('../../../../node_modules/playwright-core/browsers.json');
+const blessPackageJSON = require(path.join(process.cwd(), 'package.json'));
+const { browsers } = require(path.join(process.cwd(), 'node_modules', 'playwright-core', 'browsers.json'));
 const chromium = browsers.find((b) => b.name === 'chromium').browserVersion;
 const firefox = browsers.find((b) => b.name === 'firefox').browserVersion;
 const webkit = browsers.find((b) => b.name === 'webkit').browserVersion;

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

@@ -6,6 +6,7 @@
       "type": "string"
     },
     "trackingId": {
+      "description": "Custom session identifier",
       "type": "string"
     },
     "blockAds": {

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

@@ -68,4 +68,16 @@ describe('Management APIs', function () {
             expect(res.status).to.equal(204);
         });
     });
+    it('allows requests to /kill', async () => {
+        await start();
+        await fetch('http://localhost:3000/kill/all?token=6R0W53R135510').then(async (res) => {
+            expect(res.status).to.equal(204);
+        });
+    });
+    it('Throws an error trying to kill invalid session', async () => {
+        await start();
+        await fetch(`http://localhost:3000/kill/invalid-session?token=6R0W53R135510`).then(async (res) => {
+            expect(res.status).to.equal(404);
+        });
+    });
 });

package/build/routes/webkit/tests/kill-sessions.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/routes/webkit/tests/kill-sessions.spec.js

@@ -0,0 +1,72 @@
+import { Browserless, Config, Metrics } from '@browserless.io/browserless';
+import { expect } from 'chai';
+import { webkit } from 'playwright-core';
+describe('/kill API webkit', function () {
+    let browserless;
+    const start = ({ config = new Config(), metrics = new Metrics(), } = {}) => {
+        config.setToken('browserless');
+        browserless = new Browserless({ config, metrics });
+        return browserless.start();
+    };
+    afterEach(async () => {
+        await browserless.stop();
+    });
+    it('Kill all sessions', async () => {
+        await start();
+        const browser1 = await webkit.connect(`ws://localhost:3000/webkit/playwright?token=browserless&trackingId=session-1`);
+        const browser2 = await webkit.connect(`ws://localhost:3000/webkit/playwright?token=browserless&trackingId=session-2`);
+        await fetch('http://localhost:3000/kill/all?token=browserless').then(async (res) => {
+            expect(res.status).to.equal(204);
+        });
+        let errorThrown1;
+        try {
+            await browser1.newPage();
+        }
+        catch (e) {
+            errorThrown1 = e;
+        }
+        let errorThrown2;
+        try {
+            await browser2.newPage();
+        }
+        catch (e) {
+            errorThrown2 = e;
+        }
+        expect(errorThrown1.message).contains('closed');
+        expect(errorThrown2.message).contains('closed');
+    });
+    it('Kill session by browserId', async () => {
+        await start();
+        const browser = await webkit.connect(`ws://localhost:3000/webkit/playwright?token=browserless`);
+        await fetch('http://localhost:3000/sessions?token=browserless').then(async (res) => {
+            const sessions = await res.json();
+            const browserId = sessions[0].browserId;
+            await fetch(`http://localhost:3000/kill/${browserId}?token=browserless`).then(async (res) => {
+                expect(res.status).to.equal(204);
+            });
+        });
+        let errorThrown;
+        try {
+            await browser.newPage();
+        }
+        catch (e) {
+            errorThrown = e;
+        }
+        expect(errorThrown.message).contains('closed');
+    });
+    it('Kill session by trackingId', async () => {
+        await start();
+        const browser = await webkit.connect(`ws://localhost:3000/webkit/playwright?token=browserless&trackingId=session-1`);
+        await fetch('http://localhost:3000/kill/session-1?token=browserless').then(async (res) => {
+            expect(res.status).to.equal(204);
+        });
+        let errorThrown;
+        try {
+            await browser.newPage();
+        }
+        catch (e) {
+            errorThrown = e;
+        }
+        expect(errorThrown.message).contains('closed');
+    });
+});

package/build/routes/webkit/ws/playwright.query.json

@@ -23,6 +23,10 @@
     "token": {
       "description": "The authorization token",
       "type": "string"
+    },
+    "trackingId": {
+      "description": "Custom session identifier",
+      "type": "string"
     }
   },
   "additionalProperties": false,

package/build/shared/utils/performance/main.js

@@ -1,11 +1,12 @@
 import { fork } from 'child_process';
 import path from 'path';
+const __dirname = import.meta.dirname;
 const DEFAULT_AUDIT_CONFIG = {
     extends: 'lighthouse:default',
 };
 export default async ({ browser, context, logger, timeout, }) => {
     return new Promise((resolve, reject) => {
-        const childPath = path.join('./', 'build', 'shared', 'utils', 'performance', 'child.js');
+        const childPath = path.join(__dirname, 'child.js');
         logger.trace(`Starting up child at ${childPath}`);
         const child = fork(childPath);
         const port = new URL(browser.wsEndpoint() || '').port;

package/build/types.d.ts

@@ -520,6 +520,7 @@ export declare const BrowserlessWebKitRoutes: {
 export declare const BrowserlessManagementRoutes: {
     ActiveGetRoute: string;
     ConfigGetRoute: string;
+    KillGetRoute: string;
     MetaGetRoute: string;
     MetricsGetRoute: string;
     MetricsTotalGetRoute: string;
@@ -530,6 +531,7 @@ export declare const BrowserlessManagementRoutes: {
 export declare const BrowserlessRoutes: {
     ActiveGetRoute: string;
     ConfigGetRoute: string;
+    KillGetRoute: string;
     MetaGetRoute: string;
     MetricsGetRoute: string;
     MetricsTotalGetRoute: string;

package/build/types.js

@@ -190,6 +190,7 @@ export const BrowserlessWebKitRoutes = {
 export const BrowserlessManagementRoutes = {
     ActiveGetRoute: 'ActiveGetRoute',
     ConfigGetRoute: 'ConfigGetRoute',
+    KillGetRoute: 'KillGetRoute',
     MetaGetRoute: 'MetaGetRoute',
     MetricsGetRoute: 'MetricsGetRoute',
     MetricsTotalGetRoute: 'MetricsTotalGetRoute',

package/build/utils.d.ts

@@ -126,7 +126,7 @@ export declare class Timeout extends Error {
 export declare const bestAttemptCatch: (bestAttempt: boolean) => (err: Error) => void;
 export declare const parseBooleanParam: (params: URLSearchParams, name: string, defaultValue: boolean) => boolean;
 export declare const parseNumberParam: (params: URLSearchParams, name: string, defaultValue: number) => number;
-export declare const parseStringParam: (params: URLSearchParams, name: string, defaultValue: string) => any;
+export declare const parseStringParam: (params: URLSearchParams, name: string, defaultValue: string) => string;
 export declare const encrypt: (text: string, secret: Buffer) => string;
 export declare const decrypt: (encryptedText: string, secret: Buffer) => string;
 interface RequestInitTimeout extends RequestInit {

package/build/utils.js

@@ -538,16 +538,7 @@ export const parseStringParam = (params, name, defaultValue) => {
     if (value === null) {
         return defaultValue;
     }
-    // ?param format (no specified value)
-    if (value === '') {
-        return true;
-    }
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return value;
-    }
+    return value;
 };
 export const encrypt = (text, secret) => {
     const iv = crypto.randomBytes(16);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browserless.io/browserless",
-  "version": "2.24.0-beta-5",
+  "version": "2.24.1",
   "license": "SSPL",
   "description": "The browserless platform",
   "author": "browserless.io",
@@ -48,25 +48,25 @@
     "tsconfig.json"
   ],
   "dependencies": {
-    "debug": "^4.3.7",
+    "debug": "^4.4.0",
     "del": "^8.0.0",
     "enjoi": "^9.0.1",
     "file-type": "^19.6.0",
     "get-port": "^7.1.0",
     "gradient-string": "^3.0.0",
     "http-proxy": "^1.18.1",
-    "lighthouse": "^12.2.2",
+    "lighthouse": "^12.3.0",
     "micromatch": "^4.0.8",
     "playwright-1.45": "npm:playwright-core@1.45.3",
     "playwright-1.46": "npm:playwright-core@1.46.1",
     "playwright-1.47": "npm:playwright-core@1.47.2",
     "playwright-1.48": "npm:playwright-core@1.48.2",
-    "playwright-core": "^1.49.0",
-    "puppeteer-core": "^23.10.0",
+    "playwright-core": "^1.49.1",
+    "puppeteer-core": "^23.11.1",
     "puppeteer-extra": "^3.3.6",
     "puppeteer-extra-plugin-stealth": "^2.11.2",
     "queue": "^7.0.0",
-    "systeminformation": "^5.23.5",
+    "systeminformation": "^5.23.16",
     "tar-fs": "^3.0.6"
   },
   "optionalDependencies": {
@@ -76,23 +76,23 @@
     "@types/http-proxy": "^1.17.15",
     "@types/micromatch": "^4.0.9",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^22.10.1",
+    "@types/node": "^22.10.2",
     "@types/sinon": "^17.0.3",
-    "@typescript-eslint/eslint-plugin": "^8.17.0",
-    "@typescript-eslint/parser": "^8.17.0",
+    "@typescript-eslint/eslint-plugin": "^8.18.1",
+    "@typescript-eslint/parser": "^8.18.1",
     "assert": "^2.0.0",
     "chai": "^5.1.2",
     "cross-env": "^7.0.3",
     "env-cmd": "^10.1.0",
-    "esbuild": "^0.24.0",
+    "esbuild": "^0.24.2",
     "esbuild-plugin-polyfill-node": "^0.3.0",
-    "eslint": "^9.16.0",
+    "eslint": "^9.17.0",
     "extract-zip": "^2.0.1",
     "gunzip-maybe": "^1.4.2",
-    "marked": "^15.0.3",
+    "marked": "^15.0.4",
     "mocha": "^11.0.1",
     "move-file": "^3.1.0",
-    "prettier": "^3.4.1",
+    "prettier": "^3.4.2",
     "sinon": "^19.0.2",
     "ts-node": "^10.9.2",
     "typescript": "^5.7.2",

package/src/browsers/browsers.playwright.ts

@@ -24,6 +24,7 @@ class BasePlaywright extends EventEmitter {
   protected userDataDir: string | null;
   protected running = false;
   protected logger: Logger;
+  protected socket: Duplex | null = null;
   protected proxy = httpProxy.createProxyServer();
   protected browser: playwright.BrowserServer | null = null;
   protected browserWSEndpoint: string | null = null;
@@ -78,6 +79,7 @@ class BasePlaywright extends EventEmitter {
       this.logger.info(
         `Closing ${this.constructor.name} process and all listeners`,
       );
+      this.socket?.destroy();
       this.emit('close');
       this.cleanListeners();
       this.browser.close();
@@ -167,6 +169,7 @@ class BasePlaywright extends EventEmitter {
     socket: Duplex,
     head: Buffer,
   ): Promise<void> {
+    this.socket = socket;
     return new Promise((resolve, reject) => {
       if (!this.browserWSEndpoint) {
         throw new ServerError(

package/src/browsers/index.ts

@@ -16,7 +16,6 @@ import {
   Config,
   FileSystem,
   FirefoxPlaywright,
-  HTTPManagementRoutes,
   Hooks,
   Logger,
   NotFound,
@@ -35,6 +34,7 @@ import {
 } from '@browserless.io/browserless';
 import { Page } from 'puppeteer-core';
 import { deleteAsync } from 'del';
+import micromatch from 'micromatch';
 import path from 'path';
 
 export class BrowserManager {
@@ -236,11 +236,7 @@ export class BrowserManager {
         initialConnectURL: new URL(session.initialConnectURL, serverAddress)
           .href,
         killURL: session.id
-          ? makeExternalURL(
-              serverAddress,
-              HTTPManagementRoutes.sessions,
-              session.id,
-            )
+          ? makeExternalURL(serverAddress, '/kill/', session.id)
           : null,
         running: browser.isRunning(),
         timeAliveMs: Date.now() - session.startedOn,
@@ -277,12 +273,13 @@ export class BrowserManager {
   public async close(
     browser: BrowserInstance,
     session: BrowserlessSession,
+    force = false,
   ): Promise<void> {
     const now = Date.now();
     const keepUntil = browser.keepUntil();
     const connected = session.numbConnected;
     const hasKeepUntil = keepUntil > now;
-    const keepOpen = connected > 0 || hasKeepUntil;
+    const keepOpen = (connected > 0 || hasKeepUntil) && !force;
     const cleanupACtions: Array<() => Promise<void>> = [];
     const priorTimer = this.timers.get(session.id);
 
@@ -292,10 +289,10 @@ export class BrowserManager {
     }
 
     this.log.info(
-      `${session.numbConnected} Client(s) are currently connected, Keep-until: ${keepUntil}`,
+      `${session.numbConnected} Client(s) are currently connected, Keep-until: ${keepUntil}, force: ${force}`,
     );
 
-    if (hasKeepUntil) {
+    if (!force && hasKeepUntil) {
       const timeout = keepUntil - now;
       this.log.trace(
         `Setting timer ${timeout.toLocaleString()} for "${session.id}"`,
@@ -328,6 +325,28 @@ export class BrowserManager {
     }
   }
 
+  public async killSessions(target: string): Promise<void> {
+    this.log.info(`killSessions invoked target: "${target}"`);
+    const sessions = Array.from(this.browsers);
+    let closed = 0;
+    for (const [browser, session] of sessions) {
+      if (
+        session.trackingId === target ||
+        session.id === target ||
+        target === 'all'
+      ) {
+        this.log.info(
+          `Closing browser via killSessions BrowserId: "${session.id}", trackingId: "${session.trackingId}"`,
+        );
+        this.close(browser, session, true);
+        closed++;
+      }
+    }
+    if (closed === 0 && target !== 'all') {
+      throw new NotFound(`Couldn't locate session for id: "${target}"`);
+    }
+  }
+
   public async getAllSessions(
     trackingId?: string,
   ): Promise<BrowserlessSessionJSON[]> {
@@ -398,12 +417,14 @@ export class BrowserManager {
         );
       }
 
-      if (
-        ['/', '.', '\\'].some((routeLike) => trackingId.includes(routeLike))
-      ) {
+      if (!micromatch.isMatch(trackingId, '+([0-9a-zA-Z-_])')) {
         throw new BadRequest(`trackingId contains invalid characters`);
       }
 
+      if (trackingId === 'all') {
+        throw new BadRequest(`trackingId cannot be the reserved word "all"`);
+      }
+
       this.log.info(`Assigning session trackingId "${trackingId}"`);
     }
 

package/src/http.ts

@@ -126,6 +126,7 @@ export enum HTTPRoutes {
 export enum HTTPManagementRoutes {
   active = '/active?(/)',
   config = '/config?(/)',
+  kill = '/kill/+([0-9a-zA-Z-_])?(/)',
   meta = '/meta?(/)',
   metrics = '/metrics?(/)',
   metricsTotal = '/metrics/total?(/)',
@@ -174,4 +175,9 @@ export interface SystemQueryParameters {
    * The authorization token
    */
   token?: string;
+
+  /**
+   * Custom session identifier
+   */
+  trackingId?: string;
 }