@wdio/browserstack-service 8.45.0 → 8.47.0

package/build/cli/frameworks/automationFramework.js

@@ -0,0 +1,131 @@
+import { BStackLogger as logger } from '../cliLogger.js';
+import { eventDispatcher } from '../eventDispatcher.js';
+import { CLIUtils } from '../cliUtils.js';
+import TrackedInstance from '../instances/trackedInstance.js';
+import { AutomationFrameworkConstants } from './constants/automationFrameworkConstants.js';
+/**
+ * AutomationFramework - Automation Framework abstract class
+ */
+export default class AutomationFramework {
+    #automationFrameworkName;
+    #automationFrameworkVersion;
+    static instances = new Map();
+    static KEY_AUTOMATION_SESSIONS = 'automation_sessions';
+    static KEY_NON_BROWSERSTACK_AUTOMATION_SESSIONS = 'non_browserstack_automation_sessions';
+    /**
+   * Constructor for the AutomationFramework
+   * @param {string} automationFrameworkName - Name of the automation framework
+   * @param {string} automationFrameworkVersion - Version of the automation framework
+  */
+    constructor(automationFrameworkName, automationFrameworkVersion) {
+        this.#automationFrameworkName = automationFrameworkName;
+        this.#automationFrameworkVersion = automationFrameworkVersion;
+    }
+    /**
+   * Get the automation framework name
+   * @returns {string} The name of the automation framework
+   */
+    getAutomationFrameworkName() {
+        return this.#automationFrameworkName;
+    }
+    /**
+   * Get the automation framework version
+   * @returns {string} The version of the automation framework
+   */
+    getAutomationFrameworkVersion() {
+        return this.#automationFrameworkVersion;
+    }
+    /**
+   * Track an event
+   * @param {Object}
+   * @param {Object}
+   * @param {Object}
+   * @returns {void}
+   */
+    async trackEvent(automationFrameworkState, hookState, args = {}) {
+        logger.info(`trackEvent: automationFrameworkState=${automationFrameworkState} hookState=${hookState} args=${args}`);
+    }
+    /**
+   *
+   * @param {*} instance
+   * @param {*} automationFrameworkState
+   * @param {*} hookState
+   * @param {*} args
+   */
+    async runHooks(instance, automationFrameworkState, hookState, args = {}) {
+        logger.info(`runHooks: automationFrameworkState=${automationFrameworkState} hookState=${hookState}`);
+        const hookRegistryKey = CLIUtils.getHookRegistryKey(automationFrameworkState, hookState);
+        await eventDispatcher.notifyObserver(hookRegistryKey, args);
+    }
+    /**
+   * Register an observer
+   * @returns {void}
+   */
+    static registerObserver(automationFrameworkState, hookState, callback) {
+        eventDispatcher.registerObserver(CLIUtils.getHookRegistryKey(automationFrameworkState, hookState), callback);
+    }
+    /**
+   * Set the tracked instance
+   * @param {TrackedInstance} context - The context
+   * @param {TrackedInstance} instance - The instance
+   * @returns {void}
+   */
+    static setTrackedInstance(context, instance) {
+        logger.debug(`setTrackedInstance: ${context.getId()}`);
+        AutomationFramework.instances.set(context.getId(), instance);
+    }
+    /**
+   * Get the tracked instance
+   * @returns {TrackedInstance} The tracked instance
+   */
+    static getTrackedInstance() {
+        logger.debug(`getTrackedInstance: ${CLIUtils.getCurrentInstanceName()}`);
+        const context = TrackedInstance.createContext(CLIUtils.getCurrentInstanceName());
+        return AutomationFramework.instances.get(context.getId());
+    }
+    /**
+   * Set the state
+   * @param {TrackedInstance} instance - The instance
+   * @param {string} key - The key
+   * @param {*} value - The value
+   * @returns
+   */
+    static setState(instance, key, value) {
+        instance.getAllData().set(key, value);
+    }
+    /**
+   * Get the state
+   * @param {TrackedInstance} instance - The instance
+   * @param {string} key - The key
+   * @returns {*} The state
+   */
+    static getState(instance, key) {
+        return instance.getAllData().get(key);
+    }
+    static isAutomationSession(instance) {
+        return AutomationFramework.getState(instance, AutomationFrameworkConstants.KEY_IS_BROWSERSTACK_HUB);
+    }
+    /**
+     * Set the driver for the automation framework instance
+     * @param {AutomationFrameworkInstance} instance - The automation framework instance
+     * @param {*} driver - The driver object
+     */
+    static setDriver(instance, driver) {
+        if (this.isAutomationSession(instance)) {
+            AutomationFramework.setState(instance, AutomationFramework.KEY_AUTOMATION_SESSIONS, driver);
+        }
+        else {
+            AutomationFramework.setState(instance, AutomationFramework.KEY_NON_BROWSERSTACK_AUTOMATION_SESSIONS, driver);
+        }
+    }
+    /**
+     * Get the driver from the automation framework instance
+     * @param {AutomationFrameworkInstance} instance - The automation framework instance
+     * @returns {*} The driver object or null
+     */
+    static getDriver(instance) {
+        let driver = null;
+        driver = this.isAutomationSession(instance) ? AutomationFramework.getState(instance, AutomationFramework.KEY_AUTOMATION_SESSIONS) || null : AutomationFramework.getState(instance, AutomationFramework.KEY_NON_BROWSERSTACK_AUTOMATION_SESSIONS) || null;
+        return driver;
+    }
+}

