@wdio/browserstack-service 9.8.0 → 9.9.1

package/build/cleanup.js

@@ -1,13 +1,14 @@
 // src/util.ts
-import { hostname, platform, type, version, arch } from "node:os";
+import { hostname as hostname2, platform as platform2, type as type2, version as version2, arch as arch2 } from "node:os";
 import fs4 from "node:fs";
 import zlib from "node:zlib";
 import { format, promisify } from "node:util";
-import path3 from "node:path";
-import util from "node:util";
+import path4 from "node:path";
+import util2 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
 import Transport from "winston-transport";
@@ -50,10 +51,15 @@ var logPatcher = class extends Transport {
 };
 var logPatcher_default = logPatcher;
 
-// src/performance-tester.ts
+// src/instrumentation/performance/performance-tester.ts
 import { createObjectCsvWriter } from "csv-writer";
 import fs2 from "node:fs";
+import fsPromise from "node:fs/promises";
 import { performance, PerformanceObserver } from "node:perf_hooks";
+import util from "node:util";
+import worker from "node:worker_threads";
+import path2 from "node:path";
+import { arch, hostname, platform, type, version } from "node:os";
 
 // src/bstackLogger.ts
 import path from "node:path";
@@ -64,7 +70,7 @@ import logger from "@wdio/logger";
 // package.json
 var package_default = {
   name: "@wdio/browserstack-service",
-  version: "9.7.3",
+  version: "9.9.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",
@@ -135,9 +141,13 @@ var package_default = {
 var bstackServiceVersion = package_default.version;
 var consoleHolder = Object.assign({}, console);
 var DATA_ENDPOINT = "https://collector-observability.browserstack.com";
+var APP_ALLY_ENDPOINT = "https://app-accessibility.browserstack.com/automate";
+var APP_ALLY_ISSUES_ENDPOINT = "api/v1/issues";
+var APP_ALLY_ISSUES_SUMMARY_ENDPOINT = "api/v1/issues-summary";
 var BSTACK_SERVICE_VERSION = bstackServiceVersion;
 var LOGS_FILE = "logs/bstack-wdio-service.log";
 var FUNNEL_INSTRUMENTATION_URL = "https://api.browserstack.com/sdk/v1/event";
+var EDS_URL = "https://eds.browserstack.com";
 var BROWSERSTACK_TESTHUB_JWT = "BROWSERSTACK_TESTHUB_JWT";
 var TESTOPS_SCREENSHOT_ENV = "BS_TESTOPS_ALLOW_SCREENSHOTS";
 var BROWSERSTACK_TESTHUB_UUID = "BROWSERSTACK_TESTHUB_UUID";
@@ -214,30 +224,71 @@ var BStackLogger = class {
   }
 };
 
-// src/performance-tester.ts
-var PerformanceTester = class {
+// src/fetchWrapper.ts
+var ResponseError = class extends Error {
+  response;
+  constructor(message, res) {
+    super(message);
+    this.response = res;
+  }
+};
+async function fetchWrap(input, init) {
+  const res = await fetch(input, init);
+  if (!res.ok) {
+    throw new ResponseError(`Error response from server ${res.status}:  ${await res.text()}`, res);
+  }
+  return res;
+}
+
+// src/instrumentation/performance/performance-tester.ts
+var PerformanceTester = class _PerformanceTester {
   static _observer;
   static _csvWriter;
   static _events = [];
+  static _measuredEvents = [];
   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 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 });
+    }
     this._observer = new PerformanceObserver((list) => {
-      list.getEntries().forEach((entry) => {
-        this._events.push(entry);
-      });
+      list.getEntries().filter((entry) => entry.entryType === "measure").forEach(
+        (entry) => {
+          let finalEntry = entry;
+          finalEntry = entry.toJSON();
+          if (this.details[entry.name]) {
+            finalEntry = Object.assign(finalEntry, this.details[entry.name]);
+          }
+          delete this.details[entry.name];
+          this._measuredEvents.push(finalEntry);
+        }
+      );
+      if (process.env[PERF_MEASUREMENT_ENV]) {
+        list.getEntries().forEach((entry) => this._events.push(entry));
+      }
     });
