@powernukkitx/cli 0.0.3 → 1.0.1

package/dist/commands/console.js

@@ -0,0 +1,98 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { createConnection } from 'node:net';
+import { defineCommand } from 'citty';
+import { intro, outro, log } from '../ui/output.js';
+import { resolveServerDir } from '../services/server.js';
+function parseServerProperties(serverPath) {
+    const propsPath = join(serverPath, 'server.properties');
+    if (!existsSync(propsPath))
+        return {};
+    const props = {};
+    for (const line of readFileSync(propsPath, 'utf-8').split('\n')) {
+        if (line.startsWith('#') || !line.includes('='))
+            continue;
+        const [k, ...v] = line.split('=');
+        props[k.trim()] = v.join('=').trim();
+    }
+    return props;
+}
+function rconPacket(id, type, body) {
+    const bodyBuf = Buffer.from(body + '\0\0', 'utf-8');
+    const packet = Buffer.alloc(12 + bodyBuf.length);
+    packet.writeInt32LE(8 + bodyBuf.length, 0);
+    packet.writeInt32LE(id, 4);
+    packet.writeInt32LE(type, 8);
+    bodyBuf.copy(packet, 12);
+    return packet;
+}
+function connectRcon(host, port, password) {
+    return new Promise(resolve => {
+        const socket = createConnection({ host, port }, () => socket.write(rconPacket(1, 3, password)));
+        socket.once('data', data => {
+            if (data.readInt32LE(4) === -1) {
+                socket.destroy();
+                resolve(null);
+                return;
+            }
+            resolve({
+                send: (cmd) => {
+                    socket.write(rconPacket(2, 2, cmd));
+                    socket.once('data', d => {
+                        const resp = d.slice(12, d.length - 2).toString('utf-8');
+                        if (resp)
+                            process.stdout.write(resp + '\n');
+                    });
+                },
+                close: () => socket.destroy(),
+            });
+        });
+        socket.on('error', () => resolve(null));
+        setTimeout(() => resolve(null), 3000);
+    });
+}
+export const consoleCmd = defineCommand({
+    meta: { description: 'Attach to server console via RCON' },
+    args: {},
+    async run() {
+        intro(`💻 ${"Server console"}`);
+        const serverPath = await resolveServerDir();
+        if (!serverPath) {
+            log.error("No server detected");
+            process.exit(1);
+        }
+        const props = parseServerProperties(serverPath);
+        const enabled = props['enable-rcon'] === 'true';
+        const port = parseInt(props['rcon.port'] ?? '25575');
+        const password = props['rcon.password'] ?? '';
+        if (enabled && password) {
+            log.step("Connecting via RCON...");
+            const rcon = await connectRcon('127.0.0.1', port, password);
+            if (rcon) {
+                log.success("Connected — type commands (exit to quit)");
+                const rl = createInterface({ input: process.stdin, output: process.stdout, prompt: "> " });
+                rl.prompt();
+                rl.on('line', line => {
+                    const cmd = line.trim();
+                    if (cmd === 'exit') {
+                        rcon.close();
+                        rl.close();
+                        outro("Disconnected");
+                        process.exit(0);
+                    }
+                    rcon.send(cmd);
+                    rl.prompt();
+                });
+                rl.on('close', () => { rcon.close(); process.exit(0); });
+                return;
+            }
+        }
+        log.warn("RCON disabled in server.properties");
+        log.info("Enable enable-rcon=true in server.properties");
+        log.dim('enable-rcon=true');
+        log.dim('rcon.port=25575');
+        log.dim('rcon.password=your_password');
+        process.exit(1);
+    },
+});

package/dist/commands/doctor.d.ts

@@ -1 +1,2 @@
-export declare function doctorCmd(): Promise<void>;
+import type { CommandDef } from 'citty';
+export declare const doctorCmd: CommandDef;

package/dist/commands/doctor.js

