@dimzxzzx07/mc-headless 2.2.2 → 2.2.3

package/src/platforms/ViaVersion.ts

@@ -4,12 +4,11 @@ import { Logger } from '../utils/Logger';
 import * as path from 'path';
 import axios from 'axios';
 import * as fs from 'fs-extra';
+import * as stream from 'stream';
+import * as util from 'util';
 
-export interface ViaVersionInfo {
-    version: string;
-    downloadUrl: string;
-    fileName: string;
-}
+const pipeline = util.promisify(stream.pipeline);
+const finished = util.promisify(stream.finished);
 
 export class ViaVersionManager {
     private logger = Logger.getInstance();
@@ -24,52 +23,38 @@ export class ViaVersionManager {
 
         this.logger.info('Setting up ViaVersion, ViaBackwards, ViaRewind...');
 
-        await this.cleanupCorruptFiles(pluginsDir);
-
+        await this.cleanupRemappedFolders(pluginsDir);
         await this.downloadViaVersion(pluginsDir);
+        
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        
         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`);
-                        }
+    private async cleanupRemappedFolders(pluginsDir: string): Promise<void> {
+        try {
+            const files = await fs.readdir(pluginsDir);
+            for (const file of files) {
+                if (file.includes('.paper-remapped')) {
+                    const remappedPath = path.join(pluginsDir, file);
+                    const stat = await fs.stat(remappedPath);
+                    if (stat.isDirectory()) {
+                        await fs.remove(remappedPath);
                     }
-                } catch (error) {
-                    this.logger.warning(`Error checking ${file.name}, removing...`);
-                    await fs.remove(filePath);
                 }
             }
+        } catch (error) {
         }
     }
 
     private async downloadFile(url: string, destPath: string, fileName: string): Promise<void> {
+        if (await FileUtils.fileExists(destPath)) {
+            await fs.remove(destPath);
+        }
+
         this.logger.info(`Downloading ${fileName}...`);
 
         try {
@@ -84,24 +69,16 @@ export class ViaVersionManager {
             });
 
             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));
-            });
+            
+            await pipeline(response.data, writer);
+            await finished(writer);
 
             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)`);
+            this.logger.success(`Downloaded ${fileName} (${(stats.size / 1024 / 1024).toFixed(2)} MB)`);
 
         } catch (error) {
             this.logger.error(`Failed to download ${fileName}:`, error);
@@ -111,74 +88,19 @@ export class ViaVersionManager {
 
     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');
@@ -187,8 +109,6 @@ export class ViaVersionManager {
         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
@@ -209,6 +129,5 @@ use-natives: true
 `;
         
         await FileUtils.writeFile(configFile, configContent);
-        this.logger.debug('ViaVersion configuration created');
     }
 }

package/src/types/index.ts

@@ -88,4 +88,210 @@ export interface Player {
     ip: string;
     ping: number;
     connectedAt: Date;
+}
+
+export interface JavaInfo {
+    path: string;
+    version: string;
+    type: 'system' | 'portable';
+}
+
+export interface GeyserConfig {
+    bedrock: {
+        port: number;
+        address: string;
+    };
+    remote: {
+        address: string;
+        port: number;
+        authType: string;
+    };
+    floodgateKeyFile: string;
+    passthroughMotd: boolean;
+    passthroughPlayerCounts: boolean;
+    passthroughProtocolName: boolean;
+}
+
+export interface ViaVersionConfig {
+    enableClientSideBlockUpdates: boolean;
+    preventCollision: boolean;
+    autoTeam: boolean;
+    suppressMetadataErrors: boolean;
+    enableLegacyServerPing: boolean;
+    blockConnectionMethod: boolean;
+    nmsPlayerTicking: boolean;
+    debug: boolean;
+    maxPps: number;
+    maxPpInterval: number;
+    fixSelfRendering: boolean;
+    fixLowLevelCollision: boolean;
+    shieldBlocking: boolean;
+    fixInfestedBlockBreaking: boolean;
+    ignoreLong1_16Channel: boolean;
+    forceJsonTransform: boolean;
+    useNatives: boolean;
+}
+
+export interface SkinRestorerConfig {
+    enabled: boolean;
+    updateSkins: boolean;
+    allowDefaultSkins: boolean;
+    allowCustomSkins: boolean;
+    allowThirdParty: boolean;
+    skinCacheSize: number;
+}
+
+export interface PluginInfo {
+    name: string;
+    version: string;
+    enabled: boolean;
+    main: string;
+    authors: string[];
+    website?: string;
+    description?: string;
+    depends?: string[];
+    softDepends?: string[];
+    loadBefore?: string[];
+}
+
+export interface WorldInfo {
+    name: string;
+    size: number;
+    players: number;
+    loadedChunks: number;
+    entities: number;
+    tiles: number;
+    seed: string;
+    difficulty: Difficulty;
+    gamemode: Gamemode;
+    hardcore: boolean;
+    spawn: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+
+export interface BackupOptions {
+    type: 'full' | 'world' | 'plugins' | 'config';
+    compression: 'none' | 'gzip' | 'zip';
+    includePlayerData: boolean;
+    maxBackups: number;
+    retentionDays: number;
+}
+
+export interface RamdiskConfig {
+    enabled: boolean;
+    world: boolean;
+    plugins: boolean;
+    addons: boolean;
+    backupInterval: number;
+    masterStorage: string;
+    size: string;
+    mountPoint: string;
+}
+
+export interface SymlinkConfig {
+    enabled: boolean;
+    masterPath: string;
+    worlds: boolean;
+    plugins: boolean;
+    addons: boolean;
+    mods: boolean;
+}
+
+export interface NetworkOptimizationConfig {
+    tcpFastOpen: boolean;
+    tcpNoDelay: boolean;
+    preferIPv4: boolean;
+    compressionThreshold: number;
+    bungeeMode: boolean;
+    proxyProtocol: boolean;
+    velocity?: {
+        enabled: boolean;
+        secret: string;
+        forwardingMode: 'legacy' | 'modern';
+    };
+}
+
+export interface MemoryMonitorConfig {
+    enabled: boolean;
+    threshold: number;
+    interval: number;
+    action: 'restart' | 'stop' | 'warn';
+    maxMemoryLeakRestarts: number;
+    gcOnWarning: boolean;
+}
+
+export interface OwnerConfig {
+    usernames: string[];
+    prefix: string;
+    enabled: boolean;
+    permissions: string[];
+}
+
+export interface PterodactylConfig {
+    autoDetect: boolean;
+    useSystemJava: boolean;
+    respectPortEnv: boolean;
+    respectMemoryEnv: boolean;
+    cleanupRemapped: boolean;
+    warnUdp: boolean;
+}
+
+export interface PluginManagerConfig {
+    autoUpdate: boolean;
+    verifyOnLoad: boolean;
+    cleanupCorrupt: boolean;
+    downloadDelay: number;
+    retryCount: number;
+    retryDelay: number;
+}
+
+export interface ViaVersionManagerConfig {
+    autoDownload: boolean;
+    autoUpdate: boolean;
+    configureAutomatically: boolean;
+    downloadDelay: number;
+    versions: {
+        viaversion: string;
+        viabackwards: string;
+        viarewind: string;
+    };
+}
+
+export interface SkinRestorerManagerConfig {
+    autoDownload: boolean;
+    autoUpdate: boolean;
+    configureAutomatically: boolean;
+    downloadUrl: string;
+}
+
+export interface MinecraftServerOptions extends Partial<MinecraftConfig> {
+    enableViaVersion?: boolean;
+    enableViaBackwards?: boolean;
+    enableViaRewind?: boolean;
+    enableSkinRestorer?: boolean;
+    enableProtocolSupport?: boolean;
+    enableProtocolLib?: boolean;
+    enableTCPShield?: boolean;
+    enableSpigotOptimizers?: boolean;
+    enableSpark?: boolean;
+    enableViewDistanceTweaks?: boolean;
+    enableFarmControl?: boolean;
+    enableEntityDetection?: boolean;
+    customJavaArgs?: string[];
+    javaVersion?: '17' | '21' | 'auto';
+    usePortableJava?: boolean;
+    memoryMonitor?: MemoryMonitorConfig;
+    autoInstallJava?: boolean;
+    networkOptimization?: NetworkOptimizationConfig;
+    owners?: string[];
+    ownerCommands?: OwnerConfig;
+    silentMode?: boolean;
+    statsInterval?: number;
+    cleanLogsInterval?: number;
+    optimizeForPterodactyl?: boolean;
+    ramdisk?: RamdiskConfig;
+    symlinkMaster?: string;
 }