@wdio/browserstack-service 8.45.0 → 8.47.0

package/build/cli/instances/trackedContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackedContext.d.ts","sourceRoot":"","sources":["../../../src/cli/instances/trackedContext.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,OAAO,cAAc;;IAM/B;;;;;;KAMC;gBACW,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAOzE;;;KAGC;IACD,WAAW;IAIX;;;KAGC;IACD,YAAY;IAIZ;;;KAGC;IACD,KAAK;IAIL;;;KAGC;IACD,OAAO;CAIV"}

package/build/cli/instances/trackedContext.js

@@ -0,0 +1,47 @@
+export default class TrackedContext {
+    #id;
+    #threadId;
+    #processId;
+    #type;
+    /**
+   * Create TrackedContext
+   * @param {number} string - string Id for context - VERIFY
+   * @param {number} threadId- Integer Thread Id for context
+   * @param {number} processId - Integer Process Id for context
+   * @param {string} type
+   */
+    constructor(id, threadId, processId, type) {
+        this.#id = id;
+        this.#threadId = threadId;
+        this.#processId = processId;
+        this.#type = type;
+    }
+    /**
+   * get TrackedContext thread id
+   * @returns {number} - return thread id of context
+   */
+    getThreadId() {
+        return this.#threadId;
+    }
+    /**
+   * get TrackedContext process id
+   * @returns {number} - return process id of context
+   */
+    getProcessId() {
+        return this.#processId;
+    }
+    /**
+   * get TrackedContext id
+   * @returns {string} - returns context id
+   */
+    getId() {
+        return this.#id;
+    }
+    /**
+   * get TrackedContext type
+   * @returns {string}
+   */
+    getType() {
+        return this.#type;
+    }
+}

package/build/cli/instances/trackedInstance.d.ts

@@ -0,0 +1,40 @@
+import TrackedContext from './trackedContext.js';
+export default class TrackedInstance {
+    #private;
+    /**
+   * create TrackedInstance
+   * @param {TrackedContext} context
+   */
+    constructor(context: TrackedContext);
+    /**
+   * get TrackedInstance ref
+   * @returns {number} - returns ref id
+   */
+    getRef(): string;
+    /**
+   * get TrackedInstance context
+   * @return {TrackedContext} - returns tracked context
+   */
+    getContext(): TrackedContext;
+    /**
+   * get All data of Instance
+   * @returns {Map} - returns all data
+   */
+    getAllData(): Map<string, any>;
+    /**
+   * set multiple data in the instance
+   * @param {*} key
+   * @param {*} value
+   */
+    updateMultipleEntries(entries: Record<string, any>): void;
+    updateData(key: string, value: any): void;
+    /**
+   * get Specific data of instance.
+   * @param {*} key
+   * @returns {*}
+   */
+    getData(key: string): any;
+    hasData(key: string): boolean;
+    static createContext(target: string): TrackedContext;
+}
+//# sourceMappingURL=trackedInstance.d.ts.map

package/build/cli/instances/trackedInstance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackedInstance.d.ts","sourceRoot":"","sources":["../../../src/cli/instances/trackedInstance.ts"],"names":[],"mappings":"AAAA,OAAO,cAAc,MAAM,qBAAqB,CAAA;AAIhD,MAAM,CAAC,OAAO,OAAO,eAAe;;IAIhC;;;KAGC;gBACW,OAAO,EAAE,cAAc;IAKnC;;;KAGC;IACD,MAAM;IAIN;;;KAGC;IACD,UAAU;IAIV;;;KAGC;IACD,UAAU;IAIV;;;;KAIC;IACD,qBAAqB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAMlD,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG;IAIlC;;;;KAIC;IACD,OAAO,CAAC,GAAG,EAAE,MAAM;IAInB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAI7B,MAAM,CAAC,aAAa,CAAC,MAAM,EAAE,MAAM;CAQtC"}

package/build/cli/instances/trackedInstance.js

