appium-ios-remotexpc 0.17.0 → 0.18.1

package/src/services/ios/dvt/instruments/application-listing.ts

@@ -1,7 +1,6 @@
 import { getLogger } from '../../../../lib/logger.js';
-import type { Channel } from '../channel.js';
 import { MessageAux } from '../dtx-message.js';
-import type { DVTSecureSocketProxyService } from '../index.js';
+import { BaseInstrument } from './base-instrument.js';
 
 const log = getLogger('ApplicationListing');
 
@@ -46,24 +45,10 @@ export interface iOSApplication {
 /**
  * Application Listing service for retrieving installed applications
  */
-export class ApplicationListing {
+export class ApplicationListing extends BaseInstrument {
   static readonly IDENTIFIER =
     'com.apple.instruments.server.services.device.applictionListing';
 
-  private channel: Channel | null = null;
-
-  constructor(private readonly dvt: DVTSecureSocketProxyService) {}
-
-  /**
-   * Initialize the application listing channel
-   */
-  async initialize(): Promise<void> {
-    if (this.channel) {
-      return;
-    }
-    this.channel = await this.dvt.makeChannel(ApplicationListing.IDENTIFIER);
-  }
-
   /**
    * Get the list of installed applications from the device
    * @returns {Promise<iOSApplication[]>}

package/src/services/ios/dvt/instruments/base-instrument.ts

@@ -0,0 +1,27 @@
+import type { Channel } from '../channel.js';
+import type { DVTSecureSocketProxyService } from '../index.js';
+
+/**
+ * Base class for DVT instrument services.
+ *
+ * Subclasses must define a static `IDENTIFIER` property.
+ */
+export abstract class BaseInstrument {
+  static readonly IDENTIFIER: string;
+
+  protected channel: Channel | null = null;
+  constructor(protected readonly dvt: DVTSecureSocketProxyService) {}
+
+  protected get identifier(): string {
+    return (this.constructor as typeof BaseInstrument).IDENTIFIER;
+  }
+
+  /**
+   * Initialize the instrument channel.
+   */
+  async initialize(): Promise<void> {
+    if (!this.channel) {
+      this.channel = await this.dvt.makeChannel(this.identifier);
+    }
+  }
+}

package/src/services/ios/dvt/instruments/condition-inducer.ts

@@ -1,8 +1,7 @@
 import { getLogger } from '../../../../lib/logger.js';
 import type { ConditionGroup } from '../../../../lib/types.js';
-import type { Channel } from '../channel.js';
 import { MessageAux } from '../dtx-message.js';
-import type { DVTSecureSocketProxyService } from '../index.js';
+import { BaseInstrument } from './base-instrument.js';
 
 const log = getLogger('ConditionInducer');
 
@@ -10,24 +9,10 @@ const log = getLogger('ConditionInducer');
  * Condition Inducer service for simulating various device conditions
  * such as network conditions, thermal states, etc.
  */
-export class ConditionInducer {
+export class ConditionInducer extends BaseInstrument {
   static readonly IDENTIFIER =
     'com.apple.instruments.server.services.ConditionInducer';
 
-  private channel: Channel | null = null;
-
-  constructor(private readonly dvt: DVTSecureSocketProxyService) {}
-
-  /**
-   * Initialize the condition inducer channel
-   */
-  async initialize(): Promise<void> {
-    if (this.channel) {
-      return;
-    }
-    this.channel = await this.dvt.makeChannel(ConditionInducer.IDENTIFIER);
-  }
-
   /**
    * List all available condition inducers and their profiles
    * @returns Array of condition groups with their available profiles

package/src/services/ios/dvt/instruments/device-info.ts

@@ -0,0 +1,204 @@
+import { getLogger } from '../../../../lib/logger.js';
+import { parseBinaryPlist } from '../../../../lib/plist/index.js';
+import type { ProcessInfo } from '../../../../lib/types.js';
+import { MessageAux } from '../dtx-message.js';
+import { BaseInstrument } from './base-instrument.js';
+
+const log = getLogger('DeviceInfo');
+
+/**
+ * DeviceInfo service provides access to device information, file system,
+ * and process management through the DTX protocol.
+ *
+ * Available methods:
+ * - ls(path): List directory contents
+ * - execnameForPid(pid): Get executable path for a process ID
+ * - proclist(): Get list of running processes
+ * - isRunningPid(pid): Check if a process is running
+ * - hardwareInformation(): Get hardware details
+ * - networkInformation(): Get network configuration
+ * - machTimeInfo(): Get mach time information
+ * - machKernelName(): Get kernel name
+ * - kpepDatabase(): Get kernel performance event database
+ * - traceCodes(): Get trace code mappings
+ * - nameForUid(uid): Get username for UID
+ * - nameForGid(gid): Get group name for GID
+ */
+export class DeviceInfo extends BaseInstrument {
+  static readonly IDENTIFIER =
+    'com.apple.instruments.server.services.deviceinfo';
+
+  /**
+   * List directory contents at the specified path.
+   * @param path - The directory path to list
+   * @returns Array of filenames
+   * @throws {Error} If the directory doesn't exist or cannot be accessed
+   */
+  async ls(path: string): Promise<string[]> {
+    const result = await this.requestInformation(
+      'directoryListingForPath_',
+      path,
+    );
+
+    if (result === null || result === undefined) {
+      throw new Error(`Failed to list directory: ${path}`);
+    }
+
+    log.debug(`Listed directory ${path}: ${result.length} entries`);
+    return result;
+  }
+
+  /**
+   * Get the full executable path for a given process ID.
+   * @param pid - The process identifier
+   * @returns The full path to the executable
+   */
+  async execnameForPid(pid: number): Promise<string> {
+    return this.requestInformation('execnameForPid_', pid);
+  }
+
+  /**
+   * Get the list of all running processes on the device.
+   * @returns Array of process information objects
+   */
+  async proclist(): Promise<ProcessInfo[]> {
+    const result = await this.requestInformation('runningProcesses');
+
+    if (!Array.isArray(result)) {
+      throw new Error(
+        `proclist returned invalid data: expected an array, got ${typeof result} (${JSON.stringify(result)})`,
+      );
+    }
+
+    log.debug(`Retrieved ${result.length} running processes`);
+    return result;
+  }
+
+  /**
+   * Check if a process with the given PID is currently running.
+   * @param pid - The process identifier to check
+   * @returns true if the process is running, false otherwise
+   */
+  async isRunningPid(pid: number): Promise<boolean> {
+    return this.requestInformation('isRunningPid_', pid);
+  }
+
+  /**
+   * Get hardware information about the device.
+   * @returns Object containing hardware information
+   */
+  async hardwareInformation(): Promise<any> {
+    return this.requestInformation('hardwareInformation');
+  }
+
+  /**
+   * Get network configuration information.
+   * @returns Object containing network information
+   */
+  async networkInformation(): Promise<any> {
+    return this.requestInformation('networkInformation');
+  }
+
+  /**
+   * Get mach kernel time information.
+   * @returns Object containing mach time info
+   */
+  async machTimeInfo(): Promise<any> {
+    return this.requestInformation('machTimeInfo');
+  }
+
+  /**
+   * Get the mach kernel name.
+   * @returns The kernel name string
+   */
+  async machKernelName(): Promise<string> {
+    return this.requestInformation('machKernelName');
+  }
+
+  /**
+   * Get the kernel performance event (kpep) database.
+   * @returns Object containing kpep database or null if not available
+   */
+  async kpepDatabase(): Promise<any | null> {
+    const kpepData = await this.requestInformation('kpepDatabase');
+
+    if (kpepData === null || kpepData === undefined) {
+      return null;
+    }
+
+    // The kpepDatabase is returned as binary plist data
+    if (Buffer.isBuffer(kpepData)) {
+      try {
+        return parseBinaryPlist(kpepData);
+      } catch (error) {
+        log.warn('Failed to parse kpep database:', error);
+        return null;
+      }
+    }
+
+    return kpepData;
+  }
+
+  /**
+   * Get trace code mappings.
+   * @returns Object mapping trace codes (as hex strings) to descriptions
+   */
+  async traceCodes(): Promise<Record<string, string>> {
+    const codesFile = await this.requestInformation('traceCodesFile');
+    if (typeof codesFile !== 'string') {
+      return {};
+    }
+
+    const codes: Record<string, string> = {};
+
+    for (const line of codesFile.split('\n')) {
+      const match = line.trim().match(/^(\S+)\s+(.+)$/);
+      if (match) {
+        const [, hex, description] = match;
+        codes[hex] = description;
+      }
+    }
+
+    log.debug(`Retrieved ${Object.keys(codes).length} trace codes`);
+    return codes;
+  }
+
+  /**
+   * Get the username for a given user ID (UID).
+   * @param uid - The user identifier
+   * @returns The username string
+   */
+  async nameForUid(uid: number): Promise<string> {
+    return this.requestInformation('nameForUID_', uid);
+  }
+
+  /**
+   * Get the group name for a given group ID (GID).
+   * @param gid - The group identifier
+   * @returns The group name string
+   */
+  async nameForGid(gid: number): Promise<string> {
+    return this.requestInformation('nameForGID_', gid);
+  }
+
+  /**
+   * Generic method to request information from the device.
+   * @param selectorName - The selector name to call
+   * @param arg - Optional argument to pass to the selector
+   * @returns The information object or value returned by the selector
+   * @private
+   */
+  private async requestInformation(
+    selectorName: string,
+    arg?: any,
+  ): Promise<any> {
+    await this.initialize();
+
+    const call = this.channel!.call(selectorName);
+    const args =
+      arg !== undefined ? new MessageAux().appendObj(arg) : undefined;
+
+    await call(args);
+    return this.channel!.receivePlist();
+  }
+}

package/src/services/ios/dvt/instruments/graphics.ts

@@ -1,24 +1,13 @@
 import { getLogger } from '../../../../lib/logger.js';
-import type { Channel } from '../channel.js';
 import { MessageAux } from '../dtx-message.js';
-import type { DVTSecureSocketProxyService } from '../index.js';
+import { BaseInstrument } from './base-instrument.js';
 
 const log = getLogger('Graphics');
 
-export class Graphics {
+export class Graphics extends BaseInstrument {
   static readonly IDENTIFIER =
     'com.apple.instruments.server.services.graphics.opengl';
 
-  private channel: Channel | null = null;
-
-  constructor(private readonly dvt: DVTSecureSocketProxyService) {}
-
-  async initialize(): Promise<void> {
-    if (!this.channel) {
-      this.channel = await this.dvt.makeChannel(Graphics.IDENTIFIER);
-    }
-  }
-
   async start(): Promise<void> {
     await this.initialize();
 

package/src/services/ios/dvt/instruments/location-simulation.ts

@@ -1,7 +1,6 @@
 import { getLogger } from '../../../../lib/logger.js';
-import type { Channel } from '../channel.js';
 import { MessageAux } from '../dtx-message.js';
-import type { DVTSecureSocketProxyService } from '../index.js';
+import { BaseInstrument } from './base-instrument.js';
 
 const log = getLogger('LocationSimulation');
 
@@ -16,25 +15,10 @@ export interface LocationCoordinates {
 /**
  * Location simulation service for simulating device GPS location
  */
-export class LocationSimulation {
+export class LocationSimulation extends BaseInstrument {
   static readonly IDENTIFIER =
     'com.apple.instruments.server.services.LocationSimulation';
 
-  private channel: Channel | null = null;
-
-  constructor(private readonly dvt: DVTSecureSocketProxyService) {}
-
-  /**
-   * Initialize the location simulation channel
-   */
-  async initialize(): Promise<void> {
-    if (this.channel) {
-      return;
-    }
-
-    this.channel = await this.dvt.makeChannel(LocationSimulation.IDENTIFIER);
-  }
-
   /**
    * Set the simulated GPS location
    * @param coordinates The location coordinates

package/src/services/ios/dvt/instruments/screenshot.ts

@@ -1,26 +1,15 @@
 import { getLogger } from '../../../../lib/logger.js';
-import type { Channel } from '../channel.js';
-import type { DVTSecureSocketProxyService } from '../index.js';
+import { BaseInstrument } from './base-instrument.js';
 
 const log = getLogger('Screenshot');
 
 /**
  * Screenshot service for capturing device screenshots
  */
-export class Screenshot {
+export class Screenshot extends BaseInstrument {
   static readonly IDENTIFIER =
     'com.apple.instruments.server.services.screenshot';
 
-  private channel: Channel | null = null;
-
-  constructor(private readonly dvt: DVTSecureSocketProxyService) {}
-
-  async initialize(): Promise<void> {
-    if (!this.channel) {
-      this.channel = await this.dvt.makeChannel(Screenshot.IDENTIFIER);
-    }
-  }
-
   /**
    * Capture a screenshot from the device
    * @returns The screenshot data as a Buffer

package/src/services.ts

@@ -20,6 +20,7 @@ import DiagnosticsService from './services/ios/diagnostic-service/index.js';
 import { DVTSecureSocketProxyService } from './services/ios/dvt/index.js';
 import { ApplicationListing } from './services/ios/dvt/instruments/application-listing.js';
 import { ConditionInducer } from './services/ios/dvt/instruments/condition-inducer.js';
+import { DeviceInfo } from './services/ios/dvt/instruments/device-info.js';
 import { Graphics } from './services/ios/dvt/instruments/graphics.js';
 import { LocationSimulation } from './services/ios/dvt/instruments/location-simulation.js';
 import { Screenshot } from './services/ios/dvt/instruments/screenshot.js';
@@ -206,6 +207,7 @@ export async function startDVTService(
   const screenshot = new Screenshot(dvtService);
   const appListing = new ApplicationListing(dvtService);
   const graphics = new Graphics(dvtService);
+  const deviceInfo = new DeviceInfo(dvtService);
 
   return {
     remoteXPC: remoteXPC as RemoteXpcConnection,
@@ -215,6 +217,7 @@ export async function startDVTService(
     screenshot,
     appListing,
     graphics,
+    deviceInfo,
   };
 }