package/build/cli/frameworks/constants/automationFrameworkConstants.d.ts

@@ -0,0 +1,18 @@
+export declare const AutomationFrameworkConstants: {
+    ENV_BROWSERSTACK_PLATFORM_INDEX: string;
+    KEY_HUB_URL: string;
+    KEY_FRAMEWORK_SESSION_ID: string;
+    KEY_INPUT_CAPABILITIES: string;
+    KEY_CAPABILITIES: string;
+    KEY_IS_BROWSERSTACK_HUB: string;
+    KEY_STARTED_AT: string;
+    KEY_ENDED_AT: string;
+    KEY_PLATFORM_INDEX: string;
+    COMMAND_NEW_SESSION: string;
+    COMMAND_GET: string;
+    COMMAND_SCREENSHOT: string;
+    COMMAND_W3C_EXECUTE_SCRIPT: string;
+    COMMAND_W3C_EXECUTE_SCRIPT_ASYNC: string;
+    COMMAND_QUIT: string;
+};
+//# sourceMappingURL=automationFrameworkConstants.d.ts.map

package/build/cli/frameworks/constants/automationFrameworkConstants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"automationFrameworkConstants.d.ts","sourceRoot":"","sources":["../../../../src/cli/frameworks/constants/automationFrameworkConstants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;CAgBxC,CAAA"}

package/build/cli/frameworks/constants/automationFrameworkConstants.js

@@ -0,0 +1,17 @@
+export const AutomationFrameworkConstants = {
+    ENV_BROWSERSTACK_PLATFORM_INDEX: 'BROWSERSTACK_PLATFORM_INDEX',
+    KEY_HUB_URL: 'hub_url',
+    KEY_FRAMEWORK_SESSION_ID: 'framework_session_id',
+    KEY_INPUT_CAPABILITIES: 'input_capabilities',
+    KEY_CAPABILITIES: 'capabilities',
+    KEY_IS_BROWSERSTACK_HUB: 'is_browserstack_hub',
+    KEY_STARTED_AT: 'started_at',
+    KEY_ENDED_AT: 'ended_at',
+    KEY_PLATFORM_INDEX: 'platform_index',
+    COMMAND_NEW_SESSION: 'newsession',
+    COMMAND_GET: 'get',
+    COMMAND_SCREENSHOT: 'screenshot',
+    COMMAND_W3C_EXECUTE_SCRIPT: 'w3cexecutescript',
+    COMMAND_W3C_EXECUTE_SCRIPT_ASYNC: 'w3cexecutescriptasync',
+    COMMAND_QUIT: 'quit'
+};

package/build/cli/frameworks/constants/testFrameworkConstants.d.ts