@@ -1,119 +1,97 @@
-import { existsSync, statSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { spawn } from 'node:child_process';
-import { createSocket } from 'node:dgram';
-import { header, success, error, info, warn, highlight, dim, step, divider } from '../utils/logger.js';
-import { t } from '../lang/index.js';
-import { resolveServerDir } from '../utils/server.js';
-import { getInstalledPlugins } from '../utils/plugins.js';
-import { pauseForExit } from '../utils/pause.js';
-function checkPort(port) {
-    return new Promise((resolve) => {
-        const socket = createSocket('udp4');
-        socket.once('error', () => { socket.close(); resolve(false); });
-        socket.bind(port, '0.0.0.0', () => { socket.close(); resolve(true); });
-    });
-}
-function checkJavaVersion() {
-    return new Promise((resolve) => {
-        const java = process.env.JAVA_HOME
-            ? join(process.env.JAVA_HOME, 'bin', 'java')
-            : 'java';
-        const child = spawn(java, ['-version']);
-        let output = '';
-        child.on('error', () => resolve({ ok: false, version: '?', path: java }));
-        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: output.split('\n')[0]?.trim() || String(ver), path: java });
-            }
-            else {
-                resolve({ ok: false, version: '?', path: java });
-            }
-        });
-    });
-}
-export async function doctorCmd() {
-    header(`🩺 ${t('doctor.title')}`);
-    // Java check
-    step(t('doctor.checkingJava'));
-    const java = await checkJavaVersion();
-    if (java.ok) {
-        success(t('doctor.javaOk', java.version));
-    }
-    else {
-        warn(`Java ${highlight('21+')} required — ${dim(java.path)}`);
-    }
-    // Server detection
-    step(t('doctor.checkingServer'));
-    const serverPath = await resolveServerDir();
-    if (!serverPath) {
-        error(t('doctor.serverNotFound'));
-        await pauseForExit();
-        return;
-    }
-    success(`${t('doctor.serverFound')} ${dim(serverPath)}`);
-    // JAR check
-    step(t('doctor.checkingJar'));
-    const jarPath = join(serverPath, 'powernukkitx.jar');
-    if (existsSync(jarPath)) {
-        const size = statSync(jarPath).size;
-        const sizeMb = (size / 1024 / 1024).toFixed(1);
-        success(t('doctor.jarOk', sizeMb));
-    }
-    else {
-        error(t('doctor.jarMissing'));
-    }
-    // pnx.yml check
-    step(t('doctor.checkingConfig'));
-    const ymlPath = join(serverPath, 'pnx.yml');
-    const propsPath = join(serverPath, 'server.properties');
-    if (existsSync(ymlPath)) {
-        success(t('doctor.configFound'));
-    }
-    else if (existsSync(propsPath)) {
-        info(t('doctor.configLegacy'));
-    }
-    else {
-        warn(t('doctor.configMissing'));
-    }
-    // plugins dir
-    step(t('doctor.checkingPlugins'));
-    const pluginsDir = join(serverPath, 'plugins');
-    if (existsSync(pluginsDir)) {
-        const files = readdirSync(pluginsDir).filter(f => f.endsWith('.jar'));
-        success(t('doctor.pluginsOk', String(files.length)));
-        // Check for updates
-        const tracked = await getInstalledPlugins();
-        if (tracked.length > 0) {
-            info(t('doctor.pluginCheckHint', 'pnx plugin update'));
-        }
-    }
-    else {
-        info(t('doctor.pluginsMissing'));
-    }
-    // worlds dir
-    step(t('doctor.checkingWorlds'));
-    const worldsDir = join(serverPath, 'worlds');
-    if (existsSync(worldsDir)) {
-        const worlds = readdirSync(worldsDir).filter(f => statSync(join(worldsDir, f)).isDirectory());
-        info(t('doctor.worldsFound', String(worlds.length)));
-    }
-    else {
-        info(t('doctor.worldsMissing'));
-    }
-    // Port check
-    step(t('doctor.checkingPort'));
-    const portFree = await checkPort(19132);
-    if (portFree) {
-        success(t('doctor.portFree'));
-    }
-    else {
-        warn(t('doctor.portInUse', '19132'));
-    }
-    divider();
-    success(t('doctor.done'));
-    await pauseForExit();
-}
+import { existsSync, statSync, readdirSync } from 'node:fs';
+import { statfs } from 'node:fs/promises';
+import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { createSocket } from 'node:dgram';
+import { freemem, totalmem } from 'node:os';
+import { defineCommand } from 'citty';
+import { intro, outro, log, section, spin, isJson, json } from '../ui/output.js';
+import { resolveServerDir, checkJava } from '../services/server.js';
+import { JAR_NAME } from '../infra/paths.js';
+function checkPort(port) {
+    return new Promise(res => {
+        const s = createSocket('udp4');
+        s.once('error', () => { s.close(); res(false); });
+        s.bind(port, '0.0.0.0', () => { s.close(); res(true); });
+    });
+}
+function pnxVersion(jarPath) {
+    try {
+        const r = spawnSync('java', ['-jar', jarPath, '--version'], { timeout: 3000, encoding: 'utf8' });
+        return ((r.stdout || '') + (r.stderr || '')).match(/(\d+\.\d+\.\d+[\w.-]*)/)?.[1] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+async function diskFreeMb(dir) {
+    try {
+        const s = await statfs(dir);
+        return Math.round((s.bfree * s.bsize) / 1024 / 1024);
+    }
+    catch {
+        return null;
+    }
+}
+export const doctorCmd = defineCommand({
+    meta: { description: 'Diagnose server health' },
+    args: {},
+    async run() {
+        const sp = spin("Running diagnostics...");
+        const java = await checkJava();
+        const serverPath = await resolveServerDir();
+        const jarPath = serverPath ? join(serverPath, JAR_NAME) : null;
+        const jarExists = jarPath ? existsSync(jarPath) : false;
+        const version = jarPath && jarExists ? pnxVersion(jarPath) : null;
+        const pluginsDir = serverPath ? join(serverPath, 'plugins') : null;
+        const worldsDir = serverPath ? join(serverPath, 'worlds') : null;
+        const pluginCount = pluginsDir && existsSync(pluginsDir)
+            ? readdirSync(pluginsDir).filter(f => f.endsWith('.jar')).length : 0;
+        const worldCount = worldsDir && existsSync(worldsDir)
+            ? readdirSync(worldsDir).filter(f => statSync(join(worldsDir, f)).isDirectory()).length : 0;
+        const freeMb = Math.round(freemem() / 1024 / 1024);
+        const totalMb = Math.round(totalmem() / 1024 / 1024);
+        const disk = serverPath ? await diskFreeMb(serverPath) : null;
+        const portFree = await checkPort(19132);
+        sp.stop("Diagnostics complete");
+        if (isJson())
+            json({
+                java: { ok: java.ok, version: java.raw, vendor: java.vendor },
+                server: { found: !!serverPath, path: serverPath, pnxVersion: version },
+                ram: { freeMb, totalMb },
+                disk: disk !== null ? { freeMb: disk } : null,
+                port: { free: portFree, port: 19132 },
+                plugins: { count: pluginCount },
+                worlds: { count: worldCount },
+            });
+        intro(`🩺 ${"Server diagnostics"}`);
+        section("Java");
+        if (java.ok)
+            log.success(`${java.raw} (${java.vendor})`);
+        else {
+            log.error("Java 21+ required");
+            log.info('https://adoptium.net/');
+        }
+        section("Server");
+        if (serverPath) {
+            log.success(serverPath);
+            if (jarExists)
+                log.success(`${JAR_NAME}${version ? ` v${version}` : ''}`);
+            else
+                log.error("powernukkitx.jar missing");
+        }
+        else
+            log.error("No server — run 'pnx init'");
+        section("Plugins & Worlds");
+        log.info(`Plugins: ${pluginCount}  |  Worlds: ${worldCount}`);
+        section("System");
+        log.info(`RAM: ${freeMb} MB / ${totalMb} MB`);
+        if (disk !== null)
+            log.info(`Disk: ${disk} MB`);
+        if (portFree)
+            log.success(`Port ${'19132'} available`);
+        else
+            log.warn(`Port ${'19132'} busy`);
+        outro("Diagnostics complete");
+    },
+});

package/dist/commands/info.d.ts

@@ -1 +1,2 @@
-export declare function infoCmd(): Promise<void>;
+import type { CommandDef } from 'citty';
+export declare const infoCmd: CommandDef;

package/dist/commands/info.js

@@ -1,36 +1,41 @@
-import { existsSync } from 'node:fs';
-import { readdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import chalk from 'chalk';
-import { header, info, warn, table, highlight } from '../utils/logger.js';
-import { t } from '../lang/index.js';
-import { resolveServerDir } from '../utils/server.js';
-import { pauseForExit } from '../utils/pause.js';
-export async function infoCmd() {
-    header(`📊 ${t('info.title')}`);
-    const serverPath = await resolveServerDir();
-    const jarExists = serverPath !== null;
-    let plugins = [];
-    let worlds = [];
-    if (serverPath && existsSync(join(serverPath, 'plugins'))) {
-        const files = await readdir(join(serverPath, 'plugins'));
-        plugins = files.filter((f) => f.endsWith('.jar'));
-    }
-    if (serverPath && existsSync(join(serverPath, 'worlds'))) {
-        worlds = await readdir(join(serverPath, 'worlds'));
-    }
-    table([
-        [t('info.status'), jarExists ? chalk.green(`✔ ${t('info.installed')}`) : chalk.red(`✘ ${t('info.notInstalled')}`)],
-        [t('info.serverDir'), serverPath ? highlight(serverPath) : chalk.dim('—')],
-        [t('info.plugins'), `${plugins.length} ${t('info.plugins')}`],
-        [t('info.worlds'), `${worlds.length} ${t('info.worlds')}`],
-    ]);
-    console.log();
-    if (jarExists) {
-        info(t('info.ready'));
-    }
-    else {
-        warn(t('info.notInitialized'));
-    }
-    await pauseForExit();
-}
+import { existsSync } from 'node:fs';
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { freemem, totalmem } from 'node:os';
+import { defineCommand } from 'citty';
+import { intro, outro, log, section, isJson, json } from '../ui/output.js';
+import { c } from '../ui/theme.js';
+import { resolveServerDir } from '../services/server.js';
+export const infoCmd = defineCommand({
+    meta: { description: 'Show server information' },
+    args: {},
+    async run() {
+        const serverPath = await resolveServerDir();
+        const installed = serverPath !== null;
+        let plugins = [], worlds = [];
+        if (serverPath && existsSync(join(serverPath, 'plugins'))) {
+            plugins = (await readdir(join(serverPath, 'plugins'))).filter(f => f.endsWith('.jar'));
+        }
+        if (serverPath && existsSync(join(serverPath, 'worlds'))) {
+            worlds = await readdir(join(serverPath, 'worlds'));
+        }
+        const freeMb = Math.round(freemem() / 1024 / 1024);
+        const totalMb = Math.round(totalmem() / 1024 / 1024);
+        if (isJson())
+            json({
+                status: installed ? 'installed' : 'not_installed',
+                serverDir: serverPath, plugins: plugins.length, worlds: worlds.length,
+                ram: { freeMb, totalMb },
+            });
+        intro(`📊 ${"Server info"}`);
+        section("Server");
+        log.info(`${"Status".padEnd(12)} ${installed ? c.green('✔ ' + "Installed") : c.red('✘ ' + "Not installed")}`);
+        if (serverPath)
+            log.info(`${"Path".padEnd(12)} ${c.accent(serverPath)}`);
+        log.info(`${"Plugins".padEnd(12)} ${plugins.length}`);
+        log.info(`${"Worlds".padEnd(12)} ${worlds.length}`);
+        section("System");
+        log.info(`${"Free RAM".padEnd(12)} ${freeMb} MB / ${totalMb} MB`);
+        outro(installed ? "Ready to start with 'pnx start'" : "Run 'pnx init' to create a server");
+    },
+});

package/dist/commands/init.d.ts

@@ -1,4 +1,2 @@
-export declare function initCmd(options: {
-    dir?: string;
-    dev?: boolean;
-}): Promise<void>;
+import type { CommandDef } from 'citty';
+export declare const initCmd: CommandDef;

package/dist/commands/init.js

@@ -1,73 +1,87 @@
-import { existsSync } from 'node:fs';
-import { mkdir } from 'node:fs/promises';
-import { join, resolve } from 'node:path';
-import { cwd } from 'node:process';
-import { input, confirm } from '@inquirer/prompts';
-import chalk from 'chalk';
-import { header, success, dim, step, error } from '../utils/logger.js';
-import { t } from '../lang/index.js';
-import { getLatestRelease, findAsset, downloadFile, getStartScripts } from '../utils/github.js';
-import { startCmd } from './start.js';
-export async function initCmd(options) {
-    header(`⚡ ${t('init.title')}`);
-    const targetDir = options.dir
-        ? resolve(cwd(), options.dir)
-        : resolve(cwd(), await input({
-            message: t('init.promptDir'),
-            default: 'pnx-server',
-            validate: (v) => {
-                if (!v.trim())
-                    return 'Path is required';
-                const p = resolve(cwd(), v);
-                if (existsSync(join(p, 'powernukkitx.jar'))) {
-                    return t('init.alreadyExists');
-                }
-                return true;
-            },
-        }));
-    const serverDir = resolve(cwd(), targetDir);
-    if (existsSync(join(serverDir, 'powernukkitx.jar'))) {
-        error(t('init.alreadyExists'));
-        process.exit(1);
-    }
-    try {
-        step(t('init.fetchingInfo'));
-        const release = await getLatestRelease();
-        success(`${t('init.latestVersion')}: ${chalk.bold(release.tag_name)}`);
-        const asset = await findAsset(release, 'powernukkitx.jar');
-        if (!asset) {
-            error('powernukkitx.jar not found in latest release.');
-            process.exit(1);
-        }
-        await mkdir(serverDir, { recursive: true });
-        const jarDest = join(serverDir, 'powernukkitx.jar');
-        await downloadFile(asset.browser_download_url, jarDest, 'powernukkitx.jar');
-        success(t('init.downloaded', (asset.size / 1024 / 1024).toFixed(1)));
-        step(t('init.downloadingScripts'));
-        const scripts = getStartScripts();
-        for (const script of scripts) {
-            const dest = join(serverDir, script.name);
-            await downloadFile(script.url, dest, script.name);
-        }
-        success(t('init.scriptsDownloaded'));
-        console.log(`\n  ${chalk.hex('#FFB347').bold(t('init.nextSteps'))}`);
-        console.log(`  ${dim('  1.')} ${chalk.hex('#FFB347')(`cd ${serverDir}`)}`);
-        console.log(`  ${dim('  2.')} ${chalk.hex('#FFB347')('pnx start')}   ${dim(`# ${t('init.nextStepStart')}`)}`);
-        console.log(`  ${dim('  3.')} ${chalk.hex('#FFB347')('pnx plugin list')}   ${dim(`# ${t('init.nextStepPlugins')}`)}`);
-        console.log(`  ${dim('  4.')} ${chalk.hex('#FFB347')('pnx plugin install <name>')}   ${dim(`# ${t('init.nextStepInstall')}`)}`);
-        console.log();
-        success(t('init.success'));
-        const launchNow = await confirm({
-            message: t('init.launchPrompt'),
-            default: false,
-        });
-        if (launchNow) {
-            console.log();
-            await startCmd({});
-        }
-    }
-    catch (err) {
-        error(err.message);
-        process.exit(1);
-    }
-}
+import { existsSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { cwd } from 'node:process';
+import { defineCommand } from 'citty';
+import { intro, outro, log, spin, progress, isJson } from '../ui/output.js';
+import { promptText, promptConfirm, promptSelect } from '../ui/prompts.js';
+import { listReleases, downloadCore } from '../services/release.js';
+import { startScripts, setDefaultServer } from '../services/server.js';
+import { downloadFile } from '../infra/http.js';
+import { JAR_NAME } from '../infra/paths.js';
+export const initCmd = defineCommand({
+    meta: { description: 'Create a new PowerNukkitX server' },
+    args: {
+        dir: { type: 'string', description: 'Target directory' },
+        version: { type: 'string', description: 'Version to install (tag), skips the picker' },
+        dev: { type: 'boolean', description: 'Install dev version', default: false },
+    },
+    async run({ args }) {
+        intro(`⚡ ${"Create a PowerNukkitX server"}`);
+        let target = args.dir;
+        if (!target) {
+            target = await promptText({
+                message: "Server directory?",
+                defaultValue: 'pnx-server',
+                validate: v => {
+                    if (!v || !v.trim())
+                        return 'Required';
+                    if (existsSync(join(resolve(cwd(), v), JAR_NAME)))
+                        return "A server already exists here";
+                    return undefined;
+                },
+            });
+        }
+        const serverDir = resolve(cwd(), target);
+        if (existsSync(join(serverDir, JAR_NAME)) && args.dir) {
+            log.error("A server already exists here");
+            process.exit(1);
+        }
+        try {
+            const sp = spin("Fetching versions...");
+            const releases = await listReleases();
+            sp.stop(`${String(releases.length)} versions found`);
+            if (releases.length === 0)
+                throw new Error("No releases available");
+            let release;
+            if (args.version) {
+                const wanted = args.version.replace(/^v/, '');
+                release = releases.find(r => r.tag === args.version || r.version === wanted);
+                if (!release)
+                    throw new Error(`Version ${args.version} not found`);
+            }
+            else if (isJson()) {
+                release = releases[0];
+            }
+            else {
+                const chosen = await promptSelect("Select a version", releases.map((r, i) => ({
+                    value: r.tag,
+                    label: i === 0 ? `${r.tag} (${"latest"})` : r.tag,
+                    hint: r.prerelease ? "pre-release" : undefined,
+                })));
+                release = releases.find(r => r.tag === chosen) ?? releases[0];
+            }
+            await mkdir(serverDir, { recursive: true });
+            log.step("Downloading");
+            const { size } = await downloadCore(release, join(serverDir, JAR_NAME), pct => progress(pct, JAR_NAME));
+            log.success(`Downloaded (${(size / 1024 / 1024).toFixed(1)} MB)`);
+            const sp2 = spin("Downloading start scripts...");
+            for (const s of startScripts())
+                await downloadFile(s.url, join(serverDir, s.name));
+            sp2.stop("Start scripts downloaded");
+            await setDefaultServer(serverDir);
+            log.success("Server ready!");
+            if (await promptConfirm("Start the server now?", false)) {
+                const { runStart } = await import('./start.js');
+                await runStart({ dir: serverDir });
+            }
+            else {
+                outro("Server ready!");
+            }
+        }
+        catch (e) {
+            log.error(e.message);
+            process.exit(1);
+        }
+    },
+});

package/dist/commands/install.js

@@ -0,0 +1,45 @@
+import { join } from 'node:path';
+import { defineCommand } from 'citty';
+import { intro, outro, log, spin, progress } from '../ui/output.js';
+import { promptText } from '../ui/prompts.js';
+import { resolveServerDir } from '../services/server.js';
+import { installApprovedPlugin } from '../services/plugins.js';
+export async function runInstall(slug) {
+    intro(`📦 ${"Install plugin"}`);
+    let name = slug?.trim();
+    if (!name) {
+        const answer = await promptText({ message: "Plugin slug? (owner.name)", placeholder: 'Owner.Plugin' });
+        name = answer?.trim();
+    }
+    if (!name) {
+        log.info("No plugin specified");
+        outro('');
+        return;
+    }
+    const serverPath = (await resolveServerDir()) ?? '.';
+    const pluginsDir = join(serverPath, 'plugins');
+    const sp = spin(name);
+    try {
+        const entry = await installApprovedPlugin(name, pluginsDir, (pct, f) => progress(pct, f));
+        sp.stop(`${entry.name} v${entry.version}`);
+        log.success(`Installed ${entry.name}`);
+        log.info("Restart the server to load plugins");
+    }
+    catch (e) {
+        const msg = e?.message ?? '';
+        if (msg.startsWith('not-approved'))
+            sp.fail(`${name} is not approved or does not exist`);
+        else if (msg.startsWith('no-file'))
+            sp.fail(`No file for ${name}`);
+        else
+            sp.fail(`Failed to install ${name}`);
+    }
+    outro('');
+}
+export const installCmd = defineCommand({
+    meta: { name: 'install', description: 'Install an approved plugin by slug (owner.name)' },
+    args: { slug: { type: 'positional', description: 'Plugin slug, e.g. RedstoneCloud.CloudBridge', required: false } },
+    async run({ args }) {
+        await runInstall(args.slug);
+    },
+});

package/dist/commands/logs.d.ts

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