@mcesystems/apple-kit 1.0.10 → 1.0.11

package/dist/index.mjs

@@ -806,6 +806,134 @@ function logTask(message) {
   debugTask(message);
 }
 
+// src/utils/portManager.ts
+import { createServer } from "node:net";
+var PortManager = class {
+  allocations = /* @__PURE__ */ new Map();
+  basePort;
+  maxPortRange;
+  /**
+   * Create a new PortManager
+   *
+   * @param basePort Starting port number for allocation (default: 30000)
+   * @param maxPortRange Maximum range of ports to search (default: 1000)
+   */
+  constructor(basePort = 3e4, maxPortRange = 1e3) {
+    this.basePort = basePort;
+    this.maxPortRange = maxPortRange;
+  }
+  /**
+   * Find an available port starting from the given port number
+   */
+  async findAvailablePort(startPort) {
+    const maxPort = this.basePort + this.maxPortRange;
+    for (let port = startPort; port < maxPort; port++) {
+      const isAllocated = Array.from(this.allocations.values()).some(
+        (a) => a.localPort === port
+      );
+      if (isAllocated) {
+        continue;
+      }
+      const isAvailable = await this.isPortAvailable(port);
+      if (isAvailable) {
+        return port;
+      }
+    }
+    throw new Error(
+      `No available ports found in range ${startPort}-${maxPort}`
+    );
+  }
+  /**
+   * Check if a port is available for binding
+   */
+  isPortAvailable(port) {
+    return new Promise((resolve) => {
+      const server = createServer();
+      server.once("error", () => {
+        resolve(false);
+      });
+      server.once("listening", () => {
+        server.close(() => {
+          resolve(true);
+        });
+      });
+      server.listen(port, "127.0.0.1");
+    });
+  }
+  /**
+   * Allocate a local port for a logical port
+   *
+   * @param logicalPort The logical port number (USB hub position)
+   * @param devicePort The device port to forward to
+   * @returns The allocated port info
+   */
+  async allocate(logicalPort, devicePort) {
+    const existing = this.allocations.get(logicalPort);
+    if (existing) {
+      logTask(`Reusing existing port allocation for logical port ${logicalPort}: ${existing.localPort}`);
+      return existing;
+    }
+    const preferredPort = this.basePort + logicalPort;
+    let localPort;
+    const preferredAvailable = await this.isPortAvailable(preferredPort);
+    if (preferredAvailable) {
+      localPort = preferredPort;
+    } else {
+      localPort = await this.findAvailablePort(this.basePort);
+    }
+    const allocation = {
+      logicalPort,
+      localPort,
+      devicePort
+    };
+    this.allocations.set(logicalPort, allocation);
+    logTask(`Allocated port ${localPort} for logical port ${logicalPort} -> device port ${devicePort}`);
+    return allocation;
+  }
+  /**
+   * Release the port allocation for a logical port
+   */
+  release(logicalPort) {
+    const allocation = this.allocations.get(logicalPort);
+    if (allocation) {
+      logTask(`Released port ${allocation.localPort} for logical port ${logicalPort}`);
+      this.allocations.delete(logicalPort);
+    }
+  }
+  /**
+   * Get the current allocation for a logical port
+   */
+  getAllocation(logicalPort) {
+    return this.allocations.get(logicalPort);
+  }
+  /**
+   * Get all current allocations
+   */
+  getAllAllocations() {
+    return Array.from(this.allocations.values());
+  }
+  /**
+   * Release all allocations
+   */
+  releaseAll() {
+    logTask(`Releasing all port allocations (${this.allocations.size} ports)`);
+    this.allocations.clear();
+  }
+  /**
+   * Check if a logical port has an allocation
+   */
+  hasAllocation(logicalPort) {
+    return this.allocations.has(logicalPort);
+  }
+};
+var sharedPortManager = null;
+function getSharedPortManager() {
+  if (!sharedPortManager) {
+    sharedPortManager = new PortManager();
+  }
+  return sharedPortManager;
+}
+
 // src/logic/actions/device.ts
 import { exec as execCallback } from "node:child_process";
 import { existsSync } from "node:fs";
@@ -1203,51 +1331,107 @@ async function launchAppWithPymobiledevice3(bundleId, args, udid) {
 }
 
 // src/logic/actions/proxy.ts
