icom-wlan-node 0.1.0 → 0.2.0

package/dist/rig/IcomControl.js

@@ -38,6 +38,7 @@ const events_1 = require("events");
 const IcomPackets_1 = require("../core/IcomPackets");
 const debug_1 = require("../utils/debug");
 const Session_1 = require("../core/Session");
+const types_1 = require("../types");
 const IcomCiv_1 = require("./IcomCiv");
 const IcomAudio_1 = require("./IcomAudio");
 const IcomRigCommands_1 = require("./IcomRigCommands");
@@ -49,66 +50,397 @@ class IcomControl {
         this.rigName = '';
         this.macAddress = Buffer.alloc(6);
         this.civAssembleBuf = Buffer.alloc(0); // CIV stream reassembler
+        // Connection state machine (replaces old fragmented state flags)
+        this.connectionSession = {
+            phase: types_1.ConnectionPhase.IDLE,
+            sessionId: 0,
+            startTime: Date.now()
+        };
+        this.nextSessionId = 1;
+        // Map of sessionId -> abort function for cancelling ongoing connection attempts
+        this.abortHandlers = new Map();
+        this.monitorConfig = {
+            timeout: 5000,
+            checkInterval: 1000,
+            autoReconnect: false,
+            maxReconnectAttempts: undefined, // undefined = infinite retries
+            reconnectBaseDelay: 2000,
+            reconnectMaxDelay: 30000
+        };
         this.options = options;
+        // Setup control session
         this.sess = new Session_1.Session({ ip: options.control.ip, port: options.control.port }, {
             onData: (data) => this.onData(data),
             onSendError: (e) => this.ev.emit('error', e)
         });
-        // Pre-open local CIV/Audio sessions to obtain local ports before 0x90
-        this.civSess = new Session_1.Session({ ip: options.control.ip, port: 0 }, { onData: (b) => this.onCivData(b), onSendError: (e) => this.ev.emit('error', e) });
-        this.audioSess = new Session_1.Session({ ip: options.control.ip, port: 0 }, { onData: (b) => this.onAudioData(b), onSendError: (e) => this.ev.emit('error', e) });
+        this.sess.sessionType = types_1.SessionType.CONTROL;
+        // Setup CIV session
+        this.civSess = new Session_1.Session({ ip: options.control.ip, port: 0 }, {
+            onData: (b) => this.onCivData(b),
+            onSendError: (e) => this.ev.emit('error', e)
+        });
+        this.civSess.sessionType = types_1.SessionType.CIV;
         this.civSess.open();
+        // Setup audio session
+        this.audioSess = new Session_1.Session({ ip: options.control.ip, port: 0 }, {
+            onData: (b) => this.onAudioData(b),
+            onSendError: (e) => this.ev.emit('error', e)
+        });
+        this.audioSess.sessionType = types_1.SessionType.AUDIO;
         this.audioSess.open();
         this.civ = new IcomCiv_1.IcomCiv(this.civSess);
         this.audio = new IcomAudio_1.IcomAudio(this.audioSess);
     }
     get events() { return this.ev; }
