@mcesystems/usbmuxd-instance-manager 1.0.73 → 1.0.74

package/dist/cli.mjs

@@ -1,191 +1,890 @@
 #!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/package.json
+var require_package = __commonJS({
+  "../../node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/package.json"(exports, module) {
+    module.exports = {
+      name: "dotenv",
+      version: "17.2.3",
+      description: "Loads environment variables from .env file",
+      main: "lib/main.js",
+      types: "lib/main.d.ts",
+      exports: {
+        ".": {
+          types: "./lib/main.d.ts",
+          require: "./lib/main.js",
+          default: "./lib/main.js"
+        },
+        "./config": "./config.js",
+        "./config.js": "./config.js",
+        "./lib/env-options": "./lib/env-options.js",
+        "./lib/env-options.js": "./lib/env-options.js",
+        "./lib/cli-options": "./lib/cli-options.js",
+        "./lib/cli-options.js": "./lib/cli-options.js",
+        "./package.json": "./package.json"
+      },
+      scripts: {
+        "dts-check": "tsc --project tests/types/tsconfig.json",
+        lint: "standard",
+        pretest: "npm run lint && npm run dts-check",
+        test: "tap run tests/**/*.js --allow-empty-coverage --disable-coverage --timeout=60000",
+        "test:coverage": "tap run tests/**/*.js --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
+        prerelease: "npm test",
+        release: "standard-version"
+      },
+      repository: {
+        type: "git",
+        url: "git://github.com/motdotla/dotenv.git"
+      },
+      homepage: "https://github.com/motdotla/dotenv#readme",
+      funding: "https://dotenvx.com",
+      keywords: [
+        "dotenv",
+        "env",
+        ".env",
+        "environment",
+        "variables",
+        "config",
+        "settings"
+      ],
+      readmeFilename: "README.md",
+      license: "BSD-2-Clause",
+      devDependencies: {
+        "@types/node": "^18.11.3",
+        decache: "^4.6.2",
+        sinon: "^14.0.1",
+        standard: "^17.0.0",
+        "standard-version": "^9.5.0",
+        tap: "^19.2.0",
+        typescript: "^4.8.4"
+      },
+      engines: {
+        node: ">=12"
+      },
+      browser: {
+        fs: false
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "../../node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/lib/main.js"(exports, module) {
+    var fs = __require("fs");
+    var path = __require("path");
+    var os = __require("os");
+    var crypto = __require("crypto");
+    var packageJson = require_package();
+    var version = packageJson.version;
+    var TIPS = [
+      "\u{1F510} encrypt with Dotenvx: https://dotenvx.com",
+      "\u{1F510} prevent committing .env to code: https://dotenvx.com/precommit",
+      "\u{1F510} prevent building .env in docker: https://dotenvx.com/prebuild",
+      "\u{1F4E1} add observability to secrets: https://dotenvx.com/ops",
+      "\u{1F465} sync secrets across teammates & machines: https://dotenvx.com/ops",
+      "\u{1F5C2}\uFE0F backup and recover secrets: https://dotenvx.com/ops",
+      "\u2705 audit secrets and track compliance: https://dotenvx.com/ops",
+      "\u{1F504} add secrets lifecycle management: https://dotenvx.com/ops",
+      "\u{1F511} add access controls to secrets: https://dotenvx.com/ops",
+      "\u{1F6E0}\uFE0F  run anywhere with `dotenvx run -- yourcommand`",
+      "\u2699\uFE0F  specify custom .env file path with { path: '/custom/path/.env' }",
+      "\u2699\uFE0F  enable debug logging with { debug: true }",
+      "\u2699\uFE0F  override existing env vars with { override: true }",
+      "\u2699\uFE0F  suppress all logs with { quiet: true }",
+      "\u2699\uFE0F  write to custom object with { processEnv: myObject }",
+      "\u2699\uFE0F  load multiple .env files with { path: ['.env.local', '.env'] }"
+    ];
+    function _getRandomTip() {
+      return TIPS[Math.floor(Math.random() * TIPS.length)];
+    }
+    function parseBoolean(value) {
+      if (typeof value === "string") {
+        return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
+      }
+      return Boolean(value);
+    }
+    function supportsAnsi() {
+      return process.stdout.isTTY;
+    }
+    function dim(text) {
+      return supportsAnsi() ? `\x1B[2m${text}\x1B[0m` : text;
+    }
+    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+    function parse(src) {
+      const obj = {};
+      let lines = src.toString();
+      lines = lines.replace(/\r\n?/mg, "\n");
+      let match;
+      while ((match = LINE.exec(lines)) != null) {
+        const key = match[1];
+        let value = match[2] || "";
+        value = value.trim();
+        const maybeQuote = value[0];
+        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+        if (maybeQuote === '"') {
+          value = value.replace(/\\n/g, "\n");
+          value = value.replace(/\\r/g, "\r");
+        }
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _parseVault(options2) {
+      options2 = options2 || {};
+      const vaultPath = _vaultPath(options2);
+      options2.path = vaultPath;
+      const result = DotenvModule.configDotenv(options2);
+      if (!result.parsed) {
+        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+        err.code = "MISSING_DATA";
+        throw err;
+      }
+      const keys = _dotenvKey(options2).split(",");
+      const length = keys.length;
+      let decrypted;
+      for (let i = 0; i < length; i++) {
+        try {
+          const key = keys[i].trim();
+          const attrs = _instructions(result, key);
+          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+          break;
+        } catch (error) {
+          if (i + 1 >= length) {
+            throw error;
+          }
+        }
+      }
+      return DotenvModule.parse(decrypted);
+    }
+    function _warn(message) {
+      console.error(`[dotenv@${version}][WARN] ${message}`);
+    }
+    function _debug(message) {
+      console.log(`[dotenv@${version}][DEBUG] ${message}`);
+    }
+    function _log(message) {
+      console.log(`[dotenv@${version}] ${message}`);
+    }
+    function _dotenvKey(options2) {
+      if (options2 && options2.DOTENV_KEY && options2.DOTENV_KEY.length > 0) {
+        return options2.DOTENV_KEY;
+      }
+      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+        return process.env.DOTENV_KEY;
+      }
+      return "";
+    }
+    function _instructions(result, dotenvKey) {
+      let uri;
+      try {
+        uri = new URL(dotenvKey);
+      } catch (error) {
+        if (error.code === "ERR_INVALID_URL") {
+          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        throw error;
+      }
+      const key = uri.password;
+      if (!key) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environment = uri.searchParams.get("environment");
+      if (!environment) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+      const ciphertext = result.parsed[environmentKey];
+      if (!ciphertext) {
+        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+        throw err;
+      }
+      return { ciphertext, key };
+    }
+    function _vaultPath(options2) {
+      let possibleVaultPath = null;
+      if (options2 && options2.path && options2.path.length > 0) {
+        if (Array.isArray(options2.path)) {
+          for (const filepath of options2.path) {
+            if (fs.existsSync(filepath)) {
+              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+            }
+          }
+        } else {
+          possibleVaultPath = options2.path.endsWith(".vault") ? options2.path : `${options2.path}.vault`;
+        }
+      } else {
+        possibleVaultPath = path.resolve(process.cwd(), ".env.vault");
+      }
+      if (fs.existsSync(possibleVaultPath)) {
+        return possibleVaultPath;
+      }
+      return null;
+    }
+    function _resolveHome(envPath) {
+      return envPath[0] === "~" ? path.join(os.homedir(), envPath.slice(1)) : envPath;
+    }
+    function _configVault(options2) {
+      const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options2 && options2.debug);
+      const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options2 && options2.quiet);
+      if (debug || !quiet) {
+        _log("Loading env from encrypted .env.vault");
+      }
+      const parsed = DotenvModule._parseVault(options2);
+      let processEnv = process.env;
+      if (options2 && options2.processEnv != null) {
+        processEnv = options2.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsed, options2);
+      return { parsed };
+    }
+    function configDotenv(options2) {
+      const dotenvPath = path.resolve(process.cwd(), ".env");
+      let encoding = "utf8";
+      let processEnv = process.env;
+      if (options2 && options2.processEnv != null) {
+        processEnv = options2.processEnv;
+      }
+      let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options2 && options2.debug);
+      let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options2 && options2.quiet);
+      if (options2 && options2.encoding) {
+        encoding = options2.encoding;
+      } else {
+        if (debug) {
+          _debug("No encoding is specified. UTF-8 is used by default");
+        }
+      }
+      let optionPaths = [dotenvPath];
+      if (options2 && options2.path) {
+        if (!Array.isArray(options2.path)) {
+          optionPaths = [_resolveHome(options2.path)];
+        } else {
+          optionPaths = [];
+          for (const filepath of options2.path) {
+            optionPaths.push(_resolveHome(filepath));
+          }
+        }
+      }
+      let lastError;
+      const parsedAll = {};
+      for (const path2 of optionPaths) {
+        try {
+          const parsed = DotenvModule.parse(fs.readFileSync(path2, { encoding }));
+          DotenvModule.populate(parsedAll, parsed, options2);
+        } catch (e) {
+          if (debug) {
+            _debug(`Failed to load ${path2} ${e.message}`);
+          }
+          lastError = e;
+        }
+      }
+      const populated = DotenvModule.populate(processEnv, parsedAll, options2);
+      debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+      quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+      if (debug || !quiet) {
+        const keysCount = Object.keys(populated).length;
+        const shortPaths = [];
+        for (const filePath of optionPaths) {
+          try {
+            const relative = path.relative(process.cwd(), filePath);
+            shortPaths.push(relative);
+          } catch (e) {
+            if (debug) {
+              _debug(`Failed to load ${filePath} ${e.message}`);
+            }
+            lastError = e;
+          }
+        }
+        _log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
+      }
+      if (lastError) {
+        return { parsed: parsedAll, error: lastError };
+      } else {
+        return { parsed: parsedAll };
+      }
+    }
+    function config2(options2) {
+      if (_dotenvKey(options2).length === 0) {
+        return DotenvModule.configDotenv(options2);
+      }
+      const vaultPath = _vaultPath(options2);
+      if (!vaultPath) {
+        _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+        return DotenvModule.configDotenv(options2);
+      }
+      return DotenvModule._configVault(options2);
+    }
+    function decrypt(encrypted, keyStr) {
+      const key = Buffer.from(keyStr.slice(-64), "hex");
+      let ciphertext = Buffer.from(encrypted, "base64");
+      const nonce = ciphertext.subarray(0, 12);
+      const authTag = ciphertext.subarray(-16);
+      ciphertext = ciphertext.subarray(12, -16);
+      try {
+        const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+        aesgcm.setAuthTag(authTag);
+        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+      } catch (error) {
+        const isRange = error instanceof RangeError;
+        const invalidKeyLength = error.message === "Invalid key length";
+        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+        if (isRange || invalidKeyLength) {
+          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        } else if (decryptionFailed) {
+          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+          err.code = "DECRYPTION_FAILED";
+          throw err;
+        } else {
+          throw error;
+        }
+      }
+    }
+    function populate(processEnv, parsed, options2 = {}) {
+      const debug = Boolean(options2 && options2.debug);
+      const override = Boolean(options2 && options2.override);
+      const populated = {};
+      if (typeof parsed !== "object") {
+        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+        err.code = "OBJECT_REQUIRED";
+        throw err;
+      }
+      for (const key of Object.keys(parsed)) {
+        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+          if (override === true) {
+            processEnv[key] = parsed[key];
+            populated[key] = parsed[key];
+          }
+          if (debug) {
+            if (override === true) {
+              _debug(`"${key}" is already defined and WAS overwritten`);
+            } else {
+              _debug(`"${key}" is already defined and was NOT overwritten`);
+            }
+          }
+        } else {
+          processEnv[key] = parsed[key];
+          populated[key] = parsed[key];
+        }
+      }
+      return populated;
+    }
+    var DotenvModule = {
+      configDotenv,
+      _configVault,
+      _parseVault,
+      config: config2,
+      decrypt,
+      parse,
+      populate
+    };
+    module.exports.configDotenv = DotenvModule.configDotenv;
+    module.exports._configVault = DotenvModule._configVault;
+    module.exports._parseVault = DotenvModule._parseVault;
+    module.exports.config = DotenvModule.config;
+    module.exports.decrypt = DotenvModule.decrypt;
+    module.exports.parse = DotenvModule.parse;
+    module.exports.populate = DotenvModule.populate;
+    module.exports = DotenvModule;
+  }
+});
 
 // src/cli.ts
