minercon 3.0.2 → 3.0.4

package/package.json

@@ -2,7 +2,7 @@
   "name": "minercon",
   "displayName": "Minercon",
   "description": "A powerful RCON client for Minecraft servers with fancy tab completion",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "author": "xton <thisischriston@gmail.com>",
   "icon": "images/icon.png",
   "license": "MIT",

package/out/argumentHint.js

@@ -1,43 +0,0 @@
-"use strict";
-// src/argumentHint.ts
-//
-// Pure formatting for the "argument hint" display: given a command's usage
-// string (e.g. "gamemode <mode> [<target>]") and the line the user has typed
-// so far, work out which argument position they're at and which token in the
-// usage string corresponds to it (so it can be highlighted).
-//
-// This is presentation logic, not decision logic — it has no notion of
-// fetching, timing, or staleness — so it lives apart from completionEngine's
-// state machine, as its own pure, independently-testable function.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatArgumentHint = formatArgumentHint;
-const ARGUMENT_TOKEN_PATTERN = /(<[^>]+>|\[[^\]]+\]|\([^)]+\))/g;
-/** Returns null when there's no usage text to show anything for. */
-function formatArgumentHint(usage, line) {
-    if (!usage) {
-        return null;
-    }
-    const tokens = usage.match(ARGUMENT_TOKEN_PATTERN) || [];
-    // The literal words before the first argument token are the command path —
-    // derived straight from the usage string so we don't need a separate
-    // "commandPath" concept threaded in from wherever the usage came from.
-    const firstTokenStart = usage.search(ARGUMENT_TOKEN_PATTERN);
-    const literalPrefix = (firstTokenStart >= 0 ? usage.slice(0, firstTokenStart) : usage).trim();
-    const commandPrefixWordCount = literalPrefix.length > 0 ? literalPrefix.split(/\s+/).length : 0;
-    const commandPrefixText = '/' + literalPrefix;
-    const parts = line.trim().split(' ').filter(p => p.length > 0);
-    const hasTrailingSpace = line.endsWith(' ');
-    const argumentCount = Math.max(0, parts.length - commandPrefixWordCount);
-    let currentArgIndex;
-    if (argumentCount === 0 && !hasTrailingSpace) {
-        currentArgIndex = -1; // still typing the command/subcommand itself
-    }
-    else if (hasTrailingSpace) {
-        currentArgIndex = argumentCount; // ready for the next argument
-    }
-    else {
-        currentArgIndex = argumentCount - 1; // currently typing this argument
-    }
-    return { commandPrefixText, tokens, currentArgIndex };
-}
-//# sourceMappingURL=argumentHint.js.map

package/out/bukkitHelpParsing.js

