@browserless.io/browserless 2.12.0-beta-3 → 2.12.0-beta-6

package/src/browsers/chromium.cdp.ts

@@ -59,16 +59,16 @@ export class ChromiumCDP extends EventEmitter {
     this.removeAllListeners();
   }
 
-  public keepAlive() {
-    return false;
+  public keepUntil() {
+    return 0;
   }
 
-  public getPageId = (page: Page): string => {
+  public getPageId(page: Page): string {
     // @ts-ignore
     return page.target()._targetId;
-  };
+  }
 
-  protected onTargetCreated = async (target: Target) => {
+  protected async onTargetCreated(target: Target) {
     if (target.type() === 'page') {
       const page = await target.page().catch((e) => {
         this.logger.error(`Error in ${this.constructor.name} new page ${e}`);
@@ -130,11 +130,13 @@ export class ChromiumCDP extends EventEmitter {
         this.emit('newPage', page);
       }
     }
-  };
+  }
 
-  public isRunning = (): boolean => this.running;
+  public isRunning(): boolean {
+    return this.running;
+  }
 
-  public newPage = async (): Promise<Page> => {
+  public async newPage(): Promise<Page> {
     if (!this.browser) {
       throw new ServerError(
         `${this.constructor.name} hasn't been launched yet!`,
@@ -142,9 +144,9 @@ export class ChromiumCDP extends EventEmitter {
     }
 
     return this.browser.newPage();
-  };
+  }
 
-  public close = async (): Promise<void> => {
+  public async close(): Promise<void> {
     if (this.browser) {
       this.logger.info(
         `Closing ${this.constructor.name} process and all listeners`,
@@ -157,13 +159,17 @@ export class ChromiumCDP extends EventEmitter {
       this.browser = null;
       this.browserWSEndpoint = null;
     }
-  };
+  }
 
-  public pages = async (): Promise<Page[]> => this.browser?.pages() || [];
+  public async pages(): Promise<Page[]> {
+    return this.browser?.pages() || [];
+  }
 
-  public process = () => this.browser?.process() || null;
+  public process() {
+    return this.browser?.process() || null;
+  }
 
-  public launch = async (options: CDPLaunchOptions = {}): Promise<Browser> => {
+  public async launch(options: CDPLaunchOptions = {}): Promise<Browser> {
     this.port = await getPort();
     this.logger.info(`${this.constructor.name} got open port ${this.port}`);
     const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -205,7 +211,7 @@ export class ChromiumCDP extends EventEmitter {
       `Launching ${this.constructor.name} Handler`,
     );
     this.browser = (await launch(finalOptions)) as Browser;
-    this.browser.on('targetcreated', this.onTargetCreated);
+    this.browser.on('targetcreated', this.onTargetCreated.bind(this));
     this.running = true;
     this.browserWSEndpoint = this.browser.wsEndpoint();
     this.logger.info(
@@ -213,11 +219,13 @@ export class ChromiumCDP extends EventEmitter {
     );
 
     return this.browser;
-  };
+  }
 
-  public wsEndpoint = (): string | null => this.browserWSEndpoint;
+  public wsEndpoint(): string | null {
+    return this.browserWSEndpoint;
+  }
 
-  public publicWSEndpoint = (token: string | null): string | null => {
+  public publicWSEndpoint(token: string | null): string | null {
     if (!this.browserWSEndpoint) {
       return null;
     }
@@ -232,14 +240,14 @@ export class ChromiumCDP extends EventEmitter {
     }
 
     return externalURL.href;
-  };
+  }
 
-  public proxyPageWebSocket = async (
+  public async proxyPageWebSocket(
     req: Request,
     socket: Duplex,
     head: Buffer,
-  ): Promise<void> =>
-    new Promise(async (resolve, reject) => {
+  ): Promise<void> {
+    return new Promise(async (resolve, reject) => {
       if (!this.browserWSEndpoint || !this.browser) {
         throw new ServerError(
           `No browserWSEndpoint found, did you launch first?`,
@@ -280,13 +288,14 @@ export class ChromiumCDP extends EventEmitter {
         },
       );
     });
+  }
 
-  public proxyWebSocket = async (
+  public async proxyWebSocket(
     req: Request,
     socket: Duplex,
     head: Buffer,
-  ): Promise<void> =>
-    new Promise((resolve, reject) => {
+  ): Promise<void> {
+    return new Promise((resolve, reject) => {
       if (!this.browserWSEndpoint) {
         throw new ServerError(
           `No browserWSEndpoint found, did you launch first?`,
@@ -330,4 +339,5 @@ export class ChromiumCDP extends EventEmitter {
         },
       );
     });
+  }
 }

package/src/browsers/chromium.playwright.ts

@@ -43,13 +43,15 @@ export class ChromiumPlaywright extends EventEmitter {
     this.removeAllListeners();
   }
 
-  public keepAlive() {
-    return false;
+  public keepUntil() {
+    return 0;
   }
 
-  public isRunning = (): boolean => this.running;
+  public isRunning(): boolean {
+    return this.running;
+  }
 
-  public close = async (): Promise<void> => {
+  public async close(): Promise<void> {
     if (this.browser) {
       this.logger.info(
         `Closing ${this.constructor.name} process and all listeners`,
@@ -61,23 +63,25 @@ export class ChromiumPlaywright extends EventEmitter {
       this.browser = null;
       this.browserWSEndpoint = null;
     }
-  };
+  }
 
-  public pages = async (): Promise<[]> => [];
+  public async pages(): Promise<[]> {
+    return [];
+  }
 
-  public getPageId = (): string => {
+  public getPageId(): string {
     throw new ServerError(
       `#getPageId is not yet supported with ${this.constructor.name}.`,
     );
-  };
+  }
 
-  public makeLiveURL = (): void => {
+  public makeLiveURL(): void {
     throw new ServerError(
       `Live URLs are not yet supported with ${this.constructor.name}. In the future this will be at "${this.config.getExternalAddress()}"`,
     );
-  };
+  }
 
-  public newPage = async (): Promise<Page> => {
+  public async newPage(): Promise<Page> {
     if (!this.browser || !this.browserWSEndpoint) {
       throw new ServerError(
         `${this.constructor.name} hasn't been launched yet!`,
@@ -85,12 +89,12 @@ export class ChromiumPlaywright extends EventEmitter {
     }
     const browser = await playwright.chromium.connect(this.browserWSEndpoint);
     return await browser.newPage();
-  };
+  }
 
-  public launch = async (
+  public async launch(
     options: BrowserServerOptions = {},
     version?: string,
-  ): Promise<playwright.BrowserServer> => {
+  ): Promise<playwright.BrowserServer> {
     this.logger.info(`Launching ${this.constructor.name} Handler`);
 
     const opts = {
@@ -115,11 +119,13 @@ export class ChromiumPlaywright extends EventEmitter {
     this.browserWSEndpoint = browserWSEndpoint;
 
     return this.browser;
-  };
+  }
 
-  public wsEndpoint = (): string | null => this.browserWSEndpoint;
+  public wsEndpoint(): string | null {
+    return this.browserWSEndpoint;
+  }
 
-  public publicWSEndpoint = (token: string | null): string | null => {
+  public publicWSEndpoint(token: string | null): string | null {
     if (!this.browserWSEndpoint) {
       return null;
     }
@@ -134,18 +140,18 @@ export class ChromiumPlaywright extends EventEmitter {
     }
 
     return externalURL.href;
-  };
+  }
 
-  public proxyPageWebSocket = async () => {
+  public async proxyPageWebSocket() {
     this.logger.warn(`${this.constructor.name} Not yet implemented`);
-  };
+  }
 
-  public proxyWebSocket = async (
+  public async proxyWebSocket(
     req: Request,
     socket: Duplex,
     head: Buffer,
-  ): Promise<void> =>
-    new Promise((resolve, reject) => {
+  ): Promise<void> {
+    return new Promise((resolve, reject) => {
       if (!this.browserWSEndpoint) {
         throw new ServerError(
           `No browserWSEndpoint found, did you launch first?`,
@@ -179,4 +185,5 @@ export class ChromiumPlaywright extends EventEmitter {
         },
       );
     });
+  }
 }

package/src/browsers/firefox.playwright.ts

@@ -42,13 +42,15 @@ export class FirefoxPlaywright extends EventEmitter {
     this.removeAllListeners();
   }
 
-  public keepAlive() {
-    return false;
+  public keepUntil() {
+    return 0;
   }
 
-  public isRunning = (): boolean => this.running;
+  public isRunning(): boolean {
+    return this.running;
+  }
 
-  public close = async (): Promise<void> => {
+  public async close(): Promise<void> {
     if (this.browser) {
       this.logger.trace(
         `Closing ${this.constructor.name} process and all listeners`,
@@ -60,33 +62,34 @@ export class FirefoxPlaywright extends EventEmitter {
       this.browser = null;
       this.browserWSEndpoint = null;
     }
-  };
+  }
 
-  public pages = async (): Promise<[]> => [];
+  public async pages(): Promise<[]> {
+    return [];
+  }
 
-  public getPageId = (): string => {
+  public getPageId(): string {
     throw new ServerError(
       `#getPageId is not yet supported with ${this.constructor.name}.`,
     );
-  };
+  }
 
-  public makeLiveURL = (): void => {
+  public makeLiveURL(): void {
     throw new ServerError(
       `Live URLs are not yet supported with ${this.constructor.name}.`,
     );
-  };
+  }
 
-  public newPage = async (): Promise<Page> => {
+  public async newPage(): Promise<Page> {
     throw new ServerError(
       `Can't create new page with ${this.constructor.name}`,
     );
-  };
+  }
 
-  public launch = async (
+  public async launch(
     options: BrowserServerOptions = {},
     version?: string,
-  ): Promise<playwright.BrowserServer> => {
-
+  ): Promise<playwright.BrowserServer> {
     this.logger.info(`Launching ${this.constructor.name} Handler`);
     const opts = {
       ...options,
@@ -109,11 +112,13 @@ export class FirefoxPlaywright extends EventEmitter {
     this.running = true;
 
     return this.browser;
-  };
+  }
 
-  public wsEndpoint = (): string | null => this.browserWSEndpoint;
+  public wsEndpoint(): string | null {
+    return this.browserWSEndpoint;
+  }
 
-  public publicWSEndpoint = (token: string | null): string | null => {
+  public publicWSEndpoint(token: string | null): string | null {
     if (!this.browserWSEndpoint) {
       return null;
     }
@@ -128,18 +133,18 @@ export class FirefoxPlaywright extends EventEmitter {
     }
 
     return externalURL.href;
-  };
+  }
 
-  public proxyPageWebSocket = async () => {
+  public async proxyPageWebSocket() {
     this.logger.warn(`Not yet implemented in ${this.constructor.name}`);
-  };
+  }
 
-  public proxyWebSocket = async (
+  public async proxyWebSocket(
     req: Request,
     socket: Duplex,
     head: Buffer,
-  ): Promise<void> =>
-    new Promise((resolve, reject) => {
+  ): Promise<void> {
+    return new Promise((resolve, reject) => {
       if (!this.browserWSEndpoint) {
         throw new ServerError(
           `No browserWSEndpoint found, did you launch first?`,
@@ -173,4 +178,5 @@ export class FirefoxPlaywright extends EventEmitter {
         },
       );
     });
+  }
 }

package/src/browsers/index.ts

@@ -37,7 +37,7 @@ import path from 'path';
 
 export class BrowserManager {
   protected browsers: Map<BrowserInstance, BrowserlessSession> = new Map();
-  protected timers: Map<string, number> = new Map();
+  protected timers: Map<string, NodeJS.Timeout> = new Map();
   protected log = new Logger('browser-manager');
   protected chromeBrowsers = [ChromiumCDP, ChromeCDP];
   protected playwrightBrowserNames = [
@@ -52,10 +52,13 @@ export class BrowserManager {
     protected hooks: Hooks,
   ) {}
 
-  protected browserIsChrome = (b: BrowserInstance) =>
-    this.chromeBrowsers.some((chromeBrowser) => b instanceof chromeBrowser);
+  protected browserIsChrome(b: BrowserInstance) {
+    return this.chromeBrowsers.some(
+      (chromeBrowser) => b instanceof chromeBrowser,
+    );
+  }
 
-  protected removeUserDataDir = async (userDataDir: string | null) => {
+  protected async removeUserDataDir(userDataDir: string | null) {
     if (userDataDir && (await exists(userDataDir))) {
       this.log.info(`Deleting data directory "${userDataDir}"`);
       await deleteAsync(userDataDir, { force: true }).catch((err) => {
@@ -64,18 +67,18 @@ export class BrowserManager {
         );
       });
     }
-  };
+  }
 
-  protected onNewPage = async (req: Request, page: Page) => {
-    await this.hooks.page({ meta: req.parsed, page });
-  };
+  protected async onNewPage(req: Request, page: Page) {
+    return await this.hooks.page({ meta: req.parsed, page });
+  }
 
   /**
    * Returns the /json/protocol API contents from Chromium or Chrome, whichever is installed,
    * and modifies URLs to set them to the appropriate addresses configured.
    * When both Chrome and Chromium are installed, defaults to Chromium.
    */
-  public getProtocolJSON = async (logger: Logger): Promise<object> => {
+  public async getProtocolJSON(logger: Logger): Promise<object> {
     const Browser = (await availableBrowsers).find((InstalledBrowser) =>
       this.chromeBrowsers.some(
         (ChromeBrowser) => InstalledBrowser === ChromeBrowser,
@@ -104,14 +107,14 @@ export class BrowserManager {
     browser.close();
 
     return protocolJSON;
-  };
+  }
 
   /**
    * Returns the /json/version API from Chromium or Chrome, whichever is installed,
    * and modifies URLs to set them to the appropriate addresses configured.
    * When both Chrome and Chromium are installed, defaults to Chromium.
    */
-  public getVersionJSON = async (logger: Logger): Promise<CDPJSONPayload> => {
+  public async getVersionJSON(logger: Logger): Promise<CDPJSONPayload> {
     this.log.info(`Launching Chromium to generate /json/version results`);
     const Browser = (await availableBrowsers).find((InstalledBrowser) =>
       this.chromeBrowsers.some(
@@ -149,14 +152,14 @@ export class BrowserManager {
       'Debugger-Version': debuggerVersion,
       webSocketDebuggerUrl: this.config.getExternalWebSocketAddress(),
     };
-  };
+  }
 
   /**
    * Returns a list of all Chrome-like browsers (both Chromium and Chrome) with
    * their respective /json/list contents. URLs are modified so that subsequent
    * calls can be forwarded to the appropriate destination
    */
-  public getJSONList = async (): Promise<Array<CDPJSONPayload>> => {
+  public async getJSONList(): Promise<Array<CDPJSONPayload>> {
     const externalAddress = this.config.getExternalWebSocketAddress();
     const externalURL = new URL(externalAddress);
     const sessions = Array.from(this.browsers);
@@ -214,19 +217,19 @@ export class BrowserManager {
     return cdpResponse
       .flat()
       .filter((_) => _ !== null) as Array<CDPJSONPayload>;
-  };
+  }
 
-  protected generateSessionJson = async (
+  protected async generateSessionJson(
     browser: BrowserInstance,
     session: BrowserlessSession,
-  ) => {
+  ) {
     const serverAddress = this.config.getExternalAddress();
 
     const sessions = [
       {
         ...session,
         browser: browser.constructor.name,
-        browserId: browser.wsEndpoint()?.split('/').pop() as string,
+        browserId: session.id,
         initialConnectURL: new URL(session.initialConnectURL, serverAddress)
           .href,
         killURL: session.id
@@ -262,35 +265,63 @@ export class BrowserManager {
       }
     }
     return sessions;
-  };
+  }
 
-  public close = async (
+  public async close(
     browser: BrowserInstance,
     session: BrowserlessSession,
-  ): Promise<void> => {
+  ): Promise<void> {
+    const now = Date.now();
+    const keepUntil = browser.keepUntil();
+    const connected = session.numbConnected;
+    const hasKeepUntil = keepUntil > now;
+    const keepOpen = connected > 0 || hasKeepUntil;
     const cleanupACtions: Array<() => Promise<void>> = [];
-    this.log.info(`${session.numbConnected} Client(s) are currently connected`);
+    const priorTimer = this.timers.get(session.id);
 
-    // Don't close if there's clients still connected
-    if (session.numbConnected > 0 || browser.keepAlive()) {
-      return;
+    if (priorTimer) {
+      this.log.info(`Deleting prior keep-until timer for "${session.id}"`);
+      global.clearTimeout(priorTimer);
     }
 
-    this.log.info(`Closing browser session`);
-    cleanupACtions.push(() => browser.close());
+    this.log.info(
+      `${session.numbConnected} Client(s) are currently connected, Keep-until: ${keepUntil}`,
+    );
 
-    if (session.isTempDataDir) {
-      this.log.info(
-        `Deleting "${session.userDataDir}" user-data-dir and session from memory`,
+    if (hasKeepUntil) {
+      const timeout = keepUntil - now;
+      this.log.trace(
+        `Setting timer ${timeout.toLocaleString()} for "${session.id}"`,
+      );
+      this.timers.set(
+        session.id,
+        global.setTimeout(() => {
+          const session = this.browsers.get(browser);
+          if (session) {
+            this.log.trace(`Timer hit for "${session.id}"`),
+              this.close(browser, session);
+          }
+        }, timeout),
       );
-      this.browsers.delete(browser);
-      cleanupACtions.push(() => this.removeUserDataDir(session.userDataDir));
     }
 
-    await Promise.all(cleanupACtions.map((a) => a()));
-  };
+    if (!keepOpen) {
+      this.log.info(`Closing browser session`);
+      cleanupACtions.push(() => browser.close());
 
-  public getAllSessions = async (): Promise<BrowserlessSessionJSON[]> => {
+      if (session.isTempDataDir) {
+        this.log.info(
+          `Deleting "${session.userDataDir}" user-data-dir and session from memory`,
+        );
+        this.browsers.delete(browser);
+        cleanupACtions.push(() => this.removeUserDataDir(session.userDataDir));
+      }
+
+      await Promise.all(cleanupACtions.map((a) => a()));
+    }
+  }
+
+  public async getAllSessions(): Promise<BrowserlessSessionJSON[]> {
     const sessions = Array.from(this.browsers);
 
     const formattedSessions: BrowserlessSessionJSON[] = [];
@@ -299,9 +330,9 @@ export class BrowserManager {
       formattedSessions.push(...formattedSession);
     }
     return formattedSessions;
-  };
+  }
 
-  public complete = async (browser: BrowserInstance): Promise<void> => {
+  public async complete(browser: BrowserInstance): Promise<void> {
     const session = this.browsers.get(browser);
     if (!session) {
       this.log.info(
@@ -319,13 +350,13 @@ export class BrowserManager {
     --session.numbConnected;
 
     this.close(browser, session);
-  };
+  }
 
-  public getBrowserForRequest = async (
+  public async getBrowserForRequest(
     req: Request,
     router: BrowserHTTPRoute | BrowserWebsocketRoute,
     logger: Logger,
-  ): Promise<BrowserInstance> => {
+  ): Promise<BrowserInstance> {
     const { browser: Browser } = router;
     const blockAds = parseBooleanParam(
       req.parsed.searchParams,
@@ -459,8 +490,14 @@ export class BrowserManager {
       userDataDir,
     });
 
+    const match = (req.headers['user-agent'] || '').match(pwVersionRegex);
+    const pwVersion = match ? match[1] : 'default';
+
+    await browser.launch(launchOptions as object, pwVersion);
+    await this.hooks.browser({ browser, meta: req.parsed });
+
     const session: BrowserlessSession = {
-      id: null,
+      id: browser.wsEndpoint()?.split('/').pop() as string,
       initialConnectURL:
         path.join(req.parsed.pathname, req.parsed.search) || '',
       isTempDataDir: !manualUserDataDir,
@@ -475,21 +512,15 @@ export class BrowserManager {
 
     this.browsers.set(browser, session);
 
-    const match = (req.headers['user-agent'] || '').match(pwVersionRegex);
-    const pwVersion = match ? match[1] : 'default';
-
-    await browser.launch(launchOptions as object, pwVersion);
-    await this.hooks.browser({ browser, meta: req.parsed });
-
     browser.on('newPage', async (page) => {
       await this.onNewPage(req, page);
       (router.onNewPage || noop)(req.parsed || '', page);
     });
 
     return browser;
-  };
+  }
 
-  public shutdown = async (): Promise<void> => {
+  public async shutdown(): Promise<void> {
     this.log.info(`Closing down browser instances`);
     const sessions = Array.from(this.browsers);
     await Promise.all(sessions.map(([b]) => b.close()));
@@ -500,10 +531,10 @@ export class BrowserManager {
     this.timers = new Map();
     await this.stop();
     this.log.info(`Shutdown complete`);
-  };
+  }
 
   /**
    * Left blank for downstream SDK modules to optionally implement.
    */
-  public stop = () => {};
+  public stop() {}
 }