@powernukkitx/cli 0.0.1

package/dist/lang/index.js

@@ -0,0 +1,83 @@
+import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import en from './en.json' with { type: 'json' };
+import fr from './fr.json' with { type: 'json' };
+const translations = { en, fr };
+const CONFIG_DIR = join(homedir(), '.pnx-cli');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+let _code = 'en';
+let _strings = translations.en;
+function detectLanguage() {
+    const envLang = process.env.PNX_LANG || process.env.LANG || '';
+    if (envLang.startsWith('fr'))
+        return 'fr';
+    return 'en';
+}
+function loadSavedLanguage() {
+    try {
+        if (existsSync(CONFIG_FILE)) {
+            const raw = readFileSync(CONFIG_FILE, 'utf-8');
+            const cfg = JSON.parse(raw);
+            if (cfg.lang === 'en' || cfg.lang === 'fr')
+                return cfg.lang;
+        }
+    }
+    catch { /* ignore */ }
+    return null;
+}
+export function saveLanguage(code) {
+    try {
+        if (!existsSync(CONFIG_DIR))
+            mkdirSync(CONFIG_DIR, { recursive: true });
+        const existing = existsSync(CONFIG_FILE) ? JSON.parse(readFileSync(CONFIG_FILE, 'utf-8')) : {};
+        existing.lang = code;
+        writeFileSync(CONFIG_FILE, JSON.stringify(existing, null, 2), 'utf-8');
+    }
+    catch { /* ignore */ }
+}
+export function hasSavedLanguage() {
+    return loadSavedLanguage() !== null;
+}
+export function setLanguage(code) {
+    _code = code;
+    _strings = translations[code] || translations.en;
+}
+export function initLanguage(cliLang) {
+    const code = (cliLang ||
+        loadSavedLanguage() ||
+        detectLanguage());
+    setLanguage(code);
+    return _code;
+}
+export function getLanguage() {
+    return _code;
+}
+export function t(key, ...args) {
+    const keys = key.split('.');
+    let value = _strings;
+    for (const k of keys) {
+        if (value && typeof value === 'object' && k in value) {
+            value = value[k];
+        }
+        else {
+            value = undefined;
+            break;
+        }
+    }
+    if (typeof value === 'string') {
+        return value.replace(/{(\d+)}/g, (_, i) => String(args[parseInt(i)] ?? `{${i}}`));
+    }
+    // fallback to English
+    let fallback = translations.en;
+    for (const k of keys) {
+        if (fallback && typeof fallback === 'object' && k in fallback) {
+            fallback = fallback[k];
+        }
+        else {
+            fallback = undefined;
+            break;
+        }
+    }
+    return typeof fallback === 'string' ? fallback : key;
+}

package/dist/plugins.json

