@dimzxzzx07/mc-headless 1.6.0 → 1.7.0

package/src/platforms/ViaVersion.ts

@@ -3,192 +3,179 @@ 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;
-    build: number;
     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 getLatestViaVersionInfo(): Promise<ViaVersionInfo> {
-        try {
-            const response = await axios.get('https://api.github.com/repos/ViaVersion/ViaVersion/releases/latest');
-            const tag = response.data.tag_name;
-            const version = tag.replace('v', '');
-            
-            return {
-                version: version,
-                build: 0,
-                downloadUrl: response.data.assets[0].browser_download_url
-            };
-        } catch (error) {
-            this.logger.error('Failed to get ViaVersion info from GitHub, using fallback URL');
-            return {
-                version: '4.9.0',
-                build: 0,
-                downloadUrl: 'https://github.com/ViaVersion/ViaVersion/releases/download/v4.9.0/ViaVersion-4.9.0.jar'
-            };
-        }
-    }
+    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 }
+        ];
 
-    private async getLatestViaBackwardsInfo(): Promise<ViaVersionInfo> {
-        try {
-            const response = await axios.get('https://api.github.com/repos/ViaVersion/ViaBackwards/releases/latest');
-            const tag = response.data.tag_name;
-            const version = tag.replace('v', '');
+        for (const file of files) {
+            const filePath = path.join(pluginsDir, file.name);
             
-            return {
-                version: version,
-                build: 0,
-                downloadUrl: response.data.assets[0].browser_download_url
-            };
-        } catch (error) {
-            this.logger.error('Failed to get ViaBackwards info from GitHub, using fallback URL');
-            return {
-                version: '4.9.0',
-                build: 0,
-                downloadUrl: 'https://github.com/ViaVersion/ViaBackwards/releases/download/v4.9.0/ViaBackwards-4.9.0.jar'
-            };
+            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 getLatestViaRewindInfo(): Promise<ViaVersionInfo> {
-        try {
-            const response = await axios.get('https://api.github.com/repos/ViaVersion/ViaRewind/releases/latest');
-            const tag = response.data.tag_name;
-            const version = tag.replace('v', '');
-            
-            return {
-                version: version,
-                build: 0,
-                downloadUrl: response.data.assets[0].browser_download_url
-            };
-        } catch (error) {
-            this.logger.error('Failed to get ViaRewind info from GitHub, using fallback URL');
-            return {
-                version: '3.0.0',
-                build: 0,
-                downloadUrl: 'https://github.com/ViaVersion/ViaRewind/releases/download/v3.0.0/ViaRewind-3.0.0.jar'
-            };
-        }
-    }
+    private async downloadFile(url: string, destPath: string, fileName: string): Promise<void> {
+        this.logger.info(`Downloading ${fileName}...`);
 
-    private async downloadViaVersion(pluginsDir: string): Promise<void> {
-        const viaVersionJar = path.join(pluginsDir, 'ViaVersion.jar');
-        
-        if (await FileUtils.fileExists(viaVersionJar)) {
-            this.logger.info('ViaVersion already exists, skipping download');
-            return;
-        }
-
-        this.logger.info('Downloading ViaVersion...');
-        
         try {
-            const info = await this.getLatestViaVersionInfo();
-            
             const response = await axios({
                 method: 'GET',
-                url: info.downloadUrl,
-                responseType: 'stream'
+                url: url,
+                responseType: 'stream',
+                timeout: 60000,
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+                }
             });
 
-            const writer = require('fs').createWriteStream(viaVersionJar);
+            const writer = fs.createWriteStream(destPath);
             response.data.pipe(writer);
 
-            await new Promise((resolve, reject) => {
-                writer.on('finish', resolve);
-                writer.on('error', reject);
+            await new Promise<void>((resolve, reject) => {
+                writer.on('finish', () => resolve());
+                writer.on('error', (err) => reject(err));
             });
 
-            this.logger.success(`ViaVersion ${info.version} downloaded`);
+            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 ViaVersion', error);
+            this.logger.error(`Failed to download ${fileName}:`, error);
             throw error;
         }
     }
 
-    private async downloadViaBackwards(pluginsDir: string): Promise<void> {
-        const viaBackwardsJar = path.join(pluginsDir, 'ViaBackwards.jar');
+    private async downloadViaVersion(pluginsDir: string): Promise<void> {
+        const destPath = path.join(pluginsDir, 'ViaVersion.jar');
         
-        if (await FileUtils.fileExists(viaBackwardsJar)) {
-            this.logger.info('ViaBackwards already exists, skipping download');
-            return;
+        if (await FileUtils.fileExists(destPath)) {
+            await fs.remove(destPath);
         }
 
-        this.logger.info('Downloading ViaBackwards...');
-        
-        try {
-            const info = await this.getLatestViaBackwardsInfo();
-            
-            const response = await axios({
-                method: 'GET',
-                url: info.downloadUrl,
-                responseType: 'stream'
-            });
-
-            const writer = require('fs').createWriteStream(viaBackwardsJar);
-            response.data.pipe(writer);
-
-            await new Promise((resolve, reject) => {
-                writer.on('finish', resolve);
-                writer.on('error', reject);
-            });
+        await this.downloadFile(this.VIAVERSION_URL, destPath, 'ViaVersion.jar');
+    }
 
-            this.logger.success(`ViaBackwards ${info.version} downloaded`);
-        } catch (error) {
-            this.logger.error('Failed to download ViaBackwards', error);
-            throw error;
+    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 viaRewindJar = path.join(pluginsDir, 'ViaRewind.jar');
+        const destPath = path.join(pluginsDir, 'ViaRewind.jar');
         
-        if (await FileUtils.fileExists(viaRewindJar)) {
-            this.logger.info('ViaRewind already exists, skipping download');
-            return;
+        if (await FileUtils.fileExists(destPath)) {
+            await fs.remove(destPath);
         }
 
-        this.logger.info('Downloading ViaRewind...');
-        
-        try {
-            const info = await this.getLatestViaRewindInfo();
-            
-            const response = await axios({
-                method: 'GET',
-                url: info.downloadUrl,
-                responseType: 'stream'
-            });
+        await this.downloadFile(this.VIAREWIND_URL, destPath, 'ViaRewind.jar');
+    }
 
-            const writer = require('fs').createWriteStream(viaRewindJar);
-            response.data.pipe(writer);
+    private async verifyAllPlugins(pluginsDir: string): Promise<void> {
+        const files = ['ViaVersion.jar', 'ViaBackwards.jar', 'ViaRewind.jar'];
+        let allValid = true;
 
-            await new Promise((resolve, reject) => {
-                writer.on('finish', resolve);
-                writer.on('error', reject);
-            });
+        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;
+            }
+        }
 
-            this.logger.success(`ViaRewind ${info.version} downloaded`);
-        } catch (error) {
-            this.logger.error('Failed to download ViaRewind', error);
-            throw error;
+        if (!allValid) {
+            throw new Error('Some ViaVersion plugins are corrupt or missing');
         }
     }
 
@@ -202,25 +189,23 @@ export class ViaVersionManager {
         const configContent = `# ViaVersion Configuration
 # Auto-generated by mc-headless
 
-# Allow older clients to connect
 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
-
-# Protocol support
 nms-player-ticking: true
 debug: false
 max-pps: 800
 max-pp-interval: 4
-
-# Version-specific fixes
 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);