appium-ios-remotexpc 0.3.2 → 0.4.0

package/build/src/services/ios/mobile-image-mounter/index.d.ts

@@ -0,0 +1,122 @@
+import type { MobileImageMounterService as MobileImageMounterServiceInterface, PlistDictionary } from '../../../lib/types.js';
+import { BaseService } from '../base-service.js';
+/**
+ * Base interface for service responses
+ */
+interface BaseResponse {
+    Status?: string;
+    Error?: string;
+    DetailedError?: string;
+}
+/**
+ * Interface for image-related responses
+ */
+export interface ImageResponse extends BaseResponse {
+    ImagePresent?: boolean;
+    ImageSignature?: Buffer[] | Buffer;
+}
+/**
+ * MobileImageMounterService provides an API to:
+ * - Mount Developer Disk Images on iOS devices
+ * - Lookup mounted images and their signatures
+ * - Check if personalized images are mounted
+ * - Unmount images when needed
+ */
+declare class MobileImageMounterService extends BaseService implements MobileImageMounterServiceInterface {
+    static readonly RSD_SERVICE_NAME = "com.apple.mobile.mobile_image_mounter.shim.remote";
+    private static readonly FILE_TYPE_IMAGE;
+    private static readonly FILE_TYPE_BUILD_MANIFEST;
+    private static readonly FILE_TYPE_TRUST_CACHE;
+    private static readonly IMAGE_TYPE;
+    private static readonly MOUNT_PATH;
+    private static readonly UPLOAD_IMAGE_TIMEOUT;
+    private connection;
+    constructor(address: [string, number]);
+    /**
+     * Clean up resources when service is no longer needed
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Lookup mounted images by type
+     * @param imageType Type of image to lookup (defaults to 'Personalized')
+     * @returns Array of signatures of mounted images
+     */
+    lookup(imageType?: string): Promise<Buffer[]>;
+    /**
+     * Check if personalized image is mounted
+     * @returns True if personalized image is mounted
+     */
+    isPersonalizedImageMounted(): Promise<boolean>;
+    /**
+     * Mount personalized image for device (iOS >= 17)
+     * @param imageFilePath Path to the image file (.dmg)
+     * @param buildManifestFilePath Path to the build manifest file (.plist)
+     * @param trustCacheFilePath Path to the trust cache file (.trustcache)
+     * @param infoPlist Optional info plist dictionary
+     */
+    mount(imageFilePath: string, buildManifestFilePath: string, trustCacheFilePath: string, infoPlist?: PlistDictionary): Promise<void>;
+    /**
+     * Unmount image from device
+     * @param mountPath Mount path to unmount (defaults to '/System/Developer')
+     */
+    unmountImage(mountPath?: string): Promise<void>;
+    /**
+     * Query developer mode status (iOS 16+)
+     * @returns True if developer mode is enabled (defaults to true for older iOS)
+     */
+    queryDeveloperModeStatus(): Promise<boolean>;
+    /**
+     * Query personalization nonce for personalized images
+     * @param personalizedImageType Optional personalized image type
+     * @returns Personalization nonce as Buffer
+     */
+    queryNonce(personalizedImageType?: string): Promise<Buffer>;
+    /**
+     * Query personalization identifiers from the device
+     * @returns Personalization identifiers dictionary
+     */
+    queryPersonalizationIdentifiers(): Promise<PlistDictionary>;
+    /**
+     * Copy devices info (only for mounted images)
+     * @returns List of mounted devices
+     */
+    copyDevices(): Promise<any[]>;
+    /**
+     * Query personalization manifest from device
+     * @param imageType The image type
+     * @param signature The image signature/hash
+     * @returns Personalization manifest as Buffer
+     */
+    queryPersonalizationManifest(imageType: string, signature: Buffer): Promise<Buffer>;
+    /**
+     * Upload image to device
+     * @param imageType The image type
+     * @param image The image data
+     * @param signature The image signature/manifest
+     * @param timeout Optional timeout for upload operation (defaults to 20000ms)
+     */
+    uploadImage(imageType: string, image: Buffer, signature: Buffer, timeout?: number): Promise<void>;
+    /**
+     * Mount image on device
+     * @param imageType The image type
+     * @param signature The image signature/manifest
+     * @param extras Additional parameters for mounting
+     */
+    mountImage(imageType: string, signature: Buffer, extras?: Record<string, any>): Promise<void>;
+    private sendRequest;
+    /**
+     * Calculate hash of a buffer asynchronously
+     * @param buffer The buffer to hash
+     * @returns Promise resolving to the hash digest
+     */
+    private hashLargeBufferAsync;
+    private getOrRetrieveManifestFromTSS;
+    private isConnectionDestroyed;
+    private connectToMobileImageMounterService;
+    private closeConnection;
+    private checkIfError;
+    private assertIsFile;
+}
+export default MobileImageMounterService;
+export { MobileImageMounterService };
+//# sourceMappingURL=index.d.ts.map

