@wdio/browserstack-service 8.45.0 → 8.47.0

package/build/cli/modules/testHubModule.js

@@ -0,0 +1,232 @@
+import util from 'node:util';
+import BaseModule from './baseModule.js';
+import { BStackLogger } from '../cliLogger.js';
+import TestFramework from '../frameworks/testFramework.js';
+import { TestFrameworkState } from '../states/testFrameworkState.js';
+import { HookState } from '../states/hookState.js';
+import { CLIUtils } from '../cliUtils.js';
+import { TestFrameworkConstants } from '../frameworks/constants/testFrameworkConstants.js';
+import { GrpcClient } from '../grpcClient.js';
+import WdioMochaTestFramework from '../frameworks/wdioMochaTestFramework.js';
+import AutomationFramework from '../frameworks/automationFramework.js';
+import { AutomationFrameworkConstants } from '../frameworks/constants/automationFrameworkConstants.js';
+/**
+ * TestHub Module for BrowserStack
+ */
+export default class TestHubModule extends BaseModule {
+    logger = BStackLogger;
+    testhubConfig;
+    name;
+    static MODULE_NAME = 'TestHubModule';
+    /**
+     * Create a new TestHubModule
+     */
+    constructor(testhubConfig) {
+        super();
+        this.name = 'TestHubModule';
+        this.testhubConfig = testhubConfig;
+        TestFramework.registerObserver(TestFrameworkState.TEST, HookState.PRE, this.onBeforeTest.bind(this));
+        Object.values(TestFrameworkState).forEach(state => {
+            Object.values(HookState).forEach(hook => {
+                TestFramework.registerObserver(state, hook, this.onAllTestEvents.bind(this));
+            });
+        });
+    }
+    /**
+     * Get the module name
+     * @returns {string} The module name
+     */
+    getModuleName() {
+        return TestHubModule.MODULE_NAME;
+    }
+    onBeforeTest(args) {
+        this.logger.debug('onBeforeTest: Called after test hook from cli configured module!!!');
+        const autoInstace = AutomationFramework.getTrackedInstance();
+        const instances = [autoInstace];
+        args.autoInstance = instances;
+        this.sendTestSessionEvent(args);
+    }
+    onAllTestEvents(args) {
+        this.logger.debug('onAllTestEvents: Called after all test events from cli configured module!!!');
+        const instance = args.instance;
+        const testState = instance.getCurrentTestState();
+        const hookState = instance.getCurrentHookState();
+        const keyTestDeferred = TestFramework.getState(instance, TestFrameworkConstants.KEY_TEST_DEFERRED);
+        if (testState === TestFrameworkState.LOG) {
+            this.logger.debug(`onAllTestEvents: TestFrameworkState.LOG - ${testState}`);
+            const logEntries = WdioMochaTestFramework.getLogEntries(instance, testState, hookState);
+            if (logEntries && logEntries.length > 0) {
+                args.logEntries = logEntries;
+                this.sendLogCreatedEvent(args);
+                WdioMochaTestFramework.clearLogs(instance, testState, hookState);
+                // Handle LOG state if needed
+            }
+        }
+        else if (testState === TestFrameworkState.TEST &&
+            hookState === HookState.POST &&
+            !TestFramework.hasState(instance, TestFrameworkConstants.KEY_TEST_RESULT_AT)) {
+            this.logger.info('onAllTestEvents: dropping due to lack of results');
+            TestFramework.setState(instance, TestFrameworkConstants.KEY_TEST_DEFERRED, true);
+        }
+        else if (keyTestDeferred &&
+            testState === TestFrameworkState.LOG_REPORT &&
+            hookState === HookState.POST &&
+            TestFramework.hasState(instance, TestFrameworkConstants.KEY_TEST_RESULT_AT)) {
+            // Create a modified args object with updated test framework state
+            instance.setCurrentTestState(TestFrameworkState.TEST);
+            this.onAllTestEvents(args);
+        }
+        if (testState === TestFrameworkState.TEST || CLIUtils.matchHookRegex(testState.toString().split('.')[1])) {
+            this.sendTestFrameworkEvent(args);
+        }
+    }
+    async sendTestFrameworkEvent(args) {
+        try {
+            const testArgs = args;
+            const instance = testArgs.instance;
+            const trackedContext = instance.getContext();
+            const testData = instance.getAllData();
+            const testFrameworkName = testData.get(TestFrameworkConstants.KEY_TEST_FRAMEWORK_NAME) || '';
+            const testFrameworkVersion = testData.get(TestFrameworkConstants.KEY_TEST_FRAMEWORK_VERSION) || '';
+            const startedAt = testData.get(TestFrameworkConstants.KEY_TEST_STARTED_AT) || '';
+            const endedAt = testData.get(TestFrameworkConstants.KEY_TEST_ENDED_AT) || '';
+            const testFrameworkState = instance.getCurrentTestState().toString().split('.')[1];
+            const testHookState = instance.getCurrentHookState().toString().split('.')[1];
+            this.logger.debug(`sendTestFrameworkEvent for testState: ${testFrameworkState} hookState: ${testHookState}`);
+            const platformIndex = process.env.WDIO_WORKER_ID ? parseInt(process.env.WDIO_WORKER_ID.split('-')[0]) : 0;
+            const uuid = TestFramework.getState(instance, TestFrameworkConstants.KEY_TEST_UUID) || instance.getRef();
+            const eventJson = Buffer.from(JSON.stringify(Object.fromEntries(testData)));
+            const executionContext = { hash: trackedContext.getId(), threadId: trackedContext.getThreadId().toString(), processId: trackedContext.getProcessId().toString() };
+            const payload = {
+                platformIndex,
+                testFrameworkName,
+                testFrameworkVersion,
+                testFrameworkState,
+                testHookState,
+                startedAt,
+                endedAt,
+                uuid,
+                eventJson,
+                executionContext
+            };
+            this.logger.debug(`sendTestFrameworkEvent payload: ${JSON.stringify(payload)}`);
+            await GrpcClient.getInstance().testFrameworkEvent(payload);
+            this.logger.debug(`sendTestFrameworkEvent complete for testState: ${testFrameworkState} hookState: ${testHookState}`);
+        }
+        catch (error) {
+            this.logger.error(`Error in sendTestFrameworkEvent: ${util.format(error)}`);
+        }
+    }
+    /**
+     * Send test session event to the service
+     * @param args containing test session data
+     */
+    async sendTestSessionEvent(args) {
+        this.logger.debug('sendTestSessionEvent: Called');
+        try {
+            const instance = args.instance;
+            const autoInstances = args.autoInstance || [];
+            const trackedContext = instance.getContext();
+            const testFWName = TestFramework.getState(instance, TestFrameworkConstants.KEY_TEST_FRAMEWORK_NAME);
+            const testFWVersion = TestFramework.getState(instance, TestFrameworkConstants.KEY_TEST_FRAMEWORK_VERSION);
+            const testState = instance.getCurrentTestState().toString().split('.')[1];
+            const hookState = instance.getCurrentHookState().toString().split('.')[1];
+            this.logger.debug('sendTestSessionEvent: setup');
+            const executionContext = {
+                threadId: trackedContext.getThreadId().toString(),
+                processId: trackedContext.getProcessId().toString()
+            };
+            const payload = {
+                testFrameworkName: testFWName,
+                testFrameworkVersion: testFWVersion,
+                testFrameworkState: testState.toString(),
+                testHookState: hookState.toString(),
+                testUuid: TestFramework.getState(instance, TestFrameworkConstants.KEY_TEST_UUID).toString(),
+                executionContext,
+                automationSessions: [],
+                platformIndex: process.env.WDIO_WORKER_ID ? parseInt(process.env.WDIO_WORKER_ID.split('-')[0]) : 0,
+                capabilities: new Uint8Array()
+            };
+            // Try to get capabilities from the first driver
+            try {
+                if (autoInstances.length > 0) {
+                    const driver = AutomationFramework.getDriver(autoInstances[0]); // RemoteWebDriver equivalent
+                    const userCaps = JSON.stringify(driver.capabilities);
+                    if (userCaps) {
+                        payload.capabilities = new TextEncoder().encode(userCaps);
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.debug(`Error while getting capabilities from driver: ${error}`);
+            }
+            this.logger.debug(`sendTestSessionEvent: instance iteration ${JSON.stringify(autoInstances)}`);
+            // Process automation instances
+            for (const autoInstance of autoInstances) {
+                const sessionProvider = AutomationFramework.getState(autoInstance, AutomationFrameworkConstants.KEY_IS_BROWSERSTACK_HUB)
+                    ? 'browserstack'
+                    : 'unknown_grid';
+                // eslint-disable-next-line camelcase
+                const automationSession = {
+                    provider: sessionProvider,
+                    ref: autoInstance.getRef(),
+                    hubUrl: this.config.hubUrl,
+                    frameworkSessionId: AutomationFramework.getState(autoInstance, AutomationFrameworkConstants.KEY_FRAMEWORK_SESSION_ID).toString(),
+                    frameworkName: autoInstance.frameworkName,
+                    frameworkVersion: autoInstance.frameworkVersion
+                };
+                this.logger.debug(`sendTestSessionEvent: automationSession: ${JSON.stringify(automationSession)}`);
+                payload.platformIndex = process.env.WDIO_WORKER_ID ? parseInt(process.env.WDIO_WORKER_ID.split('-')[0]) : 0;
+                payload.automationSessions.push(automationSession);
+            }
+            this.logger.debug(`sendTestSessionEvent payload: ${JSON.stringify(payload)}`);
+            await GrpcClient.getInstance().testSessionEvent(payload);
+            this.logger.debug(`sendTestSessionEvent complete for testState: ${testState} hookState: ${hookState}`);
+        }
+        catch (error) {
+            this.logger.error(`sendTestSessionEvent: Error sending grpc call: event=${JSON.stringify(args)}, error=${error}`);
+            throw new Error(`Failed to send test session event: ${error}`);
+        }
+    }
+    async sendLogCreatedEvent(args) {
+        try {
+            const testArgs = args;
+            const logEntries = args.logEntries;
+            const instance = testArgs.instance;
+            const trackedContext = instance.getContext();
+            const testData = instance.getAllData();
+            const testFrameworkName = testData.get(TestFrameworkConstants.KEY_TEST_FRAMEWORK_NAME) || '';
+            const testFrameworkVersion = testData.get(TestFrameworkConstants.KEY_TEST_FRAMEWORK_VERSION) || '';
+            const testFrameworkState = instance.getCurrentTestState().toString().split('.')[1];
+            const testHookState = instance.getCurrentHookState().toString().split('.')[1];
+            this.logger.debug(`sendLogCreatedEvent testId: testFrameworkState: ${testFrameworkState} testHookState: ${testHookState}`);
+            const platformIndex = process.env.WDIO_WORKER_ID ? parseInt(process.env.WDIO_WORKER_ID.split('-')[0]) : 0;
+            const executionContext = { hash: trackedContext.getId(), threadId: trackedContext.getThreadId().toString(), processId: trackedContext.getProcessId().toString() };
+            const payload = {
+                platformIndex,
+                logs: [],
+                executionContext
+            };
+            for (const logEntry of logEntries) {
+                // eslint-disable-next-line camelcase
+                const logData = {
+                    testFrameworkName,
+                    testFrameworkVersion,
+                    testFrameworkState,
+                    uuid: logEntry[TestFrameworkConstants.KEY_HOOK_ID] || TestFramework.getState(instance, TestFrameworkConstants.KEY_TEST_UUID),
+                    kind: logEntry.kind,
+                    message: logEntry.message,
+                    timestamp: logEntry.timestamp,
+                    level: logEntry.level,
+                };
+                payload.logs.push(logData);
+            }
+            this.logger.debug(`sendLogCreatedEvent payload: ${JSON.stringify(payload)}`);
+            await GrpcClient.getInstance().logCreatedEvent(payload);
+            this.logger.debug(`sendLogCreatedEvent complete for testState: ${testFrameworkState} hookState: ${testHookState}`);
+        }
+        catch (error) {
+            this.logger.error(`Error in sendLogCreatedEvent: ${util.format(error)}`);
+        }
+    }
+}

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

@@ -0,0 +1,29 @@
+import BaseModule from './baseModule.js';
+import { BStackLogger } from '../cliLogger.js';
+import type AutomationFrameworkInstance from '../instances/automationFrameworkInstance.js';
+export default class WebdriverIOModule extends BaseModule {
+    name: string;
+    browserName: string | null;
+    browserVersion: string | null;
+    platforms: Array<string>;
+    testRunId: string | null;
+    logger: typeof BStackLogger;
+    static MODULE_NAME: string;
+    /**
+       * Create a new WebdriverIOModule
+       */
+    constructor();
+    /**
+       * Get the module name
+       * @returns {string} The module name
+       */
+    getModuleName(): string;
+    onBeforeDriverCreate(args: Record<string, unknown>): Promise<void>;
+    /**
+     * Handle driver creation event
+     * @param args Event arguments containing driver and instance information
+     */
+    onDriverCreated(args: Record<string, unknown>): Promise<void>;
+    getBinDriverCapabilities(instance: AutomationFrameworkInstance, caps: WebdriverIO.Capabilities): Promise<void>;
+}
+//# sourceMappingURL=webdriverIOModule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webdriverIOModule.d.ts","sourceRoot":"","sources":["../../../src/cli/modules/webdriverIOModule.ts"],"names":[],"mappings":"AACA,OAAO,UAAU,MAAM,iBAAiB,CAAA;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAI9C,OAAO,KAAK,2BAA2B,MAAM,6CAA6C,CAAA;AAM1F,MAAM,CAAC,OAAO,OAAO,iBAAkB,SAAQ,UAAU;IACrD,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACxB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IAExB,MAAM,sBAAe;IACrB,MAAM,CAAC,WAAW,SAAsB;IAExC;;SAEK;;IAaL;;;SAGK;IACL,aAAa;IAIP,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAiBxD;;;OAGG;IACG,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAqD7D,wBAAwB,CAAC,QAAQ,EAAE,2BAA2B,EAAE,IAAI,EAAE,WAAW,CAAC,YAAY;CAqBvG"}

package/build/cli/modules/webdriverIOModule.js

@@ -0,0 +1,128 @@
+import util from 'node:util';
+import BaseModule from './baseModule.js';
+import { BStackLogger } from '../cliLogger.js';
+import AutomationFramework from '../frameworks/automationFramework.js';
+import { AutomationFrameworkState } from '../states/automationFrameworkState.js';
+import { HookState } from '../states/hookState.js';
+import { AutomationFrameworkConstants } from '../frameworks/constants/automationFrameworkConstants.js';
+import { isBrowserstackSession } from '../../util.js';
+import { GrpcClient } from '../grpcClient.js';
+export default class WebdriverIOModule extends BaseModule {
+    name;
+    browserName;
+    browserVersion;
+    platforms;
+    testRunId;
+    logger = BStackLogger;
+    static MODULE_NAME = 'WebdriverIOModule';
+    /**
+       * Create a new WebdriverIOModule
+       */
+    constructor() {
+        super();
+        this.name = 'WebdriverIOModule';
+        this.browserName = null;
+        this.browserVersion = null;
+        this.platforms = [];
+        this.testRunId = null;
+        AutomationFramework.registerObserver(AutomationFrameworkState.CREATE, HookState.PRE, this.onBeforeDriverCreate.bind(this));
+        AutomationFramework.registerObserver(AutomationFrameworkState.CREATE, HookState.POST, this.onDriverCreated.bind(this));
+    }
+    /**
+       * Get the module name
+       * @returns {string} The module name
+       */
+    getModuleName() {
+        return WebdriverIOModule.MODULE_NAME;
+    }
+    async onBeforeDriverCreate(args) {
+        try {
+            const instance = args.instance;
+            this.logger.debug('onBeforeDriverCreate: driver is about to be created');
+            const capabilities = args.caps;
+            if (!capabilities) {
+                this.logger.warn('onBeforeDriverCreate: No capabilities provided');
+                return;
+            }
+            AutomationFramework.setState(instance, AutomationFrameworkConstants.KEY_INPUT_CAPABILITIES, capabilities);
+            await this.getBinDriverCapabilities(instance, capabilities);
+        }
+        catch (e) {
+            this.logger.error(`Error in onBeforeDriverCreate: ${util.format(e)}`);
+        }
+    }
+    /**
+     * Handle driver creation event
+     * @param args Event arguments containing driver and instance information
+     */
+    async onDriverCreated(args) {
+        this.logger.debug('onDriverCreated: Called');
+        try {
+            const instance = args.instance;
+            const browser = args.browser;
+            if (!instance || !browser) {
+                this.logger.warn('onDriverCreated: Missing instance or driver');
+                return;
+            }
+            AutomationFramework.setState(instance, AutomationFrameworkConstants.KEY_HUB_URL, args.hubUrl);
+            // Get session ID from driver
+            let sessionId = null;
+            try {
+                sessionId = browser.sessionId;
+                if (sessionId) {
+                    this.logger.debug(`onDriverCreated: Driver session ID: ${sessionId}`);
+                    AutomationFramework.setState(instance, AutomationFrameworkConstants.KEY_FRAMEWORK_SESSION_ID, sessionId);
+                }
+            }
+            catch (error) {
+                this.logger.debug(`onDriverCreated: Could not get session ID: ${error}`);
+            }
+            // Get capabilities from driver
+            try {
+                const capabilities = browser.capabilities;
+                if (capabilities) {
+                    this.logger.debug(`onDriverCreated: Driver capabilities: ${JSON.stringify(capabilities)}`);
+                    AutomationFramework.setState(instance, AutomationFrameworkConstants.KEY_CAPABILITIES, capabilities);
+                }
+            }
+            catch (error) {
+                this.logger.debug(`onDriverCreated: Could not get capabilities: ${error}`);
+            }
+            // Check if this is a BrowserStack hub
+            try {
+                const isBrowserStackHub = isBrowserstackSession(browser);
+                AutomationFramework.setState(instance, AutomationFrameworkConstants.KEY_IS_BROWSERSTACK_HUB, isBrowserStackHub);
+                this.logger.debug(`onDriverCreated: Is BrowserStack hub: ${isBrowserStackHub}`);
+            }
+            catch (error) {
+                this.logger.debug(`onDriverCreated: Could not determine hub type: ${error}`);
+            }
+            AutomationFramework.setDriver(instance, browser);
+            this.logger.info(`onDriverCreated: Successfully processed driver creation for session: ${sessionId}`);
+        }
+        catch (error) {
+            this.logger.error(`onDriverCreated: Error processing driver creation: ${error}`);
+        }
+    }
+    async getBinDriverCapabilities(instance, caps) {
+        try {
+            const payload = {
+                platformIndex: process.env.WDIO_WORKER_ID ? parseInt(process.env.WDIO_WORKER_ID.split('-')[0]) : 0,
+                ref: instance.getRef(),
+                userInputParams: Buffer.from(JSON.stringify(caps).toString())
+            };
+            const response = await GrpcClient.getInstance().driverInitEvent(payload);
+            if (response.success) {
+                if (response.capabilities.length > 0) {
+                    const capabilitiesStr = response.capabilities.toString('utf8');
+                    const capabilitiesObj = JSON.parse(capabilitiesStr);
+                    AutomationFramework.setState(instance, AutomationFrameworkConstants.KEY_CAPABILITIES, capabilitiesObj);
+                }
+                this.logger.debug(`getBinDriverCapabilities: got hub url ${response.hubUrl}`);
+            }
+        }
+        catch (error) {
+            this.logger.error(`getBinDriverCapabilities: Error getting capabilities: ${error}`);
+        }
+    }
+}

package/build/cli/states/automationFrameworkState.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Enum representing different states of an automation framework
+ * @readonly
+ * @enum {Object}
+ */
+export declare const AutomationFrameworkState: Readonly<{
+    /**
+   * Initial state, no session created
+   */
+    NONE: {
+        value: number;
+        toString(): string;
+    };
+    /**
+   * Framework instance is being created
+   */
+    CREATE: {
+        value: number;
+        toString(): string;
+    };
+    /**
+   * Framework is executing tests
+   */
+    EXECUTE: {
+        value: number;
+        toString(): string;
+    };
+    /**
+   * Framework is idle, not executing any tests
+   */
+    IDLE: {
+        value: number;
+        toString(): string;
+    };
+    /**
+   * Framework is shutting down
+   */
+    QUIT: {
+        value: number;
+        toString(): string;
+    };
+}>;
+/**
+ * Get state by value
+ *
+ * @param {number} value - The numeric value of the state
+ * @returns {Object|undefined} The state object or undefined if not found
+ */
+export declare const fromValue: (value: number) => {
+    value: number;
+    toString(): string;
+} | {
+    value: number;
+    toString(): string;
+} | {
+    value: number;
+    toString(): string;
+} | {
+    value: number;
+    toString(): string;
+} | {
+    value: number;
+    toString(): string;
+} | undefined;
+//# sourceMappingURL=automationFrameworkState.d.ts.map

package/build/cli/states/automationFrameworkState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"automationFrameworkState.d.ts","sourceRoot":"","sources":["../../../src/cli/states/automationFrameworkState.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;IACjC;;KAEC;;;;;IAQD;;KAEC;;;;;IAQD;;KAEC;;;;;IAQD;;KAEC;;;;;IAQD;;KAEC;;;;;EAOH,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,UAAmB,MAAM;;;;;;;;;;;;;;;aAE9C,CAAA"}

package/build/cli/states/automationFrameworkState.js

@@ -0,0 +1,61 @@
+/**
+ * Enum representing different states of an automation framework
+ * @readonly
+ * @enum {Object}
+ */
+export const AutomationFrameworkState = Object.freeze({
+    /**
+   * Initial state, no session created
+   */
+    NONE: {
+        value: 0,
+        toString() {
+            return 'AutomationFrameworkState.NONE';
+        }
+    },
+    /**
+   * Framework instance is being created
+   */
+    CREATE: {
+        value: 1,
+        toString() {
+            return 'AutomationFrameworkState.CREATE';
+        }
+    },
+    /**
+   * Framework is executing tests
+   */
+    EXECUTE: {
+        value: 2,
+        toString() {
+            return 'AutomationFrameworkState.EXECUTE';
+        }
+    },
+    /**
+   * Framework is idle, not executing any tests
+   */
+    IDLE: {
+        value: 3,
+        toString() {
+            return 'AutomationFrameworkState.IDLE';
+        }
+    },
+    /**
+   * Framework is shutting down
+   */
+    QUIT: {
+        value: 4,
+        toString() {
+            return 'AutomationFrameworkState.QUIT';
+        }
+    }
+});
+/**
+ * Get state by value
+ *
+ * @param {number} value - The numeric value of the state
+ * @returns {Object|undefined} The state object or undefined if not found
+ */
+export const fromValue = function (value) {
+    return Object.values(AutomationFrameworkState).find(state => state.value === value);
+};

package/build/cli/states/hookState.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Enum representing different states of a hook
+ * @readonly
+ * @enum {Object}
+ */
+export declare const HookState: Readonly<{
+    /**
+     * No hook, initial state
+     */
+    NONE: {
+        value: number;
+        toString(): string;
+    };
+    /**
+     * Pre-execution hook
+     */
+    PRE: {
+        value: number;
+        toString(): string;
+    };
+    /**
+     * Post-execution hook
+     */
+    POST: {
+        value: number;
+        toString(): string;
+    };
+}>;
+/**
+   * Get hook state by value
+   *
+   * @param {number} value - The numeric value of the hook state
+   * @returns {Object|undefined} The hook state object or undefined if not found
+   */
+export declare const fromValue: (value: number) => {
+    value: number;
+    toString(): string;
+} | {
+    value: number;
+    toString(): string;
+} | {
+    value: number;
+    toString(): string;
+} | undefined;
+//# sourceMappingURL=hookState.d.ts.map

package/build/cli/states/hookState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hookState.d.ts","sourceRoot":"","sources":["../../../src/cli/states/hookState.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,SAAS;IAClB;;OAEG;;;;;IAQH;;OAEG;;;;;IAQH;;OAEG;;;;;EAOL,CAAA;AAEF;;;;;KAKK;AACL,eAAO,MAAM,SAAS,UAAmB,MAAM;;;;;;;;;aAE9C,CAAA"}

package/build/cli/states/hookState.js

@@ -0,0 +1,43 @@
+/**
+ * Enum representing different states of a hook
+ * @readonly
+ * @enum {Object}
+ */
+export const HookState = Object.freeze({
+    /**
+     * No hook, initial state
+     */
+    NONE: {
+        value: 0,
+        toString() {
+            return 'HookState.NONE';
+        }
+    },
+    /**
+     * Pre-execution hook
+     */
+    PRE: {
+        value: 1,
+        toString() {
+            return 'HookState.PRE';
+        }
+    },
+    /**
+     * Post-execution hook
+     */
+    POST: {
+        value: 2,
+        toString() {
+            return 'HookState.POST';
+        }
+    }
+});
+/**
+   * Get hook state by value
+   *
+   * @param {number} value - The numeric value of the hook state
+   * @returns {Object|undefined} The hook state object or undefined if not found
+   */
+export const fromValue = function (value) {
+    return Object.values(HookState).find(state => state.value === value);
+};