@mcesystems/usbmuxd-instance-manager 1.0.72 → 1.0.73

package/README.md

@@ -108,6 +108,19 @@ await service.stop();
 | `wslDistribution` | string | `usbmuxd-alpine` | Alpine WSL2 distribution name |
 | `verboseLogging` | boolean | true | Enable verbose output |
 | `appleVendorId` | string | '05AC' | Apple vendor ID (hex) |
+| `lockdownWindowsPath` | string | `C:\ProgramData\mce\lockdown` | Windows folder for lockdown (pairing) files; synced to/from Alpine |
+| `lockdownSyncEnabled` | boolean | true | Sync lockdown files so pairing can be skipped |
+
+### Lockdown sync
+
+When enabled, the manager syncs lockdown (pairing) files between Windows and Alpine so devices that were already paired on Windows can be used without pairing again in WSL:
+
+- **To Alpine**: When a device is assigned, that device’s plist (`{UDID}.plist`) is copied from `lockdownWindowsPath` to Alpine `/var/lib/lockdown`. Only the file for that device is copied.
+- **From Alpine**: When the service stops, plists for all devices that were assigned this session (plus `SystemConfiguration.plist` if present) are copied from Alpine back to `lockdownWindowsPath` so they are available for the next run.
+
+**Alpine permissions**: `/var/lib/lockdown` is often root-owned. The sync tries a normal copy first; if that fails (e.g. permission denied), it retries with `sudo cp`. Ensure the WSL user has passwordless sudo for these commands, or that the Alpine image has `/var/lib/lockdown` writable by the default user. If both fail, a warning is logged and device assignment continues (pairing can still be done manually).
+
+Set `lockdownSyncEnabled: false` or leave `lockdownWindowsPath` empty to disable lockdown sync.
 
 ## CLI Options
 
@@ -118,7 +131,8 @@ Options:
   --batchSize <n>        Number of devices per instance (default: 4)
   --basePort <port>      Base TCP port for first instance (default: 27015)
   --maxInstances <n>     Maximum number of instances (default: 20)
-  --usbmuxdPath <path>   Path to usbmuxd executable
+  --usbmuxdPath <path>   Path to usbmuxd executable (WSL: default usbmuxd)
+  --wslDistribution <n>  WSL distribution name (default: alpine-usbmuxd-build)
   --verbose <true|false> Enable verbose logging (default: true)
   --appleVid <vid>       Apple Vendor ID in hex (default: 05AC)
   -h, --help             Show this help message
@@ -162,6 +176,65 @@ When all devices disconnect from Instance 2:
 - Instance 2 automatically terminates
 - Frees resources
 
+## Flow: Working with usbipd and WSL
+
+On Windows, the same physical USB device can be used by **either** Windows (e.g. iTunes, Apple Mobile Device) **or** WSL (usbmuxd), not both. usbipd-win is what moves the device between the two.
+
+### Device ownership
+
+| State | Who has the device | iTunes / Windows | usbmuxd (WSL) |
+|-------|--------------------|------------------|---------------|
+| Not shared | Windows | ✓ | ✗ |
+| Bound + attached to WSL | WSL | ✗ | ✓ |
+| Bound but detached | Neither (held by usbipd) | ✗ | ✗ |
+
+### Giving the device to usbmuxd (instance manager)
+
+1. **WSL** must be running (e.g. the manager starts it, or run `wsl -d alpine-usbmuxd-build -- echo ok`).
+2. **Bind** the device (take it from Windows):  
+   `usbipd bind --busid <BUSID> --force`
+3. **Attach** to WSL:  
+   `usbipd attach --wsl=<distro> --busid=<BUSID>`
+
+The instance manager does steps 2–3 automatically when it sees an iOS device. You can also use the script:
+
+```powershell
+# From packages/usbmuxd-instance-manager
+.\scripts\attach-device.ps1
+```
+
+### Giving the device back to Windows (e.g. for iTunes)
+
+1. **Detach** from WSL (stops forwarding to Linux):  
+   `usbipd detach --busid <BUSID>`  
+   Or detach all:  
+   `usbipd detach -a`
+2. **Unbind** so Windows gets the device back:  
+   `usbipd unbind --busid <BUSID>`
+
+Until you unbind, the device stays “Shared (forced)” and Windows/iTunes will not see it.
+
+### Useful usbipd commands
+
+```powershell
+$usbipd = "C:\Program Files\usbipd-win\usbipd.exe"
+
+# List devices and their state (Shared / Not shared, Attached / Not attached)
+& $usbipd list
+
+# Detach from WSL (device still bound to usbipd)
+& $usbipd detach --busid 2-5
+& $usbipd detach -a
+
+# Unbind so Windows can use the device again (e.g. iTunes)
+& $usbipd unbind --busid 2-5
+```
+
+### Quick reference
+
+- **Use device with usbmuxd-instance-manager** → bind + attach (manager or script does this when you connect a device).
+- **Use device with iTunes on Windows** → detach then unbind for that bus ID; then iTunes will see it.
+
 ## Requirements
 
 ### Runtime

