fix(websocket): time out a stalled connect/auth handshake so retry can fire

If the server accepts the TCP connection but never completes the
application-layer handshake -- it never returns the WebSocket 101 upgrade,
or upgrades but never sends auth_ok -- none of the socket's
open/message/close/error events fire. connect() therefore never settles the
connection promise and never schedules its onClose retry, so the node sits
at "connecting" indefinitely (21 hours in the reported case) until Node-RED
is restarted. This happens when the HA host's kernel is alive (answers ARP,
completes TCP handshakes) but the HA process is blocked, e.g. a storage
stall / uninterruptible I/O wait.

Add two timeouts, both routed into the existing onClose retry path:

- handshakeTimeout on the ws socket: ws emits 'error' if the opening HTTP
  handshake (the 101 upgrade) does not complete in time. Covers the
  never-upgrades case (the deterministic bare-TCP-listener repro).
- an overall auth deadline: terminate() the socket if auth_ok has not
  arrived. Covers upgrade-but-never-authenticates. terminate() (not
  close()) forces a prompt 'close' even on a wedged half-open socket whose
  peer will never complete a closing handshake.

The timer is cleared on auth_ok and on close. Healthy connections are
unaffected. No public API change.

Co-authored-by: jschwalbe <jschwalbe@gmail.com>
Co-authored-by: Claude <noreply@anthropic.com>

Author: 3 people

src/homeAssistant/createSocket.ts

@@ -13,6 +13,17 @@ import { ClientEvent } from './Websocket';
 
 const debug = Debug('home-assistant:socket');
 
+// Time budgets for the connect/auth handshake. A half-open connection -- the
+// server completes the TCP handshake but never finishes the WebSocket upgrade
+// (no 101 response), or upgrades but never sends auth_ok (e.g. a Home Assistant
+// wedged in uninterruptible I/O wait) -- otherwise fires no open/message/close/
+// error event, so the connect promise never settles and no retry ever runs. The
+// node then sits at 'connecting' indefinitely. These timeouts force a teardown
+// so the existing close/error retry path below fires as it does for every other
+// connection failure.
+const HANDSHAKE_TIMEOUT = 15000; // WS HTTP-upgrade (101) must complete within this
+const AUTH_TIMEOUT = 45000; // auth_ok must arrive within this after a connect attempt starts
+
 interface HaWebSocket extends WebSocket {
     haVersion: string;
 }
@@ -49,12 +60,33 @@ export default function createSocket({
         eventBus.emit(ClientEvent.Connecting);
 
         const socket = new WebSocket(url, {
+            handshakeTimeout: HANDSHAKE_TIMEOUT,
             rejectUnauthorized: rejectUnauthorizedCerts,
         }) as HaWebSocket;
 
         // If invalid auth, we will not try to reconnect.
         let invalidAuth = false;
 
+        // If auth_ok has not arrived in time, tear the socket down. terminate()
+        // (not close()) guarantees a prompt 'close' even on a wedged, half-open
+        // socket whose peer will never complete a closing handshake.
+        let authTimeout: ReturnType<typeof setTimeout> | undefined = setTimeout(
+            () => {
+                debug(
+                    '[Auth Phase] auth handshake timed out after %dms, terminating',
+                    AUTH_TIMEOUT,
+                );
+                socket.terminate();
+            },
+            AUTH_TIMEOUT,
+        );
+        const clearAuthTimeout = () => {
+            if (authTimeout) {
+                clearTimeout(authTimeout);
+                authTimeout = undefined;
+            }
+        };
+
         const onOpen = async () => {
             try {
                 socket.send(JSON.stringify(auth));
@@ -78,6 +110,7 @@ export default function createSocket({
                     break;
 
                 case MSG_TYPE_AUTH_OK:
+                    clearAuthTimeout();
                     socket.off('open', onOpen);
                     socket.off('message', onMessage);
                     socket.off('close', onClose);
@@ -104,6 +137,7 @@ export default function createSocket({
         };
 
         const onClose = () => {
+            clearAuthTimeout();
             // If we are in error handler make sure close handler doesn't also fire.
             socket.off('close', onClose);
             if (invalidAuth) {