-import { createLoggers as createLoggers4 } from "@mcesystems/tool-debug-g4";
+var import_dotenv = __toESM(require_main());
+import { createLoggers as createLoggers5 } from "@mcesystems/tool-debug-g4";
 
 // src/UsbmuxdService.ts
 import { EventEmitter as EventEmitter2 } from "node:events";
-import { createLoggers as createLoggers3 } from "@mcesystems/tool-debug-g4";
+import { createLoggers as createLoggers4 } from "@mcesystems/tool-debug-g4";
 import UsbDeviceListener from "@mcesystems/usb-device-listener";
 
 // src/InstanceManager.ts
-import { exec as exec2, spawn } from "node:child_process";
 import { EventEmitter } from "node:events";
-import { promisify as promisify2 } from "node:util";
-import { createLoggers as createLoggers2 } from "@mcesystems/tool-debug-g4";
+import { createLoggers as createLoggers3 } from "@mcesystems/tool-debug-g4";
 
-// src/LockdownSync.ts
+// src/usbipd.ts
 import { exec } from "node:child_process";
-import { existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
 import { promisify } from "node:util";
 import { createLoggers } from "@mcesystems/tool-debug-g4";
-var { logInfo, logWarning } = createLoggers("usbmuxd-instance-manager");
+var { logInfo, logWarning } = createLoggers("usbipd");
 var execAsync = promisify(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 = join(windowsDir, `${udid}.plist`);
-  if (!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) {
+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}`);
+    }
+  }
+  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}`);
+    }
+  }
+  /**
+   * Detach a device from WSL via usbipd
+   */
+  async detachDeviceFromWsl(busId) {
+    try {
+      await execAsync(`"${this.usbipdPath}" detach --busid=${busId}`);
+      logInfo(`Device ${busId} detached from WSL`);
+    } catch (error) {
+      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}`);
+      }
+    }
+  }
+  /**
+   * Attach a device to WSL via usbipd
+   * Note: This requires administrator privileges
+   */
+  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;
+    }
+  }
+  /**
+   * Parse usbipd list output to extract device information
+   */
+  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
+        });
+      }
+    }
+    return devices;
+  }
+  /**
+   * Find the usbipd bus ID for a device by matching VID/PID
+   */
+  async findBusIdForDevice(device) {
+    try {
+      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}`);
+      logInfo(`Found ${usbipdDevices.length} devices from usbipd list`);
+      const match = usbipdDevices.find((d) => d.vid === deviceVid && d.pid === devicePid);
+      if (match) {
+        logInfo(
+          `Found usbipd bus ID ${match.busId} for device ${device.deviceId} (${deviceVid}:${devicePid})`
+        );
+        return match.busId;
+      }
+      throw new Error(
+        `Could not find usbipd bus ID for device ${device.deviceId} (${deviceVid}:${devicePid})`
+      );
+    } catch (error) {
+      throw new Error(`Failed to run usbipd list: ${error}`);
+    }
+  }
+};
+
+// src/wsl.ts
+import { exec as exec2, spawn } from "node:child_process";
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { promisify as promisify2 } from "node:util";
+import { createLoggers as createLoggers2 } from "@mcesystems/tool-debug-g4";
+var { logInfo: logInfo2, logWarning: logWarning2, logDetail } = createLoggers2("wsl");
+var execAsync2 = promisify2(exec2);
+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.wslDistribution;
+    try {
+      if (distro) {
+        logInfo2(`Starting WSL distribution: ${distro}...`);
+        await execAsync2(`wsl -d ${distro} -- echo "WSL started"`);
+      } else {
+        logInfo2("Starting default WSL distribution...");
+        await execAsync2(`wsl -- echo "WSL started"`);
+      }
+      return true;
+    } catch (error) {
+      logWarning2(`Failed to start WSL: ${error}`);
+      return false;
+    }
+  }
+  /**
+   * Create a new usbmuxd instance
+   */
+  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 = 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 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 = join(lockdownDir, devicePlistFile);
+    if (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 = join(lockdownDir, this.SYSTEM_CONFIG_PLIST);
+    if (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 execAsync2(
+        `wsl -d ${distro} -- sh -c "mkdir -p ${wslDestDir} && cp '${wslSource}' '${wslDestDir}/'"`
+      );
+      logInfo2(`Lockdown sync: copied ${fileName} to Alpine`);
+    } catch (error) {
+      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.`
+        );
+      }
+    }
+  }
+  /**
+   * 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 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 {
+      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 {
-      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.`
-      );
+      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) {
+      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");
   }