@@ -0,0 +1,43 @@
+export declare const TestFrameworkConstants: {
+    KEY_TEST_UUID: string;
+    KEY_TEST_ID: string;
+    KEY_TEST_NAME: string;
+    KEY_TEST_FILE_PATH: string;
+    KEY_TEST_TAGS: string;
+    KEY_TEST_RESULT: string;
+    KEY_TEST_RESULT_AT: string;
+    KEY_TEST_STARTED_AT: string;
+    KEY_TEST_ENDED_AT: string;
+    KEY_TEST_LOCATION: string;
+    KEY_TEST_SCOPE: string;
+    KEY_TEST_SCOPES: string;
+    KEY_TEST_FRAMEWORK_NAME: string;
+    KEY_TEST_FRAMEWORK_VERSION: string;
+    KEY_TEST_CODE: string;
+    KEY_TEST_RERUN_NAME: string;
+    KEY_PLATFORM_INDEX: string;
+    KEY_TEST_FAILURE: string;
+    KEY_TEST_FAILURE_TYPE: string;
+    KEY_TEST_FAILURE_REASON: string;
+    KEY_TEST_LOGS: string;
+    KEY_TEST_META: string;
+    KEY_TEST_DEFERRED: string;
+    KEY_SESSION_NAME: string;
+    KEY_AUTOMATE_SESSION_NAME: string;
+    KEY_AUTOMATE_SESSION_STATUS: string;
+    KEY_AUTOMATE_SESSION_REASON: string;
+    KEY_EVENT_STARTED_AT: string;
+    KEY_EVENT_ENDED_AT: string;
+    KEY_HOOK_ID: string;
+    KEY_HOOK_RESULT: string;
+    KEY_HOOK_LOGS: string;
+    KEY_HOOK_NAME: string;
+    KEY_HOOKS_STARTED: string;
+    KEY_HOOKS_FINISHED: string;
+    DEFAULT_TEST_RESULT: string;
+    DEFAULT_HOOK_RESULT: string;
+    KIND_SCREENSHOT: string;
+    KIND_LOG: string;
+    HOOK_REGEX: string;
+};
+//# sourceMappingURL=testFrameworkConstants.d.ts.map

package/build/cli/frameworks/constants/testFrameworkConstants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testFrameworkConstants.d.ts","sourceRoot":"","sources":["../../../../src/cli/frameworks/constants/testFrameworkConstants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyClC,CAAA"}

package/build/cli/frameworks/constants/testFrameworkConstants.js

@@ -0,0 +1,42 @@
+export const TestFrameworkConstants = {
+    KEY_TEST_UUID: 'test_uuid',
+    KEY_TEST_ID: 'test_id',
+    KEY_TEST_NAME: 'test_name',
+    KEY_TEST_FILE_PATH: 'test_file_path',
+    KEY_TEST_TAGS: 'test_tags',
+    KEY_TEST_RESULT: 'test_result',
+    KEY_TEST_RESULT_AT: 'test_result_at',
+    KEY_TEST_STARTED_AT: 'test_started_at',
+    KEY_TEST_ENDED_AT: 'test_ended_at',
+    KEY_TEST_LOCATION: 'test_location',
+    KEY_TEST_SCOPE: 'test_scope',
+    KEY_TEST_SCOPES: 'test_scopes',
+    KEY_TEST_FRAMEWORK_NAME: 'test_framework_name',
+    KEY_TEST_FRAMEWORK_VERSION: 'test_framework_version',
+    KEY_TEST_CODE: 'test_code',
+    KEY_TEST_RERUN_NAME: 'test_rerun_name',
+    KEY_PLATFORM_INDEX: 'platform_index',
+    KEY_TEST_FAILURE: 'test_failure',
+    KEY_TEST_FAILURE_TYPE: 'test_failure_type',
+    KEY_TEST_FAILURE_REASON: 'test_failure_reason',
+    KEY_TEST_LOGS: 'test_logs',
+    KEY_TEST_META: 'test_meta',
+    KEY_TEST_DEFERRED: 'test_deferred',
+    KEY_SESSION_NAME: 'test_session_name',
+    KEY_AUTOMATE_SESSION_NAME: 'automate_session_name',
+    KEY_AUTOMATE_SESSION_STATUS: 'automate_session_status',
+    KEY_AUTOMATE_SESSION_REASON: 'automate_session_reason',
+    KEY_EVENT_STARTED_AT: 'event_started_at',
+    KEY_EVENT_ENDED_AT: 'event_ended_at',
+    KEY_HOOK_ID: 'hook_id',
+    KEY_HOOK_RESULT: 'hook_result',
+    KEY_HOOK_LOGS: 'hook_logs',
+    KEY_HOOK_NAME: 'hook_name',
+    KEY_HOOKS_STARTED: 'test_hooks_started',
+    KEY_HOOKS_FINISHED: 'test_hooks_finished',
+    DEFAULT_TEST_RESULT: 'pending',
+    DEFAULT_HOOK_RESULT: 'pending',
+    KIND_SCREENSHOT: 'TEST_SCREENSHOT',
+    KIND_LOG: 'TEST_LOG',
+    HOOK_REGEX: '^(BEFORE_|AFTER_)',
+};

