Update Dockerfile

Dockerfile

@@ -11,7 +11,7 @@ RUN apt-get update && apt-get install -y \
     && rm -rf /var/lib/apt/lists/*
 
 # Install Python dependencies
-RUN pip3 install flask flask-sock psutil --break-system-packages
+RUN pip3 install flask flask-sock psutil requests --break-system-packages
 
 WORKDIR /app
 
@@ -49,6 +49,9 @@ if [ ! -f eula.txt ]; then
     echo "✅ EULA accepted"
 fi
 
+# Create logs directory for persistent storage
+mkdir -p /app/logs
+
 # Create backup script
 cat > /app/backup.sh << 'BACKUPSCRIPT'
 #!/bin/bash
@@ -77,7 +80,7 @@ echo "✅ Auto-backup enabled (every 5 minutes)"
 echo ""
 
 # ==========================================
-# WEB TERMINAL SERVER (Mobile Responsive)
+# WEB TERMINAL SERVER (Fixed Uptime + Persistent Logs)
 # ==========================================
 cat > /app/web_terminal.py << 'PYTHON_SCRIPT'
 import os
@@ -88,9 +91,11 @@ import threading
 import time
 import queue
 import signal
+import requests
 from flask import Flask, render_template_string
 from flask_sock import Sock
 import psutil
+from datetime import datetime
 
 app = Flask(__name__)
 sock = Sock(app)
@@ -100,11 +105,131 @@ output_queue = queue.Queue()
 command_queue = queue.Queue()
 server_ready = threading.Event()
 
+# Persistent storage variables
+server_start_time = None
+logs_history = []
+LOGS_FILE = "/app/logs/console_logs.txt"
+UPTIME_FILE = "/app/logs/server_start_time.txt"
+GITHUB_TOKEN = os.environ.get('GITHUB_TOKEN', '')
+GITHUB_REPO = "Walukapah/mcserver"
+
+def load_logs_from_file():
+    """Load previous logs from local file"""
+    global logs_history
+    try:
+        if os.path.exists(LOGS_FILE):
+            with open(LOGS_FILE, 'r', encoding='utf-8') as f:
+                logs_history = f.read().splitlines()
+                # Keep only last 1000 lines
+                logs_history = logs_history[-1000:]
+                print(f"[LOGS] Loaded {len(logs_history)} lines from file", flush=True)
+    except Exception as e:
+        print(f"[LOGS] Error loading logs: {e}", flush=True)
+        logs_history = []
+
+def save_logs_to_file():
+    """Save logs to local file"""
+    try:
+        os.makedirs(os.path.dirname(LOGS_FILE), exist_ok=True)
+        with open(LOGS_FILE, 'w', encoding='utf-8') as f:
+            f.write('\n'.join(logs_history[-1000:]))
+    except Exception as e:
+        print(f"[LOGS] Error saving logs: {e}", flush=True)
+
+def push_logs_to_github():
+    """Push logs to GitHub for persistent storage"""
+    try:
+        if not GITHUB_TOKEN:
+            return
+        
+        # Read current logs
+        if not os.path.exists(LOGS_FILE):
+            return
+            
+        with open(LOGS_FILE, 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        # GitHub API - get current file SHA
+        api_url = f"https://api.github.com/repos/{GITHUB_REPO}/contents/logs/console_logs.txt"
+        headers = {
+            "Authorization": f"token {GITHUB_TOKEN}",
+            "Accept": "application/vnd.github.v3+json"
+        }
+        
+        # Check if file exists
+        sha = None
+        try:
+            resp = requests.get(api_url, headers=headers, timeout=10)
+            if resp.status_code == 200:
+                sha = resp.json().get('sha')
+        except:
+            pass
+        
+        # Create or update file
+        import base64
+        encoded_content = base64.b64encode(content.encode()).decode()
+        
+        data = {
+            "message": f"Update logs - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+            "content": encoded_content,
+            "branch": "main"
+        }
+        if sha:
+            data["sha"] = sha
+            
+        resp = requests.put(api_url, headers=headers, json=data, timeout=10)
+        if resp.status_code in [200, 201]:
+            print("[LOGS] Pushed to GitHub successfully", flush=True)
+    except Exception as e:
+        print(f"[LOGS] GitHub push error: {e}", flush=True)
+
+def load_uptime_from_file():
+    """Load server start time from file"""
+    global server_start_time
+    try:
+        if os.path.exists(UPTIME_FILE):
+            with open(UPTIME_FILE, 'r') as f:
+                timestamp = f.read().strip()
+                if timestamp:
+                    server_start_time = float(timestamp)
+                    print(f"[UPTIME] Loaded start time: {datetime.fromtimestamp(server_start_time)}", flush=True)
+    except Exception as e:
+        print(f"[UPTIME] Error loading uptime: {e}", flush=True)
+        server_start_time = None
+
+def save_uptime_to_file():
+    """Save server start time to file"""
+    try:
+        os.makedirs(os.path.dirname(UPTIME_FILE), exist_ok=True)
+        with open(UPTIME_FILE, 'w') as f:
+            f.write(str(server_start_time))
+    except Exception as e:
+        print(f"[UPTIME] Error saving uptime: {e}", flush=True)
+
+def add_log_line(line):
+    """Add a log line to history and save"""
+    global logs_history
+    timestamp = datetime.now().strftime('%H:%M:%S')
+    log_entry = f"[{timestamp}] {line}"
+    logs_history.append(log_entry)
+    # Keep only last 1000 lines
+    if len(logs_history) > 1000:
+        logs_history = logs_history[-1000:]
+    output_queue.put(log_entry)
+    # Save to file periodically (every 10 lines)
+    if len(logs_history) % 10 == 0:
+        save_logs_to_file()
+
 def start_minecraft():
-    global mc_process
+    global mc_process, server_start_time
     mc_dir = "/app/mcserver"
     
     print("[MC] Starting Minecraft server...", flush=True)
+    add_log_line("[SYSTEM] Starting Minecraft server...")
+    
+    # Record start time
+    server_start_time = time.time()
+    save_uptime_to_file()
     
     mc_process = subprocess.Popen(
         ["java", "-Xms1G", "-Xmx14G", "-XX:+UseG1GC", 
@@ -120,16 +245,20 @@ def start_minecraft():
     )
     
     print(f"[MC] Minecraft PID: {mc_process.pid}", flush=True)
+    add_log_line(f"[SYSTEM] Minecraft server started with PID: {mc_process.pid}")
     
     def read_output():
         try:
             for line in mc_process.stdout:
-                output_queue.put(line)
+                line = line.rstrip()
+                add_log_line(line)
                 if "Done" in line and "For help, type" in line:
                     server_ready.set()
                     print("[MC] Server is ready!", flush=True)
+                    add_log_line("[SYSTEM] Server is ready!")
         except Exception as e:
             print(f"[MC] Output error: {e}", flush=True)
+            add_log_line(f"[ERROR] Output reader error: {e}")
     
     threading.Thread(target=read_output, daemon=True).start()
     
@@ -142,6 +271,7 @@ def start_minecraft():
                         mc_process.stdin.write(cmd + "\n")
                         mc_process.stdin.flush()
                         print(f"[MC] Command: {cmd}", flush=True)
+                        add_log_line(f"> {cmd}")
                     except Exception as e:
                         print(f"[MC] Command error: {e}", flush=True)
             except queue.Empty:
@@ -172,8 +302,6 @@ HTML_TEMPLATE = """
             touch-action: manipulation;
         }
         
-        /* Mobile-first responsive design */
-        
         /* Top Navigation */
         .top-nav {
             background: #252a30;
@@ -327,6 +455,7 @@ HTML_TEMPLATE = """
         .terminal-line.warn { color: #d29922; }
         .terminal-line.error { color: #f85149; }
         .terminal-line.success { color: #3fb950; }
+        .terminal-line.system { color: #a855f7; font-weight: 500; }
         
         /* Command Input Area */
         .command-area {
@@ -827,9 +956,9 @@ HTML_TEMPLATE = """
         let ws = null;
         let reconnectAttempts = 0;
         let maxReconnectAttempts = 10;
-        let serverStartTime = null;
         let isServerRunning = false;
         let sidebarOpen = false;
+        let serverStartTime = null;
         
         function updateConnectionStatus(status, message) {
             connectionBar.className = 'connection-bar ' + status;
@@ -841,7 +970,7 @@ HTML_TEMPLATE = """
             connectionBar.innerHTML = '<i class="fas ' + icons[status] + '"></i><span>' + message + '</span>';
         }
         
-        function updateServerStatus(running) {
+        function updateServerStatus(running, startTime = null) {
             isServerRunning = running;
             const statusEl = document.getElementById('serverStatus');
             
@@ -853,7 +982,9 @@ HTML_TEMPLATE = """
                 stopBtn.disabled = false;
                 commandInput.disabled = false;
                 sendBtn.disabled = false;
-                if (!serverStartTime) serverStartTime = Date.now();
+                if (startTime) {
+                    serverStartTime = startTime * 1000; // Convert to milliseconds
+                }
             } else {
                 statusEl.className = 'status-indicator status-offline';
                 statusEl.innerHTML = '<span class="pulse"></span>Offline';
@@ -869,6 +1000,20 @@ HTML_TEMPLATE = """
         function addTerminalLine(text, type = '') {
             const line = document.createElement('div');
             line.className = 'terminal-line ' + type;
+            
+            // Check if it's a system message
+            if (text.includes('[SYSTEM]')) {
+                line.className += ' system';
+            } else if (text.includes('> ')) {
+                line.className += ' info';
+            } else if (text.toLowerCase().includes('error') || text.toLowerCase().includes('exception')) {
+                line.className += ' error';
+            } else if (text.toLowerCase().includes('warn')) {
+                line.className += ' warn';
+            } else if (text.toLowerCase().includes('done') || text.toLowerCase().includes('success')) {
+                line.className += ' success';
+            }
+            
             line.textContent = text;
             terminal.appendChild(line);
             terminal.scrollTop = terminal.scrollHeight;
@@ -879,20 +1024,24 @@ HTML_TEMPLATE = """
             }
         }
         