@@ -0,0 +1,63 @@
+import TrackedContext from './trackedContext.js';
+import crypto from 'node:crypto';
+import { threadId } from 'node:worker_threads';
+export default class TrackedInstance {
+    #context;
+    #data;
+    /**
+   * create TrackedInstance
+   * @param {TrackedContext} context
+   */
+    constructor(context) {
+        this.#context = context;
+        this.#data = new Map();
+    }
+    /**
+   * get TrackedInstance ref
+   * @returns {number} - returns ref id
+   */
+    getRef() {
+        return this.#context.getId();
+    }
+    /**
+   * get TrackedInstance context
+   * @return {TrackedContext} - returns tracked context
+   */
+    getContext() {
+        return this.#context;
+    }
+    /**
+   * get All data of Instance
+   * @returns {Map} - returns all data
+   */
+    getAllData() {
+        return this.#data;
+    }
+    /**
+   * set multiple data in the instance
+   * @param {*} key
+   * @param {*} value
+   */
+    updateMultipleEntries(entries) {
+        Object.keys(entries).forEach(key => {
+            this.#data.set(key, entries[key]);
+        });
+    }
+    updateData(key, value) {
+        this.#data.set(key, value);
+    }
+    /**
+   * get Specific data of instance.
+   * @param {*} key
+   * @returns {*}
+   */
+    getData(key) {
+        return this.#data.get(key);
+    }
+    hasData(key) {
+        return this.#data.has(key);
+    }
+    static createContext(target) {
+        return new TrackedContext(crypto.createHash('sha256').update(target).digest('hex'), threadId || 0, process.pid, typeof (target));
+    }
+}

package/build/cli/modules/accessibilityModule.d.ts

@@ -0,0 +1,33 @@
+import BaseModule from './baseModule.js';
+import { BStackLogger } from '../cliLogger.js';
+import accessibilityScripts from '../../scripts/accessibility-scripts.js';
+import type { Accessibility } from '@browserstack/wdio-browserstack-service';
+export default class AccessibilityModule extends BaseModule {
+    logger: typeof BStackLogger;
+    name: string;
+    scriptInstance: typeof accessibilityScripts;
+    accessibility: boolean;
+    isAppAccessibility: boolean;
+    isNonBstackA11y: boolean;
+    accessibilityConfig: Accessibility;
+    static MODULE_NAME: string;
+    accessibilityMap: Map<number, boolean>;
+    LOG_DISABLED_SHOWN: Map<number, boolean>;
+    constructor(accessibilityConfig: Accessibility, isNonBstackA11y: boolean);
+    onBeforeExecute(): Promise<void>;
+    private commandWrapper;
+    onBeforeTest(args: any): Promise<void>;
+    onAfterTest(): Promise<void>;
+    private shouldPatchExecuteScript;
+    private getCapability;
+    private performScanCli;
+    private sendTestStopEvent;
+    getA11yResults(browser: WebdriverIO.Browser): Promise<Array<{
+        [key: string]: any;
+    }>>;
+    getA11yResultsSummary(browser: WebdriverIO.Browser): Promise<{
+        [key: string]: any;
+    }>;
+    getDriverExecuteParams(): Promise<any>;
+}
+//# sourceMappingURL=accessibilityModule.d.ts.map

