@mcesystems/adb-kit 1.0.22 → 1.0.24

package/dist/index.js

@@ -6155,7 +6155,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: env2 } = process;
@@ -6203,7 +6203,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;
         }
@@ -29717,13 +29717,13 @@ var require_client2 = __commonJS({
     var server_1 = __importDefault(require_server());
     var DeviceClient_1 = __importDefault(require_DeviceClient());
     var Client = class extends events_1.EventEmitter {
-      constructor({ host = "127.0.0.1", port = 5037, bin = "adb", timeout = 0 } = { port: 5037 }) {
+      constructor({ host = "127.0.0.1", port = 5037, bin = "adb", timeout: timeout2 = 0 } = { port: 5037 }) {
         super();
         this.host = host;
         this.port = port;
         this.bin = bin;
-        this.timeout = timeout;
-        this.options = { host, port, bin, timeout };
+        this.timeout = timeout2;
+        this.options = { host, port, bin, timeout: timeout2 };
       }
       createTcpUsbBridge(serial, options) {
         return new server_1.default(this, serial, options);
@@ -30715,6 +30715,141 @@ module.exports = __toCommonJS(index_exports);
 // src/logic/adbDeviceKit.ts
 var adbkit = __toESM(require_dist());
 
+// ../../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`);
+  }
+};
+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);
+    }
+  }
+  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);
+  }
+  for (const host of hosts) {
+    try {
+      await checkAvailablePort({ port: options.port, host });
+    } catch (error) {
+      if (!["EADDRNOTAVAIL", "EINVAL"].includes(error.code)) {
+        throw error;
+      }
+    }
+  }
+  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);
+    }
+  }
+  if (timeout === void 0) {
+    timeout = setTimeout(() => {
+      timeout = void 0;
+      lockedPorts.old = lockedPorts.young;
+      lockedPorts.young = /* @__PURE__ */ new Set();
+    }, releaseOldLockedPortsIntervalMs);
+    if (timeout.unref) {
+      timeout.unref();
+    }
+  }
+  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;
+      }
+    }
+  }
+  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");
+  }
+  if (from < minPort || from > maxPort) {
+    throw new RangeError(`'from' must be between ${minPort} and ${maxPort}`);
+  }
+  if (to < minPort || to > maxPort) {
+    throw new RangeError(`'to' must be between ${minPort} and ${maxPort}`);
+  }
+  if (from > to) {
+    throw new RangeError("`to` must be greater than or equal to `from`");
+  }
+  const generator = function* (from2, to2) {
+    for (let port = from2; port <= to2; port++) {
+      yield port;
+    }
+  };
+  return generator(from, to);
+}
+
 // src/utils/adbPath.ts
 var import_node_fs = require("node:fs");
 var import_node_path = __toESM(require("node:path"));
@@ -30819,6 +30954,7 @@ var AdbDeviceKit = class {
   client;
   device;
   deviceId;
+  devicePort = null;
   async listDevices() {
     const devices = await this.client.listDevices();
     return devices;
@@ -30833,7 +30969,8 @@ var AdbDeviceKit = class {
         chunks.push(chunk);
       }
       return Buffer.concat(chunks).toString().trim();
-    } catch {
+    } catch (error) {
+      logError(`Error getting property ${property} for device ${this.deviceId}: ${error}`);
       return "";
     }
   }
@@ -30886,7 +31023,7 @@ var AdbDeviceKit = class {
     const devices = await this.listDevices();
     return !!devices.find((device) => device.id === this.deviceId);
   }
-  async waitForUsbDebugging(timeout = 12e4) {
+  async waitForUsbDebugging(timeout2 = 12e4) {
     if (await this.hasUsbDebugging()) {
       return true;
     }
@@ -30894,7 +31031,7 @@ var AdbDeviceKit = class {
     return new Promise((resolve, reject) => {
       const timeoutId = setTimeout(() => {
         reject(new Error("Timeout waiting for USB debugging"));
-      }, timeout);
+      }, timeout2);
       tracker.on("remove", (_) => {
         clearTimeout(timeoutId);
       });
@@ -30914,6 +31051,16 @@ var AdbDeviceKit = class {
       });
     });
   }
+  async startPortForward(serviceName) {
+    if (this.devicePort) {
+      return this.devicePort;
+    }
+    const port = await getPorts({ port: portNumbers(3e4, 31e3) });
+    if (await this.device.forward(`tcp:${port}`, serviceName)) {
+      this.devicePort = port;
+    }
+    return this.devicePort;
+  }
   getDeviceId() {
     return this.deviceId;
   }