eeroctl 1.7.1__py3-none-any.whl

eeroctl/commands/network/security.py

@@ -0,0 +1,162 @@
+"""Security commands for the Eero CLI.
+
+Commands:
+- eero network security show: Show security settings
+- eero network security wpa3: WPA3 encryption
+- eero network security band-steering: Band steering
+- eero network security upnp: UPnP
+- eero network security ipv6: IPv6
+- eero network security thread: Thread protocol
+"""
+
+import asyncio
+import sys
+
+import click
+from eero import EeroClient
+from rich.table import Table
+
+from ...context import get_cli_context
+from ...exit_codes import ExitCode
+from ...safety import OperationRisk, SafetyError, confirm_or_fail
+from ...utils import run_with_client
+
+
+@click.group(name="security")
+@click.pass_context
+def security_group(ctx: click.Context) -> None:
+    """Manage security settings.
+
+    \b
+    Commands:
+      show           - Show security settings
+      wpa3           - WPA3 encryption
+      band-steering  - Band steering
+      upnp           - UPnP
+      ipv6           - IPv6
+      thread         - Thread protocol
+
+    \b
+    Examples:
+      eero network security show
+      eero network security wpa3 enable
+      eero network security upnp disable
+    """
+    pass
+
+
+@security_group.command(name="show")
+@click.pass_context
+def security_show(ctx: click.Context) -> None:
+    """Show security settings."""
+    cli_ctx = get_cli_context(ctx)
+    console = cli_ctx.console
+    renderer = cli_ctx.renderer
+
+    async def run_cmd() -> None:
+        async def get_security(client: EeroClient) -> None:
+            with cli_ctx.status("Getting security settings..."):
+                sec_data = await client.get_security_settings(cli_ctx.network_id)
+
+            if cli_ctx.is_json_output():
+                renderer.render_json(sec_data, "eero.network.security.show/v1")
+            else:
+                table = Table(title="Security Settings")
+                table.add_column("Setting", style="cyan")
+                table.add_column("Status", justify="center")
+
+                settings = [
+                    ("WPA3", sec_data.get("wpa3", False)),
+                    ("Band Steering", sec_data.get("band_steering", True)),
+                    ("UPnP", sec_data.get("upnp", True)),
+                    ("IPv6", sec_data.get("ipv6_upstream", False)),
+                    ("Thread", sec_data.get("thread", False)),
+                ]
+
+                for name, enabled in settings:
+                    status = "[green]Enabled[/green]" if enabled else "[dim]Disabled[/dim]"
+                    table.add_row(name, status)
+
+                console.print(table)
+
+        await run_with_client(get_security)
+
+    asyncio.run(run_cmd())
+
+
+# Security toggle commands factory
+def _make_security_toggle(setting_name: str, api_method: str, display_name: str):
+    """Factory for security toggle command groups."""
+
+    @click.group(name=setting_name)
+    @click.pass_context
+    def toggle_group(ctx: click.Context) -> None:
+        pass
+
+    @toggle_group.command(name="enable")
+    @click.option("--force", "-f", is_flag=True, help="Skip confirmation")
+    @click.pass_context
+    def enable_cmd(ctx: click.Context, force: bool) -> None:
+        _set_security_setting(ctx, api_method, display_name, True, force)
+
+    @toggle_group.command(name="disable")
+    @click.option("--force", "-f", is_flag=True, help="Skip confirmation")
+    @click.pass_context
+    def disable_cmd(ctx: click.Context, force: bool) -> None:
+        _set_security_setting(ctx, api_method, display_name, False, force)
+
+    enable_cmd.__doc__ = f"Enable {display_name}."
+    disable_cmd.__doc__ = f"Disable {display_name}."
+    toggle_group.__doc__ = f"Manage {display_name}."
+
+    return toggle_group
+
+
+def _set_security_setting(ctx, api_method: str, display_name: str, enable: bool, force: bool):
+    """Set a security setting."""
+    cli_ctx = get_cli_context(ctx)
+    console = cli_ctx.console
+    action = "enable" if enable else "disable"
+
+    try:
+        confirm_or_fail(
+            action=f"{action} {display_name}",
+            target="network",
+            risk=OperationRisk.MEDIUM,
+            force=force or cli_ctx.force,
+            non_interactive=cli_ctx.non_interactive,
+            dry_run=cli_ctx.dry_run,
+        )
+    except SafetyError as e:
+        cli_ctx.renderer.render_error(e.message)
+        sys.exit(e.exit_code)
+
+    async def run_cmd() -> None:
+        async def set_setting(client: EeroClient) -> None:
+            method = getattr(client, api_method)
+            with cli_ctx.status(f"{action.capitalize()}ing {display_name}..."):
+                result = await method(enable, cli_ctx.network_id)
+
+            if result:
+                console.print(f"[bold green]{display_name} {action}d[/bold green]")
+            else:
+                console.print(f"[red]Failed to {action} {display_name}[/red]")
+                sys.exit(ExitCode.GENERIC_ERROR)
+
+        await run_with_client(set_setting)
+
+    asyncio.run(run_cmd())
+
+
+# Create and register security toggle commands
+wpa3_group = _make_security_toggle("wpa3", "set_wpa3", "WPA3")
+band_steering_group = _make_security_toggle("band-steering", "set_band_steering", "band steering")
+upnp_group = _make_security_toggle("upnp", "set_upnp", "UPnP")
+ipv6_group = _make_security_toggle("ipv6", "set_ipv6", "IPv6")
+thread_group = _make_security_toggle("thread", "set_thread_enabled", "Thread")
+
+security_group.add_command(wpa3_group)
+security_group.add_command(band_steering_group)
+security_group.add_command(upnp_group)
+security_group.add_command(ipv6_group)
+security_group.add_command(thread_group)