package/build/cli/frameworks/testFramework.d.ts

@@ -0,0 +1,89 @@
+import type TrackedContext from '../instances/trackedContext.js';
+import TrackedInstance from '../instances/trackedInstance.js';
+import type TestFrameworkInstance from '../instances/testFrameworkInstance.js';
+export default class TestFramework {
+    static instances: Map<any, any>;
+    testFrameworks: Array<string>;
+    testFrameworkVersions: Record<string, string>;
+    binSessionId: string | null;
+    /**
+   * Constructor for the TestFramework
+   * @param {Array} testFrameworks - List of Test frameworks
+   * @param {Map} testFrameworkVersions - Name of the Test frameworks
+   * @param {string} binSessionId - BinSessionId
+  */
+    constructor(testFrameworks: Array<string>, testFrameworkVersions: Record<string, string>, binSessionId: string);
+    /**
+   * get all instances
+   * @return {Map} - return all instances Map
+  */
+    getInstances(): Map<any, any>;
+    /**
+   * set testFrameworkInstance
+   * @param {TrackedContext} context
+   * @param {TestFrameworkInstance} instance
+  */
+    setInstance(context: TrackedContext, instance: TestFrameworkInstance): void;
+    /**
+   * Find instance and track any state for the test framework
+   * @returns instance
+  */
+    static getTrackedInstance(): any;
+    /**
+   * Set tracked instance
+   * @returns {string} The name of the test framework
+   */
+    static setTrackedInstance(context: TrackedContext, instance: TestFrameworkInstance): void;
+    /**
+   * get all test framework versions
+   * @returns {Map} - return all versions of framework available.
+   */
+    getTestFrameworksVersions(): Record<string, string>;
+    /**
+   * get all test frameworks
+   * @returns {Array} - return all test frameworks
+   */
+    getTestFrameworks(): string[];
+    /**
+   * Track an event
+   * @param {TestFrameworkState} testFrameworkState
+   * @param {HookState} hookState
+   * @param {*} args
+   * @returns {void}
+   */
+    trackEvent(testFrameworkState: State, hookState: State, args?: unknown): void;
+    /**
+   * run test hooks
+   * @param {TestFrameworkInstance} instance
+   * @param {TestFrameworkState} testFrameworkState
+   * @param {HookState} hookState
+   * @param {*} args
+   */
+    runHooks(instance: TestFrameworkInstance, testFrameworkState: State, hookState: State, args?: unknown): Promise<void>;
+    /**
+   * Register an observer
+   * @param {TestFrameworkState} testFrameworkState
+   * @param {HookState} hookState
+   * @param {*} callback
+   * @returns {void}
+   */
+    static registerObserver(testFrameworkState: State, hookState: State, callback: Function): void;
+    /**
+   * Resolve instance for the test framework
+   * @param {TestFrameworkInstance} testFrameworkInstance
+   * @param {string} key
+   * @returns {TestFrameworkInstance}
+   */
+    static getState(instance: TestFrameworkInstance, key: string): any;
+    static hasState(instance: TestFrameworkInstance, key: string): boolean;
+    /**
+   * Set the state
+   * @param {TrackedInstance} instance - The instance
+   * @param {string} key - The key
+   * @param {*} value - The value
+   * @returns
+   */
+    static setState(instance: TrackedInstance, key: string, value: unknown): void;
+    updateInstanceState(instance: TestFrameworkInstance, testFrameworkState: State, hookState: State): void;
+}
+//# sourceMappingURL=testFramework.d.ts.map

