@mablhq/playwright-tools 2.49.1

package/api/mablApiClientFactory.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MablApiClientFactory = void 0;
+const mablApiClient_1 = require("./mablApiClient");
+const authenticationProvider_1 = require("../providers/authenticationProvider");
+const cliConfigProvider_1 = require("../providers/cliConfigProvider");
+const types_1 = require("./types");
+const chalk_1 = __importDefault(require("chalk"));
+class MablApiClientFactory {
+    static createApiClientFromOptionalApiKey(apiKey) {
+        if (apiKey) {
+            return MablApiClientFactory.createApiClient({
+                authType: types_1.AuthType.ApiKey,
+                token: apiKey,
+            });
+        }
+        return MablApiClientFactory.createApiClient();
+    }
+    static createApiClientFromApiKey(apiKey, apiUrl) {
+        return MablApiClientFactory.createApiClient({
+            apiUrl,
+            authType: types_1.AuthType.ApiKey,
+            token: apiKey,
+        });
+    }
+    static createApiClientFromBearerToken(bearerToken) {
+        return MablApiClientFactory.createApiClient({
+            authType: types_1.AuthType.Bearer,
+            token: bearerToken,
+        });
+    }
+    static async createApiClient(opts) {
+        const { mabl } = (await cliConfigProvider_1.CliConfigProvider.getCliConfig()).http;
+        const optsFromCliHttpConfig = {
+            proxyUrl: mabl.proxyHost,
+            sslVerify: mabl.sslVerify,
+            proxyType: mabl.proxyType,
+        };
+        if (opts) {
+            return new mablApiClient_1.MablApiClient({
+                ...optsFromCliHttpConfig,
+                ...opts,
+            });
+        }
+        const authProvider = new authenticationProvider_1.AuthenticationProvider();
+        const authConfig = await authProvider.getAuthConfigWithAutoRenew();
+        if (authConfig === null || authConfig === void 0 ? void 0 : authConfig.accessToken) {
+            return new mablApiClient_1.MablApiClient({
+                ...optsFromCliHttpConfig,
+                authType: authConfig.authType,
+                token: authConfig.accessToken,
+            });
+        }
+        throw new Error('Please supply an API key or authenticate the mabl CLI tool');
+    }
+    static async createUserApiClient() {
+        if ((await authenticationProvider_1.AuthenticationProvider.getAuthType()) !== types_1.AuthType.Bearer) {
+            MablApiClientFactory.throwUserAuthTypeError();
+        }
+        return MablApiClientFactory.createApiClient();
+    }
+    static async createApiClientForAccessToken(accessToken) {
+        const httpConfig = (await cliConfigProvider_1.CliConfigProvider.getCliConfig()).http.mabl;
+        return new mablApiClient_1.MablApiClient({
+            authType: types_1.AuthType.Bearer,
+            token: accessToken,
+            proxyUrl: httpConfig.proxyHost,
+            sslVerify: httpConfig.sslVerify,
+            proxyType: httpConfig.proxyType,
+        });
+    }
+    static throwUserAuthTypeError() {
+        throw new Error(chalk_1.default.red(`Auth with user credentials required. Please run ${chalk_1.default.magenta('mabl auth login')} to log in with your mabl account`));
+    }
+}
+exports.MablApiClientFactory = MablApiClientFactory;

package/api/types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthType = void 0;
+var AuthType;
+(function (AuthType) {
+    AuthType[AuthType["Bearer"] = 0] = "Bearer";
+    AuthType[AuthType["ApiKey"] = 1] = "ApiKey";
+    AuthType[AuthType["None"] = 2] = "None";
+    AuthType[AuthType["Basic"] = 3] = "Basic";
+})(AuthType || (exports.AuthType = AuthType = {}));

package/auth/AuthClient.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthClient = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const query_string_1 = __importDefault(require("query-string"));
+const env_1 = require("../env/env");
+class AuthClient {
+    constructor() { }
+    generateCodeChallenge() {
+        const codeVerifier = this.base64URLEncode(crypto_1.default.randomBytes(32));
+        const codeChallenge = this.base64URLEncode(this.sha256(codeVerifier));
+        return { codeChallenge, codeVerifier };
+    }
+    base64URLEncode(input) {
+        return Buffer.from(input)
+            .toString('base64')
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=/g, '');
+    }
+    sha256(input) {
+        return crypto_1.default.createHash('sha256').update(input).digest();
+    }
+    buildAuthorizationUrl(codeChallenge, redirectUri, idpType) {
+        const loginQueryString = query_string_1.default.stringify({
+            codeChallenge,
+            redirectUri,
+            includeRefreshToken: true,
+        });
+        return idpType
+            ? `${env_1.BASE_APP_URL}/authorize/social/${idpType.toLowerCase()}?${loginQueryString}`
+            : `${env_1.BASE_APP_URL}/authorize?${loginQueryString}`;
+    }
+}
+exports.AuthClient = AuthClient;

