@whitewall/blip-sdk 0.0.180 → 0.0.182

package/src/sender/tcp/tcpsender.ts

@@ -10,7 +10,6 @@ import type {
     Notification,
     UnknownCommandResponse,
 } from '../../types/index.ts'
-import { logger } from '../../utils/logger.ts'
 import { BlipError } from '../bliperror.ts'
 import { RetryableError } from '../retryableerror.ts'
 import { ConnectionSender, type ConnectionSenderConstructor, OpenConnectionSender } from '../sender.ts'
@@ -41,21 +40,20 @@ export class TCPSender extends OpenConnectionSender {
         this.connectionHandle = new TCPHandle<Envelope>(
             host,
             443,
-            () => {
+            (socketRef) => {
                 this.sessionNegotiator = new SessionNegotiator(this, (session) => {
-                    this.connectionHandle
-                        .get()
-                        .then((s) => s.write(JSON.stringify(session)))
-                        .catch((err) => logger.warn('TCPSender', 'Failed to write session frame', err))
+                    socketRef.current.write(JSON.stringify(session))
                 })
-                const upgradeToTls = tlsOptions ? () => this.connectionHandle.upgradeToTls(tlsOptions) : undefined
+                const upgradeToTls = tlsOptions
+                    ? () => this.connectionHandle.upgradeToTls(tlsOptions, socketRef)
+                    : undefined
                 return this.sessionNegotiator.negotiate({
                     node: options.node,
                     authentication: auth,
                     upgradeToTls,
                 })
             },
-            () => this.envelopeResolver.rejectPendingEnvelopes('Connection was closed'),
+            () => this.rejectPending('Connection was closed'),
             (envelope: Envelope) => {
                 if (this.sessionNegotiator?.negotiating) {
                     return this.sessionNegotiator.handleEnvelope(envelope)
@@ -143,7 +141,7 @@ class TCPHandle<T> {
     constructor(
         host: string,
         port: number,
-        onConnected: () => Promise<void>,
+        onConnected: (socketRef: { current: Socket }) => Promise<void>,
         onClose: () => void,
         onMessage: (message: T) => void,
     ) {
@@ -167,17 +165,19 @@ class TCPHandle<T> {
         }
     }
 
-    public async upgradeToTls(options: ConnectionOptions): Promise<void> {
-        if (!this.currentSocketPromise) {
-            throw new Error('Cannot upgrade: no active socket.')
-        }
-        const plain = await this.currentSocketPromise
+    public async upgradeToTls(options: ConnectionOptions, socketRef: { current: Socket }): Promise<void> {
+        const plain = socketRef.current
         plain.removeAllListeners('data')
         this.buffer = Buffer.alloc(0)
 
         const { connect: tlsConnect } = await import('node:tls')
         const secured = tlsConnect({ ...options, socket: plain })
 
+        // Permanent no-op handler attached up front, so errors that arrive in
+        // the microtask gap after secureConnect resolves don't become
+        // uncaughtException. The underlying TCP socket's 'close' drives reconnect.
+        secured.on('error', () => undefined)
+
         await new Promise<void>((resolve, reject) => {
             const onError = (err: Error) => {
                 secured.off('secureConnect', onConnect)
@@ -192,7 +192,7 @@ class TCPHandle<T> {
         })
 
         this.attachDataListener(secured)
-        this.currentSocketPromise = Promise.resolve(secured)
+        socketRef.current = secured
     }
 
     private attachDataListener(socket: NodeJS.ReadableStream) {
@@ -209,7 +209,7 @@ class TCPHandle<T> {
     private async connect(
         host: string,
         port: number,
-        onConnected: () => Promise<void>,
+        onConnected: (socketRef: { current: Socket }) => Promise<void>,
         onClose: () => void,
     ): Promise<Socket> {
         const { connect } = await import('node:net')
@@ -217,42 +217,60 @@ class TCPHandle<T> {
         const socket = connect({ host, port }).setKeepAlive(true)
         this.buffer = Buffer.alloc(0)
 
-        await new Promise<void>((resolve) => {
+        // Mutable holder so upgradeToTls can swap the socket mid-handshake;
+        // the negotiator's sendSession reads .current at write time, so frames
+        // always go to the active socket even after the TLS upgrade.
+        const socketRef = { current: socket }
+
+        await new Promise<void>((resolve, reject) => {
+            let connected = false
+
             socket.once('connect', () => {
+                connected = true
                 resolve()
             })
 
             socket.once('error', (err) => {
-                if (!this.closing) {
-                    throw err
+                if (!connected) {
+                    reject(err)
                 }
+                // Post-connect errors are followed by 'close', which drives reconnect;
+                // this listener exists only to prevent uncaughtException.
             })
 
             socket.once('close', () => {
-                socket.removeAllListeners('data')
+                // socketRef.current is the TLS-upgraded socket if upgrade ran; the
+                // plain one otherwise. Both cases hold the only live data listener.
+                socketRef.current.removeAllListeners('data')
+
                 if (!this.closing) {
-                    onClose()
+                    if (connected) onClose()
 
                     this.connectionAttempts++
-                    if (this.connectionAttempts < 3) {
-                        this.currentSocketPromise = this.connect(host, port, onConnected, onClose)
-                    } else {
-                        throw new Error('Failed to connect/reconnect to TCP socket')
-                    }
+                    // Swallow the rejection of the now-orphaned previous promise; any
+                    // in-flight get() awaiter still sees it via their captured reference.
+                    const previous = this.currentSocketPromise
+                    this.currentSocketPromise =
+                        this.connectionAttempts < 3 ? this.connect(host, port, onConnected, onClose) : null
+                    previous?.catch(() => undefined)
                 }
+
+                if (!connected) reject(new Error('Socket closed before connect'))
             })
 
             this.attachDataListener(socket)
         })
 
-        // sendSession callbacks read currentSocketPromise via .get(); resolve it
-        // before onConnected runs so negotiate() can write the 'new' session frame
-        // (otherwise we deadlock waiting on the outer connect() promise).
-        this.currentSocketPromise = Promise.resolve(socket)
-
-        await onConnected()
+        try {
+            await onConnected(socketRef)
+        } catch (err) {
+            // Handshake failures (timeout, bad response) leave the socket open
+            // otherwise; destroy it so the 'close' handler drives reconnect.
+            socketRef.current.destroy()
+            throw err
+        }
         this.connectionAttempts = 0
 
-        return socket
+        return socketRef.current
     }
 }

package/src/sender/websocket/websocketsender.ts

@@ -39,7 +39,7 @@ export class WebSocketSender extends OpenConnectionSender {
                     authentication: options.authentication,
                 })
             },
-            () => this.envelopeResolver.rejectPendingEnvelopes('Connection was closed'),
+            () => this.rejectPending('Connection was closed'),
             (envelope: Envelope) => {
                 if (this.sessionNegotiator?.negotiating) {
                     return this.sessionNegotiator.handleEnvelope(envelope)
@@ -139,7 +139,10 @@ class WebSocketHandle<T> {
     }
 
     public get() {
-        return this.currentWebSocketPromise!
+        if (!this.currentWebSocketPromise) {
+            throw new Error('WebSocket connection is not available.')
+        }
+        return this.currentWebSocketPromise
     }
 
     public async close() {
@@ -159,31 +162,54 @@ class WebSocketHandle<T> {
         const connection = new WebSocket(url, 'lime')
 
         await new Promise<void>((resolve, reject) => {
+            let connected = false
+
             connection.onopen = () => {
+                connected = true
                 resolve()
             }
+            connection.onerror = (err) => {
+                if (!connected) {
+                    reject('message' in err ? new Error(`WebSocket error: ${err.message}`, { cause: err }) : err)
+                }
+                // Post-open errors are followed by 'close', which drives reconnect.
+            }
             connection.onclose = () => {
                 if (!this.closing) {
-                    this.connectionAttempts++
-
-                    if (this.connectionAttempts < 3) {
-                        this.currentWebSocketPromise = this.connect(url, onConnected, onClose, onMessage)
-                    } else {
-                        reject(new Error('Failed to connect to WebSocket'))
-                    }
+                    if (connected) onClose()
 
-                    onClose()
+                    this.connectionAttempts++
+                    // Swallow the rejection of the now-orphaned previous promise; any
+                    // in-flight get() awaiter still sees it via their captured reference.
+                    const previous = this.currentWebSocketPromise
+                    this.currentWebSocketPromise =
+                        this.connectionAttempts < 3 ? this.connect(url, onConnected, onClose, onMessage) : null
+                    previous?.catch(() => undefined)
                 }
+
+                if (!connected) reject(new Error('WebSocket closed before open'))
             }
             connection.onmessage = (event) => {
                 onMessage(JSON.parse(event.data))
             }
-            connection.onerror = (err) => {
-                reject('message' in err ? new Error(`WebSocket error: ${err.message}`, { cause: err }) : err)
-            }
         })
 
-        await onConnected(connection)
+        try {
+            await onConnected(connection)
+        } catch (err) {
+            // Handshake failures leave the socket open otherwise; tear it down so
+            // the 'onclose' handler drives reconnect. Prefer ws.terminate() (hard
+            // kill, Node only) to avoid waiting on the graceful close handshake
+            // with a peer that just failed to negotiate; fall back to close() in
+            // browsers where terminate() doesn't exist.
+            const terminable = connection as WebSocket & { terminate?: () => void }
+            if (terminable.terminate) {
+                terminable.terminate()
+            } else {
+                connection.close()
+            }
+            throw err
+        }
         this.connectionAttempts = 0
 
         return connection