package/build/src/services/ios/mobile-image-mounter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/ios/mobile-image-mounter/index.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,yBAAyB,IAAI,kCAAkC,EAC/D,eAAe,EAChB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAIjD;;GAEG;AACH,UAAU,YAAY;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,aAAc,SAAQ,YAAY;IACjD,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;CACpC;AAED;;;;;;GAMG;AACH,cAAM,yBACJ,SAAQ,WACR,YAAW,kCAAkC;IAE7C,MAAM,CAAC,QAAQ,CAAC,gBAAgB,uDACsB;IAGtD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAW;IAClD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,wBAAwB,CAAoB;IACpE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAAiB;IAC9D,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAkB;IACpD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAuB;IACzD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,oBAAoB,CAAS;IAGrD,OAAO,CAAC,UAAU,CAAkC;gBAExC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;IAIrC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAI9B;;;;OAIG;IACG,MAAM,CACV,SAAS,SAAuC,GAC/C,OAAO,CAAC,MAAM,EAAE,CAAC;IAUpB;;;OAGG;IACG,0BAA0B,IAAI,OAAO,CAAC,OAAO,CAAC;IAQpD;;;;;;OAMG;IACG,KAAK,CACT,aAAa,EAAE,MAAM,EACrB,qBAAqB,EAAE,MAAM,EAC7B,kBAAkB,EAAE,MAAM,EAC1B,SAAS,CAAC,EAAE,eAAe,GAC1B,OAAO,CAAC,IAAI,CAAC;IAgEhB;;;OAGG;IACG,YAAY,CAChB,SAAS,SAAuC,GAC/C,OAAO,CAAC,IAAI,CAAC;IAsBhB;;;OAGG;IACG,wBAAwB,IAAI,OAAO,CAAC,OAAO,CAAC;IAYlD;;;;OAIG;IACG,UAAU,CAAC,qBAAqB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAgBjE;;;OAGG;IACG,+BAA+B,IAAI,OAAO,CAAC,eAAe,CAAC;IAQjE;;;OAGG;IACG,WAAW,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IAKnC;;;;;OAKG;IACG,4BAA4B,CAChC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,MAAM,CAAC;IAgClB;;;;;;OAMG;IACG,WAAW,CACf,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,OAAO,SAAiD,GACvD,OAAO,CAAC,IAAI,CAAC;IAiChB;;;;;OAKG;IACG,UAAU,CACd,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC3B,OAAO,CAAC,IAAI,CAAC;YA4BF,WAAW;IAczB;;;;OAIG;YACW,oBAAoB;YAmBpB,4BAA4B;IAyC1C,OAAO,CAAC,qBAAqB;YASf,kCAAkC;IAchD,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,YAAY;YAMN,YAAY;CAiB3B;AAED,eAAe,yBAAyB,CAAC;AACzC,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/build/src/services/ios/mobile-image-mounter/index.js

