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

- Search libraries/ with priority scoring: correct forge/neoforge path
  gets highest priority, then filename match, then any non-installer jar.
  Fixes picking random libraries (e.g. lz4-java) instead of server jar.
- 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
- Use bytearray for buffer to reduce fragmentation
- Skip run.sh/run.bat scripts (fixes readline crash on Gentoo/AppImage)

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

@@ -589,63 +589,66 @@ def _get_start_command(self):
         all_jars = glob.glob(os.path.join(self.server_path, "*.jar"))
         server_jar_path = None
 
-        non_installer_jars = [
-            j for j in all_jars if "installer" not in os.path.basename(j).lower()
-        ]
-
-        if non_installer_jars:
-            # Look for common server jar names first
-            preferred_names = [
-                "server.jar",
-                "minecraft_server.jar",
-                "paper.jar",
-                "spigot.jar",
-                "fabric-server-launch.jar",
+        # Check for forge/neoforge server JAR in libraries/ first
+        if self.server_type in ["forge", "neoforge"]:
+            lib_path = os.path.join(self.server_path, "libraries")
+            if os.path.exists(lib_path):
+                candidates = []
+                forge_path_marker = "neoforged/neoforge" if self.server_type == "neoforge" else "minecraftforge/forge"
+                for root, dirs, files in os.walk(lib_path):
+                    for file in files:
+                        if file.endswith(".jar") and "installer" not in file.lower():
+                            full_path = os.path.join(root, file)
+                            score = 0
+                            if forge_path_marker in root.replace("\\", "/"):
+                                score = 10  # Highest priority: in correct forge/neoforge path
+                            elif self.server_type in file.lower():
+                                score = 5   # Medium: has forge/neoforge in filename
+                            candidates.append((score, full_path))
+                if candidates:
+                    candidates.sort(key=lambda x: x[0], reverse=True)
+                    server_jar_path = candidates[0][1]
+
+        # Fallback to root-level jars if nothing found in libraries
+        if not server_jar_path:
+            non_installer_jars = [
+                j for j in all_jars if "installer" not in os.path.basename(j).lower()
             ]
-            for name in preferred_names:
-                for jar in non_installer_jars:
-                    if os.path.basename(jar).lower() == name:
-                        server_jar_path = jar
+            if non_installer_jars:
+                preferred_names = [
+                    "server.jar",
+                    "minecraft_server.jar",
+                    "paper.jar",
+                    "spigot.jar",
+                    "fabric-server-launch.jar",
+                ]
+                for name in preferred_names:
+                    for jar in non_installer_jars:
+                        if os.path.basename(jar).lower() == name:
+                            server_jar_path = jar
+                            break
+                    if server_jar_path:
                         break
-                if server_jar_path:
-                    break
-
-            # If no preferred name is found, take the first non-installer jar
-            if not server_jar_path:
-                server_jar_path = non_installer_jars[0]
-
-        elif all_jars:  # Fallback if only installer jars are present for some reason
-            server_jar_path = all_jars[0]
+                if not server_jar_path:
+                    server_jar_path = non_installer_jars[0]
+            elif all_jars:
+                server_jar_path = all_jars[0]
 
-        if not server_jar_path:
-            # Special check for Forge/NeoForge libraries if run.bat is missing
-            if self.server_type in ["forge", "neoforge"]:
-                self.output_callback("Startup script missing. Checking libraries for server JAR...\n", "info")
-                lib_path = os.path.join(self.server_path, "libraries")
-                if os.path.exists(lib_path):
-                    # Search for any jar that looks like a forge/neoforge server jar
-                    for root, dirs, files in os.walk(lib_path):
-                        for file in files:
-                            if file.endswith(".jar") and ("forge" in file.lower() or "neoforge" in file.lower()) and "server" in file.lower():
-                                server_jar_path = os.path.join(root, file)
-                                break
-                        if server_jar_path: break
-                
-                if server_jar_path:
-                    self.output_callback(f"Found server JAR in libraries: {os.path.basename(server_jar_path)}\n", "success")
-                else:
-                    self.output_callback("Could not find server JAR in libraries. Installation might be incomplete.\n", "warning")
-
-        if not server_jar_path:
+        if server_jar_path:
+            lib_jar = "libraries" in server_jar_path
+            self.output_callback(
+                f"Found server JAR: {os.path.basename(server_jar_path)}{' (in libraries/)' if lib_jar else ''}\n",
+                "success",
+            )
+        else:
             # Audit directory before failing
             try:
                 files = os.listdir(self.server_path)
                 logging.info(f"Handler: Server Directory Audit: {files}")
             except Exception as ae:
                 logging.error(f"Handler: Directory Audit FAILED: {ae}")
-
             self.output_callback(
-                "Error: No server .jar file or run script found in the directory.\n",
+                "Error: No server .jar file found in the directory.\n",
                 "error",
             )
             return None, None
@@ -723,9 +726,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 +813,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 +1025,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 +1043,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 +1079,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,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)