@powernukkitx/cli 0.0.3 → 1.0.1

package/dist/commands/logs.js

@@ -0,0 +1,60 @@
+import { existsSync, readdirSync, statSync, readFileSync, watch } from 'node:fs';
+import { join } from 'node:path';
+import { defineCommand } from 'citty';
+import { intro, log } from '../ui/output.js';
+import { c } from '../ui/theme.js';
+import { resolveServerDir } from '../services/server.js';
+export const logsCmd = defineCommand({
+    meta: { description: 'View server logs' },
+    args: {
+        lines: { type: 'string', description: 'Number of lines to show', default: '50' },
+        follow: { type: 'boolean', description: 'Follow log output', default: true },
+    },
+    async run({ args }) {
+        intro(`📋 ${"Server logs"}`);
+        const serverPath = await resolveServerDir();
+        if (!serverPath) {
+            log.error("No server detected");
+            process.exit(1);
+        }
+        const logsDir = join(serverPath, 'logs');
+        if (!existsSync(logsDir)) {
+            log.error("No log files found");
+            process.exit(1);
+        }
+        const files = readdirSync(logsDir)
+            .filter(f => f.endsWith('.log') || f === 'latest.log')
+            .map(f => ({ name: f, mtime: statSync(join(logsDir, f)).mtime.getTime() }))
+            .sort((a, b) => b.mtime - a.mtime);
+        if (files.length === 0) {
+            log.error("No log files found");
+            process.exit(1);
+        }
+        const logPath = join(logsDir, files[0].name);
+        log.step(`Reading ${files[0].name}`);
+        const n = parseInt(args.lines) || 50;
+        const content = readFileSync(logPath, 'utf-8');
+        const colorize = (line) => line.replace(/\[ERROR\]/g, c.red('[ERROR]'))
+            .replace(/\[WARN\]/g, c.yellow('[WARN]'))
+            .replace(/\[INFO\]/g, c.blue('[INFO]'));
+        for (const line of content.split('\n').filter(Boolean).slice(-n)) {
+            process.stdout.write(colorize(line) + '\n');
+        }
+        if (args.follow) {
+            log.dim("Live mode (Ctrl+C to quit)");
+            process.on('SIGINT', () => { process.stdout.write('\n'); process.exit(0); });
+            let buf = content;
+            watch(logPath, () => {
+                try {
+                    const updated = readFileSync(logPath, 'utf-8');
+                    if (updated.length > buf.length) {
+                        process.stdout.write(updated.slice(buf.length));
+                        buf = updated;
+                    }
+                }
+                catch { }
+            });
+            await new Promise(() => { });
+        }
+    },
+});

package/dist/commands/menu.js

@@ -0,0 +1,94 @@
+import { intro, outro, log } from '../ui/output.js';
+import { promptSelect, promptText } from '../ui/prompts.js';
+import { resolveServerDir } from '../services/server.js';
+import { loadPid, isAlive } from '../services/process.js';
+import { c } from '../ui/theme.js';
+export async function runMenu() {
+    while (true) {
+        const done = await menuStep();
+        if (done)
+            return;
+        await promptText({ message: "Press enter to return to the menu", placeholder: '' });
+    }
+}
+async function menuStep() {
+    const serverPath = await resolveServerDir();
+    const hasServer = serverPath !== null;
+    const pid = await loadPid();
+    const running = pid !== null && isAlive(pid.pid);
+    intro(c.green(`⚡ ${"PowerNukkitX Menu"}`));
+    if (running)
+        log.info(`Server running (PID ${String(pid.pid)})`);
+    else if (hasServer)
+        log.info("Server stopped");
+    else
+        log.warn("No server detected");
+    const options = [];
+    if (!hasServer)
+        options.push({ value: 'create', label: "Create a server" });
+    if (hasServer && !running)
+        options.push({ value: 'start', label: "Start the server" });
+    if (running)
+        options.push({ value: 'stop', label: "Stop the server" });
+    if (hasServer) {
+        options.push({ value: 'plugins', label: "Manage plugins" });
+        options.push({ value: 'install', label: "Install a plugin" });
+        options.push({ value: 'update', label: "Update the core" });
+        options.push({ value: 'backup', label: "Backup" });
+    }
+    options.push({ value: 'doctor', label: "Diagnostics" });
+    options.push({ value: 'info', label: "Information" });
+    options.push({ value: 'quit', label: "Quit" });
+    const choice = await promptSelect("What do you want to do?", options);
+    switch (choice) {
+        case 'create': {
+            const { initCmd } = await import('./init.js');
+            await initCmd.run({ args: {} });
+            break;
+        }
+        case 'start': {
+            const { runStart } = await import('./start.js');
+            await runStart({});
+            break;
+        }
+        case 'stop': {
+            const { runStop } = await import('./stop.js');
+            await runStop();
+            break;
+        }
+        case 'plugins': {
+            const { installCmd } = await import('./plugin/install.js');
+            await installCmd.run({ args: {} });
+            break;
+        }
+        case 'install': {
+            const { runInstall } = await import('./install.js');
+            await runInstall();
+            break;
+        }
+        case 'update': {
+            const { runUpdate } = await import('./update.js');
+            await runUpdate();
+            break;
+        }
+        case 'backup': {
+            const { runBackup } = await import('./backup.js');
+            await runBackup();
+            break;
+        }
+        case 'doctor': {
+            const { doctorCmd } = await import('./doctor.js');
+            await doctorCmd.run({ args: {} });
+            break;
+        }
+        case 'info': {
+            const { infoCmd } = await import('./info.js');
+            await infoCmd.run({ args: {} });
+            break;
+        }
+        case 'quit':
+            outro("See you soon!");
+            return true;
+    }
+    return false;
+}

