@browserless.io/browserless 2.25.0-beta-2 → 2.25.1

package/build/routes/edge/tests/websocket.spec.js

@@ -0,0 +1,384 @@
+import { Browserless, Config, Metrics, exists, fetchJson, sleep, } from '@browserless.io/browserless';
+import { chromium } from 'playwright-core';
+import { deleteAsync } from 'del';
+import { expect } from 'chai';
+import puppeteer from 'puppeteer-core';
+describe('Edge WebSocket API', function () {
+    let browserless;
+    const start = ({ config = new Config(), metrics = new Metrics(), } = {}) => {
+        browserless = new Browserless({ config, metrics });
+        return browserless.start();
+    };
+    afterEach(async () => {
+        await browserless.stop();
+    });
+    it('runs edge websocket requests', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const browser = await puppeteer.connect({
+            browserWSEndpoint: `ws://localhost:3000/edge?token=browserless`,
+        });
+        await browser.close();
+    });
+    it('runs edge Playwright-CDP requests', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const browser = await chromium.connectOverCDP(`ws://localhost:3000/edge?token=browserless`);
+        await browser.close();
+    });
+    it('runs multiple websocket requests', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const browser = await puppeteer.connect({
+            browserWSEndpoint: `ws://localhost:3000/edge?token=browserless`,
+        });
+        const browserTwo = await puppeteer.connect({
+            browserWSEndpoint: `ws://localhost:3000/edge?token=browserless`,
+        });
+        await Promise.all([browser.close(), browserTwo.close()]);
+    });
+    it('does not close browsers when multiple clients are connected', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        // Single session
+        const browser = await puppeteer.connect({
+            browserWSEndpoint: `ws://localhost:3000/edge?token=browserless`,
+        });
+        await sleep(100);
+        const [session] = (await fetchJson('http://localhost:3000/sessions?token=browserless'));
+        expect(session.numbConnected).to.equal(1);
+        // Two sessions
+        const browserTwo = await puppeteer.connect({
+            browserWSEndpoint: `ws://localhost:3000/devtools/browser/${session.browserId}?token=browserless`,
+        });
+        await sleep(100);
+        const [twoSessions] = (await fetchJson('http://localhost:3000/sessions?token=browserless'));
+        expect(twoSessions.numbConnected).to.equal(2);
+        // Back to a single session
+        await browser.disconnect();
+        await sleep(100);
+        const [oneSession] = (await fetchJson('http://localhost:3000/sessions?token=browserless'));
+        expect(oneSession.numbConnected).to.equal(1);
+        // No sessions connected
+        await browserTwo.disconnect();
+        await sleep(100);
+        const sessionsFinal = (await fetchJson('http://localhost:3000/sessions?token=browserless'));
+        expect(sessionsFinal).to.have.length(0);
+    });
+    it('disconnects all clients when the timeout is reached', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        config.setTimeout(1000);
+        config.setConcurrent(2);
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const browser = await puppeteer.connect({
+            browserWSEndpoint: `ws://localhost:3000/edge?token=browserless`,
+        });
+        const [session] = (await fetchJson('http://localhost:3000/sessions?token=browserless'));
+        const browserTwo = await puppeteer.connect({
+            browserWSEndpoint: `ws://localhost:3000/devtools/browser/${session.browserId}?token=browserless`,
+        });
+        await sleep(3000);
+        expect(metrics.get().successful).to.equal(0);
+        expect(metrics.get().timedout).to.equal(2);
+        expect(browser.connected).to.be.false;
+        expect(browserTwo.connected).to.be.false;
+    });
+    it('rejects websocket requests', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const didError = await puppeteer
+            .connect({
+            browserWSEndpoint: `ws://localhost:3000/edge?token=bad`,
+        })
+            .then(() => false)
+            .catch(() => true);
+        expect(didError).to.be.true;
+    });
+    it('rejects file protocol requests', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const didError = await puppeteer
+            .connect({
+            browserWSEndpoint: `ws://localhost:3000/edge?token=browserless`,
+        })
+            .then(async (b) => {
+            const page = await b.newPage();
+            await page.goto('file:///etc/passwd');
+            await page.content();
+            await b.disconnect();
+            return false;
+        })
+            .catch(() => true);
+        expect(didError).to.be.true;
+    });
+    it.skip('runs with ignored arguments', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const args = {
+            ignoreDefaultArgs: true,
+        };
+        const success = await puppeteer
+            .connect({
+            browserWSEndpoint: `ws://localhost:3000/edge?token=browserless&launch=${JSON.stringify(args)}`,
+        })
+            .then(async (b) => {
+            const page = await b.newPage();
+            await page.close();
+            b.close();
+            return true;
+        })
+            .catch(() => false);
+        expect(success).to.be.true;
+    });
+    it('deletes user-data-dirs when not specified', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const browser = await puppeteer.connect({
+            browserWSEndpoint: `ws://localhost:3000/edge?token=browserless`,
+        });
+        const [{ userDataDir }] = await fetch('http://localhost:3000/sessions?token=browserless').then((r) => r.json());
+        expect(await exists(userDataDir)).to.be.true;
+        await browser.disconnect();
+        await sleep(1000);
+        expect(await exists(userDataDir)).to.be.false;
+    });
+    it('allows specified user-data-dirs', async () => {
+        const dataDir = '/tmp/data-dir';
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const launch = JSON.stringify({
+            args: [`--user-data-dir=${dataDir}`],
+        });
+        const browser = await puppeteer.connect({
+            browserWSEndpoint: `ws://localhost:3000/edge?token=browserless&launch=${launch}`,
+        });
+        const [{ userDataDir }] = await fetch('http://localhost:3000/sessions?token=browserless').then((r) => r.json());
+        expect(await exists(userDataDir)).to.be.true;
+        expect(userDataDir).to.equal(dataDir);
+        await browser.disconnect();
+        await sleep(1000);
+        expect(await exists(userDataDir)).to.be.true;
+    });
+    it('creates user-data-dirs with userDataDir options', async () => {
+        const dataDirLocation = '/tmp/browserless-test-dir';
+        const launch = JSON.stringify({
+            userDataDir: dataDirLocation,
+        });
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const browser = await puppeteer.connect({
+            browserWSEndpoint: `ws://localhost:3000/edge?token=browserless&launch=${launch}`,
+        });
+        const [{ userDataDir }] = await fetch('http://localhost:3000/sessions?token=browserless').then((r) => r.json());
+        expect(userDataDir === dataDirLocation).to.be.true;
+        expect(await exists(userDataDir)).to.be.true;
+        await browser.disconnect();
+        await sleep(500);
+        expect(await exists(userDataDir)).to.be.true;
+        await deleteAsync(userDataDir, { force: true });
+    });
+    it('creates user-data-dirs with CLI flags', async () => {
+        const dataDirLocation = '/tmp/browserless-test-dir';
+        const launch = JSON.stringify({
+            args: [`--user-data-dir=${dataDirLocation}`],
+        });
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const browser = await puppeteer.connect({
+            browserWSEndpoint: `ws://localhost:3000/edge?token=browserless&launch=${launch}`,
+        });
+        const [{ userDataDir }] = await fetch('http://localhost:3000/sessions?token=browserless').then((r) => r.json());
+        expect(userDataDir === dataDirLocation).to.be.true;
+        expect(await exists(userDataDir)).to.be.true;
+        await browser.disconnect();
+        await sleep(500);
+        expect(await exists(userDataDir)).to.be.true;
+        await deleteAsync(userDataDir, { force: true });
+    });
+    it('runs with job-based timeouts', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        config.setTimeout(-1); // No timeout
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const browser = await puppeteer.connect({
+            browserWSEndpoint: `ws://localhost:3000/edge?timeout=1000&token=browserless`,
+        });
+        expect(browser.connected).to.be.true;
+        await sleep(1200);
+        expect(metrics.get().timedout).to.equal(1);
+        expect(metrics.get().successful).to.equal(0);
+        expect(browser.connected).to.be.false;
+    });
+    it('allows the file-chooser', async () => new Promise(async (done) => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const job = async () => {
+            const browser = await puppeteer.connect({
+                browserWSEndpoint: `ws://localhost:3000/edge?token=browserless`,
+            });
+            const page = await browser.newPage();
+            await page.setContent(`<div class="output" style="height: 62%;"><label for="avatar">Choose a profile picture:</label>
+      <input type="file" id="avatar" name="avatar" accept="image/png, image/jpeg">
+    </div>`);
+            if (page.waitForFileChooser) {
+                const [fileChooser] = await Promise.all([
+                    page.waitForFileChooser(),
+                    page.click('#avatar'),
+                ]);
+                expect(fileChooser).to.not.be.undefined;
+                expect(fileChooser).to.not.be.null;
+            }
+            browser.disconnect();
+            done();
+        };
+        job();
+    }));
+    it('queues requests', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        config.setConcurrent(1);
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const job = async () => {
+            const browser = await puppeteer.connect({
+                browserWSEndpoint: `ws://localhost:3000/edge?token=browserless`,
+            });
+            await sleep(100);
+            return browser.disconnect();
+        };
+        await Promise.all([job(), job()]);
+        await sleep(100);
+        const results = metrics.get();
+        expect(results.successful).to.equal(2);
+        expect(results.rejected).to.equal(0);
+        expect(results.queued).to.equal(1);
+    });
+    it('fails requests', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        config.setConcurrent(0);
+        config.setQueued(0);
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        return puppeteer
+            .connect({
+            browserWSEndpoint: `ws://localhost:3000/edge?token=browserless`,
+        })
+            .catch((error) => {
+            const results = metrics.get();
+            expect(results.successful).to.equal(0);
+            expect(results.rejected).to.equal(1);
+            expect(results.queued).to.equal(0);
+            expect(error.message).to.contain.oneOf([`400`, `429`]);
+        });
+    });
+    it('fails requests without tokens', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        return puppeteer
+            .connect({ browserWSEndpoint: `ws://localhost:3000/edge` })
+            .catch((error) => {
+            const results = metrics.get();
+            expect(results.successful).to.equal(0);
+            expect(results.rejected).to.equal(0);
+            expect(results.queued).to.equal(0);
+            expect(error.message).to.contain(`401`);
+        });
+    });
+    it('runs playwright', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const browser = await chromium.connect(`ws://localhost:3000/edge/playwright?token=browserless`);
+        await browser.close();
+        await sleep(100);
+        const results = metrics.get();
+        expect(results.timedout).to.equal(0);
+        expect(results.successful).to.equal(1);
+        expect(results.rejected).to.equal(0);
+        expect(results.queued).to.equal(0);
+    });
+    it('runs playwright over CDP', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const browser = await chromium.connectOverCDP(`ws://localhost:3000/edge?token=browserless`);
+        await browser.close();
+        await sleep(100);
+        const results = metrics.get();
+        expect(results.timedout).to.equal(0);
+        expect(results.successful).to.equal(1);
+        expect(results.rejected).to.equal(0);
+        expect(results.queued).to.equal(0);
+    });
+    it('runs multiple versions of playwright', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const pwVersions = Object.keys(config.getPwVersions());
+        for (const version of pwVersions) {
+            const pw = await import(config.getPwVersions()[version]);
+            const browser = await pw.chromium.connect(`ws://localhost:3000/edge/playwright?token=browserless`);
+            await browser.close();
+            await sleep(100);
+        }
+        const results = metrics.get();
+        expect(results.timedout).to.equal(0);
+        expect(results.successful).to.equal(pwVersions.length);
+        expect(results.rejected).to.equal(0);
+        expect(results.queued).to.equal(0);
+    });
+    it('rejects playwright without tokens', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        await chromium.connect(`ws://localhost:3000/edge/playwright`).catch((e) => {
+            const results = metrics.get();
+            expect(e.message).to.include('Bad or missing authentication');
+            expect(results.timedout).to.equal(0);
+            expect(results.successful).to.equal(0);
+            expect(results.unauthorized).to.equal(1);
+            expect(results.queued).to.equal(0);
+        });
+    });
+    it('allows requests without token when auth token is not set', async () => {
+        await start();
+        const browser = await puppeteer.connect({
+            browserWSEndpoint: `ws://localhost:3000/edge`,
+        });
+        await browser.disconnect();
+    });
+});

