bsm-cli 1.6.0b3__py3-none-any.whl

bsm_cli/main_menus.py

@@ -0,0 +1,293 @@
+import click
+import questionary
+from bsm_cli.server import list_servers
+from questionary import Separator
+
+
+async def _world_management_menu(ctx: click.Context, server_name: str):
+    """Displays a sub-menu for world management actions."""
+    world_group = ctx.obj["cli"].get_command(ctx, "world")
+    if not world_group:
+        click.secho("Error: World command group not found.", fg="red")
+        return
+
+    menu_map = {
+        "Install/Replace World": world_group.get_command(ctx, "install"),
+        "Export Current World": world_group.get_command(ctx, "export"),
+        "Reset Current World": world_group.get_command(ctx, "reset"),
+        "Back": None,
+    }
+
+    while True:
+        choice = await questionary.select(
+            f"World Management for '{server_name}':",
+            choices=list(menu_map.keys()),
+            use_indicator=True,
+        ).ask_async()
+
+        if choice is None or choice == "Back":
+            return
+        command = menu_map.get(choice)
+        if command:
+            await ctx.invoke(command, server_name=server_name)
+            break
+
+
+async def _backup_restore_menu(ctx: click.Context, server_name: str):
+    """Displays a sub-menu for backup and restore actions."""
+    backup_group = ctx.obj["cli"].get_command(ctx, "backup")
+    if not backup_group:
+        click.secho("Error: Backup command group not found.", fg="red")
+        return
+
+    menu_map = {
+        "Create Backup": backup_group.get_command(ctx, "create"),
+        "Restore from Backup": backup_group.get_command(ctx, "restore"),
+        "Prune Old Backups": backup_group.get_command(ctx, "prune"),
+        "Back": None,
+    }
+
+    while True:
+        choice = await questionary.select(
+            f"Backup/Restore for '{server_name}':",
+            choices=list(menu_map.keys()),
+            use_indicator=True,
+        ).ask_async()
+
+        if choice is None or choice == "Back":
+            return
+        command = menu_map.get(choice)
+        if command:
+            await ctx.invoke(command, server_name=server_name)
+            break
+
+
+async def _bans_menu(ctx: click.Context, server_name: str):
+    """Displays a sub-menu for ban management actions."""
+    bans_group = ctx.obj["cli"].get_command(ctx, "bans")
+    if not bans_group:
+        click.secho("Error: Bans command group not found.", fg="red")
+        return
+
+    menu_map = {
+        "List Bans": bans_group.get_command(ctx, "list"),
+        "Add Ban": bans_group.get_command(ctx, "add"),
+        "Remove Ban": bans_group.get_command(ctx, "remove"),
+        "Back": None,
+    }
+
+    while True:
+        choice = await questionary.select(
+            f"Bans for '{server_name}':",
+            choices=list(menu_map.keys()),
+            use_indicator=True,
+        ).ask_async()
+
+        if choice is None or choice == "Back":
+            return
+        command = menu_map.get(choice)
+        if command:
+            await ctx.invoke(command, server_name=server_name)
+            break
+
+
+async def main_menu(ctx: click.Context):  # noqa: C901
+    """Displays the main application menu and drives interactive mode."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho(
+            "You are not logged in. Please run `bsm-cli auth login` first.", fg="red"
+        )
+        return
+
+    cli = ctx.obj["cli"]
+
+    while True:
+        try:
+            click.clear()
+            click.secho("BSM API Client - Main Menu", fg="magenta", bold=True)
+
+            await ctx.invoke(list_servers)
+
+            # --- Dynamically build menu choices ---
+            response = await client.async_get_servers()
+            server_names = (
+                [s.name for s in response.servers] if response.servers else []
+            )
+
+            from questionary import Choice
+
+            menu_choices: list[Choice | Separator | str] = ["Install New Server"]
+            if server_names:
+                menu_choices.append("Manage Existing Server")
+
+            menu_choices.append("Manage Plugins")
+            menu_choices.append("Manage Users")
+            menu_choices.append(Separator("--- Application ---"))
+            menu_choices.append("Exit")
+
+            choice = await questionary.select(
+                "\nChoose an action:",
+                choices=menu_choices,  # type: ignore
+                use_indicator=True,
+            ).ask_async()
+
+            if choice is None or choice == "Exit":
+                return
+
+            if choice == "Install New Server":
+                server_group = cli.get_command(ctx, "server")
+                install_cmd = server_group.get_command(ctx, "install")
+                await ctx.invoke(install_cmd)
+                click.pause("Press any key to return to the main menu...")
+
+            elif choice == "Manage Existing Server":
+                server_name = await questionary.select(
+                    "Select a server:", choices=server_names
+                ).ask_async()
+                if server_name:
+                    await manage_server_menu(ctx, server_name)
+
+            elif choice == "Manage Plugins":
+                plugin_group = cli.get_command(ctx, "plugin")
+                await ctx.invoke(plugin_group)
+                click.pause("Press any key to return to the main menu...")
+
+            elif choice == "Manage Users":
+                users_group = cli.get_command(ctx, "users")
+                await ctx.invoke(users_group)
+                click.pause("Press any key to return to the main menu...")
+
+        except (click.Abort, KeyboardInterrupt):
+            click.echo("\nAction cancelled. Returning to the main menu.")
+            click.pause()
+        except Exception as e:
+            click.secho(f"\nAn unexpected error occurred: {e}", fg="red")
+            click.pause("Press any key to return to the main menu...")
+
+
+async def manage_server_menu(ctx: click.Context, server_name: str):  # noqa: C901
+    """Displays the menu for managing a specific, existing server."""
+    cli = ctx.obj["cli"]
+
+    def get_cmd(group_name, cmd_name):
+        """Helper to safely retrieve a command object from the CLI."""
+        group = cli.get_command(ctx, group_name)
+        return group.get_command(ctx, cmd_name) if group else None
+
+    from typing import Any, Dict, Optional, Tuple
+
+    import click
+
+    # ---- Define static menu sections ----
+    control_map: Dict[str, Tuple[Optional[click.Command], Dict[str, Any]]] = {
+        "Start Server": (get_cmd("server", "start"), {}),
+        "Stop Server": (get_cmd("server", "stop"), {}),
+        "Restart Server": (get_cmd("server", "restart"), {}),
+        "Send Command to Server": (get_cmd("server", "send-command"), {}),
+    }
+    management_map = {
+        "Backup or Restore": _backup_restore_menu,
+        "Manage World": _world_management_menu,
+        "Install Addon": (get_cmd("addon", "install"), {}),
+        "Manage Addons": (get_cmd("addon", "manage"), {}),
+    }
+    config_map: Dict[str, Any] = {
+        "Configure Properties": (get_cmd("properties", "set"), {}),
+        "Configure Allowlist": (get_cmd("allowlist", "add"), {}),
+        "Configure Permissions": (get_cmd("permissions", "set"), {}),
+        "Configure Ban List": _bans_menu,
+    }
+    maintenance_map: Dict[str, Tuple[Optional[click.Command], Dict[str, Any]]] = {
+        "Update Server": (get_cmd("server", "update"), {}),
+        "Delete Server": (get_cmd("server", "delete"), {}),
+    }
+    system_map: Dict[str, Tuple[Optional[click.Command], Dict[str, Any]]] = {
+        "Configure Settings": (get_cmd("system", "settings"), {}),
+        "Monitor Resource Usage": (get_cmd("system", "monitor"), {}),
+    }
+
+    # ---- Combine all maps for easy lookup ----
+    full_menu_map = {
+        **control_map,
+        **management_map,
+        **config_map,
+        **system_map,
+        **maintenance_map,
+        "Back to Main Menu": "back",
+    }
+
+    # ---- Build the final choices list for questionary ----
+    menu_choices = [
+        Separator("--- Server Control ---"),
+        *control_map.keys(),
+        Separator("--- Management ---"),
+        *management_map.keys(),
+        Separator("--- Configuration ---"),
+        *config_map.keys(),
+    ]
+
+    if system_map:
+        menu_choices.extend(
+            [Separator("--- System & Monitoring ---"), *system_map.keys()]
+        )
+
+    menu_choices.extend(
+        [
+            Separator("--- Maintenance ---"),
+            *maintenance_map.keys(),
+            Separator("--------------------"),
+            "Back to Main Menu",
+        ]
+    )
+
+    while True:
+        click.clear()
+        click.secho(f"--- Managing Server: {server_name} ---", fg="magenta", bold=True)
+        await ctx.invoke(list_servers, server_name=server_name)  # type: ignore
+
+        choice = await questionary.select(
+            f"\nSelect an action for '{server_name}':",
+            choices=menu_choices,  # type: ignore
+            use_indicator=True,
+        ).ask_async()
+
+        if choice is None or choice == "Back to Main Menu":
+            return
+
+        action = full_menu_map.get(choice)
+        if not action:
+            continue
+
+        try:
+            if callable(action) and not hasattr(action, "commands"):
+                await action(ctx, server_name)
+            elif isinstance(action, tuple):
+                command_obj, kwargs = action
+                if not command_obj:
+                    continue
+                if hasattr(command_obj, "name") and command_obj.name == "send-command":
+                    cmd_str = await questionary.text(
+                        "Enter command to send:"
+                    ).ask_async()
+                    if cmd_str:
+                        kwargs["command_parts"] = cmd_str.split()
+                    else:
+                        continue
+                kwargs["server_name"] = server_name
+                await ctx.invoke(command_obj, **kwargs)
+                if hasattr(command_obj, "name") and command_obj.name == "delete":
+                    click.echo("\nServer has been deleted. Returning to main menu.")
+                    click.pause()
+                    return
+            elif hasattr(action, "commands"):
+                ctx.invoke(action, server_name=server_name)  # type: ignore
+
+            click.pause("\nPress any key to return to the server menu...")
+
+        except Exception as e:
+            import traceback
+
+            click.secho(f"An error occurred while executing '{choice}': {e}", fg="red")
+            click.secho(traceback.format_exc(), fg="red", dim=True)
+            click.pause()

bsm_cli/permissions.py

@@ -0,0 +1,191 @@
+import click
+import questionary
+
+from bsm_api_client.models import PermissionsSetPayload, PlayerPermissionPayload
+
+
+@click.group()
+def permissions():
+    """Manages player permission levels on a server."""
+    pass
+
+
+@permissions.command("set")
+@click.option(
+    "-s",
+    "--server",
+    "server_name",
+    required=True,
+    help="The name of the target server.",
+)
+@click.option(
+    "-p",
+    "--player",
+    "player_name",
+    help="The gamertag of the player. Skips interactive mode.",
+)
+@click.option(
+    "-l",
+    "--level",
+    type=click.Choice(["visitor", "member", "operator"], case_sensitive=False),
+    help="The permission level to grant. Skips interactive mode.",
+)
+@click.pass_context
+async def set_perm(ctx, server_name: str, player_name: str, level: str):
+    """Sets a permission level for a player on a specific server."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    try:
+        if not player_name or not level:
+            click.secho(
+                f"Player or level not specified; starting interactive editor for '{server_name}'...",
+                fg="yellow",
+            )
+            await interactive_permissions_workflow(client, server_name)
+            return
+
+        click.echo(f"Finding player '{player_name}' in global database...")
+        all_players_resp = await client.async_get_players()
+        player_data = next(
+            (
+                p
+                for p in all_players_resp.players or []
+                if p.get("name", "").lower() == player_name.lower()
+            ),
+            None,
+        )
+
+        if not player_data or not player_data.get("xuid"):
+            click.secho(
+                f"Error: Player '{player_name}' not found in the global player database.",
+                fg="red",
+            )
+            return
+
+        xuid = player_data["xuid"]
+        click.echo(
+            f"Setting permission for {player_name} (XUID: {xuid}) to '{level}'..."
+        )
+
+        payload = PermissionsSetPayload(
+            permissions=[
+                PlayerPermissionPayload(
+                    name=player_name, xuid=xuid, permission_level=level
+                )
+            ]
+        )
+        response = await client.async_set_server_permissions(server_name, payload)
+
+        if response.status == "success":
+            click.secho("Permission updated successfully.", fg="green")
+        else:
+            click.secho(f"Failed to set permission: {response.message}", fg="red")
+
+    except Exception as e:
+        click.secho(f"An error occurred: {e}", fg="red")
+
+
+@permissions.command("list")
+@click.option(
+    "-s", "--server", "server_name", required=True, help="The name of the server."
+)
+@click.pass_context
+async def list_perms(ctx, server_name: str):
+    """Lists all configured player permissions for a specific server."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    response = await client.async_get_server_permissions_data(server_name)
+
+    if response.status == "success":
+        permissions = response.permissions
+        if not permissions:
+            click.secho(
+                f"The permissions file for server '{server_name}' is empty.",
+                fg="yellow",
+            )
+            return
+
+        click.secho(f"\nPermissions for '{server_name}':", bold=True)
+        for p in permissions:
+            level = p.get("permission_level", "unknown").lower()
+            level_color = {"operator": "red", "member": "green", "visitor": "blue"}.get(
+                level, "white"
+            )
+            level_styled = click.style(level.capitalize(), fg=level_color, bold=True)
+
+            name = p.get("name", "Unknown Player")
+            xuid = p.get("xuid", "N/A")
+            click.echo(f"  - {name:<20} (XUID: {xuid:<18}) {level_styled}")
+    else:
+        click.secho(f"Failed to list permissions: {response.message}", fg="red")
+
+
+async def interactive_permissions_workflow(client, server_name: str):
+    """Guides the user through an interactive workflow to set a player's permission level."""
+    click.secho("\n--- Interactive Permission Configuration ---", bold=True)
+
+    while True:
+        player_response = await client.async_get_players()
+        all_players = player_response.players or []
+
+        if not all_players:
+            click.secho(
+                "No players found in the global player database (players.json).",
+                fg="yellow",
+            )
+            return
+
+        player_map = {f"{p['name']} (XUID: {p['xuid']})": p for p in all_players}
+        choices = sorted(list(player_map.keys())) + ["Cancel"]
+
+        player_choice_str = await questionary.select(
+            "Select a player to configure permissions for:", choices=choices
+        ).ask_async()
+
+        if not player_choice_str or player_choice_str == "Cancel":
+            click.secho("Exiting interactive permissions editor.", fg="blue")
+            break
+
+        selected_player = player_map[player_choice_str]
+        permission = await questionary.select(
+            f"Select permission level for {selected_player['name']}:",
+            choices=["member", "operator", "visitor", "Cancel"],
+            default="member",
+        ).ask_async()
+
+        if not permission or permission == "Cancel":
+            click.secho("Operation cancelled.", fg="blue")
+            continue
+
+        payload = PermissionsSetPayload(
+            permissions=[
+                PlayerPermissionPayload(
+                    name=selected_player["name"],
+                    xuid=selected_player["xuid"],
+                    permission_level=permission,
+                )
+            ]
+        )
+        perm_response = await client.async_set_server_permissions(server_name, payload)
+
+        if perm_response.status == "success":
+            click.secho(
+                f"Permission for {selected_player['name']} set to '{permission}'.",
+                fg="green",
+            )
+        else:
+            click.secho(f"Failed to set permission: {perm_response.message}", fg="red")
+
+        if (
+            await questionary.confirm(
+                "Configure another player?", default=True
+            ).ask_async()
+            is False
+        ):
+            break

