@dimzxzzx07/mc-headless 2.2.1 → 2.2.3

package/src/index.ts

@@ -4,25 +4,25 @@ import { MinecraftServer } from './core/MinecraftServer';
 import { Logger, LogLevel } from './utils/Logger';
 import { SystemDetector } from './utils/SystemDetector';
 import { JavaChecker } from './core/JavaChecker';
-
-export * from './core/MinecraftServer';
-export * from './core/ConfigHandler';
-export * from './core/JavaChecker';
-export * from './core/ServerManager';
-export * from './platforms/JavaServer';
-export * from './platforms/BedrockServer';
-export * from './platforms/GeyserBridge';
-export * from './platforms/ViaVersion';
-export * from './platforms/SkinRestorer';
-export * from './engines/Downloader';
-export * from './engines/PaperEngine';
-export * from './engines/VanillaEngine';
-export * from './engines/ForgeEngine';
-export * from './engines/FabricEngine';
-export * from './utils/Logger';
-export * from './utils/FileUtils';
-export * from './utils/SystemDetector';
-export * from './utils/PropertiesParser';
+export { MinecraftServer } from './core/MinecraftServer';
+export { ConfigHandler } from './core/ConfigHandler';
+export { JavaChecker, JavaInfo } from './core/JavaChecker';
+export { ServerManager } from './core/ServerManager';
+export { JavaServer } from './platforms/JavaServer';
+export { BedrockServer } from './platforms/BedrockServer';
+export { GeyserBridge, GeyserConfig } from './platforms/GeyserBridge';
+export { ViaVersionManager } from './platforms/ViaVersion';
+export { SkinRestorerManager } from './platforms/SkinRestorer';
+export { PluginManager } from './platforms/PluginManager';
+export { Downloader } from './engines/Downloader';
+export { PaperEngine } from './engines/PaperEngine';
+export { VanillaEngine } from './engines/VanillaEngine';
+export { ForgeEngine } from './engines/ForgeEngine';
+export { FabricEngine } from './engines/FabricEngine';
+export { Logger, LogLevel } from './utils/Logger';
+export { FileUtils } from './utils/FileUtils';
+export { SystemDetector } from './utils/SystemDetector';
+export { PropertiesParser } from './utils/PropertiesParser';
 export * from './types';
 
 export default MinecraftServer;

package/src/platforms/GeyserBridge.ts

@@ -1,111 +1,227 @@
 import { MinecraftConfig } from '../types';
-import { Downloader } from '../engines/Downloader';
 import { FileUtils } from '../utils/FileUtils';
 import { Logger } from '../utils/Logger';
 import * as path from 'path';
-import { spawn } from 'child_process';
+import * as fs from 'fs-extra';
+import * as yaml from 'js-yaml';
+
+export interface GeyserConfig {
+    bedrock: {
+        port: number;
+        address: string;
+    };
+    remote: {
+        address: string;
+        port: number;
+        authType: string;
+    };
+    floodgateKeyFile: string;
+    passthroughMotd: boolean;
+    passthroughPlayerCounts: boolean;
+    passthroughProtocolName: boolean;
+}
 
 export class GeyserBridge {
     private logger = Logger.getInstance();
-    private process: any = null;
 
-    public async setup(config: MinecraftConfig): Promise<void> {
+    public async setup(config: MinecraftConfig, isPterodactyl: boolean = false): Promise<void> {
         const pluginsDir = config.folders.plugins;
-        
         await FileUtils.ensureDir(pluginsDir);
 
-        const geyserJar = path.join(pluginsDir, 'geyser.jar');
-        const floodgateJar = path.join(pluginsDir, 'floodgate.jar');
+        this.logger.info('Setting up Geyser & Floodgate...');
+
+        await this.cleanupRemappedFolders(pluginsDir);
+        await this.downloadGeyser(pluginsDir);
+        await this.downloadFloodgate(pluginsDir);
+        
+        if (isPterodactyl) {
+            await this.configureGeyserForPterodactyl(config, pluginsDir);
+        } else {
+            await this.configureGeyser(config, pluginsDir);
+        }
 
-        if (!await FileUtils.fileExists(geyserJar)) {
-            this.logger.info('Downloading Geyser...');
-            
-            const geyserInfo = await Downloader.getGeyserInfo();
-            
-            geyserInfo.fileName = 'geyser.jar';
-            
-            const downloadedPath = await Downloader.downloadFile(geyserInfo, pluginsDir);
-            
-            if (downloadedPath && downloadedPath !== geyserJar) {
-                if (await FileUtils.fileExists(downloadedPath)) {
-                    await FileUtils.moveFile(downloadedPath, geyserJar);
+        this.logger.success('Geyser & Floodgate installed');
+    }
+
+    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()) {
+                        this.logger.warning(`Removing corrupt remapped folder: ${file}`);
+                        await fs.remove(remappedPath);
+                    }
                 }
             }
-            
-            this.logger.success('Geyser downloaded to plugins folder');
+        } catch (error) {
         }
+    }
 
