appium-ios-remotexpc 0.2.0 → 0.3.1

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+## [0.3.1](https://github.com/appium/appium-ios-remotexpc/compare/v0.3.0...v0.3.1) (2025-08-31)
+
+### Miscellaneous Chores
+
+* add bonjour service and AppleTV device info defaults ([#53](https://github.com/appium/appium-ios-remotexpc/issues/53)) ([a5924f8](https://github.com/appium/appium-ios-remotexpc/commit/a5924f8da8142dfd16219fe40f2421c528f534ce))
+
+## [0.3.0](https://github.com/appium/appium-ios-remotexpc/compare/v0.2.0...v0.3.0) (2025-08-26)
+
+### Features
+
+* Tune Node.js engines ([#60](https://github.com/appium/appium-ios-remotexpc/issues/60)) ([ab3a259](https://github.com/appium/appium-ios-remotexpc/commit/ab3a25966569c4fa07c50aad250c91cf9a837507))
+
+### Bug Fixes
+
+* use 0.9+ explicitly for xmldom reps ([#63](https://github.com/appium/appium-ios-remotexpc/issues/63)) ([4940032](https://github.com/appium/appium-ios-remotexpc/commit/4940032d439e5dd6a4537c8b8dde8ed49be7ebb9))
+
+### Miscellaneous Chores
+
+* **deps:** bump actions/checkout from 3 to 4 ([#57](https://github.com/appium/appium-ios-remotexpc/issues/57)) ([4d80170](https://github.com/appium/appium-ios-remotexpc/commit/4d80170359af0b41edfb11016ecc08aa6867a28c))
+* **deps:** bump actions/setup-node from 3 to 4 ([#58](https://github.com/appium/appium-ios-remotexpc/issues/58)) ([1f2abdd](https://github.com/appium/appium-ios-remotexpc/commit/1f2abddc315900825d5a94dd817b234a393e1f85))
+
 ## [0.2.0](https://github.com/appium/appium-ios-remotexpc/compare/v0.1.1...v0.2.0) (2025-08-14)
 
 ### Features

package/build/src/lib/apple-tv/deviceInfo/index.d.ts

@@ -0,0 +1,20 @@
+import type { AppleTVDeviceInfo } from '../types.js';
+type OpackSerialized = Buffer;
+/**
+ * Creates a standardized Apple TV device information object with default values
+ * and the specified identifier as the account ID.
+ *
+ * @param identifier - Unique identifier to use as the account ID
+ * @returns Complete Apple TV device information object
+ */
+export declare function createAppleTVDeviceInfo(identifier: string): AppleTVDeviceInfo;
+/**
+ * Encodes Apple TV device information into a binary buffer using Opack2 serialization.
+ * This creates the device info object and immediately serializes it for transmission.
+ *
+ * @param identifier - Unique identifier to use as the account ID
+ * @returns Serialized device information as a Buffer
+ */
+export declare function encodeAppleTVDeviceInfo(identifier: string): OpackSerialized;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/src/lib/apple-tv/deviceInfo/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/apple-tv/deviceInfo/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,KAAK,eAAe,GAAG,MAAM,CAAC;AAU9B;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,iBAAiB,CAU7E;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,CAM3E"}

package/build/src/lib/apple-tv/deviceInfo/index.js

@@ -0,0 +1,40 @@
+import { hostname } from 'node:os';
+import { Opack2 } from '../encryption/index.js';
+const DEFAULT_ALT_IRK = Buffer.from([
+    0xe9, 0xe8, 0x2d, 0xc0, 0x6a, 0x49, 0x79, 0x6b, 0x56, 0x6f, 0x54, 0x00, 0x19,
+    0xb1, 0xc7, 0x7b,
+]);
+const DEFAULT_BT_ADDR = '11:22:33:44:55:66';
+const DEFAULT_MAC_BUFFER = Buffer.from([0x11, 0x22, 0x33, 0x44, 0x55, 0x66]);
+const DEFAULT_PAIRING_SERIAL = 'AAAAAAAAAAAA';
+/**
+ * Creates a standardized Apple TV device information object with default values
+ * and the specified identifier as the account ID.
+ *
+ * @param identifier - Unique identifier to use as the account ID
+ * @returns Complete Apple TV device information object
+ */
+export function createAppleTVDeviceInfo(identifier) {
+    return {
+        altIRK: DEFAULT_ALT_IRK,
+        btAddr: DEFAULT_BT_ADDR,
+        mac: DEFAULT_MAC_BUFFER,
+        remotePairingSerialNumber: DEFAULT_PAIRING_SERIAL,
+        accountID: identifier,
+        model: 'computer-model',
+        name: hostname(),
+    };
+}
+/**
+ * Encodes Apple TV device information into a binary buffer using Opack2 serialization.
+ * This creates the device info object and immediately serializes it for transmission.
+ *
+ * @param identifier - Unique identifier to use as the account ID
+ * @returns Serialized device information as a Buffer
+ */
+export function encodeAppleTVDeviceInfo(identifier) {
+    const deviceInfo = createAppleTVDeviceInfo(identifier);
+    // Cast to SerializableValue to ensure type compatibility with Opack2.dumps
+    // The AppleTVDeviceInfo structure is compatible with OPACK2 serialization
+    return Opack2.dumps(deviceInfo);
+}

package/build/src/lib/apple-tv/index.d.ts

@@ -0,0 +1,9 @@
+export type { AppleTVDeviceInfo, PairingKeys, PairingResult, PairingConfig, TLV8Item, PairingDataComponentTypeValue, Opack2Value, Opack2Array, Opack2Dictionary, } from './types.js';
+export * from './errors.js';
+export * from './constants.js';
+export * from './utils/index.js';
+export * from './deviceInfo/index.js';
+export * from './encryption/index.js';
+export * from './tlv/index.js';
+export * from './srp/index.js';
+//# sourceMappingURL=index.d.ts.map

package/build/src/lib/apple-tv/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/apple-tv/index.ts"],"names":[],"mappings":"AACA,YAAY,EACV,iBAAiB,EACjB,WAAW,EACX,aAAa,EACb,aAAa,EACb,QAAQ,EACR,6BAA6B,EAC7B,WAAW,EACX,WAAW,EACX,gBAAgB,GACjB,MAAM,YAAY,CAAC;AACpB,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC"}

package/build/src/lib/apple-tv/index.js

@@ -0,0 +1,7 @@
+export * from './errors.js';
+export * from './constants.js';
+export * from './utils/index.js';
+export * from './deviceInfo/index.js';
+export * from './encryption/index.js';
+export * from './tlv/index.js';
+export * from './srp/index.js';

package/build/src/lib/bonjour/bonjour-discovery.d.ts

@@ -0,0 +1,81 @@
+import { EventEmitter } from 'node:events';
+/**
+ * Interface for a discovered Bonjour service
+ */
+export interface BonjourService {
+    name: string;
+    type: string;
+    domain: string;
+    hostname?: string;
+    port?: number;
+    txtRecord?: Record<string, string>;
+    interfaceIndex?: number;
+}
+/**
+ * Interface for AppleTV device discovered via Bonjour
+ */
+export interface AppleTVDevice {
+    name: string;
+    identifier: string;
+    hostname: string;
+    ip?: string;
+    port: number;
+    model: string;
+    version: string;
+    minVersion: string;
+    authTag?: string;
+    interfaceIndex?: number;
+}
+/**
+ * Type alias for service discovery results
+ */
+export type ServiceDiscoveryResult = Array<{
+    action: string;
+    service: BonjourService;
+}>;
+export declare class BonjourDiscovery extends EventEmitter {
+    private _browseProcess?;
+    private _isDiscovering;
+    private readonly _discoveredServices;
+    /**
+     * Start browsing for Bonjour services
+     */
+    startBrowsing(serviceType?: string, domain?: string): Promise<void>;
+    /**
+     * Stop browsing for services
+     */
+    stopBrowsing(): void;
+    /**
+     * Get all discovered services
+     */
+    getDiscoveredServices(): BonjourService[];
+    /**
+     * Resolve a specific service to get detailed information
+     */
+    resolveService(serviceName: string, serviceType?: string, domain?: string): Promise<BonjourService>;
+    /**
+     * Discover Apple TV devices with IP address resolution
+     */
+    discoverAppleTVDevicesWithIP(timeoutMs?: number): Promise<AppleTVDevice[]>;
+    /**
+     * Process browse output using the parser
+     */
+    processBrowseOutput(output: string): void;
+    /**
+     * Initialize a browsing process
+     */
+    private initializeBrowsing;
+    /**
+     * Setup event handlers for an ongoing browse process
+     */
+    private setupBrowseEventHandlers;
+    /**
+     * Resolve all discovered services
+     */
+    private resolveAllServices;
+    /**
+     * Cleanup resources
+     */
+    private cleanup;
+}
+//# sourceMappingURL=bonjour-discovery.d.ts.map

package/build/src/lib/bonjour/bonjour-discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bonjour-discovery.d.ts","sourceRoot":"","sources":["../../../../src/lib/bonjour/bonjour-discovery.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAiB3C;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,KAAK,CAAC;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,cAAc,CAAC;CACzB,CAAC,CAAC;AA6XH,qBAAa,gBAAiB,SAAQ,YAAY;IAChD,OAAO,CAAC,cAAc,CAAC,CAAe;IACtC,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAA0C;IAE9E;;OAEG;IACG,aAAa,CACjB,WAAW,GAAE,MAA+C,EAC5D,MAAM,GAAE,MAA+B,GACtC,OAAO,CAAC,IAAI,CAAC;IAgBhB;;OAEG;IACH,YAAY,IAAI,IAAI;IAQpB;;OAEG;IACH,qBAAqB,IAAI,cAAc,EAAE;IAIzC;;OAEG;IACG,cAAc,CAClB,WAAW,EAAE,MAAM,EACnB,WAAW,GAAE,MAA+C,EAC5D,MAAM,GAAE,MAA+B,GACtC,OAAO,CAAC,cAAc,CAAC;IAoB1B;;OAEG;IACG,4BAA4B,CAChC,SAAS,GAAE,MAA2C,GACrD,OAAO,CAAC,aAAa,EAAE,CAAC;IAmB3B;;OAEG;IACH,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAsBzC;;OAEG;YACW,kBAAkB;IA4BhC;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAuBhC;;OAEG;YACW,kBAAkB;IAuBhC;;OAEG;IACH,OAAO,CAAC,OAAO;CAMhB"}

package/build/src/lib/bonjour/bonjour-discovery.js

@@ -0,0 +1,461 @@
+import { logger } from '@appium/support';
+import { spawn } from 'node:child_process';
+import { resolve4 } from 'node:dns/promises';
+import { EventEmitter } from 'node:events';
+import { clearTimeout, setTimeout } from 'node:timers';
+import { setTimeout as delay } from 'node:timers/promises';
+import { BONJOUR_DEFAULT_DOMAIN, BONJOUR_SERVICE_TYPES, BONJOUR_TIMEOUTS, DNS_SD_ACTIONS, DNS_SD_COMMANDS, DNS_SD_PATTERNS, } from './constants.js';
+const log = logger.getLogger('BonjourDiscovery');
+const DNS_SD_COMMAND = 'dns-sd';
+/**
+ * Execute a dns-sd command with a timeout.
+ *
+ * @param args Arguments passed to the dns-sd CLI.
+ * @param timeoutMs Timeout in milliseconds.
+ * @param outputHandler Called for each stdout chunk from dns-sd:
+ *   - returns true: chunk handled; no result recorded; continue listening
+ *   - returns a truthy non-true value (e.g., object): store as result to return when the process ends
+ *   - returns false/undefined/null: ignore; continue listening
+ *   - throws: mark command as failed
+ * @param timeoutMessage Error message used if the command times out.
+ * @returns The value produced by outputHandler, if any, when the process ends.
+ */
+async function executeDnsSdCommand(args, timeoutMs, outputHandler, timeoutMessage) {
+    const child = spawn(DNS_SD_COMMAND, args);
+    try {
+        const result = await waitForProcessResult(child, timeoutMs, outputHandler, timeoutMessage);
+        if (!result.success) {
+            throw result.error || new Error('Process execution failed');
+        }
+        return result.data;
+    }
+    finally {
+        if (!child.killed) {
+            child.kill('SIGTERM');
+        }
+    }
+}
+/**
+ * Create a long-running browse process
+ */
+function createDnsSdBrowseProcess(serviceType, domain) {
+    return spawn(DNS_SD_COMMAND, [DNS_SD_COMMANDS.BROWSE, serviceType, domain]);
+}
+/**
+ * Wait for a child process result with a timeout.
+ *
+ * @param process Child process to observe.
+ * @param timeoutMs Timeout in milliseconds.
+ * @param outputHandler Called for each stdout chunk from dns-sd:
+ *   - returns true: chunk handled; no result recorded; continue listening
+ *   - returns a truthy non-true value (e.g., object): store as result to return when the process ends
+ *   - returns false/undefined/null: ignore; continue listening
+ *   - throws: mark command as failed
+ * @param timeoutMessage Error message used if the operation times out.
+ * @returns A ProcessResult indicating success and any data from outputHandler.
+ */
+async function waitForProcessResult(process, timeoutMs, outputHandler, timeoutMessage) {
+    return new Promise((resolve, reject) => {
+        let isResolved = false;
+        let result;
+        let exitCode = null;
+        let hasError = false;
+        let errorMessage = '';
+        const timeout = setTimeout(() => {
+            if (!isResolved) {
+                isResolved = true;
+                reject(new Error(timeoutMessage));
+            }
+        }, timeoutMs);
+        const cleanup = () => {
+            clearTimeout(timeout);
+            if (!isResolved) {
+                isResolved = true;
+                if (hasError) {
+                    reject(new Error(errorMessage));
+                }
+                else if (exitCode !== null && exitCode !== 0) {
+                    reject(new Error(`Process exited with code ${exitCode}`));
+                }
+                else if (result !== undefined) {
+                    resolve({ success: true, data: result });
+                }
+                else {
+                    resolve({ success: true });
+                }
+            }
+        };
+        process.stdout?.on('data', (data) => {
+            if (isResolved) {
+                return;
+            }
+            const output = data.toString();
+            log.debug(`[dns-sd] output: ${output}`);
+            try {
+                const handlerResult = outputHandler(output);
+                if (handlerResult === true) {
+                    result = undefined;
+                }
+                else if (handlerResult) {
+                    result = handlerResult;
+                }
+            }
+            catch (error) {
+                hasError = true;
+                errorMessage = `Output handler error: ${error}`;
+            }
+        });
+        process.stderr?.on('data', (data) => {
+            if (isResolved) {
+                return;
+            }
+            const error = data.toString();
+            log.error(`[dns-sd] error: ${error}`);
+            hasError = true;
+            errorMessage = `Process failed: ${error}`;
+        });
+        process.on('error', (error) => {
+            if (isResolved) {
+                return;
+            }
+            log.error(`[dns-sd] failed to start process: ${error}`);
+            hasError = true;
+            errorMessage = `Failed to start process: ${error}`;
+        });
+        process.on('exit', (code) => {
+            exitCode = code;
+            if (code !== null && code !== 0) {
+                log.error(`[dns-sd] process exited with error code: ${code}`);
+            }
+        });
+        process.on('close', (code) => {
+            log.debug(`[dns-sd] process closed with code: ${code}`);
+            cleanup();
+        });
+    });
+}
+/**
+ * Parse browse output and extract service information
+ */
+function parseBrowseOutput(output) {
+    const reducer = (acc, line) => {
+        const match = line.match(DNS_SD_PATTERNS.BROWSE_LINE);
+        if (!match) {
+            return acc;
+        }
+        const [, , action, , interfaceIndex, domain, serviceType, name] = match;
+        const trimmedName = name.trim();
+        const service = {
+            name: trimmedName,
+            type: serviceType,
+            domain,
+            interfaceIndex: parseInt(interfaceIndex, 10),
+        };
+        acc.push({ action, service });
+        return acc;
+    };
+    return output
+        .split('\n')
+        .filter((line) => !shouldSkipLine(line))
+        .reduce(reducer, []);
+}
+/**
+ * Parse resolve output and extract service details
+ */
+function parseResolveOutput(output, serviceName, serviceType, domain) {
+    return parseOutput(output, (line, result) => {
+        // If we already found a result, return it (early termination)
+        if (result) {
+            return result;
+        }
+        const reachableMatch = line.match(DNS_SD_PATTERNS.REACHABLE);
+        if (reachableMatch) {
+            const [, hostname, port, interfaceIndex] = reachableMatch;
+            const txtRecord = parseTxtRecord(output);
+            return {
+                name: serviceName,
+                type: serviceType,
+                domain,
+                hostname,
+                port: parseInt(port, 10),
+                txtRecord,
+                interfaceIndex: parseInt(interfaceIndex, 10),
+            };
+        }
+        return result;
+    }, null);
+}
+/**
+ * Generic method to parse output with different reducer functions
+ */
+function parseOutput(output, reducer, initialValue) {
+    const lines = output.split('\n');
+    let result = initialValue;
+    for (const line of lines) {
+        if (shouldSkipLine(line)) {
+            continue;
+        }
+        result = reducer(line, result);
+    }
+    return result;
+}
+/**
+ * Parse TXT record from output
+ */
+function parseTxtRecord(output) {
+    const txtRecord = {};
+    const txtMatch = output.match(DNS_SD_PATTERNS.TXT_RECORD);
+    if (txtMatch) {
+        const [, identifier, authTag, model, name, ver, minVer] = txtMatch;
+        txtRecord.identifier = identifier;
+        txtRecord.authTag = authTag;
+        txtRecord.model = model;
+        txtRecord.name = name;
+        txtRecord.ver = ver;
+        txtRecord.minVer = minVer;
+    }
+    return txtRecord;
+}
+/**
+ * Check if line should be skipped
+ */
+function shouldSkipLine(line) {
+    return (line.includes('Timestamp') || line.includes('---') || line.trim() === '');
+}
+/**
+ * Resolve hostname to IP address
+ */
+async function resolveIPAddress(hostname) {
+    try {
+        const address = await resolve4(hostname);
+        log.info(`[ServiceResolver] Resolved ${hostname} to IPv4: ${address}`);
+        return address;
+    }
+    catch (error) {
+        log.warn(`[ServiceResolver] Failed to resolve hostname ${hostname} to IPv4: ${error}`);
+        // For .local hostnames, try without the trailing dot
+        if (hostname.endsWith('.local.')) {
+            const cleanHostname = hostname.slice(0, -1); // Remove trailing dot
+            try {
+                const address = await resolve4(cleanHostname);
+                log.info(`[ServiceResolver] Resolved ${cleanHostname} to IPv4: ${address}`);
+                return address;
+            }
+            catch (retryError) {
+                log.warn(`[ServiceResolver] Failed to resolve ${cleanHostname} to IPv4: ${retryError}`);
+            }
+        }
+        return undefined;
+    }
+}
+/**
+ * Convert a resolved Bonjour service to an Apple TV device with IP resolution
+ */
+async function convertToAppleTVDeviceWithIP(service) {
+    if (!isValidService(service)) {
+        return null;
+    }
+    const { txtRecord, hostname, port } = service;
+    if (!txtRecord || !hasRequiredTxtFields(txtRecord)) {
+        log.warn(`[AppleTVDeviceConverter] Service ${service.name} missing required TXT record fields`);
+        return null;
+    }
+    if (!hostname || !port) {
+        log.warn(`[AppleTVDeviceConverter] Service ${service.name} missing hostname or port`);
+        return null;
+    }
+    const ipAddresses = await resolveIPAddress(hostname);
+    // Select default first one
+    // TODO: needs a decision to select from cli, if the user wants to select from the available ip's
+    const ip = ipAddresses?.[0];
+    return {
+        name: service.name,
+        identifier: txtRecord.identifier,
+        hostname,
+        ip,
+        port,
+        model: txtRecord.model,
+        version: txtRecord.ver,
+        minVersion: txtRecord.minVer || '17',
+        authTag: txtRecord.authTag,
+        interfaceIndex: service.interfaceIndex,
+    };
+}
+/**
+ * Check if the service has required fields
+ */
+function isValidService(service) {
+    return Boolean(service.hostname && service.port && service.txtRecord);
+}
+/**
+ * Check if TXT record has required fields
+ */
+function hasRequiredTxtFields(txtRecord) {
+    return Boolean(txtRecord.identifier && txtRecord.model && txtRecord.ver);
+}
+/* =========================
+ * Main Bonjour discovery service orchestrator
+ * =========================
+ */
+export class BonjourDiscovery extends EventEmitter {
+    _browseProcess;
+    _isDiscovering = false;
+    _discoveredServices = new Map();
+    /**
+     * Start browsing for Bonjour services
+     */
+    async startBrowsing(serviceType = BONJOUR_SERVICE_TYPES.APPLE_TV_PAIRING, domain = BONJOUR_DEFAULT_DOMAIN) {
+        if (this._isDiscovering) {
+            log.warn('Already discovering services');
+            return;
+        }
+        log.info(`Starting Bonjour discovery for ${serviceType}.${domain}`);
+        try {
+            await this.initializeBrowsing(serviceType, domain);
+        }
+        catch (error) {
+            this.cleanup();
+            throw error;
+        }
+    }
+    /**
+     * Stop browsing for services
+     */
+    stopBrowsing() {
+        if (this._browseProcess && !this._browseProcess.killed) {
+            log.info('Stopping Bonjour discovery');
+            this._browseProcess.kill('SIGTERM');
+        }
+        this.cleanup();
+    }
+    /**
+     * Get all discovered services
+     */
+    getDiscoveredServices() {
+        return Array.from(this._discoveredServices.values());
+    }
+    /**
+     * Resolve a specific service to get detailed information
+     */
+    async resolveService(serviceName, serviceType = BONJOUR_SERVICE_TYPES.APPLE_TV_PAIRING, domain = BONJOUR_DEFAULT_DOMAIN) {
+        log.info(`[ServiceResolver] Resolving service: ${serviceName}.${serviceType}.${domain}`);
+        const service = await executeDnsSdCommand([DNS_SD_COMMANDS.RESOLVE, serviceName, serviceType, domain], BONJOUR_TIMEOUTS.SERVICE_RESOLUTION, (output) => parseResolveOutput(output, serviceName, serviceType, domain), `Service resolution timeout for ${serviceName}`);
+        if (!service) {
+            throw new Error(`Failed to resolve service ${serviceName}`);
+        }
+        return service;
+    }
+    /**
+     * Discover Apple TV devices with IP address resolution
+     */
+    async discoverAppleTVDevicesWithIP(timeoutMs = BONJOUR_TIMEOUTS.DEFAULT_DISCOVERY) {
+        log.info('Starting Apple TV device discovery with IP resolution');
+        try {
+            await this.startBrowsing();
+            await delay(timeoutMs);
+            const devices = await this.resolveAllServices();
+            log.info(`Discovered ${devices.length} Apple TV device(s) with IP addresses:`, devices);
+            return devices;
+        }
+        finally {
+            this.stopBrowsing();
+        }
+    }
+    /**
+     * Process browse output using the parser
+     */
+    processBrowseOutput(output) {
+        const results = parseBrowseOutput(output);
+        for (const { action, service } of results) {
+            switch (action) {
+                case DNS_SD_ACTIONS.ADD:
+                    this._discoveredServices.set(service.name, service);
+                    this.emit('serviceAdded', service);
+                    log.info(`Discovered service: ${service.name}`);
+                    break;
+                case DNS_SD_ACTIONS.REMOVE:
+                    this._discoveredServices.delete(service.name);
+                    this.emit('serviceRemoved', service.name);
+                    log.info(`Service removed: ${service.name}`);
+                    break;
+                default:
+                    log.debug(`Unknown action: ${action}`);
+                    break;
+            }
+        }
+    }
+    /**
+     * Initialize a browsing process
+     */
+    async initializeBrowsing(serviceType, domain) {
+        this._isDiscovering = true;
+        this._discoveredServices.clear();
+        const browseProcess = createDnsSdBrowseProcess(serviceType, domain);
+        this._browseProcess = browseProcess;
+        try {
+            await executeDnsSdCommand([DNS_SD_COMMANDS.BROWSE, serviceType, domain], BONJOUR_TIMEOUTS.BROWSE_STARTUP, (output) => {
+                this.processBrowseOutput(output);
+                return output.includes(DNS_SD_PATTERNS.STARTING);
+            }, 'DNS-SD browse startup timeout');
+            this.setupBrowseEventHandlers(browseProcess);
+        }
+        catch (error) {
+            this._isDiscovering = false;
+            throw error;
+        }
+    }
+    /**
+     * Setup event handlers for an ongoing browse process
+     */
+    setupBrowseEventHandlers(process) {
+        process.stdout?.on('data', (data) => {
+            const output = data.toString();
+            log.debug(`dns-sd browse output: ${output}`);
+            this.processBrowseOutput(output);
+        });
+        process.stderr?.on('data', (data) => {
+            const error = data.toString();
+            log.error(`dns-sd browse error: ${error}`);
+        });
+        process.on('exit', (code) => {
+            if (code !== null && code !== 0) {
+                log.error(`dns-sd browse process exited with error code: ${code}`);
+            }
+        });
+        process.on('close', (code) => {
+            log.debug(`dns-sd browse process closed with code: ${code}`);
+            this.cleanup();
+        });
+    }
+    /**
+     * Resolve all discovered services
+     */
+    async resolveAllServices() {
+        const services = this.getDiscoveredServices();
+        log.info(`Found ${services.length} services to resolve`);
+        const devices = [];
+        for (const service of services) {
+            try {
+                log.info(`Attempting to resolve service: ${service.name}`);
+                const resolvedService = await this.resolveService(service.name);
+                const device = await convertToAppleTVDeviceWithIP(resolvedService);
+                if (device) {
+                    devices.push(device);
+                }
+            }
+            catch (error) {
+                log.warn(`Failed to resolve service ${service.name}: ${error}`);
+            }
+        }
+        return devices;
+    }
+    /**
+     * Cleanup resources
+     */
+    cleanup() {
+        log.debug('Cleaning up BonjourDiscovery resources');
+        this._browseProcess = undefined;
+        this._isDiscovering = false;
+        this._discoveredServices.clear();
+    }
+}

package/build/src/lib/bonjour/constants.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Constants for Bonjour discovery
+ */
+export declare const BONJOUR_TIMEOUTS: {
+    readonly BROWSE_STARTUP: 5000;
+    readonly SERVICE_RESOLUTION: 10000;
+    readonly DEFAULT_DISCOVERY: 5000;
+};
+export declare const BONJOUR_SERVICE_TYPES: {
+    readonly APPLE_TV_PAIRING: "_remotepairing-manual-pairing._tcp";
+};
+export declare const BONJOUR_DEFAULT_DOMAIN = "local";
+export declare const DNS_SD_COMMANDS: {
+    readonly BROWSE: "-B";
+    readonly RESOLVE: "-L";
+};
+export declare const DNS_SD_ACTIONS: {
+    readonly ADD: "Add";
+    readonly REMOVE: "Rmv";
+};
+export declare const DNS_SD_PATTERNS: {
+    readonly STARTING: "...STARTING...";
+    readonly BROWSE_LINE: RegExp;
+    readonly REACHABLE: RegExp;
+    readonly TXT_RECORD: RegExp;
+};
+//# sourceMappingURL=constants.d.ts.map