@dimzxzzx07/mc-headless 1.8.0 → 1.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dimzxzzx07/mc-headless",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "Minecraft Headless Server Manager - Run Java/Bedrock/Crossplay servers easily via Node.js",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/core/JavaChecker.ts

@@ -1,25 +1,49 @@
 import { execSync, exec } from 'child_process';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import * as https from 'https';
+import * as tar from 'tar';
 import { Logger } from '../utils/Logger';
-import { SystemDetector } from '../utils/SystemDetector';
+
+export interface JavaInfo {
+    path: string;
+    version: string;
+    type: 'system' | 'portable';
+}
 
 export class JavaChecker {
     private static logger = Logger.getInstance();
+    private static readonly JAVA_DIR = path.join('/tmp', '.mc-headless-java');
+    private static readonly JAVA_17_URL = 'https://github.com/adoptium/temurin17-binaries/releases/download/jdk-17.0.10%2B7/OpenJDK17U-jre_x64_linux_hotspot_17.0.10_7.tar.gz';
+    private static readonly JAVA_21_URL = 'https://github.com/adoptium/temurin21-binaries/releases/download/jdk-21.0.2%2B13/OpenJDK21U-jre_x64_linux_hotspot_21.0.2_13.tar.gz';
+    private static readonly JAVA_11_URL = 'https://github.com/adoptium/temurin11-binaries/releases/download/jdk-11.0.22%2B7/OpenJDK11U-jre_x64_linux_hotspot_11.0.22_7.tar.gz';
+    private static readonly JAVA_8_URL = 'https://github.com/adoptium/temurin8-binaries/releases/download/jdk8u402-b06/OpenJDK8U-jre_x64_linux_hotspot_8u402b06.tar.gz';
 
-    public static checkJava(): Promise<boolean> {
+    public static async checkJava(): Promise<boolean> {
         return new Promise((resolve) => {
-            exec('java -version', (error) => {
-                if (error) {
-                    this.logger.warning('Java is not installed');
+            exec('which java', (error, stdout) => {
+                if (error || !stdout.trim()) {
+                    this.logger.warning('Java is not installed in system');
                     resolve(false);
                 } else {
-                    this.logger.success('Java is installed');
+                    const javaPath = stdout.trim();
+                    this.logger.success(`System Java found at: ${javaPath}`);
                     resolve(true);
                 }
             });
         });
     }
 
-    public static getJavaVersion(): string | null {
+    public static getSystemJavaPath(): string | null {
+        try {
+            const stdout = execSync('which java').toString().trim();
+            return stdout || null;
+        } catch {
+            return null;
+        }
+    }
+
+    public static getSystemJavaVersion(): string | null {
         try {
             const output = execSync('java -version 2>&1').toString();
             if (output.includes('version "21')) return '21';
@@ -33,74 +57,151 @@ export class JavaChecker {
         }
     }
 
-    public static async ensureJava(version: '17' | '21' | 'auto' = 'auto'): Promise<void> {
-        const hasJava = await this.checkJava();
+    public static async getOrDownloadPortableJava(version: '17' | '21' | '11' | '8' = '17'): Promise<JavaInfo> {
+        await fs.ensureDir(this.JAVA_DIR);
+        
+        const javaHome = path.join(this.JAVA_DIR, `jre-${version}`);
+        const javaBin = path.join(javaHome, 'bin', 'java');
         
-        if (!hasJava) {
-            this.logger.warning('Java not found. Attempting to install...');
-            await this.installJava(version);
-            return;
+        if (await fs.pathExists(javaBin)) {
+            this.logger.info(`Portable Java ${version} already exists at ${javaBin}`);
+            
+            const versionOutput = execSync(`"${javaBin}" -version 2>&1`).toString();
+            this.logger.debug(`Portable Java version: ${versionOutput.split('\n')[0]}`);
+            
+            return {
+                path: javaBin,
+                version: version,
+                type: 'portable'
+            };
         }
 
-        const currentVersion = this.getJavaVersion();
-        this.logger.info(`Detected Java version: ${currentVersion}`);
-
-        if (version !== 'auto' && currentVersion !== version) {
-            this.logger.warning(`This server recommends Java ${version} but found ${currentVersion}. This may cause issues.`);
+        this.logger.info(`Downloading portable Java ${version} JRE...`);
+        
+        let downloadUrl = '';
+        switch (version) {
+            case '21':
+                downloadUrl = this.JAVA_21_URL;
+                break;
+            case '17':
+                downloadUrl = this.JAVA_17_URL;
+                break;
+            case '11':
+                downloadUrl = this.JAVA_11_URL;
+                break;
+            case '8':
+                downloadUrl = this.JAVA_8_URL;
+                break;
+            default:
+                downloadUrl = this.JAVA_17_URL;
         }
 
-        if (currentVersion === '8' || currentVersion === '11') {
-            this.logger.warning(`Java ${currentVersion} is outdated. Minecraft 1.21+ works best with Java 17 or 21.`);
-        }
+        const tarPath = path.join(this.JAVA_DIR, `jre-${version}.tar.gz`);
+        
+        await this.downloadFile(downloadUrl, tarPath);
+        
+        this.logger.info(`Extracting Java ${version}...`);
+        await fs.ensureDir(javaHome);
+        await tar.extract({
+            file: tarPath,
+            cwd: javaHome,
+            strip: 1
+        });
+        
+        await fs.remove(tarPath);
+        
+        await fs.chmod(javaBin, 0o755);
+        
+        this.logger.success(`Portable Java ${version} installed at ${javaBin}`);
+        
+        const versionOutput = execSync(`"${javaBin}" -version 2>&1`).toString();
+        this.logger.debug(`Portable Java version: ${versionOutput.split('\n')[0]}`);
+
+        return {
+            path: javaBin,
+            version: version,
+            type: 'portable'
+        };
     }
 
-    public static async installJava(version: '17' | '21' | 'auto' = 'auto'): Promise<void> {
-        const osType = SystemDetector.getOS();
-        const distro = SystemDetector.getDistro();
-        const targetVersion = version === 'auto' ? '17' : version;
+    private static downloadFile(url: string, destPath: string): Promise<void> {
+        return new Promise((resolve, reject) => {
+            this.logger.info(`Downloading from ${url}`);
+            
+            const file = fs.createWriteStream(destPath);
+            https.get(url, (response) => {
+                if (response.statusCode !== 200) {
+                    reject(new Error(`Download failed: ${response.statusCode}`));
+                    return;
+                }
 
-        let command = '';
-        const javaPackage = targetVersion === '21' ? 'openjdk-21-jre-headless' : 'openjdk-17-jre-headless';
+                const totalSize = parseInt(response.headers['content-length'] || '0');
+                let downloadedSize = 0;
+
+                response.on('data', (chunk) => {
+                    downloadedSize += chunk.length;
+                    if (totalSize > 0) {
+                        const percent = ((downloadedSize / totalSize) * 100).toFixed(1);
+                        process.stdout.write(`\rDownloading Java: ${percent}% (${(downloadedSize / 1024 / 1024).toFixed(1)} MB / ${(totalSize / 1024 / 1024).toFixed(1)} MB)`);
+                    }
+                });
+
+                response.pipe(file);
+
+                file.on('finish', () => {
+                    process.stdout.write('\n');
+                    file.close();
+                    resolve();
+                });
+
+                file.on('error', (err) => {
+                    fs.unlink(destPath).catch(() => {});
+                    reject(err);
+                });
+            }).on('error', (err) => {
+                fs.unlink(destPath).catch(() => {});
+                reject(err);
+            });
+        });
+    }
+
+    public static async ensureJava(version: '17' | '21' | 'auto' = 'auto', usePortable: boolean = true): Promise<JavaInfo> {
+        const targetVersion = version === 'auto' ? '17' : version;
         
-        if (osType === 'linux' || osType === 'android') {
-            if (distro === 'ubuntu' || distro === 'debian') {
-                command = `apt update && apt install -y ${javaPackage}`;
-            } else if (distro === 'centos' || distro === 'fedora') {
-                command = `yum install -y java-${targetVersion}-openjdk-headless`;
-            } else if (distro === 'arch') {
-                const archPackage = targetVersion === '21' ? 'jre21-openjdk-headless' : 'jre17-openjdk-headless';
-                command = `pacman -S --noconfirm ${archPackage}`;
-            } else if (distro === 'termux') {
-                command = 'pkg install -y openjdk-17';
-            } else {
-                command = `curl -s https://raw.githubusercontent.com/Dimzxzzx07/mc-headless/main/scripts/install-java.sh | bash -s ${targetVersion}`;
+        if (!usePortable) {
+            const systemJava = this.getSystemJavaPath();
+            if (systemJava) {
+                const systemVersion = this.getSystemJavaVersion();
+                if (systemVersion === targetVersion || (targetVersion === '17' && systemVersion === '21')) {
+                    this.logger.success(`Using system Java ${systemVersion} at ${systemJava}`);
+                    return {
+                        path: systemJava,
+                        version: systemVersion || targetVersion,
+                        type: 'system'
+                    };
+                }
             }
-        } else if (osType === 'darwin') {
-            command = `brew install openjdk@${targetVersion}`;
-        } else {
-            this.logger.error('Automatic Java installation not supported on this OS');
-            throw new Error('Java not installed');
         }
+        
+        return this.getOrDownloadPortableJava(targetVersion as any);
+    }
 
-        this.logger.info(`Installing Java ${targetVersion} with: ${command}`);
+    public static cleanupOldJava(): void {
+        try {
+            const files = fs.readdirSync(this.JAVA_DIR);
+            const now = Date.now();
+            const oneDay = 24 * 60 * 60 * 1000;
 
-        return new Promise((resolve, reject) => {
-            const child = exec(command, (error) => {
-                if (error) {
-                    this.logger.error('Failed to install Java');
-                    reject(error);
-                } else {
-                    this.logger.success(`Java ${targetVersion} installed successfully`);
-                    resolve();
+            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}`);
                 }
             });
-
-            if (child.stdout) {
-                child.stdout.pipe(process.stdout);
-            }
-            if (child.stderr) {
-                child.stderr.pipe(process.stderr);
-            }
-        });
+        } catch (error) {
+            this.logger.debug('No old Java to cleanup');
+        }
     }
 }