@wdio/browserstack-service 7.34.0 → 7.35.0

package/build/Percy/Percy-Handler.d.ts

@@ -0,0 +1,34 @@
+import type { Capabilities } from '@wdio/types';
+import type { BeforeCommandArgs, AfterCommandArgs } from '@wdio/reporter';
+import type { Browser, MultiRemoteBrowser } from 'webdriverio';
+declare class _PercyHandler {
+    private _percyAutoCaptureMode;
+    private _browser;
+    private _capabilities;
+    private _framework?;
+    private _testMetadata;
+    private _sessionName?;
+    private _isAppAutomate?;
+    private _isPercyCleanupProcessingUnderway?;
+    private _percyScreenshotCounter;
+    private _percyDeferredScreenshots;
+    private _percyScreenshotInterval;
+    private _percyCaptureMap?;
+    constructor(_percyAutoCaptureMode: string | undefined, _browser: Browser<'async'> | MultiRemoteBrowser<'async'>, _capabilities: Capabilities.RemoteCapability, isAppAutomate?: boolean, _framework?: string | undefined);
+    _setSessionName(name: string): void;
+    teardown(): Promise<void>;
+    percyAutoCapture(eventName: string | null, sessionName: string | null): Promise<void>;
+    before(): Promise<void>;
+    deferCapture(sessionName: string, eventName: string | null): void;
+    isDOMChangingCommand(args: BeforeCommandArgs): boolean;
+    cleanupDeferredScreenshots(): Promise<void>;
+    sleep(ms: number): Promise<unknown>;
+    browserBeforeCommand(args: BeforeCommandArgs): Promise<void>;
+    browserAfterCommand(args: BeforeCommandArgs & AfterCommandArgs): Promise<void>;
+    afterTest(): Promise<void>;
+    afterScenario(): Promise<void>;
+}
+declare const PercyHandler: typeof _PercyHandler;
+type PercyHandler = _PercyHandler;
+export default PercyHandler;
+//# sourceMappingURL=Percy-Handler.d.ts.map

package/build/Percy/Percy-Handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Percy-Handler.d.ts","sourceRoot":"","sources":["../../src/Percy/Percy-Handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACzE,OAAO,KAAK,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAY9D,cAAM,aAAa;IAWX,OAAO,CAAC,qBAAqB;IAC7B,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,aAAa;IAErB,OAAO,CAAC,UAAU,CAAC;IAdvB,OAAO,CAAC,aAAa,CAA6B;IAClD,OAAO,CAAC,YAAY,CAAC,CAAQ;IAC7B,OAAO,CAAC,cAAc,CAAC,CAAS;IAChC,OAAO,CAAC,iCAAiC,CAAC,CAAiB;IAC3D,OAAO,CAAC,uBAAuB,CAAS;IACxC,OAAO,CAAC,yBAAyB,CAAU;IAC3C,OAAO,CAAC,wBAAwB,CAAY;IAC5C,OAAO,CAAC,gBAAgB,CAAC,CAAiB;gBAG9B,qBAAqB,EAAE,MAAM,GAAG,SAAS,EACzC,QAAQ,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,kBAAkB,CAAC,OAAO,CAAC,EACxD,aAAa,EAAE,YAAY,CAAC,gBAAgB,EACpD,aAAa,CAAC,EAAE,OAAO,EACf,UAAU,CAAC,oBAAQ;IAQ/B,eAAe,CAAC,IAAI,EAAE,MAAM;IAItB,QAAQ;IAUR,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IAmBrE,MAAM;IAIZ,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAM1D,oBAAoB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO;IAuBhD,0BAA0B;IAS1B,KAAK,CAAC,EAAE,EAAE,MAAM;IAIhB,oBAAoB,CAAE,IAAI,EAAE,iBAAiB;IAmB7C,mBAAmB,CAAE,IAAI,EAAE,iBAAiB,GAAG,gBAAgB;IAwB/D,SAAS;IAMT,aAAa;CAKtB;AAGD,QAAA,MAAM,YAAY,EAAE,OAAO,aAAoD,CAAA;AAC/E,KAAK,YAAY,GAAG,aAAa,CAAA;AAEjC,eAAe,YAAY,CAAA"}

