minestrapper 0.1.0__tar.gz

minestrapper-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Faizaan J
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

minestrapper-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: minestrapper
+Version: 0.1.0
+Summary: Minestrapper is a bootstrapper for Minecraft servers that lets you easily add custom features to your server without needing a full mod/plugin loader.
+Author: Faizaan J
+Requires-Python: >=3.9
+License-File: LICENSE
+Dynamic: license-file

minestrapper-0.1.0/README.md

@@ -0,0 +1,112 @@
+# MineStrapper
+<p align="center">
+  <img width="150" height="150" alt="MineStrapperLogoPlaceholder" src="https://github.com/user-attachments/assets/38e8f391-5c0e-460a-9f05-ea9bc74ebf33" />
+</p>
+<p align="center">MineStrapper is a Python wrapper for running and extending features in a Minecraft <i>Java Edition</i> server.</p>
+
+Instead of writing full Java plugins or mods, this lets you hook into the server’s state/lifecycle events (starting, running, idle, stopping, stopped) and add custom functionality directly in Python. 
+This means simple features you want to add don't require the overhead of a mod loader (fabric, forge) or a plugin loader (paper, spigot, bukkit) and you can keep the server in its vanilla form.
+
+Of course, you can still definitely use your favorite mods or plugins along with this if you'd like.
+
+## Current Features
+- Config Handling
+  - Contains a class for managing configuration files of both Minestrapper and Minecraft.
+  - Minestrapper config uses a file named `Config.json` in a `/minestrapper` directory relative to the root of the Minecraft Server.
+  - Allows for direct editing of `server.properties`.
+- State Handling
+  - Contains a class for getting the current state of the server based on the server output.
+  - Tracks the following states: `STARTING`, `RUNNING`, `PAUSED`, `STOPPING`, `STOPPED`.
+- Periodic Callbacks
+  - A lifecycle function that runs every 20ms.
+  - Used for things that need to happen constantly.
+  - Mainly isn't used in preference of lifecycle events.
+- New Line Callbacks
+  - A lifecycle function that runs everytime a new line is sent from the Minecraft Server process
+- Logger
+  - Prints out stuff both from forwarding logs from the Minecraft process and also custom logs from Minestrapper.
+  - Keeps Minestrapper specific logs visually consistent with Minecraft Server logs (e.g. "[19:48:06] [Minestrapper/INFO]: Initialized Minestrapper Logger successfully.")
+  - Logs to a file named `latest-minestrapper.log` and then replaces the vanilla `latest.log` with it when the server stops.
+  - Provides `transformers` to modify each logged line to the output as needed. 
+- Built-in features:
+  - "State Styles"
+    - Updates the terminal title and text color based on the server's current state.
+    - Makes it easier to see whether the server is starting, running, paused, stopping, or stopped.
+  - "Server Resource Pack"
+    - Includes a lightweight HTTP server for serving a server resource pack.
+    - Removes the need for an external hosting site for the pack.
+    - Keeps resource pack delivery self-contained within the server setup.
+
+## Potential Future Features
+- Backups: Let the owner integrate save backups everytime the server closes locally. It can either be done locally only, with cloud services, or even both.
+- Remote Panels: Allow the owner along with anyone else authorized to remotely turn on and off the server. Only the owner will be able to view logs and run commands however.
+- Custom Commands: Add your own admin commands that can trigger multiple Minecraft commands or even run Python code.
+
+## Installation Guide
+1. Install Python at [https://www.python.org/](https://www.python.org/) (>=3.1).
+2. Go to your Minecraft Server directory.
+3. Make a directory exactly named `minestrapper` and change directory to it.
+```
+mkdir minestrapper && cd minestrapper
+```
+
+4. Make a new Python environment.
+
+**Windows:**
+```
+python -m venv .venv
+```
+
+**MacOS / Linux:**
+```
+python3 -m venv .venv
+```
+
+5. Activate the environment.
+
+**Windows:**
+```
+.\.venv\Scripts\activate
+```
+
+**MacOS / Linux:**
+```
+source .venv/bin/activate
+```
+
+6. Install the `minestrapper` package.
+```
+pip install minestrapper
+```
+
+7. Create a file exactly named `Config.json` and edit to your liking.
+```json
+{
+  "$schema": "https://raw.githubusercontent.com/Faizaan-J/mine-strapper/refs/heads/main/Config.schema.json"
+}
+```
+> [!NOTE]
+> The schema will help you fill out the file so it's recommended to use some kind of app that can read JSON schemas to edit the file easier. There are numerous required fields that you must fill out.
+
+8. Make an entry point file inside the `minestrapper` directory.
+
+**Example:**
+```python
+from pathlib import Path
+
+from minestrapper import Server
+
+if __name__ == "__main__":
+    server = Server(path=Path.cwd().parent)
+    server.start_server()
+
+    server.wait_loop()
+
+```
+
+## Important Notes
+- You still need to do any necessary port forwarding yourself.
+
+## License
+MineStrapper is released under the [MIT License](./LICENSE).  
+Feel free to use, modify, and share.

minestrapper-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "minestrapper"
+version="0.1.0"
+description="Minestrapper is a bootstrapper for Minecraft servers that lets you easily add custom features to your server without needing a full mod/plugin loader."
+authors = [
+    { name = "Faizaan J" } 
+]
+requires-python= ">=3.9"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[build-system]
+requires = ["setuptools", "twine"]
+build-backend = "setuptools.build_meta"

minestrapper-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

minestrapper-0.1.0/src/minestrapper/__init__.py

@@ -0,0 +1,4 @@
+from .server import Server
+from .state_handler import ServerState
+
+__all__ = ["Server", "ServerState"]

minestrapper-0.1.0/src/minestrapper/config_handler.py

@@ -0,0 +1,50 @@
+import os
+import json
+from enum import Enum
+
+class FileType(Enum):
+    CONFIG = "config"
+    SERVER_PROPERTIES = "server_properties"
+
+def key_value_to_dict(unpacked_string: list) -> dict:
+    dict = {}
+
+    for line in unpacked_string:
+        key_value = line.strip().split('=')
+        if len(key_value) == 2:
+            dict[key_value[0]] = key_value[1]
+
+    return dict
+
+def dict_to_key_value(dictionary: dict) -> str:
+    key_value_string = ""
+    for key, value in dictionary.items():
+        key_value_string += f"{key}={value}\n"
+    return key_value_string
+
+class ConfigHandler:
+    def __init__(self, path: str):
+        self.path = path
+        self.config_json = os.path.join(self.path, "minestrapper", "config.json")
+        self.server_properties_file = os.path.join(self.path, "server.properties")
+
+    def __open(self, file_type: FileType):
+        if file_type == FileType.CONFIG:
+            self.__config = json.load(open(self.config_json, 'r'))
+        elif file_type == FileType.SERVER_PROPERTIES:
+            with open(self.server_properties_file, 'r') as f:
+                self.__server_properties = key_value_to_dict(f.readlines())
+
+    def get_config(self):
+        self.__open(FileType.CONFIG)
+        return self.__config
+    
+    def get_server_properties(self):
+        self.__open(FileType.SERVER_PROPERTIES)
+        return self.__server_properties
+    
+    def set_server_properties(self, key : str, value : str):
+        self.__open(FileType.SERVER_PROPERTIES)
+        self.__server_properties[key] = value
+        with open(self.server_properties_file, 'w') as f:            
+            f.write(dict_to_key_value(self.__server_properties))

minestrapper-0.1.0/src/minestrapper/features/feature.py

@@ -0,0 +1,13 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..server import Server
+
+class Feature:
+    def __init__(self, name: str, description: str, server: "Server"):
+        self.name = name
+        self.description = description
+        self.server = server
+
+    def run(self):
+        raise NotImplementedError("Feature must implement the run method")

minestrapper-0.1.0/src/minestrapper/features/handle_built_in_features.py

@@ -0,0 +1,35 @@
+import os
+import sys
+
+from typing import TYPE_CHECKING
+
+from .state_styles.state_styles import StateStyle
+from .server_resource_pack.server_resource_pack import ServerResourcePack
+
+if TYPE_CHECKING:
+    from ..server import Server
+
+FEATURES = {
+    "state_styles": {
+        "class": StateStyle,
+        "enabled_by_default": True
+    },
+    "server_resource_pack": {
+        "class": ServerResourcePack,
+        "enabled_by_default": False
+    }
+}
+
+def handle_built_in_features(server: "Server"):
+    for feature_key, feature_info in FEATURES.items():
+        target_feature = server.config_handler.get_config()["features"].get(feature_key)
+        if target_feature is None: continue
+
+        if target_feature.get("feature_enabled", feature_info["enabled_by_default"]):
+            feature_class = feature_info["class"]
+            feature_instance = feature_class(server)
+            server.logger.info(f"Feature '{feature_instance.name}' has been started.")
+            try:
+                feature_instance.run()
+            except Exception as e:
+                server.logger.error(f"An error occurred while running the feature '{feature_instance.name}': {e}")

minestrapper-0.1.0/src/minestrapper/features/server_resource_pack/address_validator.py

@@ -0,0 +1,48 @@
+import ipaddress
+import socket
+
+def is_valid_ip(ip_address: str) -> bool:
+    try:
+        ipaddress.ip_address(ip_address)
+    except ValueError:
+        raise ValueError(f"Invalid IP address for server resource pack: {ip_address}")
+    
+    return True
+
+def get_port_integer(port: str) -> int:
+    try:
+        return int(port)
+    except (TypeError, ValueError):
+        raise ValueError(f"Port must be an integer, got {port}")
+
+def is_valid_port(port: int) -> bool:
+    if (port < 1 or port > 65535):
+        raise ValueError(f"Port must be between 1 and 65535, got {port}")
+
+    return True
+
+def is_port_free(ip: str, port: str) -> bool:
+    candidate_port = int(port)
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        return s.connect_ex((ip, candidate_port)) != 0
+
+def get_clean_address(ip: str, port: str) -> tuple[str, int]:
+    cleaned_ip = ip
+    cleaned_port = port
+
+    if (ip == "localhost"):
+        cleaned_ip = "127.0.0.1"
+    if (ip in [None, ""]):
+        cleaned_ip = "0.0.0.0"
+
+    if (not is_valid_ip(cleaned_ip)):
+        raise ValueError(f"Invalid IP address for server resource pack: {cleaned_ip}")
+    
+    port_int = get_port_integer(port)
+    if (not is_valid_port(port_int)):
+        raise ValueError(f"Invalid port for server resource pack: {port}")
+    
+    if (not is_port_free(cleaned_ip, port)):
+        cleaned_port = 0
+
+    return cleaned_ip, int(cleaned_port)

minestrapper-0.1.0/src/minestrapper/features/server_resource_pack/path_resolver.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+
+def resolve_server_path(path_str: str, server_root: str | Path) -> Path:
+    if (not path_str):
+        raise ValueError(
+            "Resource pack path is not set in config."
+            "Did you mean to disable the server_resource_pack feature?"
+        )
+
+    path = Path(path_str)
+
+    if not path.is_absolute():
+        path = Path(server_root) / path
+
+    path = path.resolve()
+
+    if (not path.exists()):
+        raise ValueError(f"Resource pack path {path} does not exist.")
+    
+    if (not path.is_file()):
+        raise ValueError(f"Resource pack path {path} is not a file.")
+    
+    if (path.suffix.lower() != ".zip"):
+        raise ValueError(f"Resource pack path {path} is not a zip file.")
+    
+    return path

minestrapper-0.1.0/src/minestrapper/features/server_resource_pack/server_resource_pack.py

@@ -0,0 +1,87 @@
+import threading
+
+import os
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+from minestrapper.logger import LogLevel
+
+from pathlib import Path
+
+from minestrapper.features.feature import Feature
+
+from typing import TYPE_CHECKING
+
+from minestrapper.features.server_resource_pack.path_resolver import resolve_server_path
+if TYPE_CHECKING:
+    from ....minestrapper.server import Server
+
+from .address_validator import get_clean_address
+
+import hashlib
+
+class ServerResourcePack(Feature):
+    def __init__(self, server: "Server"):
+        super().__init__(
+            "Server Resource Pack", 
+            "An HTTP server to serve a custom resource pack for your Minecraft Server.", 
+            server
+        )
+
+        self.config = self.server.config_handler.get_config()['features']['server_resource_pack']
+
+        self.path = resolve_server_path(self.config["path"], self.server.path)
+        self.ip, self.port = get_clean_address(self.config.get("ip", ""), self.config.get("port", ""))
+
+    def log(self, level: LogLevel, message: str):
+        self.server.logger.log(level, f"Resource Pack Server: {message}")
+
+    def get_sha1(self, file_path: Path) -> str:
+        sha1 = hashlib.sha1()
+
+        with open(file_path, "rb") as f:
+            while chunk := f.read(65536):
+                sha1.update(chunk)
+
+        return sha1.hexdigest()
+
+    def start_resource_pack_server(self):
+        file_path = self.path
+        server_instance = self.server
+        log_method = self.log
+        
+        class ResourcePackRequestHandler(BaseHTTPRequestHandler):
+            def log_message(self, format, *args):
+                log_level = LogLevel.INFO
+                if (len(args) >= 2):
+                    try:
+                        code = int(args[1])
+                        if (code >= 500):
+                            log_level = LogLevel.ERROR
+                        elif (code >= 400):
+                            log_level = LogLevel.WARNING
+                    except Exception as e:
+                        pass
+                log_method(log_level, format % args)
+
+            def do_GET(self):
+                self.send_response(200)
+                self.send_header("Content-Type", "application/zip")
+                self.send_header("Content-Length", str(os.path.getsize(file_path)))
+                self.end_headers()
+                
+                with open(file_path, "rb") as resource_pack_file:
+                    while chunk := resource_pack_file.read(65536):
+                        self.wfile.write(chunk)
+                    
+        server = HTTPServer((self.ip, self.port), ResourcePackRequestHandler)
+        threading.Thread(target=server.serve_forever, daemon=True).start()
+
+        return server
+
+    def run(self):
+        self.resource_pack_server = self.start_resource_pack_server()
+        resource_pack_url = f"http://{self.ip}:{self.port}/"
+
+        self.server.logger.info(f"Started resource pack server at {resource_pack_url}.")
+        self.server.config_handler.set_server_properties("resource-pack", resource_pack_url)
+        self.server.config_handler.set_server_properties("resource-pack-sha1", self.get_sha1(self.path))

minestrapper-0.1.0/src/minestrapper/features/state_styles/state_styles.py

@@ -0,0 +1,59 @@
+import os
+import ctypes
+
+from typing import TYPE_CHECKING, Callable
+
+from minestrapper.features.feature import Feature
+from minestrapper.util.ansi_colors import ANSI_COLORS
+from minestrapper.state_handler import ServerState
+
+if TYPE_CHECKING:
+    from ....minestrapper.server import Server
+
+class StateStyle(Feature):
+    def __init__(self, server: "Server"):
+        super().__init__("State Styles", "Provider for colored text and titles based on different server states", server)
+        self.state_styles_config = self.server.config_handler.get_config()['features']['state_styles']
+        self.styles = self.state_styles_config["styles"]
+        self.title_enabled = self.state_styles_config.get("title_enabled", False)
+        self.color_enabled = self.state_styles_config.get("color_enabled", False)
+
+    def get_colored_text(self, text: str, state: ServerState) -> str:
+        map = {
+            ServerState.STARTING: ANSI_COLORS.get(self.styles["starting"]["color"], ANSI_COLORS["reset"]),
+            ServerState.RUNNING: ANSI_COLORS.get(self.styles["running"]["color"], ANSI_COLORS["reset"]),
+            ServerState.STOPPING: ANSI_COLORS.get(self.styles["stopping"]["color"], ANSI_COLORS["reset"]),
+            ServerState.STOPPED: ANSI_COLORS.get(self.styles["stopped"]["color"], ANSI_COLORS["reset"]),
+            ServerState.PAUSED: ANSI_COLORS.get(self.styles["paused"]["color"], ANSI_COLORS["reset"]),
+        }
+
+        color = map.get(state, ANSI_COLORS["reset"])
+        
+        return f"{color}{text}{ANSI_COLORS['reset']}"
+    
+    def get_title(self, state: ServerState) -> str:
+        map = {
+            ServerState.STARTING: self.styles["starting"].get("title", "Starting"),
+            ServerState.RUNNING: self.styles["running"].get("title", "Running"),
+            ServerState.STOPPING: self.styles["stopping"].get("title", "Stopping"),
+            ServerState.STOPPED: self.styles["stopped"].get("title", "Stopped"),
+            ServerState.PAUSED: self.styles["paused"].get("title", "Paused"),
+        }
+
+        return map.get(state, "Unknown")
+    
+    def run(self):
+        if (self.color_enabled):
+            @self.server.logger.add_line_transformer
+            def state_styles_transformer(line: str):
+                return self.get_colored_text(line, self.server.state_handler.get())
+        
+        if (self.title_enabled):
+            @self.server.state_handler.on_state_change
+            def set_terminal_title():
+                title = self.get_title(self.server.state_handler.get())
+                if (os.name == "nt"):
+                    ctypes.windll.kernel32.SetConsoleTitleW(title)
+                else:
+                    sys.stdout.write(f'\x1b]0;{title}\x07')
+                    sys.stdout.flush()

minestrapper-0.1.0/src/minestrapper/logger.py

@@ -0,0 +1,76 @@
+import os
+import threading
+
+from enum import Enum
+from pathlib import Path
+from datetime import datetime
+
+from typing import TYPE_CHECKING, Callable
+
+if TYPE_CHECKING:
+    from .server import Server
+
+class LogLevel(Enum):
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+
+class Logger:
+    def __init__(self, server: "Server"):
+        self.server = server
+        self.line_transformers: list[Callable[[str], str]] = []
+
+        logs_folder = Path(server.path) / "logs"
+        logs_folder.mkdir(parents=True, exist_ok=True)
+        self.log_file = logs_folder / "latest.log"
+        self.log_file.parent.mkdir(parents=True, exist_ok=True)
+
+        self.minestrapper_log_file = logs_folder / "latest-minestrapper.log"
+        self.minestrapper_log_file.parent.mkdir(parents=True, exist_ok=True)
+        self.minestrapper_log_file.touch(exist_ok=True)
+        with open(self.minestrapper_log_file, "w", encoding="utf-8") as log:
+            log.write("")
+
+        self.info("Initialized Minestrapper Logger successfully.")
+
+    def add_line_transformer(self, transformer: Callable[[str], str]):
+        self.line_transformers.append(transformer)
+        return transformer
+    
+    def __write_line_log(self, line: str):
+        with open(self.minestrapper_log_file, "a", encoding="utf-8") as f:
+            f.write(line + "\n")
+
+    def print_with_transformation(self, message: str):
+        for transformer in self.line_transformers:
+            message = transformer(message)
+
+        print(message)
+
+    def forwarded_log(self, message: str):
+        self.print_with_transformation(message)
+        self.__write_line_log(message)
+
+    def log(self, level: LogLevel, message: str):
+        timestamp = f"[{datetime.now().strftime('%H:%M:%S')}]"
+        log_level_label = f"[Minestrapper/{level.value}]:"
+        full_line = f"{timestamp} {log_level_label} {message}"
+
+        self.print_with_transformation(full_line)
+        self.__write_line_log(full_line)
+
+    def publish_minestrapper_log(self):
+        with open(self.minestrapper_log_file, "r", encoding="utf-8") as f:
+            minestrapper_log_content = f.read()
+        
+        with open(self.log_file, "w", encoding="utf-8") as f:
+            f.write(minestrapper_log_content)
+
+    def info(self, message: str):
+        self.log(LogLevel.INFO, message)
+
+    def warning(self, message: str):
+        self.log(LogLevel.WARNING, message)
+
+    def error(self, message: str):
+        self.log(LogLevel.ERROR, message)

minestrapper-0.1.0/src/minestrapper/server.py

@@ -0,0 +1,124 @@
+from pathlib import Path
+import subprocess
+from typing import Callable
+import threading
+
+import os
+
+from .logger import Logger
+
+from .config_handler import ConfigHandler
+from .state_handler import ServerState, StateHandler
+
+from minestrapper.util.get_state_from_line import get_state_from_line
+
+from minestrapper.features.handle_built_in_features import handle_built_in_features
+
+from time import sleep as wait
+
+class Server:
+    def __init__(self, path: str | Path):
+        self.path : str = (str(path) if isinstance(path, Path) else path)
+        self.config_handler : ConfigHandler = ConfigHandler(self.path)
+        self.state_handler : StateHandler = StateHandler(ServerState.STARTING)
+        self.periodic_callbacks : list[Callable] = []
+        self.new_line_callbacks : list[Callable] = []
+        self.server_process : subprocess.Popen | None = None
+
+        self.logger = Logger(self)
+
+        os.chdir(self.path)
+
+    def __start_server_process(self):
+        config = self.config_handler.get_config()
+
+        jar_path = f"{config['server']['jar_name']}.jar"
+
+        full_command = [
+            "java"
+        ]
+        java_args = [
+            f"-Xms{config['server']['min_ram']}",
+            f"-Xmx{config['server']['max_ram']}",
+        ]
+
+        if "other_args" in config['server']:
+            java_args.extend(config['server']['other_args'])
+
+        full_command.extend(java_args)
+        full_command.extend([
+            "-jar", jar_path, "nogui"
+        ])
+
+        server_process = subprocess.Popen(
+            full_command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            encoding="utf-8",
+            errors="replace"
+        )
+
+        return server_process
+
+    def start_server(self):
+        self.server_process = self.__start_server_process()
+
+        def loop():
+            while self.state_handler.get() != ServerState.STOPPED and self.server_process is not None and self.server_process.poll() is None:
+                self.__on_periodic()
+
+                if (self.periodic_callbacks):
+                    for callback in self.periodic_callbacks:
+                        callback()
+                wait(0.020)
+                
+        self.periodic_thread = threading.Thread(target=loop, daemon=True)
+        self.periodic_thread.start()
+
+        def output_loop():
+            assert self.server_process is not None
+            if (self.server_process.stdout is not None):
+                for line in self.server_process.stdout:
+                    self.__on_new_line(line.strip("\n"))
+       
+        self.output_thread = threading.Thread(target=output_loop, daemon=True)
+        self.output_thread.start()
+
+        self.logger.info("Server process started successfully.")
+        handle_built_in_features(self)
+    
+    def wait_loop(self):
+        assert self.server_process is not None
+        self.server_process.wait()
+
+        # If the server process has stopped, this code should now run.
+        self.state_handler.set(ServerState.STOPPED)
+        self.logger.info("Server process has stopped.")
+        self.logger.publish_minestrapper_log()
+        input("Press Enter to exit...")
+
+    def __on_new_line(self, line : str):
+        new_state = get_state_from_line(line)
+        if (new_state is not None and new_state != self.state_handler.get()):
+            self.state_handler.set(new_state)
+
+        self.logger.forwarded_log(line)
+
+        if self.new_line_callbacks:
+            for callback in self.new_line_callbacks:
+                callback(line)
+
+    def on_new_line(self, function: Callable):
+        self.new_line_callbacks.append(function)
+        return function
+
+    def __on_periodic(self):
+        for callback in self.periodic_callbacks:
+            callback()
+
+    def on_periodic(self, function: Callable):
+        self.periodic_callbacks.append(function)
+
+        return function

minestrapper-0.1.0/src/minestrapper/state_handler.py

@@ -0,0 +1,44 @@
+from enum import Enum
+from typing import Callable
+
+class ServerState(Enum):
+    STARTING = "starting"
+    RUNNING = "running"
+    PAUSED = "paused"
+    STOPPING = "stopping"
+    STOPPED = "stopped"
+
+class StateHandler:
+    def __init__(self, initial_state: ServerState):
+        self.__server_state = initial_state
+        self.state_callbacks: dict[ServerState | None, list[Callable]] = {}
+
+    def set(self, state: ServerState):
+        if (state == self.__server_state):
+            return
+        
+        self.__server_state = state
+
+        for callback in self.state_callbacks.get(state, []):
+            callback()
+
+        for callback in self.state_callbacks.get(None, []):
+            callback()
+
+    def on_state_change(self, function: Callable, state: ServerState | None = None) -> Callable:
+        def decorator():
+            if state is None or self.get() == state:
+                function()
+
+        if (state is not None and not isinstance(state, ServerState)):
+            raise NameError(f"State {state} is not a valid server state.")
+
+        if state not in self.state_callbacks:
+            self.state_callbacks[state] = []
+        self.state_callbacks[state].append(function)
+
+        decorator() # Call the function immediately if we're already in the correct state
+        return decorator
+
+    def get(self) -> ServerState:
+        return self.__server_state

minestrapper-0.1.0/src/minestrapper/util/ansi_colors.py

@@ -0,0 +1,19 @@
+ANSI_COLORS = {
+    "reset": "\033[0m",
+    "red": "\033[31m",
+    "bright_red": "\033[91m",
+    "green": "\033[32m",
+    "bright_green": "\033[92m",
+    "yellow": "\033[33m",
+    "bright_yellow": "\033[93m",
+    "blue": "\033[34m",
+    "bright_blue": "\033[94m",
+    "magenta": "\033[35m",
+    "bright_magenta": "\033[95m",
+    "cyan": "\033[36m",
+    "bright_cyan": "\033[96m",
+    "white": "\033[37m",
+    "bright_white": "\033[97m",
+    "black": "\033[30m",
+    "bright_black": "\033[90m",
+}

minestrapper-0.1.0/src/minestrapper/util/get_state_from_line.py

@@ -0,0 +1,30 @@
+import re
+from ..state_handler import ServerState
+
+# These regex statements were vibe coded 🤤: 
+# "[HH:MM:SS] [Thread/Level]:"
+LOG_PREFIX = re.compile(r"^\[\d{2}:\d{2}:\d{2}\] \[[^\]]+\]: ")
+# "Playername joined the game"
+PLAYER_JOINED_REGEX = r"^[^\s]+ joined the game"
+
+def __strip_prefix(line: str) -> str:
+    return LOG_PREFIX.sub("", line, count=1)
+
+def get_state_from_line(line: str):
+    msg = __strip_prefix(line)
+
+    state_table = {
+        msg.startswith("Done ("): ServerState.RUNNING,
+        msg.startswith("Stopping the server"): ServerState.STOPPING,
+        msg.startswith("Server empty for 60 seconds, pausing"): ServerState.PAUSED,
+        re.match(PLAYER_JOINED_REGEX, msg): ServerState.RUNNING
+    }
+
+    new_state = None
+    for condition in state_table:
+        new_state_value = state_table[condition]
+        if condition:
+            new_state = new_state_value
+            break
+
+    return new_state

minestrapper-0.1.0/src/minestrapper.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: minestrapper
+Version: 0.1.0
+Summary: Minestrapper is a bootstrapper for Minecraft servers that lets you easily add custom features to your server without needing a full mod/plugin loader.
+Author: Faizaan J
+Requires-Python: >=3.9
+License-File: LICENSE
+Dynamic: license-file

minestrapper-0.1.0/src/minestrapper.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+LICENSE
+README.md
+pyproject.toml
+src/minestrapper/__init__.py
+src/minestrapper/config_handler.py
+src/minestrapper/logger.py
+src/minestrapper/server.py
+src/minestrapper/state_handler.py
+src/minestrapper.egg-info/PKG-INFO
+src/minestrapper.egg-info/SOURCES.txt
+src/minestrapper.egg-info/dependency_links.txt
+src/minestrapper.egg-info/top_level.txt
+src/minestrapper/features/__init__.py
+src/minestrapper/features/feature.py
+src/minestrapper/features/handle_built_in_features.py
+src/minestrapper/features/server_resource_pack/__init__.py
+src/minestrapper/features/server_resource_pack/address_validator.py
+src/minestrapper/features/server_resource_pack/path_resolver.py
+src/minestrapper/features/server_resource_pack/server_resource_pack.py
+src/minestrapper/features/state_styles/__init__.py
+src/minestrapper/features/state_styles/state_styles.py
+src/minestrapper/util/__init__.py
+src/minestrapper/util/ansi_colors.py
+src/minestrapper/util/get_state_from_line.py

minestrapper-0.1.0/src/minestrapper.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

minestrapper-0.1.0/src/minestrapper.egg-info/top_level.txt

@@ -0,0 +1 @@
+minestrapper