package/auth/OktaClient.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OktaClient = void 0;
+const env_1 = require("../env/env");
+const axios_1 = __importDefault(require("axios"));
+const authenticationProvider_1 = require("../providers/authenticationProvider");
+const types_1 = require("../providers/types");
+const types_2 = require("../api/types");
+const AuthClient_1 = require("./AuthClient");
+const loggingProvider_1 = require("../providers/logging/loggingProvider");
+const queryString = require('query-string');
+class OktaClient extends AuthClient_1.AuthClient {
+    constructor(httpClient) {
+        super();
+        this.httpClient = httpClient;
+    }
+    async validateAuthCode(code, codeVerifier, redirectUri) {
+        return this.getBearerAuthInfo(queryString.stringify({
+            grant_type: 'authorization_code',
+            client_id: env_1.OKTA_CLIENT_ID,
+            code_verifier: codeVerifier,
+            code,
+            redirect_uri: redirectUri,
+        }));
+    }
+    async getRefreshTokenExpiration(refreshToken) {
+        if (!refreshToken) {
+            return;
+        }
+        const url = `${env_1.OKTA_URL}/oauth2/v1/introspect`;
+        const requestOptions = {
+            method: 'POST',
+            headers: { 'content-type': 'application/x-www-form-urlencoded' },
+        };
+        const data = queryString.stringify({
+            client_id: env_1.OKTA_CLIENT_ID,
+            token_type_hint: 'refresh_token',
+            token: refreshToken,
+        });
+        try {
+            const response = await this.httpClient.post(url, data, requestOptions);
+            return response.data.exp;
+        }
+        catch (error) {
+            loggingProvider_1.logger.info(`Couldn't get refresh token expiration. Will re-use previous lifetime.`);
+            return;
+        }
+    }
+    async getBearerAuthInfo(queryStringData) {
+        const url = `${env_1.OKTA_URL}/oauth2/default/v1/token`;
+        const requestOptions = {
+            method: 'POST',
+            headers: { 'content-type': 'application/x-www-form-urlencoded' },
+        };
+        const response = await this.httpClient.post(url, queryStringData, requestOptions);
+        const authInfo = response.data;
+        const refreshTokenExpiresAt = await this.getRefreshTokenExpiration(authInfo.refresh_token);
+        authInfo.auth_provider = types_1.AuthProviderType.Okta;
+        authInfo.auth_type = types_2.AuthType.Bearer;
+        authInfo.refresh_token_expires_at = refreshTokenExpiresAt;
+        return authInfo;
+    }
+    exchangeRefreshTokenForAccessToken(refreshToken) {
+        var _a;
+        try {
+            return this.getBearerAuthInfo(queryString.stringify({
+                grant_type: 'refresh_token',
+                client_id: env_1.OKTA_CLIENT_ID,
+                refresh_token: refreshToken,
+                scope: 'openid profile email offline_access',
+            }));
+        }
+        catch (error) {
+            if (!axios_1.default.isAxiosError(error)) {
+                throw error;
+            }
+            const data = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data;
+            if (!(0, authenticationProvider_1.isOidcError)(data)) {
+                throw error;
+            }
+            return Promise.resolve({
+                auth_provider: types_1.AuthProviderType.Okta,
+                auth_type: types_2.AuthType.Bearer,
+                access_token: '',
+                id_token: '',
+                token_type: '',
+                expires_in: 0,
+                error: data.error,
+                error_description: data.error_description,
+            });
+        }
+    }
+}
+exports.OktaClient = OktaClient;

package/browserEngines/browserEngine.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTempBrowserPrefDirectory = exports.BROWSER_PREFERENCES_DIRECTORY_SUFFIX = void 0;
+const tmp = require('tmp-promise');
+const path = __importStar(require("path"));
+const env_1 = require("../env/env");
+const fs = __importStar(require("fs-extra"));
+exports.BROWSER_PREFERENCES_DIRECTORY_SUFFIX = 'MablBrowserPreferences';
+function getTempBrowserPrefDirectory(browserName = 'chrome') {
+    const tempDir = tmp.dirSync({
+        mode: 0o777,
+        prefix: `${env_1.CONF_FILE_PROJECT_NAME}-`,
+    });
+    const preferencesPath = path.normalize(`${tempDir.name}/${browserName}${exports.BROWSER_PREFERENCES_DIRECTORY_SUFFIX}`);
+    fs.ensureDirSync(preferencesPath, 0o777);
+    return preferencesPath;
+}
+exports.getTempBrowserPrefDirectory = getTempBrowserPrefDirectory;