package/build/cli/modules/accessibilityModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessibilityModule.d.ts","sourceRoot":"","sources":["../../../src/cli/modules/accessibilityModule.ts"],"names":[],"mappings":"AACA,OAAO,UAAU,MAAM,iBAAiB,CAAA;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAQ9C,OAAO,oBAAoB,MAAM,wCAAwC,CAAA;AAIzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAA;AAO5E,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,UAAU;IAEvD,MAAM,sBAAe;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ,cAAc,EAAE,OAAO,oBAAoB,CAAA;IAC3C,aAAa,EAAE,OAAO,CAAQ;IAC9B,kBAAkB,EAAE,OAAO,CAAA;IAC3B,eAAe,EAAE,OAAO,CAAA;IACxB,mBAAmB,EAAE,aAAa,CAAA;IAClC,MAAM,CAAC,WAAW,SAAwB;IAC1C,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACtC,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;gBAE5B,mBAAmB,EAAE,aAAa,EAAE,eAAe,EAAE,OAAO;IAelE,eAAe;YAsFP,cAAc;IAkCtB,YAAY,CAAC,IAAI,EAAE,GAAG;IAqCtB,WAAW;IA6DjB,OAAO,CAAC,wBAAwB;IAWhC,OAAO,CAAC,aAAa;YAuBP,cAAc;YAkCd,iBAAiB;IAuBzB,cAAc,CAAC,OAAO,EAAE,WAAW,CAAC,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KAAE,CAAC,CAAC;IAsBrF,qBAAqB,CAAC,OAAO,EAAE,WAAW,CAAC,OAAO,GAAG,OAAO,CAAC;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KAAE,CAAC;IAqBrF,sBAAsB;CAa/B"}

package/build/cli/modules/accessibilityModule.js

