@powernukkitx/cli 0.0.3 → 1.0.1

package/dist/commands/start.js

@@ -1,108 +1,74 @@
-import { existsSync } from 'node:fs';
-import { spawn } from 'node:child_process';
-import { join } from 'node:path';
-import { cwd } from 'node:process';
-import { input, confirm } from '@inquirer/prompts';
-import chalk from 'chalk';
-import { header, error, info, highlight, dim, success, step } from '../utils/logger.js';
-import { t } from '../lang/index.js';
-import { getDefaultJavaArgs, getJavaEnv } from '../utils/github.js';
-import { resolveServerDir } from '../utils/server.js';
-import { initCmd } from './init.js';
-function findJava() {
-    const javaHome = process.env.JAVA_HOME;
-    if (javaHome) {
-        return join(javaHome, 'bin', 'java');
-    }
-    return 'java';
-}
-function checkJavaVersion() {
-    return new Promise((resolve) => {
-        const java = findJava();
-        const child = spawn(java, ['-version']);
-        let output = '';
-        child.on('error', () => resolve({ ok: false, version: '?' }));
-        child.stderr.on('data', (data) => {
-            output += data.toString();
-        });
-        child.on('close', () => {
-            const match = output.match(/(?:openjdk|java) version "?(?:1\.)?(\d+)/);
-            if (match) {
-                const ver = parseInt(match[1], 10);
-                resolve({ ok: ver >= 21, version: String(ver) });
-            }
-            else {
-                resolve({ ok: false, version: '?' });
-            }
-        });
-    });
-}
-export async function startCmd(options) {
-    const serverPath = options.dir ? join(cwd(), options.dir) : ((await resolveServerDir()) || cwd());
-    if (options.dir) {
-        process.chdir(serverPath);
-    }
-    if (!existsSync(join(serverPath, 'powernukkitx.jar'))) {
-        info(t('start.jarNotFound'));
-        const createNow = await confirm({
-            message: t('start.createPrompt'),
-            default: true,
-        });
-        if (createNow) {
-            await initCmd({ dir: serverPath });
-            return;
-        }
-        error(t('start.jarNotFound'));
-        process.exit(1);
-    }
-    header(`🚀 ${t('start.title')}`);
-    let memory = options.memory || '2G';
-    let autoRestart = options.restart ?? false;
-    if (options.interactive) {
-        memory = await input({
-            message: 'Memory allocation',
-            default: memory,
-        });
-    }
-    step(t('start.checkingJava'));
-    const javaCheck = await checkJavaVersion();
-    if (!javaCheck.ok) {
-        error(t('start.javaNotFound'));
-        process.exit(1);
-    }
-    success(t('start.javaVersion', javaCheck.version));
-    const java = findJava();
-    const javaArgs = getDefaultJavaArgs();
-    const cmdArgs = [
-        `-Xms${memory}`,
-        `-XX:MaxRAMPercentage=75.0`,
-        ...javaArgs,
-        '-jar', 'powernukkitx.jar',
-    ];
-    if (options.generateOnly) {
-        console.log(`\n  ${highlight.bold(t('start.generatedCommand'))}`);
-        console.log(`  ${chalk.cyan(`${java} ${cmdArgs.join(' ')}`)}\n`);
-        return;
-    }
-    console.log(`\n  ${dim('JVM:')}     ${highlight(java)}`);
-    console.log(`  ${dim('Memory:')}  ${highlight(memory)}`);
-    console.log(`  ${dim('Restart:')} ${highlight(autoRestart ? 'Yes' : 'No')}\n`);
-    const runServer = () => {
-        const child = spawn(java, cmdArgs, {
-            stdio: 'inherit',
-            env: getJavaEnv(),
-            cwd: serverPath,
-        });
-        child.on('exit', (code) => {
-            if (code !== 0 && autoRestart) {
-                info(t('start.restarting'));
-                runServer();
-            }
-            else if (code !== 0) {
-                error(t('start.stopped', String(code ?? '?')));
-                process.exit(code ?? 0);
-            }
-        });
-    };
-    runServer();
-}
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { cwd } from 'node:process';
+import { spawn } from 'node:child_process';
+import { defineCommand } from 'citty';
+import { intro, outro, log, spin } from '../ui/output.js';
+import { promptConfirm } from '../ui/prompts.js';
+import { resolveServerDir, checkJava, findJava, buildLaunchArgs, javaEnv } from '../services/server.js';
+import { savePid } from '../services/process.js';
+import { JAR_NAME } from '../infra/paths.js';
+export async function runStart(opts) {
+    const serverPath = opts.dir
+        ? (opts.dir.includes(':') || opts.dir.startsWith('/') ? opts.dir : join(cwd(), opts.dir))
+        : (await resolveServerDir()) ?? cwd();
+    if (!existsSync(join(serverPath, JAR_NAME))) {
+        log.warn("No server found here");
+        if (!(await promptConfirm("Create a server now?", true)))
+            process.exit(0);
+        const { initCmd } = await import('./init.js');
+        await initCmd.run({ args: { dir: serverPath } });
+        return;
+    }
+    intro(`🚀 ${"Start server"}`);
+    const sp = spin("Checking Java...");
+    const java = await checkJava();
+    if (!java.ok) {
+        sp.fail("Java 21+ required — https://adoptium.net/");
+        process.exit(1);
+    }
+    sp.stop(`Java ${String(java.version)} detected`);
+    const mem = opts.memory ?? '2G';
+    const cmdArgs = buildLaunchArgs(mem);
+    const javaExe = findJava();
+    if (opts.dryRun) {
+        log.info(`${javaExe} ${cmdArgs.join(' ')}`);
+        outro("Command generated");
+        return;
+    }
+    log.step(`${"Starting..."} (memory: ${mem})`);
+    const run = () => {
+        const child = spawn(javaExe, cmdArgs, { stdio: 'inherit', env: javaEnv(), cwd: serverPath });
+        if (child.pid)
+            savePid(child.pid, serverPath);
+        log.success(`Server running (PID ${String(child.pid)})`);
+        child.on('exit', code => {
+            if (code !== 0 && opts.restart) {
+                log.warn("Restarting...");
+                run();
+            }
+            else {
+                log.info(`Server stopped (code ${String(code ?? '?')})`);
+                process.exit(code ?? 0);
+            }
+        });
+    };
+    run();
+}
+export const startCmd = defineCommand({
+    meta: { description: 'Start the PowerNukkitX server' },
+    args: {
+        dir: { type: 'string', description: 'Server directory' },
+        memory: { type: 'string', description: 'Memory (e.g. 2G)', default: '2G' },
+        restart: { type: 'boolean', description: 'Auto-restart on crash', default: false },
+        'dry-run': { type: 'boolean', description: 'Print command without running', default: false },
+    },
+    async run({ args }) {
+        await runStart({
+            dir: args.dir,
+            memory: args.memory,
+            restart: args.restart,
+            dryRun: args['dry-run'],
+        });
+    },
+});

package/dist/commands/stop.d.ts

@@ -0,0 +1,2 @@
+import type { CommandDef } from 'citty';
+export declare const stopCmd: CommandDef;

package/dist/commands/stop.js

@@ -0,0 +1,26 @@
+import { defineCommand } from 'citty';
+import { intro, outro, log, spin } from '../ui/output.js';
+import { loadPid, clearPid, killProcess, isAlive } from '../services/process.js';
+export async function runStop() {
+    intro(`⏹ ${"Stop server"}`);
+    const pid = await loadPid();
+    if (!pid || !isAlive(pid.pid)) {
+        log.warn("No server running");
+        await clearPid();
+        return;
+    }
+    const sp = spin(`Stopping server (PID ${String(pid.pid)})...`);
+    const ok = await killProcess(pid.pid);
+    await clearPid();
+    if (ok) {
+        sp.stop("Server stopped");
+        outro("Server stopped");
+    }
+    else
+        sp.fail("Failed to stop");
+}
+export const stopCmd = defineCommand({
+    meta: { description: 'Stop the running PowerNukkitX server' },
+    args: {},
+    run: () => runStop(),
+});

package/dist/commands/update.d.ts

@@ -1,5 +1,2 @@
-export declare function updateCmd(options: {
-    dir?: string;
-    dev?: boolean;
-    force?: boolean;
-}): Promise<void>;
+import type { CommandDef } from 'citty';
+export declare const updateCmd: CommandDef;

package/dist/commands/update.js

@@ -1,55 +1,34 @@
-import { existsSync } from 'node:fs';
-import { rename } from 'node:fs/promises';
-import { join } from 'node:path';
-import { cwd } from 'node:process';
-import { confirm } from '@inquirer/prompts';
-import chalk from 'chalk';
-import { header, success, error, info, step } from '../utils/logger.js';
-import { t } from '../lang/index.js';
-import { getLatestRelease, findAsset, downloadFile } from '../utils/github.js';
-import { resolveServerDir } from '../utils/server.js';
-import { initCmd } from './init.js';
-export async function updateCmd(options) {
-    const serverPath = options.dir ? join(cwd(), options.dir) : ((await resolveServerDir()) || cwd());
-    if (!existsSync(join(serverPath, 'powernukkitx.jar'))) {
-        info(t('update.notFound'));
-        const createNow = await confirm({
-            message: t('start.createPrompt'),
-            default: true,
-        });
-        if (createNow) {
-            await initCmd({ dir: serverPath });
-            return;
-        }
-        error('powernukkitx.jar not found. Run "pnx init" first.');
-        process.exit(1);
-    }
-    header(`🔄 ${t('update.title')}`);
-    process.chdir(serverPath);
-    try {
-        step(t('update.checking'));
-        const release = await getLatestRelease();
-        const asset = await findAsset(release, 'powernukkitx.jar');
-        if (!asset) {
-            error('powernukkitx.jar not found in latest release.');
-            process.exit(1);
-        }
-        success(`${t('update.available')} ${chalk.bold(release.tag_name)}`);
-        if (existsSync('powernukkitx.jar.old') && !options.force) {
-            info('Old backup found, replacing...');
-        }
-        step(t('update.saving'));
-        await rename('powernukkitx.jar', 'powernukkitx.jar.old');
-        success(t('update.saved'));
-        await downloadFile(asset.browser_download_url, 'powernukkitx.jar', 'powernukkitx.jar');
-        success(t('update.done'));
-        console.log();
-        success(t('update.done'));
-        info(t('update.restartHint'));
-        info(t('update.deleteOldHint'));
-    }
-    catch (err) {
-        error(err.message);
-        process.exit(1);
-    }
-}
+import { rename } from 'node:fs/promises';
+import { join } from 'node:path';
+import { defineCommand } from 'citty';
+import { intro, outro, log, spin, progress } from '../ui/output.js';
+import { resolveServerDir } from '../services/server.js';
+import { getLatestRelease, downloadCore } from '../services/release.js';
+import { JAR_NAME } from '../infra/paths.js';
+export async function runUpdate(force = false) {
+    intro(`🔄 ${"Update PowerNukkitX"}`);
+    const serverPath = await resolveServerDir();
+    if (!serverPath) {
+        log.error("No server found");
+        process.exit(1);
+    }
+    const sp = spin("Checking for updates...");
+    const release = await getLatestRelease(force);
+    sp.stop(`New version available: ${release.tag}`);
+    const jarPath = join(serverPath, JAR_NAME);
+    log.step("Backing up old version...");
+    await rename(jarPath, `${jarPath}.old`).catch(() => { });
+    log.step("Downloading...");
+    await downloadCore(release, jarPath, pct => progress(pct, JAR_NAME));
+    log.success("Update complete!");
+    log.info("Restart the server to apply changes");
+    outro("Update complete!");
+}
+export const updateCmd = defineCommand({
+    meta: { description: 'Update PowerNukkitX to the latest version' },
+    args: {
+        force: { type: 'boolean', description: 'Force update', default: false },
+        dev: { type: 'boolean', description: 'Dev version', default: false },
+    },
+    run: ({ args }) => runUpdate(args.force),
+});

package/dist/commands/use.d.ts

@@ -0,0 +1,2 @@
+import type { CommandDef } from 'citty';
+export declare const useCmd: CommandDef;

package/dist/commands/use.js

@@ -0,0 +1,39 @@
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { cwd } from 'node:process';
+import { defineCommand } from 'citty';
+import { intro, outro, log } from '../ui/output.js';
+import { promptSelect, promptText } from '../ui/prompts.js';
+import { detectServers, setDefaultServer } from '../services/server.js';
+import { JAR_NAME } from '../infra/paths.js';
+export const useCmd = defineCommand({
+    meta: { description: 'Set the default PowerNukkitX server directory' },
+    args: {
+        dir: { type: 'positional', description: 'Server path', required: false },
+        clear: { type: 'boolean', description: 'Remove default server', default: false },
+    },
+    async run({ args }) {
+        intro(`📌 ${"Default server"}`);
+        if (args.clear) {
+            await setDefaultServer(null);
+            log.success("Default server cleared");
+            outro("Default server cleared");
+            return;
+        }
+        let target = args.dir;
+        if (!target) {
+            const servers = detectServers();
+            target = servers.length > 0
+                ? await promptSelect("Select a server:", servers.map(s => ({ value: s, label: s })))
+                : await promptText({ message: "Server path:", defaultValue: cwd() });
+        }
+        const absPath = resolve(cwd(), target);
+        if (!existsSync(join(absPath, JAR_NAME))) {
+            log.error(`powernukkitx.jar not found in: ${absPath}`);
+            process.exit(1);
+        }
+        await setDefaultServer(absPath);
+        log.success(`Default server set: ${absPath}`);
+        outro(`Default server set: ${absPath}`);
+    },
+});

package/dist/infra/http.js

@@ -0,0 +1,119 @@
+import https from 'node:https';
+import http from 'node:http';
+import { createWriteStream } from 'node:fs';
+const REDIRECT_CODES = [301, 302, 303, 307, 308];
+export class NetworkError extends Error {
+    statusCode;
+    constructor(message, statusCode) {
+        super(message);
+        this.statusCode = statusCode;
+        this.name = 'NetworkError';
+    }
+}
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+function get(url, timeoutMs, headers) {
+    return new Promise((resolve, reject) => {
+        const mod = url.startsWith('https') ? https : http;
+        const req = mod.get(url, { timeout: timeoutMs, headers }, (res) => {
+            let body = '';
+            res.on('data', (chunk) => (body += chunk.toString()));
+            res.on('end', () => resolve({ statusCode: res.statusCode ?? 0, location: res.headers.location, body }));
+            res.on('error', reject);
+        });
+        req.on('error', reject);
+        req.on('timeout', function () {
+            this.destroy();
+            reject(new NetworkError('Request timed out'));
+        });
+    });
+}
+async function getFollow(url, timeout, headers, redirects = 5) {
+    if (redirects <= 0)
+        throw new NetworkError('Too many redirects');
+    const res = await get(url, timeout, { 'User-Agent': 'pnx-cli', ...headers });
+    if (REDIRECT_CODES.includes(res.statusCode) && res.location) {
+        return getFollow(res.location, timeout, headers, redirects - 1);
+    }
+    if (res.statusCode !== 200)
+        throw new NetworkError(`HTTP ${res.statusCode}`, res.statusCode);
+    return res.body;
+}
+export async function fetchJSON(url, opts) {
+    const retries = opts?.retries ?? 3;
+    const timeout = opts?.timeout ?? 15_000;
+    const headers = opts?.headers ?? {};
+    let lastErr = new Error('Unknown error');
+    for (let attempt = 1; attempt <= retries; attempt++) {
+        try {
+            return JSON.parse(await getFollow(url, timeout, headers));
+        }
+        catch (err) {
+            lastErr = err;
+            if (attempt < retries) {
+                opts?.onRetry?.(lastErr.message, attempt, retries);
+                await sleep(2 ** (attempt - 1) * 1000);
+            }
+        }
+    }
+    throw lastErr;
+}
+function stream(url, dest, timeout, onData) {
+    return new Promise((resolve, reject) => {
+        const mod = url.startsWith('https') ? https : http;
+        const file = createWriteStream(dest);
+        const req = mod.get(url, { timeout, headers: { 'User-Agent': 'pnx-cli' } }, (res) => {
+            const code = res.statusCode ?? 0;
+            if (REDIRECT_CODES.includes(code) && res.headers.location) {
+                file.close();
+                resolve(stream(res.headers.location, dest, timeout, onData));
+                return;
+            }
+            if (code !== 200) {
+                file.close();
+                reject(new NetworkError(`HTTP ${code}`, code));
+                return;
+            }
+            const total = parseInt(res.headers['content-length'] || '0', 10);
+            res.on('data', (chunk) => onData(chunk, total));
+            res.pipe(file);
+            file.on('finish', () => { file.close(); resolve(); });
+            file.on('error', reject);
+        });
+        req.on('error', err => { file.close(); reject(err); });
+        req.on('timeout', function () {
+            this.destroy();
+            file.close();
+            reject(new NetworkError('Download timed out'));
+        });
+    });
+}
+export async function downloadFile(url, dest, opts) {
+    const retries = opts?.retries ?? 3;
+    const timeout = opts?.timeout ?? 120_000;
+    let lastErr = new Error('Unknown error');
+    for (let attempt = 1; attempt <= retries; attempt++) {
+        try {
+            let downloaded = 0;
+            let lastPct = -1;
+            await stream(url, dest, timeout, (chunk, total) => {
+                downloaded += chunk.length;
+                if (opts?.onProgress && total > 0) {
+                    const pct = Math.round((downloaded / total) * 100);
+                    if (pct !== lastPct && pct % 5 === 0) {
+                        opts.onProgress(pct, downloaded, total);
+                        lastPct = pct;
+                    }
+                }
+            });
+            return;
+        }
+        catch (err) {
+            lastErr = err;
+            if (attempt < retries) {
+                opts?.onRetry?.(lastErr.message, attempt, retries);
+                await sleep(2 ** (attempt - 1) * 1000);
+            }
+        }
+    }
+    throw lastErr;
+}

package/dist/infra/paths.js

@@ -0,0 +1,15 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export function pnxHome() {
+    return process.env.PNX_HOME || join(homedir(), '.pnx-cli');
+}
+export function storePath(name) {
+    return join(pnxHome(), name);
+}
+export const JAR_NAME = 'powernukkitx.jar';
+export const GITHUB_LATEST_RELEASE = 'https://api.github.com/repos/PowerNukkitX/PowerNukkitX/releases/latest';
+export const GITHUB_RELEASES = 'https://api.github.com/repos/PowerNukkitX/PowerNukkitX/releases';
+export const SCRIPTS_BASE = 'https://raw.githubusercontent.com/PowerNukkitX/scripts/master';
+export function apiBase() {
+    return (process.env.PNX_API_URL ?? 'https://api.powernukkitx.org').replace(/\/$/, '');
+}

package/dist/infra/store.js

@@ -0,0 +1,24 @@
+import { existsSync } from 'node:fs';
+import { readFile, writeFile, mkdir, rm } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { storePath } from './paths.js';
+export async function readJson(name, fallback) {
+    try {
+        const file = storePath(name);
+        if (existsSync(file))
+            return JSON.parse(await readFile(file, 'utf-8'));
+    }
+    catch { }
+    return fallback;
+}
+export async function writeJson(name, data) {
+    const file = storePath(name);
+    await mkdir(dirname(file), { recursive: true });
+    await writeFile(file, JSON.stringify(data, null, 2), 'utf-8');
+}
+export async function removeFile(name) {
+    try {
+        await rm(storePath(name));
+    }
+    catch { }
+}

package/dist/services/backup.js

@@ -0,0 +1,34 @@
+import { readdirSync, statSync } from 'node:fs';
+import { mkdir, cp, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+const IGNORE = new Set(['logs', 'cache', 'crash-reports', 'backups', '.git']);
+export function dirSize(dir) {
+    let total = 0;
+    try {
+        for (const f of readdirSync(dir)) {
+            const full = join(dir, f);
+            const s = statSync(full);
+            total += s.isDirectory() ? dirSize(full) : s.size;
+        }
+    }
+    catch { }
+    return total;
+}
+export function fmtSize(b) {
+    if (b < 1024)
+        return `${b} B`;
+    if (b < 1024 ** 2)
+        return `${(b / 1024).toFixed(1)} KB`;
+    return `${(b / 1024 / 1024).toFixed(1)} MB`;
+}
+export async function createBackup(serverDir) {
+    const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const destDir = join(serverDir, 'backups', `pnx-backup-${ts}`);
+    await mkdir(destDir, { recursive: true });
+    for (const item of await readdir(serverDir)) {
+        if (IGNORE.has(item) || item.startsWith('.'))
+            continue;
+        await cp(join(serverDir, item), join(destDir, item), { recursive: true, force: true });
+    }
+    return { path: destDir, size: dirSize(destDir) };
+}