@dimzxzzx07/mc-headless 1.0.0

package/src/core/ServerManager.ts

@@ -0,0 +1,196 @@
+import { EventEmitter } from 'events';
+import { MinecraftServer } from './MinecraftServer';
+import { MinecraftConfig, ServerInfo } from '../types';
+import { Logger } from '../utils/Logger';
+import * as path from 'path';
+import * as fs from 'fs-extra';
+
+export class ServerManager extends EventEmitter {
+    private servers: Map<string, MinecraftServer> = new Map();
+    private logger: Logger;
+
+    constructor() {
+        super();
+        this.logger = Logger.getInstance();
+    }
+
+    public createServer(name: string, config: Partial<MinecraftConfig>): MinecraftServer {
+        if (this.servers.has(name)) {
+            throw new Error(`Server with name ${name} already exists`);
+        }
+
+        const server = new MinecraftServer(config);
+        this.servers.set(name, server);
+
+        server.on('ready', (info) => {
+            this.emit('server-ready', { name, info });
+        });
+
+        server.on('stop', (data) => {
+            this.emit('server-stopped', { name, data });
+        });
+
+        server.on('player-join', (player) => {
+            this.emit('player-joined', { name, player });
+        });
+
+        server.on('player-leave', (playerName) => {
+            this.emit('player-left', { name, playerName });
+        });
+
+        server.on('resource', (info) => {
+            this.emit('resource-update', { name, info });
+        });
+
+        this.logger.success(`Server created: ${name}`);
+        return server;
+    }
+
+    public getServer(name: string): MinecraftServer | undefined {
+        return this.servers.get(name);
+    }
+
+    public async startServer(name: string): Promise<ServerInfo> {
+        const server = this.servers.get(name);
+        if (!server) {
+            throw new Error(`Server not found: ${name}`);
+        }
+
+        this.logger.info(`Starting server: ${name}`);
+        return server.start();
+    }
+
+    public async stopServer(name: string): Promise<void> {
+        const server = this.servers.get(name);
+        if (!server) {
+            throw new Error(`Server not found: ${name}`);
+        }
+
+        this.logger.info(`Stopping server: ${name}`);
+        await server.stop();
+    }
+
+    public async stopAll(): Promise<void> {
+        const promises = Array.from(this.servers.entries()).map(async ([name, server]) => {
+            this.logger.info(`Stopping server: ${name}`);
+            await server.stop();
+        });
+
+        await Promise.all(promises);
+        this.logger.success('All servers stopped');
+    }
+
+    public removeServer(name: string): boolean {
+        const server = this.servers.get(name);
+        if (server) {
+            if (server['serverInfo'].status === 'running') {
+                throw new Error(`Cannot remove running server: ${name}`);
+            }
+            this.servers.delete(name);
+            this.logger.info(`Server removed: ${name}`);
+            return true;
+        }
+        return false;
+    }
+
+    public listServers(): Array<{ name: string; info: ServerInfo }> {
+        return Array.from(this.servers.entries()).map(([name, server]) => ({
+            name,
+            info: server['serverInfo']
+        }));
+    }
+
+    public getServerCount(): number {
+        return this.servers.size;
+    }
+
+    public getRunningServers(): Array<{ name: string; info: ServerInfo }> {
+        return Array.from(this.servers.entries())
+            .filter(([_, server]) => server['serverInfo'].status === 'running')
+            .map(([name, server]) => ({ name, info: server['serverInfo'] }));
+    }
+
+    public async broadcastCommand(command: string): Promise<void> {
+        const promises = Array.from(this.servers.entries()).map(async ([name, server]) => {
+            try {
+                if (server['serverInfo'].status === 'running') {
+                    server.sendCommand(command);
+                    this.logger.debug(`Command sent to ${name}: ${command}`);
+                }
+            } catch (error) {
+                this.logger.error(`Failed to send command to ${name}:`, error);
+            }
+        });
+
+        await Promise.all(promises);
+    }
+
+    public async saveAll(): Promise<void> {
+        await this.broadcastCommand('save-all');
+        this.logger.info('Save-all command sent to all servers');
+    }
+
+    public async backupAll(type: 'full' | 'world' | 'plugins' = 'world'): Promise<Map<string, string>> {
+        const results = new Map();
+
+        const promises = Array.from(this.servers.entries()).map(async ([name, server]) => {
+            try {
+                const backupPath = await server.backup(type);
+                results.set(name, backupPath);
+                this.logger.success(`Backup created for ${name}: ${backupPath}`);
+            } catch (error) {
+                this.logger.error(`Failed to backup ${name}:`, error);
+            }
+        });
+
+        await Promise.all(promises);
+        return results;
+    }
+
+    public async importServersFromDirectory(dir: string): Promise<void> {
+        if (!await fs.pathExists(dir)) {
+            throw new Error(`Directory not found: ${dir}`);
+        }
+
+        const files = await fs.readdir(dir);
+        
+        for (const file of files) {
+            if (file.endsWith('.json')) {
+                try {
+                    const configPath = path.join(dir, file);
+                    const configData = await fs.readFile(configPath, 'utf8');
+                    const config = JSON.parse(configData);
+                    const serverName = path.basename(file, '.json');
+                    
+                    this.createServer(serverName, config);
+                    this.logger.info(`Imported server: ${serverName}`);
+                } catch (error) {
+                    this.logger.error(`Failed to import ${file}:`, error);
+                }
+            }
+        }
+    }
+
+    public async exportServersToDirectory(dir: string): Promise<void> {
+        await fs.ensureDir(dir);
+
+        for (const [name, server] of this.servers) {
+            try {
+                const config = server['config'];
+                const configPath = path.join(dir, `${name}.json`);
+                await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+                this.logger.info(`Exported server: ${name}`);
+            } catch (error) {
+                this.logger.error(`Failed to export ${name}:`, error);
+            }
+        }
+    }
+
+    public getStatus(): any {
+        return {
+            totalServers: this.getServerCount(),
+            runningServers: this.getRunningServers().length,
+            servers: this.listServers()
+        };
+    }
+}

