Spaces:

lovyone
/

1102

Runtime error

App Files Files Community

lovyone commited on Feb 25

Commit

ea2a165

verified ·

1 Parent(s): 83f55db

Upload 4 files

Browse files

Files changed (4) hide show

Dockerfile +52 -0
requirements.txt +3 -0
static/index.html +615 -0
xmrig_launcher.py +343 -0

Dockerfile ADDED Viewed

	@@ -0,0 +1,52 @@

+# Use official Python runtime as base image
+FROM python:3.13
+# Set working directory
+WORKDIR /app
+# Install system dependencies and build tools
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    wget \
+    unzip \
+    gcc \
+    g++ \
+    && rm -rf /var/lib/apt/lists/*
+# Copy requirements.txt
+COPY requirements.txt .
+# Install Python dependencies using pre-built wheels only
+RUN pip install --no-cache-dir --only-binary :all: -r requirements.txt
+# Copy the launcher/server application
+COPY xmrig_launcher.py .
+# Copy static files for the web UI
+COPY static ./static
+# Create xmrig directory with write permissions
+RUN mkdir -p /app/xmrig
+# Download and extract XMRig (Linux version)
+# RUN cd /app/xmrig && \
+#     wget -q https://github.com/xmrig/xmrig/releases/download/v6.21.0/xmrig-6.21.0-linux-static-x64.tar.gz -O xmrig.tar.gz && \
+#     tar -xzf xmrig.tar.gz && \
+#     rm xmrig.tar.gz && \
+#     chmod +x xmrig-6.21.0/xmrig && \
+#     ls -la xmrig-6.21.0/ | head -20
+# Set permissions for all app files
+RUN chmod -R 777 /app
+# Expose port 8000 for the web server
+EXPOSE 8000
+# Run as root (default in Docker) for admin privileges
+USER root
+# Health check
+# Start the server with uvicorn
+CMD ["python", "-m", "uvicorn", "xmrig_launcher:app", "--host", "0.0.0.0", "--port", "8000"]

requirements.txt ADDED Viewed

	@@ -0,0 +1,3 @@

+fastapi>=0.100.0
+uvicorn[standard]>=0.24.0
+pydantic>=2.0.0

static/index.html ADDED Viewed

	@@ -0,0 +1,615 @@

+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>XMRig Mining Server</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        body {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            padding: 20px;
+        }
+        .container-main {
+            max-width: 1000px;
+            margin: 0 auto;
+        }
+        .header {
+            text-align: center;
+            color: white;
+            margin-bottom: 40px;
+            animation: slideDown 0.6s ease-out;
+        }
+        @keyframes slideDown {
+            from {
+                opacity: 0;
+                transform: translateY(-30px);
+            }
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+        .header h1 {
+            font-size: 3em;
+            font-weight: 700;
+            margin-bottom: 10px;
+            text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.3);
+        }
+        .header p {
+            font-size: 1.2em;
+            opacity: 0.95;
+        }
+        .card-custom {
+            background: rgba(255, 255, 255, 0.95);
+            border: none;
+            border-radius: 15px;
+            box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
+            backdrop-filter: blur(10px);
+            margin-bottom: 25px;
+            animation: fadeIn 0.6s ease-out;
+        }
+        @keyframes fadeIn {
+            from {
+                opacity: 0;
+                transform: translateY(20px);
+            }
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+        .card-header-custom {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            font-weight: 600;
+            font-size: 1.2em;
+            padding: 20px;
+            border-radius: 15px 15px 0 0;
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+        .card-body-custom {
+            padding: 25px;
+        }
+        .status-badge {
+            display: inline-block;
+            padding: 10px 20px;
+            border-radius: 25px;
+            font-weight: 600;
+            font-size: 0.95em;
+        }
+        .status-running {
+            background: linear-gradient(135deg, #11998e 0%, #38ef7d 100%);
+            color: white;
+            animation: pulse 1.5s infinite;
+        }
+        @keyframes pulse {
+            0%, 100% { opacity: 1; }
+            50% { opacity: 0.7; }
+        }
+        .status-stopped {
+            background: linear-gradient(135deg, #eb3349 0%, #f45c43 100%);
+            color: white;
+        }
+        .status-admin {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+        }
+        .info-row {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 20px;
+            margin-bottom: 15px;
+        }
+        .info-item {
+            padding: 15px;
+            background: #f8f9fa;
+            border-radius: 10px;
+            border-left: 4px solid #667eea;
+        }
+        .info-item label {
+            font-weight: 600;
+            color: #333;
+            display: block;
+            margin-bottom: 5px;
+        }
+        .info-item value {
+            font-size: 1.1em;
+            color: #667eea;
+            font-weight: 600;
+        }
+        .form-group {
+            margin-bottom: 20px;
+        }
+        .form-group label {
+            font-weight: 600;
+            color: #333;
+            margin-bottom: 8px;
+            display: block;
+        }
+        .form-control-custom {
+            border: 2px solid #e0e0e0;
+            border-radius: 10px;
+            padding: 12px 15px;
+            font-size: 1em;
+            transition: all 0.3s ease;
+        }
+        .form-control-custom:focus {
+            border-color: #667eea;
+            box-shadow: 0 0 0 0.2rem rgba(102, 126, 234, 0.1);
+            outline: none;
+        }
+        .btn-custom {
+            font-weight: 600;
+            padding: 12px 25px;
+            border-radius: 10px;
+            border: none;
+            transition: all 0.3s ease;
+            font-size: 1em;
+        }
+        .btn-start {
+            background: linear-gradient(135deg, #11998e 0%, #38ef7d 100%);
+            color: white;
+        }
+        .btn-start:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 10px 25px rgba(17, 153, 142, 0.3);
+            color: white;
+        }
+        .btn-start:disabled {
+            opacity: 0.6;
+            cursor: not-allowed;
+        }
+        .btn-stop {
+            background: linear-gradient(135deg, #eb3349 0%, #f45c43 100%);
+            color: white;
+        }
+        .btn-stop:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 10px 25px rgba(235, 51, 73, 0.3);
+            color: white;
+        }
+        .btn-stop:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+        }
+        .btn-group-custom {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 15px;
+            margin-top: 20px;
+        }
+        .logs-container {
+            background: #1e1e1e;
+            color: #0fc700;
+            padding: 20px;
+            border-radius: 10px;
+            font-family: 'Courier New', monospace;
+            font-size: 0.9em;
+            line-height: 1.6;
+            max-height: 500px;
+            overflow-y: auto;
+            border: 2px solid #333;
+        }
+        .logs-container::-webkit-scrollbar {
+            width: 8px;
+        }
+        .logs-container::-webkit-scrollbar-track {
+            background: #2d2d2d;
+            border-radius: 5px;
+        }
+        .logs-container::-webkit-scrollbar-thumb {
+            background: #667eea;
+            border-radius: 5px;
+        }
+        .log-line {
+            margin: 2px 0;
+            word-break: break-word;
+        }
+        .log-error {
+            color: #ff6b6b;
+        }
+        .log-success {
+            color: #51cf66;
+        }
+        .log-warning {
+            color: #ffd700;
+        }
+        .log-info {
+            color: #74c0fc;
+        }
+        .spinner {
+            display: none;
+            width: 18px;
+            height: 18px;
+            border: 3px solid rgba(255, 255, 255, 0.3);
+            border-top-color: white;
+            border-radius: 50%;
+            animation: spin 0.8s linear infinite;
+            margin-right: 8px;
+        }
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+        .spinner.active {
+            display: inline-block;
+        }
+        .stats-grid {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 15px;
+        }
+        .stat-box {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 20px;
+            border-radius: 10px;
+            text-align: center;
+        }
+        .stat-label {
+            font-size: 0.9em;
+            opacity: 0.9;
+            margin-bottom: 5px;
+        }
+        .stat-value {
+            font-size: 1.8em;
+            font-weight: 700;
+        }
+        .warning-box {
+            background: #fff3cd;
+            border: 2px solid #ffc107;
+            border-radius: 10px;
+            padding: 15px;
+            margin-bottom: 20px;
+            display: none;
+        }
+        .warning-box.show {
+            display: block;
+        }
+        .warning-box strong {
+            color: #856404;
+        }
+        @media (max-width: 768px) {
+            .info-row, .stats-grid {
+                grid-template-columns: 1fr;
+            }
+            .btn-group-custom {
+                grid-template-columns: 1fr;
+            }
+            .header h1 {
+                font-size: 2em;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container-main">
+        <!-- Header -->
+        <div class="header">
+            <h1>⛏️ XMRig Mining</h1>
+            <p>RandomX Benchmarking Server</p>
+        </div>
+        <!-- System Status -->
+        <div class="card-custom">
+            <div class="card-header-custom">
+                📊 System Status
+            </div>
+            <div class="card-body-custom">
+                <div class="stats-grid">
+                    <div class="stat-box">
+                        <div class="stat-label">Platform</div>
+                        <div class="stat-value" id="platform">Loading...</div>
+                    </div>
+                    <div class="stat-box">
+                        <div class="stat-label">CPU Cores</div>
+                        <div class="stat-value" id="cpu-count">Loading...</div>
+                    </div>
+                </div>
+                <div style="margin-top: 15px;">
+                    <div id="admin-status" style="text-align: center;"></div>
+                    <div style="text-align: center; margin-top: 10px; color: #666;">
+                        <strong>XMRig:</strong> <span id="binary-status">Loading...</span>
+                    </div>
+                </div>
+            </div>
+        </div>
+        <!-- Mining Control -->
+        <div class="card-custom">
+            <div class="card-header-custom">
+                🚀 Mining Control
+            </div>
+            <div class="card-body-custom">
+                <div style="text-align: center; margin-bottom: 20px;">
+                    <span id="status-badge" class="status-badge status-stopped">⏹️ Stopped</span>
+                </div>
+                <div class="warning-box" id="admin-warning">
+                    <strong>⚠️ Warning:</strong> Not running as Administrator. Performance will be limited. Run as Admin for 2-3x better hash rates.
+                </div>
+                <!-- Benchmark Type -->
+                <div class="form-group">
+                    <label>Benchmark Type</label>
+                    <select id="benchmark-type" class="form-control-custom w-100">
+                        <option value="1M">1M Hash (Fast ~1 min)</option>
+                        <option value="10M" selected>10M Hash (Accurate ~10 min)</option>
+                    </select>
+                    <small style="color: #999; display: block; margin-top: 5px;">Choose benchmark size</small>
+                </div>
+                <!-- Threads -->
+                <div class="form-group">
+                    <label>Threads</label>
+                    <input type="number" id="threads" class="form-control-custom w-100" value="8" min="1" max="64">
+                    <small style="color: #999; display: block; margin-top: 5px;">Number of threads (default: 8)</small>
+                </div>
+                <!-- Control Buttons -->
+                <div class="btn-group-custom">
+                    <button class="btn btn-custom btn-start" id="start-btn" onclick="startMining()">
+                        <span class="spinner" id="start-spinner"></span>
+                        ▶️ Start Mining
+                    </button>
+                    <button class="btn btn-custom btn-stop" id="stop-btn" onclick="stopMining()" disabled>
+                        ⏹️ Stop Mining
+                    </button>
+                </div>
+            </div>
+        </div>
+        <!-- Mining Logs -->
+        <div class="card-custom">
+            <div class="card-header-custom">
+                📋 Live Mining Logs
+            </div>
+            <div class="card-body-custom">
+                <div class="logs-container" id="logs-container">
+                    <div class="log-line log-info">[*] Waiting for mining to start...</div>
+                </div>
+            </div>
+        </div>
+    </div>
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
+    <script>
+        const API_URL = '/';
+        let statusCheckInterval = null;
+        let lastLogCount = 0;
+        async function getStatus() {
+            try {
+                const response = await fetch(API_URL + 'status');
+                const data = await response.json();
+                updateUI(data);
+            } catch (error) {
+                console.error('Error fetching status:', error);
+            }
+        }
+        async function getLogs() {
+            try {
+                const response = await fetch(API_URL + 'logs');
+                const data = await response.json();
+                updateLogs(data.logs);
+            } catch (error) {
+                console.error('Error fetching logs:', error);
+            }
+        }
+        function updateLogs(logs) {
+            const logsContainer = document.getElementById('logs-container');
+            if (logs.length === 0) {
+                logsContainer.innerHTML = '<div class="log-line log-info">[*] Waiting for logs...</div>';
+                return;
+            }
+            if (logs.length > lastLogCount) {
+                const newLogs = logs.slice(lastLogCount);
+                newLogs.forEach(log => {
+                    const logLine = document.createElement('div');
+                    logLine.className = 'log-line';
+                    if (log.message.includes('[!]') || log.message.includes('FAILED')) {
+                        logLine.classList.add('log-error');
+                    } else if (log.message.includes('[+]')) {
+                        logLine.classList.add('log-success');
+                    } else if (log.message.includes('[*]')) {
+                        logLine.classList.add('log-info');
+                    } else if (log.message.includes('H/s') || log.message.includes('speed')) {
+                        logLine.classList.add('log-success');
+                    } else {
+                        logLine.classList.add('log-info');
+                    }
+                    logLine.textContent = log.message;
+                    logsContainer.appendChild(logLine);
+                });
+                logsContainer.scrollTop = logsContainer.scrollHeight;
+            }
+            lastLogCount = logs.length;
+        }
+        function updateUI(data) {
+            // System Info
+            document.getElementById('platform').textContent = data.system.platform;
+            document.getElementById('cpu-count').textContent = data.system.cpu_count;
+            // Admin Status
+            const adminStatus = document.getElementById('admin-status');
+            if (data.system.admin) {
+                adminStatus.innerHTML = '<span class="status-badge status-admin">✓ Administrator</span>';
+                document.getElementById('admin-warning').classList.remove('show');
+            } else {
+                adminStatus.innerHTML = '<span class="status-badge" style="background: linear-gradient(135deg, #eb3349 0%, #f45c43 100%); color: white;">✗ Standard User</span>';
+                document.getElementById('admin-warning').classList.add('show');
+            }
+            // Binary Status
+            if (data.xmrig.binary_exists) {
+                document.getElementById('binary-status').textContent = '✓ Ready';
+                document.getElementById('start-btn').disabled = false;
+            } else {
+                document.getElementById('binary-status').textContent = '✗ Missing';
+                document.getElementById('start-btn').disabled = true;
+            }
+            // Mining Status
+            if (data.benchmark.running) {
+                document.getElementById('status-badge').textContent = '▶️ Running';
+                document.getElementById('status-badge').className = 'status-badge status-running';
+                document.getElementById('start-btn').disabled = true;
+                document.getElementById('stop-btn').disabled = false;
+            } else {
+                document.getElementById('status-badge').textContent = '⏹️ Stopped';
+                document.getElementById('status-badge').className = 'status-badge status-stopped';
+                document.getElementById('start-btn').disabled = false;
+                document.getElementById('stop-btn').disabled = true;
+            }
+        }
+        async function startMining() {
+            const benchmark = document.getElementById('benchmark-type').value;
+            const threads = parseInt(document.getElementById('threads').value) || 8;
+            const btn = document.getElementById('start-btn');
+            const spinner = document.getElementById('start-spinner');
+            btn.disabled = true;
+            spinner.classList.add('active');
+            try {
+                const response = await fetch(API_URL + 'benchmark/start', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ benchmark, threads })
+                });
+                if (response.ok) {
+                    const data = await response.json();
+                    console.log('Mining started:', data);
+                    lastLogCount = 0;
+                    startStatusPolling();
+                    await getStatus();
+                } else {
+                    const error = await response.json();
+                    alert('Error: ' + error.detail);
+                    btn.disabled = false;
+                    spinner.classList.remove('active');
+                }
+            } catch (error) {
+                alert('Error: ' + error.message);
+                btn.disabled = false;
+                spinner.classList.remove('active');
+            }
+        }
+        async function stopMining() {
+            const btn = document.getElementById('stop-btn');
+            btn.disabled = true;
+            try {
+                const response = await fetch(API_URL + 'benchmark/stop', { method: 'POST' });
+                if (response.ok) {
+                    stopStatusPolling();
+                    await getStatus();
+                } else {
+                    alert('Failed to stop mining');
+                }
+            } catch (error) {
+                alert('Error: ' + error.message);
+            }
+        }
+        function startStatusPolling() {
+            if (statusCheckInterval) return;
+            statusCheckInterval = setInterval(() => {
+                getStatus();
+                getLogs();
+            }, 1000);
+        }
+        function stopStatusPolling() {
+            if (statusCheckInterval) {
+                clearInterval(statusCheckInterval);
+                statusCheckInterval = null;
+            }
+        }
+        // Initial load
+        getStatus();
+        getLogs();
+        // Refresh every 2 seconds
+        setInterval(() => {
+            getStatus();
+            getLogs();
+        }, 2000);
+    </script>
+</body>
+</html>

xmrig_launcher.py ADDED Viewed

	@@ -0,0 +1,343 @@

+#!/usr/bin/env python3
+"""
+XMRig FastAPI Server - Web interface for RandomX benchmarking
+"""
+import os
+import sys
+import subprocess
+import json
+import platform
+import ctypes
+from pathlib import Path
+from typing import Optional
+from datetime import datetime
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+from fastapi.responses import JSONResponse, HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+import uvicorn
+import threading
+# ==================== Admin Detection ====================
+def is_admin():
+    """Check if running with admin privileges"""
+    try:
+        return ctypes.windll.shell.IsUserAnAdmin()
+    except:
+        return False
+# ==================== Pydantic Models ====================
+class BenchmarkRequest(BaseModel):
+    benchmark: str = "1M"
+    threads: Optional[int] = None
+class BenchmarkResponse(BaseModel):
+    status: str
+    benchmark: str
+    threads: int
+    running: bool
+    started_at: Optional[str] = None
+# ==================== XMRig Launcher Class ====================
+class XMRigLauncher:
+    def __init__(self, base_dir=None):
+        if base_dir is None:
+            base_dir = Path(__file__).parent.absolute()
+        self.base_dir = Path(base_dir)
+        self.xmrig_dir = self.base_dir / "xmrig"
+        self.xmrig_extracted = self.xmrig_dir / "xmrig-6.21.0"
+        self.xmrig_bin = self.xmrig_extracted / ("xmrig.exe" if platform.system() == "Windows" else "xmrig")
+        self.process = None
+        self.benchmark_config = {}
+        self.logs = []
+        self.log_reader_thread = None
+    def start_benchmark(self, benchmark="1M", threads=None):
+        """Start XMRig benchmark process"""
+        if not self.xmrig_bin.exists():
+            raise HTTPException(status_code=400, detail="XMRig binary not found. Please install it manually.")
+        if self.process and self.process.poll() is None:
+            raise HTTPException(status_code=400, detail="Benchmark already running")
+        if threads is None:
+            threads = os.cpu_count() or 4
+        # Clear previous logs
+        self.logs = []
+        # Build command
+        cmd = [str(self.xmrig_bin), f"--bench={benchmark}", "--threads", str(threads)]
+        # Store config
+        self.benchmark_config = {
+            "benchmark": benchmark,
+            "threads": threads,
+            "started_at": datetime.now().isoformat(),
+            "status": "running"
+        }
+        try:
+            # Start process with output capture
+            self.process = subprocess.Popen(
+                cmd,
+                cwd=str(self.xmrig_extracted),
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1,
+                universal_newlines=True
+            )
+            # Start log reader thread
+            self.log_reader_thread = threading.Thread(target=self._read_logs, daemon=True)
+            self.log_reader_thread.start()
+            return True
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Failed to start benchmark: {e}")
+    def _read_logs(self):
+        """Read logs from process in real-time (daemon thread)"""
+        try:
+            if self.process and self.process.stdout:
+                # This runs in a daemon thread, so blocking readline is fine
+                while self.process and self.process.poll() is None:
+                    try:
+                        line = self.process.stdout.readline()
+                        if line:
+                            log_entry = {
+                                "timestamp": datetime.now().isoformat(),
+                                "message": line.rstrip()
+                            }
+                            self.logs.append(log_entry)
+                            print(line.rstrip())
+                        else:
+                            # EOF reached
+                            break
+                    except Exception as e:
+                        print(f"[!] Error reading line: {e}")
+                        break
+        except Exception as e:
+            print(f"[!] Error in log reader: {e}")
+    def stop_benchmark(self):
+        """Stop running benchmark"""
+        if self.process and self.process.poll() is None:
+            self.process.terminate()
+            try:
+                self.process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self.process.kill()
+            self.benchmark_config["status"] = "stopped"
+            return True
+        return False
+    def is_running(self):
+        """Check if benchmark is running"""
+        return self.process and self.process.poll() is None
+    def get_output(self):
+        """Get benchmark output"""
+        if not self.process:
+            return ""
+        output = ""
+        try:
+            # Non-blocking read
+            if self.process.stdout:
+                import select
+                import io
+                ready = select.select([self.process.stdout], [], [], 0)[0]
+                if ready:
+                    output = self.process.stdout.read()
+        except:
+            pass
+        return output
+from contextlib import asynccontextmanager
+# Global launcher instance
+launcher = XMRigLauncher()
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup
+    print("\n[*] Server starting...")
+    # Check if XMRig binary exists
+    if not launcher.xmrig_bin.exists():
+        print(f"[!] XMRig binary not found at {launcher.xmrig_bin}")
+        print("[!] Please ensure XMRig is installed manually")
+    else:
+        print("[+] XMRig binary found")
+    print("[+] Server ready - click Start Mining button to begin")
+    yield
+    # Shutdown
+    print("\n[*] Server shutting down...")
+    launcher.stop_benchmark()
+# ==================== FastAPI App ====================
+app = FastAPI(
+    title="XMRig Server",
+    description="FastAPI server for RandomX benchmarking with XMRig",
+    version="1.0.0",
+    lifespan=lifespan
+)
+# Mount static files (if directory exists)
+static_dir = Path(__file__).parent / "static"
+if static_dir.exists():
+    app.mount("/static", StaticFiles(directory="static"), name="static")
+else:
+    print("[!] Warning: static/ directory not found, UI will not be available")
+@app.get("/api")
+async def api_info():
+    """API endpoints info"""
+    return {
+        "name": "XMRig Server",
+        "version": "1.0.0",
+        "endpoints": {
+            "GET /health": "Health check",
+            "GET /status": "Get system and benchmark status",
+            "POST /benchmark/start": "Start benchmark",
+            "POST /benchmark/stop": "Stop benchmark",
+            "GET /benchmark/status": "Get benchmark status"
+        }
+    }
+@app.get("/")
+async def root():
+    """Root endpoint - serve static HTML UI"""
+    try:
+        with open("static/index.html", "r", encoding="utf-8") as f:
+            return HTMLResponse(content=f.read())
+    except FileNotFoundError:
+        return HTMLResponse(
+            content="<h1>404</h1><p>static/index.html not found</p>",
+            status_code=404
+        )
+@app.get("/health")
+async def health():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "admin": is_admin()
+    }
+@app.get("/status")
+async def status():
+    """Get system and benchmark status"""
+    return {
+        "system": {
+            "platform": platform.system(),
+            "admin": is_admin(),
+            "cpu_count": os.cpu_count() or 4
+        },
+        "xmrig": {
+            "binary_exists": launcher.xmrig_bin.exists(),
+            "binary_path": str(launcher.xmrig_bin),
+            "base_dir": str(launcher.base_dir)
+        },
+        "benchmark": {
+            "running": launcher.is_running(),
+            "config": launcher.benchmark_config if launcher.benchmark_config else None
+        }
+    }
+@app.post("/benchmark/start")
+async def start_benchmark(request: BenchmarkRequest):
+    """Start a benchmark"""
+    if launcher.is_running():
+        raise HTTPException(status_code=400, detail="Benchmark already running")
+    launcher.start_benchmark(request.benchmark, request.threads)
+    return {
+        "status": "started",
+        "benchmark": request.benchmark,
+        "threads": request.threads or os.cpu_count() or 4,
+        "admin": is_admin(),
+        "admin_warning": "Run with admin for 2-3x better performance" if not is_admin() else None
+    }
+@app.post("/benchmark/stop")
+async def stop_benchmark():
+    """Stop running benchmark"""
+    if launcher.stop_benchmark():
+        return {"status": "stopped"}
+    else:
+        raise HTTPException(status_code=400, detail="No benchmark running")
+@app.get("/benchmark/status")
+async def benchmark_status():
+    """Get benchmark status"""
+    return {
+        "running": launcher.is_running(),
+        "config": launcher.benchmark_config if launcher.benchmark_config else None,
+        "pid": launcher.process.pid if launcher.process else None
+    }
+@app.get("/logs")
+async def get_logs():
+    """Get benchmark logs"""
+    return {
+        "logs": launcher.logs[-100:] if launcher.logs else [],  # Last 100 logs
+        "total_logs": len(launcher.logs)
+    }
+# ==================== Main ====================
+def main():
+    """Run the FastAPI server"""
+    print("\n" + "="*60)
+    print("XMRig FastAPI Server")
+    print("="*60)
+    print("[*] Starting server on http://127.0.0.1:8000")
+    print("[*] Web UI: http://127.0.0.1:8000/ui")
+    print("[*] API docs: http://127.0.0.1:8000/docs")
+    print("[*] ReDoc: http://127.0.0.1:8000/redoc")
+    if is_admin():
+        print("[+] Running as Administrator ✓")
+    else:
+        print("[!] NOT running as Administrator")
+        print("    → Run as Admin for 2-3x better performance")
+    print("="*60 + "\n")
+    uvicorn.run(app, host="127.0.0.1", port=8000, log_level="info")
+if __name__ == "__main__":
+    main()