@wdio/browserstack-service 9.23.2 → 9.24.0

package/build/cleanup.js

@@ -1,11 +1,11 @@
 // src/util.ts
-import { hostname as hostname2, platform as platform2, type as type2, version as version2, arch as arch2, tmpdir } from "node:os";
+import { hostname as hostname2, platform as platform3, type as type2, version as version2, arch as arch3, tmpdir } from "node:os";
 import crypto from "node:crypto";
-import fs5 from "node:fs";
+import fs7 from "node:fs";
 import zlib from "node:zlib";
-import { format, promisify } from "node:util";
-import path4 from "node:path";
-import util2 from "node:util";
+import { format, promisify as promisify2 } from "node:util";
+import path6 from "node:path";
+import util3 from "node:util";
 import gitRepoInfo from "git-repo-info";
 import gitconfig from "gitconfiglocal";
 import { FormData } from "formdata-node";
@@ -54,13 +54,13 @@ var logPatcher_default = logPatcher;
 
 // src/instrumentation/performance/performance-tester.ts
 import { createObjectCsvWriter } from "csv-writer";
-import fs2 from "node:fs";
+import fs4 from "node:fs";
 import fsPromise from "node:fs/promises";
 import { performance, PerformanceObserver } from "node:perf_hooks";
-import util from "node:util";
+import util2 from "node:util";
 import worker from "node:worker_threads";
-import path2 from "node:path";
-import { arch, hostname, platform, type, version } from "node:os";
+import path4 from "node:path";
+import { arch as arch2, hostname, platform as platform2, type, version } from "node:os";
 
 // src/bstackLogger.ts
 import path from "node:path";
