@powernukkitx/cli 0.0.3 → 1.0.0

package/dist/i18n/fr.json

@@ -0,0 +1,174 @@
+{
+  "cli": { "description": "PowerNukkitX CLI — Gérez vos serveurs Minecraft Bedrock" },
+  "menu": {
+    "title": "Menu PowerNukkitX",
+    "prompt": "Que voulez-vous faire ?",
+    "create": "Créer un serveur",
+    "start": "Démarrer le serveur",
+    "stop": "Arrêter le serveur",
+    "plugins": "Gérer les plugins",
+    "update": "Mettre à jour le core",
+    "doctor": "Diagnostic",
+    "backup": "Sauvegarde",
+    "info": "Informations",
+    "lang": "Changer la langue",
+    "quit": "Quitter",
+    "statusRunning": "Serveur en cours (PID {0})",
+    "statusStopped": "Serveur arrêté",
+    "statusNoServer": "Aucun serveur détecté",
+    "bye": "À bientôt !"
+  },
+  "init": {
+    "title": "Créer un serveur PowerNukkitX",
+    "promptDir": "Répertoire du serveur ?",
+    "alreadyExists": "Un serveur existe déjà ici",
+    "fetchingInfo": "Récupération de la dernière version...",
+    "latestVersion": "Dernière version",
+    "downloading": "Téléchargement",
+    "downloaded": "Téléchargé ({0} Mo)",
+    "downloadingScripts": "Téléchargement des scripts...",
+    "scriptsDownloaded": "Scripts téléchargés",
+    "success": "Serveur prêt !",
+    "launchPrompt": "Démarrer le serveur maintenant ?"
+  },
+  "start": {
+    "title": "Démarrage du serveur",
+    "notFound": "Aucun serveur trouvé ici",
+    "createPrompt": "Créer un serveur maintenant ?",
+    "checkingJava": "Vérification de Java...",
+    "javaOk": "Java {0} détecté",
+    "javaNotFound": "Java 21+ requis — https://adoptium.net/",
+    "starting": "Démarrage...",
+    "running": "Serveur en cours d'exécution (PID {0})",
+    "stopped": "Serveur arrêté (code {0})",
+    "restarting": "Redémarrage...",
+    "generated": "Commande générée"
+  },
+  "stop": {
+    "title": "Arrêt du serveur",
+    "notRunning": "Aucun serveur en cours d'exécution",
+    "killing": "Arrêt du serveur (PID {0})...",
+    "done": "Serveur arrêté",
+    "failed": "Échec de l'arrêt"
+  },
+  "update": {
+    "title": "Mise à jour PowerNukkitX",
+    "checking": "Vérification des mises à jour...",
+    "notFound": "Aucun serveur trouvé",
+    "available": "Nouvelle version disponible : {0}",
+    "upToDate": "Déjà à jour ({0})",
+    "saving": "Sauvegarde de l'ancienne version...",
+    "downloading": "Téléchargement...",
+    "done": "Mise à jour terminée !",
+    "restart": "Redémarrez le serveur pour appliquer les changements"
+  },
+  "doctor": {
+    "title": "Diagnostic du serveur",
+    "checking": "Analyse en cours...",
+    "java": "Java",
+    "server": "Serveur",
+    "system": "Système",
+    "plugins": "Plugins & Mondes",
+    "network": "Réseau",
+    "done": "Diagnostic terminé",
+    "javaMissing": "Java 21+ requis",
+    "jarMissing": "powernukkitx.jar manquant",
+    "noServer": "Aucun serveur — exécutez 'pnx init'",
+    "portFree": "Port {0} disponible",
+    "portBusy": "Port {0} occupé"
+  },
+  "info": {
+    "title": "Informations du serveur",
+    "server": "Serveur",
+    "system": "Système",
+    "status": "Statut",
+    "installed": "Installé",
+    "notInstalled": "Non installé",
+    "path": "Chemin",
+    "plugins": "Plugins",
+    "worlds": "Mondes",
+    "ram": "RAM libre",
+    "ready": "Prêt à démarrer avec 'pnx start'",
+    "notReady": "Exécutez 'pnx init' pour créer un serveur"
+  },
+  "backup": {
+    "title": "Sauvegarde",
+    "noServer": "Aucun serveur détecté",
+    "collecting": "Collecte des fichiers...",
+    "size": "Taille estimée : {0}",
+    "copying": "Copie en cours...",
+    "done": "Sauvegarde créée : {0} ({1})"
+  },
+  "config": {
+    "title": "Configuration",
+    "noServer": "Aucun serveur détecté",
+    "notFound": "Aucun fichier de config trouvé",
+    "editHint": "Modifiez {0} pour changer ces valeurs"
+  },
+  "use": {
+    "title": "Serveur par défaut",
+    "prompt": "Sélectionnez un serveur :",
+    "pathPrompt": "Chemin du serveur :",
+    "set": "Serveur par défaut défini : {0}",
+    "cleared": "Serveur par défaut supprimé",
+    "notFound": "powernukkitx.jar introuvable dans : {0}"
+  },
+  "lang": {
+    "title": "Langue",
+    "prompt": "Choisissez votre langue",
+    "set": "Langue définie sur {0}"
+  },
+  "logs": {
+    "title": "Logs du serveur",
+    "noServer": "Aucun serveur détecté",
+    "noLogs": "Aucun fichier de logs trouvé",
+    "watching": "Lecture de {0}",
+    "liveMode": "Mode live (Ctrl+C pour quitter)"
+  },
+  "console": {
+    "title": "Console du serveur",
+    "noServer": "Aucun serveur détecté",
+    "rconDisabled": "RCON désactivé dans server.properties",
+    "rconEnable": "Activez enable-rcon=true dans server.properties",
+    "connecting": "Connexion RCON...",
+    "connected": "Connecté — tapez des commandes (exit pour quitter)",
+    "prompt": "> ",
+    "disconnected": "Déconnecté"
+  },
+  "plugin": {
+    "titleList": "Catalogue de plugins",
+    "titleInstall": "Installation de plugins",
+    "titleInstalled": "Plugins installés",
+    "titleRemove": "Suppression de plugins",
+    "titleInfo": "Informations du plugin",
+    "titleSearch": "Recherche de plugins",
+    "titleUpdate": "Mise à jour des plugins",
+    "fetching": "Récupération depuis la marketplace...",
+    "fetchError": "Erreur : {0}",
+    "notFound": "Plugin introuvable : {0}",
+    "noPlugins": "Aucun plugin installé",
+    "noPluginsDir": "Aucun répertoire plugins/",
+    "noneSelected": "Aucun plugin sélectionné",
+    "selectInstall": "Sélectionnez les plugins à installer :",
+    "selectRemove": "Sélectionnez les plugins à supprimer :",
+    "selectUpdate": "Sélectionnez les plugins à mettre à jour :",
+    "searchPrompt": "Rechercher des plugins :",
+    "slugPrompt": "Slug du plugin :",
+    "installSuccess": "{0} installé",
+    "installError": "Erreur lors de l'installation de {0}",
+    "removeConfirm": "Supprimer {0} ?",
+    "removed": "{0} supprimé",
+    "alreadyLatest": "{0} est déjà à jour (v{1})",
+    "updated": "{0} mis à jour vers v{1}",
+    "noRelease": "Aucune version disponible pour {0}",
+    "noFile": "Aucun fichier pour {0}",
+    "urlInvalid": "L'URL doit pointer vers un .jar",
+    "restartHint": "Redémarrez le serveur pour charger les plugins",
+    "count": "{0} plugin(s)",
+    "versionsAvailable": "Versions disponibles :"
+  },
+  "errors": {
+    "timeout": "Délai dépassé",
+    "network": "Erreur réseau : {0}"
+  }
+}

