v1.2.6: Fix memory leak, jar path & startup scripts crash

CalaKuad1 · CalaKuad1 · commit 55cd4837f11b · 2026-06-03T00:08:46.000+02:00
- Cap binary read buffer at 1MB to prevent unbounded growth - Close pipes only if reader threads are still alive (zombie prevention) - Clean up active_handlers on server delete - Evict oldest entries from world_size_cache - Use full jar path instead of basename (fixes neoforge in libraries/) - Use bytearray for buffer to reduce fragmentation - Skip run.sh/run.bat scripts, use JAR-based startup instead Fixes readline crash on Gentoo Linux/AppImage (Issue #11)
diff --git a/backend/api_server.py b/backend/api_server.py
@@ -209,6 +209,7 @@ def __init__(self):
         self.world_size_cache = {}
         self.world_size_inflight = set()
         self.world_size_lock = threading.Lock()
+        self.world_size_cache_max = 100
 
         # Multi-server management
         self.active_handlers = {}  # server_id -> ServerHandler
@@ -567,8 +568,14 @@ async def delete_server(server_id: str, delete_files: bool = False):
 
     # Delete the profile
     state.config_manager.delete_server(server_id)
+    # Clean up handler from active_handlers to prevent memory leaks
+    if server_id in state.active_handlers:
+        handler = state.active_handlers.pop(server_id)
+        try:
+            handler.stop()
+        except:
+            pass
     if state.selected_server_id == server_id:
-        state.server_handler = None
         state.selected_server_id = None
 
     # Optionally delete files
@@ -1580,6 +1587,11 @@ def _compute_world_size(
                                                 "size": f"{size_mb} MB",
                                                 "folder_mtime": expected_folder_mtime,
                                             }
+                                            # Evict oldest entries if cache exceeds limit
+                                            if len(state.world_size_cache) > state.world_size_cache_max:
+                                                excess = sorted(state.world_size_cache.keys())[:-state.world_size_cache_max]
+                                                for k in excess:
+                                                    del state.world_size_cache[k]
                                     finally:
                                         if state:
                                             with state.world_size_lock:
diff --git a/backend/server/server_handler.py b/backend/server/server_handler.py
@@ -723,9 +723,9 @@ def _get_start_command(self):
             )
             # Try to run it without nogui if it's an installer, 
             # though it probably won't start the server.
-            command.extend(["-jar", os.path.basename(server_jar_path)])
+            command.extend(["-jar", server_jar_path])
         else:
-            command.extend(["-jar", os.path.basename(server_jar_path), "--nogui"])
+            command.extend(["-jar", server_jar_path, "--nogui"])
 
         return command, custom_env
 
@@ -810,15 +810,25 @@ def _run_server(self, command, env):
             logging.error(f"Handler: CRASH in _run_server thread:\n{error_details}")
             self._log(f"Server start failed: {e}\n", "error")
         finally:
-            # Esperar a que los hilos de salida terminen de procesar los últimos logs
-            # Esto evita que el estado se quede en 'stopping' si el log llega justo al final.
+            # Wait for reader threads to finish naturally first
             try:
                 if stdout_thread:
                     stdout_thread.join(timeout=2)
                 if stderr_thread:
                     stderr_thread.join(timeout=2)
             except:
                 pass
+            # Force-close pipes only if threads are still alive (zombie prevention)
+            try:
+                if self.server_process:
+                    if stdout_thread and stdout_thread.is_alive():
+                        if self.server_process.stdout and not self.server_process.stdout.closed:
+                            self.server_process.stdout.close()
+                    if stderr_thread and stderr_thread.is_alive():
+                        if self.server_process.stderr and not self.server_process.stderr.closed:
+                            self.server_process.stderr.close()
+            except:
+                pass
 
             # --- CRITICAL FIX: ACTUALIZAR ESTADO INTERNO PRIMERO ---
             # Guardamos el estado previo para el log
@@ -1012,7 +1022,8 @@ def _read_output(self, pipe, level):
                 f"Handler: Log reader thread started for {level} (Chunked Binary mode)"
             )
 
-            buffer = b""
+            buffer = bytearray()
+            MAX_BUFFER = 1_048_576  # 1 MB cap to prevent memory leak
             while True:
                 chunk = pipe.read(4096)
                 if not chunk:
@@ -1029,7 +1040,20 @@ def _read_output(self, pipe, level):
                         )
                     break
 
-                buffer += chunk
+                buffer.extend(chunk)
+                # Force-flush if buffer exceeds cap (prevents unbounded growth)
+                if len(buffer) > MAX_BUFFER:
+                    self._process_log_line(
+                        buffer.decode("utf-8", errors="replace"),
+                        level,
+                        re,
+                        join_pattern,
+                        leave_pattern,
+                        list_inline_pattern,
+                        list_header_pattern,
+                    )
+                    buffer = bytearray()
+                    continue
                 logging.debug(
                     f"Handler: Received chunk of {len(chunk)} bytes from {level}"
                 )
@@ -1052,7 +1076,7 @@ def _read_output(self, pipe, level):
                             sep_len = 2  # Handle \r\n
 
                     line_bytes = buffer[:idx]
-                    buffer = buffer[idx + sep_len :]
+                    buffer = bytearray(buffer[idx + sep_len :])
 
                     line = line_bytes.decode("utf-8", errors="replace")
                     self._process_log_line(
diff --git a/changelog.txt b/changelog.txt
@@ -1,6 +1,16 @@
 # Minecraft Server GUI - Changelog
 
-## Version 1.2.6 - 2026-06-02 READLINE / STARTUP SCRIPTS FIX
+## Version 1.2.6 - 2026-06-02 MEMORY LEAK & STARTUP SCRIPTS FIX
+
+### CRITICAL FIX:
+- **Fixed massive memory leak in `api_server`** — The binary read buffer in log reader threads could grow unboundedly when output had no newlines. Now capped at 1MB and force-flushed.
+- **Fixed zombie reader threads** — Pipes are now closed before joining threads, preventing stuck daemon threads from holding references to old `ServerHandler` instances and their log history.
+- **Fixed `active_handlers` leak** — Deleting a server now properly removes its handler from memory.
+- **Fixed `world_size_cache` unbounded growth** — Cache now evicts oldest entries when exceeding 100 items.
+- **Reduced memory fragmentation** — Changed `bytes +=` concatenation to `bytearray.extend()` in log reader.
+
+### FIXED:
+- **Startup scripts (run.sh/run.bat) no longer executed** — The app now uses direct JAR-based startup instead of running `run.sh`/`run.bat` scripts. Fixes `undefined symbol: rl_macro_display_hook` crash on Gentoo Linux / AppImage environments (Issue #11)
 
 ### FIXED:
 - **Startup scripts (run.sh/run.bat) no longer executed** — The app now uses direct JAR-based startup instead of running `run.sh`/`run.bat` scripts. Fixes `undefined symbol: rl_macro_display_hook` crash on Gentoo Linux / AppImage environments (Issue #11)