-async function startPortForward(localPort, devicePort, udid) {
-  logTask(`Starting port forward ${localPort} -> ${devicePort} for device ${udid}`);
-  const result = await runIDeviceTool("iproxy", [
-    localPort.toString(),
-    devicePort.toString(),
-    "-u",
-    udid
-  ]);
-  return {
-    localPort,
-    devicePort,
-    ...result
-  };
-}
-async function startPortForwardAsync(localPort, devicePort, udid, _timeout = 5e3) {
-  const result = await startPortForward(localPort, devicePort, udid);
-  await new Promise((resolve) => setTimeout(resolve, 500));
-  if (result.stdout.includes("error") || result.stderr.includes("error")) {
-    throw new Error("Port forwarding failed to start");
+import { spawn } from "node:child_process";
+import { join as join2 } from "node:path";
+function getResourcesBinPath2() {
+  const binPath = process.env.IDeviceBinPath;
+  if (!binPath) {
+    throw new Error("IDeviceBinPath is not set");
   }
-  return result;
+  return binPath;
+}
+function startPortForward(localPort, devicePort, udid, startupTimeout = 500) {
+  return new Promise((resolve, reject) => {
+    logTask(`Starting port forward ${localPort} -> ${devicePort} for device ${udid}`);
+    const binPath = getResourcesBinPath2();
+    const toolPath = join2(binPath, `iproxy${process.platform === "win32" ? ".exe" : ""}`);
+    const child = spawn(
+      toolPath,
+      [localPort.toString(), devicePort.toString(), "-u", udid],
+      {
+        cwd: binPath,
+        windowsHide: true,
+        stdio: ["ignore", "pipe", "pipe"]
+      }
+    );
+    let hasResolved = false;
+    let stderrOutput = "";
+    child.stderr?.on("data", (data) => {
+      const msg = data.toString();
+      stderrOutput += msg;
+      if (msg.toLowerCase().includes("error") && !hasResolved) {
+        hasResolved = true;
+        child.kill();
+        reject(new Error(`Port forwarding failed: ${msg}`));
+      }
+    });
+    child.on("error", (error) => {
+      if (!hasResolved) {
+        hasResolved = true;
+        reject(new Error(`Failed to start iproxy: ${error.message}`));
+      }
+    });
+    child.on("exit", (code) => {
+      if (!hasResolved) {
+        hasResolved = true;
+        if (code !== 0 && code !== null) {
+          reject(new Error(`iproxy exited with code ${code}: ${stderrOutput}`));
+        }
+      }
+    });
+    setTimeout(() => {
+      if (!hasResolved) {
+        hasResolved = true;
+        logTask(`Port forward started: ${localPort} -> ${devicePort} for device ${udid}`);
+        resolve({
+          result: {
+            localPort,
+            devicePort
+          },
+          process: child
+        });
+      }
+    }, startupTimeout);
+  });
 }
-async function closePortForward(udid) {
-  logTask(`Closing port forward for device ${udid}`);
-  await runIDeviceTool("iproxy", ["-u", udid, "-c"]);
+function killPortForwardProcess(process2) {
+  if (process2 && !process2.killed) {
+    logTask("Killing port forward process");
+    process2.kill();
+  }
 }
 
 // src/logic/appleDeviceKit.ts
 var AppleDeviceKit = class {
-  constructor(udid, port) {
-    this.port = port;
+  constructor(udid, logicalPort) {
+    this.logicalPort = logicalPort;
     this.deviceId = udid;
-    logInfo(`AppleDeviceKit initialized for device: ${this.deviceId}`);
+    logInfo(`AppleDeviceKit initialized for device: ${this.deviceId}, logical port: ${this.logicalPort}`);
   }
   deviceId;
+  proxyProcess = null;
+  portAllocation = null;
+  isDisposed = false;
+  /**
+   * Throws if the kit has been disposed
+   */
+  ensureNotDisposed() {
+    if (this.isDisposed) {
+      throw new Error("AppleDeviceKit has been disposed");
+    }
+  }
   /**
    * Get detailed device information
    */
   async getDeviceInfo() {
+    this.ensureNotDisposed();
     return getDeviceInfo(this.deviceId);
   }
   /**
    * Check if device is paired/trusted with this computer
    */
   async isPaired() {
+    this.ensureNotDisposed();
     return isPaired(this.deviceId);
   }
   /**
@@ -1258,6 +1442,7 @@ var AppleDeviceKit = class {
    * @param pollInterval Poll interval in milliseconds (default: 1000)
    */
   async waitForPairing(timeout = 12e4, pollInterval = 1e3) {
+    this.ensureNotDisposed();
     return waitForPairing(this.deviceId, timeout, pollInterval);
   }
   /**
@@ -1265,6 +1450,7 @@ var AppleDeviceKit = class {
    * User must accept the trust dialog on the device
    */
   async pair() {
+    this.ensureNotDisposed();
     return pair(this.deviceId);
   }
   /**
@@ -1281,12 +1467,14 @@ var AppleDeviceKit = class {
    * @returns true if device is now trusted
    */
   async trustDevice(timeout = 6e4, onWaitingForTrust) {
+    this.ensureNotDisposed();
     return trustDevice(this.deviceId, timeout, onWaitingForTrust);
   }
   /**
    * Unpair/untrust the device
    */
   async unpair() {
+    this.ensureNotDisposed();
     return unpair(this.deviceId);
   }
   /**
@@ -1295,6 +1483,7 @@ var AppleDeviceKit = class {
    * @param ipaPath Path to the IPA file
    */
   async installApp(ipaPath) {
+    this.ensureNotDisposed();
     installApp(ipaPath, this.deviceId);
   }
   /**
@@ -1303,6 +1492,7 @@ var AppleDeviceKit = class {
    * @param bundleId Application bundle identifier
    */
   async uninstallApp(bundleId) {
+    this.ensureNotDisposed();
     uninstallApp(bundleId, this.deviceId);
   }
   /**
@@ -1311,12 +1501,14 @@ var AppleDeviceKit = class {
    * @param bundleId Application bundle identifier
    */
   async isAppInstalled(bundleId) {
+    this.ensureNotDisposed();
     return isAppInstalled(bundleId, this.deviceId);
   }
   /**
    * List all installed user applications
    */
   async listApps() {
+    this.ensureNotDisposed();
     return listApps(this.deviceId);
   }
   /**
@@ -1326,24 +1518,62 @@ var AppleDeviceKit = class {
    * @param args Application arguments
    */
   async launchApp(bundleId, args = []) {
+    this.ensureNotDisposed();
     return launchApp(bundleId, args, this.deviceId);
   }
   /**
    * Start port forwarding and wait for it to be ready.
-   * we need port forwarding to be able to connect to the device from the computer
+   * The local port is automatically allocated based on the logical port.
+   *
+   * We need port forwarding to be able to connect to the device from the computer
    * and communicate with it using the local port.
    *
-   * @param localPort Local port to listen on
+   * Note: Only one port forward can be active at a time per kit instance.
+   * Starting a new port forward will kill any existing one.
+   *
    * @param devicePort Device port to forward to
-   * @param _timeout Timeout in milliseconds (reserved for future use)
+   * @param startupTimeout Time to wait for proxy to start (ms)
+   * @returns The port forward result with the allocated local port
+   */
+  async startPortForwardAsync(devicePort, startupTimeout = 500) {
+    this.ensureNotDisposed();
+    this.killProxyProcess();
+    const portManager = getSharedPortManager();
+    this.portAllocation = await portManager.allocate(this.logicalPort, devicePort);
+    const { result, process: process2 } = await startPortForward(
+      this.portAllocation.localPort,
+      devicePort,
+      this.deviceId,
+      startupTimeout
+    );
+    this.proxyProcess = process2;
+    return result;
+  }
+  /**
+   * Kill the current port forwarding process if running
    */
-  async startPortForwardAsync(localPort, devicePort, _timeout = 5e3) {
-    return startPortForwardAsync(localPort, devicePort, this.deviceId);
+  killProxyProcess() {
+    if (this.proxyProcess) {
+      killPortForwardProcess(this.proxyProcess);
+      this.proxyProcess = null;
+    }
+  }
+  /**
+   * Close the current port forwarding session and release the port
+   */
+  closePortForward() {
+    this.killProxyProcess();
+    if (this.portAllocation) {
+      const portManager = getSharedPortManager();
+      portManager.release(this.logicalPort);
+      this.portAllocation = null;
+    }
   }
   /**
    * Get the activation state of the device
    */
   async getActivationState() {
+    this.ensureNotDisposed();
     return getActivationState(this.deviceId);
   }
   /**
@@ -1357,6 +1587,7 @@ var AppleDeviceKit = class {
    * precondition: the device must be paired and trusted
    */
   async activate() {
+    this.ensureNotDisposed();
     return activate(this.deviceId);
   }
   /**
@@ -1366,16 +1597,60 @@ var AppleDeviceKit = class {
     return this.deviceId;
   }
   /**
-   * Get the logical port number
+   * Get the logical port number (USB hub position)
+   */
+  getLogicalPort() {
+    return this.logicalPort;
+  }
+  /**
+   * Get the currently allocated local port for forwarding
+   * Returns undefined if no port forward is active
+   */
+  getAllocatedPort() {
+    return this.portAllocation?.localPort;
+  }
+  /**
+   * Get the current port allocation info
+   */
+  getPortAllocation() {
+    return this.portAllocation;
+  }
+  /**
+   * Check if this kit has been disposed
    */
-  getPort() {
-    return this.port;
+  get disposed() {
+    return this.isDisposed;
   }
-  async closePortForward() {
-    return closePortForward(this.deviceId);
+  /**
+   * Check if a port forward is currently active
+   */
+  get hasActivePortForward() {
+    return this.proxyProcess !== null && !this.proxyProcess.killed;
+  }
+  /**
+   * Dispose of the kit and clean up all resources.
+   * This will kill any running proxy processes and release port allocations.
+   *
+   * After calling dispose(), the kit instance should not be used.
+   */
+  dispose() {
+    if (this.isDisposed) {
+      return;
+    }
+    logInfo(`Disposing AppleDeviceKit for device: ${this.deviceId}`);
+    this.closePortForward();
+    this.isDisposed = true;
+  }
+  /**
+   * Symbol.dispose implementation for using with `using` keyword (TypeScript 5.2+)
+   */
+  [Symbol.dispose]() {
+    this.dispose();
   }
 };
 export {
-  AppleDeviceKit
+  AppleDeviceKit,
+  PortManager,
+  getSharedPortManager
 };
 //# sourceMappingURL=index.mjs.map