appium-ios-remotexpc 0.37.1 → 0.37.2

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [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)

package/README.md

@@ -196,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appium-ios-remotexpc",
-  "version": "0.37.1",
+  "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);
-});