@powernukkitx/cli 0.0.2 → 1.0.0

package/dist/commands/update.js

@@ -1,55 +1,35 @@
-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);
+import { defineCommand } from 'citty';
+import { intro, outro, log, spin, progress } from '../ui/output.js';
+import { resolveServerDir } from '../services/server.js';
+import { getLatestRelease, downloadCore } from '../services/release.js';
+import { JAR_NAME } from '../infra/paths.js';
+import { t } from '../i18n/index.js';
+export async function runUpdate(force = false) {
+    intro(`🔄 ${t('update.title')}`);
+    const serverPath = await resolveServerDir();
+    if (!serverPath) {
+        log.error(t('update.notFound'));
         process.exit(1);
     }
+    const sp = spin(t('update.checking'));
+    const release = await getLatestRelease(force);
+    sp.stop(t('update.available', release.tag));
+    const jarPath = join(serverPath, JAR_NAME);
+    log.step(t('update.saving'));
+    await rename(jarPath, `${jarPath}.old`).catch(() => { });
+    log.step(t('update.downloading'));
+    await downloadCore(release, jarPath, pct => progress(pct, JAR_NAME));
+    log.success(t('update.done'));
+    log.info(t('update.restart'));
+    outro(t('update.done'));
 }
+export const updateCmd = defineCommand({
+    meta: { description: 'Update PowerNukkitX to the latest version' },
+    args: {
+        force: { type: 'boolean', description: 'Force update', default: false },
+        dev: { type: 'boolean', description: 'Dev version', default: false },
+    },
+    run: ({ args }) => runUpdate(args.force),
+});

package/dist/commands/use.d.ts

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

package/dist/commands/use.js

@@ -0,0 +1,40 @@
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { cwd } from 'node:process';
+import { defineCommand } from 'citty';
+import { intro, outro, log } from '../ui/output.js';
+import { promptSelect, promptText } from '../ui/prompts.js';
+import { detectServers, setDefaultServer } from '../services/server.js';
+import { JAR_NAME } from '../infra/paths.js';
+import { t } from '../i18n/index.js';
+export const useCmd = defineCommand({
+    meta: { description: 'Set the default PowerNukkitX server directory' },
+    args: {
+        dir: { type: 'positional', description: 'Server path', required: false },
+        clear: { type: 'boolean', description: 'Remove default server', default: false },
+    },
+    async run({ args }) {
+        intro(`📌 ${t('use.title')}`);
+        if (args.clear) {
+            await setDefaultServer(null);
+            log.success(t('use.cleared'));
+            outro(t('use.cleared'));
+            return;
+        }
+        let target = args.dir;
+        if (!target) {
+            const servers = detectServers();
+            target = servers.length > 0
+                ? await promptSelect(t('use.prompt'), servers.map(s => ({ value: s, label: s })))
+                : await promptText({ message: t('use.pathPrompt'), defaultValue: cwd() });
+        }
+        const absPath = resolve(cwd(), target);
+        if (!existsSync(join(absPath, JAR_NAME))) {
+            log.error(t('use.notFound', absPath));
+            process.exit(1);
+        }
+        await setDefaultServer(absPath);
+        log.success(t('use.set', absPath));
+        outro(t('use.set', absPath));
+    },
+});

package/dist/core/config.d.ts

@@ -0,0 +1,13 @@
+export interface PnxConfig {
+    defaultServer?: string;
+    lang?: string;
+    lastUpdateCheck?: number;
+    lastCoreVersion?: string;
+}
+export declare function getConfig(): Promise<PnxConfig>;
+export declare function setConfig<K extends keyof PnxConfig>(key: K, value: PnxConfig[K]): Promise<void>;
+export declare const getDefaultServer: () => Promise<string | null>;
+export declare const setDefaultServer: (p: string) => Promise<void>;
+export declare const clearDefaultServer: () => Promise<void>;
+export declare const getLang: () => Promise<string>;
+export declare const setLang: (l: string) => Promise<void>;

package/dist/core/config.js

@@ -0,0 +1,31 @@
+import { existsSync } from 'node:fs';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const DIR = join(homedir(), '.pnx-cli');
+const FILE = join(DIR, 'config.json');
+export async function getConfig() {
+    try {
+        if (existsSync(FILE))
+            return JSON.parse(await readFile(FILE, 'utf-8'));
+    }
+    catch { }
+    return {};
+}
+export async function setConfig(key, value) {
+    try {
+        const cfg = await getConfig();
+        if (value === undefined)
+            delete cfg[key];
+        else
+            cfg[key] = value;
+        await mkdir(DIR, { recursive: true });
+        await writeFile(FILE, JSON.stringify(cfg, null, 2), 'utf-8');
+    }
+    catch { }
+}
+export const getDefaultServer = async () => (await getConfig()).defaultServer ?? null;
+export const setDefaultServer = (p) => setConfig('defaultServer', p);
+export const clearDefaultServer = () => setConfig('defaultServer', undefined);
+export const getLang = async () => (await getConfig()).lang ?? 'fr';
+export const setLang = (l) => setConfig('lang', l);