package/build/cli/frameworks/testFramework.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testFramework.d.ts","sourceRoot":"","sources":["../../../src/cli/frameworks/testFramework.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,cAAc,MAAM,gCAAgC,CAAA;AAChE,OAAO,eAAe,MAAM,iCAAiC,CAAA;AAC7D,OAAO,KAAK,qBAAqB,MAAM,uCAAuC,CAAA;AAE9E,MAAM,CAAC,OAAO,OAAO,aAAa;IAC9B,MAAM,CAAC,SAAS,gBAAY;IAC5B,cAAc,EAAE,KAAK,CAAC,MAAM,CAAC,CAAK;IAClC,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAK;IAClD,YAAY,EAAE,MAAM,GAAC,IAAI,CAAO;IAEhC;;;;;IAKA;gBACY,cAAc,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,MAAM;IAM9G;;;IAGA;IACA,YAAY;IAIZ;;;;IAIA;IACA,WAAW,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,qBAAqB;IAIpE;;;IAGA;IACA,MAAM,CAAC,kBAAkB;IAKzB;;;KAGC;IACD,MAAM,CAAC,kBAAkB,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,qBAAqB;IAIlF;;;KAGC;IACD,yBAAyB;IAIzB;;;KAGC;IACD,iBAAiB;IAIjB;;;;;;KAMC;IACD,UAAU,CAAC,kBAAkB,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,GAAE,OAAY;IAI1E;;;;;;KAMC;IACK,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,GAAE,OAAY;IAO/G;;;;;;KAMC;IACD,MAAM,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ;IAIvF;;;;;KAKC;IACD,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,EAAE,GAAG,EAAE,MAAM;IAI5D,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,EAAE,GAAG,EAAE,MAAM;IAI5D;;;;;;KAMC;IACD,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;IAItE,mBAAmB,CAAC,QAAQ,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK;CAOnG"}

package/build/cli/frameworks/testFramework.js

@@ -0,0 +1,125 @@
+import { CLIUtils } from '../cliUtils.js';
+import { eventDispatcher } from '../eventDispatcher.js';
+import { BStackLogger as logger } from '../cliLogger.js';
+import TrackedInstance from '../instances/trackedInstance.js';
+export default class TestFramework {
+    static instances = new Map();
+    testFrameworks = [];
+    testFrameworkVersions = {};
+    binSessionId = null;
+    /**
+   * Constructor for the TestFramework
+   * @param {Array} testFrameworks - List of Test frameworks
+   * @param {Map} testFrameworkVersions - Name of the Test frameworks
+   * @param {string} binSessionId - BinSessionId
+  */
+    constructor(testFrameworks, testFrameworkVersions, binSessionId) {
+        this.testFrameworks = testFrameworks;
+        this.testFrameworkVersions = testFrameworkVersions;
+        this.binSessionId = binSessionId;
+    }
+    /**
+   * get all instances
+   * @return {Map} - return all instances Map
+  */
+    getInstances() {
+        return TestFramework.instances;
+    }
+    /**
+   * set testFrameworkInstance
+   * @param {TrackedContext} context
+   * @param {TestFrameworkInstance} instance
+  */
+    setInstance(context, instance) {
+        TestFramework.instances.set(context.getId, instance);
+    }
+    /**
+   * Find instance and track any state for the test framework
+   * @returns instance
+  */
+    static getTrackedInstance() {
+        const ctx = TrackedInstance.createContext(CLIUtils.getCurrentInstanceName());
+        return TestFramework.instances.get(ctx.getId());
+    }
+    /**
+   * Set tracked instance
+   * @returns {string} The name of the test framework
+   */
+    static setTrackedInstance(context, instance) {
+        TestFramework.instances.set(context.getId(), instance);
+    }
+    /**
+   * get all test framework versions
+   * @returns {Map} - return all versions of framework available.
+   */
+    getTestFrameworksVersions() {
+        return this.testFrameworkVersions;
+    }
+    /**
+   * get all test frameworks
+   * @returns {Array} - return all test frameworks
+   */
+    getTestFrameworks() {
+        return this.testFrameworks;
+    }
+    /**
+   * Track an event
+   * @param {TestFrameworkState} testFrameworkState
+   * @param {HookState} hookState
+   * @param {*} args
+   * @returns {void}
+   */
+    trackEvent(testFrameworkState, hookState, args = {}) {
+        logger.info(`trackEvent: testFrameworkState=${testFrameworkState}; hookState=${hookState}; args=${args}`);
+    }
+    /**
+   * run test hooks
+   * @param {TestFrameworkInstance} instance
+   * @param {TestFrameworkState} testFrameworkState
+   * @param {HookState} hookState
+   * @param {*} args
+   */
+    async runHooks(instance, testFrameworkState, hookState, args = {}) {
+        logger.info(`runHooks: instance=${instance} automationFrameworkState=${testFrameworkState} hookState=${hookState}`);
+        const hookRegistryKey = CLIUtils.getHookRegistryKey(testFrameworkState, hookState);
+        await eventDispatcher.notifyObserver(hookRegistryKey, args);
+    }
+    /**
+   * Register an observer
+   * @param {TestFrameworkState} testFrameworkState
+   * @param {HookState} hookState
+   * @param {*} callback
+   * @returns {void}
+   */
+    static registerObserver(testFrameworkState, hookState, callback) {
+        eventDispatcher.registerObserver(CLIUtils.getHookRegistryKey(testFrameworkState, hookState), callback);
+    }
+    /**
+   * Resolve instance for the test framework
+   * @param {TestFrameworkInstance} testFrameworkInstance
+   * @param {string} key
+   * @returns {TestFrameworkInstance}
+   */
+    static getState(instance, key) {
+        return instance.getAllData().get(key);
+    }
+    static hasState(instance, key) {
+        return instance.hasData(key);
+    }
+    /**
+   * Set the state
+   * @param {TrackedInstance} instance - The instance
+   * @param {string} key - The key
+   * @param {*} value - The value
+   * @returns
+   */
+    static setState(instance, key, value) {
+        instance.getAllData().set(key, value);
+    }
+    updateInstanceState(instance, testFrameworkState, hookState) {
+        instance.setLastTestState(instance.getCurrentTestState());
+        instance.setLastHookState(instance.getCurrentHookState());
+        instance.setCurrentTestState(testFrameworkState);
+        instance.setCurrentHookState(hookState);
+    }
+}

