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

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

package/src/routes/management/http/kill.get.ts

@@ -0,0 +1,40 @@
+import {
+  APITags,
+  BrowserlessRoutes,
+  HTTPManagementRoutes,
+  HTTPRoute,
+  Methods,
+  Request,
+  SystemQueryParameters,
+  contentTypes,
+  writeResponse,
+} from '@browserless.io/browserless';
+import { ServerResponse } from 'http';
+
+export type ResponseSchema = string;
+
+export interface QuerySchema extends SystemQueryParameters {
+  token: string;
+  browserId?: string;
+  trackingId?: string;
+}
+
+export default class KillGetRoute extends HTTPRoute {
+  name = BrowserlessRoutes.KillGetRoute;
+  accepts = [contentTypes.any];
+  auth = true;
+  browser = null;
+  concurrency = false;
+  contentTypes = [contentTypes.json];
+  description = `Kill running sessions based on BrowserId or TrackingId.`;
+  method = Methods.get;
+  path = HTTPManagementRoutes.kill;
+  tags = [APITags.management];
+
+  async handler(req: Request, res: ServerResponse): Promise<void> {
+    const target = req.parsed.pathname.split('/')[2];
+    const browserManager = this.browserManager();
+    await browserManager.killSessions(target);
+    return writeResponse(res, 204, '');
+  }
+}

package/src/routes/management/http/meta.get.ts

@@ -14,6 +14,7 @@ import {
 } from '@browserless.io/browserless';
 import { ServerResponse } from 'http';
 import { createRequire } from 'module';
+import path from 'path';
 
 export interface ResponseSchema {
   /**
@@ -49,16 +50,17 @@ export interface ResponseSchema {
 
 const semverReg = /(\*|\^|>|=|<|~)/gi;
 const require = createRequire(import.meta.url);
-const blessPackageJSON = require('../../../../package.json');
-const { browsers } =
-  require('../../../../node_modules/playwright-core/browsers.json') as {
-    browsers: [
-      {
-        name: string;
-        browserVersion: string;
-      },
-    ];
-  };
+const blessPackageJSON = require(path.join(process.cwd(), 'package.json'));
+const { browsers } = require(
+  path.join(process.cwd(), 'node_modules', 'playwright-core', 'browsers.json'),
+) as {
+  browsers: [
+    {
+      name: string;
+      browserVersion: string;
+    },
+  ];
+};
 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/src/routes/management/tests/management.spec.ts

@@ -120,4 +120,23 @@ 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/src/routes/webkit/tests/kill-sessions.spec.ts

@@ -0,0 +1,99 @@
+import { Browserless, Config, Metrics } from '@browserless.io/browserless';
+import { expect } from 'chai';
+import { webkit } from 'playwright-core';
+
+describe('/kill API webkit', 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 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 as Error).message).contains('closed');
+    expect((errorThrown2 as Error).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 as Error).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 as Error).message).contains('closed');
+  });
+});

package/src/shared/utils/performance/main.ts

@@ -2,6 +2,7 @@ import { Message, mainOptions } from './types.js';
 import { fork } from 'child_process';
 import path from 'path';
 
+const __dirname = import.meta.dirname;
 const DEFAULT_AUDIT_CONFIG = {
   extends: 'lighthouse:default',
 };
@@ -13,14 +14,7 @@ export default async ({
   timeout,
 }: mainOptions): Promise<unknown> => {
   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}`);
 

package/src/types.ts

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

package/src/utils.ts

@@ -743,23 +743,14 @@ export const parseStringParam = (
   params: URLSearchParams,
   name: string,
   defaultValue: string,
-) => {
+): string => {
   const value = params.get(name);
 
   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: string, secret: Buffer) => {