-        function formatUptime(ms) {
-            const seconds = Math.floor(ms / 1000);
-            const minutes = Math.floor(seconds / 60);
-            const hours = Math.floor(minutes / 60);
-            const days = Math.floor(hours / 24);
-            if (days > 0) return days + 'd ' + (hours % 24) + 'h';
-            if (hours > 0) return hours + 'h ' + (minutes % 60) + 'm';
-            if (minutes > 0) return minutes + 'm ' + (seconds % 60) + 's';
-            return seconds + 's';
+        function formatUptime(seconds) {
+            if (!seconds || seconds <= 0) return 'Offline';
+            
+            const days = Math.floor(seconds / 86400);
+            const hours = Math.floor((seconds % 86400) / 3600);
+            const minutes = Math.floor((seconds % 3600) / 60);
+            const secs = Math.floor(seconds % 60);
+            
+            if (days > 0) return days + 'd ' + hours + 'h ' + minutes + 'm';
+            if (hours > 0) return hours + 'h ' + minutes + 'm ' + secs + 's';
+            if (minutes > 0) return minutes + 'm ' + secs + 's';
+            return secs + 's';
         }
         
         function updateUptime() {
             if (serverStartTime && isServerRunning) {
-                const uptime = Date.now() - serverStartTime;
+                const now = Date.now();
+                const uptime = Math.floor((now - serverStartTime) / 1000);
                 document.getElementById('uptime').textContent = formatUptime(uptime);
                 document.getElementById('uptimeSub').textContent = 'Running';
             } else {
@@ -918,17 +1067,24 @@ HTML_TEMPLATE = """
                 const data = JSON.parse(event.data);
                 
                 if (data.type === 'output') {
-                    addTerminalLine(data.data.trim());
+                    addTerminalLine(data.data);
                 } else if (data.type === 'stats') {
                     document.getElementById('cpuLoad').textContent = data.cpu.toFixed(1) + '%';
                     document.getElementById('memoryUsage').textContent = data.memory.toFixed(1) + '%';
                     const memTotal = (data.memoryTotal / 1024 / 1024 / 1024).toFixed(2);
                     const memUsed = ((data.memoryTotal * data.memory / 100) / 1024 / 1024 / 1024).toFixed(2);
                     document.getElementById('memorySub').textContent = memUsed + ' / ' + memTotal + ' GB';
-                    updateServerStatus(data.running);
+                    
+                    updateServerStatus(data.running, data.serverStartTime);
+                    
                     if (data.players !== undefined) {
                         document.getElementById('playerCount').textContent = data.players;
                     }
+                } else if (data.type === 'history') {
+                    // Load history logs
+                    data.logs.forEach(log => {
+                        addTerminalLine(log);
+                    });
                 }
             };
             
@@ -953,7 +1109,6 @@ HTML_TEMPLATE = """
             const cmd = commandInput.value.trim();
             if (cmd && ws && ws.readyState === WebSocket.OPEN) {
                 ws.send(JSON.stringify({type: 'command', data: cmd}));
-                addTerminalLine('> ' + cmd, 'info');
                 commandInput.value = '';
             }
         }
@@ -961,7 +1116,6 @@ HTML_TEMPLATE = """
         function sendCmd(cmd) {
             if (ws && ws.readyState === WebSocket.OPEN) {
                 ws.send(JSON.stringify({type: 'command', data: cmd}));
-                addTerminalLine('[' + cmd + ']', 'info');
             }
         }
         
@@ -1033,7 +1187,7 @@ HTML_TEMPLATE = """
         }, false);
         
         document.getElementById('serverAddress').textContent = window.location.hostname;
