eeroctl 1.7.1__py3-none-any.whl

eeroctl/commands/network/__init__.py

@@ -0,0 +1,18 @@
+"""Network commands package for the Eero CLI.
+
+This package contains all network-related commands, split into logical submodules:
+- base: Core commands (list, show, use, rename, premium)
+- dns: DNS management commands
+- security: Security settings commands
+- sqm: SQM/QoS commands
+- guest: Guest network commands
+- backup: Backup network commands (Eero Plus)
+- speedtest: Speed test commands
+- forwards: Port forwarding commands
+- dhcp: DHCP management commands
+- advanced: Routing, Thread, Support commands
+"""
+
+from .base import network_group
+
+__all__ = ["network_group"]

eeroctl/commands/network/advanced.py

@@ -0,0 +1,191 @@
+"""Advanced network commands for the Eero CLI.
+
+Commands:
+- eero network routing: Show routing information
+- eero network thread: Thread protocol settings
+- eero network support: Support and diagnostics
+"""
+
+import asyncio
+import json
+import sys
+
+import click
+from eero import EeroClient
+from rich.panel import Panel
+
+from ...context import get_cli_context
+from ...safety import OperationRisk, SafetyError, confirm_or_fail
+from ...utils import run_with_client
+
+# ==================== Routing Subcommand ====================
+
+
+@click.command(name="routing")
+@click.pass_context
+def routing_show(ctx: click.Context) -> None:
+    """Show routing information."""
+    cli_ctx = get_cli_context(ctx)
+    console = cli_ctx.console
+    renderer = cli_ctx.renderer
+
+    async def run_cmd() -> None:
+        async def get_routing(client: EeroClient) -> None:
+            with cli_ctx.status("Getting routing information..."):
+                routing = await client.get_routing(cli_ctx.network_id)
+
+            if cli_ctx.is_json_output():
+                renderer.render_json(routing, "eero.network.routing.show/v1")
+            else:
+                console.print(
+                    Panel(
+                        json.dumps(routing, indent=2),
+                        title="Routing Information",
+                        border_style="blue",
+                    )
+                )
+
+        await run_with_client(get_routing)
+
+    asyncio.run(run_cmd())
+
+
+# ==================== Thread Subcommand Group ====================
+
+
+@click.group(name="thread")
+@click.pass_context
+def thread_cmd_group(ctx: click.Context) -> None:
+    """Manage Thread protocol settings.
+
+    Thread is used for smart home devices. Enable/disable
+    is under security settings.
+    """
+    pass
+
+
+@thread_cmd_group.command(name="show")
+@click.pass_context
+def thread_show(ctx: click.Context) -> None:
+    """Show Thread protocol information."""
+    cli_ctx = get_cli_context(ctx)
+    console = cli_ctx.console
+    renderer = cli_ctx.renderer
+
+    async def run_cmd() -> None:
+        async def get_thread(client: EeroClient) -> None:
+            with cli_ctx.status("Getting Thread information..."):
+                thread_data = await client.get_thread(cli_ctx.network_id)
+
+            if cli_ctx.is_json_output():
+                renderer.render_json(thread_data, "eero.network.thread.show/v1")
+            else:
+                console.print(
+                    Panel(
+                        json.dumps(thread_data, indent=2),
+                        title="Thread Protocol",
+                        border_style="blue",
+                    )
+                )
+
+        await run_with_client(get_thread)
+
+    asyncio.run(run_cmd())
+
+
+# ==================== Support Subcommand Group ====================
+
+
+@click.group(name="support")
+@click.pass_context
+def support_group(ctx: click.Context) -> None:
+    """Support and diagnostics.
+
+    \b
+    Commands:
+      show   - Show support information
+      bundle - Export support bundle
+    """
+    pass
+
+
+@support_group.command(name="show")
+@click.pass_context
+def support_show(ctx: click.Context) -> None:
+    """Show support information."""
+    cli_ctx = get_cli_context(ctx)
+    console = cli_ctx.console
+    renderer = cli_ctx.renderer
+
+    async def run_cmd() -> None:
+        async def get_support(client: EeroClient) -> None:
+            with cli_ctx.status("Getting support information..."):
+                support_data = await client.get_support(cli_ctx.network_id)
+
+            if cli_ctx.is_json_output():
+                renderer.render_json(support_data, "eero.network.support.show/v1")
+            else:
+                console.print(
+                    Panel(
+                        json.dumps(support_data, indent=2),
+                        title="Support Information",
+                        border_style="blue",
+                    )
+                )
+
+        await run_with_client(get_support)
+
+    asyncio.run(run_cmd())
+
+
+@support_group.group(name="bundle")
+@click.pass_context
+def bundle_group(ctx: click.Context) -> None:
+    """Manage support bundles."""
+    pass
+
+
+@bundle_group.command(name="export")
+@click.option("--out", "-o", required=True, help="Output file path")
+@click.option("--force", "-f", is_flag=True, help="Skip confirmation")
+@click.pass_context
+def bundle_export(ctx: click.Context, out: str, force: bool) -> None:
+    """Export support bundle to file.
+
+    Creates a diagnostic bundle for Eero support.
+    """
+    cli_ctx = get_cli_context(ctx)
+    console = cli_ctx.console
+
+    try:
+        confirm_or_fail(
+            action="export support bundle",
+            target=f"to {out}",
+            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 export_bundle(client: EeroClient) -> None:
+            with cli_ctx.status("Generating support bundle..."):
+                support_data = await client.get_support(cli_ctx.network_id)
+                diagnostics = await client.get_diagnostics(cli_ctx.network_id)
+
+            bundle = {
+                "support": support_data,
+                "diagnostics": diagnostics,
+            }
+
+            with open(out, "w") as f:
+                json.dump(bundle, f, indent=2, default=str)
+
+            console.print(f"[bold green]Support bundle exported to {out}[/bold green]")
+
+        await run_with_client(export_bundle)
+
+    asyncio.run(run_cmd())

eeroctl/commands/network/backup.py

@@ -0,0 +1,162 @@
+"""Backup network commands for the Eero CLI (Eero Plus feature).
+
+Commands:
+- eero network backup show: Show backup network settings
+- eero network backup enable: Enable backup network
+- eero network backup disable: Disable backup network
+- eero network backup status: Show current backup status
+"""
+
+import asyncio
+import sys
+
+import click
+from eero import EeroClient
+from rich.panel import Panel
+
+from ...context import EeroCliContext, get_cli_context
+from ...errors import is_premium_error
+from ...exit_codes import ExitCode
+from ...safety import OperationRisk, SafetyError, confirm_or_fail
+from ...utils import run_with_client
+
+
+@click.group(name="backup")
+@click.pass_context
+def backup_group(ctx: click.Context) -> None:
+    """Manage backup network (Eero Plus feature).
+
+    \b
+    Commands:
+      show    - Show backup network settings
+      enable  - Enable backup network
+      disable - Disable backup network
+      status  - Show current backup status
+    """
+    pass
+
+
+@backup_group.command(name="show")
+@click.pass_context
+def backup_show(ctx: click.Context) -> None:
+    """Show backup network configuration."""
+    cli_ctx = get_cli_context(ctx)
+    console = cli_ctx.console
+    renderer = cli_ctx.renderer
+
+    async def run_cmd() -> None:
+        async def get_backup(client: EeroClient) -> None:
+            with cli_ctx.status("Getting backup network settings..."):
+                try:
+                    backup_data = await client.get_backup_network(cli_ctx.network_id)
+                except Exception as e:
+                    if is_premium_error(e):
+                        console.print("[yellow]Backup network requires Eero Plus[/yellow]")
+                        sys.exit(ExitCode.PREMIUM_REQUIRED)
+                    raise
+
+            if cli_ctx.is_json_output():
+                renderer.render_json(backup_data, "eero.network.backup.show/v1")
+            else:
+                enabled = backup_data.get("enabled", False)
+                content = (
+                    f"[bold]Enabled:[/bold] {'[green]Yes[/green]' if enabled else '[dim]No[/dim]'}"
+                )
+                console.print(Panel(content, title="Backup Network", border_style="blue"))
+
+        await run_with_client(get_backup)
+
+    asyncio.run(run_cmd())
+
+
+@backup_group.command(name="enable")
+@click.option("--force", "-f", is_flag=True, help="Skip confirmation")
+@click.pass_context
+def backup_enable(ctx: click.Context, force: bool) -> None:
+    """Enable backup network."""
+    cli_ctx = get_cli_context(ctx)
+    _set_backup(cli_ctx, True, force)
+
+
+@backup_group.command(name="disable")
+@click.option("--force", "-f", is_flag=True, help="Skip confirmation")
+@click.pass_context
+def backup_disable(ctx: click.Context, force: bool) -> None:
+    """Disable backup network."""
+    cli_ctx = get_cli_context(ctx)
+    _set_backup(cli_ctx, False, force)
+
+
+def _set_backup(cli_ctx: EeroCliContext, enable: bool, force: bool) -> None:
+    """Set backup network state."""
+    console = cli_ctx.console
+    action = "enable" if enable else "disable"
+
+    try:
+        confirm_or_fail(
+            action=f"{action} backup network",
+            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_backup(client: EeroClient) -> None:
+            with cli_ctx.status(f"{action.capitalize()}ing backup network..."):
+                try:
+                    result = await client.set_backup_network(enable, cli_ctx.network_id)
+                except Exception as e:
+                    if is_premium_error(e):
+                        console.print("[yellow]Backup network requires Eero Plus[/yellow]")
+                        sys.exit(ExitCode.PREMIUM_REQUIRED)
+                    raise
+
+            if result:
+                console.print(f"[bold green]Backup network {action}d[/bold green]")
+            else:
+                console.print(f"[red]Failed to {action} backup network[/red]")
+                sys.exit(ExitCode.GENERIC_ERROR)
+
+        await run_with_client(set_backup)
+
+    asyncio.run(run_cmd())
+
+
+@backup_group.command(name="status")
+@click.pass_context
+def backup_status(ctx: click.Context) -> None:
+    """Show current backup network status."""
+    cli_ctx = get_cli_context(ctx)
+    console = cli_ctx.console
+    renderer = cli_ctx.renderer
+
+    async def run_cmd() -> None:
+        async def get_status(client: EeroClient) -> None:
+            with cli_ctx.status("Getting backup status..."):
+                try:
+                    status_data = await client.get_backup_status(cli_ctx.network_id)
+                    is_using = await client.is_using_backup(cli_ctx.network_id)
+                except Exception as e:
+                    if is_premium_error(e):
+                        console.print("[yellow]Backup network requires Eero Plus[/yellow]")
+                        sys.exit(ExitCode.PREMIUM_REQUIRED)
+                    raise
+
+            if cli_ctx.is_json_output():
+                renderer.render_json(
+                    {**status_data, "using_backup": is_using}, "eero.network.backup.status/v1"
+                )
+            else:
+                style = "yellow" if is_using else "green"
+                status = "Using Backup" if is_using else "Primary Connection"
+                content = f"[bold]Status:[/bold] [{style}]{status}[/{style}]"
+                console.print(Panel(content, title="Backup Status", border_style=style))
+
+        await run_with_client(get_status)
+
+    asyncio.run(run_cmd())

eeroctl/commands/network/base.py

@@ -0,0 +1,331 @@
+"""Base network commands for the Eero CLI.
+
+Commands:
+- eero network list: List all networks
+- eero network use: Set preferred network
+- eero network show: Show network details
+- eero network rename: Rename network
+- eero network premium: Check Eero Plus status
+"""
+
+import asyncio
+import sys
+from typing import Literal, Optional
+
+import click
+from eero import EeroClient
+from rich.panel import Panel
+from rich.table import Table
+
+from ...context import ensure_cli_context, get_cli_context
+from ...exit_codes import ExitCode
+from ...formatting import get_network_status_value
+from ...options import apply_options, force_option, network_option, output_option
+from ...output import OutputFormat
+from ...safety import OperationRisk, SafetyError, confirm_or_fail
+from ...utils import run_with_client, set_preferred_network
+
+
+@click.group(name="network")
+@click.pass_context
+def network_group(ctx: click.Context) -> None:
+    """Manage network settings.
+
+    \b
+    Commands:
+      list      - List all networks
+      use       - Set preferred network
+      show      - Show network details
+      rename    - Rename network (SSID)
+      premium   - Check Eero Plus status
+      dns       - DNS settings
+      security  - Security settings
+      sqm       - SQM/QoS settings
+      guest     - Guest network
+      backup    - Backup network (Eero Plus)
+      speedtest - Speed tests
+      forwards  - Port forwarding
+      dhcp      - DHCP settings
+      routing   - Routing information
+      thread    - Thread protocol
+      support   - Support bundle
+
+    \b
+    Examples:
+      eero network list              # List all networks
+      eero network show              # Show current network
+      eero network dns show          # Show DNS settings
+      eero network guest enable      # Enable guest network
+    """
+    ensure_cli_context(ctx)
+
+
+@network_group.command(name="list")
+@output_option
+@click.pass_context
+def network_list(ctx: click.Context, output: Optional[str]) -> None:
+    """List all networks.
+
+    Shows all networks associated with your account.
+    """
+    cli_ctx = apply_options(ctx, output=output)
+    console = cli_ctx.console
+
+    async def run_cmd() -> None:
+        async def get_networks(client: EeroClient) -> None:
+            with cli_ctx.status("Getting networks..."):
+                networks = await client.get_networks()
+
+            if not networks:
+                console.print("[yellow]No networks found[/yellow]")
+                return
+
+            if cli_ctx.is_structured_output():
+                data = [
+                    {
+                        "id": n.id,
+                        "name": n.name,
+                        "status": get_network_status_value(n),
+                        "public_ip": n.public_ip,
+                        "isp_name": n.isp_name,
+                    }
+                    for n in networks
+                ]
+                cli_ctx.render_structured(data, "eero.network.list/v1")
+            elif cli_ctx.output_format == OutputFormat.LIST:
+                for n in networks:
+                    status = get_network_status_value(n)
+                    # Use print() with fixed-width columns for alignment
+                    print(
+                        f"{n.id or '':<12}  {n.name or '':<25}  {status:<15}  "
+                        f"{n.public_ip or 'N/A':<15}  {n.isp_name or 'N/A'}"
+                    )
+            else:
+                table = Table(title="Eero Networks")
+                table.add_column("ID", style="dim")
+                table.add_column("Name", style="cyan")
+                table.add_column("Status", style="green")
+                table.add_column("Public IP", style="blue")
+                table.add_column("ISP", style="magenta")
+
+                for n in networks:
+                    status = get_network_status_value(n)
+                    if "online" in status.lower() or "connected" in status.lower():
+                        status_display = f"[green]{status}[/green]"
+                    elif "offline" in status.lower():
+                        status_display = f"[red]{status}[/red]"
+                    else:
+                        status_display = f"[yellow]{status}[/yellow]"
+
+                    table.add_row(
+                        n.id or "",
+                        n.name or "",
+                        status_display,
+                        n.public_ip or "N/A",
+                        n.isp_name or "N/A",
+                    )
+
+                console.print(table)
+
+        await run_with_client(get_networks)
+
+    asyncio.run(run_cmd())
+
+
+@network_group.command(name="use")
+@click.argument("network_id")
+@click.pass_context
+def network_use(ctx: click.Context, network_id: str) -> None:
+    """Set preferred network for future commands.
+
+    \b
+    Arguments:
+      NETWORK_ID  The network ID to use
+
+    \b
+    Examples:
+      eero network use abc123
+    """
+    cli_ctx = get_cli_context(ctx)
+    console = cli_ctx.console
+
+    async def run_cmd() -> None:
+        async def set_preferred(client: EeroClient) -> None:
+            client.set_preferred_network(network_id)
+            set_preferred_network(network_id)
+
+            try:
+                with cli_ctx.status(f"Verifying network {network_id}..."):
+                    net = await client.get_network(network_id)
+                console.print(
+                    f"[bold green]Preferred network set to '{net.name}' ({network_id})[/bold green]"
+                )
+            except Exception as e:
+                console.print(
+                    f"[yellow]Network ID set to {network_id}, but could not verify: {e}[/yellow]"
+                )
+
+        await run_with_client(set_preferred)
+
+    asyncio.run(run_cmd())
+
+
+@network_group.command(name="show")
+@output_option
+@network_option
+@click.pass_context
+def network_show(ctx: click.Context, output: Optional[str], network_id: Optional[str]) -> None:
+    """Show current network details.
+
+    Displays comprehensive information about the current network
+    including settings, DHCP, and recent speed test results.
+    """
+    cli_ctx = apply_options(ctx, output=output, network_id=network_id)
+
+    async def run_cmd() -> None:
+        async def get_network(client: EeroClient) -> None:
+            with cli_ctx.status("Getting network details..."):
+                network = await client.get_network(cli_ctx.network_id)
+
+            if cli_ctx.is_structured_output():
+                cli_ctx.render_structured(
+                    network.model_dump(mode="json"),
+                    "eero.network.show/v1",
+                )
+            else:
+                from ...formatting import print_network_details
+
+                detail: Literal["brief", "full"] = (
+                    "full" if cli_ctx.detail_level == "full" else "brief"
+                )
+                print_network_details(network, detail_level=detail)
+
+        await run_with_client(get_network)
+
+    asyncio.run(run_cmd())
+
+
+@network_group.command(name="rename")
+@click.option("--name", required=True, help="New network name (SSID)")
+@force_option
+@network_option
+@click.pass_context
+def network_rename(
+    ctx: click.Context, name: str, force: Optional[bool], network_id: Optional[str]
+) -> None:
+    """Rename the network (change SSID).
+
+    Note: May require network restart to take effect.
+
+    \b
+    Options:
+      --name TEXT  New network name (required)
+
+    \b
+    Examples:
+      eero network rename --name "My Home WiFi"
+    """
+    cli_ctx = apply_options(ctx, network_id=network_id, force=force)
+    console = cli_ctx.console
+
+    try:
+        confirm_or_fail(
+            action="rename network",
+            target=f"to '{name}'",
+            risk=OperationRisk.MEDIUM,
+            force=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_name(client: EeroClient) -> None:
+            with cli_ctx.status(f"Renaming network to '{name}'..."):
+                result = await client.set_network_name(name, cli_ctx.network_id)
+
+            if result:
+                console.print(f"[bold green]Network renamed to '{name}'[/bold green]")
+                console.print("[dim]Note: Network restart may be required[/dim]")
+            else:
+                console.print("[bold red]Failed to rename network[/bold red]")
+                sys.exit(ExitCode.GENERIC_ERROR)
+
+        await run_with_client(set_name)
+
+    asyncio.run(run_cmd())
+
+
+@network_group.command(name="premium")
+@output_option
+@network_option
+@click.pass_context
+def network_premium(ctx: click.Context, output: Optional[str], network_id: Optional[str]) -> None:
+    """Check Eero Plus subscription status.
+
+    Shows whether Eero Plus/Secure is active and which
+    features are available.
+    """
+    cli_ctx = apply_options(ctx, output=output, network_id=network_id)
+    console = cli_ctx.console
+    renderer = cli_ctx.renderer
+
+    async def run_cmd() -> None:
+        async def check_premium(client: EeroClient) -> None:
+            with cli_ctx.status("Checking premium status..."):
+                premium_data = await client.get_premium_status(cli_ctx.network_id)
+                is_premium = await client.is_premium(cli_ctx.network_id)
+
+            if cli_ctx.is_json_output():
+                renderer.render_json(
+                    {**premium_data, "is_active": is_premium},
+                    "eero.network.premium/v1",
+                )
+            else:
+                status_style = "green" if is_premium else "yellow"
+                status_text = "Active" if is_premium else "Not Active"
+
+                content = f"[bold]Eero Plus:[/bold] [{status_style}]{status_text}[/{status_style}]"
+                if "plan" in premium_data:
+                    content += f"\n[bold]Plan:[/bold] {premium_data['plan']}"
+                if "expires_at" in premium_data:
+                    content += f"\n[bold]Expires:[/bold] {premium_data['expires_at']}"
+
+                console.print(
+                    Panel(
+                        content,
+                        title="Premium Status",
+                        border_style="blue" if is_premium else "yellow",
+                    )
+                )
+
+        await run_with_client(check_premium)
+
+    asyncio.run(run_cmd())
+
+
+# Import and register subcommand groups after network_group is defined
+from .advanced import routing_show, support_group, thread_cmd_group  # noqa: E402
+from .backup import backup_group  # noqa: E402
+from .dhcp import dhcp_group  # noqa: E402
+from .dns import dns_group  # noqa: E402
+from .forwards import forwards_group  # noqa: E402
+from .guest import guest_group  # noqa: E402
+from .security import security_group  # noqa: E402
+from .speedtest import speedtest_group  # noqa: E402
+from .sqm import sqm_group  # noqa: E402
+
+# Register all subcommand groups
+network_group.add_command(dns_group)
+network_group.add_command(security_group)
+network_group.add_command(sqm_group)
+network_group.add_command(guest_group)
+network_group.add_command(backup_group)
+network_group.add_command(speedtest_group)
+network_group.add_command(forwards_group)
+network_group.add_command(dhcp_group)
+network_group.add_command(routing_show)
+network_group.add_command(thread_cmd_group)
+network_group.add_command(support_group)