mcserver-cli 3.0.0__py3-none-any.whl

mcserver/__init__.py

@@ -0,0 +1 @@
+__version__ = "3.0.0"

mcserver/__main__.py

@@ -0,0 +1,3 @@
+from . import app
+
+app.main()

mcserver/app.py

@@ -0,0 +1,24 @@
+def main() -> None:
+    import sys
+
+    if (sys.argv[1] if len(sys.argv) > 1 else "") == "cake":
+        from .mysterious import nothing_to_see_here_move_along
+
+        nothing_to_see_here_move_along()
+
+    MIN_PYTHON_VERSION: tuple[int, int] = (3, 14)
+    if sys.version_info < MIN_PYTHON_VERSION:
+        sys.exit(
+            f"MCServer requires Python {'.'.join(map(str, MIN_PYTHON_VERSION))} or newer."
+        )
+
+    import logging as log
+    import os
+
+    from . import cli
+
+    debug_mode = os.getenv("MCSERVER_DEBUG") == "1"
+    log_level = log.DEBUG if debug_mode else log.INFO
+    log.basicConfig(level=log_level, format="[%(levelname)s]: %(message)s")
+
+    sys.exit(cli.main())

mcserver/cli.py

@@ -0,0 +1,326 @@
+def main() -> int:
+    import argparse
+
+    from . import __version__
+    from .shared import loader_list
+
+    def command_function(args: argparse.Namespace) -> int:
+        command_name: str = args.command_name
+
+        match command_name:
+            case "add":
+                from .commands import add_projects
+
+                return add_projects(args)
+            case "import":
+                from .commands import import_setup
+
+                return import_setup(args)
+            case "help":
+                from .commands import print_help
+
+                return print_help(args)
+            case "init":
+                from .commands import initialize_server
+
+                return initialize_server(args)
+            case "list":
+                from .commands import list_projects
+
+                return list_projects(args)
+            case "op_grant":
+                from .commands import op_grant
+
+                return op_grant(args)
+            case "op_list":
+                from .commands import op_list
+
+                return op_list(args)
+            case "op_revoke":
+                from .commands import op_revoke
+
+                return op_revoke(args)
+            case "remove":
+                from .commands import remove_projects
+
+                return remove_projects(args)
+            case "search":
+                from .commands import search_projects
+
+                return search_projects(args)
+            case "show":
+                from .commands import show_projects
+
+                return show_projects(args)
+            case "start":
+                from .commands import start_server
+
+                return start_server(args)
+            case "status":
+                from .commands import server_status
+
+                return server_status(args)
+            case "stop":
+                from .commands import stop_server
+
+                return stop_server(args)
+            case "update":
+                from .commands import update_projects
+
+                return update_projects(args)
+            case "whitelist_add":
+                from .commands import whitelist_add
+
+                return whitelist_add(args)
+            case "whitelist_list":
+                from .commands import whitelist_list
+
+                return whitelist_list(args)
+            case "whitelist_remove":
+                from .commands import whitelist_remove
+
+                return whitelist_remove(args)
+            case _:
+                import logging as log
+
+                log.error(f"Unknown command: {command_name}")
+                return 1
+
+    parser = argparse.ArgumentParser(
+        prog="mcserver",
+        description="A CLI tool for managing Minecraft: Java Edition servers.",
+        epilog="Created for Linux and Termux only.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        prefix_chars="-",
+        add_help=True,
+        allow_abbrev=False,
+        exit_on_error=True,
+        suggest_on_error=True,
+        color=True,
+    )
+
+    parser.set_defaults(func=command_function, command_name="help", parser=parser)
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version="%(prog)s " + __version__,
+    )
+
+    commands = parser.add_subparsers(title="Commands")
+
+    # 'add' command
+    add_command = commands.add_parser(
+        "add",
+        help="Add mods/projects",
+        description="Add mods/plugins and their dependencies.",
+    )
+
+    add_command.set_defaults(command_name="add")
+    add_command.add_argument(
+        "projects", nargs="+", type=str, help="Project slugs or IDs"
+    )
+
+    # 'import' command
+    import_command = commands.add_parser(
+        "import",
+        help="Import a Modrinth modpack",
+        description="Import a Modrinth modpack from a file.",
+    )
+
+    import_command.set_defaults(command_name="import")
+    import_command.add_argument("modpack", type=str, help="The Modrinth modpack file")
+
+    # 'init' command
+    init_command = commands.add_parser(
+        "init",
+        help="Initialize server configurations",
+        description="Initialize the server configurations.",
+    )
+
+    init_command.set_defaults(command_name="init")
+    init_command.add_argument(
+        "--mc-version",
+        default="latest-release",
+        type=str,
+        help="Minecraft version of the server",
+        metavar="Version",
+        dest="game_version",
+    )
+
+    init_command.add_argument(
+        "--loader",
+        default="vanilla",
+        type=str,
+        choices=loader_list,
+        help="Loader for the server",
+        metavar="Loader",
+        dest="loader_name",
+    )
+
+    init_command.add_argument(
+        "--loader-version",
+        default="latest",
+        type=str,
+        help="Version of the loader",
+        metavar="Version",
+    )
+
+    init_command.add_argument(
+        "--min-ram",
+        default=512,
+        type=int,
+        help="Minimum RAM for the server (in MebiBytes)",
+        metavar="Size",
+    )
+
+    init_command.add_argument(
+        "--max-ram",
+        default=2048,
+        type=int,
+        help="Maximum RAM for the server (in MebiBytes)",
+        metavar="Size",
+    )
+
+    # 'list' command
+    list_command = commands.add_parser(
+        "list", help="List all added projects", description="List all added projects."
+    )
+
+    list_command.set_defaults(command_name="list")
+
+    # 'op' command
+    op_command = commands.add_parser(
+        "op", help="Manage operator players", description="Manage the operator status."
+    )
+
+    op_command.set_defaults(parser=op_command)
+    op_subcommands = op_command.add_subparsers(title="Subcommands")
+
+    # 'op grant'
+    op_grant_command = op_subcommands.add_parser(
+        "grant",
+        help="Grant operator to players",
+        description="Grant operator status to players.",
+    )
+
+    op_grant_command.set_defaults(command_name="op_grant")
+    op_grant_command.add_argument(
+        "players", nargs="+", type=str, help="Player names or UUIDs"
+    )
+
+    # 'op list'
+    op_list_command = op_subcommands.add_parser(
+        "list", help="List operator players", description="List all operator players."
+    )
+
+    op_list_command.set_defaults(command_name="op_list")
+
+    # 'op revoke'
+    op_revoke_command = op_subcommands.add_parser(
+        "revoke",
+        help="Revoke operator from players",
+        description="Revoke operator status from players.",
+    )
+
+    op_revoke_command.set_defaults(command_name="op_revoke")
+    op_revoke_command.add_argument(
+        "players", nargs="+", type=str, help="Player names or UUIDs"
+    )
+
+    # 'remove' command
+    remove_command = commands.add_parser(
+        "remove", help="Remove projects", description="Remove projects"
+    )
+
+    # 'search' command
+    search_command = commands.add_parser(
+        "search",
+        help="Search Modrinth projects",
+        description="Search projects from Modrinth.",
+    )
+
+    search_command.set_defaults(command_name="search")
+    search_command.add_argument("query", nargs="*", type=str, help="Query to search")
+
+    # 'show' command
+    show_command = commands.add_parser(
+        "show",
+        help="Show Modrinth project information",
+        description="Show information about Modrinth projects.",
+    )
+
+    show_command.set_defaults(command_name="show")
+    show_command.add_argument(
+        "projects", nargs="+", type=str, help="Project slugs or IDs"
+    )
+
+    # 'start' command
+    start_command = commands.add_parser(
+        "start", help="Start the server", description="Install and start the server."
+    )
+
+    start_command.set_defaults(command_name="start")
+
+    # "stop" command
+    stop_command = commands.add_parser(
+        "stop", help="Stop the server", description="Stop the running server"
+    )
+
+    stop_command.set_defaults(command_name="stop")
+    stop_command.add_argument(
+        "--force-stop", action="store_true", help="Force stop the server"
+    )
+
+    # "update" command
+    update_command = commands.add_parser(
+        "update",
+        help="Update projects from Modrinth",
+        description="Update projects from Modrinth",
+    )
+
+    # 'whitelist' command
+    whitelist_command = commands.add_parser(
+        "whitelist",
+        help="Manage whitelisted players",
+        description="Manage the player whitelist.",
+    )
+
+    whitelist_command.set_defaults(parser=whitelist_command)
+    whitelist_subcommands = whitelist_command.add_subparsers(title="Subcommands")
+
+    # 'whitelist add'
+    whitelist_add_command = whitelist_subcommands.add_parser(
+        "add",
+        help="Add players to whitelist",
+        description="Add players to the whitelist.",
+    )
+
+    whitelist_add_command.set_defaults(command_name="whitelist_add")
+    whitelist_add_command.add_argument(
+        "players", nargs="+", type=str, help="Player names or UUIDs"
+    )
+
+    # 'whitelist list'
+    whitelist_list_command = whitelist_subcommands.add_parser(
+        "list",
+        help="List whitelisted players",
+        description="List all whitelisted players.",
+    )
+
+    whitelist_list_command.set_defaults(command_name="whitelist_list")
+
+    # 'whitelist remove'
+    whitelist_remove_command = whitelist_subcommands.add_parser(
+        "remove",
+        help="Remove players from whitelist",
+        description="Remove players from the whitelist.",
+    )
+
+    whitelist_remove_command.set_defaults(command_name="whitelist_remove")
+    whitelist_remove_command.add_argument(
+        "players", nargs="+", type=str, help="Player names or UUIDs"
+    )
+
+    args = parser.parse_args()
+    return args.func(args)

