bsm-cli 1.6.0b3__py3-none-any.whl

bsm_cli/bans.py

@@ -0,0 +1,190 @@
+import click
+import questionary
+
+from bsm_api_client.models import BanAddRequest, BanRemoveRequest
+
+
+@click.group()
+def bans():
+    """Manages the server ban list."""
+    pass
+
+
+@bans.command("list")
+@click.option(
+    "-s",
+    "--server",
+    "server_name",
+    required=True,
+    help="Name of the server.",
+)
+@click.pass_context
+async def list_bans(ctx, server_name: str):
+    """Lists all players on the server's ban list."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    click.echo(f"Fetching ban list for server '{server_name}'...")
+    response = await client.async_get_server_bans(server_name)
+
+    if response.get("status") == "success":
+        bans_list = response.get("bans", [])
+        if not bans_list:
+            click.secho("The ban list is empty.", fg="green")
+        else:
+            click.secho(f"\n--- Ban List for '{server_name}' ---", bold=True)
+            for entry in bans_list:
+                click.echo(
+                    f"- {click.style(entry.get('player_name', 'Unknown'), fg='cyan')} (XUID: {entry.get('xuid')}) - Reason: {entry.get('reason', 'N/A')}"
+                )
+    else:
+        click.secho(
+            f"Failed to fetch ban list: {response.get('message', 'Unknown Error')}",
+            fg="red",
+        )
+
+
+@bans.command("add")
+@click.option(
+    "-s",
+    "--server",
+    "server_name",
+    required=True,
+    help="Name of the server.",
+)
+@click.pass_context
+async def add_ban(ctx, server_name: str):
+    """Adds a player to the server ban list interactively."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    await interactive_ban_workflow(client, server_name)
+
+
+@bans.command("remove")
+@click.option(
+    "-s",
+    "--server",
+    "server_name",
+    required=True,
+    help="Name of the server.",
+)
+@click.pass_context
+async def remove_ban(ctx, server_name: str):
+    """Removes a player from the server ban list interactively."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    response = await client.async_get_server_bans(server_name)
+    if response.get("status") != "success":
+        click.secho(
+            f"Failed to fetch ban list: {response.get('message', 'Unknown Error')}",
+            fg="red",
+        )
+        return
+
+    bans_list = response.get("bans", [])
+    if not bans_list:
+        click.secho("The ban list is currently empty.", fg="yellow")
+        return
+
+    choices = [
+        questionary.Choice(
+            title=f"{entry.get('player_name', 'Unknown')} ({entry.get('xuid')})",
+            value=entry.get("xuid"),
+        )
+        for entry in bans_list
+    ]
+
+    selected_xuid = await questionary.select(
+        "Select a player to remove from the ban list:", choices=choices
+    ).ask_async()
+
+    if not selected_xuid:
+        return
+
+    confirm = await questionary.confirm(
+        f"Are you sure you want to remove XUID '{selected_xuid}' from the ban list?"
+    ).ask_async()
+    if not confirm:
+        click.secho("Operation cancelled.", fg="yellow")
+        return
+
+    payload = BanRemoveRequest(xuid=selected_xuid)
+
+    click.echo(
+        f"Removing XUID '{selected_xuid}' from the ban list for '{server_name}'..."
+    )
+    rem_response = await client.async_remove_server_ban(server_name, payload)
+
+    if rem_response.get("status") == "success":
+        click.secho("Player successfully removed from the ban list.", fg="green")
+    else:
+        click.secho(
+            f"Failed to remove player from ban list: {rem_response.get('message', 'Unknown Error')}",
+            fg="red",
+        )
+
+
+async def interactive_ban_workflow(client, server_name: str):
+    """Guides the user through an interactive session to view and add players to the ban list."""
+    response = await client.async_get_server_bans(server_name)
+    existing_bans = response.get("bans", [])
+
+    click.secho("\n--- Interactive Ban List Configuration ---", bold=True)
+    if existing_bans:
+        click.echo("Current players in ban list:")
+        for b in existing_bans:
+            click.echo(
+                f"  - {b.get('player_name')} (XUID: {b.get('xuid')}) - Reason: {b.get('reason', 'N/A')}"
+            )
+    else:
+        click.secho("Ban list is currently empty.", fg="yellow")
+
+    click.echo("\nEnter a new player to ban. Leave Gamertag empty to finish.")
+    while True:
+        player_name = await questionary.text("Player gamertag:").ask_async()
+        if not player_name or not player_name.strip():
+            break
+
+        xuid = await questionary.text("Player XUID:").ask_async()
+        if not xuid or not xuid.strip():
+            click.secho("XUID is required to ban a player.", fg="red")
+            continue
+
+        reason = await questionary.text("Reason (optional):").ask_async()
+
+        if any(b.get("xuid") == xuid.strip() for b in existing_bans):
+            click.secho(
+                f"Player with XUID '{xuid}' is already in the list. Skipping.",
+                fg="yellow",
+            )
+            continue
+
+        payload = BanAddRequest(
+            player_name=player_name.strip(),
+            xuid=xuid.strip(),
+            reason=reason.strip() if reason.strip() else None,
+        )
+        res = await client.async_add_server_ban(server_name, payload)
+        if res.get("status") == "success":
+            click.secho(f"Successfully banned {player_name}.", fg="green")
+            existing_bans.append(
+                {
+                    "player_name": player_name.strip(),
+                    "xuid": xuid.strip(),
+                    "reason": reason.strip() if reason.strip() else None,
+                }
+            )
+        else:
+            click.secho(
+                f"Failed to ban player: {res.get('message', 'Unknown Error')}", fg="red"
+            )
+
+    click.secho("Ban list interactive configuration finished.", fg="green")

bsm_cli/config.py

@@ -0,0 +1,89 @@
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+CONFIG_FILE_NAME = ".bsm_cli_config.json"
+DEFAULT_BASE_URL = "http://127.0.0.1:11325"
+
+
+def get_config_path() -> Path:
+    """Gets the path to the configuration file."""
+    return Path.home() / CONFIG_FILE_NAME
+
+
+def load_config() -> Dict[str, Any]:
+    """Loads the configuration from the config file."""
+    config_path = get_config_path()
+    if not config_path.exists():
+        return {}
+    with open(config_path, "r") as f:
+        data = json.load(f)
+        if isinstance(data, dict):
+            return data
+        return {}
+
+
+def save_config(config: Dict[str, Any]):
+    """Saves the configuration to the config file."""
+    config_path = get_config_path()
+    with open(config_path, "w") as f:
+        json.dump(config, f, indent=4)
+
+
+class Config:
+    """Manages CLI configuration."""
+
+    def __init__(self):
+        self._config = load_config()
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Gets a configuration value."""
+        # Prioritize environment variables
+        env_var = f"BSM_{key.upper()}"
+        value = os.environ.get(env_var)
+        if value:
+            if isinstance(default, bool):
+                return value.lower() in ("true", "1", "yes")
+            return value
+
+        # Fallback to config file
+        return self._config.get(key, default)
+
+    def set(self, key: str, value: Any):
+        """Sets a configuration value."""
+        self._config[key] = value
+        save_config(self._config)
+
+    @property
+    def base_url(self) -> str:
+        """The API base URL."""
+        return str(self.get("base_url", DEFAULT_BASE_URL))
+
+    @property
+    def verify_ssl(self) -> bool:
+        """Whether to verify SSL."""
+        return bool(self.get("verify_ssl", True))
+
+    @property
+    def username(self) -> Optional[str]:
+        """The username for authentication."""
+        val = self.get("username")
+        return str(val) if val is not None else None
+
+    @property
+    def password(self) -> Optional[str]:
+        """The password for authentication."""
+        val = self.get("password")
+        return str(val) if val is not None else None
+
+    @property
+    def jwt_token(self) -> Optional[str]:
+        """The JWT for authentication."""
+        val = self.get("jwt_token")
+        return str(val) if val is not None else None
+
+    @jwt_token.setter
+    def jwt_token(self, value: Optional[str]):
+        """Sets the JWT."""
+        self.set("jwt_token", value)

