minercon 3.0.0

package/out/rconTerminal.js

@@ -0,0 +1,80 @@
+"use strict";
+// src/rconTerminal.ts
+//
+// Thin vscode.Pseudoterminal adapter over RconSession. All interactive logic
+// lives in RconSession (rconSession.ts); this file is just the VS Code glue:
+// EventEmitters, clipboard, extension context, and Pseudoterminal forwarding.
+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.RconTerminal = void 0;
+const vscode = __importStar(require("vscode"));
+const rconSession_1 = require("./rconSession");
+class RconTerminal {
+    writeEmitter = new vscode.EventEmitter();
+    onDidWrite = this.writeEmitter.event;
+    closeEmitter = new vscode.EventEmitter();
+    onDidClose = this.closeEmitter.event;
+    session;
+    dims;
+    constructor(controller, host, port, password, logger, context) {
+        const sessionHost = {
+            write: (text) => this.writeEmitter.fire(text),
+            close: (code) => this.closeEmitter.fire(code),
+            clipboard: {
+                readText: () => Promise.resolve(vscode.env.clipboard.readText()),
+                writeText: (text) => Promise.resolve(vscode.env.clipboard.writeText(text)),
+            },
+            cacheDir: context.globalStorageUri.fsPath,
+            dimensions: () => this.dims ? { columns: this.dims.columns, rows: this.dims.rows } : undefined,
+            historySize: vscode.workspace.getConfiguration('minercon').get('historySize', 100),
+        };
+        this.session = new rconSession_1.RconSession(controller, host, port, password, logger, sessionHost);
+    }
+    open(initialDimensions) {
+        this.dims = initialDimensions;
+        this.session.open();
+    }
+    close() {
+        this.session.close();
+    }
+    handleInput(data) {
+        this.session.handleInput(data);
+    }
+    setDimensions(dimensions) {
+        this.dims = dimensions;
+    }
+}
+exports.RconTerminal = RconTerminal;
+//# sourceMappingURL=rconTerminal.js.map

package/out/suggestionDisplay.js