package/dist/commands/plugin/index.d.ts

@@ -0,0 +1,2 @@
+import type { CommandDef } from 'citty';
+export declare const pluginCmd: CommandDef;

package/dist/commands/plugin/index.js

@@ -0,0 +1,13 @@
+import { defineCommand } from 'citty';
+export const pluginCmd = defineCommand({
+    meta: { description: 'Plugin management' },
+    subCommands: {
+        install: () => import('./install.js').then(m => m.installCmd),
+        list: () => import('./list.js').then(m => m.listCmd),
+        search: () => import('./search.js').then(m => m.searchCmd),
+        info: () => import('./info.js').then(m => m.infoCmd),
+        update: () => import('./update.js').then(m => m.updateCmd),
+        remove: () => import('./remove.js').then(m => m.removeCmd),
+        installed: () => import('./installed.js').then(m => m.installedCmd),
+    },
+});

package/dist/commands/plugin/info.d.ts

@@ -0,0 +1,2 @@
+import type { CommandDef } from 'citty';
+export declare const infoCmd: CommandDef;

package/dist/commands/plugin/info.js

@@ -0,0 +1,39 @@
+import { defineCommand } from 'citty';
+import { intro, outro, log, spin } from '../../ui/output.js';
+import { c } from '../../ui/theme.js';
+import { promptText } from '../../ui/prompts.js';
+import { getPluginDetail } from '../../services/plugins.js';
+export const infoCmd = defineCommand({
+    meta: { description: 'Show plugin details' },
+    args: { slug: { type: 'positional', description: 'Plugin slug', required: false } },
+    async run({ args }) {
+        const slug = args.slug ?? await promptText({ message: "Plugin slug:" });
+        const sp = spin(slug);
+        try {
+            const d = await getPluginDetail(slug);
+            sp.stop(d.name);
+            intro(`📖 ${d.name}`);
+            if (d.description)
+                log.dim(d.description);
+            log.info(`Author:    ${c.accent(d.author)}`);
+            log.info(`Version:   ${c.green(d.latest_version)}`);
+            log.info(`Downloads: ${c.cyan(d.downloads >= 1000 ? (d.downloads / 1000).toFixed(1) + 'k' : String(d.downloads))}`);
+            log.info(`Updated:   ${new Date(d.updated_at).toLocaleDateString()}`);
+            if (d.tags.length)
+                log.info(`Tags: ${d.tags.map(tag => c.cyan(tag)).join(', ')}`);
+            if (d.repository_url)
+                log.info(`Repo: ${c.blue(d.repository_url)}`);
+            if (d.releases.length) {
+                log.step("Available versions:");
+                for (const r of d.releases.slice(0, 5)) {
+                    const stable = r.is_stable ? c.green('●') : c.dim('○');
+                    log.raw(`  ${stable} v${r.version}  ${c.dim(new Date(r.created_at).toLocaleDateString())}`);
+                }
+            }
+            outro('');
+        }
+        catch {
+            sp.fail(`Plugin not found: ${slug}`);
+        }
+    },
+});

