appium-adb 14.3.4 → 14.4.0

package/lib/tools/keyboard-commands.ts

@@ -56,7 +56,9 @@ export async function isSoftKeyboardPresent(this: ADB): Promise<KeyboardState> {
       canCloseKeyboard: !!(inputViewShownMatch && inputViewShownMatch[1] === 'true'),
     };
   } catch (e) {
-    throw new Error(`Error finding softkeyboard. Original error: ${(e as Error).message}`);
+    throw new Error(`Error finding softkeyboard. Original error: ${(e as Error).message}`, {
+      cause: e,
+    });
   }
 }
 
@@ -81,7 +83,7 @@ export async function availableIMEs(this: ADB): Promise<string[]> {
     return getIMEListFromOutput(await this.shell(['ime', 'list', '-a']));
   } catch (e) {
     const err = e as Error;
-    throw new Error(`Error getting available IME's. Original error: ${err.message}`);
+    throw new Error(`Error getting available IME's. Original error: ${err.message}`, {cause: e});
   }
 }
 
@@ -95,7 +97,7 @@ export async function enabledIMEs(this: ADB): Promise<string[]> {
     return getIMEListFromOutput(await this.shell(['ime', 'list']));
   } catch (e) {
     const err = e as Error;
-    throw new Error(`Error getting enabled IME's. Original error: ${err.message}`);
+    throw new Error(`Error getting enabled IME's. Original error: ${err.message}`, {cause: e});
   }
 }
 
@@ -140,7 +142,7 @@ export async function defaultIME(this: ADB): Promise<string | null> {
     return engine.trim();
   } catch (e) {
     const err = e as Error;
-    throw new Error(`Error getting default IME. Original error: ${err.message}`);
+    throw new Error(`Error getting default IME. Original error: ${err.message}`, {cause: e});
   }
 }
 

package/lib/tools/lockmgmt.ts

@@ -1,7 +1,7 @@
 import {log} from '../logger';
-import _ from 'lodash';
 import {sleep, waitForCondition} from 'asyncbox';
 import type {ADB} from '../adb';
+import {util} from '@appium/support';
 
 const CREDENTIAL_CANNOT_BE_NULL_OR_EMPTY_ERROR = `Credential can't be null or empty`;
 const CREDENTIAL_DID_NOT_MATCH_ERROR = `didn't match`;