eeroctl/commands/network/speedtest.py

@@ -0,0 +1,99 @@
+"""Speed test commands for the Eero CLI.
+
+Commands:
+- eero network speedtest run: Run a new speed test
+- eero network speedtest show: Show last speed test results
+"""
+
+import asyncio
+
+import click
+from eero import EeroClient
+from rich.panel import Panel
+
+from ...context import get_cli_context
+from ...utils import run_with_client
+
+
+@click.group(name="speedtest")
+@click.pass_context
+def speedtest_group(ctx: click.Context) -> None:
+    """Run and view speed tests.
+
+    \b
+    Commands:
+      run   - Run a new speed test
+      show  - Show last speed test results
+    """
+    pass
+
+
+@speedtest_group.command(name="run")
+@click.pass_context
+def speedtest_run(ctx: click.Context) -> None:
+    """Run a new speed test."""
+    cli_ctx = get_cli_context(ctx)
+    console = cli_ctx.console
+    renderer = cli_ctx.renderer
+
+    async def run_cmd() -> None:
+        async def run_test(client: EeroClient) -> None:
+            with cli_ctx.status("Running speed test (this may take a minute)..."):
+                result = await client.run_speed_test(cli_ctx.network_id)
+
+            if cli_ctx.is_json_output():
+                renderer.render_json(result, "eero.network.speedtest.run/v1")
+            else:
+                download = result.get("down", {}).get("value", 0)
+                upload = result.get("up", {}).get("value", 0)
+                latency = result.get("latency", {}).get("value", 0)
+
+                content = (
+                    f"[bold]Download:[/bold] {download} Mbps\n"
+                    f"[bold]Upload:[/bold] {upload} Mbps\n"
+                    f"[bold]Latency:[/bold] {latency} ms"
+                )
+                console.print(Panel(content, title="Speed Test Results", border_style="green"))
+
+        await run_with_client(run_test)
+
+    asyncio.run(run_cmd())
+
+
+@speedtest_group.command(name="show")
+@click.pass_context
+def speedtest_show(ctx: click.Context) -> None:
+    """Show last speed test results."""
+    cli_ctx = get_cli_context(ctx)
+    console = cli_ctx.console
+    renderer = cli_ctx.renderer
+
+    async def run_cmd() -> None:
+        async def get_results(client: EeroClient) -> None:
+            with cli_ctx.status("Getting speed test results..."):
+                network = await client.get_network(cli_ctx.network_id)
+
+            speed_test = network.speed_test
+            if not speed_test:
+                console.print("[yellow]No speed test results available[/yellow]")
+                return
+
+            if cli_ctx.is_json_output():
+                renderer.render_json(speed_test, "eero.network.speedtest.show/v1")
+            else:
+                download = speed_test.get("down", {}).get("value", 0)
+                upload = speed_test.get("up", {}).get("value", 0)
+                latency = speed_test.get("latency", {}).get("value", 0)
+                tested = speed_test.get("date", "Unknown")
+
+                content = (
+                    f"[bold]Download:[/bold] {download} Mbps\n"
+                    f"[bold]Upload:[/bold] {upload} Mbps\n"
+                    f"[bold]Latency:[/bold] {latency} ms\n"
+                    f"[bold]Tested:[/bold] {tested}"
+                )
+                console.print(Panel(content, title="Speed Test Results", border_style="blue"))
+
+        await run_with_client(get_results)
+
+    asyncio.run(run_cmd())

