@powernukkitx/cli 0.0.1

package/dist/commands/backup.d.ts

@@ -0,0 +1 @@
+export declare function backupCmd(): Promise<void>;

package/dist/commands/backup.js

@@ -0,0 +1,74 @@
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { mkdir, cp, readdir } from 'node:fs/promises';
+import { cwd } from 'node:process';
+import { confirm } from '@inquirer/prompts';
+import { header, success, error, info, highlight, step } from '../utils/logger.js';
+import { t } from '../lang/index.js';
+import { resolveServerDir } from '../utils/server.js';
+import { pauseForExit } from '../utils/pause.js';
+const IGNORE = new Set(['logs', 'cache', 'crash-reports', 'backups', 'powernukkitx.jar.old']);
+function getDirSize(dir) {
+    let total = 0;
+    try {
+        const items = readdirSync(dir);
+        for (const item of items) {
+            const full = join(dir, item);
+            const s = statSync(full);
+            if (s.isDirectory())
+                total += getDirSize(full);
+            else
+                total += s.size;
+        }
+    }
+    catch { /* ignore */ }
+    return total;
+}
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+export async function backupCmd() {
+    const serverPath = await resolveServerDir(t('backup.selectServer'));
+    if (!serverPath) {
+        error(t('backup.noServer'));
+        await pauseForExit();
+        return;
+    }
+    if (serverPath === cwd()) {
+        const ok = await confirm({
+            message: t('backup.backupCurrent', highlight(serverPath)),
+            default: true,
+        });
+        if (!ok) {
+            info(t('backup.cancelled'));
+            await pauseForExit();
+            return;
+        }
+    }
+    header(`💾 ${t('backup.title')}`);
+    step(t('backup.collecting'));
+    const size = getDirSize(serverPath);
+    info(t('backup.estimatedSize', formatSize(size)));
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const backupDir = join(serverPath, 'backups');
+    const destDir = join(backupDir, `pnx-backup-${timestamp}`);
+    await mkdir(destDir, { recursive: true });
+    step(t('backup.copying'));
+    const items = await readdir(serverPath);
+    let count = 0;
+    for (const item of items) {
+        if (IGNORE.has(item) || item.startsWith('.'))
+            continue;
+        const src = join(serverPath, item);
+        const dst = join(destDir, item);
+        await cp(src, dst, { recursive: true, force: true });
+        count++;
+    }
+    const finalSize = getDirSize(destDir);
+    success(t('backup.done', destDir, formatSize(finalSize)));
+    await pauseForExit();
+}

package/dist/commands/config.d.ts

@@ -0,0 +1 @@
+export declare function configCmd(): Promise<void>;

package/dist/commands/config.js

