@dimzxzzx07/mc-headless 1.0.0

package/src/scripts/install-java.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+
+echo "Installing Java for Minecraft Server..."
+
+if [ -f /etc/os-release ]; then
+    . /etc/os-release
+    OS=$ID
+elif [ -n "$TERMUX_VERSION" ]; then
+    OS="termux"
+else
+    OS="unknown"
+fi
+
+case $OS in
+    ubuntu|debian)
+        apt update
+        apt install -y openjdk-17-jre-headless
+        ;;
+    centos|rhel)
+        yum install -y java-17-openjdk-headless
+        ;;
+    fedora)
+        dnf install -y java-17-openjdk-headless
+        ;;
+    arch)
+        pacman -S --noconfirm jre17-openjdk-headless
+        ;;
+    termux)
+        pkg install -y openjdk-17
+        ;;
+    *)
+        echo "Unsupported OS. Please install Java 17 manually."
+        exit 1
+        ;;
+esac
+
+echo "Java installation completed."
+java -version

package/src/types/index.ts

@@ -0,0 +1,89 @@
+export type Platform = 'java' | 'bedrock' | 'all';
+export type ServerType = 'paper' | 'purpur' | 'vanilla' | 'spigot' | 'forge' | 'fabric';
+export type Difficulty = 'peaceful' | 'easy' | 'normal' | 'hard';
+export type Gamemode = 'survival' | 'creative' | 'adventure' | 'spectator';
+
+export interface MinecraftConfig {
+    platform: Platform;
+    version: string;
+    type: ServerType;
+    autoAcceptEula: boolean;
+
+    memory: {
+        init: string;
+        max: string;
+        useAikarsFlags: boolean;
+    };
+
+    network: {
+        port: number;
+        bedrockPort?: number;
+        ip: string;
+        onlineMode: boolean;
+        motd: string;
+    };
+
+    world: {
+        difficulty: Difficulty;
+        hardcore: boolean;
+        gamemode: Gamemode;
+        seed?: string;
+        maxPlayers: number;
+        viewDistance: number;
+        levelName: string;
+    };
+
+    folders: {
+        addons: string;
+        mods: string;
+        plugins: string;
+        world: string;
+    };
+
+    autoRestart: boolean;
+    backup: {
+        enabled: boolean;
+        interval: string;
+        path: string;
+    };
+}
+
+export interface ServerInfo {
+    pid: number;
+    ip: string;
+    port: number;
+    bedrockPort?: number;
+    version: string;
+    type: ServerType;
+    platform: Platform;
+    players: number;
+    maxPlayers: number;
+    uptime: number;
+    memory: {
+        used: number;
+        max: number;
+    };
+    status: 'starting' | 'running' | 'stopping' | 'stopped' | 'crashed';
+}
+
+export interface DownloadInfo {
+    url: string;
+    fileName: string;
+    size?: number;
+    sha1?: string;
+}
+
+export interface BackupInfo {
+    path: string;
+    size: number;
+    createdAt: Date;
+    type: 'full' | 'world' | 'plugins';
+}
+
+export interface Player {
+    name: string;
+    uuid: string;
+    ip: string;
+    ping: number;
+    connectedAt: Date;
+}

package/src/utils/FileUtils.ts

