@dimzxzzx07/mc-headless 1.0.0

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@dimzxzzx07/mc-headless",
+  "version": "1.0.0",
+  "description": "Minecraft Headless Server Manager - Run Java/Bedrock/Crossplay servers easily via Node.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts",
+    "test": "jest",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "adm-zip": "^0.5.16",
+    "axios": "^1.6.0",
+    "chalk": "^4.1.2",
+    "fs-extra": "^11.1.1",
+    "node-cron": "^3.0.3",
+    "pidusage": "^3.0.2",
+    "tar": "^7.5.10"
+  },
+  "devDependencies": {
+    "@types/adm-zip": "^0.5.5",
+    "@types/fs-extra": "^11.0.4",
+    "@types/jest": "^29.5.5",
+    "@types/node": "^20.8.0",
+    "@types/node-cron": "^3.0.10",
+    "@types/pidusage": "^2.0.5",
+    "@types/tar": "^6.1.6",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.2.2"
+  },
+  "keywords": [
+    "minecraft",
+    "server",
+    "paper",
+    "spigot",
+    "forge",
+    "fabric",
+    "bedrock",
+    "geyser",
+    "headless",
+    "termux",
+    "automation"
+  ],
+  "author": "Dimzxzzx07",
+  "license": "UNLICENSED"
+}

package/src/core/ConfigHandler.ts

@@ -0,0 +1,136 @@
+import { MinecraftConfig } from '../types';
+
+export class ConfigHandler {
+    private config: MinecraftConfig;
+
+    constructor(config: Partial<MinecraftConfig>) {
+        this.config = this.validateAndComplete(config);
+    }
+
+    private validateAndComplete(config: Partial<MinecraftConfig>): MinecraftConfig {
+        const defaultConfig: MinecraftConfig = {
+            platform: 'java',
+            version: '1.20.1',
+            type: 'paper',
+            autoAcceptEula: true,
+
+            memory: {
+                init: '1G',
+                max: '4G',
+                useAikarsFlags: true
+            },
+
+            network: {
+                port: 25565,
+                bedrockPort: 19132,
+                ip: '0.0.0.0',
+                onlineMode: false,
+                motd: 'Minecraft Server'
+            },
+
+            world: {
+                difficulty: 'normal',
+                hardcore: false,
+                gamemode: 'survival',
+                maxPlayers: 20,
+                viewDistance: 10,
+                levelName: 'world'
+            },
+
+            folders: {
+                addons: './addons',
+                mods: './mods',
+                plugins: './plugins',
+                world: './world'
+            },
+
+            autoRestart: false,
+            backup: {
+                enabled: false,
+                interval: '24h',
+                path: './backups'
+            }
+        };
+
+        const merged = this.mergeDeep(defaultConfig, config) as MinecraftConfig;
+
+        this.validateConfig(merged);
+
+        return merged;
+    }
+
+    private validateConfig(config: MinecraftConfig): void {
+        if (!['java', 'bedrock', 'all'].includes(config.platform)) {
+            throw new Error('Invalid platform. Must be java, bedrock, or all');
+        }
+
+        if (!['paper', 'purpur', 'vanilla', 'spigot', 'forge', 'fabric'].includes(config.type)) {
+            throw new Error('Invalid server type');
+        }
+
+        if (!/^\d+\.\d+(\.\d+)?$/.test(config.version)) {
+            throw new Error('Invalid version format');
+        }
+
+        const memRegex = /^\d+[MG]$/;
+        if (!memRegex.test(config.memory.init) || !memRegex.test(config.memory.max)) {
+            throw new Error('Memory must be in format like 1G or 1024M');
+        }
+
+        if (config.network.port < 1 || config.network.port > 65535) {
+            throw new Error('Invalid port number');
+        }
+
+        if (config.world.maxPlayers < 1 || config.world.maxPlayers > 1000) {
+            throw new Error('Max players must be between 1 and 1000');
+        }
+
+        if (config.world.viewDistance < 3 || config.world.viewDistance > 32) {
+            throw new Error('View distance must be between 3 and 32');
+        }
+    }
+
+    private mergeDeep(target: any, source: any): any {
+        const output = { ...target };
+
+        if (this.isObject(target) && this.isObject(source)) {
+            Object.keys(source).forEach(key => {
+                if (this.isObject(source[key])) {
+                    if (!(key in target)) {
+                        output[key] = source[key];
+                    } else {
+                        output[key] = this.mergeDeep(target[key], source[key]);
+                    }
+                } else {
+                    output[key] = source[key];
+                }
+            });
+        }
+
+        return output;
+    }
+
+    private isObject(item: any): boolean {
+        return item && typeof item === 'object' && !Array.isArray(item);
+    }
+
+    public getConfig(): MinecraftConfig {
+        return this.config;
+    }
+
+    public getServerProperties(): Record<string, any> {
+        return {
+            'difficulty': this.config.world.difficulty,
+            'hardcore': this.config.world.hardcore.toString(),
+            'level-seed': this.config.world.seed || '',
+            'gamemode': this.config.world.gamemode,
+            'server-port': this.config.network.port.toString(),
+            'server-ip': this.config.network.ip,
+            'max-players': this.config.world.maxPlayers.toString(),
+            'view-distance': this.config.world.viewDistance.toString(),
+            'level-name': this.config.world.levelName,
+            'motd': this.config.network.motd,
+            'online-mode': this.config.network.onlineMode.toString()
+        };
+    }
+}

