@woopsy/mcpanel 1.0.3 → 2.0.0

package/dist/commands/commandRouter.js

@@ -42,6 +42,7 @@ const path = __importStar(require("path"));
 const colors = __importStar(require("../utils/colors"));
 const helpers_1 = require("../utils/helpers");
 const downloadService_1 = require("../services/downloadService");
+const updateChecker_1 = require("../services/updateChecker");
 const pidusage_1 = __importDefault(require("pidusage"));
 class CommandRouter {
     configManager;
@@ -95,7 +96,10 @@ 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',
             '  /exit                        - Close MCPANEL server manager',
             colors.gray('──────────────────────────────────────────────\n')
@@ -465,6 +469,22 @@ class CommandRouter {
         this.configManager.updateSettings({ defaultJavaPath: cleanPath });
         return colors.success(`Java set to "${cleanPath}" (version ${info.version}). It will be used on the next /start.`);
     }
+    /**
+     * Executes /update — checks npm for a newer version and prints how to update.
+     */
+    async executeUpdate() {
+        const info = await (0, updateChecker_1.checkForUpdate)(true);
+        if (!info) {
+            return colors.warning('Could not check for updates (no network connection?).');
+        }
+        if (info.updateAvailable) {
+            return [
+                colors.warning(`Update available: ${colors.bold(info.current)} → ${colors.bold(colors.green(info.latest))}`),
+                colors.gray('Update with: ') + colors.cyan(`npm i -g ${info.name}@latest`),
+            ].join('\n');
+        }
+        return colors.success(`You're on the latest version (${info.current}).`);
+    }
     /**
      * Executes /config
      */

package/dist/index.js

@@ -50,7 +50,9 @@ const playitManager_1 = require("./managers/playitManager");
 const commandRouter_1 = require("./commands/commandRouter");
 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();
@@ -58,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';
@@ -70,6 +73,12 @@ let consoleActiveServer = '';
 let logViewServer = '';
 // Readline interface
 let rl;
+let CLI_VERSION = '1.0.3';
+try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(configManager_1.APP_ROOT, 'package.json'), 'utf-8'));
+    CLI_VERSION = pkg.version || '1.0.3';
+}
+catch { /* ignore */ }
 /**
  * Renders the figlet "MCPANEL" ASCII banner with a chalk gradient.
  */
@@ -79,7 +88,7 @@ function renderBanner() {
     const tints = [chalk_1.default.cyanBright, chalk_1.default.cyan, chalk_1.default.greenBright, chalk_1.default.green, chalk_1.default.green];
     console.log();
     lines.forEach((line, i) => console.log((tints[i] || chalk_1.default.green)(line)));
-    console.log(chalk_1.default.greenBright.bold('  Minecraft Server Manager') + chalk_1.default.gray('   v1.0.0'));
+    console.log(chalk_1.default.greenBright.bold('  Minecraft Server Manager') + chalk_1.default.gray(`   v${CLI_VERSION}`));
 }
 /**
  * Renders the neofetch / Arch-Linux-style info block for the synced server.
@@ -161,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', '/exit'
+    '/config', '/clear', '/update', '/tray', '/background', '/exit'
 ];
 // Subcommands offered once "<command> " has been typed.
 const SUBCOMMANDS = {
@@ -238,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');
@@ -554,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();
@@ -609,6 +633,9 @@ async function handleCommandState(line) {
         case '/java':
             console.log(router.executeJava(args.length ? args.join(' ') : undefined));
             break;
+        case '/update':
+            console.log(await router.executeUpdate());
+            break;
         case '/config':
             console.log(router.executeConfig());
             break;
@@ -720,11 +747,31 @@ async function finishStartup() {
     currentState = 'COMMAND';
     promptUser();
 }
+/**
+ * Prints a one-time-per-launch notice if a newer version is on npm. Fail-silent
+ * and cached, so it never slows down or blocks startup.
+ */
+async function showUpdateNotice() {
+    try {
+        const info = await (0, updateChecker_1.checkForUpdate)();
+        if (info && info.updateAvailable) {
+            console.log();
+            console.log(chalk_1.default.yellow('  ⚡ Update available: ') + chalk_1.default.gray(info.current) + chalk_1.default.gray(' → ') + chalk_1.default.greenBright.bold(info.latest));
+            console.log(chalk_1.default.gray('     Update with: ') + chalk_1.default.cyan(`npm i -g ${info.name}@latest`));
+        }
+    }
+    catch {
+        // Never let an update check break startup.
+    }
+}
 /**
  * Main application setup
  */
 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/playitManager.js

