@dimzxzzx07/mc-headless 2.2.2 → 2.2.3

package/src/core/MinecraftServer.ts

@@ -3,7 +3,16 @@ import { spawn } from 'child_process';
 import * as cron from 'node-cron';
 import * as path from 'path';
 import * as fs from 'fs-extra';
-import { MinecraftConfig, ServerInfo, Player } from '../types';
+import { 
+    MinecraftConfig, 
+    ServerInfo, 
+    Player, 
+    MinecraftServerOptions,
+    MemoryMonitorConfig,
+    NetworkOptimizationConfig,
+    OwnerConfig,
+    RamdiskConfig
+} from '../types';
 import { ConfigHandler } from './ConfigHandler';
 import { JavaChecker, JavaInfo } from './JavaChecker';
 import { FileUtils } from '../utils/FileUtils';
@@ -17,38 +26,7 @@ import { ServerEngine } from '../engines/ServerEngine';
 import { GeyserBridge } from '../platforms/GeyserBridge';
 import { ViaVersionManager } from '../platforms/ViaVersion';
 import { SkinRestorerManager } from '../platforms/SkinRestorer';
-
-export interface MinecraftServerOptions extends Partial<MinecraftConfig> {
-    enableViaVersion?: boolean;
-    enableViaBackwards?: boolean;
-    enableViaRewind?: boolean;
-    enableSkinRestorer?: boolean;
-    enableProtocolSupport?: boolean;
-    customJavaArgs?: string[];
-    javaVersion?: '17' | '21' | 'auto';
-    usePortableJava?: boolean;
-    memoryMonitor?: {
-        enabled: boolean;
-        threshold: number;
-        interval: number;
-        action: 'restart' | 'warn' | 'stop';
-    };
-    autoInstallJava?: boolean;
-    networkOptimization?: {
-        tcpFastOpen: boolean;
-        bungeeMode: boolean;
-        proxyProtocol: boolean;
-    };
-    owners?: string[];
-    ownerCommands?: {
-        prefix: string;
-        enabled: boolean;
-    };
-    silentMode?: boolean;
-    statsInterval?: number;
-    cleanLogsInterval?: number;
-    optimizeForPterodactyl?: boolean;
-}
+import { PluginManager } from '../platforms/PluginManager';
 
 export class MinecraftServer extends EventEmitter {
     private config: MinecraftConfig;
@@ -58,11 +36,13 @@ export class MinecraftServer extends EventEmitter {
     private geyser: GeyserBridge;
     private viaVersion: ViaVersionManager;
     private skinRestorer: SkinRestorerManager;
+    private pluginManager: PluginManager;
     private process: any = null;
     private serverInfo: ServerInfo;
     private players: Map<string, Player> = new Map();
     private backupCron: cron.ScheduledTask | null = null;
     private cleanLogsCron: cron.ScheduledTask | null = null;
+    private ramdiskBackupCron: cron.ScheduledTask | null = null;
     private startTime: Date | null = null;
     private memoryMonitorInterval: NodeJS.Timeout | null = null;
     private statsInterval: NodeJS.Timeout | null = null;
@@ -79,6 +59,8 @@ export class MinecraftServer extends EventEmitter {
     private cgroupMemory: number = 0;
     private cgroupCpu: number = 0;
     private isPterodactyl: boolean = false;
+    private ramdiskPaths: Map<string, string> = new Map();
+    private serverReady: boolean = false;
 
     constructor(userConfig: MinecraftServerOptions = {}) {
         super();
@@ -87,35 +69,73 @@ export class MinecraftServer extends EventEmitter {
 
         this.detectEnvironment();
 
+        const defaultMemoryMonitor: MemoryMonitorConfig = {
+            enabled: true,
+            threshold: 90,
+            interval: 30000,
+            action: 'warn',
+            maxMemoryLeakRestarts: 3,
+            gcOnWarning: true
+        };
+
+        const defaultNetworkOptimization: NetworkOptimizationConfig = {
+            tcpFastOpen: true,
+            tcpNoDelay: true,
+            preferIPv4: true,
+            compressionThreshold: 64,
+            bungeeMode: false,
+            proxyProtocol: false,
+            velocity: {
+                enabled: false,
+                secret: '',
+                forwardingMode: 'modern'
+            }
+        };
+
+        const defaultOwnerCommands: OwnerConfig = {
+            prefix: '!',
+            enabled: true,
+            usernames: [],
+            permissions: []
+        };
+
+        const defaultRamdisk: RamdiskConfig = {
+            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: string) => this.owners.add(owner.toLowerCase()));
         }
 
         if (this.options.ownerCommands?.prefix) {
@@ -133,6 +153,7 @@ export class MinecraftServer extends EventEmitter {
         this.geyser = new GeyserBridge();
         this.viaVersion = new ViaVersionManager();
         this.skinRestorer = new SkinRestorerManager();
+        this.pluginManager = new PluginManager();
 
         this.serverInfo = {
             pid: 0,
@@ -151,19 +172,53 @@ export class MinecraftServer extends EventEmitter {
         };
 
         this.detectCgroupLimits();
-        this.cleanPaperCache();
     }
 
     private detectEnvironment(): void {
         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');
+            }
+        }
+    }
+
+    private detectCgroupLimits(): void {
+        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');
         }
     }
 
@@ -171,13 +226,14 @@ export class MinecraftServer extends EventEmitter {
         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;
@@ -187,29 +243,137 @@ export class MinecraftServer extends EventEmitter {
 
         this.config.world.viewDistance = 6;
         this.config.world.simulationDistance = 4;
-        
-        this.logger.info('Applied Pterodactyl optimizations');
     }
 
-    private cleanPaperCache(): void {
-        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')
+    private createEngine(): ServerEngine {
+        switch (this.config.type) {
+            case 'paper':
+            case 'purpur':
+            case 'spigot':
+                return new PaperEngine();
+            case 'vanilla':
+                return new VanillaEngine();
+            case 'forge':
+                return new ForgeEngine();
+            case 'fabric':
+                return new FabricEngine();
+            default:
+                throw new Error(`Unsupported server type: ${this.config.type}`);
+        }
+    }
+
+    private async setupSymlinkMaster(): Promise<void> {
+        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}`);
+    }
+
+    private async restoreFromMaster(): Promise<void> {
+        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}`);
-                } catch (err: any) {
-                    this.logger.warning(`Failed to clean cache: ${err.message}`);
+        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;
                 }
             }
-        });
+
+            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');
+                    }
+                }
+            }
+        }
+    }
+
+    private async setupRamdisk(): Promise<void> {
+        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`);
+        }
+    }
+
+    private async backupRamdiskToMaster(): Promise<void> {
+        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}`);
+            }
+        }
     }
 
     private cleanOldLogs(): void {
@@ -230,139 +394,38 @@ export class MinecraftServer extends EventEmitter {
                 }
             });
             this.logger.info('Old logs cleaned');
