@powernukkitx/cli 0.0.1

package/dist/commands/plugin.js

@@ -0,0 +1,385 @@
+import { existsSync } from 'node:fs';
+import { readdir, mkdir, rm, rename as fsRename } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { checkbox, confirm, input, select } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { header, success, error, info, warn, highlight, dim, step, bullet, divider } from '../utils/logger.js';
+import { t } from '../lang/index.js';
+import { fetchPluginsList, fetchPluginDetail, proxyDownloadUrl } from '../utils/api.js';
+import { downloadFile } from '../utils/github.js';
+import { saveInstalledPlugin, getInstalledPlugins } from '../utils/plugins.js';
+import { resolveServerDir } from '../utils/server.js';
+async function getPluginsDir() {
+    const server = await resolveServerDir();
+    return server ? join(server, 'plugins') : resolve('plugins');
+}
+function formatDownloads(n) {
+    if (n >= 1000)
+        return `${(n / 1000).toFixed(1)}k`;
+    return String(n);
+}
+function renderStars(n) {
+    const full = '★'.repeat(Math.min(Math.floor(n / 10), 5));
+    const empty = '☆'.repeat(Math.max(5 - full.length, 0));
+    const color = n >= 50 ? chalk.yellow : chalk.dim;
+    return color(full + empty);
+}
+// ─── List ─────────────────────────────────────────────────────
+export async function pluginListCmd(options) {
+    header(`📋 ${t('plugin.titleList')}`);
+    const params = {};
+    if (options?.sort)
+        params.sort = options.sort;
+    if (options?.limit)
+        params.limit = options.limit;
+    if (options?.page)
+        params.page = options.page;
+    if (options?.q)
+        params.q = options.q;
+    step(t('plugin.fetching'));
+    try {
+        const resp = await fetchPluginsList(params);
+        const list = resp.plugins;
+        if (list.length === 0) {
+            info(t('plugin.catalogEmpty'));
+            return;
+        }
+        for (const p of list) {
+            const name = chalk.hex('#FFB347')(p.name);
+            const author = chalk.dim(`by ${p.author}`);
+            const stars = renderStars(p.stars);
+            const downloads = chalk.cyan(`${formatDownloads(p.downloads)} downloads`);
+            const version = chalk.dim(`v${p.version}`);
+            const installCmd = chalk.hex('#6C8EBF')(`pnx plugin install ${p.slug}`);
+            console.log(`  ${name}  ${author}  ${stars}  ${downloads}  ${version}`);
+            if (p.description) {
+                console.log(`  ${chalk.dim('    ')}${p.description}`);
+            }
+            console.log(`  ${chalk.dim('    →')} ${installCmd}\n`);
+        }
+        if (resp.count > list.length) {
+            info(t('plugin.showingCount', String(list.length), String(resp.count)));
+        }
+    }
+    catch (err) {
+        error(t('plugin.fetchError', err.message));
+    }
+}
+// ─── Search ───────────────────────────────────────────────────
+export async function pluginSearchCmd(term) {
+    if (!term) {
+        term = await input({ message: t('plugin.searchPrompt'), default: '' });
+        if (!term) {
+            info(t('plugin.searchCancelled'));
+            return;
+        }
+    }
+    await pluginListCmd({ q: term });
+}
+// ─── Info ─────────────────────────────────────────────────────
+export async function pluginInfoCmd(slug) {
+    if (!slug) {
+        slug = await input({ message: t('plugin.infoPrompt'), default: '' });
+        if (!slug) {
+            info(t('plugin.infoCancelled'));
+            return;
+        }
+    }
+    header(`📖 ${t('plugin.titleInfo')} — ${highlight(slug)}`);
+    step(t('plugin.fetching'));
+    try {
+        const detail = await fetchPluginDetail(slug);
+        const latest = detail.releases.find(r => r.is_stable) || detail.releases[0];
+        console.log(`\n  ${chalk.hex('#FFB347').bold(detail.name)}`);
+        if (detail.description)
+            console.log(`  ${dim(detail.description)}`);
+        console.log();
+        console.log(`  ${dim('Author:')}      ${highlight(detail.author)}`);
+        console.log(`  ${dim('Stars:')}       ${renderStars(detail.stars)} ${detail.stars}`);
+        console.log(`  ${dim('Downloads:')}   ${chalk.cyan(formatDownloads(detail.downloads))}`);
+        console.log(`  ${dim('Version:')}     ${chalk.green(detail.latest_version)}`);
+        console.log(`  ${dim('Updated:')}     ${dim(new Date(detail.updated_at).toLocaleDateString())}`);
+        console.log(`  ${dim('Tags:')}        ${(detail.tags || []).map(t => chalk.cyan(t)).join(', ')}`);
+        if (detail.repository_url)
+            console.log(`  ${dim('Repo:')}       ${chalk.blue(detail.repository_url)}`);
+        if (detail.documentation_url)
+            console.log(`  ${dim('Docs:')}       ${chalk.blue(detail.documentation_url)}`);
+        if (detail.license_url)
+            console.log(`  ${dim('License:')}    ${chalk.blue(detail.license_url)}`);
+        // Releases
+        if (detail.releases.length > 0) {
+            divider();
+            step(t('plugin.releases'));
+            for (const r of detail.releases.slice(0, 5)) {
+                const stable = r.is_stable ? chalk.green('●') : chalk.dim('○');
+                const fileInfo = r.files.length > 0
+                    ? `${chalk.cyan((r.files[0].size / 1024).toFixed(0) + ' KB')}`
+                    : '';
+                console.log(`  ${stable} ${chalk.bold('v' + r.version)}  ${dim(new Date(r.created_at).toLocaleDateString())}  ${fileInfo}`);
+            }
+            if (detail.releases.length > 5) {
+                info(t('plugin.moreReleases', String(detail.releases.length - 5)));
+            }
+        }
+    }
+    catch (err) {
+        error(t('plugin.notFound', slug));
+        if (err.message)
+            warn(err.message);
+    }
+}
+// ─── Install ──────────────────────────────────────────────────
+async function pickVersion(releases) {
+    const choices = releases.map(r => ({
+        name: `${r.is_stable ? chalk.green('●') : chalk.dim('○')}  v${r.version}  ${dim(new Date(r.created_at).toLocaleDateString())} ${r.is_stable ? chalk.green('stable') : chalk.dim('dev')}`,
+        value: r,
+    }));
+    return await select({
+        message: t('plugin.selectVersion'),
+        choices,
+    });
+}
+export async function pluginInstallCmd(names) {
+    const pluginsDir = await getPluginsDir();
+    await mkdir(pluginsDir, { recursive: true });
+    // interactive picker if no names
+    if (names.length === 0) {
+        header(`📦 ${t('plugin.titleInstall')}`);
+        step(t('plugin.fetching'));
+        try {
+            const resp = await fetchPluginsList({ sort: 'stars', limit: 50 });
+            const choices = resp.plugins.map(p => ({
+                name: `${chalk.hex('#FFB347')(p.name)} ${chalk.dim('—')} ${chalk.dim(p.description || '')}`,
+                value: p.slug,
+            }));
+            const selected = await checkbox({
+                message: t('plugin.selectPrompt'),
+                choices,
+                pageSize: 10,
+            });
+            names = selected;
+            if (names.length === 0) {
+                info(t('plugin.noSelection'));
+                return;
+            }
+        }
+        catch (err) {
+            error(t('plugin.fetchError', err.message));
+            return;
+        }
+    }
+    header(`📦 ${t('plugin.titleInstall')}`);
+    for (const slug of names) {
+        try {
+            step(t('plugin.fetchingInfo', slug));
+            // URL install
+            if (slug.startsWith('http://') || slug.startsWith('https://')) {
+                if (slug.endsWith('.jar')) {
+                    const dest = join(pluginsDir, slug.split('/').pop() || 'plugin.jar');
+                    await downloadFile(slug, dest, dest.split('/').pop() || 'plugin.jar');
+                    success(t('plugin.installSuccess', slug.split('/').pop() || ''));
+                }
+                else {
+                    error(t('plugin.urlInvalid'));
+                }
+                continue;
+            }
+            const detail = await fetchPluginDetail(slug);
+            let release = detail.releases.find(r => r.is_stable) || detail.releases[0];
+            if (!release) {
+                error(t('plugin.noRelease', slug));
+                continue;
+            }
+            // Ask for version if multiple releases
+            if (detail.releases.length > 1) {
+                release = await pickVersion(detail.releases);
+            }
+            const file = release.files[0];
+            if (!file) {
+                error(t('plugin.noFile', slug, release.version));
+                continue;
+            }
+            // Download via proxy
+            const downloadUrl = proxyDownloadUrl(slug, release.version);
+            const dest = join(pluginsDir, file.name);
+            await downloadFile(downloadUrl, dest, file.name);
+            // Track installation
+            await saveInstalledPlugin({
+                slug,
+                name: detail.name,
+                version: release.version,
+                installedAt: new Date().toISOString(),
+                fileName: file.name,
+            });
+            success(t('plugin.installSuccess', detail.name));
+        }
+        catch (err) {
+            error(t('plugin.installError', slug));
+            if (err.message)
+                warn(err.message);
+        }
+    }
+    // Summary
+    const jars = await getInstalledJars(pluginsDir);
+    if (jars.length > 0) {
+        console.log();
+        info(t('plugin.installedCount', String(jars.length)));
+        info(t('plugin.restartHint'));
+    }
+}
+// ─── Installed ────────────────────────────────────────────────
+async function getInstalledJars(dir) {
+    if (!existsSync(dir))
+        return [];
+    const files = await readdir(dir);
+    return files.filter(f => f.endsWith('.jar'));
+}
+export async function pluginInstalledCmd() {
+    const pluginsDir = await getPluginsDir();
+    header(`📁 ${t('plugin.titleInstalled')}`);
+    if (!existsSync(pluginsDir)) {
+        info(t('plugin.noPluginsDir'));
+        return;
+    }
+    const jars = await getInstalledJars(pluginsDir);
+    if (jars.length === 0) {
+        info(t('plugin.noPlugins'));
+        return;
+    }
+    const tracked = await getInstalledPlugins();
+    bullet(jars.map((j) => {
+        const slug = j.replace('.jar', '');
+        const meta = tracked.find(p => p.fileName === j || p.slug === slug);
+        if (meta) {
+            return `${highlight(slug)} ${dim('v' + meta.version)}`;
+        }
+        return highlight(slug);
+    }));
+    console.log();
+    info(t('plugin.installedCount', String(jars.length)));
+    info(t('plugin.restartHint'));
+}
+// ─── Remove ───────────────────────────────────────────────────
+export async function pluginRemoveCmd(names) {
+    const pluginsDir = await getPluginsDir();
+    header(`🗑️ ${t('plugin.titleRemove')}`);
+    if (!existsSync(pluginsDir)) {
+        error(t('plugin.noPluginsDir'));
+        return;
+    }
+    const jars = await getInstalledJars(pluginsDir);
+    if (names.length === 0) {
+        const choices = jars.map(j => ({
+            name: highlight(j.replace('.jar', '')),
+            value: j,
+        }));
+        if (choices.length === 0) {
+            info(t('plugin.noPlugins'));
+            return;
+        }
+        const selected = await checkbox({ message: t('plugin.removePrompt'), choices });
+        names = selected;
+        if (names.length === 0) {
+            info(t('plugin.noSelection'));
+            return;
+        }
+    }
+    for (const rawName of names) {
+        const target = rawName.endsWith('.jar') ? rawName : `${rawName}.jar`;
+        const found = jars.find(j => j.toLowerCase() === target.toLowerCase());
+        if (!found) {
+            warn(t('plugin.notFound', rawName));
+            continue;
+        }
+        const ok = await confirm({ message: t('plugin.removeConfirm', found), default: false });
+        if (ok) {
+            await rm(join(pluginsDir, found));
+            success(t('plugin.removed', found));
+        }
+        else {
+            info(t('plugin.removeCancelled', found));
+        }
+    }
+}
+// ─── Update ───────────────────────────────────────────────────
+export async function pluginUpdateCmd(names) {
+    const pluginsDir = await getPluginsDir();
+    header(`🔄 ${t('plugin.titleUpdate')}`);
+    if (!existsSync(pluginsDir)) {
+        error(t('plugin.noPluginsDir'));
+        return;
+    }
+    const jars = await getInstalledJars(pluginsDir);
+    if (jars.length === 0) {
+        info(t('plugin.noPlugins'));
+        return;
+    }
+    // interactive picker if no names
+    if (names.length === 0) {
+        const choices = jars.map(j => ({
+            name: highlight(j.replace('.jar', '')),
+            value: j,
+        }));
+        const selected = await checkbox({
+            message: t('plugin.updateSelect'),
+            choices,
+        });
+        names = selected.map(n => n.replace('.jar', ''));
+        if (names.length === 0) {
+            info(t('plugin.noSelection'));
+            return;
+        }
+    }
+    for (const rawName of names) {
+        const slug = rawName.endsWith('.jar') ? rawName.replace('.jar', '') : rawName;
+        const jarFile = jars.find(j => j.toLowerCase().startsWith(slug.toLowerCase()));
+        if (!jarFile) {
+            warn(t('plugin.notFound', rawName));
+            continue;
+        }
+        step(`${t('plugin.checkingUpdates')} ${highlight(slug)}`);
+        try {
+            const detail = await fetchPluginDetail(slug);
+            const latest = detail.releases.find(r => r.is_stable) || detail.releases[0];
+            if (!latest) {
+                warn(t('plugin.noRelease', slug));
+                continue;
+            }
+            const tracked = await getInstalledPlugins();
+            const meta = tracked.find(p => p.slug === slug);
+            if (meta && meta.version === latest.version) {
+                info(t('plugin.alreadyLatest', slug, latest.version));
+                continue;
+            }
+            const file = latest.files[0];
+            if (!file) {
+                warn(t('plugin.noFile', slug, latest.version));
+                continue;
+            }
+            // Backup old
+            const oldPath = join(pluginsDir, jarFile);
+            const backupPath = join(pluginsDir, `${jarFile}.old`);
+            await fsRename(oldPath, backupPath);
+            // Download new
+            const downloadUrl = proxyDownloadUrl(slug, latest.version);
+            const newPath = join(pluginsDir, file.name);
+            await downloadFile(downloadUrl, newPath, file.name);
+            // Remove backup
+            await rm(backupPath).catch(() => { });
+            // Update tracking
+            await saveInstalledPlugin({
+                slug,
+                name: detail.name,
+                version: latest.version,
+                installedAt: new Date().toISOString(),
+                fileName: file.name,
+            });
+            success(t('plugin.updateDone', detail.name, latest.version));
+        }
+        catch (err) {
+            error(t('plugin.updateError', rawName));
+            if (err.message)
+                warn(err.message);
+        }
+    }
+}

