@woopsy/mcpanel 1.0.3 → 1.1.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;
@@ -96,6 +97,7 @@ class CommandRouter {
             '  /java [path]                 - Show/list Java runtimes, or set the one used to launch',
             '  /folder                      - Open the server folder in the file explorer',
             '  /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 +467,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,6 +50,7 @@ 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");
 // Initialize managers
 const configManager = new configManager_1.ConfigManager();
@@ -70,6 +71,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 +86,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 +168,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', '/exit'
 ];
 // Subcommands offered once "<command> " has been typed.
 const SUBCOMMANDS = {
@@ -609,6 +616,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 +730,29 @@ 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();
     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/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,11 @@ exports.getDirSize = getDirSize;
 exports.checkJava = checkJava;
 exports.findInstalledJavas = findInstalledJavas;
 exports.getSystemStats = getSystemStats;
+exports.checkForUpdates = checkForUpdates;
 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 +365,66 @@ 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;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@woopsy/mcpanel",
-  "version": "1.0.3",
+  "version": "1.1.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": {