-        } catch (err: any) {
-            this.logger.warning(`Failed to clean logs: ${err.message}`);
+        } catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            this.logger.warning(`Failed to clean logs: ${errorMessage}`);
         }
     }
 
-    private generateOptimizedConfigs(): void {
-        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');
-        }
-    }
-
-    private detectCgroupLimits(): void {
+    private async calculateWorldSize(): Promise<number> {
         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`);
-            }
+            const worldPath = path.join(process.cwd(), this.config.folders.world);
+            if (!await fs.pathExists(worldPath)) return 0;
 
-            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 getSize = async (dir: string): Promise<number> => {
+                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;
+            };
 
-    private createEngine(): ServerEngine {
-        switch (this.config.type) {
-            case 'paper':
-            case 'purpur':
-            case 'spigot':
-                return new PaperEngine();
-            case 'vanilla':
-                return new VanillaEngine();
-            case 'forge':
-                return new ForgeEngine();
-            case 'fabric':
-                return new FabricEngine();
-            default:
-                throw new Error(`Unsupported server type: ${this.config.type}`);
+            return await getSize(worldPath);
+        } catch {
+            return 0;
         }
     }
 
@@ -371,21 +434,54 @@ world-settings:
             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',
+            '-XX:+UseStringDeduplication',
+            '-XX:G1MixedGCLiveThresholdPercent=90',
+            '-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: string[] = [];
 
         if (memMax >= 16384) {
             gcArgs = [
                 '-XX:+ParallelRefProcEnabled',
-                '-XX:MaxGCPauseMillis=100',
                 '-XX:+UnlockExperimentalVMOptions',
                 '-XX:+DisableExplicitGC',
                 '-XX:+AlwaysPreTouch',
@@ -396,7 +492,6 @@ world-settings:
                 '-XX:G1HeapWastePercent=5',
                 '-XX:G1MixedGCCountTarget=4',
                 '-XX:InitiatingHeapOccupancyPercent=20',
-                '-XX:G1MixedGCLiveThresholdPercent=90',
                 '-XX:G1RSetUpdatingPauseTimePercent=5',
                 '-XX:SurvivorRatio=32',
                 '-XX:+PerfDisableSharedMem',
@@ -405,7 +500,6 @@ world-settings:
         } else if (memMax >= 8192) {
             gcArgs = [
                 '-XX:+ParallelRefProcEnabled',
-                '-XX:MaxGCPauseMillis=150',
                 '-XX:+UnlockExperimentalVMOptions',
                 '-XX:+DisableExplicitGC',
                 '-XX:+AlwaysPreTouch',
@@ -416,30 +510,30 @@ world-settings:
                 '-XX:G1HeapWastePercent=5',
                 '-XX:G1MixedGCCountTarget=4',
                 '-XX:InitiatingHeapOccupancyPercent=15',
-                '-XX:G1MixedGCLiveThresholdPercent=90',
                 '-XX:G1RSetUpdatingPauseTimePercent=5',
                 '-XX:SurvivorRatio=32',
                 '-XX:+PerfDisableSharedMem',
                 '-XX:MaxTenuringThreshold=1'
             ];
         } else {
-            gcArgs = this.config.memory.useAikarsFlags ? [
+            gcArgs = [
                 '-XX:+ParallelRefProcEnabled',
-                '-XX:MaxGCPauseMillis=200',
                 '-XX:+UnlockExperimentalVMOptions',
                 '-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') {
@@ -472,167 +566,41 @@ world-settings:
         return env;
     }
 
-    public async start(): Promise<ServerInfo> {
-        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.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.getSystemInfo();
-        this.logger.debug('System info:', systemInfo);
-
-        const serverDir = process.cwd();
-        await 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.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.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.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 = 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: number) => {
-            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();
+    private setupLogHandlers(): void {
+        this.process.stdout.on('data', (data: Buffer) => {
+            const output = data.toString();
+            process.stdout.write(output);
 
-        if (this.config.backup.enabled) {
-            this.setupBackups();
-        }
+            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`);
+                    }
 