package/dist/i18n/index.js

@@ -0,0 +1,58 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { storePath } from '../infra/paths.js';
+import en from './en.json' with { type: 'json' };
+import fr from './fr.json' with { type: 'json' };
+const tables = { en, fr };
+let _code = 'fr';
+let _strings = fr;
+/** Langue sauvegardée dans le store (config.json), sinon null. */
+function savedLang() {
+    try {
+        const file = storePath('config.json');
+        if (existsSync(file)) {
+            const cfg = JSON.parse(readFileSync(file, 'utf-8'));
+            if (cfg.lang === 'en' || cfg.lang === 'fr')
+                return cfg.lang;
+        }
+    }
+    catch { /* ignore */ }
+    return null;
+}
+function envLang() {
+    const l = process.env.PNX_LANG || process.env.LANG || '';
+    if (l.startsWith('fr'))
+        return 'fr';
+    if (l.startsWith('en'))
+        return 'en';
+    return null;
+}
+/** Applique une langue en mémoire. */
+export function setLang(code) {
+    _code = tables[code] ? code : 'fr';
+    _strings = tables[_code];
+}
+/** Résout la langue: flag explicite > store > env > défaut fr. */
+export function initLang(explicit) {
+    const code = (explicit === 'en' || explicit === 'fr' ? explicit : null) ?? savedLang() ?? envLang() ?? 'fr';
+    setLang(code);
+    return _code;
+}
+export function currentLang() { return _code; }
+/** Traduit une clé pointée, interpole {0} {1}…, fallback anglais puis clé. */
+export function t(key, ...args) {
+    const resolve = (table) => {
+        let v = table;
+        for (const k of key.split('.')) {
+            if (v && typeof v === 'object' && k in v) {
+                v = v[k];
+            }
+            else
+                return undefined;
+        }
+        return typeof v === 'string' ? v : undefined;
+    };
+    const str = resolve(_strings) ?? resolve(tables.en);
+    if (str === undefined)
+        return key;
+    return str.replace(/{(\d+)}/g, (_, i) => String(args[parseInt(i)] ?? `{${i}}`));
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,260 +1 @@
-#!/usr/bin/env node
-import { Command } from 'commander';
-import { select } from '@inquirer/prompts';
-import chalk from 'chalk';
-import { logo, highlight, dim, success } from './utils/logger.js';
-import { t, initLanguage, setLanguage, saveLanguage } from './lang/index.js';
-import { initCmd } from './commands/init.js';
-import { startCmd } from './commands/start.js';
-import { pluginInstallCmd, pluginListCmd, pluginInstalledCmd, pluginRemoveCmd, pluginSearchCmd, pluginInfoCmd, pluginUpdateCmd } from './commands/plugin.js';
-import { updateCmd } from './commands/update.js';
-import { infoCmd } from './commands/info.js';
-import { doctorCmd } from './commands/doctor.js';
-import { backupCmd } from './commands/backup.js';
-import { configCmd } from './commands/config.js';
-import { detectServer } from './utils/server.js';
-import { checkForUpdates } from './utils/updater.js';
-const program = new Command();
-// -- detect --lang from argv before Commander parses
-const langIdx = process.argv.indexOf('--lang');
-const cliLang = langIdx >= 0 && process.argv.length > langIdx + 1
-    ? process.argv[langIdx + 1]
-    : undefined;
-initLanguage(cliLang);
-program
-    .name('pnx')
-    .description(highlight('PowerNukkitX CLI — Manage your Minecraft Bedrock servers'))
-    .version('0.2.0')
-    .option('--lang <code>', 'Set language (en, fr)')
-    .addHelpText('before', logo)
-    .addHelpText('after', `\n  ${dim('📖')} ${highlight('Documentation')}: https://docs.powernukkitx.org\n`);
-program
-    .command('init')
-    .description('Create a new PowerNukkitX server')
-    .option('-d, --dir <path>', 'Target directory')
-    .option('--dev', 'Install development version')
-    .action(async (opts) => { await initCmd(opts); });
-program
-    .command('start')
-    .description('Start the PowerNukkitX server')
-    .option('-g, --generate-only', 'Generate the start command without running')
-    .option('-r, --restart', 'Auto-restart on crash')
-    .option('-m, --memory <size>', 'Memory allocation (e.g. 2G, 4G)', '2G')
-    .option('-i, --interactive', 'Interactive mode with prompts')
-    .action(async (opts) => {
-    await checkForUpdates();
-    await startCmd(opts);
-});
-const pluginCmd = program
-    .command('plugin')
-    .description('Plugin management')
-    .alias('plugins');
-pluginCmd
-    .command('install [names...]')
-    .description('Install plugins (slug from marketplace or direct .jar URL)')
-    .action(async (names) => { await pluginInstallCmd(names); });
-pluginCmd
-    .command('list')
-    .description('List available plugins from the marketplace')
-    .option('-s, --sort <type>', 'Sort by: newest, updated, stars')
-    .option('-l, --limit <n>', 'Results per page (max 100)')
-    .option('-p, --page <n>', 'Page number')
-    .option('-q, --query <term>', 'Search query')
-    .action(async (opts) => {
-    await pluginListCmd(opts);
-});
-pluginCmd
-    .command('search [term]')
-    .description('Search plugins by name, description, or author')
-    .action(async (term) => { await pluginSearchCmd(term); });
-pluginCmd
-    .command('info [slug]')
-    .description('Show detailed plugin information')
-    .action(async (slug) => { await pluginInfoCmd(slug); });
-pluginCmd
-    .command('installed')
-    .description('List locally installed plugins')
-    .action(async () => { await pluginInstalledCmd(); });
-pluginCmd
-    .command('update [names...]')
-    .description('Update installed plugins to latest version')
-    .action(async (names) => { await pluginUpdateCmd(names); });
-pluginCmd
-    .command('remove [names...]')
-    .description('Remove installed plugins')
-    .alias('rm')
-    .action(async (names) => { await pluginRemoveCmd(names); });
-program
-    .command('update')
-    .description('Update powernukkitx.jar to the latest version')
-    .option('--dev', 'Install development version')
-    .option('-f, --force', 'Force update even if versions match')
-    .action(async (opts) => { await updateCmd(opts); });
-program
-    .command('doctor')
-    .description('Diagnose server health')
-    .action(async () => { await doctorCmd(); });
-program
-    .command('backup')
-    .description('Create a server backup')
-    .action(async () => { await backupCmd(); });
-program
-    .command('config')
-    .description('View server configuration (pnx.yml or server.properties)')
-    .action(async () => { await configCmd(); });
-program
-    .command('info')
-    .description('Show server information')
-    .alias('status')
-    .action(async () => { await infoCmd(); });
-program
-    .command('lang')
-    .description('Change language / Changer la langue')
-    .option('-s, --set <code>', 'Set language (en, fr)')
-    .action(async (opts) => {
-    if (opts.set) {
-        setLanguage(opts.set);
-        saveLanguage(opts.set);
-        success(t('lang.detected', opts.set));
-        return;
-    }
-    const lang = await select({
-        message: t('lang.prompt'),
-        choices: [
-            { name: 'English', value: 'en' },
-            { name: 'Français', value: 'fr' },
-        ],
-    });
-    setLanguage(lang);
-    saveLanguage(lang);
-    success(t('lang.detected', lang));
-});
-// ─── interactive menu ────────────────────────────────────────
-async function pickLanguage() {
-    const lang = await select({
-        message: '🌐  Select your language / Choisissez votre langue',
-        default: 'en',
-        choices: [
-            { name: '🇬🇧  English', value: 'en' },
-            { name: '🇫🇷  Français', value: 'fr' },
-        ],
-    });
-    setLanguage(lang);
-    saveLanguage(lang);
-}
-async function showMainMenu() {
-    await pickLanguage();
-    while (true) {
-        const serverPath = detectServer();
-        const hasServer = serverPath !== null;
-        const statusTag = hasServer
-            ? chalk.green(`● ${t('info.installed')}`)
-            : chalk.red(`○ ${t('info.notInstalled')}`);
-        const choice = await select({
-            message: `${highlight.bold(t('lang.menu'))}  ${dim('·')} ${statusTag}`,
-            pageSize: 10,
-            choices: [
-                { name: `🚀  ${t('init.title')}`, value: 'init' },
-                { name: `▶️  ${t('start.title')}`, value: 'start' },
-                { name: `📦  ${t('plugin.titleList')}`, value: 'plugin' },
-                { name: `🔄  ${t('update.title')}`, value: 'update' },
-                { name: `🩺  ${t('doctor.title')}`, value: 'doctor' },
-                { name: `💾  ${t('backup.title')}`, value: 'backup' },
-                { name: `⚙️  ${t('config.title')}`, value: 'config' },
-                { name: `📊  ${t('info.title')}`, value: 'info' },
-                { name: `🌐  ${t('lang.prompt')}`, value: 'lang' },
-                { name: `❌  ${t('lang.exit')}`, value: 'exit' },
-            ],
-        });
-        console.log();
-        switch (choice) {
-            case 'init':
-                await initCmd({});
-                break;
-            case 'start':
-                await checkForUpdates();
-                await startCmd({});
-                break;
-            case 'plugin':
-                await pluginListCmd({});
-                await showPluginSubmenu();
-                break;
-            case 'update':
-                await updateCmd({});
-                break;
-            case 'doctor':
-                await doctorCmd();
-                break;
-            case 'backup':
-                await backupCmd();
-                break;
-            case 'config':
-                await configCmd();
-                break;
-            case 'info':
-                await infoCmd();
-                break;
-            case 'lang':
-                await pickLanguage();
-                break;
-            case 'exit':
-                process.exit(0);
-        }
-    }
-}
-async function showPluginSubmenu() {
-    while (true) {
-        const action = await select({
-            message: highlight.bold(t('lang.pluginMenu')),
-            pageSize: 6,
-            choices: [
-                { name: `📥  ${t('plugin.titleInstall')}`, value: 'install' },
-                { name: `📋  ${t('plugin.titleList')}`, value: 'list' },
-                { name: `📖  ${t('plugin.titleInfo')}`, value: 'info' },
-                { name: `🔄  ${t('plugin.titleUpdate')}`, value: 'update' },
-                { name: `🗑️  ${t('plugin.titleRemove')}`, value: 'remove' },
-                { name: `🔙  ${t('lang.back')}`, value: 'back' },
-            ],
-        });
-        if (action === 'back')
-            return;
-        console.log();
-        switch (action) {
-            case 'install':
-                await pluginInstallCmd([]);
-                break;
-            case 'list':
-                await pluginListCmd({});
-                break;
-            case 'info':
-                await pluginInfoCmd();
-                break;
-            case 'update':
-                await pluginUpdateCmd([]);
-                break;
-            case 'remove':
-                await pluginRemoveCmd([]);
-                break;
-        }
-    }
-}
-// ─── decide: menu or direct command ───────────────────────────
-async function main() {
-    const rawArgs = process.argv.slice(2);
-    const helpFlags = ['--help', '-h', '--version', '-V'];
-    const hasSubcommand = rawArgs.length > 0 && !rawArgs.every(a => a.startsWith('-'));
-    if (rawArgs.some(a => helpFlags.includes(a))) {
-        await program.parseAsync(process.argv);
-    }
-    else if (!hasSubcommand) {
-        console.log(logo);
-        await showMainMenu();
-    }
-    else {
-        await program.parseAsync(process.argv).catch((err) => {
-            console.error(err);
-            process.exit(1);
-        });
-    }
-}
-main();
+export {};

package/dist/infra/http.js

@@ -0,0 +1,121 @@
+import https from 'node:https';
+import http from 'node:http';
+import { createWriteStream } from 'node:fs';
+const REDIRECT_CODES = [301, 302, 303, 307, 308];
+export class NetworkError extends Error {
+    statusCode;
+    constructor(message, statusCode) {
+        super(message);
+        this.statusCode = statusCode;
+        this.name = 'NetworkError';
+    }
+}
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+function get(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 }));
+            res.on('error', reject);
+        });
+        req.on('error', reject);
+        req.on('timeout', function () {
+            this.destroy();
+            reject(new NetworkError('Request timed out'));
+        });
+    });
+}
+async function getFollow(url, timeout, headers, redirects = 5) {
+    if (redirects <= 0)
+        throw new NetworkError('Too many redirects');
+    const res = await get(url, timeout, { 'User-Agent': 'pnx-cli', ...headers });
+    if (REDIRECT_CODES.includes(res.statusCode) && res.location) {
+        return getFollow(res.location, timeout, headers, redirects - 1);
+    }
+    if (res.statusCode !== 200)
+        throw new NetworkError(`HTTP ${res.statusCode}`, res.statusCode);
+    return res.body;
+}
+/** GET JSON avec suivi des redirections et retry exponentiel. */
+export async function fetchJSON(url, opts) {
+    const retries = opts?.retries ?? 3;
+    const timeout = opts?.timeout ?? 15_000;
+    const headers = opts?.headers ?? {};
+    let lastErr = new Error('Unknown error');
+    for (let attempt = 1; attempt <= retries; attempt++) {
+        try {
+            return JSON.parse(await getFollow(url, timeout, headers));
+        }
+        catch (err) {
+            lastErr = err;
+            if (attempt < retries) {
+                opts?.onRetry?.(lastErr.message, attempt, retries);
+                await sleep(2 ** (attempt - 1) * 1000);
+            }
+        }
+    }
+    throw lastErr;
+}
+function stream(url, dest, timeout, onData) {
+    return new Promise((resolve, reject) => {
+        const mod = url.startsWith('https') ? https : http;
+        const file = createWriteStream(dest);
+        const req = mod.get(url, { timeout, headers: { 'User-Agent': 'pnx-cli' } }, (res) => {
+            const code = res.statusCode ?? 0;
+            if (REDIRECT_CODES.includes(code) && res.headers.location) {
+                file.close();
+                resolve(stream(res.headers.location, dest, timeout, 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'));
+        });
+    });
+}
+/** Télécharge un fichier vers `dest` avec progression et retry. */
+export async function downloadFile(url, dest, opts) {
+    const retries = opts?.retries ?? 3;
+    const timeout = opts?.timeout ?? 120_000;
+    let lastErr = new Error('Unknown error');
+    for (let attempt = 1; attempt <= retries; attempt++) {
+        try {
+            let downloaded = 0;
+            let lastPct = -1;
+            await stream(url, dest, timeout, (chunk, total) => {
+                downloaded += chunk.length;
+                if (opts?.onProgress && total > 0) {
+                    const pct = Math.round((downloaded / total) * 100);
+                    if (pct !== lastPct && pct % 5 === 0) {
+                        opts.onProgress(pct, downloaded, total);
+                        lastPct = pct;
+                    }
+                }
+            });
+            return;
+        }
+        catch (err) {
+            lastErr = err;
+            if (attempt < retries) {
+                opts?.onRetry?.(lastErr.message, attempt, retries);
+                await sleep(2 ** (attempt - 1) * 1000);
+            }
+        }
+    }
+    throw lastErr;
+}

package/dist/infra/paths.js

@@ -0,0 +1,20 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/** Répertoire d'état du CLI (~/.pnx-cli), surchargeable via PNX_HOME (tests). */
+export function pnxHome() {
+    return process.env.PNX_HOME || join(homedir(), '.pnx-cli');
+}
+/** Chemin absolu d'un fichier du store dans le répertoire d'état. */
+export function storePath(name) {
+    return join(pnxHome(), name);
+}
+/** Nom du fichier jar du core. */
+export const JAR_NAME = 'powernukkitx.jar';
+/** Endpoint GitHub de la dernière release du core. */
+export const GITHUB_LATEST_RELEASE = 'https://api.github.com/repos/PowerNukkitX/PowerNukkitX/releases/latest';
+/** Base des scripts de démarrage officiels. */
+export const SCRIPTS_BASE = 'https://raw.githubusercontent.com/PowerNukkitX/scripts/master';
+/** Base de l'API marketplace, surchargeable via PNX_API_URL. */
+export function apiBase() {
+    return (process.env.PNX_API_URL ?? 'https://api.powernukkitx.org').replace(/\/$/, '');
+}

package/dist/infra/store.js

@@ -0,0 +1,27 @@
+import { existsSync } from 'node:fs';
+import { readFile, writeFile, mkdir, rm } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { storePath } from './paths.js';
+/** Lit un fichier JSON du store, renvoie `fallback` si absent ou illisible. */
+export async function readJson(name, fallback) {
+    try {
+        const file = storePath(name);
+        if (existsSync(file))
+            return JSON.parse(await readFile(file, 'utf-8'));
+    }
+    catch { /* corrompu → fallback */ }
+    return fallback;
+}
+/** Écrit un objet en JSON dans le store (crée le répertoire au besoin). */
+export async function writeJson(name, data) {
+    const file = storePath(name);
+    await mkdir(dirname(file), { recursive: true });
+    await writeFile(file, JSON.stringify(data, null, 2), 'utf-8');
+}
+/** Supprime un fichier du store (silencieux s'il n'existe pas). */
+export async function removeFile(name) {
+    try {
+        await rm(storePath(name));
+    }
+    catch { /* absent */ }
+}