@@ -362,20 +362,28 @@ class PlayitManager {
     // Full automated setup
     // ---------------------------------------------------------------------------
     /**
-     * One-call entry point: ensures binary + secret, creates the tunnel via the
-     * API, starts the relay daemon, and returns the live tunnel status.
+     * One-call entry point: ensures binary + secret, starts the relay daemon (so
+     * the agent registers its version with playit), creates the tunnel via the
+     * API, and returns the live tunnel status.
+     *
+     * The relay MUST be started before creating a tunnel — playit rejects
+     * /tunnels/create with "AgentVersionTooOld" until a current agent has
+     * connected and reported its version.
      */
     async setupAndStart(type, callbacks = {}) {
         await this.ensureBinary();
         const secret = await this.ensureSecret(callbacks);
         this.tunnelStatus.status = 'Connecting';
         this.tunnelStatus.type = type;
+        // Start the relay first so the agent connects and registers its version.
+        callbacks.onStatus?.('Starting tunnel agent...');
+        await this.startAgent(secret);
         callbacks.onStatus?.('Checking your playit account for an existing tunnel...');
         let rd = await this.getRunData(secret);
         let tunnel = this.findTunnel(rd, type);
         if (!tunnel) {
             callbacks.onStatus?.(`Creating ${type} tunnel...`);
-            await this.createApiTunnel(type, rd.agent_id, secret);
+            await this.createTunnelWithRetry(type, rd.agent_id, secret, callbacks);
             // Poll until the tunnel leaves "pending" and gets a public address.
             for (let i = 0; i < 15 && !tunnel; i++) {
                 await this.sleep(3000);
@@ -390,11 +398,38 @@ class PlayitManager {
         this.tunnelStatus.address = address;
         this.tunnelStatus.port = port;
         this.configManager.updatePlayitTunnel({ tunnelAddress: address, tunnelPort: Number(port) });
-        callbacks.onStatus?.('Starting tunnel relay...');
-        await this.startAgent(secret);
         this.tunnelStatus.status = 'Online';
         return this.tunnelStatus;
     }
+    /**
+     * Creates a tunnel, retrying on "AgentVersionTooOld" — that error means the
+     * freshly-started agent hasn't finished registering its version yet, so we
+     * wait and retry (refreshing the agent_id) a few times.
+     */
+    async createTunnelWithRetry(type, agentId, secret, callbacks) {
+        let lastErr;
+        for (let attempt = 0; attempt < 8; attempt++) {
+            try {
+                await this.createApiTunnel(type, agentId, secret);
+                return;
+            }
+            catch (err) {
+                lastErr = err;
+                if (!/AgentVersionTooOld/i.test(err.message || ''))
+                    throw err;
+                callbacks.onStatus?.('Waiting for the agent to finish registering with playit...');
+                await this.sleep(4000);
+                try {
+                    const rd = await this.getRunData(secret);
+                    if (rd?.agent_id)
+                        agentId = rd.agent_id;
+                }
+                catch { /* keep previous agentId */ }
+            }
+        }
+        throw new Error(`${lastErr?.message || 'AgentVersionTooOld'} — the playit agent did not register in time. ` +
+            `Make sure the server can reach playit.gg, then try /tunnel again.`);
+    }
     /** Spawns the long-running daemon that relays tunnel traffic. */
     startAgent(secret) {
         return new Promise((resolve) => {

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/services/updateChecker.js

@@ -0,0 +1,140 @@
+"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.isNewer = isNewer;
+exports.checkForUpdate = checkForUpdate;
+const https = __importStar(require("https"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const configManager_1 = require("../config/configManager");
+/**
+ * Lightweight "is there a newer version on npm?" checker.
+ *
+ * - Reads the installed name/version from the package's own package.json.
+ * - Asks the npm registry's dist-tags endpoint for the latest version.
+ * - Caches the result (logs/.update-check.json) so we only hit the network
+ *   every few hours, keeping startup fast.
+ * - Fully fail-silent: no network / offline / parse error => returns null.
+ */
+const CACHE_FILE = path.join(configManager_1.APP_ROOT, 'logs', '.update-check.json');
+const CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000; // re-check at most every 6h
+const FETCH_TIMEOUT_MS = 2500;
+function readPkg() {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(configManager_1.APP_ROOT, 'package.json'), 'utf-8'));
+        if (pkg && pkg.name && pkg.version)
+            return { name: pkg.name, version: pkg.version };
+    }
+    catch { /* ignore */ }
+    return null;
+}
+function parseVer(v) {
+    // Strip any pre-release/build suffix, then split into numeric parts.
+    return v.split('-')[0].split('.').map((n) => parseInt(n, 10) || 0);
+}
+/** True if `latest` is a higher semver than `current`. */
+function isNewer(latest, current) {
+    const a = parseVer(latest);
+    const b = parseVer(current);
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        const x = a[i] || 0;
+        const y = b[i] || 0;
+        if (x > y)
+            return true;
+        if (x < y)
+            return false;
+    }
+    return false;
+}
+function fetchLatest(name) {
+    // dist-tags is a tiny payload: {"latest":"1.2.3", ...}
+    const url = `https://registry.npmjs.org/-/package/${name.replace('/', '%2F')}/dist-tags`;
+    return new Promise((resolve) => {
+        const req = https.get(url, { timeout: FETCH_TIMEOUT_MS }, (res) => {
+            if (res.statusCode && res.statusCode >= 400) {
+                res.resume();
+                resolve(null);
+                return;
+            }
+            let data = '';
+            res.on('data', (c) => { data += c; });
+            res.on('end', () => {
+                try {
+                    resolve(JSON.parse(data).latest || null);
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        });
+        req.on('error', () => resolve(null));
+        req.on('timeout', () => { req.destroy(); resolve(null); });
+    });
+}
+function readCache() {
+    try {
+        const c = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8'));
+        if (c && typeof c.latest === 'string' && typeof c.checkedAt === 'number')
+            return c;
+    }
+    catch { /* ignore */ }
+    return null;
+}
+function writeCache(latest) {
+    try {
+        fs.writeFileSync(CACHE_FILE, JSON.stringify({ latest, checkedAt: Date.now() }), 'utf-8');
+    }
+    catch { /* ignore */ }
+}
+/**
+ * Returns update info, or null if it couldn't be determined.
+ * Pass force=true (e.g. for an explicit /update command) to bypass the cache.
+ */
+async function checkForUpdate(force = false) {
+    const pkg = readPkg();
+    if (!pkg)
+        return null;
+    if (!force) {
+        const cached = readCache();
+        if (cached && Date.now() - cached.checkedAt < CHECK_INTERVAL_MS) {
+            return { name: pkg.name, current: pkg.version, latest: cached.latest, updateAvailable: isNewer(cached.latest, pkg.version) };
+        }
+    }
+    const latest = await fetchLatest(pkg.name);
+    if (!latest)
+        return null;
+    writeCache(latest);
+    return { name: pkg.name, current: pkg.version, latest, updateAvailable: isNewer(latest, pkg.version) };
+}

package/dist/utils/helpers.js

@@ -42,9 +42,14 @@ exports.getDirSize = getDirSize;
 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");
+const https = __importStar(require("https"));
 /**
  * Detects the runtime OS environment: Windows, WSL, or Linux
  */
@@ -363,3 +368,146 @@ function getSystemStats() {
         uptimeSeconds: Math.floor(os.uptime()),
     };
 }
+/**
+ * Checks npm registry for a newer version of the CLI package.
+ * Returns the latest version string if a newer version is available, or null otherwise.
+ */
+function checkForUpdates(currentVersion) {
+    return new Promise((resolve) => {
+        const options = {
+            hostname: 'registry.npmjs.org',
+            path: '/@woopsy/mcpanel/latest',
+            method: 'GET',
+            timeout: 2000,
+            headers: {
+                'User-Agent': 'mcpanel-cli',
+            },
+        };
+        const req = https.get(options, (res) => {
+            if (res.statusCode !== 200) {
+                resolve(null);
+                return;
+            }
+            let data = '';
+            res.on('data', (chunk) => { data += chunk; });
+            res.on('end', () => {
+                try {
+                    const parsed = JSON.parse(data);
+                    const latest = parsed.version;
+                    if (latest && isNewerVersion(currentVersion, latest)) {
+                        resolve(latest);
+                    }
+                    else {
+                        resolve(null);
+                    }
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        });
+        req.on('timeout', () => {
+            req.destroy();
+            resolve(null);
+        });
+        req.on('error', () => {
+            resolve(null);
+        });
+    });
+}
+/**
+ * Basic semver comparison (a < b)
+ */
+function isNewerVersion(current, latest) {
+    const cParts = current.split('.').map(Number);
+    const lParts = latest.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        const c = cParts[i] || 0;
+        const l = lParts[i] || 0;
+        if (l > c)
+            return true;
+        if (c > l)
+            return false;
+    }
+    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.0.3",
+  "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",