@powernukkitx/cli 0.0.3 → 1.0.0

package/dist/commands/doctor.js

@@ -1,119 +1,98 @@
 import { existsSync, statSync, readdirSync } from 'node:fs';
+import { statfs } from 'node:fs/promises';
 import { join } from 'node:path';
-import { spawn } from 'node:child_process';
+import { spawnSync } 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';
+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';
+import { t } from '../i18n/index.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); });
+    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 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'));
+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;
     }
-    else {
-        warn(t('doctor.configMissing'));
+    catch {
+        return null;
     }
-    // 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'));
+}
+async function diskFreeMb(dir) {
+    try {
+        const s = await statfs(dir);
+        return Math.round((s.bfree * s.bsize) / 1024 / 1024);
     }
-    else {
-        warn(t('doctor.portInUse', '19132'));
+    catch {
+        return null;
     }
-    divider();
-    success(t('doctor.done'));
-    await pauseForExit();
 }
+export const doctorCmd = defineCommand({
+    meta: { description: 'Diagnose server health' },
+    args: {},
+    async run() {
+        const sp = spin(t('doctor.checking'));
+        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(t('doctor.done'));
+        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(`🩺 ${t('doctor.title')}`);
+        section(t('doctor.java'));
+        if (java.ok)
+            log.success(`${java.raw} (${java.vendor})`);
+        else {
+            log.error(t('doctor.javaMissing'));
+            log.info('https://adoptium.net/');
+        }
+        section(t('doctor.server'));
+        if (serverPath) {
+            log.success(serverPath);
+            if (jarExists)
+                log.success(`${JAR_NAME}${version ? ` v${version}` : ''}`);
+            else
+                log.error(t('doctor.jarMissing'));
+        }
+        else
+            log.error(t('doctor.noServer'));
+        section(t('doctor.plugins'));
+        log.info(`Plugins: ${pluginCount}  |  Worlds: ${worldCount}`);
+        section(t('doctor.system'));
+        log.info(`RAM: ${freeMb} Mo / ${totalMb} Mo`);
+        if (disk !== null)
+            log.info(`Disk: ${disk} Mo`);
+        if (portFree)
+            log.success(t('doctor.portFree', '19132'));
+        else
+            log.warn(t('doctor.portBusy', '19132'));
+        outro(t('doctor.done'));
+    },
+});

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,42 @@
 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 { 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';
+import { t } from '../i18n/index.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(`📊 ${t('info.title')}`);
+        section(t('info.server'));
+        log.info(`${t('info.status').padEnd(12)} ${installed ? c.green('✔ ' + t('info.installed')) : c.red('✘ ' + t('info.notInstalled'))}`);
+        if (serverPath)
+            log.info(`${t('info.path').padEnd(12)} ${c.accent(serverPath)}`);
+        log.info(`${t('info.plugins').padEnd(12)} ${plugins.length}`);
+        log.info(`${t('info.worlds').padEnd(12)} ${worlds.length}`);
+        section(t('info.system'));
+        log.info(`${t('info.ram').padEnd(12)} ${freeMb} Mo / ${totalMb} Mo`);
+        outro(installed ? t('info.ready') : t('info.notReady'));
+    },
+});

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

@@ -2,72 +2,65 @@ 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.');
+import { defineCommand } from 'citty';
+import { intro, outro, log, spin, progress } from '../ui/output.js';
+import { promptText, promptConfirm } from '../ui/prompts.js';
+import { getLatestRelease, downloadCore } from '../services/release.js';
+import { startScripts } from '../services/server.js';
+import { downloadFile } from '../infra/http.js';
+import { JAR_NAME } from '../infra/paths.js';
+import { t } from '../i18n/index.js';
+export const initCmd = defineCommand({
+    meta: { description: 'Create a new PowerNukkitX server' },
+    args: {
+        dir: { type: 'string', description: 'Target directory' },
+        dev: { type: 'boolean', description: 'Install dev version', default: false },
+    },
+    async run({ args }) {
+        intro(`⚡ ${t('init.title')}`);
+        let target = args.dir;
+        if (!target) {
+            target = await promptText({
+                message: t('init.promptDir'),
+                defaultValue: 'pnx-server',
+                validate: v => {
+                    if (!v || !v.trim())
+                        return 'Required';
+                    if (existsSync(join(resolve(cwd(), v), JAR_NAME)))
+                        return t('init.alreadyExists');
+                    return undefined;
+                },
+            });
+        }
+        const serverDir = resolve(cwd(), target);
+        if (existsSync(join(serverDir, JAR_NAME)) && args.dir) {
+            log.error(t('init.alreadyExists'));
             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);
+        try {
+            const sp = spin(t('init.fetchingInfo'));
+            const release = await getLatestRelease();
+            sp.stop(`${t('init.latestVersion')}: ${release.tag}`);
+            await mkdir(serverDir, { recursive: true });
+            log.step(t('init.downloading'));
+            const { size } = await downloadCore(release, join(serverDir, JAR_NAME), pct => progress(pct, JAR_NAME));
+            log.success(t('init.downloaded', (size / 1024 / 1024).toFixed(1)));
+            const sp2 = spin(t('init.downloadingScripts'));
+            for (const s of startScripts())
+                await downloadFile(s.url, join(serverDir, s.name));
+            sp2.stop(t('init.scriptsDownloaded'));
+            log.success(t('init.success'));
+            if (await promptConfirm(t('init.launchPrompt'), false)) {
+                const { runStart } = await import('./start.js');
+                await runStart({ dir: serverDir });
+            }
+            else {
+                outro(t('init.success'));
+            }
         }
-        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 (e) {
+            log.error(e.message);
+            process.exit(1);
         }
-    }
-    catch (err) {
-        error(err.message);
-        process.exit(1);
-    }
-}
+    },
+});

