@woopsy/mcpanel 1.0.0

package/dist/utils/colors.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.failure = exports.info = exports.warning = exports.success = exports.bgCyan = exports.bgBlue = exports.bgGreen = exports.bgRed = exports.gray = exports.white = exports.cyan = exports.magenta = exports.blue = exports.yellow = exports.green = exports.red = exports.underline = exports.italic = exports.dim = exports.bold = exports.styles = exports.RESET = exports.ESC = void 0;
+exports.ESC = '\x1b[';
+exports.RESET = `${exports.ESC}0m`;
+exports.styles = {
+    bold: '1',
+    dim: '2',
+    italic: '3',
+    underline: '4',
+    // Foreground colors
+    black: '30',
+    red: '31',
+    green: '32',
+    yellow: '33',
+    blue: '34',
+    magenta: '35',
+    cyan: '36',
+    white: '37',
+    gray: '90',
+    // Background colors
+    bgBlack: '40',
+    bgRed: '41',
+    bgGreen: '42',
+    bgYellow: '43',
+    bgBlue: '44',
+    bgMagenta: '45',
+    bgCyan: '46',
+    bgWhite: '47',
+};
+function format(styleCode, text) {
+    return `${exports.ESC}${styleCode}m${text}${exports.RESET}`;
+}
+const bold = (txt) => format(exports.styles.bold, txt);
+exports.bold = bold;
+const dim = (txt) => format(exports.styles.dim, txt);
+exports.dim = dim;
+const italic = (txt) => format(exports.styles.italic, txt);
+exports.italic = italic;
+const underline = (txt) => format(exports.styles.underline, txt);
+exports.underline = underline;
+const red = (txt) => format(exports.styles.red, txt);
+exports.red = red;
+const green = (txt) => format(exports.styles.green, txt);
+exports.green = green;
+const yellow = (txt) => format(exports.styles.yellow, txt);
+exports.yellow = yellow;
+const blue = (txt) => format(exports.styles.blue, txt);
+exports.blue = blue;
+const magenta = (txt) => format(exports.styles.magenta, txt);
+exports.magenta = magenta;
+const cyan = (txt) => format(exports.styles.cyan, txt);
+exports.cyan = cyan;
+const white = (txt) => format(exports.styles.white, txt);
+exports.white = white;
+const gray = (txt) => format(exports.styles.gray, txt);
+exports.gray = gray;
+const bgRed = (txt) => format(exports.styles.bgRed, txt);
+exports.bgRed = bgRed;
+const bgGreen = (txt) => format(exports.styles.bgGreen, txt);
+exports.bgGreen = bgGreen;
+const bgBlue = (txt) => format(exports.styles.bgBlue, txt);
+exports.bgBlue = bgBlue;
+const bgCyan = (txt) => format(exports.styles.bgCyan, txt);
+exports.bgCyan = bgCyan;
+const success = (txt) => `${(0, exports.green)('✓')} ${txt}`;
+exports.success = success;
+const warning = (txt) => `${(0, exports.yellow)('⚠')} ${txt}`;
+exports.warning = warning;
+const info = (txt) => `${(0, exports.cyan)('ℹ')} ${txt}`;
+exports.info = info;
+const failure = (txt) => `${(0, exports.red)('❌')} ${txt}`;
+exports.failure = failure;

package/dist/utils/helpers.js

