homey-api 3.17.5 → 3.17.6

package/lib/HomeyAPI/HomeyAPIV3/SocketSession.js

@@ -6,6 +6,16 @@ const Util = require('../../Util');
 const HomeyAPIError = require('../HomeyAPIError');
 
 const SOCKET_SESSION_NOT_READY_CODE = 'ERR_SOCKET_SESSION_NOT_READY';
+const SERVER_DISCONNECT_REASON = 'io server disconnect';
+const NAMESPACE_STABILITY_TIMEOUT = 25;
+const PHASES = {
+  IDLE: 'idle',
+  CONNECTING: 'connecting',
+  HANDSHAKING: 'handshaking',
+  READY: 'ready',
+  DISCONNECTING: 'disconnecting',
+  DESTROYED: 'destroyed',
+};
 
 class SocketSession extends EventEmitter {
   static NOT_READY_CODE = SOCKET_SESSION_NOT_READY_CODE;
@@ -13,8 +23,11 @@ class SocketSession extends EventEmitter {
   constructor(homey) {
     super();
 
+    // The root socket owns transport connectivity. Each ready cycle then
+    // handshakes a disposable Homey namespace socket, while higher layers
+    // restore URI subscriptions against the current namespace revision.
     this.homey = homey;
-    this.__phase = 'idle';
+    this.__phase = PHASES.IDLE;
     this.__socket = null;
     this.__homeySocket = null;
     this.__boundHomeySocket = null;
@@ -67,7 +80,7 @@ class SocketSession extends EventEmitter {
     const abortController = new AbortController();
     this.__readyAbortController = abortController;
 
-    const readyPromise = Promise.resolve().then(async () => {
+    const readyPromise = (async () => {
       if (this.__destroyed) {
         throw this.__createAbortError('Socket session destroyed.');
       }
@@ -76,7 +89,7 @@ class SocketSession extends EventEmitter {
         throw this.__createAbortError(abortController.signal.reason);
       }
 
-      this.__setPhase('connecting');
+      this.__setPhase(PHASES.CONNECTING);
 
       const baseUrl = await this.homey.baseUrl;
 
@@ -90,12 +103,12 @@ class SocketSession extends EventEmitter {
 
       await this.__waitForSocketConnect(abortController.signal);
 
-      this.__setPhase('handshaking');
+      this.__setPhase(PHASES.HANDSHAKING);
       const namespace = await this.__handshakeClient(abortController.signal);
       await this.__connectHomeySocket(namespace, abortController.signal);
 
       this.__readyRevision += 1;
-      this.__setPhase('ready');
+      this.__setPhase(PHASES.READY);
 
       const readyState = {
         ...this.__getReadyState(),
@@ -105,7 +118,7 @@ class SocketSession extends EventEmitter {
       this.emit('ready', readyState);
 
       return readyState;
-    });
+    })();
 
     this.__readyPromise = readyPromise;
 
@@ -118,7 +131,7 @@ class SocketSession extends EventEmitter {
         }
 
         if (!this.isConnected() && !this.__destroyed && !this.__closing) {
-          this.__setPhase('idle');
+          this.__setPhase(PHASES.IDLE);
         }
       })
       .finally(() => {
@@ -187,7 +200,7 @@ class SocketSession extends EventEmitter {
     this.__closing = true;
     this.__cancelReadyCycle('Socket session disconnected.');
     const shouldEmitDisconnect = this.isConnected();
-    this.__setPhase('disconnecting');
+    this.__setPhase(PHASES.DISCONNECTING);
 
     const homeySocket = this.__homeySocket;
     if (homeySocket) {
@@ -222,7 +235,7 @@ class SocketSession extends EventEmitter {
     }
 
     this.__closing = false;
-    this.__setPhase('idle');
+    this.__setPhase(PHASES.IDLE);
   }
 
   destroy() {
@@ -246,7 +259,7 @@ class SocketSession extends EventEmitter {
       this.__socket = null;
     }
 
-    this.__setPhase('destroyed');
+    this.__setPhase(PHASES.DESTROYED);
     this.removeAllListeners();
   }
 
@@ -326,14 +339,29 @@ class SocketSession extends EventEmitter {
   }
 
   __handleSessionDisconnect(reason) {
-    const shouldEmitDisconnect = this.__phase === 'ready' || this.isConnected();
+    const shouldEmitDisconnect = this.__phase === PHASES.READY || this.isConnected();
 
     this.__cancelReadyCycle('Socket disconnected.');
-    this.__setPhase(this.__closing ? 'disconnecting' : 'idle');
+    this.__setPhase(this.__closing ? PHASES.DISCONNECTING : PHASES.IDLE);
 
     if (shouldEmitDisconnect) {
       this.emit('disconnect', reason);
     }
+
+    if (this.__homeySocket && !this.__homeySocket.connected) {
+      this.__disposeStaleHomeySocket();
+    }
+
+    if (
+      reason === SERVER_DISCONNECT_REASON
+      && this.homey.__reconnect
+      && !this.__destroyed
+      && !this.__closing
+      && this.__socket
+      && !this.__socket.connected
+    ) {
+      this.__socket.connect();
+    }
   }
 
   async __waitForSocketConnect(signal) {
@@ -427,6 +455,11 @@ class SocketSession extends EventEmitter {
         this.__homeySocket.open();
       },
     });
+    // Homey can accept the /api namespace and then tear it down immediately
+    // during socket registration. Wait briefly to confirm /api stays connected
+    // before treating the session as ready, so that failed cycles reject
+    // connect()/reconnect instead of reporting a false success.
+    await this.__waitForNamespaceStability(this.__homeySocket, signal);
 
     return this.__homeySocket;
   }
@@ -578,6 +611,67 @@ class SocketSession extends EventEmitter {
     }
   }
 
+  // Wait one short grace window after /api connects so the session is only
+  // reported as ready once the namespace has stayed connected briefly.
+  async __waitForNamespaceStability(homeySocket, signal) {
+    await new Promise((resolve, reject) => {
+      const onAbort = () => {
+        cleanup();
+        reject(this.__createAbortError(signal.reason));
+      };
+
+      const onDisconnect = (reason) => {
+        cleanup();
+        reject(this.__createNotReadyError(reason));
+      };
+
+      const timer = setTimeout(() => {
+        cleanup();
+
+        if (homeySocket.connected) {
+          resolve();
+          return;
+        }
+
+        reject(this.__createNotReadyError());
+      }, NAMESPACE_STABILITY_TIMEOUT);
+
+      const cleanup = () => {
+        clearTimeout(timer);
+        homeySocket.removeListener('disconnect', onDisconnect);
+
+        if (signal) {
+          signal.removeEventListener('abort', onAbort);
+        }
+      };
+
+      homeySocket.once('disconnect', onDisconnect);
+
+      if (signal) {
+        if (signal.aborted) {
+          cleanup();
+          reject(this.__createAbortError(signal.reason));
+          return;
+        }
+
+        signal.addEventListener('abort', onAbort, { once: true });
+      }
+    });
+  }
+
+  __disposeStaleHomeySocket() {
+    const homeySocket = this.__homeySocket;
+    if (!homeySocket) return;
+
+    this.__homeySocket = null;
+    this.__unbindHomeySocket();
+
+    // Disconnect the stale namespace socket so it cannot auto-open on the next
+    // transport connect before ensureConnected() installs its connect/error
+    // listeners for the new reconnect attempt.
+    homeySocket.disconnect();
+  }
+
   __createAbortError(message) {
     const err = new Error(message || 'Socket session aborted.');
     err.name = 'AbortError';

package/lib/HomeyAPI/HomeyAPIV3/SubscriptionRegistry.js

@@ -6,6 +6,10 @@ class SubscriptionRegistry {
   constructor({ homey, session }) {
     this.homey = homey;
     this.session = session;
+    // Each URI entry represents one wire-level subscription for the current
+    // session revision. Multiple local consumers can share that single server
+    // subscription, and needsReconnect means the consumer state still exists
+    // locally while the server-side subscription must be restored.
     this.__entries = new Map();
     this.__destroyed = false;
 
@@ -127,7 +131,7 @@ class SubscriptionRegistry {
       return entry.subscribePromise;
     }
 
-    const subscribePromise = Promise.resolve().then(async () => {
+    const subscribePromise = (async () => {
       const { homeySocket, revision } = await this.session.ensureConnected();
 
       if (entry.removed || entry.consumers.size === 0) {
@@ -151,7 +155,7 @@ class SubscriptionRegistry {
       entry.subscribedRevision = revision;
       entry.pendingRevision = 0;
       entry.hasConnected = true;
-    });
+    })();
 
     entry.subscribePromise = subscribePromise;
 
@@ -232,10 +236,9 @@ class SubscriptionRegistry {
       return;
     }
 
-    // Socket.io can report a transport reconnect before the Homey namespace has
-    // been re-handshaked. We allow both reconnect and ready to resume entries;
-    // __resumeEntry() deduplicates the work while ready is the point where the
-    // current namespace socket can be rebound safely.
+    // The transport can reconnect before the current Homey namespace is ready.
+    // Listen to both reconnect and ready so entries resume promptly, while
+    // ready is the point where the active namespace socket can be rebound.
     for (const entry of this.__entries.values()) {
       if (entry.consumers.size === 0 || !entry.needsReconnect) {
         continue;
@@ -271,8 +274,8 @@ class SubscriptionRegistry {
       return entry.reconnectPromise;
     }
 
-    const reconnectPromise = Promise.resolve()
-      .then(async () => {
+    const reconnectPromise = (async () => {
+      try {
         await this.__ensureEntrySubscribed(entry);
 
         if (
@@ -285,22 +288,23 @@ class SubscriptionRegistry {
 
         entry.needsReconnect = false;
         this.__notifyConsumers(entry, 'onReconnect');
-      })
-      .catch((err) => {
+      } catch (err) {
         if (entry.removed || entry.consumers.size === 0) {
           return;
         }
 
         this.__notifyConsumers(entry, 'onReconnectError', err);
-      })
-      .finally(() => {
-        if (entry.reconnectPromise === reconnectPromise) {
-          entry.reconnectPromise = null;
-        }
-      });
+      }
+    })();
 
     entry.reconnectPromise = reconnectPromise;
 
+    reconnectPromise.finally(() => {
+      if (entry.reconnectPromise === reconnectPromise) {
+        entry.reconnectPromise = null;
+      }
+    });
+
     return reconnectPromise;
   }
 

package/package.json

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