package/dist/commands/plugin/install.d.ts

@@ -0,0 +1,2 @@
+import type { CommandDef } from 'citty';
+export declare const installCmd: CommandDef;

package/dist/commands/plugin/install.js

@@ -0,0 +1,56 @@
+import { join } from 'node:path';
+import { defineCommand } from 'citty';
+import { intro, outro, log, spin, progress } from '../../ui/output.js';
+import { promptMulti } from '../../ui/prompts.js';
+import { resolveServerDir } from '../../services/server.js';
+import { searchPlugins, installPlugin, installFromUrl } from '../../services/plugins.js';
+export const installCmd = defineCommand({
+    meta: { description: 'Install plugins' },
+    args: { names: { type: 'positional', description: 'Plugin slugs or .jar URLs', required: false } },
+    async run({ args }) {
+        const serverPath = (await resolveServerDir()) ?? '.';
+        const pluginsDir = join(serverPath, 'plugins');
+        let names = args.names ? [args.names] : [];
+        if (names.length === 0) {
+            intro(`📦 ${"Install plugins"}`);
+            const sp = spin("Fetching from marketplace...");
+            const resp = await searchPlugins({ sort: 'stars', limit: 50 });
+            sp.stop(`${resp.plugins.length} plugins`);
+            names = await promptMulti("Select plugins to install:", resp.plugins.map(p => ({ value: p.slug, label: p.name, hint: p.description })));
+            if (names.length === 0) {
+                log.info("No plugin selected");
+                return;
+            }
+        }
+        intro(`📦 ${"Install plugins"}`);
+        for (const name of names) {
+            if (name.startsWith('http://') || name.startsWith('https://')) {
+                try {
+                    const file = await installFromUrl(name, pluginsDir, (pct, f) => progress(pct, f));
+                    log.success(`${file} installed`);
+                }
+                catch {
+                    log.error("URL must point to a .jar file");
+                }
+                continue;
+            }
+            const sp = spin(name);
+            try {
+                const entry = await installPlugin(name, pluginsDir, (pct, f) => progress(pct, f));
+                sp.stop(`${entry.name} v${entry.version}`);
+                log.success(`${entry.name} installed`);
+            }
+            catch (e) {
+                const msg = e.message;
+                if (msg.startsWith('no-release'))
+                    sp.fail(`No release available for ${name}`);
+                else if (msg.startsWith('no-file'))
+                    sp.fail(`No file for ${name}`);
+                else
+                    sp.fail(`Error installing ${name}`);
+            }
+        }
+        log.info("Restart the server to load plugins");
+        outro('');
+    },
+});

package/dist/commands/plugin/installed.d.ts

@@ -0,0 +1,2 @@
+import type { CommandDef } from 'citty';
+export declare const installedCmd: CommandDef;

package/dist/commands/plugin/installed.js

@@ -0,0 +1,41 @@
+import { existsSync } from 'node:fs';
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { defineCommand } from 'citty';
+import { intro, outro, log, isJson, json } from '../../ui/output.js';
+import { c } from '../../ui/theme.js';
+import { resolveServerDir } from '../../services/server.js';
+import { getInstalled } from '../../services/plugins.js';
+export const installedCmd = defineCommand({
+    meta: { description: 'List installed plugins' },
+    args: {},
+    async run() {
+        const serverPath = await resolveServerDir();
+        const pluginsDir = serverPath ? join(serverPath, 'plugins') : 'plugins';
+        if (!existsSync(pluginsDir)) {
+            if (isJson())
+                json({ plugins: [] });
+            log.warn("No plugins/ directory");
+            return;
+        }
+        const jars = (await readdir(pluginsDir)).filter(f => f.endsWith('.jar'));
+        if (isJson())
+            json({ plugins: jars.map(j => ({ file: j })) });
+        intro(`📁 ${"Installed plugins"}`);
+        if (jars.length === 0) {
+            log.warn("No plugins installed");
+            return;
+        }
+        const tracked = await getInstalled();
+        for (const j of jars) {
+            const meta = tracked.find(p => p.fileName === j);
+            if (meta)
+                log.raw(`  ${c.accent('●')} ${c.bold(meta.name)}  ${c.dim('v' + meta.version)}`);
+            else
+                log.raw(`  ${c.dim('○')} ${j.replace('.jar', '')}`);
+        }
+        log.info(`${String(jars.length)} plugin(s)`);
+        log.info("Restart the server to load plugins");
+        outro('');
+    },
+});