-        addTerminalLine('Connecting to Minecraft server...', 'info');
+        addTerminalLine('[SYSTEM] Connecting to Minecraft server...', 'system');
     </script>
 </body>
 </html>
@@ -1052,27 +1206,18 @@ def health():
 
 @sock.route('/ws')
 def websocket(ws):
+    global server_start_time
     print("[WS] Client connected", flush=True)
     
-    # Send recent history
-    history = []
-    temp_list = []
-    while not output_queue.empty() and len(temp_list) < 100:
-        try:
-            line = output_queue.get_nowait()
-            temp_list.append(line)
-        except:
-            break
-    
-    for line in temp_list:
-        output_queue.put(line)
-        history.append(line)
-    
-    for line in history[-50:]:
-        try:
-            ws.send(json.dumps({'type': 'output', 'data': line}))
-        except:
-            break
+    # Send history logs first
+    try:
+        if logs_history:
+            ws.send(json.dumps({
+                'type': 'history',
+                'logs': logs_history[-100:]  # Send last 100 lines
+            }))
+    except Exception as e:
+        print(f"[WS] History send error: {e}", flush=True)
     
     def send_stats():
         while True:
@@ -1081,12 +1226,18 @@ def websocket(ws):
                 memory = psutil.virtual_memory()
                 running = mc_process is not None and mc_process.poll() is None
                 
