appium-ios-remotexpc 0.0.2 → 0.0.4

package/build/src/services/ios/syslog-service/index.d.ts

@@ -0,0 +1,91 @@
+import { EventEmitter } from 'events';
+import type { PacketData } from 'tuntap-bridge';
+import type { PacketSource, SyslogOptions, SyslogService as SyslogServiceInterface } from '../../../lib/types.js';
+import { type Service } from '../base-service.js';
+/**
+ * syslog-service provides functionality to capture and process syslog messages
+ * from a remote device using Apple's XPC services.
+ */
+declare class SyslogService extends EventEmitter implements SyslogServiceInterface {
+    private readonly baseService;
+    private connection;
+    private packetConsumer;
+    private packetStreamPromise;
+    private isCapturing;
+    private enableVerboseLogging;
+    /**
+     * Creates a new syslog-service instance
+     * @param address Tuple containing [host, port]
+     */
+    constructor(address: [string, number]);
+    /**
+     * Starts capturing syslog data from the device
+     * @param service Service information
+     * @param packetSource Source of packet data (can be PacketConsumer or AsyncIterable)
+     * @param options Configuration options for syslog capture
+     * @returns Promise resolving to the initial response from the service
+     */
+    start(service: Service, packetSource: PacketSource | AsyncIterable<PacketData>, options?: SyslogOptions): Promise<void>;
+    /**
+     * Stops capturing syslog data
+     * @returns Promise that resolves when capture is stopped
+     */
+    stop(): Promise<void>;
+    /**
+     * Restart the device
+     * @param service Service information
+     * @returns Promise that resolves when the restart request is sent
+     */
+    restart(service: Service): Promise<void>;
+    private attachPacketSource;
+    private isPacketSource;
+    private processPacketStream;
+    private processPacket;
+    /**
+     * Detaches the packet source
+     */
+    private detachPacketSource;
+    /**
+     * Closes the current connection
+     */
+    private closeConnection;
+    /**
+     * Processes a TCP packet
+     * @param packet TCP packet to process
+     */
+    private processTcpPacket;
+    private processPlistPacket;
+    private processTextPacket;
+    private emitTextMessage;
+    private emitMessage;
+    /**
+     * Checks if the buffer might be a plist (XML or binary)
+     * @param buffer Buffer to check
+     * @returns True if the buffer might be a plist
+     */
+    private mightBePlist;
+    /**
+     * Processes a UDP packet
+     * @param packet UDP packet to process
+     */
+    private processUdpPacket;
+    /**
+     * Logs packet details for debugging
+     * @param packet Packet to log details for
+     */
+    private logPacketDetails;
+    /**
+     * Extracts printable text from a buffer
+     * @param buffer Buffer to extract text from
+     * @returns Printable text
+     */
+    private extractPrintableText;
+    /**
+     * Determines if a buffer contains mostly printable ASCII characters
+     * @param buffer Buffer to analyze
+     * @returns True if more than 50% of characters are printable ASCII
+     */
+    private isMostlyPrintable;
+}
+export default SyslogService;
+//# sourceMappingURL=index.d.ts.map

package/build/src/services/ios/syslog-service/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/ios/syslog-service/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,KAAK,EAAkB,UAAU,EAAE,MAAM,eAAe,CAAC;AAIhE,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,aAAa,IAAI,sBAAsB,EACxC,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAe,KAAK,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAqB/D;;;GAGG;AACH,cAAM,aAAc,SAAQ,YAAa,YAAW,sBAAsB;IACxE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAc;IAC1C,OAAO,CAAC,UAAU,CAAkC;IACpD,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,mBAAmB,CAA8B;IACzD,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,oBAAoB,CAAS;IAErC;;;OAGG;gBACS,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;IAKrC;;;;;;OAMG;IACG,KAAK,CACT,OAAO,EAAE,OAAO,EAChB,YAAY,EAAE,YAAY,GAAG,aAAa,CAAC,UAAU,CAAC,EACtD,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,IAAI,CAAC;IAgChB;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAc3B;;;;OAIG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAY9C,OAAO,CAAC,kBAAkB;IAoB1B,OAAO,CAAC,cAAc;YASR,mBAAmB;IAejC,OAAO,CAAC,aAAa;IAQrB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAY1B;;OAEG;IACH,OAAO,CAAC,eAAe;IAcvB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAexB,OAAO,CAAC,kBAAkB;IAc1B,OAAO,CAAC,iBAAiB;IAiBzB,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,WAAW;IAOnB;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAqCpB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAIxB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IASxB;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAI5B;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;CA2B1B;AAED,eAAe,aAAa,CAAC"}