@@ -0,0 +1,162 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import * as tar from 'tar';
+const AdmZip = require('adm-zip');
+import { Logger } from './Logger';
+
+export class FileUtils {
+    private static logger = Logger.getInstance();
+
+    public static async ensureDir(dir: string): Promise<void> {
+        await fs.ensureDir(dir);
+    }
+
+    public static async writeFile(filePath: string, data: string | Buffer): Promise<void> {
+        await fs.ensureDir(path.dirname(filePath));
+        await fs.writeFile(filePath, data);
+    }
+
+    public static async readFile(filePath: string): Promise<Buffer> {
+        return fs.readFile(filePath);
+    }
+
+    public static async fileExists(filePath: string): Promise<boolean> {
+        return fs.pathExists(filePath);
+    }
+
+    public static async deleteFile(filePath: string): Promise<void> {
+        if (await fs.pathExists(filePath)) {
+            await fs.remove(filePath);
+        }
+    }
+
+    public static async deleteFolder(folderPath: string): Promise<void> {
+        if (await fs.pathExists(folderPath)) {
+            await fs.remove(folderPath);
+        }
+    }
+
+    public static async copyFile(source: string, destination: string): Promise<void> {
+        await fs.ensureDir(path.dirname(destination));
+        await fs.copy(source, destination);
+    }
+
+    public static async moveFile(source: string, destination: string): Promise<void> {
+        await fs.ensureDir(path.dirname(destination));
+        await fs.move(source, destination, { overwrite: true });
+    }
+
+    public static async listFiles(dir: string, pattern?: RegExp): Promise<string[]> {
+        if (!await fs.pathExists(dir)) {
+            return [];
+        }
+
+        const files = await fs.readdir(dir);
+        
+        if (pattern) {
+            return files.filter(f => pattern.test(f));
+        }
+        
+        return files;
+    }
+
+    public static async getFileSize(filePath: string): Promise<number> {
+        const stat = await fs.stat(filePath);
+        return stat.size;
+    }
+
+    public static async extractZip(zipPath: string, destPath: string): Promise<void> {
+        this.logger.debug(`Extracting ${zipPath} to ${destPath}`);
+        
+        try {
+            const zip = new AdmZip(zipPath);
+            zip.extractAllTo(destPath, true);
+            this.logger.debug('Extraction complete');
+        } catch (error) {
+            this.logger.error('Failed to extract zip:', error);
+            throw error;
+        }
+    }
+
+    public static async extractTar(tarPath: string, destPath: string): Promise<void> {
+        this.logger.debug(`Extracting ${tarPath} to ${destPath}`);
+        
+        try {
+            await tar.extract({
+                file: tarPath,
+                cwd: destPath
+            });
+            this.logger.debug('Extraction complete');
+        } catch (error) {
+            this.logger.error('Failed to extract tar:', error);
+            throw error;
+        }
+    }
+
+    public static async createBackup(sourcePath: string, backupPath: string): Promise<void> {
+        this.logger.info(`Creating backup of ${sourcePath} to ${backupPath}`);
+        
+        await fs.ensureDir(path.dirname(backupPath));
+        
+        if (await fs.pathExists(sourcePath)) {
+            await fs.copy(sourcePath, backupPath);
+            const size = await this.getFileSize(backupPath);
+            this.logger.success(`Backup created: ${backupPath} (${size} bytes)`);
+        } else {
+            this.logger.warning(`Source path not found: ${sourcePath}`);
+        }
+    }
+
+    public static async writeProperties(filePath: string, properties: Record<string, any>): Promise<void> {
+        const lines: string[] = [];
+        
+        for (const [key, value] of Object.entries(properties)) {
+            if (value !== undefined && value !== null) {
+                lines.push(`${key}=${value}`);
+            }
+        }
+        
+        await this.writeFile(filePath, lines.join('\n'));
+        this.logger.debug(`Properties written to ${filePath}`);
+    }
+
+    public static async readProperties(filePath: string): Promise<Record<string, string>> {
+        if (!await this.fileExists(filePath)) {
+            return {};
+        }
+
+        const content = await fs.readFile(filePath, 'utf8');
+        const properties: Record<string, string> = {};
+
+        for (const line of content.split('\n')) {
+            const trimmed = line.trim();
+            if (trimmed && !trimmed.startsWith('#')) {
+                const eq = trimmed.indexOf('=');
+                if (eq > 0) {
+                    const key = trimmed.substring(0, eq).trim();
+                    const value = trimmed.substring(eq + 1).trim();
+                    properties[key] = value;
+                }
+            }
+        }
+
+        return properties;
+    }
+
+    public static async ensureServerStructure(config: any): Promise<void> {
+        const folders = [
+            config.folders.addons,
+            config.folders.mods,
+            config.folders.plugins,
+            config.folders.world,
+            path.join(process.cwd(), 'logs'),
+            path.join(process.cwd(), 'backups')
+        ];
+
+        for (const folder of folders) {
+            await this.ensureDir(folder);
+        }
+
+        this.logger.debug('Server structure created');
+    }
+}

package/src/utils/Logger.ts