-    this._observer.observe({ buffered: true, entryTypes: ["function"] });
+    const entryTypes = ["measure"];
+    if (process.env[PERF_MEASUREMENT_ENV]) {
+      entryTypes.push("function");
+    }
+    this._observer.observe({ buffered: true, entryTypes });
     this.started = true;
-    this._csvWriter = createObjectCsvWriter({
-      path: csvName,
-      header: [
-        { id: "name", title: "Function Name" },
-        { id: "time", title: "Execution Time (ms)" }
-      ]
-    });
-  }
-  static getPerformance() {
-    return performance;
+    if (process.env[PERF_MEASUREMENT_ENV]) {
+      this._csvWriter = createObjectCsvWriter({
+        path: csvName,
+        header: [
+          { id: "name", title: "Function Name" },
+          { id: "time", title: "Execution Time (ms)" }
+        ]
+      });
+    }
   }
   static calculateTimes(methods) {
     const times = {};
@@ -250,26 +301,35 @@ var PerformanceTester = class {
     const timeTaken = methods.reduce((a, c) => {
       return times[c] + (a || 0);
     }, 0);
-    BStackLogger.info(`Time for ${methods} is ${timeTaken}`);
+    BStackLogger.debug(`Time for ${methods} is ${timeTaken}`);
     return timeTaken;
   }
   static async stopAndGenerate(filename = "performance-own.html") {
     if (!this.started) {
       return;
     }
-    await sleep(2e3);
+    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)}`);
+    }
     this._observer.disconnect();
+    if (!process.env[PERF_MEASUREMENT_ENV]) {
+      return;
+    }
+    await _PerformanceTester.sleep(2e3);
     this.started = false;
     this.generateCSV(this._events);
     const content = this.generateReport(this._events);
-    const path6 = process.cwd() + "/" + filename;
-    fs2.writeFile(path6, content, (err) => {
-      if (err) {
-        BStackLogger.error(`Error in writing html ${err}`);
-        return;
-      }
-      BStackLogger.info(`Performance report is at ${path6}`);
-    });
+    const dir = path2.join(process.cwd(), filename);
+    try {
+      await fsPromise.writeFile(dir, content);
+      BStackLogger.info(`Performance report is at ${path2}`);
+    } catch (err) {
+      BStackLogger.error(`Error in writing html ${util.format(err)}`);
+    }
   }
   static generateReport(entries) {
     let html = "<!DOCTYPE html><html><head><title>Performance Report</title></head><body>";
@@ -301,6 +361,221 @@ var PerformanceTester = class {
     });
     this._csvWriter.writeRecords(dat).then(() => BStackLogger.info("Performance CSV report generated successfully")).catch((error) => console.error(error));
   }
+  static Measure(label, details = {}) {
+    const self = this;
+    return (target, key, descriptor) => {
+      const originalMethod = descriptor.value;
+      if (descriptor.value) {
+        descriptor.value = function(...args) {
+          return _PerformanceTester.measure.apply(self, [label, originalMethod, { methodName: key.toString(), ...details }, args, this]);
+        };
+      }
+    };
+  }
+  static measureWrapper(name, fn, details = {}) {
+    const self = this;
+    details.worker = _PerformanceTester.getProcessId();
+    details.testName = _PerformanceTester.scenarioThatRan && _PerformanceTester.scenarioThatRan[_PerformanceTester.scenarioThatRan.length - 1];
+    details.platform = _PerformanceTester.browser?.sessionId;
+    return function(...args) {
+      return self.measure(name, fn, details, args);
+    };
+  }
+  static isEnabled() {
+    return !(process.env.BROWSERSTACK_SDK_INSTRUMENTATION === "false");
+  }
+  static measure(label, fn, details = {}, args, thisArg = null) {
+    if (!this.started || !this.isEnabled()) {
+      return fn.apply(thisArg, args);
+    }
+    _PerformanceTester.start(label);
+    if (this.details) {
+      this.details[label] = details;
+    }
+    try {
+      const returnVal = fn.apply(thisArg, args);
+      if (returnVal instanceof Promise) {
+        return new Promise((resolve, reject) => {
+          returnVal.then((v) => {
+            _PerformanceTester.end(label);
+            resolve(v);
+          }).catch((e) => {
+            _PerformanceTester.end(label, false, util.format(e));
+            reject(e);
+          });
+        });
+      }
+      _PerformanceTester.end(label);
+      return returnVal;
+    } catch (er) {
+      _PerformanceTester.end(label, false, util.format(er));
+      throw er;
+    }
+  }
+  static start(event) {
+    const finalEvent = event + "-start";
+    if (this.eventsMap[finalEvent]) {
+      return;
+    }
+    performance.mark(finalEvent);
+    this.eventsMap[finalEvent] = 1;
+  }
+  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({
+      worker: _PerformanceTester.getProcessId(),
+      platform: _PerformanceTester.browser?.sessionId,
+      testName: _PerformanceTester.scenarioThatRan && _PerformanceTester.scenarioThatRan[_PerformanceTester.scenarioThatRan.length - 1]
+    }, details), this.details[event] || {}));
+  }
+  static getProcessId() {
+    return `${process.pid}-${worker.threadId}`;
+  }
+  static sleep = (ms = 100) => new Promise((resolve) => setTimeout(resolve, ms));
+  static async uploadEventsData() {
+    try {
+      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));
+        measures = (await Promise.all(files.map((file) => fsPromise.readFile(file, "utf-8")))).map((el) => `[${el.slice(0, -1)}]`).map((el) => JSON.parse(el)).flat();
+      }
+      if (this._measuredEvents.length > 0) {
+        measures = measures.concat(this._measuredEvents);
+      }
+      const date = /* @__PURE__ */ new Date();
+      const options = {
+        timeZone: "UTC",
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        fractionalSecondDigits: 3,
+        // To include microseconds
+        hour12: false
+      };
+      const formattedDate = new Intl.DateTimeFormat("en-GB", options).formatToParts(date).map(({ type: type3, value }) => type3 === "timeZoneName" ? "Z" : value).join("").replace(",", "T");
+      const payload = {
+        event_type: "sdk_events",
+        data: {
+          testhub_uuid: process.env.PERF_TESTHUB_UUID || process.env.SDK_RUN_ID,
+          created_day: formattedDate,
+          event_name: "SDKFeaturePerformance",
+          user_data: process.env.PERF_USER_NAME,
+          host_info: JSON.stringify({
+            hostname: hostname(),
+            platform: platform(),
+            type: type(),
+            version: version(),
+            arch: arch()
+          }),
+          event_json: { measures, sdkRunId: process.env.SDK_RUN_ID }
+        }
+      };
+      const result = await fetchWrap(`${EDS_URL}/send_sdk_events`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(payload)
+      });
+      BStackLogger.debug(`Successfully uploaded performance events ${util.format(await result.text())}`);
+    } catch (er) {
+      BStackLogger.debug(`Failed to upload performance events ${util.format(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));
+        }
+      }
+    } catch (er) {
+      BStackLogger.debug(`Failed to delete performance related files ${util.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"
+};
+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
@@ -773,7 +1048,7 @@ var UsageStats = class _UsageStats {
 var usageStats_default = UsageStats;
 
 // src/scripts/accessibility-scripts.ts
-import path2 from "node:path";
+import path3 from "node:path";
 import fs3 from "node:fs";
 import os from "node:os";
 var AccessibilityScripts = class _AccessibilityScripts {
@@ -788,7 +1063,7 @@ var AccessibilityScripts = class _AccessibilityScripts {
   // don't allow to create instances from it other than through `checkAndGetInstance`
   constructor() {
     this.browserstackFolderPath = this.getWritableDir();
-    this.commandsPath = path2.join(this.browserstackFolderPath, "commands.json");
+    this.commandsPath = path3.join(this.browserstackFolderPath, "commands.json");
   }
   static checkAndGetInstance() {
     if (!_AccessibilityScripts.instance) {
@@ -800,7 +1075,7 @@ var AccessibilityScripts = class _AccessibilityScripts {
   /* eslint-disable @typescript-eslint/no-unused-vars */
   getWritableDir() {
     const orderedPaths = [
-      path2.join(os.homedir(), ".browserstack"),
+      path3.join(os.homedir(), ".browserstack"),
       process.cwd(),
       os.tmpdir()
     ];
@@ -878,7 +1153,7 @@ function processError(error, fn, args) {
   try {
     argsString = JSON.stringify(args);
   } catch {
-    argsString = util.inspect(args, { depth: 2 });
+    argsString = util2.inspect(args, { depth: 2 });
   }
   CrashReporter.uploadCrashReport(`Error in executing ${fn.name} with args ${argsString} : ${error}`, error && error.stack || "unknown error");
 }
@@ -887,7 +1162,7 @@ function o11yErrorHandler(fn) {
     try {
       let functionToHandle = fn;
       if (process.env[PERF_MEASUREMENT_ENV]) {
-        functionToHandle = PerformanceTester.getPerformance().timerify(functionToHandle);
+        functionToHandle = performance2.timerify(functionToHandle);
       }
       const result = functionToHandle(...args);
       if (result instanceof Promise) {
@@ -960,7 +1235,7 @@ var processLaunchBuildResponse = (response, options) => {
     processAccessibilityResponse(response);
   }
 };
-var launchTestSession = o11yErrorHandler(async function launchTestSession2(options, config, bsConfig, bStackConfig) {
+var launchTestSession = PerformanceTester.measureWrapper(TESTHUB_EVENTS.START, o11yErrorHandler(async function launchTestSession2(options, config, bsConfig, bStackConfig) {
   const launchBuildUsage = usageStats_default.getInstance().launchBuildUsage;
   launchBuildUsage.triggered();
   const data = {
@@ -971,11 +1246,11 @@ var launchTestSession = o11yErrorHandler(async function launchTestSession2(optio
     started_at: (/* @__PURE__ */ new Date()).toISOString(),
     tags: getObservabilityBuildTags(options, bsConfig.buildTag),
     host_info: {
-      hostname: hostname(),
-      platform: platform(),
-      type: type(),
-      version: version(),
-      arch: arch()
+      hostname: hostname2(),
+      platform: platform2(),
+      type: type2(),
+      version: version2(),
+      arch: arch2()
     },
     ci_info: getCiInfo(),
     build_run_identifier: process.env.BROWSERSTACK_BUILD_RUN_IDENTIFIER,
@@ -1027,6 +1302,7 @@ var launchTestSession = o11yErrorHandler(async function launchTestSession2(optio
     if (jsonResponse.build_hashed_id) {
       process.env[BROWSERSTACK_TESTHUB_UUID] = jsonResponse.build_hashed_id;
       testOpsConfig_default.getInstance().buildHashedId = jsonResponse.build_hashed_id;
+      BStackLogger.info(`Testhub started with id: ${testOpsConfig_default.getInstance()?.buildHashedId}`);
     }
     processLaunchBuildResponse(jsonResponse, options);
     launchBuildUsage.success();
@@ -1038,8 +1314,162 @@ var launchTestSession = o11yErrorHandler(async function launchTestSession2(optio
       return;
     }
   }
+}));
+var isAccessibilityAutomationSession = (accessibilityFlag) => {
+  try {
+    const hasA11yJwtToken = typeof process.env.BSTACK_A11Y_JWT === "string" && process.env.BSTACK_A11Y_JWT.length > 0 && process.env.BSTACK_A11Y_JWT !== "null" && process.env.BSTACK_A11Y_JWT !== "undefined";
+    return accessibilityFlag && hasA11yJwtToken;
+  } catch (error) {
+    BStackLogger.debug(`Exception in verifying the Accessibility session with error : ${error}`);
+  }
+  return false;
+};
+var isAppAccessibilityAutomationSession = (accessibilityFlag, isAppAutomate) => {
+  const accessibilityAutomation = isAccessibilityAutomationSession(accessibilityFlag);
+  return accessibilityAutomation && isAppAutomate;
+};
+var formatString = (template, ...values) => {
+  let i = 0;
+  if (template === null) {
+    return "";
+  }
+  return template.replace(/%s/g, () => {
+    const value = values[i++];
+    return value !== null && value !== void 0 ? value : "";
+  });
+};
+var _getParamsForAppAccessibility = (commandName) => {
+  return {
+    "thTestRunUuid": process.env.TEST_ANALYTICS_ID,
+    "thBuildUuid": process.env.BROWSERSTACK_TESTHUB_UUID,
+    "thJwtToken": process.env.BROWSERSTACK_TESTHUB_JWT,
+    "authHeader": process.env.BSTACK_A11Y_JWT,
+    "scanTimestamp": Date.now(),
+    "method": commandName
+  };
+};
+var performA11yScan = async (isAppAutomate, browser, isBrowserStackSession, isAccessibility, commandName) => {
+  if (!isBrowserStackSession) {
+    BStackLogger.warn("Not a BrowserStack Automate session, cannot perform Accessibility scan.");
+    return;
+  }
+  if (!isAccessibilityAutomationSession(isAccessibility)) {
+    BStackLogger.warn("Not an Accessibility Automation session, cannot perform Accessibility scan.");
+    return;
+  }
+  try {
+    if (isAppAccessibilityAutomationSession(isAccessibility, isAppAutomate)) {
+      const results = await browser.execute(formatString(accessibility_scripts_default.performScan, JSON.stringify(_getParamsForAppAccessibility(commandName))), {});
+      BStackLogger.debug(util2.format(results));
+      return results;
+    }
+    if (accessibility_scripts_default.performScan) {
+      const results = await executeAccessibilityScript(browser, accessibility_scripts_default.performScan, { method: commandName || "" });
+      return results;
+    }
+    BStackLogger.error("AccessibilityScripts.performScan is null");
+    return;
+  } catch (err) {
+    BStackLogger.error("Accessibility Scan could not be performed : " + err);
+    return;
+  }
+};
+var getA11yResults = PerformanceTester.measureWrapper(A11Y_EVENTS.GET_RESULTS, async (isAppAutomate, browser, isBrowserStackSession, isAccessibility) => {
+  if (!isBrowserStackSession) {
+    BStackLogger.warn("Not a BrowserStack Automate session, cannot retrieve Accessibility results.");
+    return [];
+  }
+  if (!isAccessibilityAutomationSession(isAccessibility)) {
+    BStackLogger.warn("Not an Accessibility Automation session, cannot retrieve Accessibility results.");
+    return [];
+  }
+  try {
+    BStackLogger.debug("Performing scan before getting results");
+    await performA11yScan(isAppAutomate, browser, isBrowserStackSession, isAccessibility);
+    if (accessibility_scripts_default.getResults) {
+      const results = await executeAccessibilityScript(browser, accessibility_scripts_default.getResults);
+      return results;
+    }
+    BStackLogger.error("AccessibilityScripts.getResults is null");
+    return [];
+  } catch (error) {
+    BStackLogger.error("No accessibility results were found.");
+    BStackLogger.debug(`getA11yResults Failed. Error: ${error}`);
+    return [];
+  }
 });
-var stopBuildUpstream = o11yErrorHandler(async function stopBuildUpstream2() {
+var getAppA11yResults = PerformanceTester.measureWrapper(A11Y_EVENTS.GET_RESULTS, async (isAppAutomate, browser, isBrowserStackSession, isAccessibility, sessionId) => {
+  if (!isBrowserStackSession) {
+    return [];
+  }
+  if (!isAppAccessibilityAutomationSession(isAccessibility, isAppAutomate)) {
+    BStackLogger.warn("Not an Accessibility Automation session, cannot retrieve Accessibility results summary.");
+    return [];
+  }
+  try {
+    const apiUrl = `${APP_ALLY_ENDPOINT}/${APP_ALLY_ISSUES_ENDPOINT}`;
+    const apiRespone = await getAppA11yResultResponse(apiUrl, isAppAutomate, browser, isBrowserStackSession, isAccessibility, sessionId);
+    const result = apiRespone?.data?.data?.issues;
+    BStackLogger.debug(`Polling Result: ${JSON.stringify(result)}`);
+    return result;
+  } catch (error) {
+    BStackLogger.error("No accessibility summary was found.");
+    BStackLogger.debug(`getAppA11yResults Failed. Error: ${error}`);
+    return [];
+  }
+});
+var getAppA11yResultsSummary = PerformanceTester.measureWrapper(A11Y_EVENTS.GET_RESULTS_SUMMARY, async (isAppAutomate, browser, isBrowserStackSession, isAccessibility, sessionId) => {
+  if (!isBrowserStackSession) {
+    return {};
+  }
+  if (!isAppAccessibilityAutomationSession(isAccessibility, isAppAutomate)) {
+    BStackLogger.warn("Not an Accessibility Automation session, cannot retrieve Accessibility results summary.");
+    return {};
+  }
+  try {
+    const apiUrl = `${APP_ALLY_ENDPOINT}/${APP_ALLY_ISSUES_SUMMARY_ENDPOINT}`;
+    const apiRespone = await getAppA11yResultResponse(apiUrl, isAppAutomate, browser, isBrowserStackSession, isAccessibility, sessionId);
+    const result = apiRespone?.data?.data?.summary;
+    BStackLogger.debug(`Polling Result: ${JSON.stringify(result)}`);
+    return result;
+  } catch {
+    BStackLogger.error("No accessibility summary was found.");
+    return {};
+  }
+});
+var getAppA11yResultResponse = async (apiUrl, isAppAutomate, browser, isBrowserStackSession, isAccessibility, sessionId) => {
+  BStackLogger.debug("Performing scan before getting results summary");
+  await performA11yScan(isAppAutomate, browser, isBrowserStackSession, isAccessibility);
+  const upperTimeLimit = process.env.BSTACK_A11Y_POLLING_TIMEOUT ? Date.now() + parseInt(process.env.BSTACK_A11Y_POLLING_TIMEOUT) * 1e3 : Date.now() + 3e4;
+  const params = { test_run_uuid: process.env.TEST_ANALYTICS_ID, session_id: sessionId, timestamp: Date.now() };
+  const header = { Authorization: `Bearer ${process.env.BSTACK_A11Y_JWT}` };
+  const apiRespone = await pollApi(apiUrl, params, header, upperTimeLimit);
+  BStackLogger.debug(`Polling Result: ${JSON.stringify(apiRespone)}`);
+  return apiRespone;
+};
+var getA11yResultsSummary = PerformanceTester.measureWrapper(A11Y_EVENTS.GET_RESULTS_SUMMARY, async (isAppAutomate, browser, isBrowserStackSession, isAccessibility) => {
+  if (!isBrowserStackSession) {
+    return {};
+  }
+  if (!isAccessibilityAutomationSession(isAccessibility)) {
+    BStackLogger.warn("Not an Accessibility Automation session, cannot retrieve Accessibility results summary.");
+    return {};
+  }
+  try {
+    BStackLogger.debug("Performing scan before getting results summary");
+    await performA11yScan(isAppAutomate, browser, isBrowserStackSession, isAccessibility);
+    if (accessibility_scripts_default.getResultsSummary) {
+      const summaryResults = await executeAccessibilityScript(browser, accessibility_scripts_default.getResultsSummary);
+      return summaryResults;
+    }
+    BStackLogger.error("AccessibilityScripts.getResultsSummary is null");
+    return {};
+  } catch {
+    BStackLogger.error("No accessibility summary was found.");
+    return {};
+  }
+});
+var stopBuildUpstream = PerformanceTester.measureWrapper(TESTHUB_EVENTS.STOP, o11yErrorHandler(async function stopBuildUpstream2() {
   const stopBuildUsage = usageStats_default.getInstance().stopBuildUsage;
   stopBuildUsage.triggered();
   if (!process.env[TESTOPS_BUILD_COMPLETED_ENV]) {
@@ -1084,7 +1514,7 @@ var stopBuildUpstream = o11yErrorHandler(async function stopBuildUpstream2() {
       message: error.message
     };
   }
-});
+}));
 function getCiInfo() {
   const env = process.env;
   if (typeof env.JENKINS_URL === "string" && env.JENKINS_URL.length > 0 || typeof env.JENKINS_HOME === "string" && env.JENKINS_HOME.length > 0) {
@@ -1383,7 +1813,7 @@ function getObservabilityBuild(options, bstackBuildName) {
   if (options.testObservabilityOptions && options.testObservabilityOptions.buildName) {
     return options.testObservabilityOptions.buildName;
   }
-  return bstackBuildName || path3.basename(path3.resolve(process.cwd()));
+  return bstackBuildName || path4.basename(path4.resolve(process.cwd()));
 }
 function getObservabilityBuildTags(options, bstackBuildTag) {
   if (process.env.TEST_OBSERVABILITY_BUILD_TAG) {
@@ -1412,7 +1842,6 @@ var patchConsoleLogs = o11yErrorHandler(() => {
     }
   });
 });
-var sleep = (ms = 100) => new Promise((resolve) => setTimeout(resolve, ms));
 var getPlatformVersion = o11yErrorHandler(function getPlatformVersion2(caps) {
   if (!caps) {
     return void 0;
@@ -1475,36 +1904,104 @@ function checkAndTruncateVCSInfo(gitMetaData) {
   }
   return gitMetaData;
 }
+async function pollApi(url, params, headers, upperLimit, startTime = Date.now()) {
+  params.timestamp = Math.round(Date.now() / 1e3);
+  BStackLogger.debug(`current timestamp ${params.timestamp}`);
+  try {
+    const response = await makeGetRequest(url, params, headers);
+    const responseData = await response.json();
+    return {
+      data: responseData,
+      headers: response.headers,
+      message: "Polling succeeded."
+    };
+  } catch (error) {
+    if (error.response && error.response.status === 404) {
+      const nextPollTime = parseInt(error.response.headers.get("next_poll_time"), 10) * 1e3;
+      BStackLogger.debug(`timeInMillis ${nextPollTime}`);
+      if (isNaN(nextPollTime)) {
+        BStackLogger.warn("Invalid or missing `nextPollTime` header. Stopping polling.");
+        return {
+          data: {},
+          headers: error.response.headers,
+          message: "Invalid nextPollTime header value. Polling stopped."
+        };
+      }
+      const elapsedTime = nextPollTime - Date.now();
+      BStackLogger.debug(
+        `elapsedTime ${elapsedTime} timeInMillis ${nextPollTime} upperLimit ${upperLimit}`
+      );
+      if (nextPollTime > upperLimit) {
+        BStackLogger.warn("Polling stopped due to upper time limit.");
+        return {
+          data: {},
+          headers: error.response.headers,
+          message: "Polling stopped due to upper time limit."
+        };
+      }
+      BStackLogger.debug(`Polling again in ${elapsedTime}ms with params:`, params);
+      await new Promise((resolve) => setTimeout(resolve, elapsedTime));
+      return pollApi(url, params, headers, upperLimit, startTime);
+    } else if (error.response) {
+      let errorMessage = error.response.statusText;
+      try {
+        const parsedError = JSON.parse(error.response.json());
+        errorMessage = parsedError.message;
+      } catch {
+        BStackLogger.debug(`Error parsing pollApi request body ${error.response.body}`);
+        errorMessage = "Unknown error";
+      }
+      throw {
+        data: {},
+        headers: {},
+        message: errorMessage
+      };
+    } else {
+      BStackLogger.error(`Unexpected error occurred: ${error}`);
+      return { data: {}, headers: {}, message: "Unexpected error occurred." };
+    }
+  }
+}
+async function makeGetRequest(url, params, headers) {
+  const urlObj = new URL(url);
+  Object.keys(params).forEach((key) => urlObj.searchParams.append(key, params[key]));
+  const response = await fetch(urlObj.toString(), {
+    method: "GET",
+    headers
+  });
+  if (!response.ok) {
+    const error = new Error("Request failed");
+    error.response = response;
+    throw error;
+  }
+  return response;
+}
+async function executeAccessibilityScript(browser, fnBody, arg) {
+  return browser.execute(
+    `return (function (...bstackSdkArgs) {
+            return new Promise((resolve, reject) => {
+                const data = bstackSdkArgs[0];
+                bstackSdkArgs.push(resolve);
+                ${fnBody.replace(/arguments/g, "bstackSdkArgs")}
+            });
+        })(${arg ? JSON.stringify(arg) : ""})`
+  );
+}
 
 // src/cleanup.ts
 import fs7 from "node:fs";
+import util4 from "node:util";
 
 // src/instrumentation/funnelInstrumentation.ts
 import os2 from "node:os";
-import util2, { format as format2 } from "node:util";
-import path5 from "node:path";
+import util3, { format as format2 } from "node:util";
+import path6 from "node:path";
 import fs6 from "node:fs";
 
 // src/data-store.ts
-import path4 from "node:path";
+import path5 from "node:path";
 import fs5 from "node:fs";
-var workersDataDirPath = path4.join(process.cwd(), "logs", "worker_data");
-
-// src/fetchWrapper.ts
-var ResponseError = class extends Error {
-  response;
-  constructor(message, res) {
-    super(message);
-    this.response = res;
-  }
-};
-async function fetchWrap(input, init) {
-  const res = await fetch(input, init);
-  if (!res.ok) {
-    throw new ResponseError(`Error response from server ${res.status}:  ${await res.text()}`, res);
-  }
-  return res;
-}
+var workersDataDirPath = path5.join(process.cwd(), "logs", "worker_data");
 
 // src/instrumentation/funnelInstrumentation.ts
 function redactCredentialsFromFunnelData(data) {
@@ -1521,7 +2018,7 @@ function redactCredentialsFromFunnelData(data) {
 async function fireFunnelRequest(data) {
   const { userName, accessKey } = data;
   redactCredentialsFromFunnelData(data);
-  BStackLogger.debug("Sending SDK event with data " + util2.inspect(data, { depth: 6 }));
+  BStackLogger.debug("Sending SDK event with data " + util3.inspect(data, { depth: 6 }));
   const encodedAuth = Buffer.from(`${userName}:${accessKey}`, "utf8").toString("base64");
   const response = await fetchWrap(FUNNEL_INSTRUMENTATION_URL, {
     method: "POST",
@@ -1555,6 +2052,13 @@ var BStackCleanup = class _BStackCleanup {
       const error = err;
       BStackLogger.error(error);
     }
+    try {
+      if (process.argv.includes("--performanceData")) {
+        await PerformanceTester.uploadEventsData();
+      }
+    } catch (er) {
+      BStackLogger.debug(`Error in sending events data ${util4.format(er)}`);
+    }
   }
   static async executeObservabilityCleanup(funnelData) {
     if (!process.env[BROWSERSTACK_TESTHUB_JWT]) {