@dimzxzzx07/mc-headless 1.5.0 → 1.7.0

package/src/core/MinecraftServer.ts

@@ -14,29 +14,41 @@ import { ForgeEngine } from '../engines/ForgeEngine';
 import { FabricEngine } from '../engines/FabricEngine';
 import { ServerEngine } from '../engines/ServerEngine';
 import { GeyserBridge } from '../platforms/GeyserBridge';
+import { ViaVersionManager } from '../platforms/ViaVersion';
 import * as path from 'path';
 
+export interface MinecraftServerOptions extends Partial<MinecraftConfig> {
+    enableViaVersion?: boolean;
+    enableViaBackwards?: boolean;
+    enableViaRewind?: boolean;
+    enableProtocolSupport?: boolean;
+}
+
 export class MinecraftServer extends EventEmitter {
     private config: MinecraftConfig;
+    private options: MinecraftServerOptions;
     private logger: Logger;
     private engine: ServerEngine;
     private geyser: GeyserBridge;
+    private viaVersion: ViaVersionManager;
     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;
 
-    constructor(userConfig: Partial<MinecraftConfig>) {
+    constructor(userConfig: MinecraftServerOptions = {}) {
         super();
         this.logger = Logger.getInstance();
         this.logger.banner();
 
+        this.options = userConfig;
         const handler = new ConfigHandler(userConfig);
         this.config = handler.getConfig();
 
         this.engine = this.createEngine();
         this.geyser = new GeyserBridge();
+        this.viaVersion = new ViaVersionManager();
 
         this.serverInfo = {
             pid: 0,
@@ -91,9 +103,23 @@ export class MinecraftServer extends EventEmitter {
         }
 
         if (this.config.platform === 'all') {
-    await FileUtils.ensureDir(this.config.folders.plugins);
-    await this.geyser.setup(this.config);
-}
+            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');
+            }
+        }
 
         const javaArgs = this.engine.getJavaArgs(this.config);
         const serverJar = this.engine.getServerJar(jarPath);
@@ -124,6 +150,11 @@ export class MinecraftServer extends EventEmitter {
             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');
+                }
+                
                 this.emit('ready', this.serverInfo);
             }
 
@@ -140,6 +171,10 @@ export class MinecraftServer extends EventEmitter {
                     this.handlePlayerLeave(match[1]);
                 }
             }
