@dimzxzzx07/mc-headless 2.2.2 → 2.2.4

package/dist/core/MinecraftServer.js

@@ -51,6 +51,7 @@ const FabricEngine_1 = require("../engines/FabricEngine");
 const GeyserBridge_1 = require("../platforms/GeyserBridge");
 const ViaVersion_1 = require("../platforms/ViaVersion");
 const SkinRestorer_1 = require("../platforms/SkinRestorer");
+const PluginManager_1 = require("../platforms/PluginManager");
 class MinecraftServer extends events_1.EventEmitter {
     config;
     options;
@@ -59,11 +60,13 @@ class MinecraftServer extends events_1.EventEmitter {
     geyser;
     viaVersion;
     skinRestorer;
+    pluginManager;
     process = null;
     serverInfo;
     players = new Map();
     backupCron = null;
     cleanLogsCron = null;
+    ramdiskBackupCron = null;
     startTime = null;
     memoryMonitorInterval = null;
     statsInterval = null;
@@ -80,39 +83,75 @@ class MinecraftServer extends events_1.EventEmitter {
     cgroupMemory = 0;
     cgroupCpu = 0;
     isPterodactyl = false;
+    ramdiskPaths = new Map();
+    serverReady = false;
     constructor(userConfig = {}) {
         super();
         this.logger = Logger_1.Logger.getInstance();
         this.logger.banner();
         this.detectEnvironment();
+        const defaultMemoryMonitor = {
+            enabled: true,
+            threshold: 90,
+            interval: 30000,
+            action: 'warn',
+            maxMemoryLeakRestarts: 3,
+            gcOnWarning: true
+        };
+        const defaultNetworkOptimization = {
+            tcpFastOpen: true,
+            tcpNoDelay: true,
+            preferIPv4: true,
+            compressionThreshold: 64,
+            bungeeMode: false,
+            proxyProtocol: false,
+            velocity: {
+                enabled: false,
+                secret: '',
+                forwardingMode: 'modern'
+            }
+        };
+        const defaultOwnerCommands = {
+            prefix: '!',
+            enabled: true,
+            usernames: [],
+            permissions: []
+        };
+        const defaultRamdisk = {
+            enabled: false,
+            world: false,
+            plugins: false,
+            addons: false,
+            backupInterval: 300000,
+            masterStorage: '/home/minecraft-master',
+            size: '1G',
+            mountPoint: '/dev/shm/minecraft'
+        };
         this.options = {
             javaVersion: 'auto',
             usePortableJava: !this.isPterodactyl,
-            memoryMonitor: {
-                enabled: true,
-                threshold: 90,
-                interval: 30000,
-                action: 'warn'
-            },
+            memoryMonitor: defaultMemoryMonitor,
             autoInstallJava: true,
-            networkOptimization: {
-                tcpFastOpen: true,
-                bungeeMode: false,
-                proxyProtocol: false
-            },
+            networkOptimization: defaultNetworkOptimization,
             owners: [],
-            ownerCommands: {
-                prefix: '!',
-                enabled: true
-            },
+            ownerCommands: defaultOwnerCommands,
             silentMode: true,
             statsInterval: 30000,
             cleanLogsInterval: 3 * 60 * 60 * 1000,
             optimizeForPterodactyl: true,
+            ramdisk: defaultRamdisk,
+            symlinkMaster: '/home/minecraft-master',
+            enableProtocolLib: false,
+            enableTCPShield: false,
+            enableSpigotOptimizers: false,
+            enableSpark: false,
+            enableViewDistanceTweaks: false,
+            enableFarmControl: false,
+            enableEntityDetection: false,
             ...userConfig
         };
         if (this.options.owners) {
-            this.options.owners.forEach(owner => this.owners.add(owner.toLowerCase()));
+            this.options.owners.forEach((owner) => this.owners.add(owner.toLowerCase()));
         }
         if (this.options.ownerCommands?.prefix) {
             this.ownerCommandPrefix = this.options.ownerCommands.prefix;
@@ -126,6 +165,7 @@ class MinecraftServer extends events_1.EventEmitter {
         this.geyser = new GeyserBridge_1.GeyserBridge();
         this.viaVersion = new ViaVersion_1.ViaVersionManager();
         this.skinRestorer = new SkinRestorer_1.SkinRestorerManager();
+        this.pluginManager = new PluginManager_1.PluginManager();
         this.serverInfo = {
             pid: 0,
             ip: this.config.network.ip,
@@ -142,27 +182,60 @@ class MinecraftServer extends events_1.EventEmitter {
             status: 'stopped'
         };
         this.detectCgroupLimits();
-        this.cleanPaperCache();
     }
     detectEnvironment() {
         this.isPterodactyl = !!(process.env.PTERODACTYL ||
             process.env.SERVER_PORT ||
-            process.env.SERVER_MEMORY_MAX ||
             fs.existsSync('/home/container'));
         if (this.isPterodactyl) {
             this.logger.info('Pterodactyl environment detected');
+            const serverPort = process.env.SERVER_PORT;
+            if (serverPort) {
+                this.config.network.port = parseInt(serverPort);
+                this.logger.info(`Using Pterodactyl Java port: ${serverPort}`);
+            }
+            const bedrockPort = process.env.BEDROCK_PORT;
+            if (bedrockPort) {
+                this.config.network.bedrockPort = parseInt(bedrockPort);
+                this.logger.info(`Using Pterodactyl Bedrock port: ${bedrockPort}`);
+            }
+            else {
+                this.logger.warning('No BEDROCK_PORT environment variable found. Geyser will share Java port.');
+                this.logger.warning('Make sure UDP is enabled for this port in Pterodactyl panel');
+            }
+        }
+    }
+    detectCgroupLimits() {
+        try {
+            if (fs.existsSync('/sys/fs/cgroup/memory/memory.limit_in_bytes')) {
+                const limit = fs.readFileSync('/sys/fs/cgroup/memory/memory.limit_in_bytes', 'utf8');
+                this.cgroupMemory = parseInt(limit) / 1024 / 1024;
+                this.logger.debug(`Cgroup memory limit: ${this.cgroupMemory} MB`);
+            }
+            if (fs.existsSync('/sys/fs/cgroup/cpu/cpu.cfs_quota_us') && fs.existsSync('/sys/fs/cgroup/cpu/cpu.cfs_period_us')) {
+                const quota = parseInt(fs.readFileSync('/sys/fs/cgroup/cpu/cpu.cfs_quota_us', 'utf8'));
+                const period = parseInt(fs.readFileSync('/sys/fs/cgroup/cpu/cpu.cfs_period_us', 'utf8'));
+                if (quota > 0 && period > 0) {
+                    this.cgroupCpu = quota / period;
+                    this.logger.debug(`Cgroup CPU limit: ${this.cgroupCpu} cores`);
+                }
+            }
+        }
+        catch (error) {
+            this.logger.debug('Not running in cgroup environment');
         }
     }
     optimizeForPterodactylPanel() {
         const pterodactylPort = process.env.SERVER_PORT;
         if (pterodactylPort) {
             this.config.network.port = parseInt(pterodactylPort);
-            this.logger.info(`Using Pterodactyl port: ${pterodactylPort}`);
         }
         const pterodactylMemory = process.env.SERVER_MEMORY_MAX;
         if (pterodactylMemory) {
-            this.config.memory.max = pterodactylMemory;
-            this.logger.info(`Using Pterodactyl memory: ${pterodactylMemory}`);
+            const memValue = parseInt(pterodactylMemory);
+            const safeMemory = Math.floor(memValue * 0.9);
+            this.config.memory.max = `${safeMemory}M`;
+            this.logger.info(`Pterodactyl memory limit detected, using 90% safe value: ${safeMemory}MB`);
         }
         const pterodactylInitMemory = process.env.SERVER_MEMORY_INIT;
         if (pterodactylInitMemory) {
@@ -170,27 +243,119 @@ class MinecraftServer extends events_1.EventEmitter {
         }
         this.config.world.viewDistance = 6;
         this.config.world.simulationDistance = 4;
-        this.logger.info('Applied Pterodactyl optimizations');
     }
-    cleanPaperCache() {
-        const cachePaths = [
-            path.join(process.cwd(), 'plugins', '.paper-remapped'),
-            path.join(process.cwd(), 'plugins', '.paper-remapped', 'geyser.jar'),
-            path.join(process.cwd(), 'plugins', '.paper-remapped', 'ViaVersion.jar'),
-            path.join(process.cwd(), 'cache', 'paper-remapped')
+    createEngine() {
+        switch (this.config.type) {
+            case 'paper':
+            case 'purpur':
+            case 'spigot':
+                return new PaperEngine_1.PaperEngine();
+            case 'vanilla':
+                return new VanillaEngine_1.VanillaEngine();
+            case 'forge':
+                return new ForgeEngine_1.ForgeEngine();
+            case 'fabric':
+                return new FabricEngine_1.FabricEngine();
+            default:
+                throw new Error(`Unsupported server type: ${this.config.type}`);
+        }
+    }
+    async setupSymlinkMaster() {
+        if (!this.options.symlinkMaster)
+            return;
+        const masterDir = this.options.symlinkMaster;
+        await fs.ensureDir(masterDir);
+        const subDirs = ['worlds', 'plugins', 'addons', 'mods'];
+        for (const dir of subDirs) {
+            const masterSubDir = path.join(masterDir, dir);
+            await fs.ensureDir(masterSubDir);
+        }
+        this.logger.info(`Symlink master directory created at ${masterDir}`);
+    }
+    async restoreFromMaster() {
+        if (!this.options.ramdisk?.enabled)
+            return;
+        const ramdiskBase = '/dev/shm/minecraft';
+        const items = [
+            { name: 'world', target: this.config.folders.world },
+            { name: 'plugins', target: this.config.folders.plugins },
+            { name: 'addons', target: this.config.folders.addons }
         ];
-        cachePaths.forEach(cachePath => {
-            if (fs.existsSync(cachePath)) {
-                this.logger.info(`Cleaning corrupt cache: ${cachePath}`);
-                try {
-                    fs.rmSync(cachePath, { recursive: true, force: true });
-                    this.logger.debug(`Cache cleaned: ${cachePath}`);
+        for (const item of items) {
+            const ramdiskPath = path.join(ramdiskBase, item.name);
+            const masterPath = path.join(this.options.ramdisk.masterStorage, item.name);
+            if (fs.existsSync(ramdiskPath)) {
+                const ramdiskFiles = fs.readdirSync(ramdiskPath);
+                if (ramdiskFiles.length > 0) {
+                    this.logger.debug(`RAM disk ${item.name} already has data, skipping restore`);
+                    continue;
                 }
-                catch (err) {
-                    this.logger.warning(`Failed to clean cache: ${err.message}`);
+            }
+            if (fs.existsSync(masterPath)) {
+                const masterFiles = fs.readdirSync(masterPath);
+                if (masterFiles.length > 0) {
+                    this.logger.info(`Restoring ${item.name} from master storage...`);
+                    await fs.ensureDir(ramdiskPath);
+                    await fs.copy(masterPath, ramdiskPath, { overwrite: true });
+                    if (!fs.existsSync(item.target)) {
+                        await fs.symlink(ramdiskPath, item.target, 'dir');
+                    }
                 }
             }
-        });
+        }
+    }
+    async setupRamdisk() {
+        if (!this.options.ramdisk?.enabled)
+            return;
+        const ramdiskBase = '/dev/shm/minecraft';
+        await fs.ensureDir(ramdiskBase);
+        await this.restoreFromMaster();
+        const items = [
+            { name: 'world', enabled: this.options.ramdisk.world, target: this.config.folders.world },
+            { name: 'plugins', enabled: this.options.ramdisk.plugins, target: this.config.folders.plugins },
+            { name: 'addons', enabled: this.options.ramdisk.addons, target: this.config.folders.addons }
+        ];
+        for (const item of items) {
+            if (!item.enabled)
+                continue;
+            const ramdiskPath = path.join(ramdiskBase, item.name);
+            const masterPath = path.join(this.options.ramdisk.masterStorage, item.name);
+            await fs.ensureDir(masterPath);
+            if (fs.existsSync(item.target)) {
+                const stat = await fs.lstat(item.target);
+                if (stat.isSymbolicLink()) {
+                    continue;
+                }
+                await fs.copy(item.target, masterPath, { overwrite: true });
+                await fs.remove(item.target);
+            }
+            await fs.ensureDir(ramdiskPath);
+            await fs.symlink(ramdiskPath, item.target, 'dir');
+            this.ramdiskPaths.set(item.name, ramdiskPath);
+            this.logger.info(`RAM disk created for ${item.name} at ${ramdiskPath}`);
+        }
+        if (this.options.ramdisk.backupInterval > 0) {
+            const minutes = Math.floor(this.options.ramdisk.backupInterval / 60000);
+            this.ramdiskBackupCron = cron.schedule(`*/${minutes} * * * *`, () => {
+                this.backupRamdiskToMaster();
+            });
+            this.logger.info(`RAM disk backup scheduled every ${minutes} minutes`);
+        }
+    }
+    async backupRamdiskToMaster() {
+        if (!this.options.ramdisk?.enabled)
+            return;
+        for (const [name, ramdiskPath] of this.ramdiskPaths) {
+            const masterPath = path.join(this.options.ramdisk.masterStorage, name);
+            try {
+                await fs.copy(ramdiskPath, masterPath, { overwrite: true });
+                this.logger.debug(`RAM disk ${name} backed up to master storage`);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                this.logger.error(`Failed to backup ${name} RAM disk: ${errorMessage}`);
+            }
+        }
     }
     cleanOldLogs() {
         const logsDir = path.join(process.cwd(), 'logs');
@@ -211,151 +376,79 @@ class MinecraftServer extends events_1.EventEmitter {
             this.logger.info('Old logs cleaned');
         }
         catch (err) {
-            this.logger.warning(`Failed to clean logs: ${err.message}`);
-        }
-    }
-    generateOptimizedConfigs() {
-        const serverDir = process.cwd();
-        const paperGlobalYml = path.join(serverDir, 'paper-global.yml');
-        if (!fs.existsSync(paperGlobalYml)) {
-            const paperGlobalConfig = `# Paper Global Configuration
-# Optimized by MC-Headless
-
-chunk-loading:
-  autoconfig-send-distance: false
-  enable-frustum-priority: false
-  global-max-chunk-load-rate: 100
-  global-max-chunk-send-rate: 50
-
-entities:
-  despawn-ranges:
-    monster:
-      soft: 28
-      hard: 96
-    animal:
-      soft: 16
-      hard: 32
-  spawn-limits:
-    ambient: 5
-    axolotls: 5
-    creature: 10
-    monster: 15
-    water_ambient: 5
-    water_creature: 5
-
-misc:
-  max-entity-speed: 100
-  redstone-implementation: ALTERNATIVE_CURRENT
-
-player-auto-save: 6000
-player-auto-save-rate: 1200
-no-tick-view-distance: 12
-`;
-            fs.writeFileSync(paperGlobalYml, paperGlobalConfig);
-            this.logger.debug('Generated paper-global.yml');
-        }
-        const paperWorldDefaultsYml = path.join(serverDir, 'paper-world-defaults.yml');
-        if (!fs.existsSync(paperWorldDefaultsYml)) {
-            const paperWorldConfig = `# Paper World Defaults
-# Optimized by MC-Headless
-
-view-distance: 6
-no-tick-view-distance: 12
-
-despawn-ranges:
-  monster:
-    soft: 28
-    hard: 96
-  animal:
-    soft: 16
-    hard: 32
-  ambient:
-    soft: 16
-    hard: 32
-`;
-            fs.writeFileSync(paperWorldDefaultsYml, paperWorldConfig);
-            this.logger.debug('Generated paper-world-defaults.yml');
-        }
-        const spigotYml = path.join(serverDir, 'spigot.yml');
-        if (!fs.existsSync(spigotYml)) {
-            const spigotConfig = `# Spigot Configuration
-# Optimized by MC-Headless
-
-entity-activation-range:
-  animals: 16
-  monsters: 24
-  misc: 8
-  water: 8
-
-mob-spawn-range: 4
-
-world-settings:
-  default:
-    view-distance: 6
-    mob-spawn-range: 4
-    entity-activation-range:
-      animals: 16
-      monsters: 24
-      misc: 8
-      water: 8
-`;
-            fs.writeFileSync(spigotYml, spigotConfig);
-            this.logger.debug('Generated spigot.yml');
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            this.logger.warning(`Failed to clean logs: ${errorMessage}`);
         }
     }
-    detectCgroupLimits() {
+    async calculateWorldSize() {
         try {
-            if (fs.existsSync('/sys/fs/cgroup/memory/memory.limit_in_bytes')) {
-                const limit = fs.readFileSync('/sys/fs/cgroup/memory/memory.limit_in_bytes', 'utf8');
-                this.cgroupMemory = parseInt(limit) / 1024 / 1024;
-                this.logger.debug(`Cgroup memory limit: ${this.cgroupMemory} MB`);
-            }
-            if (fs.existsSync('/sys/fs/cgroup/cpu/cpu.cfs_quota_us') && fs.existsSync('/sys/fs/cgroup/cpu/cpu.cfs_period_us')) {
-                const quota = parseInt(fs.readFileSync('/sys/fs/cgroup/cpu/cpu.cfs_quota_us', 'utf8'));
-                const period = parseInt(fs.readFileSync('/sys/fs/cgroup/cpu/cpu.cfs_period_us', 'utf8'));
-                if (quota > 0 && period > 0) {
-                    this.cgroupCpu = quota / period;
-                    this.logger.debug(`Cgroup CPU limit: ${this.cgroupCpu} cores`);
+            const worldPath = path.join(process.cwd(), this.config.folders.world);
+            if (!await fs.pathExists(worldPath))
+                return 0;
+            const getSize = async (dir) => {
+                let total = 0;
+                const files = await fs.readdir(dir);
+                for (const file of files) {
+                    const filePath = path.join(dir, file);
+                    const stat = await fs.stat(filePath);
+                    if (stat.isDirectory()) {
+                        total += await getSize(filePath);
+                    }
+                    else {
+                        total += stat.size;
+                    }
                 }
-            }
-        }
-        catch (error) {
-            this.logger.debug('Not running in cgroup environment');
+                return total;
+            };
+            return await getSize(worldPath);
         }
-    }
-    createEngine() {
-        switch (this.config.type) {
-            case 'paper':
-            case 'purpur':
-            case 'spigot':
-                return new PaperEngine_1.PaperEngine();
-            case 'vanilla':
-                return new VanillaEngine_1.VanillaEngine();
-            case 'forge':
-                return new ForgeEngine_1.ForgeEngine();
-            case 'fabric':
-                return new FabricEngine_1.FabricEngine();
-            default:
-                throw new Error(`Unsupported server type: ${this.config.type}`);
+        catch {
+            return 0;
         }
     }
     buildJavaArgs() {
         if (this.options.customJavaArgs && this.options.customJavaArgs.length > 0) {
             return this.options.customJavaArgs;
         }
-        const memMax = this.parseMemory(this.config.memory.max);
+        let memMax = this.parseMemory(this.config.memory.max);
+        if (this.isPterodactyl && this.cgroupMemory > 0) {
+            const safeMem = Math.floor(this.cgroupMemory * 0.9);
+            memMax = Math.min(memMax, safeMem);
+            this.logger.info(`Adjusted memory to ${memMax}MB (90% of cgroup limit)`);
+        }
         const javaVersion = this.options.javaVersion || 'auto';
         const baseArgs = [
             `-Xms${this.config.memory.init}`,
-            `-Xmx${this.config.memory.max}`,
-            '-XX:+UseG1GC'
+            `-Xmx${memMax}M`,
+            '-XX:+UseG1GC',
+            '-XX:MaxGCPauseMillis=50',
+            '-Dio.netty.recycler.maxCapacity.default=0',
+            '-Dio.netty.leakDetectionLevel=disabled',
+            '-Dterminal.jline=false',
+            '-Dterminal.ansi=true'
         ];
+        if (this.options.networkOptimization?.preferIPv4) {
+            baseArgs.unshift('-Djava.net.preferIPv4Stack=true');
+        }
+        if (this.options.networkOptimization?.tcpFastOpen) {
+            baseArgs.unshift('-Djava.net.tcpFastOpen=true');
+        }
+        if (this.options.networkOptimization?.tcpNoDelay) {
+            baseArgs.unshift('-Djava.net.tcp.nodelay=true');
+        }
+        if (this.options.networkOptimization?.compressionThreshold) {
+            baseArgs.push(`-Dnetwork-compression-threshold=${this.options.networkOptimization.compressionThreshold}`);
+        }
+        if (this.options.networkOptimization?.velocity?.enabled) {
+            baseArgs.push('-Dvelocity.secret=' + this.options.networkOptimization.velocity.secret);
+        }
         let gcArgs = [];
         if (memMax >= 16384) {
             gcArgs = [
-                '-XX:+ParallelRefProcEnabled',
-                '-XX:MaxGCPauseMillis=100',
                 '-XX:+UnlockExperimentalVMOptions',
+                '-XX:+UseStringDeduplication',
+                '-XX:G1MixedGCLiveThresholdPercent=90',
+                '-XX:+ParallelRefProcEnabled',
                 '-XX:+DisableExplicitGC',
                 '-XX:+AlwaysPreTouch',
                 '-XX:G1NewSizePercent=40',
@@ -365,7 +458,6 @@ world-settings:
                 '-XX:G1HeapWastePercent=5',
                 '-XX:G1MixedGCCountTarget=4',
                 '-XX:InitiatingHeapOccupancyPercent=20',
-                '-XX:G1MixedGCLiveThresholdPercent=90',
                 '-XX:G1RSetUpdatingPauseTimePercent=5',
                 '-XX:SurvivorRatio=32',
                 '-XX:+PerfDisableSharedMem',
@@ -374,9 +466,10 @@ world-settings:
         }
         else if (memMax >= 8192) {
             gcArgs = [
-                '-XX:+ParallelRefProcEnabled',
-                '-XX:MaxGCPauseMillis=150',
                 '-XX:+UnlockExperimentalVMOptions',
+                '-XX:+UseStringDeduplication',
+                '-XX:G1MixedGCLiveThresholdPercent=90',
+                '-XX:+ParallelRefProcEnabled',
                 '-XX:+DisableExplicitGC',
                 '-XX:+AlwaysPreTouch',
                 '-XX:G1NewSizePercent=30',
@@ -386,7 +479,6 @@ world-settings:
                 '-XX:G1HeapWastePercent=5',
                 '-XX:G1MixedGCCountTarget=4',
                 '-XX:InitiatingHeapOccupancyPercent=15',
-                '-XX:G1MixedGCLiveThresholdPercent=90',
                 '-XX:G1RSetUpdatingPauseTimePercent=5',
                 '-XX:SurvivorRatio=32',
                 '-XX:+PerfDisableSharedMem',
@@ -394,23 +486,25 @@ world-settings:
             ];
         }
         else {
-            gcArgs = this.config.memory.useAikarsFlags ? [
-                '-XX:+ParallelRefProcEnabled',
-                '-XX:MaxGCPauseMillis=200',
+            gcArgs = [
                 '-XX:+UnlockExperimentalVMOptions',
+                '-XX:+UseStringDeduplication',
+                '-XX:G1MixedGCLiveThresholdPercent=90',
+                '-XX:+ParallelRefProcEnabled',
                 '-XX:+DisableExplicitGC',
                 '-XX:+AlwaysPreTouch',
                 '-XX:G1HeapWastePercent=5',
                 '-XX:G1MixedGCCountTarget=4',
                 '-XX:InitiatingHeapOccupancyPercent=15',
-                '-XX:G1MixedGCLiveThresholdPercent=90',
                 '-XX:G1RSetUpdatingPauseTimePercent=5',
                 '-XX:SurvivorRatio=32',
                 '-XX:+PerfDisableSharedMem',
-                '-XX:MaxTenuringThreshold=1',
-                '-Dusing.aikars.flags=https://mcflags.emc.gs',
-                '-Daikars.new.flags=true'
-            ] : [];
+                '-XX:MaxTenuringThreshold=1'
+            ];
+            if (this.config.memory.useAikarsFlags) {
+                gcArgs.push('-Dusing.aikars.flags=https://mcflags.emc.gs');
+                gcArgs.push('-Daikars.new.flags=true');
+            }
         }
         if (javaVersion === '21') {
             gcArgs.push('--enable-preview');
@@ -434,130 +528,34 @@ world-settings:
         }
         return env;
     }
-    async start() {
-        this.logger.info(`Starting ${this.config.type} server v${this.config.version}...`);
-        this.cleanPaperCache();
-        this.generateOptimizedConfigs();
-        if (this.options.cleanLogsInterval && this.options.cleanLogsInterval > 0) {
-            this.cleanLogsCron = cron.schedule('0 */3 * * *', () => this.cleanOldLogs());
-            this.logger.info('Log cleanup scheduled every 3 hours');
-        }
-        if (this.owners.size > 0) {
-            this.logger.info(`Owners configured: ${Array.from(this.owners).join(', ')}`);
-        }
-        this.javaInfo = await JavaChecker_1.JavaChecker.ensureJava(this.config.version, this.options.usePortableJava || false);
-        this.javaCommand = this.javaInfo.path;
-        this.logger.success(`Using Java ${this.javaInfo.version} (${this.javaInfo.type}) at ${this.javaInfo.path}`);
-        const systemInfo = SystemDetector_1.SystemDetector.getSystemInfo();
-        this.logger.debug('System info:', systemInfo);
-        const serverDir = process.cwd();
-        await FileUtils_1.FileUtils.ensureServerStructure(this.config);
-        this.worldSize = await this.calculateWorldSize();
-        if (this.worldSize > 10 * 1024 * 1024 * 1024) {
-            this.logger.warning(`Large world detected (${(this.worldSize / 1024 / 1024 / 1024).toFixed(2)} GB). Consider increasing memory allocation.`);
-        }
-        const jarPath = await this.engine.download(this.config, serverDir);
-        if (this.config.type === 'forge') {
-            await this.engine.prepare(this.config, serverDir, jarPath);
-        }
-        else {
-            await this.engine.prepare(this.config, serverDir);
-        }
-        if (this.config.platform === 'all') {
-            await FileUtils_1.FileUtils.ensureDir(this.config.folders.plugins);
-            await this.geyser.setup(this.config);
-        }
-        if (this.options.enableViaVersion !== false) {
-            this.logger.info('Enabling ViaVersion for client version compatibility...');
-            await FileUtils_1.FileUtils.ensureDir(this.config.folders.plugins);
-            await this.viaVersion.setup(this.config);
-            await this.viaVersion.configureViaVersion(this.config);
-            if (this.options.enableViaBackwards !== false) {
-                this.logger.info('ViaBackwards will be installed');
-            }
-            if (this.options.enableViaRewind !== false) {
-                this.logger.info('ViaRewind will be installed');
-            }
-        }
-        if (this.options.enableSkinRestorer !== false) {
-            this.logger.info('Enabling SkinRestorer for player skins...');
-            await FileUtils_1.FileUtils.ensureDir(this.config.folders.plugins);
-            await this.skinRestorer.setup(this.config);
-        }
-        const javaArgs = this.buildJavaArgs();
-        const serverJar = this.engine.getServerJar(jarPath);
-        const serverArgs = this.engine.getServerArgs();
-        const fullArgs = [
-            ...javaArgs,
-            '-jar',
-            serverJar,
-            ...serverArgs
-        ];
-        if (this.options.networkOptimization?.tcpFastOpen) {
-            fullArgs.unshift('-Djava.net.preferIPv4Stack=true');
-        }
-        if (this.options.networkOptimization?.bungeeMode) {
-            fullArgs.unshift('-Dnet.kyori.adventure.text.serializer.legacy.AMPMSupport=true');
-        }
-        const env = this.buildEnvironment();
-        this.logger.info(`Launching: ${this.javaCommand} ${fullArgs.join(' ')}`);
-        this.process = (0, child_process_1.spawn)(this.javaCommand, fullArgs, {
-            cwd: serverDir,
-            env: env,
-            stdio: ['pipe', 'pipe', 'pipe']
-        });
-        this.serverInfo.pid = this.process.pid;
-        this.serverInfo.status = 'starting';
-        this.startTime = new Date();
-        if (this.options.silentMode) {
-            this.process.stdout.pipe(process.stdout);
-            this.process.stderr.pipe(process.stderr);
-        }
-        else {
-            this.setupLogHandlers();
-        }
-        this.process.on('exit', (code) => {
-            this.serverInfo.status = 'stopped';
-            this.logger.warning(`Server stopped with code ${code}`);
-            if (this.config.autoRestart && code !== 0) {
-                this.logger.info('Auto-restarting...');
-                this.start();
-            }
-            this.emit('stop', { code });
-        });
-        if (this.options.statsInterval && this.options.statsInterval > 0) {
-            this.statsInterval = setInterval(() => this.updateStats(), this.options.statsInterval);
-        }
-        this.monitorResources();
-        if (this.config.backup.enabled) {
-            this.setupBackups();
-        }
-        setTimeout(() => {
-            if (this.serverInfo.status === 'starting') {
-                this.serverInfo.status = 'running';
-                this.logger.success('Server started successfully!');
-                if (this.options.enableViaVersion !== false) {
-                    this.logger.info('ViaVersion is active - players from older versions can connect');
-                }
-                if (this.options.enableSkinRestorer !== false) {
-                    this.logger.info('SkinRestorer is active - player skins will be restored');
-                }
-                if (this.worldSize > 0) {
-                    this.logger.info(`World size: ${(this.worldSize / 1024 / 1024 / 1024).toFixed(2)} GB`);
-                }
-                if (this.owners.size > 0) {
-                    this.logger.info(`Owner commands enabled with prefix: ${this.ownerCommandPrefix}`);
-                }
-                this.emit('ready', this.serverInfo);
-                this.startMemoryMonitor();
-            }
-        }, 10000);
-        return this.serverInfo;
-    }
     setupLogHandlers() {
         this.process.stdout.on('data', (data) => {
             const output = data.toString();
             process.stdout.write(output);
+            if (!this.serverReady) {
+                if (output.includes('Done') || output.includes('For help, type "help"')) {
+                    this.serverReady = true;
+                    this.serverInfo.status = 'running';
+                    this.logger.success('Server started successfully!');
+                    if (this.options.enableViaVersion !== false) {
+                        this.logger.info('ViaVersion is active - players from older versions can connect');
+                    }
+                    if (this.options.enableSkinRestorer !== false) {
+                        this.logger.info('SkinRestorer is active - player skins will be restored');
+                    }
+                    if (this.worldSize > 0) {
+                        this.logger.info(`World size: ${(this.worldSize / 1024 / 1024 / 1024).toFixed(2)} GB`);
+                    }
+                    if (this.owners.size > 0) {
+                        this.logger.info(`Owner commands enabled with prefix: ${this.ownerCommandPrefix}`);
+                    }
+                    if (this.options.ramdisk?.enabled) {
+                        this.logger.info('RAM disk active - worlds/plugins running in memory');
+                    }
+                    this.emit('ready', this.serverInfo);
+                    this.startMemoryMonitor();
+                }
+            }
             if (output.includes('joined the game')) {
                 const match = output.match(/(\w+) joined the game/);
                 if (match) {
@@ -856,7 +854,8 @@ world-settings:
             this.emit('resource', this.serverInfo);
         }
         catch (error) {
-            this.logger.error('Stats update error:', error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Stats update error: ${errorMessage}`);
         }
     }
     startMemoryMonitor() {
@@ -882,24 +881,26 @@ world-settings:
                             this.memoryUsageHistory[0] * 1.2;
                     if (isIncreasing) {
                         this.logger.warning('Memory leak detected!');
-                        switch (action) {
-                            case 'restart':
-                                this.logger.info('Restarting server due to memory leak...');
-                                await this.gracefulRestart();
-                                break;
-                            case 'stop':
-                                this.logger.info('Stopping server due to memory leak...');
-                                await this.stop();
-                                break;
-                            case 'warn':
-                            default:
-                                this.logger.warning('Please restart server to free memory');
+                        if (action === 'restart' && this.players.size === 0) {
+                            this.logger.info('No players online, restarting server due to memory leak...');
+                            await this.gracefulRestart();
+                        }
+                        else if (action === 'stop' && this.players.size === 0) {
+                            this.logger.info('No players online, stopping server due to memory leak...');
+                            await this.stop();
+                        }
+                        else if (action === 'warn') {
+                            this.logger.warning('Please restart server to free memory');
+                        }
+                        else {
+                            this.logger.warning('Cannot restart: players online');
                         }
                     }
                 }
             }
             catch (error) {
-                this.logger.error('Memory monitor error:', error);
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                this.logger.error(`Memory monitor error: ${errorMessage}`);
             }
         }, interval);
     }
@@ -918,6 +919,114 @@ world-settings:
         await this.stop();
         await this.start();
     }
+    async start() {
+        this.logger.info(`Starting ${this.config.type} server v${this.config.version}...`);
+        await this.setupSymlinkMaster();
+        await this.setupRamdisk();
+        if (this.options.cleanLogsInterval && this.options.cleanLogsInterval > 0) {
+            this.cleanLogsCron = cron.schedule('0 */3 * * *', () => this.cleanOldLogs());
+            this.logger.info('Log cleanup scheduled every 3 hours');
+        }
+        if (this.owners.size > 0) {
+            this.logger.info(`Owners configured: ${Array.from(this.owners).join(', ')}`);
+        }
+        this.javaInfo = await JavaChecker_1.JavaChecker.ensureJava(this.config.version, this.options.usePortableJava || false);
+        this.javaCommand = this.javaInfo.path;
+        this.logger.success(`Using Java ${this.javaInfo.version} (${this.javaInfo.type}) at ${this.javaInfo.path}`);
+        const systemInfo = SystemDetector_1.SystemDetector.getSystemInfo();
+        this.logger.debug('System info:', systemInfo);
+        const serverDir = process.cwd();
+        await FileUtils_1.FileUtils.ensureServerStructure(this.config);
+        this.worldSize = await this.calculateWorldSize();
+        if (this.worldSize > 10 * 1024 * 1024 * 1024) {
+            this.logger.warning(`Large world detected (${(this.worldSize / 1024 / 1024 / 1024).toFixed(2)} GB). Consider increasing memory allocation.`);
+        }
+        const jarPath = await this.engine.download(this.config, serverDir);
+        if (this.config.type === 'forge') {
+            await this.engine.prepare(this.config, serverDir, jarPath);
+        }
+        else {
+            await this.engine.prepare(this.config, serverDir);
+        }
+        if (this.config.platform === 'all') {
+            await FileUtils_1.FileUtils.ensureDir(this.config.folders.plugins);
+            await this.geyser.setup(this.config, this.isPterodactyl);
+        }
+        const pluginsToInstall = [
+            { name: 'ProtocolLib', enabled: this.options.enableProtocolLib, url: 'https://github.com/dmulloy2/ProtocolLib/releases/latest/download/ProtocolLib.jar' },
+            { name: 'TCPShield', enabled: this.options.enableTCPShield, url: 'https://tcpshield.com/api/download/plugin' },
+            { name: 'SpigotOptimizers', enabled: this.options.enableSpigotOptimizers, url: 'https://github.com/SpigotOptimizers/SpigotOptimizers/releases/latest/download/SpigotOptimizers.jar' },
+            { name: 'Spark', enabled: this.options.enableSpark, url: 'https://spark.lucko.me/download' },
+            { name: 'ViewDistanceTweaks', enabled: this.options.enableViewDistanceTweaks, url: 'https://github.com/ViewDistanceTweaks/ViewDistanceTweaks/releases/latest/download/ViewDistanceTweaks.jar' },
+            { name: 'FarmControl', enabled: this.options.enableFarmControl, url: 'https://github.com/FarmControl/FarmControl/releases/latest/download/FarmControl.jar' },
+            { name: 'EntityDetection', enabled: this.options.enableEntityDetection, url: 'https://github.com/EntityDetection/EntityDetection/releases/latest/download/EntityDetection.jar' }
+        ];
+        for (const plugin of pluginsToInstall) {
+            if (plugin.enabled) {
+                await this.pluginManager.installPlugin(plugin.name, plugin.url, this.config.folders.plugins);
+            }
+        }
+        if (this.options.enableViaVersion !== false) {
+            this.logger.info('Enabling ViaVersion for client version compatibility...');
+            await FileUtils_1.FileUtils.ensureDir(this.config.folders.plugins);
+            await this.viaVersion.setup(this.config);
+            await this.viaVersion.configureViaVersion(this.config);
+            if (this.options.enableViaBackwards !== false) {
+                this.logger.info('ViaBackwards will be installed');
+            }
+            if (this.options.enableViaRewind !== false) {
+                this.logger.info('ViaRewind will be installed');
+            }
+        }
+        if (this.options.enableSkinRestorer !== false) {
+            this.logger.info('Enabling SkinRestorer for player skins...');
+            await FileUtils_1.FileUtils.ensureDir(this.config.folders.plugins);
+            await this.skinRestorer.setup(this.config);
+        }
+        const javaArgs = this.buildJavaArgs();
+        const serverJar = this.engine.getServerJar(jarPath);
+        const serverArgs = this.engine.getServerArgs();
+        const fullArgs = [
+            ...javaArgs,
+            '-jar',
+            serverJar,
+            ...serverArgs
+        ];
+        const env = this.buildEnvironment();
+        this.logger.info(`Launching: ${this.javaCommand} ${fullArgs.join(' ')}`);
+        this.process = (0, child_process_1.spawn)(this.javaCommand, fullArgs, {
+            cwd: serverDir,
+            env: env,
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        this.serverInfo.pid = this.process.pid;
+        this.serverInfo.status = 'starting';
+        this.startTime = new Date();
+        if (this.options.silentMode) {
+            this.process.stdout.pipe(process.stdout);
+            this.process.stderr.pipe(process.stderr);
+        }
+        else {
+            this.setupLogHandlers();
+        }
+        this.process.on('exit', (code) => {
+            this.serverInfo.status = 'stopped';
+            this.logger.warning(`Server stopped with code ${code}`);
+            if (this.config.autoRestart && code !== 0) {
+                this.logger.info('Auto-restarting...');
+                this.start();
+            }
+            this.emit('stop', { code });
+        });
+        if (this.options.statsInterval && this.options.statsInterval > 0) {
+            this.statsInterval = setInterval(() => this.updateStats(), this.options.statsInterval);
+        }
+        this.monitorResources();
+        if (this.config.backup.enabled) {
+            this.setupBackups();
+        }
+        return this.serverInfo;
+    }
     async stop() {
         if (!this.process) {
             this.logger.warning('Server not running');
@@ -938,6 +1047,9 @@ world-settings:
         if (this.cleanLogsCron) {
             this.cleanLogsCron.stop();
         }
+        if (this.ramdiskBackupCron) {
+            this.ramdiskBackupCron.stop();
+        }
         if (this.memoryMonitorInterval) {
             clearInterval(this.memoryMonitorInterval);
         }
@@ -947,7 +1059,9 @@ world-settings:
         if (this.config.platform === 'all') {
             this.geyser.stop();
         }
-        this.cleanPaperCache();
+        if (this.options.ramdisk?.enabled) {
+            await this.backupRamdiskToMaster();
+        }
         this.logger.success('Server stopped');
     }
     sendCommand(command) {
@@ -1043,32 +1157,6 @@ world-settings:
         }
         return value;
     }
-    async calculateWorldSize() {
-        try {
-            const worldPath = path.join(process.cwd(), this.config.folders.world);
-            if (!await fs.pathExists(worldPath))
-                return 0;
-            const getSize = async (dir) => {
-                let total = 0;
-                const files = await fs.readdir(dir);
-                for (const file of files) {
-                    const filePath = path.join(dir, file);
-                    const stat = await fs.stat(filePath);
-                    if (stat.isDirectory()) {
-                        total += await getSize(filePath);
-                    }
-                    else {
-                        total += stat.size;
-                    }
-                }
-                return total;
-            };
-            return await getSize(worldPath);
-        }
-        catch {
-            return 0;
-        }
-    }
 }
 exports.MinecraftServer = MinecraftServer;
 //# sourceMappingURL=MinecraftServer.js.map