@@ -0,0 +1,114 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import { header, error, info, highlight, dim } from '../utils/logger.js';
+import { t } from '../lang/index.js';
+import { resolveServerDir } from '../utils/server.js';
+import { pauseForExit } from '../utils/pause.js';
+export async function configCmd() {
+    const serverPath = await resolveServerDir();
+    if (!serverPath) {
+        error(t('config.noServer'));
+        info(t('config.hintInit'));
+        await pauseForExit();
+        return;
+    }
+    // Prefer pnx.yml, fallback to server.properties
+    let configPath = join(serverPath, 'pnx.yml');
+    if (!existsSync(configPath)) {
+        configPath = join(serverPath, 'server.properties');
+        if (!existsSync(configPath)) {
+            error(t('config.notFound'));
+            info(t('config.hintGenerate'));
+            await pauseForExit();
+            return;
+        }
+    }
+    const isYml = configPath.endsWith('.yml');
+    header(`⚙️ ${t('config.title')} ${dim(isYml ? '(pnx.yml)' : '(server.properties)')}`);
+    let content = readFileSync(configPath, 'utf-8');
+    // Strip BOM
+    if (content.charCodeAt(0) === 0xFEFF)
+        content = content.slice(1);
+    const lines = content.split('\n');
+    if (isYml) {
+        // Display YAML with syntax highlighting
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.trim() === '' || line.trim().startsWith('#')) {
+                if (line.trim().startsWith('#')) {
+                    console.log(`  ${dim(line)}`);
+                }
+                else {
+                    console.log();
+                }
+                continue;
+            }
+            // Key: value or nested key
+            const indent = line.match(/^(\s*)/)?.[1] || '';
+            const trimmed = line.trim();
+            const colonIdx = trimmed.indexOf(':');
+            if (colonIdx > 0) {
+                const key = trimmed.slice(0, colonIdx);
+                const rest = trimmed.slice(colonIdx + 1).trim();
+                const suffix = rest
+                    ? ` ${colorYamlValue(rest)}`
+                    : '';
+                const prefix = indent ? chalk.dim(indent) : '';
+                console.log(`  ${prefix}${chalk.hex('#6C8EBF')(key)}:${suffix}`);
+            }
+            else {
+                console.log(`  ${chalk.dim(indent)}${chalk.white(trimmed)}`);
+            }
+        }
+    }
+    else {
+        // Display server.properties with highlighting
+        let inSection = false;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.startsWith('#') || line.trim() === '') {
+                const trimmed = line.replace(/^#\s*/, '').trim();
+                if (trimmed && !inSection) {
+                    console.log(`\n  ${dim(trimmed)}`);
+                    inSection = true;
+                }
+                continue;
+            }
+            inSection = false;
+            const eqIdx = line.indexOf('=');
+            if (eqIdx > 0) {
+                const key = line.slice(0, eqIdx).trim();
+                const value = line.slice(eqIdx + 1).trim();
+                console.log(`  ${highlight(key)} ${dim('=')} ${colorPropsValue(value)}`);
+            }
+        }
+    }
+    console.log(`\n  ${dim('─'.repeat(40))}`);
+    info(t('config.editHint', highlight(configPath)));
+    await pauseForExit();
+}
+function colorYamlValue(val) {
+    if (val === 'true')
+        return chalk.green(val);
+    if (val === 'false')
+        return chalk.red(val);
+    if (/^\d+(\.\d+)?$/.test(val))
+        return chalk.cyan(val);
+    if (val.startsWith('[') || val.startsWith('-'))
+        return chalk.hex('#E040FB')(val);
+    if (val.startsWith('"') && val.endsWith('"'))
+        return chalk.green(val);
+    if (val.startsWith("'") && val.endsWith("'"))
+        return chalk.green(val);
+    return chalk.white(val);
+}
+function colorPropsValue(val) {
+    if (val === 'true' || val === 'on')
+        return chalk.green(val);
+    if (val === 'false' || val === 'off')
+        return chalk.red(val);
+    if (/^\d+$/.test(val))
+        return chalk.cyan(val);
+    return chalk.white(val);
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1 @@
+export declare function doctorCmd(): Promise<void>;

package/dist/commands/doctor.js

@@ -0,0 +1,119 @@
+import { existsSync, statSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { spawn } from 'node:child_process';
+import { createSocket } from 'node:dgram';
+import { header, success, error, info, warn, highlight, dim, step, divider } from '../utils/logger.js';
+import { t } from '../lang/index.js';
+import { resolveServerDir } from '../utils/server.js';
+import { getInstalledPlugins } from '../utils/plugins.js';
+import { pauseForExit } from '../utils/pause.js';
+function checkPort(port) {
+    return new Promise((resolve) => {
+        const socket = createSocket('udp4');
+        socket.once('error', () => { socket.close(); resolve(false); });
+        socket.bind(port, '0.0.0.0', () => { socket.close(); resolve(true); });
+    });
+}
+function checkJavaVersion() {
+    return new Promise((resolve) => {
+        const java = process.env.JAVA_HOME
+            ? join(process.env.JAVA_HOME, 'bin', 'java')
+            : 'java';
+        const child = spawn(java, ['-version']);
+        let output = '';
+        child.on('error', () => resolve({ ok: false, version: '?', path: java }));
+        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: output.split('\n')[0]?.trim() || String(ver), path: java });
+            }
+            else {
+                resolve({ ok: false, version: '?', path: java });
+            }
+        });
+    });
+}
+export async function doctorCmd() {
+    header(`🩺 ${t('doctor.title')}`);
+    // Java check
+    step(t('doctor.checkingJava'));
+    const java = await checkJavaVersion();
+    if (java.ok) {
+        success(t('doctor.javaOk', java.version));
+    }
+    else {
+        warn(`Java ${highlight('21+')} required — ${dim(java.path)}`);
+    }
+    // Server detection
+    step(t('doctor.checkingServer'));
+    const serverPath = await resolveServerDir();
+    if (!serverPath) {
+        error(t('doctor.serverNotFound'));
+        await pauseForExit();
+        return;
+    }
+    success(`${t('doctor.serverFound')} ${dim(serverPath)}`);
+    // JAR check
+    step(t('doctor.checkingJar'));
+    const jarPath = join(serverPath, 'powernukkitx.jar');
+    if (existsSync(jarPath)) {
+        const size = statSync(jarPath).size;
+        const sizeMb = (size / 1024 / 1024).toFixed(1);
+        success(t('doctor.jarOk', sizeMb));
+    }
+    else {
+        error(t('doctor.jarMissing'));
+    }
+    // pnx.yml check
+    step(t('doctor.checkingConfig'));
+    const ymlPath = join(serverPath, 'pnx.yml');
+    const propsPath = join(serverPath, 'server.properties');
+    if (existsSync(ymlPath)) {
+        success(t('doctor.configFound'));
+    }
+    else if (existsSync(propsPath)) {
+        info(t('doctor.configLegacy'));
+    }
+    else {
+        warn(t('doctor.configMissing'));
+    }
+    // plugins dir
+    step(t('doctor.checkingPlugins'));
+    const pluginsDir = join(serverPath, 'plugins');
+    if (existsSync(pluginsDir)) {
+        const files = readdirSync(pluginsDir).filter(f => f.endsWith('.jar'));
+        success(t('doctor.pluginsOk', String(files.length)));
+        // Check for updates
+        const tracked = await getInstalledPlugins();
+        if (tracked.length > 0) {
+            info(t('doctor.pluginCheckHint', 'pnx plugin update'));
+        }
+    }
+    else {
+        info(t('doctor.pluginsMissing'));
+    }
+    // worlds dir
+    step(t('doctor.checkingWorlds'));
+    const worldsDir = join(serverPath, 'worlds');
+    if (existsSync(worldsDir)) {
+        const worlds = readdirSync(worldsDir).filter(f => statSync(join(worldsDir, f)).isDirectory());
+        info(t('doctor.worldsFound', String(worlds.length)));
+    }
+    else {
+        info(t('doctor.worldsMissing'));
+    }
+    // Port check
+    step(t('doctor.checkingPort'));
+    const portFree = await checkPort(19132);
+    if (portFree) {
+        success(t('doctor.portFree'));
+    }
+    else {
+        warn(t('doctor.portInUse', '19132'));
+    }
+    divider();
+    success(t('doctor.done'));
+    await pauseForExit();
+}

package/dist/commands/info.d.ts

@@ -0,0 +1 @@
+export declare function infoCmd(): Promise<void>;

package/dist/commands/info.js

@@ -0,0 +1,36 @@
+import { existsSync } from 'node:fs';
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import { header, info, warn, table, highlight } from '../utils/logger.js';
+import { t } from '../lang/index.js';
+import { resolveServerDir } from '../utils/server.js';
+import { pauseForExit } from '../utils/pause.js';
+export async function infoCmd() {
+    header(`📊 ${t('info.title')}`);
+    const serverPath = await resolveServerDir();
+    const jarExists = serverPath !== null;
+    let plugins = [];
+    let worlds = [];
+    if (serverPath && existsSync(join(serverPath, 'plugins'))) {
+        const files = await readdir(join(serverPath, 'plugins'));
+        plugins = files.filter((f) => f.endsWith('.jar'));
+    }
+    if (serverPath && existsSync(join(serverPath, 'worlds'))) {
+        worlds = await readdir(join(serverPath, 'worlds'));
+    }
+    table([
+        [t('info.status'), jarExists ? chalk.green(`✔ ${t('info.installed')}`) : chalk.red(`✘ ${t('info.notInstalled')}`)],
+        [t('info.serverDir'), serverPath ? highlight(serverPath) : chalk.dim('—')],
+        [t('info.plugins'), `${plugins.length} ${t('info.plugins')}`],
+        [t('info.worlds'), `${worlds.length} ${t('info.worlds')}`],
+    ]);
+    console.log();
+    if (jarExists) {
+        info(t('info.ready'));
+    }
+    else {
+        warn(t('info.notInitialized'));
+    }
+    await pauseForExit();
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,4 @@
+export declare function initCmd(options: {
+    dir?: string;
+    dev?: boolean;
+}): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,73 @@
+import { existsSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { cwd } from 'node:process';
+import { input, confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { header, success, dim, step, error } from '../utils/logger.js';
+import { t } from '../lang/index.js';
+import { getLatestRelease, findAsset, downloadFile, getStartScripts } from '../utils/github.js';
+import { startCmd } from './start.js';
+export async function initCmd(options) {
+    header(`⚡ ${t('init.title')}`);
+    const targetDir = options.dir
+        ? resolve(cwd(), options.dir)
+        : resolve(cwd(), await input({
+            message: t('init.promptDir'),
+            default: 'pnx-server',
+            validate: (v) => {
+                if (!v.trim())
+                    return 'Path is required';
+                const p = resolve(cwd(), v);
+                if (existsSync(join(p, 'powernukkitx.jar'))) {
+                    return t('init.alreadyExists');
+                }
+                return true;
+            },
+        }));
+    const serverDir = resolve(cwd(), targetDir);
+    if (existsSync(join(serverDir, 'powernukkitx.jar'))) {
+        error(t('init.alreadyExists'));
+        process.exit(1);
+    }
+    try {
+        step(t('init.fetchingInfo'));
+        const release = await getLatestRelease();
+        success(`${t('init.latestVersion')}: ${chalk.bold(release.tag_name)}`);
+        const asset = await findAsset(release, 'powernukkitx.jar');
+        if (!asset) {
+            error('powernukkitx.jar not found in latest release.');
+            process.exit(1);
+        }
+        await mkdir(serverDir, { recursive: true });
+        const jarDest = join(serverDir, 'powernukkitx.jar');
+        await downloadFile(asset.browser_download_url, jarDest, 'powernukkitx.jar');
+        success(t('init.downloaded', (asset.size / 1024 / 1024).toFixed(1)));
+        step(t('init.downloadingScripts'));
+        const scripts = getStartScripts();
+        for (const script of scripts) {
+            const dest = join(serverDir, script.name);
+            await downloadFile(script.url, dest, script.name);
+        }
+        success(t('init.scriptsDownloaded'));
+        console.log(`\n  ${chalk.hex('#FFB347').bold(t('init.nextSteps'))}`);
+        console.log(`  ${dim('  1.')} ${chalk.hex('#FFB347')(`cd ${serverDir}`)}`);
+        console.log(`  ${dim('  2.')} ${chalk.hex('#FFB347')('pnx start')}   ${dim(`# ${t('init.nextStepStart')}`)}`);
+        console.log(`  ${dim('  3.')} ${chalk.hex('#FFB347')('pnx plugin list')}   ${dim(`# ${t('init.nextStepPlugins')}`)}`);
+        console.log(`  ${dim('  4.')} ${chalk.hex('#FFB347')('pnx plugin install <name>')}   ${dim(`# ${t('init.nextStepInstall')}`)}`);
+        console.log();
+        success(t('init.success'));
+        const launchNow = await confirm({
+            message: t('init.launchPrompt'),
+            default: false,
+        });
+        if (launchNow) {
+            console.log();
+            await startCmd({});
+        }
+    }
+    catch (err) {
+        error(err.message);
+        process.exit(1);
+    }
+}

package/dist/commands/plugin.d.ts

@@ -0,0 +1,12 @@
+export declare function pluginListCmd(options?: {
+    sort?: string;
+    limit?: number;
+    page?: number;
+    q?: string;
+}): Promise<void>;
+export declare function pluginSearchCmd(term?: string): Promise<void>;
+export declare function pluginInfoCmd(slug?: string): Promise<void>;
+export declare function pluginInstallCmd(names: string[]): Promise<void>;
+export declare function pluginInstalledCmd(): Promise<void>;
+export declare function pluginRemoveCmd(names: string[]): Promise<void>;
+export declare function pluginUpdateCmd(names: string[]): Promise<void>;