package/dist/commands/start.d.ts

@@ -0,0 +1,7 @@
+export declare function startCmd(options: {
+    dir?: string;
+    generateOnly?: boolean;
+    restart?: boolean;
+    memory?: string;
+    interactive?: boolean;
+}): Promise<void>;

package/dist/commands/start.js

@@ -0,0 +1,108 @@
+import { existsSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { join } from 'node:path';
+import { cwd } from 'node:process';
+import { input, confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { header, error, info, highlight, dim, success, step } from '../utils/logger.js';
+import { t } from '../lang/index.js';
+import { getDefaultJavaArgs, getJavaEnv } from '../utils/github.js';
+import { resolveServerDir } from '../utils/server.js';
+import { initCmd } from './init.js';
+function findJava() {
+    const javaHome = process.env.JAVA_HOME;
+    if (javaHome) {
+        return join(javaHome, 'bin', 'java');
+    }
+    return 'java';
+}
+function checkJavaVersion() {
+    return new Promise((resolve) => {
+        const java = findJava();
+        const child = spawn(java, ['-version']);
+        let output = '';
+        child.on('error', () => resolve({ ok: false, version: '?' }));
+        child.stderr.on('data', (data) => {
+            output += data.toString();
+        });
+        child.on('close', () => {
+            const match = output.match(/(?:openjdk|java) version "?(?:1\.)?(\d+)/);
+            if (match) {
+                const ver = parseInt(match[1], 10);
+                resolve({ ok: ver >= 21, version: String(ver) });
+            }
+            else {
+                resolve({ ok: false, version: '?' });
+            }
+        });
+    });
+}
+export async function startCmd(options) {
+    const serverPath = options.dir ? join(cwd(), options.dir) : ((await resolveServerDir()) || cwd());
+    if (options.dir) {
+        process.chdir(serverPath);
+    }
+    if (!existsSync(join(serverPath, 'powernukkitx.jar'))) {
+        info(t('start.jarNotFound'));
+        const createNow = await confirm({
+            message: t('start.createPrompt'),
+            default: true,
+        });
+        if (createNow) {
+            await initCmd({ dir: serverPath });
+            return;
+        }
+        error(t('start.jarNotFound'));
+        process.exit(1);
+    }
+    header(`🚀 ${t('start.title')}`);
+    let memory = options.memory || '2G';
+    let autoRestart = options.restart ?? false;
+    if (options.interactive) {
+        memory = await input({
+            message: 'Memory allocation',
+            default: memory,
+        });
+    }
+    step(t('start.checkingJava'));
+    const javaCheck = await checkJavaVersion();
+    if (!javaCheck.ok) {
+        error(t('start.javaNotFound'));
+        process.exit(1);
+    }
+    success(t('start.javaVersion', javaCheck.version));
+    const java = findJava();
+    const javaArgs = getDefaultJavaArgs();
+    const cmdArgs = [
+        `-Xms${memory}`,
+        `-XX:MaxRAMPercentage=75.0`,
+        ...javaArgs,
+        '-jar', 'powernukkitx.jar',
+    ];
+    if (options.generateOnly) {
+        console.log(`\n  ${highlight.bold(t('start.generatedCommand'))}`);
+        console.log(`  ${chalk.cyan(`${java} ${cmdArgs.join(' ')}`)}\n`);
+        return;
+    }
+    console.log(`\n  ${dim('JVM:')}     ${highlight(java)}`);
+    console.log(`  ${dim('Memory:')}  ${highlight(memory)}`);
+    console.log(`  ${dim('Restart:')} ${highlight(autoRestart ? 'Yes' : 'No')}\n`);
+    const runServer = () => {
+        const child = spawn(java, cmdArgs, {
+            stdio: 'inherit',
+            env: getJavaEnv(),
+            cwd: serverPath,
+        });
+        child.on('exit', (code) => {
+            if (code !== 0 && autoRestart) {
+                info(t('start.restarting'));
+                runServer();
+            }
+            else if (code !== 0) {
+                error(t('start.stopped', String(code ?? '?')));
+                process.exit(code ?? 0);
+            }
+        });
+    };
+    runServer();
+}

package/dist/commands/update.d.ts

@@ -0,0 +1,5 @@
+export declare function updateCmd(options: {
+    dir?: string;
+    dev?: boolean;
+    force?: boolean;
+}): Promise<void>;

package/dist/commands/update.js

@@ -0,0 +1,55 @@
+import { existsSync } from 'node:fs';
+import { rename } from 'node:fs/promises';
+import { join } from 'node:path';
+import { cwd } from 'node:process';
+import { confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { header, success, error, info, step } from '../utils/logger.js';
+import { t } from '../lang/index.js';
+import { getLatestRelease, findAsset, downloadFile } from '../utils/github.js';
+import { resolveServerDir } from '../utils/server.js';
+import { initCmd } from './init.js';
+export async function updateCmd(options) {
+    const serverPath = options.dir ? join(cwd(), options.dir) : ((await resolveServerDir()) || cwd());
+    if (!existsSync(join(serverPath, 'powernukkitx.jar'))) {
+        info(t('update.notFound'));
+        const createNow = await confirm({
+            message: t('start.createPrompt'),
+            default: true,
+        });
+        if (createNow) {
+            await initCmd({ dir: serverPath });
+            return;
+        }
+        error('powernukkitx.jar not found. Run "pnx init" first.');
+        process.exit(1);
+    }
+    header(`🔄 ${t('update.title')}`);
+    process.chdir(serverPath);
+    try {
+        step(t('update.checking'));
+        const release = await getLatestRelease();
+        const asset = await findAsset(release, 'powernukkitx.jar');
+        if (!asset) {
+            error('powernukkitx.jar not found in latest release.');
+            process.exit(1);
+        }
+        success(`${t('update.available')} ${chalk.bold(release.tag_name)}`);
+        if (existsSync('powernukkitx.jar.old') && !options.force) {
+            info('Old backup found, replacing...');
+        }
+        step(t('update.saving'));
+        await rename('powernukkitx.jar', 'powernukkitx.jar.old');
+        success(t('update.saved'));
+        await downloadFile(asset.browser_download_url, 'powernukkitx.jar', 'powernukkitx.jar');
+        success(t('update.done'));
+        console.log();
+        success(t('update.done'));
+        info(t('update.restartHint'));
+        info(t('update.deleteOldHint'));
+    }
+    catch (err) {
+        error(err.message);
+        process.exit(1);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};