package/build/Percy/Percy-Handler.js

@@ -0,0 +1,187 @@
+"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 });
+const util_1 = require("../util");
+const PercyCaptureMap_1 = __importDefault(require("./PercyCaptureMap"));
+const PercySDK = __importStar(require("./PercySDK"));
+const PercyLogger_1 = require("./PercyLogger");
+const constants_1 = require("../constants");
+class _PercyHandler {
+    constructor(_percyAutoCaptureMode, _browser, _capabilities, isAppAutomate, _framework) {
+        this._percyAutoCaptureMode = _percyAutoCaptureMode;
+        this._browser = _browser;
+        this._capabilities = _capabilities;
+        this._framework = _framework;
+        this._testMetadata = {};
+        this._isPercyCleanupProcessingUnderway = false;
+        this._percyScreenshotCounter = 0;
+        this._percyDeferredScreenshots = [];
+        this._percyScreenshotInterval = null;
+        this._isAppAutomate = isAppAutomate;
+        if (!_percyAutoCaptureMode || !constants_1.CAPTURE_MODES.includes(_percyAutoCaptureMode)) {
+            this._percyAutoCaptureMode = 'auto';
+        }
+    }
+    _setSessionName(name) {
+        this._sessionName = name;
+    }
+    async teardown() {
+        await new Promise((resolve) => {
+            setInterval(() => {
+                if (this._percyScreenshotCounter === 0) {
+                    resolve();
+                }
+            }, 1000);
+        });
+    }
+    async percyAutoCapture(eventName, sessionName) {
+        var _a, _b, _c, _d;
+        try {
+            if (eventName) {
+                if (!sessionName) {
+                    /* Service doesn't wait for handling of browser commands so the below counter is used in teardown method to delay service exit */
+                    this._percyScreenshotCounter += 1;
+                }
+                (_a = this._percyCaptureMap) === null || _a === void 0 ? void 0 : _a.increment(sessionName ? sessionName : this._sessionName, eventName);
+                await (this._isAppAutomate ? PercySDK.screenshotApp((_b = this._percyCaptureMap) === null || _b === void 0 ? void 0 : _b.getName(sessionName ? sessionName : this._sessionName, eventName)) : PercySDK.screenshot(this._browser, (_c = this._percyCaptureMap) === null || _c === void 0 ? void 0 : _c.getName(sessionName ? sessionName : this._sessionName, eventName)));
+                this._percyScreenshotCounter -= 1;
+            }
+        }
+        catch (err) {
+            this._percyScreenshotCounter -= 1;
+            (_d = this._percyCaptureMap) === null || _d === void 0 ? void 0 : _d.decrement(sessionName ? sessionName : this._sessionName, eventName);
+            PercyLogger_1.PercyLogger.error(`Error while trying to auto capture Percy screenshot ${err}`);
+        }
+    }
+    async before() {
+        this._percyCaptureMap = new PercyCaptureMap_1.default();
+    }
+    deferCapture(sessionName, eventName) {
+        /* Service doesn't wait for handling of browser commands so the below counter is used in teardown method to delay service exit */
+        this._percyScreenshotCounter += 1;
+        this._percyDeferredScreenshots.push({ sessionName, eventName });
+    }
+    isDOMChangingCommand(args) {
+        var _a;
+        if (args.method === 'POST') {
+            if (constants_1.PERCY_DOM_CHANGING_COMMANDS_ENDPOINTS.includes(args.endpoint)) {
+                return true;
+            }
+            else if (args.endpoint.includes('/session/:sessionId/element') && args.endpoint.includes('click')) {
+                /* click element */
+                return true;
+            }
+            else if (args.endpoint.includes('/session/:sessionId/element') && args.endpoint.includes('clear')) {
+                /* clear element */
+                return true;
+            }
+            else if (args.endpoint.includes('/session/:sessionId/execute') && ((_a = args.body) === null || _a === void 0 ? void 0 : _a.script)) {
+                /* execute script sync / async */
+                return true;
+            }
+            else if (args.endpoint.includes('/session/:sessionId/touch')) {
+                /* Touch action for Appium */
+                return true;
+            }
+        }
+        else if (args.method === 'DELETE' && args.endpoint === '/session/:sessionId') {
+            return true;
+        }
+        return false;
+    }
+    async cleanupDeferredScreenshots() {
+        this._isPercyCleanupProcessingUnderway = true;
+        for await (const entry of this._percyDeferredScreenshots) {
+            await this.percyAutoCapture(entry.eventName, entry.sessionName);
+        }
+        this._percyDeferredScreenshots = [];
+        this._isPercyCleanupProcessingUnderway = false;
+    }
+    async sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    async browserBeforeCommand(args) {
+        try {
+            if (this.isDOMChangingCommand(args)) {
+                do {
+                    await this.sleep(1000);
+                } while (this._percyScreenshotInterval);
+                this._percyScreenshotInterval = setInterval(async () => {
+                    if (!this._isPercyCleanupProcessingUnderway) {
+                        clearInterval(this._percyScreenshotInterval);
+                        await this.cleanupDeferredScreenshots();
+                        this._percyScreenshotInterval = null;
+                    }
+                }, 1000);
+            }
+        }
+        catch (err) {
+            PercyLogger_1.PercyLogger.error(`Error while trying to cleanup deferred screenshots ${err}`);
+        }
+    }
+    async browserAfterCommand(args) {
+        try {
+            if (args.endpoint && this._percyAutoCaptureMode) {
+                let eventName = null;
+                if (args.endpoint.includes('click') && ['click', 'auto'].includes(this._percyAutoCaptureMode)) {
+                    eventName = 'click';
+                }
+                else if (args.endpoint.includes('screenshot') && ['screenshot', 'auto'].includes(this._percyAutoCaptureMode)) {
+                    eventName = 'screenshot';
+                }
+                else if (args.endpoint.includes('actions') && ['auto'].includes(this._percyAutoCaptureMode)) {
+                    if (args.body && args.body.actions && Array.isArray(args.body.actions) && args.body.actions.length && args.body.actions[0].type === 'key') {
+                        eventName = 'keys';
+                    }
+                }
+                else if (args.endpoint.includes('/session/:sessionId/element') && args.endpoint.includes('value') && ['auto'].includes(this._percyAutoCaptureMode)) {
+                    eventName = 'keys';
+                }
+                if (eventName) {
+                    this.deferCapture(this._sessionName, eventName);
+                }
+            }
+        }
+        catch (err) {
+            PercyLogger_1.PercyLogger.error(`Error while trying to calculate auto capture parameters ${err}`);
+        }
+    }
+    async afterTest() {
+        if (this._percyAutoCaptureMode && this._percyAutoCaptureMode === 'testcase') {
+            await this.percyAutoCapture('testcase', null);
+        }
+    }
+    async afterScenario() {
+        if (this._percyAutoCaptureMode && this._percyAutoCaptureMode === 'testcase') {
+            await this.percyAutoCapture('testcase', null);
+        }
+    }
+}
+// https://github.com/microsoft/TypeScript/issues/6543
+const PercyHandler = (0, util_1.o11yClassErrorHandler)(_PercyHandler);
+exports.default = PercyHandler;

