minercon 3.0.0

package/out/rconSession.js

@@ -0,0 +1,920 @@
+"use strict";
+// src/rconSession.ts
+//
+// Host-agnostic RCON session orchestrator. Contains all interactive-terminal
+// logic (key dispatch, tab completion, command routing, reconnect handling)
+// behind a narrow `RconSessionHost` seam whose only hard requirement is a
+// function that writes ANSI text to a terminal-shaped output stream.
+//
+// `cli.ts` is the sole host adapter — it wraps process.stdout / raw-mode
+// stdin. The VS Code extension no longer runs a session in-process; it runs
+// the built CLI as the terminal's process (see extension.ts).
+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.RconSession = void 0;
+const commandTreeCrawler_1 = require("./commandTreeCrawler");
+const completionEngine_1 = require("./completionEngine");
+const completionBackend_1 = require("./completionBackend");
+const lineEditor_1 = require("./lineEditor");
+const displaySuggestion_1 = require("./displaySuggestion");
+const rconConnectionManager_1 = require("./rconConnectionManager");
+const logger_1 = require("./logger");
+const historyStore_1 = require("./historyStore");
+const ansi = __importStar(require("./ansi"));
+const prompts_1 = require("@clack/prompts");
+const displayCommandTree_1 = require("./displayCommandTree");
+const unpaginate_1 = require("./unpaginate");
+const pagination_1 = require("./pagination");
+const pager_1 = require("./pager");
+/** Phase labels shown on the command-tree-loading progress bar / logged when `logToFile` is set. */
+function progressPhaseLabel(phase) {
+    switch (phase) {
+        case 'fetching': return 'Fetching commands...';
+        case 'loading': return 'Processing subcommands...';
+        case 'complete': return 'Commands loaded and cached!';
+        case 'cache-hit': return 'Commands loaded from cache!';
+    }
+}
+/** A command response taller than this many lines is treated as a screen-disrupting dump that the next prompt/suggestion render must clear past. */
+const LARGE_OUTPUT_LINE_THRESHOLD = 10;
+/** Commands to remember (in-memory and persisted) when the host doesn't specify a `historySize`. */
+const DEFAULT_HISTORY_SIZE = 100;
+/** Substring the TabComplete plugin's `tabcomplete` help text contains — how `detectAndInitialize` recognizes plugin mode. */
+const TAB_COMPLETE_PROBE_MARKER = 'Returns tab completions for a partial command string';
+class RconSession {
+    logger;
+    sessionHost;
+    connectionManager;
+    lineEditor;
+    serverHost;
+    serverPort;
+    isExecutingCommand = false;
+    commandTree;
+    suggestionDisplay;
+    pluginMode = false;
+    // Whether the detected plugin also exposes the `rcat` unpaginated-output
+    // command (Bukkit-family servers; not Fabric, whose probe finds no `rcat`).
+    supportsUnpaginate = false;
+    // Active output pager, if the last command's output was too tall for the
+    // window. While set, keystrokes route to it (see handleInput).
+    pager = null;
+    engine = (0, completionEngine_1.createMachine)();
+    rconBackend;
+    localBackend;
+    get completionBackend() {
+        const inner = this.pluginMode ? this.rconBackend : this.localBackend;
+        const builtinNames = this.builtinCommands.map(c => c.name);
+        return {
+            fetchCompletions: async (line) => {
+                if (line.startsWith('.')) {
+                    return builtinNames.filter(n => n.startsWith(line));
+                }
+                return inner.fetchCompletions(line);
+            },
+            fetchUsage: async (line) => {
+                if (line.startsWith('.')) {
+                    return '';
+                }
+                return inner.fetchUsage(line);
+            },
+        };
+    }
+    lastCommandOutputLines = 0;
+    historyStore;
+    historySearch = null;
+    historySearchLabel = '(reverse-i-search): ';
+    constructor(controller, host, port, password, logger, sessionHost, controllerFactory) {
+        this.logger = logger;
+        this.sessionHost = sessionHost;
+        this.serverHost = host;
+        this.serverPort = port;
+        const historySize = sessionHost.historySize ?? DEFAULT_HISTORY_SIZE;
+        this.connectionManager = new rconConnectionManager_1.RconConnectionManager(host, port, password, logger, controller, {
+            write: (text) => sessionHost.write(text),
+            showPrompt: () => this.showPrompt(),
+            onReconnected: () => this.initializeCommands(),
+        }, controllerFactory);
+        this.commandTree = new commandTreeCrawler_1.CommandTreeCrawler((cmd) => this.connectionManager.controller.send(cmd), logger, sessionHost.cacheDir, host, port);
+        this.rconBackend = new completionBackend_1.RconCompletionBackend(() => this.connectionManager.controller);
+        this.localBackend = new completionBackend_1.LocalCompletionBackend(this.commandTree);
+        this.suggestionDisplay = new displaySuggestion_1.SuggestionDisplay({
+            write: (text) => sessionHost.write(text),
+            cursorColumn: () => {
+                // Visual width of the prompt (ANSI codes stripped) plus cursor position
+                // within the typed text — gives the cursor's offset from the start of
+                // the prompt. When that exceeds the terminal width, the line has
+                // wrapped onto a later row, so reduce it mod the column count to get
+                // the cursor's actual column on that row.
+                const terminalWidth = this.sessionHost.dimensions()?.columns;
+                if (this.historySearch) {
+                    const column = this.historySearchLabel.length + this.historySearch.query.length;
+                    return terminalWidth ? column % terminalWidth : column;
+                }
+                const promptWidth = ansi.stripAnsi(this.promptText()).length;
+                const column = promptWidth + this.lineEditor.cursor;
+                return terminalWidth ? column % terminalWidth : column;
+            },
+        });
+        this.lineEditor = new lineEditor_1.LineEditor({
+            write: (text) => sessionHost.write(text),
+            promptText: () => this.promptText(),
+            onLineChanged: (line) => this.dispatchToEngine({ kind: 'lineChanged', line }),
+            beforeLineCleared: () => this.suggestionDisplay.clear(),
+            consumeOutputArtifacts: () => {
+                if (this.lastCommandOutputLines > LARGE_OUTPUT_LINE_THRESHOLD) {
+                    this.lastCommandOutputLines = 0;
+                    return true;
+                }
+                return false;
+            },
+        }, historySize);
+        this.historyStore = new historyStore_1.HistoryStore(sessionHost.cacheDir, host, port, logger, historySize);
+        this.lineEditor.loadHistory(this.historyStore.load());
+        this.keyHandlers = this.buildKeyHandlers();
+        this.builtinCommands = this.buildBuiltinCommands();
+        this.builtinLookup = new Map(this.builtinCommands.flatMap(cmd => [cmd.name, ...(cmd.aliases ?? [])].map(name => [name, cmd])));
+    }
+    open() {
+        this.writeWelcomeBanner();
+        this.detectAndInitialize();
+    }
+    writeWelcomeBanner() {
+        this.sessionHost.write(ansi.boldCyan('Minercon Terminal') + '\r\n');
+        this.sessionHost.write('Connected to ' + ansi.yellow(this.serverHost + ':' + this.serverPort) + '\r\n\r\n');
+        this.sessionHost.write(ansi.dim('Useful shortcuts:') + '\r\n');
+        this.sessionHost.write('  ' + ansi.dim('Tab: Autocomplete commands  |  Type ') + ansi.yellow('.help') + ansi.dim(' for built-in commands') + '\r\n');
+        this.sessionHost.write('  ' + ansi.dim('Ctrl+L: Clear screen  |  Ctrl+C: Cancel input') + '\r\n');
+        this.sessionHost.write('  ' + ansi.dim('Up/Down: Command history  |  Ctrl+R: Search history  |  Esc: Clear line') + '\r\n\r\n');
+    }
+    async detectAndInitialize() {
+        if (this.sessionHost.disablePlugin) {
+            this.sessionHost.write('\r\n' + ansi.yellow('Server tab-complete plugin probe disabled — using local completions') + '\r\n\r\n');
+            await this.initializeCommands();
+            return;
+        }
+        try {
+            const response = await this.connectionManager.controller.send('tabcomplete');
+            if (response && response.includes(TAB_COMPLETE_PROBE_MARKER)) {
+                this.pluginMode = true;
+                this.commandTree.isReady = true;
+                this.sessionHost.write('\r\n' + ansi.green('✓ Server tab-complete plugin detected — using server-side completions') + '\r\n\r\n');
+                await this.probeUnpaginateSupport();
+                this.showPrompt();
+                return;
+            }
+        }
+        catch {
+            // probe failed, fall through to normal init
+        }
+        await this.initializeCommands();
+    }
+    /**
+     * One-shot probe for the plugin's `rcat` command (sent with no args, it
+     * echoes RCAT_PROBE_MARKER). Distinct from the `tabcomplete` probe so an
+     * older plugin jar — or the Fabric mod, which has no `rcat` — leaves
+     * `supportsUnpaginate` false and the client never wraps. Failures are
+     * swallowed: de-pagination simply stays off.
+     */
+    async probeUnpaginateSupport() {
+        if (this.sessionHost.unpaginateOutput === false) {
+            return;
+        }
+        try {
+            const response = await this.connectionManager.controller.send('rcat');
+            this.supportsUnpaginate = (0, unpaginate_1.responseSupportsRcat)(response);
+        }
+        catch {
+            this.supportsUnpaginate = false;
+        }
+    }
+    async initializeCommands(forceRefresh = false) {
+        const cacheInfo = this.commandTree.getCacheInfo();
+        const willLoadFromCache = !forceRefresh && cacheInfo.exists;
+        const reason = forceRefresh ? 'Forcing refresh...' :
+            !cacheInfo.exists ? 'No cache found...' :
+                'Cache outdated...';
+        // Three progress-reporting strategies for the same underlying crawl,
+        // chosen by host/cache state: log lines (file logging), a one-shot cache
+        // notice, or a live clack progress bar for a fresh crawl.
+        if (this.sessionHost.logToFile) {
+            await this.loadCommandsLogged(willLoadFromCache, reason, forceRefresh);
+        }
+        else if (willLoadFromCache) {
+            await this.loadCommandsFromCache(forceRefresh);
+        }
+        else {
+            await this.loadCommandsWithProgressBar(reason, forceRefresh);
+        }
+    }
+    /** Command-tree load for the file-logging host: narrate progress through the logger rather than a progress bar. */
+    async loadCommandsLogged(willLoadFromCache, reason, forceRefresh) {
+        if (!willLoadFromCache) {
+            this.logger.info(`Loading server commands (${reason})`);
+        }
+        try {
+            await this.commandTree.initialize((progressPct, phase) => {
+                if (willLoadFromCache) {
+                    if (progressPct >= 100) {
+                        this.logger.success('Commands loaded from cache!');
+                        this.showPrompt();
+                    }
+                    return;
+                }
+                this.logger.info(`${progressPhaseLabel(phase)} (${Math.round(progressPct)}%)`);
+                if (progressPct >= 100) {
+                    this.logger.success('Commands loaded and cached!');
+                    this.showPrompt();
+                }
+            }, undefined, forceRefresh);
+        }
+        catch (error) {
+            this.logger.error(`Failed to load commands: ${error}`);
+            this.logger.warn('Autocomplete will be limited.');
+            this.showPrompt();
+        }
+    }
+    /**
+     * Command-tree load on a cache hit (terminal host): resolves in a single
+     * synchronous step, so skip the progress bar entirely (and the raw-mode
+     * dance its start/stop incurs).
+     */
+    async loadCommandsFromCache(forceRefresh) {
+        try {
+            await this.commandTree.initialize((progressPct) => {
+                if (progressPct >= 100) {
+                    this.sessionHost.write(ansi.green('✓ Commands loaded from cache!') + '\r\n\r\n');
+                    this.showPrompt();
+                }
+            }, undefined, forceRefresh);
+        }
+        catch (error) {
+            this.sessionHost.write(ansi.red(`✗ Failed to load commands: ${error}`) + '\r\n');
+            this.sessionHost.write(ansi.yellow('Autocomplete will be limited.') + '\r\n\r\n');
+            this.showPrompt();
+        }
+    }
+    /** Command-tree load for a fresh crawl (terminal host): a clack progress bar narrating phases and per-command messages. */
+    async loadCommandsWithProgressBar(reason, forceRefresh) {
+        const bar = (0, prompts_1.progress)({ style: 'block' });
+        bar.start(`Loading server commands (${reason})`);
+        let lastProgress = 0;
+        // clack's progress bar, on stop/error, closes the readline interface it
+        // created over stdin — which pauses stdin and puts it back into cooked
+        // mode. Undo both so the REPL keeps reading input a keystroke at a time.
+        const restoreStdin = () => {
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+        };
+        try {
+            await this.commandTree.initialize((progressPct, phase) => {
+                // During 'loading', leave the message alone — `onMessage` (below)
+                // narrates per-command progress there, and immediately overwriting
+                // it with the phase label would make that narration flash by unseen.
+                if (phase === 'loading') {
+                    bar.advance(progressPct - lastProgress);
+                }
+                else {
+                    bar.advance(progressPct - lastProgress, progressPhaseLabel(phase));
+                }
+                lastProgress = progressPct;
+                if (progressPct >= 100) {
+                    bar.stop('Commands loaded and cached!');
+                    restoreStdin();
+                    this.showPrompt();
+                }
+            }, (message) => bar.message(message), forceRefresh);
+        }
+        catch (error) {
+            bar.error(`Failed to load commands: ${error}`);
+            restoreStdin();
+            this.showPrompt();
+        }
+    }
+    close() {
+        this.connectionManager.dispose();
+    }
+    /** The current colored prompt string — the single source of truth for what the prompt looks like in each connection state. */
+    promptText() {
+        if (this.connectionManager.isReconnecting) {
+            return ansi.yellow('[reconnecting]') + ' > ';
+        }
+        if (!this.connectionManager.isConnected) {
+            return ansi.red('[disconnected]') + ' > ';
+        }
+        return ansi.green('>') + ' ';
+    }
+    showPrompt() {
+        if (this.isExecutingCommand) {
+            return;
+        }
+        this.sessionHost.write(this.promptText());
+    }
+    keyHandlers;
+    buildKeyHandlers() {
+        const bindings = [
+            { sequences: ['\t'], handler: () => this.handleTabComplete() },
+            { sequences: ['\x1b[Z'], handler: () => this.handleShiftTab() },
+            { sequences: ['\x1b'], handler: () => this.handleEscape() },
+            { sequences: ['\x04'], handler: () => this.handleCtrlD() },
+            { sequences: ['\x03'], handler: () => this.handleCtrlC() },
+            { sequences: ['\x18'], handler: () => this.handleCut() },
+            { sequences: ['\x16', '\x19'], handler: () => this.handlePaste() },
+            { sequences: ['\x0c'], handler: () => this.handleClearScreen() },
+            { sequences: ['\x12'], handler: () => this.startHistorySearch() },
+            { sequences: ['\x1b[A', '\x10'], handler: () => this.handleHistoryOrSuggestionArrow('up') },
+            { sequences: ['\x1b[B', '\x0e'], handler: () => this.handleHistoryOrSuggestionArrow('down') },
+            { sequences: ['\x1b[5~'], handler: () => this.handlePagePrevious() },
+            { sequences: ['\x1b[6~'], handler: () => this.handlePageNext() },
+            { sequences: ['\x1b[1;2D'], handler: () => this.lineEditor.selectLeft() },
+            { sequences: ['\x1b[1;2C'], handler: () => this.lineEditor.selectRight() },
+            { sequences: ['\x1b[1;5D', '\x1b[5D', '\x1bb'], handler: () => this.lineEditor.moveWordLeft() },
+            { sequences: ['\x1b[1;5C', '\x1b[5C', '\x1bf'], handler: () => this.lineEditor.moveWordRight() },
+            { sequences: ['\x1b[1;6D'], handler: () => this.lineEditor.selectWordLeft() },
+            { sequences: ['\x1b[1;6C'], handler: () => this.lineEditor.selectWordRight() },
+            { sequences: ['\x1b[1;2H', '\x1b[1;2~'], handler: () => this.lineEditor.selectToStart() },
+            { sequences: ['\x1b[1;2F', '\x1b[1;2$'], handler: () => this.lineEditor.selectToEnd() },
+            { sequences: ['\x1b[D', '\x02'], handler: () => this.lineEditor.moveLeft() },
+            { sequences: ['\x1b[C', '\x06'], handler: () => this.lineEditor.moveRight() },
+            { sequences: ['\x1b[H', '\x1bOH', '\x1b[1~', '\x01'], handler: () => this.lineEditor.moveToStart() },
+            { sequences: ['\x1b[F', '\x1bOF', '\x1b[4~', '\x05'], handler: () => this.lineEditor.moveToEnd() },
+            { sequences: ['\x1b[3~'], handler: () => this.lineEditor.deleteForward() },
+            { sequences: ['\x0b'], handler: () => this.killAndStash(() => this.lineEditor.killToEnd()) },
+            { sequences: ['\x15'], handler: () => this.killAndStash(() => this.lineEditor.killToStart()) },
+            { sequences: ['\x17', '\x1b\x7f', '\x1b\b'], handler: () => this.killAndStash(() => this.lineEditor.killWordBack()) },
+            { sequences: ['\x1bd'], handler: () => this.killAndStash(() => this.lineEditor.killWordForward()) },
+            { sequences: ['\x14'], handler: () => this.lineEditor.transposeChars() },
+            { sequences: ['\r', '\n'], handler: () => this.handleEnter() },
+            { sequences: ['\x7f', '\b'], handler: () => this.lineEditor.handleBackspace() },
+        ];
+        const map = new Map();
+        for (const { sequences, handler } of bindings) {
+            for (const seq of sequences) {
+                map.set(seq, handler);
+            }
+        }
+        return map;
+    }
+    killAndStash(fn) {
+        const text = fn();
+        if (text) {
+            this.sessionHost.clipboard.writeText(text);
+        }
+    }
+    handleInput(data) {
+        // The pager is a post-output interaction, active *after* a command has
+        // finished (isExecutingCommand is already false), so it's handled before
+        // that guard rather than gated by it.
+        if (this.pager) {
+            this.pager.handleKey(data);
+            return;
+        }
+        if (this.isExecutingCommand) {
+            return;
+        }
+        if (this.historySearch) {
+            this.handleHistorySearchInput(data);
+            return;
+        }
+        const handler = this.keyHandlers.get(data);
+        if (handler) {
+            handler();
+            return;
+        }
+        if (data.charCodeAt(0) < 32 && data !== '\t') {
+            return;
+        }
+        this.lineEditor.insertText(data);
+    }
+    handleEscape() {
+        if (this.suggestionDisplay.isShowing) {
+            this.dispatchToEngine({ kind: 'escape' });
+            return;
+        }
+        this.lineEditor.clearAndReset();
+        this.showPrompt();
+    }
+    handleCtrlD() {
+        if (this.lineEditor.line.length > 0) {
+            this.lineEditor.deleteForward();
+            return;
+        }
+        this.sessionHost.write('^D\r\n');
+        this.sessionHost.write('Disconnecting...\r\n');
+        this.sessionHost.close(0);
+    }
+    handleCtrlC() {
+        if (this.lineEditor.hasSelection()) {
+            this.sessionHost.clipboard.writeText(this.lineEditor.getSelectedText());
+            this.lineEditor.clearSelection();
+            this.lineEditor.redraw();
+        }
+        else if (this.lineEditor.line.length > 0) {
+            this.sessionHost.write('^C\r\n');
+            this.lineEditor.clearAndReset();
+            this.showPrompt();
+        }
+    }
+    handleCut() {
+        if (!this.lineEditor.hasSelection()) {
+            return;
+        }
+        this.sessionHost.clipboard.writeText(this.lineEditor.getSelectedText());
+        this.lineEditor.deleteSelection();
+        this.lineEditor.redraw();
+    }
+    handlePaste() {
+        this.sessionHost.clipboard.readText().then(text => {
+            if (text) {
+                this.lineEditor.insertText(text);
+            }
+        });
+    }
+    handleClearScreen() {
+        this.sessionHost.write('\x1b[2J\x1b[H');
+        this.showPrompt();
+        this.sessionHost.write(this.lineEditor.line);
+        if (this.lineEditor.cursor < this.lineEditor.line.length) {
+            const moveBack = this.lineEditor.line.length - this.lineEditor.cursor;
+            this.sessionHost.write('\x1b[' + moveBack + 'D');
+        }
+    }
+    handleHistoryOrSuggestionArrow(direction) {
+        if (this.suggestionDisplay.isShowing) {
+            this.dispatchToEngine({ kind: 'arrow', direction });
+            return;
+        }
+        if (this.lineEditor.hasSelection()) {
+            this.lineEditor.clearSelection();
+            this.lineEditor.redraw();
+        }
+        this.lineEditor.navigateHistory(direction);
+    }
+    // ── Ctrl+R: reverse history search ──
+    //
+    // While active, keystrokes edit the search query (not the line) and the
+    // matching history entries are shown in the same popup tab-completion uses
+    // (SuggestionDisplay), most-recently-used first. handleInput routes
+    // everything here instead of through keyHandlers until the search ends.
+    startHistorySearch() {
+        if (this.suggestionDisplay.isShowing) {
+            this.dispatchToEngine({ kind: 'escape' });
+        }
+        this.historySearch = (0, historyStore_1.startHistorySearch)(this.lineEditor.historyEntries, this.lineEditor.line);
+        this.renderHistorySearch();
+    }
+    handleHistorySearchInput(data) {
+        switch (data) {
+            case '\x12': // Ctrl+R again: cycle to the next-older match
+            case '\t': // Tab: cycle to the next-older match
+                this.cycleHistorySearch(1);
+                return;
+            case '\x1b[A':
+            case '\x10': // Up / Ctrl+P: move visual selection up (newer)
+                this.cycleHistorySearch(-1);
+                return;
+            case '\x1b[B':
+            case '\x0e': // Down / Ctrl+N: move visual selection down (older)
+                this.cycleHistorySearch(1);
+                return;
+            case '\x1b[Z': // Shift-Tab: cycle to the next-newer match
+                this.cycleHistorySearch(-1);
+                return;
+            case '\x1b':
+            case '\x07':
+            case '\x03': // Escape / Ctrl+G / Ctrl+C: cancel
+                this.cancelHistorySearch();
+                return;
+            case '\r':
+            case '\n': // Enter: load the match for further editing
+                this.acceptHistorySearch();
+                return;
+            case '\x7f':
+            case '\b': // Backspace: shrink the query
+                this.setHistorySearchQuery(this.historySearch.query.slice(0, -1));
+                return;
+            default:
+                if (data.charCodeAt(0) >= 32) {
+                    this.setHistorySearchQuery(this.historySearch.query + data);
+                }
+                return;
+        }
+    }
+    setHistorySearchQuery(query) {
+        this.historySearch = (0, historyStore_1.setHistorySearchQuery)(this.lineEditor.historyEntries, this.historySearch, query);
+        this.renderHistorySearch();
+    }
+    cycleHistorySearch(delta) {
+        this.historySearch = (0, historyStore_1.cycleHistorySearch)(this.historySearch, delta);
+        this.renderHistorySearch();
+    }
+    acceptHistorySearch() {
+        const search = this.historySearch;
+        const selected = search.items[search.selectedIndex] ?? search.originalLine;
+        this.suggestionDisplay.hide();
+        this.historySearch = null;
+        this.lineEditor.replaceLine(selected);
+    }
+    cancelHistorySearch() {
+        const search = this.historySearch;
+        this.suggestionDisplay.hide();
+        this.historySearch = null;
+        this.lineEditor.replaceLine(search.originalLine);
+    }
+    renderHistorySearch() {
+        const search = this.historySearch;
+        this.sessionHost.write('\r\x1b[K');
+        this.sessionHost.write(ansi.cyan(this.historySearchLabel) + search.query);
+        this.suggestionDisplay.render(search.items, search.selectedIndex, null, '');
+    }
+    handlePagePrevious() {
+        const i = this.suggestionDisplay.previousPageIndex();
+        if (i !== null) {
+            this.dispatchToEngine({ kind: 'selectIndex', index: i });
+        }
+    }
+    handlePageNext() {
+        const i = this.suggestionDisplay.nextPageIndex();
+        if (i !== null) {
+            this.dispatchToEngine({ kind: 'selectIndex', index: i });
+        }
+    }
+    dispatchToEngine(event) {
+        const { machine, effects } = (0, completionEngine_1.step)(this.engine, event);
+        this.engine = machine;
+        for (const effect of effects) {
+            this.executeEngineEffect(effect);
+        }
+    }
+    executeEngineEffect(effect) {
+        switch (effect.kind) {
+            case 'fetchCompletions':
+                this.runEngineCompletionsFetch(effect.requestId);
+                break;
+            case 'fetchUsage':
+                this.runEngineUsageFetch(effect.requestId);
+                break;
+            case 'applySuggestion': {
+                const query = this.engine.phase.kind === 'open' ? this.engine.phase.query : this.lineEditor.line;
+                this.applySuggestionText(query, effect.text);
+                break;
+            }
+            case 'render':
+                this.suggestionDisplay.render(effect.items, effect.selectedIndex, effect.usage, this.lineEditor.line);
+                break;
+            case 'hide':
+                this.suggestionDisplay.hide();
+                break;
+            case 'restoreLine':
+                this.lineEditor.replaceLine(effect.text);
+                break;
+        }
+    }
+    /** The input line the current in-flight fetch is resolving for (or the live line if somehow idle). */
+    fetchLine() {
+        return this.engine.fetch.kind === 'busy' ? this.engine.fetch.forLine : this.lineEditor.line;
+    }
+    /** Await `p`, falling back to `fallback` if it rejects — a failed fetch is just "no result". */
+    async settleOr(p, fallback) {
+        try {
+            return await p;
+        }
+        catch {
+            return fallback;
+        }
+    }
+    async runEngineCompletionsFetch(requestId) {
+        const items = await this.settleOr(this.completionBackend.fetchCompletions(this.fetchLine()), []);
+        this.dispatchToEngine({ kind: 'completionsResult', requestId, items });
+    }
+    async runEngineUsageFetch(requestId) {
+        const text = await this.settleOr(this.completionBackend.fetchUsage(this.fetchLine()), '');
+        this.dispatchToEngine({ kind: 'usageResult', requestId, text });
+    }
+    applySuggestionText(query, suggestionText) {
+        this.lineEditor.replaceLine((0, completionEngine_1.applySuggestion)(query, suggestionText));
+    }
+    handleTabComplete() {
+        this.dispatchToEngine({ kind: 'tab', line: this.lineEditor.line });
+    }
+    handleShiftTab() {
+        this.dispatchToEngine({ kind: 'shiftTab', line: this.lineEditor.line });
+    }
+    handleEnter() {
+        if (this.suggestionDisplay.isShowing) {
+            this.suggestionDisplay.hide();
+        }
+        this.suggestionDisplay.clear();
+        this.sessionHost.write('\r\n');
+        const command = this.lineEditor.line.trim();
+        this.lineEditor.resetLine();
+        this.lineEditor.resetHistoryCursor();
+        this.dispatchToEngine({ kind: 'lineChanged', line: '' });
+        if (command) {
+            // Record every command, including minercon's own built-ins, so they're
+            // recallable via Up/Ctrl+R and listed by .history — just like a shell's
+            // history includes "history" itself. .history is the one exception:
+            // it's recorded after displaying, so its own listing reflects the
+            // history *before* this invocation, not including itself.
+            if (command !== '.history') {
+                this.lineEditor.pushHistory(command);
+                this.historyStore.save(this.lineEditor.historyEntries);
+            }
+            const spaceIdx = command.indexOf(' ');
+            const cmdName = spaceIdx === -1 ? command : command.slice(0, spaceIdx);
+            const cmdArgs = spaceIdx === -1 ? '' : command.slice(spaceIdx + 1).trim();
+            const builtin = this.builtinLookup.get(cmdName);
+            if (builtin) {
+                builtin.run(cmdArgs);
+            }
+            else {
+                this.executeCommand(command);
+            }
+        }
+        else {
+            this.showPrompt();
+        }
+    }
+    // ── built-in `.` commands ──
+    //
+    // One table drives both dispatch (handleEnter → builtinLookup) and the
+    // command list .help prints — adding a command here is the whole job.
+    // Same lookup-table pattern as buildKeyHandlers; like there, the run()
+    // closures resolve collaborators lazily at call time.
+    builtinCommands;
+    builtinLookup;
+    buildBuiltinCommands() {
+        /** Writes the "this is plugin mode, there's no local cache" notice — shared by every cache-related command. */
+        const pluginModeNotice = (text) => {
+            this.sessionHost.write(ansi.yellow(text) + '\r\n\r\n');
+            this.showPrompt();
+        };
+        return [
+            {
+                name: '.help', description: 'Show this help message',
+                run: (_) => this.showHelp(),
+            },
+            {
+                name: '.clear', description: 'Clear the terminal screen',
+                run: (_) => {
+                    this.sessionHost.write('\x1b[2J\x1b[H');
+                    this.showPrompt();
+                },
+            },
+            {
+                name: '.history', description: 'Show command history',
+                run: (_) => {
+                    this.showHistory();
+                    this.lineEditor.pushHistory('.history');
+                    this.historyStore.save(this.lineEditor.historyEntries);
+                },
+            },
+            {
+                name: '.reconnect', description: 'Reconnect to the server',
+                run: (_) => { this.connectionManager.manualReconnect(); },
+            },
+            {
+                name: '.disconnect', description: 'Disconnect from the server',
+                run: (_) => this.connectionManager.disconnect(),
+            },
+            {
+                name: '.reload-commands', description: 'Force reload command database from server',
+                aliases: ['.refresh-commands'],
+                run: (_) => {
+                    if (this.pluginMode) {
+                        pluginModeNotice('Using server-side tab completion — no command cache to reload.');
+                    }
+                    else {
+                        this.initializeCommands(true);
+                    }
+                },
+            },
+            {
+                name: '.clear-cache', description: 'Clear cached command database',
+                run: (_) => {
+                    if (this.pluginMode) {
+                        pluginModeNotice('Using server-side tab completion — no cache.');
+                    }
+                    else {
+                        this.commandTree.clearCache();
+                        this.sessionHost.write(ansi.yellow('Command cache cleared.') + '\r\n\r\n');
+                        this.showPrompt();
+                    }
+                },
+            },
+            {
+                name: '.cache-info', description: 'Show command cache information',
+                run: (_) => {
+                    if (this.pluginMode) {
+                        pluginModeNotice('Using server-side tab completion — no cache.');
+                        return;
+                    }
+                    const info = this.commandTree.getCacheInfo();
+                    if (info.exists) {
+                        this.sessionHost.write(ansi.cyan('Cache Status:') + '\r\n');
+                        this.sessionHost.write('  Age: ' + info.age + '\r\n');
+                        this.sessionHost.write('  Last updated: ' + info.lastUpdated?.toLocaleString() + '\r\n\r\n');
+                    }
+                    else {
+                        this.sessionHost.write(ansi.yellow('No cache found.') + '\r\n\r\n');
+                    }
+                    this.showPrompt();
+                },
+            },
+            {
+                name: '.tree', description: 'Print command tree. Usage: .tree [<command>]',
+                run: (args) => {
+                    if (this.pluginMode) {
+                        pluginModeNotice('Using server-side tab completion — no local command tree.');
+                        return;
+                    }
+                    if (!this.commandTree.isReady) {
+                        this.sessionHost.write(ansi.yellow('Command tree not yet loaded.') + '\r\n\r\n');
+                        this.showPrompt();
+                        return;
+                    }
+                    const cmdArg = args.trim() || undefined;
+                    const output = (0, displayCommandTree_1.formatCommandTree)(this.commandTree.commands, cmdArg);
+                    output.split('\n').forEach(line => this.sessionHost.write(line + '\r\n'));
+                    if (cmdArg) {
+                        const name = cmdArg.startsWith('/') ? cmdArg.slice(1) : cmdArg;
+                        const logOutput = (0, displayCommandTree_1.formatCommandLog)(this.commandTree.getCommandLog(name));
+                        if (logOutput) {
+                            logOutput.split('\n').forEach(line => this.sessionHost.write(line + '\r\n'));
+                        }
+                    }
+                    this.showPrompt();
+                },
+            },
+        ];
+    }
+    showHistory() {
+        const entries = this.lineEditor.historyEntries;
+        if (entries.length === 0) {
+            this.sessionHost.write(ansi.gray('(no history yet)') + '\r\n');
+        }
+        else {
+            const width = String(entries.length).length;
+            entries.forEach((entry, index) => {
+                const number = String(index + 1).padStart(width, ' ');
+                this.sessionHost.write(ansi.gray(number) + '  ' + entry + '\r\n');
+            });
+        }
+        this.showPrompt();
+    }
+    showHelp() {
+        this.sessionHost.write(ansi.boldCyan('Built-in Commands:') + '\r\n');
+        for (const { name, description } of this.builtinCommands) {
+            this.sessionHost.write('  ' + ansi.yellow(name) + ' - ' + description + '\r\n');
+        }
+        this.sessionHost.write('\r\n');
+        this.sessionHost.write(ansi.boldCyan('Keyboard Shortcuts:') + '\r\n');
+        this.sessionHost.write('  ' + ansi.dim('Tab - Autocomplete commands and cycle suggestions') + '\r\n');
+        this.sessionHost.write('  ' + ansi.dim('Up/Down or Ctrl+P/Ctrl+N - Navigate command history') + '\r\n');
+        this.sessionHost.write('  ' + ansi.dim('Ctrl+R - Reverse search command history') + '\r\n');
+        this.sessionHost.write('  ' + ansi.dim('Ctrl+A/Ctrl+E - Start/end of line  |  Ctrl+B/Ctrl+F - Move by character') + '\r\n');
+        this.sessionHost.write('  ' + ansi.dim('Alt+B/Alt+F - Move by word  |  Ctrl+T - Transpose characters') + '\r\n');
+        this.sessionHost.write('  ' + ansi.dim('Ctrl+K - Kill to end of line  |  Ctrl+U - Kill to start of line') + '\r\n');
+        this.sessionHost.write('  ' + ansi.dim('Ctrl+W/Alt+Backspace - Delete word back  |  Alt+D - Delete word forward') + '\r\n');
+        this.sessionHost.write('  ' + ansi.dim('Ctrl+Y - Yank  |  Ctrl+L - Clear screen  |  Esc - Clear current line') + '\r\n');
+        this.sessionHost.write('  ' + ansi.dim('Ctrl+C - Cancel input  |  Ctrl+D - Disconnect') + '\r\n');
+        this.sessionHost.write('\r\n');
+        this.showPrompt();
+    }
+    async executeCommand(command) {
+        if (this.connectionManager.isReconnecting) {
+            this.sessionHost.write(ansi.yellow('Reconnecting... Please wait.') + '\r\n\r\n');
+            this.showPrompt();
+            return;
+        }
+        if (!this.connectionManager.isConnected) {
+            this.sessionHost.write(ansi.red('Not connected. Type ' + ansi.yellow('.reconnect') + ' to reconnect.') + '\r\n\r\n');
+            this.showPrompt();
+            return;
+        }
+        this.isExecutingCommand = true;
+        let outputLineCount = 0;
+        try {
+            // In plugin mode, route the command through the server-side `rcat`
+            // de-pagination helper so its output comes back unpaginated in one
+            // response (no-op unless the plugin supports it and the toggle is on).
+            const unpaginateActive = this.pluginMode && this.supportsUnpaginate && this.sessionHost.unpaginateOutput !== false;
+            const toSend = (0, unpaginate_1.wrapForUnpagination)(command, unpaginateActive);
+            const response = await this.connectionManager.controller.send(toSend);
+            // Some plugins paginate their OWN output (e.g. Multiverse-Core's
+            // "Page X of Y"), returning a single page per call regardless of `rcat`.
+            // When de-pagination is active, recognise that chrome and stitch every
+            // page into one response. Best-effort: any failure falls back to the
+            // single page we already have.
+            let combined = response;
+            if (unpaginateActive && response && response.trim()) {
+                try {
+                    const stitched = await (0, pagination_1.stitchPaginated)(response, command, (pageCommand) => this.connectionManager.controller.send((0, unpaginate_1.wrapForUnpagination)(pageCommand, true)), { log: (message) => this.logger.debug(message) });
+                    if (stitched !== undefined) {
+                        combined = stitched;
+                    }
+                }
+                catch (err) {
+                    this.logger.debug(`pagination stitch failed: ${(0, logger_1.errorMessage)(err)}`);
+                }
+            }
+            if (combined && combined.trim()) {
+                const formatted = ansi.formatMinecraftColors(combined);
+                const lines = formatted.split('\n');
+                outputLineCount = lines.length;
+                const rows = this.sessionHost.dimensions()?.rows ?? pager_1.FALLBACK_ROWS;
+                const shouldPage = this.sessionHost.terminalPager !== false && lines.length > rows - 1;
+                if (shouldPage) {
+                    // The pager prints its own lines, draws/erases its status prompt, and
+                    // restores the prompt itself when the user exits — so we skip the
+                    // trailing newline + showPrompt below (guarded on `this.pager`).
+                    this.startPager(lines);
+                }
+                else {
+                    lines.forEach(line => {
+                        this.sessionHost.write(`${line}\r\n`);
+                    });
+                    this.sessionHost.write('\r\n');
+                    outputLineCount++;
+                }
+            }
+            else {
+                this.sessionHost.write(ansi.dim('(no response)') + '\r\n');
+                outputLineCount = 1;
+                this.sessionHost.write('\r\n');
+                outputLineCount++;
+            }
+        }
+        catch (err) {
+            const message = (0, logger_1.errorMessage)(err);
+            this.sessionHost.write(ansi.red(`Error: ${message}`) + '\r\n');
+            outputLineCount = 1;
+            // Ask the controller whether the connection actually died rather than
+            // sniffing the error text for socket-ish substrings — a slow command's
+            // "Command timeout" used to match 'timeout' and tear down a perfectly
+            // healthy connection.
+            if (!this.connectionManager.controller.isConnected()) {
+                this.sessionHost.write(ansi.yellow('⚠  Connection lost. Auto-reconnecting...') + '\r\n');
+                outputLineCount++;
+                this.connectionManager.reportConnectionLost();
+            }
+            else {
+                this.sessionHost.write('\r\n');
+                outputLineCount++;
+            }
+        }
+        finally {
+            this.lastCommandOutputLines = outputLineCount;
+            if (outputLineCount > LARGE_OUTPUT_LINE_THRESHOLD) {
+                this.suggestionDisplay.markNeedsClearOnNextRender();
+            }
+            this.isExecutingCommand = false;
+            // When paging, the pager owns the prompt — it restores it on exit.
+            if (!this.pager) {
+                this.showPrompt();
+            }
+        }
+    }
+    /** Starts an append-only pager over `lines`; restores the prompt when it exits. */
+    startPager(lines) {
+        this.pager = new pager_1.Pager({ write: (text) => this.sessionHost.write(text), dimensions: () => this.sessionHost.dimensions() }, new pager_1.ArrayLineSource(lines), () => {
+            this.pager = null;
+            this.sessionHost.write('\r\n');
+            this.showPrompt();
+        });
+        this.pager.start();
+    }
+}
+exports.RconSession = RconSession;
+//# sourceMappingURL=rconSession.js.map