@woopsy/mcpanel 1.0.0

package/dist/config/configManager.js

@@ -0,0 +1,193 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigManager = exports.APP_ROOT = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Dynamically resolve application root folder
+exports.APP_ROOT = fs.existsSync(path.join(__dirname, '..', '..', 'package.json'))
+    ? path.resolve(__dirname, '..', '..')
+    : path.resolve(__dirname, '..');
+const CONFIG_PATH = path.join(exports.APP_ROOT, 'config.json');
+const DEFAULT_CONFIG = {
+    defaultJavaPath: 'java',
+    defaultRam: '4G',
+    autoBackupSettings: {
+        enabled: false,
+        intervalHours: 24,
+    },
+    playitSettings: {},
+    server: null,
+    externalBackups: [],
+};
+class ConfigManager {
+    config;
+    constructor() {
+        this.config = { ...DEFAULT_CONFIG };
+    }
+    /**
+     * Initializes folders and configuration file
+     */
+    initialize() {
+        const requiredDirs = ['backups', 'downloads', 'logs', 'playit'];
+        for (const dir of requiredDirs) {
+            const dirPath = path.join(exports.APP_ROOT, dir);
+            if (!fs.existsSync(dirPath)) {
+                fs.mkdirSync(dirPath, { recursive: true });
+            }
+        }
+        this.load();
+    }
+    /**
+     * Loads config.json from disk, falling back to defaults if missing or corrupted
+     */
+    load() {
+        if (!fs.existsSync(CONFIG_PATH)) {
+            this.config = { ...DEFAULT_CONFIG };
+            this.save();
+            return;
+        }
+        try {
+            const fileContent = fs.readFileSync(CONFIG_PATH, 'utf-8');
+            const parsed = JSON.parse(fileContent);
+            // Resolve the single managed server. Migrate from the legacy multi-server
+            // `servers` map (this CLI used to manage many) by adopting the first entry.
+            let server = null;
+            if (parsed.server && typeof parsed.server === 'object') {
+                const s = parsed.server;
+                server = {
+                    name: s.name,
+                    path: s.path,
+                    version: s.version || 'Unknown',
+                    software: s.software || 'Vanilla',
+                    ram: s.ram || parsed.defaultRam || '4G',
+                };
+            }
+            else if (parsed.servers && typeof parsed.servers === 'object') {
+                const first = Object.values(parsed.servers)[0];
+                if (first) {
+                    server = {
+                        name: first.name,
+                        path: first.path,
+                        version: first.version || 'Unknown',
+                        software: first.software || 'Vanilla',
+                        ram: first.ram || parsed.defaultRam || '4G',
+                    };
+                }
+            }
+            // Ensure key sections are initialized
+            this.config = {
+                defaultJavaPath: parsed.defaultJavaPath || 'java',
+                defaultRam: parsed.defaultRam || '4G',
+                autoBackupSettings: parsed.autoBackupSettings || { enabled: false, intervalHours: 24 },
+                playitSettings: parsed.playitSettings || {},
+                server,
+                externalBackups: parsed.externalBackups || [],
+            };
+            // Persist the migrated shape so the legacy keys are cleaned up on disk.
+            this.save();
+        }
+        catch (error) {
+            // Config corrupted
+            console.warn('⚠️ Config file is corrupted. Rebuilding default config.json...');
+            this.config = { ...DEFAULT_CONFIG };
+            this.save();
+        }
+    }
+    /**
+     * Saves the current config memory state to disk
+     */
+    save() {
+        try {
+            fs.writeFileSync(CONFIG_PATH, JSON.stringify(this.config, null, 2), 'utf-8');
+        }
+        catch (error) {
+            console.error('❌ Failed to save configuration file:', error);
+        }
+    }
+    /**
+     * Retrieves the raw config reference
+     */
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * Updates general settings
+     */
+    updateSettings(updates) {
+        this.config = { ...this.config, ...updates };
+        this.save();
+    }
+    /**
+     * Sets (or replaces) the single managed Minecraft server.
+     */
+    setServer(server) {
+        this.config.server = server;
+        this.save();
+    }
+    /**
+     * Returns the single managed server, or null if none is synced yet.
+     */
+    getServer() {
+        return this.config.server;
+    }
+    /**
+     * Persists the playit agent secret key so the tunnel only needs claiming once.
+     */
+    setPlayitSecret(secret) {
+        this.config.playitSettings.secret = secret;
+        this.save();
+    }
+    /**
+     * Persists the last known tunnel details for status reporting between sessions.
+     */
+    updatePlayitTunnel(details) {
+        this.config.playitSettings = { ...this.config.playitSettings, ...details };
+        this.save();
+    }
+    /**
+     * Adds an external backup location
+     */
+    addExternalBackup(backupPath) {
+        const absolute = path.resolve(backupPath);
+        if (!this.config.externalBackups.includes(absolute)) {
+            this.config.externalBackups.push(absolute);
+            this.save();
+            return true;
+        }
+        return false;
+    }
+}
+exports.ConfigManager = ConfigManager;