homey-api 3.17.0 → 3.17.2

package/lib/HomeyAPI/HomeyAPIV3/DiscoveryManager.js

@@ -0,0 +1,294 @@
+'use strict';
+
+const APIErrorHomeyOffline = require('../../APIErrorHomeyOffline');
+const APIErrorHomeySubscriptionInactive = require('../../APIErrorHomeySubscriptionInactive');
+const APIErrorHomeyInvalidSerialNumber = require('../../APIErrorHomeyInvalidSerialNumber');
+const Util = require('../../Util');
+
+class DiscoveryManager {
+  constructor(homey) {
+    this.homey = homey;
+  }
+
+  async discoverBaseUrl() {
+    const DISCOVERY_STRATEGIES = this.homey.constructor.DISCOVERY_STRATEGIES;
+    const urls = {};
+
+    if (this.homey.__strategies.includes(DISCOVERY_STRATEGIES.MDNS)) {
+      if (Util.isHTTPUnsecureSupported()) {
+        if (this.homey.__properties.mdnsFqdn) {
+          urls[DISCOVERY_STRATEGIES.MDNS] = `http://${this.homey.__properties.mdnsFqdn}`;
+        } else {
+          urls[DISCOVERY_STRATEGIES.MDNS] = `http://homey-${this.homey.id}.local`;
+        }
+      }
+    }
+
+    if (this.homey.__strategies.includes(DISCOVERY_STRATEGIES.LOCAL)) {
+      if (Util.isHTTPUnsecureSupported() && this.homey.__properties.localUrl) {
+        urls[DISCOVERY_STRATEGIES.LOCAL] = `${this.homey.__properties.localUrl}`;
+      }
+    }
+
+    if (this.homey.__strategies.includes(DISCOVERY_STRATEGIES.LOCAL_SECURE)) {
+      if (this.homey.__properties.localUrlSecure) {
+        urls[DISCOVERY_STRATEGIES.LOCAL_SECURE] = `${this.homey.__properties.localUrlSecure}`;
+      }
+    }
+
+    if (this.homey.__strategies.includes(DISCOVERY_STRATEGIES.CLOUD)) {
+      if (this.homey.__properties.remoteUrl) {
+        urls[DISCOVERY_STRATEGIES.CLOUD] = `${this.homey.__properties.remoteUrl}`;
+      }
+    }
+
+    if (this.homey.__strategies.includes(DISCOVERY_STRATEGIES.REMOTE_FORWARDED)) {
+      if (this.homey.__properties.remoteUrlForwarded) {
+        urls[DISCOVERY_STRATEGIES.REMOTE_FORWARDED] =
+          `${this.homey.__properties.remoteUrlForwarded}`;
+      }
+    }
+
+    if (!Object.keys(urls).length) {
+      throw new Error('No Discovery Strategies Available');
+    }
+
+    this.homey.__debug(`Discovery Strategies: ${Object.keys(urls).join(',')}`);
+
+    let resolve;
+    let reject;
+
+    const promise = new Promise((resolve_, reject_) => {
+      resolve = resolve_;
+      reject = reject_;
+    });
+
+    const pingAbortControllers = {};
+
+    const abortPendingPings = ({ exceptStrategyId } = {}) => {
+      Object.entries(pingAbortControllers).forEach(([strategyId, abortController]) => {
+        if (strategyId === exceptStrategyId) return;
+        if (abortController.signal.aborted) return;
+        abortController.abort('Discovery Completed');
+      });
+    };
+
+    const resolveAndAbortPendingPings = (result) => {
+      abortPendingPings({ exceptStrategyId: result.strategyId });
+      resolve(result);
+      return result;
+    };
+
+    const rejectAndAbortPendingPings = (error) => {
+      abortPendingPings();
+      reject(error);
+    };
+
+    const isSubscriptionError = (error) => {
+      return (
+        error instanceof APIErrorHomeySubscriptionInactive ||
+        error instanceof APIErrorHomeyInvalidSerialNumber
+      );
+    };
+
+    const normalizeDiscoveryError = (error) => {
+      if (error instanceof AggregateError) {
+        for (const err of error.errors) {
+          if (isSubscriptionError(err)) {
+            return err;
+          }
+        }
+
+        return new APIErrorHomeyOffline();
+      }
+
+      if (isSubscriptionError(error) || error instanceof APIErrorHomeyOffline) {
+        return error;
+      }
+
+      return new APIErrorHomeyOffline(error);
+    };
+
+    const ping = async (strategyId, timeout) => {
+      const baseUrl = urls[strategyId];
+      const abortController = new AbortController();
+      pingAbortControllers[strategyId] = abortController;
+
+      const response = await Util.fetch(
+        `${baseUrl}/api/manager/system/ping?id=${this.homey.id}`,
+        {
+          headers: {
+            'X-Homey-ID': this.homey.id,
+          },
+          signal: abortController.signal,
+        },
+        timeout
+      );
+
+      const text = await response.text();
+
+      if (!response.ok) {
+        const responseContentType = response.headers.get('Content-Type');
+        let parsed;
+
+        if (responseContentType && responseContentType.toLowerCase().includes('application/json')) {
+          try {
+            parsed = JSON.parse(text);
+            // eslint-disable-next-line no-empty
+          } catch (err) {}
+        }
+
+        if (typeof parsed === 'object' && parsed !== null) {
+          if (
+            parsed.error &&
+            parsed.error === 'Subscription Inactive' &&
+            parsed.statusCode === 403
+          ) {
+            throw new APIErrorHomeySubscriptionInactive(parsed.error, parsed.statusCode);
+          } else if (
+            parsed.error &&
+            parsed.error === 'Invalid Serial Number' &&
+            parsed.statusCode === 403
+          ) {
+            throw new APIErrorHomeyInvalidSerialNumber(parsed.error, parsed.statusCode);
+          }
+        }
+
+        throw new Error(text || response.statusText);
+      }
+
+      if (text === 'false') {
+        throw new Error('Invalid Homey ID');
+      }
+
+      const homeyId = response.headers.get('X-Homey-ID');
+
+      if (homeyId && homeyId !== this.homey.id) {
+        throw new Error('Invalid Homey ID');
+      }
+
+      const homeyVersion = response.headers.get('X-Homey-Version');
+
+      return {
+        baseUrl,
+        strategyId,
+        homeyVersion,
+      };
+    };
+
+    const pings = {};
+
+    if (urls[DISCOVERY_STRATEGIES.LOCAL_SECURE]) {
+      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(urls[DISCOVERY_STRATEGIES.LOCAL_SECURE]);
+      });
+    }
+
+    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)
+      );
+    }
+
+    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)
+      );
+    }
+
+    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)
+      );
+    }
+
+    if (urls[DISCOVERY_STRATEGIES.REMOTE_FORWARDED]) {
+      pings[DISCOVERY_STRATEGIES.REMOTE_FORWARDED] = ping(
+        DISCOVERY_STRATEGIES.REMOTE_FORWARDED,
+        2000
+      );
+      pings[DISCOVERY_STRATEGIES.REMOTE_FORWARDED].catch((err) =>
+        this.homey.__debug(
+          `Ping ${DISCOVERY_STRATEGIES.REMOTE_FORWARDED} Error:`,
+          err && err.message
+        )
+      );
+    }
+
+    const withCloudFallback = (primaryPromise) => {
+      return primaryPromise.catch((error) => {
+        if (pings[DISCOVERY_STRATEGIES.CLOUD]) {
+          return pings[DISCOVERY_STRATEGIES.CLOUD];
+        }
+
+        throw new APIErrorHomeyOffline(error);
+      });
+    };
+
+    let selectedRoutePromise;
+
+    if (pings[DISCOVERY_STRATEGIES.LOCAL_SECURE]) {
+      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.REMOTE_FORWARDED]) {
+            fallbackPromises.push(pings[DISCOVERY_STRATEGIES.REMOTE_FORWARDED]);
+          }
+
+          if (pings[DISCOVERY_STRATEGIES.MDNS]) {
+            fallbackPromises.push(pings[DISCOVERY_STRATEGIES.MDNS]);
+          }
+
+          if (pings[DISCOVERY_STRATEGIES.CLOUD]) {
+            fallbackPromises.push(pings[DISCOVERY_STRATEGIES.CLOUD]);
+          }
+
+          if (isSubscriptionError(error)) {
+            throw error;
+          }
+
+          if (!fallbackPromises.length) {
+            throw new APIErrorHomeyOffline();
+          }
+
+          return Promise.any(fallbackPromises);
+        });
+    } else if (pings[DISCOVERY_STRATEGIES.LOCAL]) {
+      selectedRoutePromise = withCloudFallback(pings[DISCOVERY_STRATEGIES.LOCAL]);
+    } else if (pings[DISCOVERY_STRATEGIES.MDNS]) {
+      selectedRoutePromise = withCloudFallback(pings[DISCOVERY_STRATEGIES.MDNS]);
+    } else if (pings[DISCOVERY_STRATEGIES.REMOTE_FORWARDED]) {
+      selectedRoutePromise = withCloudFallback(pings[DISCOVERY_STRATEGIES.REMOTE_FORWARDED]);
+    } else if (pings[DISCOVERY_STRATEGIES.CLOUD]) {
+      selectedRoutePromise = pings[DISCOVERY_STRATEGIES.CLOUD];
+    } else {
+      selectedRoutePromise = Promise.reject(new APIErrorHomeyOffline());
+    }
+
+    selectedRoutePromise
+      .then((result) => resolveAndAbortPendingPings(result))
+      .catch((error) => {
+        rejectAndAbortPendingPings(normalizeDiscoveryError(error));
+      });
+
+    return promise;
+  }
+}
+
+module.exports = DiscoveryManager;