+                # Calculate actual uptime from server_start_time
+                uptime_to_send = None
+                if running and server_start_time:
+                    uptime_to_send = server_start_time
+                
                 ws.send(json.dumps({
                     'type': 'stats',
                     'cpu': cpu,
                     'memory': memory.percent,
                     'memoryTotal': memory.total,
                     'running': running,
+                    'serverStartTime': uptime_to_send,
                     'players': 0
                 }))
             except Exception as e:
@@ -1134,6 +1285,7 @@ def websocket(ws):
 
 def cleanup(signum=None, frame=None):
     print("\n[MAIN] Shutting down...", flush=True)
+    save_logs_to_file()
     if mc_process:
         try:
             mc_process.stdin.write("stop\n")
@@ -1150,12 +1302,25 @@ signal.signal(signal.SIGTERM, cleanup)
 signal.signal(signal.SIGINT, cleanup)
 
 if __name__ == '__main__':
+    # Load previous logs and uptime
+    load_logs_from_file()
+    load_uptime_from_file()
+    
     print("[MAIN] Starting web server...", flush=True)
     
     # Start Minecraft immediately
     mc_thread = threading.Thread(target=start_minecraft, daemon=True)
     mc_thread.start()
     
+    # Start GitHub push thread (every 5 minutes)
+    def github_push_loop():
+        while True:
+            time.sleep(300)
+            push_logs_to_github()
+    
+    github_thread = threading.Thread(target=github_push_loop, daemon=True)
+    github_thread.start()
+    
     from werkzeug.serving import run_simple
     run_simple('0.0.0.0', 7860, app, threaded=True, use_reloader=False)
 PYTHON_SCRIPT
@@ -1174,9 +1339,11 @@ fi
 
 echo ""
 echo "=========================================="
-echo "✅ Minecraft Server with Mobile Responsive Web Terminal is LIVE!"
+echo "✅ Minecraft Server with Fixed Uptime + Persistent Logs is LIVE!"
 echo "🌐 Access at: https://your-space.hf.space"
 echo "📱 Mobile optimized interface enabled"
+echo "💾 Logs are now persistent across refreshes"
+echo "⏰ Uptime tracking fixed"
 echo "=========================================="
 
 # Keep container alive