bsm_cli/player.py

@@ -0,0 +1,59 @@
+import click
+
+
+@click.group()
+def player():
+    """Manages the central player database."""
+    pass
+
+
+@player.command("scan")
+@click.pass_context
+async def scan_for_players(ctx):
+    """Scans all server logs to discover player gamertags and XUIDs."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    try:
+        click.echo("Scanning all server logs for player data...")
+        response = await client.async_scan_players()
+        if response.status == "success":
+            click.secho("Player database updated successfully.", fg="green")
+        else:
+            click.secho(f"Failed to scan for players: {response.message}", fg="red")
+    except Exception as e:
+        click.secho(f"An error occurred during scan: {e}", fg="red")
+
+
+@player.command("add")
+@click.option(
+    "-p",
+    "--player",
+    "players",
+    multiple=True,
+    required=True,
+    help="Player to add in 'Gamertag:XUID' format. Use multiple times for multiple players.",
+)
+@click.pass_context
+async def add_players(ctx, players):
+    """Manually adds or updates player entries in the central player database."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    try:
+        from bsm_api_client.models import AddPlayersPayload
+
+        player_list = list(players)
+        click.echo(f"Adding/updating {len(player_list)} player(s) in the database...")
+        payload = AddPlayersPayload(players=player_list)
+        response = await client.async_add_players(payload)
+        if response.status == "success":
+            click.secho("Players added/updated successfully.", fg="green")
+        else:
+            click.secho(f"Failed to add players: {response.message}", fg="red")
+    except Exception as e:
+        click.secho(f"An error occurred while adding players: {e}", fg="red")