eeroctl 1.7.1__py3-none-any.whl

eeroctl/commands/network/dhcp.py

@@ -0,0 +1,118 @@
+"""DHCP commands for the Eero CLI.
+
+Commands:
+- eero network dhcp reservations: List DHCP reservations
+- eero network dhcp leases: List current DHCP leases
+"""
+
+import asyncio
+
+import click
+from eero import EeroClient
+from rich.table import Table
+
+from ...context import get_cli_context
+from ...utils import run_with_client
+
+
+@click.group(name="dhcp")
+@click.pass_context
+def dhcp_group(ctx: click.Context) -> None:
+    """Manage DHCP settings.
+
+    \b
+    Commands:
+      reservations - List DHCP reservations
+      leases       - List current DHCP leases
+      reserve      - Create a reservation (stub)
+      unreserve    - Remove a reservation (stub)
+    """
+    pass
+
+
+@dhcp_group.command(name="reservations")
+@click.pass_context
+def dhcp_reservations(ctx: click.Context) -> None:
+    """List DHCP reservations."""
+    cli_ctx = get_cli_context(ctx)
+    console = cli_ctx.console
+    renderer = cli_ctx.renderer
+
+    async def run_cmd() -> None:
+        async def get_reservations(client: EeroClient) -> None:
+            with cli_ctx.status("Getting DHCP reservations..."):
+                reservations = await client.get_reservations(cli_ctx.network_id)
+
+            if cli_ctx.is_json_output():
+                renderer.render_json(reservations, "eero.network.dhcp.reservations/v1")
+            else:
+                if not reservations:
+                    console.print("[yellow]No DHCP reservations configured[/yellow]")
+                    return
+
+                table = Table(title="DHCP Reservations")
+                table.add_column("MAC", style="yellow")
+                table.add_column("IP", style="green")
+                table.add_column("Hostname", style="cyan")
+
+                for res in reservations:
+                    table.add_row(
+                        res.get("mac", ""),
+                        res.get("ip", ""),
+                        res.get("hostname", ""),
+                    )
+
+                console.print(table)
+
+        await run_with_client(get_reservations)
+
+    asyncio.run(run_cmd())
+
+
+@dhcp_group.command(name="leases")
+@click.pass_context
+def dhcp_leases(ctx: click.Context) -> None:
+    """List current DHCP leases."""
+    cli_ctx = get_cli_context(ctx)
+    console = cli_ctx.console
+    renderer = cli_ctx.renderer
+
+    async def run_cmd() -> None:
+        async def get_leases(client: EeroClient) -> None:
+            with cli_ctx.status("Getting DHCP leases..."):
+                # Leases come from devices list
+                devices = await client.get_devices(cli_ctx.network_id)
+
+            if cli_ctx.is_json_output():
+                data = [
+                    {
+                        "ip": d.ip or d.ipv4,
+                        "mac": d.mac,
+                        "hostname": d.hostname,
+                        "name": d.display_name or d.nickname,
+                    }
+                    for d in devices
+                    if d.ip or d.ipv4
+                ]
+                renderer.render_json(data, "eero.network.dhcp.leases/v1")
+            else:
+                table = Table(title="DHCP Leases")
+                table.add_column("IP", style="green")
+                table.add_column("MAC", style="yellow")
+                table.add_column("Hostname", style="cyan")
+                table.add_column("Name", style="blue")
+
+                for d in devices:
+                    if d.ip or d.ipv4:
+                        table.add_row(
+                            d.ip or d.ipv4 or "",
+                            d.mac or "",
+                            d.hostname or "",
+                            d.display_name or d.nickname or "",
+                        )
+
+                console.print(table)
+
+        await run_with_client(get_leases)
+
+    asyncio.run(run_cmd())

eeroctl/commands/network/dns.py

