@dimzxzzx07/mc-headless 2.2.0 → 2.2.2

package/src/core/MinecraftServer.ts

@@ -1,6 +1,8 @@
 import { EventEmitter } from 'events';
 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 { ConfigHandler } from './ConfigHandler';
 import { JavaChecker, JavaInfo } from './JavaChecker';
@@ -15,8 +17,6 @@ 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;
@@ -46,6 +46,8 @@ export interface MinecraftServerOptions extends Partial<MinecraftConfig> {
     };
     silentMode?: boolean;
     statsInterval?: number;
+    cleanLogsInterval?: number;
+    optimizeForPterodactyl?: boolean;
 }
 
 export class MinecraftServer extends EventEmitter {
@@ -60,6 +62,7 @@ export class MinecraftServer extends EventEmitter {
     private serverInfo: ServerInfo;
     private players: Map<string, Player> = new Map();
     private backupCron: cron.ScheduledTask | null = null;
+    private cleanLogsCron: cron.ScheduledTask | null = null;
     private startTime: Date | null = null;
     private memoryMonitorInterval: NodeJS.Timeout | null = null;
     private statsInterval: NodeJS.Timeout | null = null;
@@ -75,15 +78,18 @@ export class MinecraftServer extends EventEmitter {
     private cpuUsage: number = 0;
     private cgroupMemory: number = 0;
     private cgroupCpu: number = 0;
+    private isPterodactyl: boolean = false;
 
     constructor(userConfig: MinecraftServerOptions = {}) {
         super();
         this.logger = Logger.getInstance();
         this.logger.banner();
 
+        this.detectEnvironment();
+
         this.options = {
             javaVersion: 'auto',
-            usePortableJava: true,
+            usePortableJava: !this.isPterodactyl,
             memoryMonitor: {
                 enabled: true,
                 threshold: 90,
@@ -103,6 +109,8 @@ export class MinecraftServer extends EventEmitter {
             },
             silentMode: true,
             statsInterval: 30000,
+            cleanLogsInterval: 3 * 60 * 60 * 1000,
+            optimizeForPterodactyl: true,
             ...userConfig
         };
 
@@ -117,6 +125,10 @@ 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();
@@ -139,6 +151,181 @@ 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');
+        }
+    }
+
+    private optimizeForPterodactylPanel(): void {
+        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 pterodactylInitMemory = process.env.SERVER_MEMORY_INIT;
+        if (pterodactylInitMemory) {
+            this.config.memory.init = pterodactylInitMemory;
+        }
+
+        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')
+        ];
+
+        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}`);
+                }
+            }
+        });
+    }
+
+    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: any) {
+            this.logger.warning(`Failed to clean logs: ${err.message}`);
+        }
+    }
+
+    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 {
@@ -187,11 +374,16 @@ export class MinecraftServer extends EventEmitter {
         const memMax = this.parseMemory(this.config.memory.max);
         const javaVersion = this.options.javaVersion || 'auto';
         
+        const baseArgs = [
+            `-Xms${this.config.memory.init}`,
+            `-Xmx${this.config.memory.max}`,
+            '-XX:+UseG1GC'
+        ];
+
         let gcArgs: string[] = [];
 
         if (memMax >= 16384) {
             gcArgs = [
-                '-XX:+UseG1GC',
                 '-XX:+ParallelRefProcEnabled',
                 '-XX:MaxGCPauseMillis=100',
                 '-XX:+UnlockExperimentalVMOptions',
@@ -212,7 +404,6 @@ export class MinecraftServer extends EventEmitter {
             ];
         } else if (memMax >= 8192) {
             gcArgs = [
-                '-XX:+UseG1GC',
                 '-XX:+ParallelRefProcEnabled',
                 '-XX:MaxGCPauseMillis=150',
                 '-XX:+UnlockExperimentalVMOptions',
@@ -233,7 +424,6 @@ export class MinecraftServer extends EventEmitter {
             ];
         } else {
             gcArgs = this.config.memory.useAikarsFlags ? [
-                '-XX:+UseG1GC',
                 '-XX:+ParallelRefProcEnabled',
                 '-XX:MaxGCPauseMillis=200',
                 '-XX:+UnlockExperimentalVMOptions',
@@ -256,11 +446,6 @@ export class MinecraftServer extends EventEmitter {
             gcArgs.push('--enable-preview');
         }
 
-        const baseArgs = [
-            `-Xms${this.config.memory.init}`,
-            `-Xmx${this.config.memory.max}`
-        ];
-
         return [...baseArgs, ...gcArgs];
     }
 
@@ -268,7 +453,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 +472,207 @@ export class MinecraftServer extends EventEmitter {
         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();
+
+        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;
+    }
+
+    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/);
+                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;
@@ -588,195 +973,6 @@ export class MinecraftServer extends EventEmitter {
         }
     }
 
-    public async start(): Promise<ServerInfo> {
-        this.logger.info(`Starting ${this.config.type} server v${this.config.version}...`);
-
-        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.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.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();
-        }
-
-        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;
 
@@ -877,6 +1073,10 @@ export class MinecraftServer extends EventEmitter {
             this.backupCron.stop();
         }
 
+        if (this.cleanLogsCron) {
+            this.cleanLogsCron.stop();
+        }
+
         if (this.memoryMonitorInterval) {
             clearInterval(this.memoryMonitorInterval);
         }
@@ -889,6 +1089,7 @@ export class MinecraftServer extends EventEmitter {
             this.geyser.stop();
         }
 
+        this.cleanPaperCache();
         this.logger.success('Server stopped');
     }