package/build/Percy/Percy.d.ts

@@ -0,0 +1,24 @@
+import type { BrowserstackConfig, UserConfig } from '../types';
+import type { Options } from '@wdio/types';
+declare class Percy {
+    _logfile: string;
+    _address: string;
+    _binaryPath: string | any;
+    _options: BrowserstackConfig & Options.Testrunner;
+    _config: Options.Testrunner;
+    _proc: any;
+    _isApp: boolean;
+    _projectName: string | undefined;
+    isProcessRunning: boolean;
+    constructor(options: BrowserstackConfig & Options.Testrunner, config: Options.Testrunner, bsConfig: UserConfig);
+    private getBinaryPath;
+    private sleep;
+    healthcheck(): Promise<boolean | undefined>;
+    start(): Promise<boolean>;
+    stop(): Promise<unknown>;
+    isRunning(): boolean;
+    fetchPercyToken(): Promise<any>;
+    createPercyConfig(): Promise<unknown>;
+}
+export default Percy;
+//# sourceMappingURL=Percy.d.ts.map

package/build/Percy/Percy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Percy.d.ts","sourceRoot":"","sources":["../../src/Percy/Percy.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC9D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAI1C,cAAM,KAAK;IACP,QAAQ,EAAE,MAAM,CAAiC;IACjD,QAAQ,EAAE,MAAM,CAA8D;IAE9E,WAAW,EAAE,MAAM,GAAG,GAAG,CAAO;IAChC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC,UAAU,CAAA;IACjD,OAAO,EAAE,OAAO,CAAC,UAAU,CAAA;IAC3B,KAAK,EAAE,GAAG,CAAO;IACjB,MAAM,EAAE,OAAO,CAAA;IACf,YAAY,EAAE,MAAM,GAAG,SAAS,CAAY;IAE5C,gBAAgB,UAAQ;gBAEZ,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,UAAU,EAAE,QAAQ,EAAE,UAAU;YAOhG,aAAa;YAQb,KAAK;IAIb,WAAW;IAWX,KAAK;IA4CL,IAAI;IAWV,SAAS;IAIH,eAAe;IAsBf,iBAAiB;CA8B1B;AAED,eAAe,KAAK,CAAA"}

