@powernukkitx/cli 0.0.3 → 1.0.1

package/dist/services/plugins.js

@@ -0,0 +1,139 @@
+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';
+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}` : ''}`);
+}
+export async function getPluginDetail(slug) {
+    return fetchJSON(`${apiBase()}/api/plugins/cli/${encodeURIComponent(slug)}`);
+}
+export async function fetchApprovedPlugin(slug) {
+    try {
+        const res = await fetchJSON(`${apiBase()}/api/v1/plugins/${encodeURIComponent(slug)}`);
+        return res?.data ?? null;
+    }
+    catch (e) {
+        if (e?.statusCode === 404)
+            return null;
+        throw e;
+    }
+}
+function pickJarAsset(detail) {
+    for (const rel of detail.releases ?? []) {
+        const jar = (rel.assets ?? []).find(a => a.name.endsWith('.jar'));
+        if (jar)
+            return { url: jar.downloadUrl, name: jar.name, version: rel.tag };
+    }
+    return null;
+}
+export async function installApprovedPlugin(slug, pluginsDir, onProgress) {
+    const detail = await fetchApprovedPlugin(slug);
+    if (!detail || detail.status !== 'published')
+        throw new Error(`not-approved:${slug}`);
+    const asset = pickJarAsset(detail);
+    if (!asset)
+        throw new Error(`no-file:${slug}`);
+    await mkdir(pluginsDir, { recursive: true });
+    const dest = join(pluginsDir, asset.name);
+    await downloadFile(asset.url, dest, {
+        onProgress: onProgress ? pct => onProgress(pct, asset.name) : undefined,
+    });
+    const entry = {
+        slug, name: detail.name, version: asset.version,
+        installedAt: new Date().toISOString(), fileName: asset.name,
+    };
+    await recordInstalled(entry);
+    return entry;
+}
+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}`;
+}
+export function pickRelease(detail) {
+    return detail.releases.find(r => r.is_stable) ?? detail.releases[0] ?? null;
+}
+export async function getInstalled() {
+    return readJson(REGISTRY, []);
+}
+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);
+}
+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;
+}
+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;
+}
+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,41 @@
+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);
+}
+export function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+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,51 @@
+import { fetchJSON, downloadFile } from '../infra/http.js';
+import { readJson, writeJson } from '../infra/store.js';
+import { GITHUB_LATEST_RELEASE, GITHUB_RELEASES, JAR_NAME } from '../infra/paths.js';
+const CACHE_FILE = 'latest-release.json';
+const LIST_CACHE_FILE = 'releases.json';
+const CACHE_TTL = 3_600_000;
+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,
+        prerelease: gh.prerelease ?? false,
+        body: gh.body,
+    };
+}
+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;
+}
+export async function listReleases(force = false) {
+    if (!force) {
+        const cached = await readJson(LIST_CACHE_FILE, null);
+        if (cached && Date.now() - cached.fetchedAt < CACHE_TTL)
+            return cached.data;
+    }
+    const gh = await fetchJSON(`${GITHUB_RELEASES}?per_page=30`);
+    const releases = gh
+        .filter(r => !r.draft)
+        .map(normalize)
+        .filter(r => r.assets.some(a => a.name === JAR_NAME));
+    await writeJson(LIST_CACHE_FILE, { fetchedAt: Date.now(), data: releases });
+    return releases;
+}
+export function findAsset(release, name) {
+    return release.assets.find(a => a.name === name);
+}
+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,81 @@
+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);
+}
+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;
+}
+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];
+}
+export function findJava() {
+    return process.env.JAVA_HOME ? join(process.env.JAVA_HOME, 'bin', 'java') : 'java';
+}
+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 });
+        });
+    });
+}
+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',
+    ];
+}
+export function buildLaunchArgs(memory) {
+    return [`-Xms${memory}`, '-XX:MaxRAMPercentage=75.0', ...defaultJavaArgs(), '-jar', JAR_NAME];
+}
+export function javaEnv() {
+    return { ...process.env, JAVA_TOOL_OPTIONS: '-Dfile.encoding=UTF-8', LANG: process.env.LANG ?? 'en_US.UTF-8' };
+}
+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,67 @@
+import * as clack from '@clack/prompts';
+import { c, chalk } from './theme.js';
+const _isJson = process.argv.includes('--json');
+export function isJson() { return _isJson; }
+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));
+}
+export function cancel(msg = 'Cancelled') {
+    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'); },
+};
+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,26 @@
+import { text, confirm, select, multiselect, isCancel } from '@clack/prompts';
+import { cancel } from './output.js';
+export async function promptText(opts) {
+    const res = await text(opts);
+    if (isCancel(res))
+        cancel();
+    return res;
+}
+export async function promptConfirm(message, initialValue = false) {
+    const res = await confirm({ message, initialValue });
+    if (isCancel(res))
+        cancel();
+    return res;
+}
+export async function promptSelect(message, options) {
+    const res = await select({ message, options: options });
+    if (isCancel(res))
+        cancel();
+    return res;
+}
+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,16 @@
+import chalk from 'chalk';
+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,
+};
+export function setColorEnabled(on) {
+    chalk.level = on ? (chalk.level || 1) : 0;
+}
+export { chalk };

package/package.json

@@ -1,63 +1,44 @@
-{
-  "name": "@powernukkitx/cli",
-  "version": "0.0.3",
-  "description": "PowerNukkitX CLI — Manage your Minecraft Bedrock servers with style",
-  "keywords": [
-    "powernukkitx",
-    "pnx",
-    "minecraft",
-    "bedrock",
-    "server",
-    "cli"
-  ],
-  "license": "MIT",
-  "author": "AzaleeX",
-  "type": "module",
-  "main": "dist/index.js",
-  "bin": {
-    "pnx": "dist/index.js"
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "prepublishOnly": "npm run build",
-    "dev": "tsc --watch",
-    "generate-icon": "node scripts/generate-icon.js",
-    "set-icon": "node scripts/apply-icon.js",
-    "bundle": "esbuild src/index.ts --bundle --platform=node --format=cjs --outfile=dist/bundle.js --tsconfig=tsconfig.json --external:@yao-pkg/pkg",
-    "build:exe": "npm run bundle && pkg dist/bundle.js --targets node18-win-x64,node18-linux-x64,node18-macos-x64 --output pnx-cli",
-    "build:exe:win": "npm run generate-icon && npm run bundle && pkg dist/bundle.js --targets node18-win-x64 --output pnx-cli.exe && npm run set-icon",
-    "build:exe:linux": "npm run bundle && pkg dist/bundle.js --targets node18-linux-x64 --output pnx-cli-linux",
-    "build:exe:mac": "npm run bundle && pkg dist/bundle.js --targets node18-macos-x64 --output pnx-cli-macos"
-  },
-  "dependencies": {
-    "@inquirer/prompts": "^7.10.1",
-    "chalk": "^5.6.2",
-    "commander": "^12.1.0"
-  },
-  "devDependencies": {
-    "@types/node": "^22.19.19",
-    "@yao-pkg/pkg": "^6.19.0",
-    "esbuild": "^0.28.0",
-    "rcedit": "^5.0.2",
-    "typescript": "^5.9.3"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "pkg": {
-    "assets": [
-      "dist/lang/*.json",
-      "dist/plugins.json"
-    ],
-    "targets": [
-      "node18-win-x64",
-      "node18-linux-x64",
-      "node18-macos-x64"
-    ],
-    "public": true
-  }
-}
+{
+  "name": "@powernukkitx/cli",
+  "version": "1.0.1",
+  "description": "PowerNukkitX CLI — Manage your Minecraft Bedrock servers with style",
+  "keywords": [
+    "powernukkitx",
+    "pnx",
+    "minecraft",
+    "bedrock",
+    "server",
+    "cli"
+  ],
+  "license": "MIT",
+  "author": "AzaleeX",
+  "type": "module",
+  "main": "dist/cli.js",
+  "bin": {
+    "pnx": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/PowerNukkitX/cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/PowerNukkitX/cli/issues"
+  },
+  "homepage": "https://github.com/PowerNukkitX/cli#readme",
+  "engines": {
+    "node": ">=20.12.0"
+  },
+  "scripts": {
+    "start": "node dist/cli.js",
+    "check": "find dist -name '*.js' -print0 | xargs -0 -n1 node --check",
+    "smoke": "node dist/cli.js --help"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.7.0",
+    "chalk": "^5.6.2",
+    "citty": "^0.2.2"
+  }
+}