appium-ios-remotexpc 0.13.2 → 0.15.0

package/build/src/services/ios/dvt/index.js

@@ -0,0 +1,552 @@
+import net from 'node:net';
+import { getLogger } from '../../../lib/logger.js';
+import { PlistUID, createBinaryPlist, parseBinaryPlist, } from '../../../lib/plist/index.js';
+import { ServiceConnection } from '../../../service-connection.js';
+import { BaseService } from '../base-service.js';
+import { ChannelFragmenter } from './channel-fragmenter.js';
+import { Channel } from './channel.js';
+import { DTXMessage, DTX_CONSTANTS, MessageAux } from './dtx-message.js';
+import { decodeNSKeyedArchiver } from './nskeyedarchiver-decoder.js';
+import { extractCapabilityStrings, extractNSDictionary, extractNSKeyedArchiverObjects, hasNSErrorIndicators, isNSDictionaryFormat, } from './utils.js';
+const log = getLogger('DVTSecureSocketProxyService');
+const MIN_ERROR_DESCRIPTION_LENGTH = 20;
+/**
+ * DVTSecureSocketProxyService provides access to Apple's DTServiceHub functionality
+ * This service enables various instruments and debugging capabilities through the DTX protocol
+ */
+export class DVTSecureSocketProxyService extends BaseService {
+    static RSD_SERVICE_NAME = 'com.apple.instruments.dtservicehub';
+    static BROADCAST_CHANNEL = 0;
+    connection = null;
+    socket = null;
+    supportedIdentifiers = {};
+    lastChannelCode = 0;
+    curMessageId = 0;
+    channelCache = new Map();
+    channelMessages = new Map();
+    isHandshakeComplete = false;
+    readBuffer = Buffer.alloc(0);
+    constructor(address) {
+        super(address);
+        this.channelMessages.set(DVTSecureSocketProxyService.BROADCAST_CHANNEL, new ChannelFragmenter());
+    }
+    /**
+     * Connect to the DVT service and perform handshake
+     */
+    async connect() {
+        if (this.connection) {
+            return;
+        }
+        const service = {
+            serviceName: DVTSecureSocketProxyService.RSD_SERVICE_NAME,
+            port: this.address[1].toString(),
+        };
+        // DVT uses DTX binary protocol, connect without plist-based RSDCheckin
+        this.connection = await this.startLockdownWithoutCheckin(service);
+        this.socket = this.connection.getSocket();
+        // Remove SSL context if present for raw DTX communication
+        if ('_sslobj' in this.socket) {
+            this.socket._sslobj = null;
+        }
+        await this.performHandshake();
+    }
+    /**
+     * Get supported service identifiers (capabilities)
+     */
+    getSupportedIdentifiers() {
+        return this.supportedIdentifiers;
+    }
+    /**
+     * Create a communication channel for a specific service identifier
+     * @param identifier The service identifier (e.g., 'com.apple.instruments.server.services.LocationSimulation')
+     * @returns The created channel instance
+     */
+    async makeChannel(identifier) {
+        if (!this.isHandshakeComplete) {
+            throw new Error('Handshake not complete. Call connect() first.');
+        }
+        if (this.channelCache.has(identifier)) {
+            return this.channelCache.get(identifier);
+        }
+        this.lastChannelCode++;
+        const channelCode = this.lastChannelCode;
+        const args = new MessageAux();
+        args.appendInt(channelCode);
+        args.appendObj(identifier);
+        await this.sendMessage(0, '_requestChannelWithCode:identifier:', args);
+        const [ret] = await this.recvPlist();
+        // Check for NSError in response
+        this.checkForNSError(ret, 'Failed to create channel');
+        const channel = new Channel(channelCode, this);
+        this.channelCache.set(identifier, channel);
+        this.channelMessages.set(channelCode, new ChannelFragmenter());
+        return channel;
+    }
+    /**
+     * Send a DTX message on a channel
+     * @param channel The channel code
+     * @param selector The ObjectiveC method selector
+     * @param args Optional message arguments
+     * @param expectsReply Whether a reply is expected
+     */
+    async sendMessage(channel, selector = null, args = null, expectsReply = true) {
+        if (!this.socket) {
+            throw new Error('Not connected to DVT service');
+        }
+        this.curMessageId++;
+        const auxBuffer = args ? this.buildAuxiliaryData(args) : Buffer.alloc(0);
+        const selectorBuffer = selector
+            ? this.archiveSelector(selector)
+            : Buffer.alloc(0);
+        let flags = DTX_CONSTANTS.INSTRUMENTS_MESSAGE_TYPE;
+        if (expectsReply) {
+            flags |= DTX_CONSTANTS.EXPECTS_REPLY_MASK;
+        }
+        const payloadHeader = DTXMessage.buildPayloadHeader({
+            flags,
+            auxiliaryLength: auxBuffer.length,
+            totalLength: BigInt(auxBuffer.length + selectorBuffer.length),
+        });
+        const messageHeader = DTXMessage.buildMessageHeader({
+            magic: DTX_CONSTANTS.MESSAGE_HEADER_MAGIC,
+            cb: DTX_CONSTANTS.MESSAGE_HEADER_SIZE,
+            fragmentId: 0,
+            fragmentCount: 1,
+            length: DTX_CONSTANTS.PAYLOAD_HEADER_SIZE +
+                auxBuffer.length +
+                selectorBuffer.length,
+            identifier: this.curMessageId,
+            conversationIndex: 0,
+            channelCode: channel,
+            expectsReply: expectsReply ? 1 : 0,
+        });
+        const message = Buffer.concat([
+            messageHeader,
+            payloadHeader,
+            auxBuffer,
+            selectorBuffer,
+        ]);
+        await new Promise((resolve, reject) => {
+            this.socket.write(message, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    /**
+     * Receive a plist message from a channel
+     * @param channel The channel to receive from
+     * @returns Tuple of [decoded data, auxiliary values]
+     */
+    async recvPlist(channel = DVTSecureSocketProxyService.BROADCAST_CHANNEL) {
+        const [data, aux] = await this.recvMessage(channel);
+        let decodedData = null;
+        if (data?.length) {
+            try {
+                decodedData = parseBinaryPlist(data);
+                // decode NSKeyedArchiver format
+                decodedData = decodeNSKeyedArchiver(decodedData);
+            }
+            catch (error) {
+                log.warn('Failed to parse plist data:', error);
+            }
+        }
+        return [decodedData, aux];
+    }
+    /**
+     * Receive a raw message from a channel
+     * @param channel The channel to receive from
+     * @returns Tuple of [raw data, auxiliary values]
+     */
+    async recvMessage(channel = DVTSecureSocketProxyService.BROADCAST_CHANNEL) {
+        const packetData = await this.recvPacketFragments(channel);
+        const payloadHeader = DTXMessage.parsePayloadHeader(packetData);
+        const compression = (payloadHeader.flags & 0xff000) >> 12;
+        if (compression) {
+            throw new Error('Compressed messages not supported');
+        }
+        let offset = DTX_CONSTANTS.PAYLOAD_HEADER_SIZE;
+        // Parse auxiliary data if present
+        let aux = [];
+        if (payloadHeader.auxiliaryLength > 0) {
+            const auxBuffer = packetData.subarray(offset, offset + payloadHeader.auxiliaryLength);
+            aux = this.parseAuxiliaryData(auxBuffer);
+            offset += payloadHeader.auxiliaryLength;
+        }
+        // Extract object data
+        const objSize = Number(payloadHeader.totalLength) - payloadHeader.auxiliaryLength;
+        const data = objSize > 0 ? packetData.subarray(offset, offset + objSize) : null;
+        return [data, aux];
+    }
+    /**
+     * Close the DVT service connection
+     */
+    async close() {
+        if (!this.connection) {
+            return;
+        }
+        // Send channel cancellation for all active channels
+        const activeCodes = Array.from(this.channelMessages.keys()).filter((code) => code > 0);
+        if (activeCodes.length > 0) {
+            const args = new MessageAux();
+            for (const code of activeCodes) {
+                args.appendInt(code);
+            }
+            try {
+                await this.sendMessage(DVTSecureSocketProxyService.BROADCAST_CHANNEL, '_channelCanceled:', args, false);
+            }
+            catch (error) {
+                log.debug('Error sending channel canceled message:', error);
+            }
+        }
+        this.connection.close();
+        this.connection = null;
+        this.socket = null;
+        this.isHandshakeComplete = false;
+        this.channelCache.clear();
+        this.channelMessages.clear();
+        this.channelMessages.set(DVTSecureSocketProxyService.BROADCAST_CHANNEL, new ChannelFragmenter());
+    }
+    /**
+     * Perform DTX protocol handshake to establish connection and retrieve capabilities
+     */
+    async performHandshake() {
+        const args = new MessageAux();
+        args.appendObj({
+            'com.apple.private.DTXBlockCompression': 0,
+            'com.apple.private.DTXConnection': 1,
+        });
+        await this.sendMessage(0, '_notifyOfPublishedCapabilities:', args, false);
+        const [retData, aux] = await this.recvMessage();
+        const ret = retData ? parseBinaryPlist(retData) : null;
+        const selectorName = this.extractSelectorFromResponse(ret);
+        if (selectorName !== '_notifyOfPublishedCapabilities:') {
+            throw new Error(`Invalid handshake response selector: ${selectorName}`);
+        }
+        if (!aux || aux.length === 0) {
+            throw new Error('Invalid handshake response: missing capabilities');
+        }
+        // Extract server capabilities from auxiliary data
+        this.supportedIdentifiers = this.extractCapabilitiesFromAuxData(aux[0]);
+        this.isHandshakeComplete = true;
+        log.debug(`DVT handshake complete. Found ${Object.keys(this.supportedIdentifiers).length} supported identifiers`);
+        // Consume any additional messages buffered after handshake
+        await this.drainBufferedMessages();
+    }
+    extractSelectorFromResponse(ret) {
+        if (typeof ret === 'string') {
+            return ret;
+        }
+        const objects = extractNSKeyedArchiverObjects(ret);
+        if (objects) {
+            return objects[1];
+        }
+        throw new Error('Invalid handshake response');
+    }
+    extractCapabilitiesFromAuxData(capabilitiesData) {
+        const objects = extractNSKeyedArchiverObjects(capabilitiesData);
+        if (!objects) {
+            return capabilitiesData || {};
+        }
+        const dictObj = objects[1];
+        if (isNSDictionaryFormat(dictObj)) {
+            return extractNSDictionary(dictObj, objects);
+        }
+        return extractCapabilityStrings(objects);
+    }
+    /**
+     * Drain any buffered messages that arrived during handshake
+     */
+    async drainBufferedMessages() {
+        if (this.readBuffer.length === 0) {
+            return;
+        }
+        try {
+            while (this.readBuffer.length >= DTX_CONSTANTS.MESSAGE_HEADER_SIZE) {
+                const headerData = this.readBuffer.subarray(0, DTX_CONSTANTS.MESSAGE_HEADER_SIZE);
+                const header = DTXMessage.parseMessageHeader(headerData);
+                const totalSize = DTX_CONSTANTS.MESSAGE_HEADER_SIZE + header.length;
+                if (this.readBuffer.length >= totalSize) {
+                    // Consume complete buffered message
+                    this.readBuffer = this.readBuffer.subarray(DTX_CONSTANTS.MESSAGE_HEADER_SIZE);
+                    this.readBuffer = this.readBuffer.subarray(header.length);
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            log.debug('Error while draining buffer:', error);
+        }
+    }
+    /**
+     * Receive packet fragments until a complete message is available for the specified channel
+     */
+    async recvPacketFragments(channel) {
+        while (true) {
+            const fragmenter = this.channelMessages.get(channel);
+            if (!fragmenter) {
+                throw new Error(`No fragmenter for channel ${channel}`);
+            }
+            // Check if we have a complete message
+            const message = fragmenter.get();
+            if (message) {
+                return message;
+            }
+            // Read next message header
+            const headerData = await this.readExact(DTX_CONSTANTS.MESSAGE_HEADER_SIZE);
+            const header = DTXMessage.parseMessageHeader(headerData);
+            const receivedChannel = Math.abs(header.channelCode);
+            if (!this.channelMessages.has(receivedChannel)) {
+                this.channelMessages.set(receivedChannel, new ChannelFragmenter());
+            }
+            // Update message ID tracker
+            if (!header.conversationIndex && header.identifier > this.curMessageId) {
+                this.curMessageId = header.identifier;
+            }
+            // Skip first fragment header for multi-fragment messages
+            if (header.fragmentCount > 1 && header.fragmentId === 0) {
+                continue;
+            }
+            // Read message payload
+            const messageData = await this.readExact(header.length);
+            // Add fragment to appropriate channel
+            const targetFragmenter = this.channelMessages.get(receivedChannel);
+            targetFragmenter.addFragment(header, messageData);
+        }
+    }
+    /**
+     * Read exact number of bytes from socket with buffering
+     */
+    async readExact(length) {
+        if (!this.socket) {
+            throw new Error(`${this.constructor.name} is not initialized. Call connect() before sending messages.`);
+        }
+        // Keep reading until we have enough data
+        while (this.readBuffer.length < length) {
+            const chunk = await new Promise((resolve, reject) => {
+                const onData = (data) => {
+                    this.socket.off('data', onData);
+                    this.socket.off('error', onError);
+                    resolve(data);
+                };
+                const onError = (err) => {
+                    this.socket.off('data', onData);
+                    this.socket.off('error', onError);
+                    reject(err);
+                };
+                this.socket.once('data', onData);
+                this.socket.once('error', onError);
+            });
+            this.readBuffer = Buffer.concat([this.readBuffer, chunk]);
+        }
+        // Extract exact amount requested
+        const result = this.readBuffer.subarray(0, length);
+        this.readBuffer = this.readBuffer.subarray(length);
+        return result;
+    }
+    /**
+     * Check if response contains an NSError and throw if present
+     */
+    checkForNSError(response, context) {
+        if (!response || typeof response !== 'object') {
+            return;
+        }
+        // Check NSKeyedArchiver format
+        const objects = extractNSKeyedArchiverObjects(response);
+        if (objects) {
+            // Check for NSError indicators in $objects
+            const hasNSError = objects.some((o) => hasNSErrorIndicators(o));
+            if (hasNSError) {
+                const errorMsg = objects.find((o) => typeof o === 'string' && o.length > MIN_ERROR_DESCRIPTION_LENGTH) || 'Unknown error';
+                throw new Error(`${context}: ${errorMsg}`);
+            }
+        }
+        // Check direct NSError format
+        if (hasNSErrorIndicators(response)) {
+            throw new Error(`${context}: ${JSON.stringify(response)}`);
+        }
+    }
+    /**
+     * Archive a value using NSKeyedArchiver format for DTX protocol
+     */
+    archiveValue(value) {
+        const archived = {
+            $version: 100000,
+            $archiver: 'NSKeyedArchiver',
+            $top: { root: new PlistUID(1) },
+            $objects: ['$null', value],
+        };
+        return createBinaryPlist(archived);
+    }
+    /**
+     * Archive a selector string for DTX messages
+     */
+    archiveSelector(selector) {
+        return this.archiveValue(selector);
+    }
+    /**
+     * Build auxiliary data buffer with NSKeyedArchiver encoding for objects
+     */
+    buildAuxiliaryData(args) {
+        const values = args.getValues();
+        if (values.length === 0) {
+            return Buffer.alloc(0);
+        }
+        const itemBuffers = [];
+        for (const auxValue of values) {
+            // Empty dictionary marker
+            const dictMarker = Buffer.alloc(4);
+            dictMarker.writeUInt32LE(DTX_CONSTANTS.EMPTY_DICTIONARY, 0);
+            itemBuffers.push(dictMarker);
+            // Type marker
+            const typeBuffer = Buffer.alloc(4);
+            typeBuffer.writeUInt32LE(auxValue.type, 0);
+            itemBuffers.push(typeBuffer);
+            // Value data
+            switch (auxValue.type) {
+                case DTX_CONSTANTS.AUX_TYPE_INT32: {
+                    const valueBuffer = Buffer.alloc(4);
+                    valueBuffer.writeUInt32LE(auxValue.value, 0);
+                    itemBuffers.push(valueBuffer);
+                    break;
+                }
+                case DTX_CONSTANTS.AUX_TYPE_INT64: {
+                    const valueBuffer = Buffer.alloc(8);
+                    valueBuffer.writeBigUInt64LE(BigInt(auxValue.value), 0);
+                    itemBuffers.push(valueBuffer);
+                    break;
+                }
+                case DTX_CONSTANTS.AUX_TYPE_OBJECT: {
+                    const encodedPlist = this.archiveValue(auxValue.value);
+                    const lengthBuffer = Buffer.alloc(4);
+                    lengthBuffer.writeUInt32LE(encodedPlist.length, 0);
+                    itemBuffers.push(lengthBuffer);
+                    itemBuffers.push(encodedPlist);
+                    break;
+                }
+                default:
+                    throw new Error(`Unsupported auxiliary type: ${auxValue.type}`);
+            }
+        }
+        const itemsData = Buffer.concat(itemBuffers);
+        // Build header: magic + total size of items
+        const header = Buffer.alloc(16);
+        header.writeBigUInt64LE(BigInt(DTX_CONSTANTS.MESSAGE_AUX_MAGIC), 0);
+        header.writeBigUInt64LE(BigInt(itemsData.length), 8);
+        return Buffer.concat([header, itemsData]);
+    }
+    /**
+     * Parse auxiliary data from buffer
+     *
+     * The auxiliary data format can be:
+     * 1. Standard format: [magic:8][size:8][items...]
+     * 2. NSKeyedArchiver bplist format (for handshake responses)
+     */
+    parseAuxiliaryData(buffer) {
+        if (buffer.length < 16) {
+            return [];
+        }
+        const magic = buffer.readBigUInt64LE(0);
+        // Check if this is NSKeyedArchiver bplist format (handshake response)
+        if (magic !== BigInt(DTX_CONSTANTS.MESSAGE_AUX_MAGIC)) {
+            return this.parseAuxiliaryAsBplist(buffer);
+        }
+        // Standard auxiliary format
+        return this.parseAuxiliaryStandard(buffer);
+    }
+    /**
+     * Parse auxiliary data in NSKeyedArchiver bplist format
+     */
+    parseAuxiliaryAsBplist(buffer) {
+        // Find bplist header in buffer
+        const bplistMagic = 'bplist00';
+        for (let i = 0; i < Math.min(100, buffer.length - 8); i++) {
+            if (buffer.toString('ascii', i, i + 8) === bplistMagic) {
+                try {
+                    const plistBuffer = buffer.subarray(i);
+                    const parsed = parseBinaryPlist(plistBuffer);
+                    return Array.isArray(parsed) ? parsed : [parsed];
+                }
+                catch (error) {
+                    log.warn('Failed to parse auxiliary bplist:', error);
+                }
+                break;
+            }
+        }
+        return [];
+    }
+    /**
+     * Parse auxiliary data in standard DTX format
+     */
+    parseAuxiliaryStandard(buffer) {
+        const values = [];
+        let offset = 16; // Skip magic (8) + size (8)
+        const totalSize = buffer.readBigUInt64LE(8);
+        const endOffset = offset + Number(totalSize);
+        while (offset < endOffset && offset < buffer.length) {
+            // Read and validate empty dictionary marker
+            const marker = buffer.readUInt32LE(offset);
+            offset += 4;
+            if (marker !== DTX_CONSTANTS.EMPTY_DICTIONARY) {
+                offset -= 4; // Rewind if not the expected marker
+            }
+            // Read type
+            const type = buffer.readUInt32LE(offset);
+            offset += 4;
+            // Read value based on type
+            try {
+                const value = this.parseAuxiliaryValue(buffer, type, offset);
+                values.push(value.data);
+                offset = value.newOffset;
+            }
+            catch (error) {
+                log.warn(`Failed to parse auxiliary value at offset ${offset}:`, error);
+                break;
+            }
+        }
+        return values;
+    }
+    /**
+     * Parse a single auxiliary value
+     */
+    parseAuxiliaryValue(buffer, type, offset) {
+        switch (type) {
+            case DTX_CONSTANTS.AUX_TYPE_INT32:
+                return {
+                    data: buffer.readUInt32LE(offset),
+                    newOffset: offset + 4,
+                };
+            case DTX_CONSTANTS.AUX_TYPE_INT64:
+                return {
+                    data: buffer.readBigUInt64LE(offset),
+                    newOffset: offset + 8,
+                };
+            case DTX_CONSTANTS.AUX_TYPE_OBJECT: {
+                const length = buffer.readUInt32LE(offset);
+                const plistData = buffer.subarray(offset + 4, offset + 4 + length);
+                let parsed;
+                try {
+                    parsed = parseBinaryPlist(plistData);
+                }
+                catch (error) {
+                    log.warn('Failed to parse auxiliary object plist:', error);
+                    parsed = plistData;
+                }
+                return {
+                    data: parsed,
+                    newOffset: offset + 4 + length,
+                };
+            }
+            default:
+                throw new Error(`Unknown auxiliary type: ${type}`);
+        }
+    }
+}
+export { Channel, ChannelFragmenter, DTXMessage, MessageAux, DTX_CONSTANTS };
+export { decodeNSKeyedArchiver, NSKeyedArchiverDecoder, } from './nskeyedarchiver-decoder.js';

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

@@ -0,0 +1,37 @@
+import type { ConditionGroup } from '../../../../lib/types.js';
+import type { DVTSecureSocketProxyService } from '../index.js';
+/**
+ * Condition Inducer service for simulating various device conditions
+ * such as network conditions, thermal states, etc.
+ */
+export declare class ConditionInducer {
+    private readonly dvt;
+    static readonly IDENTIFIER = "com.apple.instruments.server.services.ConditionInducer";
+    private channel;
+    constructor(dvt: DVTSecureSocketProxyService);
+    /**
+     * Initialize the condition inducer channel
+     */
+    initialize(): Promise<void>;
+    /**
+     * List all available condition inducers and their profiles
+     * @returns Array of condition groups with their available profiles
+     */
+    list(): Promise<ConditionGroup[]>;
+    /**
+     * Set a specific condition profile
+     * @param profileIdentifier The identifier of the profile to enable
+     * @throws Error if the profile identifier is not found
+     * @throws Error if a condition is already active
+     */
+    set(profileIdentifier: string): Promise<void>;
+    /**
+     * Disable the currently active condition
+     *
+     * Note: This method is idempotent - calling it when no condition is active
+     * will not throw an error.
+     */
+    disable(): Promise<void>;
+    private isNSError;
+}
+//# sourceMappingURL=condition-inducer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"condition-inducer.d.ts","sourceRoot":"","sources":["../../../../../../src/services/ios/dvt/instruments/condition-inducer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAG/D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAI/D;;;GAGG;AACH,qBAAa,gBAAgB;IAMf,OAAO,CAAC,QAAQ,CAAC,GAAG;IALhC,MAAM,CAAC,QAAQ,CAAC,UAAU,4DACiC;IAE3D,OAAO,CAAC,OAAO,CAAwB;gBAEV,GAAG,EAAE,2BAA2B;IAE7D;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAOjC;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;IAwBvC;;;;;OAKG;IACG,GAAG,CAAC,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA4CnD;;;;;OAKG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAoB9B,OAAO,CAAC,SAAS;CAKlB"}

package/build/src/services/ios/dvt/instruments/condition-inducer.js

@@ -0,0 +1,99 @@
+import { getLogger } from '../../../../lib/logger.js';
+import { MessageAux } from '../dtx-message.js';
+const log = getLogger('ConditionInducer');
+/**
+ * Condition Inducer service for simulating various device conditions
+ * such as network conditions, thermal states, etc.
+ */
+export class ConditionInducer {
+    dvt;
+    static IDENTIFIER = 'com.apple.instruments.server.services.ConditionInducer';
+    channel = null;
+    constructor(dvt) {
+        this.dvt = dvt;
+    }
+    /**
+     * Initialize the condition inducer channel
+     */
+    async initialize() {
+        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
+     */
+    async list() {
+        await this.initialize();
+        await this.channel.call('availableConditionInducers')();
+        const result = await this.channel.receivePlist();
+        // Handle different response formats
+        if (!result) {
+            log.warn('Received null/undefined response from availableConditionInducers');
+            return [];
+        }
+        // If result is already an array, return it
+        if (Array.isArray(result)) {
+            return result;
+        }
+        throw new Error(`Unexpected response format from availableConditionInducers: ${JSON.stringify(result)}`);
+    }
+    /**
+     * Set a specific condition profile
+     * @param profileIdentifier The identifier of the profile to enable
+     * @throws Error if the profile identifier is not found
+     * @throws Error if a condition is already active
+     */
+    async set(profileIdentifier) {
+        await this.initialize();
+        const groups = await this.list();
+        // Find the profile in the available groups
+        for (const group of groups) {
+            const profiles = group.profiles || [];
+            for (const profile of profiles) {
+                if (profileIdentifier !== profile.identifier) {
+                    continue;
+                }
+                log.info(`Enabling condition: ${profile.description || profile.identifier}`);
+                const args = new MessageAux()
+                    .appendObj(group.identifier)
+                    .appendObj(profile.identifier);
+                await this.channel.call('enableConditionWithIdentifier_profileIdentifier_')(args);
+                // Wait for response which may be a raised NSError
+                await this.channel.receivePlist();
+                log.info(`Successfully enabled condition profile: ${profileIdentifier}`);
+                return;
+            }
+        }
+        const availableProfiles = groups.flatMap((group) => (group.profiles || []).map((p) => p.identifier));
+        throw new Error(`Invalid profile identifier: ${profileIdentifier}. Available profiles: ${availableProfiles.join(', ')}`);
+    }
+    /**
+     * Disable the currently active condition
+     *
+     * Note: This method is idempotent - calling it when no condition is active
+     * will not throw an error.
+     */
+    async disable() {
+        await this.initialize();
+        await this.channel.call('disableActiveCondition')();
+        const response = await this.channel.receivePlist();
+        // Response can be:
+        // - true (successfully disabled condition)
+        // - NSError object, when no condition is active
+        if (response === true) {
+            log.info('Disabled active condition');
+        }
+        else if (this.isNSError(response)) {
+            log.debug('No active condition to disable');
+        }
+        else {
+            throw new Error(`Unexpected response from disableActiveCondition: ${JSON.stringify(response)}`);
+        }
+    }
+    isNSError(obj) {
+        return ['NSCode', 'NSUserInfo', 'NSDomain'].some((prop) => obj?.[prop] !== undefined);
+    }
+}