package/lib/HomeyAPI/HomeyAPIV3.js

@@ -1,9 +1,6 @@
 'use strict';
 
 const SocketIOClient = require('socket.io-client');
-const APIErrorHomeyOffline = require('../APIErrorHomeyOffline');
-const APIErrorHomeySubscriptionInactive = require('../APIErrorHomeySubscriptionInactive');
-const APIErrorHomeyInvalidSerialNumber = require('../APIErrorHomeyInvalidSerialNumber');
 const Util = require('../Util');
 const HomeyAPI = require('./HomeyAPI');
 const HomeyAPIError = require('./HomeyAPIError');
@@ -15,6 +12,7 @@ const ManagerFlowToken = require('./HomeyAPIV3/ManagerFlowToken');
 const ManagerInsights = require('./HomeyAPIV3/ManagerInsights');
 const ManagerUsers = require('./HomeyAPIV3/ManagerUsers');
 const ManagerZones = require('./HomeyAPIV3/ManagerZones');
+const DiscoveryManager = require('./HomeyAPIV3/DiscoveryManager');
 const Manager = require('./HomeyAPIV3/Manager');
 
 /**
@@ -119,6 +117,8 @@ class HomeyAPIV3 extends HomeyAPI {
       writable: true,
     });
 
+    this.__discoveryManager = new DiscoveryManager(this);
+
     this.generateManagersFromSpecification();
   }
 
@@ -128,9 +128,10 @@ class HomeyAPIV3 extends HomeyAPI {
   get baseUrl() {
     return (async () => {
       if (!this.__baseUrlPromise) {
-        this.__baseUrlPromise = this.discoverBaseUrl().then(({ baseUrl }) => {
+        this.__baseUrlPromise = (async () => {
+          const { baseUrl } = await this.discoverBaseUrl();
           return baseUrl;
-        });
+        })();
         this.__baseUrlPromise.catch(() => {});
       }
 
@@ -191,331 +192,25 @@ class HomeyAPIV3 extends HomeyAPI {
    */
 
   async discoverBaseUrl() {
-    const urls = {};
-
-    if (this.__strategies.includes(HomeyAPI.DISCOVERY_STRATEGIES.MDNS)) {
-      if (Util.isHTTPUnsecureSupported()) {
-        urls[HomeyAPI.DISCOVERY_STRATEGIES.MDNS] = `http://homey-${this.id}.local`;
-      }
-    }
-
-    if (this.__strategies.includes(HomeyAPI.DISCOVERY_STRATEGIES.LOCAL)) {
-      if (Util.isHTTPUnsecureSupported() && this.__properties.localUrl) {
-        urls[HomeyAPI.DISCOVERY_STRATEGIES.LOCAL] = `${this.__properties.localUrl}`;
-      }
-    }
-
-    if (this.__strategies.includes(HomeyAPI.DISCOVERY_STRATEGIES.LOCAL_SECURE)) {
-      if (this.__properties.localUrlSecure) {
-        urls[HomeyAPI.DISCOVERY_STRATEGIES.LOCAL_SECURE] = `${this.__properties.localUrlSecure}`;
-      }
-    }
-
-    if (this.__strategies.includes(HomeyAPI.DISCOVERY_STRATEGIES.CLOUD)) {
-      if (this.__properties.remoteUrl) {
-        urls[HomeyAPI.DISCOVERY_STRATEGIES.CLOUD] = `${this.__properties.remoteUrl}`;
-      }
-    }
+    const discoveryResult = await this.__discoveryManager.discoverBaseUrl();
+    const result = this.__applyDiscoveryResult(discoveryResult);
+    return result;
+  }
 