+    // ============================================================================
+    // State Machine Management
+    // ============================================================================
+    /**
+     * Transition to a new connection phase with logging
+     * @private
+     */
+    transitionTo(newPhase, reason) {
+        const oldPhase = this.connectionSession.phase;
+        if (oldPhase === newPhase)
+            return; // No-op if already in target phase
+        (0, debug_1.dbg)(`State transition: ${oldPhase} → ${newPhase} (${reason})`);
+        this.connectionSession.phase = newPhase;
+        // Update timestamps based on phase
+        if (newPhase === types_1.ConnectionPhase.CONNECTING || newPhase === types_1.ConnectionPhase.RECONNECTING) {
+            this.connectionSession.startTime = Date.now();
+        }
+        else if (newPhase === types_1.ConnectionPhase.IDLE) {
+            // Record disconnect time when entering IDLE
+            this.connectionSession.lastDisconnectTime = Date.now();
+        }
+    }
+    /**
+     * Validate if a state transition is legal
+     * @private
+     */
+    canTransitionTo(targetPhase) {
+        const current = this.connectionSession.phase;
+        // Define valid state transitions
+        const validTransitions = {
+            [types_1.ConnectionPhase.IDLE]: [types_1.ConnectionPhase.CONNECTING],
+            [types_1.ConnectionPhase.CONNECTING]: [types_1.ConnectionPhase.CONNECTED, types_1.ConnectionPhase.DISCONNECTING, types_1.ConnectionPhase.IDLE],
+            [types_1.ConnectionPhase.CONNECTED]: [types_1.ConnectionPhase.DISCONNECTING, types_1.ConnectionPhase.RECONNECTING],
+            [types_1.ConnectionPhase.DISCONNECTING]: [types_1.ConnectionPhase.IDLE],
+            [types_1.ConnectionPhase.RECONNECTING]: [types_1.ConnectionPhase.CONNECTED, types_1.ConnectionPhase.IDLE]
+        };
+        return validTransitions[current]?.includes(targetPhase) ?? false;
+    }
+    /**
+     * Abort an ongoing connection attempt by session ID
+     * @private
+     */
+    abortConnectionAttempt(sessionId, reason) {
+        const abortHandler = this.abortHandlers.get(sessionId);
+        if (abortHandler) {
+            (0, debug_1.dbg)(`Aborting connection session ${sessionId}: ${reason}`);
+            abortHandler(reason);
+            this.abortHandlers.delete(sessionId);
+        }
+    }
+    // ============================================================================
+    // Connection Methods
+    // ============================================================================
+    /**
+     * Connect to the rig
+     * Idempotent: multiple calls during CONNECTING phase are safe
+     * @throws Error if called during DISCONNECTING phase
+     */
     async connect() {
-        // Initialize readiness promises
-        this.loginReady = new Promise(resolve => { this.resolveLoginReady = resolve; });
-        this.civReady = new Promise(resolve => { this.resolveCivReady = resolve; });
-        this.audioReady = new Promise(resolve => { this.resolveAudioReady = resolve; });
-        this.sess.open();
-        this.sess.startAreYouThere();
-        // Wait for all sub-sessions to be ready
-        await Promise.all([this.loginReady, this.civReady, this.audioReady]);
-        (0, debug_1.dbg)('All sessions ready (login + civ + audio)');
+        const currentPhase = this.connectionSession.phase;
+        // If already connected, return immediately
+        if (currentPhase === types_1.ConnectionPhase.CONNECTED) {
+            (0, debug_1.dbg)('connect() called but already CONNECTED - returning immediately');
+            return;
+        }
+        // If already connecting or reconnecting, wait for completion (idempotent)
+        if (currentPhase === types_1.ConnectionPhase.CONNECTING || currentPhase === types_1.ConnectionPhase.RECONNECTING) {
+            (0, debug_1.dbg)(`connect() called while ${currentPhase} - idempotent behavior, will wait`);
+            // Return a promise that resolves when state changes to CONNECTED
+            return new Promise((resolve, reject) => {
+                const checkState = () => {
+                    if (this.connectionSession.phase === types_1.ConnectionPhase.CONNECTED) {
+                        resolve();
+                    }
+                    else if (this.connectionSession.phase === types_1.ConnectionPhase.IDLE) {
+                        reject(new Error('Connection failed'));
+                    }
+                    else {
+                        setTimeout(checkState, 100);
+                    }
+                };
+                checkState();
+            });
+        }
+        // Reject if in DISCONNECTING phase
+        if (currentPhase === types_1.ConnectionPhase.DISCONNECTING) {
+            throw new Error('Cannot connect while disconnecting - wait for IDLE state');
+        }
+        // Only IDLE state can transition to CONNECTING
+        if (!this.canTransitionTo(types_1.ConnectionPhase.CONNECTING)) {
+            throw new Error(`Cannot connect from ${currentPhase} state`);
+        }
+        // Start new connection session
+        const sessionId = this.nextSessionId++;
+        this.connectionSession.sessionId = sessionId;
+        this.transitionTo(types_1.ConnectionPhase.CONNECTING, `User connect() - sessionId=${sessionId}`);
+        try {
+            await this._doConnect(sessionId);
+            this.transitionTo(types_1.ConnectionPhase.CONNECTED, 'All sessions ready');
+            (0, debug_1.dbg)(`Connection session ${sessionId} established successfully`);
+        }
+        catch (err) {
+            // Clean up abort handler
+            this.abortHandlers.delete(sessionId);
+            // Transition to IDLE on failure
+            this.transitionTo(types_1.ConnectionPhase.IDLE, `Connection failed: ${err instanceof Error ? err.message : String(err)}`);
+            throw err;
+        }
+    }
+    /**
+     * Internal connection implementation
+     * Uses local promises to avoid race conditions
+     * Uses phased timeout: 30s for overall, 10s for sub-sessions after login
+     * @param sessionId - Unique session ID to prevent race conditions
+     */
+    async _doConnect(sessionId) {
+        const { loginReady, civReady, audioReady, cleanup } = this.createReadyPromises(sessionId);
+        try {
+            // Reset all session states to initial values
+            // This is CRITICAL for reconnection after radio restart
+            // Without this, the radio won't recognize our old localId/remoteId/tokens
+            (0, debug_1.dbg)('Resetting all session states before connection...');
+            this.sess.resetState();
+            this.civSess.resetState();
+            this.audioSess.resetState();
+            // Ensure all session sockets are open (critical for reconnection after disconnect)
+            this.sess.open();
+            this.civSess.open();
+            this.audioSess.open();
+            this.sess.startAreYouThere();
+            // Phase 1: Wait for login (protected by overall 30s timeout from connectWithTimeout)
+            await loginReady;
+            (0, debug_1.dbg)('Login complete, waiting for CIV/Audio sub-sessions...');
+            // Phase 2: Wait for CIV/Audio with shorter timeout (10s)
+            // If radio doesn't respond to AreYouThere, fail fast instead of waiting full 30s
+            const SUB_SESSION_TIMEOUT = 10000;
+            const subSessionTimeout = new Promise((_, reject) => {
+                setTimeout(() => {
+                    reject(new Error(`CIV/Audio sessions timeout after ${SUB_SESSION_TIMEOUT}ms - radio not responding to AreYouThere`));
+                }, SUB_SESSION_TIMEOUT);
+            });
+            await Promise.race([
+                Promise.all([civReady, audioReady]),
+                subSessionTimeout
+            ]);
+            (0, debug_1.dbg)('All sessions ready (login + civ + audio)');
+            // Start unified connection monitoring
+            this.startUnifiedMonitoring();
+            (0, debug_1.dbg)('Unified connection monitoring started');
+        }
+        finally {
+            cleanup();
+        }
+    }
+    /**
+     * Create local promises for connection readiness
+     * This avoids race conditions with instance variables
+     * @param sessionId - Connection session ID for abort handler tracking
+     */
+    createReadyPromises(sessionId) {
+        let resolveLogin;
+        let resolveCiv;
+        let resolveAudio;
+        let rejectLogin;
+        let rejectCiv;
+        let rejectAudio;
+        const loginReady = new Promise((resolve, reject) => {
+            resolveLogin = resolve;
+            rejectLogin = reject;
+        });
+        const civReady = new Promise((resolve, reject) => {
+            resolveCiv = resolve;
+            rejectCiv = reject;
+        });
+        const audioReady = new Promise((resolve, reject) => {
+            resolveAudio = resolve;
+            rejectAudio = reject;
+        });
+        // Store abort handler bound to this specific sessionId
+        // This prevents race conditions when multiple connection attempts overlap
+        const abortHandler = (reason) => {
+            (0, debug_1.dbg)(`Aborting connection session ${sessionId}: ${reason}`);
+            const error = new Error(reason);
+            rejectLogin(error);
+            rejectCiv(error);
+            rejectAudio(error);
+        };
+        this.abortHandlers.set(sessionId, abortHandler);
+        // Temporary event listeners (local scope)
+        const onLogin = (res) => {
+            if (res.ok) {
+                (0, debug_1.dbg)('Login ready - resolving local loginReady promise');
+                resolveLogin();
+            }
+        };
+        const onCivReady = () => {
+            (0, debug_1.dbg)('CIV ready - resolving local civReady promise');
+            resolveCiv();
+        };
+        const onAudioReady = () => {
+            (0, debug_1.dbg)('Audio ready - resolving local audioReady promise');
+            resolveAudio();
+        };
+        this.ev.once('login', onLogin);
+        this.ev.once('_civReady', onCivReady);
+        this.ev.once('_audioReady', onAudioReady);
+        return {
+            loginReady,
+            civReady,
+            audioReady,
+            cleanup: () => {
+                // Remove abort handler for this specific sessionId
+                // This is safe because the connection attempt is complete (success or failure)
+                this.abortHandlers.delete(sessionId);
+                // Remove event listeners
+                this.ev.off('login', onLogin);
+                this.ev.off('_civReady', onCivReady);
+                this.ev.off('_audioReady', onAudioReady);
+            }
+        };
+    }
+    /**
+     * Start unified connection monitoring
+     * Monitors all three sessions from a single timer to avoid race conditions
+     * @private
+     */
+    startUnifiedMonitoring() {
+        this.stopUnifiedMonitoring();
+        this.monitorTimer = setInterval(() => {
+            // Only monitor when CONNECTED (not during CONNECTING, RECONNECTING, DISCONNECTING, or IDLE)
+            if (this.connectionSession.phase !== types_1.ConnectionPhase.CONNECTED) {
+                return;
+            }
+            const now = Date.now();
+            const sessions = [
+                { sess: this.sess, type: types_1.SessionType.CONTROL },
+                { sess: this.civSess, type: types_1.SessionType.CIV },
+                { sess: this.audioSess, type: types_1.SessionType.AUDIO }
+            ];
+            // Check each session for timeout
+            for (const { sess, type } of sessions) {
+                if (sess['destroyed'])
+                    continue; // Skip destroyed sessions
+                const timeSinceLastData = now - sess.lastReceivedTime;
+                if (timeSinceLastData > this.monitorConfig.timeout) {
+                    (0, debug_1.dbg)(`${type} session timeout detected (${timeSinceLastData}ms since last data)`);
+                    this.handleConnectionLost(type, timeSinceLastData);
+                    return; // Only handle one timeout at a time to avoid duplicate reconnect triggers
+                }
+            }
+        }, this.monitorConfig.checkInterval);
+    }
+    /**
+     * Stop unified connection monitoring
+     * @private
+     */
+    stopUnifiedMonitoring() {
+        if (this.monitorTimer) {
+            clearInterval(this.monitorTimer);
+            this.monitorTimer = undefined;
+        }
     }
     async disconnect() {
-        // 1. Stop all timers first to prevent interference
-        if (this.tokenTimer) {
-            clearInterval(this.tokenTimer);
-            this.tokenTimer = undefined;
+        const currentPhase = this.connectionSession.phase;
+        // If already disconnecting or idle, avoid duplicate work
+        if (currentPhase === types_1.ConnectionPhase.DISCONNECTING) {
+            (0, debug_1.dbg)('disconnect() called but already DISCONNECTING - waiting for completion');
+            // Wait for transition to IDLE
+            return new Promise((resolve) => {
+                const checkState = () => {
+                    if (this.connectionSession.phase === types_1.ConnectionPhase.IDLE) {
+                        resolve();
+                    }
+                    else {
+                        setTimeout(checkState, 100);
+                    }
+                };
+                checkState();
+            });
+        }
+        if (currentPhase === types_1.ConnectionPhase.IDLE) {
+            (0, debug_1.dbg)('disconnect() called but already IDLE - no-op');
+            return;
+        }
+        // Abort any ongoing connection attempts
+        const currentSessionId = this.connectionSession.sessionId;
+        if (currentPhase === types_1.ConnectionPhase.CONNECTING || currentPhase === types_1.ConnectionPhase.RECONNECTING) {
+            (0, debug_1.dbg)(`Aborting ongoing connection attempt (sessionId=${currentSessionId})`);
+            this.abortConnectionAttempt(currentSessionId, 'User disconnect()');
+        }
+        // Transition to DISCONNECTING state
+        this.transitionTo(types_1.ConnectionPhase.DISCONNECTING, 'User disconnect()');
+        try {
+            // 1. Stop all timers first to prevent interference
+            this.stopUnifiedMonitoring(); // Stop unified monitoring
+            if (this.tokenTimer) {
+                clearInterval(this.tokenTimer);
+                this.tokenTimer = undefined;
+            }
+            this.stopMeterPolling();
+            this.sess.stopTimers();
+            if (this.civSess)
+                this.civSess.stopTimers();
+            if (this.audioSess)
+                this.audioSess.stopTimers();
+            // 2. Send DELETE token packet
+            try {
+                const del = IcomPackets_1.TokenPacket.build(0, this.sess.localId, this.sess.remoteId, IcomPackets_1.TokenType.DELETE, this.sess.innerSeq, this.sess.localToken, this.sess.rigToken);
+                this.sess.innerSeq = (this.sess.innerSeq + 1) & 0xffff;
+                this.sess.sendTracked(del);
+            }
+            catch (err) {
+                (0, debug_1.dbg)('Failed to send DELETE token packet:', err);
+                // Continue with disconnect even if this fails
+            }
+            // 3. Send CMD_DISCONNECT to all sessions
+            try {
+                this.sess.sendUntracked(IcomPackets_1.ControlPacket.toBytes(IcomPackets_1.Cmd.DISCONNECT, 0, this.sess.localId, this.sess.remoteId));
+                if (this.civSess) {
+                    this.civ.sendOpenClose(false);
+                    this.civSess.sendUntracked(IcomPackets_1.ControlPacket.toBytes(IcomPackets_1.Cmd.DISCONNECT, 0, this.civSess.localId, this.civSess.remoteId));
+                }
+                if (this.audioSess) {
+                    this.audioSess.sendUntracked(IcomPackets_1.ControlPacket.toBytes(IcomPackets_1.Cmd.DISCONNECT, 0, this.audioSess.localId, this.audioSess.remoteId));
+                }
+            }
+            catch (err) {
+                (0, debug_1.dbg)('Failed to send DISCONNECT packets:', err);
+                // Continue with disconnect even if this fails
+            }
+            // 4. Wait 200ms to ensure UDP packets are sent before closing sockets
+            await new Promise(resolve => setTimeout(resolve, 200));
+            // 5. Stop streams and close sockets
+            this.civ.stop();
+            this.audio.stop(); // Stop continuous audio transmission
+            this.sess.close();
+            if (this.civSess)
+                this.civSess.close();
+            if (this.audioSess)
+                this.audioSess.close();
+        }
+        catch (err) {
+            (0, debug_1.dbg)('Error during disconnect:', err);
+            // Continue to IDLE state even if there were errors
+        }
+        finally {
+            // Always transition to IDLE at the end
+            this.transitionTo(types_1.ConnectionPhase.IDLE, 'Disconnect complete');
         }
-        this.stopMeterPolling();
-        this.sess.stopTimers();
-        if (this.civSess)
-            this.civSess.stopTimers();
-        if (this.audioSess)
-            this.audioSess.stopTimers();
-        // 2. Send DELETE token packet
-        const del = IcomPackets_1.TokenPacket.build(0, this.sess.localId, this.sess.remoteId, IcomPackets_1.TokenType.DELETE, this.sess.innerSeq, this.sess.localToken, this.sess.rigToken);
-        this.sess.innerSeq = (this.sess.innerSeq + 1) & 0xffff;
-        this.sess.sendTracked(del);
-        // 3. Send CMD_DISCONNECT to all sessions
-        this.sess.sendUntracked(IcomPackets_1.ControlPacket.toBytes(IcomPackets_1.Cmd.DISCONNECT, 0, this.sess.localId, this.sess.remoteId));
-        if (this.civSess) {
-            this.civ.sendOpenClose(false);
-            this.civSess.sendUntracked(IcomPackets_1.ControlPacket.toBytes(IcomPackets_1.Cmd.DISCONNECT, 0, this.civSess.localId, this.civSess.remoteId));
-        }
-        if (this.audioSess) {
-            this.audioSess.sendUntracked(IcomPackets_1.ControlPacket.toBytes(IcomPackets_1.Cmd.DISCONNECT, 0, this.audioSess.localId, this.audioSess.remoteId));
-        }
-        // 4. Wait 200ms to ensure UDP packets are sent before closing sockets
-        await new Promise(resolve => setTimeout(resolve, 200));
-        // 5. Stop streams and close sockets
-        this.civ.stop();
-        this.audio.stop(); // Stop continuous audio transmission
-        this.sess.close();
-        if (this.civSess)
-            this.civSess.close();
-        if (this.audioSess)
-            this.audioSess.close();
     }
     sendCiv(data) { this.civ.sendCivData(data); }
     /**
@@ -568,10 +900,42 @@ class IcomControl {
             case IcomPackets_1.Sizes.STATUS: {
                 const civPort = IcomPackets_1.StatusPacket.getRigCivPort(buf);
                 const audioPort = IcomPackets_1.StatusPacket.getRigAudioPort(buf);
-                (0, debug_1.dbg)('STATUS <= civPort=', civPort, 'audioPort=', audioPort, 'authOK=', IcomPackets_1.StatusPacket.authOK(buf), 'connected=', IcomPackets_1.StatusPacket.getIsConnected(buf));
+                const connected = IcomPackets_1.StatusPacket.getIsConnected(buf);
+                const authOK = IcomPackets_1.StatusPacket.authOK(buf);
+                (0, debug_1.dbg)('STATUS <= civPort=', civPort, 'audioPort=', audioPort, 'authOK=', authOK, 'connected=', connected);
+                // If radio reports disconnected, handle immediately
+                if (!connected) {
+                    (0, debug_1.dbg)('Radio reported connected=false');
+                    // If we're currently attempting to connect, abort immediately (fast-fail)
+                    const currentPhase = this.connectionSession.phase;
+                    if (currentPhase === types_1.ConnectionPhase.CONNECTING || currentPhase === types_1.ConnectionPhase.RECONNECTING) {
+                        (0, debug_1.dbg)('Aborting ongoing connection attempt due to connected=false');
+                        this.abortConnectionAttempt(this.connectionSession.sessionId, 'Radio reported connected=false');
+                    }
+                    else if (currentPhase === types_1.ConnectionPhase.CONNECTED) {
+                        // Trigger reconnection for established connection
+                        (0, debug_1.dbg)('Triggering reconnection for established connection');
+                        this.handleConnectionLost(types_1.SessionType.CONTROL, 0);
+                    }
+                    break;
+                }
+                // CRITICAL: Ignore STATUS packets with invalid ports (0)
+                // Radio sends multiple STATUS packets during connection:
+                //   1. First with valid ports (e.g., 50002, 50003) when CONNINFO busy=false
+                //   2. Second with port=0 when CONNINFO busy=true (should be ignored!)
+                // If we don't check, the second packet will overwrite the valid ports with 0
+                if (civPort === 0 || audioPort === 0) {
+                    (0, debug_1.dbg)('STATUS packet has invalid ports (0) - ignoring to preserve existing valid ports');
+                    (0, debug_1.dbg)('This is normal during reconnection when rig sends CONNINFO busy=true');
+                    // Still emit status event for monitoring, but don't setRemote
+                    const info = { civPort, audioPort, authOK, connected };
+                    this.ev.emit('status', info);
+                    break;
+                }
                 const info = { civPort, audioPort, authOK: true, connected: true };
                 this.ev.emit('status', info);
-                // set remote ports and start AYT for civ/audio
+                // Only set remote ports and start sessions if ports are valid (non-zero)
+                (0, debug_1.dbg)('STATUS has valid ports - setting up CIV/Audio sessions');
                 if (this.civSess) {
                     this.civSess.setRemote(this.options.control.ip, civPort);
                     this.civSess.startAreYouThere();
@@ -604,10 +968,7 @@ class IcomControl {
                 }
                 const res = { ok, errorCode: IcomPackets_1.LoginResponsePacket.errorNum(buf), connection: IcomPackets_1.LoginResponsePacket.getConnection(buf) };
                 this.ev.emit('login', res);
-                if (ok) {
-                    (0, debug_1.dbg)('Login ready - resolving loginReady promise');
-                    this.resolveLoginReady();
-                }
+                // Note: login event is caught by createReadyPromises() listener
                 break;
             }
             case IcomPackets_1.Sizes.CAP_CAP: {
@@ -629,23 +990,28 @@ class IcomControl {
             }
             case IcomPackets_1.Sizes.CONNINFO: {
                 // rig sends twice; first time busy=false, reply with our ports
+                // IMPORTANT: During reconnection, rig may send busy=true if old connection not fully cleaned up
+                // We MUST still reply to proceed with connection (otherwise STATUS packet will never arrive)
                 const busy = IcomPackets_1.ConnInfoPacket.getBusy(buf);
                 this.macAddress = IcomPackets_1.ConnInfoPacket.getMacAddress(buf);
                 this.rigName = IcomPackets_1.ConnInfoPacket.getRigName(buf);
                 (0, debug_1.dbg)('CONNINFO <= busy=', busy, 'rigName=', this.rigName);
-                if (!busy) {
-                    const reply = IcomPackets_1.ConnInfoPacket.connInfoPacketData(buf, 0, this.sess.localId, this.sess.remoteId, 0x01, 0x03, this.sess.innerSeq, this.sess.localToken, this.sess.rigToken, this.rigName, this.options.userName, IcomPackets_1.AUDIO_SAMPLE_RATE, IcomPackets_1.AUDIO_SAMPLE_RATE, this.civSess.localPort, this.audioSess.localPort, IcomPackets_1.XIEGU_TX_BUFFER_SIZE);
-                    this.sess.innerSeq = (this.sess.innerSeq + 1) & 0xffff;
-                    this.sess.sendTracked(reply);
-                    try {
-                        // eslint-disable-next-line @typescript-eslint/no-var-requires
-                        const { hex } = require('../utils/codec');
-                        (0, debug_1.dbg)('CONNINFO -> reply with local civPort=', this.civSess.localPort, 'audioPort=', this.audioSess.localPort);
-                        (0, debug_1.dbgV)('CONNINFO reply hex (first 0x60):', hex(Buffer.from(reply.subarray(0, 0x60))));
-                        (0, debug_1.dbgV)('CONNINFO reply hex (0x60..0x90):', hex(Buffer.from(reply.subarray(0x60, 0x90))));
-                    }
-                    catch { }
+                if (busy) {
+                    (0, debug_1.dbg)('CONNINFO busy=true detected - likely reconnecting while rig still has old session');
+                    (0, debug_1.dbg)('Sending ConnInfo reply anyway to allow STATUS packet delivery');
+                }
+                // ALWAYS send reply (even when busy=true during reconnection)
+                const reply = IcomPackets_1.ConnInfoPacket.connInfoPacketData(buf, 0, this.sess.localId, this.sess.remoteId, 0x01, 0x03, this.sess.innerSeq, this.sess.localToken, this.sess.rigToken, this.rigName, this.options.userName, IcomPackets_1.AUDIO_SAMPLE_RATE, IcomPackets_1.AUDIO_SAMPLE_RATE, this.civSess.localPort, this.audioSess.localPort, IcomPackets_1.XIEGU_TX_BUFFER_SIZE);
+                this.sess.innerSeq = (this.sess.innerSeq + 1) & 0xffff;
+                this.sess.sendTracked(reply);
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-var-requires
+                    const { hex } = require('../utils/codec');
+                    (0, debug_1.dbg)('CONNINFO -> reply with local civPort=', this.civSess.localPort, 'audioPort=', this.audioSess.localPort);
+                    (0, debug_1.dbgV)('CONNINFO reply hex (first 0x60):', hex(Buffer.from(reply.subarray(0, 0x60))));
+                    (0, debug_1.dbgV)('CONNINFO reply hex (0x60..0x90):', hex(Buffer.from(reply.subarray(0x60, 0x90))));
                 }
+                catch { }
                 break;
             }
             default: {
@@ -711,8 +1077,8 @@ class IcomControl {
             if (type === IcomPackets_1.Cmd.I_AM_READY) {
                 this.civ.sendOpenClose(true);
                 this.civSess.startIdle();
-                (0, debug_1.dbg)('CIV ready - resolving civReady promise');
-                this.resolveCivReady();
+                (0, debug_1.dbg)('CIV ready - emitting internal _civReady event');
+                this.ev.emit('_civReady');
                 return;
             }
         }
@@ -868,8 +1234,8 @@ class IcomControl {
                 // Start continuous audio transmission (like Java's startTxAudio on I_AM_READY)
                 this.audio.start();
                 this.audioSess.startIdle();
-                (0, debug_1.dbg)('Audio ready - started continuous audio stream, resolving audioReady promise');
-                this.resolveAudioReady();
+                (0, debug_1.dbg)('Audio ready - started continuous audio stream, emitting internal _audioReady event');
+                this.ev.emit('_audioReady');
                 return;
             }
         }
@@ -908,5 +1274,223 @@ class IcomControl {
         this.sess.innerSeq = (this.sess.innerSeq + 1) & 0xffff;
         this.sess.sendTracked(pkt);
     }
+    // ============================================================================
+    // Connection Monitoring
+    // ============================================================================
+    /**
+     * Configure unified connection monitoring
+     * @param config - Monitoring configuration options
+     * @example
+     * rig.configureMonitoring({ timeout: 10000, checkInterval: 2000, autoReconnect: true });
+     */
+    configureMonitoring(config) {
+        this.monitorConfig = { ...this.monitorConfig, ...config };
+    }
+    /**
+     * Get current connection state for all sessions
+     * @returns Object with connection state for each session
+     */
+    getConnectionState() {
+        const now = Date.now();
+        const isTimedOut = (sess) => {
+            if (sess['destroyed'])
+                return true;
+            return (now - sess.lastReceivedTime) > this.monitorConfig.timeout;
+        };
+        return {
+            control: isTimedOut(this.sess) ? types_1.ConnectionState.DISCONNECTED : types_1.ConnectionState.CONNECTED,
+            civ: isTimedOut(this.civSess) ? types_1.ConnectionState.DISCONNECTED : types_1.ConnectionState.CONNECTED,
+            audio: isTimedOut(this.audioSess) ? types_1.ConnectionState.DISCONNECTED : types_1.ConnectionState.CONNECTED
+        };
+    }
+    /**
+     * Check if any session has lost connection
+     * @returns true if any session is disconnected
+     */
+    isAnySessionDisconnected() {
+        const state = this.getConnectionState();
+        return state.control === types_1.ConnectionState.DISCONNECTED ||
+            state.civ === types_1.ConnectionState.DISCONNECTED ||
+            state.audio === types_1.ConnectionState.DISCONNECTED;
+    }
+    /**
+     * Handle connection lost event from a session
+     * Simplified strategy: any session loss triggers full reconnect
+     * @private
+     */
+    handleConnectionLost(sessionType, timeSinceLastData) {
+        // Record disconnect time for downtime calculation
+        this.connectionSession.lastDisconnectTime = Date.now();
+        const info = {
+            sessionType,
+            reason: `No data received for ${timeSinceLastData}ms`,
+            timeSinceLastData,
+            timestamp: this.connectionSession.lastDisconnectTime
+        };
+        (0, debug_1.dbg)(`Connection lost: ${sessionType} session (${timeSinceLastData}ms since last data)`);
+        this.ev.emit('connectionLost', info);
+        // Check if auto-reconnect is enabled
+        if (!this.monitorConfig.autoReconnect) {
+            (0, debug_1.dbg)(`Auto-reconnect disabled, not attempting reconnect`);
+            // Transition to IDLE since we won't reconnect
+            this.transitionTo(types_1.ConnectionPhase.IDLE, 'Connection lost, auto-reconnect disabled');
+            return;
+        }
+        // Validate state transition to RECONNECTING
+        if (!this.canTransitionTo(types_1.ConnectionPhase.RECONNECTING)) {
+            (0, debug_1.dbg)(`Cannot transition to RECONNECTING from ${this.connectionSession.phase} - skipping reconnect`);
+            return;
+        }
+        // Simplified strategy: any session loss → full reconnect
+        // This is more reliable than trying to reconnect individual sessions
+        (0, debug_1.dbg)(`${sessionType} session lost - initiating full reconnect`);
+        this.scheduleFullReconnect();
+    }
+    /**
+     * Schedule a full reconnection (all sessions)
+     * Uses simple while loop with exponential backoff
+     * @private
+     */
+    async scheduleFullReconnect() {
+        // Prevent multiple concurrent reconnect attempts
+        if (this.connectionSession.phase === types_1.ConnectionPhase.RECONNECTING) {
+            (0, debug_1.dbg)('Full reconnect already in progress, skipping');
+            return;
+        }
+        // Transition to RECONNECTING state
+        this.transitionTo(types_1.ConnectionPhase.RECONNECTING, 'Starting full reconnect');
+        let attempt = 0;
+        const disconnectTime = this.connectionSession.lastDisconnectTime || Date.now();
+        try {
+            while (true) {
+                attempt++;
+                const delay = this.calculateReconnectDelay(attempt);
+                // Emit reconnect attempting event
+                this.ev.emit('reconnectAttempting', {
+                    sessionType: types_1.SessionType.CONTROL,
+                    attemptNumber: attempt,
+                    delay,
+                    timestamp: Date.now(),
+                    fullReconnect: true
+                });
+                (0, debug_1.dbg)(`Full reconnect attempt #${attempt} (delay: ${delay}ms)`);
+                await this.sleep(delay);
+                try {
+                    // Disconnect all sessions
+                    (0, debug_1.dbg)('Full reconnect: disconnecting all sessions');
+                    await this.disconnect();
+                    // Wait longer before reconnecting to allow rig to fully clean up old connection
+                    // This is critical - rig may report CONNINFO busy=true if we reconnect too quickly
+                    (0, debug_1.dbg)('Full reconnect: waiting 5s for rig to clean up old session...');
+                    await this.sleep(5000);
+                    // Reconnect with timeout (uses new state-machine-based connect())
+                    (0, debug_1.dbg)('Full reconnect: reconnecting');
+                    await this.connectWithTimeout(30000);
+                    // Success! Calculate downtime and emit connectionRestored event
+                    const downtime = Date.now() - disconnectTime;
+                    (0, debug_1.dbg)(`Full reconnect successful! Downtime: ${downtime}ms`);
+                    const finalState = this.getConnectionState();
+                    (0, debug_1.dbg)(`Reconnect complete - All sessions: Control=${finalState.control}, CIV=${finalState.civ}, Audio=${finalState.audio}`);
+                    // Emit connectionRestored event (fixes Problem #5)
+                    this.ev.emit('connectionRestored', {
+                        sessionType: types_1.SessionType.CONTROL,
+                        downtime,
+                        timestamp: Date.now()
+                    });
+                    // State is already CONNECTED from connect() call
+                    return;
+                }
+                catch (err) {
+                    const errorMsg = err instanceof Error ? err.message : String(err);
+                    (0, debug_1.dbg)('Full reconnect failed:', errorMsg);
+                    // Get current connection state for diagnostics
+                    const state = this.getConnectionState();
+                    (0, debug_1.dbg)(`Current state after failed reconnect: Control=${state.control}, CIV=${state.civ}, Audio=${state.audio}`);
+                    // Check if we should retry
+                    const maxAttempts = this.monitorConfig.maxReconnectAttempts;
+                    const willRetry = maxAttempts === undefined || attempt < maxAttempts;
+                    // Emit reconnect failed event
+                    this.ev.emit('reconnectFailed', {
+                        sessionType: types_1.SessionType.CONTROL,
+                        attemptNumber: attempt,
+                        error: errorMsg,
+                        timestamp: Date.now(),
+                        fullReconnect: true,
+                        willRetry,
+                        nextRetryDelay: willRetry ? this.calculateReconnectDelay(attempt + 1) : undefined
+                    });
+                    if (!willRetry) {
+                        (0, debug_1.dbg)(`Max reconnect attempts (${maxAttempts}) reached, giving up`);
+                        (0, debug_1.dbg)(`Final state: Control=${state.control}, CIV=${state.civ}, Audio=${state.audio}`);
+                        // Transition to IDLE since we're giving up
+                        this.transitionTo(types_1.ConnectionPhase.IDLE, 'Max reconnect attempts reached');
+                        return;
+                    }
+                    // Continue loop for retry
+                    (0, debug_1.dbg)(`Will retry in ${this.calculateReconnectDelay(attempt + 1)}ms...`);
+                }
+            }
+        }
+        catch (err) {
+            // Unexpected error in reconnect loop
+            (0, debug_1.dbg)('Unexpected error in scheduleFullReconnect:', err);
+            this.transitionTo(types_1.ConnectionPhase.IDLE, 'Reconnect loop error');
+        }
+    }
+    /**
+     * Connect with timeout (helper for reconnection)
+     * @private
+     */
+    async connectWithTimeout(timeout) {
+        const timeoutPromise = this.sleep(timeout).then(() => {
+            throw new Error(`Connection timeout after ${timeout}ms`);
+        });
+        await Promise.race([
+            this.connect(),
+            timeoutPromise
+        ]);
+    }
+    /**
+     * Sleep helper (returns a Promise)
+     * @private
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Calculate reconnect delay using exponential backoff
+     * @private
+     */
+    calculateReconnectDelay(attemptNumber) {
+        const delay = this.monitorConfig.reconnectBaseDelay * Math.pow(2, attemptNumber - 1);
+        return Math.min(delay, this.monitorConfig.reconnectMaxDelay);
+    }
+    // ============================================================================
+    // Public Observability APIs
+    // ============================================================================
+    /**
+     * Get current connection phase
+     * @returns Current connection phase (IDLE, CONNECTING, CONNECTED, etc.)
+     */
+    getConnectionPhase() {
+        return this.connectionSession.phase;
+    }
+    /**
+     * Get detailed connection metrics for monitoring and diagnostics
+     * @returns Connection metrics including phase, uptime, session states
+     */
+    getConnectionMetrics() {
+        const now = Date.now();
+        return {
+            phase: this.connectionSession.phase,
+            sessionId: this.connectionSession.sessionId,
+            uptime: this.connectionSession.phase === types_1.ConnectionPhase.CONNECTED
+                ? now - this.connectionSession.startTime
+                : 0,
+            sessions: this.getConnectionState(),
+            lastDisconnectTime: this.connectionSession.lastDisconnectTime,
+            isReconnecting: this.connectionSession.phase === types_1.ConnectionPhase.RECONNECTING
+        };
+    }
 }
 exports.IcomControl = IcomControl;