@woopsy/mcpanel 1.0.1 → 1.1.0

package/README.md

@@ -144,6 +144,26 @@ npm run dev      # run from TypeScript (ts-node)
 npm run build    # compile to dist/
 ```
 
+### Releasing (maintainers)
+
+Publishing is automated by GitHub Actions (`.github/workflows/publish.yml`). You never
+run `npm publish` by hand.
+
+**One-time setup:**
+1. Create an npm **Automation** token: npmjs.com → Access Tokens → Generate New Token →
+   *Automation* (these bypass 2FA in CI).
+2. Add it to the repo: GitHub → Settings → Secrets and variables → Actions → New repository
+   secret → name `NPM_TOKEN`.
+
+**Every release after that:**
+```bash
+npm version patch      # or minor / major — bumps package.json and creates a git tag
+git push --follow-tags # pushes the commit + tag; CI builds and publishes to npm
+```
+
+The workflow skips automatically if that version is already on npm, and `npm install -g @woopsy/mcpanel@latest`
+picks up the new version once it's green.
+
 ---
 
 ## License

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;
@@ -74,6 +75,7 @@ class CommandRouter {
             '  /properties                  - Edit server.properties interactively',
             '',
             colors.bold(colors.green('Tunnel Commands (Playit.gg)')),
+            '  /setup                       - One-time Playit account claim (browser approval)',
             '  /tunnel java                 - Auto-create & start a Java tunnel, returns address',
             '  /tunnel bedrock              - Auto-create & start a Bedrock tunnel, returns address',
             '  /tunnel status               - Check tunnel status, address and latency',
@@ -95,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')
@@ -464,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
      */
@@ -514,6 +533,36 @@ class CommandRouter {
             return colors.failure(`Failed to create tunnel: ${err.message}`);
         }
     }
+    /**
+     * Executes /setup — runs the one-time Playit agent claim (browser approval),
+     * saving the agent secret. Works on all platforms (HTTP claim, no playit-cli).
+     * After this, /tunnel java|bedrock is fully automatic.
+     */
+    async executeSetup() {
+        if (this.playitManager.getSecret()) {
+            return colors.warning('Playit is already set up (agent secret saved). Run /tunnel reset first if you want to re-claim.');
+        }
+        try {
+            await this.playitManager.ensureSecret({
+                onClaimUrl: (url) => {
+                    const opened = (0, helpers_1.openInBrowser)(url);
+                    console.log(`\n🔗 ${colors.bold('Approve the agent in your browser to finish setup.')}`);
+                    if (opened) {
+                        console.log(colors.gray('Your browser was opened automatically — sign in and click Approve.'));
+                    }
+                    else {
+                        console.log(colors.gray('Open this link, sign in (free account), and click Approve:'));
+                    }
+                    console.log(colors.underline(colors.cyan(url)));
+                },
+                onStatus: (msg) => console.log(colors.info(msg)),
+            });
+            return colors.success('Playit is set up! You can now run /tunnel java or /tunnel bedrock.');
+        }
+        catch (err) {
+            return colors.failure(`Setup failed: ${err.message}`);
+        }
+    }
     /**
      * Executes /tunnel reset — clears the saved secret so the agent can be re-claimed.
      */

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.
@@ -159,8 +166,9 @@ const COMMAND_LIST = [
     '/stats', '/folder', '/properties', '/java',
     '/backup create', '/backup list', '/backup restore',
     '/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 = {
@@ -608,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;
@@ -654,6 +665,9 @@ async function handleCommandState(line) {
                 console.log(colors.failure('Syntax: /plugins [list|install|remove]'));
             }
             break;
+        case '/setup':
+            console.log(await router.executeSetup());
+            break;
         case '/tunnel': {
             const sub = (args[0] || '').toLowerCase();
             if (!sub) {
@@ -716,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

@@ -37,6 +37,7 @@ exports.PlayitManager = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const https = __importStar(require("https"));
+const crypto = __importStar(require("crypto"));
 const child_process_1 = require("child_process");
 const configManager_1 = require("../config/configManager");
 const helpers_1 = require("../utils/helpers");
@@ -209,6 +210,41 @@ class PlayitManager {
     getRunData(secret) {
         return this.apiPost('/agents/rundata', {}, secret);
     }
+    /**
+     * Unauthenticated POST for the claim endpoints. Unlike apiPost it returns the
+     * raw { status, data } envelope and does NOT throw on `status:"fail"` — a fail
+     * (e.g. "CodeNotFound" while waiting for approval) is a normal polling state.
+     */
+    apiClaim(apiPath, body) {
+        const payload = JSON.stringify(body || {});
+        const url = new URL(PLAYIT_API + apiPath);
+        return new Promise((resolve, reject) => {
+            const req = https.request({
+                hostname: url.hostname,
+                path: url.pathname,
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(payload),
+                },
+            }, (res) => {
+                let data = '';
+                res.on('data', (c) => { data += c; });
+                res.on('end', () => {
+                    try {
+                        const parsed = JSON.parse(data);
+                        resolve({ status: parsed.status, data: parsed.data });
+                    }
+                    catch {
+                        reject(new Error(`Bad claim response: ${data.slice(0, 200)}`));
+                    }
+                });
+            });
+            req.on('error', reject);
+            req.write(payload);
+            req.end();
+        });
+    }
     /** Picks the public address from a rundata tunnel entry. */
     tunnelAddress(tunnel) {
         const port = tunnel?.port?.from ?? tunnel?.local_port ?? 0;
@@ -262,81 +298,92 @@ class PlayitManager {
             });
         });
     }
-    /** Ensures a write-capable agent secret, driving the one-time claim if needed. */
+    /**
+     * Ensures a write-capable agent secret, driving the one-time claim if needed.
+     *
+     * The claim is done entirely over the playit HTTP API (no playit-cli), so it
+     * works identically on Windows, WSL, Linux and macOS. The agent binary is only
+     * needed later, for the traffic relay.
+     */
     async ensureSecret(callbacks = {}) {
         const existing = this.getSecret();
         if (existing)
             return existing;
-        await this.ensureBinary();
+        // A claim code is just a short random hex string generated client-side.
+        const code = crypto.randomBytes(5).toString('hex');
+        const claimBody = { code, agent_type: 'self-managed', version: 'mcpanel 1.0' };
         callbacks.onStatus?.('Generating a new agent claim code...');
-        const code = (await this.runCli(['claim', 'generate'])).replace(/[^a-f0-9]/gi, '');
-        if (!code)
-            throw new Error('Failed to generate a claim code.');
-        const url = (await this.runCli(['claim', 'url', code, '--name', 'mcpanel', '--type', 'self-managed'])).trim();
+        await this.apiClaim('/claim/setup', claimBody);
+        const url = `https://playit.gg/claim/${code}`;
         this.tunnelStatus.claimUrl = url;
         callbacks.onClaimUrl?.(url);