@@ -0,0 +1,347 @@
+/// <reference path="../../@types/bstack-service-types.d.ts" />
+import BaseModule from './baseModule.js';
+import { BStackLogger } from '../cliLogger.js';
+import TestFramework from '../frameworks/testFramework.js';
+import AutomationFramework from '../frameworks/automationFramework.js';
+import { TestFrameworkState } from '../states/testFrameworkState.js';
+import { AutomationFrameworkState } from '../states/automationFrameworkState.js';
+import { HookState } from '../states/hookState.js';
+import accessibilityScripts from '../../scripts/accessibility-scripts.js';
+import { _getParamsForAppAccessibility, formatString, getAppA11yResults, getAppA11yResultsSummary, shouldScanTestForAccessibility, validateCapsWithA11y, validateCapsWithAppA11y, validateCapsWithNonBstackA11y } from '../../util.js';
+import { AutomationFrameworkConstants } from '../frameworks/constants/automationFrameworkConstants.js';
+import util from 'node:util';
+import PerformanceTester from '../../instrumentation/performance/performance-tester.js';
+import * as PERFORMANCE_SDK_EVENTS from '../../instrumentation/performance/constants.js';
+import { GrpcClient } from '../grpcClient.js';
+export default class AccessibilityModule extends BaseModule {
+    logger = BStackLogger;
+    name;
+    scriptInstance;
+    accessibility = false;
+    isAppAccessibility;
+    isNonBstackA11y;
+    accessibilityConfig;
+    static MODULE_NAME = 'AccessibilityModule';
+    accessibilityMap;
+    LOG_DISABLED_SHOWN;
+    constructor(accessibilityConfig, isNonBstackA11y) {
+        super();
+        this.name = 'AccessibilityModule';
+        this.accessibilityConfig = accessibilityConfig;
+        AutomationFramework.registerObserver(AutomationFrameworkState.CREATE, HookState.POST, this.onBeforeExecute.bind(this));
+        TestFramework.registerObserver(TestFrameworkState.TEST, HookState.PRE, this.onBeforeTest.bind(this));
+        TestFramework.registerObserver(TestFrameworkState.TEST, HookState.POST, this.onAfterTest.bind(this));
+        this.accessibility = true;
+        this.scriptInstance = accessibilityScripts;
+        this.accessibilityMap = new Map();
+        this.LOG_DISABLED_SHOWN = new Map();
+        this.isAppAccessibility = accessibilityConfig.isAppAccessibility || false;
+        this.isNonBstackA11y = isNonBstackA11y;
+    }
+    async onBeforeExecute() {
+        try {
+            const autoInstance = AutomationFramework.getTrackedInstance();
+            if (!autoInstance) {
+                this.logger.debug('No tracked instances found!');
+                return;
+            }
+            const browser = AutomationFramework.getDriver(autoInstance);
+            if (!browser) {
+                this.logger.debug('No browser instance found for command wrapping');
+                return;
+            }
+            const isBrowserstackSession = AutomationFramework.getState(autoInstance, AutomationFrameworkConstants.KEY_IS_BROWSERSTACK_HUB);
+            const browserCaps = AutomationFramework.getState(autoInstance, AutomationFrameworkConstants.KEY_CAPABILITIES);
+            const inputCaps = AutomationFramework.getState(autoInstance, AutomationFrameworkConstants.KEY_INPUT_CAPABILITIES);
+            const sessionId = AutomationFramework.getState(autoInstance, AutomationFrameworkConstants.KEY_FRAMEWORK_SESSION_ID);
+            const platformA11yMeta = {
+                browser_name: browserCaps.browserName,
+                browser_version: browserCaps?.browserVersion || 'latest',
+                platform_name: browserCaps?.platformName,
+                platform_version: this.getCapability(browserCaps, 'appium:platformVersion', 'platformVersion'),
+            };
+            if (this.isAppAccessibility) {
+                this.accessibility = validateCapsWithAppA11y(platformA11yMeta);
+            }
+            else if (this.isNonBstackA11y) {
+                if (validateCapsWithNonBstackA11y(platformA11yMeta.browser_name, platformA11yMeta.browser_version)) {
+                    this.accessibility = true;
+                }
+            }
+            else {
+                const device = this.getCapability(inputCaps, 'deviceName');
+                const chromeOptions = this.getCapability(inputCaps, 'goog:chromeOptions');
+                this.accessibility = validateCapsWithA11y(device, platformA11yMeta, chromeOptions);
+            }
+            //patching getA11yResultsSummary
+            browser.getAccessibilityResultsSummary = async () => {
+                if (this.isAppAccessibility) {
+                    return await getAppA11yResultsSummary(true, browser, isBrowserstackSession, this.accessibility, sessionId);
+                }
+                return await this.getA11yResultsSummary(browser);
+            };
+            //patching getA11yResults
+            browser.getAccessibilityResults = async () => {
+                if (this.isAppAccessibility) {
+                    return await getAppA11yResults(true, browser, isBrowserstackSession, this.accessibility, sessionId);
+                }
+                return await this.getA11yResults(browser);
+            };
+            //patching performScan
+            browser.performScan = async () => {
+                return await this.performScanCli(browser);
+            };
+            if (!this.accessibility) {
+                this.logger.info('Accessibility automation is disabled for this session.');
+                return;
+            }
+            if (!('overwriteCommand' in browser && Array.isArray(this.scriptInstance.commandsToWrap))) {
+                return;
+            }
+            // Wrap commands if accessibility scripts are available
+            if (this.scriptInstance.commandsToWrap && this.scriptInstance.commandsToWrap.length > 0) {
+                this.scriptInstance.commandsToWrap
+                    .filter((command) => command.name && command.class)
+                    .forEach((command) => {
+                    browser.overwriteCommand(command.name, this.commandWrapper.bind(this, command), command.class === 'Element');
+                });
+            }
+        }
+        catch (error) {
+            this.logger.error(`Error in onBeforeExecute: ${error}`);
+        }
+    }
+    async commandWrapper(command, originFunction, ...args) {
+        try {
+            const autoInstance = AutomationFramework.getTrackedInstance();
+            const sessionId = AutomationFramework.getState(autoInstance, AutomationFrameworkConstants.KEY_FRAMEWORK_SESSION_ID);
+            // Check if accessibility is still enabled for this session
+            if (sessionId && this.accessibilityMap.get(sessionId)) {
+                const browser = AutomationFramework.getDriver(autoInstance);
+                // Perform accessibility scan before command if script is available
+                if (!command.name.includes('execute') ||
+                    !this.shouldPatchExecuteScript(args.length ? args[0] : null)) {
+                    try {
+                        await this.performScanCli(browser, command.name);
+                        this.logger.debug(`Accessibility scan performed after ${command.name} command`);
+                    }
+                    catch (scanError) {
+                        this.logger.debug(`Error performing accessibility scan after ${command.name}: ${scanError}`);
+                    }
+                }
+            }
+            // Execute the original command
+            const result = await originFunction(...args);
+            return result;
+        }
+        catch (error) {
+            this.logger.error(`Error in commandWrapper for ${command.name}: ${error}`);
+            // Still execute the original command even if accessibility scan fails
+            return await originFunction(...args);
+        }
+    }
+    async onBeforeTest(args) {
+        try {
+            this.logger.debug('Accessibility before test hook. Starting accessibility scan for this test case.');
+            const suiteTitle = args.suiteTitle || '';
+            const test = args.test || {};
+            const autoInstance = AutomationFramework.getTrackedInstance();
+            const testInstance = TestFramework.getTrackedInstance();
+            const sessionId = AutomationFramework.getState(autoInstance, AutomationFrameworkConstants.KEY_FRAMEWORK_SESSION_ID);
+            const accessibilityOptions = this.config.accessibilityOptions;
+            const shouldScanTest = shouldScanTestForAccessibility(suiteTitle, test.title, accessibilityOptions) && this.accessibility;
+            // Create test metadata similar to accessibility-handler
+            const testIdentifier = testInstance.getContext().getId();
+            const testMetadata = {
+                scanTestForAccessibility: shouldScanTest,
+                accessibilityScanStarted: shouldScanTest
+            };
+            // Store test metadata in test instance
+            TestFramework.setState(testInstance, `accessibility_metadata_${testIdentifier}`, testMetadata);
+            this.accessibilityMap.set(sessionId, shouldScanTest);
+            // Log if accessibility scan is enabled for this test
+            if (shouldScanTest) {
+                this.logger.info('Accessibility test case execution has started.');
+            }
+            else if (!this.LOG_DISABLED_SHOWN.get(sessionId)) {
+                this.logger.info('Accessibility scanning disabled for this test case.');
+                this.LOG_DISABLED_SHOWN.set(sessionId, true);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Exception in starting accessibility automation scan for this test case: ${error}`);
+        }
+    }
+    async onAfterTest() {
+        this.logger.debug('Accessibility after test hook. Before sending test stop event');
+        try {
+            const autoInstance = AutomationFramework.getTrackedInstance();
+            const testInstance = TestFramework.getTrackedInstance();
+            const sessionId = AutomationFramework.getState(autoInstance, AutomationFrameworkConstants.KEY_FRAMEWORK_SESSION_ID);
+            if (!autoInstance || !testInstance) {
+                this.logger.error('No tracked instances found for accessibility after test');
+                return;
+            }
+            // Get test metadata that was stored in onBeforeTest
+            const testIdentifier = testInstance.getContext().getId();
+            const testMetadata = testInstance.getData(`accessibility_metadata_${testIdentifier}`);
+            if (!testMetadata) {
+                this.logger.debug('No accessibility metadata found for this test');
+                return;
+            }
+            const { accessibilityScanStarted, scanTestForAccessibility } = testMetadata;
+            if (!accessibilityScanStarted) {
+                this.logger.debug('Accessibility scan was not started for this test');
+                return;
+            }
+            if (scanTestForAccessibility) {
+                this.logger.info('Automate test case execution has ended. Processing for accessibility testing is underway.');
+                // Get the driver for sending test stop event
+                const browser = AutomationFramework.getDriver(autoInstance);
+                if (browser) {
+                    let dataForExtension = {
+                        'thTestRunUuid': process.env.TEST_ANALYTICS_ID,
+                        'thBuildUuid': process.env.BROWSERSTACK_TESTHUB_UUID,
+                        'thJwtToken': process.env.BROWSERSTACK_TESTHUB_JWT
+                    };
+                    const driverExecuteParams = await this.getDriverExecuteParams();
+                    dataForExtension = { ...dataForExtension, ...driverExecuteParams };
+                    // final scan and saving the results
+                    await this.sendTestStopEvent(browser, dataForExtension);
+                    this.logger.info('Accessibility testing for this test case has ended.');
+                }
+                else {
+                    this.logger.warn('No driver found to send accessibility test stop event');
+                }
+                this.accessibilityMap.delete(sessionId);
+                // Clean up test metadata
+                TestFramework.setState(testInstance, `accessibility_metadata_${testIdentifier}`, null);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Accessibility results could not be processed for the test case. Error: ${error}`);
+        }
+    }
+    shouldPatchExecuteScript(script) {
+        if (!script || typeof script !== 'string') {
+            return true;
+        }
+        return (script.toLowerCase().indexOf('browserstack_executor') !== -1 ||
+            script.toLowerCase().indexOf('browserstack_accessibility_automation_script') !== -1);
+    }
+    getCapability(capabilities, key, legacyKey = '') {
+        if (key === 'deviceName') {
+            if (capabilities['bstack:options'] && capabilities['bstack:options']?.deviceName) {
+                return capabilities['bstack:options']?.deviceName;
+            }
+            else if (capabilities['bstack:options'] && capabilities['bstack:options']?.device) {
+                return capabilities['bstack:options']?.device;
+            }
+            else if (capabilities['appium:deviceName']) {
+                return capabilities['appium:deviceName'];
+            }
+        }
+        else if (key === 'goog:chromeOptions' && capabilities['goog:chromeOptions']) {
+            return capabilities['goog:chromeOptions'];
+        }
+        else {
+            const bstackOptions = capabilities['bstack:options'];
+            if (bstackOptions && bstackOptions?.[key]) {
+                return bstackOptions?.[key];
+            }
+            else if (capabilities[legacyKey]) {
+                return capabilities[legacyKey];
+            }
+        }
+    }
+    async performScanCli(browser, commandName) {
+        return await PerformanceTester.measureWrapper(PERFORMANCE_SDK_EVENTS.A11Y_EVENTS.PERFORM_SCAN, async () => {
+            try {
+                if (!this.accessibility) {
+                    this.logger.debug('Not an Accessibility Automation session.');
+                    return;
+                }
+                if (this.isAppAccessibility) {
+                    const results = await browser.execute(formatString(this.scriptInstance.performScan, JSON.stringify(_getParamsForAppAccessibility(commandName))), {});
+                    BStackLogger.debug(util.format(results));
+                    return results;
+                }
+                const results = await browser.executeAsync(this.scriptInstance.performScan, { 'method': commandName || '' });
+                return results;
+            }
+            catch (err) {
+                this.logger.error('Accessibility Scan could not be performed : ' + err);
+                return;
+            }
+        }, { command: commandName })();
+    }
+    async sendTestStopEvent(browser, dataForExtension) {
+        try {
+            if (!this.accessibility) {
+                this.logger.debug('Not an Accessibility Automation session.');
+                return;
+            }
+            this.logger.debug('Performing scan before saving results');
+            await this.performScanCli(browser);
+            if (this.isAppAccessibility) {
+                return;
+            }
+            await PerformanceTester.measureWrapper(PERFORMANCE_SDK_EVENTS.A11Y_EVENTS.SAVE_RESULTS, async () => {
+                const results = await browser.executeAsync(accessibilityScripts.saveTestResults, dataForExtension);
+                this.logger.debug(`save results : ${util.format(results)}`);
+            })();
+        }
+        catch (error) {
+            this.logger.error(`Error while sending test stop event: ${error}`);
+        }
+    }
+    async getA11yResults(browser) {
+        return await PerformanceTester.measureWrapper(PERFORMANCE_SDK_EVENTS.A11Y_EVENTS.GET_RESULTS, async () => {
+            try {
+                if (!this.accessibility) {
+                    this.logger.debug('Not an Accessibility Automation session.');
+                    return;
+                }
+                this.logger.debug('Performing scan before getting results');
+                await this.performScanCli(browser);
+                const results = await browser.executeAsync(this.scriptInstance.getResults);
+                return results;
+            }
+            catch (error) {
+                this.logger.error('No accessibility results were found.');
+                this.logger.debug(`getA11yResults Failed. Error: ${error}`);
+                return [];
+            }
+        })();
+    }
+    async getA11yResultsSummary(browser) {
+        return await PerformanceTester.measureWrapper(PERFORMANCE_SDK_EVENTS.A11Y_EVENTS.GET_RESULTS_SUMMARY, async () => {
+            try {
+                if (!this.accessibility) {
+                    this.logger.debug('Not an Accessibility Automation session.');
+                    return;
+                }
+                this.logger.debug('Performing scan before getting results summary');
+                await this.performScanCli(browser);
+                const summaryResults = await browser.executeAsync(this.scriptInstance.getResultsSummary);
+                return summaryResults;
+            }
+            catch {
+                this.logger.error('No accessibility summary was found.');
+                return {};
+            }
+        })();
+    }
+    async getDriverExecuteParams() {
+        const payload = {
+            product: 'accessibility',
+            scriptName: 'saveResults'
+        };
+        const response = await GrpcClient.getInstance().fetchDriverExecuteParamsEvent(payload);
+        if (response.success) {
+            return response.accessibilityExecuteParams ? JSON.parse(Buffer.from(response.accessibilityExecuteParams).toString('utf8')) : {};
+        }
+        this.logger.error(`Failed to fetch driver execute params: ${response.error || 'Unknown error'}`);
+        return {};
+    }
+}

