appium-adb 16.0.0 → 16.0.1

package/lib/tools/app-commands.ts

@@ -1,9 +1,11 @@
+import path from 'node:path';
+
 import {fs, tempDir, util, system} from '@appium/support';
-import {log} from '../logger.js';
 import {waitForCondition} from 'asyncbox';
-import path from 'node:path';
-import type {ADB} from '../adb.js';
 import type {ExecError} from 'teen_process';
+
+import type {ADB} from '../adb.js';
+import {log} from '../logger.js';
 import {defaults, intersectionWith} from '../utils/index.js';
 import type {
   StringRecord,
@@ -82,9 +84,7 @@ export async function resolveLaunchableActivity(
     const names = parseLaunchableActivityNames(stdout);
     if (util.isEmpty(names)) {
       log.debug(stdout);
-      throw new Error(
-        `Unable to resolve the launchable activity of '${pkg}'. Is it installed on the device?`,
-      );
+      throw new Error(`Unable to resolve the launchable activity of '${pkg}'. Is it installed on the device?`);
     }
     if (names.length === 1) {
       return names[0];
@@ -108,20 +108,15 @@ export async function resolveLaunchableActivity(
       await fs.rimraf(tmpRoot);
     }
   }
-  const {stdout, stderr} = await this.shell(
-    ['cmd', 'package', 'resolve-activity', '--brief', pkg],
-    {
-      outputFormat: this.EXEC_OUTPUT_FORMAT.FULL,
-    },
-  );
+  const {stdout, stderr} = await this.shell(['cmd', 'package', 'resolve-activity', '--brief', pkg], {
+    outputFormat: this.EXEC_OUTPUT_FORMAT.FULL,
+  });
   for (const line of (stdout || '').split('\n').map((x) => x.trim())) {
     if (this.isValidClass(line)) {
       return line;
     }
   }
-  throw new Error(
-    `Unable to resolve the launchable activity of '${pkg}'. Original error: ${stderr || stdout}`,
-  );
+  throw new Error(`Unable to resolve the launchable activity of '${pkg}'. Original error: ${stderr || stdout}`);
 }
 
 /**
@@ -193,10 +188,7 @@ export async function grantAllPermissions(this: ADB, pkg: string, apk?: string):
     //avoiding logging error stack, as calling library function would have logged
     log.warn(`Ran into problem getting target SDK version; ignoring...`);
   }
-  if (
-    apiLevel >= MIN_API_LEVEL_WITH_PERMS_SUPPORT &&
-    targetSdk >= MIN_API_LEVEL_WITH_PERMS_SUPPORT
-  ) {
+  if (apiLevel >= MIN_API_LEVEL_WITH_PERMS_SUPPORT && targetSdk >= MIN_API_LEVEL_WITH_PERMS_SUPPORT) {
     /**
      * If the device is running Android 6.0(API 23) or higher, and your app's target SDK is 23 or higher:
      * The app has to list the permissions in the manifest.
@@ -234,11 +226,7 @@ export async function grantAllPermissions(this: ADB, pkg: string, apk?: string):
  * @param permissions - The list of permissions to be granted.
  * @throws {Error} If there was an error while changing permissions.
  */
-export async function grantPermissions(
-  this: ADB,
-  pkg: string,
-  permissions: string[],
-): Promise<void> {
+export async function grantPermissions(this: ADB, pkg: string, permissions: string[]): Promise<void> {
   // As it consumes more time for granting each permission,
   // trying to grant all permission by forming equivalent command.
   // Also, it is necessary to split long commands into chunks, since the maximum length of
@@ -317,11 +305,7 @@ export async function getGrantedPermissions(
  * _dumpsys package_ command. It may speed up the method execution.
  * @returns The list of denied permissions or an empty list.
  */
-export async function getDeniedPermissions(
-  this: ADB,
-  pkg: string,
-  cmdOutput: string | null = null,
-): Promise<string[]> {
+export async function getDeniedPermissions(this: ADB, pkg: string, cmdOutput: string | null = null): Promise<string[]> {
   log.debug('Retrieving denied permissions');
   const stdout = cmdOutput || (await this.shell(['dumpsys', 'package', pkg]));
   return extractMatchingPermissions(stdout, ['install', 'runtime'], false);
@@ -335,11 +319,7 @@ export async function getDeniedPermissions(
  *                                    _dumpsys package_ command. It may speed up the method execution.
  * @returns The list of requested permissions or an empty list.
  */
-export async function getReqPermissions(
-  this: ADB,
-  pkg: string,
-  cmdOutput: string | null = null,
-): Promise<string[]> {
+export async function getReqPermissions(this: ADB, pkg: string, cmdOutput: string | null = null): Promise<string[]> {
   log.debug('Retrieving requested permissions');
   const stdout = cmdOutput || (await this.shell(['dumpsys', 'package', pkg]));
   return extractMatchingPermissions(stdout, ['requested']);
@@ -379,10 +359,7 @@ export async function getPackageInfo(this: ADB, pkg: string): Promise<AppInfo> {
     return result;
   }
 
-  const installedPattern = new RegExp(
-    `^\\s*Package\\s+\\[${util.escapeRegExp(pkg)}\\][^:]+:$`,
-    'm',
-  );
+  const installedPattern = new RegExp(`^\\s*Package\\s+\\[${util.escapeRegExp(pkg)}\\][^:]+:$`, 'm');
   result.isInstalled = installedPattern.test(stdout);
   if (!result.isInstalled) {
     return result;
@@ -489,11 +466,7 @@ export async function activateApp(this: ADB, appId: string): Promise<void> {
  * @param opts - Options for checking installation
  * @returns True if the package is installed.
  */
-export async function isAppInstalled(
-  this: ADB,
-  pkg: string,
-  opts: IsAppInstalledOptions = {},
-): Promise<boolean> {
+export async function isAppInstalled(this: ADB, pkg: string, opts: IsAppInstalledOptions = {}): Promise<boolean> {
   const {user} = opts;
 
   log.debug(`Getting install status for ${pkg}`);
@@ -549,10 +522,7 @@ export async function listInstalledPackages(
   } catch (e) {
     const error = e as ExecError;
     // https://github.com/appium/appium-uiautomator2-driver/issues/810
-    if (
-      (error.stderr || error.stdout || error.message)?.includes('access user') &&
-      util.isEmpty(user)
-    ) {
+    if ((error.stderr || error.stdout || error.message)?.includes('access user') && util.isEmpty(user)) {
       stdout = await this.shell([...cmd, '--user', '0']);
     } else {
       throw e;
@@ -636,24 +606,17 @@ export async function startApp(this: ADB, startAppOptions: StartAppOptions): Pro
 
   const apiLevel = await this.getApiLevel();
   const cmd = buildStartCmd(options, apiLevel);
-  const intentName = `${options.action}${
-    options.optionalIntentArguments ? ' ' + options.optionalIntentArguments : ''
-  }`;
+  const intentName = `${options.action}${options.optionalIntentArguments ? ' ' + options.optionalIntentArguments : ''}`;
   try {
     const shellOpts: {timeout?: number} = {};
-    if (
-      options.waitDuration !== undefined &&
-      Number.isInteger(options.waitDuration) &&
-      options.waitDuration >= 0
-    ) {
+    if (options.waitDuration !== undefined && Number.isInteger(options.waitDuration) && options.waitDuration >= 0) {
       shellOpts.timeout = options.waitDuration;
     }
     const stdout = await this.shell(cmd, shellOpts);
     if (stdout.includes('Error: Activity class') && stdout.includes('does not exist')) {
       if (options.retry && options.activity && !options.activity.startsWith('.')) {
         log.debug(
-          `We tried to start an activity that doesn't exist, ` +
-            `retrying with '.${options.activity}' activity name`,
+          `We tried to start an activity that doesn't exist, retrying with '.${options.activity}' activity name`,
         );
         options.activity = `.${options.activity}`;
         options.retry = false;
@@ -722,10 +685,9 @@ export async function getFocusedPackageAndActivity(this: ADB): Promise<PackageAc
     stdout = await this.dumpWindows();
   } catch (e) {
     const error = e as Error;
-    throw new Error(
-      `Could not retrieve the currently focused package and activity. Original error: ${error.message}`,
-      {cause: e},
-    );
+    throw new Error(`Could not retrieve the currently focused package and activity. Original error: ${error.message}`, {
+      cause: e,
+    });
   }
 
   const nullFocusedAppRe = /^\s*mFocusedApp=null/m;
@@ -735,10 +697,7 @@ export async function getFocusedPackageAndActivity(this: ADB): Promise<PackageAc
     'mg',
   );
   const nullCurrentFocusRe = /^\s*mCurrentFocus=null/m;
-  const currentFocusAppRe = new RegExp(
-    '^\\s*mCurrentFocus.+\\{.+\\s([^\\s\\/]+)\\/([^\\s]+)\\b',
-    'mg',
-  );
+  const currentFocusAppRe = new RegExp('^\\s*mCurrentFocus.+\\{.+\\s([^\\s\\/]+)\\/([^\\s]+)\\b', 'mg');
 
   const focusedAppCandidates: PackageActivityInfo[] = [];
   const currentFocusAppCandidates: PackageActivityInfo[] = [];
@@ -848,8 +807,7 @@ export async function waitForActivityOrNot(
   );
   const possibleActivityNames = [...possibleActivityNamesSet];
   const possibleActivityPatterns = possibleActivityNames.map(
-    (actName) =>
-      new RegExp(`^${actName.replace(/\./g, '\\.').replace(/\*/g, '.*?').replace(/\$/g, '\\$')}$`),
+    (actName) => new RegExp(`^${actName.replace(/\./g, '\\.').replace(/\*/g, '.*?').replace(/\$/g, '\\$')}$`),
   );
   log.debug(
     `Expected activity name patterns to ${waitForStop ? 'not ' : ''}be focused within ${waitMs}ms: ` +
@@ -874,15 +832,12 @@ export async function waitForActivityOrNot(
       );
       log.debug(`Focused fully qualified activity name: ${fullyQualifiedActivity}`);
       const isFound =
-        allPackages.includes(appPackage) &&
-        possibleActivityPatterns.some((p) => p.test(fullyQualifiedActivity));
+        allPackages.includes(appPackage) && possibleActivityPatterns.some((p) => p.test(fullyQualifiedActivity));
       if ((!waitForStop && isFound) || (waitForStop && !isFound)) {
         return true;
       }
     }
-    log.debug(
-      'None of the expected package/activity combinations matched to the currently focused one. Retrying',
-    );
+    log.debug('None of the expected package/activity combinations matched to the currently focused one. Retrying');
     return false;
   };
 
@@ -909,12 +864,7 @@ export async function waitForActivityOrNot(
  * @param waitMs - Number of milliseconds to wait before timeout occurs.
  * @throws {Error} If timeout happens.
  */
-export async function waitForActivity(
-  this: ADB,
-  pkg: string,
-  act: string,
-  waitMs: number = 20000,
-): Promise<void> {
+export async function waitForActivity(this: ADB, pkg: string, act: string, waitMs: number = 20000): Promise<void> {
   await this.waitForActivityOrNot(pkg, act, false, waitMs);
 }
 
@@ -927,12 +877,7 @@ export async function waitForActivity(
  * @param waitMs - Number of milliseconds to wait before timeout occurs.
  * @throws {Error} If timeout happens.
  */
-export async function waitForNotActivity(
-  this: ADB,
-  pkg: string,
-  act: string,
-  waitMs: number = 20000,
-): Promise<void> {
+export async function waitForNotActivity(this: ADB, pkg: string, act: string, waitMs: number = 20000): Promise<void> {
   await this.waitForActivityOrNot(pkg, act, true, waitMs);
 }
 
@@ -945,17 +890,8 @@ export async function waitForNotActivity(
  * @returns The actual command line array
  */
 export function buildStartCmd(startAppOptions: StartCmdOptions, apiLevel: number): string[] {
-  const {
-    user,
-    waitForLaunch,
-    pkg,
-    activity,
-    action,
-    category,
-    stopApp,
-    flags,
-    optionalIntentArguments,
-  } = startAppOptions;
+  const {user, waitForLaunch, pkg, activity, action, category, stopApp, flags, optionalIntentArguments} =
+    startAppOptions;
   const cmd = ['am', apiLevel < 26 ? 'start' : 'start-activity'];
   if (util.hasValue(user)) {
     cmd.push('--user', `${user}`);

package/lib/tools/device-settings.ts

@@ -1,9 +1,10 @@
-import {log} from '../logger.js';
-import {retryInterval} from 'asyncbox';
 import {util} from '@appium/support';
+import {retryInterval} from 'asyncbox';
+import type {ExecError} from 'teen_process';
+
 import type {ADB} from '../adb.js';
+import {log} from '../logger.js';
 import type {SetPropOpts} from './types.js';
-import type {ExecError} from 'teen_process';
 
 const ANIMATION_SCALE_KEYS = [
   'animator_duration_scale',
@@ -41,12 +42,7 @@ export async function getDeviceProperty(this: ADB, property: string): Promise<st
  *
  * @throws If _setprop_ utility fails to change property value.
  */
-export async function setDeviceProperty(
-  this: ADB,
-  prop: string,
-  val: string,
-  opts: SetPropOpts = {},
-): Promise<void> {
+export async function setDeviceProperty(this: ADB, prop: string, val: string, opts: SetPropOpts = {}): Promise<void> {
   const {privileged = true} = opts;
   log.debug(`Setting device property '${prop}' to '${val}'`);
   await this.shell(['setprop', prop, val], {
@@ -148,11 +144,7 @@ export async function getScreenDensity(this: ADB): Promise<number | null> {
  * @param proxyHost - The host name of the proxy.
  * @param proxyPort - The port number to be set.
  */
-export async function setHttpProxy(
-  this: ADB,
-  proxyHost: string,
-  proxyPort: string | number,
-): Promise<void> {
+export async function setHttpProxy(this: ADB, proxyHost: string, proxyPort: string | number): Promise<void> {
   const proxy = `${proxyHost}:${proxyPort}`;
   if (typeof proxyHost === 'undefined') {
     throw new Error(`Call to setHttpProxy method with undefined proxy_host: ${proxy}`);
@@ -246,7 +238,7 @@ export async function getPlatformVersion(this: ADB): Promise<string> {
     return await this.getDeviceProperty('ro.build.version.release');
   } catch (e) {
     const err = e as Error;
-    throw new Error(`Error getting device platform version. ` + `Original error: ${err.message}`, {
+    throw new Error(`Error getting device platform version. Original error: ${err.message}`, {
       cause: e,
     });
   }
@@ -269,9 +261,7 @@ export async function getLocationProviders(this: ADB): Promise<string[]> {
   }
 
   // To emulate the legacy behavior
-  return (await this.shell(['cmd', 'location', 'is-location-enabled'])).includes('true')
-    ? ['gps']
-    : [];
+  return (await this.shell(['cmd', 'location', 'is-location-enabled'])).includes('true') ? ['gps'] : [];
 }
 
 /**
@@ -314,24 +304,15 @@ export async function toggleGPSLocationProvider(this: ADB, enabled: boolean): Pr
  * @throws If there was an error and ignoreError was true while executing 'adb shell settings put global'
  *                 command on the device under test.
  */
-export async function setHiddenApiPolicy(
-  this: ADB,
-  value: number | string,
-  ignoreError = false,
-): Promise<void> {
+export async function setHiddenApiPolicy(this: ADB, value: number | string, ignoreError = false): Promise<void> {
   try {
-    await this.shell(
-      HIDDEN_API_POLICY_KEYS.map((k) => `settings put global ${k} ${value}`).join(';'),
-    );
+    await this.shell(HIDDEN_API_POLICY_KEYS.map((k) => `settings put global ${k} ${value}`).join(';'));
   } catch (e) {
     const err = e as Error;
     if (!ignoreError) {
       throw decorateWriteSecureSettingsException(err);
     }
-    log.info(
-      `Failed to set setting keys '${HIDDEN_API_POLICY_KEYS}' to '${value}'. ` +
-        `Original error: ${err.message}`,
-    );
+    log.info(`Failed to set setting keys '${HIDDEN_API_POLICY_KEYS}' to '${value}'. Original error: ${err.message}`);
   }
 }
 
@@ -532,9 +513,7 @@ export async function addToDeviceIdleWhitelist(this: ADB, ...packages: string[])
     return false;
   }
 
-  log.info(
-    `Adding ${util.pluralize('package', packages.length)} ${JSON.stringify(packages)} to Doze whitelist`,
-  );
+  log.info(`Adding ${util.pluralize('package', packages.length)} ${JSON.stringify(packages)} to Doze whitelist`);
   await this.shellChunks((pkg) => ['dumpsys', 'deviceidle', 'whitelist', `+${pkg}`], packages);
   return true;
 }
@@ -592,9 +571,7 @@ export async function setNfcOn(this: ADB, on: boolean): Promise<void> {
   const output = stderr || stdout;
   log.debug(output);
   if (output.includes('null NfcAdapter')) {
-    throw new Error(
-      `Cannot turn ${on ? 'on' : 'off'} the NFC adapter. Does the device under test have it?`,
-    );
+    throw new Error(`Cannot turn ${on ? 'on' : 'off'} the NFC adapter. Does the device under test have it?`);
   }
 }
 
@@ -609,15 +586,7 @@ export async function setNfcOn(this: ADB, on: boolean): Promise<void> {
  * @param on - True to broadcast enable and false to broadcast disable.
  */
 export async function broadcastAirplaneMode(this: ADB, on: boolean): Promise<void> {
-  const args = [
-    'am',
-    'broadcast',
-    '-a',
-    'android.intent.action.AIRPLANE_MODE',
-    '--ez',
-    'state',
-    on ? 'true' : 'false',
-  ];
+  const args = ['am', 'broadcast', '-a', 'android.intent.action.AIRPLANE_MODE', '--ez', 'state', on ? 'true' : 'false'];
   try {
     await this.shell(args);
   } catch (e) {
@@ -666,9 +635,7 @@ export async function isDataOn(this: ADB): Promise<boolean> {
  */
 export async function isAnimationOn(this: ADB): Promise<boolean> {
   return (
-    await Promise.all(
-      ANIMATION_SCALE_KEYS.map(async (k) => (await this.getSetting('global', k)) !== '0.0'),
-    )
+    await Promise.all(ANIMATION_SCALE_KEYS.map(async (k) => (await this.getSetting('global', k)) !== '0.0'))
   ).includes(true);
 }
 

package/lib/tools/emulator-commands.ts

@@ -1,9 +1,11 @@
-import {log} from '../logger.js';
 import net from 'node:net';
-import {util, fs} from '@appium/support';
 import path from 'node:path';
+
+import {util, fs} from '@appium/support';
 import * as ini from 'ini';
+
 import type {ADB} from '../adb.js';
+import {log} from '../logger.js';
 import type {
   EmuInfo,
   EmuVersionInfo,
@@ -72,8 +74,7 @@ export async function rotate(this: ADB): Promise<void> {
 export async function powerAC(this: ADB, state: PowerAcStates = 'on'): Promise<void> {
   if (!(Object.values(this.POWER_AC_STATES) as string[]).includes(state)) {
     throw new TypeError(
-      `Wrong power AC state sent '${state}'. ` +
-        `Supported values: ${Object.values(this.POWER_AC_STATES)}]`,
+      `Wrong power AC state sent '${state}'. Supported values: ${Object.values(this.POWER_AC_STATES)}]`,
     );
   }
   await this.adbExecEmu(['power', 'ac', state]);
@@ -88,9 +89,7 @@ export async function powerAC(this: ADB, state: PowerAcStates = 'on'): Promise<v
  */
 export async function sensorSet(this: ADB, sensor: string, value: Sensors): Promise<void> {
   if (!(Object.values(this.SENSORS) as string[]).includes(sensor)) {
-    throw new TypeError(
-      `Unsupported sensor sent '${sensor}'. ` + `Supported values: ${Object.values(this.SENSORS)}]`,
-    );
+    throw new TypeError(`Unsupported sensor sent '${sensor}'. Supported values: ${Object.values(this.SENSORS)}]`);
   }
   if (value == null) {
     throw new TypeError(
@@ -130,11 +129,7 @@ export async function powerOFF(this: ADB): Promise<void> {
  * @param message - The message content.
  * @throws If phone number has invalid format.
  */
-export async function sendSMS(
-  this: ADB,
-  phoneNumber: string | number,
-  message = '',
-): Promise<void> {
+export async function sendSMS(this: ADB, phoneNumber: string | number, message = ''): Promise<void> {
   if (!message) {
     throw new TypeError('SMS message must not be empty');
   }
@@ -152,11 +147,7 @@ export async function sendSMS(
  * @throws If phone number has invalid format.
  * @throws If _action_ value is invalid.
  */
-export async function gsmCall(
-  this: ADB,
-  phoneNumber: string | number,
-  action: GsmCallActions,
-): Promise<void> {
+export async function gsmCall(this: ADB, phoneNumber: string | number, action: GsmCallActions): Promise<void> {
   if (!Object.values(this.GSM_CALL_ACTIONS).includes(action)) {
     throw new TypeError(
       `Invalid gsm action param ${action}. Supported values: ${Object.values(this.GSM_CALL_ACTIONS)}`,
@@ -211,9 +202,7 @@ export async function gsmVoice(this: ADB, state: GsmVoiceStates = 'on'): Promise
 export async function networkSpeed(this: ADB, speed: NetworkSpeed = 'full'): Promise<void> {
   // network speed <speed> allows you to set the network speed emulation.
   if (!Object.values(this.NETWORK_SPEED).includes(speed)) {
-    throw new Error(
-      `Invalid network speed param ${speed}. Supported values: ${Object.values(this.NETWORK_SPEED)}`,
-    );
+    throw new Error(`Invalid network speed param ${speed}. Supported values: ${Object.values(this.NETWORK_SPEED)}`);
   }
   await this.adbExecEmu(['network', 'speed', speed]);
 }
@@ -259,12 +248,7 @@ export async function execEmuConsoleCommand(
 
   return await new Promise<string>((resolve, reject) => {
     const connTimeoutObj = setTimeout(
-      () =>
-        reject(
-          new Error(
-            `Cannot connect to the Emulator console at ${host}:${port} ` + `after ${connTimeout}ms`,
-          ),
-        ),
+      () => reject(new Error(`Cannot connect to the Emulator console at ${host}:${port} after ${connTimeout}ms`)),
       connTimeout,
     );
     let execTimeoutObj: NodeJS.Timeout;
@@ -274,12 +258,7 @@ export async function execEmuConsoleCommand(
 
     client.once('error', (e) => {
       clearTimeout(connTimeoutObj);
-      reject(
-        new Error(
-          `Cannot connect to the Emulator console at ${host}:${port}. ` +
-            `Original error: ${e.message}`,
-        ),
-      );
+      reject(new Error(`Cannot connect to the Emulator console at ${host}:${port}. Original error: ${e.message}`));
     });
 
     client.once('connect', () => {
@@ -440,9 +419,7 @@ async function listEmulators(): Promise<EmuInfo[]> {
   }
 
   if (avdsRoot) {
-    log.warn(
-      `The value of the ANDROID_AVD_HOME environment variable '${avdsRoot}' is not an existing directory`,
-    );
+    log.warn(`The value of the ANDROID_AVD_HOME environment variable '${avdsRoot}' is not an existing directory`);
   }
 
   const prefsRoot = await getAndroidPrefsRoot();
@@ -490,9 +467,7 @@ async function getAndroidPrefsRoot(): Promise<string | null> {
   }
 
   if (location) {
-    log.warn(
-      `The value of the ANDROID_EMULATOR_HOME environment variable '${location}' is not an existing directory`,
-    );
+    log.warn(`The value of the ANDROID_EMULATOR_HOME environment variable '${location}' is not an existing directory`);
   }
 
   const home = process.env.HOME || process.env.USERPROFILE;

package/lib/tools/fs-commands.ts

@@ -1,7 +1,9 @@
 import path from 'node:path';
-import type {ADB} from '../adb.js';
+
 import type {TeenProcessExecOptions} from 'teen_process';
 
+import type {ADB} from '../adb.js';
+
 /**
  * Verify whether a remote path exists on the device under test.
  *

package/lib/tools/general-commands.ts

@@ -1,9 +1,10 @@
-import {log} from '../logger.js';
 import {fs, util} from '@appium/support';
 import {SubProcess, exec, type ExecError} from 'teen_process';
+
 import type {ADB} from '../adb.js';
-import type {ScreenrecordOptions, StringRecord} from './types.js';
+import {log} from '../logger.js';
 import {memoize} from '../utils/index.js';
+import type {ScreenrecordOptions, StringRecord} from './types.js';
 
 /**
  * Get the path to adb executable amd assign it
@@ -191,11 +192,7 @@ export async function bugreport(this: ADB, timeout: number = 120000): Promise<st
  * @param options - Screenrecord options
  * @returns screenrecord process, which can be then controlled by the client code
  */
-export function screenrecord(
-  this: ADB,
-  destination: string,
-  options: ScreenrecordOptions = {},
-): SubProcess {
+export function screenrecord(this: ADB, destination: string, options: ScreenrecordOptions = {}): SubProcess {
   const cmd: string[] = ['screenrecord'];
   const {videoSize, bitRate, timeLimit, bugReport} = options;
   if (util.hasValue(videoSize)) {
@@ -293,10 +290,7 @@ export async function isIncrementalInstallSupported(this: ADB): Promise<boolean>
   if (!binary) {
     return false;
   }
-  return (
-    util.compareVersions(`${binary.version}`, '>=', '30.0.1') &&
-    (await this.listFeatures()).includes('abb_exec')
-  );
+  return util.compareVersions(`${binary.version}`, '>=', '30.0.1') && (await this.listFeatures()).includes('abb_exec');
 }
 
 /**
@@ -329,8 +323,7 @@ export async function takeScreenshot(this: ADB, displayId?: number | string): Pr
       outputStr = typeof stdout === 'string' ? stdout : stdout.toString('utf-8');
     }
     throw new Error(
-      `Screenshot of the ${displayDescr} failed. ` +
-        `Code: '${err.code ?? 'unknown'}', output: '${outputStr}'`,
+      `Screenshot of the ${displayDescr} failed. Code: '${err.code ?? 'unknown'}', output: '${outputStr}'`,
       {cause: e},
     );
   }

package/lib/tools/keyboard-commands.ts

@@ -1,6 +1,7 @@
-import {log} from '../logger.js';
 import {sleep, waitForCondition} from 'asyncbox';
+
 import type {ADB} from '../adb.js';
+import {log} from '../logger.js';
 import type {KeyboardState} from './types.js';
 
 const KEYCODE_ESC = 111;