v1.2.7: Fix massive memory leak in api_server process

- Cap binary read buffer at 1MB to prevent unbounded growth
- Close pipes before joining reader threads to prevent zombie threads
- Clean up active_handlers on server delete
- Evict oldest entries from world_size_cache
- Use bytearray for buffer to reduce fragmentation

Author: CalaKuad1

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:

backend/server/server_handler.py

@@ -810,8 +810,16 @@ 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.
+            # Close pipes first so reader threads can unblock and terminate
+            try:
+                if self.server_process:
+                    for pipe_name in ["stdout", "stderr"]:
+                        pipe = getattr(self.server_process, pipe_name, None)
+                        if pipe and not pipe.closed:
+                            pipe.close()
+            except:
+                pass
+            # Then wait for reader threads to finish (they hold references to this handler)
             try:
                 if stdout_thread:
                     stdout_thread.join(timeout=2)
@@ -1012,7 +1020,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 +1038,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 +1074,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(

changelog.txt

@@ -1,5 +1,16 @@
 # Minecraft Server GUI - Changelog
 
+## Version 1.2.7 - 2026-06-02 MEMORY LEAK 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.
+
+---
+
 ## Version 1.2.6 - 2026-06-02 READLINE / STARTUP SCRIPTS FIX
 
 ### FIXED:

electron-app/package.json

@@ -1,7 +1,7 @@
 {
   "name": "minecraft-server-gui",
   "private": true,
-  "version": "1.2.6",
+  "version": "1.2.7",
   "repository": {
     "type": "git",
     "url": "https://github.com/CalaKuad1/Minecraft-Local-Server-GUI.git"