package/build/cli/frameworks/wdioAutomationFramework.d.ts

@@ -0,0 +1,28 @@
+import AutomationFramework from './automationFramework.js';
+/**
+ * WebdriverIO Framework class
+ */
+export default class WdioAutomationFramework extends AutomationFramework {
+    constructor(automationFrameworkName: string, automationFrameworkVersion: string);
+    /**
+     * Find instance and track any state for the automation framework
+     * @param {*} automationFrameworkState
+     * @param {*} hookState
+     * @param {*} args
+     */
+    trackEvent(automationFrameworkState: State, hookState: State, args?: Record<string, unknown>): Promise<void>;
+    /**
+     * Resolve instance for the automation framework
+     * @param {*} automationFrameworkState
+     * @param {*} hookState
+     * @param {*} args
+     * @returns instance
+     */
+    resolveInstance(automationFrameworkState: State, hookState: State, args?: Record<string, unknown>): any;
+    /**
+     * Create instance for WebdriverIO
+     * @returns {void}
+     */
+    trackWebdriverIOInstance(automationFrameworkState: State, args?: Record<string, unknown>): void;
+}
+//# sourceMappingURL=wdioAutomationFramework.d.ts.map

package/build/cli/frameworks/wdioAutomationFramework.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wdioAutomationFramework.d.ts","sourceRoot":"","sources":["../../../src/cli/frameworks/wdioAutomationFramework.ts"],"names":[],"mappings":"AAAA,OAAO,mBAAmB,MAAM,0BAA0B,CAAA;AAO1D;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,uBAAwB,SAAQ,mBAAmB;gBAExD,uBAAuB,EAAE,MAAM,EAAE,0BAA0B,EAAE,MAAM;IAI/E;;;;;OAKG;IACG,UAAU,CAAC,wBAAwB,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;IAatG;;;;;;OAMG;IACH,eAAe,CAAC,wBAAwB,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;IAWrG;;;OAGG;IACH,wBAAwB,CAAC,wBAAwB,EAAE,KAAK,EAAE,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAwB/F"}

package/build/cli/frameworks/wdioAutomationFramework.js