package/src/engines/Downloader.ts

@@ -0,0 +1,144 @@
+import axios from 'axios';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { createHash } from 'crypto';
+import { Logger } from '../utils/Logger';
+import { DownloadInfo } from '../types';
+
+export class Downloader {
+    private static logger = Logger.getInstance();
+
+    public static async downloadFile(info: DownloadInfo, destDir: string): Promise<string> {
+        const destPath = path.join(destDir, info.fileName);
+        
+        this.logger.info(`Downloading ${info.fileName}...`);
+        
+        await fs.ensureDir(destDir);
+        
+        const writer = fs.createWriteStream(destPath);
+        
+        const response = await axios({
+            method: 'GET',
+            url: info.url,
+            responseType: 'stream'
+        });
+
+        const totalLength = response.headers['content-length'];
+        
+        let downloadedLength = 0;
+        
+        response.data.on('data', (chunk: Buffer) => {
+            downloadedLength += chunk.length;
+            if (totalLength) {
+                const progress = (downloadedLength / parseInt(totalLength) * 100).toFixed(2);
+                process.stdout.write(`\rDownloading: ${progress}%`);
+            }
+        });
+
+        response.data.pipe(writer);
+
+        return new Promise((resolve, reject) => {
+            writer.on('finish', async () => {
+                process.stdout.write('\n');
+                
+                if (info.sha1) {
+                    const hash = await this.calculateSHA1(destPath);
+                    if (hash !== info.sha1) {
+                        await fs.remove(destPath);
+                        reject(new Error(`SHA1 mismatch for ${info.fileName}`));
+                        return;
+                    }
+                    this.logger.success('SHA1 verified');
+                }
+                
+                if (info.size) {
+                    const stats = await fs.stat(destPath);
+                    if (stats.size !== info.size) {
+                        await fs.remove(destPath);
+                        reject(new Error(`Size mismatch for ${info.fileName}`));
+                        return;
+                    }
+                }
+                
+                this.logger.success(`Downloaded: ${info.fileName}`);
+                resolve(destPath);
+            });
+
+            writer.on('error', reject);
+        });
+    }
+
+    public static getPaperURL(version: string, build?: string): DownloadInfo {
+        return {
+            url: `https://api.papermc.io/v2/projects/paper/versions/${version}/builds/${build || 'latest'}/downloads/paper-${version}-${build || 'latest'}.jar`,
+            fileName: `paper-${version}.jar`
+        };
+    }
+
+    public static getPurpurURL(version: string): DownloadInfo {
+        return {
+            url: `https://api.purpurmc.org/v2/purpur/${version}/latest/download`,
+            fileName: `purpur-${version}.jar`
+        };
+    }
+
+    public static getVanillaURL(version: string): DownloadInfo {
+        return {
+            url: `https://piston-data.mojang.com/v1/objects/${this.getVanillaHash(version)}/server.jar`,
+            fileName: `vanilla-${version}.jar`
+        };
+    }
+
+    public static getSpigotURL(version: string): DownloadInfo {
+        return {
+            url: `https://download.getbukkit.org/spigot/spigot-${version}.jar`,
+            fileName: `spigot-${version}.jar`
+        };
+    }
+
+    public static getForgeURL(version: string): DownloadInfo {
+        return {
+            url: `https://maven.minecraftforge.net/net/minecraftforge/forge/${version}-${version}.0/forge-${version}-${version}.0-installer.jar`,
+            fileName: `forge-${version}-installer.jar`
+        };
+    }
+
+    public static getFabricURL(version: string): DownloadInfo {
+        return {
+            url: `https://meta.fabricmc.net/v2/versions/loader/${version}/0.15.11/1.0.1/server/jar`,
+            fileName: `fabric-${version}.jar`
+        };
+    }
+
+    public static getGeyserURL(): DownloadInfo {
+        return {
+            url: 'https://download.geysermc.org/v2/projects/geyser/versions/latest/builds/latest/downloads/standalone',
+            fileName: 'geyser.jar'
+        };
+    }
+
+    public static getFloodgateURL(): DownloadInfo {
+        return {
+            url: 'https://download.geysermc.org/v2/projects/floodgate/versions/latest/builds/latest/downloads/spigot',
+            fileName: 'floodgate.jar'
+        };
+    }
+
+    private static getVanillaHash(version: string): string {
+        const hashes: Record<string, string> = {
+            '1.20.4': '8dd1a28015f51b1803213892b75b7a20c5981f4d',
+            '1.20.2': '5b2aad530acbdcdcc875c1b2e2b469f498e37d2f',
+            '1.20.1': 'ae9f122b71bdab92d28fea6e27c53b0b28e25c1a',
+            '1.19.4': '8f3112a279976a0f4bcb8152d2a13015b0e2c1f5',
+            '1.18.2': 'c8f83c5655348435ec3f61fc9c6b83f3519e8a2c'
+        };
+        return hashes[version] || hashes['1.20.1'];
+    }
+
+    private static async calculateSHA1(filePath: string): Promise<string> {
+        const hash = createHash('sha1');
+        const data = await fs.readFile(filePath);
+        hash.update(data);
+        return hash.digest('hex');
+    }
+}

