@wdio/browserstack-service 9.27.1 → 9.28.0

package/build/cleanup.js

@@ -1,14 +1,13 @@
 // src/util.ts
 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 fs7 from "node:fs";
+import fs8 from "node:fs";
 import zlib from "node:zlib";
 import { format, promisify as promisify2 } from "node:util";
-import path6 from "node:path";
+import path7 from "node:path";
 import util3 from "node:util";
 import gitRepoInfo from "git-repo-info";
 import gitconfig from "gitconfiglocal";
-import { FormData } from "formdata-node";
 import { performance as performance2 } from "node:perf_hooks";
 
 // src/logPatcher.ts
@@ -54,12 +53,12 @@ var logPatcher_default = logPatcher;
 
 // src/instrumentation/performance/performance-tester.ts
 import { createObjectCsvWriter } from "csv-writer";
-import fs4 from "node:fs";
+import fs5 from "node:fs";
 import fsPromise from "node:fs/promises";
 import { performance, PerformanceObserver } from "node:perf_hooks";
 import util2 from "node:util";
 import worker from "node:worker_threads";
-import path4 from "node:path";
+import path5 from "node:path";
 import { arch as arch2, hostname, platform as platform2, type, version } from "node:os";
 
 // src/bstackLogger.ts
@@ -71,7 +70,7 @@ import logger from "@wdio/logger";
 // package.json
 var package_default = {
   name: "@wdio/browserstack-service",
-  version: "9.27.0",
+  version: "9.27.2",
   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",
@@ -118,7 +117,6 @@ var package_default = {
     "browserstack-local": "^1.5.1",
     chalk: "^5.3.0",
     "csv-writer": "^1.6.0",
-    "formdata-node": "5.0.1",
     "git-repo-info": "^2.1.1",
     gitconfiglocal: "^2.1.0",
     glob: "^11.0.0",
@@ -149,6 +147,7 @@ var consoleHolder = Object.assign({}, console);
 var APP_ALLY_ISSUES_ENDPOINT = "api/v1/issues";
 var APP_ALLY_ISSUES_SUMMARY_ENDPOINT = "api/v1/issues-summary";
 var BSTACK_SERVICE_VERSION = bstackServiceVersion;
+var BROWSERSTACK_TEST_PLAN_ID = "BROWSERSTACK_TEST_PLAN_ID";
 var LOGS_FILE = "logs/bstack-wdio-service.log";
 var SMART_SELECTION_MODE_RELEVANT_FIRST = "relevantFirst";
 var SMART_SELECTION_MODE_RELEVANT_ONLY = "relevantOnly";
@@ -162,6 +161,7 @@ var BROWSERSTACK_ACCESSIBILITY = "BROWSERSTACK_ACCESSIBILITY";
 var BROWSERSTACK_OBSERVABILITY = "BROWSERSTACK_OBSERVABILITY";
 var MAX_GIT_META_DATA_SIZE_IN_BYTES = 64 * 1024;
 var GIT_META_DATA_TRUNCATED = "...[TRUNCATED]";
+var BINARY_BUSY_ERROR_CODES = ["ETXTBSY", "EBUSY"];
 var WDIO_NAMING_PREFIX = "WebdriverIO-";
 var UPDATED_CLI_ENDPOINT = "sdk/v1/update_cli";
 
@@ -266,10 +266,10 @@ var APIUtils = class {
 };
 
 // src/cli/cliUtils.ts
-import fs3 from "node:fs";
+import fs4 from "node:fs";
 import fsp from "node:fs/promises";
 import { platform, arch, homedir } from "node:os";
-import path3 from "node:path";
+import path4 from "node:path";
 import util, { promisify } from "node:util";
 import { exec } from "node:child_process";
 import { Readable } from "node:stream";
@@ -277,7 +277,20 @@ import yauzl from "yauzl";
 import { threadId } from "node:worker_threads";
 
 // src/fetchWrapper.ts
-import { fetch as undiciFetch, ProxyAgent } from "undici";
+import { fetch as undiciFetch, ProxyAgent, Agent as Agent2 } from "undici";
+
+// src/caCert.ts
+import { setGlobalDispatcher, Agent } from "undici";
+import tls from "node:tls";
+import fs2 from "node:fs";
+import os from "node:os";
+import path2 from "node:path";
+var mergedCa;
+function getMergedCa() {
+  return mergedCa;
+}
+
+// src/fetchWrapper.ts
 var ResponseError = class extends Error {
   response;
   constructor(message, res) {
@@ -285,26 +298,56 @@ var ResponseError = class extends Error {
     this.response = res;
   }
 };
-async function fetchWrap(input, init) {
-  const res = await _fetch(input, init);
+var dispatcherCache = /* @__PURE__ */ new Map();
+function getDispatcher(proxyUrl, connectTimeoutMs) {
+  const ca = getMergedCa();
+  const key = `${proxyUrl ?? "direct"}:${connectTimeoutMs ?? "default"}:${ca ? "ca" : "noca"}`;
+  let dispatcher = dispatcherCache.get(key);
+  if (!dispatcher) {
+    const connect = {};
+    if (connectTimeoutMs) {
+      connect.timeout = connectTimeoutMs;
+    }
+    if (proxyUrl) {
+      dispatcher = new ProxyAgent({ uri: proxyUrl, connect, ...ca ? { requestTls: { ca } } : {} });
+    } else {
+      if (ca) {
+        connect.ca = ca;
+      }
+      dispatcher = new Agent2({ connect });
+    }
+    dispatcherCache.set(key, dispatcher);
+  }
+  return dispatcher;
+}
+async function fetchWrap(input, init, options) {
+  const res = await _fetch(input, init, options);
   if (!res.ok) {
     throw new ResponseError(`Error response from server ${res.status}:  ${await res.text()}`, res);
   }
   return res;
 }
-function _fetch(input, init) {
+function _fetch(input, init, options) {
+  const connectTimeoutMs = options?.connectTimeoutMs;
   const proxyUrl = process.env.HTTP_PROXY || process.env.HTTPS_PROXY;
   if (proxyUrl) {
     const noProxy = process.env.NO_PROXY && process.env.NO_PROXY.trim() ? process.env.NO_PROXY.trim().split(/[\s,;]+/) : [];
     const request = new Request(input);
     const url = new URL(request.url);
     if (!noProxy.some((str) => url.hostname.endsWith(str))) {
+      const dispatcher = getDispatcher(proxyUrl, connectTimeoutMs);
       return undiciFetch(
         request.url,
-        { ...init, dispatcher: new ProxyAgent(proxyUrl) }
+        { ...init, dispatcher }
       );
     }
   }
+  if (connectTimeoutMs) {
+    return undiciFetch(
+      new Request(input).url,
+      { ...init, dispatcher: getDispatcher(void 0, connectTimeoutMs) }
+    );
+  }
   return fetch(input, init);
 }
 
@@ -456,20 +499,20 @@ var DISPATCHER_EVENTS = {
 };
 
 // src/cli/cliLogger.ts
-import path2 from "node:path";
-import fs2 from "node:fs";
+import path3 from "node:path";
+import fs3 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 logFilePath = path3.join(process.cwd(), LOGS_FILE);
+  static logFolderPath = path3.join(process.cwd(), "logs");
   static logFileStream;
   static logToFile(logMessage, logLevel) {
     try {
       if (!this.logFileStream) {
         this.ensureLogsFolder();
-        this.logFileStream = fs2.createWriteStream(this.logFilePath, { flags: "a" });
+        this.logFileStream = fs3.createWriteStream(this.logFilePath, { flags: "a" });
       }
       if (this.logFileStream && this.logFileStream.writable) {
         this.logFileStream.write(this.formatLog(logMessage, logLevel));
@@ -513,13 +556,13 @@ var BStackLogger2 = class {
     this.logFileStream = null;
   }
   static clearLogFile() {
-    if (fs2.existsSync(this.logFilePath)) {
-      fs2.truncateSync(this.logFilePath);
+    if (fs3.existsSync(this.logFilePath)) {
+      fs3.truncateSync(this.logFilePath);
     }
   }
   static ensureLogsFolder() {
-    if (!fs2.existsSync(this.logFolderPath)) {
-      fs2.mkdirSync(this.logFolderPath);
+    if (!fs3.existsSync(this.logFolderPath)) {
+      fs3.mkdirSync(this.logFolderPath);
     }
   }
 };
@@ -574,6 +617,9 @@ 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 CLI_CONNECT_TIMEOUT_MS = Number(process.env.BROWSERSTACK_CLI_CONNECT_TIMEOUT_MS) || 60 * 1e3;
+var CLI_FETCH_MAX_ATTEMPTS = 3;
+var CLI_FETCH_RETRY_BASE_DELAY_MS = 500;
 var CLIUtils = class _CLIUtils {
   static automationFrameworkDetail = {};
   static testFrameworkDetail = {};
@@ -598,6 +644,7 @@ var CLIUtils = class _CLIUtils {
       modifiedOpts.browserStackLocalOptions = modifiedOpts.opts;
       delete modifiedOpts.opts;
     }
+    delete modifiedOpts.testManagementOptions;
     modifiedOpts.testContextOptions = {
       skipSessionName: isFalse(modifiedOpts.setSessionName),
       skipSessionStatus: isFalse(modifiedOpts.setSessionStatus),
@@ -616,6 +663,8 @@ var CLIUtils = class _CLIUtils {
       options.testObservability
     );
     const observabilityOptions = options.testObservabilityOptions || {};
+    const testManagementOptions = options.testManagementOptions || {};
+    const testPlanId = typeof testManagementOptions.testPlanId === "string" ? testManagementOptions.testPlanId.trim() : "";
     const binconfig = {
       userName: observabilityOptions.user || config.user,
       accessKey: observabilityOptions.key || config.key,
@@ -627,26 +676,26 @@ var CLIUtils = class _CLIUtils {
     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 (testPlanId.length > 0) {
+      binconfig.testManagementOptions = {
+        testPlanId
+      };
     }
-    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];
+    const caps = Array.isArray(capabilities) ? capabilities : [capabilities];
+    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];
         });
-        if (capability["bstack:options"]) {
-          Object.keys(
-            capability["bstack:options"]
-          ).forEach((key) => {
-            platform4[key] = capability["bstack:options"][key];
-          });
-        }
-        binconfig.platforms.push(platform4);
       }
+      binconfig.platforms.push(platform4);
     }
     return JSON.stringify(binconfig);
   }
@@ -677,7 +726,7 @@ var CLIUtils = class _CLIUtils {
       BStackLogger2.debug(`Resolved binary path: ${finalBinaryPath}`);
       return finalBinaryPath;
     } catch (err) {
-      BStackLogger2.debug(
+      BStackLogger2.warn(
         `Error in setting up cli path directory, Exception: ${util.format(err)}`
       );
     }
@@ -688,7 +737,7 @@ var CLIUtils = class _CLIUtils {
       BStackLogger2.debug(
         `Worker process detected, skipping CLI update. Using existing: ${existingCliPath}`
       );
-      if (existingCliPath && fs3.existsSync(existingCliPath)) {
+      if (existingCliPath && fs4.existsSync(existingCliPath)) {
         return existingCliPath;
       }
       BStackLogger2.warn(
@@ -705,9 +754,20 @@ var CLIUtils = class _CLIUtils {
       sdk_language: this.getSdkLanguage()
     };
     if (!isNullOrEmpty(existingCliPath)) {
-      queryParams.cli_version = await this.runShellCommand(
+      if (this.isBinaryBusy(existingCliPath)) {
+        BStackLogger2.warn(`Existing binary is currently in use, skipping update: ${existingCliPath}`);
+        PerformanceTester.end(EVENTS.SDK_CLI_CHECK_UPDATE);
+        return existingCliPath;
+      }
+      const version3 = await this.runShellCommand(
         `${existingCliPath} version`
       );
+      if (version3.toLowerCase().includes("text file busy")) {
+        BStackLogger2.warn(`Binary busy during version check, skipping update: ${existingCliPath}`);
+        PerformanceTester.end(EVENTS.SDK_CLI_CHECK_UPDATE);
+        return existingCliPath;
+      }
+      queryParams.cli_version = version3;
     }
     const response = await this.requestToUpdateCLI(queryParams, config);
     if (nestedKeyValue(response, ["updated_cli_version"])) {
@@ -737,8 +797,8 @@ var CLIUtils = class _CLIUtils {
       if (isNullOrEmpty(writableDir)) {
         throw new Error("No writable directory available for the CLI");
       }
-      const cliDirPath = path3.join(writableDir, "cli");
-      if (!fs3.existsSync(cliDirPath)) {
+      const cliDirPath = path4.join(writableDir, "cli");
+      if (!fs4.existsSync(cliDirPath)) {
         createDir(cliDirPath);
       }
       return cliDirPath;
@@ -752,37 +812,37 @@ var CLIUtils = class _CLIUtils {
   static getWritableDir() {
     const writableDirOptions = [
       process.env.BROWSERSTACK_FILES_DIR,
-      path3.join(homedir(), ".browserstack"),
-      path3.join("tmp", ".browserstack")
+      path4.join(homedir(), ".browserstack"),
+      path4.join("tmp", ".browserstack")
     ];
-    for (const path9 of writableDirOptions) {
-      if (isNullOrEmpty(path9)) {
+    for (const path10 of writableDirOptions) {
+      if (isNullOrEmpty(path10)) {
         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 (fs4.existsSync(path10)) {
+          BStackLogger2.debug(`File ${path10} already exist`);
+          if (!isWritable(path10)) {
+            BStackLogger2.debug(`Giving write permission to ${path10}`);
+            const success = setReadWriteAccess(path10);
             if (!isTrue(success)) {
               BStackLogger2.warn(
-                `Unable to provide write permission to ${path9}`
+                `Unable to provide write permission to ${path10}`
               );
             }
           }
         } else {
-          BStackLogger2.debug(`File does not exist: ${path9}`);
-          createDir(path9);
-          BStackLogger2.debug(`Giving write permission to ${path9}`);
-          const success = setReadWriteAccess(path9);
+          BStackLogger2.debug(`File does not exist: ${path10}`);
+          createDir(path10);
+          BStackLogger2.debug(`Giving write permission to ${path10}`);
+          const success = setReadWriteAccess(path10);
           if (!isTrue(success)) {
             BStackLogger2.warn(
-              `Unable to provide write permission to ${path9}`
+              `Unable to provide write permission to ${path10}`
             );
           }
         }
-        return path9;
+        return path10;
       } catch (err) {
         BStackLogger2.error(
           `Unable to get writable directory, exception ${util.format(err)}`
@@ -793,16 +853,16 @@ var CLIUtils = class _CLIUtils {
   }
   static getExistingCliPath(cliDir) {
     try {
-      if (!fs3.existsSync(cliDir) || !fs3.statSync(cliDir).isDirectory()) {
+      if (!fs4.existsSync(cliDir) || !fs4.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-")
+      const allBinaries = fs4.readdirSync(cliDir).map((file) => path4.join(cliDir, file)).filter(
+        (filePath) => fs4.statSync(filePath).isFile() && path4.basename(filePath).startsWith("binary-")
       );
       if (allBinaries.length > 0) {
         const latestBinary = allBinaries.map((filePath) => ({
           filePath,
-          mtime: fs3.statSync(filePath).mtime
+          mtime: fs4.statSync(filePath).mtime
         })).reduce(
           (latest, current) => {
             if (!latest || !latest.mtime) {
@@ -823,6 +883,58 @@ var CLIUtils = class _CLIUtils {
       return "";
     }
   }
+  static isBinaryBusy(binaryPath) {
+    if (isNullOrEmpty(binaryPath)) {
+      return false;
+    }
+    if (platform() === "darwin") {
+      return false;
+    }
+    if (!fs4.existsSync(binaryPath)) {
+      return false;
+    }
+    try {
+      const fd = fs4.openSync(binaryPath, "r+");
+      fs4.closeSync(fd);
+      return false;
+    } catch (err) {
+      if (BINARY_BUSY_ERROR_CODES.includes(err.code)) {
+        BStackLogger2.debug(`Binary is busy: ${binaryPath}`);
+        return true;
+      }
+      BStackLogger2.debug(`Error checking if binary is busy: ${err.message}`);
+      return false;
+    }
+  }
+  /**
+   * fetch wrapper for CLI network calls that (a) raises undici's connect timeout
+   * above the non-overridable 10s default of global fetch and (b) retries a few
+   * times with linear backoff on transient connection failures. Both are needed
+   * for reliability in constrained CI/containerised networks (SDK-6152).
+   */
+  static fetchWithRetry = async (input, init, label) => {
+    let lastError;
+    for (let attempt = 1; attempt <= CLI_FETCH_MAX_ATTEMPTS; attempt++) {
+      try {
+        return await _fetch(input, init, { connectTimeoutMs: CLI_CONNECT_TIMEOUT_MS });
+      } catch (err) {
+        lastError = err;
+        const reason = (
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          err?.cause?.code || err?.code || err?.message
+        );
+        BStackLogger2.warn(
+          `${label} attempt ${attempt}/${CLI_FETCH_MAX_ATTEMPTS} failed: ${reason}`
+        );
+        if (attempt < CLI_FETCH_MAX_ATTEMPTS) {
+          await new Promise(
+            (resolve) => setTimeout(resolve, CLI_FETCH_RETRY_BASE_DELAY_MS * attempt)
+          );
+        }
+      }
+    }
+    throw lastError;
+  };
   static requestToUpdateCLI = async (queryParams, config) => {
     const params = new URLSearchParams(queryParams);
     const requestInit = {
@@ -831,9 +943,10 @@ var CLIUtils = class _CLIUtils {
         Authorization: `Basic ${Buffer.from(`${getBrowserStackUser(config)}:${getBrowserStackKey(config)}`).toString("base64")}`
       }
     };
-    const response = await _fetch(
+    const response = await this.fetchWithRetry(
       `${APIUtils.BROWSERSTACK_AUTOMATE_API_URL}/${UPDATED_CLI_ENDPOINT}?${params.toString()}`,
-      requestInit
+      requestInit,
+      "update_cli request"
     );
     const jsonResponse = await response.json();
     BStackLogger2.debug(`response ${JSON.stringify(jsonResponse)}`);
@@ -858,11 +971,11 @@ var CLIUtils = class _CLIUtils {
     });
   }
   static downloadLatestBinary = async (binDownloadUrl, cliDir) => {
-    const lockPath = path3.join(cliDir, "download.lock");
+    const lockPath = path4.join(cliDir, "download.lock");
     const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
     const parseLockFile = () => {
       try {
-        const content = fs3.readFileSync(lockPath, "utf8").trim();
+        const content = fs4.readFileSync(lockPath, "utf8").trim();
         const [pidLine, timestampLine] = content.split("\n");
         const pid = Number.parseInt(pidLine, 10);
         const timestamp = Number.parseInt(timestampLine, 10);
@@ -886,20 +999,20 @@ var CLIUtils = class _CLIUtils {
       const start = Date.now();
       while (true) {
         try {
-          const fd = fs3.openSync(lockPath, "wx");
+          const fd = fs4.openSync(lockPath, "wx");
           try {
-            fs3.writeFileSync(fd, `${process.pid}
+            fs4.writeFileSync(fd, `${process.pid}
 ${Date.now()}
 `);
           } catch {
           }
           return () => {
             try {
-              fs3.closeSync(fd);
+              fs4.closeSync(fd);
             } catch {
             }
             try {
-              fs3.unlinkSync(lockPath);
+              fs4.unlinkSync(lockPath);
             } catch {
             }
           };
@@ -915,14 +1028,14 @@ ${Date.now()}
                   `Stale CLI download lock detected (pid=${lockMeta.pid}, age=${lockAge}ms). Removing lock.`
                 );
                 try {
-                  fs3.unlinkSync(lockPath);
+                  fs4.unlinkSync(lockPath);
                 } catch {
                 }
                 continue;
               }
             }
             const existingBinary = _CLIUtils.getExistingCliPath(cliDir);
-            if (existingBinary && fs3.existsSync(existingBinary) && fs3.statSync(existingBinary).size > 0) {
+            if (existingBinary && fs4.existsSync(existingBinary) && fs4.statSync(existingBinary).size > 0) {
               BStackLogger2.debug(
                 `Binary appeared while waiting for lock: ${existingBinary}`
               );
@@ -943,14 +1056,17 @@ ${Date.now()}
     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)) {
+        const tmpExtractRe = /\.tmp\.\d+$/;
+        for (const entry of fs4.readdirSync(cliDir)) {
+          const isDownloadZip = entry.startsWith(CLI_DOWNLOAD_TMP_PREFIX) && entry.endsWith(CLI_DOWNLOAD_TMP_SUFFIX);
+          const isExtractTmp = tmpExtractRe.test(entry);
+          if (!isDownloadZip && !isExtractTmp) {
             continue;
           }
-          const filePath = path3.join(cliDir, entry);
+          const filePath = path4.join(cliDir, entry);
           let stats;
           try {
-            stats = fs3.statSync(filePath);
+            stats = fs4.statSync(filePath);
           } catch {
             continue;
           }
@@ -958,16 +1074,16 @@ ${Date.now()}
             continue;
           }
           try {
-            fs3.unlinkSync(filePath);
+            fs4.unlinkSync(filePath);
           } catch (err) {
             BStackLogger2.debug(
-              `Failed to delete temp CLI zip file ${filePath}: ${util.format(err)}`
+              `Failed to delete temp CLI file ${filePath}: ${util.format(err)}`
             );
           }
         }
       } catch (err) {
         BStackLogger2.debug(
-          `Failed to scan temp CLI downloads in ${cliDir}: ${util.format(err)}`
+          `Failed to scan temp CLI files in ${cliDir}: ${util.format(err)}`
         );
       }
     };
@@ -998,7 +1114,7 @@ ${Date.now()}
       }
       releaseLock = lockResult;
       const existingBinary = _CLIUtils.getExistingCliPath(cliDir);
-      if (existingBinary && fs3.existsSync(existingBinary) && fs3.statSync(existingBinary).size > 0) {
+      if (existingBinary && fs4.existsSync(existingBinary) && fs4.statSync(existingBinary).size > 0) {
         BStackLogger2.debug(
           `Binary already exists after acquiring lock: ${existingBinary}`
         );
@@ -1007,13 +1123,12 @@ ${Date.now()}
         return existingBinary;
       }
       cleanupTemporaryDownloads();
-      const zipFilePath = path3.join(
+      const zipFilePath = path4.join(
         cliDir,
         `${CLI_DOWNLOAD_TMP_PREFIX}${process.pid}_${Date.now()}${CLI_DOWNLOAD_TMP_SUFFIX}`
       );
-      const downloadedFileStream = fs3.createWriteStream(zipFilePath);
+      const downloadedFileStream = fs4.createWriteStream(zipFilePath);
       return new Promise((resolve, reject) => {
-        const binaryName = null;
         const processDownload = async () => {
           const abortController = new AbortController();
           const timeout = setTimeout(
@@ -1022,9 +1137,11 @@ ${Date.now()}
           );
           let response;
           try {
-            response = await _fetch(binDownloadUrl, {
-              signal: abortController.signal
-            });
+            response = await _fetch(
+              binDownloadUrl,
+              { signal: abortController.signal },
+              { connectTimeoutMs: CLI_CONNECT_TIMEOUT_MS }
+            );
           } finally {
             clearTimeout(timeout);
           }
@@ -1047,7 +1164,6 @@ ${Date.now()}
             nodeStream.pipe(downloadedFileStream);
             _CLIUtils.downloadFileStream(
               downloadedFileStream,
-              binaryName,
               zipFilePath,
               cliDir,
               (result) => {
@@ -1081,40 +1197,104 @@ ${Date.now()}
       return null;
     }
   };
-  static downloadFileStream(downloadedFileStream, binaryName, zipFilePath, cliDir, resolve, reject) {
+  static downloadFileStream(downloadedFileStream, zipFilePath, cliDir, resolve, reject) {
     downloadedFileStream.on("close", async function() {
       const yauzlOpenPromise = promisify(yauzl.open);
       try {
         const zipfile = await yauzlOpenPromise(zipFilePath, {
           lazyEntries: true
         });
+        let resolvedBinaryPath = null;
         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(
+            return;
+          }
+          const candidatePath = path4.join(cliDir, entry.fileName);
+          const resolvedCandidate = path4.resolve(candidatePath);
+          const resolvedDir = path4.resolve(cliDir) + path4.sep;
+          if (!resolvedCandidate.startsWith(resolvedDir)) {
+            zipfile.close();
+            reject(new Error(`Zip-slip detected: entry "${entry.fileName}" resolves outside ${cliDir}`));
+            return;
+          }
+          const isBinaryEntry = path4.basename(entry.fileName).startsWith("binary-");
+          if (!isBinaryEntry) {
+            const directStream = fs4.createWriteStream(candidatePath);
+            directStream.on("error", (writeErr) => {
+              zipfile.close();
+              reject(writeErr);
+            });
+            const openReadStreamPromise2 = promisify(
               zipfile.openReadStream
             ).bind(zipfile);
             try {
-              const readStream = await openReadStreamPromise(entry);
+              const readStream = await openReadStreamPromise2(entry);
               readStream.on("end", function() {
-                writeStream.close();
-                zipfile.readEntry();
+                directStream.end();
+                directStream.on("close", () => zipfile.readEntry());
               });
-              readStream.pipe(writeStream);
+              readStream.pipe(directStream);
             } catch (zipErr) {
+              zipfile.close();
               reject(zipErr);
             }
-            if (entry.fileName === binaryName) {
+            return;
+          }
+          const finalPath = candidatePath;
+          const tempPath = path4.join(cliDir, `${entry.fileName}.tmp.${process.pid}`);
+          const writeStream = fs4.createWriteStream(tempPath);
+          let writeStreamErrored = false;
+          writeStream.on("error", (writeErr) => {
+            writeStreamErrored = true;
+            fsp.unlink(tempPath).catch(() => {
+            });
+            zipfile.close();
+            reject(writeErr);
+          });
+          writeStream.on("close", async () => {
+            if (writeStreamErrored) {
+              return;
+            }
+            try {
+              await fsp.chmod(tempPath, "0755");
+              try {
+                await fsp.rename(tempPath, finalPath);
+              } catch (renameErr) {
+                if (renameErr.code !== "EXDEV") {
+                  throw renameErr;
+                }
+                BStackLogger2.warn(`Atomic rename failed (cross-device), falling back to copy: ${renameErr.message}`);
+                await fsp.copyFile(tempPath, finalPath);
+                await fsp.unlink(tempPath).catch(() => {
+                });
+              }
+              if (!resolvedBinaryPath) {
+                resolvedBinaryPath = finalPath;
+              }
+              zipfile.readEntry();
+            } catch (err) {
+              await fsp.unlink(tempPath).catch(() => {
+              });
               zipfile.close();
+              reject(err);
             }
+          });
+          const openReadStreamPromise = promisify(
+            zipfile.openReadStream
+          ).bind(zipfile);
+          try {
+            const readStream = await openReadStreamPromise(entry);
+            readStream.on("end", function() {
+              writeStream.end();
+            });
+            readStream.pipe(writeStream);
+          } catch (zipErr) {
+            fsp.unlink(tempPath).catch(() => {
+            });
+            zipfile.close();
+            reject(zipErr);
           }
         });
         zipfile.on("error", (zipErr) => {
@@ -1122,16 +1302,15 @@ ${Date.now()}
         });
         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);
+            BStackLogger2.warn(`Failed to delete zip file: ${zipFilePath}`);
           });
+          if (!resolvedBinaryPath) {
+            zipfile.close();
+            reject(new Error("No binary-* entry found in zip; cannot complete CLI binary extraction"));
+            return;
+          }
           zipfile.close();
+          resolve(resolvedBinaryPath);
         });
       } catch (err) {
         reject(err);
@@ -1246,11 +1425,11 @@ var PerformanceTester = class _PerformanceTester {
   static browser;
   static scenarioThatRan;
   static jsonReportDirName = "performance-report";
-  static jsonReportDirPath = path4.join(process.cwd(), "logs", this.jsonReportDirName);
+  static jsonReportDirPath = path5.join(process.cwd(), "logs", this.jsonReportDirName);
   static jsonReportFileName = `${this.jsonReportDirPath}/performance-report-${_PerformanceTester.getProcessId()}.json`;
   static startMonitoring(csvName = "performance-report.csv") {
-    if (!fs4.existsSync(this.jsonReportDirPath)) {
-      fs4.mkdirSync(this.jsonReportDirPath, { recursive: true });
+    if (!fs5.existsSync(this.jsonReportDirPath)) {
+      fs5.mkdirSync(this.jsonReportDirPath, { recursive: true });
     }
     this._observer = new PerformanceObserver((list) => {
       list.getEntries().filter((entry) => entry.entryType === "measure").forEach(
@@ -1324,10 +1503,10 @@ var PerformanceTester = class _PerformanceTester {
     this.started = false;
     this.generateCSV(this._events);
     const content = this.generateReport(this._events);
-    const dir = path4.join(process.cwd(), filename);
+    const dir = path5.join(process.cwd(), filename);
     try {
       await fsPromise.writeFile(dir, content);
-      BStackLogger.info(`Performance report is at ${path4}`);
+      BStackLogger.info(`Performance report is at ${path5}`);
     } catch (err) {
       BStackLogger.error(`Error in writing html ${util2.format(err)}`);
     }
@@ -1468,6 +1647,7 @@ var PerformanceTester = class _PerformanceTester {
   static end(event, success = true, failure, details = {}) {
     performance.mark(event + "-end");
     performance.measure(event, event + "-start", event + "-end");
+    delete this.eventsMap[event + "-start"];
     this.details[event] = Object.assign({ success, failure: util2.format(failure) }, Object.assign(Object.assign({
       clientWorkerId: _PerformanceTester.getClientWorkerId(),
       worker: _PerformanceTester.getProcessId(),
@@ -1497,7 +1677,7 @@ var PerformanceTester = class _PerformanceTester {
       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) => path4.resolve(this.jsonReportDirPath, file));
+        const files = (await fsPromise.readdir(this.jsonReportDirPath)).map((file) => path5.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}`);
@@ -1574,7 +1754,7 @@ var PerformanceTester = class _PerformanceTester {
       if (await fsPromise.access(this.jsonReportDirPath).then(() => true, () => false)) {
         const files = await fsPromise.readdir(this.jsonReportDirPath);
         for (const file of files) {
-          await fsPromise.unlink(path4.join(this.jsonReportDirPath, file));
+          await fsPromise.unlink(path5.join(this.jsonReportDirPath, file));
         }
         BStackLogger.debug(`[Performance Upload] Cleaned up ${files.length} temporary report files`);
       }
@@ -1619,17 +1799,18 @@ var logBuildError = (error, product = "") => {
   }
 };
 var getProductMapForBuildStartCall = (config, accessibilityAutomation) => {
-  return {
-    observability: config.testObservability.enabled,
-    accessibility: accessibilityAutomation,
-    percy: config.percy,
-    automate: config.automate,
-    app_automate: config.appAutomate
-  };
+  const entries = [
+    ["observability", config.testObservability.enabled],
+    ["accessibility", accessibilityAutomation],
+    ["percy", config.percy],
+    ["automate", config.automate],
+    ["app_automate", config.appAutomate]
+  ];
+  return Object.fromEntries(entries.filter(([, v]) => v !== null));
 };
 
 // src/testorchestration/testorcherstrationutils.ts
-import fs5 from "node:fs";
+import fs6 from "node:fs";
 var RUN_SMART_SELECTION = "runSmartSelection";
 var ALLOWED_ORCHESTRATION_KEYS = [
   RUN_SMART_SELECTION
@@ -1859,13 +2040,13 @@ var OrchestrationUtils = class _OrchestrationUtils {
    * @returns Formatted list of repository configurations
    */
   _loadSourceFromFile(filePath) {
-    if (!fs5.existsSync(filePath)) {
+    if (!fs6.existsSync(filePath)) {
       BStackLogger.error(`Source file '${filePath}' does not exist.`);
       return [];
     }
     let data = null;
     try {
-      const fileContent = fs5.readFileSync(filePath, "utf8");
+      const fileContent = fs6.readFileSync(filePath, "utf8");
       data = JSON.parse(fileContent);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -2448,12 +2629,11 @@ var usageStats_default = UsageStats;
 
 // src/util.ts
 import { create } from "tar";
-import { fileFromPath } from "formdata-node/file-from-path";
 
 // src/scripts/accessibility-scripts.ts
-import path5 from "node:path";
-import fs6 from "node:fs";
-import os from "node:os";
+import path6 from "node:path";
+import fs7 from "node:fs";
+import os2 from "node:os";
 var AccessibilityScripts = class _AccessibilityScripts {
   static instance = null;
   performScan = null;
@@ -2467,7 +2647,7 @@ var AccessibilityScripts = class _AccessibilityScripts {
   // don't allow to create instances from it other than through `checkAndGetInstance`
   constructor() {
     this.browserstackFolderPath = this.getWritableDir();
-    this.commandsPath = path5.join(this.browserstackFolderPath, "commands.json");
+    this.commandsPath = path6.join(this.browserstackFolderPath, "commands.json");
   }
   static checkAndGetInstance() {
     if (!_AccessibilityScripts.instance) {
@@ -2479,17 +2659,17 @@ var AccessibilityScripts = class _AccessibilityScripts {
   /* eslint-disable @typescript-eslint/no-unused-vars */
   getWritableDir() {
     const orderedPaths = [
-      path5.join(os.homedir(), ".browserstack"),
+      path6.join(os2.homedir(), ".browserstack"),
       process.cwd(),
-      os.tmpdir()
+      os2.tmpdir()
     ];
     for (const orderedPath of orderedPaths) {
       try {
-        if (fs6.existsSync(orderedPath)) {
-          fs6.accessSync(orderedPath);
+        if (fs7.existsSync(orderedPath)) {
+          fs7.accessSync(orderedPath);
           return orderedPath;
         }
-        fs6.mkdirSync(orderedPath, { recursive: true });
+        fs7.mkdirSync(orderedPath, { recursive: true });
         return orderedPath;
       } catch (error) {
       }
@@ -2498,8 +2678,8 @@ var AccessibilityScripts = class _AccessibilityScripts {
   }
   readFromExistingFile() {
     try {
-      if (fs6.existsSync(this.commandsPath)) {
-        const data = fs6.readFileSync(this.commandsPath, "utf8");
+      if (fs7.existsSync(this.commandsPath)) {
+        const data = fs7.readFileSync(this.commandsPath, "utf8");
         if (data) {
           this.update(JSON.parse(data));
         }
@@ -2522,10 +2702,10 @@ var AccessibilityScripts = class _AccessibilityScripts {
     }
   }
   store() {
-    if (!fs6.existsSync(this.browserstackFolderPath)) {
-      fs6.mkdirSync(this.browserstackFolderPath);
+    if (!fs7.existsSync(this.browserstackFolderPath)) {
+      fs7.mkdirSync(this.browserstackFolderPath);
     }
-    fs6.writeFileSync(this.commandsPath, JSON.stringify({
+    fs7.writeFileSync(this.commandsPath, JSON.stringify({
       commands: this.commandsToWrap,
       scripts: {
         scan: this.performScan,
@@ -2682,7 +2862,10 @@ var launchTestSession = PerformanceTester.measureWrapper(TESTHUB_EVENTS.START, o
     },
     product_map: getProductMapForBuildStartCall(bStackConfig, accessibilityAutomation),
     config: {},
-    test_orchestration: OrchestrationUtils.getInstance(config)?.getBuildStartData() || {}
+    test_orchestration: OrchestrationUtils.getInstance(config)?.getBuildStartData() || {},
+    test_management: {
+      test_plan_id: getTestPlanId(options)
+    }
   };
   if (accessibilityAutomation && (isTurboScale(options) || data.browserstackAutomation === false)) {
     data.accessibility.settings ??= {};
@@ -2711,6 +2894,7 @@ var launchTestSession = PerformanceTester.measureWrapper(TESTHUB_EVENTS.START, o
     const jsonResponse = await response.json();
     delete data?.accessibility?.settings?.includeEncodedExtension;
     BStackLogger.debug(`[Start_Build] Success response: ${JSON.stringify(jsonResponse)}`);
+    BStackLogger.debug(`Test Plan Id sent in request: ${getTestPlanId(options)}`);
     process.env[TESTOPS_BUILD_COMPLETED_ENV] = "true";
     if (jsonResponse.jwt) {
       process.env[BROWSERSTACK_TESTHUB_JWT] = jsonResponse.jwt;
@@ -3220,7 +3404,7 @@ function getObservabilityBuild(options, bstackBuildName) {
   if (options.testObservabilityOptions && options.testObservabilityOptions.buildName) {
     return options.testObservabilityOptions.buildName;
   }
-  return bstackBuildName || path6.basename(path6.resolve(process.cwd()));
+  return bstackBuildName || path7.basename(path7.resolve(process.cwd()));
 }
 function getObservabilityBuildTags(options, bstackBuildTag) {
   if (process.env.TEST_OBSERVABILITY_BUILD_TAG) {
@@ -3234,6 +3418,25 @@ function getObservabilityBuildTags(options, bstackBuildTag) {
   }
   return [];
 }
+function getTestPlanId(options) {
+  if (process.env[BROWSERSTACK_TEST_PLAN_ID]) {
+    return process.env[BROWSERSTACK_TEST_PLAN_ID];
+  }
+  const CLI_ARG = "--browserstack.testManagementOptions.testPlanId";
+  const argIndex = process.argv.indexOf(CLI_ARG);
+  if (argIndex !== -1 && process.argv[argIndex + 1]) {
+    return process.argv[argIndex + 1];
+  }
+  const argWithEquals = process.argv.find((arg) => arg.startsWith(`${CLI_ARG}=`));
+  if (argWithEquals) {
+    return argWithEquals.split("=")[1];
+  }
+  const testPlanId = options.testManagementOptions?.testPlanId;
+  if (typeof testPlanId === "string" && testPlanId.trim().length > 0) {
+    return testPlanId.trim();
+  }
+  return void 0;
+}
 function getBrowserStackUser(config) {
   if (process.env.BROWSERSTACK_USERNAME) {
     return process.env.BROWSERSTACK_USERNAME;
@@ -3295,6 +3498,45 @@ var getPlatformVersion = o11yErrorHandler(function getPlatformVersion2(caps, use
   }
   return void 0;
 });
+var getResolvedDeviceName = o11yErrorHandler(function getResolvedDeviceName2(driverCaps, requestedCaps) {
+  const flattenMultiremote = (caps) => {
+    if (!caps) {
+      return [];
+    }
+    const obj = caps;
+    if (obj["deviceModel"] || obj["appium:deviceModel"] || obj["deviceName"] || obj["bstack:options"]) {
+      return [caps];
+    }
+    return Object.values(obj).filter((v) => v !== null && typeof v === "object" && "capabilities" in v).map((v) => v.capabilities).filter(Boolean);
+  };
+  const sources = [
+    ...flattenMultiremote(driverCaps),
+    ...flattenMultiremote(requestedCaps)
+  ];
+  if (!sources.length) {
+    return void 0;
+  }
+  const pickString = (obj, key) => {
+    const v = obj?.[key];
+    return typeof v === "string" && v.length > 0 ? v : void 0;
+  };
+  const paths = [
+    (c) => pickString(c, "deviceModel"),
+    (c) => pickString(c, "appium:deviceModel"),
+    (c) => pickString(c["bstack:options"], "deviceName"),
+    (c) => pickString(c, "appium:deviceName"),
+    (c) => pickString(c, "deviceName")
+  ];
+  for (const path10 of paths) {
+    for (const src of sources) {
+      const v = path10(src);
+      if (v) {
+        return v;
+      }
+    }
+  }
+  return void 0;
+});
 var isObjectEmpty = (objectName) => {
   return objectName && Object.keys(objectName).length === 0 && objectName.constructor === Object;
 };
@@ -3456,28 +3698,28 @@ function nestedKeyValue(hash, keys) {
   return keys.reduce((hash2, key) => isHash(hash2) ? hash2[key] : void 0, hash);
 }
 function removeDir(dir) {
-  const list = fs7.readdirSync(dir);
+  const list = fs8.readdirSync(dir);
   for (let i = 0; i < list.length; i++) {
-    const filename = path6.join(dir, list[i]);
-    const stat = fs7.statSync(filename);
+    const filename = path7.join(dir, list[i]);
+    const stat = fs8.statSync(filename);
     if (filename === "." || filename === "..") {
     } else if (stat.isDirectory()) {
       removeDir(filename);
     } else {
-      fs7.unlinkSync(filename);
+      fs8.unlinkSync(filename);
     }
   }
-  fs7.rmdirSync(dir);
+  fs8.rmdirSync(dir);
 }
 function createDir(dir) {
-  if (fs7.existsSync(dir)) {
+  if (fs8.existsSync(dir)) {
     removeDir(dir);
   }
-  fs7.mkdirSync(dir, { recursive: true });
+  fs8.mkdirSync(dir, { recursive: true });
 }
 function isWritable(dirPath) {
   try {
-    fs7.accessSync(dirPath, fs7.constants.W_OK);
+    fs8.accessSync(dirPath, fs8.constants.W_OK);
     return true;
   } catch {
     return false;
@@ -3485,7 +3727,7 @@ function isWritable(dirPath) {
 }
 function setReadWriteAccess(dirPath) {
   try {
-    fs7.chmodSync(dirPath, 438);
+    fs8.chmodSync(dirPath, 438);
     BStackLogger.debug(`Directory ${dirPath} is now read/write accessible.`);
   } catch (err) {
     BStackLogger.error(`Failed to set directory access: ${err.stack}`);
@@ -3493,19 +3735,19 @@ function setReadWriteAccess(dirPath) {
 }
 
 // src/cleanup.ts
-import fs10 from "node:fs";
+import fs11 from "node:fs";
 import util5 from "node:util";
 
 // src/instrumentation/funnelInstrumentation.ts
-import os2 from "node:os";
+import os3 from "node:os";
 import util4, { format as format2 } from "node:util";
-import path8 from "node:path";
-import fs9 from "node:fs";
+import path9 from "node:path";
+import fs10 from "node:fs";
 
 // src/data-store.ts
-import path7 from "node:path";
-import fs8 from "node:fs";
-var workersDataDirPath = path7.join(process.cwd(), "logs", "worker_data");
+import path8 from "node:path";
+import fs9 from "node:fs";
+var workersDataDirPath = path8.join(process.cwd(), "logs", "worker_data");
 
 // src/instrumentation/funnelInstrumentation.ts
 function redactCredentialsFromFunnelData(data) {
@@ -3611,7 +3853,7 @@ Visit https://automation.browserstack.com/builds/${process.env[BROWSERSTACK_TEST
     if (!filePath) {
       return null;
     }
-    const content = fs10.readFileSync(filePath, "utf8");
+    const content = fs11.readFileSync(filePath, "utf8");
     const data = JSON.parse(content);
     this.removeFunnelDataFile(filePath);
     return data;
@@ -3620,7 +3862,7 @@ Visit https://automation.browserstack.com/builds/${process.env[BROWSERSTACK_TEST
     if (!filePath) {
       return;
     }
-    fs10.rmSync(filePath, { force: true });
+    fs11.rmSync(filePath, { force: true });
   }
 };
 void BStackCleanup.startCleanup();