@woopsy/mcpanel 1.1.0 → 2.0.0

package/dist/commands/commandRouter.js

@@ -96,6 +96,8 @@ class CommandRouter {
             '  /stats                       - System stats + CPU/RAM/disk of the server',
             '  /java [path]                 - Show/list Java runtimes, or set the one used to launch',
             '  /folder                      - Open the server folder in the file explorer',
+            '  /tray                        - Run in background, minimize console to system tray',
+            '  /background                  - Synonym for /tray',
             '  /clear                       - Clear the screen, scrollback and command history',
             '  /update                      - Check npm for a newer version of MCPANEL',
             '  /config                      - View active application config.json',

package/dist/index.js

@@ -52,6 +52,7 @@ const colors = __importStar(require("./utils/colors"));
 const helpers_1 = require("./utils/helpers");
 const updateChecker_1 = require("./services/updateChecker");
 const logger_1 = require("./utils/logger");
+const trayManager_1 = require("./managers/trayManager");
 // Initialize managers
 const configManager = new configManager_1.ConfigManager();
 configManager.initialize();
@@ -59,6 +60,7 @@ const processManager = new processManager_1.ProcessManager();
 const serverManager = new serverManager_1.ServerManager(configManager);
 const backupManager = new backupManager_1.BackupManager(configManager);
 const playitManager = new playitManager_1.PlayitManager(configManager);
+const trayManager = new trayManager_1.TrayManager(configManager, processManager, playitManager);
 const router = new commandRouter_1.CommandRouter(configManager, processManager, serverManager, backupManager, playitManager);
 const HISTORY_PATH = path.join(configManager_1.APP_ROOT, 'logs', '.history');
 let currentState = 'COMMAND';
@@ -168,7 +170,7 @@ const COMMAND_LIST = [
     '/plugins list', '/plugins install', '/plugins remove',
     '/setup',
     '/tunnel java', '/tunnel bedrock', '/tunnel status', '/tunnel stop', '/tunnel reset',
-    '/config', '/clear', '/update', '/exit'
+    '/config', '/clear', '/update', '/tray', '/background', '/exit'
 ];
 // Subcommands offered once "<command> " has been typed.
 const SUBCOMMANDS = {
@@ -245,6 +247,11 @@ function getStatusBar() {
     const running = server ? !!processManager.getActiveServer(server.name) : false;
     const backupsCount = backupManager.listBackups().length;
     const tunnelStatus = playitManager.getStatus().status;
+    // Sync menu state to the system tray
+    try {
+        trayManager.updateMenu();
+    }
+    catch { /* ignore */ }
     const serverStr = !server
         ? colors.gray('none')
         : running ? colors.green('Running') : colors.red('Offline');
@@ -561,6 +568,16 @@ async function handleCommandState(line) {
                 console.log(colors.failure(`Failed to clear: ${err.message}`));
             }
             break;
+        case '/tray':
+        case '/background': {
+            console.log(colors.info('\nPutting MCPANEL in the background...'));
+            console.log(colors.gray('The terminal window will be hidden. Use the system tray icon to restore it.'));
+            const success = trayManager.hideConsole();
+            if (!success) {
+                console.log(colors.failure('Failed to hide console window. Ensure you are running in a supported GUI environment.'));
+            }
+            break;
+        }
         case '/exit':
             logger_1.logger.info('Exiting MCPANEL manager.');
             playitManager.stopTunnel();
@@ -753,6 +770,8 @@ async function showUpdateNotice() {
 async function main() {
     renderBanner();
     await showUpdateNotice();
+    // Start the background system tray loop
+    await trayManager.start();
     rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout,

package/dist/managers/trayManager.js

@@ -0,0 +1,335 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrayManager = void 0;
+const systray2_1 = __importDefault(require("systray2"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const helpers_1 = require("../utils/helpers");
+const configManager_1 = require("../config/configManager");
+const logger_1 = require("../utils/logger");
+const SysTrayBase = systray2_1.default;
+class WSLSysTray extends SysTrayBase {
+    constructor(conf) {
+        super(conf);
+    }
+    async init() {
+        const osType = (0, helpers_1.detectOS)();
+        if (osType === 'WSL') {
+            const binName = "tray_windows_release.exe";
+            const nodeModulesBin = path.join(configManager_1.APP_ROOT, 'node_modules', 'systray2', 'traybin', binName);
+            this._binPath = nodeModulesBin;
+            // Auto chmod +x to ensure the binary is executable from WSL
+            try {
+                fs.chmodSync(nodeModulesBin, 0o755);
+            }
+            catch { /* ignore */ }
+            return new Promise(async (resolve, reject) => {
+                try {
+                    const child = require('child_process');
+                    const readline = require('readline');
+                    this._process = child.spawn(this._binPath, [], {
+                        windowsHide: true
+                    });
+                    this._process.on('error', reject);
+                    this._rl = readline.createInterface({
+                        input: this._process.stdout
+                    });
+                    const internalIdMap = this.internalIdMap;
+                    const counter = { id: 1 };
+                    const addInternalId = (item) => {
+                        const id = counter.id++;
+                        internalIdMap.set(id, item);
+                        if (item.items) {
+                            item.items.forEach(addInternalId);
+                        }
+                        item.__id = id;
+                    };
+                    this._conf.menu.items.forEach(addInternalId);
+                    const loadIcon = async (fileName) => {
+                        const buffer = await fs.promises.readFile(fileName);
+                        return buffer.toString('base64');
+                    };
+                    const resolveIcon = async (item) => {
+                        if (item.icon && fs.existsSync(item.icon)) {
+                            item.icon = await loadIcon(item.icon);
+                        }
+                        if (item.items) {
+                            await Promise.all(item.items.map((sub) => resolveIcon(sub)));
+                        }
+                    };
+                    await resolveIcon(this._conf.menu);
+                    this.onReady(() => {
+                        const itemTrimmer = (item) => ({
+                            title: item.title,
+                            tooltip: item.tooltip,
+                            checked: item.checked,
+                            enabled: item.enabled === undefined ? true : item.enabled,
+                            hidden: item.hidden,
+                            items: item.items,
+                            icon: item.icon,
+                            isTemplateIcon: item.isTemplateIcon,
+                            __id: item.__id
+                        });
+                        const menuTrimmer = (menu) => ({
+                            icon: menu.icon,
+                            title: menu.title,
+                            tooltip: menu.tooltip,
+                            items: menu.items.map(itemTrimmer),
+                            isTemplateIcon: menu.isTemplateIcon
+                        });
+                        this.writeLine(JSON.stringify(menuTrimmer(this._conf.menu)));
+                        resolve();
+                    });
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        }
+        else {
+            return super.init();
+        }
+    }
+}
+class TrayManager {
+    configManager;
+    processManager;
+    playitManager;
+    systray = null;
+    activeHandle = null;
+    isInitialized = false;
+    // Menu item state tracking
+    itemShow = { title: 'Open Console', tooltip: 'Restore terminal window', enabled: true };
+    itemHide = { title: 'Hide Console', tooltip: 'Hide terminal window from taskbar', enabled: true };
+    itemServerStatus = { title: 'Server: Checking...', tooltip: 'Current Minecraft server status', enabled: false };
+    itemServerToggle = { title: 'Start Server', tooltip: 'Toggle server state', enabled: true };
+    itemTunnelStatus = { title: 'Tunnel: Checking...', tooltip: 'Current Playit tunnel status', enabled: false };
+    itemTunnelToggle = { title: 'Start Tunnel', tooltip: 'Toggle tunnel state', enabled: true };
+    itemExit = { title: 'Exit', tooltip: 'Stop server/tunnel and exit', enabled: true };
+    constructor(configManager, processManager, playitManager) {
+        this.configManager = configManager;
+        this.processManager = processManager;
+        this.playitManager = playitManager;
+    }
+    /**
+     * Initializes and starts the system tray icon loop
+     */
+    async start() {
+        if (this.isInitialized)
+            return true;
+        const osType = (0, helpers_1.detectOS)();
+        const iconFile = osType === 'Windows' || osType === 'WSL'
+            ? path.join(configManager_1.APP_ROOT, 'assets', 'logo.ico')
+            : path.join(configManager_1.APP_ROOT, 'assets', 'logo.png');
+        try {
+            this.systray = new WSLSysTray({
+                menu: {
+                    icon: iconFile,
+                    title: 'MCPANEL',
+                    tooltip: 'MCPANEL Server Manager',
+                    items: [
+                        this.itemShow,
+                        this.itemHide,
+                        systray2_1.default.separator,
+                        this.itemServerStatus,
+                        this.itemServerToggle,
+                        systray2_1.default.separator,
+                        this.itemTunnelStatus,
+                        this.itemTunnelToggle,
+                        systray2_1.default.separator,
+                        this.itemExit
+                    ]
+                },
+                debug: false
+            });
+            this.systray.onClick((event) => {
+                this.handleTrayClick(event).catch((err) => {
+                    logger_1.logger.error('Error handling tray click event', err);
+                });
+            });
+            await this.systray.ready();
+            this.isInitialized = true;
+            logger_1.logger.info('System tray initialized successfully.');
+            this.updateMenu();
+            return true;
+        }
+        catch (err) {
+            this.systray = null;
+            logger_1.logger.error('Failed to initialize system tray', err);
+            // Fail silently for user prompt, fall back to CLI-only mode gracefully.
+            return false;
+        }
+    }
+    /**
+     * Dynamically updates the titles and states of the tray menu items
+     */
+    updateMenu() {
+        const tray = this.systray;
+        if (!tray || !this.isInitialized)
+            return;
+        const server = this.configManager.getServer();
+        const running = server ? !!this.processManager.getActiveServer(server.name) : false;
+        const tunnel = this.playitManager.getStatus();
+        // Update server status & toggle label
+        this.itemServerStatus.title = `Server: ${running ? 'Running' : 'Offline'}`;
+        this.itemServerToggle.title = running ? 'Stop Server' : 'Start Server';
+        this.itemServerToggle.enabled = !!server;
+        // Update tunnel status & toggle label
+        this.itemTunnelStatus.title = `Tunnel: ${tunnel.status}`;
+        this.itemTunnelToggle.title = tunnel.status === 'Online' || tunnel.status === 'Connecting' ? 'Stop Tunnel' : 'Start Tunnel';
+        // Push updates to the native helper
+        tray.sendAction({ type: 'update-item', item: this.itemServerStatus });
+        tray.sendAction({ type: 'update-item', item: this.itemServerToggle });
+        tray.sendAction({ type: 'update-item', item: this.itemTunnelStatus });
+        tray.sendAction({ type: 'update-item', item: this.itemTunnelToggle });
+    }
+    /**
+     * Hides the active terminal window to the background
+     */
+    hideConsole() {
+        const handle = (0, helpers_1.getActiveWindowHandle)();
+        if (!handle) {
+            logger_1.logger.warn('Could not retrieve active console window handle.');
+            return false;
+        }
+        this.activeHandle = handle;
+        const success = (0, helpers_1.hideConsoleWindow)(handle);
+        if (success) {
+            logger_1.logger.info(`Console window (${handle}) hidden to background.`);
+        }
+        return success;
+    }
+    /**
+     * Restores the hidden console window back to foreground
+     */
+    showConsole() {
+        const handle = this.activeHandle;
+        if (!handle) {
+            logger_1.logger.warn('No saved console window handle to restore.');
+            // Fallback: try to retrieve current active handle (best effort if not saved)
+            const curHandle = (0, helpers_1.getActiveWindowHandle)();
+            if (curHandle) {
+                return (0, helpers_1.showConsoleWindow)(curHandle);
+            }
+            return false;
+        }
+        const success = (0, helpers_1.showConsoleWindow)(handle);
+        if (success) {
+            logger_1.logger.info(`Console window (${handle}) restored to foreground.`);
+        }
+        return success;
+    }
+    /**
+     * Handles individual tray menu click actions
+     */
+    async handleTrayClick(event) {
+        const title = event.item.title;
+        if (title === 'Open Console') {
+            this.showConsole();
+        }
+        else if (title === 'Hide Console') {
+            this.hideConsole();
+        }
+        else if (title === 'Start Server') {
+            const server = this.configManager.getServer();
+            if (!server)
+                return;
+            const jarPath = path.join(server.path, 'server.jar');
+            let resolvedJar = jarPath;
+            if (!fs.existsSync(jarPath)) {
+                const jarFiles = fs.readdirSync(server.path).filter(f => f.endsWith('.jar'));
+                if (jarFiles.length > 0) {
+                    resolvedJar = path.join(server.path, jarFiles[0]);
+                }
+            }
+            try {
+                logger_1.logger.info(`Starting Minecraft server "${server.name}" from tray menu...`);
+                await this.processManager.startServer(server.name, server.path, resolvedJar, server.ram, this.configManager.getConfig().defaultJavaPath);
+            }
+            catch (err) {
+                logger_1.logger.error('Failed to start server from tray', err);
+            }
+            this.updateMenu();
+        }
+        else if (title === 'Stop Server') {
+            const server = this.configManager.getServer();
+            if (!server)
+                return;
+            logger_1.logger.info(`Stopping Minecraft server "${server.name}" from tray menu gracefully...`);
+            await this.processManager.stopServer(server.name);
+            this.updateMenu();
+        }
+        else if (title === 'Start Tunnel') {
+            logger_1.logger.info('Starting playit tunnel agent from tray menu...');
+            try {
+                const savedSettings = this.configManager.getConfig().playitSettings;
+                const type = (savedSettings.tunnelAddress ? 'java' : 'java'); // default to java
+                await this.playitManager.setupAndStart(type);
+            }
+            catch (err) {
+                logger_1.logger.error('Failed to start tunnel from tray', err);
+            }
+            this.updateMenu();
+        }
+        else if (title === 'Stop Tunnel') {
+            logger_1.logger.info('Stopping playit tunnel agent from tray menu...');
+            this.playitManager.stopTunnel();
+            this.updateMenu();
+        }
+        else if (title === 'Exit') {
+            logger_1.logger.info('Exit requested from system tray. Shutting down MCPANEL...');
+            // Stop server
+            const server = this.configManager.getServer();
+            if (server) {
+                await this.processManager.stopServer(server.name);
+            }
+            // Stop tunnel
+            this.playitManager.stopTunnel();
+            // Clean exit
+            const tray = this.systray;
+            if (tray) {
+                await tray.kill(true);
+            }
+            else {
+                process.exit(0);
+            }
+        }
+    }
+}
+exports.TrayManager = TrayManager;

package/dist/utils/helpers.js

@@ -43,6 +43,9 @@ exports.checkJava = checkJava;
 exports.findInstalledJavas = findInstalledJavas;
 exports.getSystemStats = getSystemStats;
 exports.checkForUpdates = checkForUpdates;
+exports.getActiveWindowHandle = getActiveWindowHandle;
+exports.hideConsoleWindow = hideConsoleWindow;
+exports.showConsoleWindow = showConsoleWindow;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const child_process_1 = require("child_process");
@@ -428,3 +431,83 @@ function isNewerVersion(current, latest) {
     }
     return false;
 }
+/**
+ * Gets the handle/ID of the active console window.
+ * Returns null if not supported or fails.
+ */
+function getActiveWindowHandle() {
+    const osType = detectOS();
+    try {
+        if (osType === 'Windows') {
+            const cmd = `powershell -NoProfile -Command "Add-Type -MemberDefinition '[DllImport(\\"user32.dll\\")] public static extern IntPtr GetForegroundWindow();' -Name Win32Util -Namespace Win32 -PassThru | Out-Null; [Win32.Win32Util]::GetForegroundWindow()"`;
+            return (0, child_process_1.execSync)(cmd).toString().trim();
+        }
+        else if (osType === 'WSL') {
+            const cmd = `powershell.exe -NoProfile -Command "Add-Type -MemberDefinition '[DllImport(\\"user32.dll\\")] public static extern IntPtr GetForegroundWindow();' -Name Win32Util -Namespace Win32 -PassThru | Out-Null; [Win32.Win32Util]::GetForegroundWindow()"`;
+            return (0, child_process_1.execSync)(cmd).toString().trim();
+        }
+        else {
+            // Native Linux
+            return (0, child_process_1.execSync)('xdotool getactivewindow 2>/dev/null').toString().trim() || null;
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Hides the console window using its handle/ID.
+ */
+function hideConsoleWindow(handle) {
+    if (!handle)
+        return false;
+    const osType = detectOS();
+    try {
+        if (osType === 'Windows') {
+            const cmd = `powershell -NoProfile -Command "Add-Type -MemberDefinition '[DllImport(\\"user32.dll\\")] public static extern bool ShowWindowAsync(IntPtr hWnd, int nCmdShow);' -Name Win32Util -Namespace Win32; [Win32.Win32Util]::ShowWindowAsync([IntPtr]${handle}, 0)"`;
+            (0, child_process_1.execSync)(cmd);
+            return true;
+        }
+        else if (osType === 'WSL') {
+            const cmd = `powershell.exe -NoProfile -Command "Add-Type -MemberDefinition '[DllImport(\\"user32.dll\\")] public static extern bool ShowWindowAsync(IntPtr hWnd, int nCmdShow);' -Name Win32Util -Namespace Win32; [Win32.Win32Util]::ShowWindowAsync([IntPtr]${handle}, 0)"`;
+            (0, child_process_1.execSync)(cmd);
+            return true;
+        }
+        else {
+            // Native Linux
+            (0, child_process_1.execSync)(`xdotool windowunmap ${handle} 2>/dev/null`);
+            return true;
+        }
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Restores and focuses the console window using its handle/ID.
+ */
+function showConsoleWindow(handle) {
+    if (!handle)
+        return false;
+    const osType = detectOS();
+    try {
+        if (osType === 'Windows') {
+            const cmd = `powershell -NoProfile -Command "Add-Type -MemberDefinition '[DllImport(\\"user32.dll\\")] public static extern bool ShowWindowAsync(IntPtr hWnd, int nCmdShow); [DllImport(\\"user32.dll\\")] public static extern bool SetForegroundWindow(IntPtr hWnd);' -Name Win32Util -Namespace Win32; [Win32.Win32Util]::ShowWindowAsync([IntPtr]${handle}, 9); [Win32.Win32Util]::SetForegroundWindow([IntPtr]${handle})"`;
+            (0, child_process_1.execSync)(cmd);
+            return true;
+        }
+        else if (osType === 'WSL') {
+            const cmd = `powershell.exe -NoProfile -Command "Add-Type -MemberDefinition '[DllImport(\\"user32.dll\\")] public static extern bool ShowWindowAsync(IntPtr hWnd, int nCmdShow); [DllImport(\\"user32.dll\\")] public static extern bool SetForegroundWindow(IntPtr hWnd);' -Name Win32Util -Namespace Win32; [Win32.Win32Util]::ShowWindowAsync([IntPtr]${handle}, 9); [Win32.Win32Util]::SetForegroundWindow([IntPtr]${handle})"`;
+            (0, child_process_1.execSync)(cmd);
+            return true;
+        }
+        else {
+            // Native Linux
+            (0, child_process_1.execSync)(`xdotool windowmap ${handle} 2>/dev/null && xdotool windowactivate ${handle} 2>/dev/null`);
+            return true;
+        }
+    }
+    catch {
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@woopsy/mcpanel",
-  "version": "1.1.0",
+  "version": "2.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": {
@@ -48,7 +48,8 @@
     "adm-zip": "^0.5.12",
     "chalk": "^4.1.2",
     "figlet": "^1.11.0",
-    "pidusage": "^4.0.1"
+    "pidusage": "^4.0.1",
+    "systray2": "^2.1.4"
   },
   "devDependencies": {
     "@types/adm-zip": "^0.5.5",