@powernukkitx/cli 0.0.2 → 1.0.0

package/dist/services/backup.js

@@ -0,0 +1,40 @@
+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']);
+/** Taille récursive d'un dossier en octets. */
+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 { /* ignore */ }
+    return total;
+}
+/** Formatte une taille en octets. */
+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`;
+}
+/**
+ * Crée une sauvegarde horodatée du serveur dans `<serverDir>/backups/`.
+ * Copie récursive (zéro dépendance), en ignorant logs/cache/backups.
+ */
+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) };
+}

package/dist/services/plugins.js

@@ -0,0 +1,111 @@
+import { join } from 'node:path';
+import { mkdir, rename, rm } from 'node:fs/promises';
+import { fetchJSON, downloadFile } from '../infra/http.js';
+import { readJson, writeJson } from '../infra/store.js';
+import { apiBase } from '../infra/paths.js';
+const REGISTRY = 'installed-plugins.json';
+/** Liste/recherche de plugins depuis la marketplace. */
+export async function searchPlugins(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 q = qs.toString();
+    return fetchJSON(`${apiBase()}/api/plugins/cli${q ? `?${q}` : ''}`);
+}
+/** Fiche détaillée d'un plugin. */
+export async function getPluginDetail(slug) {
+    return fetchJSON(`${apiBase()}/api/plugins/cli/${encodeURIComponent(slug)}`);
+}
+/** URL de download proxifiée pour un plugin. */
+export function proxyDownloadUrl(slug, version) {
+    const qs = new URLSearchParams({ proxy: '1' });
+    if (version)
+        qs.set('version', version);
+    return `${apiBase()}/api/plugins/${encodeURIComponent(slug)}/download?${qs}`;
+}
+/** Sélectionne la release stable la plus récente, sinon la première. */
+export function pickRelease(detail) {
+    return detail.releases.find(r => r.is_stable) ?? detail.releases[0] ?? null;
+}
+// --- Registre local ---
+export async function getInstalled() {
+    return readJson(REGISTRY, []);
+}
+/** Upsert par slug dans le registre local. */
+export async function recordInstalled(plugin) {
+    const list = await getInstalled();
+    const idx = list.findIndex(p => p.slug === plugin.slug);
+    if (idx >= 0)
+        list[idx] = plugin;
+    else
+        list.push(plugin);
+    await writeJson(REGISTRY, list);
+}
+export async function removeInstalled(slug) {
+    const list = (await getInstalled()).filter(p => p.slug !== slug);
+    await writeJson(REGISTRY, list);
+}
+// --- Installation ---
+/** Installe un plugin depuis la marketplace. Renvoie l'entrée enregistrée. */
+export async function installPlugin(slug, pluginsDir, onProgress) {
+    const detail = await getPluginDetail(slug);
+    const release = pickRelease(detail);
+    if (!release)
+        throw new Error(`no-release:${slug}`);
+    const file = release.files[0];
+    if (!file)
+        throw new Error(`no-file:${slug}`);
+    await mkdir(pluginsDir, { recursive: true });
+    const dest = join(pluginsDir, file.name);
+    await downloadFile(proxyDownloadUrl(slug, release.version), dest, {
+        onProgress: onProgress ? pct => onProgress(pct, file.name) : undefined,
+    });
+    const entry = {
+        slug, name: detail.name, version: release.version,
+        installedAt: new Date().toISOString(), fileName: file.name,
+    };
+    await recordInstalled(entry);
+    return entry;
+}
+/** Installe un plugin depuis une URL .jar directe. */
+export async function installFromUrl(url, pluginsDir, onProgress) {
+    if (!url.endsWith('.jar'))
+        throw new Error('url-invalid');
+    await mkdir(pluginsDir, { recursive: true });
+    const fileName = url.split('/').pop() ?? 'plugin.jar';
+    const dest = join(pluginsDir, fileName);
+    await downloadFile(url, dest, { onProgress: onProgress ? pct => onProgress(pct, fileName) : undefined });
+    return fileName;
+}
+/** Met à jour un plugin installé; null si déjà à jour. */
+export async function updatePlugin(slug, pluginsDir, currentVersion, existingJar, onProgress) {
+    const detail = await getPluginDetail(slug);
+    const release = pickRelease(detail);
+    if (!release)
+        throw new Error(`no-release:${slug}`);
+    if (currentVersion && currentVersion === release.version)
+        return null;
+    const file = release.files[0];
+    if (!file)
+        throw new Error(`no-file:${slug}`);
+    if (existingJar) {
+        await rename(join(pluginsDir, existingJar), join(pluginsDir, `${existingJar}.old`)).catch(() => { });
+    }
+    await downloadFile(proxyDownloadUrl(slug, release.version), join(pluginsDir, file.name), {
+        onProgress: onProgress ? pct => onProgress(pct, file.name) : undefined,
+    });
+    if (existingJar)
+        await rm(join(pluginsDir, `${existingJar}.old`)).catch(() => { });
+    const entry = {
+        slug, name: detail.name, version: release.version,
+        installedAt: new Date().toISOString(), fileName: file.name,
+    };
+    await recordInstalled(entry);
+    return entry;
+}

package/dist/services/process.js

@@ -0,0 +1,43 @@
+import { platform } from 'node:os';
+import { spawnSync } from 'node:child_process';
+import { readJson, writeJson, removeFile } from '../infra/store.js';
+const PID_FILE = 'pid.json';
+export async function savePid(pid, serverPath) {
+    await writeJson(PID_FILE, { pid, serverPath, startedAt: new Date().toISOString() });
+}
+export async function loadPid() {
+    return readJson(PID_FILE, null);
+}
+export async function clearPid() {
+    await removeFile(PID_FILE);
+}
+/** True si le processus `pid` est vivant. */
+export function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Arrête un processus (taskkill sous Windows, SIGTERM→SIGKILL sinon). */
+export async function killProcess(pid) {
+    if (!isAlive(pid))
+        return false;
+    try {
+        if (platform() === 'win32') {
+            spawnSync('taskkill', ['/PID', String(pid), '/F']);
+        }
+        else {
+            process.kill(pid, 'SIGTERM');
+            await new Promise(r => setTimeout(r, 5000));
+            if (isAlive(pid))
+                process.kill(pid, 'SIGKILL');
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/services/release.js

@@ -0,0 +1,38 @@
+import { fetchJSON, downloadFile } from '../infra/http.js';
+import { readJson, writeJson } from '../infra/store.js';
+import { GITHUB_LATEST_RELEASE, JAR_NAME } from '../infra/paths.js';
+const CACHE_FILE = 'latest-release.json';
+const CACHE_TTL = 3_600_000; // 1h
+function normalize(gh) {
+    return {
+        tag: gh.tag_name,
+        version: gh.tag_name.replace(/^v/, ''),
+        assets: gh.assets.map(a => ({ name: a.name, url: a.browser_download_url, size: a.size })),
+        publishedAt: gh.published_at,
+        body: gh.body,
+    };
+}
+/** Dernière release du core, mise en cache 1h (sauf `force`). */
+export async function getLatestRelease(force = false) {
+    if (!force) {
+        const cached = await readJson(CACHE_FILE, null);
+        if (cached && Date.now() - cached.fetchedAt < CACHE_TTL)
+            return cached.data;
+    }
+    const gh = await fetchJSON(GITHUB_LATEST_RELEASE);
+    const release = normalize(gh);
+    await writeJson(CACHE_FILE, { fetchedAt: Date.now(), data: release });
+    return release;
+}
+/** Retrouve un asset par nom exact. */
+export function findAsset(release, name) {
+    return release.assets.find(a => a.name === name);
+}
+/** Télécharge le jar du core vers `dest`. Renvoie sa taille. */
+export async function downloadCore(release, dest, onProgress) {
+    const asset = findAsset(release, JAR_NAME);
+    if (!asset)
+        throw new Error(`${JAR_NAME} not found in release ${release.tag}`);
+    await downloadFile(asset.url, dest, { onProgress: onProgress ? pct => onProgress(pct) : undefined });
+    return { size: asset.size };
+}

package/dist/services/server.js

@@ -0,0 +1,89 @@
+import { existsSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+import { cwd } from 'node:process';
+import { platform } from 'node:os';
+import { spawn } from 'node:child_process';
+import { readJson, writeJson } from '../infra/store.js';
+import { JAR_NAME, SCRIPTS_BASE } from '../infra/paths.js';
+const CONFIG_FILE = 'config.json';
+export async function getDefaultServer() {
+    return (await readJson(CONFIG_FILE, {})).defaultServer ?? null;
+}
+export async function setDefaultServer(path) {
+    const cfg = await readJson(CONFIG_FILE, {});
+    if (path === null)
+        delete cfg.defaultServer;
+    else
+        cfg.defaultServer = path;
+    await writeJson(CONFIG_FILE, cfg);
+}
+/** Détecte les dossiers serveur (jar présent) autour d'un point de départ. */
+export function detectServers(startPath) {
+    const base = startPath || cwd();
+    const found = [];
+    for (const dir of [base, join(base, 'pnx-server'), dirname(resolve(base))]) {
+        if (existsSync(join(dir, JAR_NAME)) && !found.includes(dir))
+            found.push(dir);
+    }
+    return found;
+}
+/** Résout le dossier serveur: défaut mémorisé, sinon détection (`pick` si plusieurs). */
+export async function resolveServerDir(pick) {
+    const def = await getDefaultServer();
+    if (def && existsSync(join(def, JAR_NAME)))
+        return def;
+    const all = detectServers();
+    if (all.length === 0)
+        return null;
+    if (all.length === 1)
+        return all[0];
+    return pick ? pick(all) : all[0];
+}
+/** Chemin de l'exécutable Java (JAVA_HOME sinon PATH). */
+export function findJava() {
+    return process.env.JAVA_HOME ? join(process.env.JAVA_HOME, 'bin', 'java') : 'java';
+}
+/** Vérifie Java (ok si >= 21) et son vendor. */
+export function checkJava() {
+    return new Promise(res => {
+        const child = spawn(findJava(), ['-version']);
+        let out = '';
+        child.on('error', () => res({ ok: false, version: 0, raw: '?', vendor: 'Unknown' }));
+        child.stderr.on('data', (d) => (out += d.toString()));
+        child.on('close', () => {
+            const m = out.match(/(?:openjdk|java) version "?(?:1\.)?(\d+)/i);
+            const version = m ? parseInt(m[1]) : 0;
+            const vendors = ['Temurin', 'GraalVM', 'Zulu', 'Corretto', 'Oracle', 'Microsoft', 'OpenJDK'];
+            const vendor = vendors.find(v => out.toLowerCase().includes(v.toLowerCase())) ?? 'Unknown';
+            res({ ok: version >= 21, version, raw: out.split('\n')[0]?.trim() || '?', vendor });
+        });
+    });
+}
+/** Arguments JVM par défaut (encodage, ZGC generational, add-opens). */
+export function defaultJavaArgs() {
+    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',
+    ];
+}
+/** Ligne de commande complète pour lancer le serveur. */
+export function buildLaunchArgs(memory) {
+    return [`-Xms${memory}`, '-XX:MaxRAMPercentage=75.0', ...defaultJavaArgs(), '-jar', JAR_NAME];
+}
+/** Environnement d'exécution du serveur (encodage UTF-8). */
+export function javaEnv() {
+    return { ...process.env, JAVA_TOOL_OPTIONS: '-Dfile.encoding=UTF-8', LANG: process.env.LANG ?? 'en_US.UTF-8' };
+}
+/** Scripts de démarrage à télécharger selon la plateforme. */
+export function startScripts() {
+    if (platform() === 'win32')
+        return [
+            { url: `${SCRIPTS_BASE}/start.bat`, name: 'start.bat' },
+            { url: `${SCRIPTS_BASE}/start.ps1`, name: 'start.ps1' },
+        ];
+    return [{ url: `${SCRIPTS_BASE}/start.sh`, name: 'start.sh' }];
+}

package/dist/ui/output.js

@@ -0,0 +1,71 @@
+import * as clack from '@clack/prompts';
+import { c, chalk } from './theme.js';
+const _isJson = process.argv.includes('--json');
+/** True si le CLI tourne en mode machine (--json). */
+export function isJson() { return _isJson; }
+/** Émet un objet JSON sur stdout et quitte (mode --json). */
+export function json(data) {
+    process.stdout.write(JSON.stringify(data, null, 2) + '\n');
+    process.exit(0);
+}
+export function intro(title) {
+    if (_isJson)
+        return;
+    clack.intro(c.primary.bold(` ${title} `));
+}
+export function outro(msg) {
+    if (_isJson)
+        return;
+    clack.outro(c.accent(msg));
+}
+export function section(title) {
+    if (_isJson)
+        return;
+    clack.log.step(c.accent.bold(title));
+}
+/** Annule proprement (prompt annulé) et quitte avec succès. */
+export function cancel(msg = 'Annulé') {
+    if (!_isJson)
+        clack.cancel(c.yellow(msg));
+    process.exit(0);
+}
+export function spin(msg) {
+    if (_isJson)
+        return { update: () => { }, stop: () => { }, fail: () => { } };
+    const s = clack.spinner();
+    s.start(msg);
+    return {
+        update: m => s.message(m),
+        stop: m => s.stop(m),
+        fail: m => s.stop(m, 1),
+    };
+}
+export const log = {
+    success: (msg) => { if (!_isJson)
+        clack.log.success(c.green(msg)); },
+    error: (msg) => { if (!_isJson)
+        clack.log.error(c.red(msg)); },
+    warn: (msg) => { if (!_isJson)
+        clack.log.warn(c.yellow(msg)); },
+    info: (msg) => { if (!_isJson)
+        clack.log.info(c.blue(msg)); },
+    step: (msg) => { if (!_isJson)
+        clack.log.step(chalk.dim(msg)); },
+    dim: (msg) => { if (!_isJson)
+        clack.log.message(chalk.dim(msg)); },
+    raw: (msg) => { if (!_isJson)
+        process.stdout.write(msg + '\n'); },
+};
+/** Barre de progression inline (0-100). */
+export function progress(pct, label) {
+    if (_isJson)
+        return;
+    const clamped = Math.max(0, Math.min(100, pct));
+    const filled = Math.floor(clamped / 5);
+    const bar = c.cyan('━'.repeat(filled)) + chalk.dim('─'.repeat(20 - filled));
+    const suffix = label ? `  ${chalk.dim(label)}` : '';
+    process.stdout.write(`\r  ${bar}  ${chalk.bold(String(clamped))}%${suffix}`);
+    if (clamped >= 100)
+        process.stdout.write('\n');
+}
+export { clack };

package/dist/ui/prompts.js

@@ -0,0 +1,30 @@
+import { text, confirm, select, multiselect, isCancel } from '@clack/prompts';
+import { cancel } from './output.js';
+/** Prompt texte. Annulation → cancel() propre. */
+export async function promptText(opts) {
+    const res = await text(opts);
+    if (isCancel(res))
+        cancel();
+    return res;
+}
+/** Prompt oui/non. */
+export async function promptConfirm(message, initialValue = false) {
+    const res = await confirm({ message, initialValue });
+    if (isCancel(res))
+        cancel();
+    return res;
+}
+/** Prompt sélection simple. */
+export async function promptSelect(message, options) {
+    const res = await select({ message, options: options });
+    if (isCancel(res))
+        cancel();
+    return res;
+}
+/** Prompt sélection multiple. */
+export async function promptMulti(message, options, required = false) {
+    const res = await multiselect({ message, options: options, required });
+    if (isCancel(res))
+        cancel();
+    return res;
+}

package/dist/ui/theme.js

@@ -0,0 +1,18 @@
+import chalk from 'chalk';
+/** Palette de couleurs unique du CLI. */
+export const c = {
+    primary: chalk.hex('#FF6B35'),
+    accent: chalk.hex('#FFB347'),
+    green: chalk.hex('#4CAF50'),
+    red: chalk.hex('#E53935'),
+    yellow: chalk.hex('#FFC107'),
+    blue: chalk.hex('#6C8EBF'),
+    cyan: chalk.hex('#4ECDC4'),
+    dim: chalk.dim,
+    bold: chalk.bold,
+};
+/** Désactive/active la couleur globalement (--no-color). */
+export function setColorEnabled(on) {
+    chalk.level = on ? (chalk.level || 1) : 0;
+}
+export { chalk };

package/dist/utils/api.d.ts

@@ -1,18 +1,9 @@
 import type { PluginListResponse, PluginDetail } from '../types.js';
-export declare function fetchJSON(url: string): Promise<any>;
-export interface ListPluginsParams {
-    sort?: 'newest' | 'updated' | 'stars';
+export declare function fetchPluginsList(params?: {
+    sort?: string;
     limit?: number;
     page?: number;
     q?: string;
-}
-export declare function fetchPluginsList(params?: ListPluginsParams): Promise<PluginListResponse>;
+}): 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

@@ -1,38 +1,5 @@
-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);
-}
+import { fetchJSON } from '../core/network.js';
+let API_BASE = (process.env.PNX_API_URL ?? 'https://api.powernukkitx.org').replace(/\/$/, '');
 export async function fetchPluginsList(params) {
     const qs = new URLSearchParams();
     if (params?.sort)
@@ -43,32 +10,15 @@ export async function fetchPluginsList(params) {
         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);
+    const q = qs.toString();
+    return fetchJSON(`${API_BASE}/api/plugins/cli${q ? `?${q}` : ''}`);
 }
 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',
-    };
+    return fetchJSON(`${API_BASE}/api/plugins/cli/${encodeURIComponent(slug)}`);
 }
 export function proxyDownloadUrl(slug, version) {
-    const qs = new URLSearchParams();
-    qs.set('proxy', '1');
+    const qs = new URLSearchParams({ proxy: '1' });
     if (version)
         qs.set('version', version);
-    return `${API_BASE}/api/plugins/${encodeURIComponent(slug)}/download?${qs.toString()}`;
+    return `${API_BASE}/api/plugins/${encodeURIComponent(slug)}/download?${qs}`;
 }

package/dist/utils/github.d.ts

@@ -9,19 +9,12 @@ interface GitHubRelease {
     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 findAsset(release: GitHubRelease, name: string): GitHubAsset | undefined;
 export declare function getStartScripts(): {
     url: string;
     name: string;
 }[];
+export declare function getDefaultJavaArgs(): string[];
+export declare function getJavaEnv(): NodeJS.ProcessEnv;
 export {};