@dimzxzzx07/mc-headless 1.6.0 → 1.8.0

package/dist/core/MinecraftServer.js

@@ -53,6 +53,7 @@ const FabricEngine_1 = require("../engines/FabricEngine");
 const GeyserBridge_1 = require("../platforms/GeyserBridge");
 const ViaVersion_1 = require("../platforms/ViaVersion");
 const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
 class MinecraftServer extends events_1.EventEmitter {
     config;
     options;
@@ -65,11 +66,44 @@ class MinecraftServer extends events_1.EventEmitter {
     players = new Map();
     backupCron = null;
     startTime = null;
+    memoryMonitorInterval = null;
+    memoryUsageHistory = [];
+    worldSize = 0;
+    playerCount = 0;
+    javaCommand = 'java';
+    owners = new Set();
+    ownerCommandPrefix = '!';
     constructor(userConfig = {}) {
         super();
         this.logger = Logger_1.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_1.ConfigHandler(userConfig);
         this.config = handler.getConfig();
         this.engine = this.createEngine();
@@ -106,13 +140,478 @@ class MinecraftServer extends events_1.EventEmitter {
                 throw new Error(`Unsupported server type: ${this.config.type}`);
         }
     }
+    async detectJavaVersion() {
+        try {
+            const output = (0, child_process_1.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';
+        }
+    }
+    async ensureJava() {
+        if (!this.options.autoInstallJava) {
+            await JavaChecker_1.JavaChecker.ensureJava();
+            return;
+        }
+        const hasJava = await JavaChecker_1.JavaChecker.checkJava();
+        if (!hasJava) {
+            this.logger.info('Java not found, attempting to install...');
+            const osType = SystemDetector_1.SystemDetector.getOS();
+            const distro = SystemDetector_1.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_1.SystemDetector.getDistro();
+                await this.installJavaLinux(distro, '17');
+            }
+        }
+        const finalVersion = await this.detectJavaVersion();
+        this.logger.success(`Java version: ${finalVersion}`);
+    }
+    async installJavaLinux(distro, version) {
+        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 = (0, child_process_1.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);
+            }
+        });
+    }
+    async installJavaMac(version) {
+        return new Promise((resolve, reject) => {
+            const command = `brew install openjdk@${version}`;
+            this.logger.info(`Installing Java ${version} with: ${command}`);
+            const install = (0, child_process_1.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);
+            }
+        });
+    }
+    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);
+        const javaVersion = this.options.javaVersion || 'auto';
+        let gcArgs = [];
+        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];
+    }
+    processOwnerCommand(player, command) {
+        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);
+        }
+    }
+    handleGamemodeCommand(player, args) {
+        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}`);
+    }
+    handleTeleportCommand(player, args) {
+        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}`);
+    }
+    handleGiveCommand(player, args) {
+        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}`);
+    }
+    handleTimeCommand(player, args) {
+        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}`);
+    }
+    handleWeatherCommand(player, args) {
+        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}`);
+    }
+    handleKillCommand(player, args) {
+        const target = args.length > 1 ? args[1] : player;
+        this.sendCommand(`kill ${target}`);
+        this.logger.info(`${player} killed ${target}`);
+    }
+    handleBanCommand(player, args) {
+        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}`);
+    }
+    handleKickCommand(player, args) {
+        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}`);
+    }
+    handleOpCommand(player, args) {
+        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}`);
+    }
+    handleDeopCommand(player, args) {
+        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}`);
+    }
+    sendOwnerHelp(player) {
+        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}`);
+        });
+    }
     async start() {
         this.logger.info(`Starting ${this.config.type} server v${this.config.version}...`);
-        await JavaChecker_1.JavaChecker.ensureJava();
+        if (this.owners.size > 0) {
+            this.logger.info(`Owners configured: ${Array.from(this.owners).join(', ')}`);
+        }
+        await this.ensureJava();
         const systemInfo = SystemDetector_1.SystemDetector.getSystemInfo();
         this.logger.debug('System info:', systemInfo);
         const serverDir = process.cwd();
         await FileUtils_1.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);
@@ -136,7 +635,7 @@ class MinecraftServer extends events_1.EventEmitter {
                 this.logger.info('ViaRewind will be installed');
             }
         }
-        const javaArgs = this.engine.getJavaArgs(this.config);
+        const javaArgs = this.buildJavaArgs();
         const serverJar = this.engine.getServerJar(jarPath);
         const serverArgs = this.engine.getServerArgs();
         const fullArgs = [
@@ -145,10 +644,16 @@ class MinecraftServer extends events_1.EventEmitter {
             serverJar,
             ...serverArgs
         ];
-        this.logger.info(`Launching: java ${fullArgs.join(' ')}`);
-        this.process = (0, child_process_1.spawn)('java', fullArgs, {
+        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 = (0, child_process_1.spawn)(this.javaCommand, fullArgs, {
             cwd: serverDir,
-            stdio: 'pipe'
+            stdio: ['pipe', 'pipe', 'pipe']
         });
         this.serverInfo.pid = this.process.pid;
         this.serverInfo.status = 'starting';
@@ -162,20 +667,43 @@ class MinecraftServer extends events_1.EventEmitter {
                 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 (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()}`);
             }
@@ -198,6 +726,66 @@ class MinecraftServer extends events_1.EventEmitter {
         }
         return this.serverInfo;
     }
+    startMemoryMonitor() {
+        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 (0, pidusage_1.default)(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);
+    }
+    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');
@@ -205,8 +793,9 @@ class MinecraftServer extends events_1.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();
             this.process = null;
@@ -214,6 +803,9 @@ class MinecraftServer extends events_1.EventEmitter {
         if (this.backupCron) {
             this.backupCron.stop();
         }
+        if (this.memoryMonitorInterval) {
+            clearInterval(this.memoryMonitorInterval);
+        }
         if (this.config.platform === 'all') {
             this.geyser.stop();
         }