appium-xcuitest-driver 10.14.10 → 10.14.11

package/lib/commands/battery.ts

@@ -1,6 +1,7 @@
 import { isIos18OrNewer } from '../utils';
 import type {XCUITestDriver} from '../driver';
 import type {BatteryInfo} from './types';
+import {getRemoteXPCServices} from '../device/remotexpc-utils';
 
 /**
  * Reads the battery information from the device under test.
@@ -16,7 +17,7 @@ export async function mobileGetBatteryInfo(
   if (isIos18OrNewer(this.opts) && this.isRealDevice()) {
     let remoteXPCConnection;
     try {
-      const {Services} = await import('appium-ios-remotexpc');
+      const Services = await getRemoteXPCServices();
       const { diagnosticsService, remoteXPC } = await Services.startDiagnosticsService(this.device.udid);
       remoteXPCConnection = remoteXPC;
       batteryInfoFromShimService = await diagnosticsService.ioregistry({

package/lib/commands/condition.ts

@@ -2,8 +2,48 @@ import {INSTRUMENT_CHANNEL, services} from 'appium-ios-device';
 import _ from 'lodash';
 import { isIos18OrNewer, requireRealDevice } from '../utils';
 import type {XCUITestDriver} from '../driver';
+import type {AppiumLogger} from '@appium/types';
 import type {DVTServiceWithConnection} from 'appium-ios-remotexpc';
 import type {Condition} from './types';
+import {getRemoteXPCServices} from '../device/remotexpc-utils';
+
+/**
+ * Abstract interface for condition inducer implementations.
+ * This facade hides the differences between RemoteXPC and Instrument Service implementations.
+ */
+export interface IConditionInducer {
+  /**
+   * Lists all available condition inducers
+   * @returns Array of available condition inducers
+   */
+  list(): Promise<Condition[]>;
+
+  /**
+   * Enables a condition inducer with the given profile
+   * @param conditionID - The condition identifier (only used by Instrument Service)
+   * @param profileID - The profile identifier
+   * @returns `true` if enabling succeeded
+   * @throws {Error} If a condition is already active
+   */
+  enable(conditionID: string, profileID: string): Promise<boolean>;
+
+  /**
+   * Disables the currently active condition inducer
+   * @returns `true` if disabling succeeded
+   */
+  disable(): Promise<boolean>;
+
+  /**
+   * Closes any open connections/resources
+   */
+  close(): Promise<void>;
+
+  /**
+   * Checks if a condition inducer is currently active
+   * @returns `true` if a condition is active
+   */
+  isActive(): boolean;
+}
 
 /**
  * Get all available ConditionInducer configuration information, which can be used with
@@ -14,32 +54,8 @@ import type {Condition} from './types';
 export async function listConditionInducers(this: XCUITestDriver): Promise<Condition[]> {
   requireRealDevice(this, 'Condition inducer');
 
-  if (isIos18OrNewer(this.opts)) {
-    let dvtConnection;
-    try {
-      dvtConnection = await startRemoteXPC(this.device.udid);
-      const result = await dvtConnection.conditionInducer.list();
-      return result as Condition[];
-    } catch (err: any) {
-      this.log.error(`Failed to list condition inducers via RemoteXPC: ${err.message}`);
-    } finally {
-      if (dvtConnection) {
-        this.log.info(`Closing remoteXPC connection for device ${this.device.udid}`);
-        await dvtConnection.remoteXPC.close();
-      }
-    }
-  }
-
-  const conditionInducerService = await services.startInstrumentService(this.device.udid);
-  try {
-    const ret = await conditionInducerService.callChannel(
-      INSTRUMENT_CHANNEL.CONDITION_INDUCER,
-      'availableConditionInducers',
-    );
-    return ret.selector;
-  } finally {
-    conditionInducerService.close();
-  }
+  const facade = this._conditionInducer ?? await createConditionInducer(this);
+  return await facade.list();
 }
 
 /**
@@ -67,45 +83,26 @@ export async function enableConditionInducer(
 ): Promise<boolean> {
   requireRealDevice(this, 'Condition inducer');
 
-  if (isIos18OrNewer(this.opts)) {
-    if (this._remoteXPCConditionInducerConnection) {
-      throw this.log.errorWithException(
-        `Condition inducer is already running. Disable it first in order to call enable again.`
-      );
-    }
-
-    try {
-      const dvtConnection = await startRemoteXPC(this.device.udid);
-      this._remoteXPCConditionInducerConnection = dvtConnection;
-
-      await dvtConnection.conditionInducer.set(profileID);
-
-      this.log.info(`Successfully enabled condition profile: ${profileID}`);
-      return true;
-    } catch (err: any) {
-      await closeRemoteXPC.call(this);
-      this.log.error(`Condition inducer '${profileID}' cannot be enabled: '${err.message}'`);
-    }
+  if (this._conditionInducer?.isActive()) {
+    throw this.log.errorWithException(
+      `Condition inducer is already running. Disable it first in order to call 'enable' again.`
+    );
   }
 
-  if (this._conditionInducerService && !this._conditionInducerService._socketClient.destroyed) {
+  const facade = await createConditionInducer(this);
+  this._conditionInducer = facade;
+
+  try {
+    return await facade.enable(conditionID, profileID);
+  } catch (err: any) {
+    this._conditionInducer = null;
+    try {
+      await facade.close();
+    } catch {}
     throw this.log.errorWithException(
-      `Condition inducer has been started. A condition is already active.`
+      `Condition inducer '${profileID}' cannot be enabled: '${err.message}'`
     );
   }
-  this._conditionInducerService = await services.startInstrumentService(this.device.udid);
-  const ret = await this._conditionInducerService.callChannel(
-    INSTRUMENT_CHANNEL.CONDITION_INDUCER,
-    'enableConditionWithIdentifier:profileIdentifier:',
-    conditionID,
-    profileID,
-  );
-  if (!_.isBoolean(ret.selector)) {
-    this._conditionInducerService.close();
-    this._conditionInducerService = null;
-    throw this.log.errorWithException(`Enable condition inducer error: '${JSON.stringify(ret.selector)}'`);
-  }
-  return ret.selector;
 }
 
 /**
@@ -122,57 +119,210 @@ export async function enableConditionInducer(
 export async function disableConditionInducer(this: XCUITestDriver): Promise<boolean> {
   requireRealDevice(this, 'Condition inducer');
 
-  if (isIos18OrNewer(this.opts)) {
-    if (!this._remoteXPCConditionInducerConnection) {
+  if (!this._conditionInducer) {
+    this.log.warn('Condition inducer is not active');
+    return false;
+  }
+
+  try {
+    return await this._conditionInducer.disable();
+  } finally {
+    try {
+      await this._conditionInducer.close();
+    } catch {}
+    this._conditionInducer = null;
+  }
+}
+
+// Private implementation classes and factory function
+
+/**
+ * RemoteXPC-based implementation for iOS 18+
+ */
+class RemoteXPCConditionInducer implements IConditionInducer {
+  private connection: DVTServiceWithConnection | null = null;
+
+  constructor(
+    private readonly udid: string,
+    private readonly log: AppiumLogger,
+  ) {}
+
+  async list(): Promise<Condition[]> {
+    let connection: DVTServiceWithConnection | null = null;
+    try {
+      connection = await this.startConnection();
+      const result = await connection.conditionInducer.list();
+      return result as Condition[];
+    } catch (err: any) {
+      this.log.error(`Failed to list condition inducers via RemoteXPC: ${err.message}`);
+      throw err;
+    } finally {
+      if (connection) {
+        this.log.info(`Closing remoteXPC connection for device ${this.udid}`);
+        await connection.remoteXPC.close();
+      }
+    }
+  }
+
+  async enable(conditionID: string, profileID: string): Promise<boolean> {
+    if (this.connection) {
+      throw new Error(
+        `Condition inducer is already running. Disable it first in order to call 'enable' again.`
+      );
+    }
+
+    try {
+      this.connection = await this.startConnection();
+      await this.connection.conditionInducer.set(profileID);
+      this.log.info(`Successfully enabled condition profile: ${profileID}`);
+      return true;
+    } catch (err: any) {
+      await this.close();
+      this.log.error(`Condition inducer '${profileID}' cannot be enabled: '${err.message}'`);
+      throw err;
+    }
+  }
+
+  async disable(): Promise<boolean> {
+    if (!this.connection) {
       this.log.warn('Condition inducer connection is not active');
       return false;
     }
 
     try {
-      await this._remoteXPCConditionInducerConnection.conditionInducer.disable();
+      await this.connection.conditionInducer.disable();
       this.log.info('Successfully disabled condition inducer');
       return true;
     } catch (err: any) {
       this.log.warn(`Failed to disable condition inducer via RemoteXPC: ${err.message}`);
       return false;
     } finally {
-      this.log.info(`Closing remoteXPC connection for device ${this.device.udid}`);
-      await closeRemoteXPC.call(this);
+      this.log.info(`Closing remoteXPC connection for device ${this.udid}`);
+      await this.close();
     }
   }
 
-  if (!this._conditionInducerService) {
-    this.log.warn('Condition inducer server is not started');
-    return false;
+  async close(): Promise<void> {
+    if (this.connection) {
+      await this.connection.remoteXPC.close();
+      this.connection = null;
+    }
   }
-  try {
-    const ret = await this._conditionInducerService.callChannel(
+
+  isActive(): boolean {
+    return this.connection !== null;
+  }
+
+  public async startConnection(): Promise<DVTServiceWithConnection> {
+    const Services = await getRemoteXPCServices();
+    return Services.startDVTService(this.udid);
+  }
+}
+
+/**
+ * Instrument Service-based implementation for iOS < 18
+ */
+class InstrumentConditionInducer implements IConditionInducer {
+  private service: any | null = null; // InstrumentService type from appium-ios-device
+
+  constructor(
+    private readonly udid: string,
+    private readonly log: AppiumLogger,
+  ) {}
+
+  async list(): Promise<Condition[]> {
+    const service = await services.startInstrumentService(this.udid);
+    try {
+      const ret = await service.callChannel(
+        INSTRUMENT_CHANNEL.CONDITION_INDUCER,
+        'availableConditionInducers',
+      );
+      return ret.selector;
+    } finally {
+      service.close();
+    }
+  }
+
+  async enable(conditionID: string, profileID: string): Promise<boolean> {
+    if (this.service && !this.service._socketClient.destroyed) {
+      throw new Error(`Condition inducer has been started. A condition is already active.`);
+    }
+
+    this.service = await services.startInstrumentService(this.udid);
+    const ret = await this.service.callChannel(
       INSTRUMENT_CHANNEL.CONDITION_INDUCER,
-      'disableActiveCondition',
+      'enableConditionWithIdentifier:profileIdentifier:',
+      conditionID,
+      profileID,
     );
+
     if (!_.isBoolean(ret.selector)) {
-      this.log.warn(`Disable condition inducer error: '${JSON.stringify(ret.selector)}'`);
-      return false;
+      this.service.close();
+      this.service = null;
+      throw new Error(`Enable condition inducer error: '${JSON.stringify(ret.selector)}'`);
     }
+
     return ret.selector;
-  } finally {
-    if (this._conditionInducerService) {
-      this._conditionInducerService.close();
-      this._conditionInducerService = null;
+  }
+
+  async disable(): Promise<boolean> {
+    if (!this.service) {
+      this.log.warn('Condition inducer server has not started');
+      return false;
+    }
+
+    try {
+      const ret = await this.service.callChannel(
+        INSTRUMENT_CHANNEL.CONDITION_INDUCER,
+        'disableActiveCondition',
+      );
+      if (!_.isBoolean(ret.selector)) {
+        this.log.warn(`Disable condition inducer error: '${JSON.stringify(ret.selector)}'`);
+        return false;
+      }
+      return ret.selector;
+    } finally {
+      if (this.service) {
+        this.service.close();
+        this.service = null;
+      }
     }
   }
-}
 
-async function startRemoteXPC(udid: string): Promise<DVTServiceWithConnection> {
-  const {Services} = await import('appium-ios-remotexpc');
-  return Services.startDVTService(udid);
-}
+  async close(): Promise<void> {
+    if (this.service) {
+      this.service.close();
+      this.service = null;
+    }
+  }
 
-async function closeRemoteXPC(this: XCUITestDriver): Promise<void> {
-  if (this._remoteXPCConditionInducerConnection) {
-    await this._remoteXPCConditionInducerConnection.remoteXPC.close();
-    this._remoteXPCConditionInducerConnection = null;
+  isActive(): boolean {
+    return this.service !== null && !this.service._socketClient.destroyed;
   }
 }
 
+/**
+ * Factory function to create the appropriate condition inducer implementation
+ * based on the iOS version
+ */
+async function createConditionInducer(
+  driver: XCUITestDriver,
+): Promise<IConditionInducer> {
+  if (!isIos18OrNewer(driver.opts)) {
+    return new InstrumentConditionInducer(driver.device.udid, driver.log);
+  }
+
+  const xpcInducer = new RemoteXPCConditionInducer(driver.device.udid, driver.log);
+  try {
+    const connection = await xpcInducer.startConnection();
+    await connection.remoteXPC.close();
+  } catch (err: any) {
+    driver.log.warn(
+      `Unable to use RemoteXPC-based condition inducer for device ${driver.device.udid}, ` +
+      `falling back to the legacy implementation: ${err.message}`
+    );
+    return new InstrumentConditionInducer(driver.device.udid, driver.log);
+  }
+  return xpcInducer;
+}
 

package/lib/device/remotexpc-utils.ts

@@ -0,0 +1,88 @@
+import {node} from 'appium/support';
+import path from 'node:path';
+import {readFileSync} from 'node:fs';
+import type {Services} from 'appium-ios-remotexpc';
+
+/**
+ * Cached RemoteXPC Services module
+ */
+let cachedRemoteXPCServices: typeof Services | null = null;
+
+/**
+ * Module root and version cached at initialization
+ */
+const {moduleRoot, remoteXpcVersion} = fetchInstallInfo();
+
+/**
+ * Get the RemoteXPC Services module dynamically
+ *
+ * This helper centralizes the import of appium-ios-remotexpc to:
+ * - Provide consistent error handling across all services
+ * - Give helpful installation instructions when the module is missing
+ *
+ * @returns The Services export from appium-ios-remotexpc
+ * @throws {Error} If the module cannot be imported
+ */
+export async function getRemoteXPCServices(): Promise<typeof Services> {
+  if (cachedRemoteXPCServices) {
+    return cachedRemoteXPCServices;
+  }
+
+  try {
+    const remotexpcModule = await import('appium-ios-remotexpc');
+    cachedRemoteXPCServices = remotexpcModule.Services;
+    return cachedRemoteXPCServices;
+  } catch (err) {
+    const error = err as Error;
+
+    if (error.message.includes('Cannot find module')) {
+      let errorMessage =
+        'Failed to import appium-ios-remotexpc module. ' +
+        'This module is required for iOS 18 and above device operations.';
+
+      if (moduleRoot && remoteXpcVersion) {
+        errorMessage +=
+          ' Please install it by running: ' +
+          `cd "${moduleRoot}" && npm install "appium-ios-remotexpc@${remoteXpcVersion}".`;
+      }
+
+      errorMessage += ` Original error: ${error.message}`;
+      throw new Error(errorMessage);
+    }
+
+    throw new Error(
+      'Failed to import appium-ios-remotexpc module. ' +
+        'This module is required for iOS 18 and above device operations. ' +
+        `Original error: ${error.message}`
+    );
+  }
+}
+
+/**
+ * Fetch module root and appium-ios-remotexpc version from package.json
+ *
+ * @returns Object containing moduleRoot and remoteXpcVersion
+ */
+function fetchInstallInfo(): {
+  moduleRoot: string | undefined;
+  remoteXpcVersion: string | undefined;
+} {
+  try {
+    const root = node.getModuleRootSync('appium-xcuitest-driver', __filename);
+    if (root) {
+      const packageJsonPath = path.join(root, 'package.json');
+      const packageJsonContent = readFileSync(packageJsonPath, 'utf8');
+      if (packageJsonContent) {
+        const packageJson = JSON.parse(packageJsonContent);
+        return {
+          moduleRoot: root,
+          remoteXpcVersion: packageJson.optionalDependencies?.['appium-ios-remotexpc'],
+        };
+      }
+    }
+  } catch {
+    // Error messages will skip install hints
+  }
+
+  return {moduleRoot: undefined, remoteXpcVersion: undefined};
+}

package/lib/driver.ts

@@ -39,6 +39,7 @@ import * as biometricCommands from './commands/biometric';
 import * as certificateCommands from './commands/certificate';
 import * as clipboardCommands from './commands/clipboard';
 import * as conditionCommands from './commands/condition';
+import type {IConditionInducer} from './commands/condition';
 import * as contentSizeCommands from './commands/content-size';
 import * as contextCommands from './commands/context';
 import * as deviceInfoCommands from './commands/device-info';
@@ -121,7 +122,6 @@ import type { PerfRecorder } from './commands/performance';
 import type { AudioRecorder } from './commands/record-audio';
 import type { TrafficCapture } from './commands/pcap';
 import type { ScreenRecorder } from './commands/recordscreen';
-import type { DVTServiceWithConnection } from 'appium-ios-remotexpc';
 import type { IOSDeviceLog } from './device/log/ios-device-log';
 import type { IOSSimulatorLog } from './device/log/ios-simulator-log';
 import type { IOSCrashLog } from './device/log/ios-crash-log';
@@ -262,8 +262,7 @@ export class XCUITestDriver
   _perfRecorders: PerfRecorder[];
   webElementsCache: LRUCache<any, any>;
 
-  _conditionInducerService: any | null; // needs types
-  _remoteXPCConditionInducerConnection: DVTServiceWithConnection | null; // RemoteXPC DVT connection for iOS>=18 condition inducer
+  _conditionInducer: IConditionInducer | null; // Condition inducer facade that abstracts implementation details
   _isSafariIphone: boolean | undefined;
   _isSafariNotched: boolean | undefined;
   _waitingAtoms: WaitingAtoms;
@@ -429,7 +428,7 @@ export class XCUITestDriver
       this._perfRecorders = [];
     }
 
-    if (this._conditionInducerService || this._remoteXPCConditionInducerConnection) {
+    if (this._conditionInducer) {
       try {
         await this.disableConditionInducer();
       } catch (err) {
@@ -1743,8 +1742,7 @@ export class XCUITestDriver
     this.pageLoadMs = 6000;
     this.landscapeWebCoordsOffset = 0;
     this._remote = null;
-    this._conditionInducerService = null;
-    this._remoteXPCConditionInducerConnection = null;
+    this._conditionInducer = null;
 
     this.webElementsCache = new LRUCache({
       max: WEB_ELEMENTS_CACHE_SIZE,

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "appium-xcuitest-driver",
-  "version": "10.14.10",
+  "version": "10.14.11",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "appium-xcuitest-driver",
-      "version": "10.14.10",
+      "version": "10.14.11",
       "license": "Apache-2.0",
       "dependencies": {
         "@appium/strongbox": "^1.0.0-rc.1",
@@ -321,12 +321,12 @@
       }
     },
     "node_modules/@babel/code-frame": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
-      "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==",
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.28.6.tgz",
+      "integrity": "sha512-JYgintcMjRiCvS8mMECzaEn+m3PfoQiyqukOMCCVQtoJGYJw8j/8LBJEiqkHLkfwCcs74E3pbAUFNg7d9VNJ+Q==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-validator-identifier": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.28.5",
         "js-tokens": "^4.0.0",
         "picocolors": "^1.1.1"
       },

package/package.json

@@ -8,7 +8,7 @@
     "xcuitest",
     "xctest"
   ],
-  "version": "10.14.10",
+  "version": "10.14.11",
   "author": "Appium Contributors",
   "license": "Apache-2.0",
   "repository": {
@@ -31,7 +31,7 @@
     ],
     "mainClass": "XCUITestDriver",
     "scripts": {
-      "build-wda": "./scripts/build-wda.js",
+      "build-wda": "./scripts/build-wda.mjs",
       "open-wda": "./scripts/open-wda.mjs",
       "tunnel-creation": "./scripts/tunnel-creation.mjs",
       "download-wda-sim": "./scripts/download-wda-sim.mjs",

package/scripts/{build-wda.js → build-wda.mjs}

@@ -1,15 +1,14 @@
-const {WebDriverAgent} = require('appium-webdriveragent');
-const xcode = require('appium-xcode');
-const {Simctl} = require('node-simctl');
-const {getSimulator} = require('appium-ios-simulator');
-const {logger} = require('appium/support');
-const {parseArgValue} = require('./utils');
+import {WebDriverAgent} from 'appium-webdriveragent';
+import * as xcode from 'appium-xcode';
+import {Simctl} from 'node-simctl';
+import {getSimulator} from 'appium-ios-simulator';
+import {logger} from 'appium/support.js';
+import {parseArgValue} from './utils.js';
 
 const log = logger.getLogger('WDA');
 
 async function build() {
   const customDevice = parseArgValue('name');
-  const xcodeVersion = await xcode.getVersion(true);
   const platformVersion = parseArgValue('sdk') || (await xcode.getMaxIOSSDK());
   const iosDevices = await new Simctl().getDevices(platformVersion, 'iOS');
   const verifyDevicePresence = (info) => {
@@ -27,7 +26,7 @@ async function build() {
     platform: deviceInfo.platform,
     checkExistence: false,
   });
-  const wda = new WebDriverAgent(xcodeVersion, {
+  const wda = new WebDriverAgent({
     iosSdkVersion: platformVersion,
     platformVersion,
     showXcodeLog: true,