@wdio/browserstack-service 9.27.2 → 9.29.0

package/build/cleanup.js

@@ -1,10 +1,10 @@
 // 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";
@@ -53,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
@@ -70,7 +70,7 @@ import logger from "@wdio/logger";
 // package.json
 var package_default = {
   name: "@wdio/browserstack-service",
-  version: "9.27.1",
+  version: "9.28.0",
   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",
@@ -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 = {};
@@ -680,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)}`
       );
     }
@@ -691,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(
@@ -751,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;
@@ -766,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)}`
@@ -807,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) {
@@ -844,12 +890,12 @@ var CLIUtils = class _CLIUtils {
     if (platform() === "darwin") {
       return false;
     }
-    if (!fs3.existsSync(binaryPath)) {
+    if (!fs4.existsSync(binaryPath)) {
       return false;
     }
     try {
-      const fd = fs3.openSync(binaryPath, "r+");
-      fs3.closeSync(fd);
+      const fd = fs4.openSync(binaryPath, "r+");
+      fs4.closeSync(fd);
       return false;
     } catch (err) {
       if (BINARY_BUSY_ERROR_CODES.includes(err.code)) {
@@ -860,6 +906,35 @@ var CLIUtils = class _CLIUtils {
       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 = {
@@ -868,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)}`);
@@ -895,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);
@@ -923,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 {
             }
           };
@@ -952,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}`
               );
@@ -981,16 +1057,16 @@ ${Date.now()}
       try {
         const now = Date.now();
         const tmpExtractRe = /\.tmp\.\d+$/;
-        for (const entry of fs3.readdirSync(cliDir)) {
+        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;
           }
@@ -998,7 +1074,7 @@ ${Date.now()}
             continue;
           }
           try {
-            fs3.unlinkSync(filePath);
+            fs4.unlinkSync(filePath);
           } catch (err) {
             BStackLogger2.debug(
               `Failed to delete temp CLI file ${filePath}: ${util.format(err)}`
@@ -1038,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}`
         );
@@ -1047,11 +1123,11 @@ ${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 processDownload = async () => {
           const abortController = new AbortController();
@@ -1061,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);
           }
@@ -1133,17 +1211,17 @@ ${Date.now()}
             zipfile.readEntry();
             return;
           }
-          const candidatePath = path3.join(cliDir, entry.fileName);
-          const resolvedCandidate = path3.resolve(candidatePath);
-          const resolvedDir = path3.resolve(cliDir) + path3.sep;
+          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 = path3.basename(entry.fileName).startsWith("binary-");
+          const isBinaryEntry = path4.basename(entry.fileName).startsWith("binary-");
           if (!isBinaryEntry) {
-            const directStream = fs3.createWriteStream(candidatePath);
+            const directStream = fs4.createWriteStream(candidatePath);
             directStream.on("error", (writeErr) => {
               zipfile.close();
               reject(writeErr);
@@ -1165,8 +1243,8 @@ ${Date.now()}
             return;
           }
           const finalPath = candidatePath;
-          const tempPath = path3.join(cliDir, `${entry.fileName}.tmp.${process.pid}`);
-          const writeStream = fs3.createWriteStream(tempPath);
+          const tempPath = path4.join(cliDir, `${entry.fileName}.tmp.${process.pid}`);
+          const writeStream = fs4.createWriteStream(tempPath);
           let writeStreamErrored = false;
           writeStream.on("error", (writeErr) => {
             writeStreamErrored = true;
@@ -1347,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(
@@ -1425,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)}`);
     }
@@ -1599,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}`);
@@ -1676,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`);
       }
@@ -1732,7 +1810,7 @@ var getProductMapForBuildStartCall = (config, accessibilityAutomation) => {
 };
 
 // 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
@@ -1962,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);
@@ -2427,6 +2505,8 @@ var TestOpsConfig = class _TestOpsConfig {
     this.manuallySet = manuallySet;
     _TestOpsConfig._instance = this;
   }
+  enabled;
+  manuallySet;
   static _instance;
   buildStopped = false;
   buildHashedId;
@@ -2553,9 +2633,9 @@ var usageStats_default = UsageStats;
 import { create } from "tar";
 
 // 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;
@@ -2569,7 +2649,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) {
@@ -2581,17 +2661,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) {
       }
@@ -2600,8 +2680,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));
         }
@@ -2624,10 +2704,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,
@@ -3326,7 +3406,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) {
@@ -3420,6 +3500,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;
 };
@@ -3581,28 +3700,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;
@@ -3610,7 +3729,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}`);
@@ -3618,19 +3737,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) {
@@ -3736,7 +3855,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;
@@ -3745,7 +3864,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();