bsm_cli/content.py

@@ -0,0 +1,21 @@
+# src/bsm_cli/content.py
+"""CLI commands for content management."""
+
+import click
+from bsm_cli.decorators import pass_async_context
+
+
+@click.group()
+def content():
+    """Commands for managing content."""
+    pass
+
+
+@content.command()
+@click.argument("file_path", type=click.Path(exists=True, dir_okay=False))
+@pass_async_context
+async def upload(ctx, file_path):
+    """Upload a content file."""
+    client = ctx.obj["client"]
+    response = await client.async_upload_content(file_path)
+    click.echo(response)

bsm_cli/decorators.py

@@ -0,0 +1,138 @@
+import asyncio
+import functools
+
+import click
+
+from bsm_api_client.exceptions import AuthError
+
+
+class AsyncGroup(click.Group):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.async_context_settings = {}
+
+    def context(self, f):
+        self.async_context_settings["context"] = f
+        return f
+
+    def invoke(self, ctx):
+        ctx.obj = ctx.obj or {}
+        if self.async_context_settings.get("context"):
+
+            async def runner():
+                async with self.async_context_settings["context"](ctx):
+                    result = super(AsyncGroup, self).invoke(ctx)
+                    if asyncio.iscoroutine(result):
+                        await result
+
+            return asyncio.run(runner())
+
+        result = super().invoke(ctx)
+        if asyncio.iscoroutine(result):
+            return asyncio.run(result)
+        return result
+
+
+def pass_async_context(f):
+    @functools.wraps(f)
+    def wrapper(*args, **kwargs):
+        ctx = click.get_current_context()
+        return f(ctx, *args, **kwargs)
+
+    return wrapper
+
+
+async def monitor_task(  # noqa: C901
+    client, task_id: str, success_message: str, failure_message: str
+):
+    """Polls the status of a background task until it completes."""
+    click.echo("Task started in the background. Monitoring for completion...")
+
+    # Try WebSocket first
+    try:
+        ws_client = await client.websocket_connect()
+        async with ws_client:
+            # No subscription needed for task updates as per documentation
+            async for msg in ws_client.listen():
+                # Expected format: {"type": "task_update", "topic": "task:{task_id}", "data": {...}}
+                if (
+                    msg.get("topic") == f"task:{task_id}"
+                    and msg.get("type") == "task_update"
+                ):
+                    data = msg.get("data", {})
+                    status = data.get("status")
+                    message = data.get("message", "No message provided.")
+
+                    if status == "success":
+                        click.secho(f"{success_message}: {message}", fg="green")
+                        return
+                    elif status == "error":
+                        click.secho(f"{failure_message}: {message}", fg="red")
+                        return
+                    elif status == "in_progress":
+                        # Maybe print progress if available, or just wait
+                        pass
+    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:
+                async for msg in ws_client.listen():
+                    if (
+                        msg.get("topic") == f"task:{task_id}"
+                        and msg.get("type") == "task_update"
+                    ):
+                        data = msg.get("data", {})
+                        status = data.get("status")
+                        message = data.get("message", "No message provided.")
+
+                        if status == "success":
+                            click.secho(f"{success_message}: {message}", fg="green")
+                            return
+                        elif status == "error":
+                            click.secho(f"{failure_message}: {message}", fg="red")
+                            return
+                        elif status == "in_progress":
+                            pass
+        except Exception as e:
+            click.secho(
+                f"WebSocket retry failed ({e}), falling back to polling...", fg="yellow"
+            )
+    except Exception as e:
+        click.secho(
+            f"WebSocket monitoring failed ({e}), falling back to polling...",
+            fg="yellow",
+        )
+
+    # Fallback to polling
+    while True:
+        try:
+            status_response = await client.async_get_task_status(task_id)
+            status = status_response.get("status")
+            message = status_response.get("message", "No message provided.")
+
+            if status == "success":
+                click.secho(f"{success_message}: {message}", fg="green")
+                break
+            elif status == "error":
+                click.secho(
+                    f"{failure_message}: {message}",
+                    fg="red",
+                )
+                break
+            elif status == "pending" or status == "in_progress":
+                # Still waiting, continue loop
+                pass
+            else:
+                # Handle unexpected status
+                click.secho(f"Unknown task status received: {status}", fg="yellow")
+
+            await asyncio.sleep(2)
+        except Exception as e:
+            click.secho(f"An error occurred while monitoring task: {e}", fg="red")
+            await asyncio.sleep(2)  # Retry polling on error