minercon 3.0.0

package/out/rconConnectionManager.js

@@ -0,0 +1,238 @@
+"use strict";
+// src/rconConnectionManager.ts
+//
+// Owns the RCON connection lifecycle: the live `RconController` (recreated on
+// each reconnect attempt), connection/reconnection status, and the
+// exponential-backoff retry loop. Pulled out of RconTerminal as part of the
+// mega-module split — see lineEditor.ts / displaySuggestion.ts for the sibling
+// extractions and their rationale.
+//
+// `RconSession` keeps `detectAndInitialize`/`initializeCommands` (they're
+// about the autocomplete command-tree and `pluginMode`, a different concern
+// that happens to run at similar times) but reads connection status and reaches
+// the live controller through this class, and is notified via `onReconnected`
+// when it should reload the command tree.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RconConnectionManager = void 0;
+const rconClient_1 = require("./rconClient");
+const logger_1 = require("./logger");
+const ansi = __importStar(require("./ansi"));
+const defaultControllerFactory = (host, port, password, logger) => new rconClient_1.RconController(host, port, password, logger);
+// Auto-reconnect timing. After a dropped connection we wait a short grace
+// period, then retry with exponential backoff (doubling each attempt) capped
+// at the max delay.
+const CONNECTION_LOST_GRACE_MS = 1000;
+const INITIAL_RECONNECT_DELAY_MS = 2000;
+const MAX_RECONNECT_DELAY_MS = 32000;
+const MAX_RECONNECT_ATTEMPTS = 5;
+class RconConnectionManager {
+    serverHost;
+    serverPort;
+    password;
+    logger;
+    host;
+    controllerFactory;
+    _controller;
+    // Intent-level connection state: whether the session currently considers
+    // itself connected, driven by the lifecycle transitions here (initial
+    // connect, `disconnect`, `reportConnectionLost`, successful reconnect). This
+    // is what the UI/prompt reads, and is deliberately distinct from the live
+    // socket truth in `RconController.isConnected()` — the two can briefly differ
+    // mid-reconnect (e.g. this is `false` while a new socket is being dialed).
+    _isConnected = true;
+    _isReconnecting = false;
+    reconnectAttempts = 0;
+    reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
+    reconnectTimeout = null;
+    constructor(serverHost, serverPort, password, logger, controller, host, controllerFactory = defaultControllerFactory) {
+        this.serverHost = serverHost;
+        this.serverPort = serverPort;
+        this.password = password;
+        this.logger = logger;
+        this.host = host;
+        this.controllerFactory = controllerFactory;
+        this._controller = controller;
+        this.wireCloseHandler(this._controller);
+    }
+    get controller() {
+        return this._controller;
+    }
+    get isConnected() {
+        return this._isConnected;
+    }
+    get isReconnecting() {
+        return this._isReconnecting;
+    }
+    /**
+     * Subscribes to unexpected-close notifications from the given controller.
+     * The handler fires when the socket drops without being triggered by an
+     * in-flight command — i.e. a silent socket timeout or server-side close.
+     * The guard conditions prevent double-triggering when the close is the
+     * result of a deliberate disconnect() or an in-progress reconnect attempt.
+     */
+    wireCloseHandler(controller) {
+        controller.setUnexpectedCloseHandler(() => {
+            if (this._isConnected && !this._isReconnecting) {
+                this.host.write(ansi.yellow('⚠  Connection lost. Auto-reconnecting...') + '\r\n');
+                this.reportConnectionLost();
+            }
+        });
+    }
+    /** Resets the reconnect-attempt counter, backoff delay, and any pending reconnect timer back to their initial state. */
+    resetReconnectState() {
+        this.reconnectAttempts = 0;
+        this.reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+    }
+    /**
+     * Records that an in-flight command discovered the connection is gone, and
+     * schedules an auto-reconnect attempt shortly after. The "Connection
+     * lost..." message itself stays with the caller (`executeCommand` accounts
+     * for it in its output-line bookkeeping).
+     */
+    reportConnectionLost() {
+        this._isConnected = false;
+        this.resetReconnectState();
+        this.reconnectTimeout = setTimeout(() => {
+            this.reconnectTimeout = null;
+            this.attemptReconnect();
+        }, CONNECTION_LOST_GRACE_MS);
+    }
+    disconnect() {
+        // No key-chord echo here: this runs for the typed /disconnect built-in.
+        // Ctrl+D echoes its own ^D in RconSession.handleCtrlD before closing.
+        this.host.write('Disconnecting...\r\n');
+        // Clear any pending reconnect
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+        try {
+            this._controller.disconnect();
+        }
+        catch (err) {
+            this.logger.error(`Error during disconnect: ${err}`);
+        }
+        this._isConnected = false;
+        this._isReconnecting = false;
+        this.host.write('Connection closed. Type ' + ansi.yellow('.reconnect') + ' to reconnect.\r\n\r\n');
+        this.host.showPrompt();
+    }
+    async manualReconnect() {
+        if (this._isReconnecting) {
+            this.host.write(ansi.yellow('Already reconnecting...') + '\r\n\r\n');
+            this.host.showPrompt();
+            return;
+        }
+        this.resetReconnectState();
+        await this.attemptReconnect();
+    }
+    async attemptReconnect() {
+        if (this._isReconnecting) {
+            return;
+        }
+        if (this._isConnected) {
+            this.host.write(ansi.green('Already connected.') + '\r\n\r\n');
+            this.host.showPrompt();
+            return;
+        }
+        this._isReconnecting = true;
+        this.reconnectAttempts++;
+        const attemptText = this.reconnectAttempts > 1 ? ` (attempt ${this.reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})` : '';
+        this.host.write(ansi.yellow('Reconnecting to ' + this.serverHost + ':' + this.serverPort + attemptText + '...') + '\r\n');
+        try {
+            // Disconnect existing controller
+            try {
+                await this._controller.disconnect();
+            }
+            catch (err) {
+                // Ignore disconnect errors during reconnect
+            }
+            // Create new controller
+            this._controller = this.controllerFactory(this.serverHost, this.serverPort, this.password, this.logger);
+            this.wireCloseHandler(this._controller);
+            await this._controller.connect();
+            this._isConnected = true;
+            this._isReconnecting = false;
+            this.resetReconnectState();
+            this.host.write(ansi.boldGreen('✓ Reconnected successfully!') + '\r\n\r\n');
+            // Reload commands after reconnection
+            this.host.onReconnected();
+        }
+        catch (err) {
+            this._isReconnecting = false;
+            if (this.reconnectAttempts < MAX_RECONNECT_ATTEMPTS) {
+                this.host.write(ansi.red('✗ Connection failed: ' + (0, logger_1.errorMessage)(err)) + '\r\n');
+                this.host.write(ansi.yellow('Retrying in ' + (this.reconnectDelay / 1000) + ' seconds...') + '\r\n');
+                // Clear any existing timeout
+                if (this.reconnectTimeout) {
+                    clearTimeout(this.reconnectTimeout);
+                }
+                this.reconnectTimeout = setTimeout(() => {
+                    this.reconnectTimeout = null;
+                    this.attemptReconnect();
+                }, this.reconnectDelay);
+                // Exponential backoff with max delay
+                this.reconnectDelay = Math.min(this.reconnectDelay * 2, MAX_RECONNECT_DELAY_MS);
+            }
+            else {
+                // Max attempts reached
+                this.host.write(ansi.boldRed('✗ Reconnection failed after ' + MAX_RECONNECT_ATTEMPTS + ' attempts.') + '\r\n');
+                this.host.write('Type ' + ansi.yellow('.reconnect') + ' to try again.\r\n\r\n');
+                this.resetReconnectState();
+                this.host.showPrompt();
+            }
+        }
+    }
+    /** Tears down any pending reconnect timer and disconnects the controller — used by `RconSession.close()`. */
+    dispose() {
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+        try {
+            this._controller.disconnect();
+        }
+        catch (err) {
+            this.logger.error(`Error during close: ${err}`);
+        }
+    }
+}
+exports.RconConnectionManager = RconConnectionManager;
+//# sourceMappingURL=rconConnectionManager.js.map