@@ -0,0 +1,286 @@
+"use strict";
+// src/suggestionDisplay.ts
+//
+// Owns the suggestion-list / argument-hint display: the items, the selected
+// index, paging state, and the ANSI rendering/clearing of whatever's drawn
+// below the prompt. Pulled out of RconTerminal as part of the mega-module
+// split — see lineEditor.ts for the sibling extraction and its rationale.
+//
+// This class has no notion of the completionEngine or of dispatching events —
+// RconSession remains the single place that talks to the engine (it's the
+// one piece deliberately kept pure/central). Callers that need to know
+// *whether* an action makes sense (page forward/back) ask the read-only
+// `...Index()` queries, which return `number | null` — `null` meaning
+// "nothing to do" — and decide for themselves whether to dispatch.
+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.SuggestionDisplay = void 0;
+const argumentHint_1 = require("./argumentHint");
+const ansi = __importStar(require("./ansi"));
+class SuggestionDisplay {
+    host;
+    currentSuggestions = [];
+    suggestionIndex = -1;
+    showing = false;
+    displayLines = 0;
+    // Paging
+    visibleStart = 0;
+    maxVisible = 10;
+    currentPage = 1;
+    needsClearOnNextRender = false;
+    constructor(host) {
+        this.host = host;
+    }
+    get isShowing() {
+        return this.showing;
+    }
+    get itemCount() {
+        return this.currentSuggestions.length;
+    }
+    get totalPages() {
+        return Math.ceil(this.currentSuggestions.length / this.maxVisible);
+    }
+    /** Replaces the direct `needsClearBeforeSuggestions = true` assignment from `executeCommand` — the next render should wipe the screen below the cursor first (e.g. after a multi-line command response may have pushed the display area around). */
+    markNeedsClearOnNextRender() {
+        this.needsClearOnNextRender = true;
+    }
+    nextPageIndex() {
+        if (!this.showing || this.currentSuggestions.length === 0 || this.totalPages <= 1) {
+            return null;
+        }
+        const nextPageStart = this.currentPage * this.maxVisible;
+        return nextPageStart < this.currentSuggestions.length ? nextPageStart : 0;
+    }
+    previousPageIndex() {
+        if (!this.showing || this.currentSuggestions.length === 0 || this.totalPages <= 1) {
+            return null;
+        }
+        return this.currentPage > 1
+            ? (this.currentPage - 2) * this.maxVisible
+            : (this.totalPages - 1) * this.maxVisible;
+    }
+    /**
+     * Sets the displayed items/selection from the engine's `render` effect and
+     * draws the appropriate combination of suggestion list and argument hint —
+     * `usage` is only ever a single, resolved usage line (the engine collapses
+     * "(too broad...)" failures and ambiguous-prefix multi-candidate responses
+     * down to empty), so a non-null `display` here means the command portion is
+     * fully resolved — independent of how many argument-level completions
+     * remain, so it's shown alongside the list whenever available.
+     */
+    render(items, selectedIndex, usage, currentLine) {
+        this.currentSuggestions = items;
+        this.suggestionIndex = selectedIndex;
+        this.clear();
+        const display = usage ? (0, argumentHint_1.formatArgumentHint)(usage, currentLine) : null;
+        let lines = [];
+        if (items.length > 0) {
+            this.showing = true;
+            lines = this.buildSuggestionListLines(currentLine);
+            if (display) {
+                lines = lines.concat(this.buildArgumentHintLines(display));
+            }
+        }
+        else {
+            this.showing = false;
+            if (display) {
+                lines = this.buildArgumentHintLines(display);
+            }
+        }
+        this.renderSuggestionArea(lines);
+    }
+    hide() {
+        this.clear();
+        this.showing = false;
+        this.suggestionIndex = -1;
+        this.currentSuggestions = [];
+        this.visibleStart = 0;
+        this.currentPage = 1;
+    }
+    /** Erases whatever's currently drawn in the display area — the single source of truth for "clear the old frame before drawing (or removing) the new one." */
+    clear() {
+        if (this.displayLines === 0) {
+            return;
+        }
+        this.host.write('\r\n'); // Move to the display area
+        for (let i = 0; i < this.displayLines; i++) {
+            this.host.write('\x1b[2K'); // Clear entire line
+            if (i < this.displayLines - 1) {
+                this.host.write('\r\n');
+            }
+        }
+        // Scroll-safe return: relative cursor-up is correct even when the \r\n
+        // above caused the terminal to scroll (absolute \x1b7/\x1b8 are not).
+        this.host.write(`\x1b[${this.displayLines}A`);
+        this.host.write('\r');
+        const col = this.host.cursorColumn();
+        if (col > 0) {
+            this.host.write(`\x1b[${col}C`);
+        }
+        this.displayLines = 0;
+    }
+    /**
+     * Builds the suggestion list's content lines — fully ANSI-styled, but with
+     * no `\x1b[2K`/`\r\n` baked in. `renderSuggestionArea` is the single place
+     * that turns a list of content strings into clear-and-draw ANSI, whether
+     * it's drawing the list alone, the hint alone, or (when there's exactly one
+     * suggestion left) both stacked together in one frame.
+     */
+    buildSuggestionListLines(currentLine) {
+        // Calculate the visible window based on the selected index
+        this.updateVisibleWindow();
+        const lines = [];
+        // Get only the completed parts of the command (everything before the last space or the whole line if no space)
+        let completedText = '';
+        if (currentLine.includes(' ')) {
+            // If there's a space, get everything up to and including the last space
+            const lastSpaceIndex = currentLine.lastIndexOf(' ');
+            completedText = currentLine.substring(0, lastSpaceIndex + 1);
+        }
+        const prefix = completedText ? ansi.hidden(completedText) : '';
+        // Show indicator if there are items above the visible window
+        if (this.visibleStart > 0) {
+            lines.push(prefix + ansi.gray('  ▲ (' + this.visibleStart + ' more above)'));
+        }
+        // Show visible suggestions in vertical list
+        const visibleEnd = Math.min(this.visibleStart + this.maxVisible, this.currentSuggestions.length);
+        for (let i = this.visibleStart; i < visibleEnd; i++) {
+            // Show selection indicator and item
+            if (i === this.suggestionIndex) {
+                // Yellow for selected item with arrow indicator
+                lines.push(prefix + ansi.brightYellow('→ ' + this.currentSuggestions[i]));
+            }
+            else {
+                // Gray for other items with space for alignment
+                lines.push(prefix + ansi.gray('  ' + this.currentSuggestions[i]));
+            }
+        }
+        // Show indicator if there are items below the visible window
+        if (visibleEnd < this.currentSuggestions.length) {
+            const remaining = this.currentSuggestions.length - visibleEnd;
+            lines.push(prefix + ansi.gray('  ▼ (' + remaining + ' more below)'));
+        }
+        // Show current position and page indicator at bottom
+        lines.push(prefix + ansi.gray('  [' + (this.suggestionIndex + 1) + '/' + this.currentSuggestions.length + '] ' +
+            'Page ' + this.currentPage + '/' + this.totalPages));
+        return lines;
+    }
+    /**
+     * Builds the argument-hint's content lines: the usage line, shown in full
+     * and literally — with the argument the user is currently editing bolded
+     * and everything else (command prefix and other tokens alike) gray. Same
+     * "fully-styled content strings, no \x1b[2K/\r\n" convention as
+     * `buildSuggestionListLines`, so `renderSuggestionArea` can draw either or
+     * both in one frame.
+     *
+     * Shown alongside or in place of the suggestion list when a command has
+     * argument structure worth showing — e.g. "/gamemode creative " (nothing
+     * left to complete for the target selector, but worth showing what comes
+     * next), or "/gamemode cr" (one match left — "creative" — where seeing the
+     * full usage helps confirm that's the right command to commit to). The
+     * actual parsing of `usage`/`line` into positions and hint text is pure —
+     * see argumentHint.ts — this is just the ANSI rendering of that
+     * already-computed structure.
+     */
+    buildArgumentHintLines(display) {
+        let usageLine = '  ' + ansi.gray(display.commandPrefixText);
+        for (let i = 0; i < display.tokens.length; i++) {
+            usageLine += ' ';
+            usageLine += (i === display.currentArgIndex)
+                ? ansi.boldBrightWhite(display.tokens[i])
+                : ansi.gray(display.tokens[i]);
+        }
+        return [usageLine];
+    }
+    /**
+     * Draws a single frame of suggestion-area content — one save/clear/restore
+     * cycle, regardless of whether `lines` came from the list, the hint, or
+     * both stacked together. `clear` (called centrally before this, by `render`)
+     * has already erased whatever was there before, so this only ever draws
+     * onto a blank area — each line gets its own `\x1b[2K` defensively, but
+     * there's no "clear the old N lines" dance to duplicate here.
+     */
+    renderSuggestionArea(lines) {
+        if (lines.length === 0) {
+            return;
+        }
+        if (this.needsClearOnNextRender) {
+            this.host.write('\x1b[J'); // Clear from cursor to end of screen
+            this.needsClearOnNextRender = false;
+        }
+        this.host.write('\r\n'); // Move to the display area
+        for (let i = 0; i < lines.length; i++) {
+            this.host.write('\x1b[2K'); // Clear line first
+            this.host.write(lines[i]);
+            if (i < lines.length - 1) {
+                this.host.write('\r\n');
+            }
+        }
+        this.displayLines = lines.length;
+        // Scroll-safe return: \x1b[N]A (relative up) is correct even when the
+        // \r\n outputs above caused the terminal to scroll. \x1b7/\x1b8 (absolute
+        // save/restore) fail in that case because the saved row is invalidated.
+        this.host.write(`\x1b[${lines.length}A`);
+        this.host.write('\r');
+        const col = this.host.cursorColumn();
+        if (col > 0) {
+            this.host.write(`\x1b[${col}C`);
+        }
+    }
+    updateVisibleWindow() {
+        // Keep a buffer of 2 items above and below the selected item when possible
+        const buffer = 2;
+        // Calculate which page the selected item is on
+        const selectedPage = Math.floor(this.suggestionIndex / this.maxVisible) + 1;
+        // Update current page if it changed
+        if (selectedPage !== this.currentPage) {
+            this.currentPage = selectedPage;
+        }
+        // Update the visible window
+        if (this.suggestionIndex < this.visibleStart + buffer) {
+            // Scrolling up
+            this.visibleStart = Math.max(0, this.suggestionIndex - buffer);
+        }
+        else if (this.suggestionIndex >= this.visibleStart + this.maxVisible - buffer) {
+            // Scrolling down
+            this.visibleStart = Math.min(this.suggestionIndex - this.maxVisible + buffer + 1, Math.max(0, this.currentSuggestions.length - this.maxVisible));
+        }
+        // Final boundary check
+        this.visibleStart = Math.max(0, this.visibleStart);
+        this.visibleStart = Math.min(this.visibleStart, Math.max(0, this.currentSuggestions.length - this.maxVisible));
+    }
+}
+exports.SuggestionDisplay = SuggestionDisplay;
+//# sourceMappingURL=suggestionDisplay.js.map