-}
-async function syncFromAlpine(udids, config2) {
-  if (!config2.lockdownSyncEnabled || !config2.lockdownWindowsPath?.trim()) {
-    return;
-  }
-  const windowsDir = config2.lockdownWindowsPath.trim();
-  try {
-    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`;
+  /**
+   * 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 copyFileFromAlpine(fileName, wslDestDir, distro, lockdownDir) {
+    const alpinePath = `${this.ALPINE_LOCKDOWN_DIR}/${fileName}`;
     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`);
+      await execAsync2(`wsl -d ${distro} -- test -f '${alpinePath}'`);
     } catch {
+      logDetail(`Lockdown sync: ${fileName} not found in Alpine (${alpinePath}), skipping`);
+      return;
+    }
+    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}`);
     }
   }
-  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 } = createLoggers2("usbmuxd-instance-manager");
-var execAsync2 = promisify2(exec2);
-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
-      });
-    }
-  }
-  return devices;
-}
+var { logWarning: logWarning3, logDetail: logDetail2, logDataObject, logTask } = createLoggers3("instance-manager");
 var DEFAULT_CONFIG = {
   batchSize: 4,
   basePort: 27015,
-  maxInstances: 20,
+  maxInstances: 5,
   usbmuxdPath: "usbmuxd",
   // Path inside WSL2
   wslDistribution: "alpine-usbmuxd-build",
   // Alpine WSL2 distribution name
   verboseLogging: true,
-  appleVendorId: "05AC",
-  lockdownWindowsPath: "C:\\ProgramData\\mce\\lockdown",
-  lockdownSyncEnabled: true
+  appleVendorId: "05AC"
 };
 var InstanceManager = class extends EventEmitter {
-  config;
+  /** 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();
-  nextInstanceId = 1;
-  startedAt = null;
-  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) */
+  /** 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;
+  config;
+  nextInstanceId = 1;
+  startedAt = null;
+  isRunning = false;
+  wsl;
+  usbipd;
   constructor(config2 = {}) {
     super();
     this.config = { ...DEFAULT_CONFIG, ...config2 };
-  }
-  /**
-   * 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.config.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;
+    this.wsl = new Wsl2(this.config.wslDistribution);
+    this.usbipd = new Usbipd(process.env.USBIPD_PATH ?? "usbipd");
   }
   /**
    * Start the instance manager
@@ -196,7 +895,6 @@ var InstanceManager = class extends EventEmitter {
     }
     this.isRunning = true;
     this.startedAt = /* @__PURE__ */ new Date();
-    this.emit("started");
   }
   /**
    * Stop the instance manager and all instances
@@ -207,147 +905,122 @@ var InstanceManager = class extends EventEmitter {
     }
     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)
-    );
-    await Promise.all(detachPromises);
+    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();
-    this.emit("stopped");
   }
-  /**
-   * Find the usbipd bus ID for a device by matching VID/PID
-   */
-  async findBusIdForDevice(device) {
-    try {
-      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");
-      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) {
-        logInfo2(
-          `Found usbipd bus ID ${match.busId} for device ${device.deviceId} (${deviceVid}:${devicePid})`
-        );
-        return match.busId;
+  async attachToWsl({
+    busId,
+    deviceId
+  }) {
+    if (!this.attachedDevices.has(busId)) {
+      this.pendingAttachDevices.add(deviceId);
+      if (!this.config.wslDistribution) {
+        throw new Error("WSL distribution not configured");
       }
-      for (const d of usbipdDevices) {
-        logInfo2(`  usbipd device: ${d.busId} ${d.vid}:${d.pid} "${d.description}"`);
-      }
-      logWarning2(
-        `Could not find usbipd bus ID for device ${device.deviceId} (${deviceVid}:${devicePid})`
+      const attached = await this.usbipd.attachDeviceToWsl(
+        busId,
+        this.wsl,
+        this.config.wslDistribution
       );
-      return null;
-    } catch (error) {
-      logWarning2(`Failed to run usbipd list: ${error}`);
-      return null;
+      if (attached) {
+        this.attachedDevices.add(busId);
+      }
     }
   }
-  /**
-   * Ensure the WSL distribution is running
-   */
-  async ensureWslRunning() {
-    const distro = this.config.wslDistribution;
-    try {
-      if (distro) {
-        logInfo2(`Starting WSL distribution: ${distro}...`);
-        await execAsync2(`wsl -d ${distro} -- echo "WSL started"`);
-      } else {
-        logInfo2("Starting default WSL distribution...");
-        await execAsync2(`wsl -- echo "WSL started"`);
-      }
-      return true;
-    } catch (error) {
-      logWarning2(`Failed to start WSL: ${error}`);
-      return false;
+  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;
   }
-  /**
-   * Attach a device to WSL via usbipd
-   * Note: This requires administrator privileges
-   */
-  async attachDeviceToWsl(busId) {
-    const distro = this.config.wslDistribution;
-    try {
-      await this.ensureWslRunning();
-      logInfo2(`Binding device ${busId}...`);
-      await execAsync2(`${USBIPD_PATH} bind --busid ${busId} --force`);
-      if (distro) {
-        logInfo2(`Attaching device ${busId} to WSL distribution ${distro}...`);
-        await execAsync2(`${USBIPD_PATH} attach --wsl=${distro} --busid=${busId}`);
-      } else {
-        logInfo2(`Attaching device ${busId} to default WSL...`);
-        await execAsync2(`${USBIPD_PATH} attach --wsl --busid=${busId}`);
-      }
-      logInfo2(`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")) {
-        logInfo2(`Device ${busId} is already attached to WSL, continuing`);
-        return true;
+  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);
       }
