@powernukkitx/cli 1.0.0 → 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,203 +1,186 @@
-# pnx-cli
-
-**PowerNukkitX CLI** — outil en ligne de commande pour gérer un serveur **Minecraft Bedrock** propulsé par [PowerNukkitX](https://github.com/PowerNukkitX/PowerNukkitX).
-
-Créez, démarrez, mettez à jour et diagnostiquez votre serveur, gérez les plugins depuis la marketplace, le tout avec une interface soignée et un menu interactif — en français ou en anglais.
-
-## Sommaire
-
-- [Installation](#installation)
-- [Prérequis](#prérequis)
-- [Démarrage rapide](#démarrage-rapide)
-- [Commandes](#commandes)
-- [Mode interactif](#mode-interactif)
-- [Options globales](#options-globales)
-- [Architecture](#architecture)
-- [Développement](#développement)
-- [Exécutables autonomes](#exécutables-autonomes-sea)
-- [Liens](#liens-utiles)
-- [Licence](#licence)
-
-## Installation
-
-```bash
-npm install -g @powernukkitx/cli
-```
-
-La commande `pnx` devient alors disponible.
-
-Alternativement, téléchargez un exécutable autonome (voir [Exécutables autonomes](#exécutables-autonomes-sea)) — aucun Node.js requis pour l'utiliser.
-
-## Prérequis
-
-- **Node.js 20.12+** (pour l'installation via npm ; inutile pour les binaires autonomes)
-- **Java 21+** pour lancer le serveur ([Adoptium Temurin](https://adoptium.net/) recommandé)
-
-## Démarrage rapide
-
-```bash
-# Menu interactif contextuel
-pnx
-
-# Créer un serveur puis le démarrer
-pnx init --dir ./pnx-server
-pnx start --memory 4G
-
-# Aide
-pnx --help
-pnx <commande> --help
-```
-
-## Commandes
-
-### `init` — créer un serveur
-
-Télécharge le dernier `powernukkitx.jar` et les scripts de démarrage.
-
-```bash
-pnx init --dir ./pnx-server
-```
-
-| Option | Description |
-|---|---|
-| `--dir <path>` | Dossier cible (sinon demandé) |
-| `--dev` | Version de développement |
-
-### `start` — démarrer le serveur
-
-Vérifie Java, construit les arguments JVM optimisés (ZGC générationnel, UTF-8) et lance le serveur.
-
-```bash
-pnx start --memory 4G --restart
-```
-
-| Option | Description |
-|---|---|
-| `--dir <path>` | Dossier du serveur |
-| `--memory <taille>` | Mémoire allouée, ex. `2G`, `4G` (défaut `2G`) |
-| `--restart` | Redémarrage automatique en cas de crash |
-| `--dry-run` | Affiche la commande sans l'exécuter |
-
-### `stop` — arrêter le serveur
-
-Arrête le serveur démarré via son PID mémorisé.
-
-```bash
-pnx stop
-```
-
-### `update` — mettre à jour le core
-
-Sauvegarde l'ancien jar en `.old` puis télécharge la dernière version.
-
-```bash
-pnx update --force
-```
-
-| Option | Description |
-|---|---|
-| `--force` | Force le re-téléchargement (ignore le cache) |
-| `--dev` | Version de développement |
-
-### `plugin` — gérer les plugins
-
-Marketplace officielle + suivi local des versions installées.
-
-```bash
-pnx plugin list                    # catalogue
-pnx plugin search essentials       # recherche
-pnx plugin info <slug>             # fiche détaillée
-pnx plugin install <slug|url.jar>  # installer (marketplace ou URL .jar)
-pnx plugin installed               # plugins locaux
-pnx plugin update [slug]           # mettre à jour
-pnx plugin remove [nom]            # supprimer
-```
-
-Sans argument, `install`, `update` et `remove` proposent une sélection interactive.
-
-### Diagnostics & utilitaires
-
-```bash
-pnx doctor          # Java, RAM, disque, port 19132, plugins/mondes
-pnx info            # état, chemin, plugins, mondes, RAM
-pnx backup          # sauvegarde horodatée du serveur
-pnx config          # affiche pnx.yml / server.properties (coloré)
-pnx use ./serveur   # définit le serveur par défaut
-pnx logs            # derniers logs (avec suivi live)
-pnx console         # console RCON attachée au serveur
-pnx lang --set fr   # langue (fr / en)
-```
-
-`doctor` et `info` acceptent `--json` pour une sortie machine.
-
-## Mode interactif
-
-Lancée sans sous-commande, `pnx` ouvre un **menu contextuel** qui :
-
-- détecte l'état (serveur présent, démarré, PID) ;
-- ne propose que les actions pertinentes (créer si absent, démarrer si arrêté, arrêter si en cours…) ;
-- route vers les commandes existantes.
-
-```bash
-pnx
-```
-
-## Options globales
-
-| Option | Description |
-|---|---|
-| `--json` | Sortie JSON machine (désactive le rendu décoratif) |
-| `--lang <fr\|en>` | Force la langue pour cette exécution |
-| `--no-color` | Désactive les couleurs |
-
-Résolution de la langue : `--lang` > configuration sauvegardée > variable d'environnement > **français** par défaut.
-
-L'état du CLI est stocké dans `~/.pnx-cli/` (config, PID, plugins installés, cache des versions). Variables d'environnement : `PNX_API_URL` (base de l'API marketplace), `PNX_HOME` (répertoire d'état).
-
-## Architecture
-
-Le code suit une architecture en couches — commandes minces, logique métier isolée et testable :
-
-```
-src/
-  cli.ts          point d'entrée (citty) + options globales
-  commands/       parse des arguments → appel service → rendu
-    plugin/       sous-commandes plugin
-  services/       logique métier pure (release, server, process, plugins, backup)
-  infra/          http, store JSON (~/.pnx-cli), constantes/endpoints
-  ui/             système d'affichage unique (clack + chalk), prompts
-  i18n/           traductions fr / en
-```
-
-Règles : les commandes ne font aucun accès réseau/fichier direct (tout passe par `services`/`infra`) ; les services ne rendent rien (ils renvoient des données).
-
-**Stack** : TypeScript, [citty](https://github.com/unjs/citty) (routing), [@clack/prompts](https://github.com/bombshell-dev/clack) (prompts), [chalk](https://github.com/chalk/chalk) (couleurs).
-
-## Développement
-
-```bash
-npm install       # dépendances
-npm run build     # compile TypeScript → dist/ (+ copie des assets i18n)
-npm run dev       # compilation en watch
-npm start         # lance dist/cli.js
-npm test          # tests des services (node:test + tsx)
-```
-
-## Exécutables autonomes (SEA)
-
-Le projet génère un binaire natif via **[Node Single Executable Applications](https://nodejs.org/api/single-executable-applications.html)** (bundling esbuild + injection `postject`) :
-
-```bash
-npm run build:sea
-```
-
-Produit `pnx` (ou `pnx.exe` sous Windows) pour **la plateforme hôte**. SEA ne cross-compile pas : lancez la commande sur chaque système cible (Windows / Linux / macOS) pour obtenir son binaire.
-
-## Liens utiles
-
-- Documentation PowerNukkitX : https://docs.powernukkitx.org
-- Dépôt PowerNukkitX : https://github.com/PowerNukkitX/PowerNukkitX
-
-## Licence
-
-MIT
+# pnx-cli
+
+**PowerNukkitX CLI** - command line tool to manage a **Minecraft Bedrock** server powered by [PowerNukkitX](https://github.com/PowerNukkitX/PowerNukkitX).
+
+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 @powernukkitx/cli
+```
+
+The `pnx` command becomes available.
+
+## Requirements
+
+- **Node.js 20.12+**
+- **Java 21+** to run the server ([Adoptium Temurin](https://adoptium.net/) recommended)
+
+## Quick start
+
+```bash
+# Contextual interactive menu
+pnx
+
+# Create a server then start it
+pnx init --dir ./pnx-server
+pnx start --memory 4G
+
+# Help
+pnx --help
+pnx <command> --help
+```
+
+## Commands
+
+### `init` - create a server
+
+Downloads the latest `powernukkitx.jar` and the start scripts.
+
+```bash
+pnx init --dir ./pnx-server
+```
+
+| Option | Description |
+|---|---|
+| `--dir <path>` | Target directory (prompted otherwise) |
+| `--dev` | Development build |
+
+### `start` - start the server
+
+Checks Java, builds optimized JVM arguments (generational ZGC, UTF-8) and launches the server.
+
+```bash
+pnx start --memory 4G --restart
+```
+
+| 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 |
+
+### `stop` - stop the server
+
+Stops the server started through its stored PID.
+
+```bash
+pnx stop
+```
+
+### `update` - update the core
+
+Backs up the old jar as `.old` then downloads the latest version.
+
+```bash
+pnx update --force
+```
+
+| Option | Description |
+|---|---|
+| `--force` | Force re-download (ignore cache) |
+| `--dev` | Development build |
+
+### `plugin` - manage plugins
+
+Official marketplace plus local tracking of installed versions.
+
+```bash
+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
+```
+
+Without an argument, `install`, `update` and `remove` offer an interactive selection.
+
+### Diagnostics and utilities
+
+```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
+```
+
+`doctor` and `info` accept `--json` for machine output.
+
+## Interactive mode
+
+Launched without a subcommand, `pnx` opens a **contextual menu** that:
+
+- 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
+pnx
+```
+
+## Global options
+
+| Option | Description |
+|---|---|
+| `--json` | Machine JSON output (disables decorative rendering) |
+| `--no-color` | Disable colors |
+
+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).
+
+## 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
+```
+
+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).
+
+## Development
+
+The shipped code lives in `dist/` (plain ES modules, no build step).
+
+```bash
+npm install       # dependencies
+npm start         # run dist/cli.js
+npm run check     # syntax check every file
+npm run smoke     # run pnx --help
+```
+
+## Links
+
+- PowerNukkitX documentation: https://docs.powernukkitx.org
+- PowerNukkitX repository: https://github.com/PowerNukkitX/PowerNukkitX
+
+## License
+
+MIT

package/dist/cli.js

@@ -1,46 +1,34 @@
-#!/usr/bin/env node
-import { defineCommand, runMain } from 'citty';
-import { initLang } from './i18n/index.js';
-import { setColorEnabled } from './ui/theme.js';
-// Flags globaux traités avant le routing citty.
-const argv = process.argv.slice(2);
-const langFlag = (() => {
-    const i = argv.findIndex(a => a === '--lang');
-    if (i >= 0 && argv[i + 1])
-        return argv[i + 1];
-    const eq = argv.find(a => a.startsWith('--lang='));
-    return eq ? eq.split('=')[1] : undefined;
-})();
-if (argv.includes('--no-color'))
-    setColorEnabled(false);
-initLang(langFlag);
-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),
-        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),
-        lang: () => import('./commands/lang.js').then(m => m.langCmd),
-        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 }) {
-        // Aucune sous-commande → menu interactif.
-        if (args._.length === 0) {
-            const { runMenu } = await import('./commands/menu.js');
-            await runMenu();
-        }
-    },
-});
-runMain(main);
+#!/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,2 +1,2 @@
-import type { CommandDef } from 'citty';
-export declare const backupCmd: CommandDef;
+import type { CommandDef } from 'citty';
+export declare const backupCmd: CommandDef;

package/dist/commands/backup.js

@@ -1,24 +1,23 @@
-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';
-import { t } from '../i18n/index.js';
-export async function runBackup() {
-    intro(`💾 ${t('backup.title')}`);
-    const serverPath = await resolveServerDir();
-    if (!serverPath) {
-        log.error(t('backup.noServer'));
-        process.exit(1);
-    }
-    const sp = spin(t('backup.collecting'));
-    sp.stop(t('backup.size', fmtSize(dirSize(serverPath))));
-    const sp2 = spin(t('backup.copying'));
-    const { path, size } = await createBackup(serverPath);
-    sp2.stop(t('backup.done', path, fmtSize(size)));
-    outro(t('backup.done', path, fmtSize(size)));
-}
-export const backupCmd = defineCommand({
-    meta: { description: 'Create a server backup' },
-    args: {},
-    run: () => runBackup(),
-});
+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>;