@dimzxzzx07/mc-headless 1.8.0 → 1.9.0

package/src/core/MinecraftServer.ts

@@ -1,10 +1,9 @@
 import { EventEmitter } from 'events';
 import { spawn, exec, execSync } from 'child_process';
-import pidusage from 'pidusage';
 import * as cron from 'node-cron';
 import { MinecraftConfig, ServerInfo, Player } from '../types';
 import { ConfigHandler } from './ConfigHandler';
-import { JavaChecker } from './JavaChecker';
+import { JavaChecker, JavaInfo } from './JavaChecker';
 import { FileUtils } from '../utils/FileUtils';
 import { Logger } from '../utils/Logger';
 import { SystemDetector } from '../utils/SystemDetector';
@@ -15,6 +14,7 @@ import { FabricEngine } from '../engines/FabricEngine';
 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';
 
@@ -22,9 +22,11 @@ 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;
@@ -42,6 +44,8 @@ export interface MinecraftServerOptions extends Partial<MinecraftConfig> {
         prefix: string;
         enabled: boolean;
     };
+    silentMode?: boolean;
+    statsInterval?: number;
 }
 
 export class MinecraftServer extends EventEmitter {
@@ -51,18 +55,26 @@ export class MinecraftServer extends EventEmitter {
     private engine: ServerEngine;
     private geyser: GeyserBridge;
     private viaVersion: ViaVersionManager;
+    private skinRestorer: SkinRestorerManager;
     private process: any = null;
     private serverInfo: ServerInfo;
     private players: Map<string, Player> = new Map();
     private backupCron: cron.ScheduledTask | null = null;
     private startTime: Date | null = null;
     private memoryMonitorInterval: NodeJS.Timeout | null = null;
+    private statsInterval: NodeJS.Timeout | null = null;
     private memoryUsageHistory: number[] = [];
     private worldSize: number = 0;
     private playerCount: number = 0;
     private javaCommand: string = 'java';
+    private javaInfo: JavaInfo | null = null;
     private owners: Set<string> = new Set();
     private ownerCommandPrefix: string = '!';
+    private lastCpuTotal: number = 0;
+    private lastCpuTime: number = 0;
+    private cpuUsage: number = 0;
+    private cgroupMemory: number = 0;
+    private cgroupCpu: number = 0;
 
     constructor(userConfig: MinecraftServerOptions = {}) {
         super();
@@ -71,11 +83,12 @@ export class MinecraftServer extends EventEmitter {
 
         this.options = {
             javaVersion: 'auto',
+            usePortableJava: true,
             memoryMonitor: {
                 enabled: true,
                 threshold: 90,
-                interval: 10000,
-                action: 'restart'
+                interval: 30000,
+                action: 'warn'
             },
             autoInstallJava: true,
             networkOptimization: {
@@ -88,6 +101,8 @@ export class MinecraftServer extends EventEmitter {
                 prefix: '!',
                 enabled: true
             },
+            silentMode: true,
+            statsInterval: 30000,
             ...userConfig
         };
 
@@ -105,6 +120,7 @@ export class MinecraftServer extends EventEmitter {
         this.engine = this.createEngine();
         this.geyser = new GeyserBridge();
         this.viaVersion = new ViaVersionManager();
+        this.skinRestorer = new SkinRestorerManager();
 
         this.serverInfo = {
             pid: 0,
@@ -118,8 +134,32 @@ export class MinecraftServer extends EventEmitter {
             maxPlayers: this.config.world.maxPlayers,
             uptime: 0,
             memory: { used: 0, max: 0 },
+            cpu: 0,
             status: 'stopped'
         };
+
+        this.detectCgroupLimits();
+    }
+
+    private detectCgroupLimits(): void {
+        try {
+            if (fs.existsSync('/sys/fs/cgroup/memory/memory.limit_in_bytes')) {
+                const limit = fs.readFileSync('/sys/fs/cgroup/memory/memory.limit_in_bytes', 'utf8');
+                this.cgroupMemory = parseInt(limit) / 1024 / 1024;
+                this.logger.debug(`Cgroup memory limit: ${this.cgroupMemory} MB`);
+            }
+
+            if (fs.existsSync('/sys/fs/cgroup/cpu/cpu.cfs_quota_us') && fs.existsSync('/sys/fs/cgroup/cpu/cpu.cfs_period_us')) {
+                const quota = parseInt(fs.readFileSync('/sys/fs/cgroup/cpu/cpu.cfs_quota_us', 'utf8'));
+                const period = parseInt(fs.readFileSync('/sys/fs/cgroup/cpu/cpu.cfs_period_us', 'utf8'));
+                if (quota > 0 && period > 0) {
+                    this.cgroupCpu = quota / period;
+                    this.logger.debug(`Cgroup CPU limit: ${this.cgroupCpu} cores`);
+                }
+            }
+        } catch (error) {
+            this.logger.debug('Not running in cgroup environment');
+        }
     }
 
     private createEngine(): ServerEngine {
@@ -163,42 +203,43 @@ export class MinecraftServer extends EventEmitter {
             return;
         }
 
-        const hasJava = await JavaChecker.checkJava();
-        if (!hasJava) {
-            this.logger.info('Java not found, attempting to install...');
-            
-            const osType = SystemDetector.getOS();
-            const distro = SystemDetector.getDistro();
-            const targetVersion = this.options.javaVersion === 'auto' ? '17' : this.options.javaVersion || '17';
-
-            if (osType === 'linux' || osType === 'android') {
-                await this.installJavaLinux(distro, targetVersion);
-            } else if (osType === 'darwin') {
-                await this.installJavaMac(targetVersion);
-            } else if (osType === 'windows') {
-                this.logger.error('Windows detected. Please install Java manually from https://adoptium.net');
-                throw new Error('Java not installed');
-            }
+        const targetVersion = this.options.javaVersion === 'auto' ? '17' : this.options.javaVersion || '17';
+        
+        if (this.options.usePortableJava) {
+            this.javaInfo = await JavaChecker.getOrDownloadPortableJava(targetVersion);
+            this.javaCommand = this.javaInfo.path;
+            this.logger.success(`Using portable Java ${this.javaInfo.version} from ${this.javaInfo.path}`);
         } else {
-            const detectedVersion = await this.detectJavaVersion();
-            this.logger.info(`Detected Java version: ${detectedVersion}`);
-            
-            if (this.options.javaVersion !== 'auto' && detectedVersion !== this.options.javaVersion) {
-                this.logger.warning(`Server configured for Java ${this.options.javaVersion} but detected ${detectedVersion}. This may cause issues.`);
-            }
-
-            if (detectedVersion === '21' || detectedVersion === '17') {
-                this.javaCommand = 'java';
-                this.logger.success(`Using Java ${detectedVersion}`);
-            } else if (detectedVersion === '11' || detectedVersion === '8') {
-                this.logger.warning(`Java ${detectedVersion} is too old. Minecraft 1.21+ requires Java 17 or 21.`);
-                this.logger.info('Attempting to install Java 17...');
+            const hasJava = await JavaChecker.checkJava();
+            if (!hasJava) {
+                this.logger.info('Java not found, attempting to install system Java...');
+                const osType = SystemDetector.getOS();
                 const distro = SystemDetector.getDistro();
-                await this.installJavaLinux(distro, '17');
+
+                if (osType === 'linux' || osType === 'android') {
+                    await this.installJavaLinux(distro, targetVersion);
+                } else if (osType === 'darwin') {
+                    await this.installJavaMac(targetVersion);
+                } else if (osType === 'windows') {
+                    this.logger.error('Windows detected. Please install Java manually from https://adoptium.net');
+                    throw new Error('Java not installed');
+                }
+            } else {
+                const detectedVersion = await this.detectJavaVersion();
+                this.logger.info(`Detected system Java version: ${detectedVersion}`);
+                
+                if (detectedVersion === '21' || detectedVersion === '17') {
+                    this.javaCommand = 'java';
+                    this.logger.success(`Using system Java ${detectedVersion}`);
+                } else {
+                    this.logger.warning(`System Java ${detectedVersion} is not optimal. Switching to portable Java...`);
+                    this.javaInfo = await JavaChecker.getOrDownloadPortableJava(targetVersion);
+                    this.javaCommand = this.javaInfo.path;
+                }
             }
         }
 
-        const finalVersion = await this.detectJavaVersion();
+        const finalVersion = this.javaInfo ? this.javaInfo.version : await this.detectJavaVersion();
         this.logger.success(`Java version: ${finalVersion}`);
     }
 
@@ -378,6 +419,30 @@ export class MinecraftServer extends EventEmitter {
         return [...baseArgs, ...gcArgs];
     }
 
+    private buildEnvironment(): NodeJS.ProcessEnv {
+        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') {
+            env.JAVA_HOME = path.dirname(path.dirname(this.javaInfo.path));
+            env.PATH = `${path.dirname(this.javaInfo.path)}:${env.PATH}`;
+        }
+        
+        if (this.cgroupMemory > 0) {
+            const memLimit = Math.min(this.parseMemory(this.config.memory.max), this.cgroupMemory);
+            env._JAVA_OPTIONS += ` -XX:MaxRAM=${memLimit}M`;
+        }
+        
+        if (this.cgroupCpu > 0) {
+            env._JAVA_OPTIONS += ` -XX:ActiveProcessorCount=${Math.floor(this.cgroupCpu)}`;
+        }
+        
+        return env;
+    }
+
     private processOwnerCommand(player: string, command: string): void {
         if (!this.options.ownerCommands?.enabled) return;
         if (!this.owners.has(player.toLowerCase())) return;
@@ -633,6 +698,51 @@ export class MinecraftServer extends EventEmitter {
         });
     }
 
+    private async updateStats(): Promise<void> {
+        if (!this.process || this.serverInfo.status !== 'running') return;
+
+        try {
+            const memMax = this.parseMemory(this.config.memory.max);
+            
+            if (fs.existsSync('/sys/fs/cgroup/memory/memory.usage_in_bytes')) {
+                const usage = parseInt(fs.readFileSync('/sys/fs/cgroup/memory/memory.usage_in_bytes', 'utf8'));
+                this.serverInfo.memory.used = Math.round(usage / 1024 / 1024);
+            } else {
+                const stats = await import('pidusage');
+                const usage = await stats.default(this.process.pid);
+                this.serverInfo.memory.used = Math.round(usage.memory / 1024 / 1024);
+            }
+            
+            this.serverInfo.memory.max = memMax;
+            
+            if (fs.existsSync('/sys/fs/cgroup/cpuacct/cpuacct.usage')) {
+                const cpuTotal = parseInt(fs.readFileSync('/sys/fs/cgroup/cpuacct/cpuacct.usage', 'utf8'));
+                const now = Date.now();
+                
+                if (this.lastCpuTotal > 0) {
+                    const cpuDiff = cpuTotal - this.lastCpuTotal;
+                    const timeDiff = now - this.lastCpuTime;
+                    this.cpuUsage = (cpuDiff / timeDiff / 1e6) * 100;
+                    if (this.cgroupCpu > 0) {
+                        this.cpuUsage = this.cpuUsage / this.cgroupCpu;
+                    }
+                    this.serverInfo.cpu = Math.min(100, Math.max(0, Math.round(this.cpuUsage)));
+                }
+                
+                this.lastCpuTotal = cpuTotal;
+                this.lastCpuTime = now;
+            }
+            
+            this.serverInfo.uptime = Math.floor((Date.now() - (this.startTime?.getTime() || 0)) / 1000);
+            this.serverInfo.players = this.players.size;
+            
+            this.emit('resource', this.serverInfo);
+            
+        } catch (error) {
+            this.logger.error('Stats update error:', error);
+        }
+    }
+
     public async start(): Promise<ServerInfo> {
         this.logger.info(`Starting ${this.config.type} server v${this.config.version}...`);
 
@@ -680,6 +790,12 @@ export class MinecraftServer extends EventEmitter {
             }
         }
 
+        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();
@@ -699,10 +815,13 @@ export class MinecraftServer extends EventEmitter {
             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']
         });
 
@@ -710,71 +829,52 @@ export class MinecraftServer extends EventEmitter {
         this.serverInfo.status = 'starting';
         this.startTime = new Date();
 
-        this.process.stdout.on('data', (data: Buffer) => {
-            const output = data.toString();
-            process.stdout.write(output);
-
-            if (output.includes('Done') || output.includes('For help, type "help"')) {
-                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.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();
-            }
-
-            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 (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('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);
+                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);
+                        }
                     }
                 }
-            }
-            
-            if (output.includes('[ViaVersion]')) {
-                this.logger.debug(`[ViaVersion] ${output.trim()}`);
-            }
-        });
+            });
 
-        this.process.stderr.on('data', (data: Buffer) => {
-            process.stderr.write(data.toString());
-        });
+            this.process.stderr.on('data', (data: Buffer) => {
+                process.stderr.write(data.toString());
+            });
+        }
 
         this.process.on('exit', (code: number) => {
             this.serverInfo.status = 'stopped';
@@ -788,12 +888,42 @@ export class MinecraftServer extends EventEmitter {
             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;
     }
 
@@ -801,16 +931,16 @@ export class MinecraftServer extends EventEmitter {
         if (!this.options.memoryMonitor?.enabled) return;
 
         const threshold = this.options.memoryMonitor.threshold || 90;
-        const interval = this.options.memoryMonitor.interval || 10000;
+        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 {
-                const stats = await pidusage(this.process.pid);
-                const memMax = this.parseMemory(this.config.memory.max);
-                const memPercent = (stats.memory / (memMax * 1024 * 1024)) * 100;
+                await this.updateStats();
+                
+                const memPercent = (this.serverInfo.memory.used / this.serverInfo.memory.max) * 100;
                 
                 this.memoryUsageHistory.push(memPercent);
                 if (this.memoryUsageHistory.length > 10) {
@@ -901,6 +1031,10 @@ export class MinecraftServer extends EventEmitter {
             clearInterval(this.memoryMonitorInterval);
         }
 
+        if (this.statsInterval) {
+            clearInterval(this.statsInterval);
+        }
+
         if (this.config.platform === 'all') {
             this.geyser.stop();
         }
@@ -918,17 +1052,7 @@ export class MinecraftServer extends EventEmitter {
     }
 
     public async getInfo(): Promise<ServerInfo> {
-        if (this.serverInfo.status === 'running' && this.process) {
-            try {
-                const stats = await pidusage(this.process.pid);
-                this.serverInfo.memory = {
-                    used: Math.round(stats.memory / 1024 / 1024),
-                    max: this.parseMemory(this.config.memory.max)
-                };
-                this.serverInfo.uptime = Math.floor((Date.now() - (this.startTime?.getTime() || 0)) / 1000);
-            } catch {}
-        }
-
+        await this.updateStats();
         return this.serverInfo;
     }
 
@@ -963,21 +1087,10 @@ export class MinecraftServer extends EventEmitter {
         setInterval(async () => {
             if (this.serverInfo.status === 'running' && this.process) {
                 try {
-                    const stats = await pidusage(this.process.pid);
-                    this.serverInfo.memory = {
-                        used: Math.round(stats.memory / 1024 / 1024),
-                        max: this.parseMemory(this.config.memory.max)
-                    };
-                    this.serverInfo.uptime = Math.floor((Date.now() - (this.startTime?.getTime() || 0)) / 1000);
-
-                    if (stats.cpu > 80) {
-                        this.logger.warning(`High CPU usage: ${stats.cpu}%`);
-                    }
-
-                    this.emit('resource', this.serverInfo);
+                    await this.updateStats();
                 } catch {}
             }
-        }, 5000);
+        }, 30000);
     }
 
     private setupBackups(): void {

package/src/index.ts

@@ -1,6 +1,9 @@
+#!/usr/bin/env node
+
 import { MinecraftServer } from './core/MinecraftServer';
 import { Logger, LogLevel } from './utils/Logger';
 import { SystemDetector } from './utils/SystemDetector';
+import { JavaChecker } from './core/JavaChecker';
 
 export * from './core/MinecraftServer';
 export * from './core/ConfigHandler';
@@ -9,6 +12,8 @@ export * from './core/ServerManager';
 export * from './platforms/JavaServer';
 export * from './platforms/BedrockServer';
 export * from './platforms/GeyserBridge';
+export * from './platforms/ViaVersion';
+export * from './platforms/SkinRestorer';
 export * from './engines/Downloader';
 export * from './engines/PaperEngine';
 export * from './engines/VanillaEngine';
@@ -29,40 +34,49 @@ if (require.main === module) {
     const systemInfo = SystemDetector.getSystemInfo();
     logger.info('System Information:', systemInfo);
 
+    JavaChecker.cleanupOldJava();
+
     const server = new MinecraftServer({
         platform: 'java',
-        version: '1.20.1',
+        version: '1.21.11',
         type: 'paper',
+        usePortableJava: true,
         memory: {
-            init: '1G',
-            max: '2G',
+            init: '2G',
+            max: '4G',
             useAikarsFlags: true
         },
         world: {
             difficulty: 'normal',
             hardcore: false,
             gamemode: 'survival',
-            maxPlayers: 10,
-            viewDistance: 10,
+            maxPlayers: 20,
+            viewDistance: 6,
             levelName: 'world'
-        }
+        },
+        enableViaVersion: true,
+        enableViaBackwards: true,
+        enableViaRewind: true,
+        enableSkinRestorer: true,
+        silentMode: true,
+        statsInterval: 30000
     });
 
     server.on('ready', (info) => {
-        logger.success(`
-Mc Headless - Powered By Dimzxzzx07
-     Address: ${info.ip}:${info.port}
-     Version: ${info.version} ${info.type}
-     Players: 0/${info.maxPlayers}
+        console.log(`
+Minecraft Headless - Powered By Dimzxzzx07
+  IP: ${info.ip}:${info.port}
+  Version: ${info.version}
+  Players: ${info.players}/${info.maxPlayers}
+  Memory: ${info.memory.used}/${info.memory.max} MB
+  CPU: ${info.cpu}%
         `);
     });
 
-    server.on('player-join', (player) => {
-        logger.info(`Player joined: ${player.name}`);
-    });
-
-    server.on('player-leave', (name) => {
-        logger.info(`Player left: ${name}`);
+    server.on('resource', (info) => {
+        if (info.memory.used > info.memory.max * 0.8) {
+            logger.warning(`High memory usage: ${info.memory.used}/${info.memory.max} MB (${info.cpu}% CPU)`);
+        }
     });
 
     server.start().catch(error => {
@@ -72,12 +86,14 @@ Mc Headless - Powered By Dimzxzzx07
     process.on('SIGINT', async () => {
         logger.info('Received SIGINT, stopping server...');
         await server.stop();
+        JavaChecker.cleanupOldJava();
         process.exit(0);
     });
 
     process.on('SIGTERM', async () => {
         logger.info('Received SIGTERM, stopping server...');
         await server.stop();
+        JavaChecker.cleanupOldJava();
         process.exit(0);
     });
 }

package/src/platforms/BedrockServer.ts

@@ -39,6 +39,7 @@ export class BedrockServer extends EventEmitter {
             maxPlayers: this.config.world.maxPlayers,
             uptime: 0,
             memory: { used: 0, max: 0 },
+            cpu: 0,
             status: 'stopped'
         };
     }
@@ -258,6 +259,7 @@ export class BedrockServer extends EventEmitter {
                         used: Math.round(stats.memory / 1024 / 1024),
                         max: 0
                     };
+                    this.serverInfo.cpu = Math.round(stats.cpu);
                     this.serverInfo.uptime = Math.floor((Date.now() - (this.startTime?.getTime() || 0)) / 1000);
 
                     this.emit('resource', this.serverInfo);

package/src/platforms/JavaServer.ts

@@ -41,6 +41,7 @@ export class JavaServer extends EventEmitter {
             maxPlayers: this.config.world.maxPlayers,
             uptime: 0,
             memory: { used: 0, max: 0 },
+            cpu: 0,
             status: 'stopped'
         };
     }
@@ -176,6 +177,7 @@ export class JavaServer extends EventEmitter {
                         used: Math.round(stats.memory / 1024 / 1024),
                         max: this.parseMemory(this.config.memory.max)
                     };
+                    this.serverInfo.cpu = Math.round(stats.cpu);
                     this.serverInfo.uptime = Math.floor((Date.now() - (this.startTime?.getTime() || 0)) / 1000);
 
                     if (stats.cpu > 80) {