package/browserEngines/browserEngines.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultBrowserEngine = exports.BrowserTypeToBrowserEngine = void 0;
+const browserTypes_1 = require("../commands/browserTypes");
+const chromiumBrowserEngine_1 = require("./chromiumBrowserEngine");
+const firefoxBrowserEngine_1 = require("./firefoxBrowserEngine");
+const webkitBrowerEngine_1 = require("./webkitBrowerEngine");
+exports.BrowserTypeToBrowserEngine = {
+    [browserTypes_1.BrowserType.Chrome]: new chromiumBrowserEngine_1.ChromiumBrowserEngine(),
+    [browserTypes_1.BrowserType.Edge]: new chromiumBrowserEngine_1.ChromiumBrowserEngine(),
+    [browserTypes_1.BrowserType.Firefox]: new firefoxBrowserEngine_1.FirefoxBrowserEngine(),
+    [browserTypes_1.BrowserType.Webkit]: new webkitBrowerEngine_1.WebkitBrowserEngine(),
+};
+exports.DefaultBrowserEngine = exports.BrowserTypeToBrowserEngine[browserTypes_1.BrowserType.Chrome];

package/browserEngines/chromiumBrowserEngine.js

@@ -0,0 +1,177 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChromiumBrowserEngine = void 0;
+const path_1 = __importDefault(require("path"));
+const async_retry_1 = __importDefault(require("async-retry"));
+const fs = __importStar(require("fs-extra"));
+const mobileEmulationUtil_1 = require("../commands/tests/mobileEmulationUtil");
+const resourceUtil_1 = require("../util/resourceUtil");
+const browserEngine_1 = require("./browserEngine");
+const cliConfigProvider_1 = require("../providers/cliConfigProvider");
+const configKeys_1 = require("../commands/config/config_cmds/configKeys");
+const loggingProvider_1 = require("../providers/logging/loggingProvider");
+const chromeFinder = require('chrome-launcher/dist/chrome-finder');
+const launchUtils = require('chrome-launcher/dist/utils');
+const baseExecutionEngineLaunchArgs = [
+    '--unlimited-storage',
+    '--disable-dev-shm-usage',
+    '--enable-print-preview-register-promos',
+    '--kiosk-printing',
+    '--disable-infobars',
+    '--enable-logging',
+    '--v=0',
+    '--enable-features=NetworkService,NetworkServiceInProcess',
+    '--disable-component-update',
+];
+const ExecutionEngineFakeAudioFilePath = '/opt/media/mabl_test_audio.wav';
+const ExecutionEngineFakeVideoFilePath = '/opt/media/mabl_test_pattern.y4m';
+class ChromiumBrowserEngine {
+    name() {
+        return 'chromium';
+    }
+    getBrowserLaunchOptions(options) {
+        const commandLineArgs = [];
+        const ignoreCommandLineDefaultArgs = [];
+        const disableFeaturesFlags = [];
+        if (options.containerTesting) {
+            commandLineArgs.push('--no-sandbox');
+        }
+        if (options.disableIsolation) {
+            disableFeaturesFlags.push('IsolateOrigins');
+            disableFeaturesFlags.push('site-per-process');
+        }
+        if (disableFeaturesFlags.length) {
+            commandLineArgs.push(`--disable-features=${disableFeaturesFlags.join(',')}`);
+        }
+        if (options.autoOpenDevtoolsForTabs) {
+            commandLineArgs.push('--auto-open-devtools-for-tabs');
+        }
+        const fakeMicrophoneMedia = (0, resourceUtil_1.findResource)('media/mabl_test_audio.wav', options.resourcesDirectoryOverride);
+        const fakeWebcamMedia = (0, resourceUtil_1.findResource)('media/mabl_test_pattern.y4m', options.resourcesDirectoryOverride);
+        const defaultDeviceDescriptor = (0, mobileEmulationUtil_1.getDeviceDescriptorForEmulation)(options.emulationConfig);
+        this.addBasicLaunchArgs(commandLineArgs, options.browserWidth, options.browserHeight, fakeMicrophoneMedia, fakeWebcamMedia, options.ignoreCertificateErrors, defaultDeviceDescriptor);
+        if (options.enableExtensions) {
+            ignoreCommandLineDefaultArgs.push('--disable-extensions');
+        }
+        return {
+            commandLineArgs,
+            defaultDeviceDescriptor,
+            ignoreCommandLineDefaultArgs,
+            permissions: ['geolocation', 'notifications'],
+        };
+    }
+    getExecutionEngineBrowserLaunchOptions(options, proxyInfo) {
+        const commandLineArgs = [...baseExecutionEngineLaunchArgs];
+        if (proxyInfo.pacProxy) {
+            commandLineArgs.push(`--proxy-pac-url=${proxyInfo.pacProxy}`);
+        }
+        else if (proxyInfo.socksProxy) {
+            commandLineArgs.push(`--proxy-server=socks=${proxyInfo.socksProxy}`);
+        }
+        else {
+            throw new Error('no proxy provided for cloud run');
+        }
+        const defaultDeviceDescriptor = (0, mobileEmulationUtil_1.getDeviceDescriptorForEmulation)(options.emulationConfig);
+        this.addBasicLaunchArgs(commandLineArgs, options.browserWidth, options.browserHeight, ExecutionEngineFakeAudioFilePath, ExecutionEngineFakeVideoFilePath, true, defaultDeviceDescriptor);
+        loggingProvider_1.logger.debug(`launchArgs: ${JSON.stringify(commandLineArgs)}`);
+        return { commandLineArgs, defaultDeviceDescriptor };
+    }
+    addBasicLaunchArgs(launchArgs, browserWidth, browserHeight, fakeMicrophoneMediaPath, fakeWebcamMediaPath, ignoreCertificateErrors, deviceDescriptor) {
+        var _a, _b;
+        launchArgs.push(`--window-size=${(_a = deviceDescriptor === null || deviceDescriptor === void 0 ? void 0 : deviceDescriptor.width) !== null && _a !== void 0 ? _a : browserWidth},${(_b = deviceDescriptor === null || deviceDescriptor === void 0 ? void 0 : deviceDescriptor.height) !== null && _b !== void 0 ? _b : browserHeight}`);
+        launchArgs.push('--use-fake-ui-for-media-stream');
+        launchArgs.push('--use-fake-device-for-media-stream');
+        launchArgs.push(`--use-file-for-fake-audio-capture=${fakeMicrophoneMediaPath}`);
+        launchArgs.push(`--use-file-for-fake-video-capture=${fakeWebcamMediaPath}`);
+        if (ignoreCertificateErrors) {
+            launchArgs.push('--ignore-certificate-errors');
+        }
+    }
+    prepareBrowserPreferencesDirectory(windowPlacement) {
+        return (0, async_retry_1.default)(() => {
+            const tempBrowserPreferencesDirectory = (0, browserEngine_1.getTempBrowserPrefDirectory)();
+            fs.ensureDirSync(path_1.default.normalize(`${tempBrowserPreferencesDirectory}/Default`));
+            const prefFilePath = path_1.default.normalize(`${tempBrowserPreferencesDirectory}/Default/Preferences`);
+            fs.writeFileSync(prefFilePath, JSON.stringify(this.generateChromiumPreferencesFile(windowPlacement), null, 3));
+            fs.chmodSync(path_1.default.normalize(`${tempBrowserPreferencesDirectory}/Default`), 0o777);
+            fs.chmodSync(prefFilePath, 0o777);
+            return tempBrowserPreferencesDirectory;
+        }, {
+            retries: 5,
+        });
+    }
+    generateChromiumPreferencesFile(windowPlacement, _proxyInfo) {
+        const preferences = {
+            download: {
+                open_pdf_in_system_reader: true,
+                prompt_for_download: false,
+            },
+            profile: {
+                avatar_index: 5,
+                name: 'mabl',
+            },
+            plugins: {
+                always_open_pdf_externally: true,
+            },
+        };
+        if (windowPlacement) {
+            preferences.browser = {
+                window_placement: {
+                    always_on_top: false,
+                    ...windowPlacement,
+                },
+            };
+        }
+        return preferences;
+    }
+    async findBrowserExecutable() {
+        const existingLocation = await cliConfigProvider_1.CliConfigProvider.getConfigProperty(configKeys_1.configKeys.browserPath);
+        if (typeof existingLocation === 'string' &&
+            existingLocation &&
+            fs.existsSync(existingLocation)) {
+            return existingLocation;
+        }
+        const chromePath = this.searchForChrome();
+        await cliConfigProvider_1.CliConfigProvider.setConfigProperty(configKeys_1.configKeys.browserPath, chromePath);
+        return chromePath;
+    }
+    searchForChrome() {
+        const chromes = chromeFinder[launchUtils.getPlatform()]();
+        return chromes.filter((chrome) => {
+            chrome = chrome.toLowerCase();
+            return !(chrome.includes('canary') ||
+                chrome.includes('dev') ||
+                chrome.includes('beta'));
+        })[0];
+    }
+    getProxySpec(_proxyInfo) {
+        return;
+    }
+}
+exports.ChromiumBrowserEngine = ChromiumBrowserEngine;

