@wdio/browserstack-service 0.0.0-canary-20260722132416

package/build/service.js

@@ -0,0 +1,740 @@
+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 { getBrowserDescription, getBrowserCapabilities, isBrowserstackCapability, getParentSuiteName, isBrowserstackSession, patchConsoleLogs, shouldAddServiceVersion, isTrue, normalizeTestReportingConfig, normalizeTestReportingEnvVariables } from './util.js';
+import InsightsHandler from './insights-handler.js';
+import TestReporter from './reporter.js';
+import { DEFAULT_OPTIONS, NOT_ALLOWED_KEYS_IN_CAPS, PERF_MEASUREMENT_ENV } from './constants.js';
+import CrashReporter from './crash-reporter.js';
+import AccessibilityHandler from './accessibility-handler.js';
+import { BStackLogger } from './bstackLogger.js';
+import PercyHandler from './Percy/Percy-Handler.js';
+import Listener from './testOps/listener.js';
+import { saveWorkerData } from './data-store.js';
+import UsageStats from './testOps/usageStats.js';
+import { shouldProcessEventForTesthub } from './testHub/utils.js';
+import AiHandler from './ai-handler.js';
+import PerformanceTester from './instrumentation/performance/performance-tester.js';
+import * as PERFORMANCE_SDK_EVENTS from './instrumentation/performance/constants.js';
+import { EVENTS } from './instrumentation/performance/constants.js';
+import { BrowserstackCLI } from './cli/index.js';
+import { TestFrameworkState } from './cli/states/testFrameworkState.js';
+import { HookState } from './cli/states/hookState.js';
+import { AutomationFrameworkState } from './cli/states/automationFrameworkState.js';
+import TestFramework from './cli/frameworks/testFramework.js';
+import { TestFrameworkConstants } from './cli/frameworks/constants/testFrameworkConstants.js';
+import { AutomationFrameworkConstants } from './cli/frameworks/constants/automationFrameworkConstants.js';
+import AutomationFramework from './cli/frameworks/automationFramework.js';
+import util from 'node:util';
+import APIUtils from './cli/apiUtils.js';
+import { CLIUtils } from './cli/cliUtils.js';
+export default class BrowserstackService {
+    _caps;
+    _config;
+    _sessionBaseUrl = `${APIUtils.BROWSERSTACK_AUTOMATE_API_URL}/automate/sessions`;
+    _failReasons = [];
+    _hookFailReasons = [];
+    _pureTestFailReasons = [];
+    _scenariosThatRan = [];
+    _failureStatuses = ['failed', 'ambiguous', 'undefined', 'unknown'];
+    _browser;
+    _suiteTitle;
+    _suiteFile;
+    _fullTitle;
+    _options;
+    _specsRan = false;
+    _observability;
+    _currentTest;
+    _insightsHandler;
+    _accessibility;
+    _accessibilityHandler;
+    _percy;
+    _percyCaptureMode = undefined;
+    _percyHandler;
+    _turboScale;
+    constructor(options, _caps, _config) {
+        this._caps = _caps;
+        this._config = _config;
+        this._options = { ...DEFAULT_OPTIONS, ...options };
+        // added to maintain backward compatibility with webdriverIO v5
+        this._config || (this._config = this._options);
+        normalizeTestReportingConfig(this._options);
+        normalizeTestReportingEnvVariables();
+        this._observability = this._options.testObservability;
+        this._accessibility = this._options.accessibility;
+        this._percy = isTrue(process.env.BROWSERSTACK_PERCY);
+        this._percyCaptureMode = process.env.BROWSERSTACK_PERCY_CAPTURE_MODE;
+        this._turboScale = this._options.turboScale;
+        PerformanceTester.startMonitoring('performance-report-service.csv');
+        if (shouldProcessEventForTesthub('')) {
+            this._config.reporters?.push(TestReporter);
+        }
+        if (process.env.BROWSERSTACK_TURBOSCALE) {
+            this._turboScale = process.env.BROWSERSTACK_TURBOSCALE === 'true';
+        }
+        process.env.BROWSERSTACK_TURBOSCALE_INTERNAL = String(this._turboScale);
+        // Cucumber specific
+        const strict = Boolean(this._config.cucumberOpts && this._config.cucumberOpts.strict);
+        // See https://github.com/cucumber/cucumber-js/blob/master/src/runtime/index.ts#L136
+        if (strict) {
+            this._failureStatuses.push('pending');
+        }
+        if (process.env.WDIO_WORKER_ID === process.env.BEST_PLATFORM_CID) {
+            process.env.PERCY_SNAPSHOT = 'true';
+        }
+    }
+    _updateCaps(fn) {
+        const multiRemoteCap = this._caps;
+        if (multiRemoteCap.capabilities) {
+            return Object.entries(multiRemoteCap).forEach(([, caps]) => fn(caps.capabilities));
+        }
+        return fn(this._caps);
+    }
+    async beforeSession(config, capabilities) {
+        PerformanceTester.start(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.INIT);
+        // if no user and key is specified even though a browserstack service was
+        // provided set user and key with values so that the session request
+        // will fail
+        const testObservabilityOptions = this._options.testObservabilityOptions;
+        if (!config.user && !(testObservabilityOptions && testObservabilityOptions.user)) {
+            config.user = 'NotSetUser';
+        }
+        if (!config.key && !(testObservabilityOptions && testObservabilityOptions.key)) {
+            config.key = 'NotSetKey';
+        }
+        this._config.user = config.user;
+        this._config.key = config.key;
+        try {
+            // Detect if multi-remote and disable CLI for those sessions
+            if (CLIUtils.checkCLISupportedFrameworks(this._config.framework) && process.env.BROWSERSTACK_IS_MULTIREMOTE !== 'true') {
+                // Connect to Browserstack CLI from worker
+                await BrowserstackCLI.getInstance().bootstrap(this._options, this._config);
+                // Get the nearest hub and update it in config
+                PerformanceTester.start(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_FIND_NEAREST_HUB);
+                const hubUrl = BrowserstackCLI.getInstance().getConfig().hubUrl;
+                if (hubUrl) {
+                    this._config.hostname = new URL(hubUrl).hostname;
+                    PerformanceTester.end(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_FIND_NEAREST_HUB);
+                }
+                else {
+                    PerformanceTester.end(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_FIND_NEAREST_HUB, false, 'Hub URL not found');
+                }
+            }
+            if (BrowserstackCLI.getInstance().isRunning()) {
+                await BrowserstackCLI.getInstance().getAutomationFramework().trackEvent(AutomationFrameworkState.CREATE, HookState.PRE, { caps: capabilities });
+                const instance = AutomationFramework.getTrackedInstance();
+                const caps = AutomationFramework.getState(instance, AutomationFrameworkConstants.KEY_CAPABILITIES);
+                Object.assign(capabilities, caps);
+                // Strip CLI-only options that BrowserStack hub doesn't accept
+                const bstackOptions = capabilities['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 capabilities[`browserstack.${key}`]);
+            }
+        }
+        catch (err) {
+            BStackLogger.error(`Error while connecting to Browserstack CLI: ${err}`);
+            PerformanceTester.end(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.INIT, false, util.format(err));
+            throw err;
+        }
+        PerformanceTester.end(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.INIT);
+        // Start tracking device allocation - this measures the gap between beforeSession end and before start
+        // This captures the time WebDriverIO takes to create the remote session with BrowserStack
+        PerformanceTester.start(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_DEVICE_ALLOCATION);
+        BStackLogger.debug('Device allocation tracking started - waiting for WebDriverIO to create remote session');
+    }
+    async before(caps, specs, browser) {
+        // End device allocation tracking - remote session is now created and browser object is available
+        PerformanceTester.end(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_DEVICE_ALLOCATION, true, 'Device allocated and session created');
+        BStackLogger.debug('Device allocation tracking ended - remote session created successfully');
+        PerformanceTester.start(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.PRE_INITIALIZE);
+        // added to maintain backward compatibility with webdriverIO v5
+        this._browser = browser ? browser : globalThis.browser;
+        PerformanceTester.browser = this._browser;
+        // Healing Support:
+        if (!shouldAddServiceVersion(this._config, this._options.testObservability, caps)) {
+            try {
+                await AiHandler.selfHeal(this._options, caps, this._browser);
+            }
+            catch (err) {
+                if (this._options.selfHeal === true) {
+                    BStackLogger.warn(`Error while setting up self-healing: ${err}. Disabling healing for this session.`);
+                }
+            }
+        }
+        // Ensure capabilities are not null in case of multiremote
+        if (this._isAppAutomate()) {
+            this._sessionBaseUrl = `${APIUtils.BROWSERSTACK_AA_API_CLOUD_URL}/app-automate/sessions`;
+        }
+        if (this._turboScale) {
+            this._sessionBaseUrl = `${APIUtils.BROWSERSTACK_AUTOMATE_API_URL}/automate-turboscale/v1/sessions`;
+        }
+        this._scenariosThatRan = [];
+        PerformanceTester.scenarioThatRan = [...(this._scenariosThatRan ?? [])];
+        if (this._browser) {
+            try {
+                const sessionId = this._browser.sessionId;
+                try {
+                    this._accessibilityHandler = new AccessibilityHandler(this._browser, this._caps, this._options, this._isAppAutomate(), this._config, this._config.framework, this._accessibility, this._turboScale, this._options.accessibilityOptions);
+                    if (isBrowserstackSession(this._browser) && BrowserstackCLI.getInstance().isRunning()) {
+                        BStackLogger.info(`CLI is running, tracking accessibility event for before: ${sessionId}`);
+                        // BrowserstackCLI.getInstance().getTestFramework()!.trackEvent(AutomationFrameworkState.CREATE, HookState.POST, { sessionId })
+                    }
+                    else {
+                        await this._accessibilityHandler.before(sessionId);
+                    }
+                    Listener.setAccessibilityOptions(this._options.accessibilityOptions);
+                }
+                catch (err) {
+                    BStackLogger.error(`[Accessibility Test Run] Error in service class before function: ${err}`);
+                }
+                if (shouldProcessEventForTesthub('')) {
+                    patchConsoleLogs();
+                    this._insightsHandler = new InsightsHandler(this._browser, this._config.framework, this._caps, this._options);
+                    if (BrowserstackCLI.getInstance().isRunning()) {
+                        await BrowserstackCLI.getInstance().getAutomationFramework().trackEvent(AutomationFrameworkState.CREATE, HookState.POST, { browser: this._browser, hubUrl: this._config.hostname });
+                        this._insightsHandler.setGitConfigPath();
+                        /**
+                         * SDK-6277: register the command/result listeners in the CLI/binary flow too,
+                         * so the user's saveScreenshot()/takeScreenshot() command result is captured and
+                         * forwarded for screenshot-on-failure. Without this the screenshot is dropped in v8.
+                         * (browserCommand routes the screenshot over gRPC in CLI mode — see insights-handler.)
+                         */
+                        // 'client:beforeCommand' only records the command synchronously — no await needed.
+                        this._browser.on('command', (command) => {
+                            if (shouldProcessEventForTesthub('')) {
+                                this._insightsHandler?.browserCommand('client:beforeCommand', Object.assign(command, { sessionId }), this._currentTest);
+                            }
+                        });
+                        this._browser.on('result', (result) => {
+                            if (shouldProcessEventForTesthub('')) {
+                                // 'client:afterCommand' is async in CLI mode (forwards the screenshot to the
+                                // binary over gRPC). Handle the returned promise so a failed upload is logged
+                                // rather than dropped. (o11yClassErrorHandler also routes method errors to
+                                // processError; this .catch makes the call-site handling explicit.)
+                                this._insightsHandler?.browserCommand('client:afterCommand', Object.assign(result, { sessionId }), this._currentTest)?.catch((err) => BStackLogger.debug(`Error forwarding afterCommand in CLI mode: ${err}`));
+                            }
+                        });
+                        PerformanceTester.end(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.PRE_INITIALIZE);
+                        return;
+                    }
+                    await this._insightsHandler.before();
+                }
+                if (!BrowserstackCLI.getInstance().isRunning()) {
+                    /**
+                     * register command event
+                     */
+                    this._browser.on('command', async (command) => {
+                        if (shouldProcessEventForTesthub('')) {
+                            this._insightsHandler?.browserCommand('client:beforeCommand', Object.assign(command, { sessionId }), this._currentTest);
+                        }
+                        await this._percyHandler?.browserBeforeCommand(Object.assign(command, { sessionId }));
+                    });
+                    /**
+                     * register result event
+                     */
+                    this._browser.on('result', (result) => {
+                        if (shouldProcessEventForTesthub('')) {
+                            this._insightsHandler?.browserCommand('client:afterCommand', Object.assign(result, { sessionId }), this._currentTest);
+                        }
+                        this._percyHandler?.browserAfterCommand(Object.assign(result, { sessionId }));
+                    });
+                }
+            }
+            catch (err) {
+                BStackLogger.error(`Error in service class before function: ${err}`);
+                if (shouldProcessEventForTesthub('')) {
+                    CrashReporter.uploadCrashReport(`Error in service class before function: ${err}`, err && err.stack);
+                }
+            }
+            if (!BrowserstackCLI.getInstance().isRunning()) {
+                if (this._percy) {
+                    this._percyHandler = new PercyHandler(this._percyCaptureMode, this._browser, this._caps, this._isAppAutomate(), this._config.framework);
+                    this._percyHandler.before();
+                }
+            }
+        }
+        PerformanceTester.end(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.PRE_INITIALIZE);
+        PerformanceTester.start(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.POST_INITIALIZE);
+        const result = await this._printSessionURL();
+        PerformanceTester.end(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.POST_INITIALIZE);
+        return result;
+    }
+    /**
+     * Set the default job name at the suite level to make sure we account
+     * for the cases where there is a long running `before` function for a
+     * suite or one that can fail.
+     * Don't do this for Jasmine because `suite.title` is `Jasmine__TopLevel__Suite`
+     * and `suite.fullTitle` is `undefined`, so no alternative to use for the job name.
+     */
+    async beforeSuite(suite) {
+        this._suiteTitle = suite.title;
+        this._insightsHandler?.setSuiteFile(suite.file);
+        this._accessibilityHandler?.setSuiteFile(suite.file);
+        if (suite.title && suite.title !== 'Jasmine__TopLevel__Suite') {
+            if (!BrowserstackCLI.getInstance().isRunning() || this._config.framework !== 'mocha') {
+                await this._setSessionName(suite.title);
+            }
+        }
+    }
+    async beforeHook(test, context) {
+        if (this._config.framework !== 'cucumber') {
+            this._currentTest = test; // not update currentTest when this is called for cucumber step
+        }
+        await this._insightsHandler?.beforeHook(test, context);
+    }
+    async afterHook(test, context, result) {
+        // Track hook failures separately
+        if (result && !result.passed) {
+            const hookError = (result.error && result.error.message) || 'Hook failed';
+            this._hookFailReasons.push(hookError);
+            // Still add to main failReasons for backward compatibility if ignoreHooksStatus is not enabled
+            if (!this._options.testObservabilityOptions?.ignoreHooksStatus) {
+                this._failReasons.push(hookError);
+            }
+        }
+        await this._insightsHandler?.afterHook(test, result);
+    }
+    async beforeTest(test) {
+        this._currentTest = test;
+        let suiteTitle = this._suiteTitle;
+        if (test.fullName) {
+            // For Jasmine, `suite.title` is `Jasmine__TopLevel__Suite`.
+            // This tweak allows us to set the real suite name.
+            const testSuiteName = test.fullName.slice(0, test.fullName.indexOf(test.description || '') - 1);
+            if (this._suiteTitle === 'Jasmine__TopLevel__Suite') {
+                suiteTitle = testSuiteName;
+            }
+            else if (this._suiteTitle) {
+                suiteTitle = getParentSuiteName(this._suiteTitle, testSuiteName);
+            }
+        }
+        await this._setAnnotation(`Test: ${test.fullName ?? test.title}`);
+        if (BrowserstackCLI.getInstance().isRunning()) {
+            await BrowserstackCLI.getInstance().getTestFramework().trackEvent(TestFrameworkState.INIT_TEST, HookState.PRE, { test });
+            const uuid = TestFramework.getState(TestFramework.getTrackedInstance(), TestFrameworkConstants.KEY_TEST_UUID);
+            this._insightsHandler?.setTestData(test, uuid);
+            await BrowserstackCLI.getInstance().getTestFramework().trackEvent(TestFrameworkState.TEST, HookState.PRE, { test, suiteTitle });
+            return;
+        }
+        await this._setSessionName(suiteTitle, test);
+        await this._accessibilityHandler?.beforeTest(suiteTitle, test);
+        await this._insightsHandler?.beforeTest(test);
+    }
+    async afterTest(test, context, results) {
+        this._specsRan = true;
+        const { error, passed } = results;
+        if (!passed) {
+            const testError = (error && error.message) || 'Unknown Error';
+            this._failReasons.push(testError);
+            // Track this as a pure test failure (not hook-related)
+            this._pureTestFailReasons.push(testError);
+        }
+        if (BrowserstackCLI.getInstance().isRunning()) {
+            await BrowserstackCLI.getInstance().getTestFramework().trackEvent(TestFrameworkState.LOG_REPORT, HookState.POST, { test, result: results });
+            await BrowserstackCLI.getInstance().getTestFramework().trackEvent(TestFrameworkState.TEST, HookState.POST, { test, result: results, suiteTite: this._suiteTitle });
+            return;
+        }
+        await this._accessibilityHandler?.afterTest(this._suiteTitle, test);
+        await this._insightsHandler?.afterTest(test, results);
+        await this._percyHandler?.afterTest();
+    }
+    async after(result) {
+        PerformanceTester.start(PERFORMANCE_SDK_EVENTS.HOOK_EVENTS.AFTER);
+        PerformanceTester.start(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.QUIT);
+        try {
+            if (BrowserstackCLI.getInstance().isRunning()) {
+                await BrowserstackCLI.getInstance().getAutomationFramework().trackEvent(AutomationFrameworkState.EXECUTE, HookState.POST, {});
+            }
+            const { preferScenarioName, setSessionName, setSessionStatus } = this._options;
+            // For Cucumber: Checks scenarios that ran (i.e. not skipped) on the session
+            // Only 1 Scenario ran and option enabled => Redefine session name to Scenario's name
+            if (preferScenarioName && this._scenariosThatRan.length === 1) {
+                this._fullTitle = this._scenariosThatRan.pop();
+            }
+            await PerformanceTester.measureWrapper(PERFORMANCE_SDK_EVENTS.AUTOMATE_EVENTS.SESSION_STATUS, async () => {
+                if (setSessionStatus && !BrowserstackCLI.getInstance().isRunning()) {
+                    const ignoreHooksStatus = this._options.testObservabilityOptions?.ignoreHooksStatus === true;
+                    let sessionStatus;
+                    let failureReason;
+                    if (result === 0 && this._specsRan) {
+                        // Test runner reported success and tests ran
+                        if (ignoreHooksStatus) {
+                            // Only consider pure test failures, ignore hook failures
+                            const hasPureTestFailures = this._pureTestFailReasons.length > 0;
+                            sessionStatus = hasPureTestFailures ? 'failed' : 'passed';
+                            failureReason = hasPureTestFailures ? this._pureTestFailReasons.join('\n') : undefined;
+                        }
+                        else {
+                            // Default behavior: consider all failures including hooks
+                            const hasReasons = this._failReasons.length > 0;
+                            sessionStatus = hasReasons ? 'failed' : 'passed';
+                            failureReason = hasReasons ? this._failReasons.join('\n') : undefined;
+                        }
+                    }
+                    else if (ignoreHooksStatus && this._specsRan) {
+                        // Test runner reported failure but ignoreHooksStatus is enabled
+                        // Check if we only have hook failures and no pure test failures
+                        const hasPureTestFailures = this._pureTestFailReasons.length > 0;
+                        const hasOnlyHookFailures = this._failReasons.length === 0 && this._hookFailReasons.length > 0;
+                        if (hasOnlyHookFailures && !hasPureTestFailures) {
+                            // Only hook failures exist - mark as passed when ignoreHooksStatus is true
+                            sessionStatus = 'passed';
+                            failureReason = undefined;
+                        }
+                        else {
+                            // Pure test failures exist - mark as failed
+                            sessionStatus = 'failed';
+                            failureReason = hasPureTestFailures ? this._pureTestFailReasons.join('\n') : undefined;
+                        }
+                    }
+                    else {
+                        // Default behavior: mark as failed (test runner reported failure or no tests ran)
+                        sessionStatus = 'failed';
+                        if (ignoreHooksStatus && this._pureTestFailReasons.length > 0) {
+                            failureReason = this._pureTestFailReasons.join('\n');
+                        }
+                        else if (this._failReasons.length > 0) {
+                            failureReason = this._failReasons.join('\n');
+                        }
+                        else {
+                            failureReason = undefined;
+                        }
+                    }
+                    BStackLogger.debug(`Setting session status to ${sessionStatus} for sessionId ${this._browser?.sessionId}, failure reason: ${failureReason}`);
+                    await this._updateJob({
+                        status: sessionStatus,
+                        ...(setSessionName ? { name: this._fullTitle } : {}),
+                        ...(failureReason ? { reason: failureReason } : {})
+                    });
+                }
+            })();
+            // Track Listener cleanup
+            PerformanceTester.start(EVENTS.SDK_LISTENER_WORKER_END);
+            await Listener.getInstance().onWorkerEnd();
+            PerformanceTester.end(EVENTS.SDK_LISTENER_WORKER_END, true);
+            // Track Percy teardown (only if CLI is not running)
+            if (!BrowserstackCLI.getInstance().isRunning()) {
+                PerformanceTester.start(EVENTS.SDK_PERCY_TEARDOWN);
+                try {
+                    await this._percyHandler?.teardown();
+                    PerformanceTester.end(EVENTS.SDK_PERCY_TEARDOWN, true);
+                }
+                catch (error) {
+                    PerformanceTester.end(EVENTS.SDK_PERCY_TEARDOWN, false, util.format(error));
+                }
+            }
+            // Track worker data save
+            PerformanceTester.start(EVENTS.SDK_WORKER_SAVE_DATA);
+            this.saveWorkerData();
+            PerformanceTester.end(EVENTS.SDK_WORKER_SAVE_DATA, true);
+            PerformanceTester.end(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.QUIT);
+            PerformanceTester.end(PERFORMANCE_SDK_EVENTS.HOOK_EVENTS.AFTER);
+            // Give the performance observer time to process the last few events
+            // before disconnecting in stopAndGenerate()
+            // await new Promise(resolve => setTimeout(resolve, 100))
+            // Track performance report generation (this is the big operation!)
+            await PerformanceTester.stopAndGenerate('performance-service.html');
+            if (process.env[PERF_MEASUREMENT_ENV]) {
+                PerformanceTester.calculateTimes([
+                    'onRunnerStart', 'onSuiteStart', 'onSuiteEnd',
+                    'onTestStart', 'onTestEnd', 'onTestSkip', 'before',
+                    'beforeHook', 'afterHook', 'beforeTest', 'afterTest',
+                    'uploadPending', 'teardown', 'browserCommand'
+                ]);
+            }
+            // Override process exit when we have only hook failures and ignoreHooksStatus is true
+            const ignoreHooksStatus = this._options.testObservabilityOptions?.ignoreHooksStatus === true;
+            const hasOnlyHookFailures = this._failReasons.length === 0 && this._hookFailReasons.length > 0;
+            const shouldOverrideResult = ignoreHooksStatus && this._specsRan && hasOnlyHookFailures;
+            if (shouldOverrideResult && result !== 0) {
+                return;
+            }
+        }
+        catch (error) {
+            BStackLogger.error(`Error in after hook: ${error}`);
+            PerformanceTester.end(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.QUIT, false, util.format(error));
+            PerformanceTester.end(PERFORMANCE_SDK_EVENTS.HOOK_EVENTS.AFTER, false, util.format(error));
+            await PerformanceTester.stopAndGenerate('performance-service.html');
+        }
+    }
+    /**
+     * For CucumberJS
+     */
+    async beforeFeature(uri, feature) {
+        this._suiteTitle = feature.name;
+        await this._setSessionName(feature.name);
+        await this._setAnnotation(`Feature: ${feature.name}`);
+        await this._insightsHandler?.beforeFeature(uri, feature);
+    }
+    /**
+     * Runs before a Cucumber Scenario.
+     * @param world world object containing information on pickle and test step
+     */
+    async beforeScenario(world) {
+        this._currentTest = world;
+        await this._accessibilityHandler?.beforeScenario(world);
+        await this._insightsHandler?.beforeScenario(world);
+        const scenarioName = world.pickle.name || 'unknown scenario';
+        await this._setAnnotation(`Scenario: ${scenarioName}`);
+    }
+    async afterScenario(world) {
+        this._specsRan = true;
+        const status = world.result?.status.toLowerCase();
+        if (status !== 'skipped') {
+            this._scenariosThatRan.push(world.pickle.name || 'unknown pickle name');
+        }
+        if (status && this._failureStatuses.includes(status)) {
+            const exception = ((world.result && world.result.message) ||
+                (status === 'pending'
+                    ? `Some steps/hooks are pending for scenario "${world.pickle.name}"`
+                    : 'Unknown Error'));
+            // For Cucumber with ignoreHooksStatus, check if failure is due to test steps or hooks
+            const ignoreHooksStatus = this._options.testObservabilityOptions?.ignoreHooksStatus === true;
+            if (ignoreHooksStatus && this._insightsHandler) {
+                // Check if any test steps failed (excluding hook failures)
+                const hasTestStepFailures = this._insightsHandler.hasTestStepFailures(world);
+                if (hasTestStepFailures) {
+                    // Test steps failed - this is a pure test failure, add to both arrays
+                    this._failReasons.push(exception);
+                    this._pureTestFailReasons.push(exception);
+                }
+                // If no test steps failed, this is likely a hook-only failure - don't add to main failure arrays
+            }
+            else {
+                // Default behavior: treat all scenario failures as test failures
+                this._failReasons.push(exception);
+                this._pureTestFailReasons.push(exception);
+            }
+        }
+        await this._accessibilityHandler?.afterScenario(world);
+        await this._insightsHandler?.afterScenario(world);
+        if (!BrowserstackCLI.getInstance().isRunning()) {
+            await this._percyHandler?.afterScenario();
+        }
+    }
+    async beforeStep(step, scenario) {
+        await this._insightsHandler?.beforeStep(step, scenario);
+        await this._setAnnotation(`Step: ${step.keyword}${step.text}`);
+    }
+    async afterStep(step, scenario, result) {
+        await this._insightsHandler?.afterStep(step, scenario, result);
+    }
+    async onReload(oldSessionId, newSessionId) {
+        if (!this._browser) {
+            return Promise.resolve();
+        }
+        const { setSessionName, setSessionStatus } = this._options;
+        const ignoreHooksStatus = this._options.testObservabilityOptions?.ignoreHooksStatus === true;
+        let sessionStatus;
+        let failureReason;
+        if (ignoreHooksStatus) {
+            // Only consider pure test failures, ignore hook failures
+            const hasPureTestFailures = this._pureTestFailReasons.length > 0;
+            sessionStatus = hasPureTestFailures ? 'failed' : 'passed';
+            failureReason = hasPureTestFailures ? this._pureTestFailReasons.join('\n') : undefined;
+        }
+        else {
+            // Default behavior: consider all failures including hooks
+            const hasReasons = this._failReasons.length > 0;
+            sessionStatus = hasReasons ? 'failed' : 'passed';
+            failureReason = hasReasons ? this._failReasons.join('\n') : undefined;
+        }
+        if (!this._browser.isMultiremote) {
+            BStackLogger.info(`Update (reloaded) job with sessionId ${oldSessionId}, ${sessionStatus}`);
+        }
+        else {
+            const browserName = this._browser.instances.filter((browserName) => this._browser && this._browser.getInstance(browserName).sessionId === newSessionId)[0];
+            BStackLogger.info(`Update (reloaded) multiremote job for browser "${browserName}" and sessionId ${oldSessionId}, ${sessionStatus}`);
+        }
+        if (setSessionStatus) {
+            await this._update(oldSessionId, {
+                status: sessionStatus,
+                ...(setSessionName ? { name: this._fullTitle } : {}),
+                ...(failureReason ? { reason: failureReason } : {})
+            });
+        }
+        BStackLogger.warn(`Session Reloaded: Old Session Id: ${oldSessionId}, New Session Id: ${newSessionId}`);
+        await this._insightsHandler?.sendCBTInfo();
+        this._scenariosThatRan = [];
+        delete this._fullTitle;
+        delete this._suiteFile;
+        this._failReasons = [];
+        this._hookFailReasons = [];
+        this._pureTestFailReasons = [];
+        await this._printSessionURL();
+    }
+    _isAppAutomate() {
+        const browserDesiredCapabilities = (this._browser?.capabilities ?? {});
+        const desiredCapabilities = (this._caps ?? {});
+        return !!browserDesiredCapabilities['appium:app'] || !!desiredCapabilities['appium:app'] || !!(desiredCapabilities['appium:options']?.app);
+    }
+    _updateJob(requestBody) {
+        return this._multiRemoteAction((sessionId, browserName) => {
+            BStackLogger.info(browserName
+                ? `Update multiremote job for browser "${browserName}" and sessionId ${sessionId}`
+                : `Update job with sessionId ${sessionId}`);
+            return this._update(sessionId, requestBody);
+        });
+    }
+    _multiRemoteAction(action) {
+        if (!this._browser) {
+            return Promise.resolve();
+        }
+        if (!this._browser.isMultiremote) {
+            return action(this._browser.sessionId);
+        }
+        const multiremotebrowser = this._browser;
+        return Promise.all(multiremotebrowser.instances
+            .filter((browserName) => {
+            const cap = getBrowserCapabilities(multiremotebrowser, this._caps, browserName);
+            return isBrowserstackCapability(cap);
+        })
+            .map((browserName) => (action(multiremotebrowser.getInstance(browserName).sessionId, browserName))));
+    }
+    _update(sessionId, requestBody) {
+        if (!isBrowserstackSession(this._browser)) {
+            return Promise.resolve();
+        }
+        const sessionUrl = `${this._sessionBaseUrl}/${sessionId}.json`;
+        BStackLogger.debug(`Updating Browserstack session at ${sessionUrl} with request body: `, requestBody);
+        if (this._turboScale) {
+            return got.patch(sessionUrl, {
+                json: requestBody,
+                username: this._config.user,
+                password: this._config.key
+            });
+        }
+        return got.put(sessionUrl, {
+            json: requestBody,
+            username: this._config.user,
+            password: this._config.key
+        });
+    }
+    async _printSessionURL() {
+        if (!this._browser || !isBrowserstackSession(this._browser)) {
+            return Promise.resolve();
+        }
+        await this._multiRemoteAction(async (sessionId, browserName) => {
+            const sessionUrl = `${this._sessionBaseUrl}/${sessionId}.json`;
+            BStackLogger.debug(`Requesting Browserstack session URL at ${sessionUrl}`);
+            let browserUrl;
+            const reqOpts = {
+                username: this._config.user,
+                password: this._config.key,
+                responseType: 'json'
+            };
+            if (this._turboScale) {
+                const response = await got(sessionUrl, reqOpts);
+                browserUrl = response.body.url;
+            }
+            else {
+                const response = await got(sessionUrl, reqOpts);
+                browserUrl = response.body.automation_session.browser_url;
+            }
+            if (!this._browser) {
+                return;
+            }
+            const capabilities = getBrowserCapabilities(this._browser, this._caps, browserName);
+            const browserString = getBrowserDescription(capabilities);
+            BStackLogger.info(`${browserString} session: ${browserUrl}`);
+        });
+    }
+    async _setSessionName(suiteTitle, test) {
+        if (!this._options.setSessionName || !suiteTitle) {
+            return;
+        }
+        let name = suiteTitle;
+        if (this._options.sessionNameFormat) {
+            name = this._options.sessionNameFormat(this._config, this._caps, suiteTitle, test?.title);
+        }
+        else if (test && !test.fullName && this._config.framework !== 'jasmine') {
+            // Mocha
+            const pre = this._options.sessionNamePrependTopLevelSuiteTitle ? `${suiteTitle} - ` : '';
+            const post = !this._options.sessionNameOmitTestTitle ? ` - ${test.title}` : '';
+            name = `${pre}${test.parent}${post}`;
+        }
+        else if (this._config.framework === 'jasmine') {
+            // Jasmine
+            name = this._caps?.['bstack:options']?.sessionName;
+        }
+        if (!BrowserstackCLI.getInstance().isRunning()) {
+            this._percyHandler?._setSessionName(name);
+        }
+        if (name !== this._fullTitle) {
+            this._fullTitle = name;
+            await this._updateJob({ name });
+        }
+    }
+    _setAnnotation(data) {
+        return this._executeCommand('annotate', { data, level: 'info' });
+    }
+    async _executeCommand(action, args) {
+        if (!this._browser || !isBrowserstackSession(this._browser)) {
+            return Promise.resolve();
+        }
+        const cmd = { action, ...(args ? { arguments: args } : {}) };
+        const script = `browserstack_executor: ${JSON.stringify(cmd)}`;
+        if (this._browser.isMultiremote) {
+            const multiRemoteBrowser = this._browser;
+            return Promise.all(Object.keys(this._caps).map(async (browserName) => {
+                const browser = multiRemoteBrowser.getInstance(browserName);
+                return (await browser.execute(script));
+            }));
+        }
+        return (await this._browser.execute(script));
+    }
+    saveWorkerData() {
+        saveWorkerData({
+            usageStats: UsageStats.getInstance().getDataToSave()
+        });
+    }
+}
+__decorate([
+    PerformanceTester.Measure(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_HOOK, { hookType: 'beforeSession' })
+], BrowserstackService.prototype, "beforeSession", null);
+__decorate([
+    PerformanceTester.Measure(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_HOOK, { hookType: 'before' })
+], BrowserstackService.prototype, "before", null);
+__decorate([
+    PerformanceTester.Measure(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_HOOK, { hookType: 'beforeSuite' })
+], BrowserstackService.prototype, "beforeSuite", null);
+__decorate([
+    PerformanceTester.Measure(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_HOOK, { hookType: 'beforeHook' })
+], BrowserstackService.prototype, "beforeHook", null);
+__decorate([
+    PerformanceTester.Measure(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_HOOK, { hookType: 'afterHook' })
+], BrowserstackService.prototype, "afterHook", null);
+__decorate([
+    PerformanceTester.Measure(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_HOOK, { hookType: 'beforeTest' })
+], BrowserstackService.prototype, "beforeTest", null);
+__decorate([
+    PerformanceTester.Measure(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_HOOK, { hookType: 'afterTest' })
+], BrowserstackService.prototype, "afterTest", null);
+__decorate([
+    PerformanceTester.Measure(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_HOOK, { hookType: 'beforeFeature' })
+], BrowserstackService.prototype, "beforeFeature", null);
+__decorate([
+    PerformanceTester.Measure(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_HOOK, { hookType: 'beforeScenario' })
+], BrowserstackService.prototype, "beforeScenario", null);
+__decorate([
+    PerformanceTester.Measure(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_HOOK, { hookType: 'afterScenario' })
+], BrowserstackService.prototype, "afterScenario", null);
+__decorate([
+    PerformanceTester.Measure(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_HOOK, { hookType: 'beforeStep' })
+], BrowserstackService.prototype, "beforeStep", null);
+__decorate([
+    PerformanceTester.Measure(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_HOOK, { hookType: 'afterStep' })
+], BrowserstackService.prototype, "afterStep", null);
+__decorate([
+    PerformanceTester.Measure(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_HOOK, { hookType: 'onReload' })
+], BrowserstackService.prototype, "onReload", null);
+__decorate([
+    PerformanceTester.Measure(PERFORMANCE_SDK_EVENTS.AUTOMATE_EVENTS.PRINT_BUILDLINK)
+], BrowserstackService.prototype, "_printSessionURL", null);
+//# sourceMappingURL=service.js.map