package/src/core/JavaChecker.ts

@@ -0,0 +1,71 @@
+import { execSync, exec } from 'child_process';
+import { Logger } from '../utils/Logger';
+import { SystemDetector } from '../utils/SystemDetector';
+
+export class JavaChecker {
+    private static logger = Logger.getInstance();
+
+    public static checkJava(): Promise<boolean> {
+        return new Promise((resolve) => {
+            exec('java -version', (error) => {
+                if (error) {
+                    this.logger.warning('Java is not installed');
+                    resolve(false);
+                } else {
+                    this.logger.success('Java is installed');
+                    resolve(true);
+                }
+            });
+        });
+    }
+
+    public static async ensureJava(): Promise<void> {
+        const hasJava = await this.checkJava();
+        
+        if (!hasJava) {
+            this.logger.warning('Java not found. Attempting to install...');
+            await this.installJava();
+        }
+
+        const version = this.getJavaVersion();
+        if (version) {
+            this.logger.success(`Java version: ${version}`);
+        }
+    }
+
+    public static getJavaVersion(): string | null {
+        try {
+            const output = execSync('java -version 2>&1').toString();
+            const match = output.match(/version "([^"]+)"/);
+            return match ? match[1] : null;
+        } catch {
+            return null;
+        }
+    }
+
+    public static async installJava(): Promise<void> {
+        const command = SystemDetector.getJavaInstallCommand();
+        
+        this.logger.info(`Installing Java with: ${command}`);
+
+        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 installed successfully');
+                    resolve();
+                }
+            });
+
+            child.stdout?.on('data', (data) => {
+                process.stdout.write(data);
+            });
+
+            child.stderr?.on('data', (data) => {
+                process.stderr.write(data);
+            });
+        });
+    }
+}

package/src/core/MinecraftServer.ts