package/build/cli/modules/automateModule.d.ts

@@ -0,0 +1,26 @@
+import BaseModule from './baseModule.js';
+import { BStackLogger } from '../cliLogger.js';
+import type { Options } from '@wdio/types';
+export default class AutomateModule extends BaseModule {
+    logger: typeof BStackLogger;
+    browserStackConfig: Options.Testrunner;
+    private sessionMap;
+    static readonly MODULE_NAME = "AutomateModule";
+    /**
+     * Create a new AutomateModule
+     */
+    constructor(browserStackConfig: Options.Testrunner);
+    getModuleName(): string;
+    onBeforeTest(args: Record<string, unknown>): Promise<void>;
+    onAfterTest(args: Record<string, unknown>): Promise<void>;
+    onAfterExecute(): Promise<void>;
+    markSessionName(sessionId: string, sessionName: string, config: {
+        user: string;
+        key: string;
+    }): Promise<void>;
+    markSessionStatus(sessionId: string, sessionStatus: 'passed' | 'failed', sessionErrorMessage: string | undefined, config: {
+        user: string;
+        key: string;
+    }): Promise<void>;
+}
+//# sourceMappingURL=automateModule.d.ts.map

package/build/cli/modules/automateModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"automateModule.d.ts","sourceRoot":"","sources":["../../../src/cli/modules/automateModule.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,iBAAiB,CAAA;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAK9C,OAAO,KAAK,EAAc,OAAO,EAAE,MAAM,aAAa,CAAA;AAsBtD,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,UAAU;IAElD,MAAM,sBAAe;IACrB,kBAAkB,EAAE,OAAO,CAAC,UAAU,CAAA;IACtC,OAAO,CAAC,UAAU,CAAsC;IAExD,MAAM,CAAC,QAAQ,CAAC,WAAW,oBAAmB;IAC9C;;OAEG;gBACS,kBAAkB,EAAE,OAAO,CAAC,UAAU;IASlD,aAAa,IAAI,MAAM;IAIjB,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IA8C1C,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IA0DzC,cAAc;IAwCd,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;KAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IA0C7G,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,QAAQ,GAAG,QAAQ,EAAE,mBAAmB,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CA0CjL"}