homey-api 3.17.6 → 3.17.7

package/assets/types/homey-api.private.d.ts

@@ -5748,6 +5748,8 @@ export class Util {
     timeoutDuration?: number,
 
     timeoutMessage?: string,
+
+    patchOptions?: Function,
   ): Promise<any>;
 
   static wait(ms: number): Promise<void>;
@@ -5790,6 +5792,8 @@ export class Util {
     timeoutDuration?: number,
 
     timeoutMessage?: string,
+
+    patchOptions?: Function,
   ): Promise<any>;
 
   static wait(ms: number): Promise<void>;
@@ -9166,6 +9170,8 @@ export class Util {
     timeoutDuration?: number,
 
     timeoutMessage?: string,
+
+    patchOptions?: Function,
   ): Promise<any>;
 
   static wait(ms: number): Promise<void>;
@@ -9208,6 +9214,8 @@ export class Util {
     timeoutDuration?: number,
 
     timeoutMessage?: string,
+
+    patchOptions?: Function,
   ): Promise<any>;
 
   static wait(ms: number): Promise<void>;

package/lib/HomeyAPI/HomeyAPIV3/DiscoveryManager.js

@@ -5,9 +5,16 @@ const APIErrorHomeySubscriptionInactive = require('../../APIErrorHomeySubscripti
 const APIErrorHomeyInvalidSerialNumber = require('../../APIErrorHomeyInvalidSerialNumber');
 const Util = require('../../Util');
 
+function getRuntimeRequire() {
+  // Avoid webpack statically bundling Node-only discovery transport into the browser build.
+  // eslint-disable-next-line no-eval
+  return eval('require');
+}
+
 class DiscoveryManager {
   constructor(homey) {
     this.homey = homey;
+    this.discoveryNodeTransport = null;
   }
 
   async discoverBaseUrl() {
@@ -17,7 +24,10 @@ class DiscoveryManager {
     if (this.homey.__strategies.includes(DISCOVERY_STRATEGIES.MDNS)) {
       if (Util.isHTTPUnsecureSupported()) {
         if (this.homey.__properties.mdnsFqdn) {
-          const port = this.homey.__properties.portHttp && this.homey.__properties.portHttp !== 80 ? `:${this.homey.__properties.portHttp}` : '';
+          const port =
+            this.homey.__properties.portHttp && this.homey.__properties.portHttp !== 80
+              ? `:${this.homey.__properties.portHttp}`
+              : '';
           urls[DISCOVERY_STRATEGIES.MDNS] = `http://${this.homey.__properties.mdnsFqdn}${port}`;
         } else {
           urls[DISCOVERY_STRATEGIES.MDNS] = `http://homey-${this.homey.id}.local`;
@@ -112,18 +122,24 @@ class DiscoveryManager {
 
     const ping = async (strategyId, timeout) => {
       const baseUrl = urls[strategyId];
+      const pingUrl = `${baseUrl}/api/manager/system/ping?id=${this.homey.id}`;
       const abortController = new AbortController();
       pingAbortControllers[strategyId] = abortController;
-
-      const response = await Util.fetch(
-        `${baseUrl}/api/manager/system/ping?id=${this.homey.id}`,
+      const discoveryTransport = this.getDiscoveryNodeTransport();
+      const fetch =
+        discoveryTransport && discoveryTransport.shouldUseForUrl(pingUrl)
+          ? discoveryTransport.fetch.bind(discoveryTransport)
+          : Util.fetch.bind(Util);
+
+      const response = await fetch(
+        pingUrl,
         {
           headers: {
             'X-Homey-ID': this.homey.id,
           },
           signal: abortController.signal,
         },
-        timeout
+        timeout,
       );
 
       const text = await response.text();
@@ -180,15 +196,9 @@ class DiscoveryManager {
     const pings = {};
 
     if (urls[DISCOVERY_STRATEGIES.LOCAL_SECURE]) {
-      pings[DISCOVERY_STRATEGIES.LOCAL_SECURE] = ping(
-        DISCOVERY_STRATEGIES.LOCAL_SECURE,
-        1200
-      );
+      pings[DISCOVERY_STRATEGIES.LOCAL_SECURE] = ping(DISCOVERY_STRATEGIES.LOCAL_SECURE, 1200);
       pings[DISCOVERY_STRATEGIES.LOCAL_SECURE].catch((err) => {
-        this.homey.__debug(
-          `Ping ${DISCOVERY_STRATEGIES.LOCAL_SECURE} Error:`,
-          err && err.message
-        );
+        this.homey.__debug(`Ping ${DISCOVERY_STRATEGIES.LOCAL_SECURE} Error:`, err && err.message);
         this.homey.__debug(urls[DISCOVERY_STRATEGIES.LOCAL_SECURE]);
       });
     }
@@ -196,34 +206,34 @@ class DiscoveryManager {
     if (urls[DISCOVERY_STRATEGIES.LOCAL]) {
       pings[DISCOVERY_STRATEGIES.LOCAL] = ping(DISCOVERY_STRATEGIES.LOCAL, 1000);
       pings[DISCOVERY_STRATEGIES.LOCAL].catch((err) =>
-        this.homey.__debug(`Ping ${DISCOVERY_STRATEGIES.LOCAL} Error:`, err && err.message)
+        this.homey.__debug(`Ping ${DISCOVERY_STRATEGIES.LOCAL} Error:`, err && err.message),
       );
     }
 
     if (urls[DISCOVERY_STRATEGIES.MDNS]) {
       pings[DISCOVERY_STRATEGIES.MDNS] = ping(DISCOVERY_STRATEGIES.MDNS, 3000);
       pings[DISCOVERY_STRATEGIES.MDNS].catch((err) =>
-        this.homey.__debug(`Ping ${DISCOVERY_STRATEGIES.MDNS} Error:`, err && err.message)
+        this.homey.__debug(`Ping ${DISCOVERY_STRATEGIES.MDNS} Error:`, err && err.message),
       );
     }
 
     if (urls[DISCOVERY_STRATEGIES.CLOUD]) {
       pings[DISCOVERY_STRATEGIES.CLOUD] = ping(DISCOVERY_STRATEGIES.CLOUD, 5000);
       pings[DISCOVERY_STRATEGIES.CLOUD].catch((err) =>
-        this.homey.__debug(`Ping ${DISCOVERY_STRATEGIES.CLOUD} Error:`, err && err.message)
+        this.homey.__debug(`Ping ${DISCOVERY_STRATEGIES.CLOUD} Error:`, err && err.message),
       );
     }
 
     if (urls[DISCOVERY_STRATEGIES.REMOTE_FORWARDED]) {
       pings[DISCOVERY_STRATEGIES.REMOTE_FORWARDED] = ping(
         DISCOVERY_STRATEGIES.REMOTE_FORWARDED,
-        2000
+        2000,
       );
       pings[DISCOVERY_STRATEGIES.REMOTE_FORWARDED].catch((err) =>
         this.homey.__debug(
           `Ping ${DISCOVERY_STRATEGIES.REMOTE_FORWARDED} Error:`,
-          err && err.message
-        )
+          err && err.message,
+        ),
       );
     }
 
@@ -240,36 +250,35 @@ class DiscoveryManager {
     let selectedRoutePromise;
 
     if (pings[DISCOVERY_STRATEGIES.LOCAL_SECURE]) {
-      selectedRoutePromise = pings[DISCOVERY_STRATEGIES.LOCAL_SECURE]
-        .catch((error) => {
-          const fallbackPromises = [];
+      selectedRoutePromise = pings[DISCOVERY_STRATEGIES.LOCAL_SECURE].catch((error) => {
+        const fallbackPromises = [];
 
-          if (pings[DISCOVERY_STRATEGIES.LOCAL]) {
-            fallbackPromises.push(pings[DISCOVERY_STRATEGIES.LOCAL]);
-          }
+        if (pings[DISCOVERY_STRATEGIES.LOCAL]) {
+          fallbackPromises.push(pings[DISCOVERY_STRATEGIES.LOCAL]);
+        }
 
-          if (pings[DISCOVERY_STRATEGIES.REMOTE_FORWARDED]) {
-            fallbackPromises.push(pings[DISCOVERY_STRATEGIES.REMOTE_FORWARDED]);
-          }
+        if (pings[DISCOVERY_STRATEGIES.REMOTE_FORWARDED]) {
+          fallbackPromises.push(pings[DISCOVERY_STRATEGIES.REMOTE_FORWARDED]);
+        }
 
-          if (pings[DISCOVERY_STRATEGIES.MDNS]) {
-            fallbackPromises.push(pings[DISCOVERY_STRATEGIES.MDNS]);
-          }
+        if (pings[DISCOVERY_STRATEGIES.MDNS]) {
+          fallbackPromises.push(pings[DISCOVERY_STRATEGIES.MDNS]);
+        }
 
-          if (pings[DISCOVERY_STRATEGIES.CLOUD]) {
-            fallbackPromises.push(pings[DISCOVERY_STRATEGIES.CLOUD]);
-          }
+        if (pings[DISCOVERY_STRATEGIES.CLOUD]) {
+          fallbackPromises.push(pings[DISCOVERY_STRATEGIES.CLOUD]);
+        }
 
-          if (isSubscriptionError(error)) {
-            throw error;
-          }
+        if (isSubscriptionError(error)) {
+          throw error;
+        }
 
-          if (!fallbackPromises.length) {
-            throw new APIErrorHomeyOffline();
-          }
+        if (!fallbackPromises.length) {
+          throw new APIErrorHomeyOffline();
+        }
 
-          return Promise.any(fallbackPromises);
-        });
+        return Promise.any(fallbackPromises);
+      });
     } else if (pings[DISCOVERY_STRATEGIES.LOCAL]) {
       selectedRoutePromise = withCloudFallback(pings[DISCOVERY_STRATEGIES.LOCAL]);
     } else if (pings[DISCOVERY_STRATEGIES.MDNS]) {
@@ -290,6 +299,17 @@ class DiscoveryManager {
 
     return promise;
   }
+
+  getDiscoveryNodeTransport() {
+    if (!Util.isNodeJS()) {
+      return null;
+    }
+
+    this.discoveryNodeTransport =
+      this.discoveryNodeTransport || getRuntimeRequire()('./DiscoveryNodeTransport');
+
+    return this.discoveryNodeTransport;
+  }
 }
 
-module.exports = DiscoveryManager;
+module.exports = DiscoveryManager;

package/lib/HomeyAPI/HomeyAPIV3/DiscoveryNodeTransport.js

@@ -0,0 +1,589 @@
+'use strict';
+
+const Util = require('../../Util');
+
+const DNS_RECORD_TYPES = {
+  A: 0x0001,
+  AAAA: 0x001c,
+};
+
+const DNS_CLASS_IN = 0x0001;
+const DNS_CLASS_QU = 0x8000;
+
+function getNodeHttpModules() {
+  return {
+    http: require('node:http'),
+    https: require('node:https'),
+  };
+}
+
+function getDnsModule() {
+  return require('node:dns');
+}
+
+function getDgramModule() {
+  return require('node:dgram');
+}
+
+function getNetModule() {
+  return require('node:net');
+}
+
+function createAbortError(reason) {
+  const error = new Error(
+    typeof reason === 'string' && reason.length > 0 ? reason : 'The operation was aborted',
+  );
+  error.name = 'AbortError';
+  error.code = 'ABORT_ERR';
+  error.type = 'aborted';
+  return error;
+}
+
+function getHostname(url) {
+  try {
+    return new URL(url).hostname;
+  } catch (error) {
+    return null;
+  }
+}
+
+function normalizeHostname(hostname) {
+  return String(hostname || '')
+    .replace(/\.$/, '')
+    .toLowerCase();
+}
+
+function shouldUseResolverLookupForHostname(hostname) {
+  return normalizeHostname(hostname).endsWith('.homey.homeylocal.com');
+}
+
+function shouldUseMdnsLookupForHostname(hostname) {
+  return normalizeHostname(hostname).endsWith('.local');
+}
+
+function getMdnsQueryTypes(options) {
+  const family = Number(options?.family) || 0;
+
+  if (family === 6) {
+    return [DNS_RECORD_TYPES.AAAA];
+  }
+
+  return [DNS_RECORD_TYPES.A];
+}
+
+function getMdnsConfig() {
+  const host = process.env.HOMEY_DISCOVERY_MDNS_HOST || '224.0.0.251';
+  const port = Number(process.env.HOMEY_DISCOVERY_MDNS_PORT) || 5353;
+
+  return {
+    host,
+    port,
+    joinMulticast: host === '224.0.0.251',
+  };
+}
+
+function encodeDnsName(hostname) {
+  const labels = normalizeHostname(hostname).split('.');
+  const parts = [];
+
+  for (const label of labels) {
+    const encodedLabel = Buffer.from(label);
+    parts.push(Buffer.from([encodedLabel.length]));
+    parts.push(encodedLabel);
+  }
+
+  parts.push(Buffer.from([0]));
+
+  return Buffer.concat(parts);
+}
+
+function buildMdnsQuestion(hostname, type) {
+  const question = Buffer.alloc(4);
+  question.writeUInt16BE(type, 0);
+  question.writeUInt16BE(DNS_CLASS_IN | DNS_CLASS_QU, 2);
+
+  return Buffer.concat([encodeDnsName(hostname), question]);
+}
+
+function buildMdnsQuery(hostname, options) {
+  const types = getMdnsQueryTypes(options);
+  const header = Buffer.alloc(12);
+
+  header.writeUInt16BE(0, 0);
+  header.writeUInt16BE(0, 2);
+  header.writeUInt16BE(types.length, 4);
+
+  return Buffer.concat([
+    header,
+    ...types.map((type) => buildMdnsQuestion(hostname, type)),
+  ]);
+}
+
+function readDnsName(buffer, offset, visited = new Set()) {
+  const labels = [];
+  let cursor = offset;
+
+  while (cursor < buffer.length) {
+    const length = buffer[cursor];
+
+    if (length === 0) {
+      return {
+        name: labels.join('.'),
+        offset: cursor + 1,
+      };
+    }
+
+    if ((length & 0xc0) === 0xc0) {
+      if (cursor + 1 >= buffer.length) {
+        throw new Error('Invalid DNS name pointer');
+      }
+
+      const pointer = ((length & 0x3f) << 8) | buffer[cursor + 1];
+
+      if (visited.has(pointer)) {
+        throw new Error('Invalid DNS name compression loop');
+      }
+
+      visited.add(pointer);
+
+      const result = readDnsName(buffer, pointer, visited);
+
+      if (result.name) {
+        labels.push(result.name);
+      }
+
+      return {
+        name: labels.join('.'),
+        offset: cursor + 2,
+      };
+    }
+
+    const labelStart = cursor + 1;
+    const labelEnd = labelStart + length;
+
+    if (labelEnd > buffer.length) {
+      throw new Error('Invalid DNS label length');
+    }
+
+    labels.push(buffer.toString('utf8', labelStart, labelEnd));
+    cursor = labelEnd;
+  }
+
+  throw new Error('Invalid DNS name');
+}
+
+function decodeIPv6Address(buffer, offset) {
+  const segments = [];
+
+  for (let index = 0; index < 8; index++) {
+    segments.push(buffer.readUInt16BE(offset + index * 2).toString(16));
+  }
+
+  return segments.join(':');
+}
+
+function parseDnsAddresses(buffer, hostname) {
+  if (buffer.length < 12) {
+    return [];
+  }
+
+  const normalizedHostname = normalizeHostname(hostname);
+  const questionCount = buffer.readUInt16BE(4);
+  const answerCount = buffer.readUInt16BE(6);
+  const authorityCount = buffer.readUInt16BE(8);
+  const additionalCount = buffer.readUInt16BE(10);
+  const recordCount = answerCount + authorityCount + additionalCount;
+  const addresses = [];
+  let offset = 12;
+
+  for (let index = 0; index < questionCount; index++) {
+    const question = readDnsName(buffer, offset);
+    offset = question.offset + 4;
+
+    if (offset > buffer.length) {
+      return [];
+    }
+  }
+
+  for (let index = 0; index < recordCount; index++) {
+    const recordName = readDnsName(buffer, offset);
+    offset = recordName.offset;
+
+    if (offset + 10 > buffer.length) {
+      return [];
+    }
+
+    const type = buffer.readUInt16BE(offset);
+    const klass = buffer.readUInt16BE(offset + 2) & 0x7fff;
+    const dataLength = buffer.readUInt16BE(offset + 8);
+    const dataOffset = offset + 10;
+    const nextOffset = dataOffset + dataLength;
+
+    if (nextOffset > buffer.length) {
+      return [];
+    }
+
+    if (klass === DNS_CLASS_IN && normalizeHostname(recordName.name) === normalizedHostname) {
+      if (type === DNS_RECORD_TYPES.A && dataLength === 4) {
+        addresses.push({
+          address: Array.from(buffer.subarray(dataOffset, nextOffset)).join('.'),
+          family: 4,
+        });
+      } else if (type === DNS_RECORD_TYPES.AAAA && dataLength === 16) {
+        addresses.push({
+          address: decodeIPv6Address(buffer, dataOffset),
+          family: 6,
+        });
+      }
+    }
+
+    offset = nextOffset;
+  }
+
+  return addresses;
+}
+
+function selectLookupResult(addresses, options) {
+  const family = Number(options?.family) || 0;
+  let candidates = addresses;
+
+  if (family === 4 || family === 6) {
+    candidates = addresses.filter((address) => address.family === family);
+  }
+
+  if (!candidates.length) {
+    return null;
+  }
+
+  if (options?.all === true) {
+    return {
+      address: candidates.map((candidate) => ({
+        address: candidate.address,
+        family: candidate.family,
+      })),
+    };
+  }
+
+  return candidates[0];
+}
+
+function createResolverLookup(signal) {
+  const dns = getDnsModule();
+  const net = getNetModule();
+
+  return (hostname, options, callback) => {
+    let settled = false;
+    let handleAbort = null;
+    const resolver = new dns.Resolver();
+
+    const finish = (error, address, family) => {
+      if (settled) {
+        return;
+      }
+
+      settled = true;
+
+      if (signal && handleAbort) {
+        signal.removeEventListener('abort', handleAbort);
+      }
+
+      callback(error, address, family);
+    };
+
+    const ipFamily = net.isIP(hostname);
+
+    if (ipFamily) {
+      finish(null, hostname, ipFamily);
+      return;
+    }
+
+    if (signal) {
+      if (signal.aborted) {
+        finish(createAbortError(signal.reason));
+        return;
+      }
+
+      handleAbort = () => {
+        resolver.cancel();
+        finish(createAbortError(signal.reason));
+      };
+
+      signal.addEventListener('abort', handleAbort, { once: true });
+    }
+
+    const family = Number(options?.family) || 0;
+
+    if (family === 6) {
+      resolver.resolve6(hostname, (error, addresses) => {
+        if (error) {
+          finish(error);
+          return;
+        }
+
+        if (!Array.isArray(addresses) || addresses.length === 0) {
+          finish(new Error(`No DNS results for ${hostname}`));
+          return;
+        }
+
+        if (options?.all === true) {
+          finish(
+            null,
+            addresses.map((address) => ({
+              address,
+              family: 6,
+            })),
+          );
+          return;
+        }
+
+        finish(null, addresses[0], 6);
+      });
+
+      return;
+    }
+
+    resolver.resolve4(hostname, (resolve4Error, addresses) => {
+      if (settled) {
+        return;
+      }
+
+      if (!resolve4Error && Array.isArray(addresses) && addresses.length > 0) {
+        if (options?.all === true) {
+          finish(
+            null,
+            addresses.map((address) => ({
+              address,
+              family: 4,
+            })),
+          );
+          return;
+        }
+
+        finish(null, addresses[0], 4);
+        return;
+      }
+
+      resolver.resolve6(hostname, (resolve6Error, resolve6Addresses) => {
+        if (resolve6Error) {
+          finish(resolve4Error || resolve6Error);
+          return;
+        }
+
+        if (!Array.isArray(resolve6Addresses) || resolve6Addresses.length === 0) {
+          finish(resolve4Error || new Error(`No DNS results for ${hostname}`));
+          return;
+        }
+
+        if (options?.all === true) {
+          finish(
+            null,
+            resolve6Addresses.map((address) => ({
+              address,
+              family: 6,
+            })),
+          );
+          return;
+        }
+
+        finish(null, resolve6Addresses[0], 6);
+      });
+    });
+  };
+}
+
+function createMdnsLookup(signal) {
+  const dgram = getDgramModule();
+  const net = getNetModule();
+
+  return (hostname, options, callback) => {
+    let settled = false;
+    let handleAbort = null;
+    let sendTimers = [];
+    const mdnsConfig = getMdnsConfig();
+    const socket = mdnsConfig.joinMulticast
+      ? dgram.createSocket({ type: 'udp4', reuseAddr: true })
+      : dgram.createSocket('udp4');
+    const query = buildMdnsQuery(hostname, options);
+
+    const cleanup = () => {
+      sendTimers.forEach(clearTimeout);
+      sendTimers = [];
+
+      if (signal && handleAbort) {
+        signal.removeEventListener('abort', handleAbort);
+      }
+
+      socket.removeAllListeners('error');
+      socket.removeAllListeners('message');
+
+      try {
+        socket.close();
+      } catch (error) {
+        void error;
+      }
+    };
+
+    const finish = (error, address, family) => {
+      if (settled) {
+        return;
+      }
+
+      settled = true;
+      cleanup();
+      callback(error, address, family);
+    };
+
+    const ipFamily = net.isIP(hostname);
+
+    if (ipFamily) {
+      finish(null, hostname, ipFamily);
+      return;
+    }
+
+    if (signal) {
+      if (signal.aborted) {
+        finish(createAbortError(signal.reason));
+        return;
+      }
+
+      handleAbort = () => {
+        finish(createAbortError(signal.reason));
+      };
+
+      signal.addEventListener('abort', handleAbort, { once: true });
+    }
+
+    socket.on('error', (error) => {
+      finish(error);
+    });
+
+    socket.on('message', (message) => {
+      let addresses = [];
+
+      try {
+        addresses = parseDnsAddresses(message, hostname);
+      } catch (error) {
+        return;
+      }
+
+      const result = selectLookupResult(addresses, options);
+
+      if (!result) {
+        return;
+      }
+
+      if (options?.all === true) {
+        finish(null, result.address);
+        return;
+      }
+
+      finish(null, result.address, result.family);
+    });
+
+    socket.bind(mdnsConfig.joinMulticast ? mdnsConfig.port : 0, () => {
+      if (settled) {
+        return;
+      }
+
+      if (mdnsConfig.joinMulticast) {
+        try {
+          socket.addMembership(mdnsConfig.host);
+        } catch (error) {
+          void error;
+        }
+      }
+
+      const sendQuery = () => {
+        if (settled) {
+          return;
+        }
+
+        socket.send(query, mdnsConfig.port, mdnsConfig.host, (error) => {
+          if (error) {
+            finish(error);
+          }
+        });
+      };
+
+      sendQuery();
+      sendTimers = [250, 1000].map((delay) => setTimeout(sendQuery, delay));
+    });
+  };
+}
+
+function getLookup(url, signal) {
+  const hostname = getHostname(url);
+
+  if (typeof hostname !== 'string') {
+    return undefined;
+  }
+
+  if (shouldUseResolverLookupForHostname(hostname)) {
+    return createResolverLookup(signal);
+  }
+
+  if (shouldUseMdnsLookupForHostname(hostname)) {
+    return createMdnsLookup(signal);
+  }
+
+  return undefined;
+}
+
+function getAgent(url, signal) {
+  const { http, https } = getNodeHttpModules();
+  const lookup = getLookup(url, signal);
+
+  if (!lookup) {
+    return undefined;
+  }
+
+  if (typeof url !== 'string') {
+    return undefined;
+  }
+
+  if (url.startsWith('https://')) {
+    return new https.Agent({
+      keepAlive: false,
+      lookup,
+    });
+  }
+
+  if (url.startsWith('http://')) {
+    return new http.Agent({
+      keepAlive: false,
+      lookup,
+    });
+  }
+
+  return undefined;
+}
+
+class DiscoveryNodeTransport {
+  static shouldUseForUrl(url) {
+    const hostname = getHostname(url);
+
+    return (
+      typeof hostname === 'string' &&
+      (
+        shouldUseResolverLookupForHostname(hostname) ||
+        shouldUseMdnsLookupForHostname(hostname)
+      )
+    );
+  }
+
+  static async fetch(url, options, timeoutDuration, timeoutMessage) {
+    return Util.fetch(
+      url,
+      options,
+      timeoutDuration,
+      timeoutMessage,
+      (resolvedOptions) => {
+        if (typeof resolvedOptions.agent === 'undefined') {
+          resolvedOptions.agent = getAgent(url, resolvedOptions.signal);
+        }
+      },
+    );
+  }
+}
+
+module.exports = DiscoveryNodeTransport;

package/lib/HomeyAPI/HomeyAPIV3.js

@@ -483,10 +483,16 @@ class HomeyAPIV3 extends HomeyAPI {
         .finally(() => {
           // Delete after 30 seconds some requests might still be pending and they should be able
           // to receive a rejected promise for this token.
-          this.__refreshMap[token + 'timeout'] = setTimeout(() => {
+          const cleanupTimer = setTimeout(() => {
             delete this.__refreshMap[token];
             delete this.__refreshMap[token + 'timeout'];
           }, 30 * 1000);
+
+          if (typeof cleanupTimer.unref === 'function') {
+            cleanupTimer.unref();
+          }
+
+          this.__refreshMap[token + 'timeout'] = cleanupTimer;
         });
     }
 
@@ -536,6 +542,14 @@ class HomeyAPIV3 extends HomeyAPI {
 
   destroy() {
     this.__destroyed = true;
+
+    for (const [key, value] of Object.entries(this.__refreshMap)) {
+      if (key.endsWith('timeout')) {
+        clearTimeout(value);
+      }
+    }
+
+    this.__refreshMap = {};
     this.__subscriptionRegistry.destroy();
     this.__socketSession.destroy();
 

package/lib/Util.js

@@ -2,244 +2,6 @@
 
 const APIErrorTimeout = require('./APIErrorTimeout');
 
-let httpAgent = null;
-let httpsAgent = null;
-
-function getNodeHttpModules() {
-  return {
-    http: require('node:http'),
-    https: require('node:https'),
-  };
-}
-
-function getDnsModule() {
-  return require('node:dns');
-}
-
-function getNetModule() {
-  return require('node:net');
-}
-
-function getSharedNodeFetchAgents() {
-  const { http, https } = getNodeHttpModules();
-
-  httpAgent = httpAgent || new http.Agent({
-    keepAlive: false,
-  });
-  httpsAgent = httpsAgent || new https.Agent({
-    keepAlive: false,
-  });
-
-  return {
-    httpAgent,
-    httpsAgent,
-  };
-}
-
-function getNodeFetchAgent(url) {
-  const { httpAgent, httpsAgent } = getSharedNodeFetchAgents();
-
-  if (typeof url !== 'string') {
-    return undefined;
-  }
-
-  if (url.startsWith('https://')) {
-    return httpsAgent;
-  }
-
-  if (url.startsWith('http://')) {
-    return httpAgent;
-  }
-
-  return undefined;
-}
-
-function createAbortError(reason) {
-  const error = new Error(
-    typeof reason === 'string' && reason.length > 0
-      ? reason
-      : 'The operation was aborted',
-  );
-  error.name = 'AbortError';
-  error.code = 'ABORT_ERR';
-  error.type = 'aborted';
-  return error;
-}
-
-function shouldUseCancellableResolverLookup(hostname) {
-  if (typeof hostname !== 'string') {
-    return false;
-  }
-
-  return hostname.endsWith('.homey.homeylocal.com');
-}
-
-function resolveHostnameWithResolver({ dns, hostname, options, finish }) {
-  const resolver = new dns.Resolver();
-  const family = Number(options?.family) || 0;
-  const wantsAll = options?.all === true;
-
-  const resolve4 = (callback) => resolver.resolve4(hostname, callback);
-  const resolve6 = (callback) => resolver.resolve6(hostname, callback);
-
-  const finishWithAddresses = (addresses, addressFamily) => {
-    if (!Array.isArray(addresses) || addresses.length === 0) {
-      finish(new Error(`No DNS results for ${hostname}`));
-      return;
-    }
-
-    if (wantsAll) {
-      finish(
-        null,
-        addresses.map((address) => ({
-          address,
-          family: addressFamily,
-        })),
-      );
-      return;
-    }
-
-    finish(null, addresses[0], addressFamily);
-  };
-
-  const maybeResolve6After4 = (error) => {
-    if (family === 4) {
-      finish(error);
-      return;
-    }
-
-    resolve6((resolve6Error, addresses) => {
-      if (resolve6Error) {
-        finish(error || resolve6Error);
-        return;
-      }
-
-      finishWithAddresses(addresses, 6);
-    });
-  };
-
-  if (family === 6) {
-    resolve6((error, addresses) => {
-      if (error) {
-        finish(error);
-        return;
-      }
-
-      finishWithAddresses(addresses, 6);
-    });
-
-    return () => resolver.cancel();
-  }
-
-  resolve4((error, addresses) => {
-    if (error) {
-      maybeResolve6After4(error);
-      return;
-    }
-
-    finishWithAddresses(addresses, 4);
-  });
-
-  return () => resolver.cancel();
-}
-
-function createTimedLookup(timeoutDuration, signal) {
-  const dns = getDnsModule();
-  const net = getNetModule();
-
-  return (hostname, options, callback) => {
-    let settled = false;
-    let timer = null;
-    let handleAbort = null;
-    let cancelLookup = null;
-
-    const finish = (error, address, family) => {
-      if (settled) {
-        return;
-      }
-
-      settled = true;
-      clearTimeout(timer);
-
-      if (signal && handleAbort) {
-        signal.removeEventListener('abort', handleAbort);
-      }
-
-      if (cancelLookup) {
-        cancelLookup();
-        cancelLookup = null;
-      }
-
-      callback(error, address, family);
-    };
-
-    const ipFamily = net.isIP(hostname);
-
-    if (ipFamily) {
-      finish(null, hostname, ipFamily);
-      return;
-    }
-
-    if (signal) {
-      if (signal.aborted) {
-        finish(createAbortError(signal.reason));
-        return;
-      }
-
-      handleAbort = () => {
-        finish(createAbortError(signal.reason));
-      };
-
-      signal.addEventListener('abort', handleAbort, { once: true });
-    }
-
-    timer = setTimeout(() => {
-      const error = new APIErrorTimeout(`DNS lookup timeout after ${timeoutDuration}ms`);
-      error.code = 'ETIMEDOUT';
-      error.syscall = 'getaddrinfo';
-      error.stage = 'dns-lookup';
-      finish(error);
-    }, timeoutDuration);
-
-    if (shouldUseCancellableResolverLookup(hostname)) {
-      cancelLookup = resolveHostnameWithResolver({
-        dns,
-        hostname,
-        options,
-        finish,
-      });
-      return;
-    }
-
-    dns.lookup(hostname, options, finish);
-  };
-}
-
-function getTimedNodeFetchAgent(url, timeoutDuration, signal) {
-  const { http, https } = getNodeHttpModules();
-  const lookup = createTimedLookup(timeoutDuration, signal);
-
-  if (typeof url !== 'string') {
-    return undefined;
-  }
-
-  if (url.startsWith('https://')) {
-    return new https.Agent({
-      keepAlive: false,
-      lookup,
-    });
-  }
-
-  if (url.startsWith('http://')) {
-    return new http.Agent({
-      keepAlive: false,
-      lookup,
-    });
-  }
-
-  return undefined;
-}
-
 /**
  * Helper Utility Class
  * @class
@@ -253,9 +15,10 @@ class Util {
    * @param  {{}=} options
    * @param  {number=} timeoutDuration
    * @param  {string=} timeoutMessage
+   * @param  {Function=} patchOptions
    * @returns {Promise<any>}
    */
-  static async fetch(url, options, timeoutDuration, timeoutMessage) {
+  static async fetch(url, options, timeoutDuration, timeoutMessage, patchOptions) {
     options = { ...options };
     let timeoutTimer = null;
     let composedAbortController = null;
@@ -274,11 +37,7 @@ class Util {
           handleExternalAbort = () => {
             composedAbortController.abort(externalSignal.reason);
           };
-          externalSignal.addEventListener(
-            'abort',
-            handleExternalAbort,
-            { once: true }
-          );
+          externalSignal.addEventListener('abort', handleExternalAbort, { once: true });
         }
       }
 
@@ -294,6 +53,14 @@ class Util {
       options.signal = composedAbortController.signal;
     }
 
+    if (typeof patchOptions === 'function') {
+      const patchedOptions = patchOptions(options, url);
+
+      if (patchedOptions && typeof patchedOptions === 'object') {
+        options = patchedOptions;
+      }
+    }
+
     let responsePromise = null;
 
     if (this.isReactNative()) {
@@ -302,13 +69,6 @@ class Util {
       responsePromise = window.fetch(url, options);
     } else if (this.isNodeJS()) {
       const fetch = require('node-fetch');
-
-      if (typeof options.agent === 'undefined') {
-        options.agent = timeoutDuration != null
-          ? getTimedNodeFetchAgent(url, timeoutDuration, options.signal)
-          : getNodeFetchAgent(url);
-      }
-
       responsePromise = fetch(url, options);
     } else if (typeof fetch !== 'undefined') {
       responsePromise = fetch(url, options);
@@ -354,7 +114,7 @@ class Util {
   static async timeout(
     promise,
     timeoutMillis = 5000,
-    message = `Timeout after ${timeoutMillis}ms`
+    message = `Timeout after ${timeoutMillis}ms`,
   ) {
     const timeoutError = new APIErrorTimeout(message);
     let timeoutRef;
@@ -370,7 +130,7 @@ class Util {
 
     returnPromise
       // eslint-disable-next-line no-unused-vars
-      .catch((err) => { })
+      .catch((err) => {})
       .finally(() => {
         clearTimeout(timeoutRef);
       });
@@ -421,7 +181,12 @@ class Util {
    */
   static isNodeJS() {
     if (this.isReactNative()) return false;
-    return typeof process !== 'undefined';
+    return (
+      typeof process !== 'undefined' &&
+      typeof process.versions === 'object' &&
+      process.versions !== null &&
+      typeof process.versions.node === 'string'
+    );
   }
 
   /**
@@ -560,7 +325,7 @@ class Util {
             buildParams(
               prefix + '[' + (typeof obj[index] === 'object' ? index : '') + ']',
               obj[index],
-              add
+              add,
             );
           }
         }
@@ -603,7 +368,6 @@ class Util {
 
     return encodedPairs.join('&');
   }
-
 }
 
 module.exports = Util;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homey-api",
-  "version": "3.17.6",
+  "version": "3.17.7",
   "description": "Homey API",
   "main": "index.js",
   "license": "SEE LICENSE",