@dimzxzzx07/mc-headless 2.2.1 → 2.2.3

package/src/core/JavaChecker.ts

@@ -3,8 +3,8 @@ import * as fs from 'fs-extra';
 import * as path from 'path';
 import * as https from 'https';
 import * as http from 'http';
+import * as os from 'os';
 import * as tar from 'tar';
-import { Logger } from '../utils/Logger';
 
 export interface JavaInfo {
     path: string;
@@ -13,21 +13,67 @@ export interface JavaInfo {
 }
 
 export class JavaChecker {
-    private static logger = Logger.getInstance();
-    private static readonly JAVA_DIR = path.join(process.cwd(), '.java');
+    private static readonly JAVA_DIR = JavaChecker.getOptimalJavaDirectory();
     
-    // Hanya pakai URL yang reliable dan direct download
     private static readonly JAVA_URLS = {
-        '21': [
-            'https://github.com/adoptium/temurin21-binaries/releases/download/jdk-21.0.2%2B13/OpenJDK21U-jdk_x64_linux_hotspot_21.0.2_13.tar.gz',
-            'https://corretto.aws/downloads/latest/amazon-corretto-21-x64-linux-jre.tar.gz'
-        ],
-        '17': [
-            'https://github.com/adoptium/temurin17-binaries/releases/download/jdk-17.0.10%2B7/OpenJDK17U-jdk_x64_linux_hotspot_17.0.10_7.tar.gz',
-            'https://corretto.aws/downloads/latest/amazon-corretto-17-x64-linux-jre.tar.gz'
-        ]
+        '21': {
+            'x64': [
+                'https://github.com/adoptium/temurin21-binaries/releases/download/jdk-21.0.2%2B13/OpenJDK21U-jre_x64_linux_hotspot_21.0.2_13.tar.gz',
+                'https://corretto.aws/downloads/latest/amazon-corretto-21-x64-linux-jre.tar.gz',
+                'https://download.bell-sw.com/java/21.0.2+13/bellsoft-jre21.0.2+13-linux-amd64.tar.gz'
+            ],
+            'arm64': [
+                'https://github.com/adoptium/temurin21-binaries/releases/download/jdk-21.0.2%2B13/OpenJDK21U-jre_aarch64_linux_hotspot_21.0.2_13.tar.gz',
+                'https://corretto.aws/downloads/latest/amazon-corretto-21-aarch64-linux-jre.tar.gz',
+                'https://download.bell-sw.com/java/21.0.2+13/bellsoft-jre21.0.2+13-linux-aarch64.tar.gz'
+            ],
+            'arm': [
+                'https://github.com/adoptium/temurin21-binaries/releases/download/jdk-21.0.2%2B13/OpenJDK21U-jre_arm_linux_hotspot_21.0.2_13.tar.gz'
+            ]
+        },
+        '17': {
+            'x64': [
+                'https://github.com/adoptium/temurin17-binaries/releases/download/jdk-17.0.10%2B7/OpenJDK17U-jre_x64_linux_hotspot_17.0.10_7.tar.gz',
+                'https://corretto.aws/downloads/latest/amazon-corretto-17-x64-linux-jre.tar.gz',
+                'https://download.bell-sw.com/java/17.0.10+13/bellsoft-jre17.0.10+13-linux-amd64.tar.gz'
+            ],
+            'arm64': [
+                'https://github.com/adoptium/temurin17-binaries/releases/download/jdk-17.0.10%2B7/OpenJDK17U-jre_aarch64_linux_hotspot_17.0.10_7.tar.gz',
+                'https://corretto.aws/downloads/latest/amazon-corretto-17-aarch64-linux-jre.tar.gz',
+                'https://download.bell-sw.com/java/17.0.10+13/bellsoft-jre17.0.10+13-linux-aarch64.tar.gz'
+            ],
+            'arm': [
+                'https://github.com/adoptium/temurin17-binaries/releases/download/jdk-17.0.10%2B7/OpenJDK17U-jre_arm_linux_hotspot_17.0.10_7.tar.gz'
+            ]
+        }
     };
 
+    private static getOptimalJavaDirectory(): string {
+        const pterodactylDir = '/home/container/.java';
+        const tmpDir = '/tmp/.mc-headless';
+        
+        try {
+            if (fs.existsSync('/home/container')) {
+                return pterodactylDir;
+            }
+        } catch {
+        }
+        
+        const totalRamGB = os.totalmem() / 1024 / 1024 / 1024;
+        if (totalRamGB < 3) {
+            console.warn(`Warning: Low RAM (${totalRamGB.toFixed(1)} GB). Java in /tmp may cause issues.`);
+        }
+        
+        return tmpDir;
+    }
+
+    private static getArch(): 'x64' | 'arm64' | 'arm' {
+        const arch = process.arch;
+        if (arch === 'arm64') return 'arm64';
+        if (arch === 'arm') return 'arm';
+        return 'x64';
+    }
+
     public static getRequiredJavaVersion(serverVersion: string): '17' | '21' {
         if (serverVersion.startsWith('1.21') || serverVersion === '1.21.11') {
             return '21';
@@ -42,11 +88,8 @@ export class JavaChecker {
         return new Promise((resolve) => {
             exec('which java', (error, stdout) => {
                 if (error || !stdout.trim()) {
-                    this.logger.warning('Java is not installed in system');
                     resolve(false);
                 } else {
-                    const javaPath = stdout.trim();
-                    this.logger.success(`System Java found at: ${javaPath}`);
                     resolve(true);
                 }
             });
@@ -65,95 +108,166 @@ export class JavaChecker {
     public static getSystemJavaVersion(): string | null {
         try {
             const output = execSync('java -version 2>&1').toString();
-            if (output.includes('version "21')) return '21';
-            if (output.includes('version "17')) return '17';
-            if (output.includes('version "11')) return '11';
-            if (output.includes('version "1.8')) return '8';
-            const match = output.match(/version "([^"]+)"/);
-            return match ? match[1] : null;
+            
+            const versionRegex = /(?:version|openjdk|java)[\s"]+(\d+)(?:\.(\d+))?/i;
+            const match = output.match(versionRegex);
+            
+            if (match) {
+                const majorVersion = parseInt(match[1]);
+                if (majorVersion === 21) return '21';
+                if (majorVersion === 17) return '17';
+                if (majorVersion === 11) return '11';
+                if (majorVersion === 8) return '8';
+                if (majorVersion === 1 && match[2] === '8') return '8';
+            }
+            
+            if (output.includes('version "21') || output.includes('openjdk 21')) return '21';
+            if (output.includes('version "17') || output.includes('openjdk 17')) return '17';
+            if (output.includes('version "11') || output.includes('openjdk 11')) return '11';
+            if (output.includes('version "1.8') || output.includes('openjdk 1.8')) return '8';
+            
+            return null;
         } catch {
             return null;
         }
     }
 
-    private static async downloadWithNode(url: string, destPath: string): Promise<void> {
+    private static shouldUpdateJava(javaHome: string): boolean {
+        try {
+            const stats = fs.statSync(javaHome);
+            const ageInDays = (Date.now() - stats.mtimeMs) / (1000 * 60 * 60 * 24);
+            return ageInDays > 30;
+        } catch {
+            return true;
+        }
+    }
+
+    private static async downloadAndExtractWithStream(url: string, javaHome: string, retryCount = 0): Promise<void> {
+        const maxRetries = 3;
+        const userAgents = [
+            'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36'
+        ];
+
         return new Promise((resolve, reject) => {
-            this.logger.info(`Downloading Java from ${url}`);
+            console.log(`Downloading Java...`);
             
             const protocol = url.startsWith('https') ? https : http;
             
+            let isDone = false;
+            let cleanup = () => {
+                if (!isDone) {
+                    isDone = true;
+                    fs.remove(javaHome).catch(() => {});
+                }
+            };
+
             const request = protocol.get(url, {
                 headers: {
-                    'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36'
+                    'User-Agent': userAgents[retryCount % userAgents.length],
+                    'Accept': 'application/octet-stream',
+                    'Accept-Encoding': 'gzip, deflate'
                 }
             }, (response) => {
                 if (response.statusCode === 301 || response.statusCode === 302 || response.statusCode === 307 || response.statusCode === 308) {
                     const location = response.headers.location;
-                    if (location) {
-                        this.logger.info(`Redirecting to ${location}`);
-                        this.downloadWithNode(location, destPath).then(resolve).catch(reject);
-                        return;
+                    if (location && retryCount < maxRetries) {
+                        this.downloadAndExtractWithStream(location, javaHome, retryCount + 1).then(resolve).catch(reject);
+                    } else {
+                        cleanup();
+                        reject(new Error('Redirect failed'));
                     }
+                    return;
                 }
 
                 if (response.statusCode !== 200) {
-                    reject(new Error(`Download failed: ${response.statusCode}`));
+                    if (response.statusCode === 429 && retryCount < maxRetries) {
+                        setTimeout(() => {
+                            this.downloadAndExtractWithStream(url, javaHome, retryCount + 1).then(resolve).catch(reject);
+                        }, 10000);
+                    } else if (response.statusCode && response.statusCode >= 500 && retryCount < maxRetries) {
+                        setTimeout(() => {
+                            this.downloadAndExtractWithStream(url, javaHome, retryCount + 1).then(resolve).catch(reject);
+                        }, 10000);
+                    } else {
+                        cleanup();
+                        reject(new Error(`Download failed: ${response.statusCode}`));
+                    }
                     return;
                 }
 
-                const contentType = response.headers['content-type'];
-                if (contentType && contentType.includes('text/html')) {
-                    reject(new Error('Received HTML instead of binary - likely license redirect'));
-                    return;
-                }
+                const contentLength = response.headers['content-length'];
+                let downloadedBytes = 0;
 
-                const file = fs.createWriteStream(destPath);
-                const totalSize = parseInt(response.headers['content-length'] || '0');
-                let downloadedSize = 0;
-                let lastPercent = 0;
+                fs.ensureDirSync(javaHome);
 
-                response.on('data', (chunk) => {
-                    downloadedSize += chunk.length;
-                    if (totalSize > 0) {
-                        const percent = ((downloadedSize / totalSize) * 100).toFixed(1);
-                        if (parseFloat(percent) >= lastPercent + 5 || parseFloat(percent) >= 100) {
-                            lastPercent = parseFloat(percent);
-                            process.stdout.write(`\rDownloading Java: ${percent}% (${(downloadedSize / 1024 / 1024).toFixed(1)} MB)`);
-                        }
-                    }
+                const extractor = tar.extract({
+                    cwd: javaHome,
+                    strip: 1
                 });
 
-                response.pipe(file);
+                let extractError: Error | null = null;
 
-                file.on('finish', () => {
-                    process.stdout.write('\n');
-                    file.close();
-                    
-                    const stats = fs.statSync(destPath);
-                    if (stats.size < 1000000) {
-                        fs.unlinkSync(destPath);
-                        reject(new Error(`Downloaded file too small: ${stats.size} bytes - possibly HTML page`));
-                        return;
+                extractor.on('finish', () => {
+                    if (!isDone) {
+                        isDone = true;
+                        resolve();
                     }
-                    
-                    resolve();
                 });
 
-                file.on('error', (err) => {
-                    fs.unlink(destPath).catch(() => {});
+                extractor.on('error', (err) => {
+                    extractError = err;
+                    cleanup();
                     reject(err);
                 });
+
+                response.on('data', (chunk) => {
+                    downloadedBytes += chunk.length;
+                });
+
+                response.on('error', (err) => {
+                    extractor.end();
+                    cleanup();
+                    reject(err);
+                });
+
+                response.on('end', () => {
+                    if (contentLength) {
+                        const expected = parseInt(contentLength);
+                        if (downloadedBytes < expected * 0.95) {
+                            cleanup();
+                            reject(new Error(`Download incomplete: ${downloadedBytes} of ${expected} bytes`));
+                            return;
+                        }
+                    }
+                    
+                    extractor.on('finish', () => {
+                        if (!isDone && !extractError) {
+                            isDone = true;
+                            resolve();
+                        }
+                    });
+                });
+
+                response.pipe(extractor);
             });
 
             request.on('error', (err) => {
-                fs.unlink(destPath).catch(() => {});
-                reject(err);
+                if (retryCount < maxRetries) {
+                    setTimeout(() => {
+                        this.downloadAndExtractWithStream(url, javaHome, retryCount + 1).then(resolve).catch(reject);
+                    }, 5000);
+                } else {
+                    cleanup();
+                    reject(err);
+                }
             });
 
             request.setTimeout(300000, () => {
                 request.destroy();
-                fs.unlink(destPath).catch(() => {});
-                reject(new Error('Download timeout after 5 minutes'));
+                cleanup();
+                reject(new Error('Download timeout'));
             });
 
             request.end();
@@ -163,55 +277,50 @@ export class JavaChecker {
     public static async getOrDownloadPortableJava(version: '17' | '21'): Promise<JavaInfo> {
         await fs.ensureDir(this.JAVA_DIR);
         
-        const javaHome = path.join(this.JAVA_DIR, `jre-${version}`);
+        const arch = this.getArch();
+        const javaHome = path.join(this.JAVA_DIR, `jre-${version}-${arch}`);
         const javaBin = path.join(javaHome, 'bin', 'java');
         
         if (await fs.pathExists(javaBin)) {
-            this.logger.info(`Portable Java ${version} already exists at ${javaBin}`);
-            
-            try {
-                const versionOutput = execSync(`"${javaBin}" -version 2>&1`).toString();
-                this.logger.debug(`Portable Java version: ${versionOutput.split('\n')[0]}`);
+            if (!this.shouldUpdateJava(javaHome)) {
                 return {
                     path: javaBin,
                     version: version,
                     type: 'portable'
                 };
-            } catch (error) {
-                this.logger.warning(`Existing Java seems corrupted, re-downloading...`);
-                await fs.remove(javaHome);
             }
+            console.log('Java update available, downloading latest...');
+            await fs.remove(javaHome);
+        }
+
+        const archUrls = this.JAVA_URLS[version]?.[arch];
+        if (!archUrls || archUrls.length === 0) {
+            throw new Error(`No Java download for ${version} on ${arch}`);
         }
 
-        const urls = this.JAVA_URLS[version] || this.JAVA_URLS['21'];
         let lastError: Error | null = null;
 
-        for (let i = 0; i < urls.length; i++) {
-            const url = urls[i];
-            const tarPath = path.join(this.JAVA_DIR, `jre-${version}-${Date.now()}.tar.gz`);
+        for (let i = 0; i < archUrls.length; i++) {
+            const url = archUrls[i];
             
             try {
-                this.logger.info(`Downloading portable Java ${version} (attempt ${i + 1}/${urls.length})...`);
-                this.logger.info(`URL: ${url}`);
-                
-                await this.downloadWithNode(url, tarPath);
-                
-                this.logger.info(`Extracting Java ${version}...`);
+                await fs.remove(javaHome);
                 await fs.ensureDir(javaHome);
-                await tar.extract({
-                    file: tarPath,
-                    cwd: javaHome,
-                    strip: 1
-                });
                 
-                await fs.remove(tarPath);
+                await this.downloadAndExtractWithStream(url, javaHome);
                 
-                await fs.chmod(javaBin, 0o755);
+                if (!await fs.pathExists(javaBin)) {
+                    throw new Error('Java binary not found after extraction');
+                }
                 
-                this.logger.success(`Portable Java ${version} installed at ${javaBin}`);
+                await fs.chmod(javaBin, 0o755);
                 
-                const versionOutput = execSync(`"${javaBin}" -version 2>&1`).toString();
-                this.logger.debug(`Portable Java version: ${versionOutput.split('\n')[0]}`);
+                try {
+                    execSync(`"${javaBin}" -version 2>&1`);
+                } catch {
+                    await fs.remove(javaHome);
+                    throw new Error('Java verification failed');
+                }
 
                 return {
                     path: javaBin,
@@ -221,55 +330,62 @@ export class JavaChecker {
                 
             } catch (error) {
                 lastError = error instanceof Error ? error : new Error(String(error));
-                this.logger.warning(`Attempt ${i + 1} failed: ${lastError.message}`);
-                await fs.remove(tarPath).catch(() => {});
+                console.log(`Download attempt ${i + 1} failed, trying next source...`);
+                await fs.remove(javaHome).catch(() => {});
             }
         }
 
-        throw new Error(`Failed to download Java ${version} after ${urls.length} attempts. Last error: ${lastError?.message}`);
+        throw new Error(`Failed to download Java: ${lastError?.message}`);
     }
 
     public static async ensureJava(serverVersion: string, usePortable: boolean = true): Promise<JavaInfo> {
         const requiredVersion = this.getRequiredJavaVersion(serverVersion);
-        this.logger.info(`Server requires Java ${requiredVersion}`);
         
         if (!usePortable) {
             const systemJava = this.getSystemJavaPath();
             if (systemJava) {
                 const systemVersion = this.getSystemJavaVersion();
                 if (systemVersion === requiredVersion) {
-                    this.logger.success(`Using system Java ${systemVersion} at ${systemJava}`);
                     return {
                         path: systemJava,
                         version: systemVersion,
                         type: 'system'
                     };
-                } else {
-                    this.logger.warning(`System Java is ${systemVersion}, but server needs Java ${requiredVersion}`);
                 }
             }
         }
         
-        this.logger.info(`Downloading portable Java ${requiredVersion}...`);
         return this.getOrDownloadPortableJava(requiredVersion);
     }
 
     public static cleanupOldJava(): void {
         try {
+            if (!fs.existsSync(this.JAVA_DIR)) return;
+            
             const files = fs.readdirSync(this.JAVA_DIR);
             const now = Date.now();
             const oneDay = 24 * 60 * 60 * 1000;
 
             files.forEach(file => {
                 const filePath = path.join(this.JAVA_DIR, file);
-                const stats = fs.statSync(filePath);
-                if (now - stats.mtimeMs > oneDay) {
-                    fs.removeSync(filePath);
-                    this.logger.debug(`Cleaned up old Java: ${file}`);
+                try {
+                    const stats = fs.statSync(filePath);
+                    if (now - stats.mtimeMs > oneDay) {
+                        if (stats.isDirectory()) {
+                            fs.removeSync(filePath);
+                        }
+                    }
+                } catch {
                 }
             });
-        } catch (error) {
-            this.logger.debug('No old Java to cleanup');
+        } catch {
         }
     }
+
+    public static getJavaInfo(): { dir: string; arch: string } {
+        return {
+            dir: this.JAVA_DIR,
+            arch: this.getArch()
+        };
+    }
 }