package/dist/commands/plugin/list.d.ts

@@ -0,0 +1,2 @@
+import type { CommandDef } from 'citty';
+export declare const listCmd: CommandDef;

package/dist/commands/plugin/list.js

@@ -0,0 +1,47 @@
+import { defineCommand } from 'citty';
+import { intro, outro, log, spin, isJson, json } from '../../ui/output.js';
+import { c } from '../../ui/theme.js';
+import { searchPlugins } from '../../services/plugins.js';
+function stars(n) {
+    const full = '★'.repeat(Math.min(Math.floor(n / 10), 5));
+    const empty = '☆'.repeat(5 - full.length);
+    return (n >= 50 ? c.yellow : c.dim)(full + empty);
+}
+function dl(n) { return n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n); }
+export async function renderList(params) {
+    const sp = spin("Fetching from marketplace...");
+    try {
+        const resp = await searchPlugins(params);
+        sp.stop(`${resp.plugins.length} plugins`);
+        if (isJson())
+            json({ plugins: resp.plugins, count: resp.count });
+        intro(`📋 ${"Plugin catalog"}`);
+        for (const p of resp.plugins) {
+            log.raw(`  ${c.accent.bold(p.name)}  ${c.dim('by ' + p.author)}  ${stars(p.stars)}  ${c.cyan(dl(p.downloads) + ' dl')}  ${c.dim('v' + p.version)}`);
+            if (p.description)
+                log.raw(`    ${c.dim(p.description)}`);
+            log.raw(`    ${c.dim('→')} ${c.blue('pnx plugin install ' + p.slug)}\n`);
+        }
+        if (resp.count > resp.plugins.length)
+            log.info(`${resp.plugins.length}/${resp.count}`);
+        outro('');
+    }
+    catch (e) {
+        sp.fail(`Error: ${e.message}`);
+    }
+}
+export const listCmd = defineCommand({
+    meta: { description: 'List available plugins' },
+    args: {
+        sort: { type: 'string', description: 'Sort: newest|updated|stars' },
+        limit: { type: 'string', description: 'Results per page', default: '20' },
+        page: { type: 'string', description: 'Page number', default: '1' },
+        query: { type: 'string', description: 'Search query' },
+    },
+    run: ({ args }) => renderList({
+        sort: args.sort,
+        limit: parseInt(args.limit),
+        page: parseInt(args.page),
+        q: args.query,
+    }),
+});

package/dist/commands/plugin/remove.d.ts

@@ -0,0 +1,2 @@
+import type { CommandDef } from 'citty';
+export declare const removeCmd: CommandDef;

package/dist/commands/plugin/remove.js

