@wdio/browserstack-service 0.0.0-canary-20260722132416

package/build/launcher.js

@@ -0,0 +1,1077 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import got from 'got';
+import { FormData } from 'formdata-node';
+import { v4 as uuidv4 } from 'uuid';
+import fs from 'node:fs';
+import path from 'node:path';
+import { promisify, format } from 'node:util';
+import { performance, PerformanceObserver } from 'node:perf_hooks';
+import os from 'node:os';
+import { SevereServiceError } from 'webdriverio';
+import * as BrowserstackLocalLauncher from 'browserstack-local';
+import { startPercy, stopPercy, getBestPlatformForPercySnapshot } from './Percy/PercyHelper.js';
+import { BSTACK_SERVICE_VERSION, NOT_ALLOWED_KEYS_IN_CAPS, PERF_MEASUREMENT_ENV, RERUN_ENV, RERUN_TESTS_ENV, BROWSERSTACK_TESTHUB_UUID, VALID_APP_EXTENSION, BROWSERSTACK_PERCY, BROWSERSTACK_OBSERVABILITY, WDIO_NAMING_PREFIX } from './constants.js';
+import { launchTestSession, shouldAddServiceVersion, stopBuildUpstream, getCiInfo, isBStackSession, isUndefined, isAccessibilityAutomationSession, isTrue, getBrowserStackUser, getBrowserStackKey, uploadLogs, ObjectsAreEqual, isValidCapsForHealing, getBooleanValueFromString, validateCapsWithNonBstackA11y, mergeChromeOptions, normalizeTestReportingConfig, normalizeTestReportingEnvVariables, isValidEnabledValue, isMultiRemoteCaps } from './util.js';
+import { getProductMap } from './testHub/utils.js';
+import CrashReporter from './crash-reporter.js';
+import { BStackLogger } from './bstackLogger.js';
+import { PercyLogger } from './Percy/PercyLogger.js';
+import { FileStream } from './fileStream.js';
+import { sendStart, sendFinish } from './instrumentation/funnelInstrumentation.js';
+import BrowserStackConfig from './config.js';
+import { setupExitHandlers } from './exitHandler.js';
+import AiHandler from './ai-handler.js';
+import TestOpsConfig from './testOps/testOpsConfig.js';
+import PerformanceTester from './instrumentation/performance/performance-tester.js';
+import * as PERFORMANCE_SDK_EVENTS from './instrumentation/performance/constants.js';
+import { BrowserstackCLI } from './cli/index.js';
+import { CLIUtils } from './cli/cliUtils.js';
+import accessibilityScripts from './scripts/accessibility-scripts.js';
+import util from 'node:util';
+import APIUtils from './cli/apiUtils.js';
+export default class BrowserstackLauncherService {
+    _options;
+    _config;
+    browserstackLocal;
+    _buildName;
+    _projectName;
+    _buildTag;
+    _buildIdentifier;
+    _accessibilityAutomation = null;
+    _percy;
+    _percyBestPlatformCaps;
+    browserStackConfig;
+    constructor(_options, capabilities, _config) {
+        this._options = _options;
+        this._config = _config;
+        BStackLogger.clearLogFile();
+        PercyLogger.clearLogFile();
+        setupExitHandlers();
+        // added to maintain backward compatibility with webdriverIO v5
+        this._config || (this._config = _options);
+        //normalizing testReporting config and env variables
+        normalizeTestReportingConfig(this._options);
+        normalizeTestReportingEnvVariables();
+        this.browserStackConfig = BrowserStackConfig.getInstance(_options, _config);
+        if (Array.isArray(capabilities)) {
+            capabilities
+                .flatMap((c) => {
+                if (Object.values(c).length > 0 && Object.values(c).every(c => typeof c === 'object' && c.capabilities)) {
+                    return Object.values(c).map((o) => o.capabilities);
+                }
+                return c;
+            })
+                .forEach((capability) => {
+                if (!capability['bstack:options']) {
+                    // Skipping adding of service version if session is not of browserstack
+                    if (isBStackSession(this._config)) {
+                        const extensionCaps = Object.keys(capability).filter((cap) => cap.includes(':'));
+                        if (extensionCaps.length) {
+                            capability['bstack:options'] = { wdioService: BSTACK_SERVICE_VERSION };
+                            if (!isUndefined(capability['browserstack.accessibility'])) {
+                                this._accessibilityAutomation ||= isTrue(capability['browserstack.accessibility']);
+                            }
+                            else if (isTrue(this._options.accessibility)) {
+                                capability['bstack:options'].accessibility = true;
+                            }
+                        }
+                        else if (shouldAddServiceVersion(this._config, this._options.testObservability)) {
+                            capability['browserstack.wdioService'] = BSTACK_SERVICE_VERSION;
+                        }
+                    }
+                    // Need this details for sending data to Observability
+                    this._buildIdentifier = capability['browserstack.buildIdentifier']?.toString();
+                    this._buildName = capability.build?.toString();
+                }
+                else {
+                    capability['bstack:options'].wdioService = BSTACK_SERVICE_VERSION;
+                    this._buildName = capability['bstack:options'].buildName;
+                    this._projectName = capability['bstack:options'].projectName;
+                    this._buildTag = capability['bstack:options'].buildTag;
+                    this._buildIdentifier = capability['bstack:options'].buildIdentifier;
+                    if (!isUndefined(capability['bstack:options'].accessibility)) {
+                        this._accessibilityAutomation ||= isTrue(capability['bstack:options'].accessibility);
+                    }
+                    else if (isTrue(this._options.accessibility)) {
+                        capability['bstack:options'].accessibility = (isTrue(this._options.accessibility));
+                    }
+                }
+            });
+        }
+        else if (typeof capabilities === 'object') {
+            Object.entries(capabilities).forEach(([, caps]) => {
+                if (!caps.capabilities['bstack:options']) {
+                    if (isBStackSession(this._config)) {
+                        const extensionCaps = Object.keys(caps.capabilities).filter((cap) => cap.includes(':'));
+                        if (extensionCaps.length) {
+                            caps.capabilities['bstack:options'] = { wdioService: BSTACK_SERVICE_VERSION };
+                            if (!isUndefined(caps.capabilities['browserstack.accessibility'])) {
+                                this._accessibilityAutomation ||= isTrue(caps.capabilities['browserstack.accessibility']);
+                            }
+                            else if (isTrue(this._options.accessibility)) {
+                                caps.capabilities['bstack:options'] = { wdioService: BSTACK_SERVICE_VERSION, accessibility: (isTrue(this._options.accessibility)) };
+                            }
+                        }
+                        else if (shouldAddServiceVersion(this._config, this._options.testObservability)) {
+                            caps.capabilities['browserstack.wdioService'] = BSTACK_SERVICE_VERSION;
+                        }
+                    }
+                    this._buildIdentifier = caps.capabilities['browserstack.buildIdentifier'];
+                }
+                else {
+                    const bstackOptions = caps.capabilities['bstack:options'];
+                    bstackOptions.wdioService = BSTACK_SERVICE_VERSION;
+                    this._buildName = bstackOptions.buildName;
+                    this._projectName = bstackOptions.projectName;
+                    this._buildTag = bstackOptions.buildTag;
+                    this._buildIdentifier = bstackOptions.buildIdentifier;
+                    if (!isUndefined(bstackOptions.accessibility)) {
+                        this._accessibilityAutomation ||= isTrue(bstackOptions.accessibility);
+                    }
+                    else if (isTrue(this._options.accessibility)) {
+                        bstackOptions.accessibility = isTrue(this._options.accessibility);
+                    }
+                }
+            });
+        }
+        this.browserStackConfig.buildIdentifier = this._buildIdentifier;
+        this.browserStackConfig.buildName = this._buildName;
+        PerformanceTester.startMonitoring('performance-report-launcher.csv');
+        if (!isUndefined(this._options.accessibility)) {
+            this._accessibilityAutomation ||= isTrue(this._options.accessibility);
+        }
+        this._options.accessibility = this._accessibilityAutomation;
+        // by default observability will be true unless specified as false
+        this._options.testObservability = this._options.testObservability !== false;
+        if (this._options.testObservability
+            &&
+                // update files to run if it's a rerun
+                process.env[RERUN_ENV] && process.env[RERUN_TESTS_ENV]) {
+            this._config.specs = process.env[RERUN_TESTS_ENV].split(',');
+        }
+        try {
+            CrashReporter.setConfigDetails(this._config, capabilities, this._options);
+        }
+        catch (error) {
+            BStackLogger.error(`[Crash_Report_Upload] Config processing failed due to ${error}`);
+        }
+    }
+    async onWorkerStart(cid, caps) {
+        try {
+            if (this._options.percy && this._percyBestPlatformCaps) {
+                const isThisBestPercyPlatform = ObjectsAreEqual(caps, this._percyBestPlatformCaps);
+                if (isThisBestPercyPlatform) {
+                    process.env.BEST_PLATFORM_CID = cid;
+                }
+            }
+        }
+        catch (err) {
+            PercyLogger.error(`Error while setting best platform for Percy snapshot at worker start ${err}`);
+        }
+    }
+    async onPrepare(config, capabilities) {
+        PerformanceTester.start(PERFORMANCE_SDK_EVENTS.FRAMEWORK_EVENTS.INIT);
+        // // Send Funnel start request
+        await sendStart(this.browserStackConfig);
+        // Convert glob patterns in specs to resolved relative paths
+        if (config.specs && Array.isArray(config.specs) && isValidEnabledValue(this._options.testOrchestrationOptions?.runSmartSelection?.enabled)) {
+            try {
+                // Import glob for expanding file patterns
+                const glob = (await import('glob')).sync;
+                const path = await import('node:path');
+                // Use ConfigParser.getFilePaths equivalent logic to expand specs
+                const expandedSpecs = [];
+                for (const specPattern of config.specs) {
+                    if (typeof specPattern === 'string') {
+                        if (specPattern.startsWith('file://')) {
+                            expandedSpecs.push(specPattern);
+                            continue;
+                        }
+                        // Expand glob pattern to relative paths
+                        const pattern = specPattern.replace(/\\/g, '/');
+                        // Use config.rootDir which is set to the config file's directory
+                        const rootDir = config.rootDir || process.cwd();
+                        // Get current working directory for final relative path calculation
+                        const cwd = process.cwd();
+                        const filenames = glob(pattern, {
+                            cwd: rootDir,
+                            matchBase: true
+                        }) || [];
+                        // Convert paths to be relative to the current working directory (where command is run)
+                        filenames
+                            .forEach((filename) => {
+                            let absolutePath = filename;
+                            // If filename is not absolute, resolve it relative to rootDir (config file's directory)
+                            if (!path.isAbsolute(filename)) {
+                                absolutePath = path.resolve(rootDir, filename);
+                            }
+                            // Make path relative to current working directory
+                            let relativePath = path.relative(cwd, absolutePath);
+                            // Normalize path separators for consistency (Windows compatibility)
+                            relativePath = relativePath.replace(/\\/g, '/');
+                            expandedSpecs.push(relativePath);
+                        });
+                    }
+                }
+                if (expandedSpecs.length > 0) {
+                    BStackLogger.info(`Expanded specs from glob patterns to ${expandedSpecs.length} files`);
+                    config.specs = expandedSpecs;
+                }
+            }
+            catch (error) {
+                BStackLogger.error(`Failed to expand spec patterns: ${error}`);
+            }
+        }
+        try {
+            // Detect if multi-remote and disable CLI for those sessions
+            const isMultiremote = isMultiRemoteCaps(capabilities);
+            process.env.BROWSERSTACK_IS_MULTIREMOTE = String(isMultiremote);
+            if (CLIUtils.checkCLISupportedFrameworks(config.framework) && !isMultiremote) {
+                PerformanceTester.start(PERFORMANCE_SDK_EVENTS.FRAMEWORK_EVENTS.START);
+                CLIUtils.setFrameworkDetail(WDIO_NAMING_PREFIX + config.framework, 'WebdriverIO'); // TODO: make this constant
+                const binconfig = CLIUtils.getBinConfig(config, capabilities, this._options, this._buildTag);
+                await BrowserstackCLI.getInstance().bootstrap(this._options, config, binconfig);
+                BStackLogger.debug(`Is CLI running ${BrowserstackCLI.getInstance().isRunning()}`);
+                PerformanceTester.end(PERFORMANCE_SDK_EVENTS.FRAMEWORK_EVENTS.START);
+            }
+        }
+        catch (err) {
+            BStackLogger.error(`Error while starting CLI ${err}`);
+            PerformanceTester.end(PERFORMANCE_SDK_EVENTS.FRAMEWORK_EVENTS.START, false, util.format(err));
+        }
+        PerformanceTester.end(PERFORMANCE_SDK_EVENTS.FRAMEWORK_EVENTS.INIT);
+        // Setting up healing for those sessions where we don't add the service version capability as it indicates that the session is not being run on BrowserStack
+        if (!shouldAddServiceVersion(this._config, this._options.testObservability, capabilities)) {
+            try {
+                if (capabilities.browserName) {
+                    capabilities = await AiHandler.setup(this._config, this.browserStackConfig, this._options, capabilities, false);
+                }
+                else if (Array.isArray(capabilities)) {
+                    for (let i = 0; i < capabilities.length; i++) {
+                        if (capabilities[i].browserName) {
+                            capabilities[i] = await AiHandler.setup(this._config, this.browserStackConfig, this._options, capabilities[i], false);
+                        }
+                    }
+                }
+                else if (isValidCapsForHealing(capabilities)) {
+                    // setting up healing in case capabilities.xyz.capabilities.browserName where xyz can be anything:
+                    capabilities = await AiHandler.setup(this._config, this.browserStackConfig, this._options, capabilities, true);
+                }
+            }
+            catch (err) {
+                if (this._options.selfHeal === true) {
+                    BStackLogger.warn(`Error while setting up Browserstack healing Extension ${err}. Disabling healing for this session.`);
+                }
+            }
+        }
+        /**
+         * Upload app to BrowserStack if valid file path to app is given.
+         * Update app value of capability directly if app_url, custom_id, shareable_id is given
+         */
+        if (!BrowserstackCLI.getInstance().isRunning()) {
+            if (!this._options.app) {
+                BStackLogger.debug('app is not defined in browserstack-service config, skipping ...');
+            }
+            else {
+                let app = {};
+                const appConfig = this._options.app;
+                try {
+                    app = await this._validateApp(appConfig);
+                }
+                catch (error) {
+                    throw new SevereServiceError(error);
+                }
+                if (VALID_APP_EXTENSION.includes(path.extname(app.app))) {
+                    if (fs.existsSync(app.app)) {
+                        const data = await this._uploadApp(app);
+                        BStackLogger.info(`app upload completed: ${JSON.stringify(data)}`);
+                        app.app = data.app_url;
+                    }
+                    else if (app.customId) {
+                        app.app = app.customId;
+                    }
+                    else {
+                        throw new SevereServiceError(`[Invalid app path] app path ${app.app} is not correct, Provide correct path to app under test`);
+                    }
+                }
+                BStackLogger.info(`Using app: ${app.app}`);
+                this._updateCaps(capabilities, 'app', app.app);
+            }
+        }
+        /**
+         * buildIdentifier in service options will take precedence over specified in capabilities
+        */
+        if (this._options.buildIdentifier) {
+            this._buildIdentifier = this._options.buildIdentifier;
+            this._updateCaps(capabilities, 'buildIdentifier', this._buildIdentifier);
+        }
+        /**
+         * evaluate buildIdentifier in case unique execution identifiers are present
+         * e.g., ${BUILD_NUMBER} and ${DATE_TIME}
+        */
+        this._handleBuildIdentifier(capabilities);
+        // remove accessibilityOptions from the capabilities if present
+        this._updateObjectTypeCaps(capabilities, 'accessibilityOptions');
+        const shouldSetupPercy = this._options.percy || (isUndefined(this._options.percy) && this._options.app);
+        let buildStartResponse = null;
+        if (!BrowserstackCLI.getInstance().isRunning() && (this._options.testObservability || this._accessibilityAutomation || shouldSetupPercy)) {
+            BStackLogger.debug('Sending launch start event');
+            buildStartResponse = await launchTestSession(this._options, this._config, {
+                projectName: this._projectName,
+                buildName: this._buildName,
+                buildTag: this._buildTag,
+                bstackServiceVersion: BSTACK_SERVICE_VERSION,
+                buildIdentifier: this._buildIdentifier
+            }, this.browserStackConfig, this._accessibilityAutomation);
+            //added checks for Accessibility running on non-bstack infra
+            if (isAccessibilityAutomationSession(this._accessibilityAutomation) && (process.env.BROWSERSTACK_TURBOSCALE || !shouldAddServiceVersion(this._config, this._options.testObservability))) {
+                const overrideOptions = accessibilityScripts.ChromeExtension;
+                this._updateObjectTypeCaps(capabilities, 'goog:chromeOptions', overrideOptions);
+            }
+            if (buildStartResponse?.accessibility) {
+                if (this._accessibilityAutomation === null) {
+                    this.browserStackConfig.accessibility = buildStartResponse.accessibility.success;
+                    this._accessibilityAutomation = buildStartResponse.accessibility.success;
+                    this._options.accessibility = buildStartResponse.accessibility.success;
+                    if (buildStartResponse.accessibility.success === true) {
+                        this._updateCaps(capabilities, 'accessibility', 'true');
+                    }
+                }
+            }
+            this.browserStackConfig.accessibility = this._accessibilityAutomation;
+            if (this._accessibilityAutomation && this._options.accessibilityOptions) {
+                const filteredOpts = Object.keys(this._options.accessibilityOptions)
+                    .filter(key => !NOT_ALLOWED_KEYS_IN_CAPS.includes(key))
+                    .reduce((opts, key) => {
+                    return {
+                        ...opts,
+                        [key]: this._options.accessibilityOptions?.[key]
+                    };
+                }, {});
+                this._updateObjectTypeCaps(capabilities, 'accessibilityOptions', filteredOpts);
+            }
+            else if (isAccessibilityAutomationSession(this._accessibilityAutomation)) {
+                this._updateObjectTypeCaps(capabilities, 'accessibilityOptions', {});
+            }
+            this._removeCliOnlyCapabilityOptions(capabilities);
+            if (shouldSetupPercy) {
+                try {
+                    const bestPlatformPercyCaps = getBestPlatformForPercySnapshot(capabilities);
+                    this._percyBestPlatformCaps = bestPlatformPercyCaps;
+                    process.env[BROWSERSTACK_PERCY] = 'false';
+                    await this.setupPercy(this._options, this._config, {
+                        projectName: this._projectName
+                    });
+                    this._updateBrowserStackPercyConfig();
+                }
+                catch (err) {
+                    PercyLogger.error(`Error while setting up Percy ${err}`);
+                }
+            }
+        }
+        // send testhub build uuid and product map instrumentation
+        this._updateCaps(capabilities, 'testhubBuildUuid');
+        this._updateCaps(capabilities, 'buildProductMap');
+        if (isValidEnabledValue(this._options.testOrchestrationOptions?.runSmartSelection?.enabled)) {
+            // Helper function to convert specs from cwd-relative to rootDir-relative
+            const convertToRootDirRelative = (specs) => {
+                const rootDir = config.rootDir || process.cwd();
+                const cwd = process.cwd();
+                return specs.map((spec) => {
+                    if (typeof spec !== 'string') {
+                        return spec;
+                    }
+                    // Convert from cwd-relative to absolute
+                    const absolutePath = path.isAbsolute(spec) ? spec : path.resolve(cwd, spec);
+                    // Then make it relative to rootDir (config file's directory)
+                    const relativePath = path.relative(rootDir, absolutePath);
+                    // Normalize path separators
+                    return relativePath.replace(/\\/g, '/');
+                });
+            };
+            // Apply test orchestration if enabled
+            try {
+                // Import dynamically to avoid circular dependencies
+                const { applyOrchestrationIfEnabled } = await import('./testorchestration/apply-orchestration.js');
+                if (config.specs && config.specs.length > 0 && this._options.testObservability && isValidEnabledValue(this._options.testOrchestrationOptions?.runSmartSelection?.enabled)) {
+                    BStackLogger.info('Applying test orchestration');
+                    // Ensure we're passing string[] to applyOrchestrationIfEnabled
+                    const specs = config.specs.filter(spec => typeof spec === 'string');
+                    console.log(`Specs before orchestration: ${specs}`);
+                    const orderedSpecs = await applyOrchestrationIfEnabled(specs, this._options);
+                    console.log(`Specs after orchestration before conversion: ${orderedSpecs}`);
+                    // Use ordered specs if available, otherwise use original specs
+                    const specsToConvert = orderedSpecs && orderedSpecs.length > 0 ? orderedSpecs : specs;
+                    config.specs = convertToRootDirRelative(specsToConvert);
+                    console.log(`Specs after orchestration: ${config.specs}`);
+                    BStackLogger.info('Test specs updated with orchestrated order');
+                }
+            }
+            catch (error) {
+                BStackLogger.error(`Error applying test orchestration: ${error}`);
+                // On error, we still need to convert specs from cwd-relative to rootDir-relative
+                if (config.specs && config.specs.length > 0) {
+                    const specs = config.specs.filter(spec => typeof spec === 'string');
+                    config.specs = convertToRootDirRelative(specs);
+                    BStackLogger.debug(`Specs converted back to rootDir-relative after error: ${config.specs}`);
+                }
+            }
+        }
+        // local binary will be handled by CLI
+        if (BrowserstackCLI.getInstance().isRunning()) {
+            return;
+        }
+        if (!this._options.browserstackLocal) {
+            return BStackLogger.info('browserstackLocal is not enabled - skipping...');
+        }
+        const opts = {
+            key: this._config.key,
+            ...this._options.opts
+        };
+        this.browserstackLocal = new BrowserstackLocalLauncher.Local();
+        this._updateCaps(capabilities, 'local');
+        if (opts.localIdentifier) {
+            this._updateCaps(capabilities, 'localIdentifier', opts.localIdentifier);
+        }
+        /**
+         * measure BrowserStack tunnel boot time
+         */
+        const obs = new PerformanceObserver((list) => {
+            const entry = list.getEntries()[0];
+            BStackLogger.info(`Browserstack Local successfully started after ${entry.duration}ms`);
+        });
+        obs.observe({ entryTypes: ['measure'] });
+        let timer;
+        performance.mark('tbTunnelStart');
+        PerformanceTester.start(PERFORMANCE_SDK_EVENTS.AUTOMATE_EVENTS.LOCAL_START);
+        return Promise.race([
+            promisify(this.browserstackLocal.start.bind(this.browserstackLocal))(opts),
+            new Promise((resolve, reject) => {
+                /* istanbul ignore next */
+                timer = setTimeout(function () {
+                    reject('Browserstack Local failed to start within 60 seconds!');
+                }, 60000);
+            })
+        ]).then(function (result) {
+            clearTimeout(timer);
+            PerformanceTester.end(PERFORMANCE_SDK_EVENTS.AUTOMATE_EVENTS.LOCAL_START);
+            performance.mark('tbTunnelEnd');
+            performance.measure('bootTime', 'tbTunnelStart', 'tbTunnelEnd');
+            return Promise.resolve(result);
+        }, function (err) {
+            PerformanceTester.end(PERFORMANCE_SDK_EVENTS.AUTOMATE_EVENTS.LOCAL_START, false, err);
+            clearTimeout(timer);
+            return Promise.reject(err);
+        });
+    }
+    async onComplete() {
+        PerformanceTester.start(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_CLEANUP);
+        PerformanceTester.start(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_ON_STOP);
+        PerformanceTester.start(PERFORMANCE_SDK_EVENTS.FRAMEWORK_EVENTS.STOP);
+        try {
+            BStackLogger.debug('Inside OnComplete hook..');
+            BStackLogger.debug('Sending stop launch event');
+            const isCLIEnabled = BrowserstackCLI.getInstance().isRunning();
+            try {
+                await (isCLIEnabled ? BrowserstackCLI.getInstance().stop() : stopBuildUpstream());
+                PerformanceTester.end(PERFORMANCE_SDK_EVENTS.FRAMEWORK_EVENTS.STOP);
+            }
+            catch (err) {
+                BStackLogger.error(`Error while stopping CLI ${err}`);
+                PerformanceTester.end(PERFORMANCE_SDK_EVENTS.FRAMEWORK_EVENTS.STOP, false, util.format(err));
+            }
+            if (process.env[BROWSERSTACK_OBSERVABILITY] && process.env[BROWSERSTACK_TESTHUB_UUID]) {
+                console.log(`\nVisit https://automation.browserstack.com/builds/${process.env[BROWSERSTACK_TESTHUB_UUID]} to view build report, insights, and many more debugging information all at one place!\n`);
+            }
+            this.browserStackConfig.testObservability.buildStopped = true;
+            if (process.env[PERF_MEASUREMENT_ENV]) {
+                PerformanceTester.calculateTimes(['launchTestSession', 'stopBuildUpstream']);
+                if (!process.env.START_TIME) {
+                    PerformanceTester.end(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_CLEANUP);
+                    await PerformanceTester.stopAndGenerate('performance-launcher.html');
+                    return;
+                }
+                const duration = (new Date()).getTime() - (new Date(process.env.START_TIME)).getTime();
+                BStackLogger.info(`Total duration is ${duration / 1000} s`);
+            }
+            BStackLogger.info(`BrowserStack service run ended for id: ${this.browserStackConfig?.sdkRunID} testhub id: ${TestOpsConfig.getInstance()?.buildHashedId}`);
+            await sendFinish(this.browserStackConfig, isCLIEnabled);
+            try {
+                PerformanceTester.start(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_SEND_LOGS);
+                await this._uploadServiceLogs();
+                PerformanceTester.end(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_SEND_LOGS);
+            }
+            catch (error) {
+                BStackLogger.debug(`Failed to upload BrowserStack WDIO Service logs ${error}`);
+                PerformanceTester.end(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_SEND_LOGS, false, util.format(error));
+            }
+            PerformanceTester.end(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_ON_STOP);
+            PerformanceTester.end(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_CLEANUP);
+            await PerformanceTester.stopAndGenerate('performance-launcher.html');
+        }
+        catch (error) {
+            PerformanceTester.end(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_ON_STOP, false, util.format(error));
+            PerformanceTester.end(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_CLEANUP, false, util.format(error));
+            await PerformanceTester.stopAndGenerate('performance-launcher.html');
+            BStackLogger.error(`Error in onComplete hook: ${error}`);
+        }
+        BStackLogger.clearLogger();
+        if (this._options.percy) {
+            await this.stopPercy();
+            PercyLogger.clearLogger();
+        }
+        // local binary will be handled by CLI
+        if (BrowserstackCLI.getInstance().isRunning()) {
+            return;
+        }
+        if (!this.browserstackLocal || !this.browserstackLocal.isRunning()) {
+            return;
+        }
+        if (this._options.forcedStop) {
+            return process.kill(this.browserstackLocal.pid);
+        }
+        let timer;
+        PerformanceTester.start(PERFORMANCE_SDK_EVENTS.AUTOMATE_EVENTS.LOCAL_STOP);
+        return Promise.race([
+            new Promise((resolve, reject) => {
+                this.browserstackLocal?.stop((err) => {
+                    if (err) {
+                        return reject(err);
+                    }
+                    resolve();
+                });
+            }),
+            new Promise((resolve, reject) => {
+                /* istanbul ignore next */
+                timer = setTimeout(() => reject(new Error('Browserstack Local failed to stop within 60 seconds!')), 60000);
+            })
+        ]).then(function (result) {
+            clearTimeout(timer);
+            PerformanceTester.end(PERFORMANCE_SDK_EVENTS.AUTOMATE_EVENTS.LOCAL_STOP);
+            return Promise.resolve(result);
+        }, function (err) {
+            PerformanceTester.end(PERFORMANCE_SDK_EVENTS.AUTOMATE_EVENTS.LOCAL_STOP, false, err);
+            clearTimeout(timer);
+            return Promise.reject(err);
+        });
+    }
+    async setupPercy(options, config, bsConfig) {
+        if (this._percy?.isRunning()) {
+            process.env[BROWSERSTACK_PERCY] = 'true';
+            return;
+        }
+        try {
+            this._percy = await startPercy(options, config, bsConfig);
+            if (!this._percy) {
+                throw new Error('Could not start percy, check percy logs for info.');
+            }
+            PercyLogger.info('Percy started successfully');
+            process.env[BROWSERSTACK_PERCY] = 'true';
+            let signal = 0;
+            const handler = async () => {
+                signal++;
+                signal === 1 && await this.stopPercy();
+            };
+            process.on('beforeExit', handler);
+            process.on('SIGINT', handler);
+            process.on('SIGTERM', handler);
+        }
+        catch (err) {
+            PercyLogger.debug(`Error in percy setup ${err}`);
+            process.env[BROWSERSTACK_PERCY] = 'false';
+        }
+    }
+    async stopPercy() {
+        if (!this._percy || !this._percy.isRunning()) {
+            return;
+        }
+        try {
+            await stopPercy(this._percy);
+            PercyLogger.info('Percy stopped');
+        }
+        catch (err) {
+            PercyLogger.error('Error occured while stopping percy : ' + err);
+        }
+    }
+    async _uploadApp(app) {
+        BStackLogger.info(`uploading app ${app.app} ${app.customId ? `and custom_id: ${app.customId}` : ''} to browserstack`);
+        const form = new FormData();
+        if (app.app) {
+            const fileName = path.basename(app.app);
+            form.append('file', new FileStream(fs.createReadStream(app.app)), fileName);
+        }
+        if (app.customId) {
+            form.append('custom_id', app.customId);
+        }
+        const res = await got.post(`${APIUtils.BROWSERSTACK_AA_API_CLOUD_URL}/app-automate/upload`, {
+            body: form,
+            username: this._config.user,
+            password: this._config.key
+        }).json().catch((err) => {
+            throw new SevereServiceError(`app upload failed ${err.message}`);
+        });
+        return res;
+    }
+    /**
+     * @param  {String | AppConfig}  appConfig    <string>: should be "app file path" or "app_url" or "custom_id" or "shareable_id".
+     *                                            <object>: only "path" and "custom_id" should coexist as multiple properties.
+     */
+    async _validateApp(appConfig) {
+        const app = {};
+        if (typeof appConfig === 'string') {
+            app.app = appConfig;
+        }
+        else if (typeof appConfig === 'object' && Object.keys(appConfig).length) {
+            if (Object.keys(appConfig).length > 2 || (Object.keys(appConfig).length === 2 && (!appConfig.path || !appConfig.custom_id))) {
+                throw new SevereServiceError(`keys ${Object.keys(appConfig)} can't co-exist as app values, use any one property from
+                            {id<string>, path<string>, custom_id<string>, shareable_id<string>}, only "path" and "custom_id" can co-exist.`);
+            }
+            app.app = appConfig.id || appConfig.path || appConfig.custom_id || appConfig.shareable_id;
+            app.customId = appConfig.custom_id;
+        }
+        else {
+            throw new SevereServiceError('[Invalid format] app should be string or an object');
+        }
+        if (!app.app) {
+            throw new SevereServiceError(`[Invalid app property] supported properties are {id<string>, path<string>, custom_id<string>, shareable_id<string>}.
+                        For more details please visit https://www.browserstack.com/docs/app-automate/appium/set-up-tests/specify-app ')`);
+        }
+        return app;
+    }
+    async _uploadServiceLogs() {
+        const clientBuildUuid = this._getClientBuildUuid();
+        await PerformanceTester.measureWrapper(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_UPLOAD_LOGS, async () => {
+            const response = await uploadLogs(getBrowserStackUser(this._config), getBrowserStackKey(this._config), clientBuildUuid);
+            BStackLogger.logToFile(`Response - ${format(response)}`, 'debug');
+        })();
+    }
+    _removeCliOnlyCapabilityOptions(capabilities) {
+        if (!capabilities || typeof capabilities !== 'object') {
+            return;
+        }
+        const strip = (capability) => {
+            const capabilityRecord = capability;
+            const bstackOptions = capabilityRecord['bstack:options'];
+            if (bstackOptions && typeof bstackOptions === 'object') {
+                NOT_ALLOWED_KEYS_IN_CAPS.forEach(key => delete bstackOptions[key]);
+            }
+            NOT_ALLOWED_KEYS_IN_CAPS.forEach(key => delete capabilityRecord[`browserstack.${key}`]);
+            const alwaysMatch = capability.alwaysMatch;
+            if (alwaysMatch && typeof alwaysMatch === 'object') {
+                strip(alwaysMatch);
+            }
+        };
+        if (Array.isArray(capabilities)) {
+            capabilities
+                .flatMap((c) => {
+                if (Object.values(c).length > 0 && Object.values(c).every(c => typeof c === 'object' && c.capabilities)) {
+                    return Object.values(c).map((o) => o.capabilities);
+                }
+                return c;
+            })
+                .forEach(strip);
+        }
+        else {
+            Object.entries(capabilities).forEach(([, caps]) => {
+                strip(caps.capabilities);
+            });
+        }
+    }
+    _updateObjectTypeCaps(capabilities, capType, value) {
+        try {
+            if (Array.isArray(capabilities)) {
+                capabilities
+                    .flatMap((c) => {
+                    if (Object.values(c).length > 0 && Object.values(c).every(c => typeof c === 'object' && c.capabilities)) {
+                        return Object.values(c).map((o) => o.capabilities);
+                    }
+                    return c;
+                })
+                    .forEach((capability) => {
+                    if (validateCapsWithNonBstackA11y(capability.browserName, capability.browserVersion)) {
+                        if (capType === 'goog:chromeOptions' && value) {
+                            const chromeOptions = capability['goog:chromeOptions'];
+                            if (chromeOptions) {
+                                const finalChromeOptions = mergeChromeOptions(chromeOptions, value);
+                                capability['goog:chromeOptions'] = finalChromeOptions;
+                            }
+                            else {
+                                capability['goog:chromeOptions'] = value;
+                            }
+                            return;
+                        }
+                    }
+                    if (!capability['bstack:options']) {
+                        const extensionCaps = Object.keys(capability).filter((cap) => cap.includes(':'));
+                        if (extensionCaps.length) {
+                            if (capType === 'accessibilityOptions' && value) {
+                                capability['bstack:options'] = { accessibilityOptions: value };
+                            }
+                        }
+                        else if (capType === 'accessibilityOptions') {
+                            if (value) {
+                                const accessibilityOpts = { ...value };
+                                if (capability?.accessibility) {
+                                    accessibilityOpts.authToken = process.env.BSTACK_A11Y_JWT;
+                                    accessibilityOpts.scannerVersion = process.env.BSTACK_A11Y_SCANNER_VERSION;
+                                }
+                                capability['browserstack.accessibilityOptions'] = accessibilityOpts;
+                            }
+                            else {
+                                delete capability['browserstack.accessibilityOptions'];
+                            }
+                        }
+                    }
+                    else if (capType === 'accessibilityOptions') {
+                        if (value) {
+                            const accessibilityOpts = { ...value };
+                            if (capability['bstack:options'].accessibility) {
+                                accessibilityOpts.authToken = process.env.BSTACK_A11Y_JWT;
+                                accessibilityOpts.scannerVersion = process.env.BSTACK_A11Y_SCANNER_VERSION;
+                            }
+                            capability['bstack:options'].accessibilityOptions = accessibilityOpts;
+                        }
+                        else {
+                            delete capability['bstack:options'].accessibilityOptions;
+                        }
+                    }
+                });
+            }
+            else if (typeof capabilities === 'object') {
+                Object.entries(capabilities).forEach(([, caps]) => {
+                    if (validateCapsWithNonBstackA11y(caps.capabilities.browserName, caps.capabilities.browserVersion)) {
+                        if (capType === 'goog:chromeOptions' && value) {
+                            const chromeOptions = caps.capabilities['goog:chromeOptions'];
+                            if (chromeOptions) {
+                                const finalChromeOptions = mergeChromeOptions(chromeOptions, value);
+                                caps.capabilities['goog:chromeOptions'] = finalChromeOptions;
+                            }
+                            else {
+                                caps.capabilities['goog:chromeOptions'] = value;
+                            }
+                            return;
+                        }
+                    }
+                    if (!caps.capabilities['bstack:options']) {
+                        const extensionCaps = Object.keys(caps.capabilities).filter((cap) => cap.includes(':'));
+                        if (extensionCaps.length) {
+                            if (capType === 'accessibilityOptions' && value) {
+                                caps.capabilities['bstack:options'] = { accessibilityOptions: value };
+                            }
+                        }
+                        else if (capType === 'accessibilityOptions') {
+                            if (value) {
+                                const accessibilityOpts = { ...value };
+                                if (caps.capabilities['browserstack.accessibility']) {
+                                    accessibilityOpts.authToken = process.env.BSTACK_A11Y_JWT;
+                                    accessibilityOpts.scannerVersion = process.env.BSTACK_A11Y_SCANNER_VERSION;
+                                }
+                                caps.capabilities['browserstack.accessibilityOptions'] = accessibilityOpts;
+                            }
+                            else {
+                                delete caps.capabilities['browserstack.accessibilityOptions'];
+                            }
+                        }
+                    }
+                    else if (capType === 'accessibilityOptions') {
+                        if (value) {
+                            const accessibilityOpts = { ...value };
+                            if (caps.capabilities['bstack:options'].accessibility) {
+                                accessibilityOpts.authToken = process.env.BSTACK_A11Y_JWT;
+                                accessibilityOpts.scannerVersion = process.env.BSTACK_A11Y_SCANNER_VERSION;
+                            }
+                            caps.capabilities['bstack:options'].accessibilityOptions = accessibilityOpts;
+                        }
+                        else {
+                            delete caps.capabilities['bstack:options'].accessibilityOptions;
+                        }
+                    }
+                });
+            }
+        }
+        catch (error) {
+            BStackLogger.debug(`Exception while retrieving capability value. Error - ${error}`);
+        }
+    }
+    _updateCaps(capabilities, capType, value) {
+        if (Array.isArray(capabilities)) {
+            capabilities
+                .flatMap((c) => {
+                if (Object.values(c).length > 0 && Object.values(c).every(c => typeof c === 'object' && c.capabilities)) {
+                    return Object.values(c).map((o) => o.capabilities);
+                }
+                return c;
+            })
+                .forEach((capability) => {
+                if (!capability['bstack:options']) {
+                    const extensionCaps = Object.keys(capability).filter((cap) => cap.includes(':'));
+                    if (extensionCaps.length) {
+                        if (capType === 'local') {
+                            capability['bstack:options'] = { local: true };
+                        }
+                        else if (capType === 'app') {
+                            capability['appium:app'] = value;
+                        }
+                        else if (capType === 'buildIdentifier' && value) {
+                            capability['bstack:options'] = { buildIdentifier: value };
+                        }
+                        else if (capType === 'testhubBuildUuid' && TestOpsConfig.getInstance().buildHashedId) {
+                            capability['bstack:options'] = { testhubBuildUuid: TestOpsConfig.getInstance().buildHashedId };
+                        }
+                        else if (capType === 'buildProductMap' && getProductMap(this.browserStackConfig)) {
+                            capability['bstack:options'] = { buildProductMap: getProductMap(this.browserStackConfig) };
+                        }
+                        else if (capType === 'accessibility') {
+                            capability['bstack:options'] = { accessibility: getBooleanValueFromString(value) };
+                        }
+                    }
+                    else if (capType === 'local') {
+                        capability['browserstack.local'] = true;
+                    }
+                    else if (capType === 'app') {
+                        capability.app = value;
+                    }
+                    else if (capType === 'buildIdentifier') {
+                        if (value) {
+                            capability['browserstack.buildIdentifier'] = value;
+                        }
+                        else {
+                            delete capability['browserstack.buildIdentifier'];
+                        }
+                    }
+                    else if (capType === 'localIdentifier') {
+                        capability['browserstack.localIdentifier'] = value;
+                    }
+                    else if (capType === 'testhubBuildUuid') {
+                        capability['browserstack.testhubBuildUuid'] = TestOpsConfig.getInstance().buildHashedId;
+                    }
+                    else if (capType === 'buildProductMap') {
+                        capability['browserstack.buildProductMap'] = getProductMap(this.browserStackConfig);
+                    }
+                    else if (capType === 'accessibility') {
+                        capability['browserstack.accessibility'] = getBooleanValueFromString(value);
+                    }
+                }
+                else if (capType === 'local') {
+                    capability['bstack:options'].local = true;
+                }
+                else if (capType === 'app') {
+                    capability['appium:app'] = value;
+                }
+                else if (capType === 'buildIdentifier') {
+                    if (value) {
+                        capability['bstack:options'].buildIdentifier = value;
+                    }
+                    else {
+                        delete capability['bstack:options'].buildIdentifier;
+                    }
+                }
+                else if (capType === 'localIdentifier') {
+                    capability['bstack:options'].localIdentifier = value;
+                }
+                else if (capType === 'testhubBuildUuid') {
+                    capability['bstack:options'].testhubBuildUuid = TestOpsConfig.getInstance().buildHashedId;
+                }
+                else if (capType === 'buildProductMap') {
+                    capability['bstack:options'].buildProductMap = getProductMap(this.browserStackConfig);
+                }
+                else if (capType === 'accessibility') {
+                    capability['bstack:options'].accessibility = getBooleanValueFromString(value);
+                }
+            });
+        }
+        else if (typeof capabilities === 'object') {
+            Object.entries(capabilities).forEach(([, caps]) => {
+                if (!caps.capabilities['bstack:options']) {
+                    const extensionCaps = Object.keys(caps.capabilities).filter((cap) => cap.includes(':'));
+                    if (extensionCaps.length) {
+                        if (capType === 'local') {
+                            caps.capabilities['bstack:options'] = { local: true };
+                        }
+                        else if (capType === 'app') {
+                            caps.capabilities['appium:app'] = value;
+                        }
+                        else if (capType === 'buildIdentifier' && value) {
+                            caps.capabilities['bstack:options'] = { buildIdentifier: value };
+                        }
+                        else if (capType === 'testhubBuildUuid') {
+                            caps.capabilities['bstack:options'] = { testhubBuildUuid: TestOpsConfig.getInstance().buildHashedId };
+                        }
+                        else if (capType === 'buildProductMap') {
+                            caps.capabilities['bstack:options'] = { buildProductMap: getProductMap(this.browserStackConfig) };
+                        }
+                        else if (capType === 'accessibility') {
+                            caps.capabilities['bstack:options'] = { accessibility: getBooleanValueFromString(value) };
+                        }
+                    }
+                    else if (capType === 'local') {
+                        caps.capabilities['browserstack.local'] = true;
+                    }
+                    else if (capType === 'app') {
+                        caps.capabilities['appium:app'] = value;
+                    }
+                    else if (capType === 'buildIdentifier') {
+                        if (value) {
+                            caps.capabilities['browserstack.buildIdentifier'] = value;
+                        }
+                        else {
+                            delete caps.capabilities['browserstack.buildIdentifier'];
+                        }
+                    }
+                    else if (capType === 'localIdentifier') {
+                        caps.capabilities['browserstack.localIdentifier'] = value;
+                    }
+                    else if (capType === 'testhubBuildUuid') {
+                        caps.capabilities['browserstack.testhubBuildUuid'] = TestOpsConfig.getInstance().buildHashedId;
+                    }
+                    else if (capType === 'buildProductMap') {
+                        caps.capabilities['browserstack.buildProductMap'] = getProductMap(this.browserStackConfig);
+                    }
+                    else if (capType === 'accessibility') {
+                        caps.capabilities['browserstack.accessibility'] = getBooleanValueFromString(value);
+                    }
+                }
+                else if (capType === 'local') {
+                    caps.capabilities['bstack:options'].local = true;
+                }
+                else if (capType === 'app') {
+                    caps.capabilities['appium:app'] = value;
+                }
+                else if (capType === 'buildIdentifier') {
+                    if (value) {
+                        caps.capabilities['bstack:options'].buildIdentifier = value;
+                    }
+                    else {
+                        delete caps.capabilities['bstack:options'].buildIdentifier;
+                    }
+                }
+                else if (capType === 'localIdentifier') {
+                    caps.capabilities['bstack:options'].localIdentifier = value;
+                }
+                else if (capType === 'testhubBuildUuid') {
+                    caps.capabilities['bstack:options'].testhubBuildUuid = TestOpsConfig.getInstance().buildHashedId;
+                }
+                else if (capType === 'buildProductMap') {
+                    caps.capabilities['bstack:options'].buildProductMap = getProductMap(this.browserStackConfig);
+                }
+                else if (capType === 'accessibility') {
+                    caps.capabilities['bstack:options'].accessibility = getBooleanValueFromString(value);
+                }
+            });
+        }
+        else {
+            throw new SevereServiceError('Capabilities should be an object or Array!');
+        }
+    }
+    _updateBrowserStackPercyConfig() {
+        const { percyAutoEnabled = false, percyCaptureMode, buildId, percy } = this._percy || {};
+        // Setting to browserStackConfig for populating data in funnel instrumentaion
+        this.browserStackConfig.percyCaptureMode = percyCaptureMode;
+        this.browserStackConfig.percyBuildId = buildId;
+        this.browserStackConfig.isPercyAutoEnabled = percyAutoEnabled;
+        // To handle stop percy build
+        this._options.percy = percy;
+        // To pass data to workers
+        process.env.BROWSERSTACK_PERCY = String(percy);
+        process.env.BROWSERSTACK_PERCY_CAPTURE_MODE = percyCaptureMode;
+    }
+    _handleBuildIdentifier(capabilities) {
+        if (!this._buildIdentifier) {
+            return;
+        }
+        if ((!this._buildName || process.env.BROWSERSTACK_BUILD_NAME) && this._buildIdentifier) {
+            this._updateCaps(capabilities, 'buildIdentifier');
+            BStackLogger.warn('Skipping buildIdentifier as buildName is not passed.');
+            return;
+        }
+        if (this._buildIdentifier && this._buildIdentifier.includes('${DATE_TIME}')) {
+            const formattedDate = new Intl.DateTimeFormat('en-GB', {
+                month: 'short',
+                day: '2-digit',
+                hour: '2-digit',
+                minute: '2-digit',
+                hour12: false
+            })
+                .format(new Date())
+                .replace(/ |, /g, '-');
+            this._buildIdentifier = this._buildIdentifier.replace('${DATE_TIME}', formattedDate);
+            this._updateCaps(capabilities, 'buildIdentifier', this._buildIdentifier);
+        }
+        if (!this._buildIdentifier.includes('${BUILD_NUMBER}')) {
+            return;
+        }
+        const ciInfo = getCiInfo();
+        if (ciInfo !== null && ciInfo.build_number) {
+            this._buildIdentifier = this._buildIdentifier.replace('${BUILD_NUMBER}', 'CI ' + ciInfo.build_number);
+            this._updateCaps(capabilities, 'buildIdentifier', this._buildIdentifier);
+        }
+        else {
+            const localBuildNumber = this._getLocalBuildNumber();
+            if (localBuildNumber) {
+                this._buildIdentifier = this._buildIdentifier.replace('${BUILD_NUMBER}', localBuildNumber);
+                this._updateCaps(capabilities, 'buildIdentifier', this._buildIdentifier);
+            }
+        }
+    }
+    /**
+     * @return {string} if buildName doesn't exist in json file, it will return 1
+     *                  else returns corresponding value in json file (e.g. { "wdio-build": { "identifier" : 2 } } => 2 in this case)
+     */
+    _getLocalBuildNumber() {
+        const browserstackFolderPath = path.join(os.homedir(), '.browserstack');
+        try {
+            if (!fs.existsSync(browserstackFolderPath)) {
+                fs.mkdirSync(browserstackFolderPath);
+            }
+            const filePath = path.join(browserstackFolderPath, '.build-name-cache.json');
+            if (!fs.existsSync(filePath)) {
+                fs.appendFileSync(filePath, JSON.stringify({}));
+            }
+            const buildCacheFileData = fs.readFileSync(filePath);
+            const parsedBuildCacheFileData = JSON.parse(buildCacheFileData.toString());
+            if (this._buildName && this._buildName in parsedBuildCacheFileData) {
+                const prevIdentifier = parseInt((parsedBuildCacheFileData[this._buildName].identifier));
+                const newIdentifier = prevIdentifier + 1;
+                this._updateLocalBuildCache(filePath, this._buildName, newIdentifier);
+                return newIdentifier.toString();
+            }
+            const newIdentifier = 1;
+            this._updateLocalBuildCache(filePath, this._buildName, 1);
+            return newIdentifier.toString();
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    _updateLocalBuildCache(filePath, buildName, buildIdentifier) {
+        if (!buildName || !filePath) {
+            return;
+        }
+        const jsonContent = JSON.parse(fs.readFileSync(filePath).toString());
+        jsonContent[buildName] = { 'identifier': buildIdentifier };
+        fs.writeFileSync(filePath, JSON.stringify(jsonContent));
+    }
+    _getClientBuildUuid() {
+        if (process.env[BROWSERSTACK_TESTHUB_UUID]) {
+            return process.env[BROWSERSTACK_TESTHUB_UUID];
+        }
+        const uuid = uuidv4();
+        BStackLogger.logToFile(`If facing any issues, please contact BrowserStack support with the Build Run Id - ${uuid}`, 'info');
+        return uuid;
+    }
+}
+__decorate([
+    PerformanceTester.Measure(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_SETUP)
+], BrowserstackLauncherService.prototype, "onWorkerStart", null);
+__decorate([
+    PerformanceTester.Measure(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_PRE_TEST)
+], BrowserstackLauncherService.prototype, "onPrepare", null);
+__decorate([
+    PerformanceTester.Measure(PERFORMANCE_SDK_EVENTS.APP_AUTOMATE_EVENTS.APP_UPLOAD)
+], BrowserstackLauncherService.prototype, "_uploadApp", null);
+//# sourceMappingURL=launcher.js.map