@mcesystems/usbmuxd-instance-manager 1.0.72 → 1.0.74

package/dist/index.js

@@ -37,138 +37,114 @@ module.exports = __toCommonJS(index_exports);
 
 // src/UsbmuxdService.ts
 var import_node_events2 = require("node:events");
-var import_tool_debug_g42 = require("@mcesystems/tool-debug-g4");
+var import_tool_debug_g44 = 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_events = require("node:events");
+var import_tool_debug_g43 = require("@mcesystems/tool-debug-g4");
+
+// src/usbipd.ts
+var import_node_child_process = require("node:child_process");
 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 { logInfo, logWarning } = (0, import_tool_debug_g4.createLoggers)("usbipd");
 var execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
-var USBIPD_PATH = '"C:\\Program Files\\usbipd-win\\usbipd.exe"';
-function parseUsbipdList(output) {
-  const devices = [];
-  const lines = output.split(/\r?\n/);
-  for (const line of lines) {
-    const match = line.match(/^(\d+-\d+)\s+([0-9a-f]{4}):([0-9a-f]{4})\s+(.+)$/i);
-    if (match) {
-      const rest = match[4].trim();
-      const stateMatch = rest.match(/^(.+?)\s{2,}(\S.*)$/);
-      const description = stateMatch ? stateMatch[1].trim() : rest;
-      const state = stateMatch ? stateMatch[2].trim() : "Unknown";
-      devices.push({
-        busId: match[1],
-        vid: match[2].toUpperCase(),
-        pid: match[3].toUpperCase(),
-        description,
-        state
-      });
+var Usbipd = class {
+  constructor(usbipdPath) {
+    this.usbipdPath = usbipdPath;
+  }
+  async unbindAllDevicesFromWsl() {
+    try {
+      await execAsync(`"${this.usbipdPath}" unbind -a`);
+      logInfo("All devices unbound from WSL");
+    } catch (error) {
+      logWarning(`Failed to unbind all devices from WSL: ${error}`);
     }
   }
-  return devices;
-}
-var DEFAULT_CONFIG = {
-  batchSize: 4,
-  basePort: 27015,
-  maxInstances: 20,
-  usbmuxdPath: "usbmuxd",
-  // Path inside WSL2
-  wslDistribution: "alpine-usbmuxd-build",
-  // Alpine WSL2 distribution name
-  verboseLogging: true,
-  appleVendorId: "05AC"
-};
-var InstanceManager = class extends import_node_events.EventEmitter {
-  config;
-  instances = /* @__PURE__ */ new Map();
-  deviceMappings = /* @__PURE__ */ new Map();
-  processes = /* @__PURE__ */ new Map();
-  nextInstanceId = 1;
-  startedAt = null;
-  isRunning = false;
-  /** Tracks which devices have been attached to WSL */
-  attachedDevices = /* @__PURE__ */ new Set();
-  /** Cached WSL IP address for connecting from Windows */
-  wslIpAddress = null;
-  constructor(config = {}) {
-    super();
-    this.config = { ...DEFAULT_CONFIG, ...config };
+  async detachAllDevicesFromWsl() {
+    try {
+      await execAsync(`"${this.usbipdPath}" detach -a`);
+      logInfo("All devices detached from WSL");
+    } catch (error) {
+      logWarning(`Failed to detach all devices from WSL: ${error}`);
+    }
   }
   /**
-   * Detect the WSL2 IP address for the configured distribution
-   * This IP is needed to connect from Windows to services inside WSL
+   * Detach a device from WSL via usbipd
    */
-  async detectWslIpAddress() {
-    if (this.wslIpAddress) {
-      return this.wslIpAddress;
-    }
-    const distro = this.config.wslDistribution || "alpine-usbmuxd-build";
+  async detachDeviceFromWsl(busId) {
     try {
-      const { stdout } = await execAsync(`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}`);
-        return this.wslIpAddress;
-      }
+      await execAsync(`"${this.usbipdPath}" detach --busid=${busId}`);
+      logInfo(`Device ${busId} detached from WSL`);
     } catch (error) {
-      logWarning(`Failed to detect WSL IP via ip addr: ${error}`);
-    }
-    try {
-      const { stdout } = await execAsync(`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}`);
-        return this.wslIpAddress;
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("no device with busid") || message.includes("There is no device")) {
+        logInfo(`Device ${busId} already detached`);
+      } else {
+        logWarning(`Failed to detach device ${busId}: ${error}`);
       }
-    } catch (error) {
-      logWarning(`Failed to detect WSL IP via hostname: ${error}`);
     }
-    logWarning("Could not detect WSL IP, falling back to localhost");
-    this.wslIpAddress = "127.0.0.1";
-    return this.wslIpAddress;
   }
   /**
-   * Start the instance manager
+   * Attach a device to WSL via usbipd
+   * Note: This requires administrator privileges
    */
-  start() {
-    if (this.isRunning) {
-      throw new Error("Instance manager is already running");
+  async attachDeviceToWsl(busId, wsl, distro) {
+    try {
+      await wsl.ensureWslRunning();
+      logInfo(`Binding device ${busId}...`);
+      await execAsync(`"${this.usbipdPath}" bind --busid ${busId} --force`);
+      if (distro) {
+        logInfo(`Attaching device ${busId} to WSL distribution ${distro}...`);
+        await execAsync(`"${this.usbipdPath}" attach --wsl=${distro} --busid=${busId}`);
+      } else {
+        logInfo(`Attaching device ${busId} to default WSL...`);
+        await execAsync(`"${this.usbipdPath}" attach --wsl --busid=${busId}`);
+      }
+      logInfo(`Device ${busId} attached to WSL successfully`);
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("already attached to a client")) {
+        logInfo(`Device ${busId} is already attached to WSL, continuing`);
+        return true;
+      }
+      logWarning(`Failed to attach device ${busId} to WSL: ${error}`);
+      return false;
     }
-    this.isRunning = true;
-    this.startedAt = /* @__PURE__ */ new Date();
-    this.emit("started");
   }
   /**
-   * Stop the instance manager and all instances
+   * Parse usbipd list output to extract device information
    */
-  async stop() {
-    if (!this.isRunning) {
-      return;
+  parseUsbipdList(output) {
+    const devices = [];
+    const lines = output.split(/\r?\n/);
+    for (const line of lines) {
+      const match = line.match(/^(\d+-\d+)\s+([0-9a-f]{4}):([0-9a-f]{4})\s+(.+)$/i);
+      if (match) {
+        const rest = match[4].trim();
+        const stateMatch = rest.match(/^(.+?)\s{2,}(\S.*)$/);
+        const description = stateMatch ? stateMatch[1].trim() : rest;
+        const state = stateMatch ? stateMatch[2].trim() : "Unknown";
+        devices.push({
+          busId: match[1],
+          vid: match[2].toUpperCase(),
+          pid: match[3].toUpperCase(),
+          description,
+          state
+        });
+      }
     }
-    this.isRunning = false;
-    const detachPromises = Array.from(this.attachedDevices).map(
-      (busId) => this.detachDeviceFromWsl(busId)
-    );
-    await Promise.all(detachPromises);
-    this.attachedDevices.clear();
-    const stopPromises = Array.from(this.instances.keys()).map((id) => this.stopInstance(id));
-    await Promise.all(stopPromises);
-    this.instances.clear();
-    this.deviceMappings.clear();
-    this.processes.clear();
-    this.emit("stopped");
+    return devices;
   }
   /**
    * Find the usbipd bus ID for a device by matching VID/PID
    */
   async findBusIdForDevice(device) {
     try {
-      const { stdout } = await execAsync(`${USBIPD_PATH} list`);
-      const usbipdDevices = parseUsbipdList(stdout);
+      const { stdout } = await execAsync(`"${this.usbipdPath}" list`);
+      const usbipdDevices = this.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}`);
@@ -180,100 +156,474 @@ var InstanceManager = class extends import_node_events.EventEmitter {
         );
         return match.busId;
       }
-      for (const d of usbipdDevices) {
-        logInfo(`  usbipd device: ${d.busId} ${d.vid}:${d.pid} "${d.description}"`);
-      }
-      logWarning(
+      throw new Error(
         `Could not find usbipd bus ID for device ${device.deviceId} (${deviceVid}:${devicePid})`
       );
-      return null;
     } catch (error) {
-      logWarning(`Failed to run usbipd list: ${error}`);
-      return null;
+      throw new Error(`Failed to run usbipd list: ${error}`);
+    }
+  }
+};
+
+// src/wsl.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_node_util2 = require("node:util");
+var import_tool_debug_g42 = require("@mcesystems/tool-debug-g4");
+var { logInfo: logInfo2, logWarning: logWarning2, logDetail } = (0, import_tool_debug_g42.createLoggers)("wsl");
+var execAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.exec);
+var Wsl2 = class {
+  constructor(wslDistribution) {
+    this.wslDistribution = wslDistribution;
+  }
+  ALPINE_LOCKDOWN_DIR = "/var/lib/lockdown";
+  SYSTEM_CONFIG_PLIST = "SystemConfiguration.plist";
+  wslIpAddress = null;
+  /**
+   * Detect the WSL2 IP address for the configured distribution
+   * This IP is needed to connect from Windows to services inside WSL
+   */
+  async detectWslIpAddress() {
+    if (this.wslIpAddress) {
+      return this.wslIpAddress;
+    }
+    const distro = this.wslDistribution || "alpine-usbmuxd-build";
+    try {
+      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];
+        logInfo2(`Detected WSL IP address: ${this.wslIpAddress}`);
+        return this.wslIpAddress;
+      }
+    } catch (error) {
+      logWarning2(`Failed to detect WSL IP via ip addr: ${error}`);
+    }
+    try {
+      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;
+        logInfo2(`Detected WSL IP address (hostname): ${this.wslIpAddress}`);
+        return this.wslIpAddress;
+      }
+    } catch (error) {
+      logWarning2(`Failed to detect WSL IP via hostname: ${error}`);
     }
+    logWarning2("Could not detect WSL IP, falling back to localhost");
+    this.wslIpAddress = "127.0.0.1";
+    return this.wslIpAddress;
   }
   /**
    * Ensure the WSL distribution is running
    */
   async ensureWslRunning() {
-    const distro = this.config.wslDistribution;
+    const distro = this.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;
     }
   }
   /**
-   * Attach a device to WSL via usbipd
-   * Note: This requires administrator privileges
+   * Create a new usbmuxd instance
    */
-  async attachDeviceToWsl(busId) {
-    const distro = this.config.wslDistribution;
+  async createInstance({
+    id,
+    basePort,
+    verboseLogging,
+    usbmuxdPath,
+    onLog,
+    onExit
+  }) {
+    const port = basePort + id - 1;
+    logInfo2(`Creating instance ${id} on port ${port}`);
+    const host = await this.detectWslIpAddress();
+    const usbmuxdArgs = [
+      "-f",
+      // Foreground
+      "-v",
+      // Verbose (if enabled)
+      "-S",
+      `0.0.0.0:${port}`,
+      // Listen on all interfaces (for Windows → WSL2)
+      "--pidfile",
+      "NONE"
+    ];
+    if (!verboseLogging) {
+      usbmuxdArgs.splice(1, 1);
+    }
+    const wslArgs = [
+      "-d",
+      this.wslDistribution || "alpine-usbmuxd-build",
+      usbmuxdPath,
+      ...usbmuxdArgs
+    ];
+    const process2 = (0, import_node_child_process2.spawn)("wsl", wslArgs, {
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: true,
+      windowsHide: false
+    });
+    process2.stdout?.on("data", (data) => {
+      onLog(data.toString().trim());
+    });
+    process2.stderr?.on("data", (data) => {
+      onLog(data.toString().trim());
+    });
+    process2.on("exit", onExit);
+    const pid = process2.pid;
+    if (pid === void 0) {
+      process2.kill("SIGKILL");
+      throw new Error("Failed to get PID for usbmuxd instance");
+    }
+    const instance = {
+      id,
+      host,
+      port,
+      pid,
+      deviceUdids: [],
+      startedAt: /* @__PURE__ */ new Date()
+    };
+    return { instance, process: process2 };
+  }
+  /**
+   * Convert a Windows path to the equivalent path inside WSL (e.g. C:\foo\bar -> /mnt/c/foo/bar).
+   */
+  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;
+  }
+  /**
+   * Get the native Apple lockdown directory path for the current platform.
+   * This is where Apple/iTunes stores pairing records natively.
+   */
+  getAppleLockdownPath() {
+    if (process.platform === "win32") {
+      return (0, import_node_path.join)(process.env.ProgramData ?? "C:\\ProgramData", "Apple", "Lockdown");
+    }
+    if (process.platform === "darwin") {
+      return "/var/db/lockdown";
+    }
+    if (process.platform === "linux") {
+      return "/var/lib/lockdown";
+    }
+    return null;
+  }
+  /**
+   * Copy a single device's lockdown plist from the native Apple lockdown directory
+   * to Alpine so usbmuxd can use it (skip pairing).
+   *
+   * Uses the platform-specific Apple/iTunes lockdown directory
+   * (e.g. C:\ProgramData\Apple\Lockdown on Windows, /var/db/lockdown on macOS).
+   *
+   * No-op if the lockdown directory cannot be determined or files don't exist.
+   */
+  async syncToAlpine(udid) {
+    const lockdownDir = this.getAppleLockdownPath();
+    if (!lockdownDir) {
+      logWarning2("Lockdown sync to Alpine: unsupported platform, skipping");
+      return;
+    }
+    logDetail(`Lockdown sync to Alpine: source dir = ${lockdownDir}, udid = ${udid}`);
+    const distro = this.wslDistribution || "alpine-usbmuxd-build";
+    const wslDestDir = this.ALPINE_LOCKDOWN_DIR;
+    const devicePlistFile = `${udid}.plist`;
+    const devicePlistPath = (0, import_node_path.join)(lockdownDir, devicePlistFile);
+    if ((0, import_node_fs.existsSync)(devicePlistPath)) {
+      await this.copyFileToAlpine(
+        this.windowsPathToWsl(devicePlistPath),
+        wslDestDir,
+        distro,
+        devicePlistFile
+      );
+    } else {
+      logDetail(
+        `Lockdown sync to Alpine: ${devicePlistFile} not found at ${devicePlistPath}, skipping`
+      );
+    }
+    const systemConfigPath = (0, import_node_path.join)(lockdownDir, this.SYSTEM_CONFIG_PLIST);
+    if ((0, import_node_fs.existsSync)(systemConfigPath)) {
+      await this.copyFileToAlpine(
+        this.windowsPathToWsl(systemConfigPath),
+        wslDestDir,
+        distro,
+        this.SYSTEM_CONFIG_PLIST
+      );
+    } else {
+      logDetail(
+        `Lockdown sync to Alpine: ${this.SYSTEM_CONFIG_PLIST} not found at ${systemConfigPath}, skipping`
+      );
+    }
+  }
+  /**
+   * Copy a single file into the Alpine lockdown directory.
+   * Falls back to sudo if the initial copy fails.
+   */
+  async copyFileToAlpine(wslSource, wslDestDir, distro, fileName) {
     try {
-      await this.ensureWslRunning();
-      logInfo(`Binding device ${busId}...`);
-      await execAsync(`${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}`);
-      } else {
-        logInfo(`Attaching device ${busId} to default WSL...`);
-        await execAsync(`${USBIPD_PATH} attach --wsl --busid=${busId}`);
-      }
-      logInfo(`Device ${busId} attached to WSL successfully`);
-      return true;
+      await execAsync2(
+        `wsl -d ${distro} -- sh -c "mkdir -p ${wslDestDir} && cp '${wslSource}' '${wslDestDir}/'"`
+      );
+      logInfo2(`Lockdown sync: copied ${fileName} to Alpine`);
     } catch (error) {
-      logWarning(`Failed to attach device ${busId} to WSL: ${error}`);
-      return false;
+      try {
+        await execAsync2(
+          `wsl -d ${distro} -- sh -c "mkdir -p ${wslDestDir} && sudo cp '${wslSource}' '${wslDestDir}/'"`
+        );
+        logInfo2(`Lockdown sync: copied ${fileName} to Alpine (via sudo)`);
+      } catch (sudoError) {
+        logWarning2(
+          `Lockdown sync to Alpine failed for ${fileName}: ${error}. Sudo fallback failed: ${sudoError}. Ensure /var/lib/lockdown is writable or use passwordless sudo.`
+        );
+      }
     }
   }
   /**
-   * Detach a device from WSL via usbipd
+   * Copy lockdown plists from Alpine back to the native Apple lockdown directory
+   * (for devices that were assigned this session).
+   * Also copies SystemConfiguration.plist if present in Alpine.
+   *
+   * No-op if the lockdown directory cannot be determined.
    */
-  async detachDeviceFromWsl(busId) {
+  async syncFromAlpine(udids) {
+    logInfo2(`Lockdown sync from Alpine: starting (${udids.length} device(s))`);
+    const lockdownDir = this.getAppleLockdownPath();
+    if (!lockdownDir) {
+      logWarning2("Lockdown sync: unsupported platform, skipping");
+      return;
+    }
+    logDetail(`Lockdown sync: target dir = ${lockdownDir}`);
     try {
-      await execAsync(`${USBIPD_PATH} detach --busid=${busId}`);
-      logInfo(`Device ${busId} detached from WSL`);
+      (0, import_node_fs.mkdirSync)(lockdownDir, { recursive: true });
+    } catch (error) {
+      logWarning2(`Lockdown sync: could not create lockdown dir ${lockdownDir}: ${error}`);
+      return;
+    }
+    const distro = this.wslDistribution || "alpine-usbmuxd-build";
+    const wslDestDir = this.windowsPathToWsl(lockdownDir);
+    try {
+      const { stdout } = await execAsync2(`wsl -d ${distro} -- ls -la ${this.ALPINE_LOCKDOWN_DIR}/`);
+      logDetail(`Lockdown sync: Alpine ${this.ALPINE_LOCKDOWN_DIR} contents:
+${stdout}`);
     } catch (error) {
-      logWarning(`Failed to detach device ${busId}: ${error}`);
+      logWarning2(`Lockdown sync: could not list Alpine lockdown dir: ${error}`);
+    }
+    const filesToSync = [...udids.map((udid) => `${udid}.plist`), this.SYSTEM_CONFIG_PLIST];
+    logDetail(`Lockdown sync: files to sync = [${filesToSync.join(", ")}]`);
+    for (const fileName of filesToSync) {
+      await this.copyFileFromAlpine(fileName, wslDestDir, distro, lockdownDir);
     }
+    logInfo2("Lockdown sync from Alpine: done");
   }
   /**
-   * Handle device connection
-   * Attaches device to WSL, then assigns to an existing instance or creates a new one
+   * Copy a single file from the Alpine lockdown directory back to Windows.
+   * Skips if the file does not exist in Alpine; logs a warning if the copy fails.
    */
-  async onDeviceConnected(device) {
-    if (this.deviceMappings.has(device.deviceId)) {
-      logWarning(`Device ${device.deviceId} is already connected`);
+  async copyFileFromAlpine(fileName, wslDestDir, distro, lockdownDir) {
+    const alpinePath = `${this.ALPINE_LOCKDOWN_DIR}/${fileName}`;
+    try {
+      await execAsync2(`wsl -d ${distro} -- test -f '${alpinePath}'`);
+    } catch {
+      logDetail(`Lockdown sync: ${fileName} not found in Alpine (${alpinePath}), skipping`);
       return;
     }
-    const busId = await this.findBusIdForDevice(device);
-    if (!busId) {
-      logWarning(`Cannot attach device ${device.deviceId} - bus ID not found`);
+    logDetail(`Lockdown sync: copying ${fileName} \u2192 ${wslDestDir}/`);
+    try {
+      await execAsync2(`wsl -d ${distro} -- cp -f '${alpinePath}' '${wslDestDir}/'`);
+      logInfo2(`Lockdown sync: copied ${fileName} from Alpine to ${lockdownDir}`);
+    } catch (error) {
+      logWarning2(`Lockdown sync: failed to copy ${fileName} from Alpine to ${lockdownDir}: ${error}`);
     }
-    if (busId && !this.attachedDevices.has(busId)) {
-      const attached = await this.attachDeviceToWsl(busId);
+  }
+};
+
+// src/InstanceManager.ts
+var { logWarning: logWarning3, logDetail: logDetail2, logDataObject, logTask } = (0, import_tool_debug_g43.createLoggers)("instance-manager");
+var DEFAULT_CONFIG = {
+  batchSize: 4,
+  basePort: 27015,
+  maxInstances: 5,
+  usbmuxdPath: "usbmuxd",
+  // Path inside WSL2
+  wslDistribution: "alpine-usbmuxd-build",
+  // Alpine WSL2 distribution name
+  verboseLogging: true,
+  appleVendorId: "05AC"
+};
+var InstanceManager = class extends import_node_events.EventEmitter {
+  /** Map of usbmuxd instance IDs to instances */
+  instances = /* @__PURE__ */ new Map();
+  /** Map of device IDs to device mappings host:port */
+  deviceMappings = /* @__PURE__ */ new Map();
+  /** Map of usbmuxd instance IDs to child processes running it on wsl2*/
+  processes = /* @__PURE__ */ new Map();
+  /** 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();
+  config;
+  nextInstanceId = 1;
+  startedAt = null;
+  isRunning = false;
+  wsl;
+  usbipd;
+  constructor(config = {}) {
+    super();
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.wsl = new Wsl2(this.config.wslDistribution);
+    this.usbipd = new Usbipd(process.env.USBIPD_PATH ?? "usbipd");
+  }
+  /**
+   * Start the instance manager
+   */
+  start() {
+    if (this.isRunning) {
+      throw new Error("Instance manager is already running");
+    }
+    this.isRunning = true;
+    this.startedAt = /* @__PURE__ */ new Date();
+  }
+  /**
+   * Stop the instance manager and all instances
+   */
+  async stop() {
+    if (!this.isRunning) {
+      return;
+    }
+    this.isRunning = false;
+    const udids = Array.from(this.deviceMappings.keys());
+    await this.wsl.syncFromAlpine(udids);
+    await this.usbipd.detachAllDevicesFromWsl();
+    await this.usbipd.unbindAllDevicesFromWsl();
+    this.attachedDevices.clear();
+    const stopPromises = Array.from(this.instances.keys()).map((id) => this.stopInstance(id));
+    await Promise.all(stopPromises);
+    this.instances.clear();
+    this.deviceMappings.clear();
+    this.processes.clear();
+  }
+  async attachToWsl({
+    busId,
+    deviceId
+  }) {
+    if (!this.attachedDevices.has(busId)) {
+      this.pendingAttachDevices.add(deviceId);
+      if (!this.config.wslDistribution) {
+        throw new Error("WSL distribution not configured");
+      }
+      const attached = await this.usbipd.attachDeviceToWsl(
+        busId,
+        this.wsl,
+        this.config.wslDistribution
+      );
       if (attached) {
         this.attachedDevices.add(busId);
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
       }
     }
+  }
+  async removeDevice(mapping) {
+    const instance = await this.detachFromWsl({ deviceId: mapping.udid });
+    if (!instance) {
+      throw new Error(`Instance ${mapping.instanceId} not found`);
+    }
+    if (mapping.busId) {
+      await this.usbipd.detachDeviceFromWsl(mapping.busId);
+      this.attachedDevices.delete(mapping.busId);
+    }
+    const deviceIndex = instance.deviceUdids.indexOf(mapping.udid);
+    if (deviceIndex > -1) {
+      instance.deviceUdids.splice(deviceIndex, 1);
+    }
+    this.deviceMappings.delete(mapping.udid);
+    return instance;
+  }
+  async onUsbmuxdInstanceEnd({
+    instanceId,
+    code,
+    signal
+  }) {
+    this.emit("instance-exited", {
+      instanceId,
+      code,
+      signal
+    });
+    for (const [_, mapping] of this.deviceMappings.entries()) {
+      if (mapping.instanceId === instanceId) {
+        this.removeDevice(mapping);
+      }
+    }
+    this.instances.delete(instanceId);
+    this.processes.get(instanceId)?.kill();
+    this.processes.delete(instanceId);
+  }
+  async onUsbmuxdInstanceStart({
+    instance,
+    process: process2
+  }) {
+    this.instances.set(instance.id, instance);
+    this.processes.set(instance.id, process2);
+    this.emit("instance-started", {
+      instanceId: instance.id
+    });
+  }
+  async getInstance() {
     let targetInstance = this.findInstanceWithCapacity();
     if (!targetInstance) {
       if (this.instances.size >= this.config.maxInstances) {
         throw new Error(`Maximum number of instances (${this.config.maxInstances}) reached`);
       }
-      targetInstance = await this.createInstance();
+      const newInstanceId = this.nextInstanceId++;
+      let onExit = (code, signal) => {
+        this.onUsbmuxdInstanceEnd({ instanceId: newInstanceId, code, signal });
+      };
+      onExit = onExit.bind(this);
+      const { instance, process: process2 } = await this.wsl.createInstance({
+        id: newInstanceId,
+        basePort: this.config.basePort,
+        verboseLogging: this.config.verboseLogging,
+        usbmuxdPath: this.config.usbmuxdPath,
+        onLog: (message) => this.emit("instance-log", {
+          instanceId: newInstanceId,
+          level: "info",
+          message
+        }),
+        onExit
+      });
+      this.onUsbmuxdInstanceStart({ instance, process: process2 });
+      targetInstance = instance;
     }
-    targetInstance.deviceUdids.push(device.deviceId);
+    return targetInstance;
+  }
+  /**
+   * Handle device connection only for not attached devices
+   * Attaches device to WSL, then assigns to an existing instance or creates a new one
+   */
+  async onDeviceConnected(device) {
+    const busId = await this.usbipd.findBusIdForDevice(device);
+    if (this.attachedDevices.has(busId)) {
+      logTask(`Device ${device.deviceId} is already attached. skipping onDeviceConnected...`);
+      return;
+    }
+    logDataObject("Device connected", { device });
+    await this.wsl.syncToAlpine(device.deviceId);
+    await this.attachToWsl({ busId, deviceId: device.deviceId });
+    const targetInstance = await this.getInstance();
     const mapping = {
       udid: device.deviceId,
       instanceId: targetInstance.id,
@@ -283,74 +633,52 @@ var InstanceManager = class extends import_node_events.EventEmitter {
       busId: busId ?? void 0
     };
     this.deviceMappings.set(device.deviceId, mapping);
+    targetInstance.deviceUdids.push(device.deviceId);
     this.emit("device-assigned", {
       device,
       instance: targetInstance,
       mapping
     });
+    this.pendingAttachDevices.delete(device.deviceId);
   }
-  /**
-   * Pair a device with the usbmuxd host.
-   * This is required once per device before most commands will work.
-   * The pairing record is stored in WSL and persists across restarts.
-   *
-   * @param udid Device UDID to pair
-   * @param goIosPath Optional path to go-ios binary (defaults to "ios")
-   * @returns true if pairing succeeded, false otherwise
-   */
-  async pairDevice(udid, goIosPath = "ios") {
-    const mapping = this.deviceMappings.get(udid);
+  async detachFromWsl({ deviceId }) {
+    const mapping = this.deviceMappings.get(deviceId);
     if (!mapping) {
-      logWarning(`Cannot pair device ${udid} - not found in mappings`);
-      return false;
+      throw new Error(`Device ${deviceId} was not tracked`);
     }
-    try {
-      const socketAddress = `${mapping.host}:${mapping.port}`;
-      logInfo(`Pairing device ${udid} via ${socketAddress}...`);
-      const { stderr } = await execAsync(`"${goIosPath}" pair --udid=${udid}`, {
-        env: { ...process.env, USBMUXD_SOCKET_ADDRESS: socketAddress }
-      });
-      if (stderr?.includes("error")) {
-        logWarning(`Pairing warning for ${udid}: ${stderr}`);
-      }
-      logInfo(`Device ${udid} paired successfully`);
-      this.emit("device-paired", { udid, mapping });
-      return true;
-    } catch (error) {
-      logWarning(`Failed to pair device ${udid}: ${error}`);
-      return false;
+    if (mapping.busId) {
+      await this.usbipd.detachDeviceFromWsl(mapping.busId);
+      this.attachedDevices.delete(mapping.busId);
+    }
+    const instance = this.instances.get(mapping.instanceId);
+    if (!instance) {
+      logWarning3(`Instance ${mapping.instanceId} not found`);
+      this.deviceMappings.delete(deviceId);
+      throw new Error(`Instance ${mapping.instanceId} not found`);
     }
+    return instance;
   }
   /**
-   * Handle device disconnection
+   * Handle device disconnection only for attached devices
    * Detaches from WSL, removes device from instance, and stops instance if empty
    */
   async onDeviceDisconnected(device) {
-    const mapping = this.deviceMappings.get(device.deviceId);
-    if (!mapping) {
-      logWarning(`Device ${device.deviceId} was not tracked`);
+    if (!this.attachedDevices.has(device.deviceId)) {
+      logTask(`Device ${device.deviceId} is not attached. skipping onDeviceDisconnected...`);
       return;
     }
-    if (mapping.busId) {
-      await this.detachDeviceFromWsl(mapping.busId);
-      this.attachedDevices.delete(mapping.busId);
-    }
-    const instance = this.instances.get(mapping.instanceId);
-    if (!instance) {
-      logWarning(`Instance ${mapping.instanceId} not found`);
-      this.deviceMappings.delete(device.deviceId);
-      return;
-    }
-    const deviceIndex = instance.deviceUdids.indexOf(device.deviceId);
-    if (deviceIndex > -1) {
-      instance.deviceUdids.splice(deviceIndex, 1);
+    logDataObject("Device disconnected", { device });
+    const mapping = this.deviceMappings.get(device.deviceId);
+    if (!mapping) {
+      throw new Error(`Device ${device.deviceId} was not tracked`);
     }
-    this.deviceMappings.delete(device.deviceId);
+    const instance = await this.removeDevice(mapping);
     this.emit("device-removed", {
       device,
       instance
     });
     if (instance.deviceUdids.length === 0) {
+      logDetail2(`Instance ${instance.id} is empty, stopping...`);
       await this.stopInstance(instance.id);
     }
   }
@@ -365,104 +693,18 @@ var InstanceManager = class extends import_node_events.EventEmitter {
     }
     return null;
   }
-  /**
-   * Create a new usbmuxd instance
-   */
-  async createInstance() {
-    const instanceId = this.nextInstanceId++;
-    const port = this.config.basePort + instanceId - 1;
-    const host = await this.detectWslIpAddress();
-    const usbmuxdArgs = [
-      "-f",
-      // Foreground
-      "-v",
-      // Verbose (if enabled)
-      "-S",
-      `0.0.0.0:${port}`,
-      // Listen on all interfaces (for Windows → WSL2)
-      "--pidfile",
-      "NONE"
-    ];
-    if (!this.config.verboseLogging) {
-      usbmuxdArgs.splice(1, 1);
-    }
-    const wslArgs = [
-      "-d",
-      this.config.wslDistribution || "alpine-usbmuxd-build",
-      this.config.usbmuxdPath,
-      ...usbmuxdArgs
-    ];
-    const process2 = (0, import_node_child_process.spawn)("wsl", wslArgs, {
-      stdio: ["ignore", "pipe", "pipe"],
-      windowsHide: false
-      // Show console for debugging
-    });
-    process2.stdout?.on("data", (data) => {
-      this.emit("instance-log", {
-        instanceId,
-        level: "info",
-        message: data.toString().trim()
-      });
-    });
-    process2.stderr?.on("data", (data) => {
-      this.emit("instance-log", {
-        instanceId,
-        level: "error",
-        message: data.toString().trim()
-      });
-    });
-    process2.on("exit", (code, signal) => {
-      this.emit("instance-exited", {
-        instanceId,
-        code,
-        signal
-      });
-      if (this.instances.has(instanceId)) {
-        this.instances.delete(instanceId);
-        this.processes.delete(instanceId);
-      }
-    });
-    const pid = process2.pid;
-    if (pid === void 0) {
-      process2.kill("SIGKILL");
-      throw new Error("Failed to get PID for usbmuxd instance");
-    }
-    const instance = {
-      id: instanceId,
-      host,
-      port,
-      pid,
-      deviceUdids: [],
-      startedAt: /* @__PURE__ */ new Date()
-    };
-    this.instances.set(instanceId, instance);
-    this.processes.set(instanceId, process2);
-    this.emit("instance-started", instance);
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    return instance;
-  }
   /**
    * Stop a specific instance
    */
   async stopInstance(instanceId) {
     const instance = this.instances.get(instanceId);
-    const process2 = this.processes.get(instanceId);
-    if (!instance || !process2) {
+    const childProcess = this.processes.get(instanceId);
+    if (!instance || !childProcess) {
       return;
     }
-    process2.kill("SIGTERM");
-    await new Promise((resolve) => {
-      const timeout = setTimeout(() => {
-        if (!process2.killed) {
-          process2.kill("SIGKILL");
-        }
-        resolve();
-      }, 5e3);
-      process2.once("exit", () => {
-        clearTimeout(timeout);
-        resolve();
-      });
-    });
+    for (const process2 of this.processes.values()) {
+      process2.kill("SIGKILL");
+    }
     this.instances.delete(instanceId);
     this.processes.delete(instanceId);
     for (const [udid, mapping] of this.deviceMappings.entries()) {
@@ -514,7 +756,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, logDataObject: logDataObject2 } = (0, import_tool_debug_g44.createLoggers)("usbmuxd-service");
 var UsbmuxdService = class extends import_node_events2.EventEmitter {
   manager;
   usbListener;
@@ -538,6 +780,9 @@ var UsbmuxdService = class extends import_node_events2.EventEmitter {
     this.manager.on(
       "device-assigned",
       (payload) => {
+        logInfo3(
+          `Device ${payload.device.deviceId} connected to usbmuxd instance at ${payload.mapping.host}:${payload.mapping.port}`
+        );
         this.emit("device-assigned", payload);
       }
     );
@@ -573,17 +818,12 @@ var UsbmuxdService = class extends import_node_events2.EventEmitter {
     }
     const config = this.manager.getConfig();
     const appleVid = Number.parseInt(config.appleVendorId, 16);
-    logInfo2("Starting service...");
-    logInfo2(`Batch size: ${config.batchSize} devices per instance`);
-    logInfo2(`Base port: ${config.basePort}`);
-    logInfo2(`Max instances: ${config.maxInstances}`);
-    logInfo2(`usbmuxd path: ${config.usbmuxdPath}`);
-    logInfo2(`Monitoring Apple devices (VID: ${config.appleVendorId})`);
+    logDataObject2("Starting service...", { config });
     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) {
@@ -594,7 +834,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) {
@@ -608,8 +848,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;
@@ -623,11 +863,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
@@ -659,18 +899,6 @@ var UsbmuxdService = class extends import_node_events2.EventEmitter {
   getConfig() {
     return this.manager.getConfig();
   }
-  /**
-   * Pair a device with the usbmuxd host.
-   * This is required once per device before most commands will work.
-   * The pairing record is stored in WSL and persists across restarts.
-   *
-   * @param udid Device UDID to pair
-   * @param goIosPath Optional path to go-ios binary
-   * @returns true if pairing succeeded, false otherwise
-   */
-  async pairDevice(udid, goIosPath) {
-    return this.manager.pairDevice(udid, goIosPath);
-  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {