@powernukkitx/cli 0.0.3 → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AzaleeX
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,177 +1,186 @@
 # pnx-cli
 
-PowerNukkitX CLI est un outil en ligne de commande pour gérer un serveur **Minecraft Bedrock** propulsé par **PowerNukkitX**.
+**PowerNukkitX CLI** - command line tool to manage a **Minecraft Bedrock** server powered by [PowerNukkitX](https://github.com/PowerNukkitX/PowerNukkitX).
 
-Il propose un menu interactif, la gestion des plugins, des outils de diagnostic, des sauvegardes, et des commandes rapides pour initialiser ou démarrer un serveur.
+Create, start, update and diagnose your server, manage plugins from the marketplace, all with a clean interface and an interactive menu.
+
+## Contents
+
+- [Installation](#installation)
+- [Requirements](#requirements)
+- [Quick start](#quick-start)
+- [Commands](#commands)
+- [Interactive mode](#interactive-mode)
+- [Global options](#global-options)
+- [Architecture](#architecture)
+- [Development](#development)
+- [Links](#links)
+- [License](#license)
 
 ## Installation
 
 ```bash
-npm install -g pnx-cli
+npm install -g @powernukkitx/cli
 ```
 
-Après installation, la commande disponible est `pnx`.
+The `pnx` command becomes available.
 
-## Prérequis
+## Requirements
 
-- [Node.js](https://nodejs.org/) **18 ou plus**
-- Un dossier de serveur PowerNukkitX si vous souhaitez gérer une installation existante
+- **Node.js 20.12+**
+- **Java 21+** to run the server ([Adoptium Temurin](https://adoptium.net/) recommended)
 
-## Démarrage rapide
-
-Lancer le menu interactif :
+## Quick start
 
 ```bash
+# Contextual interactive menu
 pnx
-```
 
-Afficher l’aide :
+# Create a server then start it
+pnx init --dir ./pnx-server
+pnx start --memory 4G
 
-```bash
+# Help
 pnx --help
+pnx <command> --help
 ```
 
-Choisir la langue :
-
-```bash
-pnx --lang fr
-```
-
-## Fonctionnalités
-
-- Initialiser un nouveau serveur PowerNukkitX
-- Démarrer le serveur avec options de mémoire et redémarrage automatique
-- Installer, lister, rechercher, mettre à jour et supprimer des plugins
-- Vérifier l’état du serveur avec un diagnostic intégré
-- Créer des sauvegardes du serveur
-- Consulter la configuration et les informations du serveur
-- Mettre à jour `powernukkitx.jar`
-- Utiliser l’interface en anglais ou en français
+## Commands
 
-## Commandes disponibles
+### `init` - create a server
 
-### Initialiser un serveur
+Downloads the latest `powernukkitx.jar` and the start scripts.
 
 ```bash
 pnx init --dir ./pnx-server
 ```
 
-Options :
+| Option | Description |
+|---|---|
+| `--dir <path>` | Target directory (prompted otherwise) |
+| `--dev` | Development build |
 
-- `-d, --dir <path>` : dossier cible
-- `--dev` : installer la version de développement
+### `start` - start the server
 
-### Démarrer le serveur
+Checks Java, builds optimized JVM arguments (generational ZGC, UTF-8) and launches the server.
 
 ```bash
 pnx start --memory 4G --restart
 ```
 
-Options :
+| Option | Description |
+|---|---|
+| `--dir <path>` | Server directory |
+| `--memory <size>` | Allocated memory, e.g. `2G`, `4G` (default `2G`) |
+| `--restart` | Auto restart on crash |
+| `--dry-run` | Print the command without running it |
 
-- `-g, --generate-only` : générer la commande de démarrage sans l’exécuter
-- `-r, --restart` : redémarrer automatiquement en cas de crash
-- `-m, --memory <size>` : mémoire allouée, par exemple `2G` ou `4G`
-- `-i, --interactive` : mode interactif avec prompts
+### `stop` - stop the server
 
-### Gérer les plugins
+Stops the server started through its stored PID.
 
 ```bash
-pnx plugin list
-pnx plugin search essentials
-pnx plugin info <slug>
-pnx plugin install <name>
-pnx plugin update
-pnx plugin remove <name>
-pnx plugin installed
+pnx stop
 ```
 
-Sous-commandes :
+### `update` - update the core
 
-- `install [names...]` : installer un plugin depuis le marketplace ou une URL `.jar`
-- `list` : afficher les plugins disponibles
-- `search [term]` : rechercher par nom, description ou auteur
-- `info [slug]` : afficher la fiche détaillée d’un plugin
-- `installed` : lister les plugins installés localement
-- `update [names...]` : mettre à jour les plugins installés
-- `remove [names...]` : supprimer des plugins installés
-
-### Mettre à jour le serveur
+Backs up the old jar as `.old` then downloads the latest version.
 
 ```bash
 pnx update --force
 ```
 
-Options :
+| Option | Description |
+|---|---|
+| `--force` | Force re-download (ignore cache) |
+| `--dev` | Development build |
 
-- `--dev` : installer la version de développement
-- `-f, --force` : forcer la mise à jour même si la version correspond
+### `plugin` - manage plugins
 
-### Diagnostics et utilitaires
+Official marketplace plus local tracking of installed versions.
 
 ```bash
-pnx doctor
-pnx backup
-pnx config
-pnx info
-pnx lang --set fr
+pnx plugin list                    # catalog
+pnx plugin search essentials       # search
+pnx plugin info <slug>             # details
+pnx plugin install <slug|url.jar>  # install (marketplace or .jar URL)
+pnx plugin installed               # local plugins
+pnx plugin update [slug]           # update
+pnx plugin remove [name]           # remove
 ```
 
-## Mode interactif
+Without an argument, `install`, `update` and `remove` offer an interactive selection.
 
-Si vous lancez `pnx` sans sous-commande, l’application ouvre un menu interactif pour :
+### Diagnostics and utilities
 
-- créer ou initialiser un serveur
-- démarrer le serveur
-- gérer les plugins
-- mettre à jour PowerNukkitX
-- lancer un diagnostic
-- effectuer une sauvegarde
-- changer la langue
+```bash
+pnx doctor          # Java, RAM, disk, port 19132, plugins/worlds
+pnx info            # status, path, plugins, worlds, RAM
+pnx backup          # timestamped server backup
+pnx config          # print pnx.yml / server.properties (colored)
+pnx use ./server    # set the default server
+pnx logs            # latest logs (with live follow)
+pnx console         # RCON console attached to the server
+```
 
-## Développement
+`doctor` and `info` accept `--json` for machine output.
 
-Installer les dépendances :
+## Interactive mode
 
-```bash
-npm install
-```
+Launched without a subcommand, `pnx` opens a **contextual menu** that:
 
-Compiler le projet :
+- detects state (server present, running, PID);
+- only offers relevant actions (create if missing, start if stopped, stop if running...);
+- routes to the existing commands.
 
 ```bash
-npm run build
+pnx
 ```
 
-Lancer la CLI localement :
+## Global options
 
-```bash
-npm start
-```
+| Option | Description |
+|---|---|
+| `--json` | Machine JSON output (disables decorative rendering) |
+| `--no-color` | Disable colors |
 
-Surveiller les changements TypeScript :
+CLI state is stored in `~/.pnx-cli/` (config, PID, installed plugins, version cache). Environment variables: `PNX_API_URL` (marketplace API base), `PNX_HOME` (state directory).
 
-```bash
-npm run dev
+## Architecture
+
+The code follows a layered architecture - thin commands, isolated business logic:
+
+```
+dist/
+  cli.js          entry point (citty) + global options
+  commands/       parse arguments -> call service -> render
+    plugin/       plugin subcommands
+  services/       pure business logic (release, server, process, plugins, backup)
+  infra/          http, JSON store (~/.pnx-cli), constants/endpoints
+  ui/             single output system (clack + chalk), prompts
 ```
 
-## Exécutables autonomes
+Rules: commands do no direct network/file access (everything goes through `services`/`infra`); services render nothing (they return data).
+
+**Stack**: [citty](https://github.com/unjs/citty) (routing), [@clack/prompts](https://github.com/bombshell-dev/clack) (prompts), [chalk](https://github.com/chalk/chalk) (colors).
 
-Le projet fournit aussi des scripts pour générer des exécutables Windows, Linux et macOS :
+## Development
+
+The shipped code lives in `dist/` (plain ES modules, no build step).
 
 ```bash
-npm run build:exe:win
-npm run build:exe:linux
-npm run build:exe:mac
+npm install       # dependencies
+npm start         # run dist/cli.js
+npm run check     # syntax check every file
+npm run smoke     # run pnx --help
 ```
 
-## Liens utiles
+## Links
 
-- Documentation PowerNukkitX : https://docs.powernukkitx.org
-- Dépôt PowerNukkitX : https://github.com/PowerNukkitX/PowerNukkitX
+- PowerNukkitX documentation: https://docs.powernukkitx.org
+- PowerNukkitX repository: https://github.com/PowerNukkitX/PowerNukkitX
 
-## Licence
+## License
 
 MIT
-
-

package/dist/cli.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from 'citty';
+import { setColorEnabled } from './ui/theme.js';
+if (process.argv.slice(2).includes('--no-color'))
+    setColorEnabled(false);
+const main = defineCommand({
+    meta: {
+        name: 'pnx',
+        version: '1.0.0',
+        description: 'PowerNukkitX CLI — Manage your Minecraft Bedrock servers',
+    },
+    subCommands: {
+        init: () => import('./commands/init.js').then(m => m.initCmd),
+        install: () => import('./commands/install.js').then(m => m.installCmd),
+        start: () => import('./commands/start.js').then(m => m.startCmd),
+        stop: () => import('./commands/stop.js').then(m => m.stopCmd),
+        update: () => import('./commands/update.js').then(m => m.updateCmd),
+        info: () => import('./commands/info.js').then(m => m.infoCmd),
+        doctor: () => import('./commands/doctor.js').then(m => m.doctorCmd),
+        backup: () => import('./commands/backup.js').then(m => m.backupCmd),
+        config: () => import('./commands/config.js').then(m => m.configCmd),
+        use: () => import('./commands/use.js').then(m => m.useCmd),
+        logs: () => import('./commands/logs.js').then(m => m.logsCmd),
+        console: () => import('./commands/console.js').then(m => m.consoleCmd),
+        plugin: () => import('./commands/plugin/index.js').then(m => m.pluginCmd),
+    },
+    async run({ args }) {
+        if (args._.length === 0) {
+            const { runMenu } = await import('./commands/menu.js');
+            await runMenu();
+        }
+    },
+});
+runMain(main);

package/dist/commands/backup.d.ts

@@ -1 +1,2 @@
-export declare function backupCmd(): Promise<void>;
+import type { CommandDef } from 'citty';
+export declare const backupCmd: CommandDef;

package/dist/commands/backup.js

@@ -1,74 +1,23 @@
-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();
-}
+import { defineCommand } from 'citty';
+import { intro, outro, log, spin } from '../ui/output.js';
+import { resolveServerDir } from '../services/server.js';
+import { createBackup, dirSize, fmtSize } from '../services/backup.js';
+export async function runBackup() {
+    intro(`💾 ${"Backup"}`);
+    const serverPath = await resolveServerDir();
+    if (!serverPath) {
+        log.error("No server detected");
+        process.exit(1);
+    }
+    const sp = spin("Collecting files...");
+    sp.stop(`Estimated size: ${fmtSize(dirSize(serverPath))}`);
+    const sp2 = spin("Copying files...");
+    const { path, size } = await createBackup(serverPath);
+    sp2.stop(`Backup created: ${path} (${fmtSize(size)})`);
+    outro(`Backup created: ${path} (${fmtSize(size)})`);
+}
+export const backupCmd = defineCommand({
+    meta: { description: 'Create a server backup' },
+    args: {},
+    run: () => runBackup(),
+});

package/dist/commands/config.d.ts

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

package/dist/commands/config.js

@@ -1,114 +1,60 @@
-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);
-}
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { defineCommand } from 'citty';
+import { intro, outro, log } from '../ui/output.js';
+import { c } from '../ui/theme.js';
+import { resolveServerDir } from '../services/server.js';
+function colorVal(val) {
+    if (val === 'true' || val === 'on')
+        return c.green(val);
+    if (val === 'false' || val === 'off')
+        return c.red(val);
+    if (/^\d+(\.\d+)?$/.test(val))
+        return c.cyan(val);
+    return val;
+}
+export const configCmd = defineCommand({
+    meta: { description: 'View server configuration' },
+    args: {},
+    async run() {
+        intro(`⚙️ ${"Configuration"}`);
+        const serverPath = await resolveServerDir();
+        if (!serverPath) {
+            log.error("No server detected");
+            process.exit(1);
+        }
+        let cfgPath = join(serverPath, 'pnx.yml');
+        if (!existsSync(cfgPath))
+            cfgPath = join(serverPath, 'server.properties');
+        if (!existsSync(cfgPath)) {
+            log.error("No config file found");
+            process.exit(1);
+        }
+        let content = readFileSync(cfgPath, 'utf-8');
+        if (content.charCodeAt(0) === 0xfeff)
+            content = content.slice(1);
+        const sep = cfgPath.endsWith('.yml') ? ':' : '=';
+        for (const line of content.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                log.raw('');
+                continue;
+            }
+            if (trimmed.startsWith('#')) {
+                log.raw(`  ${c.dim(line)}`);
+                continue;
+            }
+            const idx = trimmed.indexOf(sep);
+            if (idx > 0) {
+                const key = trimmed.slice(0, idx);
+                const val = trimmed.slice(idx + 1).trim();
+                const indent = line.match(/^(\s*)/)?.[1] ?? '';
+                log.raw(`  ${indent}${c.blue(key)}${sep}${val ? ' ' + colorVal(val) : ''}`);
+            }
+            else
+                log.raw(`  ${c.dim(trimmed)}`);
+        }
+        log.info(`Edit ${cfgPath} to change these values`);
+        outro('');
+    },
+});

package/dist/commands/console.d.ts

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