package/build/Percy/Percy.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_child_process_1 = require("node:child_process");
+const util_1 = require("../util");
+const PercyLogger_1 = require("./PercyLogger");
+const PercyBinary_1 = __importDefault(require("./PercyBinary"));
+const logDir = 'logs';
+class Percy {
+    constructor(options, config, bsConfig) {
+        this._logfile = node_path_1.default.join(logDir, 'percy.log');
+        this._address = process.env.PERCY_SERVER_ADDRESS || 'http://127.0.0.1:5338';
+        this._binaryPath = null;
+        this._proc = null;
+        this._projectName = undefined;
+        this.isProcessRunning = false;
+        this._options = options;
+        this._config = config;
+        this._isApp = Boolean(options.app);
+        this._projectName = bsConfig.projectName;
+    }
+    async getBinaryPath() {
+        if (!this._binaryPath) {
+            const pb = new PercyBinary_1.default();
+            this._binaryPath = await pb.getBinaryPath(this._config);
+        }
+        return this._binaryPath;
+    }
+    async sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    async healthcheck() {
+        try {
+            const resp = await (0, util_1.nodeRequest)('GET', 'percy/healthcheck', null, this._address);
+            if (resp) {
+                return true;
+            }
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    async start() {
+        const binaryPath = await this.getBinaryPath();
+        const logStream = node_fs_1.default.createWriteStream(this._logfile, { flags: 'a' });
+        const token = await this.fetchPercyToken();
+        const configPath = await this.createPercyConfig();
+        if (!token) {
+            return false;
+        }
+        const commandArgs = [`${this._isApp ? 'app:exec' : 'exec'}:start`];
+        if (configPath) {
+            commandArgs.push('-c', configPath);
+        }
+        this._proc = (0, node_child_process_1.spawn)(binaryPath, commandArgs, { env: { ...process.env, PERCY_TOKEN: token } });
+        this._proc.stdout.pipe(logStream);
+        this._proc.stderr.pipe(logStream);
+        this.isProcessRunning = true;
+        const that = this;
+        this._proc.on('close', function () {
+            that.isProcessRunning = false;
+        });
+        do {
+            const healthcheck = await this.healthcheck();
+            if (healthcheck) {
+                PercyLogger_1.PercyLogger.debug('Percy healthcheck successful');
+                return true;
+            }
+            await this.sleep(1000);
+        } while (this.isProcessRunning);
+        return false;
+    }
+    async stop() {
+        const binaryPath = await this.getBinaryPath();
+        return new Promise((resolve) => {
+            const proc = (0, node_child_process_1.spawn)(binaryPath, ['exec:stop']);
+            proc.on('close', (code) => {
+                this.isProcessRunning = false;
+                resolve(code);
+            });
+        });
+    }
+    isRunning() {
+        return this.isProcessRunning;
+    }
+    async fetchPercyToken() {
+        const projectName = this._projectName;
+        try {
+            const type = this._isApp ? 'app' : 'automate';
+            const response = await (0, util_1.nodeRequest)('GET', `api/app_percy/get_project_token?name=${projectName}&type=${type}`, {
+                username: (0, util_1.getBrowserStackUser)(this._config),
+                password: (0, util_1.getBrowserStackKey)(this._config)
+            }, 'https://api.browserstack.com');
+            PercyLogger_1.PercyLogger.debug('Percy fetch token success : ' + response.token);
+            return response.token;
+        }
+        catch (err) {
+            PercyLogger_1.PercyLogger.error(`Percy unable to fetch project token: ${err}`);
+            return null;
+        }
+    }
+    async createPercyConfig() {
+        if (!this._options.percyOptions) {
+            return null;
+        }
+        const configPath = node_path_1.default.join(node_os_1.default.tmpdir(), 'percy.json');
+        const percyOptions = this._options.percyOptions;
+        if (!percyOptions.version) {
+            percyOptions.version = '2';
+        }
+        return new Promise((resolve) => {
+            node_fs_1.default.writeFile(configPath, JSON.stringify(percyOptions), (err) => {
+                if (err) {
+                    PercyLogger_1.PercyLogger.error(`Error creating percy config: ${err}`);
+                    resolve(null);
+                }
+                PercyLogger_1.PercyLogger.debug('Percy config created at ' + configPath);
+                resolve(configPath);
+            });
+        });
+    }
+}
+exports.default = Percy;

package/build/Percy/PercyBinary.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import type { Options } from '@wdio/types';
+declare class PercyBinary {
+    _hostOS: NodeJS.Platform;
+    _httpPath: any;
+    _binaryName: string;
+    _orderedPaths: string[];
+    constructor();
+    private makePath;
+    private checkPath;
+    private _getAvailableDirs;
+    getBinaryPath(conf: Options.Testrunner): Promise<string>;
+    validateBinary(binaryPath: string): Promise<unknown>;
+    download(conf: any, destParentDir: any): Promise<string>;
+}
+export default PercyBinary;
+//# sourceMappingURL=PercyBinary.d.ts.map

package/build/Percy/PercyBinary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PercyBinary.d.ts","sourceRoot":"","sources":["../../src/Percy/PercyBinary.ts"],"names":[],"mappings":";AASA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAE1C,cAAM,WAAW;IACb,OAAO,kBAAmB;IAC1B,SAAS,EAAE,GAAG,CAAO;IACrB,WAAW,SAAU;IAErB,aAAa,WAIZ;;YAca,QAAQ;YAOR,SAAS;YAWT,iBAAiB;IAUzB,aAAa,CAAC,IAAI,EAAE,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAgBxD,cAAc,CAAC,UAAU,EAAE,MAAM;IAgBjC,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,aAAa,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;CAkEjE;AAED,eAAe,WAAW,CAAA"}

package/build/Percy/PercyBinary.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const yauzl_1 = __importDefault(require("yauzl"));
+const fs = require('node:fs');
+const got_1 = __importDefault(require("got"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_child_process_1 = require("node:child_process");
+const PercyLogger_1 = require("./PercyLogger");
+class PercyBinary {
+    constructor() {
+        this._hostOS = process.platform;
+        this._httpPath = null;
+        this._binaryName = 'percy';
+        this._orderedPaths = [
+            node_path_1.default.join(node_os_1.default.homedir(), '.browserstack'),
+            process.cwd(),
+            node_os_1.default.tmpdir()
+        ];
+        const base = 'https://github.com/percy/cli/releases/latest/download';
+        if (this._hostOS.match(/darwin|mac os/i)) {
+            this._httpPath = base + '/percy-osx.zip';
+        }
+        else if (this._hostOS.match(/mswin|msys|mingw|cygwin|bccwin|wince|emc|win32/i)) {
+            this._httpPath = base + '/percy-win.zip';
+            this._binaryName = 'percy.exe';
+        }
+        else {
+            this._httpPath = base + '/percy-linux.zip';
+        }
+    }
+    async makePath(path) {
+        if (await this.checkPath(path)) {
+            return true;
+        }
+        return promises_1.default.mkdir(path).then(() => true).catch(() => false);
+    }
+    async checkPath(path) {
+        try {
+            const hasDir = await promises_1.default.access(path).then(() => true, () => false);
+            if (hasDir) {
+                return true;
+            }
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    async _getAvailableDirs() {
+        for (let i = 0; i < this._orderedPaths.length; i++) {
+            const path = this._orderedPaths[i];
+            if (await this.makePath(path)) {
+                return path;
+            }
+        }
+        throw new Error('Error trying to download percy binary');
+    }
+    async getBinaryPath(conf) {
+        const destParentDir = await this._getAvailableDirs();
+        const binaryPath = node_path_1.default.join(destParentDir, this._binaryName);
+        if (await this.checkPath(binaryPath)) {
+            return binaryPath;
+        }
+        const downloadedBinaryPath = await this.download(conf, destParentDir);
+        const isValid = await this.validateBinary(downloadedBinaryPath);
+        if (!isValid) {
+            // retry once
+            PercyLogger_1.PercyLogger.error('Corrupt percy binary, retrying');
+            return await this.download(conf, destParentDir);
+        }
+        return downloadedBinaryPath;
+    }
+    async validateBinary(binaryPath) {
+        const versionRegex = /^.*@percy\/cli \d.\d+.\d+/;
+        return new Promise((resolve) => {
+            const proc = (0, node_child_process_1.spawn)(binaryPath, ['--version']);
+            proc.stdout.on('data', (data) => {
+                if (versionRegex.test(data)) {
+                    resolve(true);
+                }
+            });
+            proc.on('close', () => {
+                resolve(false);
+            });
+        });
+    }
+    async download(conf, destParentDir) {
+        if (!await this.checkPath(destParentDir)) {
+            await promises_1.default.mkdir(destParentDir);
+        }
+        const binaryName = this._binaryName;
+        const zipFilePath = node_path_1.default.join(destParentDir, binaryName + '.zip');
+        const binaryPath = node_path_1.default.join(destParentDir, binaryName);
+        const downloadedFileStream = fs.createWriteStream(zipFilePath);
+        return new Promise((resolve, reject) => {
+            const stream = got_1.default.extend({ followRedirect: true }).get(this._httpPath, { isStream: true });
+            stream.on('error', (err) => {
+                PercyLogger_1.PercyLogger.error(`Got Error in percy binary download response: ${err}`);
+            });
+            stream.pipe(downloadedFileStream)
+                .on('finish', () => {
+                yauzl_1.default.open(zipFilePath, { lazyEntries: true }, function (err, zipfile) {
+                    if (err) {
+                        return reject(err);
+                    }
+                    zipfile.readEntry();
+                    zipfile.on('entry', (entry) => {
+                        if (/\/$/.test(entry.fileName)) {
+                            // Directory file names end with '/'.
+                            zipfile.readEntry();
+                        }
+                        else {
+                            // file entry
+                            const writeStream = fs.createWriteStream(node_path_1.default.join(destParentDir, entry.fileName));
+                            zipfile.openReadStream(entry, function (zipErr, readStream) {
+                                if (zipErr) {
+                                    reject(err);
+                                }
+                                readStream.on('end', function () {
+                                    writeStream.close();
+                                    zipfile.readEntry();
+                                });
+                                readStream.pipe(writeStream);
+                            });
+                            if (entry.fileName === binaryName) {
+                                zipfile.close();
+                            }
+                        }
+                    });
+                    zipfile.on('error', (zipErr) => {
+                        reject(zipErr);
+                    });
+                    zipfile.once('end', () => {
+                        fs.chmod(binaryPath, '0755', function (zipErr) {
+                            if (zipErr) {
+                                reject(zipErr);
+                            }
+                            resolve(binaryPath);
+                        });
+                        zipfile.close();
+                    });
+                });
+            });
+        });
+    }
+}
+exports.default = PercyBinary;

package/build/Percy/PercyCaptureMap.d.ts

@@ -0,0 +1,9 @@
+declare class PercyCaptureMap {
+    #private;
+    increment(sessionName: string, eventName: string): void;
+    decrement(sessionName: string, eventName: string): void;
+    getName(sessionName: string, eventName: string): string;
+    get(sessionName: string, eventName: string): number;
+}
+export default PercyCaptureMap;
+//# sourceMappingURL=PercyCaptureMap.d.ts.map

package/build/Percy/PercyCaptureMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PercyCaptureMap.d.ts","sourceRoot":"","sources":["../../src/Percy/PercyCaptureMap.ts"],"names":[],"mappings":"AAKA,cAAM,eAAe;;IAGjB,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAYhD,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAQhD,OAAO,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAI9C,GAAG,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;CAW7C;AAED,eAAe,eAAe,CAAA"}

package/build/Percy/PercyCaptureMap.js

@@ -0,0 +1,46 @@
+"use strict";
+/*
+ * Maintains a counter for each driver to get consistent and
+ * unique screenshot names for percy
+ */
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PercyCaptureMap_map;
+Object.defineProperty(exports, "__esModule", { value: true });
+class PercyCaptureMap {
+    constructor() {
+        _PercyCaptureMap_map.set(this, {});
+    }
+    increment(sessionName, eventName) {
+        if (!__classPrivateFieldGet(this, _PercyCaptureMap_map, "f")[sessionName]) {
+            __classPrivateFieldGet(this, _PercyCaptureMap_map, "f")[sessionName] = {};
+        }
+        if (!__classPrivateFieldGet(this, _PercyCaptureMap_map, "f")[sessionName][eventName]) {
+            __classPrivateFieldGet(this, _PercyCaptureMap_map, "f")[sessionName][eventName] = 0;
+        }
+        __classPrivateFieldGet(this, _PercyCaptureMap_map, "f")[sessionName][eventName]++;
+    }
+    decrement(sessionName, eventName) {
+        if (!__classPrivateFieldGet(this, _PercyCaptureMap_map, "f")[sessionName] || !__classPrivateFieldGet(this, _PercyCaptureMap_map, "f")[sessionName][eventName]) {
+            return;
+        }
+        __classPrivateFieldGet(this, _PercyCaptureMap_map, "f")[sessionName][eventName]--;
+    }
+    getName(sessionName, eventName) {
+        return `${sessionName}-${eventName}-${this.get(sessionName, eventName)}`;
+    }
+    get(sessionName, eventName) {
+        if (!__classPrivateFieldGet(this, _PercyCaptureMap_map, "f")[sessionName]) {
+            return 0;
+        }
+        if (!__classPrivateFieldGet(this, _PercyCaptureMap_map, "f")[sessionName][eventName]) {
+            return 0;
+        }
+        return __classPrivateFieldGet(this, _PercyCaptureMap_map, "f")[sessionName][eventName] - 1;
+    }
+}
+_PercyCaptureMap_map = new WeakMap();
+exports.default = PercyCaptureMap;

package/build/Percy/PercyHelper.d.ts

@@ -0,0 +1,8 @@
+import type { Capabilities } from '@wdio/types';
+import type { BrowserstackConfig, UserConfig } from '../types';
+import type { Options } from '@wdio/types';
+import Percy from './Percy';
+export declare const startPercy: (options: BrowserstackConfig & Options.Testrunner, config: Options.Testrunner, bsConfig: UserConfig) => Promise<Percy>;
+export declare const stopPercy: (percy: Percy) => Promise<unknown>;
+export declare const getBestPlatformForPercySnapshot: (capabilities?: Capabilities.RemoteCapabilities) => any;
+//# sourceMappingURL=PercyHelper.d.ts.map

package/build/Percy/PercyHelper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PercyHelper.d.ts","sourceRoot":"","sources":["../../src/Percy/PercyHelper.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE9D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAG1C,OAAO,KAAK,MAAM,SAAS,CAAA;AAE3B,eAAO,MAAM,UAAU,YAAmB,kBAAkB,GAAG,QAAQ,UAAU,UAAU,QAAQ,UAAU,YAAY,UAAU,KAAG,QAAQ,KAAK,CAQlJ,CAAA;AAED,eAAO,MAAM,SAAS,UAAiB,KAAK,qBAG3C,CAAA;AAED,eAAO,MAAM,+BAA+B,kBAAmB,aAAa,kBAAkB,KAAI,GAgDjG,CAAA"}