@@ -0,0 +1,44 @@
+import { existsSync } from 'node:fs';
+import { readdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { defineCommand } from 'citty';
+import { intro, outro, log } from '../../ui/output.js';
+import { promptMulti, promptConfirm } from '../../ui/prompts.js';
+import { resolveServerDir } from '../../services/server.js';
+import { removeInstalled } from '../../services/plugins.js';
+export const removeCmd = defineCommand({
+    meta: { description: 'Remove installed plugins' },
+    args: { names: { type: 'positional', description: 'Plugin names', required: false } },
+    async run({ args }) {
+        const serverPath = (await resolveServerDir()) ?? '.';
+        const pluginsDir = join(serverPath, 'plugins');
+        if (!existsSync(pluginsDir)) {
+            log.error("No plugins/ directory");
+            return;
+        }
+        const jars = (await readdir(pluginsDir)).filter(f => f.endsWith('.jar'));
+        if (jars.length === 0) {
+            log.warn("No plugins installed");
+            return;
+        }
+        let names = args.names ? [args.names] : [];
+        if (names.length === 0) {
+            names = await promptMulti("Select plugins to remove:", jars.map(j => ({ value: j, label: j.replace('.jar', '') })));
+        }
+        intro(`🗑️ ${"Remove plugins"}`);
+        for (const name of names) {
+            const target = name.endsWith('.jar') ? name : `${name}.jar`;
+            const found = jars.find(j => j.toLowerCase() === target.toLowerCase());
+            if (!found) {
+                log.warn(`Plugin not found: ${name}`);
+                continue;
+            }
+            if (await promptConfirm(`Remove ${found}?`, false)) {
+                await rm(join(pluginsDir, found));
+                await removeInstalled(found.replace('.jar', ''));
+                log.success(`${found} removed`);
+            }
+        }
+        outro('');
+    },
+});

package/dist/commands/plugin/search.d.ts

@@ -0,0 +1,2 @@
+import type { CommandDef } from 'citty';
+export declare const searchCmd: CommandDef;

package/dist/commands/plugin/search.js

@@ -0,0 +1,11 @@
+import { defineCommand } from 'citty';
+import { promptText } from '../../ui/prompts.js';
+import { renderList } from './list.js';
+export const searchCmd = defineCommand({
+    meta: { description: 'Search plugins' },
+    args: { term: { type: 'positional', description: 'Search term', required: false } },
+    async run({ args }) {
+        const term = args.term ?? await promptText({ message: "Search plugins:" });
+        await renderList({ q: term, limit: 20, page: 1 });
+    },
+});

package/dist/commands/plugin/update.d.ts

@@ -0,0 +1,2 @@
+import type { CommandDef } from 'citty';
+export declare const updateCmd: CommandDef;

package/dist/commands/plugin/update.js

@@ -0,0 +1,52 @@
+import { existsSync } from 'node:fs';
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { defineCommand } from 'citty';
+import { intro, outro, log, spin, progress } from '../../ui/output.js';
+import { promptMulti } from '../../ui/prompts.js';
+import { resolveServerDir } from '../../services/server.js';
+import { getInstalled, updatePlugin } from '../../services/plugins.js';
+export const updateCmd = defineCommand({
+    meta: { description: 'Update installed plugins' },
+    args: { names: { type: 'positional', description: 'Plugin slugs', required: false } },
+    async run({ args }) {
+        const serverPath = (await resolveServerDir()) ?? '.';
+        const pluginsDir = join(serverPath, 'plugins');
+        if (!existsSync(pluginsDir)) {
+            log.error("No plugins/ directory");
+            return;
+        }
+        const jars = (await readdir(pluginsDir)).filter(f => f.endsWith('.jar'));
+        let names = args.names ? [args.names] : [];
+        if (names.length === 0) {
+            names = await promptMulti("Select plugins to update:", jars.map(j => ({ value: j.replace('.jar', ''), label: j.replace('.jar', '') })));
+        }
+        intro(`🔄 ${"Update plugins"}`);
+        const tracked = await getInstalled();
+        for (const slug of names) {
+            const sp = spin(slug);
+            try {
+                const meta = tracked.find(p => p.slug === slug);
+                const existingJar = jars.find(j => j.toLowerCase().startsWith(slug.toLowerCase()));
+                const entry = await updatePlugin(slug, pluginsDir, meta?.version, existingJar, (pct, f) => progress(pct, f));
+                if (!entry) {
+                    sp.stop(`${slug} is already up to date (v${meta?.version ?? '?'})`);
+                    continue;
+                }
+                sp.stop(`${entry.name} v${entry.version}`);
+                log.success(`${entry.name} updated to v${entry.version}`);
+            }
+            catch (e) {
+                const msg = e.message;
+                if (msg.startsWith('no-release'))
+                    sp.fail(`No release available for ${slug}`);
+                else if (msg.startsWith('no-file'))
+                    sp.fail(`No file for ${slug}`);
+                else
+                    sp.fail(`Error installing ${slug}`);
+            }
+        }
+        log.info("Restart the server to load plugins");
+        outro('');
+    },
+});

package/dist/commands/start.d.ts

@@ -1,7 +1,2 @@
-export declare function startCmd(options: {
-    dir?: string;
-    generateOnly?: boolean;
-    restart?: boolean;
-    memory?: string;
-    interactive?: boolean;
-}): Promise<void>;
+import type { CommandDef } from 'citty';
+export declare const startCmd: CommandDef;