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

package/build/browsers/index.js

@@ -18,24 +18,26 @@ export class BrowserManager {
         this.config = config;
         this.hooks = hooks;
     }
-    browserIsChrome = (b) => this.chromeBrowsers.some((chromeBrowser) => b instanceof chromeBrowser);
-    removeUserDataDir = async (userDataDir) => {
+    browserIsChrome(b) {
+        return this.chromeBrowsers.some((chromeBrowser) => b instanceof chromeBrowser);
+    }
+    async removeUserDataDir(userDataDir) {
         if (userDataDir && (await exists(userDataDir))) {
             this.log.info(`Deleting data directory "${userDataDir}"`);
             await deleteAsync(userDataDir, { force: true }).catch((err) => {
                 this.log.error(`Error cleaning up user-data-dir "${err}" at ${userDataDir}`);
             });
         }
-    };
-    onNewPage = async (req, page) => {
-        await this.hooks.page({ meta: req.parsed, page });
-    };
+    }
+    async onNewPage(req, 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.
      */
-    getProtocolJSON = async (logger) => {
+    async getProtocolJSON(logger) {
         const Browser = (await availableBrowsers).find((InstalledBrowser) => this.chromeBrowsers.some((ChromeBrowser) => InstalledBrowser === ChromeBrowser));
         if (!Browser) {
             throw new Error(`No Chrome or Chromium browsers are installed!`);
@@ -56,13 +58,13 @@ export class BrowserManager {
         const protocolJSON = await res.json();
         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.
      */
-    getVersionJSON = async (logger) => {
+    async getVersionJSON(logger) {
         this.log.info(`Launching Chromium to generate /json/version results`);
         const Browser = (await availableBrowsers).find((InstalledBrowser) => this.chromeBrowsers.some((ChromeBrowser) => InstalledBrowser === ChromeBrowser));
         if (!Browser) {
@@ -90,13 +92,13 @@ 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
      */
-    getJSONList = async () => {
+    async getJSONList() {
         const externalAddress = this.config.getExternalWebSocketAddress();
         const externalURL = new URL(externalAddress);
         const sessions = Array.from(this.browsers);
@@ -138,14 +140,14 @@ export class BrowserManager {
         return cdpResponse
             .flat()
             .filter((_) => _ !== null);
-    };
-    generateSessionJson = async (browser, session) => {
+    }
+    async generateSessionJson(browser, session) {
         const serverAddress = this.config.getExternalAddress();
         const sessions = [
             {
                 ...session,
                 browser: browser.constructor.name,
-                browserId: browser.wsEndpoint()?.split('/').pop(),
+                browserId: session.id,
                 initialConnectURL: new URL(session.initialConnectURL, serverAddress)
                     .href,
                 killURL: session.id
@@ -176,24 +178,43 @@ export class BrowserManager {
             }
         }
         return sessions;
-    };
-    close = async (browser, session) => {
+    }
+    async close(browser, session) {
+        const now = Date.now();
+        const keepUntil = browser.keepUntil();
+        const connected = session.numbConnected;
+        const hasKeepUntil = keepUntil > now;
+        const keepOpen = connected > 0 || hasKeepUntil;
         const cleanupACtions = [];
-        this.log.info(`${session.numbConnected} Client(s) are currently connected`);
-        // Don't close if there's clients still connected
-        if (session.numbConnected > 0 || browser.keepAlive()) {
-            return;
+        const priorTimer = this.timers.get(session.id);
+        if (priorTimer) {
+            this.log.info(`Deleting prior keep-until timer for "${session.id}"`);
+            global.clearTimeout(priorTimer);
+        }
+        this.log.info(`${session.numbConnected} Client(s) are currently connected, Keep-until: ${keepUntil}`);
+        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.log.info(`Closing browser session`);
-        cleanupACtions.push(() => browser.close());
-        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));
+        if (!keepOpen) {
+            this.log.info(`Closing browser session`);
+            cleanupACtions.push(() => browser.close());
+            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()));
         }
-        await Promise.all(cleanupACtions.map((a) => a()));
-    };
-    getAllSessions = async () => {
+    }
+    async getAllSessions() {
         const sessions = Array.from(this.browsers);
         const formattedSessions = [];
         for (const [browser, session] of sessions) {
@@ -201,8 +222,8 @@ export class BrowserManager {
             formattedSessions.push(...formattedSession);
         }
         return formattedSessions;
-    };
-    complete = async (browser) => {
+    }
+    async complete(browser) {
         const session = this.browsers.get(browser);
         if (!session) {
             this.log.info(`Couldn't locate session for browser, proceeding with close`);
@@ -214,8 +235,8 @@ export class BrowserManager {
         }
         --session.numbConnected;
         this.close(browser, session);
-    };
-    getBrowserForRequest = async (req, router, logger) => {
+    }
+    async getBrowserForRequest(req, router, logger) {
         const { browser: Browser } = router;
         const blockAds = parseBooleanParam(req.parsed.searchParams, 'blockAds', false);
         const decodedLaunchOptions = convertIfBase64(req.parsed.searchParams.get('launch') || '{}');
@@ -307,8 +328,12 @@ export class BrowserManager {
             logger,
             userDataDir,
         });
+        const match = (req.headers['user-agent'] || '').match(pwVersionRegex);
+        const pwVersion = match ? match[1] : 'default';
+        await browser.launch(launchOptions, pwVersion);
+        await this.hooks.browser({ browser, meta: req.parsed });
         const session = {
-            id: null,
+            id: browser.wsEndpoint()?.split('/').pop(),
             initialConnectURL: path.join(req.parsed.pathname, req.parsed.search) || '',
             isTempDataDir: !manualUserDataDir,
             launchOptions,
@@ -320,17 +345,13 @@ export class BrowserManager {
             userDataDir,
         };
         this.browsers.set(browser, session);
-        const match = (req.headers['user-agent'] || '').match(pwVersionRegex);
-        const pwVersion = match ? match[1] : 'default';
-        await browser.launch(launchOptions, 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;
-    };
-    shutdown = async () => {
+    }
+    async shutdown() {
         this.log.info(`Closing down browser instances`);
         const sessions = Array.from(this.browsers);
         await Promise.all(sessions.map(([b]) => b.close()));
@@ -341,9 +362,9 @@ export class BrowserManager {
         this.timers = new Map();
         await this.stop();
         this.log.info(`Shutdown complete`);
-    };
+    }
     /**
      * Left blank for downstream SDK modules to optionally implement.
      */
-    stop = () => { };
+    stop() { }
 }

package/build/browsers/webkit.playwright.d.ts

@@ -21,16 +21,16 @@ export declare class WebkitPlaywright extends EventEmitter {
         userDataDir: WebkitPlaywright['userDataDir'];
     });
     protected cleanListeners(): void;
-    keepAlive(): boolean;
-    isRunning: () => boolean;
-    close: () => Promise<void>;
-    pages: () => Promise<[]>;
-    getPageId: () => string;
-    makeLiveURL: () => void;
-    newPage: () => Promise<Page>;
-    launch: (options?: BrowserServerOptions, version?: string) => Promise<playwright.BrowserServer>;
-    wsEndpoint: () => string | null;
-    publicWSEndpoint: (token: string | null) => string | null;
-    proxyPageWebSocket: () => Promise<void>;
-    proxyWebSocket: (req: Request, socket: Duplex, head: Buffer) => Promise<void>;
+    keepUntil(): number;
+    isRunning(): boolean;
+    close(): Promise<void>;
+    pages(): Promise<[]>;
+    getPageId(): string;
+    makeLiveURL(): void;
+    newPage(): Promise<Page>;
+    launch(options?: BrowserServerOptions, version?: string): Promise<playwright.BrowserServer>;
+    wsEndpoint(): string | null;
+    publicWSEndpoint(token: string | null): string | null;
+    proxyPageWebSocket(): Promise<void>;
+    proxyWebSocket(req: Request, socket: Duplex, head: Buffer): Promise<void>;
 }

package/build/browsers/webkit.playwright.js

@@ -21,11 +21,13 @@ export class WebkitPlaywright extends EventEmitter {
     cleanListeners() {
         this.removeAllListeners();
     }
-    keepAlive() {
-        return false;
+    keepUntil() {
+        return 0;
     }
-    isRunning = () => this.running;
-    close = async () => {
+    isRunning() {
+        return this.running;
+    }
+    async close() {
         if (this.browser) {
             this.logger.info(`Closing ${this.constructor.name} process and all listeners`);
             this.emit('close');
@@ -35,27 +37,29 @@ export class WebkitPlaywright extends EventEmitter {
             this.browser = null;
             this.browserWSEndpoint = null;
         }
-    };
-    pages = async () => [];
-    getPageId = () => {
+    }
+    async pages() {
+        return [];
+    }
+    getPageId() {
         throw new ServerError(`#getPageId is not yet supported with ${this.constructor.name}.`);
-    };
-    makeLiveURL = () => {
+    }
+    makeLiveURL() {
         throw new ServerError(`Live URLs are not yet supported with ${this.constructor.name}.`);
-    };
-    newPage = async () => {
+    }
+    async newPage() {
         throw new ServerError(`Can't create new page with ${this.constructor.name}`);
-    };
-    launch = async (options = {}, version) => {
+    }
+    async launch(options = {}, version) {
         this.logger.info(`Launching ${this.constructor.name} Handler`);
-        const opts = ({
+        const opts = {
             ...options,
             args: [
                 ...(options.args || []),
                 this.userDataDir ? `-profile=${this.userDataDir}` : '',
             ],
             executablePath: playwright.webkit.executablePath(),
-        });
+        };
         const versionedPw = await this.config.loadPwVersion(version);
         this.browser = await versionedPw.webkit.launchServer(opts);
         const browserWSEndpoint = this.browser.wsEndpoint();
@@ -63,9 +67,11 @@ export class WebkitPlaywright extends EventEmitter {
         this.browserWSEndpoint = browserWSEndpoint;
         this.running = true;
         return this.browser;
-    };
-    wsEndpoint = () => this.browserWSEndpoint;
-    publicWSEndpoint = (token) => {
+    }
+    wsEndpoint() {
+        return this.browserWSEndpoint;
+    }
+    publicWSEndpoint(token) {
         if (!this.browserWSEndpoint) {
             return null;
         }
@@ -76,26 +82,28 @@ export class WebkitPlaywright extends EventEmitter {
             externalURL.searchParams.set('token', token);
         }
         return externalURL.href;
-    };
-    proxyPageWebSocket = async () => {
-        this.logger.warn(`Not yet implemented`);
-    };
-    proxyWebSocket = async (req, socket, head) => new Promise((resolve, reject) => {
-        if (!this.browserWSEndpoint) {
-            throw new ServerError(`No browserWSEndpoint found, did you launch first?`);
-        }
-        socket.once('close', resolve);
-        this.logger.info(`Proxying ${req.parsed.href} to ${this.constructor.name} ${this.browserWSEndpoint}`);
-        // Delete headers known to cause issues
-        delete req.headers.origin;
-        req.url = '';
-        this.proxy.ws(req, socket, head, {
-            changeOrigin: true,
-            target: this.browserWSEndpoint,
-        }, (error) => {
-            this.logger.error(`Error proxying session to ${this.constructor.name}: ${error}`);
-            this.close();
-            return reject(error);
+    }
+    async proxyPageWebSocket() {
+        return this.logger.warn(`Not yet implemented`);
+    }
+    async proxyWebSocket(req, socket, head) {
+        return new Promise((resolve, reject) => {
+            if (!this.browserWSEndpoint) {
+                throw new ServerError(`No browserWSEndpoint found, did you launch first?`);
+            }
+            socket.once('close', resolve);
+            this.logger.info(`Proxying ${req.parsed.href} to ${this.constructor.name} ${this.browserWSEndpoint}`);
+            // Delete headers known to cause issues
+            delete req.headers.origin;
+            req.url = '';
+            this.proxy.ws(req, socket, head, {
+                changeOrigin: true,
+                target: this.browserWSEndpoint,
+            }, (error) => {
+                this.logger.error(`Error proxying session to ${this.constructor.name}: ${error}`);
+                this.close();
+                return reject(error);
+            });
         });
-    });
+    }
 }

package/build/config.d.ts

@@ -38,13 +38,13 @@ export declare class Config extends EventEmitter {
     protected pwVersions: {
         [key: string]: string;
     };
-    getRoutes: () => string;
-    getHost: () => string;
-    getPort: () => number;
-    getIsWin: () => boolean;
-    getToken: () => string | null;
-    getDebug: () => string;
-    getPwVersions: () => {
+    getRoutes(): string;
+    getHost(): string;
+    getPort(): number;
+    getIsWin(): boolean;
+    getToken(): string | null;
+    getDebug(): string;
+    getPwVersions(): {
         [key: string]: string;
     };
     /**
@@ -52,73 +52,75 @@ export declare class Config extends EventEmitter {
      * to "-1" or "Infinity" for no limit.
      * @returns number
      */
-    getConcurrent: () => number;
+    getConcurrent(): number;
     /**
      * The maximum number of queued sessions allowed. Set to
      * "-1" or "Infinity" for no limit.
      * @returns number
      */
-    getQueued: () => number;
-    getTimeout: () => number;
-    getStatic: () => string;
-    getDebuggerDir: () => string;
-    getRetries: () => number;
-    getAllowFileProtocol: () => boolean;
-    getCPULimit: () => number;
-    getMemoryLimit: () => number;
-    getHealthChecksEnabled: () => boolean;
-    getFailedHealthURL: () => string | null;
-    getQueueAlertURL: () => string | null;
-    getRejectAlertURL: () => string | null;
-    getTimeoutAlertURL: () => string | null;
-    getErrorAlertURL: () => string | null;
-    hasDebugger: () => Promise<boolean>;
+    getQueued(): number;
+    getTimeout(): number;
+    getStatic(): string;
+    getDebuggerDir(): string;
+    getRetries(): number;
+    getAllowFileProtocol(): boolean;
+    getCPULimit(): number;
+    getMemoryLimit(): number;
+    getHealthChecksEnabled(): boolean;
+    getFailedHealthURL(): string | null;
+    getQueueAlertURL(): string | null;
+    getRejectAlertURL(): string | null;
+    getTimeoutAlertURL(): string | null;
+    getErrorAlertURL(): string | null;
+    hasDebugger(): Promise<boolean>;
     /**
      * If true, allows GET style calls on our browser-based APIs, using
      * ?body=JSON format.
      */
-    getAllowGetCalls: () => boolean;
+    getAllowGetCalls(): boolean;
     /**
      * Determines if CORS is allowed
      */
-    getAllowCORS: () => boolean;
-    getDataDir: () => Promise<string>;
-    getDownloadsDir: () => Promise<string>;
+    getAllowCORS(): boolean;
+    getDataDir(): Promise<string>;
+    getDownloadsDir(): Promise<string>;
     /**
      * Repeats the TOKEN parameter up to 24 characters so we can
      * do AES encoding for saving things to disk and generating
      * secure links.
      */
-    getAESKey: () => Buffer;
-    getMetricsJSONPath: () => string;
-    setPwVersions: (versions: {
+    getAESKey(): Buffer;
+    getMetricsJSONPath(): string;
+    setPwVersions(versions: {
         [key: string]: string;
-    }) => void;
-    loadPwVersion: (version: string) => Promise<typeof playwright>;
-    setDataDir: (newDataDir: string) => Promise<string>;
-    setRoutes: (newRoutePath: string) => string;
-    setConcurrent: (newConcurrent: number) => number;
-    setQueued: (newQueued: number) => number;
-    setToken: (newToken: string | null) => string | null;
-    setTimeout: (newTimeout: number) => number;
-    setStatic: (newStatic: string) => string;
-    setRetries: (newRetries: number) => number;
-    setCPULimit: (limit: number) => number;
-    setMemoryLimit: (limit: number) => number;
-    enableHealthChecks: (enable: boolean) => boolean;
-    enableGETRequests: (enable: boolean) => boolean;
-    enableCORS: (enable: boolean) => boolean;
-    setCORSMethods: (methods: string) => string;
-    setCORSOrigin: (origin: string) => string;
-    setCORSMaxAge: (maxAge: number) => number;
-    setFailedHealthURL: (url: string | null) => string | null;
-    setQueueAlertURL: (url: string | null) => string | null;
-    setRejectAlertURL: (url: string | null) => string | null;
-    setTimeoutAlertURL: (url: string | null) => string | null;
-    setErrorAlertURL: (url: string | null) => string | null;
-    setMetricsJSONPath: (path: string) => string;
-    setPort: (port: number) => number;
-    setAllowFileProtocol: (allow: boolean) => boolean;
+    }): {
+        [key: string]: string;
+    };
+    loadPwVersion(version: string): Promise<typeof playwright>;
+    setDataDir(newDataDir: string): Promise<string>;
+    setRoutes(newRoutePath: string): string;
+    setConcurrent(newConcurrent: number): number;
+    setQueued(newQueued: number): number;
+    setToken(newToken: string | null): string | null;
+    setTimeout(newTimeout: number): number;
+    setStatic(newStatic: string): string;
+    setRetries(newRetries: number): number;
+    setCPULimit(limit: number): number;
+    setMemoryLimit(limit: number): number;
+    enableHealthChecks(enable: boolean): boolean;
+    enableGETRequests(enable: boolean): boolean;
+    enableCORS(enable: boolean): boolean;
+    setCORSMethods(methods: string): string;
+    setCORSOrigin(origin: string): string;
+    setCORSMaxAge(maxAge: number): number;
+    setFailedHealthURL(url: string | null): string | null;
+    setQueueAlertURL(url: string | null): string | null;
+    setRejectAlertURL(url: string | null): string | null;
+    setTimeoutAlertURL(url: string | null): string | null;
+    setErrorAlertURL(url: string | null): string | null;
+    setMetricsJSONPath(path: string): string;
+    setPort(port: number): number;
+    setAllowFileProtocol(allow: boolean): boolean;
     /**
      * Returns the fully-qualified server address, which
      * includes host, protocol, and port for which the
@@ -128,7 +130,7 @@ export declare class Config extends EventEmitter {
      *
      * @returns Fully-qualified server address
      */
-    getServerAddress: () => string;
+    getServerAddress(): string;
     /**
      * Returns the fully-qualified URL for the
      * external address that browserless might be
@@ -137,7 +139,7 @@ export declare class Config extends EventEmitter {
      *
      * @returns {string} The URL to reach the server
      */
-    getExternalAddress: () => string;
+    getExternalAddress(): string;
     /**
      * Set the external URL, which Browserless uses for encoding
      * URLs over the HOST:PORT that it's bound to.
@@ -145,7 +147,7 @@ export declare class Config extends EventEmitter {
      * @param address The fully-qualified URL, eg https://www.example.com/
      * @returns {string} The address
      */
-    setExternalAddress: (address: string) => string;
+    setExternalAddress(address: string): string;
     /**
      * Returns the fully-qualified WebSocket URL for the
      * external address that browserless might be
@@ -154,14 +156,14 @@ export declare class Config extends EventEmitter {
      *
      * @returns {string} The URL to reach the server
      */
-    getExternalWebSocketAddress: () => string;
+    getExternalWebSocketAddress(): string;
     /**
      * When CORS is enabled, returns relevant CORS headers
      * to requests and for the OPTIONS call. Values can be
      * overridden by specifying `CORS_ALLOW_METHODS`, `CORS_ALLOW_ORIGIN`,
      * and `CORS_MAX_AGE`
      */
-    getCORSHeaders: () => {
+    getCORSHeaders(): {
         'Access-Control-Allow-Methods': string;
         'Access-Control-Allow-Origin': string;
         'Access-Control-Max-Age': number;
@@ -170,9 +172,9 @@ export declare class Config extends EventEmitter {
      * Implement any browserless-core-specific shutdown logic here.
      * Calls the empty-SDK stop method for downstream implementations.
      */
-    shutdown: () => Promise<void>;
+    shutdown(): Promise<void>;
     /**
      * Left blank for downstream SDK modules to optionally implement.
      */
-    stop: () => void;
+    stop(): void;
 }