@@ -0,0 +1,66 @@
+import AutomationFramework from './automationFramework.js';
+import { AutomationFrameworkState } from '../states/automationFrameworkState.js';
+import { CLIUtils } from '../cliUtils.js';
+import TrackedInstance from '../instances/trackedInstance.js';
+import AutomationFrameworkInstance from '../instances/automationFrameworkInstance.js';
+import { BStackLogger as logger } from '../cliLogger.js';
+/**
+ * WebdriverIO Framework class
+ */
+export default class WdioAutomationFramework extends AutomationFramework {
+    constructor(automationFrameworkName, automationFrameworkVersion) {
+        super(automationFrameworkName, automationFrameworkVersion);
+    }
+    /**
+     * Find instance and track any state for the automation framework
+     * @param {*} automationFrameworkState
+     * @param {*} hookState
+     * @param {*} args
+     */
+    async trackEvent(automationFrameworkState, hookState, args = {}) {
+        logger.info(`trackEvent: automationFrameworkState=${automationFrameworkState} hookState=${hookState}`);
+        await super.trackEvent(automationFrameworkState, hookState, args);
+        const instance = this.resolveInstance(automationFrameworkState, hookState, args);
+        if (instance === null) {
+            logger.error(`trackEvent: instance not found for automationFrameworkState=${automationFrameworkState} hookState=${hookState}`);
+            return;
+        }
+        args.instance = instance;
+        await this.runHooks(instance, automationFrameworkState, hookState, args);
+    }
+    /**
+     * Resolve instance for the automation framework
+     * @param {*} automationFrameworkState
+     * @param {*} hookState
+     * @param {*} args
+     * @returns instance
+     */
+    resolveInstance(automationFrameworkState, hookState, args = {}) {
+        let instance = null;
+        logger.info(`resolveInstance: resolving instance for automationFrameworkState=${automationFrameworkState} hookState=${hookState}`);
+        if (automationFrameworkState === AutomationFrameworkState.CREATE || automationFrameworkState === AutomationFrameworkState.NONE) {
+            this.trackWebdriverIOInstance(automationFrameworkState, args);
+        }
+        instance = AutomationFramework.getTrackedInstance();
+        return instance;
+    }
+    /**
+     * Create instance for WebdriverIO
+     * @returns {void}
+     */
+    trackWebdriverIOInstance(automationFrameworkState, args = {}) {
+        if (
+        // !args.browser &&
+        AutomationFramework.getTrackedInstance()) {
+            logger.info('trackWebdriverIOInstance: instance already exists');
+            return;
+        }
+        const target = CLIUtils.getCurrentInstanceName();
+        const trackedContext = TrackedInstance.createContext(target);
+        let instance = null;
+        logger.info(`trackWebdriverIOInstance: created instance for target=${target}, state=${automationFrameworkState}, args=${args}`);
+        instance = new AutomationFrameworkInstance(trackedContext, this.getAutomationFrameworkName(), this.getAutomationFrameworkVersion(), automationFrameworkState);
+        AutomationFramework.setTrackedInstance(trackedContext, instance);
+        logger.info(`trackWebdriverIOInstance: saved instance contextId=${trackedContext.getId()} target=${target}`);
+    }
+}

package/build/cli/frameworks/wdioMochaTestFramework.d.ts