mcserver/commands/__init__.py

@@ -0,0 +1,39 @@
+from .add_projects import main as add_projects
+from .import_setup import main as import_setup
+from .initialize_server import main as initialize_server
+from .list_projects import main as list_projects
+from .op_grant import main as op_grant
+from .op_list import main as op_list
+from .op_revoke import main as op_revoke
+from .print_help import main as print_help
+from .remove_projects import main as remove_projects
+from .search_projects import main as search_projects
+from .show_projects import main as show_projects
+from .server_status import main as server_status
+from .start_server import main as start_server
+from .stop_server import main as stop_server
+from .update_projects import main as update_projects
+from .whitelist_add import main as whitelist_add
+from .whitelist_list import main as whitelist_list
+from .whitelist_remove import main as whitelist_remove
+
+__all__ = [
+    "add_projects",
+    "import_setup",
+    "initialize_server",
+    "list_projects",
+    "op_grant",
+    "op_list",
+    "op_revoke",
+    "print_help",
+    "remove_projects",
+    "search_projects",
+    "server_status",
+    "show_projects",
+    "start_server",
+    "stop_server",
+    "update_projects",
+    "whitelist_add",
+    "whitelist_list",
+    "whitelist_remove",
+]

mcserver/commands/add_projects.py

@@ -0,0 +1,7 @@
+import argparse
+
+
+def main(args: argparse.Namespace) -> int:
+    projects: list[str] = args.projects
+    print(args)
+    return 0