@@ -0,0 +1,97 @@
+import chalk from 'chalk';
+
+export enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    SUCCESS = 2,
+    WARNING = 3,
+    ERROR = 4,
+    NONE = 5
+}
+
+export class Logger {
+    private static instance: Logger;
+    private logLevel: LogLevel = LogLevel.INFO;
+    private logFile: string | null = null;
+    private fs: any;
+
+    private constructor() {
+        try {
+            this.fs = require('fs-extra');
+        } catch {}
+    }
+
+    public static getInstance(): Logger {
+        if (!Logger.instance) {
+            Logger.instance = new Logger();
+        }
+        return Logger.instance;
+    }
+
+    public setLogLevel(level: LogLevel): void {
+        this.logLevel = level;
+    }
+
+    public setLogFile(filePath: string): void {
+        this.logFile = filePath;
+    }
+
+    private log(level: LogLevel, message: string, ...args: any[]): void {
+        if (level < this.logLevel) return;
+
+        const timestamp = new Date().toISOString();
+        const levelName = LogLevel[level];
+        
+        let coloredMessage = '';
+        switch (level) {
+            case LogLevel.DEBUG:
+                coloredMessage = chalk.gray(`[${timestamp}] [${levelName}] ${message}`);
+                break;
+            case LogLevel.INFO:
+                coloredMessage = chalk.cyan(`[${timestamp}] [${levelName}] ${message}`);
+                break;
+            case LogLevel.SUCCESS:
+                coloredMessage = chalk.green(`[${timestamp}] [${levelName}] ${message}`);
+                break;
+            case LogLevel.WARNING:
+                coloredMessage = chalk.yellow(`[${timestamp}] [${levelName}] ${message}`);
+                break;
+            case LogLevel.ERROR:
+                coloredMessage = chalk.red(`[${timestamp}] [${levelName}] ${message}`);
+                break;
+        }
+
+        console.log(coloredMessage, ...args);
+
+        if (this.logFile && this.fs) {
+            const logMessage = `[${timestamp}] [${levelName}] ${message} ${args.map(a => JSON.stringify(a)).join(' ')}\n`;
+            this.fs.appendFileSync(this.logFile, logMessage);
+        }
+    }
+
+    public debug(message: string, ...args: any[]): void {
+        this.log(LogLevel.DEBUG, message, ...args);
+    }
+
+    public info(message: string, ...args: any[]): void {
+        this.log(LogLevel.INFO, message, ...args);
+    }
+
+    public success(message: string, ...args: any[]): void {
+        this.log(LogLevel.SUCCESS, message, ...args);
+    }
+
+    public warning(message: string, ...args: any[]): void {
+        this.log(LogLevel.WARNING, message, ...args);
+    }
+
+    public error(message: string, ...args: any[]): void {
+        this.log(LogLevel.ERROR, message, ...args);
+    }
+
+    public banner(): void {
+        console.log(chalk.cyan(`
+Mc Headless - Powered By Dimzxzzx07
+        `));
+    }
+}

package/src/utils/PropertiesParser.ts

@@ -0,0 +1,126 @@
+export class PropertiesParser {
+    public static parse(content: string): Record<string, string> {
+        const properties: Record<string, string> = {};
+        const lines = content.split('\n');
+
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed && !trimmed.startsWith('#')) {
+                const eqIndex = trimmed.indexOf('=');
+                if (eqIndex > 0) {
+                    const key = trimmed.substring(0, eqIndex).trim();
+                    const value = trimmed.substring(eqIndex + 1).trim();
+                    properties[key] = value;
+                }
+            }
+        }
+
+        return properties;
+    }
+
+    public static stringify(properties: Record<string, any>): string {
+        const lines: string[] = [];
+
+        for (const [key, value] of Object.entries(properties)) {
+            if (value !== undefined && value !== null) {
+                lines.push(`${key}=${value}`);
+            }
+        }
+
+        return lines.join('\n');
+    }
+
+    public static generateServerProperties(config: any): Record<string, any> {
+        return {
+            'allow-flight': false,
+            'allow-nether': true,
+            'broadcast-console-to-ops': true,
+            'broadcast-rcon-to-ops': true,
+            'difficulty': config.world.difficulty,
+            'enable-command-block': false,
+            'enable-jmx-monitoring': false,
+            'enable-query': false,
+            'enable-rcon': false,
+            'enable-status': true,
+            'enforce-secure-profile': true,
+            'enforce-whitelist': false,
+            'entity-broadcast-range-percentage': 100,
+            'force-gamemode': false,
+            'function-permission-level': 2,
+            'gamemode': config.world.gamemode,
+            'generate-structures': true,
+            'generator-settings': '',
+            'hardcore': config.world.hardcore,
+            'hide-online-players': false,
+            'initial-disabled-packs': '',
+            'initial-enabled-packs': 'vanilla',
+            'level-name': config.world.levelName,
+            'level-seed': config.world.seed || '',
+            'level-type': 'minecraft\\:normal',
+            'max-chained-neighbor-updates': 1000000,
+            'max-players': config.world.maxPlayers,
+            'max-tick-time': 60000,
+            'max-world-size': 29999984,
+            'motd': config.network.motd,
+            'network-compression-threshold': 256,
+            'online-mode': config.network.onlineMode,
+            'op-permission-level': 4,
+            'player-idle-timeout': 0,
+            'prevent-proxy-connections': false,
+            'pvp': true,
+            'query.port': 25565,
+            'rate-limit': 0,
+            'rcon.password': '',
+            'rcon.port': 25575,
+            'require-resource-pack': false,
+            'resource-pack': '',
+            'resource-pack-id': '',
+            'resource-pack-prompt': '',
+            'resource-pack-sha1': '',
+            'server-ip': config.network.ip,
+            'server-port': config.network.port,
+            'simulation-distance': config.world.viewDistance,
+            'spawn-animals': true,
+            'spawn-monsters': true,
+            'spawn-npcs': true,
+            'spawn-protection': 16,
+            'sync-chunk-writes': true,
+            'text-filtering-config': '',
+            'use-native-transport': true,
+            'view-distance': config.world.viewDistance,
+            'white-list': false
+        };
+    }
+
+    public static generateBedrockProperties(config: any): Record<string, any> {
+        return {
+            'server-name': config.network.motd.replace(/§./g, ''),
+            'gamemode': config.world.gamemode,
+            'difficulty': config.world.difficulty,
+            'allow-cheats': false,
+            'max-players': config.world.maxPlayers,
+            'online-mode': config.network.onlineMode,
+            'white-list': false,
+            'server-port': config.network.bedrockPort || 19132,
+            'server-portv6': 19133,
+            'level-name': config.world.levelName,
+            'level-seed': config.world.seed || '',
+            'level-type': 'DEFAULT',
+            'enable-query': true,
+            'enable-rcon': false,
+            'rcon-port': 25575,
+            'rcon-password': '',
+            'max-threads': 8,
+            'tick-distance': 4,
+            'default-player-permission-level': 'member',
+            'texturepack-required': false,
+            'content-log-file-enabled': false,
+            'compression-threshold': 1,
+            'server-authoritative-movement': 'server-auth',
+            'player-movement-score-threshold': 20,
+            'player-movement-distance-threshold': 0.3,
+            'player-movement-duration-threshold-in-ms': 500,
+            'correct-player-movement': false
+        };
+    }
+}

