bsm-cli 1.6.0b3__py3-none-any.whl

bsm_cli/plugins.py

@@ -0,0 +1,296 @@
+import json
+
+import click
+import questionary
+
+from bsm_api_client.models import PluginStatusSetPayload, TriggerEventPayload
+
+
+def _print_plugin_table(plugins):
+    """
+    Internal helper to print a formatted table of plugins, their statuses, and versions.
+    """
+    if not plugins:
+        click.secho("No plugins found or configured.", fg="yellow")
+        return
+
+    click.secho("BSM API Client - Plugin Statuses & Versions", fg="magenta", bold=True)
+
+    plugin_names = list(plugins.keys())
+    versions = [config.get("version", "N/A") for config in plugins.values()]
+
+    max_name_len = max(len(name) for name in plugin_names) if plugin_names else 20
+    max_version_len = max(
+        (max(len(v) for v in versions) if versions else 0), len("Version")
+    )
+    max_status_len = len("Disabled")
+
+    header = f"{'Plugin Name':<{max_name_len}} | {'Status':<{max_status_len}} | {'Version':<{max_version_len}}"
+    click.secho(header, underline=True)
+    click.secho("-" * len(header))
+
+    for name, config in sorted(plugins.items()):
+        is_enabled = config.get("enabled", False)
+        version = config.get("version", "N/A")
+
+        status_str = "Enabled" if is_enabled else "Disabled"
+        status_color = "green" if is_enabled else "red"
+
+        click.echo(f"{name:<{max_name_len}} | ", nl=False)
+        click.secho(f"{status_str:<{max_status_len}}", fg=status_color, nl=False)
+        click.echo(f" | {version:<{max_version_len}}")
+
+
+async def interactive_plugin_workflow(client):  # noqa: C901
+    """Guides the user through an interactive session to enable or disable plugins."""
+    try:
+        response = await client.async_get_plugin_statuses()
+        if response.status != "success":
+            click.secho(
+                f"Failed to retrieve plugin statuses: {response.message}", fg="red"
+            )
+            return
+
+        plugins = response.plugins
+        if not plugins:
+            click.secho("No plugins found or configured to edit.", fg="yellow")
+            return
+
+        _print_plugin_table(plugins)
+        click.echo()
+
+        while True:
+            click.clear()
+            click.secho("--- Manage Plugins ---", fg="magenta", bold=True)
+
+            response = await client.async_get_plugin_statuses()
+            if response.status != "success":
+                click.secho(
+                    f"Failed to retrieve plugin statuses: {response.message}", fg="red"
+                )
+                return
+
+            plugins = response.plugins
+            if not plugins:
+                click.secho("No plugins found or configured to edit.", fg="yellow")
+                return
+
+            menu_choices = []
+            for name, config_dict in sorted(plugins.items()):
+                is_enabled = config_dict.get("enabled", False)
+                version = config_dict.get("version", "N/A")
+                status = "🟢" if is_enabled else "⚪"
+                menu_choices.append(
+                    questionary.Choice(
+                        title=f"{status} {name} (v{version})", value=name
+                    )
+                )
+
+            menu_choices.extend(
+                [
+                    questionary.Separator("--- Actions ---"),
+                    questionary.Choice(title="Reload All Plugins", value="RELOAD"),
+                    questionary.Choice(title="Back", value="BACK"),
+                ]
+            )
+
+            choice = await questionary.select(
+                "Select a plugin to manage or an action:", choices=menu_choices
+            ).ask_async()
+
+            if not choice or choice == "BACK":
+                return
+
+            if choice == "RELOAD":
+                click.secho("Reloading plugins...", fg="cyan")
+                try:
+                    reload_response = await client.async_reload_plugins()
+                    if reload_response.status == "success":
+                        click.secho(reload_response.message, fg="green")
+                    else:
+                        click.secho(
+                            f"Failed to reload plugins: {reload_response.message}",
+                            fg="red",
+                        )
+                except Exception as e_reload:
+                    click.secho(f"Error reloading plugins: {e_reload}", fg="red")
+                click.pause()
+                continue
+
+            # Handle specific plugin
+            plugin_name = choice
+            config_dict = plugins.get(plugin_name)
+
+            if not config_dict:
+                continue
+
+            is_enabled = config_dict.get("enabled", False)
+            pack_menu = []
+            if is_enabled:
+                pack_menu.append("Disable")
+            else:
+                pack_menu.append("Enable")
+
+            pack_menu.append("Back")
+
+            action_choice = await questionary.select(
+                f"Actions for {plugin_name}:", choices=pack_menu
+            ).ask_async()
+
+            if not action_choice or action_choice == "Back":
+                continue
+
+            if action_choice == "Enable":
+                payload = PluginStatusSetPayload(enabled=True)
+                res = await client.async_set_plugin_status(plugin_name, payload)
+                if res.status == "success":
+                    click.secho(
+                        f"Plugin '{plugin_name}' enabled successfully.", fg="green"
+                    )
+                else:
+                    click.secho(
+                        f"Failed to enable plugin '{plugin_name}': {res.message}",
+                        fg="red",
+                    )
+            elif action_choice == "Disable":
+                payload = PluginStatusSetPayload(enabled=False)
+                res = await client.async_set_plugin_status(plugin_name, payload)
+                if res.status == "success":
+                    click.secho(
+                        f"Plugin '{plugin_name}' disabled successfully.", fg="green"
+                    )
+                else:
+                    click.secho(
+                        f"Failed to disable plugin '{plugin_name}': {res.message}",
+                        fg="red",
+                    )
+
+            click.pause()
+
+    except Exception as e:
+        click.secho(f"An error occurred during plugin configuration: {e}", fg="red")
+
+
+@click.group(invoke_without_command=True)
+@click.pass_context
+async def plugin(ctx):
+    """Manages plugins."""
+    if ctx.invoked_subcommand is None:
+        client = ctx.obj.get("client")
+        if not client:
+            click.secho("You are not logged in.", fg="red")
+            return
+        await interactive_plugin_workflow(client)
+
+
+@plugin.command("list")
+@click.pass_context
+async def list_plugins(ctx):
+    """Lists all discoverable plugins."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    try:
+        response = await client.async_get_plugin_statuses()
+        if response.status == "success":
+            plugins = response.plugins
+            if not plugins:
+                click.secho("No plugins found.", fg="yellow")
+                return
+
+            _print_plugin_table(plugins)
+        else:
+            click.secho(f"Failed to list plugins: {response.message}", fg="red")
+    except Exception as e:
+        click.secho(f"An error occurred: {e}", fg="red")
+
+
+@plugin.command("enable")
+@click.argument("plugin_name")
+@click.pass_context
+async def enable_plugin(ctx, plugin_name: str):
+    """Enables a plugin."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    try:
+        payload = PluginStatusSetPayload(enabled=True)
+        response = await client.async_set_plugin_status(plugin_name, payload)
+        if response.status == "success":
+            click.secho(f"Plugin '{plugin_name}' enabled successfully.", fg="green")
+        else:
+            click.secho(f"Failed to enable plugin: {response.message}", fg="red")
+    except Exception as e:
+        click.secho(f"An error occurred: {e}", fg="red")
+
+
+@plugin.command("disable")
+@click.argument("plugin_name")
+@click.pass_context
+async def disable_plugin(ctx, plugin_name: str):
+    """Disables a plugin."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    try:
+        payload = PluginStatusSetPayload(enabled=False)
+        response = await client.async_set_plugin_status(plugin_name, payload)
+        if response.status == "success":
+            click.secho(f"Plugin '{plugin_name}' disabled successfully.", fg="green")
+        else:
+            click.secho(f"Failed to disable plugin: {response.message}", fg="red")
+    except Exception as e:
+        click.secho(f"An error occurred: {e}", fg="red")
+
+
+@plugin.command("reload")
+@click.pass_context
+async def reload_plugins(ctx):
+    """Reloads all plugins."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    try:
+        response = await client.async_reload_plugins()
+        if response.status == "success":
+            click.secho("Plugins reloaded successfully.", fg="green")
+        else:
+            click.secho(f"Failed to reload plugins: {response.message}", fg="red")
+    except Exception as e:
+        click.secho(f"An error occurred: {e}", fg="red")
+
+
+@plugin.command("trigger-event")
+@click.argument("event_name")
+@click.option(
+    "--payload-json", help="Optional JSON string to use as the event payload."
+)
+@click.pass_context
+async def trigger_event(ctx, event_name: str, payload_json: str):
+    """Triggers a custom plugin event."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    try:
+        payload = None
+        if payload_json:
+            payload = json.loads(payload_json)
+
+        event_payload = TriggerEventPayload(event_name=event_name, payload=payload)
+        response = await client.async_trigger_plugin_event(event_payload)
+        if response.status == "success":
+            click.secho(f"Event '{event_name}' triggered successfully.", fg="green")
+        else:
+            click.secho(f"Failed to trigger event: {response.message}", fg="red")
+    except Exception as e:
+        click.secho(f"An error occurred: {e}", fg="red")

bsm_cli/properties.py

@@ -0,0 +1,197 @@
+import click
+import questionary
+
+from bsm_api_client.models import PropertiesPayload
+
+
+@click.group()
+def properties():
+    """Manages a server's server.properties file."""
+    pass
+
+
+@properties.command("get")
+@click.option(
+    "-s",
+    "--server",
+    "server_name",
+    required=True,
+    help="The name of the target server.",
+)
+@click.option("-p", "--prop", "property_name", help="Display a single property value.")
+@click.pass_context
+async def get_props(ctx, server_name: str, property_name: str):
+    """Displays server properties from a server's server.properties file."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    response = await client.async_get_server_properties(server_name)
+
+    if response.status == "success":
+        properties = response.properties
+        if property_name:
+            value = properties.get(property_name)
+            if value is not None:
+                click.echo(value)
+            else:
+                click.secho(f"Error: Property '{property_name}' not found.", fg="red")
+        else:
+            click.secho(f"\nProperties for '{server_name}':", bold=True)
+            max_key_len = max(len(k) for k in properties.keys()) if properties else 0
+            for key, value in sorted(properties.items()):
+                click.echo(f"  {key:<{max_key_len}} = {value}")
+    else:
+        click.secho(f"Failed to get properties: {response.message}", fg="red")
+
+
+@properties.command("set")
+@click.option(
+    "-s",
+    "--server",
+    "server_name",
+    required=True,
+    help="The name of the target server.",
+)
+@click.option(
+    "-p",
+    "--prop",
+    "properties",
+    multiple=True,
+    help="A 'key=value' pair to set. Use multiple times for multiple properties.",
+)
+@click.pass_context
+async def set_props(ctx, server_name: str, properties: tuple[str]):
+    """Sets one or more properties in a server's server.properties file."""
+    client = ctx.obj.get("client")
+    if not client:
+        click.secho("You are not logged in.", fg="red")
+        return
+
+    try:
+        if not properties:
+            click.secho(
+                f"No properties specified; starting interactive editor for '{server_name}'...",
+                fg="yellow",
+            )
+            await interactive_properties_workflow(client, server_name)
+            return
+
+        props_to_update = {}
+        for p in properties:
+            if "=" not in p:
+                click.secho(f"Error: Invalid format '{p}'. Use 'key=value'.", fg="red")
+                raise click.Abort()
+            key, value = p.split("=", 1)
+            props_to_update[key.strip()] = value.strip()
+
+        click.echo(
+            f"Updating {len(props_to_update)} propert(y/ies) for '{server_name}'..."
+        )
+
+        payload = PropertiesPayload(properties=props_to_update)
+        response = await client.async_update_server_properties(server_name, payload)
+
+        if response.status == "success":
+            click.secho("Properties updated successfully.", fg="green")
+        else:
+            click.secho(f"Failed to set properties: {response.message}", fg="red")
+
+    except Exception as e:
+        click.secho(f"An error occurred: {e}", fg="red")
+
+
+async def interactive_properties_workflow(client, server_name: str):  # noqa: C901
+    """Guides a user through an interactive session to edit `server.properties`."""
+    click.secho("\n--- Interactive Server Properties Configuration ---", bold=True)
+    click.echo("Loading current server properties...")
+
+    properties_response = await client.async_get_server_properties(server_name)
+    if properties_response.status == "error":
+        click.secho(f"Error: {properties_response.message}", fg="red")
+        raise click.Abort()
+
+    current_properties = (
+        properties_response.properties if properties_response.properties else {}
+    )
+    changes = {}
+
+    async def _prompt(prop: str, message: str, prompter, **kwargs):
+        """A nested helper to abstract the prompting and change-tracking logic."""
+        original_value = current_properties.get(prop)
+
+        if prompter == questionary.confirm:
+            default_bool = str(original_value).lower() == "true"
+            new_val = await prompter(
+                message, default=default_bool, **kwargs
+            ).ask_async()
+            if new_val is None:
+                return
+            if new_val != default_bool:
+                changes[prop] = str(new_val).lower()
+        else:
+            new_val = await prompter(
+                message, default=str(original_value), **kwargs
+            ).ask_async()
+            if new_val is None:
+                return
+            if new_val != original_value:
+                changes[prop] = new_val
+
+    await _prompt("server-name", "Server name (visible in LAN list):", questionary.text)
+    await _prompt("level-name", "World folder name:", questionary.text)
+    await _prompt(
+        "gamemode",
+        "Default gamemode:",
+        questionary.select,
+        choices=["survival", "creative", "adventure"],
+    )
+    await _prompt(
+        "difficulty",
+        "Game difficulty:",
+        questionary.select,
+        choices=["peaceful", "easy", "normal", "hard"],
+    )
+    await _prompt("allow-cheats", "Allow cheats:", questionary.confirm)
+    await _prompt("max-players", "Maximum players:", questionary.text)
+    await _prompt(
+        "online-mode", "Require Xbox Live authentication:", questionary.confirm
+    )
+    await _prompt("allow-list", "Enable allowlist:", questionary.confirm)
+    await _prompt(
+        "default-player-permission-level",
+        "Default permission for new players:",
+        questionary.select,
+        choices=["visitor", "member", "operator"],
+    )
+    await _prompt("view-distance", "View distance (chunks):", questionary.text)
+    await _prompt(
+        "tick-distance", "Tick simulation distance (chunks):", questionary.text
+    )
+    await _prompt(
+        "level-seed", "Level seed (leave blank for random):", questionary.text
+    )
+    await _prompt("texturepack-required", "Require texture packs:", questionary.confirm)
+
+    if not changes:
+        click.secho("\nNo properties were changed.", fg="cyan")
+        return
+
+    click.secho("\nApplying the following changes:", bold=True)
+    for key, value in changes.items():
+        original = current_properties.get(key, "not set")
+        click.echo(
+            f"  - {key}: {click.style(original, fg='red')} -> {click.style(value, fg='green')}"
+        )
+
+    if not await questionary.confirm("Save these changes?", default=True).ask_async():
+        raise click.Abort()
+
+    payload = PropertiesPayload(properties=changes)
+    update_response = await client.async_update_server_properties(server_name, payload)
+
+    if update_response.status == "success":
+        click.secho("Server properties updated successfully.", fg="green")
+    else:
+        click.secho(f"Failed to update properties: {update_response.message}", fg="red")