appium-adb 14.0.2 → 14.0.4

package/build/lib/tools/system-calls.js

@@ -77,7 +77,7 @@ const path_1 = __importDefault(require("path"));
 const logger_js_1 = require("../logger.js");
 const bluebird_1 = __importDefault(require("bluebird"));
 const support_1 = require("@appium/support");
-const helpers_1 = require("../helpers");
+const helpers_js_1 = require("../helpers.js");
 const teen_process_1 = require("teen_process");
 const asyncbox_1 = require("asyncbox");
 const lodash_1 = __importDefault(require("lodash"));
@@ -103,22 +103,12 @@ const SDK_BINARY_ROOTS = [
 const MIN_DELAY_ADB_API_LEVEL = 28;
 const REQUIRED_SERVICES = ['activity', 'package', 'window'];
 const MAX_SHELL_BUFFER_LENGTH = 1000;
-/**
- * Retrieve full path to the given binary.
- *
- * @this {import('../adb.js').ADB}
- * @param {string} binaryName - The name of the binary.
- * @return {Promise<string>} Full path to the given binary including current SDK root.
- */
-async function getSdkBinaryPath(binaryName) {
-    return await this.getBinaryFromSdkRoot(binaryName);
-}
+// Private methods (defined early as they're used by public methods)
 /**
  * Retrieve full binary name for the current operating system.
  *
- * @param {string} binaryName - simple binary name, for example 'android'.
- * @return {string} Formatted binary name depending on the current platform,
- *                  for example, 'android.bat' on Windows.
+ * @param binaryName - The name of the binary
+ * @returns The binary name with appropriate extension for the current OS
  */
 function _getBinaryNameForOS(binaryName) {
     if (!support_1.system.isWindows()) {
@@ -132,30 +122,61 @@ function _getBinaryNameForOS(binaryName) {
     }
     return binaryName;
 }
+/**
+ * Returns the Android binaries locations
+ *
+ * @param sdkRoot - The Android SDK root directory path
+ * @param fullBinaryName - The full name of the binary (with extension)
+ * @returns Array of possible binary location paths
+ */
+function getSdkBinaryLocationCandidates(sdkRoot, fullBinaryName) {
+    return SDK_BINARY_ROOTS.map((x) => path_1.default.resolve(sdkRoot, ...(lodash_1.default.isArray(x) ? x : [x]), fullBinaryName));
+}
+/**
+ * Get the path to the openssl binary for the current operating system
+ *
+ * @returns The full path to the openssl binary
+ * @throws {Error} If openssl is not found in PATH
+ */
+async function getOpenSslForOs() {
+    const binaryName = `openssl${support_1.system.isWindows() ? '.exe' : ''}`;
+    try {
+        return await support_1.fs.which(binaryName);
+    }
+    catch {
+        throw new Error('The openssl tool must be installed on the system and available on the path');
+    }
+}
+// Public methods
+/**
+ * Retrieve full path to the given binary.
+ *
+ * @param binaryName - The name of the binary
+ * @returns The full path to the binary
+ */
+async function getSdkBinaryPath(binaryName) {
+    return await this.getBinaryFromSdkRoot(binaryName);
+}
 exports.getBinaryNameForOS = lodash_1.default.memoize(_getBinaryNameForOS);
 /**
  * Retrieve full path to the given binary and caches it into `binaries`
  * property of the current ADB instance.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} binaryName - Simple name of a binary file.
- * @return {Promise<string>} Full path to the given binary. The method tries
- *                  to enumerate all the known locations where the binary
- *                  might be located and stops the search as soon as the first
- *                  match is found on the local file system.
- * @throws {Error} If the binary with given name is not present at any
- *                 of known locations or Android SDK is not installed on the
- *                 local file system.
+ * @param binaryName - The name of the binary
+ * @returns The full path to the binary
+ * @throws {Error} If SDK root is not set or binary cannot be found
  */
 async function getBinaryFromSdkRoot(binaryName) {
-    if (( /** @type {import('./types').StringRecord} */(this.binaries))[binaryName]) {
-        return ( /** @type {import('./types').StringRecord} */(this.binaries))[binaryName];
+    if (this.binaries?.[binaryName]) {
+        return this.binaries[binaryName];
     }
     const fullBinaryName = this.getBinaryNameForOS(binaryName);
-    const binaryLocs = getSdkBinaryLocationCandidates(
-    /** @type {string} */ (this.sdkRoot), fullBinaryName);
+    if (!this.sdkRoot) {
+        throw new Error('SDK root is not set');
+    }
+    const binaryLocs = getSdkBinaryLocationCandidates(this.sdkRoot, fullBinaryName);
     // get subpaths for currently installed build tool directories
-    let buildToolsDirs = await (0, exports.getBuildToolsDirs)(/** @type {string} */ (this.sdkRoot));
+    let buildToolsDirs = await (0, exports.getBuildToolsDirs)(this.sdkRoot);
     if (this.buildToolsVersion) {
         buildToolsDirs = buildToolsDirs
             .filter((x) => path_1.default.basename(x) === this.buildToolsVersion);
@@ -184,38 +205,23 @@ async function getBinaryFromSdkRoot(binaryName) {
             `installed at '${this.sdkRoot}'?`);
     }
     logger_js_1.log.info(`Using '${fullBinaryName}' from '${binaryLoc}'`);
-    ( /** @type {import('./types').StringRecord} */(this.binaries))[binaryName] = binaryLoc;
+    if (!this.binaries) {
+        this.binaries = {};
+    }
+    this.binaries[binaryName] = binaryLoc;
     return binaryLoc;
 }
-/**
- *  Returns the Android binaries locations
- *
- * @param {string} sdkRoot The path to Android SDK root.
- * @param {string} fullBinaryName The name of full binary name.
- * @return {string[]} The list of SDK_BINARY_ROOTS paths
- *                          with sdkRoot and fullBinaryName.
- */
-function getSdkBinaryLocationCandidates(sdkRoot, fullBinaryName) {
-    return SDK_BINARY_ROOTS.map((x) => path_1.default.resolve(sdkRoot, ...(lodash_1.default.isArray(x) ? x : [x]), fullBinaryName));
-}
 /**
  * Retrieve full path to the given binary.
  * This method does not have cache.
  *
- * @param {string} binaryName - Simple name of a binary file.
- *                              e.g. 'adb', 'android'
- * @return {Promise<string>} Full path to the given binary. The method tries
- *                  to enumerate all the known locations where the binary
- *                  might be located and stops the search as soon as the first
- *                  match is found on the local file system.
- *                  e.g. '/Path/To/Android/sdk/platform-tools/adb'
- * @throws {Error} If the binary with given name is not present at any
- *                 of known locations or Android SDK is not installed on the
- *                 local file system.
+ * @param binaryName - The name of the binary
+ * @returns The full path to the binary
+ * @throws {Error} If binary cannot be found in the Android SDK
  */
 async function getAndroidBinaryPath(binaryName) {
     const fullBinaryName = (0, exports.getBinaryNameForOS)(binaryName);
-    const sdkRoot = (0, helpers_1.getSdkRootFromEnv)();
+    const sdkRoot = (0, helpers_js_1.getSdkRootFromEnv)();
     const binaryLocs = getSdkBinaryLocationCandidates(sdkRoot ?? '', fullBinaryName);
     for (const loc of binaryLocs) {
         if (await support_1.fs.exists(loc)) {
@@ -228,21 +234,22 @@ async function getAndroidBinaryPath(binaryName) {
 /**
  * Retrieve full path to a binary file using the standard system lookup tool.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} binaryName - The name of the binary.
- * @return {Promise<string>} Full path to the binary received from 'which'/'where'
- *                  output.
- * @throws {Error} If lookup tool returns non-zero return code.
+ * @param binaryName - The name of the binary
+ * @returns The full path to the binary
+ * @throws {Error} If binary cannot be found in PATH
  */
 async function getBinaryFromPath(binaryName) {
-    if (( /** @type {import('./types').StringRecord} */(this.binaries))[binaryName]) {
-        return ( /** @type {import('./types').StringRecord} */(this.binaries))[binaryName];
+    if (this.binaries?.[binaryName]) {
+        return this.binaries[binaryName];
     }
     const fullBinaryName = this.getBinaryNameForOS(binaryName);
     try {
         const binaryLoc = await support_1.fs.which(fullBinaryName);
         logger_js_1.log.info(`Using '${fullBinaryName}' from '${binaryLoc}'`);
-        ( /** @type {import('./types').StringRecord} */(this.binaries))[binaryName] = binaryLoc;
+        if (!this.binaries) {
+            this.binaries = {};
+        }
+        this.binaries[binaryName] = binaryLoc;
         return binaryLoc;
     }
     catch {
@@ -253,11 +260,9 @@ async function getBinaryFromPath(binaryName) {
 /**
  * Retrieve the list of devices visible to adb.
  *
- * @this {import('../adb.js').ADB}
- * @param {import('./types').ConnectedDevicesOptions} [opts={}] - Additional options mapping.
- * @return {Promise<import('./types').Device[]>} The list of devices or an empty list if
- *                          no devices are connected.
- * @throws {Error} If there was an error while listing devices.
+ * @param opts - Options for device retrieval
+ * @returns Array of connected devices
+ * @throws {Error} If adb devices command fails or returns unexpected output
  */
 async function getConnectedDevices(opts = {}) {
     logger_js_1.log.debug('Getting connected devices');
@@ -270,7 +275,8 @@ async function getConnectedDevices(opts = {}) {
         ({ stdout } = await (0, teen_process_1.exec)(this.executable.path, args));
     }
     catch (e) {
-        throw new Error(`Error while getting connected devices. Original error: ${e.message}`);
+        const error = e;
+        throw new Error(`Error while getting connected devices. Original error: ${error.message}`);
     }
     const listHeader = 'List of devices';
     // expecting adb devices to return output as
@@ -282,7 +288,7 @@ async function getConnectedDevices(opts = {}) {
     }
     // slicing output we care about
     stdout = stdout.slice(startingIndex);
-    let excludedLines = [listHeader, 'adb server', '* daemon'];
+    const excludedLines = [listHeader, 'adb server', '* daemon'];
     if (!this.allowOfflineDevices) {
         excludedLines.push('offline');
     }
@@ -315,16 +321,14 @@ async function getConnectedDevices(opts = {}) {
 /**
  * Retrieve the list of devices visible to adb within the given timeout.
  *
- * @this {import('../adb.js').ADB}
- * @param {number} timeoutMs - The maximum number of milliseconds to get at least
- *                             one list item.
- * @return {Promise<import('./types').Device[]>} The list of connected devices.
- * @throws {Error} If no connected devices can be detected within the given timeout.
+ * @param timeoutMs - Maximum time to wait for devices (default: 20000ms)
+ * @returns Array of connected devices
+ * @throws {Error} If no devices are found within the timeout period
  */
 async function getDevicesWithRetry(timeoutMs = 20000) {
     logger_js_1.log.debug('Trying to find connected Android devices');
     try {
-        let devices;
+        let devices = [];
         await (0, asyncbox_1.waitForCondition)(async () => {
             try {
                 devices = await this.getConnectedDevices();
@@ -334,8 +338,9 @@ async function getDevicesWithRetry(timeoutMs = 20000) {
                 logger_js_1.log.debug('Could not find online devices');
             }
             catch (err) {
-                logger_js_1.log.debug(err.stack);
-                logger_js_1.log.warn(`Got an unexpected error while fetching connected devices list: ${err.message}`);
+                const error = err;
+                logger_js_1.log.debug(error.stack);
+                logger_js_1.log.warn(`Got an unexpected error while fetching connected devices list: ${error.message}`);
             }
             try {
                 await this.reconnect();
@@ -348,10 +353,11 @@ async function getDevicesWithRetry(timeoutMs = 20000) {
             waitMs: timeoutMs,
             intervalMs: 200,
         });
-        return /** @type {any} */ (devices);
+        return devices;
     }
     catch (e) {
-        if (/Condition unmet/.test(e.message)) {
+        const error = e;
+        if (/Condition unmet/.test(error.message)) {
             throw new Error(`Could not find a connected Android device in ${timeoutMs}ms`);
         }
         else {
@@ -362,13 +368,8 @@ async function getDevicesWithRetry(timeoutMs = 20000) {
 /**
  * Kick current connection from host/device side and make it reconnect
  *
- * @this {import('../adb.js').ADB}
- * @param {string} [target=offline] One of possible targets to reconnect:
- * offline, device or null
- * Providing `null` will cause reconnection to happen from the host side.
- *
- * @throws {Error} If either ADB version is too old and does not support this
- * command or there was a failure during reconnect.
+ * @param target - The target to reconnect (default: 'offline')
+ * @throws {Error} If reconnect command fails
  */
 async function reconnect(target = 'offline') {
     logger_js_1.log.debug(`Reconnecting adb (target ${target})`);
@@ -380,13 +381,12 @@ async function reconnect(target = 'offline') {
         await this.adbExec(args);
     }
     catch (e) {
-        throw new Error(`Cannot reconnect adb. Original error: ${e.stderr || e.message}`);
+        const error = e;
+        throw new Error(`Cannot reconnect adb. Original error: ${error.stderr || error.message}`);
     }
 }
 /**
  * Restart adb server, unless _this.suppressKillServer_ property is true.
- *
- * @this {import('../adb.js').ADB}
  */
 async function restartAdb() {
     if (this.suppressKillServer) {
@@ -404,7 +404,6 @@ async function restartAdb() {
 }
 /**
  * Kill adb server.
- * @this {import('../adb.js').ADB}
  */
 async function killServer() {
     logger_js_1.log.debug(`Killing adb server on port '${this.adbPort}'`);
@@ -416,8 +415,7 @@ async function killServer() {
  * Reset Telnet authentication token.
  * @see {@link http://tools.android.com/recent/emulator2516releasenotes} for more details.
  *
- * @this {import('../adb.js').ADB}
- * @returns {Promise<boolean>} If token reset was successful.
+ * @returns True if token was reset successfully, false otherwise
  */
 exports.resetTelnetAuthToken = lodash_1.default.memoize(async function resetTelnetAuthToken() {
     // The methods is used to remove telnet auth token
@@ -433,7 +431,8 @@ exports.resetTelnetAuthToken = lodash_1.default.memoize(async function resetTeln
         await support_1.fs.writeFile(dstPath, '');
     }
     catch (e) {
-        logger_js_1.log.warn(`Error ${e.message} while resetting the content of ${dstPath}. Ignoring resetting of emulator's telnet authentication token`);
+        const error = e;
+        logger_js_1.log.warn(`Error ${error.message} while resetting the content of ${dstPath}. Ignoring resetting of emulator's telnet authentication token`);
         return false;
     }
     return true;
@@ -441,8 +440,8 @@ exports.resetTelnetAuthToken = lodash_1.default.memoize(async function resetTeln
 /**
  * Execute the given emulator command using _adb emu_ tool.
  *
- * @this {import('../adb.js').ADB}
- * @param {string[]} cmd - The array of rest command line parameters.
+ * @param cmd - Array of command arguments
+ * @throws {Error} If emulator is not connected or command execution fails
  */
 async function adbExecEmu(cmd) {
     await this.verifyEmulatorConnected();
@@ -450,38 +449,25 @@ async function adbExecEmu(cmd) {
     await this.adbExec(['emu', ...cmd]);
 }
 let isExecLocked = false;
-/** @type {{STDOUT: 'stdout', FULL: 'full'}} */
-exports.EXEC_OUTPUT_FORMAT = Object.freeze({
+exports.EXEC_OUTPUT_FORMAT = {
     STDOUT: 'stdout',
     FULL: 'full',
-});
+};
 /**
  * Execute the given adb command.
  *
- * @template {import('teen_process').TeenProcessExecOptions & import('./types').ShellExecOptions & import('./types').SpecialAdbExecOptions} TExecOpts
- * @this {import('../adb.js').ADB}
- * @param {string|string[]} cmd - The array of rest command line parameters
- *                      or a single string parameter.
- * @param {TExecOpts} [opts] Additional options mapping. See
- * {@link https://github.com/appium/node-teen_process}
- * for more details.
- * You can also set the additional `exclusive` param
- * to `true` that assures no other parallel adb commands
- * are going to be executed while the current one is running
- * You can set the `outputFormat` param to `stdout` to receive just the stdout
- * output (default) or `full` to receive the stdout and stderr response from a
- * command with a zero exit code
- * @return {Promise<TExecOpts extends import('./types').TFullOutputOption ? import('teen_process').TeenProcessExecResult : string>}
- * Command's stdout or an object containing stdout and stderr.
- * @throws {Error} If the command returned non-zero exit code.
+ * @param cmd - Command string or array of command arguments
+ * @param opts - Execution options
+ * @returns Command output (string or ExecResult depending on outputFormat)
+ * @throws {Error} If command execution fails or timeout is exceeded
  */
 async function adbExec(cmd, opts) {
     if (!cmd) {
         throw new Error('You need to pass in a command to adbExec()');
     }
-    const optsCopy = lodash_1.default.cloneDeep(opts) ?? /** @type {TExecOpts} */ ({});
+    const optsCopy = lodash_1.default.cloneDeep(opts ?? {});
     // setting default timeout for each command to prevent infinite wait.
-    optsCopy.timeout = optsCopy.timeout || this.adbExecTimeout || helpers_1.DEFAULT_ADB_EXEC_TIMEOUT;
+    optsCopy.timeout = optsCopy.timeout || this.adbExecTimeout || helpers_js_1.DEFAULT_ADB_EXEC_TIMEOUT;
     optsCopy.timeoutCapName = optsCopy.timeoutCapName || 'adbExecTimeout'; // For error message
     const { outputFormat = this.EXEC_OUTPUT_FORMAT.STDOUT } = optsCopy;
     cmd = lodash_1.default.isArray(cmd) ? cmd : [cmd];
@@ -491,37 +477,37 @@ async function adbExec(cmd, opts) {
             const args = [...this.executable.defaultArgs, ...cmd];
             logger_js_1.log.debug(`Running '${this.executable.path} ` +
                 (args.find((arg) => /\s+/.test(arg)) ? support_1.util.quote(args) : args.join(' ')) + `'`);
-            let { stdout, stderr } = await (0, teen_process_1.exec)(this.executable.path, args, optsCopy);
+            const { stdout: rawStdout, stderr } = await (0, teen_process_1.exec)(this.executable.path, args, optsCopy);
             // sometimes ADB prints out weird stdout warnings that we don't want
             // to include in any of the response data, so let's strip it out
-            stdout = stdout.replace(LINKER_WARNING_REGEXP, '').trim();
+            const stdout = rawStdout.replace(LINKER_WARNING_REGEXP, '').trim();
             return outputFormat === this.EXEC_OUTPUT_FORMAT.FULL ? { stdout, stderr } : stdout;
         }
         catch (e) {
-            const errText = `${e.message}, ${e.stdout}, ${e.stderr}`;
+            const error = e;
+            const errText = `${error.message}, ${error.stdout}, ${error.stderr}`;
             if (ADB_RETRY_ERROR_PATTERNS.some((p) => p.test(errText))) {
                 logger_js_1.log.info(`Error sending command, reconnecting device and retrying: ${cmd}`);
-                await (0, asyncbox_1.sleep)(1000);
                 await this.getDevicesWithRetry();
                 // try again one time
-                if (adbRetried) {
+                if (!adbRetried) {
                     adbRetried = true;
                     return await execFunc();
                 }
             }
-            if (e.code === 0 && e.stdout) {
-                return e.stdout.replace(LINKER_WARNING_REGEXP, '').trim();
+            if (error.code === 0 && error.stdout) {
+                return error.stdout.replace(LINKER_WARNING_REGEXP, '').trim();
             }
-            if (lodash_1.default.isNull(e.code)) {
-                e.message = `Error executing adbExec. Original error: '${e.message}'. ` +
+            if (lodash_1.default.isNull(error.code)) {
+                error.message = `Error executing adbExec. Original error: '${error.message}'. ` +
                     `Try to increase the ${optsCopy.timeout}ms adb execution timeout ` +
                     `represented by '${optsCopy.timeoutCapName}' capability`;
             }
             else {
-                e.message = `Error executing adbExec. Original error: '${e.message}'; ` +
-                    `Command output: ${e.stderr || e.stdout || '<empty>'}`;
+                error.message = `Error executing adbExec. Original error: '${error.message}'; ` +
+                    `Command output: ${error.stderr || error.stdout || '<empty>'}`;
             }
-            throw e;
+            throw error;
         }
     };
     if (isExecLocked) {
@@ -547,17 +533,13 @@ async function adbExec(cmd, opts) {
 /**
  * Execute the given command using _adb shell_ prefix.
  *
- * @this {import('../adb.js').ADB}
- * @template {import('./types').ShellExecOptions} TShellExecOpts
- * @param {string|string[]} cmd - The array of rest command line parameters or a single
- *                                      string parameter.
- * @param {TShellExecOpts} [opts] - Additional options mapping.
- * @return {Promise<TShellExecOpts extends import('./types').TFullOutputOption ? import('teen_process').TeenProcessExecResult : string>}
- * Command's stdout.
- * @throws {Error} If the command returned non-zero exit code.
+ * @param cmd - Command string or array of command arguments
+ * @param opts - Execution options
+ * @returns Command output (string or ExecResult depending on outputFormat)
+ * @throws {Error} If command execution fails
  */
 async function shell(cmd, opts) {
-    const { privileged, } = opts ?? /** @type {TShellExecOpts} */ ({});
+    const { privileged, } = opts ?? {};
     const cmdArr = lodash_1.default.isArray(cmd) ? cmd : [cmd];
     const fullCmd = ['shell'];
     if (privileged) {
@@ -576,10 +558,10 @@ async function shell(cmd, opts) {
     return await this.adbExec(fullCmd, opts);
 }
 /**
+ * Create a new ADB subprocess with the given arguments
  *
- * @this {import('../adb.js').ADB}
- * @param {string[]} [args=[]]
- * @returns {import('teen_process').SubProcess}
+ * @param args - Array of command arguments (default: empty array)
+ * @returns A SubProcess instance
  */
 function createSubProcess(args = []) {
     // add the default arguments
@@ -590,28 +572,27 @@ function createSubProcess(args = []) {
 /**
  * Retrieve the current adb port.
  * @todo can probably deprecate this now that the logic is just to read this.adbPort
+ * @deprecated Use this.adbPort instead
  *
- * @this {import('../adb.js').ADB}
- * @return {number} The current adb port number.
+ * @returns The ADB server port number
  */
 function getAdbServerPort() {
-    return /** @type {number} */ (this.adbPort);
+    return this.adbPort;
 }
 /**
- * Retrieve the current emulator port from _adb devives_ output.
+ * Retrieve the current emulator port from _adb devices_ output.
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<number>} The current emulator port.
- * @throws {Error} If there are no connected devices.
+ * @returns The emulator port number
+ * @throws {Error} If no devices are connected or emulator port cannot be found
  */
 async function getEmulatorPort() {
     logger_js_1.log.debug('Getting running emulator port');
-    if (this.emulatorPort !== null) {
-        return /** @type {number} */ (this.emulatorPort);
+    if (!lodash_1.default.isNil(this.emulatorPort)) {
+        return this.emulatorPort;
     }
     try {
-        let devices = await this.getConnectedDevices();
-        let port = this.getPortFromEmulatorString(devices[0].udid);
+        const devices = await this.getConnectedDevices();
+        const port = this.getPortFromEmulatorString(devices[0].udid);
         if (port) {
             return port;
         }
@@ -620,38 +601,35 @@ async function getEmulatorPort() {
         }
     }
     catch (e) {
-        throw new Error(`No devices connected. Original error: ${e.message}`);
+        const error = e;
+        throw new Error(`No devices connected. Original error: ${error.message}`);
     }
 }
 /**
  * Retrieve the current emulator port by parsing emulator name string.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} emStr - Emulator name string.
- * @return {number|false} Either the current emulator port or
- * _false_ if port number cannot be parsed.
+ * @param emStr - The emulator string (e.g., 'emulator-5554')
+ * @returns The port number if found, false otherwise
  */
 function getPortFromEmulatorString(emStr) {
-    let portPattern = /emulator-(\d+)/;
-    if (portPattern.test(emStr)) {
-        return parseInt(( /** @type {RegExpExecArray} */(portPattern.exec(emStr)))[1], 10);
-    }
-    return false;
+    const portPattern = /emulator-(\d+)/;
+    const match = portPattern.exec(emStr);
+    return match ? parseInt(match[1], 10) : false;
 }
 /**
  * Retrieve the list of currently connected emulators.
  *
- * @this {import('../adb.js').ADB}
- * @param {import('./types').ConnectedDevicesOptions} [opts={}] - Additional options mapping.
- * @return {Promise<import('./types').Device[]>} The list of connected devices.
+ * @param opts - Options for device retrieval
+ * @returns Array of connected emulator devices
+ * @throws {Error} If error occurs while getting emulators
  */
 async function getConnectedEmulators(opts = {}) {
     logger_js_1.log.debug('Getting connected emulators');
     try {
-        let devices = await this.getConnectedDevices(opts);
-        let emulators = [];
-        for (let device of devices) {
-            let port = this.getPortFromEmulatorString(device.udid);
+        const devices = await this.getConnectedDevices(opts);
+        const emulators = [];
+        for (const device of devices) {
+            const port = this.getPortFromEmulatorString(device.udid);
             if (port) {
                 device.port = port;
                 emulators.push(device);
@@ -661,14 +639,14 @@ async function getConnectedEmulators(opts = {}) {
         return emulators;
     }
     catch (e) {
-        throw new Error(`Error getting emulators. Original error: ${e.message}`);
+        const error = e;
+        throw new Error(`Error getting emulators. Original error: ${error.message}`);
     }
 }
 /**
  * Set _emulatorPort_ property of the current class.
  *
- * @this {import('../adb.js').ADB}
- * @param {number} emPort - The emulator port to be set.
+ * @param emPort - The emulator port number
  */
 function setEmulatorPort(emPort) {
     this.emulatorPort = emPort;
@@ -676,13 +654,12 @@ function setEmulatorPort(emPort) {
 /**
  * Set the identifier of the current device (_this.curDeviceId_).
  *
- * @this {import('../adb.js').ADB}
- * @param {string} deviceId - The device identifier.
+ * @param deviceId - The device identifier
  */
 function setDeviceId(deviceId) {
     logger_js_1.log.debug(`Setting device id to ${deviceId}`);
     this.curDeviceId = deviceId;
-    let argsHasDevice = this.executable.defaultArgs.indexOf('-s');
+    const argsHasDevice = this.executable.defaultArgs.indexOf('-s');
     if (argsHasDevice !== -1) {
         // remove the old device id from the arguments
         this.executable.defaultArgs.splice(argsHasDevice, 2);
@@ -690,10 +667,9 @@ function setDeviceId(deviceId) {
     this.executable.defaultArgs.push('-s', deviceId);
 }
 /**
- * Set the the current device object.
+ * Set the current device object.
  *
- * @this {import('../adb.js').ADB}
- * @param {import('./types').Device} deviceObj - The device object to be set.
+ * @param deviceObj - The device object containing udid and other properties
  */
 function setDevice(deviceObj) {
     const deviceId = deviceObj.udid;
@@ -709,9 +685,9 @@ function setDevice(deviceObj) {
  * `deviceId` (only if AVD with a matching name is found)
  * and `emulatorPort` instance properties.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} avdName - Emulator name.
- * @return {Promise<import('./types').Device|null>} Currently running emulator or _null_.
+ * @param avdName - The name of the AVD to find
+ * @returns The device object if found, null otherwise
+ * @throws {Error} If error occurs while getting AVD
  */
 async function getRunningAVD(avdName) {
     logger_js_1.log.debug(`Trying to find '${avdName}' emulator`);
@@ -736,47 +712,47 @@ async function getRunningAVD(avdName) {
         return null;
     }
     catch (e) {
-        throw new Error(`Error getting AVD. Original error: ${e.message}`);
+        const error = e;
+        throw new Error(`Error getting AVD. Original error: ${error.message}`);
     }
 }
 /**
- * Get the object for the currently running emulator.
+ * Get the object for the currently running emulator with retry.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} avdName - Emulator name.
- * @param {number} [timeoutMs=20000] - The maximum number of milliseconds
- *                                     to wait until at least one running AVD object
- *                                     is detected.
- * @return {Promise<import('./types').Device|null>} Currently running emulator or _null_.
- * @throws {Error} If no device has been detected within the timeout.
+ * @param avdName - The name of the AVD to find
+ * @param timeoutMs - Maximum time to wait (default: 20000ms)
+ * @returns The device object if found, null otherwise
+ * @throws {Error} If error occurs while getting AVD with retry
  */
 async function getRunningAVDWithRetry(avdName, timeoutMs = 20000) {
     try {
-        return /** @type {import('./types').Device|null} */ (await (0, asyncbox_1.waitForCondition)(async () => {
+        return await (0, asyncbox_1.waitForCondition)(async () => {
             try {
                 return await this.getRunningAVD(avdName.replace('@', ''));
             }
             catch (e) {
-                logger_js_1.log.debug(e.message);
+                const error = e;
+                logger_js_1.log.debug(error.message);
                 return false;
             }
         }, {
             waitMs: timeoutMs,
             intervalMs: 1000,
-        }));
+        });
     }
     catch (e) {
-        throw new Error(`Error getting AVD with retry. Original error: ${e.message}`);
+        const error = e;
+        throw new Error(`Error getting AVD with retry. Original error: ${error.message}`);
     }
 }
 /**
  * Shutdown all running emulators by killing their processes.
  *
- * @this {import('../adb.js').ADB}
- * @throws {Error} If killing tool returned non-zero return code.
+ * @throws {Error} If error occurs while killing emulators
  */
 async function killAllEmulators() {
-    let cmd, args;
+    let cmd;
+    let args;
     if (support_1.system.isWindows()) {
         cmd = 'TASKKILL';
         args = ['TASKKILL', '/IM', 'emulator.exe'];
@@ -789,20 +765,18 @@ async function killAllEmulators() {
         await (0, teen_process_1.exec)(cmd, args);
     }
     catch (e) {
-        throw new Error(`Error killing emulators. Original error: ${e.message}`);
+        const error = e;
+        throw new Error(`Error killing emulators. Original error: ${error.message}`);
     }
 }
 /**
  * Kill emulator with the given name. No error
- * is thrown is given avd does not exist/is not running.
+ * is thrown if given avd does not exist/is not running.
  *
- * @this {import('../adb.js').ADB}
- * @param {string?} [avdName=null] - The name of the emulator to be killed. If empty,
- *                            the current emulator will be killed.
- * @param {number} [timeout=60000] - The amount of time to wait before throwing
- *                                    an exception about unsuccessful killing
- * @return {Promise<boolean>} - True if the emulator was killed, false otherwise.
- * @throws {Error} if there was a failure by killing the emulator
+ * @param avdName - The name of the AVD to kill (null to kill current AVD)
+ * @param timeout - Maximum time to wait for emulator to be killed (default: 60000ms)
+ * @returns True if emulator was killed, false if it was not running
+ * @throws {Error} If emulator is still running after timeout
  */
 async function killEmulator(avdName = null, timeout = 60000) {
     if (support_1.util.hasValue(avdName)) {
@@ -830,8 +804,9 @@ async function killEmulator(avdName = null, timeout = 60000) {
                     ? !await this.getRunningAVD(avdName)
                     : !await this.isEmulatorConnected();
             }
-            catch { }
-            return false;
+            catch {
+                return false;
+            }
         }, {
             waitMs: timeout,
             intervalMs: 2000,
@@ -846,23 +821,22 @@ async function killEmulator(avdName = null, timeout = 60000) {
 /**
  * Start an emulator with given parameters and wait until it is fully started.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} avdName - The name of an existing emulator.
- * @param {import('./types').AvdLaunchOptions} [opts={}]
- * @returns {Promise<SubProcess>} Emulator subprocess instance
- * @throws {Error} If the emulator fails to start within the given timeout.
+ * @param avdName - The name of the AVD to launch
+ * @param opts - Launch options
+ * @returns The SubProcess instance for the launched emulator
+ * @throws {Error} If emulator fails to launch or boot
  */
 async function launchAVD(avdName, opts = {}) {
     const { args = [], env = {}, language, country, launchTimeout = 60000, readyTimeout = 60000, retryTimes = 1, } = opts;
     logger_js_1.log.debug(`Launching Emulator with AVD ${avdName}, launchTimeout ` +
         `${launchTimeout}ms and readyTimeout ${readyTimeout}ms`);
     const emulatorBinaryPath = await this.getSdkBinaryPath('emulator');
-    if (avdName.startsWith('@')) {
-        avdName = avdName.slice(1);
+    let processedAvdName = avdName;
+    if (processedAvdName.startsWith('@')) {
+        processedAvdName = processedAvdName.slice(1);
     }
-    await this.checkAvdExist(avdName);
-    /** @type {string[]} */
-    const launchArgs = ['-avd', avdName];
+    await this.checkAvdExist(processedAvdName);
+    const launchArgs = ['-avd', processedAvdName];
     launchArgs.push(...(toAvdLocaleArgs(language ?? null, country ?? null)));
     let isDelayAdbFeatureEnabled = false;
     if (this.allowDelayAdb) {
@@ -870,7 +844,7 @@ async function launchAVD(avdName, opts = {}) {
         if (revision && support_1.util.compareVersions(revision, '>=', '29.0.7')) {
             // https://androidstudio.googleblog.com/2019/05/emulator-2907-canary.html
             try {
-                const { target } = await this.getEmuImageProperties(avdName);
+                const { target } = await this.getEmuImageProperties(processedAvdName);
                 const apiMatch = /\d+/.exec(target);
                 // https://issuetracker.google.com/issues/142533355
                 if (apiMatch && parseInt(apiMatch[0], 10) >= MIN_DELAY_ADB_API_LEVEL) {
@@ -882,8 +856,9 @@ async function launchAVD(avdName, opts = {}) {
                 }
             }
             catch (e) {
+                const error = e;
                 logger_js_1.log.info(`The -delay-adb emulator startup detection feature will not be enabled. ` +
-                    `Original error: ${e.message}`);
+                    `Original error: ${error.message}`);
             }
         }
     }
@@ -891,7 +866,7 @@ async function launchAVD(avdName, opts = {}) {
         logger_js_1.log.info('The -delay-adb emulator startup detection feature has been explicitly disabled');
     }
     if (!lodash_1.default.isEmpty(args)) {
-        launchArgs.push(...(lodash_1.default.isArray(args) ? args : /** @type {string[]} */ (support_1.util.shellParse(`${args}`))));
+        launchArgs.push(...(lodash_1.default.isArray(args) ? args : support_1.util.shellParse(`${args}`)));
     }
     logger_js_1.log.debug(`Running '${emulatorBinaryPath}' with args: ${support_1.util.quote(launchArgs)}`);
     if (!lodash_1.default.isEmpty(env)) {
@@ -905,9 +880,9 @@ async function launchAVD(avdName, opts = {}) {
         proc.on(`line-${streamName}`, (line) => logger_js_1.log.debug(`[AVD OUTPUT] ${line}`));
     }
     proc.on('die', (code, signal) => {
-        logger_js_1.log.warn(`Emulator avd ${avdName} exited with code ${code}${signal ? `, signal ${signal}` : ''}`);
+        logger_js_1.log.warn(`Emulator avd ${processedAvdName} exited with code ${code}${signal ? `, signal ${signal}` : ''}`);
     });
-    await (0, asyncbox_1.retry)(retryTimes, async () => await this.getRunningAVDWithRetry(avdName, launchTimeout));
+    await (0, asyncbox_1.retry)(retryTimes, async () => await this.getRunningAVDWithRetry(processedAvdName, launchTimeout));
     // At this point we have deviceId already assigned
     const timer = new support_1.timing.Timer().start();
     if (isDelayAdbFeatureEnabled) {
@@ -915,7 +890,8 @@ async function launchAVD(avdName, opts = {}) {
             await this.adbExec(['wait-for-device'], { timeout: readyTimeout });
         }
         catch (e) {
-            throw new Error(`'${avdName}' Emulator has failed to boot: ${e.stderr || e.message}`);
+            const error = e;
+            throw new Error(`'${processedAvdName}' Emulator has failed to boot: ${error.stderr || error.message}`);
         }
     }
     await this.waitForEmulatorReady(Math.trunc(readyTimeout - timer.getDuration().asMilliSeconds));
@@ -924,9 +900,8 @@ async function launchAVD(avdName, opts = {}) {
 /**
  * Get the adb version. The result of this method is cached.
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<import('./types').Version>}
- * @throws {Error} If it is not possible to parse adb binary version.
+ * @returns Version information object
+ * @throws {Error} If error occurs while getting adb version
  */
 exports.getVersion = lodash_1.default.memoize(async function getVersion() {
     let stdout;
@@ -934,20 +909,21 @@ exports.getVersion = lodash_1.default.memoize(async function getVersion() {
         stdout = await this.adbExec('version');
     }
     catch (e) {
-        throw new Error(`Error getting adb version: ${e.stderr || e.message}`);
+        const error = e;
+        throw new Error(`Error getting adb version: ${error.stderr || error.message}`);
     }
     const result = {};
     const binaryVersionMatch = BINARY_VERSION_PATTERN.exec(stdout);
     if (binaryVersionMatch) {
         result.binary = {
-            version: semver.coerce(binaryVersionMatch[1]),
+            version: semver.coerce(binaryVersionMatch[1])?.version || binaryVersionMatch[1],
             build: parseInt(binaryVersionMatch[2], 10),
         };
     }
     const bridgeVersionMatch = BRIDGE_VERSION_PATTERN.exec(stdout);
     if (bridgeVersionMatch) {
         result.bridge = {
-            version: semver.coerce(bridgeVersionMatch[1]),
+            version: semver.coerce(bridgeVersionMatch[1])?.version || bridgeVersionMatch[1],
         };
     }
     return result;
@@ -955,14 +931,11 @@ exports.getVersion = lodash_1.default.memoize(async function getVersion() {
 /**
  * Check if the current emulator is ready to accept further commands (booting completed).
  *
- * @this {import('../adb.js').ADB}
- * @param {number} [timeoutMs=20000] - The maximum number of milliseconds to wait.
- * @returns {Promise<void>}
- * @throws {Error} If the emulator is not ready within the given timeout.
+ * @param timeoutMs - Maximum time to wait (default: 20000ms)
+ * @throws {Error} If emulator is not ready within the timeout period
  */
 async function waitForEmulatorReady(timeoutMs = 20000) {
     logger_js_1.log.debug(`Waiting up to ${timeoutMs}ms for the emulator to be ready`);
-    /** @type {RegExp[]} */
     const requiredServicesRe = REQUIRED_SERVICES.map((name) => new RegExp(`\\b${name}:`));
     let services;
     const timer = new support_1.timing.Timer().start();
@@ -990,15 +963,17 @@ async function waitForEmulatorReady(timeoutMs = 20000) {
                     }
                     isBootCompleted = true;
                 }
-                services = await this.shell(['service', 'list']);
-                if (!requiredServicesRe.every((pattern) => pattern.test(services))) {
-                    logger_js_1.log.debug(`Running services: ${services}`);
+                const servicesOutput = await this.shell(['service', 'list']);
+                services = servicesOutput;
+                if (!servicesOutput || !requiredServicesRe.every((pattern) => pattern.test(servicesOutput))) {
+                    logger_js_1.log.debug(`Running services: ${servicesOutput}`);
                     return false;
                 }
                 return true;
             }
             catch (err) {
-                logger_js_1.log.debug(`Intermediate error: ${err.message}`);
+                const error = err;
+                logger_js_1.log.debug(`Intermediate error: ${error.message}`);
                 return false;
             }
         }, {
@@ -1008,9 +983,10 @@ async function waitForEmulatorReady(timeoutMs = 20000) {
     }
     catch {
         let suffix = '';
-        if (services !== undefined) {
+        const servicesValue = services;
+        if (servicesValue) {
             const missingServices = lodash_1.default.zip(REQUIRED_SERVICES, requiredServicesRe)
-                .filter(([, pattern]) => !( /** @type {RegExp} */(pattern)).test(services))
+                .filter(([, pattern]) => !pattern.test(servicesValue))
                 .map(([name]) => name);
             suffix = ` (${missingServices} service${missingServices.length === 1 ? ' is' : 's are'} not running)`;
         }
@@ -1025,14 +1001,12 @@ async function waitForEmulatorReady(timeoutMs = 20000) {
 /**
  * Check if the current device is ready to accept further commands (booting completed).
  *
- * @this {import('../adb.js').ADB}
- * @param {number} [appDeviceReadyTimeout=30] - The maximum number of seconds to wait.
- * @throws {Error} If the device is not ready within the given timeout.
+ * @param appDeviceReadyTimeout - Timeout in seconds (default: 30)
+ * @throws {Error} If device is not ready within the timeout period
  */
 async function waitForDevice(appDeviceReadyTimeout = 30) {
     const timeoutMs = appDeviceReadyTimeout * 1000;
-    /** @type {Error|null} */
-    let lastError = null;
+    let lastErrorMessage = null;
     try {
         await (0, asyncbox_1.waitForCondition)(async () => {
             try {
@@ -1041,7 +1015,8 @@ async function waitForDevice(appDeviceReadyTimeout = 30) {
                 return true;
             }
             catch (e) {
-                lastError = e;
+                const error = e;
+                lastErrorMessage = error.message;
                 try {
                     try {
                         await this.reconnect();
@@ -1051,7 +1026,9 @@ async function waitForDevice(appDeviceReadyTimeout = 30) {
                     }
                     await this.getConnectedDevices();
                 }
-                catch { }
+                catch {
+                    // Ignore errors during reconnection
+                }
                 return false;
             }
         }, {
@@ -1061,8 +1038,8 @@ async function waitForDevice(appDeviceReadyTimeout = 30) {
     }
     catch {
         let suffix = '';
-        if (lastError) {
-            suffix = ` Original error: ${ /** @type {Error} */(lastError).message}`;
+        if (lastErrorMessage) {
+            suffix = ` Original error: ${lastErrorMessage}`;
         }
         throw new Error(`The device is not ready after ${appDeviceReadyTimeout}s.${suffix}`);
     }
@@ -1070,9 +1047,8 @@ async function waitForDevice(appDeviceReadyTimeout = 30) {
 /**
  * Reboot the current device and wait until it is completed.
  *
- * @this {import('../adb.js').ADB}
- * @param {number} [retries=DEFAULT_ADB_REBOOT_RETRIES] - The maximum number of reboot retries.
- * @throws {Error} If the device failed to reboot and number of retries is exceeded.
+ * @param retries - Number of retry attempts (default: 90)
+ * @throws {Error} If reboot fails or device is not ready after reboot
  */
 async function reboot(retries = DEFAULT_ADB_REBOOT_RETRIES) {
     // Get root access so we can run the next shell commands which require root access
@@ -1087,13 +1063,14 @@ async function reboot(retries = DEFAULT_ADB_REBOOT_RETRIES) {
         await this.shell(['start']);
     }
     catch (e) {
-        const { message } = e;
+        const error = e;
+        const { message } = error;
         // provide a helpful error message if the reason reboot failed was because ADB couldn't gain root access
         if (message.includes('must be root')) {
             throw new Error(`Could not reboot device. Rebooting requires root access and ` +
                 `attempt to get root access on device failed with error: '${message}'`);
         }
-        throw e;
+        throw error;
     }
     finally {
         // Return root state to what it was before
@@ -1115,9 +1092,8 @@ async function reboot(retries = DEFAULT_ADB_REBOOT_RETRIES) {
 /**
  * Switch adb server root privileges.
  *
- * @this {import('../adb.js').ADB}
- * @param {boolean} isElevated - Should we elevate to to root or unroot? (default true)
- * @return {Promise<import('./types').RootResult>}
+ * @param isElevated - True to enable root, false to disable
+ * @returns Result object indicating success and whether device was already rooted
  */
 async function changeUserPrivileges(isElevated) {
     const cmd = isElevated ? 'root' : 'unroot';
@@ -1126,10 +1102,11 @@ async function changeUserPrivileges(isElevated) {
             return await cmdFunc();
         }
         catch (err) {
+            const error = err;
             // Check the output of the stdErr to see if there's any clues that show that the device went offline
             // and if it did go offline, restart ADB
             if (['closed', 'device offline', 'timeout expired']
-                .some((x) => (err.stderr || '').toLowerCase().includes(x))) {
+                .some((x) => (error.stderr || '').toLowerCase().includes(x))) {
                 logger_js_1.log.warn(`Attempt to ${cmd} caused ADB to think the device went offline`);
                 try {
                     await this.reconnect();
@@ -1140,7 +1117,7 @@ async function changeUserPrivileges(isElevated) {
                 return await cmdFunc();
             }
             else {
-                throw err;
+                throw error;
             }
         }
     };
@@ -1166,7 +1143,8 @@ async function changeUserPrivileges(isElevated) {
         return { isSuccessful: true, wasAlreadyRooted };
     }
     catch (err) {
-        const { stderr = '', message } = err;
+        const error = err;
+        const { stderr = '', message } = error;
         logger_js_1.log.warn(`Unable to ${cmd} adb daemon. Original error: '${message}'. Stderr: '${stderr}'. Continuing.`);
         return { isSuccessful: false, wasAlreadyRooted };
     }
@@ -1174,8 +1152,7 @@ async function changeUserPrivileges(isElevated) {
 /**
  * Switch adb server to root mode
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<import('./types').RootResult>}
+ * @returns Result object indicating success and whether device was already rooted
  */
 async function root() {
     return await this.changeUserPrivileges(true);
@@ -1183,8 +1160,7 @@ async function root() {
 /**
  * Switch adb server to non-root mode.
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<import('./types').RootResult>}
+ * @returns Result object indicating success and whether device was already rooted
  */
 async function unroot() {
     return await this.changeUserPrivileges(false);
@@ -1192,10 +1168,7 @@ async function unroot() {
 /**
  * Checks whether the current user is root
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<boolean>} True if the user is root
- * @throws {Error} if there was an error while identifying
- * the user.
+ * @returns True if current user is root, false otherwise
  */
 async function isRoot() {
     return (await this.shell(['whoami'])).trim() === 'root';
@@ -1209,11 +1182,8 @@ async function isRoot() {
  * Read https://github.com/appium/appium/issues/10964
  * for more details on this topic
  *
- * @this {import('../adb.js').ADB}
- * @param {Buffer|string} cert - base64-decoded content of the actual certificate
- * represented as a string or a buffer
- * @throws {Error} If openssl tool is not available on the destination system
- * or if there was an error while installing the certificate
+ * @param cert - Certificate as Buffer or base64-encoded string
+ * @throws {Error} If certificate installation fails
  */
 async function installMitmCertificate(cert) {
     const openSsl = await getOpenSslForOs();
@@ -1245,10 +1215,11 @@ async function installMitmCertificate(cert) {
         await this.adbExec(['remount']);
     }
     catch (err) {
+        const error = err;
         throw new Error(`Cannot inject the custom certificate. ` +
             `Is the certificate properly encoded into base64-string? ` +
             `Do you have root permissions on the device? ` +
-            `Original error: ${err.message}`);
+            `Original error: ${error.message}`);
     }
     finally {
         await support_1.fs.rimraf(tmpRoot);
@@ -1257,12 +1228,9 @@ async function installMitmCertificate(cert) {
 /**
  * Verifies if the given root certificate is already installed on the device.
  *
- * @this {import('../adb.js').ADB}
- * @param {Buffer|string} cert - base64-decoded content of the actual certificate
- * represented as a string or a buffer
- * @throws {Error} If openssl tool is not available on the destination system
- * or if there was an error while checking the certificate
- * @returns {Promise<boolean>} true if the given certificate is already installed
+ * @param cert - Certificate as Buffer or base64-encoded string
+ * @returns True if certificate is installed, false otherwise
+ * @throws {Error} If certificate hash cannot be retrieved
  */
 async function isMitmCertificateInstalled(cert) {
     const openSsl = await getOpenSslForOs();
@@ -1275,9 +1243,10 @@ async function isMitmCertificateInstalled(cert) {
         certHash = stdout.trim();
     }
     catch (err) {
+        const error = err;
         throw new Error(`Cannot retrieve the certificate hash. ` +
             `Is the certificate properly encoded into base64-string? ` +
-            `Original error: ${err.message}`);
+            `Original error: ${error.message}`);
     }
     finally {
         await support_1.fs.rimraf(tmpRoot);
@@ -1292,18 +1261,12 @@ async function isMitmCertificateInstalled(cert) {
  * there is a limit for a maximum length of a single adb command. that is why
  * we need all this complicated logic.
  *
- * @this {import('../adb.js').ADB}
- * @param {(x: string) => string[]} argTransformer A function, that receives single argument
- * from the `args` array and transforms it into a shell command. The result
- * of the function must be an array, where each item is a part of a single command.
- * The last item of the array could be ';'. If this is not a semicolon then it is going to
- * be added automatically.
- * @param {string[]} args Array of argument values to create chunks for
- * @throws {Error} If any of the chunks returns non-zero exit code after being executed
+ * @param argTransformer - Function to transform each argument into command array
+ * @param args - Array of arguments to process
+ * @throws {Error} If argument transformer returns invalid result or command execution fails
  */
 async function shellChunks(argTransformer, args) {
     const commands = [];
-    /** @type {string[]} */
     let cmdChunk = [];
     for (const arg of args) {
         const nextCmd = argTransformer(arg);
@@ -1336,15 +1299,13 @@ async function shellChunks(argTransformer, args) {
         throw lastError;
     }
 }
-// #region Private functions
 /**
  * Transforms the given language and country abbreviations
  * to AVD arguments array
  *
- * @param {?string} language Language name, for example 'fr'
- * @param {?string} country Country name, for example 'CA'
- * @returns {Array<string>} The generated arguments. The
- * resulting array might be empty if both arguments are empty
+ * @param language - Language code (e.g., 'en', 'fr')
+ * @param country - Country code (e.g., 'US', 'FR')
+ * @returns Array of AVD locale arguments
  */
 function toAvdLocaleArgs(language, country) {
     const result = [];
@@ -1373,7 +1334,8 @@ function toAvdLocaleArgs(language, country) {
  * Retrieves full paths to all 'build-tools' subfolders under the particular
  * SDK root folder
  *
- * @type {(sdkRoot: string) => Promise<string[]>}
+ * @param sdkRoot - The Android SDK root directory path
+ * @returns Array of build-tools directory paths (newest first)
  */
 exports.getBuildToolsDirs = lodash_1.default.memoize(async function getBuildToolsDirs(sdkRoot) {
     let buildToolsDirs = await support_1.fs.glob('*/', {
@@ -1387,34 +1349,19 @@ exports.getBuildToolsDirs = lodash_1.default.memoize(async function getBuildTool
             .map((pair) => pair[1]);
     }
     catch (err) {
+        const error = err;
         logger_js_1.log.warn(`Cannot sort build-tools folders ${JSON.stringify(buildToolsDirs.map((dir) => path_1.default.basename(dir)))} ` +
             `by semantic version names.`);
-        logger_js_1.log.warn(`Falling back to sorting by modification date. Original error: ${err.message}`);
-        /** @type {[number, string][]} */
+        logger_js_1.log.warn(`Falling back to sorting by modification date. Original error: ${error.message}`);
         const pairs = await bluebird_1.default.map(buildToolsDirs, async (dir) => [(await support_1.fs.stat(dir)).mtime.valueOf(), dir]);
         buildToolsDirs = pairs
-            // @ts-ignore This sorting works
-            .sort((a, b) => a[0] < b[0])
+            .sort((a, b) => a[0] < b[0] ? 1 : -1)
             .map((pair) => pair[1]);
     }
     logger_js_1.log.info(`Found ${buildToolsDirs.length} 'build-tools' folders under '${sdkRoot}' (newest first):`);
-    for (let dir of buildToolsDirs) {
+    for (const dir of buildToolsDirs) {
         logger_js_1.log.info(`    ${dir}`);
     }
     return buildToolsDirs;
 });
-/**
- *
- * @returns {Promise<string>}
- */
-async function getOpenSslForOs() {
-    const binaryName = `openssl${support_1.system.isWindows() ? '.exe' : ''}`;
-    try {
-        return await support_1.fs.which(binaryName);
-    }
-    catch {
-        throw new Error('The openssl tool must be installed on the system and available on the path');
-    }
-}
-// #endregion
 //# sourceMappingURL=system-calls.js.map