bsm-cli 1.6.0b3__py3-none-any.whl

bsm_cli/server.py

@@ -0,0 +1,471 @@
+import asyncio
+import os
+
+import click
+import questionary
+from bsm_cli.allowlist import interactive_allowlist_workflow
+from bsm_cli.decorators import monitor_task, pass_async_context
+from bsm_cli.permissions import interactive_permissions_workflow
+from bsm_cli.properties import interactive_properties_workflow
+
+from bsm_api_client.exceptions import AuthError
+from bsm_api_client.models import CommandPayload, InstallServerPayload
+
+
+def _print_server_table(servers):
+    """Prints a formatted table of server information to the console."""
+    header = f"{'SERVER NAME':<25} {'STATUS':<15} {'VERSION'}"
+    click.secho(header, bold=True)
+    click.echo("-" * 65)
+
+    if not servers:
+        click.echo("  No servers found.")
+    else:
+        for server_data in servers:
+            name = getattr(server_data, "name", "N/A")
+            status = getattr(server_data, "status", "UNKNOWN").upper()
+            version = getattr(server_data, "version", "UNKNOWN")
+
+            color_map = {
+                "RUNNING": "green",
+                "STOPPED": "red",
+                "STARTING": "yellow",
+                "STOPPING": "yellow",
+                "INSTALLING": "bright_cyan",
+                "UPDATING": "bright_cyan",
+                "INSTALLED": "bright_magenta",
+                "UPDATED": "bright_magenta",
+                "UNKNOWN": "bright_black",
+            }
+            status_color = color_map.get(status, "red")
+
+            status_styled = click.style(f"{status:<10}", fg=status_color)
+            name_styled = click.style(name, fg="cyan")
+            version_styled = click.style(version, fg="bright_white")
+
+            click.echo(f"  {name_styled:<38} {status_styled:<20} {version_styled}")
+    click.echo("-" * 65)
+
+
+@click.group()
+def server():
+    """Manages servers."""
+    pass
+
+
+@server.command("list")
+@click.option(
+    "--loop", is_flag=True, help="Continuously refresh server statuses every 5 seconds."
+)
+@click.option("--server-name", help="Display status for only a specific server.")
+@pass_async_context
+async def list_servers(ctx, loop, server_name):  # noqa: C901
+    """Lists all configured Bedrock servers and their current operational status."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    async def _display_status():
+        response = await client.async_get_servers()
+        all_servers = response.servers or []
+
+        if server_name:
+            servers_to_show = [
+                s for s in all_servers if getattr(s, "name", "") == server_name
+            ]
+        else:
+            servers_to_show = all_servers
+
+        _print_server_table(servers_to_show)
+
+    try:
+        if loop:
+            # Initial display
+            click.clear()
+            click.secho(
+                "--- Bedrock Servers Status (Press CTRL+C to exit) ---",
+                fg="magenta",
+                bold=True,
+            )
+            await _display_status()
+
+            # Try to use WebSocket for updates
+            try:
+                ws_client = await client.websocket_connect()
+
+                async with ws_client:
+                    # Subscribe to multiple topics for comprehensive status updates
+                    await ws_client.subscribe("event:after_server_statuses_updated")
+                    await ws_client.subscribe("event:after_server_start")
+                    await ws_client.subscribe("event:after_server_stop")
+                    await ws_client.subscribe("event:after_server_updated")
+                    await ws_client.subscribe("event:after_delete_server_data")
+
+                    # Listen for updates
+                    async for _ in ws_client.listen():
+                        click.clear()
+                        click.secho(
+                            "--- Bedrock Servers Status (Press CTRL+C to exit) ---",
+                            fg="magenta",
+                            bold=True,
+                        )
+                        await _display_status()
+
+            except (KeyboardInterrupt, click.Abort):
+                raise
+            except AuthError:
+                click.secho(
+                    "WebSocket authentication failed. Attempting to refresh token...",
+                    fg="yellow",
+                )
+                try:
+                    await client.authenticate()
+                    # Retry WebSocket once
+                    ws_client = await client.websocket_connect()
+                    async with ws_client:
+                        await ws_client.subscribe("event:after_server_statuses_updated")
+                        async for _ in ws_client.listen():
+                            click.clear()
+                            click.secho(
+                                "--- Bedrock Servers Status (Press CTRL+C to exit) ---",
+                                fg="magenta",
+                                bold=True,
+                            )
+                            await _display_status()
+                except Exception as e:
+                    click.secho(
+                        f"WebSocket retry failed ({e}), falling back to polling...",
+                        fg="yellow",
+                    )
+                    await asyncio.sleep(2)
+                    while True:
+                        click.clear()
+                        click.secho(
+                            "--- Bedrock Servers Status (Press CTRL+C to exit) ---",
+                            fg="magenta",
+                            bold=True,
+                        )
+                        await _display_status()
+                        await asyncio.sleep(5)
+            except Exception as e:
+                # Fallback to polling if WebSocket fails
+                click.secho(
+                    f"WebSocket connection failed ({e}), falling back to polling...",
+                    fg="yellow",
+                )
+
+            # If we are here, WebSocket failed or closed. Fallback to polling.
+            await asyncio.sleep(2)
+            while True:
+                click.clear()
+                click.secho(
+                    "--- Bedrock Servers Status (Press CTRL+C to exit) ---",
+                    fg="magenta",
+                    bold=True,
+                )
+                try:
+                    await _display_status()
+                except Exception as e:
+                    click.secho(f"Error refreshing status: {e}", fg="red")
+                await asyncio.sleep(5)
+        else:
+            if not server_name:
+                click.secho("--- Bedrock Servers Status ---", fg="magenta", bold=True)
+            await _display_status()
+
+    except (KeyboardInterrupt, click.Abort):
+        click.secho("\nExiting status monitor.", fg="green")
+    except Exception as e:
+        click.secho(f"An error occurred: {e}", fg="red")
+
+
+@server.command("start")
+@click.option(
+    "-s", "--server", "server_name", required=True, help="Name of the server to start."
+)
+@pass_async_context
+async def start_server(ctx, server_name: str):
+    """Starts a specific Bedrock server instance."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    click.echo(f"Attempting to start server '{server_name}'...")
+    try:
+        response = await client.async_start_server(server_name)
+        if response.task_id:
+            await monitor_task(
+                client,
+                response.task_id,
+                "Server started successfully",
+                "Failed to start server",
+            )
+        elif response.status == "success":
+            click.secho(f"Server '{server_name}' started successfully.", fg="green")
+        else:
+            click.secho(f"Failed to start server: {response.message}", fg="red")
+    except Exception as e:
+        click.secho(f"Failed to start server: {e}", fg="red")
+
+
+@server.command("stop")
+@click.option(
+    "-s", "--server", "server_name", required=True, help="Name of the server to stop."
+)
+@pass_async_context
+async def stop_server(ctx, server_name: str):
+    """Sends a graceful stop command to a running Bedrock server."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    click.echo(f"Attempting to stop server '{server_name}'...")
+    try:
+        response = await client.async_stop_server(server_name)
+        if response.task_id:
+            await monitor_task(
+                client,
+                response.task_id,
+                "Server stopped successfully",
+                "Failed to stop server",
+            )
+        elif response.status == "success":
+            click.secho(f"Stop signal sent to server '{server_name}'.", fg="green")
+        else:
+            click.secho(f"Failed to stop server: {response.message}", fg="red")
+    except Exception as e:
+        click.secho(f"Failed to stop server: {e}", fg="red")
+
+
+@server.command("restart")
+@click.option(
+    "-s",
+    "--server",
+    "server_name",
+    required=True,
+    help="Name of the server to restart.",
+)
+@pass_async_context
+async def restart_server(ctx, server_name: str):
+    """Gracefully restarts a specific Bedrock server."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    click.echo(f"Attempting to restart server '{server_name}'...")
+    try:
+        response = await client.async_restart_server(server_name)
+        if response.task_id:
+            await monitor_task(
+                client,
+                response.task_id,
+                "Server restarted successfully",
+                "Failed to restart server",
+            )
+        elif response.status == "success":
+            click.secho(f"Restart signal sent to server '{server_name}'.", fg="green")
+        else:
+            click.secho(f"Failed to restart server: {response.message}", fg="red")
+    except Exception as e:
+        click.secho(f"Failed to restart server: {e}", fg="red")
+
+
+@server.command("install")
+@click.pass_context
+async def install(ctx):  # noqa: C901
+    """Guides you through installing and configuring a new Bedrock server instance."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    try:
+        click.secho("--- New Bedrock Server Installation ---", bold=True)
+        server_name = await questionary.text(
+            "Enter a name for the new server:"
+        ).ask_async()
+        if not server_name:
+            raise click.Abort()
+
+        target_version = await questionary.text(
+            "Enter server version (e.g., LATEST, PREVIEW, CUSTOM, 1.20.81.01):",
+            default="LATEST",
+        ).ask_async()
+        if not target_version:
+            raise click.Abort()
+
+        server_zip_path = None
+        if target_version.upper() == "CUSTOM":
+            response = await client.async_get_custom_zips()
+            available_files = response.custom_zips
+
+            if not available_files:
+                click.secho(
+                    "No custom server ZIP files found in the content/custom directory.",
+                    fg="red",
+                )
+                return
+
+            file_map = {os.path.basename(f): f for f in available_files}
+            choices = sorted(list(file_map.keys())) + ["Cancel"]
+            selection = await questionary.select(
+                "Select a custom server ZIP to install:", choices=choices
+            ).ask_async()
+
+            if not selection or selection == "Cancel":
+                raise click.Abort()
+            server_zip_path = file_map[selection]
+
+        overwrite = await questionary.confirm(
+            "Overwrite existing server if it exists?", default=False
+        ).ask_async()
+
+        click.echo(f"\nInstalling server '{server_name}' version '{target_version}'...")
+
+        payload = InstallServerPayload(
+            server_name=server_name,
+            server_version=target_version,
+            overwrite=overwrite,
+            server_zip_path=server_zip_path,
+        )
+        install_result = await client.async_install_new_server(payload)
+
+        if install_result.task_id:
+            await monitor_task(
+                client,
+                install_result.task_id,
+                "Server installation completed successfully",
+                "Installation failed",
+            )
+        elif install_result.status == "success":
+            click.secho("Server files installed successfully.", fg="green")
+        else:
+            click.secho(f"Failed to install server: {install_result.message}", fg="red")
+            return
+
+        await interactive_properties_workflow(client, server_name)
+        if await questionary.confirm(
+            "\nConfigure the allowlist now?", default=False
+        ).ask_async():
+            await interactive_allowlist_workflow(client, server_name)
+        if await questionary.confirm(
+            "\nConfigure player permissions now?", default=False
+        ).ask_async():
+            await interactive_permissions_workflow(client, server_name)
+
+        click.secho(
+            "\nInstallation and initial configuration complete!", fg="green", bold=True
+        )
+
+        if await questionary.confirm(
+            f"Start server '{server_name}' now?", default=True
+        ).ask_async():
+            await ctx.invoke(start_server, server_name=server_name)
+
+    except Exception as e:
+        click.secho(f"An application error occurred: {e}", fg="red")
+
+
+@server.command("update")
+@click.option(
+    "-s", "--server", "server_name", required=True, help="Name of the server to update."
+)
+@pass_async_context
+async def update(ctx, server_name: str):
+    """Checks for and applies updates to an existing Bedrock server."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    click.echo(f"Checking for updates for server '{server_name}'...")
+    try:
+        response = await client.async_update_server(server_name)
+        if response.task_id:
+            await monitor_task(
+                client,
+                response.task_id,
+                "Server update completed successfully",
+                "Failed to update server",
+            )
+        elif response.status == "success":
+            click.secho("Update check complete.", fg="green")
+        else:
+            click.secho(f"Failed to update server: {response.message}", fg="red")
+    except Exception as e:
+        click.secho(f"A server update error occurred: {e}", fg="red")
+
+
+@server.command("delete")
+@click.option(
+    "-s", "--server", "server_name", required=True, help="Name of the server to delete."
+)
+@click.option("-y", "--yes", is_flag=True, help="Bypass the confirmation prompt.")
+@pass_async_context
+async def delete_server(ctx, server_name: str, yes: bool):
+    """Deletes all data for a server, including world, configs, and backups."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    if not yes:
+        click.secho(
+            f"WARNING: This will permanently delete all data for server '{server_name}',\n"
+            "including the installation, worlds, and all associated backups.",
+            fg="red",
+            bold=True,
+        )
+        click.confirm(
+            f"\nAre you absolutely sure you want to delete '{server_name}'?", abort=True
+        )
+
+    click.echo(f"Proceeding with deletion of server '{server_name}'...")
+    try:
+        response = await client.async_delete_server(server_name)
+        if response.task_id:
+            await monitor_task(
+                client,
+                response.task_id,
+                "Server deleted successfully",
+                "Failed to delete server",
+            )
+        elif response.status == "success":
+            click.secho(
+                f"Server '{server_name}' and all its data have been deleted.",
+                fg="green",
+            )
+        else:
+            click.secho(f"Failed to delete server: {response.message}", fg="red")
+    except Exception as e:
+        click.secho(f"Failed to delete server: {e}", fg="red")
+
+
+@server.command("send-command")
+@click.option(
+    "-s", "--server", "server_name", required=True, help="Name of the target server."
+)
+@click.argument("command_parts", nargs=-1, required=True)
+@click.pass_context
+async def send_command(ctx, server_name: str, command_parts: str):
+    """Sends a command to a running Bedrock server's console."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    command_string = " ".join(command_parts)
+    click.echo(f"Sending command to '{server_name}': {command_string}")
+    try:
+        payload = CommandPayload(command=command_string)
+        response = await client.async_send_server_command(server_name, payload)
+        if response.status == "success":
+            click.secho("Command sent successfully.", fg="green")
+        else:
+            click.secho(f"Failed to send command: {response.message}", fg="red")
+    except Exception as e:
+        click.secho(f"Failed to send command: {e}", fg="red")