package/browserEngines/firefoxBrowserEngine.js

@@ -0,0 +1,134 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirefoxBrowserEngine = void 0;
+const mobileEmulationUtil_1 = require("../commands/tests/mobileEmulationUtil");
+const path_1 = __importDefault(require("path"));
+const fs = __importStar(require("fs-extra"));
+const browserEngine_1 = require("./browserEngine");
+const async_retry_1 = __importDefault(require("async-retry"));
+class FirefoxBrowserEngine {
+    name() {
+        return 'firefox';
+    }
+    getBrowserLaunchOptions(options) {
+        return {
+            commandLineArgs: [],
+            ignoreCommandLineDefaultArgs: [],
+            defaultDeviceDescriptor: (0, mobileEmulationUtil_1.getDeviceDescriptorForEmulation)(options.emulationConfig),
+            permissions: ['geolocation', 'notifications'],
+        };
+    }
+    getExecutionEngineBrowserLaunchOptions(options, _proxyInfo) {
+        return {
+            commandLineArgs: [],
+            defaultDeviceDescriptor: (0, mobileEmulationUtil_1.getDeviceDescriptorForEmulation)(options.emulationConfig),
+        };
+    }
+    prepareBrowserPreferencesDirectory(_windowPlacement, proxyInfo) {
+        const customPreferences = {};
+        if (proxyInfo === null || proxyInfo === void 0 ? void 0 : proxyInfo.pacProxy) {
+            customPreferences['network.proxy.autoconfig_url'] = proxyInfo.pacProxy;
+            customPreferences['network.proxy.type'] = 2;
+        }
+        else if (proxyInfo === null || proxyInfo === void 0 ? void 0 : proxyInfo.socksProxy) {
+            const socksUrl = new URL(proxyInfo.socksProxy);
+            customPreferences['network.proxy.socks'] = socksUrl.hostname;
+            customPreferences['network.proxy.socks_port'] = Number.parseInt(socksUrl.port);
+            customPreferences['network.proxy.socks_version'] = 5;
+            customPreferences['network.proxy.type'] = 1;
+        }
+        return (0, async_retry_1.default)(() => {
+            const preferenceFileName = 'user.js';
+            const tempBrowserPreferencesDirectory = (0, browserEngine_1.getTempBrowserPrefDirectory)(this.name());
+            const prefFilePath = path_1.default.normalize(`${tempBrowserPreferencesDirectory}/${preferenceFileName}`);
+            fs.writeFileSync(prefFilePath, this.generatePreferencesInfo(customPreferences));
+            return tempBrowserPreferencesDirectory;
+        }, {
+            retries: 5,
+        });
+    }
+    findBrowserExecutable() {
+        return Promise.resolve('');
+    }
+    generatePreferencesInfo(customPrefs = {}) {
+        const lines = [];
+        const prefs = { ...this.getFirefoxUserPrefs(), ...customPrefs };
+        for (const [name, value] of Object.entries(prefs)) {
+            lines.push(`user_pref(${JSON.stringify(name)}, ${JSON.stringify(value)});`);
+        }
+        return lines.join('\n');
+    }
+    getFirefoxUserPrefs() {
+        return {
+            'xpinstall.signatures.required': false,
+            'browser.preferences.defaultPerformanceSettings.enabled': false,
+            'layers.acceleration.disabled': true,
+            'browser.cache.memory.enable': false,
+            'browser.cache.offline.enable': false,
+            'browser.cache.disk.capacity': 262144,
+            'browser.sessionhistory.max_entries': 1,
+            'browser.sessionhistory.max_total_viewers': 0,
+            'media.memory_caches_combined_limit_kb': 65536,
+            'media.memory_caches_combined_limit_pc_sysmem': 1,
+            'pdfjs.enabledCache.state': false,
+            'plugin.disable_full_page_plugin_for_types': 'application/pdf,application/vnd.adobe.xfdf,application/vnd.adobe.xdp+xml',
+            'browser.helperApps.alwaysAsk.force': true,
+            'browser.helperApps.neverAsk.saveToDisk': [
+                'application/csv',
+                'application/force-download',
+                'application/gzip',
+                'application/pdf',
+                'application/vnd.ms-excel',
+                'application/msword',
+                'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+                'application/x-7z-compressed',
+                'application/x-bzip',
+                'application/x-bzip2',
+                'application/x-gzip',
+                'application/zip',
+                'binary/octet-stream',
+                'application/octet-stream',
+                'image/png',
+                'image/jpeg',
+                'image/gif',
+                'text/csv',
+                'text/comma-separated-values',
+                'text/plain',
+            ].join(','),
+            'media.navigator.permission.disabled': true,
+            'media.navigator.streams.fake': true,
+            'dom.webnotifications.enabled': true,
+            'network.proxy.socks_remote_dns': true,
+        };
+    }
+    getProxySpec(_proxyInfo) {
+        return;
+    }
+}
+exports.FirefoxBrowserEngine = FirefoxBrowserEngine;

