@qodo/sdk 0.1.0

package/dist/api/websocket.js

@@ -0,0 +1,685 @@
+import WebSocket from "ws";
+import { EventEmitter } from "events";
+import { v4 as uuid } from "uuid";
+import { getAuthConfig } from "../auth/index.js";
+import { ServerData } from "../session/index.js";
+import { getCurrentEnvironment } from "../session/index.js";
+// WebSocket-specific configuration
+const WS_CONFIG = {
+    IDLE_TIMEOUT: 600000,
+    HEARTBEAT_INTERVAL: 30000,
+    HEARTBEAT_TIMEOUT: 60000,
+    CONNECTION_TIMEOUT: 15000,
+    INITIAL_RECONNECT_DELAY: 1000,
+    MAX_RECONNECT_DELAY: 30000,
+    RECONNECT_BACKOFF_FACTOR: 1.5,
+    MESSAGE_QUEUE_MAX_SIZE: 1000,
+    READY_TIMEOUT: 300000,
+};
+export var ConnectionState;
+(function (ConnectionState) {
+    ConnectionState["DISCONNECTED"] = "DISCONNECTED";
+    ConnectionState["CONNECTING"] = "CONNECTING";
+    ConnectionState["CONNECTED"] = "CONNECTED";
+    ConnectionState["RECONNECTING"] = "RECONNECTING";
+    ConnectionState["DISCONNECTING"] = "DISCONNECTING";
+    ConnectionState["FAILED"] = "FAILED";
+})(ConnectionState || (ConnectionState = {}));
+export var ReadyState;
+(function (ReadyState) {
+    ReadyState["IDLE"] = "IDLE";
+    ReadyState["WAITING_INITIAL_READY"] = "WAITING_INITIAL_READY";
+    ReadyState["READY"] = "READY";
+    ReadyState["MESSAGE_SENT"] = "MESSAGE_SENT";
+    ReadyState["WAITING_READY"] = "WAITING_READY";
+    ReadyState["CHECKPOINT_RECOVERY"] = "CHECKPOINT_RECOVERY";
+})(ReadyState || (ReadyState = {}));
+export class WebSocketClient extends EventEmitter {
+    ws;
+    shouldDebugLog() {
+        const env = getCurrentEnvironment();
+        // In SDK mode, default is silent unless sdkDebug=true or QODO_DEBUG=true.
+        if (env?.sdkMode) {
+            return !!env.sdkDebug || process.env.QODO_DEBUG === 'true';
+        }
+        return process.env.QODO_DEBUG === 'true';
+    }
+    debug(...args) {
+        if (this.shouldDebugLog()) {
+            // eslint-disable-next-line no-console
+            console.debug(...args);
+        }
+    }
+    state = ConnectionState.DISCONNECTED;
+    sessionId;
+    requestId;
+    connectionId;
+    // Idle management
+    idleTimer;
+    autoDisconnected = false;
+    // Heartbeat management
+    heartbeatInterval;
+    lastPongReceived = Date.now();
+    lastPingSent = 0;
+    // Reconnection management
+    reconnectAttempts = 0;
+    reconnectTimer;
+    isReconnecting = false;
+    // Message queue for handling during disconnection
+    messageQueue = [];
+    isProcessingQueue = false;
+    // Ready protocol state management
+    readyState = ReadyState.IDLE;
+    latestCheckpointId;
+    lastSentMessage;
+    readyTimer;
+    pendingOutbox = [];
+    receivedResponsesSinceMessage = false; // Track if any responses received after sending message
+    hasReceivedResponsesSinceLastMessage() {
+        return this.receivedResponsesSinceMessage;
+    }
+    // Connection-timeout timer (ensure we clear/unref to avoid keeping event loop alive)
+    connectionTimeoutTimer;
+    constructor() {
+        super();
+    }
+    setState(newState) {
+        if (this.state !== newState) {
+            const oldState = this.state;
+            this.state = newState;
+            this.debug(`[WebSocketClient] Connection state transition: ${oldState} → ${newState} | ` +
+                `ReadyState: ${this.readyState} | ` +
+                `Session: ${this.sessionId?.substring(0, 8)}...`);
+            this.emit('stateChanged', newState);
+        }
+    }
+    setReadyState(newState, context) {
+        if (this.readyState !== newState) {
+            const oldState = this.readyState;
+            this.readyState = newState;
+            this.debug(`[WebSocketClient] Ready state transition: ${oldState} → ${newState}` +
+                (context ? ` | Context: ${context}` : '') +
+                ` | Session: ${this.sessionId?.substring(0, 8)}...` +
+                ` | Checkpoint: ${this.latestCheckpointId?.substring(0, 8) || 'none'}`);
+            this.emit('readyStateChanged', { oldState, newState, context });
+        }
+    }
+    async handleReadyMessage(message) {
+        const checkpointId = message.data?.tool_args?.checkpoint_id;
+        const previousCheckpoint = this.latestCheckpointId;
+        const previousReadyState = this.readyState;
+        this.debug(`[WebSocketClient] Ready message received | ` +
+            `State: ${this.readyState} | ` +
+            `Checkpoint: ${checkpointId?.substring(0, 8) || 'none'} | ` +
+            `Previous: ${previousCheckpoint?.substring(0, 8) || 'none'}`);
+        // Update checkpoint if provided and changed
+        if (checkpointId && checkpointId !== previousCheckpoint) {
+            this.latestCheckpointId = checkpointId;
+            this.debug(`[WebSocketClient] Checkpoint ID updated: ${previousCheckpoint?.substring(0, 8) || 'none'} → ` +
+                `${checkpointId.substring(0, 8)}`);
+        }
+        // Handle based on current state
+        switch (this.readyState) {
+            case ReadyState.WAITING_INITIAL_READY:
+                this.clearReadyTimer();
+                this.setReadyState(ReadyState.READY, 'Initial Ready received after connection');
+                await this.processOutbox();
+                break;
+            case ReadyState.WAITING_READY:
+                this.clearReadyTimer();
+                this.setReadyState(ReadyState.READY, 'Ready received after responses completed');
+                await this.processOutbox();
+                break;
+            case ReadyState.MESSAGE_SENT:
+                // Ready in MESSAGE_SENT should only be accepted if responses were received
+                if (!this.receivedResponsesSinceMessage) {
+                    this.debug(`[WebSocketClient] Unexpected Ready without responses | ` +
+                        `Checkpoint: ${checkpointId?.substring(0, 8) || 'none'} | ` +
+                        `This indicates server failed to process the message`);
+                    // Trigger checkpoint recovery - server acknowledged but didn't process
+                    this.clearReadyTimer();
+                    await this.initiateCheckpointRecovery('Ready received without any responses (server processing failure)');
+                    return;
+                }
+                // Normal case: Ready after responses signals server finished processing
+                this.debug('[WebSocketClient] Ready received, responses complete');
+                this.clearReadyTimer();
+                this.setReadyState(ReadyState.READY, 'Ready received, server finished processing');
+                await this.processOutbox();
+                break;
+            case ReadyState.READY:
+                this.debug('[WebSocketClient] Ready received while already in READY state (duplicate)');
+                break;
+            case ReadyState.IDLE:
+                this.debug('[WebSocketClient] Ready received while IDLE - transitioning to READY');
+                this.setReadyState(ReadyState.READY, 'Ready received while idle');
+                break;
+            case ReadyState.CHECKPOINT_RECOVERY:
+                this.debug('[WebSocketClient] Ready received during recovery - resuming normal flow');
+                this.clearReadyTimer();
+                this.setReadyState(ReadyState.READY, 'Recovery completed, Ready received');
+                await this.processOutbox();
+                break;
+        }
+        // Emit event for monitoring.
+        // Include previous ready state so listeners can distinguish initial Ready
+        // from completion Ready after MESSAGE_SENT.
+        this.emit('readyReceived', checkpointId, previousReadyState);
+    }
+    async connect(sessionId, requestId) {
+        // Update session info if provided
+        if (sessionId)
+            this.sessionId = sessionId;
+        if (requestId)
+            this.requestId = requestId;
+        if (this.state === ConnectionState.CONNECTED) {
+            this.resetIdleTimer();
+            return;
+        }
+        // If we auto-disconnected due to idle, reconnect
+        if (this.autoDisconnected || this.state === ConnectionState.DISCONNECTED) {
+            this.autoDisconnected = false;
+            await this.establishConnection();
+        }
+    }
+    async sendMessage(type, data) {
+        // Reset idle timer on any outgoing message
+        this.resetIdleTimer();
+        const messageToSend = { type, data, timestamp: Date.now() };
+        this.debug(`[WebSocketClient] sendMessage called | ` +
+            `Type: ${type} | ` +
+            `ReadyState: ${this.readyState} | ` +
+            `ConnectionState: ${this.state}`);
+        // Save as last sent message for potential recovery
+        this.lastSentMessage = messageToSend;
+        this.debug(`[WebSocketClient] Last sent message cached | ` +
+            `Type: ${type} | ` +
+            `Timestamp: ${messageToSend.timestamp}`);
+        if (this.readyState === ReadyState.READY && this.ws && this.state === ConnectionState.CONNECTED) {
+            // Send immediately
+            this.receivedResponsesSinceMessage = false; // Reset flag when sending new message
+            await this.sendImmediately(messageToSend);
+            this.setReadyState(ReadyState.MESSAGE_SENT, `Sent ${type} message`);
+            this.startReadyTimer(); // Expect Ready after server processes message
+        }
+        else {
+            // Queue until Ready
+            this.pendingOutbox.push(messageToSend);
+            this.debug(`[WebSocketClient] Message queued | ` +
+                `Type: ${type} | ` +
+                `Queue size: ${this.pendingOutbox.length} | ` +
+                `Reason: ReadyState=${this.readyState}, Connected=${this.state === ConnectionState.CONNECTED}`);
+            if (this.state === ConnectionState.DISCONNECTED) {
+                this.debug('[WebSocketClient] Initiating connection due to queued message');
+                await this.connect();
+            }
+        }
+    }
+    async sendImmediately(msg) {
+        const formatted = this.formatMessage(msg.type, msg.data);
+        this.ws.send(formatted);
+        this.debug(`[WebSocketClient] Message sent immediately | ` +
+            `Type: ${msg.type} | ` +
+            `Size: ${formatted.length} bytes`);
+    }
+    async processOutbox() {
+        this.debug(`[WebSocketClient] Processing outbox | ` +
+            `Queue size: ${this.pendingOutbox.length} | ` +
+            `ReadyState: ${this.readyState}`);
+        if (this.pendingOutbox.length > 0 && this.readyState === ReadyState.READY) {
+            const msg = this.pendingOutbox.shift();
+            this.debug(`[WebSocketClient] Sending queued message | ` +
+                `Type: ${msg.type} | ` +
+                `Queued at: ${msg.timestamp} | ` +
+                `Wait time: ${Date.now() - msg.timestamp}ms | ` +
+                `Remaining in queue: ${this.pendingOutbox.length}`);
+            this.receivedResponsesSinceMessage = false; // Reset flag when sending queued message
+            await this.sendImmediately(msg);
+            this.setReadyState(ReadyState.MESSAGE_SENT, `Sent queued ${msg.type} message`);
+            this.startReadyTimer(); // Expect Ready after server processes message
+        }
+        else if (this.pendingOutbox.length === 0) {
+            this.debug('[WebSocketClient] Outbox is empty, no messages to process');
+        }
+        else {
+            this.debug(`[WebSocketClient] Cannot process outbox | ` +
+                `ReadyState: ${this.readyState} (expected READY)`);
+        }
+    }
+    startReadyTimer() {
+        this.clearReadyTimer();
+        this.readyTimer = setTimeout(async () => {
+            this.debug(`[WebSocketClient] Ready timeout expired | ` +
+                `State: ${this.readyState} | ` +
+                `Last message: ${this.lastSentMessage?.type} | ` +
+                `Checkpoint: ${this.latestCheckpointId?.substring(0, 8) || 'none'}`);
+            await this.initiateCheckpointRecovery('Ready timeout');
+        }, WS_CONFIG.READY_TIMEOUT);
+        // Do not keep the event loop alive solely because of this timer
+        this.readyTimer.unref?.();
+    }
+    clearReadyTimer() {
+        if (this.readyTimer) {
+            clearTimeout(this.readyTimer);
+            this.readyTimer = undefined;
+        }
+    }
+    async initiateCheckpointRecovery(reason) {
+        this.debug(`[WebSocketClient] ===== CHECKPOINT RECOVERY INITIATED ===== | ` +
+            `Reason: ${reason} | ` +
+            `Checkpoint: ${this.latestCheckpointId?.substring(0, 8) || 'none'} | ` +
+            `Last message type: ${this.lastSentMessage?.type} | ` +
+            `Current state: ${this.readyState}`);
+        this.setReadyState(ReadyState.CHECKPOINT_RECOVERY, reason);
+        // Disconnect current connection
+        this.debug('[WebSocketClient] Disconnecting for checkpoint recovery');
+        this.disconnect();
+        // Reconnect with checkpoint (URL will include checkpoint_id)
+        this.debug(`[WebSocketClient] Reconnecting with checkpoint | ` +
+            `Checkpoint ID: ${this.latestCheckpointId?.substring(0, 8) || 'none'} | ` +
+            `Session ID: ${this.sessionId?.substring(0, 8)}...`);
+        try {
+            await this.establishConnection();
+            this.debug('[WebSocketClient] Reconnection successful during recovery');
+            // Wait for Ready state is set in handleReadyMessage when initial Ready is received
+            // Resend last message once Ready received
+            if (this.lastSentMessage) {
+                this.pendingOutbox.unshift(this.lastSentMessage);
+                this.debug(`[WebSocketClient] Last message re-queued for recovery | ` +
+                    `Type: ${this.lastSentMessage.type} | ` +
+                    `Original timestamp: ${this.lastSentMessage.timestamp}`);
+            }
+            else {
+                this.debug('[WebSocketClient] No last message to resend during recovery');
+            }
+            // Emit event for monitoring
+            this.emit('checkpointRecovery', { reason, checkpoint: this.latestCheckpointId });
+        }
+        catch (error) {
+            this.debug(`[WebSocketClient] Checkpoint recovery failed | ` +
+                `Error: ${error instanceof Error ? error.message : error}`);
+            this.setReadyState(ReadyState.IDLE, 'Recovery failed');
+            throw error;
+        }
+        this.debug('[WebSocketClient] ===== CHECKPOINT RECOVERY COMPLETED =====');
+    }
+    disconnect() {
+        // Hold a reference to the current socket to close it safely
+        const wsRef = this.ws;
+        // Stop all timers and reconnection attempts
+        this.clearTimers();
+        this.autoDisconnected = false;
+        this.isReconnecting = false;
+        // Invalidate the current connection so any late events from wsRef are ignored
+        // Event handlers compare this.connectionId to their captured id
+        this.connectionId = uuid();
+        if (wsRef) {
+            try {
+                // Attempt a graceful close when open; otherwise force terminate to avoid races
+                if (wsRef.readyState === WebSocket.OPEN) {
+                    this.setState(ConnectionState.DISCONNECTING);
+                    wsRef.close(1000, 'Normal closure');
+                }
+                else if (wsRef.readyState === WebSocket.CONNECTING || wsRef.readyState === WebSocket.CLOSING) {
+                    // Avoid an "open" event racing in after manual disconnect
+                    try {
+                        wsRef.terminate?.();
+                    }
+                    catch { }
+                }
+            }
+            catch { }
+        }
+        // Explicitly mark as disconnected and reset internal refs
+        this.setState(ConnectionState.DISCONNECTED);
+        this.ws = undefined;
+        this.setReadyState(ReadyState.IDLE, 'Manual disconnect');
+        this.lastPingSent = 0;
+    }
+    getState() {
+        return this.state;
+    }
+    keepAlive() {
+        if (this.state === ConnectionState.CONNECTED) {
+            this.resetIdleTimer();
+        }
+    }
+    // === Private Methods ===
+    async establishConnection() {
+        if (this.state === ConnectionState.CONNECTING) {
+            await this.waitForConnection();
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            try {
+                this.setState(ConnectionState.CONNECTING);
+                this.connectionId = uuid();
+                const currentConnectionId = this.connectionId;
+                const wsUrl = this.buildWebSocketUrl();
+                const { token } = getAuthConfig();
+                this.debug(`Connecting to WebSocket: ${wsUrl}`);
+                const ws = new WebSocket(wsUrl, {
+                    headers: {
+                        'Authorization': `Bearer ${token}`,
+                    },
+                    handshakeTimeout: WS_CONFIG.CONNECTION_TIMEOUT,
+                });
+                this.ws = ws;
+                // Set up event handlers
+                ws.on('open', () => {
+                    if (this.connectionId !== currentConnectionId) {
+                        ws.close();
+                        return;
+                    }
+                    // Clear pending connection timeout timer if any
+                    if (this.connectionTimeoutTimer) {
+                        clearTimeout(this.connectionTimeoutTimer);
+                        this.connectionTimeoutTimer = undefined;
+                    }
+                    this.setState(ConnectionState.CONNECTED);
+                    this.reconnectAttempts = 0;
+                    this.emit('connected');
+                    this.debug(`[WebSocketClient] WebSocket connected | ` +
+                        `Session: ${this.sessionId?.substring(0, 8)}... | ` +
+                        `Checkpoint: ${this.latestCheckpointId?.substring(0, 8) || 'none'}`);
+                    // Transition to waiting for initial Ready
+                    this.setReadyState(ReadyState.WAITING_INITIAL_READY, 'Connection opened, awaiting initial Ready');
+                    this.startReadyTimer(); // Wait for initial Ready
+                    // Start idle timer immediately upon connection
+                    this.startIdleTimer();
+                    // Start heartbeat
+                    this.startHeartbeat();
+                    // Process any queued messages (old mechanism, will be replaced by pendingOutbox)
+                    this.processQueuedMessages();
+                    this.debug('[WebSocketClient] Connection established, waiting for initial Ready signal');
+                    resolve();
+                });
+                ws.on('message', (data) => {
+                    if (this.connectionId !== currentConnectionId)
+                        return;
+                    this.resetIdleTimer();
+                    this.lastPongReceived = Date.now(); // any message is also a ping
+                    const message = data.toString();
+                    // Try to detect Ready messages
+                    try {
+                        const parsed = JSON.parse(message);
+                        if (parsed && parsed.data && parsed.data.tool === 'Ready') {
+                            // Handle Ready message separately
+                            this.handleReadyMessage(parsed);
+                            return;
+                        }
+                    }
+                    catch (e) {
+                        // Not JSON or not a Ready message, continue with normal flow
+                    }
+                    // Track that we received a non-Ready message (response)
+                    if (this.readyState === ReadyState.MESSAGE_SENT) {
+                        this.receivedResponsesSinceMessage = true;
+                    }
+                    // Emit non-Ready messages to AgentAPI
+                    this.emit('message', message);
+                });
+                ws.on('close', (code, reason) => {
+                    if (this.connectionId !== currentConnectionId)
+                        return;
+                    // Clear pending connection-timeout timer
+                    if (this.connectionTimeoutTimer) {
+                        clearTimeout(this.connectionTimeoutTimer);
+                        this.connectionTimeoutTimer = undefined;
+                    }
+                    this.handleClose(code, reason.toString());
+                    if (this.state === ConnectionState.CONNECTING) {
+                        reject(new Error(`Connection closed during setup: ${code} ${reason}`));
+                    }
+                });
+                ws.on('error', (error) => {
+                    if (this.connectionId !== currentConnectionId)
+                        return;
+                    // Clear pending connection-timeout timer
+                    if (this.connectionTimeoutTimer) {
+                        clearTimeout(this.connectionTimeoutTimer);
+                        this.connectionTimeoutTimer = undefined;
+                    }
+                    this.debug('WebSocket error:', error);
+                    this.emit('error', error);
+                    if (this.state === ConnectionState.CONNECTING) {
+                        reject(error);
+                    }
+                });
+                ws.on('pong', () => {
+                    if (this.connectionId === currentConnectionId) {
+                        this.lastPongReceived = Date.now();
+                        this.debug('Pong received, heartbeat OK');
+                    }
+                });
+                // Connection timeout
+                this.connectionTimeoutTimer = setTimeout(() => {
+                    if (this.connectionId === currentConnectionId && this.state === ConnectionState.CONNECTING) {
+                        ws.close();
+                        reject(new Error('Connection timeout'));
+                    }
+                }, WS_CONFIG.CONNECTION_TIMEOUT);
+                this.connectionTimeoutTimer.unref?.();
+            }
+            catch (error) {
+                this.setState(ConnectionState.FAILED);
+                reject(error);
+            }
+        });
+    }
+    async waitForConnection(timeout = WS_CONFIG.CONNECTION_TIMEOUT) {
+        const startTime = Date.now();
+        while (this.state === ConnectionState.CONNECTING || this.state === ConnectionState.RECONNECTING) {
+            if (Date.now() - startTime > timeout) {
+                throw new Error('Connection timeout while waiting');
+            }
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        if (this.state !== ConnectionState.CONNECTED) {
+            throw new Error('Failed to establish connection');
+        }
+    }
+    buildWebSocketUrl() {
+        const baseUrl = ServerData.getInstance().getBaseUrl();
+        const wsUrl = baseUrl.replace(/^http/, 'ws');
+        const trimmedBase = wsUrl.replace(/\/+$/, '');
+        const url = new URL(`${trimmedBase}/v2/agentic/ws/connect`);
+        // Use current session ID, or generate one if not set
+        const currentSessionId = this.sessionId || uuid();
+        url.searchParams.set('session_id', currentSessionId);
+        if (this.requestId) {
+            url.searchParams.set('request_id', this.requestId);
+        }
+        // Include checkpoint_id if available for recovery
+        if (this.latestCheckpointId && this.readyState === ReadyState.CHECKPOINT_RECOVERY) {
+            url.searchParams.set('checkpoint_id', this.latestCheckpointId);
+            this.debug(`[WebSocketClient] Building URL with checkpoint | ` +
+                `Checkpoint: ${this.latestCheckpointId.substring(0, 8)}...`);
+        }
+        else {
+            this.debug('[WebSocketClient] Building URL without checkpoint (fresh connection)');
+        }
+        return url.toString();
+    }
+    formatMessage(type, data) {
+        return `${type} ${JSON.stringify(data)}\n`;
+    }
+    handleClose(code, reason) {
+        this.clearTimers();
+        if (this.autoDisconnected) {
+            this.debug('WebSocket closed due to idle timeout');
+            this.setState(ConnectionState.DISCONNECTED);
+            this.emit('disconnected', { reason: 'idle', code });
+            return;
+        }
+        this.debug(`WebSocket closed: ${code} ${reason}`);
+        // Determine if we should reconnect
+        if (code === 1000 || code === 1001) {
+            // Normal closure
+            this.setState(ConnectionState.DISCONNECTED);
+            this.emit('disconnected', { reason: 'normal', code });
+        }
+        else if (code === 1008) {
+            // Authentication failure - don't reconnect
+            this.setState(ConnectionState.FAILED);
+            this.emit('error', new Error('Authentication failed'));
+        }
+        else {
+            // Unexpected closure - attempt reconnect
+            this.setState(ConnectionState.FAILED);
+            this.attemptReconnection().catch((error) => {
+                this.debug('Reconnection attempt failed:', error instanceof Error ? error.message : error);
+            });
+        }
+    }
+    async attemptReconnection() {
+        if (this.isReconnecting)
+            return;
+        this.isReconnecting = true;
+        this.setState(ConnectionState.RECONNECTING);
+        this.reconnectAttempts++;
+        const delay = this.calculateBackoffDelay(this.reconnectAttempts);
+        this.debug(`Attempting reconnection ${this.reconnectAttempts} in ${delay}ms`);
+        this.reconnectTimer = setTimeout(async () => {
+            try {
+                await this.establishConnection();
+                this.isReconnecting = false;
+                this.emit('reconnected');
+            }
+            catch (error) {
+                this.debug('Reconnection failed:', error instanceof Error ? error.message : error);
+                this.isReconnecting = false;
+                // Infinite retry - always attempt again
+                setTimeout(() => this.attemptReconnection(), 1000);
+            }
+        }, delay);
+        this.reconnectTimer.unref?.();
+    }
+    calculateBackoffDelay(attempt) {
+        const delay = WS_CONFIG.INITIAL_RECONNECT_DELAY *
+            Math.pow(WS_CONFIG.RECONNECT_BACKOFF_FACTOR, attempt - 1);
+        const jitter = delay * 0.25 * (Math.random() - 0.5);
+        return Math.min(delay + jitter, WS_CONFIG.MAX_RECONNECT_DELAY);
+    }
+    // === Idle Timer Management ===
+    startIdleTimer() {
+        this.clearIdleTimer();
+        this.idleTimer = setTimeout(() => {
+            this.debug('Connection idle for 10 minutes, disconnecting...');
+            this.autoDisconnected = true;
+            // Clean disconnect - ready for next request
+            if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                this.ws.close(1000, 'Idle timeout');
+            }
+            this.setState(ConnectionState.DISCONNECTED);
+            this.emit('disconnected', { reason: 'idle' });
+        }, WS_CONFIG.IDLE_TIMEOUT);
+        // Let process exit if this is the only pending timer
+        this.idleTimer.unref?.();
+    }
+    clearIdleTimer() {
+        if (this.idleTimer) {
+            clearTimeout(this.idleTimer);
+            this.idleTimer = undefined;
+        }
+    }
+    resetIdleTimer() {
+        this.startIdleTimer();
+    }
+    // === Heartbeat Management ===
+    startHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+        }
+        this.heartbeatInterval = setInterval(() => {
+            if (this.state === ConnectionState.CONNECTED && this.ws) {
+                const now = Date.now();
+                const timeSinceLastPong = now - this.lastPongReceived;
+                // If we haven't sent a ping recently, or if it's time to send another one
+                if (this.lastPingSent === 0 || (now - this.lastPingSent) >= WS_CONFIG.HEARTBEAT_INTERVAL) {
+                    try {
+                        this.ws.ping();
+                        this.lastPingSent = now;
+                        this.debug('Ping sent, waiting for pong...');
+                    }
+                    catch (error) {
+                        this.debug('Error sending ping:', error);
+                    }
+                }
+                // If we sent a ping and enough time has passed without a pong, timeout
+                else if (this.lastPingSent > 0 && timeSinceLastPong > WS_CONFIG.HEARTBEAT_TIMEOUT) {
+                    this.debug('Heartbeat timeout, closing connection');
+                    this.ws.close();
+                    return;
+                }
+            }
+        }, WS_CONFIG.HEARTBEAT_INTERVAL);
+        // Allow process to exit if heartbeat is the last thing running
+        this.heartbeatInterval.unref?.();
+    }
+    stopHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = undefined;
+        }
+    }
+    async processQueuedMessages() {
+        if (this.isProcessingQueue || this.messageQueue.length === 0)
+            return;
+        this.isProcessingQueue = true;
+        this.debug(`Processing ${this.messageQueue.length} queued messages`);
+        try {
+            while (this.messageQueue.length > 0 && this.state === ConnectionState.CONNECTED) {
+                const queuedMessage = this.messageQueue.shift();
+                try {
+                    const message = this.formatMessage(queuedMessage.type, queuedMessage.data);
+                    this.ws.send(message);
+                    this.debug(`Sent queued ${queuedMessage.type} message`);
+                }
+                catch (error) {
+                    console.error('Error processing queued message:', error);
+                    if (queuedMessage.retryCount < 3) {
+                        queuedMessage.retryCount++;
+                        this.messageQueue.unshift(queuedMessage);
+                        break;
+                    }
+                }
+            }
+        }
+        finally {
+            this.isProcessingQueue = false;
+        }
+    }
+    // === Cleanup ===
+    clearTimers() {
+        this.clearIdleTimer();
+        this.stopHeartbeat();
+        this.clearReadyTimer();
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+        if (this.connectionTimeoutTimer) {
+            clearTimeout(this.connectionTimeoutTimer);
+            this.connectionTimeoutTimer = undefined;
+        }
+    }
+    cleanup() {
+        this.debug(`[WebSocketClient] Cleanup called | ` +
+            `State: ${this.state} | ` +
+            `ReadyState: ${this.readyState} | ` +
+            `Queued messages: ${this.messageQueue.length} | ` +
+            `Pending outbox: ${this.pendingOutbox.length}`);
+        this.clearTimers();
+        this.disconnect();
+        this.messageQueue = [];
+        this.pendingOutbox = [];
+        this.isReconnecting = false;
+        this.latestCheckpointId = undefined;
+        this.lastSentMessage = undefined;
+        this.setReadyState(ReadyState.IDLE, 'Cleanup performed');
+        this.removeAllListeners();
+        this.debug('[WebSocketClient] Cleanup completed');
+    }
+}
+//# sourceMappingURL=websocket.js.map