@@ -0,0 +1,82 @@
+import TestFramework from './testFramework.js';
+import TestFrameworkInstance from '../instances/testFrameworkInstance.js';
+import type { Frameworks } from '@wdio/types';
+export default class WdioMochaTestFramework extends TestFramework {
+    static KEY_HOOK_LAST_STARTED: string;
+    static KEY_HOOK_LAST_FINISHED: string;
+    /**
+   * Constructor for the TestFramework
+   * @param {Array} testFrameworks - List of Test frameworks
+   * @param {Map} testFrameworkVersions - Name of the Test frameworks
+   * @param {string} binSessionId - BinSessionId
+  */
+    constructor(testFrameworks: string[], testFrameworkVersions: Record<string, string>, binSessionId: string);
+    /**
+     * Find instance and track any state for the test framework
+     * @param {TestFrameworkState} testFrameworkState
+     * @param {HookState} hookState
+     * @param {*} args
+  */
+    trackEvent(testFrameworkState: State, hookState: State, args?: Record<string, unknown>): Promise<void>;
+    /**
+   * Resolve instance for the test framework
+   * @param {TestFrameworkState} testFrameworkState
+   * @param {HookState} hookState
+   * @param {*} args
+   * @returns {TestFrameworkInstance}
+   */
+    resolveInstance(testFrameworkState: State, hookState: State, args?: Record<string, unknown>): TestFrameworkInstance | null;
+    /**
+   * Track WebdriverIO instance
+   * @param {TestFrameworkState} testFrameworkState
+   * @param {*} args
+   */
+    trackWdioMochaInstance(testFrameworkState: State, args: Record<string, unknown>): void;
+    getTestData(instance: TestFrameworkInstance, test: Frameworks.Test): Promise<Record<string, unknown>>;
+    loadTestResult(instance: TestFrameworkInstance, args: Record<string, unknown>): void;
+    /**
+     * Load log entries into the test framework instance.
+     * @param instance TestFrameworkInstance
+     * @param testFrameworkState TestFrameworkState
+     * @param hookState HookState
+     * @param args Additional arguments (level, message, etc.)
+     */
+    loadLogEntries(instance: TestFrameworkInstance, testFrameworkState: State, hookState: State, logEntry: Record<string, unknown>): void;
+    /**
+     * Get the last active hook for the given instance and hook key.
+     * @param instance TestFrameworkInstance
+     * @param lastHookKey string
+     * @returns Record<string, unknown> | null
+     */
+    static lastActiveHook(instance: TestFrameworkInstance, lastHookKey: string): Record<string, unknown> | null;
+    /**
+     * Clear logs for a specific hook.
+     * @param instance TestFrameworkInstance
+     * @param lastHookKey string
+     */
+    static clearHookLogs(instance: TestFrameworkInstance, lastHookKey: string): void;
+    /**
+     * Clear all logs for the given instance, test framework state, and hook state.
+     * @param instance TestFrameworkInstance
+     * @param testFrameworkState TestFrameworkState
+     * @param hookState HookState
+     */
+    static clearLogs(instance: TestFrameworkInstance, testFrameworkState: State, hookState: State): void;
+    /**
+     * Get all log entries for the given instance, test framework state, and hook state.
+     * @param instance TestFrameworkInstance
+     * @param testFrameworkState TestFrameworkState
+     * @param hookState HookState
+     * @returns unknown[]
+     */
+    static getLogEntries(instance: TestFrameworkInstance, testFrameworkState: State, hookState: State): unknown[];
+    /**
+     * Track hook events for the test framework.
+     * @param instance TestFrameworkInstance
+     * @param testFrameworkState TestFrameworkState
+     * @param hookState HookState
+     * @param args Additional arguments (e.g., test result, test method)
+     */
+    trackHookEvents(instance: TestFrameworkInstance, testFrameworkState: State, hookState: State, args: Record<string, unknown>): Promise<void>;
+}
+//# sourceMappingURL=wdioMochaTestFramework.d.ts.map

package/build/cli/frameworks/wdioMochaTestFramework.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wdioMochaTestFramework.d.ts","sourceRoot":"","sources":["../../../src/cli/frameworks/wdioMochaTestFramework.ts"],"names":[],"mappings":"AAGA,OAAO,aAAa,MAAM,oBAAoB,CAAA;AAG9C,OAAO,qBAAqB,MAAM,uCAAuC,CAAA;AAKzE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAI7C,MAAM,CAAC,OAAO,OAAO,sBAAuB,SAAQ,aAAa;IAC7D,MAAM,CAAC,qBAAqB,SAA2B;IACvD,MAAM,CAAC,sBAAsB,SAA4B;IAEzD;;;;;IAKA;gBACY,cAAc,EAAE,MAAM,EAAE,EAAE,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,MAAM;IAIzG;;;;;IAKA;IACM,UAAU,CAAC,kBAAkB,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;IAoDhG;;;;;;KAMC;IACD,eAAe,CAAC,kBAAkB,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,qBAAqB,GAAC,IAAI;IAa5H;;;;KAIC;IACD,sBAAsB,CAAC,kBAAkB,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAqCzE,WAAW,CAAC,QAAQ,EAAE,qBAAqB,EAAE,IAAI,EAAE,UAAU,CAAC,IAAI;IAmBxE,cAAc,CAAC,QAAQ,EAAE,qBAAqB,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAwB7E;;;;;;OAMG;IACH,cAAc,CAAC,QAAQ,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IA6B9H;;;;;OAKG;IACH,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,qBAAqB,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAqB3G;;;;OAIG;IACH,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,qBAAqB,EAAE,WAAW,EAAE,MAAM;IAOzE;;;;;OAKG;IACH,MAAM,CAAC,SAAS,CAAC,QAAQ,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK;IAY7F;;;;;;OAMG;IACH,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,GAAG,OAAO,EAAE;IAY7G;;;;;;OAMG;IACG,eAAe,CACjB,QAAQ,EAAE,qBAAqB,EAC/B,kBAAkB,EAAE,KAAK,EACzB,SAAS,EAAE,KAAK,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAwDpC"}