asdf

app.py

@@ -3,12 +3,228 @@ from pathlib import Path
 import os
 import subprocess
 import sys
+import shutil
 
 PAPER_JAR_URL = "https://fill-data.papermc.io/v1/objects/234a9b32098100c6fc116664d64e36ccdb58b5b649af0f80bcccb08b0255eaea/paper-1.20.1-196.jar"
+NGROK_URL = "https://bin.equinox.io/c/bNyj1mQVY4c/ngrok-v3-stable-linux-amd64.tgz"
+
 DATA_DIR = Path("/data")
+JAVA_DIR = DATA_DIR / "java"
+NGROK_DIR = DATA_DIR / "ngrok"
 JAR_NAME = "paper-1.20.1-196.jar"
 JAR_PATH = DATA_DIR / JAR_NAME
 
+# Java download URLs (OpenJDK 17)
+JAVA_URLS = {
+    "linux_x64": "https://download.java.net/java/GA/jdk17.0.2/dfd4a8d0985749f896bed50d7138ee7f/8/GPL/openjdk-17.0.2_linux-x64_bin.tar.gz",
+    "linux_aarch64": "https://download.java.net/java/GA/jdk17.0.2/dfd4a8d0985749f896bed50d7138ee7f/8/GPL/openjdk-17.0.2_linux-aarch64_bin.tar.gz"
+}
+
+def load_env_vars():
+    """Load environment variables from .env file if it exists"""
+    env_vars = {}
+    env_file = Path(".env")
+    
+    if env_file.exists():
+        try:
+            with open(env_file, 'r') as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith('#') and '=' in line:
+                        key, value = line.split('=', 1)
+                        env_vars[key.strip()] = value.strip().strip('"\'')
+            print(f"Loaded {len(env_vars)} environment variables from .env")
+        except Exception as e:
+            print(f"Warning: Could not read .env file: {e}")
+    
+    # Also check system environment variables
+    ngrok_token = env_vars.get('NGROK_TOKEN') or os.getenv('NGROK_TOKEN')
+    
+    return {
+        'NGROK_TOKEN': ngrok_token
+    }
+
+def check_ngrok():
+    """Check if ngrok is available and return the path"""
+    # Check system PATH first
+    ngrok_path = shutil.which("ngrok")
+    if ngrok_path:
+        try:
+            result = subprocess.run([ngrok_path, "version"], capture_output=True, text=True)
+            print(f"Found ngrok: {ngrok_path}")
+            print(f"Version: {result.stdout.strip()}")
+            return ngrok_path
+        except:
+            pass
+    
+    # Check our custom ngrok installation
+    custom_ngrok = NGROK_DIR / "ngrok"
+    if custom_ngrok.exists():
+        try:
+            result = subprocess.run([str(custom_ngrok), "version"], capture_output=True, text=True)
+            print(f"Found custom ngrok: {custom_ngrok}")
+            print(f"Version: {result.stdout.strip()}")
+            return str(custom_ngrok)
+        except:
+            pass
+    
+    return None
+
+def install_ngrok():
+    """Download and install ngrok"""
+    print("Installing ngrok...")
+    
+    # Create ngrok directory
+    NGROK_DIR.mkdir(parents=True, exist_ok=True)
+    
+    # Download ngrok
+    ngrok_archive = DATA_DIR / "ngrok.tgz"
+    if not download_file(NGROK_URL, ngrok_archive):
+        return False
+    
+    # Extract ngrok
+    print("Extracting ngrok...")
+    try:
+        import tarfile
+        with tarfile.open(ngrok_archive, 'r:gz') as tar:
+            tar.extractall(NGROK_DIR)
+        
+        # Make ngrok executable
+        ngrok_bin = NGROK_DIR / "ngrok"
+        ngrok_bin.chmod(0o755)
+        
+        # Clean up
+        ngrok_archive.unlink()
+        
+        print(f"✓ ngrok installed to: {ngrok_bin}")
+        return True
+        
+    except Exception as e:
+        print(f"Failed to extract ngrok: {e}")
+        return False
+
+def setup_ngrok():
+    """Setup ngrok with authentication token"""
+    env_vars = load_env_vars()
+    ngrok_token = env_vars.get('NGROK_TOKEN')
+    
+    if not ngrok_token:
+        print("Warning: NGROK_TOKEN not found in environment variables or .env file")
+        print("Please set NGROK_TOKEN in your .env file or Hugging Face Space secrets")
+        return False
+    
+    # Get ngrok path
+    ngrok_path = check_ngrok()
+    if not ngrok_path:
+        print("ngrok not found. Installing...")
+        if not install_ngrok():
+            print("Failed to install ngrok")
+            return False
+        ngrok_path = check_ngrok()
+        if not ngrok_path:
+            print("ngrok installation failed")
+            return False
+    
+    # Configure ngrok with auth token
+    print("Configuring ngrok with auth token...")
+    try:
+        result = subprocess.run([
+            ngrok_path, "config", "add-authtoken", ngrok_token
+        ], capture_output=True, text=True)
+        
+        if result.returncode == 0:
+            print("✓ ngrok configured successfully")
+            return True
+        else:
+            print(f"Failed to configure ngrok: {result.stderr}")
+            return False
+            
+    except Exception as e:
+        print(f"Failed to configure ngrok: {e}")
+        return False
+
+def start_ngrok_tunnel(port=25565):
+    """Start ngrok tunnel for the Minecraft server"""
+    ngrok_path = check_ngrok()
+    if not ngrok_path:
+        print("ngrok not found. Run setup first.")
+        return None
+    
+    print(f"Starting ngrok tunnel for port {port}...")
+    try:
+        # Start ngrok in background
+        process = subprocess.Popen([
+            ngrok_path, "tcp", str(port), "--log", "stdout"
+        ], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        
+        # Give ngrok a moment to start
+        import time
+        time.sleep(3)
+        
+        # Try to get the tunnel URL from ngrok API
+        try:
+            import json
+            import urllib.request
+            
+            # ngrok exposes a local API on port 4040
+            api_url = "http://localhost:4040/api/tunnels"
+            with urllib.request.urlopen(api_url) as response:
+                data = json.loads(response.read().decode())
+                
+            if data.get('tunnels'):
+                tunnel_url = data['tunnels'][0]['public_url']
+                print(f"✓ ngrok tunnel active: {tunnel_url}")
+                print(f"Players can connect to: {tunnel_url.replace('tcp://', '')}")
+                return process, tunnel_url
+            else:
+                print("No active tunnels found")
+                return process, None
+                
+        except Exception as e:
+            print(f"Could not retrieve tunnel URL: {e}")
+            print("Check ngrok dashboard at http://localhost:4040")
+            return process, None
+            
+    except Exception as e:
+        print(f"Failed to start ngrok tunnel: {e}")
+        return None, None
+
+def check_java():
+    """Check if Java is available and return the path"""
+    # Check if java is already in PATH
+    java_path = shutil.which("java")
+    if java_path:
+        try:
+            result = subprocess.run([java_path, "-version"], capture_output=True, text=True)
+            print(f"Found Java: {java_path}")
+            print(result.stderr.split('\n')[0])  # Java version info is in stderr
+            return java_path
+        except:
+            pass
+    
+    # Check our custom Java installation
+    custom_java = JAVA_DIR / "bin" / "java"
+    if custom_java.exists():
+        try:
+            result = subprocess.run([str(custom_java), "-version"], capture_output=True, text=True)
+            print(f"Found custom Java: {custom_java}")
+            print(result.stderr.split('\n')[0])  # Java version info is in stderr
+            return str(custom_java)
+        except:
+            pass
+    
+    return None
+    """Detect the platform architecture"""
+    import platform
+    machine = platform.machine().lower()
+    if 'x86_64' in machine or 'amd64' in machine:
+        return "linux_x64"
+    elif 'aarch64' in machine or 'arm64' in machine:
+        return "linux_aarch64"
+    else:
+        print(f"Unsupported architecture: {machine}")
+        return "linux_x64"  # Default fallback
+
 def download_file(url, destination):
     print(f"Downloading {url}...")
     try:
@@ -43,9 +259,80 @@ def download_file(url, destination):
         print(f"\n✗ Failed to download {url}: {e}")
         return False
 
-def setup_minecraft_server():    
+def install_java():
+    """Download and install Java if not available"""
+    print("Installing Java...")
+    
+    platform_key = get_platform()
+    java_url = JAVA_URLS.get(platform_key)
+    
+    if not java_url:
+        print(f"No Java download available for platform: {platform_key}")
+        return False
+    
+    # Download Java
+    java_archive = DATA_DIR / "java.tar.gz"
+    if not download_file(java_url, java_archive):
+        return False
+    
+    # Extract Java
+    print("Extracting Java...")
+    try:
+        import tarfile
+        with tarfile.open(java_archive, 'r:gz') as tar:
+            # Extract to temporary directory first
+            temp_dir = DATA_DIR / "java_temp"
+            temp_dir.mkdir(exist_ok=True)
+            tar.extractall(temp_dir)
+            
+            # Find the extracted JDK directory (usually has a version number)
+            extracted_dirs = [d for d in temp_dir.iterdir() if d.is_dir() and d.name.startswith('jdk')]
+            if not extracted_dirs:
+                print("Could not find extracted JDK directory")
+                return False
+            
+            jdk_dir = extracted_dirs[0]
+            
+            # Move to final location
+            if JAVA_DIR.exists():
+                shutil.rmtree(JAVA_DIR)
+            shutil.move(str(jdk_dir), str(JAVA_DIR))
+            
+            # Clean up
+            shutil.rmtree(temp_dir)
+            java_archive.unlink()
+            
+        print(f"✓ Java installed to: {JAVA_DIR}")
+        
+        # Make java executable
+        java_bin = JAVA_DIR / "bin" / "java"
+        java_bin.chmod(0o755)
+        
+        return True
+        
+    except Exception as e:
+        print(f"Failed to extract Java: {e}")
+        return False
+
+def setup_minecraft_server():
+    """Set up the Minecraft server in persistent storage"""
+    
+    # Ensure the data directory exists
     DATA_DIR.mkdir(parents=True, exist_ok=True)
     
+    # Check and install Java if needed
+    java_path = check_java()
+    if not java_path:
+        print("Java not found. Installing Java...")
+        if not install_java():
+            print("Failed to install Java. Cannot proceed.")
+            return False
+        java_path = check_java()
+        if not java_path:
+            print("Java installation failed or not working.")
+            return False
+    
+    # Download the server JAR if it doesn't exist
     if not JAR_PATH.exists():
         print(f"Downloading Minecraft server to {JAR_PATH}")
         if not download_file(PAPER_JAR_URL, JAR_PATH):
@@ -53,8 +340,10 @@ def setup_minecraft_server():
     else:
         print(f"Server JAR already exists at {JAR_PATH}")
     
+    # Create server.properties file if it doesn't exist
     server_properties_path = DATA_DIR / "server.properties"
     if not server_properties_path.exists():
+        print("Creating server.properties...")
         server_properties = """# Minecraft server properties
 server-port=25565
 gamemode=survival
@@ -68,23 +357,38 @@ motd=Hugging Face Minecraft Server
         with open(server_properties_path, 'w') as f:
             f.write(server_properties)
     
+    # Create eula.txt (required for server to start)
     eula_path = DATA_DIR / "eula.txt"
     if not eula_path.exists():
+        print("Creating eula.txt...")
         with open(eula_path, 'w') as f:
             f.write("eula=true\n")
+    
+    print("✓ Minecraft server setup complete!")
+    print(f"Server files are stored in: {DATA_DIR}")
+    print(f"Java path: {java_path}")
     return True
 
 def start_server():
+    """Start the Minecraft server"""
     if not JAR_PATH.exists():
         print("Server JAR not found. Run setup first.")
         return False
     
+    # Get Java path
+    java_path = check_java()
+    if not java_path:
+        print("Java not found. Run setup first.")
+        return False
+    
+    # Change to the data directory
     os.chdir(DATA_DIR)
     
+    # Start the server
     cmd = [
-        "java",
-        "-Xmx2G",
-        "-Xms1G",
+        java_path,
+        "-Xmx2G",  # Max heap size
+        "-Xms1G",  # Initial heap size
         "-jar", str(JAR_PATH),
         "--nogui"
     ]
@@ -101,6 +405,7 @@ def start_server():
             bufsize=1
         )
         
+        # Print server output in real-time
         for line in process.stdout:
             print(line.strip())
             
@@ -109,5 +414,7 @@ def start_server():
         return False
 
 if __name__ == "__main__":
-    setup_minecraft_server()
-    start_server()
+    if setup_minecraft_server():
+        start_server()
+    else:
+        print("Setup failed. Cannot start server.")