-        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}`);
+                    }
 
-                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();
                 }
-                
-                this.emit('ready', this.serverInfo);
-                this.startMemoryMonitor();
             }
-        }, 10000);
-
-        return this.serverInfo;
-    }
-
-    private setupLogHandlers(): void {
-        this.process.stdout.on('data', (data: Buffer) => {
-            const output = data.toString();
-            process.stdout.write(output);
 
             if (output.includes('joined the game')) {
                 const match = output.match(/(\w+) joined the game/);
@@ -969,7 +937,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}`);
         }
     }
 
@@ -1003,24 +972,23 @@ world-settings:
                     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);
     }
@@ -1050,6 +1018,145 @@ world-settings:
         await this.start();
     }
 
+    public async start(): Promise<ServerInfo> {
+        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.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.getSystemInfo();
+        this.logger.debug('System info:', systemInfo);
+
+        const serverDir = process.cwd();
+        await 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.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.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.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 = 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: number) => {
+            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;
+    }
+
     public async stop(): Promise<void> {
         if (!this.process) {
             this.logger.warning('Server not running');
@@ -1077,6 +1184,10 @@ world-settings:
             this.cleanLogsCron.stop();
         }
 
+        if (this.ramdiskBackupCron) {
+            this.ramdiskBackupCron.stop();
+        }
+
         if (this.memoryMonitorInterval) {
             clearInterval(this.memoryMonitorInterval);
         }
@@ -1089,7 +1200,10 @@ world-settings:
             this.geyser.stop();
         }
 
-        this.cleanPaperCache();
+        if (this.options.ramdisk?.enabled) {
+            await this.backupRamdiskToMaster();
+        }
+
         this.logger.success('Server stopped');
     }
 
@@ -1200,33 +1314,4 @@ world-settings:
         }
         return value;
     }
-
-    private async calculateWorldSize(): Promise<number> {
-        try {
-            const worldPath = path.join(process.cwd(), this.config.folders.world);
-            if (!await fs.pathExists(worldPath)) return 0;
-
-            const getSize = async (dir: string): Promise<number> => {
-                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;
-        }
-    }
 }