+            
+            if (output.includes('[ViaVersion]')) {
+                this.logger.debug(`[ViaVersion] ${output.trim()}`);
+            }
         });
 
         this.process.stderr.on('data', (data: Buffer) => {

package/src/engines/Downloader.ts

@@ -100,19 +100,19 @@ export class Downloader {
     }
 
     public static async getGeyserInfo(): Promise<DownloadInfo> {
-    try {
-        const res = await axios.get('https://download.geysermc.org/v2/projects/geyser/versions/latest');
-        const latestBuild = res.data.builds[res.data.builds.length - 1];
-        
-        return {
-            url: `https://download.geysermc.org/v2/projects/geyser/versions/latest/builds/${latestBuild}/downloads/spigot`,
-            fileName: 'geyser.jar'
-        };
-    } catch (error) {
-        Downloader.logger.error(`Failed to get Geyser info: ${error}`);
-        throw error;
+        try {
+            const res = await axios.get('https://download.geysermc.org/v2/projects/geyser/versions/latest');
+            const latestBuild = res.data.builds[res.data.builds.length - 1];
+            
+            return {
+                url: `https://download.geysermc.org/v2/projects/geyser/versions/latest/builds/${latestBuild}/downloads/standalone`,
+                fileName: 'geyser.jar'
+            };
+        } catch (error) {
+            Downloader.logger.error(`Failed to get Geyser info: ${error}`);
+            throw error;
+        }
     }
-}
 
     public static async getFloodgateInfo(): Promise<DownloadInfo> {
         try {
@@ -166,14 +166,18 @@ export class Downloader {
 
     private static getVanillaHash(version: string): string {
         const hashes: Record<string, string> = {
-            '1.21': 'e6c1f9b4b9d9d9b9b9d9d9b9b9d9d9b9d9b9d9d9',
+            '1.21.11': 'e6c1f9b4b9d9d9b9b9d9d9b9b9d9d9b9d9b9d9d9',
+            '1.21.4': '8dd1a28015f51b1803213892b75b7a20c5981f4d',
+            '1.21.3': '5b2aad530acbdcdcc875c1b2e2b469f498e37d2f',
+            '1.21.1': 'ae9f122b71bdab92d28fea6e27c53b0b28e25c1a',
+            '1.21': 'ae9f122b71bdab92d28fea6e27c53b0b28e25c1a',
             '1.20.4': '8dd1a28015f51b1803213892b75b7a20c5981f4d',
             '1.20.2': '5b2aad530acbdcdcc875c1b2e2b469f498e37d2f',
             '1.20.1': 'ae9f122b71bdab92d28fea6e27c53b0b28e25c1a',
             '1.19.4': '8f3112a279976a0f4bcb8152d2a13015b0e2c1f5',
             '1.18.2': 'c8f83c5655348435ec3f61fc9c6b83f3519e8a2c'
         };
-        return hashes[version] || hashes['1.20.1'];
+        return hashes[version] || hashes['1.21.1'];
     }
 
     private static async calculateSHA1(filePath: string): Promise<string> {

package/src/platforms/ProtocolSupport.ts

@@ -0,0 +1,52 @@
+import { MinecraftConfig } from '../types';
+import { FileUtils } from '../utils/FileUtils';
+import { Logger } from '../utils/Logger';
+import * as path from 'path';
+import axios from 'axios';
+
+export class ProtocolSupportManager {
+    private logger = Logger.getInstance();
+
+    public async setup(config: MinecraftConfig): Promise<void> {
+        const pluginsDir = config.folders.plugins;
+        await FileUtils.ensureDir(pluginsDir);
+
+        this.logger.info('Setting up ProtocolSupport...');
+
+        await this.downloadProtocolSupport(pluginsDir);
+
+        this.logger.success('ProtocolSupport installed successfully');
+    }
+
+    private async downloadProtocolSupport(pluginsDir: string): Promise<void> {
+        const psJar = path.join(pluginsDir, 'ProtocolSupport.jar');
+        
+        if (await FileUtils.fileExists(psJar)) {
+            this.logger.info('ProtocolSupport already exists, skipping download');
+            return;
+        }
+
+        this.logger.info('Downloading ProtocolSupport...');
+        
+        try {
+            const response = await axios({
+                method: 'GET',
+                url: 'https://github.com/ProtocolSupport/ProtocolSupport/releases/latest/download/ProtocolSupport.jar',
+                responseType: 'stream'
+            });
+
+            const writer = require('fs').createWriteStream(psJar);
+            response.data.pipe(writer);
+
+            await new Promise((resolve, reject) => {
+                writer.on('finish', resolve);
+                writer.on('error', reject);
+            });
+
+            this.logger.success('ProtocolSupport downloaded');
+        } catch (error) {
+            this.logger.error('Failed to download ProtocolSupport', error);
+            throw error;
+        }
+    }
+}

package/src/platforms/ViaVersion.ts

@@ -0,0 +1,214 @@
+import { MinecraftConfig } from '../types';
+import { FileUtils } from '../utils/FileUtils';
+import { Logger } from '../utils/Logger';
+import * as path from 'path';
+import axios from 'axios';
+import * as fs from 'fs-extra';
+
+export interface ViaVersionInfo {
+    version: string;
+    downloadUrl: string;
+    fileName: string;
+}
+
+export class ViaVersionManager {
+    private logger = Logger.getInstance();
+
+    private readonly VIAVERSION_URL = 'https://github.com/ViaVersion/ViaVersion/releases/download/5.7.2/ViaVersion-5.7.2.jar';
+    private readonly VIABACKWARDS_URL = 'https://github.com/ViaVersion/ViaBackwards/releases/download/5.7.2/ViaBackwards-5.7.2.jar';
+    private readonly VIAREWIND_URL = 'https://github.com/ViaVersion/ViaRewind/releases/download/4.0.15/ViaRewind-4.0.15.jar';
+
+    public async setup(config: MinecraftConfig): Promise<void> {
+        const pluginsDir = config.folders.plugins;
+        await FileUtils.ensureDir(pluginsDir);
+
+        this.logger.info('Setting up ViaVersion, ViaBackwards, ViaRewind...');
+
+        await this.cleanupCorruptFiles(pluginsDir);
+
+        await this.downloadViaVersion(pluginsDir);
+        await this.downloadViaBackwards(pluginsDir);
+        await this.downloadViaRewind(pluginsDir);
+
+        await this.verifyAllPlugins(pluginsDir);
+
+        this.logger.success('ViaVersion suite installed successfully');
+        this.logger.info('Players from older versions can now connect to your server');
+    }
+
+    private async cleanupCorruptFiles(pluginsDir: string): Promise<void> {
+        const files = [
+            { name: 'ViaVersion.jar', url: this.VIAVERSION_URL },
+            { name: 'ViaBackwards.jar', url: this.VIABACKWARDS_URL },
+            { name: 'ViaRewind.jar', url: this.VIAREWIND_URL }
+        ];
+
+        for (const file of files) {
+            const filePath = path.join(pluginsDir, file.name);
+            
+            if (await FileUtils.fileExists(filePath)) {
+                try {
+                    const stats = await fs.stat(filePath);
+                    if (stats.size < 100000) {
+                        this.logger.warning(`Corrupt ${file.name} detected (${stats.size} bytes), removing...`);
+                        await fs.remove(filePath);
+                    } else {
+                        const buffer = await fs.readFile(filePath);
+                        if (buffer[0] !== 0x50 || buffer[1] !== 0x4B) {
+                            this.logger.warning(`Invalid ZIP header in ${file.name}, removing...`);
+                            await fs.remove(filePath);
+                        } else {
+                            this.logger.info(`${file.name} is valid, keeping it`);
+                        }
+                    }
+                } catch (error) {
+                    this.logger.warning(`Error checking ${file.name}, removing...`);
+                    await fs.remove(filePath);
+                }
+            }
+        }
+    }
+
+    private async downloadFile(url: string, destPath: string, fileName: string): Promise<void> {
+        this.logger.info(`Downloading ${fileName}...`);
+
+        try {
+            const response = await axios({
+                method: 'GET',
+                url: url,
+                responseType: 'stream',
+                timeout: 60000,
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+                }
+            });
+
+            const writer = fs.createWriteStream(destPath);
+            response.data.pipe(writer);
+
+            await new Promise<void>((resolve, reject) => {
+                writer.on('finish', () => resolve());
+                writer.on('error', (err) => reject(err));
+            });
+
+            const stats = await fs.stat(destPath);
+            if (stats.size < 100000) {
+                throw new Error(`Downloaded file too small: ${stats.size} bytes`);
+            }
+
+            const buffer = await fs.readFile(destPath);
+            if (buffer[0] !== 0x50 || buffer[1] !== 0x4B) {
+                throw new Error('Invalid ZIP header');
+            }
+
+            this.logger.success(`Downloaded: ${fileName} (${(stats.size / 1024 / 1024).toFixed(2)} MB)`);
+
+        } catch (error) {
+            this.logger.error(`Failed to download ${fileName}:`, error);
+            throw error;
+        }
+    }
+
+    private async downloadViaVersion(pluginsDir: string): Promise<void> {
+        const destPath = path.join(pluginsDir, 'ViaVersion.jar');
+        
+        if (await FileUtils.fileExists(destPath)) {
+            await fs.remove(destPath);
+        }
+
+        await this.downloadFile(this.VIAVERSION_URL, destPath, 'ViaVersion.jar');
+    }
+
+    private async downloadViaBackwards(pluginsDir: string): Promise<void> {
+        const destPath = path.join(pluginsDir, 'ViaBackwards.jar');
+        
+        if (await FileUtils.fileExists(destPath)) {
+            await fs.remove(destPath);
+        }
+
+        await this.downloadFile(this.VIABACKWARDS_URL, destPath, 'ViaBackwards.jar');
+    }
+
+    private async downloadViaRewind(pluginsDir: string): Promise<void> {
+        const destPath = path.join(pluginsDir, 'ViaRewind.jar');
+        
+        if (await FileUtils.fileExists(destPath)) {
+            await fs.remove(destPath);
+        }
+
+        await this.downloadFile(this.VIAREWIND_URL, destPath, 'ViaRewind.jar');
+    }
+
+    private async verifyAllPlugins(pluginsDir: string): Promise<void> {
+        const files = ['ViaVersion.jar', 'ViaBackwards.jar', 'ViaRewind.jar'];
+        let allValid = true;
+
+        for (const file of files) {
+            const filePath = path.join(pluginsDir, file);
+            
+            if (!await FileUtils.fileExists(filePath)) {
+                this.logger.error(`${file} is missing!`);
+                allValid = false;
+                continue;
+            }
+
+            try {
+                const stats = await fs.stat(filePath);
+                if (stats.size < 100000) {
+                    this.logger.error(`${file} is too small: ${stats.size} bytes`);
+                    allValid = false;
+                    continue;
+                }
+
+                const buffer = await fs.readFile(filePath);
+                if (buffer[0] !== 0x50 || buffer[1] !== 0x4B) {
+                    this.logger.error(`${file} has invalid ZIP header`);
+                    allValid = false;
+                    continue;
+                }
+
+                this.logger.debug(`${file} verified OK (${(stats.size / 1024 / 1024).toFixed(2)} MB)`);
+            } catch (error) {
+                this.logger.error(`Failed to verify ${file}:`, error);
+                allValid = false;
+            }
+        }
+
+        if (!allValid) {
+            throw new Error('Some ViaVersion plugins are corrupt or missing');
+        }
+    }
+
+    public async configureViaVersion(config: MinecraftConfig): Promise<void> {
+        const pluginsDir = config.folders.plugins;
+        const viaConfigDir = path.join(pluginsDir, 'ViaVersion');
+        await FileUtils.ensureDir(viaConfigDir);
+
+        const configFile = path.join(viaConfigDir, 'config.yml');
+        
+        const configContent = `# ViaVersion Configuration
+# Auto-generated by mc-headless
+
+enable-client-side-block-updates: true
+prevent-collision: true
+auto-team: true
+suppress-metadata-errors: false
+enable-legacy-server-ping: true
+block-connection-method: true
+nms-player-ticking: true
+debug: false
+max-pps: 800
+max-pp-interval: 4
+fix-self-rendering: true
+fix-low-level-collision: true
+shield-blocking: true
+fix-infested-block-breaking: true
+ignore-long-1_16-channel: true
+force-json-transform: false
+use-natives: true
+`;
+        
+        await FileUtils.writeFile(configFile, configContent);
+        this.logger.debug('ViaVersion configuration created');
+    }
+}