minercon 3.0.0

package/out/minercon

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+"use strict";
+// src/cli.ts — standalone CLI entry point for the Minercon terminal.
+// Compiles to out/cli.js; the build script copies it to out/minercon.
+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 });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const util_1 = require("util");
+const consola_1 = require("consola");
+const prompts_1 = require("@clack/prompts");
+const rconClient_1 = require("./rconClient");
+const rconSession_1 = require("./rconSession");
+const cliConfig_1 = require("./cliConfig");
+// ── Config file ──────────────────────────────────────────────────────────────
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'minercon');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+// ── Prompt cancellation ──────────────────────────────────────────────────────
+/** Unwraps a clack prompt result, exiting cleanly if the user cancelled (Ctrl+C/Esc). */
+function unwrap(result) {
+    if ((0, prompts_1.isCancel)(result)) {
+        (0, prompts_1.cancel)('Cancelled.');
+        process.exit(0);
+    }
+    return result;
+}
+// ── Main ─────────────────────────────────────────────────────────────────────
+async function main() {
+    const { values, positionals } = (0, util_1.parseArgs)({
+        args: process.argv.slice(2),
+        options: {
+            password: { type: 'string', short: 'p' },
+            save: { type: 'boolean', default: false },
+            'log-file': { type: 'string' },
+            'log-level': { type: 'string' },
+            'history-size': { type: 'string' },
+            'no-plugin': { type: 'boolean', default: false },
+            'no-unpaginate': { type: 'boolean', default: false },
+            'no-pager': { type: 'boolean', default: false },
+            help: { type: 'boolean', short: 'h', default: false },
+            version: { type: 'boolean', short: 'V', default: false },
+        },
+        allowPositionals: true,
+        strict: false,
+    });
+    if (values.version) {
+        const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+        process.stdout.write(`minercon ${pkg.version}\n`);
+        process.exit(0);
+    }
+    if (values.help) {
+        process.stdout.write([
+            'Usage: minercon [host] [port] [options]',
+            '',
+            'Options:',
+            '  -p, --password <pw>   RCON password (also: MCRCON_PASSWORD env var)',
+            '  --save                Save host/port/history-size to ~/.config/minercon/config.json',
+            '  --log-file <path>     Write log output to a file instead of the console',
+            '  --log-level <level>   consola log level, e.g. debug, info, warn, error (default: info)',
+            '  --history-size <n>    Number of commands to remember in history (default: 100)',
+            '  --no-plugin           Skip the server-side tab-complete plugin probe (manual testing only;',
+            '                        not persisted to config)',
+            '  --no-unpaginate       Do not request unpaginated output via the plugin (keep server pages)',
+            '  --no-pager            Do not page tall output; print it all at once',
+            '  -V, --version         Print version and exit',
+            '  -h, --help            Show this help',
+            '',
+            'Environment:',
+            '  MCRCON_PASSWORD       RCON password (used if --password is not given)',
+            '  MCRCON_LOG_FILE       Log file path (used if --log-file is not given)',
+            '  MCRCON_LOG_LEVEL      Log level (used if --log-level is not given)',
+            '  MCRCON_HISTORY_SIZE   History size (used if --history-size is not given)',
+            '  MCRCON_UNPAGINATE     Set to 0 to disable unpaginated output (default on)',
+            '  MCRCON_PAGER          Set to 0 to disable the output pager (default on)',
+            '',
+        ].join('\n'));
+        process.exit(0);
+    }
+    if (!process.stdin.isTTY) {
+        process.stderr.write('Error: minercon is an interactive terminal and does not support piped input\n');
+        process.exit(1);
+    }
+    const logLevelResolution = (0, cliConfig_1.resolveLogLevel)(values['log-level'], process.env['MCRCON_LOG_LEVEL']);
+    if ('error' in logLevelResolution) {
+        process.stderr.write(`Error: ${logLevelResolution.error}\n`);
+        process.exit(1);
+    }
+    const logFilePath = values['log-file'] ?? process.env['MCRCON_LOG_FILE'];
+    const logStream = logFilePath
+        ? fs.createWriteStream(logFilePath, { flags: 'a' })
+        : undefined;
+    (0, prompts_1.updateSettings)({ withGuide: false });
+    const logger = (0, consola_1.createConsola)({
+        level: logLevelResolution.level,
+        ...(logStream ? { stdout: logStream, stderr: logStream } : {}),
+    });
+    const savedConfig = (0, cliConfig_1.readConfig)(CONFIG_FILE);
+    // Resolve host
+    let host = (0, cliConfig_1.resolveHost)(positionals[0], savedConfig);
+    if (!host) {
+        host = unwrap(await (0, prompts_1.text)({
+            message: 'RCON host (e.g. 127.0.0.1):',
+            validate: (value) => {
+                if (!value || value.trim() === '') {
+                    return 'host is required';
+                }
+            },
+        })).trim();
+    }
+    // Resolve port
+    let port;
+    const portResolution = (0, cliConfig_1.resolvePort)(positionals[1], savedConfig);
+    if (portResolution && 'error' in portResolution) {
+        process.stderr.write(`Error: ${portResolution.error}\n`);
+        process.exit(1);
+    }
+    else if (portResolution) {
+        port = portResolution.port;
+    }
+    else {
+        const raw = unwrap(await (0, prompts_1.text)({
+            message: 'RCON port',
+            placeholder: '25575',
+            defaultValue: '25575',
+            validate: (value) => {
+                if (value && (0, cliConfig_1.parsePort)(value) === null) {
+                    return `invalid port: ${value}`;
+                }
+            },
+        }));
+        const parsed = (0, cliConfig_1.parsePort)(raw);
+        if (parsed === null) {
+            process.stderr.write(`Error: invalid port: ${raw}\n`);
+            process.exit(1);
+        }
+        port = parsed;
+    }
+    // Resolve password — never saved to disk
+    let password = (0, cliConfig_1.resolvePassword)(values.password, process.env['MCRCON_PASSWORD']);
+    if (!password) {
+        password = unwrap(await (0, prompts_1.password)({ message: `RCON password for ${host}:${port}:` }));
+    }
+    // Resolve history size
+    const historySizeResolution = (0, cliConfig_1.resolveHistorySize)(values['history-size'], process.env['MCRCON_HISTORY_SIZE'], savedConfig);
+    if ('error' in historySizeResolution) {
+        process.stderr.write(`Error: ${historySizeResolution.error}\n`);
+        process.exit(1);
+    }
+    const historySize = historySizeResolution.historySize;
+    if (values.save) {
+        (0, cliConfig_1.writeConfig)(CONFIG_FILE, { host, port, historySize });
+        logger.info(`Saved ${host}:${port} (history size ${historySize}) to ${CONFIG_FILE}`);
+    }
+    // ── Establish connection ──────────────────────────────────────────────────
+    const controller = new rconClient_1.RconController(host, port, password, logger);
+    logger.info(`Connecting to ${host}:${port}...`);
+    try {
+        await controller.connect();
+    }
+    catch (err) {
+        logger.error(`Failed to connect: ${err}`);
+        process.exit(1);
+    }
+    // ── Build session host ────────────────────────────────────────────────────
+    let pasteboard = '';
+    // Cache lives in the same config dir as config.json
+    const cacheDir = CONFIG_DIR;
+    const sessionHost = {
+        write: (text) => process.stdout.write(text),
+        close: (code) => {
+            teardown();
+            process.exit(code);
+        },
+        clipboard: {
+            readText: () => Promise.resolve(pasteboard),
+            writeText: (text) => { pasteboard = text; return Promise.resolve(); },
+        },
+        cacheDir,
+        dimensions: () => process.stdout.columns && process.stdout.rows
+            ? { columns: process.stdout.columns, rows: process.stdout.rows }
+            : undefined,
+        historySize,
+        disablePlugin: values['no-plugin'],
+        // Both default-on: disabled only by their --no-* flag or env var set to '0'.
+        unpaginateOutput: !values['no-unpaginate'] && process.env['MCRCON_UNPAGINATE'] !== '0',
+        terminalPager: !values['no-pager'] && process.env['MCRCON_PAGER'] !== '0',
+        logToFile: logFilePath !== undefined,
+    };
+    const session = new rconSession_1.RconSession(controller, host, port, password, logger, sessionHost);
+    // ── TTY / signal setup ────────────────────────────────────────────────────
+    let tornDown = false;
+    function teardown() {
+        if (tornDown) {
+            return;
+        }
+        tornDown = true;
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        session.close();
+    }
+    process.on('exit', teardown);
+    process.on('SIGINT', () => { teardown(); process.exit(0); });
+    process.on('SIGTERM', () => { teardown(); process.exit(0); });
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    process.stdout.on('resize', () => {
+        // dimensions() reads process.stdout.columns/rows live — nothing to do here
+    });
+    process.stdin.on('data', (chunk) => {
+        session.handleInput(chunk);
+    });
+    // Open the session (writes the welcome banner and starts the plugin probe)
+    session.open();
+}
+main().catch((err) => {
+    process.stderr.write(`Error: ${err}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/out/pager.js

@@ -0,0 +1,168 @@
+"use strict";
+// src/pager.ts
+//
+// A `more`-style, append-only terminal pager for large command output.
+//
+// Why append-only (and not a `less`-style repaint): the server-side
+// de-pagination (the `rcat` plugin wrap) hands us the *full* output in one
+// response, which can be hundreds of lines. We page it at the terminal's real
+// height — but the paged content MUST remain in the terminal's scrollback after
+// the pager exits (an alternate-screen / repaint pager would restore the screen
+// and wipe it, a regression). So we only ever print *forward*, below what's
+// already shown, and draw a one-line status prompt that is erased in place
+// before the next batch. Backward viewing is the terminal's own scrollback,
+// which works precisely because nothing is ever cleared.
+//
+// The pager reads from a `LineSource` rather than a fixed array so a future
+// just-in-time "fetch the next page as you scroll" source (the deferred
+// no-plugin option C) can drop into the same UI unchanged.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pager = exports.FALLBACK_COLS = exports.FALLBACK_ROWS = exports.ArrayLineSource = void 0;
+exports.visualRowCount = visualRowCount;
+const ansi_1 = require("./ansi");
+/** The trivial in-memory source: the whole response, split into lines. */
+class ArrayLineSource {
+    lines;
+    constructor(lines) {
+        this.lines = lines;
+    }
+    length() { return this.lines.length; }
+    lineAt(index) { return this.lines[index]; }
+}
+exports.ArrayLineSource = ArrayLineSource;
+exports.FALLBACK_ROWS = 24;
+exports.FALLBACK_COLS = 80;
+/**
+ * Number of visual terminal rows a single (possibly ANSI-styled) source line
+ * occupies once the terminal soft-wraps it at `columns`. ANSI-aware: color/
+ * style escapes are stripped before measuring so they don't count toward width,
+ * and — because we only *count* here and let the terminal do the actual wrap —
+ * no escape sequence is ever split. An empty line still occupies one row.
+ */
+function visualRowCount(line, columns) {
+    const width = (0, ansi_1.stripAnsi)(line).length;
+    if (width === 0) {
+        return 1;
+    }
+    return Math.ceil(width / Math.max(1, columns));
+}
+/**
+ * Drives one paging interaction over `source`. Created and `start()`ed once the
+ * session decides the output is too tall for the window; fed keystrokes via
+ * `handleKey` until it calls `onDone` (which restores the prompt).
+ */
+class Pager {
+    host;
+    source;
+    onDone;
+    // Index of the next not-yet-printed source line.
+    next = 0;
+    // Whether a status prompt line is currently drawn on the cursor's row.
+    statusShown = false;
+    finished = false;
+    constructor(host, source, onDone) {
+        this.host = host;
+        this.source = source;
+        this.onDone = onDone;
+    }
+    /** True once the pager has exited (so the session can drop its reference). */
+    get isFinished() { return this.finished; }
+    /** Prints the first screenful and the status prompt. */
+    start() {
+        this.advancePage();
+    }
+    rows() { return this.host.dimensions()?.rows ?? exports.FALLBACK_ROWS; }
+    columns() { return this.host.dimensions()?.columns ?? exports.FALLBACK_COLS; }
+    /** Reserve one row for the status prompt; never less than one content row. */
+    pageHeight() { return Math.max(1, this.rows() - 1); }
+    clearStatus() {
+        if (this.statusShown) {
+            // Return to column 0 and clear the line in place — never clears the
+            // screen, never touches the alternate buffer, so scrollback is retained.
+            this.host.write('\r\x1b[K');
+            this.statusShown = false;
+        }
+    }
+    drawStatus() {
+        const shown = this.next;
+        const total = this.source.length();
+        this.host.write((0, ansi_1.dim)(`-- More -- (${shown}/${total})  Space: more · G: all · q: quit`));
+        this.statusShown = true;
+    }
+    /** Prints source lines (recomputing height each call) until `maxRows` visual rows are used or the source is exhausted. */
+    printRows(maxRows) {
+        const cols = this.columns();
+        let used = 0;
+        while (this.next < this.source.length() && used < maxRows) {
+            const line = this.source.lineAt(this.next);
+            this.host.write(`${line}\r\n`);
+            used += visualRowCount(line, cols);
+            this.next++;
+        }
+    }
+    atEnd() { return this.next >= this.source.length(); }
+    /** After printing a batch: either redraw the status prompt, or finish if done. */
+    afterBatch() {
+        if (this.atEnd()) {
+            this.finish();
+        }
+        else {
+            this.drawStatus();
+        }
+    }
+    advancePage() {
+        this.clearStatus();
+        this.printRows(this.pageHeight());
+        this.afterBatch();
+    }
+    advanceLine() {
+        this.clearStatus();
+        this.printRows(1);
+        this.afterBatch();
+    }
+    printAllRemaining() {
+        this.clearStatus();
+        this.printRows(Number.POSITIVE_INFINITY);
+        this.finish();
+    }
+    finish() {
+        this.clearStatus();
+        this.finished = true;
+        this.onDone();
+    }
+    /**
+     * Handles one input chunk while the pager is active. Forward-only by design;
+     * scrolling back up is the terminal's native scrollback.
+     */
+    handleKey(data) {
+        if (this.finished) {
+            return;
+        }
+        switch (data) {
+            case ' ':
+            case 'f':
+            case '\x1b[6~': // PageDown
+                this.advancePage();
+                break;
+            case '\r':
+            case '\n':
+            case '\x1b[B': // Down arrow
+            case 'j':
+                this.advanceLine();
+                break;
+            case 'G':
+                this.printAllRemaining();
+                break;
+            case 'q':
+            case '\x03': // Ctrl+C
+                this.finish();
+                break;
+            default:
+                // Ignore everything else (incl. attempts to scroll up — use the
+                // terminal's own scrollback).
+                break;
+        }
+    }
+}
+exports.Pager = Pager;
+//# sourceMappingURL=pager.js.map

package/out/pagination.js

@@ -0,0 +1,142 @@
+"use strict";
+// src/pagination.ts
+//
+// Client-side "stitching" of plugin commands that paginate their OWN output,
+// independently of the server-side `rcat` de-pagination. Some plugins — most
+// notably Multiverse-Core — only ever return a single page per RCON call, with
+// a "Page X of Y" header and their own page argument, so `rcat` alone still
+// leaves you on page 1. When de-pagination is active we recognise that chrome,
+// re-issue the command once per page, strip the headers, and concatenate the
+// bodies into one response that flows into the pager like any other output.
+//
+// The set of recognised formats lives in DEFAULT_PATTERNS and is intentionally
+// open: add a PaginationPattern for each plugin family whose page navigation we
+// can actually drive from the command line. Plugins with no usable "go to page
+// N" command have no pattern and fall through unchanged — e.g.
+// Multiverse-Portals, whose `mvp list [filter] [page]` treats the first
+// positional as a name filter, so there is no way to request page 2 of the
+// *unfiltered* list. If a future version exposes a real page flag, add a
+// pattern here and it will be picked up automatically.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PATTERNS = void 0;
+exports.stitchPaginated = stitchPaginated;
+const ansi_1 = require("./ansi");
+// --- Multiverse-Core -------------------------------------------------------
+//
+// ContentDisplay output looks like:
+//
+//   ====[ Multiverse World List ]====
+//   [Page 2 of 3]
+//   elficka - NORMAL
+//   ...
+//
+// A specific page is fetched with `--page N` (also accepts `--page=N`).
+const MV_PAGE_LINE = /\[Page (\d+) of (\d+)\]/i;
+const MV_TITLE_LINE = /^={2,}\[.*\]={2,}$/;
+const MV_PAGE_ARG = /\s--page(?:=|\s+)\d+\b/i;
+/** Hard cap on pages we'll fetch — a clamp against bogus/huge page counts. */
+const MAX_PAGES = 1000;
+const multiverseCore = {
+    name: 'multiverse-core',
+    detect(response) {
+        const match = (0, ansi_1.stripColors)(response).match(MV_PAGE_LINE);
+        if (!match) {
+            return undefined;
+        }
+        const page = Number(match[1]);
+        // totalPages comes from untrusted server output; clamp it to MAX_PAGES so a
+        // bogus or huge value can't drive an unbounded fetch walk.
+        const totalPages = Math.min(Number(match[2]), MAX_PAGES);
+        return { page, totalPages };
+    },
+    pageCommand(command, page) {
+        const base = command.replace(MV_PAGE_ARG, '').trimEnd();
+        return `${base} --page ${page}`;
+    },
+    contentLines(response) {
+        return response.split('\n').filter(line => {
+            const bare = (0, ansi_1.stripColors)(line).trim();
+            return !MV_PAGE_LINE.test(bare) && !MV_TITLE_LINE.test(bare);
+        });
+    },
+    titleLines(response) {
+        return response.split('\n').filter(line => MV_TITLE_LINE.test((0, ansi_1.stripColors)(line).trim()));
+    },
+    hasExplicitPage(command) {
+        return MV_PAGE_ARG.test(command);
+    },
+};
+/** Recognised paginated-output formats, tried in order. */
+exports.DEFAULT_PATTERNS = [multiverseCore];
+/**
+ * If `firstResponse` is a recognised paginated output and `command` did not
+ * already request a specific page, fetch every page via `fetchPage`, strip the
+ * chrome, and return the concatenated result. Returns `undefined` when nothing
+ * was stitched (not paginated, single page, explicit page requested, or no
+ * pattern matched) so the caller can use the original response unchanged.
+ *
+ * Resilient by design: a page fetch that throws, or whose response no longer
+ * matches the pattern, stops/skips rather than corrupting the output — so the
+ * result is never worse than the single page the caller already holds.
+ */
+async function stitchPaginated(firstResponse, command, fetchPage, options = {}) {
+    const patterns = options.patterns ?? exports.DEFAULT_PATTERNS;
+    for (const pattern of patterns) {
+        if (pattern.hasExplicitPage(command)) {
+            continue;
+        }
+        const detected = pattern.detect(firstResponse);
+        if (!detected) {
+            continue;
+        }
+        // detect() already clamps totalPages to a safe maximum.
+        const totalPages = detected.totalPages;
+        if (totalPages <= 1) {
+            return undefined; // single page — nothing to stitch
+        }
+        const pages = new Map();
+        pages.set(detected.page, trimBlankEdges(pattern.contentLines(firstResponse)));
+        for (let page = 1; page <= totalPages; page++) {
+            if (pages.has(page)) {
+                continue;
+            }
+            let pageResponse;
+            try {
+                pageResponse = await fetchPage(pattern.pageCommand(command, page));
+            }
+            catch (err) {
+                options.log?.(`pagination: ${pattern.name} page ${page} fetch failed: ${String(err)}`);
+                break; // give up the walk; emit what we have
+            }
+            // A non-matching page (error text, out of range) is skipped rather than
+            // appended verbatim.
+            if (!pattern.detect(pageResponse)) {
+                options.log?.(`pagination: ${pattern.name} page ${page} did not match; skipping`);
+                continue;
+            }
+            pages.set(page, trimBlankEdges(pattern.contentLines(pageResponse)));
+        }
+        const out = [...pattern.titleLines(firstResponse)];
+        for (let page = 1; page <= totalPages; page++) {
+            const content = pages.get(page);
+            if (content) {
+                out.push(...content);
+            }
+        }
+        return out.join('\n');
+    }
+    return undefined;
+}
+/** Drop leading/trailing blank lines so stitched pages don't accrue gaps. */
+function trimBlankEdges(lines) {
+    let start = 0;
+    let end = lines.length;
+    while (start < end && (0, ansi_1.stripColors)(lines[start]).trim() === '') {
+        start++;
+    }
+    while (end > start && (0, ansi_1.stripColors)(lines[end - 1]).trim() === '') {
+        end--;
+    }
+    return lines.slice(start, end);
+}
+//# sourceMappingURL=pagination.js.map

package/out/rconClient.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RconController = void 0;
+const rconProtocol_1 = require("./rconProtocol");
+const logger_1 = require("./logger");
+class RconController {
+    host;
+    port;
+    password;
+    client = null;
+    logger;
+    // Serializes every `send` through this controller — completions/usage
+    // fetches and actual command execution all funnel through here (see
+    // RconCompletionBackend, CommandTreeCrawler, RconSession.executeCommand).
+    // Without this, e.g. hitting Enter on "/mvp list" while its argument-hint
+    // "cmdusage mvp list" round trip is still in flight fires two concurrent
+    // RCON exchanges over the same socket — which the server doesn't tolerate
+    // and answers by closing the connection. Chaining onto this promise (and
+    // swallowing its rejection so one failed command doesn't wedge the queue)
+    // guarantees at most one command is ever outstanding at a time.
+    sendQueue = Promise.resolve();
+    createProtocol;
+    unexpectedCloseHandler = null;
+    constructor(host, port, password, logger, 
+    // Defaults to a real RconProtocol; tests substitute a fake here so the
+    // queue-serialization/error-handling logic can be exercised without a
+    // live server (mirrors RconProtocol's own `createSocket` seam).
+    createProtocol = (h, p, pw, l) => new rconProtocol_1.RconProtocol(h, p, pw, l)) {
+        this.host = host;
+        this.port = port;
+        this.password = password;
+        this.logger = logger;
+        this.createProtocol = createProtocol;
+    }
+    /** Called by `RconConnectionManager` so it can react to unexpected socket closes without polling. */
+    setUnexpectedCloseHandler(handler) {
+        this.unexpectedCloseHandler = handler;
+    }
+    async connect() {
+        this.client = this.createProtocol(this.host, this.port, this.password, this.logger);
+        // Set up error handler
+        this.client.on('error', (error) => {
+            this.logger.error(`RCON error: ${error.message}`);
+        });
+        // Set up close handler
+        this.client.on('close', () => {
+            this.logger.info('RCON connection closed');
+            this.client = null;
+            this.unexpectedCloseHandler?.();
+        });
+        await this.client.connect();
+        this.logger.info('RCON session established.');
+    }
+    send(cmd) {
+        const result = this.sendQueue.then(() => this.sendNow(cmd));
+        this.sendQueue = result.catch(() => undefined);
+        return result;
+    }
+    async sendNow(cmd) {
+        if (!this.client) {
+            throw new Error('Not connected');
+        }
+        const sentAt = Date.now();
+        this.logger.debug(`send: ${cmd}`);
+        try {
+            const res = await this.client.send(cmd);
+            const elapsedMs = Date.now() - sentAt;
+            this.logger.debug(`recv (+${elapsedMs}ms): ${cmd} -> ${res.length} chars`);
+            return res;
+        }
+        catch (err) {
+            this.logger.error('Error sending command: ' + (0, logger_1.errorMessage)(err));
+            throw err;
+        }
+    }
+    async disconnect() {
+        if (!this.client) {
+            return;
+        }
+        try {
+            await this.client.disconnect();
+        }
+        catch (e) {
+            // ignore
+        }
+        this.client = null;
+    }
+    // The live socket-level truth: do we currently have an authenticated
+    // connection? `RconConnectionManager` tracks a separate, intent-level
+    // `isConnected` (whether the session *believes* it's connected) that can
+    // briefly diverge from this during reconnects — see that class.
+    isConnected() {
+        return this.client !== null && this.client.isConnected();
+    }
+}
+exports.RconController = RconController;
+//# sourceMappingURL=rconClient.js.map