@@ -0,0 +1,326 @@
+import { EventEmitter } from 'events';
+import { spawn } from 'child_process';
+import pidusage from 'pidusage';
+import * as cron from 'node-cron';
+import { MinecraftConfig, ServerInfo, Player } from '../types';
+import { ConfigHandler } from './ConfigHandler';
+import { JavaChecker } from './JavaChecker';
+import { FileUtils } from '../utils/FileUtils';
+import { Logger } from '../utils/Logger';
+import { SystemDetector } from '../utils/SystemDetector';
+import { PaperEngine } from '../engines/PaperEngine';
+import { VanillaEngine } from '../engines/VanillaEngine';
+import { ForgeEngine } from '../engines/ForgeEngine';
+import { FabricEngine } from '../engines/FabricEngine';
+import { ServerEngine } from '../engines/ServerEngine';
+import { GeyserBridge } from '../platforms/GeyserBridge';
+import * as path from 'path';
+
+export class MinecraftServer extends EventEmitter {
+    private config: MinecraftConfig;
+    private logger: Logger;
+    private engine: ServerEngine;
+    private geyser: GeyserBridge;
+    private process: any = null;
+    private serverInfo: ServerInfo;
+    private players: Map<string, Player> = new Map();
+    private backupCron: cron.ScheduledTask | null = null;
+    private startTime: Date | null = null;
+
+    constructor(userConfig: Partial<MinecraftConfig>) {
+        super();
+        this.logger = Logger.getInstance();
+        this.logger.banner();
+
+        const handler = new ConfigHandler(userConfig);
+        this.config = handler.getConfig();
+
+        this.engine = this.createEngine();
+        this.geyser = new GeyserBridge();
+
+        this.serverInfo = {
+            pid: 0,
+            ip: this.config.network.ip,
+            port: this.config.network.port,
+            bedrockPort: this.config.platform === 'all' ? this.config.network.bedrockPort : undefined,
+            version: this.config.version,
+            type: this.config.type,
+            platform: this.config.platform,
+            players: 0,
+            maxPlayers: this.config.world.maxPlayers,
+            uptime: 0,
+            memory: { used: 0, max: 0 },
+            status: 'stopped'
+        };
+    }
+
+    private createEngine(): ServerEngine {
+        switch (this.config.type) {
+            case 'paper':
+            case 'purpur':
+            case 'spigot':
+                return new PaperEngine();
+            case 'vanilla':
+                return new VanillaEngine();
+            case 'forge':
+                return new ForgeEngine();
+            case 'fabric':
+                return new FabricEngine();
+            default:
+                throw new Error(`Unsupported server type: ${this.config.type}`);
+        }
+    }
+
+    public async start(): Promise<ServerInfo> {
+        this.logger.info(`Starting ${this.config.type} server v${this.config.version}...`);
+
+        await JavaChecker.ensureJava();
+
+        const systemInfo = SystemDetector.getSystemInfo();
+        this.logger.debug('System info:', systemInfo);
+
+        const serverDir = process.cwd();
+        await FileUtils.ensureServerStructure(this.config);
+
+        const jarPath = await this.engine.download(this.config, serverDir);
+        
+        if (this.config.type === 'forge') {
+            await this.engine.prepare(this.config, serverDir, jarPath);
+        } else {
+            await this.engine.prepare(this.config, serverDir);
+        }
+
+        if (this.config.platform === 'all') {
+            await this.geyser.setup(this.config);
+        }
+
+        const javaArgs = this.engine.getJavaArgs(this.config);
+        const serverJar = this.engine.getServerJar(jarPath);
+        const serverArgs = this.engine.getServerArgs();
+
+        const fullArgs = [
+            ...javaArgs,
+            '-jar',
+            serverJar,
+            ...serverArgs
+        ];
+
+        this.logger.info(`Launching: java ${fullArgs.join(' ')}`);
+
+        this.process = spawn('java', fullArgs, {
+            cwd: serverDir,
+            stdio: 'pipe'
+        });
+
+        this.serverInfo.pid = this.process.pid!;
+        this.serverInfo.status = 'starting';
+        this.startTime = new Date();
+
+        this.process.stdout.on('data', (data: Buffer) => {
+            const output = data.toString();
+            process.stdout.write(output);
+
+            if (output.includes('Done') || output.includes('For help, type "help"')) {
+                this.serverInfo.status = 'running';
+                this.logger.success('Server started successfully!');
+                this.emit('ready', this.serverInfo);
+            }
+
+            if (output.includes('joined the game')) {
+                const match = output.match(/(\w+) joined the game/);
+                if (match) {
+                    this.handlePlayerJoin(match[1]);
+                }
+            }
+
+            if (output.includes('left the game')) {
+                const match = output.match(/(\w+) left the game/);
+                if (match) {
+                    this.handlePlayerLeave(match[1]);
+                }
+            }
+        });
+
+        this.process.stderr.on('data', (data: Buffer) => {
+            process.stderr.write(data.toString());
+        });
+
+        this.process.on('exit', (code: number) => {
+            this.serverInfo.status = 'stopped';
+            this.logger.warning(`Server stopped with code ${code}`);
+
+            if (this.config.autoRestart && code !== 0) {
+                this.logger.info('Auto-restarting...');
+                this.start();
+            }
+
+            this.emit('stop', { code });
+        });
+
+        this.monitorResources();
+
+        if (this.config.backup.enabled) {
+            this.setupBackups();
+        }
+
+        return this.serverInfo;
+    }
+
+    public async stop(): Promise<void> {
+        if (!this.process) {
+            this.logger.warning('Server not running');
+            return;
+        }
+
+        this.logger.info('Stopping server...');
+        this.serverInfo.status = 'stopping';
+
+        this.sendCommand('stop');
+
+        await new Promise(resolve => setTimeout(resolve, 5000));
+
+        if (this.process) {
+            this.process.kill();
+            this.process = null;
+        }
+
+        if (this.backupCron) {
+            this.backupCron.stop();
+        }
+
+        if (this.config.platform === 'all') {
+            this.geyser.stop();
+        }
+
+        this.logger.success('Server stopped');
+    }
+
+    public sendCommand(command: string): void {
+        if (!this.process || this.serverInfo.status !== 'running') {
+            throw new Error('Server not running');
+        }
+
+        this.process.stdin.write(command + '\n');
+        this.logger.debug(`Command sent: ${command}`);
+    }
+
+    public async getInfo(): Promise<ServerInfo> {
+        if (this.serverInfo.status === 'running' && this.process) {
+            try {
+                const stats = await pidusage(this.process.pid);
+                this.serverInfo.memory = {
+                    used: Math.round(stats.memory / 1024 / 1024),
+                    max: this.parseMemory(this.config.memory.max)
+                };
+                this.serverInfo.uptime = Math.floor((Date.now() - (this.startTime?.getTime() || 0)) / 1000);
+            } catch {}
+        }
+
+        return this.serverInfo;
+    }
+
+    public getPlayers(): Player[] {
+        return Array.from(this.players.values());
+    }
+
+    public async backup(type: 'full' | 'world' | 'plugins' = 'full'): Promise<string> {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const backupName = `backup-${type}-${timestamp}`;
+        const backupPath = path.join(this.config.backup.path, backupName);
+
+        this.logger.info(`Creating ${type} backup...`);
+
+        switch (type) {
+            case 'full':
+                await FileUtils.createBackup(process.cwd(), backupPath);
+                break;
+            case 'world':
+                await FileUtils.createBackup(this.config.folders.world, backupPath);
+                break;
+            case 'plugins':
+                await FileUtils.createBackup(this.config.folders.plugins, backupPath);
+                break;
+        }
+
+        this.logger.success(`Backup created: ${backupPath}`);
+        return backupPath;
+    }
+
+    private monitorResources(): void {
+        setInterval(async () => {
+            if (this.serverInfo.status === 'running' && this.process) {
+                try {
+                    const stats = await pidusage(this.process.pid);
+                    this.serverInfo.memory = {
+                        used: Math.round(stats.memory / 1024 / 1024),
+                        max: this.parseMemory(this.config.memory.max)
+                    };
+                    this.serverInfo.uptime = Math.floor((Date.now() - (this.startTime?.getTime() || 0)) / 1000);
+
+                    if (stats.cpu > 80) {
+                        this.logger.warning(`High CPU usage: ${stats.cpu}%`);
+                    }
+
+                    this.emit('resource', this.serverInfo);
+                } catch {}
+            }
+        }, 5000);
+    }
+
+    private setupBackups(): void {
+        const cronExpression = this.convertIntervalToCron(this.config.backup.interval);
+        
+        if (cronExpression) {
+            this.backupCron = cron.schedule(cronExpression, () => {
+                this.backup('world');
+            });
+            this.logger.info(`Backups scheduled: ${this.config.backup.interval}`);
+        }
+    }
+
+    private convertIntervalToCron(interval: string): string | null {
+        const match = interval.match(/(\d+)([hms])/);
+        if (!match) return null;
+
+        const value = parseInt(match[1]);
+        const unit = match[2];
+
+        switch (unit) {
+            case 'h':
+                return `0 */${value} * * *`;
+            case 'm':
+                return `*/${value} * * * *`;
+            case 's':
+                return `*/${value} * * * * *`;
+            default:
+                return null;
+        }
+    }
+
+    private handlePlayerJoin(name: string): void {
+        const player: Player = {
+            name,
+            uuid: '',
+            ip: '',
+            ping: 0,
+            connectedAt: new Date()
+        };
+        this.players.set(name, player);
+        this.serverInfo.players = this.players.size;
+        this.emit('player-join', player);
+    }
+
+    private handlePlayerLeave(name: string): void {
+        this.players.delete(name);
+        this.serverInfo.players = this.players.size;
+        this.emit('player-leave', name);
+    }
+
+    private parseMemory(memStr: string): number {
+        const value = parseInt(memStr);
+        if (memStr.endsWith('G')) {
+            return value * 1024;
+        }
+        return value;
+    }
+}