@@ -1,62 +0,0 @@
-"use strict";
-// src/bukkitHelpParsing.ts
-//
-// Pure parsing of Bukkit's hand-written `/help <command>` pages - a
-// "§e--------- §fHelp: /<cmd> ----...§e" banner line followed by
-// `Description:`/`Usage:`/`Aliases:` lines. This is a different grammar from
-// the flat Brigadier `/cmd <args>` blobs `helpTextParsing.ts` handles
-// (`minecraft:help`, vanilla's plain `help`): on a server where the
-// `minecraft:` namespace is supported (Paper/Spigot), `help <path>` is
-// *always* one of these pages, for every command - vanilla-backed or
-// Bukkit-added alike - so no shape-sniffing is needed to decide which parser
-// applies, only `LocalCommandTree.supportsMinecraftNamespace`.
-//
-// No state, no IO — every export here is a deterministic function of its
-// arguments.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractBukkitUsageLines = extractBukkitUsageLines;
-exports.extractBukkitAliases = extractBukkitAliases;
-const ansi_1 = require("./ansi");
-/**
- * Extract the `Usage: ...` line(s) from a Bukkit-style `/help <command>`
- * response (e.g. "Description: ...\nUsage: /version [plugin name]\nAliases:
- * ..."), normalized so each reads as `<commandPath> ...` for `parseHelpLines`.
- * Returns `[]` if there's no Usage line, or if its content is just the bare
- * command name with nothing after it — the generic response Bukkit gives for
- * Brigadier-backed (vanilla) commands ("Description: A Mojang provided
- * command.\nUsage: <name>"), which carries no argument info.
- */
-function extractBukkitUsageLines(helpText, commandPath) {
-    const lines = (0, ansi_1.stripColors)(helpText).split('\n').map(line => line.trim());
-    const usageIndex = lines.findIndex(line => /^Usage:\s*/i.test(line));
-    if (usageIndex === -1) {
-        return [];
-    }
-    const result = [lines[usageIndex].replace(/^Usage:\s*/i, '')];
-    for (let i = usageIndex + 1; i < lines.length; i++) {
-        const line = lines[i];
-        if (!line || /^[A-Za-z][A-Za-z ]*:/.test(line) || line.startsWith('---')) {
-            break;
-        }
-        result.push(line);
-    }
-    const normalizedPath = commandPath.toLowerCase();
-    return result.filter(line => line.replace(/^\//, '').toLowerCase() !== normalizedPath);
-}
-/**
- * Extract alias names from a Bukkit-style `/help <command>` response's
- * `Aliases: a, b, c` line (e.g. "Description: ...\nUsage: ...\nAliases: ver,
- * about"). Returns `[]` if there's no Aliases line.
- */
-function extractBukkitAliases(helpText) {
-    const lines = (0, ansi_1.stripColors)(helpText).split('\n').map(line => line.trim());
-    const aliasesLine = lines.find(line => /^Aliases:\s*/i.test(line));
-    if (!aliasesLine) {
-        return [];
-    }
-    return aliasesLine.replace(/^Aliases:\s*/i, '')
-        .split(',')
-        .map(alias => alias.trim())
-        .filter(alias => alias.length > 0);
-}
-//# sourceMappingURL=bukkitHelpParsing.js.map

package/out/commandSuggestions.js

@@ -1,202 +0,0 @@
-"use strict";
-// src/commandSuggestions.ts
-//
-// Pure suggestion generation: given the command tree `LocalCommandTree`
-// builds and the user's current input line, work out what to suggest next
-// and what argument-help text to show. No state, no IO — a deterministic
-// function of the tree and the input.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSuggestions = getSuggestions;
-const commandTree_1 = require("./commandTree");
-/**
- * Get suggestions based on current input
- */
-function getSuggestions(rootCommands, isReady, input) {
-    if (!isReady) {
-        return { suggestions: [], argumentHelp: undefined };
-    }
-    const trimmed = input.trim();
-    if (!trimmed.startsWith('/')) {
-        return { suggestions: [], argumentHelp: undefined };
-    }
-    const hasTrailingSpace = input.endsWith(' ');
-    const parts = trimmed.slice(1).split(' ').filter(p => p.length > 0);
-    const commandName = parts[0];
-    // Handle root command suggestions
-    if (parts.length === 0 || (parts.length === 1 && !hasTrailingSpace)) {
-        const suggestions = Array.from(rootCommands.keys())
-            .filter(cmd => cmd.startsWith(commandName || ''))
-            .sort();
-        return { suggestions, argumentHelp: undefined };
-    }
-    // Find the command node
-    const rootNode = rootCommands.get(commandName);
-    if (!rootNode) {
-        return { suggestions: [], argumentHelp: undefined };
-    }
-    // Navigate through the parameter tree
-    let currentParameters = rootNode.members || [];
-    let paramIndex = 1; // Start after the command name
-    // The command path consumed so far (root command + any literal/subcommand
-    // tokens navigated past) - see SuggestionResult.commandPath.
-    const pathParts = [commandName];
-    // Navigate through completed parts (not including what we're currently typing)
-    const partsToNavigate = hasTrailingSpace ? parts.length : parts.length - 1;
-    while (paramIndex < partsToNavigate && currentParameters.length > 0) {
-        const currentPart = parts[paramIndex];
-        let navigated = false;
-        // Get the first parameter at this position
-        const firstParam = currentParameters[0];
-        if (firstParam.type === commandTree_1.ParameterType.SUBCOMMAND) {
-            // Direct subcommand
-            if (firstParam.name === currentPart || firstParam.literal === currentPart) {
-                currentParameters = firstParam.members || [];
-                navigated = true;
-            }
-        }
-        else if (firstParam.type === commandTree_1.ParameterType.CHOICE_LIST && firstParam.choices) {
-            // Choice list - find matching choice and navigate into it
-            for (const choice of firstParam.choices) {
-                if (choice.type === commandTree_1.ParameterType.SUBCOMMAND &&
-                    (choice.name === currentPart || choice.literal === currentPart)) {
-                    // IMPORTANT: Navigate into the selected choice's members
-                    currentParameters = choice.members || [];
-                    navigated = true;
-                    break;
-                }
-                else if (choice.type === commandTree_1.ParameterType.LITERAL && choice.literal === currentPart) {
-                    // For literal choices, move to next parameter position
-                    currentParameters = currentParameters.slice(1);
-                    navigated = true;
-                    break;
-                }
-            }
-        }
-        else if (firstParam.type === commandTree_1.ParameterType.LITERAL && firstParam.literal === currentPart) {
-            // Literal parameter
-            currentParameters = currentParameters.slice(1);
-            navigated = true;
-        }
-        paramIndex++;
-        if (navigated) {
-            pathParts.push(currentPart);
-        }
-        else {
-            // It's an argument value, skip to next position
-            currentParameters = currentParameters.slice(1);
-        }
-    }
-    // Build argument help from current position
-    const argumentHelp = buildArgumentHelp(currentParameters);
-    const commandPath = pathParts.join(' ');
-    // Generate suggestions based on current position
-    let suggestions = [];
-    if (hasTrailingSpace) {
-        // We want suggestions for the NEXT parameter
-        suggestions = generateSuggestionsForNextPosition(currentParameters);
-    }
-    else {
-        // We're typing something, get matching suggestions
-        const currentPart = parts[parts.length - 1] || '';
-        suggestions = generateSuggestionsForCurrentPart(currentParameters, currentPart);
-    }
-    return { suggestions, argumentHelp, commandPath };
-}
-/**
- * Generate suggestions for what we're currently typing
- * Must handle CHOICE_LIST parameters properly
- */
-function generateSuggestionsForCurrentPart(parameters, currentPart) {
-    const suggestions = [];
-    for (const param of parameters) {
-        if (param.type === commandTree_1.ParameterType.SUBCOMMAND) {
-            // Direct subcommand
-            const name = param.name || param.literal || '';
-            if (name.startsWith(currentPart)) {
-                suggestions.push(name);
-            }
-        }
-        else if (param.type === commandTree_1.ParameterType.CHOICE_LIST && param.choices) {
-            // Choice list - add all matching choices
-            for (const choice of param.choices) {
-                if (choice.type === commandTree_1.ParameterType.SUBCOMMAND) {
-                    const name = choice.name || choice.literal || '';
-                    if (name.startsWith(currentPart)) {
-                        suggestions.push(name);
-                    }
-                }
-                else if (choice.type === commandTree_1.ParameterType.LITERAL) {
-                    const literal = choice.literal || '';
-                    if (literal.startsWith(currentPart)) {
-                        suggestions.push(literal);
-                    }
-                }
-            }
-        }
-        else if (param.type === commandTree_1.ParameterType.LITERAL) {
-            const literal = param.literal || '';
-            if (literal.startsWith(currentPart)) {
-                suggestions.push(literal);
-            }
-        }
-        // We only process the first parameter position
-        break;
-    }
-    return suggestions.sort();
-}
-/**
- * Generate suggestions for the next parameter position
- * Must handle CHOICE_LIST parameters properly
- */
-function generateSuggestionsForNextPosition(parameters) {
-    const suggestions = [];
-    if (parameters.length === 0) {
-        return suggestions;
-    }
-    const firstParam = parameters[0];
-    if (firstParam.type === commandTree_1.ParameterType.SUBCOMMAND) {
-        // Direct subcommand
-        suggestions.push(firstParam.name || firstParam.literal || '');
-    }
-    else if (firstParam.type === commandTree_1.ParameterType.CHOICE_LIST && firstParam.choices) {
-        // Choice list - add all choices as suggestions
-        for (const choice of firstParam.choices) {
-            if (choice.type === commandTree_1.ParameterType.SUBCOMMAND) {
-                suggestions.push(choice.name || choice.literal || '');
-            }
-            else if (choice.type === commandTree_1.ParameterType.LITERAL) {
-                suggestions.push(choice.literal || '');
-            }
-        }
-    }
-    else if (firstParam.type === commandTree_1.ParameterType.LITERAL) {
-        suggestions.push(firstParam.literal || '');
-    }
-    // Don't suggest anything for ARGUMENT types
-    return suggestions.sort();
-}
-/**
- * Build argument help string from parameters
- */
-function buildArgumentHelp(parameters) {
-    if (parameters.length === 0) {
-        return '';
-    }
-    return parameters.map(param => {
-        if (param.type === commandTree_1.ParameterType.ARGUMENT) {
-            return param.optional ? `[<${param.name}>]` : `<${param.name}>`;
-        }
-        else if (param.type === commandTree_1.ParameterType.CHOICE_LIST && param.choices) {
-            const choices = param.choices.map((c) => c.literal).join('|');
-            return `(${choices})`;
-        }
-        else if (param.type === commandTree_1.ParameterType.LITERAL) {
-            return param.literal;
-        }
-        else if (param.type === commandTree_1.ParameterType.SUBCOMMAND) {
-            return param.name; // Show subcommand name
-        }
-        return '';
-    }).join(' ');
-}
-//# sourceMappingURL=commandSuggestions.js.map

package/out/completionsBackend.js

@@ -1,97 +0,0 @@
-"use strict";
-// src/completionsBackend.ts
-//
-// The completionEngine state machine knows it needs completions and usage
-// text for a given input line — it doesn't know or care whether those come
-// from a network round trip or an in-memory lookup. A CompletionsBackend is
-// that boundary: one implementation asks the server-side TabComplete
-// plugin over RCON, the other asks the locally-built command tree.
-//
-// Driving both modes through the same backend interface (and therefore the
-// same engine, the same dispatch plumbing, and the same rendering) is what
-// lets RconSession be entirely mode-blind — "which backend" is decided once,
-// not branched on at every call site.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LocalCompletionsBackend = exports.RconCompletionsBackend = void 0;
-const completionEngine_1 = require("./completionEngine");
-/**
- * Server-side completions via the TabComplete plugin's `tabcomplete`/`cmdusage` commands.
- *
- * Takes a `controller` thunk rather than a fixed `RconController` — the
- * connection manager replaces its controller wholesale on every reconnect, so
- * capturing one instance up front would silently start sending through a dead
- * (disconnected) controller after the first reconnect, with every fetch
- * throwing "Not connected" (swallowed by the caller as "no completions").
- * Looking it up fresh on each call always reaches whatever's live.
- */
-class RconCompletionsBackend {
-    getController;
-    constructor(getController) {
-        this.getController = getController;
-    }
-    async fetchCompletions(line) {
-        const query = (0, completionEngine_1.buildCompletionsQuery)(line);
-        if (query === null) {
-            return [];
-        }
-        const response = await this.getController().send(`tabcomplete ${query}`);
-        return (0, completionEngine_1.parseCompletionsResponse)(response ?? undefined);
-    }
-    async fetchUsage(line) {
-        const query = (0, completionEngine_1.buildUsageQuery)(line);
-        if (query === null) {
-            return '';
-        }
-        const response = await this.getController().send(`cmdusage ${query}`);
-        return (0, completionEngine_1.parseUsageResponse)(response ?? undefined);
-    }
-}
-exports.RconCompletionsBackend = RconCompletionsBackend;
-/**
- * Local completions via the command tree LocalCommandTree builds at
- * startup — a synchronous in-memory lookup, wrapped in `async` so it flows
- * through exactly the same dispatch path as the RCON backend (the `await`
- * still yields to the microtask queue, so a `dispatchToEngine` call made from
- * here lands *after* the effect loop that triggered it has finished — same
- * ordering guarantee the real async backend gets for free from the network).
- */
-class LocalCompletionsBackend {
-    commandTree;
-    // getSuggestions sometimes returns incomplete argument help for inputs that
-    // are mid-command (e.g. once the user is typing a free-form argument like a
-    // player name, the locally-built tree may not have anything to say). Stick
-    // with the first full version we saw for this command rather than flicker
-    // between that and "(nothing)" — mirrors the original local-mode behavior.
-    cachedCommand = null;
-    cachedHelp = null;
-    constructor(commandTree) {
-        this.commandTree = commandTree;
-    }
-    async fetchCompletions(line) {
-        return this.commandTree.getSuggestions(line).suggestions;
-    }
-    async fetchUsage(line) {
-        const result = this.commandTree.getSuggestions(line);
-        // Everything up to the first space, including any "namespace:" prefix -
-        // \S rather than \w so "minecraft:clear" isn't truncated to "minecraft".
-        const commandName = (line.match(/^\/?(\S+)/) || [])[1] || '';
-        if (commandName !== this.cachedCommand) {
-            this.cachedCommand = commandName;
-            this.cachedHelp = null;
-        }
-        if (result.argumentHelp !== undefined) {
-            // Match the shape of the server's `cmdusage` response (e.g. "clear
-            // [<targets>] [<item>]") - formatArgumentHint derives the command
-            // prefix from this leading commandPath, so it must be present even
-            // when there's no argument help (e.g. "reload").
-            const usage = result.argumentHelp ? `${result.commandPath} ${result.argumentHelp}` : result.commandPath;
-            if (this.cachedHelp === null) {
-                this.cachedHelp = usage;
-            }
-            return this.cachedHelp;
-        }
-        return this.cachedHelp ?? '';
-    }
-}
-exports.LocalCompletionsBackend = LocalCompletionsBackend;
-//# sourceMappingURL=completionsBackend.js.map

package/out/connectionManager.js

@@ -1,209 +0,0 @@
-"use strict";
-// src/connectionManager.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 / suggestionDisplay.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.ConnectionManager = 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);
-class ConnectionManager {
-    serverHost;
-    serverPort;
-    password;
-    logger;
-    host;
-    controllerFactory;
-    _controller;
-    _isConnected = true;
-    _isReconnecting = false;
-    reconnectAttempts = 0;
-    maxReconnectAttempts = 5;
-    reconnectDelay = 2000;
-    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;
-    }
-    get controller() {
-        return this._controller;
-    }
-    get isConnected() {
-        return this._isConnected;
-    }
-    get isReconnecting() {
-        return this._isReconnecting;
-    }
-    /** Resets the reconnect-attempt counter, backoff delay, and any pending reconnect timer back to their initial state. */
-    resetReconnectState() {
-        this.reconnectAttempts = 0;
-        this.reconnectDelay = 2000;
-        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();
-        }, 1000);
-    }
-    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}/${this.maxReconnectAttempts})` : '';
-        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);
-            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 < this.maxReconnectAttempts) {
-                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, 32000);
-            }
-            else {
-                // Max attempts reached
-                this.host.write(ansi.boldRed('✗ Reconnection failed after ' + this.maxReconnectAttempts + ' 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.ConnectionManager = ConnectionManager;
-//# sourceMappingURL=connectionManager.js.map