appium-adb 14.1.0 → 14.1.2

package/lib/helpers.ts

@@ -1,10 +1,10 @@
 import path from 'path';
-import { system, fs, zip, util } from '@appium/support';
-import { log } from './logger.js';
+import {system, fs, zip, util} from '@appium/support';
+import {log} from './logger.js';
 import _ from 'lodash';
-import { exec, type ExecError } from 'teen_process';
-import type { ADB } from './adb.js';
-import type { ApkManifest } from './tools/types.js';
+import {exec, type ExecError} from 'teen_process';
+import type {ADB} from './adb.js';
+import type {ApkManifest} from './tools/types.js';
 
 // Declare __filename for CommonJS compatibility
 declare const __filename: string;
@@ -21,12 +21,16 @@ const MODULE_NAME = 'appium-adb';
 /**
  * Calculates the absolute path to the given resource
  */
-export const getResourcePath = _.memoize(async function getResourcePath (relPath: string): Promise<string> {
+export const getResourcePath = _.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`);
+  if (!(await fs.exists(resultPath))) {
+    throw new Error(
+      `Cannot find the resource '${relPath}' under the '${moduleRoot}' ` +
+        `folder of ${MODULE_NAME} Node.js module`,
+    );
   }
   return resultPath;
 });
@@ -34,21 +38,26 @@ export const getResourcePath = _.memoize(async function getResourcePath (relPath
 /**
  * Retrieves the actual path to SDK root folder from the system environment
  */
-export function getSdkRootFromEnv (): string | undefined {
+export function getSdkRootFromEnv(): string | undefined {
   return process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT;
 }
 
 /**
  * Retrieves the actual path to SDK root folder
  */
-export async function requireSdkRoot (customRoot: string | null = null): Promise<string> {
+export async function requireSdkRoot(customRoot: string | null = null): Promise<string> {
   const sdkRoot = customRoot || getSdkRootFromEnv();
-  const docMsg = 'Read https://developer.android.com/studio/command-line/variables for more details';
+  const docMsg =
+    'Read https://developer.android.com/studio/command-line/variables for more details';
   if (!sdkRoot || _.isEmpty(sdkRoot)) {
-    throw new Error(`Neither ANDROID_HOME nor ANDROID_SDK_ROOT environment variable was exported. ${docMsg}`);
+    throw new Error(
+      `Neither ANDROID_HOME nor ANDROID_SDK_ROOT environment variable was exported. ${docMsg}`,
+    );
   }
-  if (!await fs.exists(sdkRoot)) {
-    throw new Error(`The Android SDK root folder '${sdkRoot}' does not exist on the local file system. ${docMsg}`);
+  if (!(await fs.exists(sdkRoot))) {
+    throw new Error(
+      `The Android SDK root folder '${sdkRoot}' does not exist on the local file system. ${docMsg}`,
+    );
   }
 
   const stats = await fs.stat(sdkRoot);
@@ -62,19 +71,22 @@ export async function requireSdkRoot (customRoot: string | null = null): Promise
  * @param zipPath
  * @param dstRoot
  */
-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);
   log.debug('Unzip successful');
 }
 
-export const getJavaHome = _.memoize(async function getJavaHome (): Promise<string> {
+export const getJavaHome = _.memoize(async function getJavaHome(): Promise<string> {
   const result = process.env.JAVA_HOME;
   if (!result) {
     throw new Error('The JAVA_HOME environment variable is not set for the current process');
   }
-  if (!await fs.exists(result)) {
+  if (!(await fs.exists(result))) {
     throw new Error(`The JAVA_HOME location '${result}' must exist`);
   }
   const stats = await fs.stat(result);
@@ -84,7 +96,7 @@ export const getJavaHome = _.memoize(async function getJavaHome (): Promise<stri
   return result;
 });
 
-export const getJavaForOs = _.memoize(async function getJavaForOs (): Promise<string> {
+export const getJavaForOs = _.memoize(async function getJavaForOs(): Promise<string> {
   let javaHome: string | undefined;
   let errMsg: string | undefined;
   try {
@@ -105,16 +117,18 @@ export const getJavaForOs = _.memoize(async function getJavaForOs (): Promise<st
   } catch {
     // Ignore and throw custom error below
   }
-  throw new Error(`The '${executableName}' binary could not be found ` +
-    `neither in PATH nor under JAVA_HOME (${javaHome ? path.resolve(javaHome, 'bin') : errMsg})`);
+  throw new Error(
+    `The '${executableName}' binary could not be found ` +
+      `neither in PATH nor under JAVA_HOME (${javaHome ? path.resolve(javaHome, 'bin') : errMsg})`,
+  );
 });
 
 /**
  * Transforms given options into the list of `adb install.install-multiple` command arguments
  */
-export function buildInstallArgs (
+export function buildInstallArgs(
   apiLevel: number,
-  options: BuildInstallArgsOptions = {}
+  options: BuildInstallArgsOptions = {},
 ): string[] {
   const result: string[] = [];
 
@@ -129,9 +143,11 @@ export function buildInstallArgs (
   }
   if (options.grantPermissions) {
     if (apiLevel < 23) {
-      log.debug(`Skipping permissions grant option, since ` +
-                `the current API level ${apiLevel} does not support applications ` +
-                `permissions customization`);
+      log.debug(
+        `Skipping permissions grant option, since ` +
+          `the current API level ${apiLevel} does not support applications ` +
+          `permissions customization`,
+      );
     } else {
       result.push('-g');
     }
@@ -148,7 +164,7 @@ export function buildInstallArgs (
  * Extracts various package manifest details
  * from the given application file.
  */
-export async function readPackageManifest (this: ADB, apkPath: string): Promise<ApkManifest> {
+export async function readPackageManifest(this: ADB, apkPath: string): Promise<ApkManifest> {
   await this.initAapt2();
   const aapt2Binary = this.binaries?.aapt2;
   if (!aapt2Binary) {
@@ -173,7 +189,7 @@ export async function readPackageManifest (this: ADB, apkPath: string): Promise<
   const extractValue = (
     line: string,
     propPattern: RegExp,
-    valueTransformer: ((x: string) => any) | null
+    valueTransformer: ((x: string) => any) | null,
   ): any => {
     const match = propPattern.exec(line);
     if (match) {
@@ -184,7 +200,7 @@ export async function readPackageManifest (this: ADB, apkPath: string): Promise<
   const extractArray = (
     line: string,
     propPattern: RegExp,
-    valueTransformer: ((x: string) => any) | null
+    valueTransformer: ((x: string) => any) | null,
   ): any[] => {
     let match: RegExpExecArray | null;
     const resultArray: any[] = [];
@@ -220,11 +236,7 @@ export async function readPackageManifest (this: ADB, apkPath: string): Promise<
         ['compileSdkVersion', /compileSdkVersion='([^']+)'/, toInt],
         ['compileSdkVersionCodename', /compileSdkVersionCodename='([^']+)'/, null],
       ] as const) {
-        const value = extractValue(
-          line,
-          pattern,
-          transformer
-        );
+        const value = extractValue(line, pattern, transformer);
         if (!_.isUndefined(value)) {
           (result as Record<string, any>)[name] = value;
         }
@@ -271,7 +283,7 @@ export async function readPackageManifest (this: ADB, apkPath: string): Promise<
 /**
  * Calculates the absolute path to the current module's root folder
  */
-const getModuleRoot = _.memoize(async function getModuleRoot (): Promise<string> {
+const getModuleRoot = _.memoize(async function getModuleRoot(): Promise<string> {
   let moduleRoot = path.dirname(path.resolve(__filename));
   let isAtFsRoot = false;
   while (!isAtFsRoot) {
@@ -279,7 +291,7 @@ const getModuleRoot = _.memoize(async function getModuleRoot (): Promise<string>
     try {
       if (await fs.exists(manifestPath)) {
         const manifestContent = await fs.readFile(manifestPath, 'utf8');
-        const manifest = JSON.parse(manifestContent) as { name?: string };
+        const manifest = JSON.parse(manifestContent) as {name?: string};
         if (manifest.name === MODULE_NAME) {
           return moduleRoot;
         }

package/lib/logcat.ts

@@ -1,20 +1,26 @@
-import { logger, util } from '@appium/support';
+import {logger, util} from '@appium/support';
 import B from 'bluebird';
 import _ from 'lodash';
-import { EventEmitter } from 'node:events';
-import { SubProcess, exec } from 'teen_process';
-import { LRUCache } from 'lru-cache';
-import type { ExecError } from 'teen_process';
-import type { ADBExecutable } from './types';
-import type {
-  LogEntry,
-  LogcatOpts as StartCaptureOptions,
-} from './tools/types';
+import {EventEmitter} from 'node:events';
+import {SubProcess, exec} from 'teen_process';
+import {LRUCache} from 'lru-cache';
+import type {ExecError} from 'teen_process';
+import type {ADBExecutable} from './types';
+import type {LogEntry, LogcatOpts as StartCaptureOptions} from './tools/types';
 
 const log = logger.getLogger('Logcat');
 const MAX_BUFFER_SIZE = 10000;
 const LOGCAT_PROC_STARTUP_TIMEOUT = 10000;
-const SUPPORTED_FORMATS = ['brief', 'process', 'tag', 'thread', 'raw', 'time', 'threadtime', 'long'] as const;
+const SUPPORTED_FORMATS = [
+  'brief',
+  'process',
+  'tag',
+  'thread',
+  'raw',
+  'time',
+  'threadtime',
+  'long',
+] as const;
 const SUPPORTED_PRIORITIES = ['v', 'd', 'i', 'w', 'e', 'f', 's'] as const;
 const DEFAULT_PRIORITY = 'v';
 const DEFAULT_TAG = '*';
@@ -70,14 +76,12 @@ export class Logcat extends EventEmitter {
         await this.clear();
       }
 
-      const {
-        format = DEFAULT_FORMAT,
-        filterSpecs = [],
-      } = opts;
+      const {format = DEFAULT_FORMAT, filterSpecs = []} = opts;
       const cmd = [
         ...this.adb.defaultArgs,
         'logcat',
-        '-v', requireFormat(format),
+        '-v',
+        requireFormat(format),
         ...formatFilterSpecs(filterSpecs),
       ];
       log.debug(`Starting logs capture with command: ${util.quote([this.adb.path, ...cmd])}`);
@@ -129,8 +133,10 @@ export class Logcat extends EventEmitter {
         continue;
       }
       const [message, timestamp] = value;
-      if (this.logIndexSinceLastRequest && index > this.logIndexSinceLastRequest
-          || !this.logIndexSinceLastRequest) {
+      if (
+        (this.logIndexSinceLastRequest && index > this.logIndexSinceLastRequest) ||
+        !this.logIndexSinceLastRequest
+      ) {
         recentLogIndex = index;
         result.push(toLogEntry(message, timestamp));
       }
@@ -185,7 +191,7 @@ export default Logcat;
 
 // Private entities
 
-type LogFormat = typeof SUPPORTED_FORMATS[number];
+type LogFormat = (typeof SUPPORTED_FORMATS)[number];
 
 function requireFormat(format: string): LogFormat {
   if (!SUPPORTED_FORMATS.includes(format as LogFormat)) {
@@ -213,11 +219,15 @@ function requireSpec(spec: string): string {
     resultTag = DEFAULT_TAG;
   }
   if (!priority) {
-    log.info(`The priority value in spec '${spec}' is empty. Defaulting to Verbose (${DEFAULT_PRIORITY})`);
+    log.info(
+      `The priority value in spec '${spec}' is empty. Defaulting to Verbose (${DEFAULT_PRIORITY})`,
+    );
     return `${resultTag}:${DEFAULT_PRIORITY}`;
   }
   if (!SUPPORTED_PRIORITIES.some((p) => _.toLower(priority) === _.toLower(p))) {
-    log.info(`The priority value in spec '${spec}' is unknown. Supported values are: ${SUPPORTED_PRIORITIES}`);
+    log.info(
+      `The priority value in spec '${spec}' is unknown. Supported values are: ${SUPPORTED_PRIORITIES}`,
+    );
     log.info(`Defaulting to Verbose (${DEFAULT_PRIORITY})`);
     return `${resultTag}:${DEFAULT_PRIORITY}`;
   }
@@ -230,5 +240,5 @@ function formatFilterSpecs(filterSpecs: string | string[]): string[] {
   }
   return filterSpecs
     .filter((spec) => spec && _.isString(spec) && !spec.startsWith('-'))
-    .map((spec) => spec.includes(':') ? requireSpec(spec) : spec);
+    .map((spec) => (spec.includes(':') ? requireSpec(spec) : spec));
 }

package/lib/logger.ts

@@ -1,4 +1,3 @@
-import { logger } from '@appium/support';
+import {logger} from '@appium/support';
 
 export const log = logger.getLogger('ADB');
-

package/lib/tools/aab-utils.js

@@ -1,8 +1,8 @@
-import { log } from '../logger.js';
+import {log} from '../logger.js';
 import path from 'path';
-import { fs, tempDir, util } from '@appium/support';
-import { LRUCache } from 'lru-cache';
-import { unzipFile } from '../helpers.js';
+import {fs, tempDir, util} from '@appium/support';
+import {LRUCache} from 'lru-cache';
+import {unzipFile} from '../helpers.js';
 import AsyncLock from 'async-lock';
 import B from 'bluebird';
 import crypto from 'crypto';
@@ -21,19 +21,19 @@ process.on('exit', () => {
   }
 
   const paths = /** @type {string[]} */ ([...AAB_CACHE.values()]);
-  log.debug(`Performing cleanup of ${paths.length} cached .aab ` +
-    util.pluralize('package', paths.length));
+  log.debug(
+    `Performing cleanup of ${paths.length} cached .aab ` + util.pluralize('package', paths.length),
+  );
   for (const appPath of paths) {
     try {
       // Asynchronous calls are not supported in onExit handler
       fs.rimrafSync(appPath);
     } catch (e) {
-      log.warn((/** @type {Error} */ (e)).message);
+      log.warn(/** @type {Error} */ (e).message);
     }
   }
 });
 
-
 /**
  * Builds a universal .apk from the given .aab package. See
  * https://developer.android.com/studio/command-line/bundletool#generate_apks
@@ -46,8 +46,8 @@ process.on('exit', () => {
  * by default.
  * @throws {Error} If there was an error while creating the universal .apk
  */
-export async function extractUniversalApk (aabPath, opts = {}) {
-  if (!await fs.exists(aabPath)) {
+export async function extractUniversalApk(aabPath, opts = {}) {
+  if (!(await fs.exists(aabPath))) {
     throw new Error(`The file at '${aabPath}' either does not exist or is not accessible`);
   }
 
@@ -58,21 +58,19 @@ export async function extractUniversalApk (aabPath, opts = {}) {
   try {
     return await AAB_CACHE_GUARD.acquire(aabPath, async () => {
       const aabHash = await fs.hash(aabPath);
-      const {
-        keystore,
-        keystorePassword,
-        keyAlias,
-        keyPassword,
-      } = opts;
+      const {keystore, keystorePassword, keyAlias, keyPassword} = opts;
       let cacheHash = aabHash;
       if (keystore) {
-        if (!await fs.exists(keystore)) {
-          throw new Error(`The keystore file at '${keystore}' either does not exist ` +
-            `or is not accessible`);
+        if (!(await fs.exists(keystore))) {
+          throw new Error(
+            `The keystore file at '${keystore}' either does not exist ` + `or is not accessible`,
+          );
         }
         if (!keystorePassword || !keyAlias || !keyPassword) {
-          throw new Error('It is mandatory to also provide keystore password, key alias, ' +
-            'and key password if the keystore path is set');
+          throw new Error(
+            'It is mandatory to also provide keystore password, key alias, ' +
+              'and key password if the keystore path is set',
+          );
         }
         const keystoreHash = await fs.hash(keystore);
         const keyAliasHash = crypto.createHash('sha1');
@@ -91,16 +89,25 @@ export async function extractUniversalApk (aabPath, opts = {}) {
       await this.initAapt2();
       const args = [
         'build-apks',
-        '--aapt2', (/** @type {import('./types').StringRecord} */ (this.binaries)).aapt2,
-        '--bundle', aabPath,
-        '--output', tmpApksPath,
-        ...(keystore ? [
-          '--ks', keystore,
-          '--ks-pass', `pass:${keystorePassword}`,
-          '--ks-key-alias', keyAlias,
-          '--key-pass', `pass:${keyPassword}`,
-        ] : []),
-        '--mode=universal'
+        '--aapt2',
+        /** @type {import('./types').StringRecord} */ (this.binaries).aapt2,
+        '--bundle',
+        aabPath,
+        '--output',
+        tmpApksPath,
+        ...(keystore
+          ? [
+              '--ks',
+              keystore,
+              '--ks-pass',
+              `pass:${keystorePassword}`,
+              '--ks-key-alias',
+              keyAlias,
+              '--key-pass',
+              `pass:${keyPassword}`,
+            ]
+          : []),
+        '--mode=universal',
       ];
       log.debug(`Preparing universal .apks bundle from '${aabPath}'`);
       await this.execBundletool(args, `Cannot build a universal .apks bundle from '${aabPath}'`);
@@ -123,8 +130,10 @@ export async function extractUniversalApk (aabPath, opts = {}) {
       } catch {}
       if (!universalApkPath) {
         log.debug(`The following items were extracted from the .aab bundle: ${allFileNames}`);
-        throw new Error(`${UNIVERSAL_APK} cannot be found in '${aabPath}' bundle. ` +
-          `Does the archive contain a valid application bundle?`);
+        throw new Error(
+          `${UNIVERSAL_APK} cannot be found in '${aabPath}' bundle. ` +
+            `Does the archive contain a valid application bundle?`,
+        );
       }
       const resultPath = path.join(tmpRoot, apkName);
       log.debug(`Found ${UNIVERSAL_APK} at '${universalApkPath}'. Caching it to '${resultPath}'`);

package/lib/tools/android-manifest.js

@@ -1,12 +1,8 @@
 import _ from 'lodash';
-import { exec } from 'teen_process';
-import { log } from '../logger.js';
-import {
-  unzipFile,
-  APKS_EXTENSION,
-  readPackageManifest,
-} from '../helpers.js';
-import { fs, zip, tempDir, util } from '@appium/support';
+import {exec} from 'teen_process';
+import {log} from '../logger.js';
+import {unzipFile, APKS_EXTENSION, readPackageManifest} from '../helpers.js';
+import {fs, zip, tempDir, util} from '@appium/support';
 import path from 'path';
 
 /**
@@ -18,16 +14,14 @@ import path from 'path';
  * @throws {error} If there was an error while getting the data from the given
  *                 application package.
  */
-export async function packageAndLaunchActivityFromManifest (appPath) {
+export async function packageAndLaunchActivityFromManifest(appPath) {
   if (appPath.endsWith(APKS_EXTENSION)) {
     appPath = await this.extractBaseApk(appPath);
   }
 
   const {
     name: apkPackage,
-    launchableActivity: {
-      name: apkActivity,
-    },
+    launchableActivity: {name: apkActivity},
   } = await readPackageManifest.bind(this)(appPath);
   log.info(`Package name: '${apkPackage}'`);
   log.info(`Main activity name: '${apkActivity}'`);
@@ -43,7 +37,7 @@ export async function packageAndLaunchActivityFromManifest (appPath) {
  * @throws {error} If there was an error while getting the data from the given
  *                 application package.
  */
-export async function targetSdkVersionFromManifest (appPath) {
+export async function targetSdkVersionFromManifest(appPath) {
   log.debug(`Extracting target SDK version of '${appPath}'`);
   const originalAppPath = appPath;
   if (appPath.endsWith(APKS_EXTENSION)) {
@@ -54,7 +48,7 @@ export async function targetSdkVersionFromManifest (appPath) {
   if (!targetSdkVersion) {
     throw new Error(
       `Cannot extract targetSdkVersion of '${originalAppPath}'. Does ` +
-      `the package manifest define it?`
+        `the package manifest define it?`,
     );
   }
   return targetSdkVersion;
@@ -69,8 +63,8 @@ export async function targetSdkVersionFromManifest (appPath) {
  * _dumpsys package_ command. It may speed up the method execution.
  * @return {Promise<number>} The version of the target SDK.
  */
-export async function targetSdkVersionUsingPKG (pkg, cmdOutput = null) {
-  const stdout = cmdOutput || await this.shell(['dumpsys', 'package', pkg]);
+export async function targetSdkVersionUsingPKG(pkg, cmdOutput = null) {
+  const stdout = cmdOutput || (await this.shell(['dumpsys', 'package', pkg]));
   const targetSdkVersionMatch = new RegExp(/targetSdk=([^\s\s]+)/g).exec(stdout);
   return targetSdkVersionMatch && targetSdkVersionMatch.length >= 2
     ? parseInt(targetSdkVersionMatch[1], 10)
@@ -87,10 +81,14 @@ export async function targetSdkVersionUsingPKG (pkg, cmdOutput = null) {
  * @param {string} manifestPackage - The name of the manifest package
  * @param {string} targetPackage - The name of the destination package
  */
-export async function compileManifest (manifest, manifestPackage, targetPackage) {
-  const {platform, platformPath} = await getAndroidPlatformAndPath(/** @type {string} */ (this.sdkRoot));
+export async function compileManifest(manifest, manifestPackage, targetPackage) {
+  const {platform, platformPath} = await getAndroidPlatformAndPath(
+    /** @type {string} */ (this.sdkRoot),
+  );
   if (!platform || !platformPath) {
-    throw new Error('Cannot compile the manifest. The required platform does not exist (API level >= 17)');
+    throw new Error(
+      'Cannot compile the manifest. The required platform does not exist (API level >= 17)',
+    );
   }
   const resultPath = `${manifest}.apk`;
   const androidJarPath = path.resolve(platformPath, 'android.jar');
@@ -102,37 +100,53 @@ export async function compileManifest (manifest, manifestPackage, targetPackage)
     // https://developer.android.com/studio/command-line/aapt2
     const args = [
       'link',
-      '-o', resultPath,
-      '--manifest', manifest,
-      '--rename-manifest-package', manifestPackage,
-      '--rename-instrumentation-target-package', targetPackage,
-      '-I', androidJarPath,
+      '-o',
+      resultPath,
+      '--manifest',
+      manifest,
+      '--rename-manifest-package',
+      manifestPackage,
+      '--rename-instrumentation-target-package',
+      targetPackage,
+      '-I',
+      androidJarPath,
       '-v',
     ];
-    log.debug(`Compiling the manifest using '${util.quote([
-      (/** @type {import('./types').StringRecord} */ (this.binaries)).aapt2,
-      ...args
-    ])}'`);
-    await exec((/** @type {import('./types').StringRecord} */ (this.binaries)).aapt2, args);
+    log.debug(
+      `Compiling the manifest using '${util.quote([
+        /** @type {import('./types').StringRecord} */ (this.binaries).aapt2,
+        ...args,
+      ])}'`,
+    );
+    await exec(/** @type {import('./types').StringRecord} */ (this.binaries).aapt2, args);
   } catch (e) {
-    log.debug('Cannot compile the manifest using aapt2. Defaulting to aapt. ' +
-      `Original error: ${e.stderr || e.message}`);
+    log.debug(
+      'Cannot compile the manifest using aapt2. Defaulting to aapt. ' +
+        `Original error: ${e.stderr || e.message}`,
+    );
     await this.initAapt();
     const args = [
       'package',
-      '-M', manifest,
-      '--rename-manifest-package', manifestPackage,
-      '--rename-instrumentation-target-package', targetPackage,
-      '-I', androidJarPath,
-      '-F', resultPath,
+      '-M',
+      manifest,
+      '--rename-manifest-package',
+      manifestPackage,
+      '--rename-instrumentation-target-package',
+      targetPackage,
+      '-I',
+      androidJarPath,
+      '-F',
+      resultPath,
       '-f',
     ];
-    log.debug(`Compiling the manifest using '${util.quote([
-      (/** @type {import('./types').StringRecord} */ (this.binaries)).aapt,
-      ...args
-    ])}'`);
+    log.debug(
+      `Compiling the manifest using '${util.quote([
+        /** @type {import('./types').StringRecord} */ (this.binaries).aapt,
+        ...args,
+      ])}'`,
+    );
     try {
-      await exec((/** @type {import('./types').StringRecord} */ (this.binaries)).aapt, args);
+      await exec(/** @type {import('./types').StringRecord} */ (this.binaries).aapt, args);
     } catch (e1) {
       throw new Error(`Cannot compile the manifest. Original error: ${e1.stderr || e1.message}`);
     }
@@ -154,7 +168,7 @@ export async function compileManifest (manifest, manifestPackage, targetPackage)
  * @param {string} dstApk - Full path to the resulting package.
  *                          The file will be overridden if it already exists.
  */
-export async function insertManifest (manifest, srcApk, dstApk) {
+export async function insertManifest(manifest, srcApk, dstApk) {
   log.debug(`Inserting manifest '${manifest}', src: '${srcApk}', dst: '${dstApk}'`);
   await zip.assertValidZip(srcApk);
   await unzipFile(`${manifest}.apk`);
@@ -164,16 +178,22 @@ export async function insertManifest (manifest, srcApk, dstApk) {
     await fs.copyFile(srcApk, dstApk);
     log.debug('Moving manifest');
     try {
-      await exec((/** @type {import('./types').StringRecord} */ (this.binaries)).aapt, [
-        'remove', dstApk, manifestName
+      await exec(/** @type {import('./types').StringRecord} */ (this.binaries).aapt, [
+        'remove',
+        dstApk,
+        manifestName,
       ]);
     } catch {}
-    await exec((/** @type {import('./types').StringRecord} */ (this.binaries)).aapt, [
-      'add', dstApk, manifestName
-    ], {cwd: path.dirname(manifest)});
+    await exec(
+      /** @type {import('./types').StringRecord} */ (this.binaries).aapt,
+      ['add', dstApk, manifestName],
+      {cwd: path.dirname(manifest)},
+    );
   } catch (e) {
-    log.debug('Cannot insert manifest using aapt. Defaulting to zip. ' +
-      `Original error: ${e.stderr || e.message}`);
+    log.debug(
+      'Cannot insert manifest using aapt. Defaulting to zip. ' +
+        `Original error: ${e.stderr || e.message}`,
+    );
     const tmpRoot = await tempDir.openDir();
     try {
       // Unfortunately NodeJS does not provide any reliable methods
@@ -201,14 +221,16 @@ export async function insertManifest (manifest, srcApk, dstApk) {
  * @param {string} appPath - The full path to .apk(s) package.
  * @return {Promise<boolean>} True if the manifest requires Internet access permission.
  */
-export async function hasInternetPermissionFromManifest (appPath) {
+export async function hasInternetPermissionFromManifest(appPath) {
   log.debug(`Checking if '${appPath}' requires internet access permission in the manifest`);
   if (appPath.endsWith(APKS_EXTENSION)) {
     appPath = await this.extractBaseApk(appPath);
   }
 
   const {usesPermissions} = await readPackageManifest.bind(this)(appPath);
-  return usesPermissions.some((/** @type {string} */ name) => name === 'android.permission.INTERNET');
+  return usesPermissions.some(
+    (/** @type {string} */ name) => name === 'android.permission.INTERNET',
+  );
 }
 
 // #region Private functions
@@ -219,7 +241,7 @@ export async function hasInternetPermissionFromManifest (appPath) {
  * @param {string} sdkRoot
  * @return {Promise<import('./types').PlatformInfo>} The resulting path to the newest installed platform.
  */
-export async function getAndroidPlatformAndPath (sdkRoot) {
+export async function getAndroidPlatformAndPath(sdkRoot) {
   const propsPaths = await fs.glob('*/build.prop', {
     cwd: path.resolve(sdkRoot, 'platforms'),
     absolute: true,
@@ -241,8 +263,10 @@ export async function getAndroidPlatformAndPath (sdkRoot) {
     };
   }
   if (_.isEmpty(platformsMapping)) {
-    log.warn(`Found zero platform folders at '${path.resolve(sdkRoot, 'platforms')}'. ` +
-      `Do you have any Android SDKs installed?`);
+    log.warn(
+      `Found zero platform folders at '${path.resolve(sdkRoot, 'platforms')}'. ` +
+        `Do you have any Android SDKs installed?`,
+    );
     return {
       platform: null,
       platformPath: null,