@@ -71,7 +71,7 @@ import logger from "@wdio/logger";
 // package.json
 var package_default = {
   name: "@wdio/browserstack-service",
-  version: "9.23.1",
+  version: "9.23.3",
   description: "WebdriverIO service for better Browserstack integration",
   author: "Adam Bjerstedt <abjerstedt@gmail.com>",
   homepage: "https://github.com/webdriverio/webdriverio/tree/main/packages/wdio-browserstack-service",
@@ -122,7 +122,7 @@ var package_default = {
     "git-repo-info": "^2.1.1",
     gitconfiglocal: "^2.1.0",
     glob: "^11.0.0",
-    tar: "^6.1.15",
+    tar: "^7.5.7",
     undici: "^6.21.3",
     uuid: "^11.1.0",
     webdriverio: "workspace:*",
@@ -163,7 +163,7 @@ var BROWSERSTACK_OBSERVABILITY = "BROWSERSTACK_OBSERVABILITY";
 var MAX_GIT_META_DATA_SIZE_IN_BYTES = 64 * 1024;
 var GIT_META_DATA_TRUNCATED = "...[TRUNCATED]";
 var WDIO_NAMING_PREFIX = "WebdriverIO-";
-var PERF_METRICS_WAIT_TIME = 2e3;
+var UPDATED_CLI_ENDPOINT = "sdk/v1/update_cli";
 
 // src/bstackLogger.ts
 var log = logger("@wdio/browserstack-service");
@@ -256,6 +256,17 @@ var APIUtils = class {
   }
 };
 
+// src/cli/cliUtils.ts
+import fs3 from "node:fs";
+import fsp from "node:fs/promises";
+import { platform, arch, homedir } from "node:os";
+import path3 from "node:path";
+import util, { promisify } from "node:util";
+import { exec } from "node:child_process";
+import { Readable } from "node:stream";
+import yauzl from "yauzl";
+import { threadId } from "node:worker_threads";
+
 // src/fetchWrapper.ts
 import { fetch as undiciFetch, ProxyAgent } from "undici";
 var ResponseError = class extends Error {
@@ -288,29 +299,963 @@ function _fetch(input, init) {
   return fetch(input, init);
 }
 
+// src/instrumentation/performance/constants.ts
+var EVENTS = {
+  SDK_SETUP: "sdk:setup",
+  SDK_CLEANUP: "sdk:cleanup",
+  SDK_PRE_TEST: "sdk:pre-test",
+  SDK_TEST: "sdk:test",
+  SDK_POST_TEST: "sdk:post-test",
+  SDK_HOOK: "sdk:hook",
+  SDK_DRIVER: "sdk:driver",
+  SDK_A11Y: "sdk:a11y",
+  SDK_O11Y: "sdk:o11y",
+  SDK_AUTO_CAPTURE: "sdk:auto-capture",
+  SDK_PROXY_SETUP: "sdk:proxy-setup",
+  SDK_TESTHUB: "sdk:testhub",
+  SDK_AUTOMATE: "sdk:automate",
+  SDK_APP_AUTOMATE: "sdk:app-automate",
+  SDK_TURBOSCALE: "sdk:turboscale",
+  SDK_PERCY: "sdk:percy",
+  SDK_PRE_INITIALIZE: "sdk:driver:pre-initialization",
+  SDK_POST_INITIALIZE: "sdk:driver:post-initialization",
+  SDK_CLI_CHECK_UPDATE: "sdk:cli:check-update",
+  SDK_CLI_DOWNLOAD: "sdk:cli:download",
+  SDK_CLI_ON_BOOTSTRAP: "sdk:cli:on-bootstrap",
+  SDK_CLI_ON_CONNECT: "sdk:cli:on-connect",
+  SDK_CLI_START: "sdk:cli:start",
+  SDK_CLI_ON_STOP: "sdk:cli:on-stop",
+  SDK_CONNECT_BIN_SESSION: "sdk:connectBinSession",
+  SDK_START_BIN_SESSION: "sdk:startBinSession",
+  // New events from Python SDK
+  SDK_DRIVER_INIT: "sdk:driverInit",
+  SDK_FIND_NEAREST_HUB: "sdk:findNearestHub",
+  SDK_AUTOMATION_FRAMEWORK_INIT: "sdk:automationFrameworkInit",
+  SDK_AUTOMATION_FRAMEWORK_START: "sdk:automationFrameworkStart",
+  SDK_AUTOMATION_FRAMEWORK_STOP: "sdk:automationFrameworkStop",
+  SDK_ACCESSIBILITY_CONFIG: "sdk:accessibilityConfig",
+  SDK_OBSERVABILITY_CONFIG: "sdk:observabilityConfig",
+  SDK_AI_SELF_HEAL_STEP: "sdk:aiSelfHealStep",
+  SDK_AI_SELF_HEAL_GET_RESULT: "sdk:aiSelfHealGetResult",
+  SDK_TEST_FRAMEWORK_EVENT: "sdk:testFrameworkEvent",
+  SDK_TEST_SESSION_EVENT: "sdk:testSessionEvent",
+  SDK_CLI_LOG_CREATED_EVENT: "sdk:cli:logCreatedEvent",
+  SDK_CLI_ENQUEUE_TEST_EVENT: "sdk:cli:enqueueTestEvent",
+  SDK_ON_STOP: "sdk:onStop",
+  SDK_SEND_LOGS: "sdk:sendlogs",
+  // Funnel Events
+  SDK_FUNNEL_TEST_ATTEMPTED: "sdk:funnel:test-attempted",
+  SDK_FUNNEL_TEST_SUCCESSFUL: "sdk:funnel:test-successful",
+  // Log Upload Events
+  SDK_UPLOAD_LOGS: "sdk:upload-logs",
+  // Key Metrics Events
+  SDK_SEND_KEY_METRICS: "sdk:send-key-metrics",
+  SDK_KEY_METRICS_PREPARATION: "sdk:key-metrics:preparation",
+  SDK_KEY_METRICS_UPLOAD: "sdk:key-metrics:upload",
+  // CLI Binary Events
+  SDK_CLI_DOWNLOAD_BINARY: "sdk:cli:download-binary",
+  SDK_CLI_BINARY_VERIFICATION: "sdk:cli:binary-verification",
+  // Cleanup & Shutdown Events (tracking gap between driver:quit and funnel:test-successful)
+  SDK_LISTENER_WORKER_END: "sdk:listener:worker-end",
+  SDK_PERCY_TEARDOWN: "sdk:percy:teardown",
+  SDK_WORKER_SAVE_DATA: "sdk:worker:save-data",
+  SDK_PERFORMANCE_REPORT_GEN: "sdk:performance:report-generation",
+  SDK_PERFORMANCE_JSON_WRITE: "sdk:performance:json-write",
+  SDK_PERFORMANCE_HTML_GEN: "sdk:performance:html-generation",
+  // Device Allocation Event (tracking gap between beforeSession and before hooks)
+  SDK_DEVICE_ALLOCATION: "sdk:device-allocation"
+};
+var TESTHUB_EVENTS = {
+  START: `${EVENTS.SDK_TESTHUB}:start`,
+  STOP: `${EVENTS.SDK_TESTHUB}:stop`
+};
+var AUTOMATE_EVENTS = {
+  KEEP_ALIVE: `${EVENTS.SDK_AUTOMATE}:keep-alive`,
+  HUB_MANAGEMENT: `${EVENTS.SDK_AUTOMATE}:hub-management`,
+  LOCAL_START: `${EVENTS.SDK_AUTOMATE}:local-start`,
+  LOCAL_STOP: `${EVENTS.SDK_AUTOMATE}:local-stop`,
+  DRIVER_MANAGE: `${EVENTS.SDK_AUTOMATE}:driver-manage`,
+  SESSION_NAME: `${EVENTS.SDK_AUTOMATE}:session-name`,
+  SESSION_STATUS: `${EVENTS.SDK_AUTOMATE}:session-status`,
+  SESSION_ANNOTATION: `${EVENTS.SDK_AUTOMATE}:session-annotation`,
+  IDLE_TIMEOUT: `${EVENTS.SDK_AUTOMATE}:idle-timeout`,
+  GENERATE_CI_ARTIFACT: `${EVENTS.SDK_AUTOMATE}:ci-artifacts`,
+  PRINT_BUILDLINK: `${EVENTS.SDK_AUTOMATE}:print-buildlink`
+};
+var A11Y_EVENTS = {
+  PERFORM_SCAN: `${EVENTS.SDK_A11Y}:driver-performscan`,
+  SAVE_RESULTS: `${EVENTS.SDK_A11Y}:save-results`,
+  GET_RESULTS: `${EVENTS.SDK_A11Y}:get-accessibility-results`,
+  GET_RESULTS_SUMMARY: `${EVENTS.SDK_A11Y}:get-accessibility-results-summary`
+};
+var PERCY_EVENTS = {
+  DOWNLOAD: `${EVENTS.SDK_PERCY}:download`,
+  SCREENSHOT: `${EVENTS.SDK_PERCY}:screenshot`,
+  START: `${EVENTS.SDK_PERCY}:start`,
+  STOP: `${EVENTS.SDK_PERCY}:stop`,
+  AUTO_CAPTURE: `${EVENTS.SDK_PERCY}:auto-capture`,
+  SNAPSHOT: `${EVENTS.SDK_PERCY}:snapshot`,
+  SCREENSHOT_APP: `${EVENTS.SDK_PERCY}:screenshot-app`
+};
+var O11Y_EVENTS = {
+  SYNC: `${EVENTS.SDK_O11Y}:sync`,
+  TAKE_SCREENSHOT: `${EVENTS.SDK_O11Y}:driver-takeScreenShot`,
+  PRINT_BUILDLINK: `${EVENTS.SDK_O11Y}:print-buildlink`
+};
+var HOOK_EVENTS = {
+  BEFORE_EACH: `${EVENTS.SDK_HOOK}:before-each`,
+  AFTER_EACH: `${EVENTS.SDK_HOOK}:after-each`,
+  AFTER_ALL: `${EVENTS.SDK_HOOK}:after-all`,
+  BEFORE_ALL: `${EVENTS.SDK_HOOK}:before-all`,
+  BEFORE: `${EVENTS.SDK_HOOK}:before`,
+  AFTER: `${EVENTS.SDK_HOOK}:after`
+};
+var TURBOSCALE_EVENTS = {
+  HUB_MANAGEMENT: `${EVENTS.SDK_TURBOSCALE}:hub-management`,
+  PRINT_BUILDLINK: `${EVENTS.SDK_TURBOSCALE}:print-buildlink`
+};
+var APP_AUTOMATE_EVENTS = {
+  APP_UPLOAD: `${EVENTS.SDK_APP_AUTOMATE}:app-upload`
+};
+var DRIVER_EVENT = {
+  QUIT: `${EVENTS.SDK_DRIVER}:quit`,
+  GET: `${EVENTS.SDK_DRIVER}:get`,
+  PRE_EXECUTE: `${EVENTS.SDK_DRIVER}:pre-execute`,
+  POST_EXECUTE: `${EVENTS.SDK_DRIVER}:post-execute`,
+  INIT: EVENTS.SDK_DRIVER_INIT,
+  PRE_INITIALIZE: EVENTS.SDK_PRE_INITIALIZE,
+  POST_INITIALIZE: EVENTS.SDK_POST_INITIALIZE
+};
+var FRAMEWORK_EVENTS = {
+  INIT: EVENTS.SDK_AUTOMATION_FRAMEWORK_INIT,
+  START: EVENTS.SDK_AUTOMATION_FRAMEWORK_START,
+  STOP: EVENTS.SDK_AUTOMATION_FRAMEWORK_STOP
+};
+var CONFIG_EVENTS = {
+  ACCESSIBILITY: EVENTS.SDK_ACCESSIBILITY_CONFIG,
+  OBSERVABILITY: EVENTS.SDK_OBSERVABILITY_CONFIG
+};
+var AI_EVENTS = {
+  SELF_HEAL_STEP: EVENTS.SDK_AI_SELF_HEAL_STEP,
+  SELF_HEAL_GET_RESULT: EVENTS.SDK_AI_SELF_HEAL_GET_RESULT
+};
+var DISPATCHER_EVENTS = {
+  TEST_FRAMEWORK: EVENTS.SDK_TEST_FRAMEWORK_EVENT,
+  TEST_SESSION: EVENTS.SDK_TEST_SESSION_EVENT,
+  LOG_CREATED: EVENTS.SDK_CLI_LOG_CREATED_EVENT,
+  ENQUEUE_TEST: EVENTS.SDK_CLI_ENQUEUE_TEST_EVENT
+};
+
+// src/cli/cliLogger.ts
+import path2 from "node:path";
+import fs2 from "node:fs";
+import chalk2 from "chalk";
+import logger2 from "@wdio/logger";
+var log2 = logger2("@wdio/browserstack-service/cli");
+var BStackLogger2 = class {
+  static logFilePath = path2.join(process.cwd(), LOGS_FILE);
+  static logFolderPath = path2.join(process.cwd(), "logs");
+  static logFileStream;
+  static logToFile(logMessage, logLevel) {
+    try {
+      if (!this.logFileStream) {
+        this.ensureLogsFolder();
+        this.logFileStream = fs2.createWriteStream(this.logFilePath, { flags: "a" });
+      }
+      if (this.logFileStream && this.logFileStream.writable) {
+        this.logFileStream.write(this.formatLog(logMessage, logLevel));
+      }
+    } catch (error) {
+      log2.debug(`Failed to log to file. Error ${error}`);
+    }
+  }
+  static formatLog(logMessage, level) {
+    return `${chalk2.gray((/* @__PURE__ */ new Date()).toISOString())} ${chalk2[COLORS[level]](level.toUpperCase())} ${chalk2.whiteBright("@wdio/browserstack-service")} ${logMessage}
+`;
+  }
+  static info(message) {
+    this.logToFile(message, "info");
+    log2.info(message);
+  }
+  static error(message) {
+    this.logToFile(message, "error");
+    log2.error(message);
+  }
+  static debug(message, param) {
+    this.logToFile(message, "debug");
+    if (param) {
+      log2.debug(message, param);
+    } else {
+      log2.debug(message);
+    }
+  }
+  static warn(message) {
+    this.logToFile(message, "warn");
+    log2.warn(message);
+  }
+  static trace(message) {
+    this.logToFile(message, "trace");
+    log2.trace(message);
+  }
+  static clearLogger() {
+    if (this.logFileStream) {
+      this.logFileStream.end();
+    }
+    this.logFileStream = null;
+  }
+  static clearLogFile() {
+    if (fs2.existsSync(this.logFilePath)) {
+      fs2.truncateSync(this.logFilePath);
+    }
+  }
+  static ensureLogsFolder() {
+    if (!fs2.existsSync(this.logFolderPath)) {
+      fs2.mkdirSync(this.logFolderPath);
+    }
+  }
+};
+
+// src/cli/frameworks/constants/testFrameworkConstants.ts
+var 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_)"
+};
+
+// src/cli/cliUtils.ts
+var CLI_LOCK_TIMEOUT_MS = 5 * 60 * 1e3;
+var CLI_LOCK_POLL_MS = 1e3;
+var CLI_DOWNLOAD_TIMEOUT_MS = 5 * 60 * 1e3;
+var CLI_DOWNLOAD_TMP_PREFIX = "downloaded_file_";
+var CLI_DOWNLOAD_TMP_SUFFIX = ".zip";
+var CLIUtils = class _CLIUtils {
+  static automationFrameworkDetail = {};
+  static testFrameworkDetail = {};
+  static CLISupportedFrameworks = ["mocha"];
+  static isDevelopmentEnv() {
+    return process.env.BROWSERSTACK_CLI_ENV === "development";
+  }
+  static getCLIParamsForDevEnv() {
+    return {
+      id: process.env.BROWSERSTACK_CLI_ENV || "",
+      listen: `unix:/tmp/sdk-platform-${process.env.BROWSERSTACK_CLI_ENV}.sock`
+    };
+  }
+  /**
+   * Build config object for binary session request
+   * @returns {string}
+   * @throws {Error}
+   */
+  static getBinConfig(config, capabilities, options, buildTag) {
+    const modifiedOpts = { ...options };
+    if (modifiedOpts.opts) {
+      modifiedOpts.browserStackLocalOptions = modifiedOpts.opts;
+      delete modifiedOpts.opts;
+    }
+    modifiedOpts.testContextOptions = {
+      skipSessionName: isFalse(modifiedOpts.setSessionName),
+      skipSessionStatus: isFalse(modifiedOpts.setSessionStatus),
+      sessionNameOmitTestTitle: modifiedOpts.sessionNameOmitTestTitle || false,
+      sessionNamePrependTopLevelSuiteTitle: modifiedOpts.sessionNamePrependTopLevelSuiteTitle || false,
+      sessionNameFormat: modifiedOpts.sessionNameFormat || ""
+    };
+    const commonBstackOptions = (() => {
+      if (capabilities && !Array.isArray(capabilities) && typeof capabilities === "object" && "bstack:options" in capabilities) {
+        return capabilities["bstack:options"] || {};
+      }
+      return {};
+    })();
+    const isNonBstackA11y = isTurboScale(options) || !shouldAddServiceVersion(
+      config,
+      options.testObservability
+    );
+    const observabilityOptions = options.testObservabilityOptions || {};
+    const binconfig = {
+      userName: observabilityOptions.user || config.user,
+      accessKey: observabilityOptions.key || config.key,
+      platforms: [],
+      isNonBstackA11yWDIO: isNonBstackA11y,
+      ...modifiedOpts,
+      ...commonBstackOptions
+    };
+    binconfig.buildName = observabilityOptions.buildName || binconfig.buildName;
+    binconfig.projectName = observabilityOptions.projectName || binconfig.projectName;
+    binconfig.buildTag = this.getObservabilityBuildTags(observabilityOptions, buildTag) || [];
+    let caps = capabilities;
+    if (capabilities && !Array.isArray(capabilities)) {
+      caps = [capabilities];
+    }
+    if (Array.isArray(caps)) {
+      for (const cap of caps) {
+        const platform4 = {};
+        const capability = cap;
+        Object.keys(capability).filter((key) => key !== "bstack:options").forEach((key) => {
+          platform4[key] = capability[key];
+        });
+        if (capability["bstack:options"]) {
+          Object.keys(
+            capability["bstack:options"]
+          ).forEach((key) => {
+            platform4[key] = capability["bstack:options"][key];
+          });
+        }
+        binconfig.platforms.push(platform4);
+      }
+    }
+    return JSON.stringify(binconfig);
+  }
+  static getSdkVersion() {
+    return BSTACK_SERVICE_VERSION;
+  }
+  static getSdkLanguage() {
+    return "ECMAScript";
+  }
+  static async setupCliPath(config) {
+    BStackLogger2.debug("Configuring Cli path.");
+    const developmentBinaryPath = process.env.SDK_CLI_BIN_PATH || null;
+    if (!isNullOrEmpty(developmentBinaryPath)) {
+      BStackLogger2.debug(`Development Cli Path: ${developmentBinaryPath}`);
+      return developmentBinaryPath;
+    }
+    try {
+      const cliDir = this.getCliDir();
+      if (isNullOrEmpty(cliDir)) {
+        throw new Error("No writable directory available for the CLI");
+      }
+      const existingCliPath = this.getExistingCliPath(cliDir);
+      const finalBinaryPath = await this.checkAndUpdateCli(
+        existingCliPath,
+        cliDir,
+        config
+      );
+      BStackLogger2.debug(`Resolved binary path: ${finalBinaryPath}`);
+      return finalBinaryPath;
+    } catch (err) {
+      BStackLogger2.debug(
+        `Error in setting up cli path directory, Exception: ${util.format(err)}`
+      );
+    }
+    return null;
+  }
+  static async checkAndUpdateCli(existingCliPath, cliDir, config) {
+    if (process.env.BROWSERSTACK_TESTHUB_JWT) {
+      BStackLogger2.debug(
+        `Worker process detected, skipping CLI update. Using existing: ${existingCliPath}`
+      );
+      if (existingCliPath && fs3.existsSync(existingCliPath)) {
+        return existingCliPath;
+      }
+      BStackLogger2.warn(
+        "Worker process has no existing CLI binary, attempting download as fallback."
+      );
+    }
+    PerformanceTester.start(EVENTS.SDK_CLI_CHECK_UPDATE);
+    BStackLogger2.info(`Current CLI Path Found: ${existingCliPath}`);
+    const queryParams = {
+      sdk_version: _CLIUtils.getSdkVersion(),
+      os: platform(),
+      os_arch: arch(),
+      cli_version: "0",
+      sdk_language: this.getSdkLanguage()
+    };
+    if (!isNullOrEmpty(existingCliPath)) {
+      queryParams.cli_version = await this.runShellCommand(
+        `${existingCliPath} version`
+      );
+    }
+    const response = await this.requestToUpdateCLI(queryParams, config);
+    if (nestedKeyValue(response, ["updated_cli_version"])) {
+      BStackLogger2.debug(
+        `Need to update binary, current binary version: ${queryParams.cli_version}`
+      );
+      const browserStackBinaryUrl = process.env.BROWSERSTACK_BINARY_URL || null;
+      if (!isNullOrEmpty(browserStackBinaryUrl)) {
+        BStackLogger2.debug(
+          `Using BROWSERSTACK_BINARY_URL: ${browserStackBinaryUrl}`
+        );
+        response.url = browserStackBinaryUrl;
+      }
+      const finalBinaryPath = await this.downloadLatestBinary(
+        nestedKeyValue(response, ["url"]),
+        cliDir
+      );
+      PerformanceTester.end(EVENTS.SDK_CLI_CHECK_UPDATE);
+      return finalBinaryPath;
+    }
+    PerformanceTester.end(EVENTS.SDK_CLI_CHECK_UPDATE);
+    return existingCliPath;
+  }
+  static getCliDir() {
+    const writableDir = this.getWritableDir();
+    try {
+      if (isNullOrEmpty(writableDir)) {
+        throw new Error("No writable directory available for the CLI");
+      }
+      const cliDirPath = path3.join(writableDir, "cli");
+      if (!fs3.existsSync(cliDirPath)) {
+        createDir(cliDirPath);
+      }
+      return cliDirPath;
+    } catch (err) {
+      BStackLogger2.error(
+        `Error in getting writable directory, writableDir=${util.format(err)}`
+      );
+      return "";
+    }
+  }
+  static getWritableDir() {
+    const writableDirOptions = [
+      process.env.BROWSERSTACK_FILES_DIR,
+      path3.join(homedir(), ".browserstack"),
+      path3.join("tmp", ".browserstack")
+    ];
+    for (const path9 of writableDirOptions) {
+      if (isNullOrEmpty(path9)) {
+        continue;
+      }
+      try {
+        if (fs3.existsSync(path9)) {
+          BStackLogger2.debug(`File ${path9} already exist`);
+          if (!isWritable(path9)) {
+            BStackLogger2.debug(`Giving write permission to ${path9}`);
+            const success = setReadWriteAccess(path9);
+            if (!isTrue(success)) {
+              BStackLogger2.warn(
+                `Unable to provide write permission to ${path9}`
+              );
+            }
+          }
+        } else {
+          BStackLogger2.debug(`File does not exist: ${path9}`);
+          createDir(path9);
+          BStackLogger2.debug(`Giving write permission to ${path9}`);
+          const success = setReadWriteAccess(path9);
+          if (!isTrue(success)) {
+            BStackLogger2.warn(
+              `Unable to provide write permission to ${path9}`
+            );
+          }
+        }
+        return path9;
+      } catch (err) {
+        BStackLogger2.error(
+          `Unable to get writable directory, exception ${util.format(err)}`
+        );
+      }
+    }
+    return null;
+  }
+  static getExistingCliPath(cliDir) {
+    try {
+      if (!fs3.existsSync(cliDir) || !fs3.statSync(cliDir).isDirectory()) {
+        return "";
+      }
+      const allBinaries = fs3.readdirSync(cliDir).map((file) => path3.join(cliDir, file)).filter(
+        (filePath) => fs3.statSync(filePath).isFile() && path3.basename(filePath).startsWith("binary-")
+      );
+      if (allBinaries.length > 0) {
+        const latestBinary = allBinaries.map((filePath) => ({
+          filePath,
+          mtime: fs3.statSync(filePath).mtime
+        })).reduce(
+          (latest, current) => {
+            if (!latest || !latest.mtime) {
+              return current;
+            }
+            if (current.mtime > latest.mtime) {
+              return current;
+            }
+            return latest;
+          },
+          null
+        );
+        return latestBinary ? latestBinary.filePath : "";
+      }
+      return "";
+    } catch (err) {
+      BStackLogger2.error(`Error while reading CLI path: ${util.format(err)}`);
+      return "";
+    }
+  }
+  static requestToUpdateCLI = async (queryParams, config) => {
+    const params = new URLSearchParams(queryParams);
+    const requestInit = {
+      method: "GET",
+      headers: {
+        Authorization: `Basic ${Buffer.from(`${getBrowserStackUser(config)}:${getBrowserStackKey(config)}`).toString("base64")}`
+      }
+    };
+    const response = await _fetch(
+      `${APIUtils.BROWSERSTACK_AUTOMATE_API_URL}/${UPDATED_CLI_ENDPOINT}?${params.toString()}`,
+      requestInit
+    );
+    const jsonResponse = await response.json();
+    BStackLogger2.debug(`response ${JSON.stringify(jsonResponse)}`);
+    return jsonResponse;
+  };
+  static runShellCommand(cmdCommand, workingDir = "") {
+    return new Promise((resolve) => {
+      const process2 = exec(
+        cmdCommand,
+        { cwd: workingDir, timeout: 5e3 },
+        (error, stdout, stderr) => {
+          if (error) {
+            resolve(stderr.trim() || "SHELL_EXECUTE_ERROR");
+          } else {
+            resolve(stdout.trim());
+          }
+        }
+      );
+      process2.on("error", () => {
+        resolve("SHELL_EXECUTE_ERROR");
+      });
+    });
+  }
+  static downloadLatestBinary = async (binDownloadUrl, cliDir) => {
+    const lockPath = path3.join(cliDir, "download.lock");
+    const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+    const parseLockFile = () => {
+      try {
+        const content = fs3.readFileSync(lockPath, "utf8").trim();
+        const [pidLine, timestampLine] = content.split("\n");
+        const pid = Number.parseInt(pidLine, 10);
+        const timestamp = Number.parseInt(timestampLine, 10);
+        if (!Number.isFinite(pid) || !Number.isFinite(timestamp)) {
+          return null;
+        }
+        return { pid, timestamp };
+      } catch {
+        return null;
+      }
+    };
+    const isProcessRunning = (pid) => {
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    const acquireLock = async (timeoutMs = CLI_LOCK_TIMEOUT_MS, pollMs = CLI_LOCK_POLL_MS) => {
+      const start = Date.now();
+      while (true) {
+        try {
+          const fd = fs3.openSync(lockPath, "wx");
+          try {
+            fs3.writeFileSync(fd, `${process.pid}
+${Date.now()}
+`);
+          } catch {
+          }
+          return () => {
+            try {
+              fs3.closeSync(fd);
+            } catch {
+            }
+            try {
+              fs3.unlinkSync(lockPath);
+            } catch {
+            }
+          };
+        } catch (e) {
+          const error = e;
+          if (error.code === "EEXIST") {
+            const lockMeta = parseLockFile();
+            if (lockMeta) {
+              const lockAge = Date.now() - lockMeta.timestamp;
+              const running = isProcessRunning(lockMeta.pid);
+              if (!running || lockAge > timeoutMs) {
+                BStackLogger2.warn(
+                  `Stale CLI download lock detected (pid=${lockMeta.pid}, age=${lockAge}ms). Removing lock.`
+                );
+                try {
+                  fs3.unlinkSync(lockPath);
+                } catch {
+                }
+                continue;
+              }
+            }
+            const existingBinary = _CLIUtils.getExistingCliPath(cliDir);
+            if (existingBinary && fs3.existsSync(existingBinary) && fs3.statSync(existingBinary).size > 0) {
+              BStackLogger2.debug(
+                `Binary appeared while waiting for lock: ${existingBinary}`
+              );
+              return { alreadyExists: existingBinary };
+            }
+            if (Date.now() - start > timeoutMs) {
+              throw new Error(
+                `Timeout waiting for lock: ${lockPath}`
+              );
+            }
+            await sleep(pollMs);
+            continue;
+          }
+          throw e;
+        }
+      }
+    };
+    const cleanupTemporaryDownloads = (maxAgeMs = CLI_LOCK_TIMEOUT_MS) => {
+      try {
+        const now = Date.now();
+        for (const entry of fs3.readdirSync(cliDir)) {
+          if (!entry.startsWith(CLI_DOWNLOAD_TMP_PREFIX) || !entry.endsWith(CLI_DOWNLOAD_TMP_SUFFIX)) {
+            continue;
+          }
+          const filePath = path3.join(cliDir, entry);
+          let stats;
+          try {
+            stats = fs3.statSync(filePath);
+          } catch {
+            continue;
+          }
+          if (now - stats.mtimeMs < maxAgeMs) {
+            continue;
+          }
+          try {
+            fs3.unlinkSync(filePath);
+          } catch (err) {
+            BStackLogger2.debug(
+              `Failed to delete temp CLI zip file ${filePath}: ${util.format(err)}`
+            );
+          }
+        }
+      } catch (err) {
+        BStackLogger2.debug(
+          `Failed to scan temp CLI downloads in ${cliDir}: ${util.format(err)}`
+        );
+      }
+    };
+    PerformanceTester.start(EVENTS.SDK_CLI_DOWNLOAD);
+    BStackLogger2.debug(`Downloading SDK binary from: ${binDownloadUrl}`);
+    let downloadEnded = false;
+    const endDownload = (success = true, errMsg) => {
+      if (downloadEnded) {
+        return;
+      }
+      downloadEnded = true;
+      if (success) {
+        PerformanceTester.end(EVENTS.SDK_CLI_DOWNLOAD);
+        return;
+      }
+      PerformanceTester.end(
+        EVENTS.SDK_CLI_DOWNLOAD,
+        false,
+        errMsg
+      );
+    };
+    let releaseLock;
+    try {
+      const lockResult = await acquireLock();
+      if (typeof lockResult !== "function") {
+        endDownload();
+        return lockResult.alreadyExists;
+      }
+      releaseLock = lockResult;
+      const existingBinary = _CLIUtils.getExistingCliPath(cliDir);
+      if (existingBinary && fs3.existsSync(existingBinary) && fs3.statSync(existingBinary).size > 0) {
+        BStackLogger2.debug(
+          `Binary already exists after acquiring lock: ${existingBinary}`
+        );
+        endDownload();
+        releaseLock();
+        return existingBinary;
+      }
+      cleanupTemporaryDownloads();
+      const zipFilePath = path3.join(
+        cliDir,
+        `${CLI_DOWNLOAD_TMP_PREFIX}${process.pid}_${Date.now()}${CLI_DOWNLOAD_TMP_SUFFIX}`
+      );
+      const downloadedFileStream = fs3.createWriteStream(zipFilePath);
+      return new Promise((resolve, reject) => {
+        const binaryName = null;
+        const processDownload = async () => {
+          const abortController = new AbortController();
+          const timeout = setTimeout(
+            () => abortController.abort(),
+            CLI_DOWNLOAD_TIMEOUT_MS
+          );
+          let response;
+          try {
+            response = await _fetch(binDownloadUrl, {
+              signal: abortController.signal
+            });
+          } finally {
+            clearTimeout(timeout);
+          }
+          if (!response.body) {
+            throw new Error("No response body received");
+          }
+          downloadedFileStream.on("error", function(err) {
+            BStackLogger2.error(
+              `Got Error while downloading cli binary file: ${err}`
+            );
+            endDownload(false, util.format(err));
+            releaseLock?.();
+            reject(err);
+          });
+          try {
+            const arrayBuffer = await response.arrayBuffer();
+            const nodeStream = Readable.from([
+              new Uint8Array(arrayBuffer)
+            ]);
+            nodeStream.pipe(downloadedFileStream);
+            _CLIUtils.downloadFileStream(
+              downloadedFileStream,
+              binaryName,
+              zipFilePath,
+              cliDir,
+              (result) => {
+                endDownload();
+                releaseLock?.();
+                resolve(result);
+              },
+              (err) => {
+                endDownload(false, util.format(err));
+                releaseLock?.();
+                reject(err);
+              }
+            );
+          } catch (err) {
+            BStackLogger2.error(
+              `Got Error in cli binary downloading request ${util.format(err)}`
+            );
+            endDownload(false, util.format(err));
+            releaseLock?.();
+            reject(err);
+          }
+        };
+        processDownload();
+      });
+    } catch (err) {
+      releaseLock?.();
+      endDownload(false, util.format(err));
+      BStackLogger2.debug(
+        `Failed to download binary, Exception: ${util.format(err)}`
+      );
+      return null;
+    }
+  };
+  static downloadFileStream(downloadedFileStream, binaryName, zipFilePath, cliDir, resolve, reject) {
+    downloadedFileStream.on("close", async function() {
+      const yauzlOpenPromise = promisify(yauzl.open);
+      try {
+        const zipfile = await yauzlOpenPromise(zipFilePath, {
+          lazyEntries: true
+        });
+        zipfile.readEntry();
+        zipfile.on("entry", async (entry) => {
+          if (!binaryName) {
+            binaryName = entry.fileName;
+          }
+          if (/\/$/.test(entry.fileName)) {
+            zipfile.readEntry();
+          } else {
+            const writeStream = fs3.createWriteStream(
+              path3.join(cliDir, entry.fileName)
+            );
+            const openReadStreamPromise = promisify(
+              zipfile.openReadStream
+            ).bind(zipfile);
+            try {
+              const readStream = await openReadStreamPromise(entry);
+              readStream.on("end", function() {
+                writeStream.close();
+                zipfile.readEntry();
+              });
+              readStream.pipe(writeStream);
+            } catch (zipErr) {
+              reject(zipErr);
+            }
+            if (entry.fileName === binaryName) {
+              zipfile.close();
+            }
+          }
+        });
+        zipfile.on("error", (zipErr) => {
+          reject(zipErr);
+        });
+        zipfile.once("end", () => {
+          fsp.unlink(zipFilePath).catch(() => {
+            BStackLogger2.warn(
+              `Failed to delete zip file: ${zipFilePath}`
+            );
+          });
+          fsp.chmod(`${cliDir}/${binaryName}`, "0755").then(() => {
+            resolve(`${cliDir}/${binaryName}`);
+          }).catch((err) => {
+            reject(err);
+          });
+          zipfile.close();
+        });
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+  static getTestFrameworkDetail() {
+    if (process.env.BROWSERSTACK_TEST_FRAMEWORK_DETAIL) {
+      return JSON.parse(process.env.BROWSERSTACK_TEST_FRAMEWORK_DETAIL);
+    }
+    return this.testFrameworkDetail;
+  }
+  static getAutomationFrameworkDetail() {
+    if (process.env.BROWSERSTACK_AUTOMATION_FRAMEWORK_DETAIL) {
+      return JSON.parse(
+        process.env.BROWSERSTACK_AUTOMATION_FRAMEWORK_DETAIL
+      );
+    }
+    return this.automationFrameworkDetail;
+  }
+  static setFrameworkDetail(testFramework, automationFramework) {
+    if (!testFramework || !automationFramework) {
+      BStackLogger2.debug(
+        `Test or Automation framework not provided testFramework=${testFramework}, automationFramework=${automationFramework}`
+      );
+    }
+    this.testFrameworkDetail = {
+      name: testFramework,
+      version: { [testFramework]: _CLIUtils.getSdkVersion() }
+    };
+    this.automationFrameworkDetail = {
+      name: automationFramework,
+      version: { [automationFramework]: _CLIUtils.getSdkVersion() }
+    };
+    process.env.BROWSERSTACK_AUTOMATION_FRAMEWORK_DETAIL = JSON.stringify(
+      this.automationFrameworkDetail
+    );
+    process.env.BROWSERSTACK_TEST_FRAMEWORK_DETAIL = JSON.stringify(
+      this.testFrameworkDetail
+    );
+  }
+  /**
+   * Get the current instance name using thread id and processId
+   * @returns {string}
+   */
+  static getCurrentInstanceName() {
+    return `${process.pid}:${threadId}`;
+  }
+  /**
+   * Generate a unique client worker identifier combining thread ID and process ID.
+   * This identifier is used to track worker-specific events and performance metrics
+   * across distributed test execution. Format matches the Python SDK implementation
+   * for consistency across SDKs.
+   *
+   * Format: "threadId-processId"
+   *
+   * @param context - Optional execution context with threadId and processId
+   * @returns Worker ID string in format "threadId-processId"
+   * @example
+   * const workerId = CLIUtils.getClientWorkerId() // Returns "1-12345"
+   * const workerId = CLIUtils.getClientWorkerId({ threadId: 123, processId: 456 }) // Returns "123-456"
+   */
+  static getClientWorkerId(context) {
+    const workerThreadId = context?.threadId?.toString() || threadId.toString();
+    const workerProcessId = context?.processId?.toString() || process.pid.toString();
+    return `${workerThreadId}-${workerProcessId}`;
+  }
+  /**
+   *
+   * @param {TestFrameworkState | AutomationFrameworkState} frameworkState
+   * @param {HookState} hookState
+   * @returns {string}
+   */
+  static getHookRegistryKey(frameworkState, hookState) {
+    return `${frameworkState}:${hookState}`;
+  }
+  static matchHookRegex(hookState) {
+    const pattern = new RegExp(TestFrameworkConstants.HOOK_REGEX);
+    return pattern.test(hookState);
+  }
+  static getObservabilityBuildTags(observabilityOptions, bstackBuildTag) {
+    if (process.env.TEST_OBSERVABILITY_BUILD_TAG) {
+      return process.env.TEST_OBSERVABILITY_BUILD_TAG.split(",");
+    }
+    if (observabilityOptions.buildTag) {
+      return observabilityOptions.buildTag;
+    }
+    if (bstackBuildTag) {
+      return [bstackBuildTag];
+    }
+    return [];
+  }
+  static checkCLISupportedFrameworks(framework) {
+    if (framework === void 0) {
+      return false;
+    }
+    return this.CLISupportedFrameworks.includes(framework);
+  }
+};
+
 // src/instrumentation/performance/performance-tester.ts
 var PerformanceTester = class _PerformanceTester {
   static _observer;
   static _csvWriter;
   static _events = [];
   static _measuredEvents = [];
+  static _hasStoppedGeneration = false;
+  static _stopGenerateCallCount = 0;
   static started = false;
   static details = {};
   static eventsMap = {};
   static browser;
   static scenarioThatRan;
   static jsonReportDirName = "performance-report";
-  static jsonReportDirPath = path2.join(process.cwd(), "logs", this.jsonReportDirName);
+  static jsonReportDirPath = path4.join(process.cwd(), "logs", this.jsonReportDirName);
   static jsonReportFileName = `${this.jsonReportDirPath}/performance-report-${_PerformanceTester.getProcessId()}.json`;
   static startMonitoring(csvName = "performance-report.csv") {
-    if (!fs2.existsSync(this.jsonReportDirPath)) {
-      fs2.mkdirSync(this.jsonReportDirPath, { recursive: true });
+    if (!fs4.existsSync(this.jsonReportDirPath)) {
+      fs4.mkdirSync(this.jsonReportDirPath, { recursive: true });
     }
     this._observer = new PerformanceObserver((list) => {
       list.getEntries().filter((entry) => entry.entryType === "measure").forEach(
         (entry) => {
-          let finalEntry = entry;
-          finalEntry = entry.toJSON();
+          let finalEntry = entry.toJSON();
+          try {
+            if (typeof finalEntry.startTime === "number" && typeof performance.timeOrigin === "number") {
+              const originalStartTime = finalEntry.startTime;
+              finalEntry.startTime = performance.timeOrigin + finalEntry.startTime;
+              BStackLogger.debug(`Timestamp conversion for ${entry.name}: ${originalStartTime} -> ${finalEntry.startTime} (timeOrigin: ${performance.timeOrigin})`);
+            }
+          } catch (e) {
+            BStackLogger.debug(`Error converting startTime to epoch: ${util2.format(e)}`);
+          }
           if (this.details[entry.name]) {
             finalEntry = Object.assign(finalEntry, this.details[entry.name]);
           }
@@ -356,28 +1301,26 @@ var PerformanceTester = class _PerformanceTester {
     if (!this.started) {
       return;
     }
-    await _PerformanceTester.sleep(PERF_METRICS_WAIT_TIME);
     try {
       const eventsJson = JSON.stringify(this._measuredEvents);
       const finalJSONStr = eventsJson.slice(1, -1) + ",";
       await fsPromise.appendFile(this.jsonReportFileName, finalJSONStr);
     } catch (er) {
-      BStackLogger.debug(`Failed to write events of the worker to ${this.jsonReportFileName}: ${util.format(er)}`);
+      BStackLogger.debug(`Failed to write events of the worker to ${this.jsonReportFileName}: ${util2.format(er)}`);
     }
     this._observer.disconnect();
     if (!process.env[PERF_MEASUREMENT_ENV]) {
       return;
     }
-    await _PerformanceTester.sleep(PERF_METRICS_WAIT_TIME);
     this.started = false;
     this.generateCSV(this._events);
     const content = this.generateReport(this._events);
-    const dir = path2.join(process.cwd(), filename);
+    const dir = path4.join(process.cwd(), filename);
     try {
       await fsPromise.writeFile(dir, content);
-      BStackLogger.info(`Performance report is at ${path2}`);
+      BStackLogger.info(`Performance report is at ${path4}`);
     } catch (err) {
-      BStackLogger.error(`Error in writing html ${util.format(err)}`);
+      BStackLogger.error(`Error in writing html ${util2.format(err)}`);
     }
   }
   static generateReport(entries) {
@@ -437,27 +1380,71 @@ var PerformanceTester = class _PerformanceTester {
     if (!this.started || !this.isEnabled()) {
       return fn.apply(thisArg, args);
     }
-    _PerformanceTester.start(label);
-    if (this.details) {
-      this.details[label] = details;
-    }
+    const uniqueId = `${Date.now()}-${Math.random().toString(36).substring(7)}`;
+    const startMark = `${label}-start-${uniqueId}`;
+    const endMark = `${label}-end-${uniqueId}`;
+    performance.mark(startMark);
+    const detailsWithContext = {
+      ...details,
+      measurementId: uniqueId
+    };
     try {
       const returnVal = fn.apply(thisArg, args);
       if (returnVal instanceof Promise) {
         return new Promise((resolve, reject) => {
           returnVal.then((v) => {
-            _PerformanceTester.end(label);
+            performance.mark(endMark);
+            performance.measure(label, startMark, endMark);
+            this.details[label] = Object.assign({
+              success: true,
+              failure: void 0
+            }, Object.assign(Object.assign({
+              clientWorkerId: _PerformanceTester.getClientWorkerId(),
+              worker: _PerformanceTester.getProcessId(),
+              platform: _PerformanceTester.browser?.sessionId,
+              testName: _PerformanceTester.scenarioThatRan?.pop()
+            }, detailsWithContext), this.details[label] || {}));
             resolve(v);
           }).catch((e) => {
-            _PerformanceTester.end(label, false, util.format(e));
+            performance.mark(endMark);
+            performance.measure(label, startMark, endMark);
+            this.details[label] = Object.assign({
+              success: false,
+              failure: util2.format(e)
+            }, Object.assign(Object.assign({
+              clientWorkerId: _PerformanceTester.getClientWorkerId(),
+              worker: _PerformanceTester.getProcessId(),
+              platform: _PerformanceTester.browser?.sessionId,
+              testName: _PerformanceTester.scenarioThatRan?.pop()
+            }, detailsWithContext), this.details[label] || {}));
             reject(e);
           });
         });
       }
-      _PerformanceTester.end(label);
+      performance.mark(endMark);
+      performance.measure(label, startMark, endMark);
+      this.details[label] = Object.assign({
+        success: true,
+        failure: void 0
+      }, Object.assign(Object.assign({
+        clientWorkerId: _PerformanceTester.getClientWorkerId(),
+        worker: _PerformanceTester.getProcessId(),
+        platform: _PerformanceTester.browser?.sessionId,
+        testName: _PerformanceTester.scenarioThatRan?.pop()
+      }, detailsWithContext), this.details[label] || {}));
       return returnVal;
     } catch (er) {
-      _PerformanceTester.end(label, false, util.format(er));
+      performance.mark(endMark);
+      performance.measure(label, startMark, endMark);
+      this.details[label] = Object.assign({
+        success: false,
+        failure: util2.format(er)
+      }, Object.assign(Object.assign({
+        clientWorkerId: _PerformanceTester.getClientWorkerId(),
+        worker: _PerformanceTester.getProcessId(),
+        platform: _PerformanceTester.browser?.sessionId,
+        testName: _PerformanceTester.scenarioThatRan?.pop()
+      }, detailsWithContext), this.details[label] || {}));
       throw er;
     }
   }
@@ -472,26 +1459,62 @@ var PerformanceTester = class _PerformanceTester {
   static end(event, success = true, failure, details = {}) {
     performance.mark(event + "-end");
     performance.measure(event, event + "-start", event + "-end");
-    this.details[event] = Object.assign({ success, failure: util.format(failure) }, Object.assign(Object.assign({
+    this.details[event] = Object.assign({ success, failure: util2.format(failure) }, Object.assign(Object.assign({
+      clientWorkerId: _PerformanceTester.getClientWorkerId(),
       worker: _PerformanceTester.getProcessId(),
       platform: _PerformanceTester.browser?.sessionId,
       testName: _PerformanceTester.scenarioThatRan && _PerformanceTester.scenarioThatRan[_PerformanceTester.scenarioThatRan.length - 1]
     }, details), this.details[event] || {}));
   }
+  /**
+   * Get client worker ID in format "threadId-processId".
+   * This method provides a consistent identifier across the SDK for tracking
+   * worker-specific events and performance metrics.
+   *
+   * @returns Worker ID string in format "threadId-processId"
+   */
+  static getClientWorkerId() {
+    return CLIUtils.getClientWorkerId();
+  }
   static getProcessId() {
     return `${process.pid}-${worker.threadId}`;
   }
   static sleep = (ms = 100) => new Promise((resolve) => setTimeout(resolve, ms));
   static async uploadEventsData() {
+    this.start(EVENTS.SDK_SEND_KEY_METRICS);
     try {
+      const workerId = `${process.pid}`;
+      BStackLogger.debug(`[Performance Upload] Starting upload for worker ${workerId}`);
+      this.start(EVENTS.SDK_KEY_METRICS_PREPARATION);
       let measures = [];
       if (await fsPromise.access(this.jsonReportDirPath).then(() => true).catch(() => false)) {
-        const files = (await fsPromise.readdir(this.jsonReportDirPath)).map((file) => path2.resolve(this.jsonReportDirPath, file));
+        const files = (await fsPromise.readdir(this.jsonReportDirPath)).map((file) => path4.resolve(this.jsonReportDirPath, file));
         measures = (await Promise.all(files.map((file) => fsPromise.readFile(file, "utf-8")))).map((el) => `[${el.slice(0, -1)}]`).map((el) => JSON.parse(el)).flat();
       }
+      BStackLogger.debug(`[Performance Upload] Total events from files: ${measures.length}`);
       if (this._measuredEvents.length > 0) {
-        measures = measures.concat(this._measuredEvents);
+        BStackLogger.debug(`[Performance Upload] Adding ${this._measuredEvents.length} in-memory events`);
+        measures = measures.concat(
+          this._measuredEvents.map((e) => {
+            if (typeof e.toJSON === "function") {
+              return e.toJSON();
+            }
+            return e;
+          })
+        );
       }
+      const ensureEpochTimes = (arr) => {
+        const now = Date.now();
+        const cutoff = 1e12;
+        const timeOrigin = typeof performance !== "undefined" && typeof performance.timeOrigin === "number" ? performance.timeOrigin : now - process.uptime() * 1e3;
+        return arr.map((entry) => {
+          if (typeof entry.startTime === "number" && entry.startTime < cutoff) {
+            entry.startTime = timeOrigin + entry.startTime;
+          }
+          return entry;
+        });
+      };
+      measures = ensureEpochTimes(measures);
       const date = /* @__PURE__ */ new Date();
       const options = {
         timeZone: "UTC",
@@ -506,6 +1529,7 @@ var PerformanceTester = class _PerformanceTester {
         hour12: false
       };
       const formattedDate = new Intl.DateTimeFormat("en-GB", options).formatToParts(date).map(({ type: type3, value }) => type3 === "timeZoneName" ? "Z" : value).join("").replace(",", "T");
+      this.end(EVENTS.SDK_KEY_METRICS_PREPARATION, true);
       const payload = {
         event_type: "sdk_events",
         data: {
@@ -515,10 +1539,10 @@ var PerformanceTester = class _PerformanceTester {
           user_data: process.env.PERF_USER_NAME,
           host_info: JSON.stringify({
             hostname: hostname(),
-            platform: platform(),
+            platform: platform2(),
             type: type(),
             version: version(),
-            arch: arch()
+            arch: arch2()
           }),
           event_json: { measures, sdkRunId: process.env.SDK_RUN_ID }
         }
@@ -530,111 +1554,27 @@ var PerformanceTester = class _PerformanceTester {
         },
         body: JSON.stringify(payload)
       });
-      BStackLogger.debug(`Successfully uploaded performance events ${util.format(await result.text())}`);
+      BStackLogger.debug(`[Performance Upload] Successfully uploaded to EDS: ${util2.format(await result.text())}`);
+      this.end(EVENTS.SDK_SEND_KEY_METRICS, true);
     } catch (er) {
-      BStackLogger.debug(`Failed to upload performance events ${util.format(er)}`);
+      BStackLogger.debug(`[Performance Upload] Failed to upload events: ${util2.format(er)}`);
+      this.end(EVENTS.SDK_KEY_METRICS_PREPARATION, false, er);
+      this.end(EVENTS.SDK_SEND_KEY_METRICS, false, er);
     }
     try {
       if (await fsPromise.access(this.jsonReportDirPath).then(() => true, () => false)) {
         const files = await fsPromise.readdir(this.jsonReportDirPath);
         for (const file of files) {
-          await fsPromise.unlink(path2.join(this.jsonReportDirPath, file));
+          await fsPromise.unlink(path4.join(this.jsonReportDirPath, file));
         }
+        BStackLogger.debug(`[Performance Upload] Cleaned up ${files.length} temporary report files`);
       }
     } catch (er) {
-      BStackLogger.debug(`Failed to delete performance related files ${util.format(er)}`);
+      BStackLogger.debug(`[Performance Upload] Failed to delete temporary files: ${util2.format(er)}`);
     }
   }
 };
 
-// src/instrumentation/performance/constants.ts
-var EVENTS = {
-  SDK_SETUP: "sdk:setup",
-  SDK_CLEANUP: "sdk:cleanup",
-  SDK_PRE_TEST: "sdk:pre-test",
-  SDK_TEST: "sdk:test",
-  SDK_POST_TEST: "sdk:post-test",
-  SDK_HOOK: "sdk:hook",
-  SDK_DRIVER: "sdk:driver",
-  SDK_A11Y: "sdk:a11y",
-  SDK_O11Y: "sdk:o11y",
-  SDK_AUTO_CAPTURE: "sdk:auto-capture",
-  SDK_PROXY_SETUP: "sdk:proxy-setup",
-  SDK_TESTHUB: "sdk:testhub",
-  SDK_AUTOMATE: "sdk:automate",
-  SDK_APP_AUTOMATE: "sdk:app-automate",
-  SDK_TURBOSCALE: "sdk:turboscale",
-  SDK_PERCY: "sdk:percy",
-  SDK_PRE_INITIALIZE: "sdk:driver:pre-initialization",
-  SDK_POST_INITIALIZE: "sdk:driver:post-initialization",
-  SDK_CLI_CHECK_UPDATE: "sdk:cli:check-update",
-  SDK_CLI_DOWNLOAD: "sdk:cli:download",
-  SDK_CLI_ON_BOOTSTRAP: "sdk:cli:on-bootstrap",
-  SDK_CLI_ON_CONNECT: "sdk:cli:on-connect",
-  SDK_CLI_START: "sdk:cli:start",
-  SDK_CLI_ON_STOP: "sdk:cli:on-stop",
-  SDK_CONNECT_BIN_SESSION: "sdk:connectBinSession",
-  SDK_START_BIN_SESSION: "sdk:startBinSession"
-};
-var TESTHUB_EVENTS = {
-  START: `${EVENTS.SDK_TESTHUB}:start`,
-  STOP: `${EVENTS.SDK_TESTHUB}:stop`
-};
-var AUTOMATE_EVENTS = {
-  KEEP_ALIVE: `${EVENTS.SDK_AUTOMATE}:keep-alive`,
-  HUB_MANAGEMENT: `${EVENTS.SDK_AUTOMATE}:hub-management`,
-  LOCAL_START: `${EVENTS.SDK_AUTOMATE}:local-start`,
-  LOCAL_STOP: `${EVENTS.SDK_AUTOMATE}:local-stop`,
-  DRIVER_MANAGE: `${EVENTS.SDK_AUTOMATE}:driver-manage`,
-  SESSION_NAME: `${EVENTS.SDK_AUTOMATE}:session-name`,
-  SESSION_STATUS: `${EVENTS.SDK_AUTOMATE}:session-status`,
-  SESSION_ANNOTATION: `${EVENTS.SDK_AUTOMATE}:session-annotation`,
-  IDLE_TIMEOUT: `${EVENTS.SDK_AUTOMATE}:idle-timeout`,
-  GENERATE_CI_ARTIFACT: `${EVENTS.SDK_AUTOMATE}:ci-artifacts`,
-  PRINT_BUILDLINK: `${EVENTS.SDK_AUTOMATE}:print-buildlink`
-};
-var A11Y_EVENTS = {
-  PERFORM_SCAN: `${EVENTS.SDK_A11Y}:driver-performscan`,
-  SAVE_RESULTS: `${EVENTS.SDK_A11Y}:save-results`,
-  GET_RESULTS: `${EVENTS.SDK_A11Y}:get-accessibility-results`,
-  GET_RESULTS_SUMMARY: `${EVENTS.SDK_A11Y}:get-accessibility-results-summary`
-};
-var PERCY_EVENTS = {
-  DOWNLOAD: `${EVENTS.SDK_PERCY}:download`,
-  SCREENSHOT: `${EVENTS.SDK_PERCY}:screenshot`,
-  START: `${EVENTS.SDK_PERCY}:start`,
-  STOP: `${EVENTS.SDK_PERCY}:stop`,
-  AUTO_CAPTURE: `${EVENTS.SDK_PERCY}:auto-capture`,
-  SNAPSHOT: `${EVENTS.SDK_PERCY}:snapshot`,
-  SCREENSHOT_APP: `${EVENTS.SDK_PERCY}:screenshot-app`
-};
-var O11Y_EVENTS = {
-  SYNC: `${EVENTS.SDK_O11Y}:sync`,
-  TAKE_SCREENSHOT: `${EVENTS.SDK_O11Y}:driver-takeScreenShot`,
-  PRINT_BUILDLINK: `${EVENTS.SDK_O11Y}:print-buildlink`
-};
-var HOOK_EVENTS = {
-  BEFORE_EACH: `${EVENTS.SDK_HOOK}:before-each`,
-  AFTER_EACH: `${EVENTS.SDK_HOOK}:after-each`,
-  AFTER_ALL: `${EVENTS.SDK_HOOK}:after-all`,
-  BEFORE_ALL: `${EVENTS.SDK_HOOK}:before-all`,
-  BEFORE: `${EVENTS.SDK_HOOK}:before`,
-  AFTER: `${EVENTS.SDK_HOOK}:after`
-};
-var TURBOSCALE_EVENTS = {
-  HUB_MANAGEMENT: `${EVENTS.SDK_TURBOSCALE}:hub-management`,
-  PRINT_BUILDLINK: `${EVENTS.SDK_TURBOSCALE}:print-buildlink`
-};
-var APP_AUTOMATE_EVENTS = {
-  APP_UPLOAD: `${EVENTS.SDK_APP_AUTOMATE}:app-upload`
-};
-var DRIVER_EVENT = {
-  QUIT: `${EVENTS.SDK_DRIVER}:quit`,
-  GET: `${EVENTS.SDK_DRIVER}:get`,
-  PRE_EXECUTE: `${EVENTS.SDK_DRIVER}:pre-execute`,
-  POST_EXECUTE: `${EVENTS.SDK_DRIVER}:post-execute`
-};
-
 // src/testHub/utils.ts
 var handleErrorForObservability = (error) => {
   process.env[BROWSERSTACK_OBSERVABILITY] = "false";
@@ -680,7 +1620,7 @@ var getProductMapForBuildStartCall = (config, accessibilityAutomation) => {
 };
 
 // src/testorchestration/testorcherstrationutils.ts
-import fs3 from "node:fs";
+import fs5 from "node:fs";
 var RUN_SMART_SELECTION = "runSmartSelection";
 var ALLOWED_ORCHESTRATION_KEYS = [
   RUN_SMART_SELECTION
@@ -910,13 +1850,13 @@ var OrchestrationUtils = class _OrchestrationUtils {
    * @returns Formatted list of repository configurations
    */
   _loadSourceFromFile(filePath) {
-    if (!fs3.existsSync(filePath)) {
+    if (!fs5.existsSync(filePath)) {
       BStackLogger.error(`Source file '${filePath}' does not exist.`);
       return [];
     }
     let data = null;
     try {
-      const fileContent = fs3.readFileSync(filePath, "utf8");
+      const fileContent = fs5.readFileSync(filePath, "utf8");
       data = JSON.parse(fileContent);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -1489,12 +2429,12 @@ var UsageStats = class _UsageStats {
 var usageStats_default = UsageStats;
 
 // src/util.ts
-import tar from "tar";
+import { create } from "tar";
 import { fileFromPath } from "formdata-node/file-from-path";
 
 // src/scripts/accessibility-scripts.ts
-import path3 from "node:path";
-import fs4 from "node:fs";
+import path5 from "node:path";
+import fs6 from "node:fs";
 import os from "node:os";
 var AccessibilityScripts = class _AccessibilityScripts {
   static instance = null;
@@ -1509,7 +2449,7 @@ var AccessibilityScripts = class _AccessibilityScripts {
   // don't allow to create instances from it other than through `checkAndGetInstance`
   constructor() {
     this.browserstackFolderPath = this.getWritableDir();
-    this.commandsPath = path3.join(this.browserstackFolderPath, "commands.json");
+    this.commandsPath = path5.join(this.browserstackFolderPath, "commands.json");
   }
   static checkAndGetInstance() {
     if (!_AccessibilityScripts.instance) {
@@ -1521,17 +2461,17 @@ var AccessibilityScripts = class _AccessibilityScripts {
   /* eslint-disable @typescript-eslint/no-unused-vars */
   getWritableDir() {
     const orderedPaths = [
-      path3.join(os.homedir(), ".browserstack"),
+      path5.join(os.homedir(), ".browserstack"),
       process.cwd(),
       os.tmpdir()
     ];
     for (const orderedPath of orderedPaths) {
       try {
-        if (fs4.existsSync(orderedPath)) {
-          fs4.accessSync(orderedPath);
+        if (fs6.existsSync(orderedPath)) {
+          fs6.accessSync(orderedPath);
           return orderedPath;
         }
-        fs4.mkdirSync(orderedPath, { recursive: true });
+        fs6.mkdirSync(orderedPath, { recursive: true });
         return orderedPath;
       } catch (error) {
       }
@@ -1540,8 +2480,8 @@ var AccessibilityScripts = class _AccessibilityScripts {
   }
   readFromExistingFile() {
     try {
-      if (fs4.existsSync(this.commandsPath)) {
-        const data = fs4.readFileSync(this.commandsPath, "utf8");
+      if (fs6.existsSync(this.commandsPath)) {
+        const data = fs6.readFileSync(this.commandsPath, "utf8");
         if (data) {
           this.update(JSON.parse(data));
         }
@@ -1564,10 +2504,10 @@ var AccessibilityScripts = class _AccessibilityScripts {
     }
   }
   store() {
-    if (!fs4.existsSync(this.browserstackFolderPath)) {
-      fs4.mkdirSync(this.browserstackFolderPath);
+    if (!fs6.existsSync(this.browserstackFolderPath)) {
+      fs6.mkdirSync(this.browserstackFolderPath);
     }
-    fs4.writeFileSync(this.commandsPath, JSON.stringify({
+    fs6.writeFileSync(this.commandsPath, JSON.stringify({
       commands: this.commandsToWrap,
       scripts: {
         scan: this.performScan,
@@ -1582,7 +2522,7 @@ var AccessibilityScripts = class _AccessibilityScripts {
 var accessibility_scripts_default = AccessibilityScripts.checkAndGetInstance();
 
 // src/util.ts
-var pGitconfig = promisify(gitconfig);
+var pGitconfig = promisify2(gitconfig);
 var DEFAULT_REQUEST_CONFIG = {
   headers: {
     "Content-Type": "application/json",
@@ -1603,7 +2543,7 @@ function processError(error, fn, args) {
   try {
     argsString = JSON.stringify(args);
   } catch {
-    argsString = util2.inspect(args, { depth: 2 });
+    argsString = util3.inspect(args, { depth: 2 });
   }
   CrashReporter.uploadCrashReport(`Error in executing ${fn.name} with args ${argsString} : ${error}`, error && error.stack || "unknown error");
 }
@@ -1699,10 +2639,10 @@ var launchTestSession = PerformanceTester.measureWrapper(TESTHUB_EVENTS.START, o
     tags: getObservabilityBuildTags(options, bsConfig.buildTag),
     host_info: {
       hostname: hostname2(),
-      platform: platform2(),
+      platform: platform3(),
       type: type2(),
       version: version2(),
-      arch: arch2()
+      arch: arch3()
     },
     ci_info: getCiInfo(),
     build_run_identifier: process.env.BROWSERSTACK_BUILD_RUN_IDENTIFIER,
@@ -1815,7 +2755,7 @@ var performA11yScan = async (isAppAutomate, browser, isBrowserStackSession, isAc
   try {
     if (isAppAccessibilityAutomationSession(isAccessibility, isAppAutomate)) {
       const results = await browser.execute(formatString(accessibility_scripts_default.performScan, JSON.stringify(_getParamsForAppAccessibility(commandName))), {});
-      BStackLogger.debug(util2.format(results));
+      BStackLogger.debug(util3.format(results));
       return results;
     }
     if (accessibility_scripts_default.performScan) {
@@ -2261,7 +3201,7 @@ function getObservabilityBuild(options, bstackBuildName) {
   if (options.testObservabilityOptions && options.testObservabilityOptions.buildName) {
     return options.testObservabilityOptions.buildName;
   }
-  return bstackBuildName || path4.basename(path4.resolve(process.cwd()));
+  return bstackBuildName || path6.basename(path6.resolve(process.cwd()));
 }
 function getObservabilityBuildTags(options, bstackBuildTag) {
   if (process.env.TEST_OBSERVABILITY_BUILD_TAG) {
@@ -2275,9 +3215,24 @@ function getObservabilityBuildTags(options, bstackBuildTag) {
   }
   return [];
 }
+function getBrowserStackUser(config) {
+  if (process.env.BROWSERSTACK_USERNAME) {
+    return process.env.BROWSERSTACK_USERNAME;
+  }
+  return config.user;
+}
+function getBrowserStackKey(config) {
+  if (process.env.BROWSERSTACK_ACCESS_KEY) {
+    return process.env.BROWSERSTACK_ACCESS_KEY;
+  }
+  return config.key;
+}
 function isTrue(value) {
   return (value + "").toLowerCase() === "true";
 }
+function isFalse(value) {
+  return (value + "").toLowerCase() === "false";
+}
 var patchConsoleLogs = o11yErrorHandler(() => {
   const BSTestOpsPatcher = new logPatcher_default({});
   Object.keys(consoleHolder).forEach((method) => {
@@ -2472,21 +3427,66 @@ function isValidEnabledValue(value) {
   }
   return false;
 }
+function isNullOrEmpty(string) {
+  return !string || string.trim() === "";
+}
+function isHash(entity) {
+  return Boolean(entity && typeof entity === "object" && !Array.isArray(entity));
+}
+function nestedKeyValue(hash, keys) {
+  return keys.reduce((hash2, key) => isHash(hash2) ? hash2[key] : void 0, hash);
+}
+function removeDir(dir) {
+  const list = fs7.readdirSync(dir);
+  for (let i = 0; i < list.length; i++) {
+    const filename = path6.join(dir, list[i]);
+    const stat = fs7.statSync(filename);
+    if (filename === "." || filename === "..") {
+    } else if (stat.isDirectory()) {
+      removeDir(filename);
+    } else {
+      fs7.unlinkSync(filename);
+    }
+  }
+  fs7.rmdirSync(dir);
+}
+function createDir(dir) {
+  if (fs7.existsSync(dir)) {
+    removeDir(dir);
+  }
+  fs7.mkdirSync(dir, { recursive: true });
+}
+function isWritable(dirPath) {
+  try {
+    fs7.accessSync(dirPath, fs7.constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function setReadWriteAccess(dirPath) {
+  try {
+    fs7.chmodSync(dirPath, 438);
+    BStackLogger.debug(`Directory ${dirPath} is now read/write accessible.`);
+  } catch (err) {
+    BStackLogger.error(`Failed to set directory access: ${err.stack}`);
+  }
+}
 
 // src/cleanup.ts
-import fs8 from "node:fs";
-import util4 from "node:util";
+import fs10 from "node:fs";
+import util5 from "node:util";
 
 // src/instrumentation/funnelInstrumentation.ts
 import os2 from "node:os";
-import util3, { format as format2 } from "node:util";
-import path6 from "node:path";
-import fs7 from "node:fs";
+import util4, { format as format2 } from "node:util";
+import path8 from "node:path";
+import fs9 from "node:fs";
 
 // src/data-store.ts
-import path5 from "node:path";
-import fs6 from "node:fs";
-var workersDataDirPath = path5.join(process.cwd(), "logs", "worker_data");
+import path7 from "node:path";
+import fs8 from "node:fs";
+var workersDataDirPath = path7.join(process.cwd(), "logs", "worker_data");
 
 // src/instrumentation/funnelInstrumentation.ts
 function redactCredentialsFromFunnelData(data) {
@@ -2503,7 +3503,7 @@ function redactCredentialsFromFunnelData(data) {
 async function fireFunnelRequest(data) {
   const { userName, accessKey } = data;
   redactCredentialsFromFunnelData(data);
-  BStackLogger.debug("Sending SDK event with data " + util3.inspect(data, { depth: 6 }));
+  BStackLogger.debug("Sending SDK event with data " + util4.inspect(data, { depth: 6 }));
   const encodedAuth = Buffer.from(`${userName}:${accessKey}`, "utf8").toString("base64");
   const response = await fetchWrap(APIUtils.FUNNEL_INSTRUMENTATION_URL, {
     method: "POST",
@@ -2542,7 +3542,7 @@ var BStackCleanup = class _BStackCleanup {
         await PerformanceTester.uploadEventsData();
       }
     } catch (er) {
-      BStackLogger.debug(`Error in sending events data ${util4.format(er)}`);
+      BStackLogger.debug(`Error in sending events data ${util5.format(er)}`);
     }
   }
   static async executeObservabilityCleanup(funnelData) {
@@ -2592,7 +3592,7 @@ Visit https://automation.browserstack.com/builds/${process.env[BROWSERSTACK_TEST
     if (!filePath) {
       return null;
     }
-    const content = fs8.readFileSync(filePath, "utf8");
+    const content = fs10.readFileSync(filePath, "utf8");
     const data = JSON.parse(content);
     this.removeFunnelDataFile(filePath);
     return data;
@@ -2601,7 +3601,7 @@ Visit https://automation.browserstack.com/builds/${process.env[BROWSERSTACK_TEST
     if (!filePath) {
       return;
     }
-    fs8.rmSync(filePath, { force: true });
+    fs10.rmSync(filePath, { force: true });
   }
 };
 void BStackCleanup.startCleanup();