package/out/rconProtocol.js

@@ -0,0 +1,421 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RconProtocol = void 0;
+// src/rconProtocol.ts
+const net = __importStar(require("net"));
+const events_1 = require("events");
+// RCON packet type tags. The wire protocol reuses the value 2 for two
+// different things depending on direction (SERVERDATA_EXECCOMMAND when we send,
+// SERVERDATA_AUTH_RESPONSE when the server replies), so they live in separate
+// enums: nothing in this file ever compares an outgoing tag to an incoming one,
+// which keeps that shared value from being mistaken for a single meaning.
+var OutgoingType;
+(function (OutgoingType) {
+    OutgoingType[OutgoingType["AUTH"] = 3] = "AUTH";
+    OutgoingType[OutgoingType["COMMAND"] = 2] = "COMMAND";
+})(OutgoingType || (OutgoingType = {}));
+var IncomingType;
+(function (IncomingType) {
+    IncomingType[IncomingType["RESPONSE"] = 0] = "RESPONSE";
+    IncomingType[IncomingType["AUTH_RESPONSE"] = 2] = "AUTH_RESPONSE";
+})(IncomingType || (IncomingType = {}));
+class RconProtocol extends events_1.EventEmitter {
+    socket = null;
+    host;
+    port;
+    password;
+    logger;
+    createSocket;
+    authenticated = false;
+    requestId = 0;
+    responseBuffer = Buffer.alloc(0);
+    // For tracking requests and responses
+    pendingRequests = new Map();
+    // Configuration
+    RESPONSE_TIMEOUT = 10000; // 10 seconds for command responses
+    AUTH_TIMEOUT = 5000; // 5 seconds for the login handshake
+    constructor(host, port, password, logger, 
+    // Defaults to a real socket; tests substitute a `SocketLike` fake here
+    // (record/replay harness — see src/test/rconProtocol.test.ts) so the
+    // wire protocol can be exercised without a live server.
+    createSocket = () => new net.Socket()) {
+        super();
+        this.host = host;
+        this.port = port;
+        this.password = password;
+        this.logger = logger;
+        this.createSocket = createSocket;
+    }
+    /**
+     * Connect to the RCON server
+     */
+    async connect() {
+        return new Promise((resolve, reject) => {
+            this.socket = this.createSocket();
+            // Enable TCP keepalive to prevent idle connection drops
+            // This sends periodic probes to keep the connection alive through NAT/firewalls
+            this.socket.setKeepAlive(true, 60000); // Send keepalive probes every 60 seconds
+            // Don't set a socket timeout - let the connection stay open indefinitely
+            // The keepalive will handle detecting dead connections
+            // Handle connection
+            this.socket.once('connect', async () => {
+                this.logger.info(`Connected to ${this.host}:${this.port}`);
+                try {
+                    await this.authenticate();
+                    resolve();
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+            // Handle data
+            this.socket.on('data', (data) => {
+                this.handleData(data);
+            });
+            // Handle errors
+            this.socket.on('error', (error) => {
+                this.logger.error(`Socket error: ${error.message}`);
+                this.emit('error', error);
+                reject(error);
+            });
+            // Handle timeout (shouldn't happen now that we removed setTimeout)
+            this.socket.on('timeout', () => {
+                this.logger.warn('Socket timeout — calling disconnect()');
+                const error = new Error('Connection timeout');
+                this.emit('error', error);
+                this.disconnect();
+            });
+            // Handle close
+            this.socket.on('close', () => {
+                const pending = [...this.pendingRequests.values()]
+                    .map(r => r.kind === 'command' ? r.command : r.kind)
+                    .join(', ');
+                this.logger.info(`Connection closed (pending: ${pending || 'none'})`);
+                this.authenticated = false;
+                this.emit('close');
+                for (const request of this.pendingRequests.values()) {
+                    if (request.kind !== 'fence') {
+                        clearTimeout(request.timeout);
+                    }
+                    // Deliver any accumulated fragments if the server closed mid-response
+                    // (e.g. the final fragment was exactly one full packet and we were
+                    // still waiting for more).
+                    if (request.kind === 'command' && request.fragments.length > 0) {
+                        request.resolve(request.fragments.join(''));
+                    }
+                    else {
+                        request.reject(new Error('Connection closed'));
+                    }
+                }
+                this.pendingRequests.clear();
+            });
+            // Connect
+            this.socket.connect(this.port, this.host);
+        });
+    }
+    /**
+     * Authenticate with the RCON server
+     */
+    async authenticate() {
+        if (!this.socket) {
+            throw new Error('Not connected');
+        }
+        return new Promise((resolve, reject) => {
+            const authId = this.getNextRequestId();
+            // Set up auth response handler
+            const authTimeout = setTimeout(() => {
+                this.pendingRequests.delete(authId);
+                reject(new Error('Authentication timeout'));
+            }, this.AUTH_TIMEOUT);
+            this.pendingRequests.set(authId, {
+                kind: 'auth',
+                resolve: () => {
+                    clearTimeout(authTimeout);
+                    this.authenticated = true;
+                    this.logger.info('Authentication successful');
+                    resolve();
+                },
+                reject: (error) => {
+                    clearTimeout(authTimeout);
+                    reject(error);
+                },
+                timeout: authTimeout
+            });
+            // Send auth packet
+            const packet = this.createPacket(authId, OutgoingType.AUTH, this.password);
+            if (this.socket) {
+                this.socket.write(packet);
+            }
+        });
+    }
+    /**
+     * Send a command to the server
+     */
+    async send(command) {
+        if (!this.socket || !this.authenticated) {
+            throw new Error('Not connected or authenticated');
+        }
+        // Use the double-packet technique for detecting end of fragmented
+        // responses: send the real command, then — once the first response
+        // fragment arrives — send an empty "fence" command. RCON processes
+        // commands in order, so when the fence response arrives all real
+        // fragments have already been received. Sending the fence only after
+        // the first fragment (via sendFence below) ensures the server has
+        // started replying before it sees the fence, which prevents servers
+        // from treating two back-to-back packets with no intervening response
+        // as a protocol error and closing the connection.
+        return new Promise((resolve, reject) => {
+            const requestId = this.getNextRequestId();
+            const dummyId = this.getNextRequestId();
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(requestId);
+                this.pendingRequests.delete(dummyId);
+                reject(new Error(`Command timeout: ${command}`));
+            }, this.RESPONSE_TIMEOUT);
+            this.pendingRequests.set(requestId, {
+                kind: 'command',
+                command: command,
+                resolve: (response) => {
+                    clearTimeout(timeout);
+                    this.pendingRequests.delete(requestId);
+                    this.pendingRequests.delete(dummyId);
+                    resolve(response);
+                },
+                reject: (error) => {
+                    clearTimeout(timeout);
+                    this.pendingRequests.delete(requestId);
+                    this.pendingRequests.delete(dummyId);
+                    reject(error);
+                },
+                timeout: timeout,
+                fragments: [],
+                // Sent on the first response fragment — ensures the fence arrives in
+                // its own TCP read() on the server, not batched with the command packet.
+                // RconClient.run() closes the connection if read() returns more bytes
+                // than the first packet's length field, so back-to-back writes that
+                // arrive in one read() cause an immediate disconnect.
+                sendFence: () => {
+                    if (this.socket) {
+                        const dummyPacket = this.createPacket(dummyId, OutgoingType.COMMAND, '');
+                        this.socket.write(dummyPacket);
+                    }
+                },
+            });
+            this.pendingRequests.set(dummyId, {
+                kind: 'fence',
+                resolve: () => {
+                    const mainRequest = this.pendingRequests.get(requestId);
+                    if (mainRequest && mainRequest.kind === 'command') {
+                        mainRequest.resolve(mainRequest.fragments.join(''));
+                    }
+                },
+                reject: () => { },
+            });
+            const commandPacket = this.createPacket(requestId, OutgoingType.COMMAND, command);
+            if (this.socket) {
+                this.socket.write(commandPacket);
+            }
+        });
+    }
+    /**
+     * Handle incoming data from the socket
+     */
+    handleData(data) {
+        // Append to buffer
+        this.responseBuffer = Buffer.concat([this.responseBuffer, data]);
+        // Process complete packets
+        while (this.responseBuffer.length >= 4) {
+            // Read packet size (first 4 bytes, little-endian)
+            const size = this.responseBuffer.readInt32LE(0);
+            // Check if we have the complete packet
+            if (this.responseBuffer.length < size + 4) {
+                // Wait for more data
+                break;
+            }
+            // Extract the packet
+            const packetBuffer = this.responseBuffer.subarray(0, size + 4);
+            this.responseBuffer = this.responseBuffer.subarray(size + 4);
+            // Parse the packet
+            try {
+                const packet = this.parsePacket(packetBuffer);
+                this.handlePacket(packet);
+            }
+            catch (error) {
+                this.logger.error(`Error parsing packet: ${error}`);
+            }
+        }
+    }
+    /** The single in-flight auth request, if any, with the id it's keyed under. */
+    findAuthRequest() {
+        for (const [id, request] of this.pendingRequests) {
+            if (request.kind === 'auth') {
+                return { id, request };
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Handle a parsed packet
+     */
+    handlePacket(packet) {
+        // Failed auth: the server replies with id -1 rather than echoing the id we
+        // sent, so we can't look it up — find the pending auth request directly.
+        if (packet.id === -1) {
+            const auth = this.findAuthRequest();
+            if (auth) {
+                this.pendingRequests.delete(auth.id);
+                auth.request.reject(new Error('Authentication failed'));
+            }
+            return;
+        }
+        const request = this.pendingRequests.get(packet.id);
+        if (!request) {
+            // Some servers don't echo our auth id on the AUTH_RESPONSE packet — if an
+            // auth handshake is in flight, this unmatched response is it.
+            if (packet.type === IncomingType.AUTH_RESPONSE) {
+                const auth = this.findAuthRequest();
+                if (auth) {
+                    this.pendingRequests.delete(auth.id);
+                    auth.request.resolve();
+                    return;
+                }
+            }
+            this.logger.warn(`Received packet with unknown request ID: ${packet.id}`);
+            return;
+        }
+        switch (request.kind) {
+            case 'auth':
+                // Auth gets two packets: an empty RESPONSE_VALUE we ignore, then the
+                // AUTH_RESPONSE we resolve on. Delete on resolve so the entry doesn't
+                // linger where the close handler could re-fire it.
+                if (packet.type === IncomingType.AUTH_RESPONSE) {
+                    this.pendingRequests.delete(packet.id);
+                    request.resolve();
+                }
+                return;
+            case 'command':
+                if (packet.type !== IncomingType.RESPONSE) {
+                    return;
+                }
+                // First fragment in: send the fence so its reply can mark the end of
+                // this (possibly multi-packet) response.
+                if (request.sendFence) {
+                    request.sendFence();
+                    request.sendFence = undefined;
+                }
+                request.fragments.push(packet.body);
+                return;
+            case 'fence':
+                // The fence's reply means every fragment of the command it follows has
+                // arrived; its resolve settles that command (and clears both entries).
+                if (packet.type !== IncomingType.RESPONSE) {
+                    return;
+                }
+                request.resolve();
+                return;
+        }
+    }
+    /**
+     * Create an RCON packet
+     */
+    createPacket(id, type, body) {
+        // Calculate size (4 bytes ID + 4 bytes type + body + 2 null terminators)
+        const bodyLength = Buffer.byteLength(body, 'utf8');
+        const size = 4 + 4 + bodyLength + 2;
+        // Create buffer (size field + packet content)
+        const buffer = Buffer.alloc(4 + size);
+        // Write size (little-endian)
+        buffer.writeInt32LE(size, 0);
+        // Write ID (little-endian)
+        buffer.writeInt32LE(id, 4);
+        // Write type (little-endian)
+        buffer.writeInt32LE(type, 8);
+        // Write body
+        buffer.write(body, 12, bodyLength, 'utf8');
+        // Null terminators are already 0 from Buffer.alloc
+        return buffer;
+    }
+    /**
+     * Parse a packet from a buffer
+     */
+    parsePacket(buffer) {
+        if (buffer.length < 14) {
+            throw new Error('Packet too small');
+        }
+        const size = buffer.readInt32LE(0);
+        const id = buffer.readInt32LE(4);
+        const type = buffer.readInt32LE(8);
+        // Read body (from byte 12 to size + 2, excluding null terminators)
+        const bodyEnd = Math.min(12 + size - 10, buffer.length - 2);
+        const body = buffer.toString('utf8', 12, bodyEnd);
+        return { size, id, type, body };
+    }
+    /**
+     * Get the next request ID
+     */
+    getNextRequestId() {
+        return ++this.requestId;
+    }
+    /**
+     * Disconnect from the server
+     */
+    async disconnect() {
+        if (this.socket) {
+            this.authenticated = false;
+            // Clear pending requests
+            for (const [, request] of this.pendingRequests) {
+                if (request.kind !== 'fence') {
+                    clearTimeout(request.timeout);
+                }
+                request.reject(new Error('Disconnected'));
+            }
+            this.pendingRequests.clear();
+            // Close socket
+            this.socket.destroy();
+            this.socket = null;
+        }
+    }
+    /**
+     * The lowest-level connection truth: an open socket that has authenticated.
+     * `RconController.isConnected()` forwards to this; `RconConnectionManager`
+     * keeps a separate intent-level flag that can briefly diverge during reconnects.
+     */
+    isConnected() {
+        return this.socket !== null && this.authenticated;
+    }
+}
+exports.RconProtocol = RconProtocol;
+//# sourceMappingURL=rconProtocol.js.map