package/src/engines/FabricEngine.ts

@@ -0,0 +1,49 @@
+import { ServerEngine } from './ServerEngine';
+import { MinecraftConfig } from '../types';
+import { Downloader } from './Downloader';
+import { FileUtils } from '../utils/FileUtils';
+import { PropertiesParser } from '../utils/PropertiesParser';
+import * as path from 'path';
+
+export class FabricEngine implements ServerEngine {
+    public async download(config: MinecraftConfig, serverDir: string): Promise<string> {
+        const downloadInfo = Downloader.getFabricURL(config.version);
+        return Downloader.downloadFile(downloadInfo, serverDir);
+    }
+
+    public async prepare(config: MinecraftConfig, serverDir: string): Promise<void> {
+        if (config.autoAcceptEula) {
+            await FileUtils.writeFile(
+                path.join(serverDir, 'eula.txt'),
+                'eula=true'
+            );
+        }
+
+        const properties = PropertiesParser.generateServerProperties(config);
+        await FileUtils.writeProperties(
+            path.join(serverDir, 'server.properties'),
+            properties
+        );
+    }
+
+    public getJavaArgs(config: MinecraftConfig): string[] {
+        const args: string[] = [];
+
+        args.push(`-Xms${config.memory.init}`);
+        args.push(`-Xmx${config.memory.max}`);
+
+        return args;
+    }
+
+    public getServerJar(jarPath: string): string {
+        return jarPath;
+    }
+
+    public getServerArgs(): string[] {
+        return ['nogui'];
+    }
+
+    public getServerType(): string {
+        return 'fabric';
+    }
+}

package/src/engines/ForgeEngine.ts