-    if (this.__strategies.includes(HomeyAPI.DISCOVERY_STRATEGIES.REMOTE_FORWARDED)) {
-      if (this.__properties.remoteUrlForwarded) {
-        urls[HomeyAPI.DISCOVERY_STRATEGIES.REMOTE_FORWARDED] =
-          `${this.__properties.remoteUrlForwarded}`;
-      }
-    }
+  __applyDiscoveryResult({ baseUrl, strategyId, homeyVersion }) {
+    this.__baseUrl = baseUrl;
+    this.__baseUrlPromise = Promise.resolve(baseUrl);
+    this.__strategyId = strategyId;
 
-    if (!Object.keys(urls).length) {
-      throw new Error('No Discovery Strategies Available');
+    if (homeyVersion != null) {
+      this.version = homeyVersion;
     }
 
-    this.__debug(`Discovery Strategies: ${Object.keys(urls).join(',')}`);
-
-    // Create the returned Promise
-    let resolve;
-    let reject;
-
-    const promise = new Promise((resolve_, reject_) => {
-      resolve = resolve_;
-      reject = reject_;
-    });
-
-    promise
-      .then(({ baseUrl, strategyId }) => {
-        this.__baseUrl = baseUrl;
-        this.__strategyId = strategyId;
-      })
-      .catch(() => {});
-
-    // Ping method
-    const ping = async (strategyId, timeout) => {
-      const baseUrl = urls[strategyId];
-
-      const response = await Util.fetch(
-        `${baseUrl}/api/manager/system/ping?id=${this.id}`,
-        {
-          headers: {
-            'X-Homey-ID': this.id,
-          },
-        },
-        timeout
-      );
-
-      const text = await response.text();
-
-      if (!response.ok) {
-        const responseContentType = response.headers.get('Content-Type');
-        let parsed;
-
-        if (responseContentType && responseContentType.toLowerCase().includes('application/json')) {
-          try {
-            parsed = JSON.parse(text);
-            // eslint-disable-next-line no-empty
-          } catch (err) {}
-        }
-
-        if (typeof parsed === 'object' && parsed !== null) {
-          if (
-            parsed.error &&
-            parsed.error === 'Subscription Inactive' &&
-            parsed.statusCode === 403
-          ) {
-            throw new APIErrorHomeySubscriptionInactive(parsed.error, parsed.statusCode);
-          } else if (
-            parsed.error &&
-            parsed.error === 'Invalid Serial Number' &&
-            parsed.statusCode === 403
-          ) {
-            throw new APIErrorHomeyInvalidSerialNumber(parsed.error, parsed.statusCode);
-          }
-        }
-
-        throw new Error(text || response.statusText);
-      }
-
-      if (text === 'false') {
-        throw new Error('Invalid Homey ID');
-      }
-
-      const homeyId = response.headers.get('X-Homey-ID');
-
-      if (homeyId && homeyId !== this.id) {
-        throw new Error('Invalid Homey ID'); // TODO: Add to Homey Connect
-      }
-
-      // Set the version that Homey told us.
-      // It's the absolute truth, because the Cloud API may be behind.
-      const homeyVersion = response.headers.get('X-Homey-Version');
-
-      if (homeyVersion !== this.version) {
-        this.version = homeyVersion;
-      }
-
-      return {
-        baseUrl,
-        strategyId,
-      };
+    return {
+      baseUrl,
+      strategyId,
+      homeyVersion,
     };
-
-    const pings = {};
-
-    // Ping localSecure (https://xxx-xxx-xxx-xx.homey.homeylocal.com)
-    if (urls[HomeyAPI.DISCOVERY_STRATEGIES.LOCAL_SECURE]) {
-      pings[HomeyAPI.DISCOVERY_STRATEGIES.LOCAL_SECURE] = ping(
-        HomeyAPI.DISCOVERY_STRATEGIES.LOCAL_SECURE,
-        1200
-      );
-      pings[HomeyAPI.DISCOVERY_STRATEGIES.LOCAL_SECURE].catch((err) => {
-        this.__debug(
-          `Ping ${HomeyAPI.DISCOVERY_STRATEGIES.LOCAL_SECURE} Error:`,
-          err && err.message
-        );
-        this.__debug(urls[HomeyAPI.DISCOVERY_STRATEGIES.LOCAL_SECURE]);
-      });
-    }
-
-    // Ping local (http://xxx-xxx-xxx-xxx)
-    if (urls[HomeyAPI.DISCOVERY_STRATEGIES.LOCAL]) {
-      pings[HomeyAPI.DISCOVERY_STRATEGIES.LOCAL] = ping(HomeyAPI.DISCOVERY_STRATEGIES.LOCAL, 1000);
-      pings[HomeyAPI.DISCOVERY_STRATEGIES.LOCAL].catch((err) =>
-        this.__debug(`Ping ${HomeyAPI.DISCOVERY_STRATEGIES.LOCAL} Error:`, err && err.message)
-      );
-    }
-
-    // Ping mdns (http://homey-<homeyId>.local)
-    if (urls[HomeyAPI.DISCOVERY_STRATEGIES.MDNS]) {
-      pings[HomeyAPI.DISCOVERY_STRATEGIES.MDNS] = ping(HomeyAPI.DISCOVERY_STRATEGIES.MDNS, 3000);
-      pings[HomeyAPI.DISCOVERY_STRATEGIES.MDNS].catch((err) =>
-        this.__debug(`Ping ${HomeyAPI.DISCOVERY_STRATEGIES.MDNS} Error:`, err && err.message)
-      );
-    }
-
-    // Ping cloud (https://<homeyId>.connect.athom.com)
-    if (urls[HomeyAPI.DISCOVERY_STRATEGIES.CLOUD]) {
-      pings[HomeyAPI.DISCOVERY_STRATEGIES.CLOUD] = ping(HomeyAPI.DISCOVERY_STRATEGIES.CLOUD, 5000);
-      pings[HomeyAPI.DISCOVERY_STRATEGIES.CLOUD].catch((err) =>
-        this.__debug(`Ping ${HomeyAPI.DISCOVERY_STRATEGIES.CLOUD} Error:`, err && err.message)
-      );
-    }
-
-    // Ping Direct (https://xxx-xxx-xxx-xx.homey.homeylocal.com:12345)
-    if (urls[HomeyAPI.DISCOVERY_STRATEGIES.REMOTE_FORWARDED]) {
-      pings[HomeyAPI.DISCOVERY_STRATEGIES.REMOTE_FORWARDED] = ping(
-        HomeyAPI.DISCOVERY_STRATEGIES.REMOTE_FORWARDED,
-        2000
-      );
-      pings[HomeyAPI.DISCOVERY_STRATEGIES.REMOTE_FORWARDED].catch((err) =>
-        this.__debug(
-          `Ping ${HomeyAPI.DISCOVERY_STRATEGIES.REMOTE_FORWARDED} Error:`,
-          err && err.message
-        )
-      );
-    }
-
-    // Select the best route
-    if (pings[HomeyAPI.DISCOVERY_STRATEGIES.LOCAL_SECURE]) {
-      pings[HomeyAPI.DISCOVERY_STRATEGIES.LOCAL_SECURE]
-        .then((result) => resolve(result))
-        .catch((error) => {
-          const promises = [];
-
-          if (pings[HomeyAPI.DISCOVERY_STRATEGIES.LOCAL]) {
-            promises.push(pings[HomeyAPI.DISCOVERY_STRATEGIES.LOCAL]);
-          }
-
-          if (pings[HomeyAPI.DISCOVERY_STRATEGIES.REMOTE_FORWARDED]) {
-            promises.push(pings[HomeyAPI.DISCOVERY_STRATEGIES.REMOTE_FORWARDED]);
-          }
-
-          if (pings[HomeyAPI.DISCOVERY_STRATEGIES.MDNS]) {
-            promises.push(pings[HomeyAPI.DISCOVERY_STRATEGIES.MDNS]);
-          }
-
-          if (pings[HomeyAPI.DISCOVERY_STRATEGIES.CLOUD]) {
-            promises.push(pings[HomeyAPI.DISCOVERY_STRATEGIES.CLOUD]);
-          }
-
-          if (
-            error instanceof APIErrorHomeySubscriptionInactive ||
-            error instanceof APIErrorHomeyInvalidSerialNumber
-          ) {
-            throw error;
-          }
-
-          if (!promises.length) {
-            throw new APIErrorHomeyOffline();
-          }
-
-          return Promise.any(promises);
-        })
-        .then((result) => resolve(result))
-        .catch((error) => {
-          if (error instanceof AggregateError) {
-            for (const err of error.errors) {
-              if (
-                err instanceof APIErrorHomeySubscriptionInactive ||
-                err instanceof APIErrorHomeyInvalidSerialNumber
-              ) {
-                reject(err);
-                return;
-              }
-            }
-          }
-
-          if (
-            error instanceof APIErrorHomeySubscriptionInactive ||
-            error instanceof APIErrorHomeyInvalidSerialNumber
-          ) {
-            reject(error);
-            return;
-          }
-
-          reject(new APIErrorHomeyOffline());
-        });
-    } else if (pings[HomeyAPI.DISCOVERY_STRATEGIES.LOCAL]) {
-      pings[HomeyAPI.DISCOVERY_STRATEGIES.LOCAL]
-        .then((result) => resolve(result))
-        .catch((err) => {
-          if (pings[HomeyAPI.DISCOVERY_STRATEGIES.CLOUD]) {
-            pings[HomeyAPI.DISCOVERY_STRATEGIES.CLOUD]
-              .then((result) => resolve(result))
-              .catch((err) => {
-                if (
-                  err instanceof APIErrorHomeySubscriptionInactive ||
-                  err instanceof APIErrorHomeyInvalidSerialNumber
-                ) {
-                  reject(err);
-                  return;
-                }
-
-                reject(new APIErrorHomeyOffline(err));
-              });
-          } else {
-            reject(new APIErrorHomeyOffline(err));
-          }
-        });
-    } else if (pings[HomeyAPI.DISCOVERY_STRATEGIES.MDNS]) {
-      pings[HomeyAPI.DISCOVERY_STRATEGIES.MDNS]
-        .then((result) => resolve(result))
-        .catch((err) => {
-          if (pings[HomeyAPI.DISCOVERY_STRATEGIES.CLOUD]) {
-            pings[HomeyAPI.DISCOVERY_STRATEGIES.CLOUD]
-              .then((result) => resolve(result))
-              .catch((err) => {
-                if (
-                  err instanceof APIErrorHomeySubscriptionInactive ||
-                  err instanceof APIErrorHomeyInvalidSerialNumber
-                ) {
-                  reject(err);
-                  return;
-                }
-
-                reject(new APIErrorHomeyOffline(err));
-              });
-          } else {
-            reject(new APIErrorHomeyOffline(err));
-          }
-        });
-    } else if (pings[HomeyAPI.DISCOVERY_STRATEGIES.REMOTE_FORWARDED]) {
-      pings[HomeyAPI.DISCOVERY_STRATEGIES.REMOTE_FORWARDED]
-        .then((result) => resolve(result))
-        .catch((err) => {
-          if (pings[HomeyAPI.DISCOVERY_STRATEGIES.CLOUD]) {
-            pings[HomeyAPI.DISCOVERY_STRATEGIES.CLOUD]
-              .then((result) => resolve(result))
-              .catch((err) => {
-                if (
-                  err instanceof APIErrorHomeySubscriptionInactive ||
-                  err instanceof APIErrorHomeyInvalidSerialNumber
-                ) {
-                  reject(err);
-                  return;
-                }
-
-                reject(new APIErrorHomeyOffline(err));
-              });
-          } else {
-            reject(new APIErrorHomeyOffline(err));
-          }
-        });
-    } else if (pings[HomeyAPI.DISCOVERY_STRATEGIES.CLOUD]) {
-      pings[HomeyAPI.DISCOVERY_STRATEGIES.CLOUD]
-        .then((result) => resolve(result))
-        .catch((err) => {
-          if (
-            err instanceof APIErrorHomeySubscriptionInactive ||
-            err instanceof APIErrorHomeyInvalidSerialNumber
-          ) {
-            reject(err);
-            return;
-          }
-
-          reject(new APIErrorHomeyOffline(err));
-        });
-    } else {
-      reject(new APIErrorHomeyOffline());
-    }
-
-    return promise;
   }
 
   async call({

package/lib/Util.js

@@ -2,6 +2,244 @@
 
 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
@@ -19,16 +257,41 @@ class Util {
    */
   static async fetch(url, options, timeoutDuration, timeoutMessage) {
     options = { ...options };
-    let abortTimeout = null;
+    let timeoutTimer = null;
+    let composedAbortController = null;
+    let didTimeoutTriggerAbort = false;
+    let externalSignal = null;
+    let handleExternalAbort = null;
 
     if (timeoutDuration != null) {
-      const abortController = new AbortController();
+      composedAbortController = new AbortController();
+      externalSignal = options.signal;
+
+      if (externalSignal) {
+        if (externalSignal.aborted) {
+          composedAbortController.abort(externalSignal.reason);
+        } else {
+          handleExternalAbort = () => {
+            composedAbortController.abort(externalSignal.reason);
+          };
+          externalSignal.addEventListener(
+            'abort',
+            handleExternalAbort,
+            { once: true }
+          );
+        }
+      }
 
-      abortTimeout = setTimeout(() => {
-        abortController.abort('Timeout');
+      timeoutTimer = setTimeout(() => {
+        if (composedAbortController.signal.aborted) {
+          return;
+        }
+
+        didTimeoutTriggerAbort = true;
+        composedAbortController.abort('Timeout');
       }, timeoutDuration);
 
-      options.signal = abortController.signal;
+      options.signal = composedAbortController.signal;
     }
 
     let responsePromise = null;
@@ -39,6 +302,13 @@ 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);
@@ -51,20 +321,16 @@ class Util {
 
       return result;
     } catch (err) {
-      if (err.name === 'AbortError') {
-        if (options.signal && options.signal.aborted && options.signal.reason === 'Timeout') {
-          throw new APIErrorTimeout(timeoutMessage ?? `Timeout after ${timeoutDuration}ms`);
-        }
-      }
-
-      if (err.type === 'aborted') {
-        // https://github.com/node-fetch/node-fetch/blob/2.x/src/abort-error.js
+      if ((err.name === 'AbortError' || err.type === 'aborted') && didTimeoutTriggerAbort) {
         throw new APIErrorTimeout(timeoutMessage ?? `Timeout after ${timeoutDuration}ms`);
       }
 
       throw err;
     } finally {
-      clearTimeout(abortTimeout);
+      clearTimeout(timeoutTimer);
+      if (externalSignal && handleExternalAbort) {
+        externalSignal.removeEventListener('abort', handleExternalAbort);
+      }
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homey-api",
-  "version": "3.17.0",
+  "version": "3.17.2",
   "description": "Homey API",
   "main": "index.js",
   "license": "SEE LICENSE",
@@ -13,7 +13,7 @@
   ],
   "types": "assets/types/homey-api.d.ts",
   "scripts": {
-    "test": "jest --verbose",
+    "test": "node --test",
     "lint": "eslint .",
     "serve": "concurrently \"serve jsdoc/\"  \"npm run jsdoc:watch\"",
     "build": "npm run build:specs && npm run build:jsdoc && npm run build:types && npm run build:webpack;",
@@ -46,7 +46,7 @@
   },
   "homepage": "https://github.com/athombv/node-homey-api#readme",
   "engines": {
-    "node": ">=16"
+    "node": ">=22"
   },
   "dependencies": {
     "engine.io-client": "^3.5.5",
@@ -59,7 +59,6 @@
     "@babel/core": "^7.16.0",
     "@babel/plugin-proposal-class-properties": "^7.16.0",
     "@babel/preset-env": "^7.16.0",
-    "@types/jest": "^29.5.12",
     "@typescript-eslint/eslint-plugin": "^6.1.0",
     "@typescript-eslint/parser": "^6.1.0",
     "babel-loader": "^8.2.3",
@@ -67,12 +66,10 @@
     "ejs": "^3.1.6",
     "eslint": "^7.32.0",
     "eslint-config-athom": "^2.1.1",
-    "eslint-plugin-jest": "^27.4.0",
     "express": "^4.18.2",
     "fs-extra": "^10.0.0",
     "homey-api": "^3.0.8",
     "http-server": "^0.12.3",
-    "jest": "^30.0.0-alpha.2",
     "jsdoc": "4.0.5",
     "jsdoc-to-markdown": "^8.0.0",
     "jsdoc-ts-utils": "^4.0.0",