package/build/src/services/ios/syslog-service/index.js

@@ -0,0 +1,323 @@
+import { logger } from '@appium/support';
+import { EventEmitter } from 'events';
+import { isBinaryPlist } from '../../../lib/plist/binary-plist-parser.js';
+import { parsePlist } from '../../../lib/plist/unified-plist-parser.js';
+import { ServiceConnection } from '../../../service-connection.js';
+import { BaseService } from '../base-service.js';
+const syslogLog = logger.getLogger('SyslogMessages');
+const log = logger.getLogger('Syslog');
+const MIN_PRINTABLE_RATIO = 0.5;
+const ASCII_PRINTABLE_MIN = 32;
+const ASCII_PRINTABLE_MAX = 126;
+const NON_PRINTABLE_ASCII_REGEX = /[^\x20-\x7E]/g;
+const PLIST_XML_MARKERS = ['<?xml', '<plist'];
+const BINARY_PLIST_MARKER = 'bplist';
+const BINARY_PLIST_MARKER_ALT = 'Ibplist00';
+const MIN_PLIST_SIZE = 8;
+const PLIST_HEADER_CHECK_SIZE = 100;
+const DEFAULT_SYSLOG_REQUEST = {
+    Request: 'StartActivity',
+    MessageFilter: 65535,
+    StreamFlags: 60,
+};
+/**
+ * syslog-service provides functionality to capture and process syslog messages
+ * from a remote device using Apple's XPC services.
+ */
+class SyslogService extends EventEmitter {
+    baseService;
+    connection = null;
+    packetConsumer = null;
+    packetStreamPromise = null;
+    isCapturing = false;
+    enableVerboseLogging = false;
+    /**
+     * Creates a new syslog-service instance
+     * @param address Tuple containing [host, port]
+     */
+    constructor(address) {
+        super();
+        this.baseService = new BaseService(address);
+    }
+    /**
+     * Starts capturing syslog data from the device
+     * @param service Service information
+     * @param packetSource Source of packet data (can be PacketConsumer or AsyncIterable)
+     * @param options Configuration options for syslog capture
+     * @returns Promise resolving to the initial response from the service
+     */
+    async start(service, packetSource, options = {}) {
+        if (this.isCapturing) {
+            log.info('Syslog capture already in progress. Stopping previous capture.');
+            await this.stop();
+        }
+        const { pid = -1, enableVerboseLogging = false } = options;
+        this.enableVerboseLogging = enableVerboseLogging;
+        this.isCapturing = true;
+        this.attachPacketSource(packetSource);
+        try {
+            this.connection = await this.baseService.startLockdownService(service);
+            const request = {
+                ...DEFAULT_SYSLOG_REQUEST,
+                Pid: pid,
+            };
+            const response = await this.connection.sendPlistRequest(request);
+            log.info(`Syslog capture started: ${response}`);
+            this.emit('start', response);
+        }
+        catch (error) {
+            this.isCapturing = false;
+            this.detachPacketSource();
+            throw error;
+        }
+    }
+    /**
+     * Stops capturing syslog data
+     * @returns Promise that resolves when capture is stopped
+     */
+    async stop() {
+        if (!this.isCapturing) {
+            log.info('No syslog capture in progress.');
+            return;
+        }
+        this.detachPacketSource();
+        this.closeConnection();
+        this.isCapturing = false;
+        log.info('Syslog capture stopped');
+        this.emit('stop');
+    }
+    /**
+     * Restart the device
+     * @param service Service information
+     * @returns Promise that resolves when the restart request is sent
+     */
+    async restart(service) {
+        try {
+            const conn = await this.baseService.startLockdownService(service);
+            const request = { Request: 'Restart' };
+            const res = await conn.sendPlistRequest(request);
+            log.info(`Restart response: ${res}`);
+        }
+        catch (error) {
+            log.error(`Error during restart: ${error}`);
+            throw error;
+        }
+    }
+    attachPacketSource(packetSource) {
+        if (this.isPacketSource(packetSource)) {
+            this.packetConsumer = {
+                onPacket: (packet) => this.processPacket(packet),
+            };
+            packetSource.addPacketConsumer(this.packetConsumer);
+        }
+        else {
+            // Store the promise so we can handle it properly
+            this.packetStreamPromise = this.processPacketStream(packetSource);
+            // Handle any errors from the stream processing
+            this.packetStreamPromise.catch((error) => {
+                log.error(`Packet stream processing failed: ${error}`);
+                this.emit('error', error);
+            });
+        }
+    }
+    isPacketSource(source) {
+        return (typeof source === 'object' &&
+            source !== null &&
+            'addPacketConsumer' in source &&
+            'removePacketConsumer' in source);
+    }
+    async processPacketStream(packetStream) {
+        try {
+            for await (const packet of packetStream) {
+                if (!this.isCapturing) {
+                    break;
+                }
+                this.processPacket(packet);
+            }
+        }
+        catch (error) {
+            log.error(`Error processing packet stream: ${error}`);
+        }
+    }
+    processPacket(packet) {
+        if (packet.protocol === 'TCP') {
+            this.processTcpPacket(packet);
+        }
+        else if (packet.protocol === 'UDP') {
+            this.processUdpPacket(packet);
+        }
+    }
+    /**
+     * Detaches the packet source
+     */
+    detachPacketSource() {
+        if (this.packetConsumer) {
+            this.packetConsumer = null;
+        }
+        // Cancel the packet stream processing if it's running
+        if (this.packetStreamPromise) {
+            // Setting isCapturing to false will cause the stream loop to exit
+            this.packetStreamPromise = null;
+        }
+    }
+    /**
+     * Closes the current connection
+     */
+    closeConnection() {
+        if (!this.connection) {
+            return;
+        }
+        try {
+            this.connection.close();
+        }
+        catch (error) {
+            log.debug(`Error closing connection: ${error}`);
+        }
+        finally {
+            this.connection = null;
+        }
+    }
+    /**
+     * Processes a TCP packet
+     * @param packet TCP packet to process
+     */
+    processTcpPacket(packet) {
+        try {
+            if (this.mightBePlist(packet.payload)) {
+                this.processPlistPacket(packet);
+            }
+            else {
+                this.processTextPacket(packet);
+            }
+        }
+        catch (error) {
+            log.debug(`Error processing packet: ${error}`);
+            this.emitTextMessage(packet.payload);
+        }
+        this.logPacketDetails(packet);
+    }
+    processPlistPacket(packet) {
+        try {
+            const plistData = parsePlist(packet.payload);
+            log.debug('Successfully parsed packet as plist');
+            this.emit('plist', plistData);
+            const message = JSON.stringify(plistData);
+            this.emitMessage(message);
+        }
+        catch (error) {
+            log.debug(`Failed to parse as plist: ${error}`);
+            this.processTextPacket(packet);
+        }
+    }
+    processTextPacket(packet) {
+        const message = this.extractPrintableText(packet.payload);
+        if (!message.trim()) {
+            log.debug('TCP packet contains no printable text, ignoring.');
+            return;
+        }
+        const isMostlyPrintable = this.isMostlyPrintable(packet.payload);
+        if (!isMostlyPrintable) {
+            log.debug(`TCP packet not mostly printable, but contains text: ${message}`);
+        }
+        this.emitMessage(message);
+    }
+    emitTextMessage(buffer) {
+        const message = this.extractPrintableText(buffer);
+        if (message.trim()) {
+            this.emitMessage(message);
+        }
+    }
+    emitMessage(message) {
+        if (this.enableVerboseLogging) {
+            syslogLog.info(message);
+        }
+        this.emit('message', message);
+    }
+    /**
+     * Checks if the buffer might be a plist (XML or binary)
+     * @param buffer Buffer to check
+     * @returns True if the buffer might be a plist
+     */
+    mightBePlist(buffer) {
+        try {
+            if (buffer.length < MIN_PLIST_SIZE) {
+                return false;
+            }
+            // Check for XML plist
+            const headerStr = buffer.toString('utf8', 0, Math.min(PLIST_HEADER_CHECK_SIZE, buffer.length));
+            if (PLIST_XML_MARKERS.every((marker) => headerStr.includes(marker))) {
+                return true;
+            }
+            // Check for binary plist
+            if (isBinaryPlist(buffer)) {
+                return true;
+            }
+            // Check alternative binary plist markers
+            const firstNineChars = buffer.toString('ascii', 0, Math.min(9, buffer.length));
+            return (firstNineChars === BINARY_PLIST_MARKER_ALT ||
+                firstNineChars.includes(BINARY_PLIST_MARKER));
+        }
+        catch (error) {
+            log.debug(`Error checking if buffer is plist: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Processes a UDP packet
+     * @param packet UDP packet to process
+     */
+    processUdpPacket(packet) {
+        log.debug(`Received UDP packet (not filtered here): ${packet}`);
+    }
+    /**
+     * Logs packet details for debugging
+     * @param packet Packet to log details for
+     */
+    logPacketDetails(packet) {
+        log.debug('Received syslog-like TCP packet:');
+        log.debug(`  Source: ${packet.src}`);
+        log.debug(`  Destination: ${packet.dst}`);
+        log.debug(`  Source port: ${packet.sourcePort}`);
+        log.debug(`  Destination port: ${packet.destPort}`);
+        log.debug(`  Payload length: ${packet.payload.length}`);
+    }
+    /**
+     * Extracts printable text from a buffer
+     * @param buffer Buffer to extract text from
+     * @returns Printable text
+     */
+    extractPrintableText(buffer) {
+        return buffer.toString().replace(NON_PRINTABLE_ASCII_REGEX, '');
+    }
+    /**
+     * Determines if a buffer contains mostly printable ASCII characters
+     * @param buffer Buffer to analyze
+     * @returns True if more than 50% of characters are printable ASCII
+     */
+    isMostlyPrintable(buffer) {
+        try {
+            const str = buffer.toString('utf8');
+            if (!str || str.length === 0) {
+                return false;
+            }
+            const totalLength = str.length;
+            const threshold = totalLength * MIN_PRINTABLE_RATIO;
+            let printableCount = 0;
+            for (let i = 0; i < totalLength; i++) {
+                const code = str.charCodeAt(i);
+                if (code >= ASCII_PRINTABLE_MIN && code <= ASCII_PRINTABLE_MAX) {
+                    printableCount++;
+                    if (printableCount > threshold) {
+                        return true;
+                    }
+                }
+            }
+            return printableCount / totalLength > MIN_PRINTABLE_RATIO;
+        }
+        catch (error) {
+            log.debug(error);
+            return false;
+        }
+    }
+}
+export default SyslogService;

package/build/src/services/ios/tunnel-service/index.d.ts

@@ -0,0 +1,17 @@
+import { TLSSocket } from 'tls';
+import { LockdownService } from '../../../lib/lockdown/index.js';
+import { PlistService } from '../../../lib/plist/plist-service.js';
+/**
+ * Starts a CoreDeviceProxy session over an existing TLS-upgraded lockdown connection.
+ *
+ * @param lockdownClient - The TLS-upgraded lockdown client used to send the StartService request.
+ * @param deviceID - The device identifier to be used in the Connect request.
+ * @param udid - The device UDID used to retrieve the pair record.
+ * @param tlsOptions - TLS options for upgrading the usbmuxd socket.
+ * @returns A promise that resolves with a TLS-upgraded socket and PlistService for communication with CoreDeviceProxy.
+ */
+export declare function startCoreDeviceProxy(lockdownClient: LockdownService, deviceID: number | string, udid: string, tlsOptions?: Partial<import('tls').ConnectionOptions>): Promise<{
+    socket: TLSSocket;
+    plistService: PlistService;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/build/src/services/ios/tunnel-service/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/ios/tunnel-service/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AAEhC,OAAO,EACL,eAAe,EAEhB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAMnE;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CACxC,cAAc,EAAE,eAAe,EAC/B,QAAQ,EAAE,MAAM,GAAG,MAAM,EACzB,IAAI,EAAE,MAAM,EACZ,UAAU,GAAE,OAAO,CAAC,OAAO,KAAK,EAAE,iBAAiB,CAAM,GACxD,OAAO,CAAC;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,YAAY,EAAE,YAAY,CAAA;CAAE,CAAC,CA4D5D"}

package/build/src/services/ios/tunnel-service/index.js

@@ -0,0 +1,57 @@
+import { logger } from '@appium/support';
+import { TLSSocket } from 'tls';
+import { LockdownService, upgradeSocketToTLS, } from '../../../lib/lockdown/index.js';
+import { PlistService } from '../../../lib/plist/plist-service.js';
+import { createUsbmux } from '../../../lib/usbmux/index.js';
+const log = logger.getLogger('TunnelService');
+const LABEL = 'appium-internal';
+/**
+ * Starts a CoreDeviceProxy session over an existing TLS-upgraded lockdown connection.
+ *
+ * @param lockdownClient - The TLS-upgraded lockdown client used to send the StartService request.
+ * @param deviceID - The device identifier to be used in the Connect request.
+ * @param udid - The device UDID used to retrieve the pair record.
+ * @param tlsOptions - TLS options for upgrading the usbmuxd socket.
+ * @returns A promise that resolves with a TLS-upgraded socket and PlistService for communication with CoreDeviceProxy.
+ */
+export async function startCoreDeviceProxy(lockdownClient, deviceID, udid, tlsOptions = {}) {
+    // Wait for TLS upgrade to complete if in progress
+    await lockdownClient.waitForTLSUpgrade();
+    const response = await lockdownClient.sendAndReceive({
+        Label: LABEL,
+        Request: 'StartService',
+        Service: 'com.apple.internal.devicecompute.CoreDeviceProxy',
+        EscrowBag: null,
+    });
+    lockdownClient.close();
+    if (!response.Port) {
+        throw new Error('Service didnt return a port');
+    }
+    log.debug(`Connecting to CoreDeviceProxy service on port: ${response.Port}`);
+    const usbmux = await createUsbmux();
+    try {
+        const pairRecord = await usbmux.readPairRecord(udid);
+        if (!pairRecord ||
+            !pairRecord.HostCertificate ||
+            !pairRecord.HostPrivateKey) {
+            throw new Error('Missing required pair record or certificates for TLS upgrade');
+        }
+        const coreDeviceSocket = await usbmux.connect(Number(deviceID), Number(response.Port));
+        log.debug('Socket connected to CoreDeviceProxy, upgrading to TLS...');
+        const fullTlsOptions = {
+            ...tlsOptions,
+            cert: pairRecord.HostCertificate,
+            key: pairRecord.HostPrivateKey,
+        };
+        const tlsSocket = await upgradeSocketToTLS(coreDeviceSocket, fullTlsOptions);
+        const plistService = new PlistService(tlsSocket);
+        return { socket: tlsSocket, plistService };
+    }
+    catch (err) {
+        // If we haven't connected yet, we can safely close the usbmux
+        await usbmux
+            .close()
+            .catch((closeErr) => log.error(`Error closing usbmux: ${closeErr}`));
+        throw err;
+    }
+}

package/build/src/services.d.ts

@@ -0,0 +1,14 @@
+import RemoteXpcConnection from './lib/remote-xpc/remote-xpc-connection.js';
+import type { DiagnosticsService as DiagnosticsServiceType, SyslogService as SyslogServiceType } from './lib/types.js';
+export declare function startDiagnosticsService(udid: string): Promise<DiagnosticsServiceType>;
+export declare function startSyslogService(udid: string): Promise<SyslogServiceType>;
+export declare function createRemoteXPCConnection(udid: string): Promise<{
+    remoteXPC: RemoteXpcConnection;
+    tunnelConnection: {
+        host: string;
+        port: number;
+        udid: string;
+        packetStreamPort: number;
+    };
+}>;
+//# sourceMappingURL=services.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../src/services.ts"],"names":[],"mappings":"AAEA,OAAO,mBAAmB,MAAM,2CAA2C,CAAC;AAG5E,OAAO,KAAK,EACV,kBAAkB,IAAI,sBAAsB,EAC5C,aAAa,IAAI,iBAAiB,EACnC,MAAM,gBAAgB,CAAC;AAOxB,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,sBAAsB,CAAC,CASjC;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

@@ -0,0 +1,48 @@
+import { strongbox } from '@appium/strongbox';
+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 SyslogService from './services/ios/syslog-service/index.js';
+const APPIUM_XCUITEST_DRIVER_NAME = 'appium-xcuitest-driver';
+const TUNNEL_REGISTRY_PORT = 'tunnelRegistryPort';
+export async function startDiagnosticsService(udid) {
+    const { remoteXPC, tunnelConnection } = await createRemoteXPCConnection(udid);
+    const diagnosticsService = remoteXPC.findService(DiagnosticsService.RSD_SERVICE_NAME);
+    return new DiagnosticsService([
+        tunnelConnection.host,
+        parseInt(diagnosticsService.port, 10),
+    ]);
+}
+export async function startSyslogService(udid) {
+    const { tunnelConnection } = await createRemoteXPCConnection(udid);
+    return new SyslogService([tunnelConnection.host, tunnelConnection.port]);
+}
+export async function createRemoteXPCConnection(udid) {
+    const tunnelConnection = await getTunnelInformation(udid);
+    const remoteXPC = await startService(tunnelConnection.host, tunnelConnection.port);
+    return { remoteXPC, tunnelConnection };
+}
+// #region Private Functions
+async function getTunnelInformation(udid) {
+    const box = strongbox(APPIUM_XCUITEST_DRIVER_NAME);
+    const item = await box.createItem(TUNNEL_REGISTRY_PORT);
+    const tunnelRegistryPort = await item.read();
+    if (tunnelRegistryPort === undefined) {
+        throw new Error('Tunnel registry port not found. Please run the tunnel creation script first: sudo appium driver run xcuitest tunnel-creation');
+    }
+    const tunnelApiClient = new TunnelApiClient(`http://127.0.0.1:${tunnelRegistryPort}/remotexpc/tunnels`);
+    const tunnelExists = await tunnelApiClient.hasTunnel(udid);
+    if (!tunnelExists) {
+        throw new Error(`No tunnel found for device ${udid}. Please run the tunnel creation script first: sudo appium driver run xcuitest tunnel-creation`);
+    }
+    const tunnelConnection = await tunnelApiClient.getTunnelConnection(udid);
+    if (!tunnelConnection) {
+        throw new Error(`Failed to get tunnel connection details for device ${udid}`);
+    }
+    return tunnelConnection;
+}
+async function startService(host, port) {
+    return await TunnelManager.createRemoteXPCConnection(host, port);
+}
+// #endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appium-ios-remotexpc",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "main": "build/src/index.js",
   "types": "build/src/index.d.ts",
   "type": "module",
@@ -18,6 +18,7 @@
     "build:es": "tsc",
     "build": "run-s clean:* build:*",
     "lint": "eslint src --ext .ts --quiet",
+    "prepare": "npm run build",
     "format": "prettier --write \"{src,test}/**/*.{ts,tsx}\"",
     "format:check": "prettier --check \"{src,test}/**/*.{ts,tsx}\"",
     "lint:fix": "eslint src --ext .ts --fix",
@@ -35,7 +36,7 @@
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/appium/appium-ios-remotexpc.git"
+    "url": "git+https://github.com/appium/appium-ios-remotexpc.git"
   },
   "bugs": {
     "url": "https://github.com/appium/appium-ios-remotexpc/issues"
@@ -74,5 +75,13 @@
     "@xmldom/xmldom": "^0.9.8",
     "npm-run-all2": "^7.0.2",
     "tuntap-bridge": "^0.x"
-  }
+  },
+  "files": [
+    "src",
+    "scripts",
+    "build/src",
+    "!.DS_Store",
+    "CHANGELOG.md",
+    "LICENSE"
+  ]
 }

package/.github/dependabot.yml

@@ -1,38 +0,0 @@
-# Dependabot configuration file
-# See: https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
-
-version: 2
-updates:
-  # Enable npm dependency updates
-  - package-ecosystem: "npm"
-    directory: "/"
-    schedule:
-      interval: "weekly"
-    # Specify which branches to update
-    target-branch: "main"
-    # Set version update strategy
-    versioning-strategy: "auto"
-    # Set review requirements
-    open-pull-requests-limit: 10
-    # Group all dev dependencies together
-    groups:
-      dev-dependencies:
-        patterns:
-          - "*"
-        exclude-patterns:
-          - "@types/*"  # Keep type definitions separate
-    # Labels for pull requests
-    labels:
-      - "dependencies"
-      - "npm"
-
-  # Enable GitHub Actions updates
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "monthly"
-    target-branch: "main"
-    # Labels for pull requests
-    labels:
-      - "dependencies"
-      - "github-actions"