package/out/terminalOutput.js

@@ -0,0 +1,110 @@
+"use strict";
+// src/terminalOutput.ts
+//
+// Coordinates the CLI's logger output with in-place terminal redraws (the
+// command-loading progress bar, the line editor's prompt, ...). Kept
+// separate from cli.ts (which wires it to process.stdout and argv) so it can
+// be unit-tested without a real TTY.
+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.createTerminalWriter = createTerminalWriter;
+exports.createCliLogger = createCliLogger;
+const ansi = __importStar(require("./ansi"));
+const logger_1 = require("./logger");
+const fs = __importStar(require("fs"));
+// Computed once at module load (not per log line) - see `logLevelRank`.
+const ERROR_RANK = (0, logger_1.logLevelRank)('error');
+const WARNING_RANK = (0, logger_1.logLevelRank)('warning');
+const INFO_RANK = (0, logger_1.logLevelRank)('info');
+const DEBUG_RANK = (0, logger_1.logLevelRank)('debug');
+/** Formats a Date as "HH:MM:SS.mmm" — used to timestamp debug log lines down to the millisecond. */
+function formatTimestamp(d) {
+    const pad = (n, width = 2) => String(n).padStart(width, '0');
+    return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)}`;
+}
+function createTerminalWriter(sink) {
+    let currentLine = '';
+    return {
+        write(text) {
+            sink(text);
+            const lastCr = text.lastIndexOf('\r');
+            currentLine = lastCr === -1 ? currentLine + text : text.slice(lastCr + 1);
+            const lastNl = currentLine.lastIndexOf('\n');
+            if (lastNl !== -1) {
+                currentLine = currentLine.slice(lastNl + 1);
+            }
+        },
+        writeLogLine(line) {
+            if (currentLine) {
+                this.write('\r\x1b[K' + line + currentLine);
+            }
+            else {
+                this.write(line);
+            }
+        },
+    };
+}
+/**
+ * A `Logger` that writes through `terminal` (stdout) or, if `logFile` is
+ * given, appends to that file instead. Messages below `logLevel` (default
+ * "info", so "debug" is suppressed) are dropped entirely. Debug lines are
+ * additionally prefixed with a millisecond-resolution timestamp, since
+ * they're meant for performance investigation.
+ */
+function createCliLogger(terminal, logFile, logLevel = 'info') {
+    const thresholdRank = (0, logger_1.logLevelRank)(logLevel);
+    function write(levelRank, label, color, msg) {
+        if (levelRank < thresholdRank) {
+            return;
+        }
+        const prefix = levelRank === DEBUG_RANK ? `${formatTimestamp(new Date())} ${label}` : label;
+        if (logFile) {
+            // Synchronous append: log lines are infrequent, and a WriteStream's
+            // async open left a window where a write could be queued before the
+            // file existed on disk, racing readers (and CI) that check it back.
+            fs.appendFileSync(logFile, `${prefix} ${msg}\n`);
+        }
+        else {
+            terminal.writeLogLine(`${ansi.style(color, prefix)} ${msg}\n`);
+        }
+    }
+    return {
+        error: (msg) => write(ERROR_RANK, 'ERROR', ansi.RED, msg),
+        warning: (msg) => write(WARNING_RANK, 'WARN', ansi.YELLOW, msg),
+        info: (msg) => write(INFO_RANK, 'INFO', ansi.CYAN, msg),
+        debug: (msg) => write(DEBUG_RANK, 'DEBUG', ansi.GRAY, msg),
+    };
+}
+//# sourceMappingURL=terminalOutput.js.map

package/out/unpaginate.js

@@ -0,0 +1,30 @@
+"use strict";
+// src/unpaginate.ts
+//
+// Client side of the server-side de-pagination feature. When the TabComplete
+// plugin is present *and* exposes the `rcat` command (Bukkit-family servers —
+// not Fabric, which doesn't paginate), the interactive terminal wraps each
+// server-bound command as `rcat <command>` so its output comes back unpaginated
+// in a single response. See docs/UNPAGINATED_OUTPUT.md.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RCAT_PROBE_MARKER = void 0;
+exports.responseSupportsRcat = responseSupportsRcat;
+exports.wrapForUnpagination = wrapForUnpagination;
+/** Line the plugin's `rcat` (no-arg) response emits; used to detect support. */
+exports.RCAT_PROBE_MARKER = 'rcat: returns unpaginated command output';
+/** True iff a probe response indicates the server supports `rcat`. */
+function responseSupportsRcat(response) {
+    return !!response && response.includes(exports.RCAT_PROBE_MARKER);
+}
+/**
+ * Returns the command to actually send: `rcat <command>` when de-pagination is
+ * active, otherwise the command unchanged. Empty/whitespace input is never
+ * wrapped (nothing to run).
+ */
+function wrapForUnpagination(command, supported) {
+    if (!supported || command.trim().length === 0) {
+        return command;
+    }
+    return `rcat ${command}`;
+}
+//# sourceMappingURL=unpaginate.js.map

package/package.json

@@ -0,0 +1,138 @@
+{
+  "name": "minercon",
+  "displayName": "Minercon",
+  "description": "A powerful RCON client for Minecraft servers with advanced fragmentation support",
+  "version": "3.0.0",
+  "author": "xton <thisischriston@gmail.com>",
+  "icon": "images/icon.png",
+  "license": "MIT",
+  "homepage": "https://github.com/xton/minercon",
+  "bugs": {
+    "url": "https://github.com/xton/minercon/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xton/minercon.git"
+  },
+  "keywords": [
+    "minecraft",
+    "rcon",
+    "terminal",
+    "server-admin",
+    "tab-completion",
+    "minecraft-server",
+    "console",
+    "rcon-client"
+  ],
+  "files": [
+    "out/*.js",
+    "out/minercon",
+    "images/icon.png",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "vscode": "^1.95.0",
+    "node": ">=18"
+  },
+  "categories": [
+    "Other"
+  ],
+  "activationEvents": [],
+  "main": "./dist/extension.js",
+  "bin": {
+    "minercon": "out/minercon"
+  },
+  "scripts": {
+    "vscode:prepublish": "npm run compile && node esbuild.js --production",
+    "prepublishOnly": "npm run compile",
+    "compile": "tsc -p ./ && node esbuild.js && node scripts/post-compile.js",
+    "watch": "tsc -w -p ./",
+    "pretest": "npm run compile && npm run lint",
+    "lint": "eslint src",
+    "test": "vscode-test",
+    "test:functional": "npm run compile && mocha --ui tdd --timeout 660000 'out/test/functional/**/*.test.js'",
+    "test:functional:connection": "npm run compile && mocha --ui tdd --timeout 660000 out/test/functional/connection.test.js",
+    "test:functional:local": "npm run compile && mocha --ui tdd --timeout 660000 out/test/functional/localMode.test.js",
+    "test:functional:plugin": "npm run compile && mocha --ui tdd --timeout 660000 out/test/functional/pluginMode.test.js",
+    "record-rcon-fixtures": "npm run compile && node out/test/recordRconFixtures.js"
+  },
+  "devDependencies": {
+    "@types/mocha": "^10.0.10",
+    "@types/node": "22.x",
+    "@types/vscode": "^1.95.0",
+    "@typescript-eslint/eslint-plugin": "^8.42.0",
+    "@typescript-eslint/parser": "^8.42.0",
+    "@vscode/test-cli": "^0.0.11",
+    "@vscode/test-electron": "^2.5.2",
+    "@xterm/headless": "^6.0.0",
+    "esbuild": "^0.28.1",
+    "eslint": "^9.34.0",
+    "testcontainers": "^12.0.1",
+    "typescript": "^5.9.2"
+  },
+  "contributes": {
+    "commands": [
+      {
+        "command": "minercon.connect",
+        "title": "Minercon: Connect to Server",
+        "category": "Minercon",
+        "icon": "$(terminal)"
+      },
+      {
+        "command": "minercon.connectNew",
+        "title": "Minercon: Connect with New Credentials",
+        "category": "Minercon",
+        "icon": "$(terminal)"
+      },
+      {
+        "command": "minercon.saveDefaults",
+        "title": "Minercon: Save Current Connection as Default",
+        "category": "Minercon",
+        "icon": "$(terminal)"
+      }
+    ],
+    "terminal": {
+      "profiles": [
+        {
+          "id": "minercon.terminal",
+          "title": "Minecraft Server"
+        }
+      ]
+    },
+    "configuration": {
+      "title": "Minercon",
+      "properties": {
+        "minercon.defaultHost": {
+          "type": "string",
+          "default": "",
+          "description": "Default RCON host address"
+        },
+        "minercon.defaultPort": {
+          "type": "number",
+          "default": null,
+          "description": "Default RCON port"
+        },
+        "minercon.historySize": {
+          "type": "number",
+          "default": 100,
+          "minimum": 1,
+          "description": "Number of commands to remember in history (in-memory and persisted to disk)"
+        },
+        "minercon.unpaginateOutput": {
+          "type": "boolean",
+          "default": true,
+          "description": "When the server tab-complete plugin is installed, request full unpaginated output for commands (e.g. /help) instead of the server's small pages. No effect on servers without the plugin."
+        },
+        "minercon.terminalPager": {
+          "type": "boolean",
+          "default": true,
+          "description": "Page command output taller than the terminal window through a built-in pager (Space: more, G: all, q: quit). When off, tall output is printed all at once."
+        }
+      }
+    }
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.5.1",
+    "consola": "^3.4.2"
+  }
+}