package/build/routes/edge/ws/browser.d.ts

@@ -0,0 +1,7 @@
+import { EdgeCDP } from '@browserless.io/browserless';
+import { default as Browser, QuerySchema } from '../../../shared/browser.ws.js';
+export default class EdgeBrowserWebSocketRoute extends Browser {
+    name: string;
+    browser: typeof EdgeCDP;
+}
+export { QuerySchema };

package/build/routes/edge/ws/browser.js

@@ -0,0 +1,6 @@
+import { BrowserlessRoutes, EdgeCDP } from '@browserless.io/browserless';
+import { default as Browser } from '../../../shared/browser.ws.js';
+export default class EdgeBrowserWebSocketRoute extends Browser {
+    name = BrowserlessRoutes.EdgeBrowserWebSocketRoute;
+    browser = EdgeCDP;
+}

package/build/routes/edge/ws/browser.query.json

@@ -0,0 +1,120 @@
+{
+  "type": "object",
+  "properties": {
+    "launch": {
+      "description": "Launch options, which can be either an object\nof puppeteer.launch options or playwright.launchServer\noptions, depending on the API. Must be either JSON\nobject, or a base64-encoded JSON object.",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/CDPLaunchOptions"
+        },
+        {
+          "type": "string"
+        }
+      ]
+    },
+    "blockAds": {
+      "description": "Whether or nor to load ad-blocking extensions for the session.\nThis currently uses uBlock Origin and may cause certain sites\nto not load properly.",
+      "type": "boolean"
+    },
+    "timeout": {
+      "description": "Override the system-level timeout for this request.\nAccepts a value in milliseconds.",
+      "type": "number"
+    },
+    "token": {
+      "description": "The authorization token",
+      "type": "string"
+    },
+    "trackingId": {
+      "description": "Custom session identifier",
+      "type": "string"
+    }
+  },
+  "additionalProperties": false,
+  "definitions": {
+    "CDPLaunchOptions": {
+      "type": "object",
+      "properties": {
+        "args": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "defaultViewport": {
+          "type": "object",
+          "properties": {
+            "deviceScaleFactor": {
+              "type": "number"
+            },
+            "hasTouch": {
+              "type": "boolean"
+            },
+            "height": {
+              "type": "number"
+            },
+            "isLandscape": {
+              "type": "boolean"
+            },
+            "isMobile": {
+              "type": "boolean"
+            },
+            "width": {
+              "type": "number"
+            }
+          },
+          "additionalProperties": false,
+          "required": [
+            "height",
+            "width"
+          ]
+        },
+        "devtools": {
+          "type": "boolean"
+        },
+        "dumpio": {
+          "type": "boolean"
+        },
+        "headless": {
+          "enum": [
+            false,
+            "shell",
+            true
+          ]
+        },
+        "ignoreDefaultArgs": {
+          "anyOf": [
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            {
+              "type": "boolean"
+            }
+          ]
+        },
+        "ignoreHTTPSErrors": {
+          "type": "boolean"
+        },
+        "slowMo": {
+          "type": "number"
+        },
+        "stealth": {
+          "type": "boolean"
+        },
+        "timeout": {
+          "type": "number"
+        },
+        "userDataDir": {
+          "type": "string"
+        },
+        "waitForInitialPage": {
+          "type": "boolean"
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/build/routes/edge/ws/cdp.d.ts

@@ -0,0 +1,8 @@
+import { EdgeCDP, WebsocketRoutes } from '@browserless.io/browserless';
+import { default as ChromiumWebSocketRoute, QuerySchema } from '../../../shared/chromium.ws.js';
+export default class EdgeCDPWebSocketRoute extends ChromiumWebSocketRoute {
+    name: string;
+    browser: typeof EdgeCDP;
+    path: WebsocketRoutes[];
+}
+export { QuerySchema };

package/build/routes/edge/ws/cdp.js

@@ -0,0 +1,7 @@
+import { BrowserlessRoutes, EdgeCDP, WebsocketRoutes, } from '@browserless.io/browserless';
+import { default as ChromiumWebSocketRoute, } from '../../../shared/chromium.ws.js';
+export default class EdgeCDPWebSocketRoute extends ChromiumWebSocketRoute {
+    name = BrowserlessRoutes.EdgeCDPWebSocketRoute;
+    browser = EdgeCDP;
+    path = [WebsocketRoutes.edge];
+}

package/build/routes/edge/ws/cdp.query.json

@@ -0,0 +1,120 @@
+{
+  "type": "object",
+  "properties": {
+    "launch": {
+      "description": "Launch options, which can be either an object\nof puppeteer.launch options or playwright.launchServer\noptions, depending on the API. Must be either JSON\nobject, or a base64-encoded JSON object.",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/CDPLaunchOptions"
+        },
+        {
+          "type": "string"
+        }
+      ]
+    },
+    "blockAds": {
+      "description": "Whether or nor to load ad-blocking extensions for the session.\nThis currently uses uBlock Origin and may cause certain sites\nto not load properly.",
+      "type": "boolean"
+    },
+    "timeout": {
+      "description": "Override the system-level timeout for this request.\nAccepts a value in milliseconds.",
+      "type": "number"
+    },
+    "token": {
+      "description": "The authorization token",
+      "type": "string"
+    },
+    "trackingId": {
+      "description": "Custom session identifier",
+      "type": "string"
+    }
+  },
+  "additionalProperties": false,
+  "definitions": {
+    "CDPLaunchOptions": {
+      "type": "object",
+      "properties": {
+        "args": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "defaultViewport": {
+          "type": "object",
+          "properties": {
+            "deviceScaleFactor": {
+              "type": "number"
+            },
+            "hasTouch": {
+              "type": "boolean"
+            },
+            "height": {
+              "type": "number"
+            },
+            "isLandscape": {
+              "type": "boolean"
+            },
+            "isMobile": {
+              "type": "boolean"
+            },
+            "width": {
+              "type": "number"
+            }
+          },
+          "additionalProperties": false,
+          "required": [
+            "height",
+            "width"
+          ]
+        },
+        "devtools": {
+          "type": "boolean"
+        },
+        "dumpio": {
+          "type": "boolean"
+        },
+        "headless": {
+          "enum": [
+            false,
+            "shell",
+            true
+          ]
+        },
+        "ignoreDefaultArgs": {
+          "anyOf": [
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            {
+              "type": "boolean"
+            }
+          ]
+        },
+        "ignoreHTTPSErrors": {
+          "type": "boolean"
+        },
+        "slowMo": {
+          "type": "number"
+        },
+        "stealth": {
+          "type": "boolean"
+        },
+        "timeout": {
+          "type": "number"
+        },
+        "userDataDir": {
+          "type": "string"
+        },
+        "waitForInitialPage": {
+          "type": "boolean"
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/build/routes/edge/ws/page.d.ts

@@ -0,0 +1,8 @@
+import { EdgeCDP } from '@browserless.io/browserless';
+import { default as Page, QuerySchema } from '../../../shared/page.ws.js';
+export default class EdgePageWebSocketRoute extends Page {
+    name: string;
+    browser: typeof EdgeCDP;
+    auth: boolean;
+}
+export { QuerySchema };

package/build/routes/edge/ws/page.js

@@ -0,0 +1,7 @@
+import { BrowserlessRoutes, EdgeCDP } from '@browserless.io/browserless';
+import { default as Page } from '../../../shared/page.ws.js';
+export default class EdgePageWebSocketRoute extends Page {
+    name = BrowserlessRoutes.EdgePageWebSocketRoute;
+    browser = EdgeCDP;
+    auth = false;
+}