@browserless.io/browserless 2.8.0 → 2.9.0

package/build/shared/utils/function/handler.js

@@ -29,7 +29,7 @@ export default (config, logger, options = {}) => async (req, browser) => {
      */
     page.on('request', async (request) => {
         const requestUrl = request.url();
-        logger.log(`Outbound Page Request: "${requestUrl}"`);
+        logger.info(`Outbound Page Request: "${requestUrl}"`);
         if (requestUrl.startsWith(functionRequestPath)) {
             const filename = path.basename(requestUrl);
             if (filename === functionCodeJS) {
@@ -48,23 +48,23 @@ export default (config, logger, options = {}) => async (req, browser) => {
                     status: 200,
                 });
             }
-            logger.log(`Static asset request to "${requestUrl}" couldn't be found, 404-ing`);
+            logger.warn(`Static asset request to "${requestUrl}" couldn't be found, 404-ing`);
             return request.respond({
                 body: code,
                 contentType: `Couldn't locate this file "${filename}" request "${requestUrl}" in "${functionAssetLocation}"`,
                 status: 404,
             });
         }
-        logger.log(`Request: "${requestUrl}" no responder found, continuing...`);
+        logger.info(`Request: "${requestUrl}" no responder found, continuing...`);
         return request.continue();
     });
     page.on('response', (res) => {
-        if (res.status() !== 200) {
-            logger.log(`Received a non-200 response for request "${res.url()}"`);
+        if (!res.ok()) {
+            logger.warn(`Received a non-200 response for request "${res.url()}"`);
         }
     });
     page.on('console', (event) => {
-        logger.log(`${event.type()}: ${event.text()}`);
+        logger.trace(`${event.type()}: ${event.text()}`);
     });
     await page.goto(functionIndexHTML);
     const { contentType, payload } = await page
@@ -85,7 +85,7 @@ export default (config, logger, options = {}) => async (req, browser) => {
         });
     }, browserWSEndpoint, context, functionCodeJS, JSON.stringify(options))
         .catch((e) => {
-        logger.log(`Error running code: ${e}`);
+        logger.error(`Error running code: ${e}`);
         throw new BadRequest(e.message);
     });
     return {

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

@@ -1,11 +1,11 @@
-import { createLogger } from '@browserless.io/browserless';
+import { Logger } from '@browserless.io/browserless';
 import lighthouse from 'lighthouse';
-const debug = createLogger('http:performance:child');
-debug(`Child init`);
+const logger = new Logger('http:performance:child');
+logger.info(`Child init`);
 const send = (msg) => process.send && process.send(msg);
 const start = async ({ url, config, options }) => {
     try {
-        debug(`Child got payload, starting lighthouse`);
+        logger.info(`Child got payload, starting lighthouse`);
         const results = await lighthouse(url, options, config);
         send({
             data: results?.lhr,

package/build/shared/utils/performance/main.d.ts

@@ -1,3 +1,3 @@
 import { mainOptions } from './types.js';
-declare const _default: ({ browser, context, timeout, }: mainOptions) => Promise<unknown>;
+declare const _default: ({ browser, context, logger, timeout, }: mainOptions) => Promise<unknown>;
 export default _default;

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

@@ -1,14 +1,12 @@
-import { createLogger } from '@browserless.io/browserless';
 import { fork } from 'child_process';
 import path from 'path';
 const DEFAULT_AUDIT_CONFIG = {
     extends: 'lighthouse:default',
 };
-export default async ({ browser, context, timeout, }) => {
+export default async ({ browser, context, logger, timeout, }) => {
     return new Promise((resolve, reject) => {
-        const debug = createLogger('http:performance:main');
         const childPath = path.join('./', 'build', 'shared', 'utils', 'performance', 'child.js');
-        debug(`Starting up child at ${childPath}`);
+        logger.trace(`Starting up child at ${childPath}`);
         const child = fork(childPath);
         const port = new URL(browser.wsEndpoint() || '').port;
         let closed = false;
@@ -34,13 +32,13 @@ export default async ({ browser, context, timeout, }) => {
             port,
         };
         child.on('error', (err) => {
-            debug(`Error in child process`, err);
+            logger.error(`Error in child process`, err);
             reject('Performance run error: ' + err.message);
             close(child.pid);
         });
         child.on('message', (payload) => {
             if (payload.event === 'created') {
-                debug(`Child process is up, sending performance request`);
+                logger.info(`Child process is up, sending performance request`);
                 return child.send({
                     config,
                     event: 'start',
@@ -49,7 +47,7 @@ export default async ({ browser, context, timeout, }) => {
                 });
             }
             if (payload.event === 'complete') {
-                debug(`Performance gathered, closing and resolving request`);
+                logger.info(`Performance gathered, closing and resolving request`);
                 close(child.pid);
                 return resolve({
                     data: payload.data,

package/build/shared/utils/performance/types.d.ts

@@ -1,5 +1,5 @@
+import { BrowserInstance, Logger } from '@browserless.io/browserless';
 import { Config, Flags } from 'lighthouse';
-import { BrowserInstance } from '@browserless.io/browserless';
 export interface Message {
     data?: unknown;
     error?: unknown;
@@ -12,6 +12,7 @@ export interface mainOptions {
         config?: unknown;
         url: string;
     };
+    logger: Logger;
     timeout: number;
 }
 export interface start {

package/build/utils.d.ts

@@ -120,6 +120,6 @@ interface RequestInitTimeout extends RequestInit {
 }
 export declare const fetchTimeout: (input: RequestInfo | URL, initWithTimeout?: RequestInitTimeout) => Promise<Response>;
 export declare const untildify: (path: string) => string;
-export declare const printLogo: (docsLink: string) => string;
+export declare const printLogo: (docsLink: string, debugURL?: string | boolean) => string;
 export declare const getCDPClient: (page: Page) => CDPSession;
 export {};

package/build/utils.js

@@ -561,12 +561,16 @@ export const untildify = (path) => {
     const homeDir = homedir();
     return homeDir ? path.replace(/^~(?=$|\/|\\)/, homeDir) : path;
 };
-export const printLogo = (docsLink) => `
+export const printLogo = (docsLink, debugURL) => `
 ---------------------------------------------------------
 | browserless.io
 | To read documentation and more, load in your browser:
 |
-| ${docsLink}
+| OpenAPI: ${docsLink}
+| Full Documentation: https://docs.browserless.io/ ${
+/*prettier-ignore*/
+debugURL ? `
+| Debbuger: ${debugURL}` : ""}
 ---------------------------------------------------------
 ${gradient('#ff1a8c', '#ffea00')(`
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browserless.io/browserless",
-  "version": "2.8.0",
+  "version": "2.9.0",
   "license": "SSPL",
   "description": "The browserless platform",
   "author": "browserless.io",
@@ -25,8 +25,9 @@
     "clean": "node scripts/clean.js",
     "dev": "npm run build:dev && env-cmd -f .env node build",
     "install:adblock": "node scripts/install-adblock.js",
+    "install:debugger": "node scripts/install-debugger.js",
     "install:browsers": "npx --yes playwright install chromium firefox webkit chrome",
-    "install:dev": "npm run install:browsers",
+    "install:dev": "npm run install:browsers && npm run install:debugger",
     "lint": "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",
@@ -55,40 +56,42 @@
     "get-port": "^7.1.0",
     "gradient-string": "^2.0.0",
     "http-proxy": "^1.18.1",
-    "lighthouse": "^11.1.0",
+    "lighthouse": "^12.0.0",
     "micromatch": "^4.0.4",
-    "playwright-core": "1.43.0",
-    "puppeteer-core": "^22.6.4",
+    "playwright-core": "1.44.0",
+    "puppeteer-core": "^22.8.0",
     "puppeteer-extra": "^3.3.6",
     "puppeteer-extra-plugin-stealth": "^2.11.2",
     "queue": "^7.0.0",
-    "systeminformation": "^5.22.7"
+    "systeminformation": "^5.22.8",
+    "tar-fs": "^3.0.6"
   },
   "optionalDependencies": {
-    "@types/chai": "^4.3.14",
+    "@types/chai": "^4.3.16",
     "@types/debug": "^4.1.12",
     "@types/gradient-string": "^1.1.6",
     "@types/http-proxy": "^1.17.14",
-    "@types/micromatch": "^4.0.6",
+    "@types/micromatch": "^4.0.7",
     "@types/mocha": "^10.0.6",
-    "@types/node": "^20.12.7",
+    "@types/node": "^20.12.11",
     "@types/sinon": "^17.0.3",
-    "@typescript-eslint/eslint-plugin": "^7.6.0",
-    "@typescript-eslint/parser": "^7.6.0",
+    "@typescript-eslint/eslint-plugin": "^7.8.0",
+    "@typescript-eslint/parser": "^7.8.0",
     "assert": "^2.0.0",
-    "chai": "^5.1.0",
+    "chai": "^5.1.1",
     "cross-env": "^7.0.3",
     "env-cmd": "^10.1.0",
-    "esbuild": "^0.20.2",
+    "esbuild": "^0.21.2",
     "esbuild-plugin-polyfill-node": "^0.3.0",
     "eslint": "^8.57.0",
     "eslint-plugin-typescript-sort-keys": "^3.2.0",
     "extract-zip": "^2.0.1",
-    "marked": "^12.0.1",
+    "gunzip-maybe": "^1.4.2",
+    "marked": "^12.0.2",
     "mocha": "^10.4.0",
     "move-file": "^3.1.0",
     "prettier": "^3.2.5",
-    "sinon": "^17.0.1",
+    "sinon": "^17.0.2",
     "ts-node": "^10.9.2",
     "typescript": "^5.4.5",
     "typescript-json-schema": "^0.63.0"

package/scripts/install-debugger.js

@@ -1,20 +1,60 @@
-import { cp } from 'fs/promises';
-import { fileURLToPath } from 'url';
-import path from 'path';
+/* global fetch, console, process */
+import { Readable } from 'stream';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import os from 'os';
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
+import { deleteAsync } from 'del';
+import gunzip from 'gunzip-maybe';
+import { moveFile } from 'move-file';
+import tar from 'tar-fs';
 
-const from = path.join(
-  __dirname,
-  '..',
-  'node_modules',
-  'browserless-debugger',
-  'static',
-);
-const to = path.join(__dirname, '..', 'static', 'debugger');
+const registryURL = 'https://registry.npmjs.org/@browserless.io/debugger/';
+const tmp = join(os.tmpdir(), 'browserless-debugger');
+const untarDir = join(tmp, 'package', 'static');
+const debuggerDir = join(process.cwd(), 'static', 'debugger');
+
+const lastFromArr = (arr) => arr[arr.length - 1];
+const dlAndExtract = (url) =>
+  fetch(url).then(
+    (response) =>
+      new Promise((resolve, reject) => {
+        // @ts-ignore
+        Readable.fromWeb(response.body)
+          .pipe(gunzip())
+          .pipe(tar.extract(tmp))
+          .on('error', reject)
+          .on('finish', resolve);
+      }),
+  );
+
+const getLatestVersion = async () => {
+  const response = await fetch(registryURL);
+  const json = await response.json();
+  const latest = lastFromArr(Object.keys(json.versions));
+  return json.versions[latest];
+};
 
 (async () => {
-  await cp(from, to, {
-    recursive: true,
+  if (existsSync(debuggerDir)) {
+    await deleteAsync(debuggerDir);
+  }
+
+  const dist = await getLatestVersion()
+    .then((version) => version.dist.tarball)
+    .catch((error) => {
+      console.error(`Couldn't fetch latest debugger version: ${error.message}`);
+      process.exit(1);
+    });
+
+  await dlAndExtract(dist).catch((error) => {
+    console.error(`Couldn't download debugger: ${error.message}`);
+    process.exit(1);
   });
-})();
+
+  await moveFile(untarDir, debuggerDir);
+  await deleteAsync(tmp, { force: true });
+})().catch((error) => {
+  console.error(`An error occurred: ${error.message}`);
+  process.exit(1);
+});

package/src/browserless.ts

@@ -23,7 +23,6 @@ import {
   WebSocketRoute,
   WebkitPlaywright,
   availableBrowsers,
-  createLogger,
   getRouteFiles,
   makeExternalURL,
   printLogo,
@@ -46,7 +45,7 @@ type routeInstances =
   | BrowserWebsocketRoute;
 
 export class Browserless extends EventEmitter {
-  protected debug: debug.Debugger = createLogger('index');
+  protected logger: BlessLogger;
   protected browserManager: BrowserManager;
   protected config: Config;
   protected fileSystem: FileSystem;
@@ -94,6 +93,7 @@ export class Browserless extends EventEmitter {
   } = {}) {
     super();
     this.Logger = LoggerOverride ?? BlessLogger;
+    this.logger = new this.Logger('index');
     this.config = config || new Config();
     this.metrics = metrics || new Metrics();
     this.token = token || new Token(this.config);
@@ -129,7 +129,7 @@ export class Browserless extends EventEmitter {
 
     this.metrics.reset();
 
-    this.debug(
+    this.logger.info(
       `Current period usage: ${JSON.stringify({
         date: aggregatedStats.date,
         error: aggregatedStats.error,
@@ -146,7 +146,7 @@ export class Browserless extends EventEmitter {
     );
 
     if (metricsPath) {
-      this.debug(`Saving metrics to "${metricsPath}"`);
+      this.logger.info(`Saving metrics to "${metricsPath}"`);
       this.fileSystem.append(
         metricsPath,
         JSON.stringify(aggregatedStats),
@@ -170,7 +170,7 @@ export class Browserless extends EventEmitter {
     );
   };
 
-  private routeIsDisabled(route: routeInstances) {
+  protected routeIsDisabled(route: routeInstances) {
     return this.disabledRouteNames.some((name) => name === route.name);
   }
 
@@ -230,11 +230,18 @@ export class Browserless extends EventEmitter {
     const [[internalHttpRouteFiles, internalWsRouteFiles], installedBrowsers] =
       await Promise.all([getRouteFiles(this.config), availableBrowsers]);
 
+    const hasDebugger = await this.config.hasDebugger();
+    const debuggerURL =
+      hasDebugger &&
+      makeExternalURL(
+        this.config.getExternalAddress(),
+        `/debugger/?token=${this.config.getToken()}`,
+      );
     const docsLink = makeExternalURL(this.config.getExternalAddress(), '/docs');
 
-    this.debug(printLogo(docsLink));
-    this.debug(`Running as user "${userInfo().username}"`);
-    this.debug('Starting import of HTTP Routes');
+    this.logger.info(printLogo(docsLink, debuggerURL));
+    this.logger.info(`Running as user "${userInfo().username}"`);
+    this.logger.info('Starting import of HTTP Routes');
 
     for (const httpRoute of [
       ...this.httpRouteFiles,
@@ -281,7 +288,7 @@ export class Browserless extends EventEmitter {
       }
     }
 
-    this.debug('Starting import of WebSocket Routes');
+    this.logger.info('Starting import of WebSocket Routes');
     for (const wsRoute of [
       ...this.webSocketRouteFiles,
       ...internalWsRouteFiles,
@@ -349,7 +356,7 @@ export class Browserless extends EventEmitter {
       .map((r) => r.name);
 
     if (duplicateNamedRoutes.length) {
-      this.debug(
+      this.logger.warn(
         `Found duplicate routing names. Route names must be unique:`,
         duplicateNamedRoutes,
       );
@@ -358,7 +365,9 @@ export class Browserless extends EventEmitter {
     httpRoutes.forEach((r) => this.router.registerHTTPRoute(r));
     wsRoutes.forEach((r) => this.router.registerWebSocketRoute(r));
 
-    this.debug(`Imported and validated all route files, starting up server.`);
+    this.logger.info(
+      `Imported and validated all route files, starting up server.`,
+    );
 
     this.server = new HTTPServer(
       this.config,
@@ -370,7 +379,7 @@ export class Browserless extends EventEmitter {
     );
 
     await this.server.start();
-    this.debug(`Starting metrics collection.`);
+    this.logger.info(`Starting metrics collection.`);
     this.metricsSaveIntervalID = setInterval(
       () => this.saveMetrics(),
       this.metricsSaveInterval,

package/src/browsers/chrome.cdp.ts

@@ -1,10 +1,7 @@
-import {
-  chromeExecutablePath,
-  createLogger,
-} from '@browserless.io/browserless';
+import { Logger, chromeExecutablePath } from '@browserless.io/browserless';
 import { ChromiumCDP } from './chromium.cdp.js';
 
 export class ChromeCDP extends ChromiumCDP {
   protected executablePath = chromeExecutablePath();
-  protected debug = createLogger('browsers:chrome:cdp');
+  protected logger = new Logger('browsers:chrome:cdp');
 }

package/src/browsers/chrome.playwright.ts

@@ -1,10 +1,7 @@
-import {
-  chromeExecutablePath,
-  createLogger,
-} from '@browserless.io/browserless';
+import { Logger, chromeExecutablePath } from '@browserless.io/browserless';
 import { ChromiumPlaywright } from './chromium.playwright.js';
 
 export class ChromePlaywright extends ChromiumPlaywright {
   protected executablePath = chromeExecutablePath();
-  protected debug = createLogger('browsers:chrome:playwright');
+  protected logger = new Logger('browsers:chrome:playwright');
 }

package/src/browsers/chromium.cdp.ts

@@ -2,9 +2,9 @@ import {
   BLESS_PAGE_IDENTIFIER,
   CDPLaunchOptions,
   Config,
+  Logger,
   Request,
   ServerError,
-  createLogger,
   noop,
   once,
 } from '@browserless.io/browserless';
@@ -29,7 +29,7 @@ export class ChromiumCDP extends EventEmitter {
   protected browser: Browser | null = null;
   protected browserWSEndpoint: string | null = null;
   protected port?: number;
-  protected debug = createLogger('browsers:chromium:cdp');
+  protected logger: Logger;
   protected proxy = httpProxy.createProxyServer();
   protected executablePath = playwright.chromium.executablePath();
 
@@ -37,9 +37,11 @@ export class ChromiumCDP extends EventEmitter {
     blockAds,
     config,
     userDataDir,
+    logger,
   }: {
     blockAds: boolean;
     config: Config;
+    logger: Logger;
     userDataDir: ChromiumCDP['userDataDir'];
   }) {
     super();
@@ -47,7 +49,9 @@ export class ChromiumCDP extends EventEmitter {
     this.userDataDir = userDataDir;
     this.config = config;
     this.blockAds = blockAds;
-    this.debug(`Starting new browser instance`);
+    this.logger = logger;
+
+    this.logger.info(`Starting new ${this.constructor.name} instance`);
   }
 
   protected cleanListeners() {
@@ -63,31 +67,62 @@ export class ChromiumCDP extends EventEmitter {
   protected onTargetCreated = async (target: Target) => {
     if (target.type() === 'page') {
       const page = await target.page().catch((e) => {
-        this.debug(`Error in new page ${e}`);
+        this.logger.error(`Error in ${this.constructor.name} new page ${e}`);
         return null;
       });
 
       if (page) {
-        if (!this.config.getAllowFileProtocol()) {
-          this.debug(`Setting up file:// protocol request rejection`);
-          page.on('request', async (request) => {
-            if (request.url().startsWith('file://')) {
-              this.debug(`File protocol request found in request, terminating`);
-              page.close().catch(noop);
-              this.close();
-            }
-          });
-
-          page.on('response', async (response) => {
-            if (response.url().startsWith('file://')) {
-              this.debug(
-                `File protocol request found in response, terminating`,
-              );
-              page.close().catch(noop);
-              this.close();
-            }
-          });
-        }
+        this.logger.trace(`Setting up file:// protocol request rejection`);
+
+        page.on('error', (err) => {
+          this.logger.error(err);
+        });
+
+        page.on('pageerror', (err) => {
+          this.logger.warn(err);
+        });
+
+        page.on('framenavigated', (frame) => {
+          this.logger.trace(`Navigation to ${frame.url()}`);
+        });
+
+        page.on('console', (message) => {
+          this.logger.trace(`${message.type()}: ${message.text()}`);
+        });
+
+        page.on('requestfailed', (req) => {
+          this.logger.warn(`"${req.failure()?.errorText}": ${req.url()}`);
+        });
+
+        page.on('request', async (request) => {
+          this.logger.trace(`${request.method()}: ${request.url()}`);
+          if (
+            !this.config.getAllowFileProtocol() &&
+            request.url().startsWith('file://')
+          ) {
+            this.logger.error(
+              `File protocol request found in request to ${this.constructor.name}, terminating`,
+            );
+            page.close().catch(noop);
+            this.close();
+          }
+        });
+
+        page.on('response', async (response) => {
+          this.logger.trace(`${response.status()}: ${response.url()}`);
+
+          if (
+            !this.config.getAllowFileProtocol() &&
+            response.url().startsWith('file://')
+          ) {
+            this.logger.error(
+              `File protocol request found in response to ${this.constructor.name}, terminating`,
+            );
+            page.close().catch(noop);
+            this.close();
+          }
+        });
+
         this.emit('newPage', page);
       }
     }
@@ -97,7 +132,9 @@ export class ChromiumCDP extends EventEmitter {
 
   public newPage = async (): Promise<Page> => {
     if (!this.browser) {
-      throw new ServerError(`Browser hasn't been launched yet!`);
+      throw new ServerError(
+        `${this.constructor.name} hasn't been launched yet!`,
+      );
     }
 
     return this.browser.newPage();
@@ -105,7 +142,9 @@ export class ChromiumCDP extends EventEmitter {
 
   public close = async (): Promise<void> => {
     if (this.browser) {
-      this.debug(`Closing browser process and all listeners`);
+      this.logger.info(
+        `Closing ${this.constructor.name} process and all listeners`,
+      );
       this.emit('close');
       this.cleanListeners();
       this.browser.removeAllListeners();
@@ -122,7 +161,7 @@ export class ChromiumCDP extends EventEmitter {
 
   public launch = async (options: CDPLaunchOptions = {}): Promise<Browser> => {
     this.port = await getPort();
-    this.debug(`Got open port ${this.port}`);
+    this.logger.info(`${this.constructor.name} got open port ${this.port}`);
     const __dirname = path.dirname(fileURLToPath(import.meta.url));
     const finalOptions = {
       ...options,
@@ -157,13 +196,17 @@ export class ChromiumCDP extends EventEmitter {
       ? puppeteerStealth.launch.bind(puppeteerStealth)
       : puppeteer.launch.bind(puppeteer);
 
-    this.debug(finalOptions, `Launching CDP Handler`);
-    // @ts-ignore mis-matched types from stealth...
+    this.logger.info(
+      finalOptions,
+      `Launching ${this.constructor.name} Handler`,
+    );
     this.browser = (await launch(finalOptions)) as Browser;
     this.browser.on('targetcreated', this.onTargetCreated);
     this.running = true;
     this.browserWSEndpoint = this.browser.wsEndpoint();
-    this.debug(`Browser is running on ${this.browserWSEndpoint}`);
+    this.logger.info(
+      `${this.constructor.name} is running on ${this.browserWSEndpoint}`,
+    );
 
     return this.browser;
   };
@@ -199,7 +242,9 @@ export class ChromiumCDP extends EventEmitter {
         );
       }
       socket.once('close', resolve);
-      this.debug(`Proxying ${req.parsed.href}`);
+      this.logger.info(
+        `Proxying ${req.parsed.href} to ${this.constructor.name}`,
+      );
 
       const shouldMakePage = req.parsed.pathname.includes(
         BLESS_PAGE_IDENTIFIER,
@@ -223,7 +268,9 @@ export class ChromiumCDP extends EventEmitter {
           target,
         },
         (error) => {
-          this.debug(`Error proxying session: ${error}`);
+          this.logger.error(
+            `Error proxying session to ${this.constructor.name}: ${error}`,
+          );
           this.close();
           return reject(error);
         },
@@ -253,8 +300,8 @@ export class ChromiumCDP extends EventEmitter {
       this.browser?.process()?.once('close', close);
       socket.once('close', close);
 
-      this.debug(
-        `Proxying ${req.parsed.href} to browser ${this.browserWSEndpoint}`,
+      this.logger.info(
+        `Proxying ${req.parsed.href} to ${this.constructor.name} ${this.browserWSEndpoint}`,
       );
 
       req.url = '';
@@ -271,7 +318,9 @@ export class ChromiumCDP extends EventEmitter {
           target: this.browserWSEndpoint,
         },
         (error) => {
-          this.debug(`Error proxying session: ${error}`);
+          this.logger.error(
+            `Error proxying session to ${this.constructor.name}: ${error}`,
+          );
           this.close();
           return reject(error);
         },