@@ -0,0 +1,365 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectOS = detectOS;
+exports.openInBrowser = openInBrowser;
+exports.openInFileExplorer = openInFileExplorer;
+exports.normalizeInputPath = normalizeInputPath;
+exports.openTerminalTail = openTerminalTail;
+exports.getDirSize = getDirSize;
+exports.checkJava = checkJava;
+exports.findInstalledJavas = findInstalledJavas;
+exports.getSystemStats = getSystemStats;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+/**
+ * Detects the runtime OS environment: Windows, WSL, or Linux
+ */
+function detectOS() {
+    if (process.platform === 'win32') {
+        return 'Windows';
+    }
+    try {
+        if (fs.existsSync('/proc/version')) {
+            const versionInfo = fs.readFileSync('/proc/version', 'utf-8').toLowerCase();
+            if (versionInfo.includes('microsoft') || versionInfo.includes('wsl')) {
+                return 'WSL';
+            }
+        }
+    }
+    catch {
+        // Ignore error and fall through
+    }
+    return 'Linux';
+}
+/**
+ * Opens a URL in the user's default browser (cross-platform, best-effort).
+ * Returns true if a launcher process was spawned, false if none was available.
+ */
+function openInBrowser(url) {
+    const osType = detectOS();
+    const candidates = [];
+    if (osType === 'Windows') {
+        candidates.push({ cmd: 'cmd', args: ['/c', 'start', '', url] });
+    }
+    else if (osType === 'WSL') {
+        // Use Windows interop so the link opens in the host's browser.
+        candidates.push({ cmd: 'wslview', args: [url] });
+        candidates.push({ cmd: 'cmd.exe', args: ['/c', 'start', '', url] });
+        candidates.push({ cmd: 'xdg-open', args: [url] });
+    }
+    else if (process.platform === 'darwin') {
+        candidates.push({ cmd: 'open', args: [url] });
+    }
+    else {
+        candidates.push({ cmd: 'xdg-open', args: [url] });
+    }
+    for (const { cmd, args } of candidates) {
+        try {
+            const child = (0, child_process_1.spawn)(cmd, args, { stdio: 'ignore', detached: true });
+            let failed = false;
+            child.on('error', () => { failed = true; });
+            child.unref();
+            if (!failed)
+                return true;
+        }
+        catch {
+            // Try the next candidate launcher.
+        }
+    }
+    return false;
+}
+/**
+ * Opens a directory in the OS file explorer (cross-platform, best-effort).
+ * Returns true if a launcher process was spawned.
+ */
+function openInFileExplorer(dir) {
+    const osType = detectOS();
+    const candidates = [];
+    if (osType === 'Windows') {
+        candidates.push({ cmd: 'explorer', args: [dir] });
+    }
+    else if (osType === 'WSL') {
+        // Convert the WSL path to a Windows path and open in Windows Explorer.
+        let winPath = '';
+        try {
+            winPath = (0, child_process_1.execSync)(`wslpath -w "${dir}"`).toString().trim();
+        }
+        catch { /* ignore */ }
+        if (winPath)
+            candidates.push({ cmd: 'explorer.exe', args: [winPath] });
+        candidates.push({ cmd: 'xdg-open', args: [dir] });
+    }
+    else if (process.platform === 'darwin') {
+        candidates.push({ cmd: 'open', args: [dir] });
+    }
+    else {
+        candidates.push({ cmd: 'xdg-open', args: [dir] });
+    }
+    for (const { cmd, args } of candidates) {
+        try {
+            // explorer.exe returns a non-zero exit code even on success, so we don't
+            // inspect the exit code — spawning without an immediate throw is enough.
+            const child = (0, child_process_1.spawn)(cmd, args, { stdio: 'ignore', detached: true });
+            let failed = false;
+            child.on('error', () => { failed = true; });
+            child.unref();
+            if (!failed)
+                return true;
+        }
+        catch {
+            // Try the next candidate.
+        }
+    }
+    return false;
+}
+/**
+ * Normalizes a user-supplied folder path so a Windows-style path pasted into a
+ * WSL/Linux session (e.g. "C:\Users\me\Server") is converted to its mount path
+ * ("/mnt/c/Users/me/Server"). Leaves native paths untouched.
+ */
+function normalizeInputPath(input) {
+    // Strip surrounding quotes/whitespace.
+    const p = input.trim().replace(/^['"]|['"]$/g, '');
+    const isWindowsDrivePath = /^[a-zA-Z]:[\\/]/.test(p);
+    const isUncPath = p.startsWith('\\\\');
+    // Only translate Windows paths when we're NOT actually on Windows.
+    if ((isWindowsDrivePath || isUncPath) && detectOS() !== 'Windows') {
+        // Prefer the real wslpath tool (handles UNC, spaces, casing correctly).
+        try {
+            const converted = (0, child_process_1.execSync)(`wslpath -u '${p.replace(/'/g, "'\\''")}'`)
+                .toString()
+                .trim();
+            if (converted)
+                return converted;
+        }
+        catch {
+            // wslpath unavailable — fall back to a manual drive-letter conversion.
+        }
+        const m = p.match(/^([a-zA-Z]):[\\/](.*)$/);
+        if (m) {
+            const drive = m[1].toLowerCase();
+            const rest = m[2].replace(/\\/g, '/');
+            return `/mnt/${drive}/${rest}`;
+        }
+    }
+    // Also convert lone backslashes for non-drive inputs on non-Windows hosts.
+    if (detectOS() !== 'Windows' && p.includes('\\') && !p.includes('/')) {
+        return p.replace(/\\/g, '/');
+    }
+    return p;
+}
+/**
+ * Opens a NEW terminal window that live-tails a log file (like `tail -f`),
+ * so the user can watch server logs while keeping the mcpanel prompt usable.
+ * Cross-platform, best-effort. Returns true if a window was launched.
+ */
+function openTerminalTail(logPath, title) {
+    const osType = detectOS();
+    const candidates = [];
+    if (osType === 'Windows') {
+        // PowerShell can follow a growing file; cmd's `start` opens a new window.
+        const ps = `Get-Content -Path '${logPath.replace(/'/g, "''")}' -Wait -Tail 200`;
+        candidates.push({ cmd: 'cmd', args: ['/c', 'start', title, 'powershell', '-NoExit', '-Command', ps] });
+    }
+    else if (osType === 'WSL') {
+        // Open a Windows console that runs `wsl tail -f` on the Linux-side path.
+        candidates.push({ cmd: 'cmd.exe', args: ['/c', 'start', title, 'wsl.exe', 'tail', '-n', '200', '-f', logPath] });
+        // Fall back to a native X terminal if one is available under WSLg.
+        candidates.push({ cmd: 'x-terminal-emulator', args: ['-e', `tail -n 200 -f "${logPath}"`] });
+        candidates.push({ cmd: 'xterm', args: ['-T', title, '-e', `tail -n 200 -f "${logPath}"`] });
+    }
+    else if (process.platform === 'darwin') {
+        const script = `tell application "Terminal" to do script "tail -n 200 -f '${logPath}'"`;
+        candidates.push({ cmd: 'osascript', args: ['-e', script] });
+    }
+    else {
+        candidates.push({ cmd: 'x-terminal-emulator', args: ['-e', `tail -n 200 -f "${logPath}"`] });
+        candidates.push({ cmd: 'gnome-terminal', args: ['--title', title, '--', 'bash', '-c', `tail -n 200 -f "${logPath}"; exec bash`] });
+        candidates.push({ cmd: 'konsole', args: ['-e', `tail -n 200 -f "${logPath}"`] });
+        candidates.push({ cmd: 'xterm', args: ['-T', title, '-e', `tail -n 200 -f "${logPath}"`] });
+    }
+    for (const { cmd, args } of candidates) {
+        try {
+            const child = (0, child_process_1.spawn)(cmd, args, { stdio: 'ignore', detached: true });
+            let failed = false;
+            child.on('error', () => { failed = true; });
+            child.unref();
+            if (!failed)
+                return true;
+        }
+        catch {
+            // Try the next candidate terminal.
+        }
+    }
+    return false;
+}
+/**
+ * Recursively sums the byte size of all files under a directory.
+ * Symlinks are not followed. Returns 0 on error.
+ */
+function getDirSize(dir) {
+    let total = 0;
+    let stack = [dir];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        let entries;
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const full = `${current}/${entry.name}`;
+            if (entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory()) {
+                stack.push(full);
+            }
+            else if (entry.isFile()) {
+                try {
+                    total += fs.statSync(full).size;
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }
+    return total;
+}
+/**
+ * Checks if Java is installed and returns version details
+ */
+function checkJava(javaPath = 'java') {
+    try {
+        // `java -version` writes to stderr, so merge it into stdout (2>&1) to capture it.
+        const result = (0, child_process_1.execSync)(`"${javaPath}" -version 2>&1`, { stdio: ['pipe', 'pipe', 'pipe'] });
+        const output = result.toString() || '';
+        return { installed: true, version: cleanJavaVersion(output) };
+    }
+    catch (error) {
+        const stderr = error.stderr ? error.stderr.toString() : '';
+        const stdout = error.stdout ? error.stdout.toString() : '';
+        const combined = (stderr + '\n' + stdout).trim();
+        if (combined.includes('version') || combined.includes('openjdk') || combined.includes('Java(TM)')) {
+            return { installed: true, version: cleanJavaVersion(combined) };
+        }
+        return { installed: false, version: 'None' };
+    }
+}
+/**
+ * Best-effort discovery of installed Java runtimes (Linux/WSL/macOS common
+ * locations). Returns each working java binary with its version, newest first.
+ */
+function findInstalledJavas() {
+    const found = new Map(); // path -> version
+    const searchRoots = [
+        '/usr/lib/jvm',
+        '/usr/java',
+        '/opt/java',
+        '/Library/Java/JavaVirtualMachines',
+    ];
+    for (const root of searchRoots) {
+        let entries = [];
+        try {
+            entries = fs.readdirSync(root);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            // Linux layout: <root>/<jdk>/bin/java ; macOS: <jdk>/Contents/Home/bin/java
+            const candidates = [
+                `${root}/${entry}/bin/java`,
+                `${root}/${entry}/Contents/Home/bin/java`,
+            ];
+            for (const bin of candidates) {
+                if (found.has(bin))
+                    continue;
+                try {
+                    if (fs.statSync(bin).isFile()) {
+                        const info = checkJava(bin);
+                        if (info.installed)
+                            found.set(bin, info.version);
+                    }
+                }
+                catch { /* not a file / not accessible */ }
+            }
+        }
+    }
+    return Array.from(found.entries())
+        .map(([path, version]) => ({ path, version }))
+        // Sort by leading version number descending (newest JDK first).
+        .sort((a, b) => parseInt(b.version, 10) - parseInt(a.version, 10));
+}
+/**
+ * Cleans the Java version output to a short recognizable string
+ */
+function cleanJavaVersion(output) {
+    const lines = output.split('\n');
+    const versionLine = lines.find(line => line.includes('version') || line.includes('openjdk'));
+    if (versionLine) {
+        // Extract version (e.g. "17.0.2" or "21.0.1")
+        const match = versionLine.match(/"([^"]+)"/);
+        if (match && match[1]) {
+            return match[1];
+        }
+        return versionLine.trim();
+    }
+    return 'Detected';
+}
+function getSystemStats() {
+    const totalMem = os.totalmem();
+    const freeMem = os.freemem();
+    const usedMem = totalMem - freeMem;
+    const totalMemGB = parseFloat((totalMem / (1024 * 1024 * 1024)).toFixed(2));
+    const freeMemGB = parseFloat((freeMem / (1024 * 1024 * 1024)).toFixed(2));
+    const usedMemGB = parseFloat((usedMem / (1024 * 1024 * 1024)).toFixed(2));
+    const memUsagePct = parseFloat(((usedMem / totalMem) * 100).toFixed(1));
+    // Calculate average CPU load percentage from load average over the last 1 min
+    const loadAvg = os.loadavg()[0]; // 1-minute load average
+    const cpuCount = os.cpus().length;
+    // load avg / cpus * 100 capped at 100 or actual representation
+    const cpuUsage = parseFloat(Math.min((loadAvg / cpuCount) * 100, 100).toFixed(1));
+    return {
+        cpuUsage: isNaN(cpuUsage) ? 0 : cpuUsage,
+        totalMemGB,
+        freeMemGB,
+        usedMemGB,
+        memUsagePct,
+        uptimeSeconds: Math.floor(os.uptime()),
+    };
+}

package/dist/utils/logger.js

@@ -0,0 +1,85 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const configManager_1 = require("../config/configManager");
+const LOGS_DIR = path.join(configManager_1.APP_ROOT, 'logs');
+function ensureLogsDirExists() {
+    if (!fs.existsSync(LOGS_DIR)) {
+        fs.mkdirSync(LOGS_DIR, { recursive: true });
+    }
+}
+function writeLog(filename, message) {
+    ensureLogsDirExists();
+    const filePath = path.join(LOGS_DIR, filename);
+    const timestamp = new Date().toISOString();
+    fs.appendFileSync(filePath, `[${timestamp}] ${message}\n`, 'utf-8');
+}
+exports.logger = {
+    info(message) {
+        writeLog('mcpanel.log', `INFO: ${message}`);
+    },
+    error(message, error) {
+        const errorDetails = error ? ` - ${error.stack || error.message || error}` : '';
+        writeLog('mcpanel.log', `ERROR: ${message}${errorDetails}`);
+    },
+    warn(message) {
+        writeLog('mcpanel.log', `WARN: ${message}`);
+    },
+    logServerStart(serverName, message) {
+        writeLog('server-start.log', `[${serverName}] ${message}`);
+        writeLog('mcpanel.log', `SERVER START: [${serverName}] ${message}`);
+    },
+    logServerStop(serverName, message) {
+        writeLog('server-stop.log', `[${serverName}] ${message}`);
+        writeLog('mcpanel.log', `SERVER STOP: [${serverName}] ${message}`);
+    },
+    logTunnel(message) {
+        writeLog('tunnel.log', message);
+        writeLog('mcpanel.log', `TUNNEL: ${message}`);
+    },
+    getServerLogPath(serverName) {
+        ensureLogsDirExists();
+        // Return path to the runtime console log for the server
+        return path.join(LOGS_DIR, `server-${serverName.toLowerCase()}.log`);
+    },
+    writeServerConsoleLog(serverName, data) {
+        ensureLogsDirExists();
+        const filePath = path.join(LOGS_DIR, `server-${serverName.toLowerCase()}.log`);
+        fs.appendFileSync(filePath, data, 'utf-8');
+    }
+};

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@woopsy/mcpanel",
+  "version": "1.0.0",
+  "description": "MCPANEL — a terminal-based, single-server Minecraft server manager with an Arch/neofetch-style UI, live logs, backups, plugins and Playit.gg tunnels.",
+  "main": "dist/index.js",
+  "bin": {
+    "mcpanel": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "postbuild": "node -e \"try{require('fs').chmodSync('dist/index.js',0o755)}catch(e){}\"",
+    "start": "ts-node src/index.ts",
+    "dev": "ts-node src/index.ts",
+    "prod": "node dist/index.js",
+    "prepublishOnly": "npm run build",
+    "install:global": "npm run build && npm install -g ."
+  },
+  "keywords": [
+    "minecraft",
+    "minecraft-server",
+    "server-manager",
+    "cli",
+    "terminal",
+    "tui",
+    "fabric",
+    "paper",
+    "playit",
+    "backups",
+    "wsl"
+  ],
+  "author": "Woopsy (https://github.com/Woopsyyy)",
+  "license": "MIT",
+  "homepage": "https://github.com/Woopsyyy/MCPANEL#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Woopsyyy/MCPANEL.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Woopsyyy/MCPANEL/issues"
+  },
+  "dependencies": {
+    "adm-zip": "^0.5.12",
+    "chalk": "^4.1.2",
+    "figlet": "^1.11.0",
+    "pidusage": "^4.0.1"
+  },
+  "devDependencies": {
+    "@types/adm-zip": "^0.5.5",
+    "@types/figlet": "^1.7.0",
+    "@types/node": "^20.12.12",
+    "@types/pidusage": "^2.0.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.5"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "private": false
+}