package/src/utils/SystemDetector.ts

@@ -0,0 +1,127 @@
+import { execSync } from 'child_process';
+import * as os from 'os';
+
+export type OSType = 'linux' | 'darwin' | 'windows' | 'android' | 'unknown';
+export type DistroType = 'ubuntu' | 'debian' | 'centos' | 'fedora' | 'arch' | 'termux' | 'unknown';
+
+export class SystemDetector {
+    public static getOS(): OSType {
+        const platform = os.platform();
+        
+        if (platform === 'linux') {
+            if (process.env.TERMUX_VERSION || process.env.PREFIX === '/data/data/com.termux/files/usr') {
+                return 'android';
+            }
+            return 'linux';
+        } else if (platform === 'darwin') {
+            return 'darwin';
+        } else if (platform === 'win32') {
+            return 'windows';
+        }
+        
+        return 'unknown';
+    }
+
+    public static getDistro(): DistroType {
+        const osType = this.getOS();
+        
+        if (osType === 'android') {
+            return 'termux';
+        }
+        
+        if (osType === 'linux') {
+            try {
+                const osRelease = execSync('cat /etc/os-release').toString();
+                
+                if (osRelease.includes('Ubuntu')) return 'ubuntu';
+                if (osRelease.includes('Debian')) return 'debian';
+                if (osRelease.includes('CentOS')) return 'centos';
+                if (osRelease.includes('Fedora')) return 'fedora';
+                if (osRelease.includes('Arch')) return 'arch';
+            } catch {}
+        }
+        
+        return 'unknown';
+    }
+
+    public static hasJava(): boolean {
+        try {
+            execSync('java -version', { stdio: 'ignore' });
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    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 getArch(): string {
+        return os.arch();
+    }
+
+    public static getTotalMemory(): number {
+        return os.totalmem() / (1024 * 1024 * 1024);
+    }
+
+    public static getCPUCores(): number {
+        return os.cpus().length;
+    }
+
+    public static getSystemInfo(): any {
+        return {
+            os: this.getOS(),
+            distro: this.getDistro(),
+            arch: this.getArch(),
+            memoryGB: this.getTotalMemory(),
+            cpuCores: this.getCPUCores(),
+            hostname: os.hostname(),
+            platform: os.platform(),
+            release: os.release(),
+            hasJava: this.hasJava(),
+            javaVersion: this.getJavaVersion()
+        };
+    }
+
+    public static getJavaInstallCommand(): string {
+        const osType = this.getOS();
+        const distro = this.getDistro();
+
+        if (osType === 'android') {
+            return 'pkg install openjdk-17 -y';
+        }
+
+        if (osType === 'linux') {
+            switch (distro) {
+                case 'ubuntu':
+                case 'debian':
+                    return 'apt update && apt install openjdk-17-jre-headless -y';
+                case 'centos':
+                    return 'yum install java-17-openjdk-headless -y';
+                case 'fedora':
+                    return 'dnf install java-17-openjdk-headless -y';
+                case 'arch':
+                    return 'pacman -S jre17-openjdk-headless --noconfirm';
+                default:
+                    return 'echo "Please install Java 17 manually"';
+            }
+        }
+
+        if (osType === 'darwin') {
+            return 'brew install openjdk@17';
+        }
+
+        if (osType === 'windows') {
+            return 'Please download Java 17 from https://adoptium.net';
+        }
+
+        return 'echo "Unable to determine Java installation command"';
+    }
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "noImplicitAny": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}