implement tunnel feature in server handler

- Created a .gitignore file to exclude unnecessary files and directories.
- Updated the GUI to include controls for managing the tunnel and displaying the public IP.
- Added functionality to download and extract the bore executable if not already present.
- Updated README.md to document the new "Make Public" feature and its usage.

Author: CalaKuad1

.gitignore

@@ -0,0 +1,27 @@
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+# Virtual Environment
+venv/
+.venv/
+
+# Downloaded Dependencies
+bore.exe
+
+# Environment Variables
+.env
+
+# IDE / Editor specific
+.vscode/
+.idea/
+
+# Build artifacts
+build/
+dist/
+*.egg-info/
+
+# Log files
+*.log

README.md

@@ -25,6 +25,10 @@ A user-friendly desktop application for installing, managing, and running local
 - **Smart & Automated**:
   - **Automatic EULA Handling**: Automatically detects and accepts the EULA on the first run of a new server.
   - **Smart Startup**: Automatically uses the correct startup script (`run.bat`/`run.sh`) for Forge servers.
+- **Make Public (Experimental)**:
+  - Expose your local server to the internet with a single click, allowing friends to join from anywhere.
+  - **Disclaimer**: This feature uses a free, public tunneling service. As such, it may introduce lag and is not guaranteed to be stable. The public address will be different each time you start the tunnel.
+  - Powered by the open-source tool **[bore](https://github.com/ekzhang/bore)** by **ekzhang**.
 - **Customization & Settings**:
   - **Custom RAM Allocation**: Easily set the minimum and maximum RAM for your server.
   - **Configuration Saving**: Remembers your server path and settings between sessions.

minecraft_server_gui.py

@@ -17,7 +17,7 @@
 
 from gui.widgets import CollapsiblePane
 from utils.constants import *
-from utils.helpers import format_size, get_folder_size, get_local_ip
+from utils.helpers import format_size, get_folder_size, get_local_ip, get_server_port
 from utils.api_client import fetch_player_avatar_image, fetch_player_uuid, download_server_jar, get_server_versions, fetch_username_from_uuid, get_forge_versions
 from server.server_handler import ServerHandler
 from server.config_manager import ConfigManager
@@ -89,9 +89,13 @@ def on_close(self):
 
             if response is not None:
                 self.log_to_console("Stopping server before exiting...\n", "info")
+                if self.server_handler.is_tunnel_running():
+                    self.server_handler.stop_tunnel()
                 self.server_handler.stop()
                 self._wait_for_server_to_stop_and_destroy()
         else:
+            if hasattr(self, 'server_handler') and self.server_handler.is_tunnel_running():
+                self.server_handler.stop_tunnel()
             self.master.destroy()
 
     def _wait_for_server_to_stop_and_destroy(self):
@@ -769,6 +773,18 @@ def add_info_row(label_text, var_text):
         self.copy_ip_button = ctk.CTkButton(ip_frame, text="Copy", width=60, command=self._copy_ip_to_clipboard)
         self.copy_ip_button.pack(side=tk.LEFT, padx=5)
 
+        # --- Public IP (Tunnel) ---
+        row_idx = info_grid.grid_size()[1]
+        ctk.CTkLabel(info_grid, text="Public IP:", font=ctk.CTkFont(weight="bold")).grid(row=row_idx, column=0, sticky='w', padx=(0,10), pady=(5,0))
+        public_ip_frame = ctk.CTkFrame(info_grid, fg_color="transparent")
+        public_ip_frame.grid(row=row_idx, column=1, sticky='ew', pady=(5,0))
+        self.public_ip_label = ctk.CTkLabel(public_ip_frame, text="Tunnel is offline")
+        self.public_ip_label.pack(side=tk.LEFT, anchor='w')
+        self.tunnel_button = ctk.CTkButton(public_ip_frame, text="Make Public", width=100, command=self._toggle_tunnel)
+        self.tunnel_button.pack(side=tk.LEFT, padx=5)
+        self.tunnel_info_button = ctk.CTkButton(public_ip_frame, text="?", width=28, command=self.show_tunnel_info)
+        self.tunnel_info_button.pack(side=tk.LEFT, padx=(0, 5))
+
         # --- Bottom Panel for Console ---
         console_card = ctk.CTkFrame(parent_frame)
         console_card.grid(row=1, column=0, sticky='nsew')
@@ -792,6 +808,45 @@ def add_info_row(label_text, var_text):
         self.console_send_btn = ctk.CTkButton(command_frame, text="Send", width=70, command=self.send_command_from_console_button)
         self.console_send_btn.grid(row=0, column=1)
 
+    def show_tunnel_info(self):
+        """Displays a pop-up window with information about the tunnel feature."""
+        info_win = ctk.CTkToplevel(self.master)
+        info_win.title("About the 'Make Public' Feature")
+        info_win.transient(self.master)
+        info_win.grab_set()
+
+        info_text = """
+        About the 'Make Public' Feature
+
+        This experimental feature uses a free, public
+        tunneling service to expose your local server
+        to the internet for others to join.
+
+        Important Notes:
+         • A new random address is generated each time.
+         • Connection may experience higher latency (lag).
+
+        Acknowledgements:
+        This is powered by the open-source project 'bore'
+        created by ekzhang.
+        """
+
+        ctk.CTkLabel(info_win, text=info_text, justify=tk.LEFT, wraplength=350).pack(padx=20, pady=20)
+        ctk.CTkButton(info_win, text="OK", command=info_win.destroy).pack(pady=10, padx=20)
+
+        # Center the window
+        self.master.update_idletasks()
+        master_x = self.master.winfo_x()
+        master_y = self.master.winfo_y()
+        master_w = self.master.winfo_width()
+        master_h = self.master.winfo_height()
+        win_w = info_win.winfo_width()
+        win_h = info_win.winfo_height()
+        x = master_x + (master_w - win_w) // 2
+        y = master_y + (master_h - win_h) // 2
+        info_win.geometry(f"+{x}+{y}")
+        info_win.focus()
+
     def _on_ram_slider_change(self, value):
         # Update the label as the slider moves
         max_ram = int(value)
@@ -815,6 +870,17 @@ def _copy_ip_to_clipboard(self):
             self.master.clipboard_append(ip)
             self.log_to_console(f"Copied '{ip}' to clipboard.\n", "success")
 
+    def _toggle_tunnel(self):
+        if self.server_handler.is_tunnel_running():
+            self.server_handler.stop_tunnel()
+            self.tunnel_button.configure(text="Make Public")
+            self.public_ip_label.configure(text="Tunnel is offline")
+        else:
+            port = get_server_port(self.server_properties_path)
+            self.server_handler.start_tunnel(port)
+            self.tunnel_button.configure(text="Stop Tunnel")
+            self.public_ip_label.configure(text="Starting tunnel...")
+
     def _update_dashboard_info(self):
         if not self.server_path: return
         properties = {}
@@ -1115,6 +1181,8 @@ def start_server_thread(self):
         self._update_server_status_display()
 
     def stop_server(self):
+        if self.server_handler.is_tunnel_running():
+            self.server_handler.stop_tunnel()
         self.server_handler.stop()
         self.stop_button.configure(state=tk.DISABLED)
         self._update_server_status_display()
@@ -1137,6 +1205,17 @@ def process_server_output(self, line, level):
             self._detect_type_from_log(clean_line)
             return
 
+        if clean_line.startswith("PUBLIC_URL:"):
+            url = clean_line.replace("PUBLIC_URL:", "").strip()
+            self.public_ip_label.configure(text=url)
+            self.tunnel_button.configure(text="Stop Tunnel")
+            return
+
+        if "PUBLIC_URL_STOPPED" in clean_line:
+            self.public_ip_label.configure(text="Tunnel is offline")
+            self.tunnel_button.configure(text="Make Public")
+            return
+
         if self.expecting_player_list_next_line:
             self.players_connected = [p.strip() for p in clean_line.split(',') if p.strip()]
             self._refresh_players_display()

server/server_handler.py

@@ -4,7 +4,9 @@
 import glob
 import sys
 import logging
-from utils.api_client import download_file_from_url
+import re
+
+from utils.api_client import download_file_from_url, download_and_extract_zip
 
 class ServerHandler:
     def __init__(self, server_path, server_type, ram_min, ram_max, ram_unit, output_callback):
@@ -15,10 +17,15 @@ def __init__(self, server_path, server_type, ram_min, ram_max, ram_unit, output_
         self.ram_unit = ram_unit
         self.output_callback = output_callback
         self.server_process = None
+        self.tunnel_process = None
+        self.public_url = None
+        self.tunnel_thread = None
+        self.stop_tunnel_event = threading.Event()
         self.server_fully_started = False
         self.server_stopping = False
         self.server_running = False
 
+
     def install_forge_server(self, forge_version, minecraft_version, progress_callback):
         """Downloads and installs a Forge server."""
         # This is an example URL structure. You'll need to get the correct URLs.
@@ -228,3 +235,143 @@ def force_stop_state(self):
         self.server_process = None
         self.server_running = False
         self.server_stopping = False
+
+    def get_bore_path(self):
+        """Returns the expected path to the bore executable."""
+        return os.path.join(os.getcwd(), "bore.exe")
+
+    def is_bore_downloaded(self):
+        """Checks if bore.exe exists."""
+        return os.path.exists(self.get_bore_path())
+
+    def _download_bore(self):
+        """Downloads and extracts bore.exe."""
+        # URL for bore v0.5.0 for Windows
+        bore_url = "https://github.com/ekzhang/bore/releases/download/v0.5.0/bore-v0.5.0-x86_64-pc-windows-msvc.zip"
+        extract_dir = os.getcwd()
+        
+        self.output_callback("Downloading bore executable (this will only happen once)...\n", "info")
+
+        # Simple progress display via output_callback. A real progress bar would require more GUI integration.
+        def progress_callback(p):
+            self.output_callback(f"\rDownload progress: {p}%", "info")
+
+        if download_and_extract_zip(bore_url, extract_dir, progress_callback):
+            self.output_callback("\nBore downloaded successfully.\n", "info")
+            return True
+        else:
+            self.output_callback("\nFailed to download bore.\n", "error")
+            return False
+
+    def start_tunnel(self, port):
+        """Starts the tunnel using bore."""
+        if self.is_tunnel_running():
+            self.output_callback("Tunnel is already running.\n", "warning")
+            return
+
+        if not self.is_bore_downloaded():
+            self.output_callback("Bore executable not found. Attempting to download...\n", "info")
+            if not self._download_bore():
+                self.output_callback("Could not start tunnel due to download failure.\n", "error")
+                return
+        
+        bore_path = self.get_bore_path()
+        command = [bore_path, "local", str(port), "--to", "bore.pub"]
+
+        self.output_callback("Starting tunnel...\n", "info")
+
+        self.stop_tunnel_event.clear()
+        self.tunnel_thread = threading.Thread(target=self._run_tunnel, args=(command,), daemon=True)
+        self.tunnel_thread.start()
+
+    def _run_tunnel(self, command):
+        """Runs the bore process and captures its output."""
+        try:
+            self.tunnel_process = subprocess.Popen(
+                command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                encoding='utf-8',
+                errors='replace',
+                creationflags=subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
+            )
+
+            self.output_callback("Tunnel process started. Waiting for public URL...\n", "info")
+
+            # Read output line-by-line to find the URL
+            for line in iter(self.tunnel_process.stdout.readline, ''):
+                if self.stop_tunnel_event.is_set():
+                    break
+                
+                line_stripped = line.strip()
+                if not line_stripped:
+                    continue
+
+                self.output_callback(f"[Tunnel] {line_stripped}\n", "normal")
+                
+                # Clean the line of ANSI escape codes for reliable parsing
+                clean_line = re.sub(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])', '', line_stripped)
+
+                if "listening at" in clean_line and not self.public_url:
+                    try:
+                        url_part = clean_line.split("listening at")[1].strip()
+                        self.public_url = url_part
+                        self.output_callback(f"PUBLIC_URL:{self.public_url}\n", "success")
+                        # URL found, break the reading loop and move to waiting
+                        break
+                    except IndexError:
+                        self.output_callback("Could not parse public URL from tunnel output.\n", "warning")
+            
+            # If we are here, we either found the URL, the process died, or we are stopping
+            if self.stop_tunnel_event.is_set():
+                # We were asked to stop while searching for URL, which is handled in stop_tunnel
+                pass
+            elif self.public_url:
+                # URL was found, now just wait for the process to end for any reason.
+                # This will block the thread until stop_tunnel() is called or the process dies.
+                self.tunnel_process.wait()
+            else:
+                # Loop finished but we have no URL, means process died before giving one
+                self.output_callback("Tunnel process exited before providing a public URL.\n", "warning")
+
+        except FileNotFoundError:
+            self.output_callback(f"Error: bore.exe not found at {command[0]}\n", "error")
+        except Exception as e:
+            self.output_callback(f"An error occurred while running the tunnel: {e}\n", "error")
+        finally:
+            # This block now runs only when the process has truly terminated
+            self.tunnel_process = None
+            self.public_url = None
+            if not self.stop_tunnel_event.is_set():
+                 self.output_callback("Tunnel stopped unexpectedly.\n", "error")
+            
+            # Always notify GUI to reset state
+            self.output_callback("PUBLIC_URL_STOPPED\n", "info")
+
+    def stop_tunnel(self):
+        """Stops the tunnel process."""
+        if not self.is_tunnel_running():
+            return
+            
+        self.output_callback("Stopping tunnel...\n", "info")
+        self.stop_tunnel_event.set()
+        if self.tunnel_process:
+            self.tunnel_process.terminate()
+            try:
+                self.tunnel_process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self.tunnel_process.kill()
+        
+        if self.tunnel_thread:
+            self.tunnel_thread.join(timeout=2)
+
+        self.tunnel_process = None
+        self.tunnel_thread = None
+        self.public_url = None
+        self.output_callback("Tunnel stopped.\n", "info")
+        self.output_callback("PUBLIC_URL_STOPPED\n", "info")
+
+    def is_tunnel_running(self):
+        """Checks if the tunnel process is running."""
+        return self.tunnel_thread and self.tunnel_thread.is_alive()

utils/api_client.py

@@ -7,6 +7,7 @@
 import xml.etree.ElementTree as ET
 from collections import defaultdict
 import re
+import zipfile
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -138,6 +139,31 @@ def download_file_from_url(download_url, save_path, progress_callback):
         logging.error(f"Failed to download file: {e}")
         return False
 
+def download_and_extract_zip(url, extract_to_dir, progress_callback):
+    """Downloads a zip file and extracts its contents."""
+    os.makedirs(extract_to_dir, exist_ok=True)
+    zip_path = os.path.join(extract_to_dir, 'temp.zip')
+    
+    logging.info(f"Downloading zip from {url} to {zip_path}")
+    if not download_file_from_url(url, zip_path, progress_callback):
+        logging.error("Failed to download the zip file.")
+        return False
+    
+    logging.info(f"Extracting {zip_path} to {extract_to_dir}")
+    try:
+        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+            zip_ref.extractall(extract_to_dir)
+        logging.info("Extraction complete.")
+    except zipfile.BadZipFile:
+        logging.error("Failed to extract: The file is not a valid zip file.")
+        return False
+    finally:
+        if os.path.exists(zip_path):
+            os.remove(zip_path)
+            
+    return True
+
+
 if __name__ == '__main__':
     print("Fetching Forge versions...")
     forge_versions = get_forge_versions()