appium-ios-remotexpc 0.37.0 → 0.37.2

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [0.37.2](https://github.com/appium/appium-ios-remotexpc/compare/v0.37.1...v0.37.2) (2026-03-22)
+
+### Miscellaneous Chores
+
+* Migrate scripts to ESM/.mjs ([#173](https://github.com/appium/appium-ios-remotexpc/issues/173)) ([8d6053b](https://github.com/appium/appium-ios-remotexpc/commit/8d6053b6bfde353296905daf345b8e15d4307873))
+
+## [0.37.1](https://github.com/appium/appium-ios-remotexpc/compare/v0.37.0...v0.37.1) (2026-03-21)
+
 ## [0.37.0](https://github.com/appium/appium-ios-remotexpc/compare/v0.36.0...v0.37.0) (2026-03-21)
 
 ### Features

package/README.md

@@ -11,7 +11,7 @@ This library provides functionality for:
 
 - Remote XPC (Cross Process Communication) with iOS devices
 - Lockdown communication
-- USB device multiplexing (usbmux)
+- Device multiplexing via **usbmuxd** (lists USB **and** WiFi-attached devices; see below)
 - Property list (plist) handling
 - IPv6 tunneling services to iOS devices using TUN/TAP interfaces
 - System log access
@@ -32,7 +32,7 @@ npm install appium-ios-remotexpc
 ## Features
 
 - **Plist Handling**: Encode, decode, parse, and create property lists for iOS device communication.
-- **USB Device Communication**: Connect to iOS devices over USB using the usbmux protocol.
+- **Device communication over usbmux / usbmuxd**: The system **usbmuxd** daemon exposes a single device list that includes machines plugged in over **USB** and, when pairing and wireless sync are set up, the same iPhone/iPad **over WiFi**. WiFi entries are marked **`ConnectionType: Network`** (USB entries use `ConnectionType: USB`). This library connects through usbmuxd the same way for both; the tunnel path is unchanged (lockdown → CoreDeviceProxy → TUN/TAP → Remote XPC).
 - **Remote XPC**: Establish Remote XPC connections with iOS devices.
 - **Service Architecture**: Connect to various iOS services:
     - System Log Service: Access device logs
@@ -130,6 +130,20 @@ const remoteXPC = await TunnelManager.createRemoteXPCConnection(
 const services = remoteXPC.getServices();
 ```
 
+### iPhone / iPad over WiFi (usbmuxd “network” devices)
+
+**usbmuxd** (the multiplexer daemon, e.g. on macOS) does **not** only list USB devices: once a device is paired with the host and wireless sync / lockdown-over-WiFi is enabled, **the same daemon’s device list includes that device as attached over WiFi**. In plist responses from `ListDevices`, those rows carry **`ConnectionType: Network`** (and a distinct `DeviceID` from any USB listing for the same physical device).
+
+There is no separate “WiFi API” in this library: call `createUsbmux()` → `listDevices()` (or any other client that queries **usbmuxd**) and use the returned **`DeviceID`** and UDID with `createLockdownServiceByUDID` and the tunnel steps in the previous section—identical to USB.
+
+**Typical host-side setup:**
+
+1. Pair the device with this Mac and tap **Trust** on the device if prompted.
+2. Allow the device to connect over WiFi (e.g. in Finder under the device, enable **Show this [device] when on WiFi**, or use Xcode **Devices and Simulators** with the equivalent option so lockdown can reach the device without USB).
+3. Confirm **usbmuxd** reports the device with **`ConnectionType: Network`**—for example by logging the result of `listDevices()` from this library, or by checking another usbmuxd client’s device list while the device is on the same network and not on USB.
+
+For an end-to-end tunnel smoke test with the tunnel registry HTTP API, use `npm run tunnel-creation` or `npm run test:tunnel-creation` (see `scripts/test-tunnel-creation.ts`), usually with **sudo** for TUN/TAP.
+
 ### Apple TV / tvOS over WiFi
 
 Apple TV and tvOS devices over WiFi are supported. The following symbols are part of the public API and are intended for external use (e.g. by the Appium XCUITest driver):
@@ -182,10 +196,19 @@ All pull requests must pass these checks before merging. The workflows are defin
 - `npm run format` - Run prettier
 - `npm run lint:fix` - Run ESLint with auto-fix
 - `npm test` - Run tests (requires sudo privileges for tunneling)
-- `npm run test:tunnel-creation` - Create tunnels for testing (requires sudo)
+
+CLI helpers under `scripts/` are ESM (`.mjs`) and load the library via the package entrypoint. Run `npm run build` before using them so `appium-ios-remotexpc` resolves to `build/`.
+
+- `npm run tunnel-creation` / `npm run test:tunnel-creation` — Create USB tunnels and start the tunnel registry HTTP API (requires `sudo`)
+- `npm run test:tunnel-creation:lsof` — Same as above with `--keep-open` (for inspecting open sockets)
+- `npm run pair-appletv` — Pair an Apple TV over WiFi for Remote XPC (requires `sudo`)
+- `npm run start-appletv-tunnel` — Start an Apple TV WiFi tunnel and tunnel registry (requires `sudo`)
+
+Pass `--help` after `--` to any of these npm scripts to see CLI flags (for example: `npm run pair-appletv -- --help`).
 
 ## Project Structure
 
+- `/scripts` - Optional CLI helpers (ESM `.mjs`) for tunnels and Apple TV pairing; use via `npm run` entries under [Scripts](#scripts)
 - `/src` - Source code
   - `/lib` - Core libraries
     - `/lockdown` - Device lockdown protocol
@@ -193,7 +216,7 @@ All pull requests must pass these checks before merging. The workflows are defin
     - `/plist` - Property list processing
     - `/remote-xpc` - XPC connection handling
     - `/tunnel` - Tunneling implementation with tuntap integration
-    - `/usbmux` - USB multiplexing protocol
+    - `/usbmux` - usbmuxd client (USB and WiFi-listed devices)
   - `/services` - Service implementations
     - `/ios`
       - `/diagnostic-service` - Device diagnostics
@@ -208,7 +231,7 @@ npm test
 ```
 
 Note: Integration tests require:
-- Physical iOS devices connected
+- Physical iOS devices connected (USB and/or **WiFi** if the device is paired and visible to usbmux as `Network`)
 - Sudo privileges for tunnel creation
 - Device trust established
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appium-ios-remotexpc",
-  "version": "0.37.0",
+  "version": "0.37.2",
   "main": "build/src/index.js",
   "types": "build/src/index.d.ts",
   "type": "module",
@@ -18,11 +18,11 @@
     "clean:build": "rimraf ./build",
     "build:es": "tsc",
     "build": "run-s clean:* build:*",
-    "lint": "eslint src --ext .ts --quiet",
+    "lint": "eslint src scripts --quiet",
     "prepare": "husky && 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",
+    "lint:fix": "eslint src scripts --fix",
     "test": "mocha test/integration/**/*.ts",
     "test:all": "mocha -r tsx/cjs test/run-integration-tests.ts",
     "test:tunnel": "mocha test/integration/tunnel-test.ts --exit --timeout 1m",
@@ -33,9 +33,9 @@
     "test:mobile-config": "mocha test/integration/mobile-config-test.ts --exit --timeout 1m",
     "test:springboard": "mocha test/integration/springboard-service-test.ts --exit --timeout 1m",
     "test:unit": "NODE_ENV=test mocha 'test/unit/**/*.ts' --exit --timeout 2m",
-    "tunnel-creation": "sudo tsx scripts/test-tunnel-creation.ts",
-    "pair-appletv": "sudo tsx scripts/pair-appletv.ts",
-    "start-appletv-tunnel": "sudo tsx scripts/start-appletv-tunnel.ts",
+    "tunnel-creation": "sudo node scripts/tunnel-creation.mjs",
+    "pair-appletv": "sudo node scripts/pair-appletv.mjs",
+    "start-appletv-tunnel": "sudo node scripts/start-appletv-tunnel.mjs",
     "test:webinspector": "mocha test/integration/webinspector-test.ts --exit --timeout 1m",
     "test:misagent": "mocha test/integration/misagent-service-test.ts --exit --timeout 1m",
     "test:afc": "mocha test/integration/afc-test.ts --exit --timeout 1m",
@@ -55,8 +55,8 @@
     "test:dvt:network-monitor": "mocha test/integration/dvt_instruments/network-monitor-test.ts --exit --timeout 1m",
     "test:dvt:process-control": "mocha test/integration/process-control-test.ts --exit --timeout 1m",
     "test:testmanagerd": "mocha test/integration/testmanagerd-test.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"
+    "test:tunnel-creation": "sudo node scripts/tunnel-creation.mjs",
+    "test:tunnel-creation:lsof": "sudo node scripts/tunnel-creation.mjs --keep-open"
   },
   "keywords": [],
   "author": "Appium Contributors",
@@ -102,6 +102,7 @@
     "@xmldom/xmldom": "^0.9.8",
     "appium-ios-tuntap": "^0.x",
     "axios": "^1.12.0",
+    "commander": "^14.0.1",
     "dnssd": "^0.x",
     "minimatch": "^10.1.1",
     "node-devicectl": "^1.2.0",

package/scripts/pair-appletv.mjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+/**
+ * Pair Apple TV / tvOS devices over WiFi for Remote XPC tunnels.
+ *
+ * Usage:
+ *   npm run pair-appletv -- [options]
+ */
+
+import { logger } from '@appium/support';
+import { Command } from 'commander';
+import { AppleTVPairingService, UserInputService } from 'appium-ios-remotexpc';
+
+const log = logger.getLogger('AppleTVPairing');
+
+async function main() {
+  const program = new Command();
+  program
+    .name('pair-appletv')
+    .description('Pair Apple TV / tvOS devices over WiFi for Remote XPC tunnels')
+    .option(
+      '-d, --device <selector>',
+      'Device selector: name, identifier (e.g. AA:BB:CC:DD:EE:FF), or index (0, 1, …)',
+    );
+
+  program.parse(process.argv);
+  const options = program.opts();
+
+  const userInput = new UserInputService();
+  const pairingService = new AppleTVPairingService(userInput);
+  const result = await pairingService.discoverAndPair(options.device);
+
+  if (result.success) {
+    log.info(`Pairing successful! Record saved to: ${result.pairingFile}`);
+  } else {
+    throw result.error ?? new Error('Pairing failed');
+  }
+}
+
+await main();

package/scripts/{start-appletv-tunnel.ts → start-appletv-tunnel.mjs}

@@ -1,43 +1,70 @@
-#!/usr/bin/env tsx
-import * as tls from 'node:tls';
-
-import { PacketStreamServer, TunnelManager } from '../src/index.js';
-import type { TunnelRegistry } from '../src/index.js';
-import { AppleTVTunnelService } from '../src/lib/apple-tv/tunnel/index.js';
-import type { AppleTVDevice } from '../src/lib/bonjour/bonjour-discovery.js';
-import { getLogger } from '../src/lib/logger.js';
-import type { TunnelConnection } from '../src/lib/tunnel/index.js';
+#!/usr/bin/env node
+/**
+ * Start an Apple TV Remote XPC tunnel and expose the tunnel registry API.
+ */
+
+import { logger } from '@appium/support';
+import { Command } from 'commander';
 import {
-  DEFAULT_TUNNEL_REGISTRY_PORT,
+  AppleTVTunnelService,
+  PacketStreamServer,
+  TunnelManager,
   startTunnelRegistryServer,
-} from '../src/lib/tunnel/tunnel-registry-server.js';
+} from 'appium-ios-remotexpc';
+import { DEFAULT_TUNNEL_REGISTRY_PORT } from '../build/src/lib/tunnel/tunnel-registry-server.js';
 
-const log = getLogger('WiFiTunnel');
+const log = logger.getLogger('WiFiTunnel');
 const PACKET_STREAM_PORT = 50100;
 
-async function main(): Promise<void> {
-  const args = process.argv.slice(2);
-  const specificDeviceIdentifier = args.find((arg) => !arg.startsWith('-'));
+function parsePort(value) {
+  const port = Number.parseInt(value, 10);
+  if (!Number.isFinite(port) || port <= 0 || port > 65535) {
+    throw new Error(
+      `Invalid port: ${value}. Expected an integer between 1 and 65535.`,
+    );
+  }
+  return port;
+}
+
+async function main() {
+  const program = new Command();
+  program
+    .name('start-appletv-tunnel')
+    .description('Start an Apple TV WiFi tunnel and tunnel registry HTTP API')
+    .argument(
+      '[deviceIdentifier]',
+      'Optional Apple TV device identifier to target',
+    )
+    .option(
+      '--tunnel-registry-port <port>',
+      `Port for tunnel registry API (default: ${DEFAULT_TUNNEL_REGISTRY_PORT})`,
+      parsePort,
+    );
+
+  program.parse(process.argv);
+  const options = program.opts();
+  const deviceIdentifier = program.args[0];
+  const registryPort =
+    options.tunnelRegistryPort ?? DEFAULT_TUNNEL_REGISTRY_PORT;
 
-  if (specificDeviceIdentifier) {
+  if (deviceIdentifier) {
     log.info(
-      `Starting Apple TV tunnel for specific device identifier: ${specificDeviceIdentifier}`,
+      `Starting Apple TV tunnel for specific device identifier: ${deviceIdentifier}`,
     );
   } else {
     log.info('Starting Apple TV tunnel (will try all discovered devices)');
   }
 
   const tunnelService = new AppleTVTunnelService();
-  let tunnel: TunnelConnection | null = null;
-  let tlsSocket: tls.TLSSocket | null = null;
-  let deviceInfo: AppleTVDevice | null = null;
-  let packetStreamServer: PacketStreamServer | null = null;
+  let tunnel = null;
+  let tlsSocket = null;
+  let deviceInfo = null;
+  let packetStreamServer = null;
 
-  const cleanup = async (signal: string): Promise<void> => {
+  const cleanup = async (signal) => {
     log.warn(`\nCleaning up (${signal})...`);
 
     try {
-      // Close packet stream server first
       if (packetStreamServer) {
         log.info('Closing packet stream server...');
         await packetStreamServer.stop();
@@ -89,7 +116,7 @@ async function main(): Promise<void> {
     log.info('Starting Apple TV tunnel...');
     const result = await tunnelService.startTunnel(
       undefined,
-      specificDeviceIdentifier,
+      deviceIdentifier,
     );
     tlsSocket = result.socket;
     deviceInfo = result.device;
@@ -101,13 +128,11 @@ async function main(): Promise<void> {
     log.info('Creating tunnel with TunnelManager...');
     tunnel = await TunnelManager.getTunnel(tlsSocket);
 
-    // Start packet stream server (same as iPhone tunnel)
     let packetStreamPort = 0;
     try {
       packetStreamServer = new PacketStreamServer(PACKET_STREAM_PORT);
       await packetStreamServer.start();
 
-      // Attach packet consumer to tunnel to receive packet data
       const consumer = packetStreamServer.getPacketConsumer();
       if (consumer && tunnel.addPacketConsumer) {
         tunnel.addPacketConsumer(consumer);
@@ -123,7 +148,7 @@ async function main(): Promise<void> {
     const now = Date.now();
     const nowISOString = new Date().toISOString();
 
-    const registry: TunnelRegistry = {
+    const registry = {
       tunnels: {
         [deviceInfo.identifier]: {
           udid: deviceInfo.identifier,
@@ -144,7 +169,7 @@ async function main(): Promise<void> {
       },
     };
 
-    await startTunnelRegistryServer(registry);
+    await startTunnelRegistryServer(registry, registryPort);
 
     log.info('=== TUNNEL ESTABLISHED ===');
     log.info(`Tunnel Address: ${tunnel.Address}`);
@@ -154,7 +179,7 @@ async function main(): Promise<void> {
 
     log.info('\n📁 Tunnel registry API:');
     log.info(
-      `   http://localhost:${DEFAULT_TUNNEL_REGISTRY_PORT}/remotexpc/tunnels`,
+      `   http://localhost:${registryPort}/remotexpc/tunnels`,
     );
     log.info('   - GET /remotexpc/tunnels - List all tunnels');
     log.info(
@@ -169,9 +194,7 @@ async function main(): Promise<void> {
   } catch (error) {
     log.error('Tunnel failed:', error);
     throw error;
-  } finally {
-    await cleanup('Shutdown');
   }
 }
 
-main();
+await main();

package/scripts/{test-tunnel-creation.ts → tunnel-creation.mjs}

@@ -1,10 +1,10 @@
-#!/usr/bin/env tsx
+#!/usr/bin/env node
 /**
- * Test script for creating lockdown service, starting CoreDeviceProxy, and creating tunnel
- * This script demonstrates the tunnel creation workflow for all connected devices
+ * Create lockdown + CoreDeviceProxy tunnels for connected USB devices and expose the tunnel registry API.
  */
+
 import { logger } from '@appium/support';
-import type { ConnectionOptions } from 'tls';
+import { Command } from 'commander';
 
 import {
   PacketStreamServer,
@@ -12,26 +12,27 @@ import {
   createLockdownServiceByUDID,
   createUsbmux,
   startCoreDeviceProxy,
-} from '../src/index.js';
-import type { SocketInfo, TunnelRegistry } from '../src/index.js';
-import {
-  DEFAULT_TUNNEL_REGISTRY_PORT,
   startTunnelRegistryServer,
-} from '../src/lib/tunnel/tunnel-registry-server.js';
-import type { Device } from '../src/lib/usbmux/index.js';
+} from 'appium-ios-remotexpc';
+import { DEFAULT_TUNNEL_REGISTRY_PORT } from '../build/src/lib/tunnel/tunnel-registry-server.js';
 
 const log = logger.getLogger('TunnelCreation');
-/**
- * Update tunnel registry with new tunnel information
- */
-async function updateTunnelRegistry(
-  results: TunnelResult[],
-): Promise<TunnelRegistry> {
+
+function parsePort(value) {
+  const port = Number.parseInt(value, 10);
+  if (!Number.isFinite(port) || port <= 0 || port > 65535) {
+    throw new Error(
+      `Invalid port: ${value}. Expected an integer between 1 and 65535.`,
+    );
+  }
+  return port;
+}
+
+async function updateTunnelRegistry(results) {
   const now = Date.now();
   const nowISOString = new Date().toISOString();
 
-  // Initialize registry if it doesn't exist
-  const registry: TunnelRegistry = {
+  const registry = {
     tunnels: {},
     metadata: {
       lastUpdated: nowISOString,
@@ -40,7 +41,6 @@ async function updateTunnelRegistry(
     },
   };
 
-  // Update tunnels
   for (const result of results) {
     if (result.success) {
       const udid = result.device.Properties.SerialNumber;
@@ -58,39 +58,21 @@ async function updateTunnelRegistry(
     }
   }
 
-  // Update metadata
   registry.metadata = {
     lastUpdated: nowISOString,
     totalTunnels: Object.keys(registry.tunnels).length,
-    activeTunnels: Object.keys(registry.tunnels).length, // Assuming all are active for now
+    activeTunnels: Object.keys(registry.tunnels).length,
   };
 
   return registry;
 }
 
-const activeServers: Array<{ server: any; port: number }> = [];
-const packetStreamServers: Map<string, PacketStreamServer> = new Map();
-
-const deviceInfoMap: Map<
-  string,
-  {
-    udid: string;
-    address: string;
-    rsdPort?: number;
-    connectionType: string;
-    productId: number;
-  }
-> = new Map();
+const packetStreamServers = new Map();
 
-let PACKET_STREAM_BASE_PORT = 50000;
-/**
- * Setup cleanup handlers for graceful shutdown
- */
-function setupCleanupHandlers(): void {
-  const cleanup = async (signal: string) => {
+function setupCleanupHandlers() {
+  const cleanup = async (signal) => {
     log.warn(`\nCleaning up (${signal})...`);
 
-    // Close all packet stream servers
     if (packetStreamServers.size > 0) {
       log.info(
         `Closing ${packetStreamServers.size} packet stream server(s)...`,
@@ -111,7 +93,6 @@ function setupCleanupHandlers(): void {
     log.info('Cleanup completed.');
   };
 
-  // Handle various termination signals
   process.on('SIGINT', async () => {
     await cleanup('SIGINT (Ctrl+C)');
     process.exit(0);
@@ -125,7 +106,6 @@ function setupCleanupHandlers(): void {
     process.exit(0);
   });
 
-  // Handle uncaught exceptions and unhandled rejections
   process.on('uncaughtException', async (error) => {
     log.error('Uncaught Exception:', error);
     await cleanup('Uncaught Exception');
@@ -137,24 +117,7 @@ function setupCleanupHandlers(): void {
   });
 }
 
-/**
- * Interface for tunnel result
- */
-interface TunnelResult {
-  device: Device;
-  tunnel: {
-    Address: string;
-    RsdPort?: number;
-  };
-  packetStreamPort?: number;
-  success: boolean;
-  error?: string;
-}
-
-async function createTunnelForDevice(
-  device: Device,
-  tlsOptions: Partial<ConnectionOptions>,
-): Promise<TunnelResult & { socket?: any; socketInfo?: SocketInfo }> {
+async function createTunnelForDevice(device, tlsOptions, packetStreamBaseRef) {
   const udid = device.Properties.SerialNumber;
 
   try {
@@ -185,9 +148,9 @@ async function createTunnelForDevice(
       `Tunnel created for address: ${tunnel.Address} with RsdPort: ${tunnel.RsdPort}`,
     );
 
-    let packetStreamPort: number | undefined;
+    let packetStreamPort;
     try {
-      packetStreamPort = PACKET_STREAM_BASE_PORT++;
+      packetStreamPort = packetStreamBaseRef.value++;
       const packetStreamServer = new PacketStreamServer(packetStreamPort);
       await packetStreamServer.start();
 
@@ -215,16 +178,6 @@ async function createTunnelForDevice(
         socket.setNoDelay(true);
       }
 
-      const deviceInfo = {
-        udid: device.Properties.SerialNumber,
-        address: tunnel.Address,
-        rsdPort: tunnel.RsdPort,
-        connectionType: device.Properties.ConnectionType,
-        productId: device.Properties.ProductID,
-      };
-
-      deviceInfoMap.set(device.Properties.SerialNumber, deviceInfo);
-
       return {
         device,
         tunnel: {
@@ -261,14 +214,32 @@ async function createTunnelForDevice(
   }
 }
 
-/**
- */
-async function main(): Promise<void> {
+async function main() {
   setupCleanupHandlers();
 
-  const args = process.argv.slice(2);
-  const keepOpenFlag = args.includes('--keep-open') || args.includes('-k');
-  const specificUdid = args.find((arg) => !arg.startsWith('-'));
+  const program = new Command();
+  program
+    .name('tunnel-creation')
+    .description(
+      'Create tunnels for connected USB devices (lockdown + CoreDeviceProxy)',
+    )
+    .argument('[udid]', 'Optional device UDID (omit for all devices)')
+    .option('--udid <udid>', 'UDID of the device to create tunnel for')
+    .option('-k, --keep-open', 'Keep connections open for lsof inspection')
+    .option(
+      '--packet-stream-base-port <port>',
+      'Base port for packet stream servers (1-65535)',
+      parsePort,
+    )
+    .option(
+      '--tunnel-registry-port <port>',
+      `Port for tunnel registry API (default: ${DEFAULT_TUNNEL_REGISTRY_PORT})`,
+      parsePort,
+    );
+
+  program.parse(process.argv);
+  const options = program.opts();
+  const specificUdid = options.udid ?? program.args[0] ?? undefined;
 
   if (specificUdid) {
     log.info(
@@ -278,16 +249,22 @@ async function main(): Promise<void> {
     log.info('Starting tunnel creation test for all connected devices');
   }
 
-  if (keepOpenFlag) {
+  if (options.keepOpen) {
     log.info('Running in "keep connections open" mode for lsof inspection');
   }
 
-  try {
-    const tlsOptions: Partial<ConnectionOptions> = {
-      rejectUnauthorized: false,
-      minVersion: 'TLSv1.2',
-    };
+  const tlsOptions = {
+    rejectUnauthorized: false,
+    minVersion: 'TLSv1.2',
+  };
+
+  const packetStreamBaseRef = {
+    value: options.packetStreamBasePort ?? 50000,
+  };
+  const registryPort =
+    options.tunnelRegistryPort ?? DEFAULT_TUNNEL_REGISTRY_PORT;
 
+  try {
     log.info('Connecting to usbmuxd...');
     const usbmux = await createUsbmux();
 
@@ -331,10 +308,14 @@ async function main(): Promise<void> {
 
     log.info(`\nProcessing ${devicesToProcess.length} device(s)...`);
 
-    const results: TunnelResult[] = [];
+    const results = [];
 
     for (const device of devicesToProcess) {
-      const result = await createTunnelForDevice(device, tlsOptions);
+      const result = await createTunnelForDevice(
+        device,
+        tlsOptions,
+        packetStreamBaseRef,
+      );
       results.push(result);
 
       if (devicesToProcess.length > 1) {
@@ -353,11 +334,11 @@ async function main(): Promise<void> {
     if (successful.length > 0) {
       log.info('\n✅ Successful tunnels:');
       const registry = await updateTunnelRegistry(results);
-      await startTunnelRegistryServer(registry);
+      await startTunnelRegistryServer(registry, registryPort);
 
       log.info('\n📁 Tunnel registry API:');
       log.info('   The tunnel registry is now available through the API at:');
-      log.info('   http://localhost:42314/remotexpc/tunnels');
+      log.info(`   http://localhost:${registryPort}/remotexpc/tunnels`);
       log.info('\n   Available endpoints:');
       log.info('   - GET /remotexpc/tunnels - List all tunnels');
       log.info('   - GET /remotexpc/tunnels/:udid - Get tunnel by UDID');
@@ -365,15 +346,15 @@ async function main(): Promise<void> {
 
       log.info('\n💡 Example usage:');
       log.info(
-        `   curl http://localhost:${DEFAULT_TUNNEL_REGISTRY_PORT}/remotexpc/tunnels`,
+        `   curl http://localhost:${registryPort}/remotexpc/tunnels`,
       );
       log.info(
-        `   curl http://localhost:${DEFAULT_TUNNEL_REGISTRY_PORT}/remotexpc/tunnels/metadata`,
+        `   curl http://localhost:${registryPort}/remotexpc/tunnels/metadata`,
       );
       if (successful.length > 0) {
         const firstUdid = successful[0].device.Properties.SerialNumber;
         log.info(
-          `   curl http://localhost:${DEFAULT_TUNNEL_REGISTRY_PORT}/remotexpc/tunnels/${firstUdid}`,
+          `   curl http://localhost:${registryPort}/remotexpc/tunnels/${firstUdid}`,
         );
       }
     }
@@ -383,5 +364,4 @@ async function main(): Promise<void> {
   }
 }
 
-// Run the main function
-main();
+await main();

package/scripts/pair-appletv.ts

@@ -1,78 +0,0 @@
-#!/usr/bin/env tsx
-import {
-  AppleTVPairingService,
-  UserInputService,
-} from '../src/lib/apple-tv/index.js';
-import { getLogger } from '../src/lib/logger.js';
-
-interface CLIArgs {
-  device?: string;
-  help?: boolean;
-}
-
-function parseArgs(): CLIArgs {
-  const args: CLIArgs = {};
-  const cliArgs = process.argv.slice(2);
-
-  for (let i = 0; i < cliArgs.length; i++) {
-    const arg = cliArgs[i];
-    if (arg === '--device' || arg === '-d') {
-      args.device = cliArgs[++i];
-    } else if (arg === '--help' || arg === '-h') {
-      args.help = true;
-    }
-  }
-
-  return args;
-}
-
-function printHelp(): void {
-  // eslint-disable-next-line no-console
-  console.log(`
-Apple TV Pairing Script
-
-Usage: pair-appletv [options]
-
-Options:
-  -d, --device <selector>   Specify device to pair with. Can be:
-                            - Device name (e.g., "Living Room")
-                            - Device identifier (e.g., "AA:BB:CC:DD:EE:FF")
-                            - Device index (e.g., "0", "1", "2")
-                            If not specified and multiple devices are found,
-                            you will be prompted to choose one.
-  -h, --help               Show this help message
-
-Examples:
-  pair-appletv                           # Discover and select device interactively
-  pair-appletv --device "Living Room"    # Pair with device named "Living Room"
-  pair-appletv --device 0                # Pair with first discovered device
-  pair-appletv -d AA:BB:CC:DD:EE:FF      # Pair with device by identifier
-`);
-}
-
-// CLI interface
-async function main(): Promise<void> {
-  const log = getLogger('AppleTVPairing');
-  const args = parseArgs();
-
-  if (args.help) {
-    printHelp();
-    return;
-  }
-
-  const userInput = new UserInputService();
-  const pairingService = new AppleTVPairingService(userInput);
-  const result = await pairingService.discoverAndPair(args.device);
-
-  if (result.success) {
-    log.info(`Pairing successful! Record saved to: ${result.pairingFile}`);
-  } else {
-    const error = result.error ?? new Error('Pairing failed');
-    log.error(`Pairing failed: ${error.message}`);
-    throw error;
-  }
-}
-
-main().catch(() => {
-  process.exit(1);
-});