-        if (!await FileUtils.fileExists(floodgateJar)) {
-            this.logger.info('Downloading Floodgate...');
-            
-            const floodgateInfo = await Downloader.getFloodgateInfo();
-            
-            floodgateInfo.fileName = 'floodgate.jar';
-            
-            const downloadedPath = await Downloader.downloadFile(floodgateInfo, pluginsDir);
-            
-            if (downloadedPath && downloadedPath !== floodgateJar) {
-                if (await FileUtils.fileExists(downloadedPath)) {
-                    await FileUtils.moveFile(downloadedPath, floodgateJar);
-                }
+    private async downloadGeyser(pluginsDir: string): Promise<void> {
+        const geyserJar = path.join(pluginsDir, 'Geyser-Spigot.jar');
+        
+        const possibleNames = ['geyser.jar', 'Geyser.jar', 'Geyser-Spigot.jar'];
+        for (const name of possibleNames) {
+            const oldPath = path.join(pluginsDir, name);
+            if (await FileUtils.fileExists(oldPath)) {
+                await fs.remove(oldPath);
             }
-            
-            this.logger.success('Floodgate downloaded to plugins folder');
         }
 
-        this.logger.success('Geyser & Floodgate installed');
+        this.logger.info('Downloading Geyser...');
+
+        try {
+            const response = await require('axios')({
+                method: 'GET',
+                url: 'https://download.geysermc.org/v2/projects/geyser/versions/latest/builds/latest/downloads/spigot',
+                responseType: 'stream',
+                timeout: 60000,
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+                }
+            });
+
+            const writer = fs.createWriteStream(geyserJar);
+            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(geyserJar);
+            if (stats.size < 100000) {
+                throw new Error(`Downloaded file too small: ${stats.size} bytes`);
+            }
+
+            this.logger.success(`Geyser downloaded (${(stats.size / 1024 / 1024).toFixed(2)} MB)`);
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Failed to download Geyser: ${errorMessage}`);
+            throw error;
+        }
     }
 
-    public async startStandalone(config: MinecraftConfig, serverDir: string): Promise<void> {
-        const geyserDir = path.join(serverDir, 'geyser-standalone');
-        await FileUtils.ensureDir(geyserDir);
+    private async downloadFloodgate(pluginsDir: string): Promise<void> {
+        const floodgateJar = path.join(pluginsDir, 'floodgate.jar');
         
-        const geyserJar = path.join(geyserDir, 'geyser.jar');
-
-        if (!await FileUtils.fileExists(geyserJar)) {
-            this.logger.info('Downloading Geyser standalone...');
-            
-            const geyserInfo = await Downloader.getGeyserInfo();
-            geyserInfo.fileName = 'geyser.jar';
-            
-            const downloadedPath = await Downloader.downloadFile(geyserInfo, geyserDir);
-            
-            if (downloadedPath && downloadedPath !== geyserJar) {
-                if (await FileUtils.fileExists(downloadedPath)) {
-                    await FileUtils.moveFile(downloadedPath, geyserJar);
+        if (await FileUtils.fileExists(floodgateJar)) {
+            await fs.remove(floodgateJar);
+        }
+
+        this.logger.info('Downloading Floodgate...');
+
+        try {
+            const response = await require('axios')({
+                method: 'GET',
+                url: 'https://download.geysermc.org/v2/projects/floodgate/versions/latest/builds/latest/downloads/spigot',
+                responseType: 'stream',
+                timeout: 60000,
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
                 }
+            });
+
+            const writer = fs.createWriteStream(floodgateJar);
+            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(floodgateJar);
+            if (stats.size < 100000) {
+                throw new Error(`Downloaded file too small: ${stats.size} bytes`);
             }
-            
-            this.logger.success('Geyser standalone downloaded');
+
+            this.logger.success(`Floodgate downloaded (${(stats.size / 1024 / 1024).toFixed(2)} MB)`);
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Failed to download Floodgate: ${errorMessage}`);
+            throw error;
         }
+    }
 