@@ -17,13 +17,13 @@ const HIDE_KEYBOARD_WAIT_TIME = 100;
  * @return True if the management is supported. The result is cached per ADB instance
  */
 export async function isLockManagementSupported(this: ADB): Promise<boolean> {
-  if (!_.isBoolean(this._isLockManagementSupported)) {
+  if (typeof this._isLockManagementSupported !== 'boolean') {
     const passFlag = '__PASS__';
     let output = '';
     try {
       output = await this.shell([`locksettings help && echo ${passFlag}`]);
     } catch {}
-    this._isLockManagementSupported = _.includes(output, passFlag);
+    this._isLockManagementSupported = output.includes(passFlag);
     log.debug(
       `Extended lock settings management is ` +
         `${this._isLockManagementSupported ? '' : 'not '}supported`,
@@ -52,12 +52,12 @@ export async function verifyLockCredential(
     const {stdout, stderr} = await this.shell(buildCommand('verify', credential), {
       outputFormat: this.EXEC_OUTPUT_FORMAT.FULL,
     });
-    if (_.includes(stdout, 'verified successfully')) {
+    if (stdout?.includes('verified successfully')) {
       return true;
     }
     if (
       [`didn't match`, CREDENTIAL_CANNOT_BE_NULL_OR_EMPTY_ERROR].some((x) =>
-        _.includes(stderr || stdout, x),
+        (stderr || stdout)?.includes(x),
       )
     ) {
       return false;
@@ -71,6 +71,7 @@ export async function verifyLockCredential(
           (e as Error & {stderr?: string; stdout?: string}).stdout ||
           (e as Error).message
         }`,
+      {cause: e},
     );
   }
 }
@@ -97,7 +98,7 @@ export async function clearLockCredential(
     });
     if (
       !['user has no password', 'Lock credential cleared'].some((x) =>
-        _.includes(stderr || stdout, x),
+        (stderr || stdout)?.includes(x),
       )
     ) {
       throw new Error(stderr || stdout);
@@ -110,6 +111,7 @@ export async function clearLockCredential(
           (e as Error & {stderr?: string; stdout?: string}).stdout ||
           (e as Error).message
         }`,
+      {cause: e},
     );
   }
 }
@@ -129,7 +131,7 @@ export async function isLockEnabled(this: ADB): Promise<boolean> {
     if (
       /\bfalse\b/.test(stdout) ||
       [CREDENTIAL_DID_NOT_MATCH_ERROR, CREDENTIAL_CANNOT_BE_NULL_OR_EMPTY_ERROR].some((x) =>
-        _.includes(stderr || stdout, x),
+        (stderr || stdout)?.includes(x),
       )
     ) {
       return true;
@@ -141,6 +143,7 @@ export async function isLockEnabled(this: ADB): Promise<boolean> {
   } catch (e) {
     throw new Error(
       `Cannot check if device lock is enabled. Original error: ${(e as Error).message}`,
+      {cause: e},
     );
   }
 }
@@ -174,7 +177,7 @@ export async function setLockCredential(
         `Only the following credential types are supported: ${SUPPORTED_LOCK_CREDENTIAL_TYPES}`,
     );
   }
-  if (_.isEmpty(credential) && !_.isInteger(credential)) {
+  if (util.isEmpty(credential) && !Number.isInteger(credential)) {
     throw new Error('Device lock credential cannot be empty');
   }
   const cmd = buildCommand(`set-${credentialType}`, oldCredential, credential);
@@ -182,7 +185,7 @@ export async function setLockCredential(
     const {stdout, stderr} = await this.shell(cmd, {
       outputFormat: this.EXEC_OUTPUT_FORMAT.FULL,
     });
-    if (!_.includes(stdout, 'set to')) {
+    if (!stdout?.includes('set to')) {
       throw new Error(stderr || stdout);
     }
   } catch (e) {
@@ -193,6 +196,7 @@ export async function setLockCredential(
           (e as Error & {stderr?: string; stdout?: string}).stdout ||
           (e as Error).message
         }`,
+      {cause: e},
     );
   }
 }
@@ -295,9 +299,9 @@ export async function lock(this: ADB): Promise<void> {
  */
 export function isShowingLockscreen(dumpsys: string): boolean {
   return (
-    _.some(['mShowingLockscreen=true', 'mDreamingLockscreen=true'], (x) => dumpsys.includes(x)) ||
+    ['mShowingLockscreen=true', 'mDreamingLockscreen=true'].some((x) => dumpsys.includes(x)) ||
     // `mIsShowing` and `mInputRestricted` are `true` in lock condition. `false` is unlock condition.
-    _.every([/KeyguardStateMonitor[\n\s]+mIsShowing=true/, /\s+mInputRestricted=true/], (x) =>
+    [/KeyguardStateMonitor[\n\s]+mIsShowing=true/, /\s+mInputRestricted=true/].every((x) =>
       x.test(dumpsys),
     )
   );
@@ -327,10 +331,10 @@ function buildCommand(
   ...args: string[]
 ): string[] {
   const cmd = ['locksettings', verb];
-  if (oldCredential && !_.isEmpty(oldCredential)) {
+  if (oldCredential && !util.isEmpty(oldCredential)) {
     cmd.push('--old', oldCredential);
   }
-  if (!_.isEmpty(args)) {
+  if (args.length > 0) {
     cmd.push(...args);
   }
   return cmd;

package/lib/tools/logcat-commands.ts

@@ -1,4 +1,3 @@
-import _ from 'lodash';
 import {Logcat} from '../logcat';
 import type {ADB} from '../adb';
 import type {LogcatOpts, LogEntry, LogcatListener} from './types';
@@ -10,7 +9,7 @@ import type {LogcatOpts, LogEntry, LogcatListener} from './types';
  * @throws {Error} If restart fails.
  */
 export async function startLogcat(this: ADB, opts: LogcatOpts = {}): Promise<void> {
-  if (!_.isEmpty(this.logcat)) {
+  if (this.logcat) {
     throw new Error("Trying to start logcat capture but it's already started!");
   }
 
@@ -30,7 +29,7 @@ export async function startLogcat(this: ADB, opts: LogcatOpts = {}): Promise<voi
  */
 export async function stopLogcat(this: ADB): Promise<void> {
   const logcat = this.logcat;
-  if (!logcat || _.isEmpty(this.logcat)) {
+  if (!logcat) {
     return;
   }
   try {
@@ -49,7 +48,7 @@ export async function stopLogcat(this: ADB): Promise<void> {
  */
 export function getLogcatLogs(this: ADB): LogEntry[] {
   const logcat = this.logcat;
-  if (!logcat || _.isEmpty(this.logcat)) {
+  if (!logcat) {
     throw new Error(`Can't get logcat logs since logcat hasn't started`);
   }
   return logcat.getLogs();
@@ -63,7 +62,7 @@ export function getLogcatLogs(this: ADB): LogEntry[] {
  */
 export function setLogcatListener(this: ADB, listener: LogcatListener): void {
   const logcat = this.logcat;
-  if (!logcat || _.isEmpty(this.logcat)) {
+  if (!logcat) {
     throw new Error("Logcat process hasn't been started");
   }
   logcat.on('output', listener);
@@ -79,7 +78,7 @@ export function setLogcatListener(this: ADB, listener: LogcatListener): void {
  */
 export function removeLogcatListener(this: ADB, listener: LogcatListener): void {
   const logcat = this.logcat;
-  if (!logcat || _.isEmpty(this.logcat)) {
+  if (!logcat) {
     throw new Error("Logcat process hasn't been started");
   }
   logcat.removeListener('output', listener);

package/lib/tools/network-commands.ts

@@ -1,5 +1,4 @@
 import {EOL} from 'node:os';
-import _ from 'lodash';
 import {log} from '../logger';
 import type {ADB} from '../adb';
 import type {PortFamily, PortInfo} from './types';
@@ -126,7 +125,7 @@ export async function listPorts(this: ADB, family: PortFamily = '4'): Promise<Po
   const sourceProcName = `/proc/net/tcp${family === '6' ? '6' : ''}`;
   const output = await this.shell(['cat', sourceProcName]);
   const lines = output.split('\n');
-  if (_.isEmpty(lines)) {
+  if (!lines.length) {
     log.debug(output);
     throw new Error(`Cannot parse the payload of ${sourceProcName}`);
   }

package/lib/tools/process-commands.ts

@@ -1,5 +1,5 @@
-import _ from 'lodash';
 import {log} from '../logger';
+import {util} from '@appium/support';
 import type {ExecError} from 'teen_process';
 import type {ADB} from '../adb';
 
@@ -19,7 +19,7 @@ const PS_TITLE_PATTERN: RegExp = new RegExp(
  * @returns the output of `ps` command where all processes are included
  */
 export async function listProcessStatus(this: ADB): Promise<string> {
-  if (!_.isBoolean(this._doesPsSupportAOption)) {
+  if (typeof this._doesPsSupportAOption !== 'boolean') {
     try {
       this._doesPsSupportAOption = /^-A\b/m.test(await this.shell(['ps', '--help']));
     } catch (e: unknown) {
@@ -108,7 +108,7 @@ export async function getProcessIdsByName(this: ADB, name: string): Promise<numb
     }
   }
 
-  return _.uniq(pids);
+  return util.uniq(pids);
 }
 
 /**
@@ -126,14 +126,16 @@ export async function killProcessesByName(
   try {
     log.debug(`Attempting to kill all ${name} processes`);
     const pids: number[] = await this.getProcessIdsByName(name);
-    if (_.isEmpty(pids)) {
+    if (pids.length === 0) {
       log.info(`No '${name}' process has been found`);
     } else {
       await Promise.all(pids.map((p: number) => this.killProcessByPID(p, signal)));
     }
   } catch (e: unknown) {
     const err: Error = e as Error;
-    throw new Error(`Unable to kill ${name} processes. Original error: ${err.message}`);
+    throw new Error(`Unable to kill ${name} processes. Original error: ${err.message}`, {
+      cause: e,
+    });
   }
 }
 
@@ -158,10 +160,10 @@ export async function killProcessByPID(
     await this.shell(['kill', `-${signal}`, `${pid}`]);
   } catch (e: unknown) {
     const err: ExecError = e as ExecError;
-    if (_.includes(err.stderr, noProcessFlag)) {
+    if ((err.stderr ?? '').includes(noProcessFlag)) {
       return;
     }
-    if (!_.includes(err.stderr, 'Operation not permitted')) {
+    if (!(err.stderr ?? '').includes('Operation not permitted')) {
       throw err;
     }
     log.info(`Cannot kill PID ${pid} due to insufficient permissions. Retrying as root`);
@@ -171,7 +173,7 @@ export async function killProcessByPID(
       });
     } catch (e1: unknown) {
       const err1: ExecError = e1 as ExecError;
-      if (_.includes(err1.stderr, noProcessFlag)) {
+      if ((err1.stderr ?? '').includes(noProcessFlag)) {
         return;
       }
       throw err1;
@@ -188,5 +190,5 @@ export async function killProcessByPID(
  * @throws {Error} If the given process name is not a valid class name.
  */
 export async function processExists(this: ADB, processName: string): Promise<boolean> {
-  return !_.isEmpty(await this.getProcessIdsByName(processName));
+  return (await this.getProcessIdsByName(processName)).length > 0;
 }

package/lib/tools/system-calls.ts

@@ -1,13 +1,12 @@
 import path from 'node:path';
 import {log} from '../logger';
 import {system, fs, util, tempDir, timing} from '@appium/support';
-import {DEFAULT_ADB_EXEC_TIMEOUT, getSdkRootFromEnv} from '../helpers';
 import {exec, SubProcess} from 'teen_process';
 import type {ExecError, TeenProcessExecResult} from 'teen_process';
 import {asyncmap, retry, retryInterval, sleep, waitForCondition} from 'asyncbox';
-import _ from 'lodash';
 import * as semver from 'semver';
 import type {ADB} from '../adb';
+import {DEFAULT_ADB_EXEC_TIMEOUT, cloneDeep, getSdkRootFromEnv, memoize, zip} from '../utils';
 import type {
   ConnectedDevicesOptions,
   Device,
@@ -81,7 +80,7 @@ function _getBinaryNameForOS(binaryName: string): string {
  */
 function getSdkBinaryLocationCandidates(sdkRoot: string, fullBinaryName: string): string[] {
   return SDK_BINARY_ROOTS.map((x) =>
-    path.resolve(sdkRoot, ...(_.isArray(x) ? x : [x]), fullBinaryName),
+    path.resolve(sdkRoot, ...(Array.isArray(x) ? x : [x]), fullBinaryName),
   );
 }
 
@@ -100,7 +99,7 @@ async function getOpenSslForOs(): Promise<string> {
   }
 }
 
-export const getBinaryNameForOS = _.memoize(_getBinaryNameForOS);
+export const getBinaryNameForOS = memoize(_getBinaryNameForOS);
 
 /**
  * Retrieve full path to the given binary and caches it into `binaries`
@@ -124,19 +123,16 @@ export async function getBinaryFromSdkRoot(this: ADB, binaryName: string): Promi
   let buildToolsDirs = await getBuildToolsDirs(this.sdkRoot);
   if (this.buildToolsVersion) {
     buildToolsDirs = buildToolsDirs.filter((x) => path.basename(x) === this.buildToolsVersion);
-    if (_.isEmpty(buildToolsDirs)) {
+    if (util.isEmpty(buildToolsDirs)) {
       log.info(`Found no build tools whose version matches to '${this.buildToolsVersion}'`);
     } else {
       log.info(`Using build tools at '${buildToolsDirs}'`);
     }
   }
   binaryLocs.push(
-    ..._.flatten(
-      buildToolsDirs.map((dir) => [
-        path.resolve(dir, fullBinaryName),
-        path.resolve(dir, 'lib', fullBinaryName),
-      ]),
-    ),
+    ...buildToolsDirs
+      .map((dir) => [path.resolve(dir, fullBinaryName), path.resolve(dir, 'lib', fullBinaryName)])
+      .flat(),
   );
 
   let binaryLoc: string | null = null;
@@ -146,7 +142,7 @@ export async function getBinaryFromSdkRoot(this: ADB, binaryName: string): Promi
       break;
     }
   }
-  if (_.isNull(binaryLoc)) {
+  if (binaryLoc === null) {
     throw new Error(
       `Could not find '${fullBinaryName}' in ${JSON.stringify(binaryLocs)}. ` +
         `Do you have Android Build Tools ${this.buildToolsVersion ? `v ${this.buildToolsVersion} ` : ''}` +
@@ -235,7 +231,9 @@ export async function getConnectedDevices(
     ({stdout} = await exec(this.executable.path, args));
   } catch (e: unknown) {
     const error = e as Error;
-    throw new Error(`Error while getting connected devices. Original error: ${error.message}`);
+    throw new Error(`Error while getting connected devices. Original error: ${error.message}`, {
+      cause: e,
+    });
   }
   const listHeader = 'List of devices';
   // expecting adb devices to return output as
@@ -253,7 +251,7 @@ export async function getConnectedDevices(
   }
   const devices = stdout
     .split('\n')
-    .map(_.trim)
+    .map((x) => x.trim())
     .filter((line) => line && !excludedLines.some((x) => line.includes(x)))
     .map((line) => {
       // state is "device", afaic
@@ -271,7 +269,7 @@ export async function getConnectedDevices(
       }
       return device;
     });
-  if (_.isEmpty(devices)) {
+  if (util.isEmpty(devices)) {
     log.debug('No connected devices have been detected');
   } else {
     log.debug(`Connected devices: ${JSON.stringify(devices)}`);
@@ -322,7 +320,9 @@ export async function getDevicesWithRetry(this: ADB, timeoutMs: number = 20000):
   } catch (e: unknown) {
     const error = e as Error;
     if (/Condition unmet/.test(error.message)) {
-      throw new Error(`Could not find a connected Android device in ${timeoutMs}ms`);
+      throw new Error(`Could not find a connected Android device in ${timeoutMs}ms`, {
+        cause: e,
+      });
     } else {
       throw e;
     }
@@ -346,7 +346,9 @@ export async function reconnect(this: ADB, target: string | null = 'offline'): P
     await this.adbExec(args);
   } catch (e: unknown) {
     const error = e as ExecError;
-    throw new Error(`Cannot reconnect adb. Original error: ${error.stderr || error.message}`);
+    throw new Error(`Cannot reconnect adb. Original error: ${error.stderr || error.message}`, {
+      cause: e,
+    });
   }
 }
 
@@ -384,7 +386,7 @@ export async function killServer(this: ADB): Promise<void> {
  *
  * @returns True if token was reset successfully, false otherwise
  */
-export const resetTelnetAuthToken = _.memoize(
+export const resetTelnetAuthToken = memoize(
   async function resetTelnetAuthToken(): Promise<boolean> {
     // The methods is used to remove telnet auth token
     //
@@ -451,14 +453,14 @@ export async function adbExec<
     throw new Error('You need to pass in a command to adbExec()');
   }
 
-  const optsCopy = _.cloneDeep(opts ?? {}) as TExecOpts;
+  const optsCopy = cloneDeep(opts ?? {}) as TExecOpts;
   // setting default timeout for each command to prevent infinite wait.
   optsCopy.timeout = optsCopy.timeout || this.adbExecTimeout || DEFAULT_ADB_EXEC_TIMEOUT;
   optsCopy.timeoutCapName = optsCopy.timeoutCapName || 'adbExecTimeout'; // For error message
 
   const {outputFormat = this.EXEC_OUTPUT_FORMAT.STDOUT} = optsCopy;
 
-  cmd = _.isArray(cmd) ? cmd : [cmd];
+  cmd = Array.isArray(cmd) ? cmd : [cmd];
   let adbRetried = false;
   const execFunc = async (): Promise<string | ExecResult> => {
     try {
@@ -495,7 +497,7 @@ export async function adbExec<
         return error.stdout.replace(LINKER_WARNING_REGEXP, '').trim();
       }
 
-      if (_.isNull(error.code)) {
+      if (error.code === null) {
         error.message =
           `Error executing adbExec. Original error: '${error.message}'. ` +
           `Try to increase the ${optsCopy.timeout}ms adb execution timeout ` +
@@ -544,7 +546,7 @@ export async function shell<TShellExecOpts extends ShellExecOptions = ShellExecO
 ): Promise<TShellExecOpts extends TFullOutputOption ? ExecResult : string> {
   const {privileged} = opts ?? ({} as TShellExecOpts);
 
-  const cmdArr = _.isArray(cmd) ? cmd : [cmd];
+  const cmdArr = Array.isArray(cmd) ? cmd : [cmd];
   const fullCmd: string[] = ['shell'];
   if (privileged) {
     log.info(`'adb shell ${util.quote(cmdArr)}' requires root access`);
@@ -592,7 +594,7 @@ export function getAdbServerPort(this: ADB): number {
  */
 export async function getEmulatorPort(this: ADB): Promise<number> {
   log.debug('Getting running emulator port');
-  if (!_.isNil(this.emulatorPort)) {
+  if (this.emulatorPort != null) {
     return this.emulatorPort;
   }
   try {
@@ -605,7 +607,7 @@ export async function getEmulatorPort(this: ADB): Promise<number> {
     }
   } catch (e: unknown) {
     const error = e as Error;
-    throw new Error(`No devices connected. Original error: ${error.message}`);
+    throw new Error(`No devices connected. Original error: ${error.message}`, {cause: e});
   }
 }
 
@@ -647,7 +649,7 @@ export async function getConnectedEmulators(
     return emulators;
   } catch (e: unknown) {
     const error = e as Error;
-    throw new Error(`Error getting emulators. Original error: ${error.message}`);
+    throw new Error(`Error getting emulators. Original error: ${error.message}`, {cause: e});
   }
 }
 
@@ -684,7 +686,7 @@ export function setDeviceId(this: ADB, deviceId: string): void {
 export function setDevice(this: ADB, deviceObj: Device): void {
   const deviceId = deviceObj.udid;
   const emPort = this.getPortFromEmulatorString(deviceId);
-  if (_.isNumber(emPort)) {
+  if (typeof emPort === 'number' && !Number.isNaN(emPort)) {
     this.setEmulatorPort(emPort);
   }
   this.setDeviceId(deviceId);
@@ -705,7 +707,7 @@ export async function getRunningAVD(this: ADB, avdName: string): Promise<Device
   try {
     const emulators = await this.getConnectedEmulators();
     for (const emulator of emulators) {
-      if (_.isNumber(emulator.port)) {
+      if (typeof emulator.port === 'number' && !Number.isNaN(emulator.port)) {
         this.setEmulatorPort(emulator.port);
       }
       const runningAVDName = await this.execEmuConsoleCommand(['avd', 'name'], {
@@ -713,7 +715,7 @@ export async function getRunningAVD(this: ADB, avdName: string): Promise<Device
         execTimeout: 5000,
         connTimeout: 1000,
       });
-      if (_.toLower(avdName) === _.toLower(runningAVDName.trim())) {
+      if (avdName.toLowerCase() === runningAVDName.trim().toLowerCase()) {
         log.debug(`Found emulator '${avdName}' on port ${emulator.port}`);
         this.setDeviceId(emulator.udid);
         return emulator;
@@ -723,7 +725,7 @@ export async function getRunningAVD(this: ADB, avdName: string): Promise<Device
     return null;
   } catch (e: unknown) {
     const error = e as Error;
-    throw new Error(`Error getting AVD. Original error: ${error.message}`);
+    throw new Error(`Error getting AVD. Original error: ${error.message}`, {cause: e});
   }
 }
 
@@ -758,7 +760,9 @@ export async function getRunningAVDWithRetry(
     )) as Device | null;
   } catch (e: unknown) {
     const error = e as Error;
-    throw new Error(`Error getting AVD with retry. Original error: ${error.message}`);
+    throw new Error(`Error getting AVD with retry. Original error: ${error.message}`, {
+      cause: e,
+    });
   }
 }
 
@@ -781,7 +785,7 @@ export async function killAllEmulators(this: ADB): Promise<void> {
     await exec(cmd, args);
   } catch (e: unknown) {
     const error = e as Error;
-    throw new Error(`Error killing emulators. Original error: ${error.message}`);
+    throw new Error(`Error killing emulators. Original error: ${error.message}`, {cause: e});
   }
 }
 
@@ -906,12 +910,12 @@ export async function launchAVD(
     log.info('The -delay-adb emulator startup detection feature has been explicitly disabled');
   }
 
-  if (!_.isEmpty(args)) {
-    launchArgs.push(...(_.isArray(args) ? args : util.shellParse(`${args}`)));
+  if (!util.isEmpty(args)) {
+    launchArgs.push(...(Array.isArray(args) ? args : util.shellParse(`${args}`)));
   }
 
   log.debug(`Running '${emulatorBinaryPath}' with args: ${util.quote(launchArgs)}`);
-  if (!_.isEmpty(env)) {
+  if (!util.isEmpty(env)) {
     log.debug(`Customized emulator environment: ${JSON.stringify(env)}`);
   }
   const proc = new SubProcess(emulatorBinaryPath, launchArgs, {
@@ -939,6 +943,7 @@ export async function launchAVD(
       const error = e as ExecError;
       throw new Error(
         `'${processedAvdName}' Emulator has failed to boot: ${error.stderr || error.message}`,
+        {cause: e},
       );
     }
   }
@@ -952,13 +957,13 @@ export async function launchAVD(
  * @returns Version information object
  * @throws {Error} If error occurs while getting adb version
  */
-export const getVersion = _.memoize(async function getVersion(this: ADB): Promise<Version> {
+export const getVersion = memoize(async function getVersion(this: ADB): Promise<Version> {
   let stdout: string;
   try {
     stdout = await this.adbExec('version');
   } catch (e: unknown) {
     const error = e as ExecError;
-    throw new Error(`Error getting adb version: ${error.stderr || error.message}`);
+    throw new Error(`Error getting adb version: ${error.stderr || error.message}`, {cause: e});
   }
 
   const result: Partial<Version> = {};
@@ -1044,7 +1049,7 @@ export async function waitForEmulatorReady(this: ADB, timeoutMs: number = 20000)
     let suffix = '';
     const servicesValue = services;
     if (servicesValue) {
-      const missingServices = _.zip(REQUIRED_SERVICES, requiredServicesRe)
+      const missingServices = zip(REQUIRED_SERVICES, requiredServicesRe)
         .filter(([, pattern]) => !(pattern as RegExp).test(servicesValue))
         .map(([name]) => name);
       suffix = ` (${missingServices} service${missingServices.length === 1 ? ' is' : 's are'} not running)`;
@@ -1133,6 +1138,7 @@ export async function reboot(
       throw new Error(
         `Could not reboot device. Rebooting requires root access and ` +
           `attempt to get root access on device failed with error: '${message}'`,
+        {cause: e},
       );
     }
     throw error;
@@ -1293,6 +1299,7 @@ export async function installMitmCertificate(this: ADB, cert: Buffer | string):
         `Is the certificate properly encoded into base64-string? ` +
         `Do you have root permissions on the device? ` +
         `Original error: ${error.message}`,
+      {cause: err},
     );
   } finally {
     await fs.rimraf(tmpRoot);
@@ -1325,6 +1332,7 @@ export async function isMitmCertificateInstalled(
       `Cannot retrieve the certificate hash. ` +
         `Is the certificate properly encoded into base64-string? ` +
         `Original error: ${error.message}`,
+      {cause: err},
     );
   } finally {
     await fs.rimraf(tmpRoot);
@@ -1353,10 +1361,10 @@ export async function shellChunks(
   let cmdChunk: string[] = [];
   for (const arg of args) {
     const nextCmd = argTransformer(arg);
-    if (!_.isArray(nextCmd)) {
+    if (!Array.isArray(nextCmd)) {
       throw new Error('Argument transformer must result in an array');
     }
-    if (_.last(nextCmd) !== ';') {
+    if (nextCmd.at(-1) !== ';') {
       nextCmd.push(';');
     }
     if (nextCmd.join(' ').length + cmdChunk.join(' ').length >= MAX_SHELL_BUFFER_LENGTH) {
@@ -1365,7 +1373,7 @@ export async function shellChunks(
     }
     cmdChunk = [...cmdChunk, ...nextCmd];
   }
-  if (!_.isEmpty(cmdChunk)) {
+  if (!util.isEmpty(cmdChunk)) {
     commands.push(cmdChunk);
   }
   log.debug(`Got the following command chunks to execute: ${JSON.stringify(commands)}`);
@@ -1392,18 +1400,18 @@ export async function shellChunks(
  */
 export function toAvdLocaleArgs(language: string | null, country: string | null): string[] {
   const result: string[] = [];
-  if (language && _.isString(language)) {
+  if (language && typeof language === 'string') {
     result.push('-prop', `persist.sys.language=${language.toLowerCase()}`);
   }
-  if (country && _.isString(country)) {
+  if (country && typeof country === 'string') {
     result.push('-prop', `persist.sys.country=${country.toUpperCase()}`);
   }
   let locale: string | undefined;
-  if (_.isString(language) && _.isString(country) && language && country) {
+  if (typeof language === 'string' && typeof country === 'string' && language && country) {
     locale = language.toLowerCase() + '-' + country.toUpperCase();
-  } else if (language && _.isString(language)) {
+  } else if (language && typeof language === 'string') {
     locale = language.toLowerCase();
-  } else if (country && _.isString(country)) {
+  } else if (country && typeof country === 'string') {
     locale = country;
   }
   if (locale) {
@@ -1419,7 +1427,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(
+export const getBuildToolsDirs = memoize(async function getBuildToolsDirs(
   sdkRoot: string,
 ): Promise<string[]> {
   let buildToolsDirs = await fs.glob('*/', {

package/lib/tools/types.ts

@@ -1,4 +1,4 @@
-import * as emuConstants from './emu-constants';
+import type * as emuConstants from './emu-constants';
 
 export type StringRecord<T = any> = Record<string, T>;
 

package/lib/utils/helpers/constants.ts

@@ -0,0 +1,6 @@
+export const APKS_EXTENSION = '.apks';
+export const APK_EXTENSION = '.apk';
+export const APK_INSTALL_TIMEOUT = 60000;
+export const DEFAULT_ADB_EXEC_TIMEOUT = 20000; // in milliseconds
+
+export const MODULE_NAME = 'appium-adb';