-      logWarning2(`Failed to attach device ${busId} to WSL: ${error}`);
-      return false;
     }
+    this.instances.delete(instanceId);
+    this.processes.get(instanceId)?.kill();
+    this.processes.delete(instanceId);
   }
-  /**
-   * Detach a device from WSL via usbipd
-   */
-  async detachDeviceFromWsl(busId) {
-    try {
-      await execAsync2(`${USBIPD_PATH} detach --busid=${busId}`);
-      logInfo2(`Device ${busId} detached from WSL`);
-    } catch (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}`);
+  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`);
       }
+      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;
     }
+    return targetInstance;
   }
   /**
-   * Handle device connection
+   * 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) {
-    if (this.deviceMappings.has(device.deviceId)) {
-      logWarning2(`Device ${device.deviceId} is already connected`);
+    const busId = await this.usbipd.findBusIdForDevice(device);
+    if (this.attachedDevices.has(busId)) {
+      logTask(`Device ${device.deviceId} is already attached. skipping onDeviceConnected...`);
       return;
     }
-    await syncToAlpine(device.deviceId, this.config);
-    const busId = await this.findBusIdForDevice(device);
-    if (!busId) {
-      logWarning2(`Cannot attach device ${device.deviceId} - bus ID not found`);
-    }
-    if (busId && !this.attachedDevices.has(busId)) {
-      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();
-    if (!targetInstance) {
-      if (this.instances.size >= this.config.maxInstances) {
-        throw new Error(`Maximum number of instances (${this.config.maxInstances}) reached`);
-      }
-      targetInstance = await this.createInstance();
-    }
-    targetInstance.deviceUdids.push(device.deviceId);
+    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,
@@ -357,77 +1030,52 @@ var InstanceManager = class extends 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) {
-      logWarning2(`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}`;
-      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")) {
-        logWarning2(`Pairing warning for ${udid}: ${stderr}`);
-      }
-      logInfo2(`Device ${udid} paired successfully`);
-      this.emit("device-paired", { udid, mapping });
-      return true;
-    } catch (error) {
-      logWarning2(`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) {
-    if (this.pendingAttachDevices.has(device.deviceId)) {
+    if (!this.attachedDevices.has(device.deviceId)) {
+      logTask(`Device ${device.deviceId} is not attached. skipping onDeviceDisconnected...`);
       return;
     }
+    logDataObject("Device disconnected", { device });
     const mapping = this.deviceMappings.get(device.deviceId);
     if (!mapping) {
-      logWarning2(`Device ${device.deviceId} was not tracked`);
-      return;
-    }
-    if (mapping.busId) {
-      await this.detachDeviceFromWsl(mapping.busId);
-      this.attachedDevices.delete(mapping.busId);
-    }
-    const instance = this.instances.get(mapping.instanceId);
-    if (!instance) {
-      logWarning2(`Instance ${mapping.instanceId} not found`);
-      this.deviceMappings.delete(device.deviceId);
-      return;
+      throw new Error(`Device ${device.deviceId} was not tracked`);
     }
-    const deviceIndex = instance.deviceUdids.indexOf(device.deviceId);
-    if (deviceIndex > -1) {
-      instance.deviceUdids.splice(deviceIndex, 1);
-    }
-    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);
     }
   }
@@ -442,104 +1090,18 @@ var InstanceManager = class extends 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 = 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()) {
@@ -591,7 +1153,7 @@ var InstanceManager = class extends EventEmitter {
 };
 
 // src/UsbmuxdService.ts
-var { logInfo: logInfo3, logError } = createLoggers3("usbmuxd-instance-manager");
+var { logInfo: logInfo3, logError, logDataObject: logDataObject2 } = createLoggers4("usbmuxd-service");
 var UsbmuxdService = class extends EventEmitter2 {
   manager;
   usbListener;
@@ -615,6 +1177,9 @@ var UsbmuxdService = class extends EventEmitter2 {
     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);
       }
     );
@@ -650,12 +1215,7 @@ var UsbmuxdService = class extends EventEmitter2 {
     }
     const config2 = this.manager.getConfig();
     const appleVid = Number.parseInt(config2.appleVendorId, 16);
-    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})`);
+    logDataObject2("Starting service...", { config: config2 });
     this.usbListener.onDeviceAdd(async (device) => {
       if (device.vid !== appleVid) {
         return;
@@ -736,22 +1296,11 @@ var UsbmuxdService = class extends EventEmitter2 {
   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);
-  }
 };
 
 // src/cli.ts
-var { logInfo: logInfo4, logError: logError2, logHeader, logDataObject } = createLoggers4("usbmuxd-cli");
+import_dotenv.default.config();
+var { logInfo: logInfo4, logError: logError2, logHeader, logDataObject: logDataObject3 } = createLoggers5("usbmuxd-cli");
 var args = process.argv.slice(2);
 var options = {};
 for (let i = 0; i < args.length; i++) {
@@ -773,31 +1322,25 @@ var config = {
   appleVendorId: options.appleVid || "05AC"
 };
 logHeader("usbmuxd Instance Manager");
-logDataObject("Multi-instance manager for iOS device connections", { config });
+logDataObject3("Multi-instance manager for iOS device connections", { config });
 var service = new UsbmuxdService(config);
-process.on("SIGINT", async () => {
+async function shutdown(eventName) {
   logInfo4("");
-  logInfo4("Received SIGINT, shutting down gracefully...");
+  logInfo4(`Received ${eventName}, shutting down gracefully...`);
   try {
     await service.stop();
     logInfo4("Shutdown complete");
     process.exit(0);
   } catch (error) {
-    logError2("Error during shutdown:", error);
+    logError2(`Error during ${eventName}:`, error);
     process.exit(1);
   }
+}
+process.on("SIGINT", async () => {
+  void shutdown("SIGINT");
 });
 process.on("SIGTERM", async () => {
-  logInfo4("");
-  logInfo4("Received SIGTERM, shutting down gracefully...");
-  try {
-    await service.stop();
-    logInfo4("Shutdown complete");
-    process.exit(0);
-  } catch (error) {
-    logError2("Error during shutdown:", error);
-    process.exit(1);
-  }
+  void shutdown("SIGTERM");
 });
 setInterval(() => {
   const stats = service.getStats();
@@ -806,7 +1349,7 @@ setInterval(() => {
     `Uptime: ${stats.uptimeSeconds}s | Instances: ${stats.instanceCount} | Devices: ${stats.deviceCount}`
   );
   if (instances.length > 0) {
-    logDataObject("Active instances:", { instances });
+    logDataObject3("Active instances:", { instances });
   }
 }, 3e4);
 if (args.includes("--help") || args.includes("-h")) {
@@ -830,7 +1373,7 @@ if (args.includes("--help") || args.includes("-h")) {
 try {
   service.start();
 } catch (error) {
-  logError2("Failed to start service:", error);
-  process.exit(1);
+  logError2("Failed to start service", error);
+  shutdown("Failed to start service");
 }
 //# sourceMappingURL=cli.mjs.map