@dimzxzzx07/mc-headless 2.2.1 → 2.2.3

package/dist/core/MinecraftServer.js

@@ -37,6 +37,8 @@ exports.MinecraftServer = void 0;
 const events_1 = require("events");
 const child_process_1 = require("child_process");
 const cron = __importStar(require("node-cron"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
 const ConfigHandler_1 = require("./ConfigHandler");
 const JavaChecker_1 = require("./JavaChecker");
 const FileUtils_1 = require("../utils/FileUtils");
@@ -49,8 +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 path = __importStar(require("path"));
-const fs = __importStar(require("fs-extra"));
+const PluginManager_1 = require("../platforms/PluginManager");
 class MinecraftServer extends events_1.EventEmitter {
     config;
     options;
@@ -59,10 +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;
@@ -78,46 +82,90 @@ class MinecraftServer extends events_1.EventEmitter {
     cpuUsage = 0;
     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: 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) => this.owners.add(owner.toLowerCase()));
         }
         if (this.options.ownerCommands?.prefix) {
             this.ownerCommandPrefix = this.options.ownerCommands.prefix;
         }
         const handler = new ConfigHandler_1.ConfigHandler(userConfig);
         this.config = handler.getConfig();
+        if (this.isPterodactyl && this.options.optimizeForPterodactyl) {
+            this.optimizeForPterodactylPanel();
+        }
         this.engine = this.createEngine();
         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,
@@ -135,6 +183,28 @@ class MinecraftServer extends events_1.EventEmitter {
         };
         this.detectCgroupLimits();
     }
+    detectEnvironment() {
+        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');
+            }
+        }
+    }
     detectCgroupLimits() {
         try {
             if (fs.existsSync('/sys/fs/cgroup/memory/memory.limit_in_bytes')) {
@@ -155,6 +225,25 @@ class MinecraftServer extends events_1.EventEmitter {
             this.logger.debug('Not running in cgroup environment');
         }
     }
+    optimizeForPterodactylPanel() {
+        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;
+    }
     createEngine() {
         switch (this.config.type) {
             case 'paper':
@@ -171,18 +260,194 @@ class MinecraftServer extends events_1.EventEmitter {
                 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 }
+        ];
+        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');
+                    }
+                }
+            }
+        }
+    }
+    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');
+        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}`);
+        }
+    }
+    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;
+        }
+    }
     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${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 = [];
         if (memMax >= 16384) {
             gcArgs = [
-                '-XX:+UseG1GC',
                 '-XX:+ParallelRefProcEnabled',
-                '-XX:MaxGCPauseMillis=100',
                 '-XX:+UnlockExperimentalVMOptions',
                 '-XX:+DisableExplicitGC',
                 '-XX:+AlwaysPreTouch',
@@ -193,7 +458,6 @@ class MinecraftServer extends events_1.EventEmitter {
                 '-XX:G1HeapWastePercent=5',
                 '-XX:G1MixedGCCountTarget=4',
                 '-XX:InitiatingHeapOccupancyPercent=20',
-                '-XX:G1MixedGCLiveThresholdPercent=90',
                 '-XX:G1RSetUpdatingPauseTimePercent=5',
                 '-XX:SurvivorRatio=32',
                 '-XX:+PerfDisableSharedMem',
@@ -202,9 +466,7 @@ class MinecraftServer extends events_1.EventEmitter {
         }
         else if (memMax >= 8192) {
             gcArgs = [
-                '-XX:+UseG1GC',
                 '-XX:+ParallelRefProcEnabled',
-                '-XX:MaxGCPauseMillis=150',
                 '-XX:+UnlockExperimentalVMOptions',
                 '-XX:+DisableExplicitGC',
                 '-XX:+AlwaysPreTouch',
@@ -215,7 +477,6 @@ class MinecraftServer extends events_1.EventEmitter {
                 '-XX:G1HeapWastePercent=5',
                 '-XX:G1MixedGCCountTarget=4',
                 '-XX:InitiatingHeapOccupancyPercent=15',
-                '-XX:G1MixedGCLiveThresholdPercent=90',
                 '-XX:G1RSetUpdatingPauseTimePercent=5',
                 '-XX:SurvivorRatio=32',
                 '-XX:+PerfDisableSharedMem',
@@ -223,32 +484,27 @@ class MinecraftServer extends events_1.EventEmitter {
             ];
         }
         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];
     }
     buildEnvironment() {
@@ -268,6 +524,67 @@ class MinecraftServer extends events_1.EventEmitter {
         }
         return env;
     }
+    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) {
+                    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) => {
+            process.stderr.write(data.toString());
+        });
+    }
     processOwnerCommand(player, command) {
         if (!this.options.ownerCommands?.enabled)
             return;
@@ -533,11 +850,79 @@ class MinecraftServer extends events_1.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}`);
         }
     }
+    startMemoryMonitor() {
+        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);
+    }
+    async gracefulRestart() {
+        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();
+    }
     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(', ')}`);
         }
@@ -561,7 +946,21 @@ class MinecraftServer extends events_1.EventEmitter {
         }
         if (this.config.platform === 'all') {
             await FileUtils_1.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) {
             this.logger.info('Enabling ViaVersion for client version compatibility...');
@@ -589,12 +988,6 @@ class MinecraftServer extends events_1.EventEmitter {
             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, {
@@ -610,41 +1003,7 @@ class MinecraftServer extends events_1.EventEmitter {
             this.process.stderr.pipe(process.stderr);
         }
         else {
-            this.process.stdout.on('data', (data) => {
-                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) => {
-                process.stderr.write(data.toString());
-            });
+            this.setupLogHandlers();
         }
         this.process.on('exit', (code) => {
             this.serverInfo.status = 'stopped';
@@ -662,87 +1021,8 @@ class MinecraftServer extends events_1.EventEmitter {
         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;
     }
-    startMemoryMonitor() {
-        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);
-    }
-    async gracefulRestart() {
-        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();
-    }
     async stop() {
         if (!this.process) {
             this.logger.warning('Server not running');
@@ -760,6 +1040,12 @@ class MinecraftServer extends events_1.EventEmitter {
         if (this.backupCron) {
             this.backupCron.stop();
         }
+        if (this.cleanLogsCron) {
+            this.cleanLogsCron.stop();
+        }
+        if (this.ramdiskBackupCron) {
+            this.ramdiskBackupCron.stop();
+        }
         if (this.memoryMonitorInterval) {
             clearInterval(this.memoryMonitorInterval);
         }
@@ -769,6 +1055,9 @@ class MinecraftServer extends events_1.EventEmitter {
         if (this.config.platform === 'all') {
             this.geyser.stop();
         }
+        if (this.options.ramdisk?.enabled) {
+            await this.backupRamdiskToMaster();
+        }
         this.logger.success('Server stopped');
     }
     sendCommand(command) {
@@ -864,32 +1153,6 @@ class MinecraftServer extends events_1.EventEmitter {
         }
         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