@mcesystems/apple-kit 1.0.22 → 1.0.24

package/dist/index.js

@@ -510,7 +510,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js"(exports2, module2) {
     "use strict";
-    var os = require("os");
+    var os2 = require("os");
     var tty = require("tty");
     var hasFlag = require_has_flag();
     var { env } = process;
@@ -558,7 +558,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os.release().split(".");
+        const osRelease = os2.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -796,151 +796,156 @@ var require_src = __commonJS({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  AppleDeviceKit: () => AppleDeviceKit,
-  PortManager: () => PortManager,
-  getSharedPortManager: () => getSharedPortManager
+  AppleDeviceKit: () => AppleDeviceKit
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/utils/debug.ts
-var import_debug = __toESM(require_src());
-var debug = (0, import_debug.default)("apple-kit");
-var debugTask = (0, import_debug.default)("apple-kit:task");
-var debugWarning = (0, import_debug.default)("apple-kit:warning");
-var debugError = (0, import_debug.default)("apple-kit:error");
-function logInfo(message) {
-  debug(message);
-}
-function logTask(message) {
-  debugTask(message);
-}
-
-// src/utils/portManager.ts
-var import_node_net = require("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;
+// ../../node_modules/.pnpm/get-port@7.1.0/node_modules/get-port/index.js
+var import_node_net = __toESM(require("node:net"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var Locked = class extends Error {
+  constructor(port) {
+    super(`${port} is locked`);
   }
-  /**
-   * 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;
-      }
+};
+var lockedPorts = {
+  old: /* @__PURE__ */ new Set(),
+  young: /* @__PURE__ */ new Set()
+};
+var releaseOldLockedPortsIntervalMs = 1e3 * 15;
+var minPort = 1024;
+var maxPort = 65535;
+var timeout;
+var getLocalHosts = () => {
+  const interfaces = import_node_os.default.networkInterfaces();
+  const results = /* @__PURE__ */ new Set([void 0, "0.0.0.0"]);
+  for (const _interface of Object.values(interfaces)) {
+    for (const config of _interface) {
+      results.add(config.address);
     }
-    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 = (0, import_node_net.createServer)();
-      server.once("error", () => {
-        resolve(false);
-      });
-      server.once("listening", () => {
-        server.close(() => {
-          resolve(true);
-        });
-      });
-      server.listen(port, "127.0.0.1");
+  return results;
+};
+var checkAvailablePort = (options) => new Promise((resolve, reject) => {
+  const server = import_node_net.default.createServer();
+  server.unref();
+  server.on("error", reject);
+  server.listen(options, () => {
+    const { port } = server.address();
+    server.close(() => {
+      resolve(port);
     });
+  });
+});
+var getAvailablePort = async (options, hosts) => {
+  if (options.host || options.port === 0) {
+    return checkAvailablePort(options);
   }
-  /**
-   * 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;
+  for (const host of hosts) {
+    try {
+      await checkAvailablePort({ port: options.port, host });
+    } catch (error) {
+      if (!["EADDRNOTAVAIL", "EINVAL"].includes(error.code)) {
+        throw error;
+      }
     }
-    const preferredPort = this.basePort + logicalPort;
-    let localPort;
-    const preferredAvailable = await this.isPortAvailable(preferredPort);
-    if (preferredAvailable) {
-      localPort = preferredPort;
-    } else {
-      localPort = await this.findAvailablePort(this.basePort);
+  }
+  return options.port;
+};
+var portCheckSequence = function* (ports) {
+  if (ports) {
+    yield* ports;
+  }
+  yield 0;
+};
+async function getPorts(options) {
+  let ports;
+  let exclude = /* @__PURE__ */ new Set();
+  if (options) {
+    if (options.port) {
+      ports = typeof options.port === "number" ? [options.port] : options.port;
+    }
+    if (options.exclude) {
+      const excludeIterable = options.exclude;
+      if (typeof excludeIterable[Symbol.iterator] !== "function") {
+        throw new TypeError("The `exclude` option must be an iterable.");
+      }
+      for (const element of excludeIterable) {
+        if (typeof element !== "number") {
+          throw new TypeError("Each item in the `exclude` option must be a number corresponding to the port you want excluded.");
+        }
+        if (!Number.isSafeInteger(element)) {
+          throw new TypeError(`Number ${element} in the exclude option is not a safe integer and can't be used`);
+        }
+      }
+      exclude = new Set(excludeIterable);
     }
-    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);
+  if (timeout === void 0) {
+    timeout = setTimeout(() => {
+      timeout = void 0;
+      lockedPorts.old = lockedPorts.young;
+      lockedPorts.young = /* @__PURE__ */ new Set();
+    }, releaseOldLockedPortsIntervalMs);
+    if (timeout.unref) {
+      timeout.unref();
     }
   }
-  /**
-   * Get the current allocation for a logical port
-   */
-  getAllocation(logicalPort) {
-    return this.allocations.get(logicalPort);
+  const hosts = getLocalHosts();
+  for (const port of portCheckSequence(ports)) {
+    try {
+      if (exclude.has(port)) {
+        continue;
+      }
+      let availablePort = await getAvailablePort({ ...options, port }, hosts);
+      while (lockedPorts.old.has(availablePort) || lockedPorts.young.has(availablePort)) {
+        if (port !== 0) {
+          throw new Locked(port);
+        }
+        availablePort = await getAvailablePort({ ...options, port }, hosts);
+      }
+      lockedPorts.young.add(availablePort);
+      return availablePort;
+    } catch (error) {
+      if (!["EADDRINUSE", "EACCES"].includes(error.code) && !(error instanceof Locked)) {
+        throw error;
+      }
+    }
   }
-  /**
-   * Get all current allocations
-   */
-  getAllAllocations() {
-    return Array.from(this.allocations.values());
+  throw new Error("No available ports found");
+}
+function portNumbers(from, to) {
+  if (!Number.isInteger(from) || !Number.isInteger(to)) {
+    throw new TypeError("`from` and `to` must be integer numbers");
   }
-  /**
-   * Release all allocations
-   */
-  releaseAll() {
-    logTask(`Releasing all port allocations (${this.allocations.size} ports)`);
-    this.allocations.clear();
+  if (from < minPort || from > maxPort) {
+    throw new RangeError(`'from' must be between ${minPort} and ${maxPort}`);
   }
-  /**
-   * Check if a logical port has an allocation
-   */
-  hasAllocation(logicalPort) {
-    return this.allocations.has(logicalPort);
+  if (to < minPort || to > maxPort) {
+    throw new RangeError(`'to' must be between ${minPort} and ${maxPort}`);
   }
-};
-var sharedPortManager = null;
-function getSharedPortManager() {
-  if (!sharedPortManager) {
-    sharedPortManager = new PortManager();
+  if (from > to) {
+    throw new RangeError("`to` must be greater than or equal to `from`");
   }
-  return sharedPortManager;
+  const generator = function* (from2, to2) {
+    for (let port = from2; port <= to2; port++) {
+      yield port;
+    }
+  };
+  return generator(from, to);
+}
+
+// src/utils/debug.ts
+var import_debug = __toESM(require_src());
+var debug = (0, import_debug.default)("apple-kit");
+var debugTask = (0, import_debug.default)("apple-kit:task");
+var debugWarning = (0, import_debug.default)("apple-kit:warning");
+var debugError = (0, import_debug.default)("apple-kit:error");
+function logInfo(message) {
+  debug(message);
+}
+function logTask(message) {
+  debugTask(message);
 }
 
 // src/logic/actions/device.ts
@@ -1089,7 +1094,7 @@ async function isPaired(udid) {
     return false;
   }
 }
-async function trustDevice(udid, timeout = 6e4, onWaitingForTrust) {
+async function trustDevice(udid, timeout2 = 6e4, onWaitingForTrust) {
   logTask(`Trusting device ${udid}`);
   if (await isPaired(udid)) {
     logInfo(`Device ${udid} is already trusted`);
@@ -1104,7 +1109,7 @@ async function trustDevice(udid, timeout = 6e4, onWaitingForTrust) {
   logInfo("Please accept the trust dialog on the device...");
   onWaitingForTrust?.();
   try {
-    await waitForPairing(udid, timeout, 1e3);
+    await waitForPairing(udid, timeout2, 1e3);
     logInfo(`Device ${udid} is now trusted`);
     return true;
   } catch {
@@ -1112,17 +1117,17 @@ async function trustDevice(udid, timeout = 6e4, onWaitingForTrust) {
     return false;
   }
 }
-async function waitForPairing(udid, timeout = 12e4, pollInterval = 1e3) {
+async function waitForPairing(udid, timeout2 = 12e4, pollInterval = 1e3) {
   logTask(`Waiting for pairing on device ${udid}`);
   const startTime = Date.now();
-  while (Date.now() - startTime < timeout) {
+  while (Date.now() - startTime < timeout2) {
     if (await isPaired(udid)) {
       logInfo(`Device ${udid} is now paired`);
       return true;
     }
     await new Promise((resolve) => setTimeout(resolve, pollInterval));
   }
-  throw new Error(`Timeout waiting for device pairing after ${timeout}ms`);
+  throw new Error(`Timeout waiting for device pairing after ${timeout2}ms`);
 }
 async function pair(udid) {
   logTask(`Initiating pairing for device ${udid}`);
@@ -1415,11 +1420,13 @@ var AppleDeviceKit = class {
   constructor(udid, logicalPort) {
     this.logicalPort = logicalPort;
     this.deviceId = udid;
-    logInfo(`AppleDeviceKit initialized for device: ${this.deviceId}, logical port: ${this.logicalPort}`);
+    logInfo(
+      `AppleDeviceKit initialized for device: ${this.deviceId}, logical port: ${this.logicalPort}`
+    );
   }
   deviceId;
   proxyProcess = null;
-  portAllocation = null;
+  devicePort = null;
   isDisposed = false;
   /**
    * Throws if the kit has been disposed
@@ -1450,9 +1457,9 @@ var AppleDeviceKit = class {
    * @param timeout Timeout in milliseconds (default: 120000)
    * @param pollInterval Poll interval in milliseconds (default: 1000)
    */
-  async waitForPairing(timeout = 12e4, pollInterval = 1e3) {
+  async waitForPairing(timeout2 = 12e4, pollInterval = 1e3) {
     this.ensureNotDisposed();
-    return waitForPairing(this.deviceId, timeout, pollInterval);
+    return waitForPairing(this.deviceId, timeout2, pollInterval);
   }
   /**
    * Attempt to pair/trust the device
@@ -1475,9 +1482,9 @@ var AppleDeviceKit = class {
    * @param onWaitingForTrust Callback when waiting for user to accept trust dialog
    * @returns true if device is now trusted
    */
-  async trustDevice(timeout = 6e4, onWaitingForTrust) {
+  async trustDevice(timeout2 = 6e4, onWaitingForTrust) {
     this.ensureNotDisposed();
-    return trustDevice(this.deviceId, timeout, onWaitingForTrust);
+    return trustDevice(this.deviceId, timeout2, onWaitingForTrust);
   }
   /**
    * Unpair/untrust the device
@@ -1547,10 +1554,9 @@ var AppleDeviceKit = class {
   async startPortForwardAsync(devicePort, startupTimeout = 500) {
     this.ensureNotDisposed();
     this.killProxyProcess();
-    const portManager = getSharedPortManager();
-    this.portAllocation = await portManager.allocate(this.logicalPort, devicePort);
+    this.devicePort = await getPorts({ port: portNumbers(3e4, 31e3) });
     const { result, process: process2 } = await startPortForward(
-      this.portAllocation.localPort,
+      this.devicePort,
       devicePort,
       this.deviceId,
       startupTimeout
@@ -1572,10 +1578,8 @@ var AppleDeviceKit = class {
    */
   closePortForward() {
     this.killProxyProcess();
-    if (this.portAllocation) {
-      const portManager = getSharedPortManager();
-      portManager.release(this.logicalPort);
-      this.portAllocation = null;
+    if (this.devicePort) {
+      this.devicePort = null;
     }
   }
   /**
@@ -1615,14 +1619,8 @@ var AppleDeviceKit = class {
    * 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;
+  getDevicePort() {
+    return this.devicePort;
   }
   /**
    * Check if this kit has been disposed
@@ -1659,8 +1657,6 @@ var AppleDeviceKit = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AppleDeviceKit,
-  PortManager,
-  getSharedPortManager
+  AppleDeviceKit
 });
 //# sourceMappingURL=index.js.map