@@ -0,0 +1,65 @@
+import { ServerEngine } from './ServerEngine';
+import { MinecraftConfig } from '../types';
+import { Downloader } from './Downloader';
+import { FileUtils } from '../utils/FileUtils';
+import { PropertiesParser } from '../utils/PropertiesParser';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+
+export class ForgeEngine implements ServerEngine {
+    public async download(config: MinecraftConfig, serverDir: string): Promise<string> {
+        const downloadInfo = Downloader.getForgeURL(config.version);
+        return Downloader.downloadFile(downloadInfo, serverDir);
+    }
+
+    public async prepare(config: MinecraftConfig, serverDir: string, jarPath: string): Promise<void> {
+        if (config.autoAcceptEula) {
+            await FileUtils.writeFile(
+                path.join(serverDir, 'eula.txt'),
+                'eula=true'
+            );
+        }
+
+        const properties = PropertiesParser.generateServerProperties(config);
+        await FileUtils.writeProperties(
+            path.join(serverDir, 'server.properties'),
+            properties
+        );
+
+        const installerPath = jarPath;
+        const forgeJar = path.join(serverDir, `forge-${config.version}-${config.version}.0-server.jar`);
+
+        if (!await FileUtils.fileExists(forgeJar)) {
+            console.log('Running Forge installer...');
+            execSync(`java -jar "${installerPath}" --installServer`, {
+                cwd: serverDir,
+                stdio: 'inherit'
+            });
+        }
+    }
+
+    public getJavaArgs(config: MinecraftConfig): string[] {
+        const args: string[] = [];
+
+        args.push(`-Xms${config.memory.init}`);
+        args.push(`-Xmx${config.memory.max}`);
+
+        return args;
+    }
+
+    public getServerJar(jarPath: string): string {
+        const dir = path.dirname(jarPath);
+        const files = fs.readdirSync(dir);
+        const forgeJar = files.find((f: string) => f.includes('forge') && f.endsWith('-server.jar'));
+        return forgeJar ? path.join(dir, forgeJar) : jarPath;
+    }
+
+    public getServerArgs(): string[] {
+        return ['nogui'];
+    }
+
+    public getServerType(): string {
+        return 'forge';
+    }
+}

package/src/engines/PaperEngine.ts

@@ -0,0 +1,68 @@
+import { ServerEngine } from './ServerEngine';
+import { MinecraftConfig } from '../types';
+import { Downloader } from './Downloader';
+import { FileUtils } from '../utils/FileUtils';
+import { PropertiesParser } from '../utils/PropertiesParser';
+import * as path from 'path';
+
+export class PaperEngine implements ServerEngine {
+    public async download(config: MinecraftConfig, serverDir: string): Promise<string> {
+        const downloadInfo = Downloader.getPaperURL(config.version);
+        return Downloader.downloadFile(downloadInfo, serverDir);
+    }
+
+    public async prepare(config: MinecraftConfig, serverDir: string): Promise<void> {
+        if (config.autoAcceptEula) {
+            await FileUtils.writeFile(
+                path.join(serverDir, 'eula.txt'),
+                'eula=true'
+            );
+        }
+
+        const properties = PropertiesParser.generateServerProperties(config);
+        await FileUtils.writeProperties(
+            path.join(serverDir, 'server.properties'),
+            properties
+        );
+    }
+
+    public getJavaArgs(config: MinecraftConfig): string[] {
+        const args: string[] = [];
+
+        args.push(`-Xms${config.memory.init}`);
+        args.push(`-Xmx${config.memory.max}`);
+
+        if (config.memory.useAikarsFlags) {
+            args.push('-XX:+UseG1GC');
+            args.push('-XX:+ParallelRefProcEnabled');
+            args.push('-XX:MaxGCPauseMillis=200');
+            args.push('-XX:+UnlockExperimentalVMOptions');
+            args.push('-XX:+DisableExplicitGC');
+            args.push('-XX:+AlwaysPreTouch');
+            args.push('-XX:G1HeapWastePercent=5');
+            args.push('-XX:G1MixedGCCountTarget=4');
+            args.push('-XX:InitiatingHeapOccupancyPercent=15');
+            args.push('-XX:G1MixedGCLiveThresholdPercent=90');
+            args.push('-XX:G1RSetUpdatingPauseTimePercent=5');
+            args.push('-XX:SurvivorRatio=32');
+            args.push('-XX:+PerfDisableSharedMem');
+            args.push('-XX:MaxTenuringThreshold=1');
+            args.push('-Dusing.aikars.flags=https://mcflags.emc.gs');
+            args.push('-Daikars.new.flags=true');
+        }
+
+        return args;
+    }
+
+    public getServerJar(jarPath: string): string {
+        return jarPath;
+    }
+
+    public getServerArgs(): string[] {
+        return ['nogui'];
+    }
+
+    public getServerType(): string {
+        return 'paper';
+    }
+}