eeroctl/commands/network/sqm.py

@@ -0,0 +1,194 @@
+"""SQM (Smart Queue Management) commands for the Eero CLI.
+
+Commands:
+- eero network sqm show: Show SQM settings
+- eero network sqm enable: Enable SQM
+- eero network sqm disable: Disable SQM
+- eero network sqm set: Configure bandwidth limits
+"""
+
+import asyncio
+import sys
+from typing import Optional
+
+import click
+from eero import EeroClient
+from rich.panel import Panel
+
+from ...context import EeroCliContext, get_cli_context
+from ...exit_codes import ExitCode
+from ...safety import OperationRisk, SafetyError, confirm_or_fail
+from ...utils import run_with_client
+
+
+@click.group(name="sqm")
+@click.pass_context
+def sqm_group(ctx: click.Context) -> None:
+    """Manage Smart Queue Management (SQM) / QoS settings.
+
+    \b
+    Commands:
+      show    - Show SQM settings
+      enable  - Enable SQM
+      disable - Disable SQM
+      set     - Configure bandwidth limits
+
+    \b
+    Examples:
+      eero network sqm show
+      eero network sqm enable
+      eero network sqm set --upload 50 --download 200
+    """
+    pass
+
+
+@sqm_group.command(name="show")
+@click.pass_context
+def sqm_show(ctx: click.Context) -> None:
+    """Show SQM settings."""
+    cli_ctx = get_cli_context(ctx)
+    console = cli_ctx.console
+    renderer = cli_ctx.renderer
+
+    async def run_cmd() -> None:
+        async def get_sqm(client: EeroClient) -> None:
+            with cli_ctx.status("Getting SQM settings..."):
+                sqm_data = await client.get_sqm_settings(cli_ctx.network_id)
+
+            if cli_ctx.is_json_output():
+                renderer.render_json(sqm_data, "eero.network.sqm.show/v1")
+            else:
+                enabled = sqm_data.get("enabled", False)
+                upload_bw = sqm_data.get("upload_bandwidth")
+                download_bw = sqm_data.get("download_bandwidth")
+
+                content = (
+                    f"[bold]Enabled:[/bold] {'[green]Yes[/green]' if enabled else '[dim]No[/dim]'}"
+                )
+                if upload_bw:
+                    content += f"\n[bold]Upload:[/bold] {upload_bw} Mbps"
+                if download_bw:
+                    content += f"\n[bold]Download:[/bold] {download_bw} Mbps"
+
+                console.print(Panel(content, title="SQM Settings", border_style="blue"))
+
+        await run_with_client(get_sqm)
+
+    asyncio.run(run_cmd())
+
+
+@sqm_group.command(name="enable")
+@click.option("--force", "-f", is_flag=True, help="Skip confirmation")
+@click.pass_context
+def sqm_enable(ctx: click.Context, force: bool) -> None:
+    """Enable SQM."""
+    cli_ctx = get_cli_context(ctx)
+    _set_sqm_enabled(cli_ctx, True, force)
+
+
+@sqm_group.command(name="disable")
+@click.option("--force", "-f", is_flag=True, help="Skip confirmation")
+@click.pass_context
+def sqm_disable(ctx: click.Context, force: bool) -> None:
+    """Disable SQM."""
+    cli_ctx = get_cli_context(ctx)
+    _set_sqm_enabled(cli_ctx, False, force)
+
+
+def _set_sqm_enabled(cli_ctx: EeroCliContext, enable: bool, force: bool) -> None:
+    """Enable or disable SQM."""
+    console = cli_ctx.console
+    action = "enable" if enable else "disable"
+
+    try:
+        confirm_or_fail(
+            action=f"{action} SQM",
+            target="network",
+            risk=OperationRisk.MEDIUM,
+            force=force or cli_ctx.force,
+            non_interactive=cli_ctx.non_interactive,
+            dry_run=cli_ctx.dry_run,
+        )
+    except SafetyError as e:
+        cli_ctx.renderer.render_error(e.message)
+        sys.exit(e.exit_code)
+
+    async def run_cmd() -> None:
+        async def set_sqm(client: EeroClient) -> None:
+            with cli_ctx.status(f"{action.capitalize()}ing SQM..."):
+                result = await client.set_sqm_enabled(enable, cli_ctx.network_id)
+
+            if result:
+                console.print(f"[bold green]SQM {action}d[/bold green]")
+            else:
+                console.print(f"[red]Failed to {action} SQM[/red]")
+                sys.exit(ExitCode.GENERIC_ERROR)
+
+        await run_with_client(set_sqm)
+
+    asyncio.run(run_cmd())
+
+
+@sqm_group.command(name="set")
+@click.option("--upload", "-u", type=int, help="Upload bandwidth limit (Mbps)")
+@click.option("--download", "-d", type=int, help="Download bandwidth limit (Mbps)")
+@click.option("--force", "-f", is_flag=True, help="Skip confirmation")
+@click.pass_context
+def sqm_set(
+    ctx: click.Context, upload: Optional[int], download: Optional[int], force: bool
+) -> None:
+    """Configure SQM bandwidth limits.
+
+    \b
+    Options:
+      --upload, -u    Upload bandwidth in Mbps
+      --download, -d  Download bandwidth in Mbps
+
+    \b
+    Examples:
+      eero network sqm set --upload 50 --download 200
+    """
+    cli_ctx = get_cli_context(ctx)
+    console = cli_ctx.console
+
+    if upload is None and download is None:
+        console.print("[yellow]Specify --upload and/or --download[/yellow]")
+        sys.exit(ExitCode.USAGE_ERROR)
+
+    try:
+        confirm_or_fail(
+            action="configure SQM",
+            target=f"upload={upload}Mbps download={download}Mbps",
+            risk=OperationRisk.MEDIUM,
+            force=force or cli_ctx.force,
+            non_interactive=cli_ctx.non_interactive,
+            dry_run=cli_ctx.dry_run,
+        )
+    except SafetyError as e:
+        cli_ctx.renderer.render_error(e.message)
+        sys.exit(e.exit_code)
+
+    async def run_cmd() -> None:
+        async def configure_sqm(client: EeroClient) -> None:
+            with cli_ctx.status("Configuring SQM..."):
+                result = await client.configure_sqm(
+                    enabled=True,
+                    upload_mbps=upload,
+                    download_mbps=download,
+                    network_id=cli_ctx.network_id,
+                )
+
+            if result:
+                msg_parts = []
+                if upload:
+                    msg_parts.append(f"Upload={upload}Mbps")
+                if download:
+                    msg_parts.append(f"Download={download}Mbps")
+                console.print(f"[bold green]SQM configured: {' '.join(msg_parts)}[/bold green]")
+            else:
+                console.print("[red]Failed to configure SQM[/red]")
+                sys.exit(ExitCode.GENERIC_ERROR)
+
+        await run_with_client(configure_sqm)
+
+    asyncio.run(run_cmd())