-        const javaArgs = [
-            `-Xms${config.memory.init}`,
-            `-Xmx${config.memory.max}`,
-            '-jar',
-            geyserJar
-        ];
-
-        this.logger.info('Starting Geyser standalone...');
-        this.process = spawn('java', javaArgs, {
-            cwd: geyserDir,
-            stdio: 'pipe'
-        });
-
-        this.process.stdout.on('data', (data: Buffer) => {
-            process.stdout.write(`[Geyser] ${data.toString()}`);
-        });
-
-        this.process.stderr.on('data', (data: Buffer) => {
-            process.stderr.write(`[Geyser Error] ${data.toString()}`);
-        });
+    private async configureGeyser(config: MinecraftConfig, pluginsDir: string): Promise<void> {
+        const geyserConfigPath = path.join(pluginsDir, 'Geyser-Spigot', 'config.yml');
+        await fs.ensureDir(path.dirname(geyserConfigPath));
+
+        const geyserConfig: GeyserConfig = {
+            bedrock: {
+                port: config.network.bedrockPort || 19132,
+                address: config.network.ip
+            },
+            remote: {
+                address: '127.0.0.1',
+                port: config.network.port,
+                authType: 'floodgate'
+            },
+            floodgateKeyFile: 'floodgate/key.pem',
+            passthroughMotd: true,
+            passthroughPlayerCounts: true,
+            passthroughProtocolName: true
+        };
+
+        await fs.writeFile(geyserConfigPath, yaml.dump(geyserConfig));
+        this.logger.debug('Geyser configured for standalone mode');
     }
 