-        callbacks.onStatus?.('Waiting for the agent to be claimed (this only happens once)...');
-        const secret = await this.exchangeClaim(code);
+        // Poll setup (which also keeps the code alive) until the user approves.
+        callbacks.onStatus?.('Waiting for you to approve the agent in your browser (this only happens once)...');
+        const deadline = Date.now() + 5 * 60 * 1000; // 5 minutes
+        let approved = false;
+        while (Date.now() < deadline) {
+            await this.sleep(3000);
+            const res = await this.apiClaim('/claim/setup', claimBody);
+            const status = typeof res.data === 'string' ? res.data : '';
+            if (status === 'UserAccepted') {
+                approved = true;
+                break;
+            }
+            if (status === 'UserRejected') {
+                this.tunnelStatus.claimUrl = null;
+                throw new Error('Claim was rejected in the browser. Run /setup to try again.');
+            }
+        }
+        if (!approved) {
+            this.tunnelStatus.claimUrl = null;
+            throw new Error('Timed out waiting for approval. Open the link, click Approve, then run /setup again.');
+        }
+        // Exchange the approved code for the 64-char agent secret.
+        callbacks.onStatus?.('Approved! Retrieving your agent secret...');
+        let secret = '';
+        for (let i = 0; i < 10 && !secret; i++) {
+            const ex = await this.apiClaim('/claim/exchange', { code });
+            const match = JSON.stringify(ex.data ?? '').match(/[a-f0-9]{64}/i);
+            if (ex.status === 'success' && match)
+                secret = match[0].toLowerCase();
+            else
+                await this.sleep(2000);
+        }
+        if (!secret) {
+            this.tunnelStatus.claimUrl = null;
+            throw new Error('Could not retrieve the agent secret after approval. Run /setup to try again.');
+        }
         this.configManager.setPlayitSecret(secret);
         this.tunnelStatus.claimUrl = null;
         callbacks.onStatus?.('Agent claimed and linked. Secret saved — future tunnels are fully automatic.');
         return secret;
     }
-    /** Spawns `claim exchange` and resolves once a 64-char hex secret is printed. */
-    exchangeClaim(code) {
-        return new Promise((resolve, reject) => {
-            const cliPath = this.getCliPath();
-            const child = (0, child_process_1.spawn)(cliPath, ['claim', 'exchange', code, '--wait', '0'], {
-                cwd: path.dirname(cliPath),
-                stdio: ['ignore', 'pipe', 'pipe'],
-            });
-            this.claimProcess = child;
-            let buffer = '';
-            const scan = (data) => {
-                buffer += stripAnsi(data.toString());
-                const match = buffer.match(/[a-f0-9]{64}/i);
-                if (match) {
-                    this.claimProcess = null;
-                    try {
-                        child.kill();
-                    }
-                    catch { /* ignore */ }
-                    resolve(match[0].toLowerCase());
-                }
-            };
-            child.stdout?.on('data', scan);
-            child.stderr?.on('data', scan);
-            child.on('close', (codeExit) => {
-                if (this.claimProcess === child) {
-                    this.claimProcess = null;
-                    const match = buffer.match(/[a-f0-9]{64}/i);
-                    if (match)
-                        resolve(match[0].toLowerCase());
-                    else
-                        reject(new Error(`Claim was not completed (exit ${codeExit}). Visit the link, then try again.`));
-                }
-            });
-            child.on('error', (err) => { this.claimProcess = null; reject(err); });
-        });
-    }
     // ---------------------------------------------------------------------------
     // 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);
@@ -351,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.1",
+  "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": {
@@ -18,6 +18,7 @@
     "dev": "ts-node src/index.ts",
     "prod": "node dist/index.js",
     "prepublishOnly": "npm run build",
+    "push": "node scripts/push.js",
     "install:global": "npm run build && npm install -g ."
   },
   "keywords": [