@mcesystems/usbmuxd-instance-manager 1.0.72 → 1.0.73

package/dist/index.js

@@ -37,16 +37,100 @@ 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_g43 = require("@mcesystems/tool-debug-g4");
 var import_usb_device_listener = __toESM(require("@mcesystems/usb-device-listener"));
 
 // src/InstanceManager.ts
-var import_node_child_process = require("node:child_process");
+var import_node_child_process2 = require("node:child_process");
 var import_node_events = require("node:events");
+var import_node_util2 = require("node:util");
+var import_tool_debug_g42 = require("@mcesystems/tool-debug-g4");
+
+// src/LockdownSync.ts
+var import_node_child_process = require("node:child_process");
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
 var import_node_util = require("node:util");
 var import_tool_debug_g4 = require("@mcesystems/tool-debug-g4");
 var { logInfo, logWarning } = (0, import_tool_debug_g4.createLoggers)("usbmuxd-instance-manager");
 var execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
+var ALPINE_LOCKDOWN_DIR = "/var/lib/lockdown";
+var SYSTEM_CONFIG_PLIST = "SystemConfiguration.plist";
+function windowsPathToWsl(windowsPath) {
+  const normalized = windowsPath.replace(/\\/g, "/").trim();
+  const driveMatch = normalized.match(/^([a-zA-Z]):\/?(.*)$/);
+  if (driveMatch) {
+    const drive = driveMatch[1].toLowerCase();
+    const rest = driveMatch[2] || "";
+    return `/mnt/${drive}${rest ? `/${rest}` : ""}`;
+  }
+  return normalized;
+}
+async function syncToAlpine(udid, config) {
+  if (!config.lockdownSyncEnabled || !config.lockdownWindowsPath?.trim()) {
+    return;
+  }
+  const windowsDir = config.lockdownWindowsPath.trim();
+  const windowsFile = (0, import_node_path.join)(windowsDir, `${udid}.plist`);
+  if (!(0, import_node_fs.existsSync)(windowsFile)) {
+    return;
+  }
+  const distro = config.wslDistribution || "alpine-usbmuxd-build";
+  const wslSource = windowsPathToWsl(windowsFile);
+  const wslDestDir = ALPINE_LOCKDOWN_DIR;
+  try {
+    await execAsync(
+      `wsl -d ${distro} -- sh -c "mkdir -p ${wslDestDir} && cp '${wslSource}' '${wslDestDir}/'"`
+    );
+    logInfo(`Lockdown sync: copied ${udid}.plist to Alpine`);
+  } catch (error) {
+    try {
+      await execAsync(
+        `wsl -d ${distro} -- sh -c "mkdir -p ${wslDestDir} && sudo cp '${wslSource}' '${wslDestDir}/'"`
+      );
+      logInfo(`Lockdown sync: copied ${udid}.plist to Alpine (via sudo)`);
+    } catch (sudoError) {
+      logWarning(
+        `Lockdown sync to Alpine failed for ${udid}: ${error}. Sudo fallback failed: ${sudoError}. Ensure /var/lib/lockdown is writable or use passwordless sudo.`
+      );
+    }
+  }
+}
+async function syncFromAlpine(udids, config) {
+  if (!config.lockdownSyncEnabled || !config.lockdownWindowsPath?.trim()) {
+    return;
+  }
+  const windowsDir = config.lockdownWindowsPath.trim();
+  try {
+    (0, import_node_fs.mkdirSync)(windowsDir, { recursive: true });
+  } catch (error) {
+    logWarning(`Lockdown sync: could not create Windows dir ${windowsDir}: ${error}`);
+    return;
+  }
+  const distro = config.wslDistribution || "alpine-usbmuxd-build";
+  const wslDestDir = windowsPathToWsl(windowsDir);
+  for (const udid of udids) {
+    const plist = `${udid}.plist`;
+    try {
+      await execAsync(
+        `wsl -d ${distro} -- sh -c "test -f '${ALPINE_LOCKDOWN_DIR}/${plist}' && cp '${ALPINE_LOCKDOWN_DIR}/${plist}' '${wslDestDir}/'"`
+      );
+      logInfo(`Lockdown sync: copied ${plist} from Alpine to Windows`);
+    } catch {
+    }
+  }
+  try {
+    await execAsync(
+      `wsl -d ${distro} -- sh -c "test -f '${ALPINE_LOCKDOWN_DIR}/${SYSTEM_CONFIG_PLIST}' && cp '${ALPINE_LOCKDOWN_DIR}/${SYSTEM_CONFIG_PLIST}' '${wslDestDir}/'"`
+    );
+    logInfo(`Lockdown sync: copied ${SYSTEM_CONFIG_PLIST} from Alpine to Windows`);
+  } catch {
+  }
+}
+
+// src/InstanceManager.ts
+var { logInfo: logInfo2, logWarning: logWarning2 } = (0, import_tool_debug_g42.createLoggers)("usbmuxd-instance-manager");
+var execAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.exec);
 var USBIPD_PATH = '"C:\\Program Files\\usbipd-win\\usbipd.exe"';
 function parseUsbipdList(output) {
   const devices = [];
@@ -78,7 +162,9 @@ var DEFAULT_CONFIG = {
   wslDistribution: "alpine-usbmuxd-build",
   // Alpine WSL2 distribution name
   verboseLogging: true,
-  appleVendorId: "05AC"
+  appleVendorId: "05AC",
+  lockdownWindowsPath: "C:\\ProgramData\\mce\\lockdown",
+  lockdownSyncEnabled: true
 };
 var InstanceManager = class extends import_node_events.EventEmitter {
   config;
@@ -90,6 +176,8 @@ var InstanceManager = class extends import_node_events.EventEmitter {
   isRunning = false;
   /** Tracks which devices have been attached to WSL */
   attachedDevices = /* @__PURE__ */ new Set();
+  /** Device IDs currently in the attach flow (ignore disconnect until attach completes) */
+  pendingAttachDevices = /* @__PURE__ */ new Set();
   /** Cached WSL IP address for connecting from Windows */
   wslIpAddress = null;
   constructor(config = {}) {
@@ -106,28 +194,28 @@ var InstanceManager = class extends import_node_events.EventEmitter {
     }
     const distro = this.config.wslDistribution || "alpine-usbmuxd-build";
     try {
-      const { stdout } = await execAsync(`wsl -d ${distro} -- ip -4 addr show eth0`);
+      const { stdout } = await execAsync2(`wsl -d ${distro} -- ip -4 addr show eth0`);
       const match = stdout.match(/inet\s+(\d+\.\d+\.\d+\.\d+)/);
       if (match) {
         this.wslIpAddress = match[1];
-        logInfo(`Detected WSL IP address: ${this.wslIpAddress}`);
+        logInfo2(`Detected WSL IP address: ${this.wslIpAddress}`);
         return this.wslIpAddress;
       }
     } catch (error) {
-      logWarning(`Failed to detect WSL IP via ip addr: ${error}`);
+      logWarning2(`Failed to detect WSL IP via ip addr: ${error}`);
     }
     try {
-      const { stdout } = await execAsync(`wsl -d ${distro} -- hostname -I`);
+      const { stdout } = await execAsync2(`wsl -d ${distro} -- hostname -I`);
       const ip = stdout.trim().split(/\s+/)[0];
       if (ip && /^\d+\.\d+\.\d+\.\d+$/.test(ip)) {
         this.wslIpAddress = ip;
-        logInfo(`Detected WSL IP address (hostname): ${this.wslIpAddress}`);
+        logInfo2(`Detected WSL IP address (hostname): ${this.wslIpAddress}`);
         return this.wslIpAddress;
       }
     } catch (error) {
-      logWarning(`Failed to detect WSL IP via hostname: ${error}`);
+      logWarning2(`Failed to detect WSL IP via hostname: ${error}`);
     }
-    logWarning("Could not detect WSL IP, falling back to localhost");
+    logWarning2("Could not detect WSL IP, falling back to localhost");
     this.wslIpAddress = "127.0.0.1";
     return this.wslIpAddress;
   }
@@ -150,6 +238,8 @@ var InstanceManager = class extends import_node_events.EventEmitter {
       return;
     }
     this.isRunning = false;
+    const udids = Array.from(this.deviceMappings.keys());
+    await syncFromAlpine(udids, this.config);
     const detachPromises = Array.from(this.attachedDevices).map(
       (busId) => this.detachDeviceFromWsl(busId)
     );
@@ -167,28 +257,28 @@ var InstanceManager = class extends import_node_events.EventEmitter {
    */
   async findBusIdForDevice(device) {
     try {
-      const { stdout } = await execAsync(`${USBIPD_PATH} list`);
+      const { stdout } = await execAsync2(`${USBIPD_PATH} list`);
       const usbipdDevices = parseUsbipdList(stdout);
       const deviceVid = device.vid.toString(16).toUpperCase().padStart(4, "0");
       const devicePid = device.pid.toString(16).toUpperCase().padStart(4, "0");
-      logInfo(`Looking for device with VID:PID ${deviceVid}:${devicePid}`);
-      logInfo(`Found ${usbipdDevices.length} devices from usbipd list`);
+      logInfo2(`Looking for device with VID:PID ${deviceVid}:${devicePid}`);
+      logInfo2(`Found ${usbipdDevices.length} devices from usbipd list`);
       const match = usbipdDevices.find((d) => d.vid === deviceVid && d.pid === devicePid);
       if (match) {
-        logInfo(
+        logInfo2(
           `Found usbipd bus ID ${match.busId} for device ${device.deviceId} (${deviceVid}:${devicePid})`
         );
         return match.busId;
       }
       for (const d of usbipdDevices) {
-        logInfo(`  usbipd device: ${d.busId} ${d.vid}:${d.pid} "${d.description}"`);
+        logInfo2(`  usbipd device: ${d.busId} ${d.vid}:${d.pid} "${d.description}"`);
       }
-      logWarning(
+      logWarning2(
         `Could not find usbipd bus ID for device ${device.deviceId} (${deviceVid}:${devicePid})`
       );
       return null;
     } catch (error) {
-      logWarning(`Failed to run usbipd list: ${error}`);
+      logWarning2(`Failed to run usbipd list: ${error}`);
       return null;
     }
   }
@@ -199,15 +289,15 @@ var InstanceManager = class extends import_node_events.EventEmitter {
     const distro = this.config.wslDistribution;
     try {
       if (distro) {
-        logInfo(`Starting WSL distribution: ${distro}...`);
-        await execAsync(`wsl -d ${distro} -- echo "WSL started"`);
+        logInfo2(`Starting WSL distribution: ${distro}...`);
+        await execAsync2(`wsl -d ${distro} -- echo "WSL started"`);
       } else {
-        logInfo("Starting default WSL distribution...");
-        await execAsync(`wsl -- echo "WSL started"`);
+        logInfo2("Starting default WSL distribution...");
+        await execAsync2(`wsl -- echo "WSL started"`);
       }
       return true;
     } catch (error) {
-      logWarning(`Failed to start WSL: ${error}`);
+      logWarning2(`Failed to start WSL: ${error}`);
       return false;
     }
   }
@@ -219,19 +309,24 @@ var InstanceManager = class extends import_node_events.EventEmitter {
     const distro = this.config.wslDistribution;
     try {
       await this.ensureWslRunning();
-      logInfo(`Binding device ${busId}...`);
-      await execAsync(`${USBIPD_PATH} bind --busid ${busId} --force`);
+      logInfo2(`Binding device ${busId}...`);
+      await execAsync2(`${USBIPD_PATH} bind --busid ${busId} --force`);
       if (distro) {
-        logInfo(`Attaching device ${busId} to WSL distribution ${distro}...`);
-        await execAsync(`${USBIPD_PATH} attach --wsl=${distro} --busid=${busId}`);
+        logInfo2(`Attaching device ${busId} to WSL distribution ${distro}...`);
+        await execAsync2(`${USBIPD_PATH} attach --wsl=${distro} --busid=${busId}`);
       } else {
-        logInfo(`Attaching device ${busId} to default WSL...`);
-        await execAsync(`${USBIPD_PATH} attach --wsl --busid=${busId}`);
+        logInfo2(`Attaching device ${busId} to default WSL...`);
+        await execAsync2(`${USBIPD_PATH} attach --wsl --busid=${busId}`);
       }
-      logInfo(`Device ${busId} attached to WSL successfully`);
+      logInfo2(`Device ${busId} attached to WSL successfully`);
       return true;
     } catch (error) {
-      logWarning(`Failed to attach device ${busId} to WSL: ${error}`);
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("already attached to a client")) {
+        logInfo2(`Device ${busId} is already attached to WSL, continuing`);
+        return true;
+      }
+      logWarning2(`Failed to attach device ${busId} to WSL: ${error}`);
       return false;
     }
   }
@@ -240,10 +335,15 @@ var InstanceManager = class extends import_node_events.EventEmitter {
    */
   async detachDeviceFromWsl(busId) {
     try {
-      await execAsync(`${USBIPD_PATH} detach --busid=${busId}`);
-      logInfo(`Device ${busId} detached from WSL`);
+      await execAsync2(`${USBIPD_PATH} detach --busid=${busId}`);
+      logInfo2(`Device ${busId} detached from WSL`);
     } catch (error) {
-      logWarning(`Failed to detach device ${busId}: ${error}`);
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("no device with busid") || message.includes("There is no device")) {
+        logInfo2(`Device ${busId} already detached`);
+      } else {
+        logWarning2(`Failed to detach device ${busId}: ${error}`);
+      }
     }
   }
   /**
@@ -252,18 +352,24 @@ var InstanceManager = class extends import_node_events.EventEmitter {
    */
   async onDeviceConnected(device) {
     if (this.deviceMappings.has(device.deviceId)) {
-      logWarning(`Device ${device.deviceId} is already connected`);
+      logWarning2(`Device ${device.deviceId} is already connected`);
       return;
     }
+    await syncToAlpine(device.deviceId, this.config);
     const busId = await this.findBusIdForDevice(device);
     if (!busId) {
-      logWarning(`Cannot attach device ${device.deviceId} - bus ID not found`);
+      logWarning2(`Cannot attach device ${device.deviceId} - bus ID not found`);
     }
     if (busId && !this.attachedDevices.has(busId)) {
-      const attached = await this.attachDeviceToWsl(busId);
-      if (attached) {
-        this.attachedDevices.add(busId);
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
+      this.pendingAttachDevices.add(device.deviceId);
+      try {
+        const attached = await this.attachDeviceToWsl(busId);
+        if (attached) {
+          this.attachedDevices.add(busId);
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
+        }
+      } finally {
+        this.pendingAttachDevices.delete(device.deviceId);
       }
     }
     let targetInstance = this.findInstanceWithCapacity();
@@ -301,23 +407,23 @@ var InstanceManager = class extends import_node_events.EventEmitter {
   async pairDevice(udid, goIosPath = "ios") {
     const mapping = this.deviceMappings.get(udid);
     if (!mapping) {
-      logWarning(`Cannot pair device ${udid} - not found in mappings`);
+      logWarning2(`Cannot pair device ${udid} - not found in mappings`);
       return false;
     }
     try {
       const socketAddress = `${mapping.host}:${mapping.port}`;
-      logInfo(`Pairing device ${udid} via ${socketAddress}...`);
-      const { stderr } = await execAsync(`"${goIosPath}" pair --udid=${udid}`, {
+      logInfo2(`Pairing device ${udid} via ${socketAddress}...`);
+      const { stderr } = await execAsync2(`"${goIosPath}" pair --udid=${udid}`, {
         env: { ...process.env, USBMUXD_SOCKET_ADDRESS: socketAddress }
       });
       if (stderr?.includes("error")) {
-        logWarning(`Pairing warning for ${udid}: ${stderr}`);
+        logWarning2(`Pairing warning for ${udid}: ${stderr}`);
       }
-      logInfo(`Device ${udid} paired successfully`);
+      logInfo2(`Device ${udid} paired successfully`);
       this.emit("device-paired", { udid, mapping });
       return true;
     } catch (error) {
-      logWarning(`Failed to pair device ${udid}: ${error}`);
+      logWarning2(`Failed to pair device ${udid}: ${error}`);
       return false;
     }
   }
@@ -326,9 +432,12 @@ var InstanceManager = class extends import_node_events.EventEmitter {
    * Detaches from WSL, removes device from instance, and stops instance if empty
    */
   async onDeviceDisconnected(device) {
+    if (this.pendingAttachDevices.has(device.deviceId)) {
+      return;
+    }
     const mapping = this.deviceMappings.get(device.deviceId);
     if (!mapping) {
-      logWarning(`Device ${device.deviceId} was not tracked`);
+      logWarning2(`Device ${device.deviceId} was not tracked`);
       return;
     }
     if (mapping.busId) {
@@ -337,7 +446,7 @@ var InstanceManager = class extends import_node_events.EventEmitter {
     }
     const instance = this.instances.get(mapping.instanceId);
     if (!instance) {
-      logWarning(`Instance ${mapping.instanceId} not found`);
+      logWarning2(`Instance ${mapping.instanceId} not found`);
       this.deviceMappings.delete(device.deviceId);
       return;
     }
@@ -392,7 +501,7 @@ var InstanceManager = class extends import_node_events.EventEmitter {
       this.config.usbmuxdPath,
       ...usbmuxdArgs
     ];
-    const process2 = (0, import_node_child_process.spawn)("wsl", wslArgs, {
+    const process2 = (0, import_node_child_process2.spawn)("wsl", wslArgs, {
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: false
       // Show console for debugging
@@ -514,7 +623,7 @@ var InstanceManager = class extends import_node_events.EventEmitter {
 };
 
 // src/UsbmuxdService.ts
-var { logInfo: logInfo2, logError } = (0, import_tool_debug_g42.createLoggers)("usbmuxd-instance-manager");
+var { logInfo: logInfo3, logError } = (0, import_tool_debug_g43.createLoggers)("usbmuxd-instance-manager");
 var UsbmuxdService = class extends import_node_events2.EventEmitter {
   manager;
   usbListener;
@@ -573,17 +682,17 @@ 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})`);
+    logInfo3("Starting service...");
+    logInfo3(`Batch size: ${config.batchSize} devices per instance`);
+    logInfo3(`Base port: ${config.basePort}`);
+    logInfo3(`Max instances: ${config.maxInstances}`);
+    logInfo3(`usbmuxd path: ${config.usbmuxdPath}`);
+    logInfo3(`Monitoring Apple devices (VID: ${config.appleVendorId})`);
     this.usbListener.onDeviceAdd(async (device) => {
       if (device.vid !== appleVid) {
         return;
       }
-      logInfo2(`Apple device connected: ${device.deviceId} (${device.deviceName || "Unknown"})`);
+      logInfo3(`Apple device connected: ${device.deviceId} (${device.deviceName || "Unknown"})`);
       try {
         await this.manager.onDeviceConnected(device);
       } catch (error) {
@@ -594,7 +703,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 +717,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 +732,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