@mcesystems/usbmuxd-instance-manager 1.0.72

package/dist/index.js

@@ -0,0 +1,680 @@
+"use strict";
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  InstanceManager: () => InstanceManager,
+  UsbmuxdService: () => UsbmuxdService
+});
+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_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_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 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 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 };
+  }
+  /**
+   * 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 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;
+      }
+    } 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;
+      }
+    } 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
+   */
+  start() {
+    if (this.isRunning) {
+      throw new Error("Instance manager is already running");
+    }
+    this.isRunning = true;
+    this.startedAt = /* @__PURE__ */ new Date();
+    this.emit("started");
+  }
+  /**
+   * Stop the instance manager and all instances
+   */
+  async stop() {
+    if (!this.isRunning) {
+      return;
+    }
+    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");
+  }
+  /**
+   * 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 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;
+      }
+      for (const d of usbipdDevices) {
+        logInfo(`  usbipd device: ${d.busId} ${d.vid}:${d.pid} "${d.description}"`);
+      }
+      logWarning(
+        `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;
+    }
+  }
+  /**
+   * Ensure the WSL distribution is running
+   */
+  async ensureWslRunning() {
+    const distro = this.config.wslDistribution;
+    try {
+      if (distro) {
+        logInfo(`Starting WSL distribution: ${distro}...`);
+        await execAsync(`wsl -d ${distro} -- echo "WSL started"`);
+      } else {
+        logInfo("Starting default WSL distribution...");
+        await execAsync(`wsl -- echo "WSL started"`);
+      }
+      return true;
+    } catch (error) {
+      logWarning(`Failed to start WSL: ${error}`);
+      return false;
+    }
+  }
+  /**
+   * Attach a device to WSL via usbipd
+   * Note: This requires administrator privileges
+   */
+  async attachDeviceToWsl(busId) {
+    const distro = this.config.wslDistribution;
+    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;
+    } catch (error) {
+      logWarning(`Failed to attach device ${busId} to WSL: ${error}`);
+      return false;
+    }
+  }
+  /**
+   * Detach a device from WSL via usbipd
+   */
+  async detachDeviceFromWsl(busId) {
+    try {
+      await execAsync(`${USBIPD_PATH} detach --busid=${busId}`);
+      logInfo(`Device ${busId} detached from WSL`);
+    } catch (error) {
+      logWarning(`Failed to detach device ${busId}: ${error}`);
+    }
+  }
+  /**
+   * Handle device connection
+   * Attaches device to WSL, then assigns to an existing instance or creates a new one
+   */
+  async onDeviceConnected(device) {
+    if (this.deviceMappings.has(device.deviceId)) {
+      logWarning(`Device ${device.deviceId} is already connected`);
+      return;
+    }
+    const busId = await this.findBusIdForDevice(device);
+    if (!busId) {
+      logWarning(`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));
+      }
+    }
+    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);
+    const mapping = {
+      udid: device.deviceId,
+      instanceId: targetInstance.id,
+      host: targetInstance.host,
+      port: targetInstance.port,
+      addedAt: /* @__PURE__ */ new Date(),
+      busId: busId ?? void 0
+    };
+    this.deviceMappings.set(device.deviceId, mapping);
+    this.emit("device-assigned", {
+      device,
+      instance: targetInstance,
+      mapping
+    });
+  }
+  /**
+   * 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);
+    if (!mapping) {
+      logWarning(`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}`, {
+        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;
+    }
+  }
+  /**
+   * Handle device disconnection
+   * 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`);
+      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);
+    }
+    this.deviceMappings.delete(device.deviceId);
+    this.emit("device-removed", {
+      device,
+      instance
+    });
+    if (instance.deviceUdids.length === 0) {
+      await this.stopInstance(instance.id);
+    }
+  }
+  /**
+   * Find an instance with available capacity
+   */
+  findInstanceWithCapacity() {
+    for (const instance of this.instances.values()) {
+      if (instance.deviceUdids.length < this.config.batchSize) {
+        return instance;
+      }
+    }
+    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) {
+      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();
+      });
+    });
+    this.instances.delete(instanceId);
+    this.processes.delete(instanceId);
+    for (const [udid, mapping] of this.deviceMappings.entries()) {
+      if (mapping.instanceId === instanceId) {
+        this.deviceMappings.delete(udid);
+      }
+    }
+    this.emit("instance-stopped", instance);
+  }
+  /**
+   * Get device-to-port mapping for a specific UDID
+   */
+  getDevicePort(udid) {
+    const mapping = this.deviceMappings.get(udid);
+    return mapping ? mapping.port : null;
+  }
+  /**
+   * Get all device mappings
+   */
+  getDeviceMappings() {
+    return Array.from(this.deviceMappings.values());
+  }
+  /**
+   * Get all running instances
+   */
+  getInstances() {
+    return Array.from(this.instances.values());
+  }
+  /**
+   * Get manager statistics
+   */
+  getStats() {
+    const now = Date.now();
+    const startTime = this.startedAt?.getTime() || now;
+    const uptimeSeconds = Math.floor((now - startTime) / 1e3);
+    return {
+      instanceCount: this.instances.size,
+      deviceCount: this.deviceMappings.size,
+      uptimeSeconds,
+      startedAt: this.startedAt || /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+
+// src/UsbmuxdService.ts
+var { logInfo: logInfo2, logError } = (0, import_tool_debug_g42.createLoggers)("usbmuxd-instance-manager");
+var UsbmuxdService = class extends import_node_events2.EventEmitter {
+  manager;
+  usbListener;
+  isListening = false;
+  constructor(config = {}) {
+    super();
+    this.manager = new InstanceManager(config);
+    this.usbListener = new import_usb_device_listener.default();
+    this.setupEventHandlers();
+  }
+  /**
+   * Forward manager events to service subscribers (no logging; CLI/examples handle logging).
+   */
+  setupEventHandlers() {
+    this.manager.on("instance-started", (instance) => {
+      this.emit("instance-started", instance);
+    });
+    this.manager.on("instance-stopped", (instance) => {
+      this.emit("instance-stopped", instance);
+    });
+    this.manager.on(
+      "device-assigned",
+      (payload) => {
+        this.emit("device-assigned", payload);
+      }
+    );
+    this.manager.on(
+      "device-removed",
+      (payload) => {
+        this.emit("device-removed", payload);
+      }
+    );
+    this.manager.on(
+      "instance-log",
+      (payload) => {
+        this.emit("instance-log", payload);
+      }
+    );
+    this.manager.on(
+      "instance-exited",
+      (payload) => {
+        this.emit("instance-exited", payload);
+      }
+    );
+    this.manager.on("device-paired", (payload) => {
+      this.emit("device-paired", payload);
+    });
+  }
+  /**
+   * Start the service
+   * Begins monitoring for iOS devices
+   */
+  start() {
+    if (this.isListening) {
+      throw new Error("Service is already running");
+    }
+    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})`);
+    this.usbListener.onDeviceAdd(async (device) => {
+      if (device.vid !== appleVid) {
+        return;
+      }
+      logInfo2(`Apple device connected: ${device.deviceId} (${device.deviceName || "Unknown"})`);
+      try {
+        await this.manager.onDeviceConnected(device);
+      } catch (error) {
+        logError("Error handling device connection:", error);
+      }
+    });
+    this.usbListener.onDeviceRemove(async (device) => {
+      if (device.vid !== appleVid) {
+        return;
+      }
+      logInfo2(`Apple device disconnected: ${device.deviceId}`);
+      try {
+        await this.manager.onDeviceDisconnected(device);
+      } catch (error) {
+        logError("Error handling device disconnection:", error);
+      }
+    });
+    try {
+      this.usbListener.startListening({
+        targetDevices: []
+        // Monitor all devices, we'll filter by VID
+      });
+      this.isListening = true;
+      this.manager.start();
+      logInfo2("Service started successfully");
+      logInfo2("Waiting for iOS devices...");
+    } catch (error) {
+      logError("Failed to start USB listener:", error);
+      throw error;
+    }
+  }
+  /**
+   * Stop the service
+   * Stops monitoring and terminates all instances
+   */
+  async stop() {
+    if (!this.isListening) {
+      return;
+    }
+    logInfo2("Stopping service...");
+    this.usbListener.stopListening();
+    this.isListening = false;
+    await this.manager.stop();
+    logInfo2("Service stopped");
+  }
+  /**
+   * Get device port mapping
+   */
+  getDevicePort(udid) {
+    return this.manager.getDevicePort(udid);
+  }
+  /**
+   * Get all device mappings
+   */
+  getDeviceMappings() {
+    return this.manager.getDeviceMappings();
+  }
+  /**
+   * Get all running instances
+   */
+  getInstances() {
+    return this.manager.getInstances();
+  }
+  /**
+   * Get service statistics
+   */
+  getStats() {
+    return this.manager.getStats();
+  }
+  /**
+   * Get current configuration
+   */
+  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 = {
+  InstanceManager,
+  UsbmuxdService
+});
+//# sourceMappingURL=index.js.map