@@ -0,0 +1,363 @@
+import { logger } from '@appium/support';
+import { createHash } from 'crypto';
+import { Stats, promises as fs } from 'fs';
+import { performance } from 'perf_hooks';
+import { Readable } from 'stream';
+import { parseXmlPlist } from '../../../lib/plist/index.js';
+import { getManifestFromTSS } from '../../../lib/tss/index.js';
+import { ServiceConnection } from '../../../service-connection.js';
+import { BaseService } from '../base-service.js';
+const log = logger.getLogger('MobileImageMounterService');
+/**
+ * MobileImageMounterService provides an API to:
+ * - Mount Developer Disk Images on iOS devices
+ * - Lookup mounted images and their signatures
+ * - Check if personalized images are mounted
+ * - Unmount images when needed
+ */
+class MobileImageMounterService extends BaseService {
+    static RSD_SERVICE_NAME = 'com.apple.mobile.mobile_image_mounter.shim.remote';
+    // Constants
+    static FILE_TYPE_IMAGE = 'image';
+    static FILE_TYPE_BUILD_MANIFEST = 'build_manifest';
+    static FILE_TYPE_TRUST_CACHE = 'trust_cache';
+    static IMAGE_TYPE = 'Personalized';
+    static MOUNT_PATH = '/System/Developer';
+    static UPLOAD_IMAGE_TIMEOUT = 20000;
+    // Connection cache
+    connection = null;
+    constructor(address) {
+        super(address);
+    }
+    /**
+     * Clean up resources when service is no longer needed
+     */
+    async cleanup() {
+        this.closeConnection();
+    }
+    /**
+     * Lookup mounted images by type
+     * @param imageType Type of image to lookup (defaults to 'Personalized')
+     * @returns Array of signatures of mounted images
+     */
+    async lookup(imageType = MobileImageMounterService.IMAGE_TYPE) {
+        const response = (await this.sendRequest({
+            Command: 'LookupImage',
+            ImageType: imageType,
+        }));
+        const signatures = response.ImageSignature || [];
+        return signatures.filter(Buffer.isBuffer);
+    }
+    /**
+     * Check if personalized image is mounted
+     * @returns True if personalized image is mounted
+     */
+    async isPersonalizedImageMounted() {
+        try {
+            return (await this.lookup()).length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Mount personalized image for device (iOS >= 17)
+     * @param imageFilePath Path to the image file (.dmg)
+     * @param buildManifestFilePath Path to the build manifest file (.plist)
+     * @param trustCacheFilePath Path to the trust cache file (.trustcache)
+     * @param infoPlist Optional info plist dictionary
+     */
+    async mount(imageFilePath, buildManifestFilePath, trustCacheFilePath, infoPlist) {
+        if (await this.isPersonalizedImageMounted()) {
+            log.info('Personalized image is already mounted');
+            return;
+        }
+        const start = performance.now();
+        // Validate files and read content
+        await Promise.all([
+            this.assertIsFile(imageFilePath, MobileImageMounterService.FILE_TYPE_IMAGE),
+            this.assertIsFile(buildManifestFilePath, MobileImageMounterService.FILE_TYPE_BUILD_MANIFEST),
+            this.assertIsFile(trustCacheFilePath, MobileImageMounterService.FILE_TYPE_TRUST_CACHE),
+        ]);
+        const [image, trustCache, buildManifestContent] = await Promise.all([
+            fs.readFile(imageFilePath),
+            fs.readFile(trustCacheFilePath),
+            fs.readFile(buildManifestFilePath, 'utf8'),
+        ]);
+        const buildManifest = parseXmlPlist(buildManifestContent);
+        const manifest = await this.getOrRetrieveManifestFromTSS(image, buildManifest);
+        await this.uploadImage(MobileImageMounterService.IMAGE_TYPE, image, manifest);
+        const extras = {
+            ImageTrustCache: trustCache,
+        };
+        if (infoPlist) {
+            extras.ImageInfoPlist = infoPlist;
+        }
+        await this.mountImage(MobileImageMounterService.IMAGE_TYPE, manifest, extras);
+        const end = performance.now();
+        log.info(`Successfully mounted personalized image in ${(end - start).toFixed(2)} ms`);
+    }
+    /**
+     * Unmount image from device
+     * @param mountPath Mount path to unmount (defaults to '/System/Developer')
+     */
+    async unmountImage(mountPath = MobileImageMounterService.MOUNT_PATH) {
+        const response = (await this.sendRequest({
+            Command: 'UnmountImage',
+            MountPath: mountPath,
+        }));
+        if (response.Error === 'UnknownCommand') {
+            throw new Error('Unmount command is not supported on this iOS version');
+        }
+        if (response.DetailedError?.includes('There is no matching entry')) {
+            throw new Error(`No mounted image found at path: ${mountPath}`);
+        }
+        if (response.Error === 'InternalError') {
+            throw new Error(`Internal error occurred while unmounting: ${JSON.stringify(response)}`);
+        }
+        this.checkIfError(response);
+        log.info(`Successfully unmounted image from ${mountPath}`);
+    }
+    /**
+     * Query developer mode status (iOS 16+)
+     * @returns True if developer mode is enabled (defaults to true for older iOS)
+     */
+    async queryDeveloperModeStatus() {
+        try {
+            const response = await this.sendRequest({
+                Command: 'QueryDeveloperModeStatus',
+            });
+            this.checkIfError(response);
+            return Boolean(response.DeveloperModeStatus);
+        }
+        catch {
+            return true; // Default for older iOS versions
+        }
+    }
+    /**
+     * Query personalization nonce for personalized images
+     * @param personalizedImageType Optional personalized image type
+     * @returns Personalization nonce as Buffer
+     */
+    async queryNonce(personalizedImageType) {
+        const request = { Command: 'QueryNonce' };
+        if (personalizedImageType) {
+            request.PersonalizedImageType = personalizedImageType;
+        }
+        const response = await this.sendRequest(request);
+        this.checkIfError(response);
+        const nonce = response.PersonalizationNonce;
+        if (!Buffer.isBuffer(nonce)) {
+            throw new Error('Invalid nonce received from device');
+        }
+        return nonce;
+    }
+    /**
+     * Query personalization identifiers from the device
+     * @returns Personalization identifiers dictionary
+     */
+    async queryPersonalizationIdentifiers() {
+        const response = await this.sendRequest({
+            Command: 'QueryPersonalizationIdentifiers',
+        });
+        this.checkIfError(response);
+        return response.PersonalizationIdentifiers;
+    }
+    /**
+     * Copy devices info (only for mounted images)
+     * @returns List of mounted devices
+     */
+    async copyDevices() {
+        const response = await this.sendRequest({ Command: 'CopyDevices' });
+        return response.EntryList || [];
+    }
+    /**
+     * Query personalization manifest from device
+     * @param imageType The image type
+     * @param signature The image signature/hash
+     * @returns Personalization manifest as Buffer
+     */
+    async queryPersonalizationManifest(imageType, signature) {
+        try {
+            const response = await this.sendRequest({
+                Command: 'QueryPersonalizationManifest',
+                PersonalizedImageType: imageType,
+                ImageType: imageType,
+                ImageSignature: signature,
+            });
+            this.checkIfError(response);
+            const manifest = response.ImageSignature;
+            if (!manifest || !Buffer.isBuffer(manifest)) {
+                throw new Error('MissingManifestError: Personalization manifest not found on device');
+            }
+            return manifest;
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.includes('MissingManifestError')) {
+                throw error;
+            }
+            throw new Error('MissingManifestError: Personalization manifest not found on device');
+        }
+    }
+    /**
+     * Upload image to device
+     * @param imageType The image type
+     * @param image The image data
+     * @param signature The image signature/manifest
+     * @param timeout Optional timeout for upload operation (defaults to 20000ms)
+     */
+    async uploadImage(imageType, image, signature, timeout = MobileImageMounterService.UPLOAD_IMAGE_TIMEOUT) {
+        const receiveBytesResult = (await this.sendRequest({
+            Command: 'ReceiveBytes',
+            ImageType: imageType,
+            ImageSize: image.length,
+            ImageSignature: signature,
+        }));
+        this.checkIfError(receiveBytesResult);
+        if (receiveBytesResult.Status !== 'ReceiveBytesAck') {
+            throw new Error(`Unexpected return from mobile_image_mounter: ${JSON.stringify(receiveBytesResult)}`);
+        }
+        const conn = await this.connectToMobileImageMounterService();
+        const socket = conn.getSocket();
+        await new Promise((resolve, reject) => {
+            socket.write(image, (error) => error ? reject(error) : resolve());
+        });
+        const uploadResult = await conn.receive(timeout);
+        if (uploadResult.Status !== 'Complete') {
+            throw new Error(`Image upload failed: ${JSON.stringify(uploadResult)}`);
+        }
+        log.debug('Image uploaded successfully');
+    }
+    /**
+     * Mount image on device
+     * @param imageType The image type
+     * @param signature The image signature/manifest
+     * @param extras Additional parameters for mounting
+     */
+    async mountImage(imageType, signature, extras) {
+        const request = {
+            Command: 'MountImage',
+            ImageType: imageType,
+            ImageSignature: signature,
+            ...extras,
+        };
+        const response = (await this.sendRequest(request));
+        if (response.DetailedError?.includes('is already mounted')) {
+            log.info('Image was already mounted');
+            return;
+        }
+        if (response.DetailedError?.includes('Developer mode is not enabled')) {
+            throw new Error('Developer mode is not enabled on this device');
+        }
+        this.checkIfError(response);
+        if (response.Status !== 'Complete') {
+            throw new Error(`Mount image failed: ${JSON.stringify(response)}`);
+        }
+        log.debug('Image mounted successfully');
+    }
+    async sendRequest(request, timeout) {
+        const isNewConnection = !this.connection || this.isConnectionDestroyed();
+        const conn = await this.connectToMobileImageMounterService();
+        const res = await conn.sendPlistRequest(request, timeout);
+        if (isNewConnection && res?.Request === 'StartService') {
+            return await conn.receive();
+        }
+        return res;
+    }
+    /**
+     * Calculate hash of a buffer asynchronously
+     * @param buffer The buffer to hash
+     * @returns Promise resolving to the hash digest
+     */
+    async hashLargeBufferAsync(buffer) {
+        return new Promise((resolve, reject) => {
+            const hash = createHash('sha384');
+            const stream = Readable.from(buffer);
+            stream.on('data', (chunk) => {
+                hash.update(chunk);
+            });
+            stream.on('end', () => {
+                resolve(hash.digest());
+            });
+            stream.on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+    async getOrRetrieveManifestFromTSS(image, buildManifest) {
+        try {
+            const imageHash = await this.hashLargeBufferAsync(image);
+            const manifest = await this.queryPersonalizationManifest('DeveloperDiskImage', imageHash);
+            log.debug('Successfully retrieved existing personalization manifest from device');
+            return manifest;
+        }
+        catch (error) {
+            if (error.message?.includes('MissingManifestError')) {
+                log.debug('Personalization manifest not found on device, using TSS...');
+                const identifiers = await this.queryPersonalizationIdentifiers();
+                const ecid = identifiers.UniqueChipID;
+                if (!ecid) {
+                    throw new Error('Could not retrieve device ECID from personalization identifiers');
+                }
+                const manifest = await getManifestFromTSS(ecid, buildManifest, () => this.queryPersonalizationIdentifiers(), (type) => this.queryNonce(type));
+                log.debug('Successfully generated manifest from TSS');
+                return manifest;
+            }
+            throw error;
+        }
+    }
+    isConnectionDestroyed() {
+        try {
+            const socket = this.connection.getSocket();
+            return !socket || socket.destroyed;
+        }
+        catch {
+            return true;
+        }
+    }
+    async connectToMobileImageMounterService() {
+        if (this.connection && !this.isConnectionDestroyed()) {
+            return this.connection;
+        }
+        const newConnection = await this.startLockdownService({
+            serviceName: MobileImageMounterService.RSD_SERVICE_NAME,
+            port: this.address[1].toString(),
+        });
+        this.connection = newConnection;
+        return newConnection;
+    }
+    closeConnection() {
+        if (this.connection) {
+            try {
+                this.connection.close();
+            }
+            catch {
+                // Ignore close errors
+            }
+            this.connection = null;
+        }
+    }
+    checkIfError(response) {
+        if (response.Error) {
+            throw new Error(response.Error);
+        }
+    }
+    async assertIsFile(filePath, fileType) {
+        try {
+            const fileStat = await fs.stat(filePath);
+            if (!fileStat.isFile()) {
+                throw new Error(`Expected ${fileType} file, got non-file: ${filePath}`);
+            }
+            return fileStat;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                throw new Error(`${fileType} file not found: ${filePath}`);
+            }
+            throw error;
+        }
+    }
+}
+export default MobileImageMounterService;
+export { MobileImageMounterService };

package/build/src/services.d.ts

@@ -1,7 +1,8 @@
 import { RemoteXpcConnection } from './lib/remote-xpc/remote-xpc-connection.js';
-import type { DiagnosticsServiceWithConnection, NotificationProxyServiceWithConnection, SyslogService as SyslogServiceType } from './lib/types.js';
+import type { DiagnosticsServiceWithConnection, MobileImageMounterServiceWithConnection, NotificationProxyServiceWithConnection, SyslogService as SyslogServiceType } from './lib/types.js';
 export declare function startDiagnosticsService(udid: string): Promise<DiagnosticsServiceWithConnection>;
 export declare function startNotificationProxyService(udid: string): Promise<NotificationProxyServiceWithConnection>;
+export declare function startMobileImageMounterService(udid: string): Promise<MobileImageMounterServiceWithConnection>;
 export declare function startSyslogService(udid: string): Promise<SyslogServiceType>;
 export declare function createRemoteXPCConnection(udid: string): Promise<{
     remoteXPC: RemoteXpcConnection;

package/build/src/services.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../src/services.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAGhF,OAAO,KAAK,EACV,gCAAgC,EAChC,sCAAsC,EACtC,aAAa,IAAI,iBAAiB,EACnC,MAAM,gBAAgB,CAAC;AAQxB,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,gCAAgC,CAAC,CAY3C;AAED,wBAAsB,6BAA6B,CACjD,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,sCAAsC,CAAC,CAYjD;AAED,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,iBAAiB,CAAC,CAG5B;AAED,wBAAsB,yBAAyB,CAAC,IAAI,EAAE,MAAM;;;;;;;;GAO3D"}
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../src/services.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAGhF,OAAO,KAAK,EACV,gCAAgC,EAChC,uCAAuC,EACvC,sCAAsC,EACtC,aAAa,IAAI,iBAAiB,EACnC,MAAM,gBAAgB,CAAC;AASxB,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,gCAAgC,CAAC,CAY3C;AAED,wBAAsB,6BAA6B,CACjD,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,sCAAsC,CAAC,CAYjD;AAED,wBAAsB,8BAA8B,CAClD,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,uCAAuC,CAAC,CAYlD;AAED,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,iBAAiB,CAAC,CAG5B;AAED,wBAAsB,yBAAyB,CAAC,IAAI,EAAE,MAAM;;;;;;;;GAO3D"}

package/build/src/services.js

@@ -3,6 +3,7 @@ import { RemoteXpcConnection } from './lib/remote-xpc/remote-xpc-connection.js';
 import { TunnelManager } from './lib/tunnel/index.js';
 import { TunnelApiClient } from './lib/tunnel/tunnel-api-client.js';
 import DiagnosticsService from './services/ios/diagnostic-service/index.js';
+import MobileImageMounterService from './services/ios/mobile-image-mounter/index.js';
 import { NotificationProxyService } from './services/ios/notification-proxy/index.js';
 import SyslogService from './services/ios/syslog-service/index.js';
 const APPIUM_XCUITEST_DRIVER_NAME = 'appium-xcuitest-driver';
@@ -29,6 +30,17 @@ export async function startNotificationProxyService(udid) {
         ]),
     };
 }
+export async function startMobileImageMounterService(udid) {
+    const { remoteXPC, tunnelConnection } = await createRemoteXPCConnection(udid);
+    const mobileImageMounterService = remoteXPC.findService(MobileImageMounterService.RSD_SERVICE_NAME);
+    return {
+        remoteXPC: remoteXPC,
+        mobileImageMounterService: new MobileImageMounterService([
+            tunnelConnection.host,
+            parseInt(mobileImageMounterService.port, 10),
+        ]),
+    };
+}
 export async function startSyslogService(udid) {
     const { tunnelConnection } = await createRemoteXPCConnection(udid);
     return new SyslogService([tunnelConnection.host, tunnelConnection.port]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appium-ios-remotexpc",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "main": "build/src/index.js",
   "types": "build/src/index.d.ts",
   "type": "module",
@@ -29,6 +29,7 @@
     "test:pair-record": "mocha test/integration/read-pair-record-test.ts --exit --timeout 1m",
     "test:diagnostics": "mocha test/integration/diagnostics-test.ts --exit --timeout 1m",
     "test:notification": "mocha test/integration/notification-proxy-test.ts --exit --timeout 1m",
+    "test:image-mounter": "mocha test/integration/mobile-image-mounter-test.ts --exit --timeout 1m",
     "test:unit": "mocha 'test/unit/**/*.ts' --exit --timeout 2m",
     "test:tunnel-creation": "sudo tsx scripts/test-tunnel-creation.ts",
     "test:tunnel-creation:lsof": "sudo tsx scripts/test-tunnel-creation.ts --keep-open"
@@ -70,8 +71,9 @@
     "@appium/support": "^7.0.0-rc.1",
     "@types/node": "^24.0.10",
     "@xmldom/xmldom": "^0.9.8",
-    "npm-run-all2": "^8.0.4",
-    "appium-ios-tuntap": "^0.x"
+    "appium-ios-tuntap": "^0.x",
+    "axios": "^1.12.0",
+    "npm-run-all2": "^8.0.4"
   },
   "files": [
     "src",

package/src/index.ts

@@ -14,12 +14,14 @@ import { startCoreDeviceProxy } from './services/ios/tunnel-service/index.js';
 
 export type {
   DiagnosticsService,
+  MobileImageMounterService,
   SyslogService,
   SocketInfo,
   TunnelResult,
   TunnelRegistry,
   TunnelRegistryEntry,
   DiagnosticsServiceWithConnection,
+  MobileImageMounterServiceWithConnection,
 } from './lib/types.js';
 export {
   createUsbmux,

package/src/lib/plist/binary-plist-creator.ts

@@ -59,7 +59,11 @@ class BinaryPlistCreator {
     const objectData: Buffer[] = [];
 
     for (const value of this._objectTable) {
-      objectOffsets.push(this._calculateObjectDataLength(objectData));
+      // Calculate offset including the header length
+      objectOffsets.push(
+        BPLIST_MAGIC_AND_VERSION.length +
+          this._calculateObjectDataLength(objectData),
+      );
       objectData.push(this._createObjectData(value));
     }
 
@@ -341,11 +345,22 @@ class BinaryPlistCreator {
     // Check if string can be ASCII
     // eslint-disable-next-line no-control-regex
     const isAscii = /^[\x00-\x7F]*$/.test(value);
-    const stringBuffer = isAscii
-      ? Buffer.from(value, 'ascii')
-      : Buffer.from(value, 'utf16le');
 
-    // Fixed the typo here - using stringBuffer.length instead of value.length for Unicode strings
+    let stringBuffer: Buffer;
+    if (isAscii) {
+      stringBuffer = Buffer.from(value, 'ascii');
+    } else {
+      // Unicode strings should be stored as UTF-16BE in binary plists
+      const utf16leBuffer = Buffer.from(value, 'utf16le');
+      stringBuffer = Buffer.alloc(utf16leBuffer.length);
+
+      // Convert UTF-16LE to UTF-16BE
+      for (let i = 0; i < utf16leBuffer.length; i += 2) {
+        stringBuffer[i] = utf16leBuffer[i + 1]; // High byte
+        stringBuffer[i + 1] = utf16leBuffer[i]; // Low byte
+      }
+    }
+
     const length = isAscii ? value.length : stringBuffer.length / 2;
     let header: Buffer;
 

package/src/lib/plist/binary-plist-parser.ts

@@ -270,15 +270,21 @@ class BinaryPlistParser {
    * @returns The parsed string
    */
   private _parseUnicodeString(startOffset: number, objLength: number): string {
-    // Unicode strings are stored as UTF-16BE
-    const utf16Buffer = Buffer.alloc(objLength * 2);
-    for (let j = 0; j < objLength; j++) {
-      utf16Buffer.writeUInt16BE(
-        this._buffer.readUInt16BE(startOffset + j * 2),
-        j * 2,
-      );
+    // Unicode strings are stored as UTF-16BE in binary plists
+    const bytesToRead = objLength * 2;
+    const stringBuffer = this._buffer.slice(
+      startOffset,
+      startOffset + bytesToRead,
+    );
+
+    // Convert UTF-16BE to UTF-16LE for proper decoding
+    const utf16leBuffer = Buffer.alloc(bytesToRead);
+    for (let i = 0; i < bytesToRead; i += 2) {
+      utf16leBuffer[i] = stringBuffer[i + 1]; // Low byte
+      utf16leBuffer[i + 1] = stringBuffer[i]; // High byte
     }
-    return utf16Buffer.toString('utf16le', 0, objLength * 2);
+
+    return utf16leBuffer.toString('utf16le');
   }
 
   /**
@@ -476,8 +482,10 @@ class BinaryPlistParser {
         obj.startOffset + j * this._objectRefSize,
       );
       const refValue = this._objectTable[refIdx];
-      // Ensure we're not adding a TempObject to the array
-      if (!this._isTempObject(refValue)) {
+      // Handle TempObjects correctly - they should be resolved by the time we get here
+      if (this._isTempObject(refValue)) {
+        array.push(refValue.value);
+      } else {
         array.push(refValue);
       }
     }
@@ -511,8 +519,10 @@ class BinaryPlistParser {
         );
       }
 
-      // Ensure we're not adding a TempObject to the dictionary
-      if (!this._isTempObject(value)) {
+      // Handle TempObjects correctly - they should be resolved by the time we get here
+      if (this._isTempObject(value)) {
+        dict[key] = value.value;
+      } else {
         dict[key] = value;
       }
     }