@browserless.io/browserless 2.24.0-beta-4 → 2.24.0

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/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-4",
+  "version": "2.24.0",
   "license": "SSPL",
   "description": "The browserless platform",
   "author": "browserless.io",
@@ -48,7 +48,7 @@
     "tsconfig.json"
   ],
   "dependencies": {
-    "debug": "^4.3.7",
+    "debug": "^4.4.0",
     "del": "^8.0.0",
     "enjoi": "^9.0.1",
     "file-type": "^19.6.0",
@@ -62,11 +62,11 @@
     "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.9.0",
+    "puppeteer-core": "^23.10.1",
     "puppeteer-extra": "^3.3.6",
     "puppeteer-extra-plugin-stealth": "^2.11.2",
     "queue": "^7.0.0",
-    "systeminformation": "^5.23.5",
+    "systeminformation": "^5.23.6",
     "tar-fs": "^3.0.6"
   },
   "optionalDependencies": {
@@ -92,7 +92,7 @@
     "marked": "^15.0.3",
     "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;
 }

package/src/routes/chrome/tests/kill-sessions.spec.ts

@@ -0,0 +1,99 @@
+import { Browserless, Config, Metrics } from '@browserless.io/browserless';
+import { expect } from 'chai';
+import puppeteer from 'puppeteer-core';
+
+describe('/kill API', function () {
+  let browserless: Browserless;
+
+  const start = ({
+    config = new Config(),
+    metrics = new Metrics(),
+  }: { config?: Config; metrics?: Metrics } = {}) => {
+    config.setToken('6R0W53R135510');
+    browserless = new Browserless({ config, metrics });
+    return browserless.start();
+  };
+
+  afterEach(async () => {
+    await browserless.stop();
+  });
+
+  it('Kill all sessions', async () => {
+    await start();
+    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) => {
+        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 as Error).message).contains('closed');
+    expect((errorThrown2 as Error).message).contains('closed');
+  });
+
+  it('Kill session by browserId', async () => {
+    await start();
+    const browser = await puppeteer.connect({
+      browserWSEndpoint: `ws://localhost:3000/chrome?token=6R0W53R135510`,
+    });
+
+    await fetch('http://localhost:3000/sessions?token=6R0W53R135510').then(
+      async (res) => {
+        const sessions = await res.json();
+        const browserId = sessions[0].browserId;
+        await fetch(
+          `http://localhost:3000/kill/${browserId}?token=6R0W53R135510`,
+        ).then(async (res) => {
+          expect(res.status).to.equal(204);
+        });
+      },
+    );
+
+    let errorThrown;
+    try {
+      await browser.newPage();
+    } catch (e) {
+      errorThrown = e;
+    }
+    expect((errorThrown as Error).message).contains('closed');
+  });
+
+  it('Kill session by trackingId', async () => {
+    await start();
+    const browser = await puppeteer.connect({
+      browserWSEndpoint: `ws://localhost:3000/chrome?token=6R0W53R135510&trackingId=session-1`,
+    });
+
+    await fetch(
+      'http://localhost:3000/kill/session-1?token=6R0W53R135510',
+    ).then(async (res) => {
+      expect(res.status).to.equal(204);
+    });
+
+    let errorThrown;
+    try {
+      await browser.newPage();
+    } catch (e) {
+      errorThrown = e;
+    }
+    expect((errorThrown as Error).message).contains('closed');
+  });
+});

package/src/routes/chromium/tests/kill-sessions.spec.ts

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

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

@@ -513,4 +513,33 @@ describe('Chromium WebSocket API', function () {
 
     await browser.disconnect();
   });
+
+  it('Throws an error while creating a session with invalid trackingId', async () => {
+    await start();
+
+    const didError = await puppeteer
+      .connect({
+        browserWSEndpoint: `ws://localhost:3000/chromium?trackingId=all`,
+      })
+      .then(() => false)
+      .catch(() => true);
+
+    expect(didError).to.be.true;
+  });
+
+  it('Throws an error while creating a session with duplicated trackingId', async () => {
+    await start();
+
+    await puppeteer.connect({
+      browserWSEndpoint: `ws://localhost:3000/chromium?trackingId=duplicated`,
+    });
+    const didError = await puppeteer
+      .connect({
+        browserWSEndpoint: `ws://localhost:3000/chromium?trackingId=duplicated`,
+      })
+      .then(() => false)
+      .catch(() => true);
+
+    expect(didError).to.be.true;
+  });
 });

package/src/routes/firefox/tests/kill-sessions.spec.ts

@@ -0,0 +1,99 @@
+import { Browserless, Config, Metrics } from '@browserless.io/browserless';
+import { expect } from 'chai';
+import { firefox } from 'playwright-core';
+
+describe('/kill API firefox', function () {
+  let browserless: Browserless;
+
+  const start = ({
+    config = new Config(),
+    metrics = new Metrics(),
+  }: { config?: Config; metrics?: 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 firefox.connect(
+      `ws://localhost:3000/playwright/firefox?token=browserless`,
+    );
+    const browser2 = await firefox.connect(
+      `ws://localhost:3000/playwright/firefox?token=browserless`,
+    );
+
+    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 as Error).message).contains('closed');
+    expect((errorThrown2 as Error).message).contains('closed');
+  });
+
+  it('Kill session by browserId', async () => {
+    await start();
+    const browser = await firefox.connect(
+      `ws://localhost:3000/playwright/firefox?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 as Error).message).contains('closed');
+  });
+
+  it('Kill session by trackingId', async () => {
+    await start();
+    const browser = await firefox.connect(
+      `ws://localhost:3000/playwright/firefox?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 as Error).message).contains('closed');
+  });
+});