-    public stop(): void {
-        if (this.process) {
-            this.process.kill();
-            this.process = null;
-            this.logger.info('Geyser stopped');
+    private async configureGeyserForPterodactyl(config: MinecraftConfig, pluginsDir: string): Promise<void> {
+        const geyserConfigPath = path.join(pluginsDir, 'Geyser-Spigot', 'config.yml');
+        await fs.ensureDir(path.dirname(geyserConfigPath));
+
+        const pterodactylPort = parseInt(process.env.SERVER_PORT || config.network.port.toString());
+        const hasSeparateBedrockPort = !!(process.env.BEDROCK_PORT || config.network.bedrockPort);
+
+        let geyserConfig: GeyserConfig;
+
+        if (hasSeparateBedrockPort) {
+            geyserConfig = {
+                bedrock: {
+                    port: parseInt(process.env.BEDROCK_PORT || config.network.bedrockPort?.toString() || '19132'),
+                    address: '0.0.0.0'
+                },
+                remote: {
+                    address: '127.0.0.1',
+                    port: pterodactylPort,
+                    authType: 'floodgate'
+                },
+                floodgateKeyFile: 'floodgate/key.pem',
+                passthroughMotd: true,
+                passthroughPlayerCounts: true,
+                passthroughProtocolName: true
+            };
+            this.logger.info(`Geyser configured with separate Bedrock port: ${geyserConfig.bedrock.port}`);
+        } else {
+            geyserConfig = {
+                bedrock: {
+                    port: pterodactylPort,
+                    address: '0.0.0.0'
+                },
+                remote: {
+                    address: '127.0.0.1',
+                    port: pterodactylPort,
+                    authType: 'floodgate'
+                },
+                floodgateKeyFile: 'floodgate/key.pem',
+                passthroughMotd: true,
+                passthroughPlayerCounts: true,
+                passthroughProtocolName: true
+            };
+            this.logger.info(`Geyser configured for port sharing on ${pterodactylPort} (TCP+UDP required)`);
+            this.logger.warning('Make sure Pterodactyl panel has UDP enabled for this port');
         }
+
+        await fs.writeFile(geyserConfigPath, yaml.dump(geyserConfig));
+        this.logger.debug('Geyser configured for Pterodactyl mode');
+    }
+
+    public stop(): void {
     }
 }

package/src/platforms/PluginManager.ts

@@ -0,0 +1,206 @@
+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';
+import * as stream from 'stream';
+import * as util from 'util';
+
+const pipeline = util.promisify(stream.pipeline);
+const finished = util.promisify(stream.finished);
+
+export class PluginManager {
+    private logger = Logger.getInstance();
+
+    public async installPlugin(name: string, url: string, pluginsDir: string): Promise<void> {
+        const pluginJar = path.join(pluginsDir, `${name}.jar`);
+        
+        if (await FileUtils.fileExists(pluginJar)) {
+            this.logger.info(`${name} already exists, skipping download`);
+            return;
+        }
+
+        this.logger.info(`Downloading ${name}...`);
+
+        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 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                    'Accept': 'application/octet-stream'
+                },
+                maxRedirects: 5
+            });
+
+            if (response.status !== 200) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+
+            const writer = fs.createWriteStream(pluginJar);
+            await pipeline(response.data, writer);
+            await finished(writer);
+
+            const stats = await fs.stat(pluginJar);
+            if (stats.size < 100000) {
+                await fs.remove(pluginJar);
+                throw new Error(`File too small: ${stats.size} bytes`);
+            }
+
+            this.logger.success(`${name} downloaded (${(stats.size / 1024 / 1024).toFixed(2)} MB)`);
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Failed to download ${name}: ${errorMessage}`);
+        }
+    }
+
+    public async installMultiple(plugins: Array<{name: string, url: string}>, pluginsDir: string): Promise<void> {
+        for (let i = 0; i < plugins.length; i++) {
+            const plugin = plugins[i];
+            await this.installPlugin(plugin.name, plugin.url, pluginsDir);
+            
+            if (i < plugins.length - 1) {
+                await new Promise(resolve => setTimeout(resolve, 1000));
+            }
+        }
+    }
+
+    public async installFromGithub(repo: string, assetName: string, pluginsDir: string): Promise<void> {
+        const apiUrl = `https://api.github.com/repos/${repo}/releases/latest`;
+        
+        try {
+            const response = await axios.get(apiUrl, {
+                headers: {
+                    'User-Agent': 'Mozilla/5.0'
+                }
+            });
+
+            const asset = response.data.assets.find((a: any) => a.name.includes(assetName));
+            if (!asset) {
+                throw new Error(`Asset ${assetName} not found in latest release`);
+            }
+
+            await this.installPlugin(
+                asset.name.replace('.jar', ''),
+                asset.browser_download_url,
+                pluginsDir
+            );
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Failed to install from GitHub ${repo}: ${errorMessage}`);
+        }
+    }
+
+    public async updatePlugin(name: string, url: string, pluginsDir: string): Promise<void> {
+        const pluginJar = path.join(pluginsDir, `${name}.jar`);
+        
+        if (await FileUtils.fileExists(pluginJar)) {
+            await fs.remove(pluginJar);
+        }
+
+        await this.installPlugin(name, url, pluginsDir);
+    }
+
+    public async removePlugin(name: string, pluginsDir: string): Promise<void> {
+        const pluginJar = path.join(pluginsDir, `${name}.jar`);
+        
+        if (await FileUtils.fileExists(pluginJar)) {
+            await fs.remove(pluginJar);
+            this.logger.info(`${name} removed`);
+        }
+    }
+
+    public async listPlugins(pluginsDir: string): Promise<string[]> {
+        if (!await FileUtils.fileExists(pluginsDir)) {
+            return [];
+        }
+
+        const files = await fs.readdir(pluginsDir);
+        return files.filter(f => f.endsWith('.jar')).map(f => f.replace('.jar', ''));
+    }
+
+    public async getPluginInfo(pluginName: string, pluginsDir: string): Promise<any> {
+        const pluginJar = path.join(pluginsDir, `${pluginName}.jar`);
+        
+        if (!await FileUtils.fileExists(pluginJar)) {
+            return null;
+        }
+
+        const stats = await fs.stat(pluginJar);
+        return {
+            name: pluginName,
+            size: stats.size,
+            modified: stats.mtime,
+            path: pluginJar
+        };
+    }
+
+    public async verifyPlugin(pluginName: string, pluginsDir: string): Promise<boolean> {
+        const pluginJar = path.join(pluginsDir, `${pluginName}.jar`);
+        
+        if (!await FileUtils.fileExists(pluginJar)) {
+            return false;
+        }
+
+        const stats = await fs.stat(pluginJar);
+        if (stats.size < 100000) {
+            return false;
+        }
+
+        try {
+            const buffer = await fs.readFile(pluginJar);
+            if (buffer[0] !== 0x50 || buffer[1] !== 0x4B) {
+                return false;
+            }
+        } catch {
+            return false;
+        }
+
+        return true;
+    }
+
+    public async cleanupCorruptPlugins(pluginsDir: string): Promise<number> {
+        if (!await FileUtils.fileExists(pluginsDir)) {
+            return 0;
+        }
+
+        let cleaned = 0;
+        const files = await fs.readdir(pluginsDir);
+
+        for (const file of files) {
+            if (!file.endsWith('.jar')) continue;
+
+            const filePath = path.join(pluginsDir, file);
+            try {
+                const stats = await fs.stat(filePath);
+                if (stats.size < 100000) {
+                    await fs.remove(filePath);
+                    this.logger.warning(`Removed corrupt plugin: ${file}`);
+                    cleaned++;
+                    continue;
+                }
+
+                const buffer = await fs.readFile(filePath);
+                if (buffer[0] !== 0x50 || buffer[1] !== 0x4B) {
+                    await fs.remove(filePath);
+                    this.logger.warning(`Removed invalid ZIP: ${file}`);
+                    cleaned++;
+                }
+            } catch {
+                await fs.remove(filePath);
+                this.logger.warning(`Removed inaccessible plugin: ${file}`);
+                cleaned++;
+            }
+        }
+
+        if (cleaned > 0) {
+            this.logger.info(`Cleaned up ${cleaned} corrupt plugins`);
+        }
+
+        return cleaned;
+    }
+}