@mcesystems/apple-kit 1.0.23 → 1.0.25

package/dist/index.mjs

@@ -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"(exports, module) {
     "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;
         }
@@ -793,151 +793,158 @@ var require_src = __commonJS({
   }
 });
 
-// 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
-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;
+// ../../node_modules/.pnpm/get-port@7.1.0/node_modules/get-port/index.js
+import net from "node:net";
+import os from "node:os";
+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 = os.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 = 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 = net.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
 import { exec as execCallback } from "node:child_process";
 import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { promisify } from "node:util";
 
 // src/logic/dataParser.ts
@@ -973,6 +980,13 @@ function parseAppList(output) {
 
 // src/logic/actions/device.ts
 var execAsync = promisify(execCallback);
+function getModuleDir() {
+  if (typeof import.meta !== "undefined" && import.meta.url) {
+    const { fileURLToPath } = __require("node:url");
+    return dirname(fileURLToPath(import.meta.url));
+  }
+  return __dirname;
+}
 async function getDeviceInfo(udid) {
   logTask(`Getting device info for ${udid}`);
   const result = await runIDeviceTool("ideviceinfo", ["-u", udid]);
@@ -1001,12 +1015,17 @@ async function getDeviceInfo(udid) {
   };
 }
 async function runIDeviceTool(toolName, args = [], options = {}) {
-  const command = `"${toolName}${process.platform === "win32" ? ".exe" : ""}" ${args.map((a) => `"${a}"`).join(" ")}`;
+  const binPath = getIDeviceBinPath();
+  const ext = process.platform === "win32" ? ".exe" : "";
+  const toolPath = binPath ? join(binPath, `${toolName}${ext}`) : `${toolName}${ext}`;
+  const command = `"${toolPath}" ${args.map((a) => `"${a}"`).join(" ")}`;
   return execIDevice(command, options);
 }
 async function execIDevice(command, options = {}) {
   const binPath = getIDeviceBinPath();
-  options.cwd = binPath;
+  if (binPath) {
+    options.cwd = binPath;
+  }
   const result = await execAsync(command, {
     ...options,
     env: process.env,
@@ -1018,12 +1037,66 @@ async function execIDevice(command, options = {}) {
     stderr: result.stderr.toString()
   };
 }
+function getPlatformDir() {
+  const platform = process.platform;
+  if (platform === "win32") {
+    return "windows";
+  }
+  if (platform === "darwin") {
+    return "darwin";
+  }
+  if (platform === "linux") {
+    return "linux";
+  }
+  return platform;
+}
+function getBundledResourcesPath() {
+  const moduleDir = getModuleDir();
+  let packageRoot;
+  if (moduleDir.includes("dist")) {
+    packageRoot = join(moduleDir, "..", "..");
+  } else {
+    packageRoot = join(moduleDir, "..", "..", "..", "..");
+  }
+  const platformDir = getPlatformDir();
+  const distPath = join(packageRoot, "dist", "resources", "bin", platformDir);
+  if (existsSync(join(distPath, "idevice_id")) || existsSync(join(distPath, "idevice_id.exe"))) {
+    return distPath;
+  }
+  const devPath = join(packageRoot, "resources", "bin", platformDir);
+  if (existsSync(join(devPath, "idevice_id")) || existsSync(join(devPath, "idevice_id.exe"))) {
+    return devPath;
+  }
+  return null;
+}
 function getResourcesBinPath() {
-  const binPath = process.env.IDeviceBinPath;
-  if (!binPath) {
-    throw new Error("IDeviceBinPath is not set");
+  const envBinPath = process.env.IDeviceBinPath;
+  if (envBinPath) {
+    return envBinPath;
+  }
+  const bundledPath = getBundledResourcesPath();
+  if (bundledPath) {
+    return bundledPath;
+  }
+  if (process.platform === "darwin") {
+    const homebrewArmPath = "/opt/homebrew/bin";
+    if (existsSync(join(homebrewArmPath, "idevice_id"))) {
+      return homebrewArmPath;
+    }
+    const homebrewIntelPath = "/usr/local/bin";
+    if (existsSync(join(homebrewIntelPath, "idevice_id"))) {
+      return homebrewIntelPath;
+    }
   }
-  return binPath;
+  if (process.platform === "linux") {
+    const linuxPaths = ["/usr/bin", "/usr/local/bin"];
+    for (const linuxPath of linuxPaths) {
+      if (existsSync(join(linuxPath, "idevice_id"))) {
+        return linuxPath;
+      }
+    }
+  }
+  return "";
 }
 function getIDeviceBinPath() {
   return getResourcesBinPath();
@@ -1080,7 +1153,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`);
@@ -1095,7 +1168,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 {
@@ -1103,17 +1176,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}`);
@@ -1332,27 +1405,93 @@ async function launchAppWithPymobiledevice3(bundleId, args, udid) {
 
 // src/logic/actions/proxy.ts
 import { spawn } from "node:child_process";
-import { join as join2 } from "node:path";
+import { existsSync as existsSync2 } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+function getModuleDir2() {
+  if (typeof import.meta !== "undefined" && import.meta.url) {
+    const { fileURLToPath } = __require("node:url");
+    return dirname2(fileURLToPath(import.meta.url));
+  }
+  return __dirname;
+}
+function getPlatformDir2() {
+  const platform = process.platform;
+  if (platform === "win32") {
+    return "windows";
+  }
+  if (platform === "darwin") {
+    return "darwin";
+  }
+  if (platform === "linux") {
+    return "linux";
+  }
+  return platform;
+}
+function getBundledResourcesPath2() {
+  const moduleDir = getModuleDir2();
+  let packageRoot;
+  if (moduleDir.includes("dist")) {
+    packageRoot = join2(moduleDir, "..", "..");
+  } else {
+    packageRoot = join2(moduleDir, "..", "..", "..", "..");
+  }
+  const platformDir = getPlatformDir2();
+  const distPath = join2(packageRoot, "dist", "resources", "bin", platformDir);
+  if (existsSync2(join2(distPath, "iproxy")) || existsSync2(join2(distPath, "iproxy.exe"))) {
+    return distPath;
+  }
+  const devPath = join2(packageRoot, "resources", "bin", platformDir);
+  if (existsSync2(join2(devPath, "iproxy")) || existsSync2(join2(devPath, "iproxy.exe"))) {
+    return devPath;
+  }
+  return null;
+}
 function getResourcesBinPath2() {
-  const binPath = process.env.IDeviceBinPath;
-  if (!binPath) {
-    throw new Error("IDeviceBinPath is not set");
+  const envBinPath = process.env.IDeviceBinPath;
+  if (envBinPath) {
+    return envBinPath;
+  }
+  const bundledPath = getBundledResourcesPath2();
+  if (bundledPath) {
+    return bundledPath;
+  }
+  if (process.platform === "darwin") {
+    const homebrewArmPath = "/opt/homebrew/bin";
+    if (existsSync2(join2(homebrewArmPath, "iproxy"))) {
+      return homebrewArmPath;
+    }
+    const homebrewIntelPath = "/usr/local/bin";
+    if (existsSync2(join2(homebrewIntelPath, "iproxy"))) {
+      return homebrewIntelPath;
+    }
   }
-  return binPath;
+  if (process.platform === "linux") {
+    const linuxPaths = ["/usr/bin", "/usr/local/bin"];
+    for (const linuxPath of linuxPaths) {
+      if (existsSync2(join2(linuxPath, "iproxy"))) {
+        return linuxPath;
+      }
+    }
+  }
+  return "";
 }
 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 ext = process.platform === "win32" ? ".exe" : "";
+    const toolPath = binPath ? join2(binPath, `iproxy${ext}`) : `iproxy${ext}`;
+    const spawnOptions = {
+      windowsHide: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    };
+    if (binPath) {
+      spawnOptions.cwd = binPath;
+    }
     const child = spawn(
       toolPath,
       [localPort.toString(), devicePort.toString(), "-u", udid],
-      {
-        cwd: binPath,
-        windowsHide: true,
-        stdio: ["ignore", "pipe", "pipe"]
-      }
+      spawnOptions
     );
     let hasResolved = false;
     let stderrOutput = "";
@@ -1406,11 +1545,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;
+  localDevicePort = null;
   isDisposed = false;
   /**
    * Throws if the kit has been disposed
@@ -1441,9 +1582,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
@@ -1466,9 +1607,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
@@ -1538,10 +1679,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.localDevicePort = await getPorts({ port: portNumbers(3e4, 31e3) });
     const { result, process: process2 } = await startPortForward(
-      this.portAllocation.localPort,
+      this.localDevicePort,
       devicePort,
       this.deviceId,
       startupTimeout
@@ -1563,10 +1703,8 @@ var AppleDeviceKit = class {
    */
   closePortForward() {
     this.killProxyProcess();
-    if (this.portAllocation) {
-      const portManager = getSharedPortManager();
-      portManager.release(this.logicalPort);
-      this.portAllocation = null;
+    if (this.localDevicePort) {
+      this.localDevicePort = null;
     }
   }
   /**
@@ -1606,14 +1744,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.localDevicePort;
   }
   /**
    * Check if this kit has been disposed
@@ -1649,8 +1781,6 @@ var AppleDeviceKit = class {
   }
 };
 export {
-  AppleDeviceKit,
-  PortManager,
-  getSharedPortManager
+  AppleDeviceKit
 };
 //# sourceMappingURL=index.mjs.map