package/dist/core/network.d.ts

@@ -0,0 +1,13 @@
+export interface FetchOpts {
+    retries?: number;
+    timeout?: number;
+    headers?: Record<string, string>;
+}
+export interface DownloadOpts {
+    label?: string;
+    onProgress?: (pct: number, downloaded: number, total: number) => void;
+    timeout?: number;
+    retries?: number;
+}
+export declare function fetchJSON(url: string, opts?: FetchOpts): Promise<unknown>;
+export declare function downloadFile(url: string, dest: string, opts?: DownloadOpts): Promise<void>;

package/dist/core/network.js

@@ -0,0 +1,139 @@
+import https from 'node:https';
+import http from 'node:http';
+import { createWriteStream } from 'node:fs';
+import { log } from './output.js';
+class NetworkError extends Error {
+    statusCode;
+    attempt;
+    constructor(message, statusCode, attempt) {
+        super(message);
+        this.statusCode = statusCode;
+        this.attempt = attempt;
+        this.name = 'NetworkError';
+    }
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+function doGet(url, timeoutMs, headers) {
+    return new Promise((resolve, reject) => {
+        const mod = url.startsWith('https') ? https : http;
+        const req = mod.get(url, { timeout: timeoutMs, headers }, (res) => {
+            let body = '';
+            res.on('data', (chunk) => (body += chunk.toString()));
+            res.on('end', () => resolve({
+                statusCode: res.statusCode ?? 0,
+                location: res.headers.location,
+                body,
+                contentLength: parseInt(res.headers['content-length'] || '0', 10),
+                raw: res,
+            }));
+            res.on('error', reject);
+        });
+        req.on('error', reject);
+        req.on('timeout', function () {
+            this.destroy();
+            reject(new NetworkError('Request timed out'));
+        });
+    });
+}
+async function fetchRaw(url, opts, redirects = 5) {
+    if (redirects <= 0)
+        throw new NetworkError('Too many redirects');
+    const res = await doGet(url, opts.timeout, { 'User-Agent': 'pnx-cli', ...opts.headers });
+    if ([301, 302, 303, 307, 308].includes(res.statusCode) && res.location) {
+        return fetchRaw(res.location, opts, redirects - 1);
+    }
+    if (res.statusCode !== 200)
+        throw new NetworkError(`HTTP ${res.statusCode}`, res.statusCode);
+    return res.body;
+}
+export async function fetchJSON(url, opts) {
+    const config = {
+        retries: opts?.retries ?? 3,
+        timeout: opts?.timeout ?? 15_000,
+        headers: opts?.headers ?? {},
+    };
+    let lastErr = new Error('Unknown error');
+    for (let attempt = 1; attempt <= config.retries; attempt++) {
+        try {
+            const body = await fetchRaw(url, config);
+            return JSON.parse(body);
+        }
+        catch (err) {
+            lastErr = err;
+            if (attempt < config.retries) {
+                log.warn(`Network error (attempt ${attempt}/${config.retries}): ${err.message}`);
+                await sleep(Math.pow(2, attempt - 1) * 1000);
+            }
+        }
+    }
+    throw lastErr;
+}
+function doStream(url, dest, timeoutMs, onData) {
+    return new Promise((resolve, reject) => {
+        const mod = url.startsWith('https') ? https : http;
+        const file = createWriteStream(dest);
+        const req = mod.get(url, { timeout: timeoutMs, headers: { 'User-Agent': 'pnx-cli' } }, (res) => {
+            const code = res.statusCode ?? 0;
+            if ([301, 302, 303, 307, 308].includes(code) && res.headers.location) {
+                file.close();
+                resolve(doStream(res.headers.location, dest, timeoutMs, onData));
+                return;
+            }
+            if (code !== 200) {
+                file.close();
+                reject(new NetworkError(`HTTP ${code}`, code));
+                return;
+            }
+            const total = parseInt(res.headers['content-length'] || '0', 10);
+            res.on('data', (chunk) => onData(chunk, total));
+            res.pipe(file);
+            file.on('finish', () => {
+                file.close();
+                resolve();
+            });
+            file.on('error', reject);
+        });
+        req.on('error', (err) => {
+            file.close();
+            reject(err);
+        });
+        req.on('timeout', function () {
+            this.destroy();
+            file.close();
+            reject(new NetworkError('Download timed out'));
+        });
+    });
+}
+export async function downloadFile(url, dest, opts) {
+    const retries = opts?.retries ?? 3;
+    const timeout = opts?.timeout ?? 120_000;
+    const onProgress = opts?.onProgress;
+    let lastErr = new Error('Unknown error');
+    for (let attempt = 1; attempt <= retries; attempt++) {
+        try {
+            let downloaded = 0;
+            let lastPct = -1;
+            await doStream(url, dest, timeout, (chunk, total) => {
+                downloaded += chunk.length;
+                if (onProgress && total > 0) {
+                    const pct = Math.round((downloaded / total) * 100);
+                    if (pct !== lastPct && pct % 5 === 0) {
+                        onProgress(pct, downloaded, total);
+                        lastPct = pct;
+                    }
+                }
+            });
+            return;
+        }
+        catch (err) {
+            lastErr = err;
+            if (attempt < retries) {
+                log.warn(`Download error (attempt ${attempt}/${retries}): ${err.message}`);
+                await sleep(Math.pow(2, attempt - 1) * 1000);
+            }
+        }
+    }
+    throw lastErr;
+}

package/dist/core/output.d.ts

@@ -0,0 +1,33 @@
+import * as clack from '@clack/prompts';
+import chalk from 'chalk';
+declare const c: {
+    primary: import("chalk").ChalkInstance;
+    accent: import("chalk").ChalkInstance;
+    green: import("chalk").ChalkInstance;
+    red: import("chalk").ChalkInstance;
+    yellow: import("chalk").ChalkInstance;
+    blue: import("chalk").ChalkInstance;
+    cyan: import("chalk").ChalkInstance;
+};
+export declare function isJson(): boolean;
+export declare function json(data: unknown): never;
+export declare function intro(title: string): void;
+export declare function outro(msg: string): void;
+export declare function section(title: string): void;
+export declare function cancel(msg?: string): never;
+export declare function spin(msg: string): {
+    update: (m: string) => void;
+    stop: (m: string) => void;
+    fail: (m: string) => void;
+};
+export declare const log: {
+    success: (msg: string) => void;
+    error: (msg: string) => void;
+    warn: (msg: string) => void;
+    info: (msg: string) => void;
+    step: (msg: string) => void;
+    dim: (msg: string) => void;
+    raw: (msg: string) => void;
+};
+export declare function progress(pct: number, label?: string): void;
+export { clack, chalk, c };

package/dist/core/output.js

@@ -0,0 +1,75 @@
+import * as clack from '@clack/prompts';
+import chalk from 'chalk';
+const c = {
+    primary: chalk.hex('#FF6B35'),
+    accent: chalk.hex('#FFB347'),
+    green: chalk.hex('#4CAF50'),
+    red: chalk.hex('#E53935'),
+    yellow: chalk.hex('#FFC107'),
+    blue: chalk.hex('#6C8EBF'),
+    cyan: chalk.hex('#4ECDC4'),
+};
+const _isJson = process.argv.includes('--json');
+export function isJson() { return _isJson; }
+export function json(data) {
+    process.stdout.write(JSON.stringify(data, null, 2) + '\n');
+    process.exit(0);
+}
+export function intro(title) {
+    if (_isJson)
+        return;
+    clack.intro(c.primary.bold(` ${title} `));
+}
+export function outro(msg) {
+    if (_isJson)
+        return;
+    clack.outro(c.accent(msg));
+}
+export function section(title) {
+    if (_isJson)
+        return;
+    clack.log.step(c.accent.bold(title));
+}
+export function cancel(msg = 'Annulé') {
+    clack.cancel(c.yellow(msg));
+    process.exit(0);
+}
+export function spin(msg) {
+    if (_isJson)
+        return { update: () => { }, stop: () => { }, fail: () => { } };
+    const s = clack.spinner();
+    s.start(msg);
+    return {
+        update: (m) => s.message(m),
+        stop: (m) => s.stop(m),
+        fail: (m) => s.stop(m, 1),
+    };
+}
+export const log = {
+    success: (msg) => { if (!_isJson)
+        clack.log.success(c.green(msg)); },
+    error: (msg) => { if (!_isJson)
+        clack.log.error(c.red(msg)); },
+    warn: (msg) => { if (!_isJson)
+        clack.log.warn(c.yellow(msg)); },
+    info: (msg) => { if (!_isJson)
+        clack.log.info(c.blue(msg)); },
+    step: (msg) => { if (!_isJson)
+        clack.log.step(chalk.dim(msg)); },
+    dim: (msg) => { if (!_isJson)
+        clack.log.message(chalk.dim(msg)); },
+    raw: (msg) => { if (!_isJson)
+        process.stdout.write(msg + '\n'); },
+};
+export function progress(pct, label) {
+    if (_isJson)
+        return;
+    const clamped = Math.max(0, Math.min(100, pct));
+    const filled = Math.floor(clamped / 5);
+    const bar = c.cyan('━'.repeat(filled)) + chalk.dim('─'.repeat(20 - filled));
+    const suffix = label ? `  ${chalk.dim(label)}` : '';
+    process.stdout.write(`\r  ${bar}  ${chalk.bold(String(clamped))}%${suffix}`);
+    if (clamped >= 100)
+        process.stdout.write('\n');
+}
+export { clack, chalk, c };

package/dist/core/process.d.ts

@@ -0,0 +1,10 @@
+export interface PidInfo {
+    pid: number;
+    serverPath: string;
+    startedAt: string;
+}
+export declare function savePid(pid: number, serverPath: string): Promise<void>;
+export declare function loadPid(): Promise<PidInfo | null>;
+export declare function clearPid(): Promise<void>;
+export declare function isProcessAlive(pid: number): boolean;
+export declare function killProcess(pid: number): Promise<boolean>;

package/dist/core/process.js

@@ -0,0 +1,53 @@
+import { existsSync } from 'node:fs';
+import { readFile, writeFile, mkdir, rm } from 'node:fs/promises';
+import { homedir, platform } from 'node:os';
+import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+const DIR = join(homedir(), '.pnx-cli');
+const PID_FILE = join(DIR, 'pid.json');
+export async function savePid(pid, serverPath) {
+    await mkdir(DIR, { recursive: true });
+    await writeFile(PID_FILE, JSON.stringify({ pid, serverPath, startedAt: new Date().toISOString() }), 'utf-8');
+}
+export async function loadPid() {
+    try {
+        if (existsSync(PID_FILE))
+            return JSON.parse(await readFile(PID_FILE, 'utf-8'));
+    }
+    catch { }
+    return null;
+}
+export async function clearPid() {
+    try {
+        await rm(PID_FILE);
+    }
+    catch { }
+}
+export function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function killProcess(pid) {
+    if (!isProcessAlive(pid))
+        return false;
+    try {
+        if (platform() === 'win32') {
+            spawnSync('taskkill', ['/PID', String(pid), '/F']);
+        }
+        else {
+            process.kill(pid, 'SIGTERM');
+            await new Promise(r => setTimeout(r, 5000));
+            if (isProcessAlive(pid))
+                process.kill(pid, 'SIGKILL');
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/i18n/en.json

@@ -0,0 +1,174 @@
+{
+  "cli": { "description": "PowerNukkitX CLI — Manage your Minecraft Bedrock servers" },
+  "menu": {
+    "title": "PowerNukkitX Menu",
+    "prompt": "What do you want to do?",
+    "create": "Create a server",
+    "start": "Start the server",
+    "stop": "Stop the server",
+    "plugins": "Manage plugins",
+    "update": "Update the core",
+    "doctor": "Diagnostics",
+    "backup": "Backup",
+    "info": "Information",
+    "lang": "Change language",
+    "quit": "Quit",
+    "statusRunning": "Server running (PID {0})",
+    "statusStopped": "Server stopped",
+    "statusNoServer": "No server detected",
+    "bye": "See you soon!"
+  },
+  "init": {
+    "title": "Create a PowerNukkitX server",
+    "promptDir": "Server directory?",
+    "alreadyExists": "A server already exists here",
+    "fetchingInfo": "Fetching latest version...",
+    "latestVersion": "Latest version",
+    "downloading": "Downloading",
+    "downloaded": "Downloaded ({0} MB)",
+    "downloadingScripts": "Downloading start scripts...",
+    "scriptsDownloaded": "Start scripts downloaded",
+    "success": "Server ready!",
+    "launchPrompt": "Start the server now?"
+  },
+  "start": {
+    "title": "Start server",
+    "notFound": "No server found here",
+    "createPrompt": "Create a server now?",
+    "checkingJava": "Checking Java...",
+    "javaOk": "Java {0} detected",
+    "javaNotFound": "Java 21+ required — https://adoptium.net/",
+    "starting": "Starting...",
+    "running": "Server running (PID {0})",
+    "stopped": "Server stopped (code {0})",
+    "restarting": "Restarting...",
+    "generated": "Command generated"
+  },
+  "stop": {
+    "title": "Stop server",
+    "notRunning": "No server running",
+    "killing": "Stopping server (PID {0})...",
+    "done": "Server stopped",
+    "failed": "Failed to stop"
+  },
+  "update": {
+    "title": "Update PowerNukkitX",
+    "checking": "Checking for updates...",
+    "notFound": "No server found",
+    "available": "New version available: {0}",
+    "upToDate": "Already up to date ({0})",
+    "saving": "Backing up old version...",
+    "downloading": "Downloading...",
+    "done": "Update complete!",
+    "restart": "Restart the server to apply changes"
+  },
+  "doctor": {
+    "title": "Server diagnostics",
+    "checking": "Running diagnostics...",
+    "java": "Java",
+    "server": "Server",
+    "system": "System",
+    "plugins": "Plugins & Worlds",
+    "network": "Network",
+    "done": "Diagnostics complete",
+    "javaMissing": "Java 21+ required",
+    "jarMissing": "powernukkitx.jar missing",
+    "noServer": "No server — run 'pnx init'",
+    "portFree": "Port {0} available",
+    "portBusy": "Port {0} busy"
+  },
+  "info": {
+    "title": "Server info",
+    "server": "Server",
+    "system": "System",
+    "status": "Status",
+    "installed": "Installed",
+    "notInstalled": "Not installed",
+    "path": "Path",
+    "plugins": "Plugins",
+    "worlds": "Worlds",
+    "ram": "Free RAM",
+    "ready": "Ready to start with 'pnx start'",
+    "notReady": "Run 'pnx init' to create a server"
+  },
+  "backup": {
+    "title": "Backup",
+    "noServer": "No server detected",
+    "collecting": "Collecting files...",
+    "size": "Estimated size: {0}",
+    "copying": "Copying files...",
+    "done": "Backup created: {0} ({1})"
+  },
+  "config": {
+    "title": "Configuration",
+    "noServer": "No server detected",
+    "notFound": "No config file found",
+    "editHint": "Edit {0} to change these values"
+  },
+  "use": {
+    "title": "Default server",
+    "prompt": "Select a server:",
+    "pathPrompt": "Server path:",
+    "set": "Default server set: {0}",
+    "cleared": "Default server cleared",
+    "notFound": "powernukkitx.jar not found in: {0}"
+  },
+  "lang": {
+    "title": "Language",
+    "prompt": "Choose your language",
+    "set": "Language set to {0}"
+  },
+  "logs": {
+    "title": "Server logs",
+    "noServer": "No server detected",
+    "noLogs": "No log files found",
+    "watching": "Reading {0}",
+    "liveMode": "Live mode (Ctrl+C to quit)"
+  },
+  "console": {
+    "title": "Server console",
+    "noServer": "No server detected",
+    "rconDisabled": "RCON disabled in server.properties",
+    "rconEnable": "Enable enable-rcon=true in server.properties",
+    "connecting": "Connecting via RCON...",
+    "connected": "Connected — type commands (exit to quit)",
+    "prompt": "> ",
+    "disconnected": "Disconnected"
+  },
+  "plugin": {
+    "titleList": "Plugin catalog",
+    "titleInstall": "Install plugins",
+    "titleInstalled": "Installed plugins",
+    "titleRemove": "Remove plugins",
+    "titleInfo": "Plugin info",
+    "titleSearch": "Search plugins",
+    "titleUpdate": "Update plugins",
+    "fetching": "Fetching from marketplace...",
+    "fetchError": "Error: {0}",
+    "notFound": "Plugin not found: {0}",
+    "noPlugins": "No plugins installed",
+    "noPluginsDir": "No plugins/ directory",
+    "noneSelected": "No plugin selected",
+    "selectInstall": "Select plugins to install:",
+    "selectRemove": "Select plugins to remove:",
+    "selectUpdate": "Select plugins to update:",
+    "searchPrompt": "Search plugins:",
+    "slugPrompt": "Plugin slug:",
+    "installSuccess": "{0} installed",
+    "installError": "Error installing {0}",
+    "removeConfirm": "Remove {0}?",
+    "removed": "{0} removed",
+    "alreadyLatest": "{0} is already up to date (v{1})",
+    "updated": "{0} updated to v{1}",
+    "noRelease": "No release available for {0}",
+    "noFile": "No file for {0}",
+    "urlInvalid": "URL must point to a .jar file",
+    "restartHint": "Restart the server to load plugins",
+    "count": "{0} plugin(s)",
+    "versionsAvailable": "Available versions:"
+  },
+  "errors": {
+    "timeout": "Request timed out",
+    "network": "Network error: {0}"
+  }
+}