package/dist/commands/lang.d.ts

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

package/dist/commands/lang.js

@@ -0,0 +1,28 @@
+import { defineCommand } from 'citty';
+import { intro, outro, log } from '../ui/output.js';
+import { promptSelect } from '../ui/prompts.js';
+import { setLang, t } from '../i18n/index.js';
+import { readJson, writeJson } from '../infra/store.js';
+async function persistLang(code) {
+    const cfg = await readJson('config.json', {});
+    cfg.lang = code;
+    await writeJson('config.json', cfg);
+}
+export const langCmd = defineCommand({
+    meta: { description: 'Change language / Changer la langue' },
+    args: { set: { type: 'string', description: 'Language code (en, fr)' } },
+    async run({ args }) {
+        intro(`🌐 ${t('lang.title')}`);
+        let lang = args.set;
+        if (lang !== 'en' && lang !== 'fr') {
+            lang = await promptSelect(t('lang.prompt'), [
+                { value: 'fr', label: '🇫🇷  Français' },
+                { value: 'en', label: '🇬🇧  English' },
+            ]);
+        }
+        setLang(lang);
+        await persistLang(lang);
+        log.success(t('lang.set', lang));
+        outro(t('lang.set', lang));
+    },
+});

package/dist/commands/logs.d.ts

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

package/dist/commands/logs.js

@@ -0,0 +1,61 @@
+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';
+import { t } from '../i18n/index.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(`📋 ${t('logs.title')}`);
+        const serverPath = await resolveServerDir();
+        if (!serverPath) {
+            log.error(t('logs.noServer'));
+            process.exit(1);
+        }
+        const logsDir = join(serverPath, 'logs');
+        if (!existsSync(logsDir)) {
+            log.error(t('logs.noLogs'));
+            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(t('logs.noLogs'));
+            process.exit(1);
+        }
+        const logPath = join(logsDir, files[0].name);
+        log.step(t('logs.watching', 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(t('logs.liveMode'));
+            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 { /* rotation en cours */ }
+            });
+            await new Promise(() => { });
+        }
+    },
+});

package/dist/commands/menu.js

@@ -0,0 +1,86 @@
+import { intro, outro, log } from '../ui/output.js';
+import { promptSelect } from '../ui/prompts.js';
+import { detectServers } from '../services/server.js';
+import { loadPid, isAlive } from '../services/process.js';
+import { t } from '../i18n/index.js';
+/** Menu interactif racine, contextuel à l'état du serveur. */
+export async function runMenu() {
+    const servers = detectServers();
+    const hasServer = servers.length > 0;
+    const pid = await loadPid();
+    const running = pid !== null && isAlive(pid.pid);
+    intro(`⚡ ${t('menu.title')}`);
+    if (running)
+        log.info(t('menu.statusRunning', String(pid.pid)));
+    else if (hasServer)
+        log.info(t('menu.statusStopped'));
+    else
+        log.warn(t('menu.statusNoServer'));
+    const options = [];
+    if (!hasServer)
+        options.push({ value: 'create', label: t('menu.create') });
+    if (hasServer && !running)
+        options.push({ value: 'start', label: t('menu.start') });
+    if (running)
+        options.push({ value: 'stop', label: t('menu.stop') });
+    if (hasServer) {
+        options.push({ value: 'plugins', label: t('menu.plugins') });
+        options.push({ value: 'update', label: t('menu.update') });
+        options.push({ value: 'backup', label: t('menu.backup') });
+    }
+    options.push({ value: 'doctor', label: t('menu.doctor') });
+    options.push({ value: 'info', label: t('menu.info') });
+    options.push({ value: 'lang', label: t('menu.lang') });
+    options.push({ value: 'quit', label: t('menu.quit') });
+    const choice = await promptSelect(t('menu.prompt'), 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 '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 'lang': {
+            const { langCmd } = await import('./lang.js');
+            await langCmd.run({ args: {} });
+            break;
+        }
+        case 'quit':
+            outro(t('menu.bye'));
+            break;
+    }
+}

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;