@dimzxzzx07/mc-headless 2.2.1 → 2.2.3

package/src/core/MinecraftServer.ts

@@ -1,7 +1,18 @@
 import { EventEmitter } from 'events';
 import { spawn } from 'child_process';
 import * as cron from 'node-cron';
-import { MinecraftConfig, ServerInfo, Player } from '../types';
+import * as path from 'path';
+import * as fs from 'fs-extra';
+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';
@@ -15,38 +26,7 @@ import { ServerEngine } from '../engines/ServerEngine';
 import { GeyserBridge } from '../platforms/GeyserBridge';
 import { ViaVersionManager } from '../platforms/ViaVersion';
 import { SkinRestorerManager } from '../platforms/SkinRestorer';
-import * as path from 'path';
-import * as fs from 'fs-extra';
-
-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;
-}
+import { PluginManager } from '../platforms/PluginManager';
 
 export class MinecraftServer extends EventEmitter {
     private config: MinecraftConfig;
@@ -56,10 +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;
@@ -75,39 +58,84 @@ export class MinecraftServer extends EventEmitter {
     private cpuUsage: number = 0;
     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();
         this.logger = Logger.getInstance();
         this.logger.banner();
 
+        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: true,
-            memoryMonitor: {
-                enabled: true,
-                threshold: 90,
-                interval: 30000,
-                action: 'warn'
-            },
+            usePortableJava: !this.isPterodactyl,
+            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) {
@@ -117,10 +145,15 @@ export class MinecraftServer extends EventEmitter {
         const handler = new ConfigHandler(userConfig);
         this.config = handler.getConfig();
 
+        if (this.isPterodactyl && this.options.optimizeForPterodactyl) {
+            this.optimizeForPterodactylPanel();
+        }
+
         this.engine = this.createEngine();
         this.geyser = new GeyserBridge();
         this.viaVersion = new ViaVersionManager();
         this.skinRestorer = new SkinRestorerManager();
+        this.pluginManager = new PluginManager();
 
         this.serverInfo = {
             pid: 0,
@@ -141,6 +174,33 @@ export class MinecraftServer extends EventEmitter {
         this.detectCgroupLimits();
     }
 
+    private detectEnvironment(): void {
+        this.isPterodactyl = !!(
+            process.env.PTERODACTYL ||
+            process.env.SERVER_PORT ||
+            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')) {
@@ -162,6 +222,29 @@ export class MinecraftServer extends EventEmitter {
         }
     }
 
+    private optimizeForPterodactylPanel(): void {
+        const pterodactylPort = process.env.SERVER_PORT;
+        if (pterodactylPort) {
+            this.config.network.port = parseInt(pterodactylPort);
+        }
+
+        const pterodactylMemory = process.env.SERVER_MEMORY_MAX;
+        if (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) {
+            this.config.memory.init = pterodactylInitMemory;
+        }
+
+        this.config.world.viewDistance = 6;
+        this.config.world.simulationDistance = 4;
+    }
+
     private createEngine(): ServerEngine {
         switch (this.config.type) {
             case 'paper':
@@ -179,21 +262,226 @@ export class MinecraftServer extends EventEmitter {
         }
     }
 
+    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 }
+        ];
+
+        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 {
+        const logsDir = path.join(process.cwd(), 'logs');
+        if (!fs.existsSync(logsDir)) return;
+
+        try {
+            const files = fs.readdirSync(logsDir);
+            const now = Date.now();
+            const threeHours = 3 * 60 * 60 * 1000;
+
+            files.forEach(file => {
+                const filePath = path.join(logsDir, file);
+                const stats = fs.statSync(filePath);
+                if (now - stats.mtimeMs > threeHours) {
+                    fs.unlinkSync(filePath);
+                    this.logger.debug(`Cleaned old log: ${file}`);
+                }
+            });
+            this.logger.info('Old logs cleaned');
+        } catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            this.logger.warning(`Failed to clean logs: ${errorMessage}`);
+        }
+    }
+
+    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;
+        }
+    }
+
     private buildJavaArgs(): string[] {
         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${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:+UseG1GC',
                 '-XX:+ParallelRefProcEnabled',
-                '-XX:MaxGCPauseMillis=100',
                 '-XX:+UnlockExperimentalVMOptions',
                 '-XX:+DisableExplicitGC',
                 '-XX:+AlwaysPreTouch',
@@ -204,7 +492,6 @@ export class MinecraftServer extends EventEmitter {
                 '-XX:G1HeapWastePercent=5',
                 '-XX:G1MixedGCCountTarget=4',
                 '-XX:InitiatingHeapOccupancyPercent=20',
-                '-XX:G1MixedGCLiveThresholdPercent=90',
                 '-XX:G1RSetUpdatingPauseTimePercent=5',
                 '-XX:SurvivorRatio=32',
                 '-XX:+PerfDisableSharedMem',
@@ -212,9 +499,7 @@ export class MinecraftServer extends EventEmitter {
             ];
         } else if (memMax >= 8192) {
             gcArgs = [
-                '-XX:+UseG1GC',
                 '-XX:+ParallelRefProcEnabled',
-                '-XX:MaxGCPauseMillis=150',
                 '-XX:+UnlockExperimentalVMOptions',
                 '-XX:+DisableExplicitGC',
                 '-XX:+AlwaysPreTouch',
@@ -225,42 +510,36 @@ export class MinecraftServer extends EventEmitter {
                 '-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 ? [
-                '-XX:+UseG1GC',
+            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') {
             gcArgs.push('--enable-preview');
         }
 
-        const baseArgs = [
-            `-Xms${this.config.memory.init}`,
-            `-Xmx${this.config.memory.max}`
-        ];
-
         return [...baseArgs, ...gcArgs];
     }
 
@@ -268,7 +547,6 @@ export class MinecraftServer extends EventEmitter {
         const env: NodeJS.ProcessEnv = { ...process.env };
         
         env.MALLOC_ARENA_MAX = '2';
-        
         env._JAVA_OPTIONS = `-Xmx${this.config.memory.max}`;
         
         if (this.javaInfo && this.javaInfo.type === 'portable') {
@@ -288,6 +566,81 @@ export class MinecraftServer extends EventEmitter {
         return env;
     }
 
+    private setupLogHandlers(): void {
+        this.process.stdout.on('data', (data: Buffer) => {
+            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) {
+                    this.playerCount++;
+                    this.handlePlayerJoin(match[1]);
+                    
+                    if (this.owners.has(match[1].toLowerCase())) {
+                        this.sendCommand(`tellraw ${match[1]} {"text":"Welcome Owner! Use ${this.ownerCommandPrefix}help for commands","color":"gold"}`);
+                    }
+                }
+            }
+
+            if (output.includes('left the game')) {
+                const match = output.match(/(\w+) left the game/);
+                if (match) {
+                    this.playerCount--;
+                    this.handlePlayerLeave(match[1]);
+                }
+            }
+
+            if (output.includes('<') && output.includes('>')) {
+                const chatMatch = output.match(/<(\w+)>\s+(.+)/);
+                if (chatMatch) {
+                    const player = chatMatch[1];
+                    const message = chatMatch[2];
+                    
+                    if (message.startsWith(this.ownerCommandPrefix)) {
+                        const command = message.substring(this.ownerCommandPrefix.length);
+                        this.processOwnerCommand(player, command);
+                    }
+                }
+            }
+        });
+
+        this.process.stderr.on('data', (data: Buffer) => {
+            process.stderr.write(data.toString());
+        });
+    }
+
     private processOwnerCommand(player: string, command: string): void {
         if (!this.options.ownerCommands?.enabled) return;
         if (!this.owners.has(player.toLowerCase())) return;
@@ -584,13 +937,98 @@ export class MinecraftServer extends EventEmitter {
             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}`);
         }
     }
 
+    private startMemoryMonitor(): void {
+        if (!this.options.memoryMonitor?.enabled) return;
+
+        const threshold = this.options.memoryMonitor.threshold || 90;
+        const interval = this.options.memoryMonitor.interval || 30000;
+        const action = this.options.memoryMonitor.action || 'warn';
+
+        this.memoryMonitorInterval = setInterval(async () => {
+            if (this.serverInfo.status !== 'running' || !this.process) return;
+
+            try {
+                await this.updateStats();
+                
+                const memPercent = (this.serverInfo.memory.used / this.serverInfo.memory.max) * 100;
+                
+                this.memoryUsageHistory.push(memPercent);
+                if (this.memoryUsageHistory.length > 10) {
+                    this.memoryUsageHistory.shift();
+                }
+
+                if (memPercent > threshold) {
+                    this.logger.warning(`High memory usage: ${memPercent.toFixed(1)}%`);
+                    
+                    const isIncreasing = this.memoryUsageHistory.length > 5 && 
+                                        this.memoryUsageHistory[this.memoryUsageHistory.length - 1] > 
+                                        this.memoryUsageHistory[0] * 1.2;
+                    
+                    if (isIncreasing) {
+                        this.logger.warning('Memory leak detected!');
+                        
+                        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) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                this.logger.error(`Memory monitor error: ${errorMessage}`);
+            }
+        }, interval);
+    }
+
+    private async gracefulRestart(): Promise<void> {
+        this.logger.info('Initiating graceful restart...');
+        
+        this.sendCommand('say Server restarting in 30 seconds');
+        this.sendCommand('save-all');
+        
+        await new Promise(resolve => setTimeout(resolve, 10000));
+        
+        this.sendCommand('say Server restarting in 20 seconds');
+        
+        await new Promise(resolve => setTimeout(resolve, 10000));
+        
+        this.sendCommand('say Server restarting in 10 seconds');
+        this.sendCommand('save-all');
+        
+        await new Promise(resolve => setTimeout(resolve, 5000));
+        
+        this.sendCommand('say Server restarting in 5 seconds');
+        
+        await new Promise(resolve => setTimeout(resolve, 5000));
+        
+        await this.stop();
+        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(', ')}`);
         }
@@ -623,7 +1061,23 @@ export class MinecraftServer extends EventEmitter {
 
         if (this.config.platform === 'all') {
             await FileUtils.ensureDir(this.config.folders.plugins);
-            await this.geyser.setup(this.config);
+            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) {
@@ -657,14 +1111,6 @@ export class MinecraftServer extends EventEmitter {
             ...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(' ')}`);
@@ -683,47 +1129,7 @@ export class MinecraftServer extends EventEmitter {
             this.process.stdout.pipe(process.stdout);
             this.process.stderr.pipe(process.stderr);
         } else {
-            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/);
-                    if (match) {
-                        this.playerCount++;
-                        this.handlePlayerJoin(match[1]);
-                        
-                        if (this.owners.has(match[1].toLowerCase())) {
-                            this.sendCommand(`tellraw ${match[1]} {"text":"Welcome Owner! Use ${this.ownerCommandPrefix}help for commands","color":"gold"}`);
-                        }
-                    }
-                }
-
-                if (output.includes('left the game')) {
-                    const match = output.match(/(\w+) left the game/);
-                    if (match) {
-                        this.playerCount--;
-                        this.handlePlayerLeave(match[1]);
-                    }
-                }
-
-                if (output.includes('<') && output.includes('>')) {
-                    const chatMatch = output.match(/<(\w+)>\s+(.+)/);
-                    if (chatMatch) {
-                        const player = chatMatch[1];
-                        const message = chatMatch[2];
-                        
-                        if (message.startsWith(this.ownerCommandPrefix)) {
-                            const command = message.substring(this.ownerCommandPrefix.length);
-                            this.processOwnerCommand(player, command);
-                        }
-                    }
-                }
-            });
-
-            this.process.stderr.on('data', (data: Buffer) => {
-                process.stderr.write(data.toString());
-            });
+            this.setupLogHandlers();
         }
 
         this.process.on('exit', (code: number) => {
@@ -748,112 +1154,9 @@ export class MinecraftServer extends EventEmitter {
             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;
     }
 
-    private startMemoryMonitor(): void {
-        if (!this.options.memoryMonitor?.enabled) return;
-
-        const threshold = this.options.memoryMonitor.threshold || 90;
-        const interval = this.options.memoryMonitor.interval || 30000;
-        const action = this.options.memoryMonitor.action || 'warn';
-
-        this.memoryMonitorInterval = setInterval(async () => {
-            if (this.serverInfo.status !== 'running' || !this.process) return;
-
-            try {
-                await this.updateStats();
-                
-                const memPercent = (this.serverInfo.memory.used / this.serverInfo.memory.max) * 100;
-                
-                this.memoryUsageHistory.push(memPercent);
-                if (this.memoryUsageHistory.length > 10) {
-                    this.memoryUsageHistory.shift();
-                }
-
-                if (memPercent > threshold) {
-                    this.logger.warning(`High memory usage: ${memPercent.toFixed(1)}%`);
-                    
-                    const isIncreasing = this.memoryUsageHistory.length > 5 && 
-                                        this.memoryUsageHistory[this.memoryUsageHistory.length - 1] > 
-                                        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');
-                        }
-                    }
-                }
-
-            } catch (error) {
-                this.logger.error('Memory monitor error:', error);
-            }
-        }, interval);
-    }
-
-    private async gracefulRestart(): Promise<void> {
-        this.logger.info('Initiating graceful restart...');
-        
-        this.sendCommand('say Server restarting in 30 seconds');
-        this.sendCommand('save-all');
-        
-        await new Promise(resolve => setTimeout(resolve, 10000));
-        
-        this.sendCommand('say Server restarting in 20 seconds');
-        
-        await new Promise(resolve => setTimeout(resolve, 10000));
-        
-        this.sendCommand('say Server restarting in 10 seconds');
-        this.sendCommand('save-all');
-        
-        await new Promise(resolve => setTimeout(resolve, 5000));
-        
-        this.sendCommand('say Server restarting in 5 seconds');
-        
-        await new Promise(resolve => setTimeout(resolve, 5000));
-        
-        await this.stop();
-        await this.start();
-    }
-
     public async stop(): Promise<void> {
         if (!this.process) {
             this.logger.warning('Server not running');
@@ -877,6 +1180,14 @@ export class MinecraftServer extends EventEmitter {
             this.backupCron.stop();
         }
 
+        if (this.cleanLogsCron) {
+            this.cleanLogsCron.stop();
+        }
+
+        if (this.ramdiskBackupCron) {
+            this.ramdiskBackupCron.stop();
+        }
+
         if (this.memoryMonitorInterval) {
             clearInterval(this.memoryMonitorInterval);
         }
@@ -889,6 +1200,10 @@ export class MinecraftServer extends EventEmitter {
             this.geyser.stop();
         }
 
+        if (this.options.ramdisk?.enabled) {
+            await this.backupRamdiskToMaster();
+        }
+
         this.logger.success('Server stopped');
     }
 
@@ -999,33 +1314,4 @@ export class MinecraftServer extends EventEmitter {
         }
         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;
-        }
-    }
 }