package/dist/cli.js

@@ -24,20 +24,104 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/cli.ts
-var import_tool_debug_g43 = require("@mcesystems/tool-debug-g4");
+var import_tool_debug_g44 = require("@mcesystems/tool-debug-g4");
 
 // src/UsbmuxdService.ts
 var import_node_events2 = require("node:events");
-var import_tool_debug_g42 = require("@mcesystems/tool-debug-g4");
+var import_tool_debug_g43 = require("@mcesystems/tool-debug-g4");
 var import_usb_device_listener = __toESM(require("@mcesystems/usb-device-listener"));
 
 // src/InstanceManager.ts
-var import_node_child_process = require("node:child_process");
+var import_node_child_process2 = require("node:child_process");
 var import_node_events = require("node:events");
+var import_node_util2 = require("node:util");
+var import_tool_debug_g42 = require("@mcesystems/tool-debug-g4");
+
+// src/LockdownSync.ts
+var import_node_child_process = require("node:child_process");
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
 var import_node_util = require("node:util");
 var import_tool_debug_g4 = require("@mcesystems/tool-debug-g4");
 var { logInfo, logWarning } = (0, import_tool_debug_g4.createLoggers)("usbmuxd-instance-manager");
 var execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
+var ALPINE_LOCKDOWN_DIR = "/var/lib/lockdown";
+var SYSTEM_CONFIG_PLIST = "SystemConfiguration.plist";
+function windowsPathToWsl(windowsPath) {
+  const normalized = windowsPath.replace(/\\/g, "/").trim();
+  const driveMatch = normalized.match(/^([a-zA-Z]):\/?(.*)$/);
+  if (driveMatch) {
+    const drive = driveMatch[1].toLowerCase();
+    const rest = driveMatch[2] || "";
+    return `/mnt/${drive}${rest ? `/${rest}` : ""}`;
+  }
+  return normalized;
+}
+async function syncToAlpine(udid, config2) {
+  if (!config2.lockdownSyncEnabled || !config2.lockdownWindowsPath?.trim()) {
+    return;
+  }
+  const windowsDir = config2.lockdownWindowsPath.trim();
+  const windowsFile = (0, import_node_path.join)(windowsDir, `${udid}.plist`);
+  if (!(0, import_node_fs.existsSync)(windowsFile)) {
+    return;
+  }
+  const distro = config2.wslDistribution || "alpine-usbmuxd-build";
+  const wslSource = windowsPathToWsl(windowsFile);
+  const wslDestDir = ALPINE_LOCKDOWN_DIR;
+  try {
+    await execAsync(
+      `wsl -d ${distro} -- sh -c "mkdir -p ${wslDestDir} && cp '${wslSource}' '${wslDestDir}/'"`
+    );
+    logInfo(`Lockdown sync: copied ${udid}.plist to Alpine`);
+  } catch (error) {
+    try {
+      await execAsync(
+        `wsl -d ${distro} -- sh -c "mkdir -p ${wslDestDir} && sudo cp '${wslSource}' '${wslDestDir}/'"`
+      );
+      logInfo(`Lockdown sync: copied ${udid}.plist to Alpine (via sudo)`);
+    } catch (sudoError) {
+      logWarning(
+        `Lockdown sync to Alpine failed for ${udid}: ${error}. Sudo fallback failed: ${sudoError}. Ensure /var/lib/lockdown is writable or use passwordless sudo.`
+      );
+    }
+  }
+}
+async function syncFromAlpine(udids, config2) {
+  if (!config2.lockdownSyncEnabled || !config2.lockdownWindowsPath?.trim()) {
+    return;
+  }
+  const windowsDir = config2.lockdownWindowsPath.trim();
+  try {
+    (0, import_node_fs.mkdirSync)(windowsDir, { recursive: true });
+  } catch (error) {
+    logWarning(`Lockdown sync: could not create Windows dir ${windowsDir}: ${error}`);
+    return;
+  }
+  const distro = config2.wslDistribution || "alpine-usbmuxd-build";
+  const wslDestDir = windowsPathToWsl(windowsDir);
+  for (const udid of udids) {
+    const plist = `${udid}.plist`;
+    try {
+      await execAsync(
+        `wsl -d ${distro} -- sh -c "test -f '${ALPINE_LOCKDOWN_DIR}/${plist}' && cp '${ALPINE_LOCKDOWN_DIR}/${plist}' '${wslDestDir}/'"`
+      );
+      logInfo(`Lockdown sync: copied ${plist} from Alpine to Windows`);
+    } catch {
+    }
+  }
+  try {
+    await execAsync(
+      `wsl -d ${distro} -- sh -c "test -f '${ALPINE_LOCKDOWN_DIR}/${SYSTEM_CONFIG_PLIST}' && cp '${ALPINE_LOCKDOWN_DIR}/${SYSTEM_CONFIG_PLIST}' '${wslDestDir}/'"`
+    );
+    logInfo(`Lockdown sync: copied ${SYSTEM_CONFIG_PLIST} from Alpine to Windows`);
+  } catch {
+  }
+}
+
+// src/InstanceManager.ts
+var { logInfo: logInfo2, logWarning: logWarning2 } = (0, import_tool_debug_g42.createLoggers)("usbmuxd-instance-manager");
+var execAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.exec);
 var USBIPD_PATH = '"C:\\Program Files\\usbipd-win\\usbipd.exe"';
 function parseUsbipdList(output) {
   const devices = [];
@@ -69,7 +153,9 @@ var DEFAULT_CONFIG = {
   wslDistribution: "alpine-usbmuxd-build",
   // Alpine WSL2 distribution name
   verboseLogging: true,
-  appleVendorId: "05AC"
+  appleVendorId: "05AC",
+  lockdownWindowsPath: "C:\\ProgramData\\mce\\lockdown",
+  lockdownSyncEnabled: true
 };
 var InstanceManager = class extends import_node_events.EventEmitter {
   config;
@@ -81,6 +167,8 @@ var InstanceManager = class extends import_node_events.EventEmitter {
   isRunning = false;
   /** Tracks which devices have been attached to WSL */
   attachedDevices = /* @__PURE__ */ new Set();
+  /** Device IDs currently in the attach flow (ignore disconnect until attach completes) */
+  pendingAttachDevices = /* @__PURE__ */ new Set();
   /** Cached WSL IP address for connecting from Windows */
   wslIpAddress = null;
   constructor(config2 = {}) {
@@ -97,28 +185,28 @@ var InstanceManager = class extends import_node_events.EventEmitter {
     }
     const distro = this.config.wslDistribution || "alpine-usbmuxd-build";
     try {
-      const { stdout } = await execAsync(`wsl -d ${distro} -- ip -4 addr show eth0`);
+      const { stdout } = await execAsync2(`wsl -d ${distro} -- ip -4 addr show eth0`);
       const match = stdout.match(/inet\s+(\d+\.\d+\.\d+\.\d+)/);
       if (match) {
         this.wslIpAddress = match[1];
-        logInfo(`Detected WSL IP address: ${this.wslIpAddress}`);
+        logInfo2(`Detected WSL IP address: ${this.wslIpAddress}`);
         return this.wslIpAddress;
       }
     } catch (error) {
-      logWarning(`Failed to detect WSL IP via ip addr: ${error}`);
+      logWarning2(`Failed to detect WSL IP via ip addr: ${error}`);
     }
     try {
-      const { stdout } = await execAsync(`wsl -d ${distro} -- hostname -I`);
+      const { stdout } = await execAsync2(`wsl -d ${distro} -- hostname -I`);
       const ip = stdout.trim().split(/\s+/)[0];
       if (ip && /^\d+\.\d+\.\d+\.\d+$/.test(ip)) {
         this.wslIpAddress = ip;
-        logInfo(`Detected WSL IP address (hostname): ${this.wslIpAddress}`);
+        logInfo2(`Detected WSL IP address (hostname): ${this.wslIpAddress}`);
         return this.wslIpAddress;
       }
     } catch (error) {
-      logWarning(`Failed to detect WSL IP via hostname: ${error}`);
+      logWarning2(`Failed to detect WSL IP via hostname: ${error}`);
     }
-    logWarning("Could not detect WSL IP, falling back to localhost");
+    logWarning2("Could not detect WSL IP, falling back to localhost");
     this.wslIpAddress = "127.0.0.1";
     return this.wslIpAddress;
   }
@@ -141,6 +229,8 @@ var InstanceManager = class extends import_node_events.EventEmitter {
       return;
     }
     this.isRunning = false;
+    const udids = Array.from(this.deviceMappings.keys());
+    await syncFromAlpine(udids, this.config);
     const detachPromises = Array.from(this.attachedDevices).map(
       (busId) => this.detachDeviceFromWsl(busId)
     );
@@ -158,28 +248,28 @@ var InstanceManager = class extends import_node_events.EventEmitter {
    */
   async findBusIdForDevice(device) {
     try {
-      const { stdout } = await execAsync(`${USBIPD_PATH} list`);
+      const { stdout } = await execAsync2(`${USBIPD_PATH} list`);
       const usbipdDevices = parseUsbipdList(stdout);
       const deviceVid = device.vid.toString(16).toUpperCase().padStart(4, "0");
       const devicePid = device.pid.toString(16).toUpperCase().padStart(4, "0");
-      logInfo(`Looking for device with VID:PID ${deviceVid}:${devicePid}`);
-      logInfo(`Found ${usbipdDevices.length} devices from usbipd list`);
+      logInfo2(`Looking for device with VID:PID ${deviceVid}:${devicePid}`);
+      logInfo2(`Found ${usbipdDevices.length} devices from usbipd list`);
       const match = usbipdDevices.find((d) => d.vid === deviceVid && d.pid === devicePid);
       if (match) {
-        logInfo(
+        logInfo2(
           `Found usbipd bus ID ${match.busId} for device ${device.deviceId} (${deviceVid}:${devicePid})`
         );
         return match.busId;
       }
       for (const d of usbipdDevices) {
-        logInfo(`  usbipd device: ${d.busId} ${d.vid}:${d.pid} "${d.description}"`);
+        logInfo2(`  usbipd device: ${d.busId} ${d.vid}:${d.pid} "${d.description}"`);
       }
-      logWarning(
+      logWarning2(
         `Could not find usbipd bus ID for device ${device.deviceId} (${deviceVid}:${devicePid})`
       );
       return null;
     } catch (error) {
-      logWarning(`Failed to run usbipd list: ${error}`);
+      logWarning2(`Failed to run usbipd list: ${error}`);
       return null;
     }
   }
@@ -190,15 +280,15 @@ var InstanceManager = class extends import_node_events.EventEmitter {
     const distro = this.config.wslDistribution;
     try {
       if (distro) {
-        logInfo(`Starting WSL distribution: ${distro}...`);
-        await execAsync(`wsl -d ${distro} -- echo "WSL started"`);
+        logInfo2(`Starting WSL distribution: ${distro}...`);
+        await execAsync2(`wsl -d ${distro} -- echo "WSL started"`);
       } else {
-        logInfo("Starting default WSL distribution...");
-        await execAsync(`wsl -- echo "WSL started"`);
+        logInfo2("Starting default WSL distribution...");
+        await execAsync2(`wsl -- echo "WSL started"`);
       }
       return true;
     } catch (error) {
-      logWarning(`Failed to start WSL: ${error}`);
+      logWarning2(`Failed to start WSL: ${error}`);
       return false;
     }
   }
@@ -210,19 +300,24 @@ var InstanceManager = class extends import_node_events.EventEmitter {
     const distro = this.config.wslDistribution;
     try {
       await this.ensureWslRunning();
-      logInfo(`Binding device ${busId}...`);
-      await execAsync(`${USBIPD_PATH} bind --busid ${busId} --force`);
+      logInfo2(`Binding device ${busId}...`);
+      await execAsync2(`${USBIPD_PATH} bind --busid ${busId} --force`);
       if (distro) {
-        logInfo(`Attaching device ${busId} to WSL distribution ${distro}...`);
-        await execAsync(`${USBIPD_PATH} attach --wsl=${distro} --busid=${busId}`);
+        logInfo2(`Attaching device ${busId} to WSL distribution ${distro}...`);
+        await execAsync2(`${USBIPD_PATH} attach --wsl=${distro} --busid=${busId}`);
       } else {
-        logInfo(`Attaching device ${busId} to default WSL...`);
-        await execAsync(`${USBIPD_PATH} attach --wsl --busid=${busId}`);
+        logInfo2(`Attaching device ${busId} to default WSL...`);
+        await execAsync2(`${USBIPD_PATH} attach --wsl --busid=${busId}`);
       }
-      logInfo(`Device ${busId} attached to WSL successfully`);
+      logInfo2(`Device ${busId} attached to WSL successfully`);
       return true;
     } catch (error) {
-      logWarning(`Failed to attach device ${busId} to WSL: ${error}`);
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("already attached to a client")) {
+        logInfo2(`Device ${busId} is already attached to WSL, continuing`);
+        return true;
+      }
+      logWarning2(`Failed to attach device ${busId} to WSL: ${error}`);
       return false;
     }
   }
@@ -231,10 +326,15 @@ var InstanceManager = class extends import_node_events.EventEmitter {
    */
   async detachDeviceFromWsl(busId) {
     try {
-      await execAsync(`${USBIPD_PATH} detach --busid=${busId}`);
-      logInfo(`Device ${busId} detached from WSL`);
+      await execAsync2(`${USBIPD_PATH} detach --busid=${busId}`);
+      logInfo2(`Device ${busId} detached from WSL`);
     } catch (error) {
-      logWarning(`Failed to detach device ${busId}: ${error}`);
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("no device with busid") || message.includes("There is no device")) {
+        logInfo2(`Device ${busId} already detached`);
+      } else {
+        logWarning2(`Failed to detach device ${busId}: ${error}`);
+      }
     }
   }
   /**
@@ -243,18 +343,24 @@ var InstanceManager = class extends import_node_events.EventEmitter {
    */
   async onDeviceConnected(device) {
     if (this.deviceMappings.has(device.deviceId)) {
-      logWarning(`Device ${device.deviceId} is already connected`);
+      logWarning2(`Device ${device.deviceId} is already connected`);
       return;
     }
+    await syncToAlpine(device.deviceId, this.config);
     const busId = await this.findBusIdForDevice(device);
     if (!busId) {
-      logWarning(`Cannot attach device ${device.deviceId} - bus ID not found`);
+      logWarning2(`Cannot attach device ${device.deviceId} - bus ID not found`);
     }
     if (busId && !this.attachedDevices.has(busId)) {
-      const attached = await this.attachDeviceToWsl(busId);
-      if (attached) {
-        this.attachedDevices.add(busId);
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
+      this.pendingAttachDevices.add(device.deviceId);
+      try {
+        const attached = await this.attachDeviceToWsl(busId);
+        if (attached) {
+          this.attachedDevices.add(busId);
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
+        }
+      } finally {
+        this.pendingAttachDevices.delete(device.deviceId);
       }
     }
     let targetInstance = this.findInstanceWithCapacity();
@@ -292,23 +398,23 @@ var InstanceManager = class extends import_node_events.EventEmitter {
   async pairDevice(udid, goIosPath = "ios") {
     const mapping = this.deviceMappings.get(udid);
     if (!mapping) {
-      logWarning(`Cannot pair device ${udid} - not found in mappings`);
+      logWarning2(`Cannot pair device ${udid} - not found in mappings`);
       return false;
     }
     try {
       const socketAddress = `${mapping.host}:${mapping.port}`;
-      logInfo(`Pairing device ${udid} via ${socketAddress}...`);
-      const { stderr } = await execAsync(`"${goIosPath}" pair --udid=${udid}`, {
+      logInfo2(`Pairing device ${udid} via ${socketAddress}...`);
+      const { stderr } = await execAsync2(`"${goIosPath}" pair --udid=${udid}`, {
         env: { ...process.env, USBMUXD_SOCKET_ADDRESS: socketAddress }
       });
       if (stderr?.includes("error")) {
-        logWarning(`Pairing warning for ${udid}: ${stderr}`);
+        logWarning2(`Pairing warning for ${udid}: ${stderr}`);
       }
-      logInfo(`Device ${udid} paired successfully`);
+      logInfo2(`Device ${udid} paired successfully`);
       this.emit("device-paired", { udid, mapping });
       return true;
     } catch (error) {
-      logWarning(`Failed to pair device ${udid}: ${error}`);
+      logWarning2(`Failed to pair device ${udid}: ${error}`);
       return false;
     }
   }
@@ -317,9 +423,12 @@ var InstanceManager = class extends import_node_events.EventEmitter {
    * Detaches from WSL, removes device from instance, and stops instance if empty
    */
   async onDeviceDisconnected(device) {
+    if (this.pendingAttachDevices.has(device.deviceId)) {
+      return;
+    }
     const mapping = this.deviceMappings.get(device.deviceId);
     if (!mapping) {
-      logWarning(`Device ${device.deviceId} was not tracked`);
+      logWarning2(`Device ${device.deviceId} was not tracked`);
       return;
     }
     if (mapping.busId) {
@@ -328,7 +437,7 @@ var InstanceManager = class extends import_node_events.EventEmitter {
     }
     const instance = this.instances.get(mapping.instanceId);
     if (!instance) {
-      logWarning(`Instance ${mapping.instanceId} not found`);
+      logWarning2(`Instance ${mapping.instanceId} not found`);
       this.deviceMappings.delete(device.deviceId);
       return;
     }
@@ -383,7 +492,7 @@ var InstanceManager = class extends import_node_events.EventEmitter {
       this.config.usbmuxdPath,
       ...usbmuxdArgs
     ];
-    const process2 = (0, import_node_child_process.spawn)("wsl", wslArgs, {
+    const process2 = (0, import_node_child_process2.spawn)("wsl", wslArgs, {
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: false
       // Show console for debugging
@@ -505,7 +614,7 @@ var InstanceManager = class extends import_node_events.EventEmitter {
 };
 
 // src/UsbmuxdService.ts
-var { logInfo: logInfo2, logError } = (0, import_tool_debug_g42.createLoggers)("usbmuxd-instance-manager");
+var { logInfo: logInfo3, logError } = (0, import_tool_debug_g43.createLoggers)("usbmuxd-instance-manager");
 var UsbmuxdService = class extends import_node_events2.EventEmitter {
   manager;
   usbListener;
@@ -564,17 +673,17 @@ var UsbmuxdService = class extends import_node_events2.EventEmitter {
     }
     const config2 = this.manager.getConfig();
     const appleVid = Number.parseInt(config2.appleVendorId, 16);
-    logInfo2("Starting service...");
-    logInfo2(`Batch size: ${config2.batchSize} devices per instance`);
-    logInfo2(`Base port: ${config2.basePort}`);
-    logInfo2(`Max instances: ${config2.maxInstances}`);
-    logInfo2(`usbmuxd path: ${config2.usbmuxdPath}`);
-    logInfo2(`Monitoring Apple devices (VID: ${config2.appleVendorId})`);
+    logInfo3("Starting service...");
+    logInfo3(`Batch size: ${config2.batchSize} devices per instance`);
+    logInfo3(`Base port: ${config2.basePort}`);
+    logInfo3(`Max instances: ${config2.maxInstances}`);
+    logInfo3(`usbmuxd path: ${config2.usbmuxdPath}`);
+    logInfo3(`Monitoring Apple devices (VID: ${config2.appleVendorId})`);
     this.usbListener.onDeviceAdd(async (device) => {
       if (device.vid !== appleVid) {
         return;
       }
-      logInfo2(`Apple device connected: ${device.deviceId} (${device.deviceName || "Unknown"})`);
+      logInfo3(`Apple device connected: ${device.deviceId} (${device.deviceName || "Unknown"})`);
       try {
         await this.manager.onDeviceConnected(device);
       } catch (error) {
@@ -585,7 +694,7 @@ var UsbmuxdService = class extends import_node_events2.EventEmitter {
       if (device.vid !== appleVid) {
         return;
       }
-      logInfo2(`Apple device disconnected: ${device.deviceId}`);
+      logInfo3(`Apple device disconnected: ${device.deviceId}`);
       try {
         await this.manager.onDeviceDisconnected(device);
       } catch (error) {
@@ -599,8 +708,8 @@ var UsbmuxdService = class extends import_node_events2.EventEmitter {
       });
       this.isListening = true;
       this.manager.start();
-      logInfo2("Service started successfully");
-      logInfo2("Waiting for iOS devices...");
+      logInfo3("Service started successfully");
+      logInfo3("Waiting for iOS devices...");
     } catch (error) {
       logError("Failed to start USB listener:", error);
       throw error;
@@ -614,11 +723,11 @@ var UsbmuxdService = class extends import_node_events2.EventEmitter {
     if (!this.isListening) {
       return;
     }
-    logInfo2("Stopping service...");
+    logInfo3("Stopping service...");
     this.usbListener.stopListening();
     this.isListening = false;
     await this.manager.stop();
-    logInfo2("Service stopped");
+    logInfo3("Service stopped");
   }
   /**
    * Get device port mapping
@@ -665,7 +774,7 @@ var UsbmuxdService = class extends import_node_events2.EventEmitter {
 };
 
 // src/cli.ts
-var { logInfo: logInfo3, logError: logError2, logHeader, logDataObject } = (0, import_tool_debug_g43.createLoggers)("usbmuxd-cli");
+var { logInfo: logInfo4, logError: logError2, logHeader, logDataObject } = (0, import_tool_debug_g44.createLoggers)("usbmuxd-cli");
 var args = process.argv.slice(2);
 var options = {};
 for (let i = 0; i < args.length; i++) {
@@ -682,7 +791,7 @@ var config = {
   batchSize: options.batchSize ? Number.parseInt(options.batchSize, 10) : 4,
   basePort: options.basePort ? Number.parseInt(options.basePort, 10) : 27015,
   maxInstances: options.maxInstances ? Number.parseInt(options.maxInstances, 10) : 20,
-  usbmuxdPath: options.usbmuxdPath || "C:\\Program Files\\usbmuxd-win-mce\\usbmuxd.exe",
+  usbmuxdPath: options.usbmuxdPath || "usbmuxd",
   verboseLogging: options.verbose !== "false",
   appleVendorId: options.appleVid || "05AC"
 };
@@ -690,11 +799,11 @@ logHeader("usbmuxd Instance Manager");
 logDataObject("Multi-instance manager for iOS device connections", { config });
 var service = new UsbmuxdService(config);
 process.on("SIGINT", async () => {
-  logInfo3("");
-  logInfo3("Received SIGINT, shutting down gracefully...");
+  logInfo4("");
+  logInfo4("Received SIGINT, shutting down gracefully...");
   try {
     await service.stop();
-    logInfo3("Shutdown complete");
+    logInfo4("Shutdown complete");
     process.exit(0);
   } catch (error) {
     logError2("Error during shutdown:", error);
@@ -702,11 +811,11 @@ process.on("SIGINT", async () => {
   }
 });
 process.on("SIGTERM", async () => {
-  logInfo3("");
-  logInfo3("Received SIGTERM, shutting down gracefully...");
+  logInfo4("");
+  logInfo4("Received SIGTERM, shutting down gracefully...");
   try {
     await service.stop();
-    logInfo3("Shutdown complete");
+    logInfo4("Shutdown complete");
     process.exit(0);
   } catch (error) {
     logError2("Error during shutdown:", error);
@@ -724,21 +833,21 @@ setInterval(() => {
   }
 }, 3e4);
 if (args.includes("--help") || args.includes("-h")) {
-  logInfo3("Usage: usbmuxd-instance-manager [OPTIONS]");
-  logInfo3("");
-  logInfo3("Options:");
-  logInfo3("  --batchSize <n>        Number of devices per instance (default: 4)");
-  logInfo3("  --basePort <port>      Base TCP port for first instance (default: 27015)");
-  logInfo3("  --maxInstances <n>     Maximum number of instances (default: 20)");
-  logInfo3("  --usbmuxdPath <path>   Path to usbmuxd executable");
-  logInfo3("  --verbose <true|false> Enable verbose logging (default: true)");
-  logInfo3("  --appleVid <vid>       Apple Vendor ID in hex (default: 05AC)");
-  logInfo3("  -h, --help             Show this help message");
-  logInfo3("");
-  logInfo3("Examples:");
-  logInfo3("  usbmuxd-instance-manager");
-  logInfo3("  usbmuxd-instance-manager --batchSize 6 --basePort 27020");
-  logInfo3("");
+  logInfo4("Usage: usbmuxd-instance-manager [OPTIONS]");
+  logInfo4("");
+  logInfo4("Options:");
+  logInfo4("  --batchSize <n>        Number of devices per instance (default: 4)");
+  logInfo4("  --basePort <port>      Base TCP port for first instance (default: 27015)");
+  logInfo4("  --maxInstances <n>     Maximum number of instances (default: 20)");
+  logInfo4("  --usbmuxdPath <path>   Path to usbmuxd executable");
+  logInfo4("  --verbose <true|false> Enable verbose logging (default: true)");
+  logInfo4("  --appleVid <vid>       Apple Vendor ID in hex (default: 05AC)");
+  logInfo4("  -h, --help             Show this help message");
+  logInfo4("");
+  logInfo4("Examples:");
+  logInfo4("  usbmuxd-instance-manager");
+  logInfo4("  usbmuxd-instance-manager --batchSize 6 --basePort 27020");
+  logInfo4("");
   process.exit(0);
 }
 try {