appium-adb 16.0.0 → 16.0.1

package/lib/tools/lockmgmt.ts

@@ -1,7 +1,8 @@
-import {log} from '../logger.js';
+import {util} from '@appium/support';
 import {sleep, waitForCondition} from 'asyncbox';
+
 import type {ADB} from '../adb.js';
-import {util} from '@appium/support';
+import {log} from '../logger.js';
 
 const CREDENTIAL_CANNOT_BE_NULL_OR_EMPTY_ERROR = `Credential can't be null or empty`;
 const CREDENTIAL_DID_NOT_MATCH_ERROR = `didn't match`;
@@ -24,10 +25,7 @@ export async function isLockManagementSupported(this: ADB): Promise<boolean> {
       output = await this.shell([`locksettings help && echo ${passFlag}`]);
     } catch {}
     this._isLockManagementSupported = output.includes(passFlag);
-    log.debug(
-      `Extended lock settings management is ` +
-        `${this._isLockManagementSupported ? '' : 'not '}supported`,
-    );
+    log.debug(`Extended lock settings management is ${this._isLockManagementSupported ? '' : 'not '}supported`);
   }
   return this._isLockManagementSupported as boolean;
 }
@@ -44,10 +42,7 @@ export async function isLockManagementSupported(this: ADB): Promise<boolean> {
  * @return True if the given credential matches to the device's one
  * @throws {Error} If the verification faces an unexpected error
  */
-export async function verifyLockCredential(
-  this: ADB,
-  credential: string | null = null,
-): Promise<boolean> {
+export async function verifyLockCredential(this: ADB, credential: string | null = null): Promise<boolean> {
   try {
     const {stdout, stderr} = await this.shell(buildCommand('verify', credential), {
       outputFormat: this.EXEC_OUTPUT_FORMAT.FULL,
@@ -55,11 +50,7 @@ export async function verifyLockCredential(
     if (stdout?.includes('verified successfully')) {
       return true;
     }
-    if (
-      [`didn't match`, CREDENTIAL_CANNOT_BE_NULL_OR_EMPTY_ERROR].some((x) =>
-        (stderr || stdout)?.includes(x),
-      )
-    ) {
+    if ([`didn't match`, CREDENTIAL_CANNOT_BE_NULL_OR_EMPTY_ERROR].some((x) => (stderr || stdout)?.includes(x))) {
       return false;
     }
     throw new Error(stderr || stdout);
@@ -88,19 +79,12 @@ export async function verifyLockCredential(
  * null/empty value assumes the device has no lock currently set.
  * @throws {Error} If operation faces an unexpected error
  */
-export async function clearLockCredential(
-  this: ADB,
-  credential: string | null = null,
-): Promise<void> {
+export async function clearLockCredential(this: ADB, credential: string | null = null): Promise<void> {
   try {
     const {stdout, stderr} = await this.shell(buildCommand('clear', credential), {
       outputFormat: this.EXEC_OUTPUT_FORMAT.FULL,
     });
-    if (
-      !['user has no password', 'Lock credential cleared'].some((x) =>
-        (stderr || stdout)?.includes(x),
-      )
-    ) {
+    if (!['user has no password', 'Lock credential cleared'].some((x) => (stderr || stdout)?.includes(x))) {
       throw new Error(stderr || stdout);
     }
   } catch (e) {
@@ -141,10 +125,7 @@ export async function isLockEnabled(this: ADB): Promise<boolean> {
     }
     throw new Error(stderr || stdout);
   } catch (e) {
-    throw new Error(
-      `Cannot check if device lock is enabled. Original error: ${(e as Error).message}`,
-      {cause: e},
-    );
+    throw new Error(`Cannot check if device lock is enabled. Original error: ${(e as Error).message}`, {cause: e});
   }
 }
 
@@ -301,9 +282,7 @@ export function isShowingLockscreen(dumpsys: string): boolean {
   return (
     ['mShowingLockscreen=true', 'mDreamingLockscreen=true'].some((x) => dumpsys.includes(x)) ||
     // `mIsShowing` and `mInputRestricted` are `true` in lock condition. `false` is unlock condition.
-    [/KeyguardStateMonitor[\n\s]+mIsShowing=true/, /\s+mInputRestricted=true/].every((x) =>
-      x.test(dumpsys),
-    )
+    [/KeyguardStateMonitor[\n\s]+mIsShowing=true/, /\s+mInputRestricted=true/].every((x) => x.test(dumpsys))
   );
 }
 
@@ -325,11 +304,7 @@ export function isScreenStateOff(dumpsys: string): boolean {
  * @param oldCredential
  * @param args
  */
-function buildCommand(
-  verb: string,
-  oldCredential: string | null = null,
-  ...args: string[]
-): string[] {
+function buildCommand(verb: string, oldCredential: string | null = null, ...args: string[]): string[] {
   const cmd = ['locksettings', verb];
   if (oldCredential && !util.isEmpty(oldCredential)) {
     cmd.push('--old', oldCredential);
@@ -357,12 +332,7 @@ async function swipeUp(this: ADB, windowDumpsys: string): Promise<void> {
   const y0 = (displayHeight / 5) * 4;
   const x1 = x0;
   const y1 = displayHeight / 5;
-  await this.shell([
-    'input',
-    'touchscreen',
-    'swipe',
-    ...[x0, y0, x1, y1].map((c) => `${Math.trunc(c)}`),
-  ]);
+  await this.shell(['input', 'touchscreen', 'swipe', ...[x0, y0, x1, y1].map((c) => `${Math.trunc(c)}`)]);
 }
 
 /**

package/lib/tools/logcat-commands.ts

@@ -1,5 +1,5 @@
-import {Logcat} from '../logcat.js';
 import type {ADB} from '../adb.js';
+import {Logcat} from '../logcat.js';
 import type {LogcatOpts, LogEntry, LogcatListener} from './types.js';
 
 /**

package/lib/tools/network-commands.ts

@@ -1,6 +1,7 @@
 import {EOL} from 'node:os';
-import {log} from '../logger.js';
+
 import type {ADB} from '../adb.js';
+import {log} from '../logger.js';
 import type {PortFamily, PortInfo} from './types.js';
 
 /**
@@ -21,11 +22,7 @@ export async function getForwardList(this: ADB): Promise<string[]> {
  * @param systemPort - The number of the local system port.
  * @param devicePort - The number of the remote device port.
  */
-export async function forwardPort(
-  this: ADB,
-  systemPort: string | number,
-  devicePort: string | number,
-): Promise<void> {
+export async function forwardPort(this: ADB, systemPort: string | number, devicePort: string | number): Promise<void> {
   log.debug(`Forwarding system: ${systemPort} to device: ${devicePort}`);
   await this.adbExec(['forward', `tcp:${systemPort}`, `tcp:${devicePort}`]);
 }
@@ -61,11 +58,7 @@ export async function getReverseList(this: ADB): Promise<string[]> {
  * @param devicePort - The number of the remote device port.
  * @param systemPort - The number of the local system port.
  */
-export async function reversePort(
-  this: ADB,
-  devicePort: string | number,
-  systemPort: string | number,
-): Promise<void> {
+export async function reversePort(this: ADB, devicePort: string | number, systemPort: string | number): Promise<void> {
   log.debug(`Forwarding device: ${devicePort} to system: ${systemPort}`);
   await this.adbExec(['reverse', `tcp:${devicePort}`, `tcp:${systemPort}`]);
 }

package/lib/tools/process-commands.ts

@@ -1,7 +1,8 @@
-import {log} from '../logger.js';
 import {util} from '@appium/support';
 import type {ExecError} from 'teen_process';
+
 import type {ADB} from '../adb.js';
+import {log} from '../logger.js';
 
 const PID_COLUMN_TITLE: string = 'PID';
 const PROCESS_NAME_COLUMN_TITLE: string = 'NAME';
@@ -118,11 +119,7 @@ export async function getProcessIdsByName(this: ADB, name: string): Promise<numb
  * @param signal - The signal to send to the process. Default is 'SIGTERM' ('15').
  * @throws {Error} If the processes cannot be killed.
  */
-export async function killProcessesByName(
-  this: ADB,
-  name: string,
-  signal: string = 'SIGTERM',
-): Promise<void> {
+export async function killProcessesByName(this: ADB, name: string, signal: string = 'SIGTERM'): Promise<void> {
   try {
     log.debug(`Attempting to kill all ${name} processes`);
     const pids: number[] = await this.getProcessIdsByName(name);
@@ -148,11 +145,7 @@ export async function killProcessesByName(
  * @param signal - The signal to send to the process. Default is 'SIGTERM' ('15').
  * @throws {Error} If the process cannot be killed.
  */
-export async function killProcessByPID(
-  this: ADB,
-  pid: string | number,
-  signal: string = 'SIGTERM',
-): Promise<void> {
+export async function killProcessByPID(this: ADB, pid: string | number, signal: string = 'SIGTERM'): Promise<void> {
   log.debug(`Attempting to kill process ${pid}`);
   const noProcessFlag: string = 'No such process';
   try {

package/lib/tools/system-calls.ts

@@ -1,18 +1,14 @@
 import path from 'node:path';
-import {log} from '../logger.js';
+
 import {system, fs, util, tempDir, timing} from '@appium/support';
-import {exec, SubProcess} from 'teen_process';
-import type {ExecError, TeenProcessExecResult} from 'teen_process';
 import {asyncmap, retry, retryInterval, sleep, waitForCondition} from 'asyncbox';
 import * as semver from 'semver';
+import {exec, SubProcess} from 'teen_process';
+import type {ExecError, TeenProcessExecResult} from 'teen_process';
+
 import type {ADB} from '../adb.js';
-import {
-  DEFAULT_ADB_EXEC_TIMEOUT,
-  cloneDeep,
-  getSdkRootFromEnv,
-  memoize,
-  zip,
-} from '../utils/index.js';
+import {log} from '../logger.js';
+import {DEFAULT_ADB_EXEC_TIMEOUT, cloneDeep, getSdkRootFromEnv, memoize, zip} from '../utils/index.js';
 import type {
   ConnectedDevicesOptions,
   Device,
@@ -87,9 +83,7 @@ function _getBinaryNameForOS(binaryName: string): string {
  * @returns Array of possible binary location paths
  */
 function getSdkBinaryLocationCandidates(sdkRoot: string, fullBinaryName: string): string[] {
-  return SDK_BINARY_ROOTS.map((x) =>
-    path.resolve(sdkRoot, ...(Array.isArray(x) ? x : [x]), fullBinaryName),
-  );
+  return SDK_BINARY_ROOTS.map((x) => path.resolve(sdkRoot, ...(Array.isArray(x) ? x : [x]), fullBinaryName));
 }
 
 /**
@@ -235,10 +229,7 @@ export async function getConnectedDevices(
  * @returns Array of connected devices
  * @throws {Error} If adb devices command fails or returns unexpected output
  */
-export async function getConnectedDevices(
-  this: ADB,
-  opts?: ConnectedDevicesOptions,
-): Promise<Device[]>;
+export async function getConnectedDevices(this: ADB, opts?: ConnectedDevicesOptions): Promise<Device[]>;
 export async function getConnectedDevices(
   this: ADB,
   opts: ConnectedDevicesOptions = {},
@@ -339,9 +330,7 @@ export async function getDevicesWithRetry(this: ADB, timeoutMs: number = 20000):
         } catch (err: unknown) {
           const error = err as Error;
           log.debug(error.stack);
-          log.warn(
-            `Got an unexpected error while fetching connected devices list: ${error.message}`,
-          );
+          log.warn(`Got an unexpected error while fetching connected devices list: ${error.message}`);
         }
 
         try {
@@ -426,33 +415,27 @@ export async function killServer(this: ADB): Promise<void> {
  *
  * @returns True if token was reset successfully, false otherwise
  */
-export const resetTelnetAuthToken = memoize(
-  async function resetTelnetAuthToken(): Promise<boolean> {
-    // The methods is used to remove telnet auth token
-    //
-    const homeFolderPath = process.env[process.platform === 'win32' ? 'USERPROFILE' : 'HOME'];
-    if (!homeFolderPath) {
-      log.warn(
-        `Cannot find the path to user home folder. Ignoring resetting of emulator's telnet authentication token`,
-      );
-      return false;
-    }
-    const dstPath = path.resolve(homeFolderPath, '.emulator_console_auth_token');
-    log.debug(
-      `Overriding ${dstPath} with an empty string to avoid telnet authentication for emulator commands`,
+export const resetTelnetAuthToken = memoize(async function resetTelnetAuthToken(): Promise<boolean> {
+  // The methods is used to remove telnet auth token
+  //
+  const homeFolderPath = process.env[process.platform === 'win32' ? 'USERPROFILE' : 'HOME'];
+  if (!homeFolderPath) {
+    log.warn(`Cannot find the path to user home folder. Ignoring resetting of emulator's telnet authentication token`);
+    return false;
+  }
+  const dstPath = path.resolve(homeFolderPath, '.emulator_console_auth_token');
+  log.debug(`Overriding ${dstPath} with an empty string to avoid telnet authentication for emulator commands`);
+  try {
+    await fs.writeFile(dstPath, '');
+  } catch (e: unknown) {
+    const error = e as Error;
+    log.warn(
+      `Error ${error.message} while resetting the content of ${dstPath}. Ignoring resetting of emulator's telnet authentication token`,
     );
-    try {
-      await fs.writeFile(dstPath, '');
-    } catch (e: unknown) {
-      const error = e as Error;
-      log.warn(
-        `Error ${error.message} while resetting the content of ${dstPath}. Ignoring resetting of emulator's telnet authentication token`,
-      );
-      return false;
-    }
-    return true;
-  },
-);
+    return false;
+  }
+  return true;
+});
 
 /**
  * Execute the given emulator command using _adb emu_ tool.
@@ -494,16 +477,8 @@ export async function adbExec(
  * @returns Command stdout
  * @throws {Error} If command execution fails or timeout is exceeded
  */
-export async function adbExec(
-  this: ADB,
-  cmd: string | string[],
-  opts?: AdbExecOptions,
-): Promise<string>;
-export async function adbExec(
-  this: ADB,
-  cmd: string | string[],
-  opts?: AdbExecOptions,
-): Promise<string | ExecResult> {
+export async function adbExec(this: ADB, cmd: string | string[], opts?: AdbExecOptions): Promise<string>;
+export async function adbExec(this: ADB, cmd: string | string[], opts?: AdbExecOptions): Promise<string | ExecResult> {
   if (!cmd) {
     throw new Error('You need to pass in a command to adbExec()');
   }
@@ -607,16 +582,8 @@ export async function shell(
  * @returns Command stdout
  * @throws {Error} If command execution fails
  */
-export async function shell(
-  this: ADB,
-  cmd: string | string[],
-  opts?: ShellExecOptions,
-): Promise<string>;
-export async function shell(
-  this: ADB,
-  cmd: string | string[],
-  opts?: ShellExecOptions,
-): Promise<string | ExecResult> {
+export async function shell(this: ADB, cmd: string | string[], opts?: ShellExecOptions): Promise<string>;
+export async function shell(this: ADB, cmd: string | string[], opts?: ShellExecOptions): Promise<string | ExecResult> {
   const {privileged} = opts ?? {};
 
   const cmdArr = Array.isArray(cmd) ? cmd : [cmd];
@@ -703,10 +670,7 @@ export async function getConnectedEmulators(
  * @returns Array of connected emulator devices
  * @throws {Error} If error occurs while getting emulators
  */
-export async function getConnectedEmulators(
-  this: ADB,
-  opts?: ConnectedDevicesOptions,
-): Promise<Device[]>;
+export async function getConnectedEmulators(this: ADB, opts?: ConnectedDevicesOptions): Promise<Device[]>;
 export async function getConnectedEmulators(
   this: ADB,
   opts: ConnectedDevicesOptions = {},
@@ -898,9 +862,7 @@ export async function killEmulator(
     }
   }
   await this.adbExec(['emu', 'kill']);
-  log.debug(
-    `Waiting up to ${timeout}ms until the emulator '${avdName ? avdName : this.curDeviceId}' is killed`,
-  );
+  log.debug(`Waiting up to ${timeout}ms until the emulator '${avdName ? avdName : this.curDeviceId}' is killed`);
   try {
     await waitForCondition(
       async () => {
@@ -934,23 +896,10 @@ export async function killEmulator(
  * @returns The SubProcess instance for the launched emulator
  * @throws {Error} If emulator fails to launch or boot
  */
-export async function launchAVD(
-  this: ADB,
-  avdName: string,
-  opts: AvdLaunchOptions = {},
-): Promise<SubProcess> {
-  const {
-    args = [],
-    env = {},
-    language,
-    country,
-    launchTimeout = 60000,
-    readyTimeout = 60000,
-    retryTimes = 1,
-  } = opts;
+export async function launchAVD(this: ADB, avdName: string, opts: AvdLaunchOptions = {}): Promise<SubProcess> {
+  const {args = [], env = {}, language, country, launchTimeout = 60000, readyTimeout = 60000, retryTimes = 1} = opts;
   log.debug(
-    `Launching Emulator with AVD ${avdName}, launchTimeout ` +
-      `${launchTimeout}ms and readyTimeout ${readyTimeout}ms`,
+    `Launching Emulator with AVD ${avdName}, launchTimeout ${launchTimeout}ms and readyTimeout ${readyTimeout}ms`,
   );
   const emulatorBinaryPath = await this.getSdkBinaryPath('emulator');
   let processedAvdName = avdName;
@@ -990,7 +939,11 @@ export async function launchAVD(
   }
 
   if (!util.isEmpty(args)) {
-    launchArgs.push(...(Array.isArray(args) ? args : util.shellParse(`${args}`)));
+    launchArgs.push(
+      ...(Array.isArray(args)
+        ? args
+        : util.shellParse(`${args}`).filter((token): token is string => typeof token === 'string')),
+    );
   }
 
   log.debug(`Running '${emulatorBinaryPath}' with args: ${util.quote(launchArgs)}`);
@@ -1005,14 +958,9 @@ export async function launchAVD(
     proc.on(`line-${streamName}`, (line: string) => log.debug(`[AVD OUTPUT] ${line}`));
   }
   proc.on('die', (code: number | null, signal: string | null) => {
-    log.warn(
-      `Emulator avd ${processedAvdName} exited with code ${code}${signal ? `, signal ${signal}` : ''}`,
-    );
+    log.warn(`Emulator avd ${processedAvdName} exited with code ${code}${signal ? `, signal ${signal}` : ''}`);
   });
-  await retry(
-    retryTimes,
-    async () => await this.getRunningAVDWithRetry(processedAvdName, launchTimeout),
-  );
+  await retry(retryTimes, async () => await this.getRunningAVDWithRetry(processedAvdName, launchTimeout));
   // At this point we have deviceId already assigned
   const timer = new timing.Timer().start();
   if (isDelayAdbFeatureEnabled) {
@@ -1020,10 +968,9 @@ export async function launchAVD(
       await this.adbExec(['wait-for-device'], {timeout: readyTimeout});
     } catch (e: unknown) {
       const error = e as ExecError;
-      throw new Error(
-        `'${processedAvdName}' Emulator has failed to boot: ${error.stderr || error.message}`,
-        {cause: e},
-      );
+      throw new Error(`'${processedAvdName}' Emulator has failed to boot: ${error.stderr || error.message}`, {
+        cause: e,
+      });
     }
   }
   await this.waitForEmulatorReady(Math.trunc(readyTimeout - timer.getDuration().asMilliSeconds));
@@ -1104,10 +1051,7 @@ export async function waitForEmulatorReady(this: ADB, timeoutMs: number = 20000)
 
           const servicesOutput = await this.shell(['service', 'list']);
           services = servicesOutput;
-          if (
-            !servicesOutput ||
-            !requiredServicesRe.every((pattern) => pattern.test(servicesOutput))
-          ) {
+          if (!servicesOutput || !requiredServicesRe.every((pattern) => pattern.test(servicesOutput))) {
             log.debug(`Running services: ${servicesOutput}`);
             return false;
           }
@@ -1194,10 +1138,7 @@ export async function waitForDevice(this: ADB, appDeviceReadyTimeout: number = 3
  * @param retries - Number of retry attempts (default: 90)
  * @throws {Error} If reboot fails or device is not ready after reboot
  */
-export async function reboot(
-  this: ADB,
-  retries: number = DEFAULT_ADB_REBOOT_RETRIES,
-): Promise<void> {
+export async function reboot(this: ADB, retries: number = DEFAULT_ADB_REBOOT_RETRIES): Promise<void> {
   // Get root access so we can run the next shell commands which require root access
   const {wasAlreadyRooted} = await this.root();
   try {
@@ -1255,11 +1196,7 @@ export async function changeUserPrivileges(this: ADB, isElevated: boolean): Prom
       const error = err as ExecError;
       // 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) =>
-          (error.stderr || '').toLowerCase().includes(x),
-        )
-      ) {
+      if (['closed', 'device offline', 'timeout expired'].some((x) => (error.stderr || '').toLowerCase().includes(x))) {
         log.warn(`Attempt to ${cmd} caused ADB to think the device went offline`);
         try {
           await this.reconnect();
@@ -1298,9 +1235,7 @@ export async function changeUserPrivileges(this: ADB, isElevated: boolean): Prom
   } catch (err: unknown) {
     const error = err as ExecError;
     const {stderr = '', message} = error;
-    log.warn(
-      `Unable to ${cmd} adb daemon. Original error: '${message}'. Stderr: '${stderr}'. Continuing.`,
-    );
+    log.warn(`Unable to ${cmd} adb daemon. Original error: '${message}'. Stderr: '${stderr}'. Continuing.`);
     return {isSuccessful: false, wasAlreadyRooted};
   }
 }
@@ -1356,11 +1291,9 @@ export async function installMitmCertificate(this: ADB, cert: Buffer | string):
     log.debug(`Got certificate hash: ${certHash}`);
     log.debug('Preparing certificate content');
     const {stdout: stdoutBuff1} = await exec(openSsl, ['x509', '-in', srcCert], {isBuffer: true});
-    const {stdout: stdoutBuff2} = await exec(
-      openSsl,
-      ['x509', '-in', srcCert, '-text', '-fingerprint', '-noout'],
-      {isBuffer: true},
-    );
+    const {stdout: stdoutBuff2} = await exec(openSsl, ['x509', '-in', srcCert, '-text', '-fingerprint', '-noout'], {
+      isBuffer: true,
+    });
     const dstCertContent = Buffer.concat([stdoutBuff1, stdoutBuff2]);
     const dstCert = path.resolve(tmpRoot, `${certHash}.0`);
     await fs.writeFile(dstCert, dstCertContent);
@@ -1392,10 +1325,7 @@ export async function installMitmCertificate(this: ADB, cert: Buffer | string):
  * @returns True if certificate is installed, false otherwise
  * @throws {Error} If certificate hash cannot be retrieved
  */
-export async function isMitmCertificateInstalled(
-  this: ADB,
-  cert: Buffer | string,
-): Promise<boolean> {
+export async function isMitmCertificateInstalled(this: ADB, cert: Buffer | string): Promise<boolean> {
   const openSsl = await getOpenSslForOs();
 
   const tmpRoot = await tempDir.openDir();
@@ -1431,11 +1361,7 @@ export async function isMitmCertificateInstalled(
  * @param args - Array of arguments to process
  * @throws {Error} If argument transformer returns invalid result or command execution fails
  */
-export async function shellChunks(
-  this: ADB,
-  argTransformer: (x: string) => string[],
-  args: string[],
-): Promise<void> {
+export async function shellChunks(this: ADB, argTransformer: (x: string) => string[], args: string[]): Promise<void> {
   const commands: string[][] = [];
   let cmdChunk: string[] = [];
   for (const arg of args) {
@@ -1506,9 +1432,7 @@ export function toAvdLocaleArgs(language: string | null, country: string | null)
  * @param sdkRoot - The Android SDK root directory path
  * @returns Array of build-tools directory paths (newest first)
  */
-export const getBuildToolsDirs = memoize(async function getBuildToolsDirs(
-  sdkRoot: string,
-): Promise<string[]> {
+export const getBuildToolsDirs = memoize(async function getBuildToolsDirs(sdkRoot: string): Promise<string[]> {
   let buildToolsDirs = await fs.glob('*/', {
     cwd: path.resolve(sdkRoot, 'build-tools'),
     absolute: true,
@@ -1531,9 +1455,7 @@ export const getBuildToolsDirs = memoize(async function getBuildToolsDirs(
     );
     buildToolsDirs = pairs.sort((a, b) => (a[0] < b[0] ? 1 : -1)).map((pair) => pair[1]);
   }
-  log.info(
-    `Found ${buildToolsDirs.length} 'build-tools' folders under '${sdkRoot}' (newest first):`,
-  );
+  log.info(`Found ${buildToolsDirs.length} 'build-tools' folders under '${sdkRoot}' (newest first):`);
   for (const dir of buildToolsDirs) {
     log.info(`    ${dir}`);
   }

package/lib/tools/types.ts

@@ -732,14 +732,10 @@ export interface RootResult {
 }
 
 export type Sensors = (typeof emuConstants.SENSORS)[keyof typeof emuConstants.SENSORS];
-export type NetworkSpeed =
-  (typeof emuConstants.NETWORK_SPEED)[keyof typeof emuConstants.NETWORK_SPEED];
-export type GsmVoiceStates =
-  (typeof emuConstants.GSM_VOICE_STATES)[keyof typeof emuConstants.GSM_VOICE_STATES];
-export type GsmCallActions =
-  (typeof emuConstants.GSM_CALL_ACTIONS)[keyof typeof emuConstants.GSM_CALL_ACTIONS];
-export type PowerAcStates =
-  (typeof emuConstants.POWER_AC_STATES)[keyof typeof emuConstants.POWER_AC_STATES];
+export type NetworkSpeed = (typeof emuConstants.NETWORK_SPEED)[keyof typeof emuConstants.NETWORK_SPEED];
+export type GsmVoiceStates = (typeof emuConstants.GSM_VOICE_STATES)[keyof typeof emuConstants.GSM_VOICE_STATES];
+export type GsmCallActions = (typeof emuConstants.GSM_CALL_ACTIONS)[keyof typeof emuConstants.GSM_CALL_ACTIONS];
+export type PowerAcStates = (typeof emuConstants.POWER_AC_STATES)[keyof typeof emuConstants.POWER_AC_STATES];
 
 export interface PlatformInfo {
   /**

package/lib/utils/helpers/index.ts

@@ -1,9 +1,4 @@
-export {
-  APKS_EXTENSION,
-  APK_EXTENSION,
-  APK_INSTALL_TIMEOUT,
-  DEFAULT_ADB_EXEC_TIMEOUT,
-} from './constants.js';
+export {APKS_EXTENSION, APK_EXTENSION, APK_INSTALL_TIMEOUT, DEFAULT_ADB_EXEC_TIMEOUT} from './constants.js';
 export {buildInstallArgs, type BuildInstallArgsOptions} from './install.js';
 export {readPackageManifest} from './manifest.js';
 export {getResourcePath, unzipFile} from './resource.js';

package/lib/utils/helpers/install.ts

@@ -1,4 +1,5 @@
 import {util} from '@appium/support';
+
 import {log} from '../../logger.js';
 
 export interface BuildInstallArgsOptions {
@@ -16,10 +17,7 @@ export interface BuildInstallArgsOptions {
  * @param options - Install options mapped to adb flags
  * @returns A list of install flags
  */
-export function buildInstallArgs(
-  apiLevel: number,
-  options: BuildInstallArgsOptions = {},
-): string[] {
+export function buildInstallArgs(apiLevel: number, options: BuildInstallArgsOptions = {}): string[] {
   const result: string[] = [];
 
   if (!util.hasValue(options.replace) || options.replace) {

package/lib/utils/helpers/manifest.ts

@@ -1,7 +1,8 @@
 import {util} from '@appium/support';
 import {exec, type ExecError} from 'teen_process';
-import {log} from '../../logger.js';
+
 import type {ADB} from '../../adb.js';
+import {log} from '../../logger.js';
 import type {ApkManifest} from '../../tools/types.js';
 
 /**
@@ -34,22 +35,14 @@ export async function readPackageManifest(this: ADB, apkPath: string): Promise<A
     throw new Error(`${prefix}. ${suffix}`, {cause: e});
   }
 
-  const extractValue = (
-    line: string,
-    propPattern: RegExp,
-    valueTransformer: ((x: string) => any) | null,
-  ): any => {
+  const extractValue = (line: string, propPattern: RegExp, valueTransformer: ((x: string) => any) | null): any => {
     const match = propPattern.exec(line);
     if (match) {
       return valueTransformer ? valueTransformer(match[1]) : match[1];
     }
     return undefined;
   };
-  const extractArray = (
-    line: string,
-    propPattern: RegExp,
-    valueTransformer: ((x: string) => any) | null,
-  ): any[] => {
+  const extractArray = (line: string, propPattern: RegExp, valueTransformer: ((x: string) => any) | null): any[] => {
     let match: RegExpExecArray | null;
     const resultArray: any[] = [];
     while ((match = propPattern.exec(line))) {

package/lib/utils/helpers/resource.ts

@@ -1,18 +1,17 @@
 import path from 'node:path';
 import {fileURLToPath} from 'node:url';
+
 import {fs, zip, util} from '@appium/support';
+
 import {log} from '../../logger.js';
 import {MODULE_NAME} from './constants.js';
 
-export const getResourcePath = util.memoize(async function getResourcePath(
-  relPath: string,
-): Promise<string> {
+export const getResourcePath = util.memoize(async function getResourcePath(relPath: string): Promise<string> {
   const moduleRoot = await getModuleRoot();
   const resultPath = path.resolve(moduleRoot, relPath);
   if (!(await fs.exists(resultPath))) {
     throw new Error(
-      `Cannot find the resource '${relPath}' under the '${moduleRoot}' ` +
-        `folder of ${MODULE_NAME} Node.js module`,
+      `Cannot find the resource '${relPath}' under the '${moduleRoot}' folder of ${MODULE_NAME} Node.js module`,
     );
   }
   return resultPath;
@@ -24,10 +23,7 @@ export const getResourcePath = util.memoize(async function getResourcePath(
  * @param zipPath - Source zip file path
  * @param dstRoot - Destination directory. Defaults to zip parent directory
  */
-export async function unzipFile(
-  zipPath: string,
-  dstRoot: string = path.dirname(zipPath),
-): Promise<void> {
+export async function unzipFile(zipPath: string, dstRoot: string = path.dirname(zipPath)): Promise<void> {
   log.debug(`Unzipping '${zipPath}' to '${dstRoot}'`);
   await zip.assertValidZip(zipPath);
   await zip.extractAllTo(zipPath, dstRoot);