@dimzxzzx07/mc-headless 1.6.0 → 1.8.0

package/src/core/MinecraftServer.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'events';
-import { spawn } from 'child_process';
+import { spawn, exec, execSync } from 'child_process';
 import pidusage from 'pidusage';
 import * as cron from 'node-cron';
 import { MinecraftConfig, ServerInfo, Player } from '../types';
@@ -16,12 +16,32 @@ import { ServerEngine } from '../engines/ServerEngine';
 import { GeyserBridge } from '../platforms/GeyserBridge';
 import { ViaVersionManager } from '../platforms/ViaVersion';
 import * as path from 'path';
+import * as fs from 'fs-extra';
 
 export interface MinecraftServerOptions extends Partial<MinecraftConfig> {
     enableViaVersion?: boolean;
     enableViaBackwards?: boolean;
     enableViaRewind?: boolean;
     enableProtocolSupport?: boolean;
+    customJavaArgs?: string[];
+    javaVersion?: '17' | '21' | 'auto';
+    memoryMonitor?: {
+        enabled: boolean;
+        threshold: number;
+        interval: number;
+        action: 'restart' | 'warn' | 'stop';
+    };
+    autoInstallJava?: boolean;
+    networkOptimization?: {
+        tcpFastOpen: boolean;
+        bungeeMode: boolean;
+        proxyProtocol: boolean;
+    };
+    owners?: string[];
+    ownerCommands?: {
+        prefix: string;
+        enabled: boolean;
+    };
 }
 
 export class MinecraftServer extends EventEmitter {
@@ -36,13 +56,49 @@ export class MinecraftServer extends EventEmitter {
     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 memoryUsageHistory: number[] = [];
+    private worldSize: number = 0;
+    private playerCount: number = 0;
+    private javaCommand: string = 'java';
+    private owners: Set<string> = new Set();
+    private ownerCommandPrefix: string = '!';
 
     constructor(userConfig: MinecraftServerOptions = {}) {
         super();
         this.logger = Logger.getInstance();
         this.logger.banner();
 
-        this.options = userConfig;
+        this.options = {
+            javaVersion: 'auto',
+            memoryMonitor: {
+                enabled: true,
+                threshold: 90,
+                interval: 10000,
+                action: 'restart'
+            },
+            autoInstallJava: true,
+            networkOptimization: {
+                tcpFastOpen: true,
+                bungeeMode: false,
+                proxyProtocol: false
+            },
+            owners: [],
+            ownerCommands: {
+                prefix: '!',
+                enabled: true
+            },
+            ...userConfig
+        };
+
+        if (this.options.owners) {
+            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(userConfig);
         this.config = handler.getConfig();
 
@@ -83,10 +139,508 @@ export class MinecraftServer extends EventEmitter {
         }
     }
 
+    private async detectJavaVersion(): Promise<string> {
+        try {
+            const output = execSync('java -version 2>&1').toString();
+            if (output.includes('version "21')) {
+                return '21';
+            } else if (output.includes('version "17')) {
+                return '17';
+            } else if (output.includes('version "11')) {
+                return '11';
+            } else if (output.includes('version "8')) {
+                return '8';
+            }
+            return 'unknown';
+        } catch {
+            return 'none';
+        }
+    }
+
+    private async ensureJava(): Promise<void> {
+        if (!this.options.autoInstallJava) {
+            await JavaChecker.ensureJava();
+            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');
+            }
+        } 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 distro = SystemDetector.getDistro();
+                await this.installJavaLinux(distro, '17');
+            }
+        }
+
+        const finalVersion = await this.detectJavaVersion();
+        this.logger.success(`Java version: ${finalVersion}`);
+    }
+
+    private async installJavaLinux(distro: string, version: string): Promise<void> {
+        return new Promise((resolve, reject) => {
+            let command = '';
+            const javaPackage = version === '21' ? 'openjdk-21-jre-headless' : 'openjdk-17-jre-headless';
+            
+            if (distro === 'ubuntu' || distro === 'debian') {
+                command = `apt update && apt install -y ${javaPackage}`;
+            } else if (distro === 'centos' || distro === 'fedora') {
+                command = `yum install -y java-${version}-openjdk-headless`;
+            } else if (distro === 'arch') {
+                const archPackage = version === '21' ? 'jre21-openjdk-headless' : 'jre17-openjdk-headless';
+                command = `pacman -S --noconfirm ${archPackage}`;
+            } else if (distro === 'termux') {
+                command = 'pkg install -y openjdk-17';
+            } else {
+                this.logger.error('Unsupported Linux distribution. Please install Java manually.');
+                reject(new Error('Unsupported distribution'));
+                return;
+            }
+
+            this.logger.info(`Installing Java ${version} with: ${command}`);
+            
+            const install = exec(command, (error) => {
+                if (error) {
+                    reject(error);
+                } else {
+                    resolve();
+                }
+            });
+
+            if (install.stdout) {
+                install.stdout.pipe(process.stdout);
+            }
+            if (install.stderr) {
+                install.stderr.pipe(process.stderr);
+            }
+        });
+    }
+
+    private async installJavaMac(version: string): Promise<void> {
+        return new Promise((resolve, reject) => {
+            const command = `brew install openjdk@${version}`;
+            
+            this.logger.info(`Installing Java ${version} with: ${command}`);
+            
+            const install = exec(command, (error) => {
+                if (error) {
+                    reject(error);
+                } else {
+                    resolve();
+                }
+            });
+
+            if (install.stdout) {
+                install.stdout.pipe(process.stdout);
+            }
+            if (install.stderr) {
+                install.stderr.pipe(process.stderr);
+            }
+        });
+    }
+
+    private async calculateWorldSize(): Promise<number> {
+        try {
+            const worldPath = path.join(process.cwd(), this.config.folders.world);
+            if (!await fs.pathExists(worldPath)) return 0;
+
+            const getSize = async (dir: string): Promise<number> => {
+                let total = 0;
+                const files = await fs.readdir(dir);
+                
+                for (const file of files) {
+                    const filePath = path.join(dir, file);
+                    const stat = await fs.stat(filePath);
+                    
+                    if (stat.isDirectory()) {
+                        total += await getSize(filePath);
+                    } else {
+                        total += stat.size;
+                    }
+                }
+                
+                return total;
+            };
+
+            return await getSize(worldPath);
+        } catch {
+            return 0;
+        }
+    }
+
+    private buildJavaArgs(): string[] {
+        if (this.options.customJavaArgs && this.options.customJavaArgs.length > 0) {
+            return this.options.customJavaArgs;
+        }
+
+        const memMax = this.parseMemory(this.config.memory.max);
+        const javaVersion = this.options.javaVersion || 'auto';
+        
+        let gcArgs: string[] = [];
+
+        if (memMax >= 16384) {
+            gcArgs = [
+                '-XX:+UseG1GC',
+                '-XX:+ParallelRefProcEnabled',
+                '-XX:MaxGCPauseMillis=100',
+                '-XX:+UnlockExperimentalVMOptions',
+                '-XX:+DisableExplicitGC',
+                '-XX:+AlwaysPreTouch',
+                '-XX:G1NewSizePercent=40',
+                '-XX:G1MaxNewSizePercent=50',
+                '-XX:G1HeapRegionSize=16M',
+                '-XX:G1ReservePercent=15',
+                '-XX:G1HeapWastePercent=5',
+                '-XX:G1MixedGCCountTarget=4',
+                '-XX:InitiatingHeapOccupancyPercent=20',
+                '-XX:G1MixedGCLiveThresholdPercent=90',
+                '-XX:G1RSetUpdatingPauseTimePercent=5',
+                '-XX:SurvivorRatio=32',
+                '-XX:+PerfDisableSharedMem',
+                '-XX:MaxTenuringThreshold=1'
+            ];
+        } else if (memMax >= 8192) {
+            gcArgs = [
+                '-XX:+UseG1GC',
+                '-XX:+ParallelRefProcEnabled',
+                '-XX:MaxGCPauseMillis=150',
+                '-XX:+UnlockExperimentalVMOptions',
+                '-XX:+DisableExplicitGC',
+                '-XX:+AlwaysPreTouch',
+                '-XX:G1NewSizePercent=30',
+                '-XX:G1MaxNewSizePercent=40',
+                '-XX:G1HeapRegionSize=8M',
+                '-XX:G1ReservePercent=10',
+                '-XX:G1HeapWastePercent=5',
+                '-XX:G1MixedGCCountTarget=4',
+                '-XX:InitiatingHeapOccupancyPercent=15',
+                '-XX:G1MixedGCLiveThresholdPercent=90',
+                '-XX:G1RSetUpdatingPauseTimePercent=5',
+                '-XX:SurvivorRatio=32',
+                '-XX:+PerfDisableSharedMem',
+                '-XX:MaxTenuringThreshold=1'
+            ];
+        } else {
+            gcArgs = this.config.memory.useAikarsFlags ? [
+                '-XX:+UseG1GC',
+                '-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'
+            ] : [];
+        }
+
+        if (javaVersion === '21') {
+            gcArgs.push('--enable-preview');
+        }
+
+        const baseArgs = [
+            `-Xms${this.config.memory.init}`,
+            `-Xmx${this.config.memory.max}`
+        ];
+
+        return [...baseArgs, ...gcArgs];
+    }
+
+    private processOwnerCommand(player: string, command: string): void {
+        if (!this.options.ownerCommands?.enabled) return;
+        if (!this.owners.has(player.toLowerCase())) return;
+
+        const cmd = command.toLowerCase().trim();
+        const args = cmd.split(' ');
+
+        switch (args[0]) {
+            case 'gamemode':
+            case 'gm':
+                this.handleGamemodeCommand(player, args);
+                break;
+            case 'tp':
+            case 'teleport':
+                this.handleTeleportCommand(player, args);
+                break;
+            case 'give':
+                this.handleGiveCommand(player, args);
+                break;
+            case 'time':
+                this.handleTimeCommand(player, args);
+                break;
+            case 'weather':
+                this.handleWeatherCommand(player, args);
+                break;
+            case 'kill':
+                this.handleKillCommand(player, args);
+                break;
+            case 'ban':
+                this.handleBanCommand(player, args);
+                break;
+            case 'kick':
+                this.handleKickCommand(player, args);
+                break;
+            case 'op':
+                this.handleOpCommand(player, args);
+                break;
+            case 'deop':
+                this.handleDeopCommand(player, args);
+                break;
+            case 'reload':
+                this.sendCommand('reload');
+                this.logger.info(`${player} reloaded the server`);
+                break;
+            case 'save':
+                this.sendCommand('save-all');
+                this.logger.info(`${player} saved the world`);
+                break;
+            case 'list':
+                this.sendCommand('list');
+                break;
+            case 'help':
+                this.sendOwnerHelp(player);
+                break;
+            default:
+                this.sendCommand(command);
+        }
+    }
+
+    private handleGamemodeCommand(player: string, args: string[]): void {
+        if (args.length < 2) {
+            this.sendCommand(`tellraw ${player} {"text":"Usage: ${this.ownerCommandPrefix}gamemode <survival|creative|adventure|spectator> [player]","color":"red"}`);
+            return;
+        }
+
+        const gamemode = args[1];
+        const target = args.length > 2 ? args[2] : player;
+
+        let gamemodeNum = 0;
+        switch (gamemode) {
+            case 'survival':
+            case '0':
+                gamemodeNum = 0;
+                break;
+            case 'creative':
+            case '1':
+                gamemodeNum = 1;
+                break;
+            case 'adventure':
+            case '2':
+                gamemodeNum = 2;
+                break;
+            case 'spectator':
+            case '3':
+                gamemodeNum = 3;
+                break;
+            default:
+                this.sendCommand(`tellraw ${player} {"text":"Invalid gamemode. Use: survival, creative, adventure, spectator","color":"red"}`);
+                return;
+        }
+
+        this.sendCommand(`gamemode ${gamemodeNum} ${target}`);
+        this.logger.info(`${player} set gamemode of ${target} to ${gamemode}`);
+    }
+
+    private handleTeleportCommand(player: string, args: string[]): void {
+        if (args.length < 2) {
+            this.sendCommand(`tellraw ${player} {"text":"Usage: ${this.ownerCommandPrefix}tp <player> [x y z]","color":"red"}`);
+            return;
+        }
+
+        const target = args[1];
+        if (args.length >= 4) {
+            const x = args[2];
+            const y = args[3];
+            const z = args[4] || '0';
+            this.sendCommand(`tp ${target} ${x} ${y} ${z}`);
+        } else {
+            this.sendCommand(`tp ${player} ${target}`);
+        }
+        this.logger.info(`${player} teleported to ${target}`);
+    }
+
+    private handleGiveCommand(player: string, args: string[]): void {
+        if (args.length < 3) {
+            this.sendCommand(`tellraw ${player} {"text":"Usage: ${this.ownerCommandPrefix}give <player> <item> [amount]","color":"red"}`);
+            return;
+        }
+
+        const target = args[1];
+        const item = args[2];
+        const amount = args.length > 3 ? args[3] : '1';
+        
+        this.sendCommand(`give ${target} ${item} ${amount}`);
+        this.logger.info(`${player} gave ${amount} x ${item} to ${target}`);
+    }
+
+    private handleTimeCommand(player: string, args: string[]): void {
+        if (args.length < 2) {
+            this.sendCommand(`tellraw ${player} {"text":"Usage: ${this.ownerCommandPrefix}time <set|add|query> <value>","color":"red"}`);
+            return;
+        }
+
+        const subCmd = args[1];
+        const value = args.length > 2 ? args[2] : '';
+
+        if (subCmd === 'set') {
+            if (value === 'day') {
+                this.sendCommand('time set day');
+            } else if (value === 'night') {
+                this.sendCommand('time set night');
+            } else {
+                this.sendCommand(`time set ${value}`);
+            }
+        } else if (subCmd === 'add') {
+            this.sendCommand(`time add ${value}`);
+        } else if (subCmd === 'query') {
+            this.sendCommand('time query daytime');
+        }
+
+        this.logger.info(`${player} changed time: ${subCmd} ${value}`);
+    }
+
+    private handleWeatherCommand(player: string, args: string[]): void {
+        if (args.length < 2) {
+            this.sendCommand(`tellraw ${player} {"text":"Usage: ${this.ownerCommandPrefix}weather <clear|rain|thunder> [duration]","color":"red"}`);
+            return;
+        }
+
+        const weather = args[1];
+        const duration = args.length > 2 ? args[2] : '';
+
+        if (weather === 'clear') {
+            this.sendCommand('weather clear');
+        } else if (weather === 'rain') {
+            this.sendCommand('weather rain');
+        } else if (weather === 'thunder') {
+            this.sendCommand('weather thunder');
+        }
+
+        if (duration) {
+            this.sendCommand(`weather ${weather} ${duration}`);
+        }
+
+        this.logger.info(`${player} changed weather to ${weather}`);
+    }
+
+    private handleKillCommand(player: string, args: string[]): void {
+        const target = args.length > 1 ? args[1] : player;
+        this.sendCommand(`kill ${target}`);
+        this.logger.info(`${player} killed ${target}`);
+    }
+
+    private handleBanCommand(player: string, args: string[]): void {
+        if (args.length < 2) {
+            this.sendCommand(`tellraw ${player} {"text":"Usage: ${this.ownerCommandPrefix}ban <player> [reason]","color":"red"}`);
+            return;
+        }
+
+        const target = args[1];
+        const reason = args.slice(2).join(' ') || 'Banned by owner';
+        
+        this.sendCommand(`ban ${target} ${reason}`);
+        this.logger.info(`${player} banned ${target}: ${reason}`);
+    }
+
+    private handleKickCommand(player: string, args: string[]): void {
+        if (args.length < 2) {
+            this.sendCommand(`tellraw ${player} {"text":"Usage: ${this.ownerCommandPrefix}kick <player> [reason]","color":"red"}`);
+            return;
+        }
+
+        const target = args[1];
+        const reason = args.slice(2).join(' ') || 'Kicked by owner';
+        
+        this.sendCommand(`kick ${target} ${reason}`);
+        this.logger.info(`${player} kicked ${target}: ${reason}`);
+    }
+
+    private handleOpCommand(player: string, args: string[]): void {
+        if (args.length < 2) {
+            this.sendCommand(`tellraw ${player} {"text":"Usage: ${this.ownerCommandPrefix}op <player>","color":"red"}`);
+            return;
+        }
+
+        const target = args[1];
+        this.sendCommand(`op ${target}`);
+        this.logger.info(`${player} opped ${target}`);
+    }
+
+    private handleDeopCommand(player: string, args: string[]): void {
+        if (args.length < 2) {
+            this.sendCommand(`tellraw ${player} {"text":"Usage: ${this.ownerCommandPrefix}deop <player>","color":"red"}`);
+            return;
+        }
+
+        const target = args[1];
+        this.sendCommand(`deop ${target}`);
+        this.logger.info(`${player} deopped ${target}`);
+    }
+
+    private sendOwnerHelp(player: string): void {
+        const commands = [
+            `{"text":"\\n=== Owner Commands ===\\n","color":"gold","bold":true}`,
+            `{"text":"${this.ownerCommandPrefix}gamemode <mode> [player] - Change gamemode\\n","color":"yellow"}`,
+            `{"text":"${this.ownerCommandPrefix}tp <player> [x y z] - Teleport\\n","color":"yellow"}`,
+            `{"text":"${this.ownerCommandPrefix}give <player> <item> [amount] - Give items\\n","color":"yellow"}`,
+            `{"text":"${this.ownerCommandPrefix}time <set|add> <value> - Change time\\n","color":"yellow"}`,
+            `{"text":"${this.ownerCommandPrefix}weather <clear|rain|thunder> - Change weather\\n","color":"yellow"}`,
+            `{"text":"${this.ownerCommandPrefix}kill [player] - Kill player\\n","color":"yellow"}`,
+            `{"text":"${this.ownerCommandPrefix}ban <player> [reason] - Ban player\\n","color":"yellow"}`,
+            `{"text":"${this.ownerCommandPrefix}kick <player> [reason] - Kick player\\n","color":"yellow"}`,
+            `{"text":"${this.ownerCommandPrefix}op <player> - Give operator\\n","color":"yellow"}`,
+            `{"text":"${this.ownerCommandPrefix}deop <player> - Remove operator\\n","color":"yellow"}`,
+            `{"text":"${this.ownerCommandPrefix}reload - Reload server\\n","color":"yellow"}`,
+            `{"text":"${this.ownerCommandPrefix}save - Save world\\n","color":"yellow"}`,
+            `{"text":"${this.ownerCommandPrefix}list - List players\\n","color":"yellow"}`,
+            `{"text":"${this.ownerCommandPrefix}help - Show this help\\n","color":"yellow"}`
+        ];
+
+        commands.forEach(cmd => {
+            this.sendCommand(`tellraw ${player} ${cmd}`);
+        });
+    }
+
     public async start(): Promise<ServerInfo> {
         this.logger.info(`Starting ${this.config.type} server v${this.config.version}...`);
 
-        await JavaChecker.ensureJava();
+        if (this.owners.size > 0) {
+            this.logger.info(`Owners configured: ${Array.from(this.owners).join(', ')}`);
+        }
+
+        await this.ensureJava();
 
         const systemInfo = SystemDetector.getSystemInfo();
         this.logger.debug('System info:', systemInfo);
@@ -94,6 +648,11 @@ export class MinecraftServer extends EventEmitter {
         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') {
@@ -121,7 +680,7 @@ export class MinecraftServer extends EventEmitter {
             }
         }
 
-        const javaArgs = this.engine.getJavaArgs(this.config);
+        const javaArgs = this.buildJavaArgs();
         const serverJar = this.engine.getServerJar(jarPath);
         const serverArgs = this.engine.getServerArgs();
 
@@ -132,11 +691,19 @@ export class MinecraftServer extends EventEmitter {
             ...serverArgs
         ];
 
-        this.logger.info(`Launching: java ${fullArgs.join(' ')}`);
+        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');
+        }
+
+        this.logger.info(`Launching: ${this.javaCommand} ${fullArgs.join(' ')}`);
 