mcserver/commands/import_setup.py

@@ -0,0 +1,6 @@
+import argparse
+
+
+def main(args: argparse.Namespace) -> int:
+    print(args)
+    return 0

mcserver/commands/initialize_server.py

@@ -0,0 +1,119 @@
+import argparse
+
+
+def main(args: argparse.Namespace) -> int:
+    # CLI Arguments
+    game_version: str = args.game_version
+
+    loader_name: str = args.loader_name
+    loader_version: str | None = args.loader_version
+
+    min_ram: int = args.min_ram
+    max_ram: int = args.max_ram
+
+    # Imports
+    import copy
+    import logging as log
+
+    from .. import __version__, config, shared, state
+    from ..metadata import metadata_file, set_metadata
+
+    # Special loader version
+    if loader_name == "vanilla":
+        loader_version = None
+
+    # Special latest game_version
+    if game_version in ["latest", "latest-release", "latest-snapshot"]:
+        from ..mojang import manifest as mojang_manifest
+
+        match game_version:
+            case "latest" | "latest-release":
+                game_version = mojang_manifest.get_latest_release_version()
+                log.info(f"Latest Minecraft release version is: {game_version}")
+            case "latest-snapshot":
+                game_version = mojang_manifest.get_latest_snapshot_version()
+                log.info(f"Latest Minecraft snapshot version is: {game_version}")
+
+    # Special latest loader_version
+    if loader_version == "latest":
+        match loader_name:
+            # Mod Loaders
+            case "fabric":
+                from ..fabricmc import meta as fabricmc_meta
+
+                loader_versions = fabricmc_meta.get_loader_versions()
+                for version in loader_versions:
+                    if version["is_stable"]:
+                        loader_version = version["loader_version"]
+                        break
+
+                log.info(f"Latest Fabric loader version is {loader_version}")
+            case "quilt":
+                from ..quiltmc import meta as quiltmc_meta
+
+                loader_versions = quiltmc_meta.get_loader_versions()
+                latest_quilt_version = loader_versions[0]
+                loader_version = str(latest_quilt_version["loader_version"])
+                log.info(f"Latest Quilt loader version is {loader_version}")
+            # Plugin Loader
+            case "paper":
+                from ..papermc import api as papermc_api
+
+                latest_paper_version = papermc_api.get_latest_project_build(
+                    "paper", game_version
+                )
+                loader_version = str(latest_paper_version["build_id"])
+                log.info(f"Latest Paper build version is: {loader_version}")
+            case "purpur":
+                from ..purpurmc import api as purpurmc_api
+
+                latest_purpur_version = purpurmc_api.get_latest_project_build(
+                    "purpur", game_version
+                )
+                loader_version = str(latest_purpur_version["build_id"])
+                log.info(f"Latest Purpur build version is: {loader_version}")
+
+            case _:
+                log.error(f"Unknown loader: {loader_name}")
+                return 1
+
+    # Is first initializing
+    is_first_initialize = not metadata_file.exists()
+    shared.set_loader_context(loader_name)
+
+    shared.mcserver_dir.mkdir(exist_ok=True)
+    state.set_state("initializing_server")
+
+    config.configs_dir.mkdir(exist_ok=True)
+    shared.tempfiles_dir.mkdir(exist_ok=True)
+    if shared.loader_context["project_directory"] is not None:
+        shared.loader_context["project_directory"].mkdir(exist_ok=True)
+
+    # Write configuration to file
+    for config_name in shared.default_configs.keys():
+        default_config = copy.deepcopy(shared.default_configs[config_name])
+
+        config_override: dict = {}
+        match config_name:
+            case "launcher":
+                config_override = {"ram": {"min": min_ram, "max": max_ram}}
+
+            case "server":
+                config_override = {
+                    "game_version": game_version,
+                    "loader": {"name": loader_name, "version": loader_version},
+                }
+
+        config_data = shared.merge_dict(default_config, config_override)
+        try:
+            config.generate_config(config_name, config_data)
+        except FileExistsError:
+            log.debug(f"Configuration file {config_name} already exists")
+
+    if is_first_initialize:
+        set_metadata(__version__)
+        log.info("Initialized server configurations.")
+    else:
+        log.info("Reinitialized server configurations.")
+
+    return 0

