bsm-cli 1.6.0b3__py3-none-any.whl

bsm_cli/allowlist.py

@@ -0,0 +1,229 @@
+import click
+import questionary
+
+from bsm_api_client.models import AllowlistAddPayload, AllowlistRemovePayload
+
+
+@click.group()
+def allowlist():
+    """Manages a server's player allowlist."""
+    pass
+
+
+@allowlist.command("add")
+@click.option(
+    "-s", "--server", "server_name", required=True, help="The name of the server."
+)
+@click.option(
+    "-p",
+    "--player",
+    "players",
+    multiple=True,
+    help="Gamertag of the player to add. Use multiple times for multiple players.",
+)
+@click.option(
+    "--ignore-limit",
+    is_flag=True,
+    help="Allow player(s) to join even if the server is full.",
+)
+@click.pass_context
+async def add(ctx, server_name: str, players: tuple[str], ignore_limit: bool):
+    """Adds one or more players to a server's allowlist."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    try:
+        if not players:
+            click.secho(
+                f"No player specified; starting interactive editor for '{server_name}'...",
+                fg="yellow",
+            )
+            await interactive_allowlist_workflow(client, server_name)
+            return
+
+        payload = AllowlistAddPayload(
+            players=list(players), ignoresPlayerLimit=ignore_limit
+        )
+        response = await client.async_add_server_allowlist(server_name, payload)
+
+        message = response.message
+        click.secho(
+            message,
+            fg="green",
+        )
+
+    except Exception as e:
+        click.secho(f"\nAn error occurred: {e}", fg="red")
+
+
+@allowlist.command("remove")
+@click.option(
+    "-s", "--server", "server_name", required=True, help="The name of the server."
+)
+@click.option(
+    "-p",
+    "--player",
+    "players",
+    multiple=True,
+    required=True,
+    help="Gamertag of the player to remove. Use multiple times for multiple players.",
+)
+@click.pass_context
+async def remove(ctx, server_name: str, players: tuple[str]):
+    """Removes one or more players from a server's allowlist."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    player_list = list(players)
+    click.echo(
+        f"Removing {len(player_list)} player(s) from '{server_name}' allowlist..."
+    )
+
+    payload = AllowlistRemovePayload(players=player_list)
+    response = await client.async_remove_server_allowlist_players(server_name, payload)
+
+    if response.status == "success":
+        details = response.details or {}
+        removed_players = details["removed"] or []
+        not_found_players = details["not_found"] or []
+
+        message = response.message
+        click.secho(message, fg="cyan" if not removed_players else "green")
+
+        if removed_players:
+            click.secho(
+                f"\nSuccessfully removed {len(removed_players)} player(s):", fg="green"
+            )
+            for p_name in removed_players:
+                click.echo(f"  - {p_name}")
+        if not_found_players:
+            click.secho(
+                f"\n{len(not_found_players)} player(s) were not found in the allowlist:",
+                fg="yellow",
+            )
+            for p_name in not_found_players:
+                click.echo(f"  - {p_name}")
+    else:
+        click.secho(
+            f"Failed to remove players from allowlist: {response.message}", fg="red"
+        )
+
+
+@allowlist.command("list")
+@click.option(
+    "-s", "--server", "server_name", required=True, help="The name of the server."
+)
+@click.pass_context
+async def list_players(ctx, server_name: str):
+    """Lists all players currently on a server's allowlist."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    response = await client.async_get_server_allowlist(server_name)
+
+    if response.status == "success":
+        players = response.players
+        if not players:
+            click.secho(
+                f"The allowlist for server '{server_name}' is empty.", fg="yellow"
+            )
+            return
+
+        click.secho(f"\nAllowlist for '{server_name}':", bold=True)
+        for p in players:
+            limit_str = (
+                click.style(" (Ignores Player Limit)", fg="yellow")
+                if p.get("ignoresPlayerLimit")
+                else ""
+            )
+            click.echo(f"  - {p.get('name')}{limit_str}")
+    else:
+        click.secho(f"Failed to list allowlist: {response.message}", fg="red")
+
+
+async def interactive_allowlist_workflow(client, server_name: str):  # noqa: C901
+    """Guides the user through an interactive session to view and add players to the allowlist."""
+    response = await client.async_get_server_allowlist(server_name)
+    existing_players = response.players or []
+
+    click.secho("\n--- Interactive Allowlist Configuration ---", bold=True)
+    if existing_players:
+        click.echo("Current players in allowlist:")
+        for p in existing_players:
+            limit_str = (
+                click.style(" (Ignores Limit)", fg="yellow")
+                if p.get("ignoresPlayerLimit")
+                else ""
+            )
+            click.echo(f"  - {p.get('name')}{limit_str}")
+    else:
+        click.secho("Allowlist is currently empty.", fg="yellow")
+
+    from typing import Any, Dict, List
+
+    new_players_to_add: List[Dict[str, Any]] = []
+    click.echo("\nEnter new players to add. Press Enter on an empty line to finish.")
+    while True:
+        player_name = await questionary.text("Player gamertag:").ask_async()
+        if not player_name or not player_name.strip():
+            break
+
+        if any(
+            p["name"].lower() == player_name.lower()
+            for p in existing_players + new_players_to_add
+        ):
+            click.secho(
+                f"Player '{player_name}' is already in the list. Skipping.", fg="yellow"
+            )
+            continue
+
+        ignore_limit = await questionary.confirm(
+            f"Should '{player_name}' ignore the player limit?", default=False
+        ).ask_async()
+        new_players_to_add.append(
+            {"name": player_name.strip(), "ignoresPlayerLimit": ignore_limit}
+        )
+
+    if new_players_to_add:
+        # The interactive mode will add all players with their specified ignore limit.
+        # We need to group them by the ignore limit flag and make separate API calls.
+        players_ignore_limit = [
+            p["name"] for p in new_players_to_add if p["ignoresPlayerLimit"]
+        ]
+        players_no_ignore_limit = [
+            p["name"] for p in new_players_to_add if not p["ignoresPlayerLimit"]
+        ]
+
+        if players_ignore_limit:
+            click.echo("Adding players with ignore limit...")
+            payload = AllowlistAddPayload(
+                players=players_ignore_limit, ignoresPlayerLimit=True
+            )
+            response = await client.async_add_server_allowlist(server_name, payload)
+            if response.status != "success":
+                click.secho(
+                    f"Failed to add players with ignore limit: {response.message}",
+                    fg="red",
+                )
+
+        if players_no_ignore_limit:
+            click.echo("Adding players without ignore limit...")
+            payload = AllowlistAddPayload(
+                players=players_no_ignore_limit, ignoresPlayerLimit=False
+            )
+            response = await client.async_add_server_allowlist(server_name, payload)
+            if response.status != "success":
+                click.secho(
+                    f"Failed to add players without ignore limit: {response.message}",
+                    fg="red",
+                )
+
+        click.secho("Allowlist updated.", fg="green")
+    else:
+        click.secho("No new players were added.", fg="cyan")

bsm_cli/auth.py

@@ -0,0 +1,106 @@
+import click
+
+from bsm_api_client import AuthError, BedrockServerManagerApi
+
+
+def _validate_and_get_url(url: str) -> str:
+    """Validates and returns a url with a scheme."""
+    if not url.startswith("http://") and not url.startswith("https://"):
+        return f"http://{url}"
+    return url
+
+
+@click.group()
+def auth():
+    """Manages authentication."""
+    pass
+
+
+@auth.command()
+@click.option(
+    "--base-url", prompt=True, help="The base URL of the Bedrock Server Manager API."
+)
+@click.option(
+    "--verify-ssl/--no-verify-ssl",
+    is_flag=True,
+    default=True,
+    prompt=True,
+    help="Enable/disable SSL verification.",
+)
+@click.option("--username", help="The username for authentication.")
+@click.option("--password", help="The password for authentication.")
+@click.option("--token", help="The JWT token for authentication.")
+@click.pass_context
+async def login(ctx, base_url, username, password, verify_ssl, token):
+    """Logs in to the Bedrock Server Manager API."""
+    config = ctx.obj["config"]
+
+    if base_url:
+        validated_url = _validate_and_get_url(base_url)
+        config.set("base_url", validated_url)
+
+    config.set("verify_ssl", verify_ssl)
+
+    if token:
+        config.jwt_token = token
+        click.echo("Token set.")
+        return
+
+    if not username and not password and not token:
+        await interactive_login(ctx)
+        return
+
+    if username and not password:
+        password = click.prompt("Password", hide_input=True)
+
+    client = BedrockServerManagerApi(
+        base_url=config.base_url,
+        username=username,
+        password=password,
+        verify_ssl=config.verify_ssl,
+    )
+    try:
+        token_data = await client.authenticate()
+        config.jwt_token = token_data.access_token
+        click.echo("Login successful.")
+    except AuthError as e:
+        click.secho(f"Login failed: {e}", fg="red")
+    finally:
+        await client.close()
+
+
+async def interactive_login(ctx):
+    """Handles the interactive login prompt."""
+    config = ctx.obj["config"]
+    username = click.prompt("Username")
+    password = click.prompt("Password", hide_input=True)
+
+    validated_url = _validate_and_get_url(config.base_url)
+    if validated_url != config.base_url:
+        config.set("base_url", validated_url)
+
+    client = BedrockServerManagerApi(
+        base_url=validated_url,
+        username=username,
+        password=password,
+        verify_ssl=config.verify_ssl,
+    )
+    try:
+        token_data = await client.authenticate()
+        config.jwt_token = token_data.access_token
+        click.echo("Login successful.")
+    except AuthError as e:
+        click.secho(f"Login failed: {e}", fg="red")
+    finally:
+        await client.close()
+
+
+@auth.command()
+@click.pass_context
+async def logout(ctx):
+    """Logs out from the Bedrock Server Manager API."""
+    config = ctx.obj["config"]
+    config.jwt_token = None
+    click.echo("Logged out.")
+    if "client" in ctx.obj and ctx.obj["client"]:
+        await ctx.obj["client"].close()

bsm_cli/backup.py

@@ -0,0 +1,263 @@
+import os
+
+import click
+import questionary
+from bsm_cli.decorators import monitor_task, pass_async_context
+
+from bsm_api_client.models import BackupActionPayload, RestoreActionPayload
+
+
+@click.group()
+def backup():
+    """Manages server backups."""
+    pass
+
+
+@backup.command("create")
+@click.option(
+    "-s", "--server", "server_name", required=True, help="Name of the target server."
+)
+@click.option(
+    "-t",
+    "--type",
+    "backup_type",
+    type=click.Choice(["world", "config", "all"], case_sensitive=False),
+    help="Type of backup to create; skips interactive menu.",
+)
+@click.option(
+    "-f",
+    "--file",
+    "file_to_backup",
+    help="Specific file to back up (required if --type=config).",
+)
+@pass_async_context
+async def create_backup(ctx, server_name: str, backup_type: str, file_to_backup: str):
+    """Creates a backup of specified server data."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    try:
+        if not backup_type:
+            backup_type, file_to_backup, _ = await _interactive_backup_menu(server_name)
+
+        if backup_type == "config" and not file_to_backup:
+            raise click.UsageError(
+                "Option '--file' is required when using '--type config'."
+            )
+
+        click.echo(f"Starting '{backup_type}' backup for server '{server_name}'...")
+
+        payload = BackupActionPayload(
+            backup_type=backup_type, file_to_backup=file_to_backup
+        )
+        response = await client.async_trigger_server_backup(server_name, payload)
+
+        if response.task_id:
+            await monitor_task(
+                client,
+                response.task_id,
+                "Backup completed successfully",
+                "Failed to create backup",
+            )
+            click.echo("Pruning old backups...")
+            prune_response = await client.async_prune_server_backups(server_name)
+            if prune_response.task_id:
+                await monitor_task(
+                    client,
+                    prune_response.task_id,
+                    "Pruning complete",
+                    "Failed to prune backups",
+                )
+            elif prune_response.status == "success":
+                click.secho("Pruning complete.", fg="green")
+            else:
+                click.secho(
+                    f"Failed to prune backups: {prune_response.message}", fg="red"
+                )
+        elif response.status == "success":
+            click.secho("Backup completed successfully.", fg="green")
+        else:
+            click.secho(f"Failed to create backup: {response.message}", fg="red")
+
+    except Exception as e:
+        click.secho(f"An error occurred: {e}", fg="red")
+
+
+@backup.command("restore")
+@click.option(
+    "-s", "--server", "server_name", required=True, help="Name of the target server."
+)
+@click.option(
+    "-f",
+    "--file",
+    "backup_file_path",
+    type=click.Path(exists=True, dir_okay=False, resolve_path=True),
+    help="Path to the backup file to restore; skips interactive menu.",
+)
+@pass_async_context
+async def restore_backup(ctx, server_name: str, backup_file_path: str):  # noqa: C901
+    """Restores server data from a specified backup file."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    try:
+        if not backup_file_path:
+            restore_type, backup_file_path, _ = await _interactive_restore_menu(
+                client, server_name
+            )
+        else:
+            filename = os.path.basename(backup_file_path).lower()
+            if "world" in filename:
+                restore_type = "world"
+            elif "allowlist" in filename:
+                restore_type = "allowlist"
+            elif "permissions" in filename:
+                restore_type = "permissions"
+            elif "properties" in filename:
+                restore_type = "properties"
+            else:
+                raise click.UsageError(
+                    f"Could not determine restore type from filename '{filename}'."
+                )
+
+        click.echo(
+            f"Starting '{restore_type}' restore for server '{server_name}' from '{os.path.basename(backup_file_path)}'..."
+        )
+
+        payload = RestoreActionPayload(
+            restore_type=restore_type, backup_file=os.path.basename(backup_file_path)
+        )
+        response = await client.async_restore_server_backup(server_name, payload)
+
+        if response.task_id:
+            await monitor_task(
+                client,
+                response.task_id,
+                "Restore completed successfully",
+                "Failed to restore backup",
+            )
+        elif response.status == "success":
+            click.secho("Restore completed successfully.", fg="green")
+        else:
+            click.secho(f"Failed to restore backup: {response.message}", fg="red")
+
+    except Exception as e:
+        click.secho(f"An error occurred: {e}", fg="red")
+
+
+@backup.command("prune")
+@click.option(
+    "-s",
+    "--server",
+    "server_name",
+    required=True,
+    help="Name of the server whose backups to prune.",
+)
+@pass_async_context
+async def prune_backups(ctx, server_name: str):
+    """Deletes old backups for a server."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    try:
+        click.echo(f"Pruning old backups for server '{server_name}'...")
+        response = await client.async_prune_server_backups(server_name)
+        if response.task_id:
+            await monitor_task(
+                client,
+                response.task_id,
+                "Pruning complete",
+                "Failed to prune backups",
+            )
+        elif response.status == "success":
+            click.secho("Pruning complete.", fg="green")
+        else:
+            click.secho(f"Failed to prune backups: {response.message}", fg="red")
+    except Exception as e:
+        click.secho(f"An error occurred during pruning: {e}", fg="red")
+
+
+async def _interactive_backup_menu(server_name: str):
+    click.secho(f"Entering interactive backup for server: {server_name}", fg="yellow")
+
+    backup_type_map = {
+        "Backup World Only": ("world", None, True),
+        "Backup Everything (World + Configs)": ("all", None, True),
+        "Backup a Specific Configuration File": ("config", None, False),
+    }
+
+    choice = await questionary.select(
+        "Select a backup option:",
+        choices=list(backup_type_map.keys()) + ["Cancel"],
+    ).ask_async()
+
+    if not choice or choice == "Cancel":
+        raise click.Abort()
+
+    b_type, b_file, b_change_status = backup_type_map[choice]
+
+    if b_type == "config":
+        config_file_map = {
+            "allowlist.json": "allowlist.json",
+            "permissions.json": "permissions.json",
+            "server.properties": "server.properties",
+        }
+        file_choice = await questionary.select(
+            "Which configuration file do you want to back up?",
+            choices=list(config_file_map.keys()) + ["Cancel"],
+        ).ask_async()
+
+        if not file_choice or file_choice == "Cancel":
+            raise click.Abort()
+        b_file = config_file_map[file_choice]
+
+    return b_type, b_file, b_change_status
+
+
+async def _interactive_restore_menu(client, server_name: str):
+    click.secho(f"Entering interactive restore for server: {server_name}", fg="yellow")
+
+    restore_type_map = {
+        "Restore World": "world",
+        "Restore Allowlist": "allowlist",
+        "Restore Permissions": "permissions",
+        "Restore Properties": "properties",
+    }
+
+    choice = await questionary.select(
+        "What do you want to restore?",
+        choices=list(restore_type_map.keys()) + ["Cancel"],
+    ).ask_async()
+
+    if not choice or choice == "Cancel":
+        raise click.Abort()
+    restore_type = restore_type_map[choice]
+
+    response = await client.async_list_server_backups(server_name, restore_type)
+    backup_files = response.backups
+    if not backup_files:
+        click.secho(
+            f"No '{restore_type}' backups found for server '{server_name}'.",
+            fg="yellow",
+        )
+        raise click.Abort()
+
+    file_map = {os.path.basename(f): f for f in backup_files}
+    file_choices = sorted(list(file_map.keys()), reverse=True)
+
+    file_to_restore_basename = await questionary.select(
+        f"Select a '{restore_type}' backup to restore:",
+        choices=file_choices + ["Cancel"],
+    ).ask_async()
+
+    if not file_to_restore_basename or file_to_restore_basename == "Cancel":
+        raise click.Abort()
+    selected_file_path = file_map[file_to_restore_basename]
+
+    return restore_type, selected_file_path, True