@limrun/appium-xcuitest-driver 10.11.0-lim.4 → 10.14.6-lim.1

package/lib/commands/{xctest-record-screen.js → xctest-record-screen.ts}

@@ -2,6 +2,11 @@ import _ from 'lodash';
 import {fs, util} from 'appium/support';
 import {encodeBase64OrUpload} from '../utils';
 import path from 'node:path';
+import type {XCUITestDriver} from '../driver';
+import type {Simulator} from 'appium-ios-simulator';
+import type {RealDevice} from '../device/real-device-management';
+import type {HTTPHeaders} from '@appium/types';
+import type {XcTestScreenRecordingInfo, XcTestScreenRecording} from './types';
 
 const MOV_EXT = '.mov';
 const FEATURE_NAME = 'xctest_screen_record';
@@ -10,30 +15,9 @@ const DOMAIN_TYPE = 'appDataContainer';
 const USERNAME = 'mobile';
 const SUBDIRECTORY = 'Attachments';
 
-/**
- * @typedef {Object} XcTestScreenRecordingInfo
- * @property {string} uuid Unique identifier of the video being recorded
- * @property {number} fps FPS value
- * @property {number} codec Video codec, where 0 is h264
- * @property {number} startedAt The timestamp when the screen recording has started in float Unix seconds
- */
-
-/**
- * @typedef {Object} XcTestScreenRecordingType
- * @property {string} payload Base64-encoded content of the recorded media
- * file if `remotePath` parameter is empty or null or an empty string otherwise.
- * The media is expected to a be a valid QuickTime movie (.mov).
- * @typedef {XcTestScreenRecordingInfo & XcTestScreenRecordingType} XcTestScreenRecording
- */
-
-/**
- * @this {XCUITestDriver}
- * @param {string} uuid Unique identifier of the video being recorded
- * @returns {Promise<string>} The full path to the screen recording movie
- */
-async function retrieveRecodingFromSimulator(uuid) {
-  const device = /** @type {import('appium-ios-simulator').Simulator} */ (this.device);
-  const dataRoot = /** @type {string} */ (device.getDir());
+async function retrieveRecodingFromSimulator(this: XCUITestDriver, uuid: string): Promise<string> {
+  const device = this.device as Simulator;
+  const dataRoot = device.getDir();
   // On Simulators the path looks like
   // $HOME/Library/Developer/CoreSimulator/Devices/F8E1968A-8443-4A9A-AB86-27C54C36A2F6/data/Containers/Data/InternalDaemon/4E3FE8DF-AD0A-41DA-B6EC-C35E5798C219/Attachments/A044DAF7-4A58-4CD5-95C3-29B4FE80C377
   const internalDaemonRoot = path.resolve(dataRoot, 'Containers', 'Data', 'InternalDaemon');
@@ -52,13 +36,8 @@ async function retrieveRecodingFromSimulator(uuid) {
   return videoPath;
 }
 
-/**
- * @this {XCUITestDriver}
- * @param {string} uuid Unique identifier of the video being recorded
- * @returns {Promise<string>} The full path to the screen recording movie
- */
-async function retrieveRecodingFromRealDevice(uuid) {
-  const device = /** @type {import('../device/real-device-management').RealDevice} */ (this.device);
+async function retrieveRecodingFromRealDevice(this: XCUITestDriver, uuid: string): Promise<string> {
+  const device = this.device as RealDevice;
 
   const fileNames = await device.devicectl.listFiles(DOMAIN_TYPE, DOMAIN_IDENTIFIER, {
     username: USERNAME,
@@ -69,7 +48,10 @@ async function retrieveRecodingFromRealDevice(uuid) {
       `Unable to locate XCTest screen recording identified by '${uuid}' for the device ${this.opts.udid}`
     );
   }
-  const videoPath = path.join(/** @type {string} */ (this.opts.tmpDir), `${uuid}${MOV_EXT}`);
+  if (!this.opts.tmpDir) {
+    throw new Error('tmpDir is not set in driver options');
+  }
+  const videoPath = path.join(this.opts.tmpDir, `${uuid}${MOV_EXT}`);
   await device.devicectl.pullFile(`${SUBDIRECTORY}/${uuid}`, videoPath, {
     username: USERNAME,
     domainIdentifier: DOMAIN_IDENTIFIER,
@@ -80,15 +62,10 @@ async function retrieveRecodingFromRealDevice(uuid) {
   return videoPath;
 }
 
-/**
- * @this {XCUITestDriver}
- * @param {string} uuid Unique identifier of the video being recorded
- * @returns {Promise<string>} The full path to the screen recording movie
- */
-async function retrieveXcTestScreenRecording(uuid) {
+async function retrieveXcTestScreenRecording(this: XCUITestDriver, uuid: string): Promise<string> {
   return this.isRealDevice()
-    ? await retrieveRecodingFromRealDevice.bind(this)(uuid)
-    : await retrieveRecodingFromSimulator.bind(this)(uuid);
+    ? await retrieveRecodingFromRealDevice.call(this, uuid)
+    : await retrieveRecodingFromSimulator.call(this, uuid);
 }
 
 /**
@@ -102,14 +79,16 @@ async function retrieveXcTestScreenRecording(uuid) {
  * If the recording is already running this API is a noop.
  *
  * @since Xcode 15/iOS 17
- * @param {number} [fps] FPS value
- * @param {number} [codec] Video codec, where 0 is h264, 1 is HEVC
- * @returns {Promise<XcTestScreenRecordingInfo>} The information
- * about a newly created or a running the screen recording.
+ * @param fps - FPS value
+ * @param codec - Video codec, where 0 is h264, 1 is HEVC
+ * @returns The information about a newly created or a running the screen recording.
  * @throws {Error} If screen recording has failed to start.
- * @this {XCUITestDriver}
  */
-export async function mobileStartXctestScreenRecording(fps, codec) {
+export async function mobileStartXctestScreenRecording(
+  this: XCUITestDriver,
+  fps?: number,
+  codec?: number,
+): Promise<XcTestScreenRecordingInfo> {
   if (this.isRealDevice()) {
     // This feature might be used to abuse real devices as there is no
     // reliable way (yet) to cleanup video recordings stored there
@@ -117,16 +96,14 @@ export async function mobileStartXctestScreenRecording(fps, codec) {
     this.assertFeatureEnabled(FEATURE_NAME);
   }
 
-  const opts = {};
+  const opts: {codec?: number; fps?: number} = {};
   if (_.isInteger(codec)) {
     opts.codec = codec;
   }
   if (_.isInteger(fps)) {
     opts.fps = fps;
   }
-  const response = /** @type {XcTestScreenRecordingInfo} */ (
-    await this.proxyCommand('/wda/video/start', 'POST', opts)
-  );
+  const response = await this.proxyCommand('/wda/video/start', 'POST', opts) as XcTestScreenRecordingInfo;
   this.log.info(`Started a new screen recording: ${JSON.stringify(response)}`);
   return response;
 }
@@ -134,13 +111,11 @@ export async function mobileStartXctestScreenRecording(fps, codec) {
 /**
  * Retrieves information about the current running screen recording.
  * If no screen recording is running then `null` is returned.
- *
- * @returns {Promise<XcTestScreenRecordingInfo?>}
  */
-export async function mobileGetXctestScreenRecordingInfo() {
-  return /** @type {XcTestScreenRecordingInfo?} */ (
-    await this.proxyCommand('/wda/video', 'GET')
-  );
+export async function mobileGetXctestScreenRecordingInfo(
+  this: XCUITestDriver,
+): Promise<XcTestScreenRecordingInfo | null> {
+  return (await this.proxyCommand('/wda/video', 'GET')) as XcTestScreenRecordingInfo | null;
 }
 
 /**
@@ -157,29 +132,37 @@ export async function mobileGetXctestScreenRecordingInfo() {
  * on the device directly or by doing factory reset.
  *
  * @since Xcode 15/iOS 17
- * @param {string} [remotePath] The path to the remote location, where the resulting video should be
+ * @param remotePath - The path to the remote location, where the resulting video should be
  * uploaded.
  * The following protocols are supported: `http`, `https`, `ftp`. Null or empty
  * string value (the default setting) means the content of resulting file
  * should be encoded as Base64 and passed as the endpoint response value. An
  * exception will be thrown if the generated media file is too big to fit into
  * the available process memory.
- * @param {string} [user] The name of the user for the remote authentication.
+ * @param user - The name of the user for the remote authentication.
  * Only works if `remotePath` is provided.
- * @param {string} [pass] The password for the remote authentication.
+ * @param pass - The password for the remote authentication.
  * Only works if `remotePath` is provided.
- * @param {import('@appium/types').HTTPHeaders} [headers] Additional headers mapping for multipart http(s) uploads
- * @param {string} [fileFieldName] The name of the form field where the file content BLOB should be stored for
+ * @param headers - Additional headers mapping for multipart http(s) uploads
+ * @param fileFieldName - The name of the form field where the file content BLOB should be stored for
  * http(s) uploads
- * @param {Record<string, any> | [string, any][]} [formFields] Additional form fields for multipart http(s) uploads
- * @param {'PUT' | 'POST' | 'PATCH'} [method='PUT'] The http multipart upload method name.
+ * @param formFields - Additional form fields for multipart http(s) uploads
+ * @param method - The http multipart upload method name.
  * Only works if `remotePath` is provided.
- * @returns {Promise<XcTestScreenRecording>}
+ * @returns The resulting movie with base64-encoded content or empty string if uploaded remotely.
  * @throws {Error} If there was an error while retrieving the video
  * file or the file content cannot be uploaded to the remote location.
- * @this {XCUITestDriver}
  */
-export async function mobileStopXctestScreenRecording(remotePath, user, pass, headers, fileFieldName, formFields, method) {
+export async function mobileStopXctestScreenRecording(
+  this: XCUITestDriver,
+  remotePath?: string,
+  user?: string,
+  pass?: string,
+  headers?: HTTPHeaders,
+  fileFieldName?: string,
+  formFields?: Record<string, any> | [string, any][],
+  method: 'PUT' | 'POST' | 'PATCH' = 'PUT',
+): Promise<XcTestScreenRecording> {
   const screenRecordingInfo = await this.mobileGetXctestScreenRecordingInfo();
   if (!screenRecordingInfo) {
     throw new Error('There is no active screen recording. Did you start one beforehand?');
@@ -187,8 +170,11 @@ export async function mobileStopXctestScreenRecording(remotePath, user, pass, he
 
   this.log.debug(`Stopping the active screen recording: ${JSON.stringify(screenRecordingInfo)}`);
   await this.proxyCommand('/wda/video/stop', 'POST', {});
-  const videoPath = await retrieveXcTestScreenRecording.bind(this)(screenRecordingInfo.uuid);
-  const result = /** @type {XcTestScreenRecording} */ (screenRecordingInfo);
+  const videoPath = await retrieveXcTestScreenRecording.call(this, screenRecordingInfo.uuid);
+  const result: XcTestScreenRecording = {
+    ...screenRecordingInfo,
+    payload: '', // Will be set below
+  };
   try {
     result.payload = await encodeBase64OrUpload(videoPath, remotePath, {
       user, pass, headers, fileFieldName, formFields, method
@@ -199,6 +185,3 @@ export async function mobileStopXctestScreenRecording(remotePath, user, pass, he
   return result;
 }
 
-/**
- * @typedef {import('../driver').XCUITestDriver} XCUITestDriver
- */

package/lib/commands/{xctest.js → xctest.ts}

@@ -2,34 +2,42 @@ import B from 'bluebird';
 import {logger} from 'appium/support';
 import _ from 'lodash';
 import {errors} from 'appium/driver';
+import type {XCUITestDriver} from '../driver';
+import type {XCTestResult, RunXCTestResult} from './types';
+import type {StringRecord} from '@appium/types';
+import type IDB from 'appium-idb';
 
 const XCTEST_TIMEOUT = 360000; // 60 minute timeout
 
 const xctestLog = logger.getLogger('XCTest');
 
 /**
- * Asserts that IDB is present and that launchWithIDB was used
+ * Asserts that IDB is present and that launchWithIDB was used.
  *
- * @param {XCUITestDriver['opts']} opts Opts object from the driver instance
+ * @param opts - Opts object from the driver instance
+ * @returns The IDB instance
+ * @throws {Error} If IDB is not available or launchWithIDB is not enabled
  */
-export function assertIDB(opts) {
-  if (!this.device?.idb || !opts.launchWithIDB) {
+export function assertIDB(this: XCUITestDriver, opts: XCUITestDriver['opts']): IDB {
+  const device = this.device as any;
+  if (!device?.idb || !opts.launchWithIDB) {
     throw new Error(
       `To use XCTest runner, IDB (https://github.com/facebook/idb) must be installed ` +
         `and sessions must be run with the "launchWithIDB" capability`,
     );
   }
-  return this.device.idb;
+  return device.idb;
 }
 
 /**
- * Parse the stdout of XC test log
- * @param {string} stdout A line of standard out from `idb xctest run ...`
- * @returns {XCTestResult[]|string[]} results The final output of the XCTest run
+ * Parse the stdout of XC test log.
+ *
+ * @param stdout - A line of standard out from `idb xctest run ...`
+ * @returns The final output of the XCTest run
  */
-export function parseXCTestStdout(stdout) {
+export function parseXCTestStdout(stdout: string): XCTestResult[] | string[] {
   // Parses a 'key' into JSON format
-  function parseKey(name) {
+  function parseKey(name: string): string {
     const words = name.split(' ');
     let out = '';
     for (const word of words) {
@@ -39,7 +47,7 @@ export function parseXCTestStdout(stdout) {
   }
 
   // Parses a 'value' into JSON format
-  function parseValue(value) {
+  function parseValue(value: string): any {
     value = value || '';
     switch (value.toLowerCase()) {
       case 'true':
@@ -51,7 +59,7 @@ export function parseXCTestStdout(stdout) {
       default:
         break;
     }
-    if (!isNaN(value)) {
+    if (!isNaN(Number(value))) {
       if (!_.isString(value)) {
         return 0;
       } else if (value.indexOf('.') > 0) {
@@ -73,16 +81,14 @@ export function parseXCTestStdout(stdout) {
     return [lines[0]];
   }
 
-  /** @type {XCTestResult[]} */
-  const results = [];
+  const results: XCTestResult[] = [];
   for (const line of lines) {
     // The properties are split up by pipes and each property
     // has the format "Some Key : Some Value"
     const properties = line.split('|');
 
     // Parse each property
-    /** @type {XCTestResult} */
-    const output = /** @type {any} */ ({});
+    const output: any = {};
     let entryIndex = 0;
     for (const prop of properties) {
       if (entryIndex === 0) {
@@ -94,7 +100,7 @@ export function parseXCTestStdout(stdout) {
         // e.g. Location /path/to/XCTesterAppUITests/XCTesterAppUITests.swift:36
         output.location = prop.substring(prop.indexOf('Location') + 8).trim();
       } else {
-        let [key, value] = prop.split(':');
+        const [key, value] = prop.split(':');
         output[parseKey(key.trim())] = parseValue(value ? value.trim() : '');
       }
       entryIndex++;
@@ -123,12 +129,13 @@ export function parseXCTestStdout(stdout) {
 }
 
 /**
- * @typedef {Error} XCUITestError
- *
- * @property {number} code Subprocess exit code
- * @property {string} signal The signal (SIG*) that caused the process to fail
- * @property {XCTestResult[]} results The output of the failed test (if there is output)
+ * Error thrown when XCTest subprocess returns non-zero exit code.
  */
+export interface XCUITestError extends Error {
+  code: number;
+  signal?: string;
+  result?: XCTestResult[];
+}
 
 /**
  * Run a native XCTest script.
@@ -137,36 +144,36 @@ export function parseXCTestStdout(stdout) {
  *
  * **Facebook's [IDB](https://github.com/facebook/idb) tool is required** to run such tests; see [the idb docs](https://fbidb.io/docs/test-execution/) for reference.
  *
- * @param {string} testRunnerBundleId - Test app bundle (e.g.: `io.appium.XCTesterAppUITests.xctrunner`)
- * @param {string} appUnderTestBundleId - App-under-test bundle
- * @param {string} xcTestBundleId - XCTest bundle ID
- * @param {string[]} args - Launch arguments to start the test with (see [reference documentation](https://developer.apple.com/documentation/xctest/xcuiapplication/1500477-launcharguments))
- * @param {'app'|'ui'|'logic'} testType - XC test type
- * @param {import('@appium/types').StringRecord} [env] - Environment variables passed to test
- * @param {number} timeout - Timeout (in ms) for session completion.
+ * @param testRunnerBundleId - Test app bundle (e.g.: `io.appium.XCTesterAppUITests.xctrunner`)
+ * @param appUnderTestBundleId - App-under-test bundle
+ * @param xcTestBundleId - XCTest bundle ID
+ * @param args - Launch arguments to start the test with (see [reference documentation](https://developer.apple.com/documentation/xctest/xcuiapplication/1500477-launcharguments))
+ * @param testType - XC test type
+ * @param env - Environment variables passed to test
+ * @param timeout - Timeout (in ms) for session completion
+ * @returns The array of test results
  * @throws {XCUITestError} Error thrown if subprocess returns non-zero exit code
- * @returns {Promise<import('./types').RunXCTestResult>} The array of test results
- * @this {XCUITestDriver}
  */
 export async function mobileRunXCTest(
-  testRunnerBundleId,
-  appUnderTestBundleId,
-  xcTestBundleId,
-  args = [],
-  testType = 'ui',
-  env,
+  this: XCUITestDriver,
+  testRunnerBundleId: string,
+  appUnderTestBundleId: string,
+  xcTestBundleId: string,
+  args: string[] = [],
+  testType: 'app' | 'ui' | 'logic' = 'ui',
+  env?: StringRecord,
   timeout = XCTEST_TIMEOUT,
-) {
-  const subproc = await assertIDB(this.opts).runXCUITest(
+): Promise<RunXCTestResult> {
+  const subproc = await assertIDB.call(this, this.opts).runXCUITest(
     testRunnerBundleId,
     appUnderTestBundleId,
     xcTestBundleId,
     {env, args, testType},
   );
   return await new B((resolve, reject) => {
-    let mostRecentLogObject = null;
-    let xctestTimeout;
-    let lastErrorMessage = null;
+    let mostRecentLogObject: XCTestResult[] | string[] | null = null;
+    let xctestTimeout: NodeJS.Timeout | undefined;
+    let lastErrorMessage: string | null = null;
     if (timeout > 0) {
       xctestTimeout = setTimeout(
         () =>
@@ -179,11 +186,11 @@ export async function mobileRunXCTest(
       );
     }
 
-    subproc.on('output', (stdout, stderr) => {
+    subproc.on('output', (stdout: string, stderr: string) => {
       if (stdout) {
         try {
           mostRecentLogObject = parseXCTestStdout(stdout);
-        } catch (err) {
+        } catch (err: any) {
           // Fails if log parsing fails.
           // This is in case IDB changes the way that logs are formatted and
           // it breaks 'parseXCTestStdout'. If that happens we still want the process
@@ -202,23 +209,25 @@ export async function mobileRunXCTest(
       }
     });
 
-    subproc.on('exit', (code, signal) => {
-      clearTimeout(xctestTimeout);
+    subproc.on('exit', (code: number | null, signal: string | null) => {
+      if (xctestTimeout) {
+        clearTimeout(xctestTimeout);
+      }
       if (code !== 0) {
-        const err = /** @type {any} */ (new Error(lastErrorMessage || mostRecentLogObject));
-        err.code = code;
+        const err = new Error(lastErrorMessage || String(mostRecentLogObject)) as XCUITestError;
+        err.code = code ?? -1;
         if (signal != null) {
           err.signal = signal;
         }
         if (mostRecentLogObject) {
-          err.result = mostRecentLogObject;
+          err.result = mostRecentLogObject as XCTestResult[];
         }
         return reject(err);
       }
       resolve({
-        code,
-        signal,
-        results: mostRecentLogObject,
+        code: code ?? 0,
+        signal: signal ?? null,
+        results: mostRecentLogObject as XCTestResult[],
         passed: true,
       });
     });
@@ -230,11 +239,12 @@ export async function mobileRunXCTest(
  *
  * **Facebook's [IDB](https://github.com/facebook/idb) tool is required** for this command to work.
  *
- * @param {string} xctestApp - Path of the XCTest app (URL or filename with extension `.app`)
- * @returns {Promise<void>}
- * @this {XCUITestDriver}
+ * @param xctestApp - Path of the XCTest app (URL or filename with extension `.app`)
  */
-export async function mobileInstallXCTestBundle(xctestApp) {
+export async function mobileInstallXCTestBundle(
+  this: XCUITestDriver,
+  xctestApp: string,
+): Promise<void> {
   if (!_.isString(xctestApp)) {
     throw new errors.InvalidArgumentError(
       `'xctestApp' is a required parameter for 'installXCTestBundle' and ` +
@@ -242,7 +252,7 @@ export async function mobileInstallXCTestBundle(xctestApp) {
     );
   }
   xctestLog.info(`Installing bundle '${xctestApp}'`);
-  const idb = assertIDB(this.opts);
+  const idb = assertIDB.call(this, this.opts);
   const res = await this.helpers.configureApp(xctestApp, '.xctest');
   await idb.installXCTestBundle(res);
 }
@@ -252,34 +262,31 @@ export async function mobileInstallXCTestBundle(xctestApp) {
  *
  * **Facebook's [IDB](https://github.com/facebook/idb) tool is required** for this command to work.
  *
- * @returns {Promise<string[]>} List of XCTest bundles (e.g.: `XCTesterAppUITests.XCTesterAppUITests/testLaunchPerformance`)
- * @this {XCUITestDriver}
+ * @returns List of XCTest bundles (e.g.: `XCTesterAppUITests.XCTesterAppUITests/testLaunchPerformance`)
  */
-export async function mobileListXCTestBundles() {
-  return await assertIDB(this.opts).listXCTestBundles();
+export async function mobileListXCTestBundles(this: XCUITestDriver): Promise<string[]> {
+  return await assertIDB.call(this, this.opts).listXCTestBundles();
 }
 
 /**
- * List XCTests in a test bundle
+ * List XCTests in a test bundle.
  *
  * **Facebook's [IDB](https://github.com/facebook/idb) tool is required** for this command to work.
- * @param {string} bundle - Bundle ID of the XCTest
  *
- * @returns {Promise<string[]>} The list of xctests in the test bundle (e.g., `['XCTesterAppUITests.XCTesterAppUITests/testExample', 'XCTesterAppUITests.XCTesterAppUITests/testLaunchPerformance']`)
- * @this {XCUITestDriver}
+ * @param bundle - Bundle ID of the XCTest
+ * @returns The list of xctests in the test bundle (e.g., `['XCTesterAppUITests.XCTesterAppUITests/testExample', 'XCTesterAppUITests.XCTesterAppUITests/testLaunchPerformance']`)
  */
-export async function mobileListXCTestsInTestBundle(bundle) {
+export async function mobileListXCTestsInTestBundle(
+  this: XCUITestDriver,
+  bundle: string,
+): Promise<string[]> {
   if (!_.isString(bundle)) {
     throw new errors.InvalidArgumentError(
       `'bundle' is a required parameter for 'listXCTestsInTestBundle' and ` +
         `must be a string. Found '${bundle}'`,
     );
   }
-  const idb = assertIDB(this.opts);
+  const idb = assertIDB.call(this, this.opts);
   return await idb.listXCTestsInTestBundle(bundle);
 }
 
-/**
- * @typedef {import('../driver').XCUITestDriver} XCUITestDriver
- * @typedef {import('./types').XCTestResult} XCTestResult
- */

package/lib/desired-caps.ts

@@ -408,7 +408,7 @@ export const desiredCapConstraints = {
   // Useful when WDA is behind a gateway that requires authentication headers
   wdaRequestHeaders: {
     isObject: true,
-  }
+  },
 } as const satisfies Constraints;
 
 export type XCUITestDriverConstraints = typeof desiredCapConstraints;

package/lib/device/log/ios-simulator-log.ts

@@ -172,6 +172,8 @@ export class IOSSimulatorLog extends LineConsumingLog {
         this.onOutput(line, ...(streamName === 'stderr' ? ['STDERR'] : []));
       });
     }
+    // We immediately start anyway so this is commented out.
+    //
     // const startDetector = (stdout: string, stderr: string) => {
     //   if (EXECVP_ERROR_PATTERN.test(stderr)) {
     //     throw new Error('iOS log capture process failed to start');

package/lib/device/simulator-management.ts

@@ -49,7 +49,6 @@ export async function createSim(this: XCUITestDriver): Promise<Simulator> {
     devicesSetPath,
     // @ts-ignore This is ok
     logger: this.log,
-    limClient: this.limClient,
   });
 }
 
@@ -75,7 +74,6 @@ export async function getExistingSim(this: XCUITestDriver): Promise<Simulator |
       devicesSetPath,
       // @ts-ignore This is ok
       logger: this.log,
-      limClient: this.limClient,
     });
 
   const simctl = new Simctl({devicesSetPath, limClient: this.limClient});

package/lib/doctor/optional-checks.ts

@@ -4,39 +4,6 @@ import type {IDoctorCheck, AppiumLogger, DoctorCheckResult} from '@appium/types'
 import '@colors/colors';
 import {exec} from 'teen_process';
 
-export class OptionalIdbCommandCheck implements IDoctorCheck {
-  log!: AppiumLogger;
-  static readonly IDB_README_URL = 'https://git.io/JnxQc';
-
-  async diagnose(): Promise<DoctorCheckResult> {
-    const fbIdbPath = await resolveExecutablePath('idb');
-    const fbCompanionIdbPath = await resolveExecutablePath('idb_companion');
-    if (fbIdbPath && fbCompanionIdbPath) {
-      return doctor.okOptional('idb and idb_companion are installed');
-    }
-
-    if (!fbIdbPath && fbCompanionIdbPath) {
-      return doctor.nokOptional('idb is not installed');
-    } else if (fbIdbPath && !fbCompanionIdbPath) {
-      return doctor.nokOptional('idb_companion is not installed');
-    }
-    return doctor.nokOptional('idb and idb_companion are not installed');
-  }
-
-  async fix(): Promise<string> {
-    return `Why ${'idb'.bold} is needed and how to install it: ${OptionalIdbCommandCheck.IDB_README_URL}`;
-  }
-
-  hasAutofix(): boolean {
-    return false;
-  }
-
-  isOptional(): boolean {
-    return true;
-  }
-}
-export const optionalIdbCheck = new OptionalIdbCommandCheck();
-
 export class OptionalSimulatorCheck implements IDoctorCheck {
   log!: AppiumLogger;
   static readonly SUPPORTED_SIMULATOR_PLATFORMS: SimulatorPlatform[] = [