mcserver/commands/list_projects.py

@@ -0,0 +1,6 @@
+import argparse
+
+
+def main(args: argparse.Namespace) -> int:
+    print(args)
+    return 0

mcserver/commands/op_grant.py

@@ -0,0 +1,7 @@
+import argparse
+
+
+def main(args: argparse.Namespace) -> int:
+    players: list[str] = args.players
+    print(args)
+    return 0

mcserver/commands/op_list.py

@@ -0,0 +1,32 @@
+import argparse
+
+
+def main(args: argparse.Namespace) -> int:
+    import logging as log
+
+    from ..server_files import ops
+    from ..shared import pluralize
+
+    if not ops.ops_file.exists():
+        log.error(f"File '{ops.ops_file}' not found.")
+        return 1
+
+    operator_players = ops.list_players()
+
+    players: list[str] = []
+    for player in operator_players:
+        players.append(
+            f"{player['player_name']} ({player['player_uuid']}) Level: {player["permission_level"]}"
+        )
+
+    players.sort()
+    sorted_players = "\n".join(players)
+
+    player_count = len(operator_players)
+    if player_count == 0:
+        log.info("There's no operator player.")
+        return 0
+
+    log.info(f"All {player_count} operator {pluralize("player", player_count)}:")
+    print(sorted_players)
+    return 0

mcserver/commands/op_revoke.py

@@ -0,0 +1,7 @@
+import argparse
+
+
+def main(args: argparse.Namespace) -> int:
+    players: list[str] = args.players
+    print(args)
+    return 0

mcserver/commands/print_help.py

@@ -0,0 +1,7 @@
+import argparse
+
+
+def main(args: argparse.Namespace) -> int:
+    parser: argparse.ArgumentParser = args.parser
+    parser.print_help()
+    return 0

mcserver/commands/remove_projects.py

@@ -0,0 +1,6 @@
+import argparse
+
+
+def main(args: argparse.Namespace) -> int:
+    print(args)
+    return 0

mcserver/commands/search_projects.py

@@ -0,0 +1,7 @@
+import argparse
+
+
+def main(args: argparse.Namespace) -> int:
+    query: list[str] = args.query
+    print(args)
+    return 0

mcserver/commands/server_status.py

@@ -0,0 +1,6 @@
+import argparse
+
+
+def main(args: argparse.Namespace) -> int:
+    print(args)
+    return 0

mcserver/commands/show_projects.py

@@ -0,0 +1,26 @@
+import argparse
+
+
+def main(args: argparse.Namespace) -> int:
+    projects: list[str] = args.projects
+
+    from ..modrinth import api as modrinth_api
+    from ..shared import format_number
+
+    project_information = modrinth_api.get_project_information(projects)
+    for project in project_information:
+        if "project_title" in project and "project_slug" in project:
+            print(f"Name: {project['project_title']} ({project['project_slug']})")
+
+        if "download_count" in project:
+            print(f"Downloads: {format_number(project['download_count'])}")
+
+        if "follower_count" in project:
+            print(f"Followers: {format_number(project["follower_count"])}")
+
+        if "project_slug" in project:
+            print(
+                f"Homepage: https://modrinth.com/{project['project_type']}/{project['project_slug']}"
+            )
+
+    return 0