package/browserEngines/unsupportedBrowserEngine.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedBrowserEngine = void 0;
+const mobileEmulationUtil_1 = require("../commands/tests/mobileEmulationUtil");
+class UnsupportedBrowserEngine {
+    name() {
+        throw new Error('Unsupported browser engine');
+    }
+    getBrowserLaunchOptions(options) {
+        return {
+            commandLineArgs: [],
+            ignoreCommandLineDefaultArgs: [],
+            defaultDeviceDescriptor: (0, mobileEmulationUtil_1.getDeviceDescriptorForEmulation)(options.emulationConfig),
+        };
+    }
+    getExecutionEngineBrowserLaunchOptions(_options, _proxyInfo) {
+        throw new Error('Unsupported browser engine');
+    }
+    prepareBrowserPreferencesDirectory(_windowPlacement) {
+        throw new Error('Unsupported browser engine');
+    }
+    findBrowserExecutable() {
+        throw new Error('Unsupported browser engine');
+    }
+    getProxySpec(_proxyInfo) {
+        throw new Error('Unsupported browser engine');
+    }
+}
+exports.UnsupportedBrowserEngine = UnsupportedBrowserEngine;

package/browserEngines/webkitBrowerEngine.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebkitBrowserEngine = void 0;
+const mobileEmulationUtil_1 = require("../commands/tests/mobileEmulationUtil");
+const browserEngine_1 = require("./browserEngine");
+const async_retry_1 = __importDefault(require("async-retry"));
+class WebkitBrowserEngine {
+    name() {
+        return 'webkit';
+    }
+    getBrowserLaunchOptions(options) {
+        return {
+            commandLineArgs: [],
+            ignoreCommandLineDefaultArgs: [],
+            defaultDeviceDescriptor: (0, mobileEmulationUtil_1.getDeviceDescriptorForEmulation)(options.emulationConfig),
+        };
+    }
+    getExecutionEngineBrowserLaunchOptions(options, _proxyInfo) {
+        return {
+            commandLineArgs: [],
+            defaultDeviceDescriptor: (0, mobileEmulationUtil_1.getDeviceDescriptorForEmulation)(options.emulationConfig),
+        };
+    }
+    prepareBrowserPreferencesDirectory(_windowPlacement) {
+        return (0, async_retry_1.default)(() => {
+            const tempBrowserPreferencesDirectory = (0, browserEngine_1.getTempBrowserPrefDirectory)(this.name());
+            return tempBrowserPreferencesDirectory;
+        }, {
+            retries: 5,
+        });
+    }
+    findBrowserExecutable() {
+        return Promise.resolve('');
+    }
+    getProxySpec(proxyInfo) {
+        const { httpProxy, socksProxy, excludeFromProxy } = proxyInfo;
+        const server = httpProxy !== null && httpProxy !== void 0 ? httpProxy : socksProxy;
+        if (!server) {
+            throw new Error('no proxy provided for cloud run');
+        }
+        const bypass = (excludeFromProxy === null || excludeFromProxy === void 0 ? void 0 : excludeFromProxy.length)
+            ? excludeFromProxy.join(',')
+            : undefined;
+        return { server, bypass };
+    }
+}
+exports.WebkitBrowserEngine = WebkitBrowserEngine;