@@ -0,0 +1,197 @@
+"""DNS commands for the Eero CLI.
+
+Commands:
+- eero network dns show: Show DNS settings
+- eero network dns mode set: Set DNS mode
+- eero network dns caching: Enable/disable DNS caching
+"""
+
+import asyncio
+import sys
+
+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="dns")
+@click.pass_context
+def dns_group(ctx: click.Context) -> None:
+    """Manage DNS settings.
+
+    \b
+    Commands:
+      show       - Show current DNS settings
+      mode       - Set DNS mode
+      caching    - Enable/disable DNS caching
+
+    \b
+    Examples:
+      eero network dns show
+      eero network dns mode set google
+      eero network dns caching enable
+    """
+    pass
+
+
+@dns_group.command(name="show")
+@click.pass_context
+def dns_show(ctx: click.Context) -> None:
+    """Show current DNS settings."""
+    cli_ctx = get_cli_context(ctx)
+    console = cli_ctx.console
+    renderer = cli_ctx.renderer
+
+    async def run_cmd() -> None:
+        async def get_dns(client: EeroClient) -> None:
+            with cli_ctx.status("Getting DNS settings..."):
+                dns_data = await client.get_dns_settings(cli_ctx.network_id)
+
+            if cli_ctx.is_json_output():
+                renderer.render_json(dns_data, "eero.network.dns.show/v1")
+            else:
+                caching = dns_data.get("dns_caching", False)
+                mode = dns_data.get("dns_mode", "auto")
+                custom_dns = dns_data.get("custom_dns", [])
+
+                content = (
+                    f"[bold]DNS Mode:[/bold] {mode}\n"
+                    f"[bold]DNS Caching:[/bold] {'[green]Enabled[/green]' if caching else '[dim]Disabled[/dim]'}"
+                )
+                if custom_dns:
+                    content += f"\n[bold]Custom DNS:[/bold] {', '.join(custom_dns)}"
+
+                console.print(Panel(content, title="DNS Settings", border_style="blue"))
+
+        await run_with_client(get_dns)
+
+    asyncio.run(run_cmd())
+
+
+@dns_group.group(name="mode")
+@click.pass_context
+def dns_mode_group(ctx: click.Context) -> None:
+    """Set DNS mode."""
+    pass
+
+
+@dns_mode_group.command(name="set")
+@click.argument("mode", type=click.Choice(["auto", "cloudflare", "google", "opendns", "custom"]))
+@click.option("--servers", "-s", multiple=True, help="Custom DNS servers (for 'custom' mode)")
+@click.option("--force", "-f", is_flag=True, help="Skip confirmation")
+@click.pass_context
+def dns_mode_set(ctx: click.Context, mode: str, servers: tuple, force: bool) -> None:
+    """Set DNS mode.
+
+    \b
+    Modes:
+      auto       - Use ISP DNS
+      cloudflare - Use Cloudflare (1.1.1.1)
+      google     - Use Google (8.8.8.8)
+      opendns    - Use OpenDNS
+      custom     - Use custom servers (requires --servers)
+
+    \b
+    Examples:
+      eero network dns mode set google
+      eero network dns mode set custom --servers 8.8.8.8 --servers 8.8.4.4
+    """
+    cli_ctx = get_cli_context(ctx)
+    console = cli_ctx.console
+
+    if mode == "custom" and not servers:
+        console.print("[red]Error: --servers required for custom mode[/red]")
+        sys.exit(ExitCode.USAGE_ERROR)
+
+    try:
+        confirm_or_fail(
+            action="change DNS mode",
+            target=f"to {mode}",
+            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_mode(client: EeroClient) -> None:
+            custom_servers = list(servers) if servers else None
+            with cli_ctx.status(f"Setting DNS mode to {mode}..."):
+                result = await client.set_dns_mode(mode, custom_servers, cli_ctx.network_id)
+
+            if result:
+                console.print(f"[bold green]DNS mode set to {mode}[/bold green]")
+            else:
+                console.print("[red]Failed to set DNS mode[/red]")
+                sys.exit(ExitCode.GENERIC_ERROR)
+
+        await run_with_client(set_mode)
+
+    asyncio.run(run_cmd())
+
+
+@dns_group.group(name="caching")
+@click.pass_context
+def dns_caching_group(ctx: click.Context) -> None:
+    """Manage DNS caching."""
+    pass
+
+
+@dns_caching_group.command(name="enable")
+@click.option("--force", "-f", is_flag=True, help="Skip confirmation")
+@click.pass_context
+def dns_caching_enable(ctx: click.Context, force: bool) -> None:
+    """Enable DNS caching."""
+    cli_ctx = get_cli_context(ctx)
+    _set_dns_caching(cli_ctx, True, force)
+
+
+@dns_caching_group.command(name="disable")
+@click.option("--force", "-f", is_flag=True, help="Skip confirmation")
+@click.pass_context
+def dns_caching_disable(ctx: click.Context, force: bool) -> None:
+    """Disable DNS caching."""
+    cli_ctx = get_cli_context(ctx)
+    _set_dns_caching(cli_ctx, False, force)
+
+
+def _set_dns_caching(cli_ctx: EeroCliContext, enable: bool, force: bool) -> None:
+    """Set DNS caching state."""
+    console = cli_ctx.console
+    action = "enable" if enable else "disable"
+
+    try:
+        confirm_or_fail(
+            action=f"{action} DNS caching",
+            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_caching(client: EeroClient) -> None:
+            with cli_ctx.status(f"{action.capitalize()}ing DNS caching..."):
+                result = await client.set_dns_caching(enable, cli_ctx.network_id)
+
+            if result:
+                console.print(f"[bold green]DNS caching {action}d[/bold green]")
+            else:
+                console.print(f"[red]Failed to {action} DNS caching[/red]")
+                sys.exit(ExitCode.GENERIC_ERROR)
+
+        await run_with_client(set_caching)
+
+    asyncio.run(run_cmd())

eeroctl/commands/network/forwards.py

@@ -0,0 +1,115 @@
+"""Port forwarding commands for the Eero CLI.
+
+Commands:
+- eero network forwards list: List all port forwards
+- eero network forwards show: Show details of a port forward
+"""
+
+import asyncio
+import sys
+
+import click
+from eero import EeroClient
+from rich.panel import Panel
+from rich.table import Table
+
+from ...context import get_cli_context
+from ...exit_codes import ExitCode
+from ...utils import run_with_client
+
+
+@click.group(name="forwards")
+@click.pass_context
+def forwards_group(ctx: click.Context) -> None:
+    """Manage port forwarding rules.
+
+    \b
+    Commands:
+      list   - List all port forwards
+      show   - Show details of a port forward
+      add    - Add a new port forward (stub)
+      delete - Delete a port forward (stub)
+    """
+    pass
+
+
+@forwards_group.command(name="list")
+@click.pass_context
+def forwards_list(ctx: click.Context) -> None:
+    """List all port forwarding rules."""
+    cli_ctx = get_cli_context(ctx)
+    console = cli_ctx.console
+    renderer = cli_ctx.renderer
+
+    async def run_cmd() -> None:
+        async def get_forwards(client: EeroClient) -> None:
+            with cli_ctx.status("Getting port forwards..."):
+                forwards = await client.get_forwards(cli_ctx.network_id)
+
+            if cli_ctx.is_json_output():
+                renderer.render_json(forwards, "eero.network.forwards.list/v1")
+            else:
+                if not forwards:
+                    console.print("[yellow]No port forwards configured[/yellow]")
+                    return
+
+                table = Table(title="Port Forwards")
+                table.add_column("ID", style="dim")
+                table.add_column("Name", style="cyan")
+                table.add_column("External Port")
+                table.add_column("Internal IP")
+                table.add_column("Internal Port")
+                table.add_column("Protocol")
+
+                for fwd in forwards:
+                    table.add_row(
+                        str(fwd.get("id", "")),
+                        fwd.get("name", ""),
+                        str(fwd.get("external_port", "")),
+                        fwd.get("internal_ip", ""),
+                        str(fwd.get("internal_port", "")),
+                        fwd.get("protocol", "tcp"),
+                    )
+
+                console.print(table)
+
+        await run_with_client(get_forwards)
+
+    asyncio.run(run_cmd())
+
+
+@forwards_group.command(name="show")
+@click.argument("forward_id")
+@click.pass_context
+def forwards_show(ctx: click.Context, forward_id: str) -> None:
+    """Show details of a port forward."""
+    cli_ctx = get_cli_context(ctx)
+    console = cli_ctx.console
+    renderer = cli_ctx.renderer
+
+    async def run_cmd() -> None:
+        async def get_forward(client: EeroClient) -> None:
+            with cli_ctx.status("Getting port forward..."):
+                forwards = await client.get_forwards(cli_ctx.network_id)
+
+            target = None
+            for fwd in forwards:
+                if str(fwd.get("id")) == forward_id:
+                    target = fwd
+                    break
+
+            if not target:
+                console.print(f"[red]Port forward '{forward_id}' not found[/red]")
+                sys.exit(ExitCode.NOT_FOUND)
+
+            if cli_ctx.is_json_output():
+                renderer.render_json(target, "eero.network.forwards.show/v1")
+            else:
+                content = "\n".join(f"[bold]{k}:[/bold] {v}" for k, v in target.items())
+                console.print(
+                    Panel(content, title=f"Port Forward: {forward_id}", border_style="blue")
+                )
+
+        await run_with_client(get_forward)
+
+    asyncio.run(run_cmd())

eeroctl/commands/network/guest.py

@@ -0,0 +1,162 @@
+"""Guest network commands for the Eero CLI.
+
+Commands:
+- eero network guest show: Show guest network settings
+- eero network guest enable: Enable guest network
+- eero network guest disable: Disable guest network
+- eero network guest set: Configure guest network
+"""
+
+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="guest")
+@click.pass_context
+def guest_group(ctx: click.Context) -> None:
+    """Manage guest network.
+
+    \b
+    Commands:
+      show    - Show guest network settings
+      enable  - Enable guest network
+      disable - Disable guest network
+      set     - Configure guest network
+
+    \b
+    Examples:
+      eero network guest show
+      eero network guest enable
+      eero network guest set --name "Guest WiFi" --password "secret123"
+    """
+    pass
+
+
+@guest_group.command(name="show")
+@click.pass_context
+def guest_show(ctx: click.Context) -> None:
+    """Show guest network settings."""
+    cli_ctx = get_cli_context(ctx)
+    console = cli_ctx.console
+    renderer = cli_ctx.renderer
+
+    async def run_cmd() -> None:
+        async def get_guest(client: EeroClient) -> None:
+            with cli_ctx.status("Getting guest network settings..."):
+                network = await client.get_network(cli_ctx.network_id)
+
+            if cli_ctx.is_json_output():
+                data = {
+                    "enabled": network.guest_network_enabled,
+                    "name": network.guest_network_name,
+                    "password": "********" if network.guest_network_password else None,
+                }
+                renderer.render_json(data, "eero.network.guest.show/v1")
+            else:
+                enabled = network.guest_network_enabled
+                content = (
+                    f"[bold]Enabled:[/bold] {'[green]Yes[/green]' if enabled else '[dim]No[/dim]'}\n"
+                    f"[bold]Name:[/bold] {network.guest_network_name or 'N/A'}\n"
+                    f"[bold]Password:[/bold] {'********' if network.guest_network_password else 'N/A'}"
+                )
+                console.print(Panel(content, title="Guest Network", border_style="blue"))
+
+        await run_with_client(get_guest)
+
+    asyncio.run(run_cmd())
+
+
+@guest_group.command(name="enable")
+@click.option("--force", "-f", is_flag=True, help="Skip confirmation")
+@click.pass_context
+def guest_enable(ctx: click.Context, force: bool) -> None:
+    """Enable guest network."""
+    cli_ctx = get_cli_context(ctx)
+    _set_guest_network(cli_ctx, True, None, None, force)
+
+
+@guest_group.command(name="disable")
+@click.option("--force", "-f", is_flag=True, help="Skip confirmation")
+@click.pass_context
+def guest_disable(ctx: click.Context, force: bool) -> None:
+    """Disable guest network."""
+    cli_ctx = get_cli_context(ctx)
+    _set_guest_network(cli_ctx, False, None, None, force)
+
+
+@guest_group.command(name="set")
+@click.option("--name", help="Guest network name")
+@click.option("--password", help="Guest network password")
+@click.option("--force", "-f", is_flag=True, help="Skip confirmation")
+@click.pass_context
+def guest_set(
+    ctx: click.Context, name: Optional[str], password: Optional[str], force: bool
+) -> None:
+    """Configure guest network settings.
+
+    \b
+    Options:
+      --name      Guest network SSID
+      --password  Guest network password
+
+    \b
+    Examples:
+      eero network guest set --name "Guest WiFi" --password "welcome123"
+    """
+    cli_ctx = get_cli_context(ctx)
+    _set_guest_network(cli_ctx, True, name, password, force)
+
+
+def _set_guest_network(
+    cli_ctx: EeroCliContext,
+    enable: bool,
+    name: Optional[str],
+    password: Optional[str],
+    force: bool,
+) -> None:
+    """Set guest network settings."""
+    console = cli_ctx.console
+    action = "enable" if enable else "disable"
+
+    try:
+        confirm_or_fail(
+            action=f"{action} guest 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_guest(client: EeroClient) -> None:
+            with cli_ctx.status(f"{action.capitalize()}ing guest network..."):
+                result = await client.set_guest_network(
+                    enabled=enable,
+                    name=name,
+                    password=password,
+                    network_id=cli_ctx.network_id,
+                )
+
+            if result:
+                console.print(f"[bold green]Guest network {action}d[/bold green]")
+            else:
+                console.print(f"[red]Failed to {action} guest network[/red]")
+                sys.exit(ExitCode.GENERIC_ERROR)
+
+        await run_with_client(set_guest)
+
+    asyncio.run(run_cmd())