bsm_cli/system.py

@@ -0,0 +1,142 @@
+import time
+
+import click
+import questionary
+
+from bsm_api_client.models import ServerSettingItemPayload
+
+
+@click.group()
+def system():
+    """Manages server OS-level resource monitoring and settings."""
+    pass
+
+
+@system.command("settings")
+@click.option(
+    "-s",
+    "--server",
+    "server_name",
+    required=True,
+    help="Name of the server to configure.",
+)
+@click.pass_context
+async def server_settings(ctx, server_name: str):
+    """Configures autostart and autoupdate settings for a Bedrock server."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    click.secho(
+        f"Starting interactive settings configuration for '{server_name}'...",
+        fg="yellow",
+    )
+
+    settings_response = await client.async_get_server_settings(server_name)
+    if settings_response.status != "success" or not settings_response.settings:
+        click.secho(
+            f"Failed to fetch server settings: {settings_response.message}", fg="red"
+        )
+        return
+
+    settings = settings_response.settings
+
+    current_autoupdate = settings.get("settings", {}).get("autoupdate", False)
+    current_autostart = settings.get("settings", {}).get("autostart", False)
+
+    click.secho(
+        f"\n--- Interactive Settings Configuration for '{server_name}' ---", bold=True
+    )
+
+    autoupdate_choice = await questionary.confirm(
+        "Enable check for updates when the server starts?", default=current_autoupdate
+    ).ask_async()
+
+    if autoupdate_choice is not None and autoupdate_choice != current_autoupdate:
+        payload = ServerSettingItemPayload(
+            key="settings.autoupdate", value=autoupdate_choice
+        )
+        response = await client.async_set_server_setting(server_name, payload)
+        if response.status == "success":
+            click.secho(
+                f"Autoupdate setting configured to '{autoupdate_choice}'.", fg="green"
+            )
+        else:
+            click.secho(f"Failed to set autoupdate: {response.message}", fg="red")
+
+    autostart_choice = await questionary.confirm(
+        "Enable the server to start automatically when the manager starts?",
+        default=current_autostart,
+    ).ask_async()
+
+    if autostart_choice is not None and autostart_choice != current_autostart:
+        payload = ServerSettingItemPayload(
+            key="settings.autostart", value=autostart_choice
+        )
+        response = await client.async_set_server_setting(server_name, payload)
+        if response.status == "success":
+            click.secho(
+                f"Autostart setting configured to '{autostart_choice}'.", fg="green"
+            )
+        else:
+            click.secho(f"Failed to set autostart: {response.message}", fg="red")
+
+    click.secho("\nSettings configuration complete.", fg="green", bold=True)
+
+
+@system.command("monitor")
+@click.option(
+    "-s",
+    "--server",
+    "server_name",
+    required=True,
+    help="Name of the server to monitor.",
+)
+@click.pass_context
+async def monitor_usage(ctx, server_name: str):
+    """Continuously monitors CPU and memory usage of a specific server process."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    click.secho(
+        f"Starting resource monitoring for server '{server_name}'. Press CTRL+C to exit.",
+        fg="cyan",
+    )
+    time.sleep(1)
+
+    try:
+        while True:
+            response = await client.async_get_server_process_info(server_name)
+
+            click.clear()
+            click.secho(
+                f"--- Monitoring Server: {server_name} ---", fg="magenta", bold=True
+            )
+            click.echo(
+                f"(Last updated: {time.strftime('%H:%M:%S')}, Press CTRL+C to exit)\n"
+            )
+
+            if response.status == "error":
+                click.secho(f"Error: {response.message}", fg="red")
+            elif response.process_info is None:
+                click.secho("Server process not found (is it running?).", fg="yellow")
+            else:
+                info = response.process_info
+                pid_str = info.get("pid", "N/A")
+                cpu_str = f"{info.get('cpu_percent', 0.0):.1f}%"
+                mem_str = f"{info.get('memory_mb', 0.0):.1f} MB"
+                uptime_str = info.get("uptime", "N/A")
+
+                click.echo(f"  {'PID':<15}: {click.style(str(pid_str), fg='cyan')}")
+                click.echo(f"  {'CPU Usage':<15}: {click.style(cpu_str, fg='green')}")
+                click.echo(
+                    f"  {'Memory Usage':<15}: {click.style(mem_str, fg='green')}"
+                )
+                click.echo(f"  {'Uptime':<15}: {click.style(uptime_str, fg='white')}")
+
+            time.sleep(2)
+    except (KeyboardInterrupt, click.Abort):
+        click.secho("\nMonitoring stopped.", fg="green")