package/src/engines/ServerEngine.ts

@@ -0,0 +1,10 @@
+import { MinecraftConfig } from '../types';
+
+export interface ServerEngine {
+    download(config: MinecraftConfig, serverDir: string): Promise<string>;
+    prepare(config: MinecraftConfig, serverDir: string, jarPath?: string): Promise<void>;
+    getJavaArgs(config: MinecraftConfig): string[];
+    getServerJar(jarPath: string): string;
+    getServerArgs(): string[];
+    getServerType(): string;
+}

package/src/engines/VanillaEngine.ts

@@ -0,0 +1,49 @@
+import { ServerEngine } from './ServerEngine';
+import { MinecraftConfig } from '../types';
+import { Downloader } from './Downloader';
+import { FileUtils } from '../utils/FileUtils';
+import { PropertiesParser } from '../utils/PropertiesParser';
+import * as path from 'path';
+
+export class VanillaEngine implements ServerEngine {
+    public async download(config: MinecraftConfig, serverDir: string): Promise<string> {
+        const downloadInfo = Downloader.getVanillaURL(config.version);
+        return Downloader.downloadFile(downloadInfo, serverDir);
+    }
+
+    public async prepare(config: MinecraftConfig, serverDir: string): Promise<void> {
+        if (config.autoAcceptEula) {
+            await FileUtils.writeFile(
+                path.join(serverDir, 'eula.txt'),
+                'eula=true'
+            );
+        }
+
+        const properties = PropertiesParser.generateServerProperties(config);
+        await FileUtils.writeProperties(
+            path.join(serverDir, 'server.properties'),
+            properties
+        );
+    }
+
+    public getJavaArgs(config: MinecraftConfig): string[] {
+        const args: string[] = [];
+
+        args.push(`-Xms${config.memory.init}`);
+        args.push(`-Xmx${config.memory.max}`);
+
+        return args;
+    }
+
+    public getServerJar(jarPath: string): string {
+        return jarPath;
+    }
+
+    public getServerArgs(): string[] {
+        return ['nogui'];
+    }
+
+    public getServerType(): string {
+        return 'vanilla';
+    }
+}

package/src/index.ts

@@ -0,0 +1,83 @@
+import { MinecraftServer } from './core/MinecraftServer';
+import { Logger, LogLevel } from './utils/Logger';
+import { SystemDetector } from './utils/SystemDetector';
+
+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 './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 * from './types';
+
+export default MinecraftServer;
+
+if (require.main === module) {
+    const logger = Logger.getInstance();
+    logger.setLogLevel(LogLevel.INFO);
+    
+    const systemInfo = SystemDetector.getSystemInfo();
+    logger.info('System Information:', systemInfo);
+
+    const server = new MinecraftServer({
+        platform: 'java',
+        version: '1.20.1',
+        type: 'paper',
+        memory: {
+            init: '1G',
+            max: '2G',
+            useAikarsFlags: true
+        },
+        world: {
+            difficulty: 'normal',
+            hardcore: false,
+            gamemode: 'survival',
+            maxPlayers: 10,
+            viewDistance: 10,
+            levelName: 'world'
+        }
+    });
+
+    server.on('ready', (info) => {
+        logger.success(`
+Mc Headless - Powered By Dimzxzzx07
+     Address: ${info.ip}:${info.port}
+     Version: ${info.version} ${info.type}
+     Players: 0/${info.maxPlayers}
+        `);
+    });
+
+    server.on('player-join', (player) => {
+        logger.info(`Player joined: ${player.name}`);
+    });
+
+    server.on('player-leave', (name) => {
+        logger.info(`Player left: ${name}`);
+    });
+
+    server.start().catch(error => {
+        logger.error('Failed to start server:', error);
+    });
+
+    process.on('SIGINT', async () => {
+        logger.info('Received SIGINT, stopping server...');
+        await server.stop();
+        process.exit(0);
+    });
+
+    process.on('SIGTERM', async () => {
+        logger.info('Received SIGTERM, stopping server...');
+        await server.stop();
+        process.exit(0);
+    });
+}