-        this.process = spawn('java', fullArgs, {
+        this.process = spawn(this.javaCommand, fullArgs, {
             cwd: serverDir,
-            stdio: 'pipe'
+            stdio: ['pipe', 'pipe', 'pipe']
         });
 
         this.serverInfo.pid = this.process.pid!;
@@ -155,22 +722,50 @@ export class MinecraftServer extends EventEmitter {
                     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 (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('[ViaVersion]')) {
                 this.logger.debug(`[ViaVersion] ${output.trim()}`);
@@ -202,6 +797,83 @@ export class MinecraftServer extends EventEmitter {
         return this.serverInfo;
     }
 
+    private startMemoryMonitor(): void {
+        if (!this.options.memoryMonitor?.enabled) return;
+
+        const threshold = this.options.memoryMonitor.threshold || 90;
+        const interval = this.options.memoryMonitor.interval || 10000;
+        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;
+                
+                this.memoryUsageHistory.push(memPercent);
+                if (this.memoryUsageHistory.length > 10) {
+                    this.memoryUsageHistory.shift();
+                }
+
+                if (memPercent > threshold) {
+                    this.logger.warning(`High memory usage: ${memPercent.toFixed(1)}%`);
+                    
+                    const isIncreasing = this.memoryUsageHistory.length > 5 && 
+                                        this.memoryUsageHistory[this.memoryUsageHistory.length - 1] > 
+                                        this.memoryUsageHistory[0] * 1.2;
+                    
+                    if (isIncreasing) {
+                        this.logger.warning('Memory leak detected!');
+                        
+                        switch (action) {
+                            case 'restart':
+                                this.logger.info('Restarting server due to memory leak...');
+                                await this.gracefulRestart();
+                                break;
+                            case 'stop':
+                                this.logger.info('Stopping server due to memory leak...');
+                                await this.stop();
+                                break;
+                            case 'warn':
+                            default:
+                                this.logger.warning('Please restart server to free memory');
+                        }
+                    }
+                }
+
+            } catch (error) {
+                this.logger.error('Memory monitor error:', error);
+            }
+        }, interval);
+    }
+
+    private async gracefulRestart(): Promise<void> {
+        this.logger.info('Initiating graceful restart...');
+        
+        this.sendCommand('say Server restarting in 30 seconds');
+        this.sendCommand('save-all');
+        
+        await new Promise(resolve => setTimeout(resolve, 10000));
+        
+        this.sendCommand('say Server restarting in 20 seconds');
+        
+        await new Promise(resolve => setTimeout(resolve, 10000));
+        
+        this.sendCommand('say Server restarting in 10 seconds');
+        this.sendCommand('save-all');
+        
+        await new Promise(resolve => setTimeout(resolve, 5000));
+        
+        this.sendCommand('say Server restarting in 5 seconds');
+        
+        await new Promise(resolve => setTimeout(resolve, 5000));
+        
+        await this.stop();
+        await this.start();
+    }
+
     public async stop(): Promise<void> {
         if (!this.process) {
             this.logger.warning('Server not running');
@@ -211,9 +883,10 @@ export class MinecraftServer extends EventEmitter {
         this.logger.info('Stopping server...');
         this.serverInfo.status = 'stopping';
 
+        this.sendCommand('save-all');
         this.sendCommand('stop');
 
-        await new Promise(resolve => setTimeout(resolve, 5000));
+        await new Promise(resolve => setTimeout(resolve, 10000));
 
         if (this.process) {
             this.process.kill();
@@ -224,6 +897,10 @@ export class MinecraftServer extends EventEmitter {
             this.backupCron.stop();
         }
 
+        if (this.memoryMonitorInterval) {
+            clearInterval(this.memoryMonitorInterval);
+        }
+
         if (this.config.platform === 'all') {
             this.geyser.stop();
         }