@@ -0,0 +1,66 @@
+{
+    "essentials": {
+        "name": "EssentialsPNX",
+        "description": "Essential commands pour votre serveur PNX (tpa, warp, home, etc.)",
+        "author": "PowerNukkitX",
+        "source": "github",
+        "repo": "PowerNukkitX/EssentialsPNX",
+        "asset": "EssentialsPNX.jar"
+    },
+    "economyapi": {
+        "name": "EconomyAPI",
+        "description": "Système économique complet pour votre serveur",
+        "author": "onebone",
+        "source": "github",
+        "repo": "onebone/EconomyAPI",
+        "asset": "EconomyAPI.jar"
+    },
+    "lands": {
+        "name": "Lands",
+        "description": "Système de protection de terrains et claims",
+        "author": "Angelic47",
+        "source": "github",
+        "repo": "Angelic47/Lands",
+        "asset": "Lands.jar"
+    },
+    "worldprotect": {
+        "name": "WorldProtect",
+        "description": "Protection et gestion avancée des mondes",
+        "author": "PowerNukkitX",
+        "source": "github",
+        "repo": "PowerNukkitX/WorldProtect",
+        "asset": "WorldProtect.jar"
+    },
+    "motd": {
+        "name": "MOTD",
+        "description": "Personnalisation du message du jour sur votre serveur",
+        "author": "PowerNukkitX",
+        "source": "github",
+        "repo": "PowerNukkitX/MOTD",
+        "asset": "MOTD.jar"
+    },
+    "fawe": {
+        "name": "FastAsyncWorldEdit",
+        "description": "WorldEdit ultra-rapide pour PNX",
+        "author": "IntellectualSites",
+        "source": "github",
+        "repo": "IntellectualSites/FastAsyncWorldEdit",
+        "asset": "FastAsyncWorldEdit-Bukkit.jar"
+    },
+    "tpsoptimizer": {
+        "name": "TPSOptimizer",
+        "description": "Optimise les performances et le TPS de votre serveur",
+        "author": "Creeperface01",
+        "source": "github",
+        "repo": "Creeperface01/TPSOptimizer",
+        "asset": "TPSOptimizer.jar"
+    },
+    "pets": {
+        "name": "Pets",
+        "description": "Ajoute des animaux de compagnie personnalisés",
+        "author": "PetteriM1",
+        "source": "github",
+        "repo": "PetteriM1/Pets",
+        "asset": "Pets.jar"
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,61 @@
+export interface PluginListItem {
+    name: string;
+    slug: string;
+    description: string;
+    tags: string[];
+    version: string;
+    downloads: number;
+    stars: number;
+    author: string;
+}
+export interface PluginFile {
+    id: string;
+    name: string;
+    url: string;
+    size: number;
+}
+export interface PluginRelease {
+    id: string;
+    version: string;
+    is_stable: boolean;
+    created_at: string;
+    tag: string;
+    files: PluginFile[];
+}
+export interface PluginDetail {
+    name: string;
+    slug: string;
+    description: string;
+    long_description: string;
+    tags: string[];
+    downloads: number;
+    stars: number;
+    author: string;
+    author_id: string;
+    icon_url: string | null;
+    banner_url: string | null;
+    repository_url: string | null;
+    documentation_url: string | null;
+    license_url: string | null;
+    website_url: string | null;
+    created_at: string;
+    updated_at: string;
+    latest_version: string;
+    releases: PluginRelease[];
+}
+export interface PluginListResponse {
+    plugins: PluginListItem[];
+    count: number;
+}
+export interface ServerConfig {
+    jarPath: string;
+    javaArgs: string[];
+    autoRestart: boolean;
+}
+export interface InstalledPlugin {
+    slug: string;
+    name: string;
+    version: string;
+    installedAt: string;
+    fileName: string;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/api.d.ts

@@ -0,0 +1,18 @@
+import type { PluginListResponse, PluginDetail } from '../types.js';
+export declare function fetchJSON(url: string): Promise<any>;
+export interface ListPluginsParams {
+    sort?: 'newest' | 'updated' | 'stars';
+    limit?: number;
+    page?: number;
+    q?: string;
+}
+export declare function fetchPluginsList(params?: ListPluginsParams): Promise<PluginListResponse>;
+export declare function fetchPluginDetail(slug: string): Promise<PluginDetail>;
+export interface ResolvedDownload {
+    url: string;
+    name: string;
+    size: number;
+    version: string;
+}
+export declare function resolveDownload(slug: string, version?: string): Promise<ResolvedDownload>;
+export declare function proxyDownloadUrl(slug: string, version?: string): string;

package/dist/utils/api.js

@@ -0,0 +1,74 @@
+import https from 'node:https';
+import http from 'node:http';
+import { t } from '../lang/index.js';
+let API_BASE = process.env.PNX_API_URL || 'http://localhost:3000';
+if (API_BASE.endsWith('/'))
+    API_BASE = API_BASE.slice(0, -1);
+function agentGet(url, redirects = 5) {
+    if (redirects <= 0)
+        return Promise.reject(new Error('Too many redirects'));
+    return new Promise((resolve, reject) => {
+        const mod = url.startsWith('https') ? https : http;
+        mod.get(url, { timeout: 15_000, headers: { 'User-Agent': 'pnx-cli' } }, (res) => {
+            const code = res.statusCode ?? 0;
+            if ([301, 302, 303, 307, 308].includes(code)) {
+                if (res.headers.location) {
+                    resolve(agentGet(res.headers.location, redirects - 1));
+                    return;
+                }
+            }
+            if (code !== 200) {
+                reject(new Error(`HTTP ${code}`));
+                return;
+            }
+            let data = '';
+            res.on('data', (chunk) => (data += chunk));
+            res.on('end', () => resolve(data));
+        })
+            .on('error', reject)
+            .on('timeout', function () { this?.destroy(); reject(new Error(t('errors.timeout'))); });
+    });
+}
+export async function fetchJSON(url) {
+    const raw = await agentGet(url);
+    return JSON.parse(raw);
+}
+export async function fetchPluginsList(params) {
+    const qs = new URLSearchParams();
+    if (params?.sort)
+        qs.set('sort', params.sort);
+    if (params?.limit)
+        qs.set('limit', String(params.limit));
+    if (params?.page)
+        qs.set('page', String(params.page));
+    if (params?.q)
+        qs.set('q', params.q);
+    const query = qs.toString();
+    const url = `${API_BASE}/api/plugins/cli${query ? `?${query}` : ''}`;
+    return fetchJSON(url);
+}
+export async function fetchPluginDetail(slug) {
+    const url = `${API_BASE}/api/plugins/cli/${encodeURIComponent(slug)}`;
+    return fetchJSON(url);
+}
+export async function resolveDownload(slug, version) {
+    const qs = new URLSearchParams();
+    qs.set('resolve', '1');
+    if (version)
+        qs.set('version', version);
+    const url = `${API_BASE}/api/plugins/${encodeURIComponent(slug)}/download?${qs.toString()}`;
+    const data = await fetchJSON(url);
+    return {
+        url: data.url || data.download_url,
+        name: data.name || data.file_name || `${slug}.jar`,
+        size: data.size || 0,
+        version: data.version || version || 'latest',
+    };
+}
+export function proxyDownloadUrl(slug, version) {
+    const qs = new URLSearchParams();
+    qs.set('proxy', '1');
+    if (version)
+        qs.set('version', version);
+    return `${API_BASE}/api/plugins/${encodeURIComponent(slug)}/download?${qs.toString()}`;
+}

package/dist/utils/github.d.ts

@@ -0,0 +1,27 @@
+interface GitHubAsset {
+    name: string;
+    browser_download_url: string;
+    size: number;
+}
+interface GitHubRelease {
+    tag_name: string;
+    assets: GitHubAsset[];
+    published_at: string;
+    body: string;
+}
+export declare function fetchJSON(url: string, redirects?: number): Promise<any>;
+export declare function getLatestRelease(): Promise<GitHubRelease>;
+export declare function findAsset(release: GitHubRelease, name: string): Promise<GitHubAsset | undefined>;
+export declare function findPluginAsset(repo: string, assetName: string): Promise<{
+    url: string;
+    size: number;
+} | null>;
+export declare function downloadFile(url: string, dest: string, label?: string): Promise<void>;
+export declare function generateServerId(): string;
+export declare function getDefaultJavaArgs(): string[];
+export declare function getJavaEnv(): Record<string, string>;
+export declare function getStartScripts(): {
+    url: string;
+    name: string;
+}[];
+export {};

package/dist/utils/github.js

@@ -0,0 +1,187 @@
+import https from 'node:https';
+import http from 'node:http';
+import { randomBytes } from 'node:crypto';
+import { createWriteStream, existsSync } from 'node:fs';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { homedir, platform } from 'node:os';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import { step } from './logger.js';
+import { t } from '../lang/index.js';
+const CACHE_DIR = join(homedir(), '.pnx-cli');
+const CACHE_FILE = join(CACHE_DIR, 'latest-release.json');
+const CACHE_TTL = 3_600_000;
+export async function fetchJSON(url, redirects = 5) {
+    if (redirects <= 0)
+        return Promise.reject(new Error('Too many redirects'));
+    return new Promise((resolve, reject) => {
+        const mod = url.startsWith('https') ? https : http;
+        mod.get(url, { timeout: 15_000, headers: { 'User-Agent': 'pnx-cli' } }, (res) => {
+            const code = res.statusCode ?? 0;
+            if ([301, 302, 303, 307, 308].includes(code)) {
+                if (res.headers.location) {
+                    resolve(fetchJSON(res.headers.location, redirects - 1));
+                    return;
+                }
+            }
+            if (code !== 200) {
+                reject(new Error(`HTTP ${code}`));
+                return;
+            }
+            let data = '';
+            res.on('data', (chunk) => (data += chunk));
+            res.on('end', () => {
+                try {
+                    resolve(JSON.parse(data));
+                }
+                catch {
+                    reject(new Error('Invalid JSON response'));
+                }
+            });
+        })
+            .on('error', reject)
+            .on('timeout', function () {
+            this?.destroy();
+            reject(new Error(t('errors.timeout')));
+        });
+    });
+}
+async function getCachedRelease() {
+    try {
+        if (existsSync(CACHE_FILE)) {
+            const raw = await readFile(CACHE_FILE, 'utf-8');
+            const cached = JSON.parse(raw);
+            if (Date.now() - cached.fetchedAt < CACHE_TTL) {
+                return cached.data;
+            }
+        }
+    }
+    catch { /* ignore */ }
+    return null;
+}
+async function setCachedRelease(data) {
+    try {
+        await mkdir(CACHE_DIR, { recursive: true });
+        await writeFile(CACHE_FILE, JSON.stringify({ fetchedAt: Date.now(), data }), 'utf-8');
+    }
+    catch { /* ignore */ }
+}
+export async function getLatestRelease() {
+    const cached = await getCachedRelease();
+    if (cached)
+        return cached;
+    const data = await fetchJSON('https://api.github.com/repos/PowerNukkitX/PowerNukkitX/releases/latest');
+    await setCachedRelease(data);
+    return data;
+}
+export async function findAsset(release, name) {
+    return release.assets.find((a) => a.name === name);
+}
+export async function findPluginAsset(repo, assetName) {
+    try {
+        const data = await fetchJSON(`https://api.github.com/repos/${repo}/releases/latest`);
+        const asset = data.assets.find((a) => a.name === assetName);
+        if (asset)
+            return { url: asset.browser_download_url, size: asset.size };
+    }
+    catch { /* not found */ }
+    return null;
+}
+export function downloadFile(url, dest, label) {
+    const fileName = label || dest.split(/[/\\]/).pop() || 'file';
+    step(chalk.cyan(fileName));
+    function doGet(targetUrl, redirects = 5) {
+        if (redirects <= 0)
+            return Promise.reject(new Error('Too many redirects'));
+        return new Promise((resolve, reject) => {
+            const file = createWriteStream(dest);
+            const mod = targetUrl.startsWith('https') ? https : http;
+            mod.get(targetUrl, { timeout: 120_000, headers: { 'User-Agent': 'pnx-cli' } }, (res) => {
+                const code = res.statusCode ?? 0;
+                if ([301, 302, 303, 307, 308].includes(code)) {
+                    if (res.headers.location) {
+                        file.close();
+                        resolve(doGet(res.headers.location, redirects - 1));
+                        return;
+                    }
+                }
+                if (code !== 200) {
+                    file.close();
+                    reject(new Error(`HTTP ${code}`));
+                    return;
+                }
+                const total = parseInt(res.headers['content-length'] || '0', 10);
+                let downloaded = 0;
+                let lastPercent = -1;
+                res.on('data', (chunk) => {
+                    downloaded += chunk.length;
+                    if (total > 0) {
+                        const percent = Math.round((downloaded / total) * 100);
+                        if (percent !== lastPercent && percent % 5 === 0) {
+                            const done = '━'.repeat(Math.floor(percent / 5));
+                            const left = '─'.repeat(20 - Math.floor(percent / 5));
+                            process.stdout.write(`\r  ${chalk.hex('#4ECDC4')(done)}${chalk.dim(left)} ${chalk.bold(String(percent))}%`);
+                            lastPercent = percent;
+                        }
+                    }
+                });
+                res.pipe(file);
+                file.on('finish', () => {
+                    if (total > 0)
+                        process.stdout.write('\n');
+                    file.close();
+                    resolve();
+                });
+            })
+                .on('error', (err) => {
+                file.close();
+                reject(err);
+            })
+                .on('timeout', function () {
+                this?.destroy();
+                file.close();
+                reject(new Error(t('errors.timeout')));
+            });
+        });
+    }
+    return doGet(url);
+}
+export function generateServerId() {
+    return randomBytes(4).toString('hex');
+}
+export function getDefaultJavaArgs() {
+    return [
+        '-Dfile.encoding=UTF-8',
+        '-Dstdout.encoding=UTF-8',
+        '-Dstderr.encoding=UTF-8',
+        '-Djansi.passthrough=true',
+        '-Dterminal.ansi=true',
+        '-XX:+UseZGC',
+        '-XX:+ZGenerational',
+        '-XX:+UseStringDeduplication',
+        '--add-opens', 'java.base/java.lang=ALL-UNNAMED',
+        '--add-opens', 'java.base/java.io=ALL-UNNAMED',
+        '--add-opens', 'java.base/java.net=ALL-UNNAMED',
+    ];
+}
+export function getJavaEnv() {
+    return {
+        ...process.env,
+        JAVA_TOOL_OPTIONS: '-Dfile.encoding=UTF-8',
+        LANG: process.env.LANG || 'en_US.UTF-8',
+    };
+}
+const RAW_BASE = 'https://raw.githubusercontent.com/PowerNukkitX/scripts/master';
+export function getStartScripts() {
+    const os = platform();
+    if (os === 'win32') {
+        return [
+            { url: `${RAW_BASE}/start.bat`, name: 'start.bat' },
+            { url: `${RAW_BASE}/start.ps1`, name: 'start.ps1' },
+        ];
+    }
+    // linux, darwin, etc.
+    return [
+        { url: `${RAW_BASE}/start.sh`, name: 'start.sh' },
+    ];
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,15 @@
+export declare const logo: string;
+export declare function success(msg: string): void;
+export declare function error(msg: string): void;
+export declare function warn(msg: string): void;
+export declare function info(msg: string): void;
+export declare function step(msg: string): void;
+export declare function header(title: string): void;
+export declare function subheader(title: string): void;
+export declare function table(rows: [string, string][]): void;
+export declare function bullet(items: string[]): void;
+export declare function divider(): void;
+export declare const highlight: import("chalk").ChalkInstance;
+export declare const dim: import("chalk").ChalkInstance;
+export declare const bold: import("chalk").ChalkInstance;
+export declare const code: (s: string) => string;

package/dist/utils/logger.js

@@ -0,0 +1,72 @@
+import chalk from 'chalk';
+// ─── palette ──────────────────────────────────────────────────
+const c = {
+    primary: chalk.hex('#FF6B35'),
+    accent: chalk.hex('#FF8C42'),
+    gold: chalk.hex('#FFB347'),
+    blue: chalk.hex('#6C8EBF'),
+    cyan: chalk.hex('#4ECDC4'),
+    green: chalk.hex('#4CAF50'),
+    red: chalk.hex('#E53935'),
+    yellow: chalk.hex('#FFC107'),
+    dim: chalk.dim,
+    bold: chalk.bold,
+};
+// ─── logo ─────────────────────────────────────────────────────
+export const logo = `
+${c.primary.bold('  ╭──────────────────────────────────────╮')}
+${c.primary.bold('  │')}  ${c.accent.bold('██████╗ ███╗   ██╗██╗  ██╗')}   ${c.primary.bold('│')}
+${c.primary.bold('  │')}  ${c.accent.bold('██╔══██╗████╗  ██║╚██╗██╔╝')}   ${c.primary.bold('│')}
+${c.primary.bold('  │')}  ${c.accent.bold('██████╔╝██╔██╗ ██║ ╚███╔╝')}    ${c.primary.bold('│')}
+${c.primary.bold('  │')}  ${c.accent.bold('██╔═══╝ ██║╚██╗██║ ██╔██╗')}    ${c.primary.bold('│')}
+${c.primary.bold('  │')}  ${c.accent.bold('██║     ██║ ╚████║██╔╝ ██╗')}   ${c.primary.bold('│')}
+${c.primary.bold('  │')}  ${c.accent.bold('╚═╝     ╚═╝  ╚═══╝╚═╝  ╚═╝')}   ${c.primary.bold('│')}
+${c.primary.bold('  ╰──────────────────────────────────────╯')}
+${c.gold('        PowerNukkitX  ·  Minecraft Bedrock')}
+${c.dim('              Server Management CLI')}
+`;
+// ─── helpers ──────────────────────────────────────────────────
+const pad = (s) => `  ${s}`;
+export function success(msg) {
+    console.log(pad(`${c.green('✔')} ${c.bold(msg)}`));
+}
+export function error(msg) {
+    console.log(pad(`${c.red('✘')} ${c.bold(msg)}`));
+}
+export function warn(msg) {
+    console.log(pad(`${c.yellow('⚠')} ${msg}`));
+}
+export function info(msg) {
+    console.log(pad(`${c.blue('ℹ')} ${msg}`));
+}
+export function step(msg) {
+    console.log(pad(`${c.dim('▸')} ${c.dim(msg)}`));
+}
+export function header(title) {
+    const line = c.primary('─'.repeat(50));
+    console.log(`\n  ${line}`);
+    console.log(`  ${c.accent.bold(title)}`);
+    console.log(`  ${line}`);
+}
+export function subheader(title) {
+    console.log(`\n  ${c.accent('┃')} ${c.bold(title)}`);
+    console.log(`  ${c.accent('┃')} ${c.dim('─'.repeat(Math.min(title.length, 40)))}`);
+}
+export function table(rows) {
+    const max = Math.max(...rows.map(([l]) => l.length));
+    for (const [label, value] of rows) {
+        console.log(pad(`${c.accent(label.padEnd(max + 2))}${value}`));
+    }
+}
+export function bullet(items) {
+    for (const item of items) {
+        console.log(pad(`${c.cyan('●')} ${item}`));
+    }
+}
+export function divider() {
+    console.log(pad(c.dim('─'.repeat(50))));
+}
+export const highlight = c.gold;
+export const dim = c.dim;
+export const bold = c.bold;
+export const code = (s) => c.cyan(s);

package/dist/utils/pause.d.ts

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

package/dist/utils/pause.js

@@ -0,0 +1,6 @@
+import { input } from '@inquirer/prompts';
+import { dim } from './logger.js';
+export async function pauseForExit() {
+    console.log();
+    await input({ message: dim('Press Enter to continue...') });
+}

package/dist/utils/plugins.d.ts

@@ -0,0 +1,4 @@
+import type { InstalledPlugin } from '../types.js';
+export declare function getInstalledPlugins(): Promise<InstalledPlugin[]>;
+export declare function saveInstalledPlugin(plugin: InstalledPlugin): Promise<void>;
+export declare function getPluginVersion(slug: string): Promise<string | null>;

package/dist/utils/plugins.js

@@ -0,0 +1,34 @@
+import { existsSync } from 'node:fs';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const CACHE_DIR = join(homedir(), '.pnx-cli');
+const PLUGINS_FILE = join(CACHE_DIR, 'installed-plugins.json');
+export async function getInstalledPlugins() {
+    try {
+        if (!existsSync(PLUGINS_FILE))
+            return [];
+        const raw = await readFile(PLUGINS_FILE, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+}
+export async function saveInstalledPlugin(plugin) {
+    await mkdir(CACHE_DIR, { recursive: true });
+    const list = await getInstalledPlugins();
+    const idx = list.findIndex(p => p.slug === plugin.slug);
+    if (idx >= 0) {
+        list[idx] = plugin;
+    }
+    else {
+        list.push(plugin);
+    }
+    await writeFile(PLUGINS_FILE, JSON.stringify(list, null, 2), 'utf-8');
+}
+export async function getPluginVersion(slug) {
+    const list = await getInstalledPlugins();
+    const p = list.find(x => x.slug === slug);
+    return p ? p.version : null;
+}

package/dist/utils/server.d.ts

@@ -0,0 +1,3 @@
+export declare function detectServer(startPath?: string): string | null;
+export declare function detectAllServers(startPath?: string): string[];
+export declare function resolveServerDir(label?: string): Promise<string | null>;