ui-cli 1.2.1__py3-none-any.whl

ui_cli/commands/local/firewall.py

@@ -0,0 +1,285 @@
+"""Firewall commands for local controller."""
+
+import asyncio
+from typing import Annotated, Any
+
+import typer
+
+from ui_cli.local_client import LocalAPIError, UniFiLocalClient
+from ui_cli.output import (
+    OutputFormat,
+    console,
+    output_csv,
+    output_json,
+    print_error,
+)
+
+app = typer.Typer(name="firewall", help="Firewall rules and groups", no_args_is_help=True)
+
+
+# Ruleset display names
+RULESET_NAMES = {
+    "WAN_IN": "WAN In",
+    "WAN_OUT": "WAN Out",
+    "WAN_LOCAL": "WAN Local",
+    "LAN_IN": "LAN In",
+    "LAN_OUT": "LAN Out",
+    "LAN_LOCAL": "LAN Local",
+    "GUEST_IN": "Guest In",
+    "GUEST_OUT": "Guest Out",
+    "GUEST_LOCAL": "Guest Local",
+}
+
+
+def format_action(action: str) -> tuple[str, str]:
+    """Format action with color."""
+    action_lower = action.lower()
+    if action_lower == "accept":
+        return "accept", "green"
+    elif action_lower == "drop":
+        return "drop", "red"
+    elif action_lower == "reject":
+        return "reject", "yellow"
+    return action, "white"
+
+
+def format_protocol(rule: dict[str, Any]) -> str:
+    """Format protocol for display."""
+    protocol = rule.get("protocol", "all")
+    if protocol == "all":
+        return "any"
+    return protocol.upper()
+
+
+def format_address(rule: dict[str, Any], prefix: str) -> str:
+    """Format source or destination address."""
+    # Check for network type
+    net_type = rule.get(f"{prefix}_network_type", "")
+    if net_type == "ADDRv4":
+        addr = rule.get(f"{prefix}_address", "")
+        return addr if addr else "any"
+
+    # Check for firewall group
+    group = rule.get(f"{prefix}_firewallgroup_ids", [])
+    if group:
+        return f"group:{len(group)}"
+
+    # Check for specific network
+    network = rule.get(f"{prefix}_network", "")
+    if network:
+        return network
+
+    return "any"
+
+
+def format_port(rule: dict[str, Any], prefix: str) -> str:
+    """Format port information."""
+    port = rule.get(f"{prefix}_port", "")
+    if port:
+        return str(port)
+    return "*"
+
+
+def get_ruleset_order(ruleset: str) -> int:
+    """Get sort order for rulesets."""
+    order = ["WAN_IN", "WAN_OUT", "WAN_LOCAL", "LAN_IN", "LAN_OUT", "LAN_LOCAL", "GUEST_IN", "GUEST_OUT", "GUEST_LOCAL"]
+    try:
+        return order.index(ruleset)
+    except ValueError:
+        return 100
+
+
+@app.command("list")
+def list_rules(
+    ruleset: Annotated[
+        str | None,
+        typer.Option("--ruleset", "-r", help="Filter by ruleset (e.g., WAN_IN, LAN_IN)"),
+    ] = None,
+    output: Annotated[
+        OutputFormat,
+        typer.Option("--output", "-o", help="Output format"),
+    ] = OutputFormat.TABLE,
+    verbose: Annotated[
+        bool,
+        typer.Option("--verbose", "-v", help="Show additional details"),
+    ] = False,
+) -> None:
+    """List firewall rules."""
+    from ui_cli.commands.local.utils import run_with_spinner
+
+    async def _list():
+        client = UniFiLocalClient()
+        return await client.get_firewall_rules()
+
+    try:
+        rules = run_with_spinner(_list(), "Fetching firewall rules...")
+    except LocalAPIError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+    if not rules:
+        console.print("[dim]No firewall rules found[/dim]")
+        return
+
+    # Filter by ruleset if specified
+    if ruleset:
+        ruleset_upper = ruleset.upper()
+        rules = [r for r in rules if r.get("ruleset", "").upper() == ruleset_upper]
+        if not rules:
+            console.print(f"[dim]No rules found for ruleset '{ruleset}'[/dim]")
+            return
+
+    # Sort by ruleset then by rule index
+    rules.sort(key=lambda r: (get_ruleset_order(r.get("ruleset", "")), r.get("rule_index", 0)))
+
+    if output == OutputFormat.JSON:
+        output_json(rules)
+    elif output == OutputFormat.CSV:
+        columns = [
+            ("name", "Name"),
+            ("ruleset", "Ruleset"),
+            ("action", "Action"),
+            ("protocol", "Protocol"),
+            ("src_address", "Source"),
+            ("dst_address", "Destination"),
+            ("enabled", "Enabled"),
+        ]
+        csv_data = []
+        for r in rules:
+            csv_data.append({
+                "name": r.get("name", ""),
+                "ruleset": r.get("ruleset", ""),
+                "action": r.get("action", ""),
+                "protocol": format_protocol(r),
+                "src_address": format_address(r, "src"),
+                "dst_address": format_address(r, "dst"),
+                "enabled": "Yes" if r.get("enabled", True) else "No",
+            })
+        output_csv(csv_data, columns)
+    else:
+        from rich.table import Table
+
+        table = Table(title="Firewall Rules", show_header=True, header_style="bold cyan")
+        table.add_column("Name")
+        table.add_column("Ruleset")
+        table.add_column("Action")
+        table.add_column("Protocol")
+        table.add_column("Source")
+        table.add_column("Destination")
+        if verbose:
+            table.add_column("Src Port")
+            table.add_column("Dst Port")
+        table.add_column("Enabled")
+
+        for r in rules:
+            name = r.get("name", "(unnamed)")
+            ruleset_name = RULESET_NAMES.get(r.get("ruleset", ""), r.get("ruleset", ""))
+            action, action_style = format_action(r.get("action", ""))
+            protocol = format_protocol(r)
+            src = format_address(r, "src")
+            dst = format_address(r, "dst")
+            enabled = "[green]✓[/green]" if r.get("enabled", True) else "[dim]✗[/dim]"
+
+            if verbose:
+                src_port = format_port(r, "src")
+                dst_port = format_port(r, "dst")
+                table.add_row(
+                    name,
+                    ruleset_name,
+                    f"[{action_style}]{action}[/{action_style}]",
+                    protocol,
+                    src,
+                    dst,
+                    src_port,
+                    dst_port,
+                    enabled,
+                )
+            else:
+                table.add_row(
+                    name,
+                    ruleset_name,
+                    f"[{action_style}]{action}[/{action_style}]",
+                    protocol,
+                    src,
+                    dst,
+                    enabled,
+                )
+
+        console.print(table)
+        console.print(f"\n[dim]{len(rules)} rule(s)[/dim]")
+
+
+@app.command("groups")
+def list_groups(
+    output: Annotated[
+        OutputFormat,
+        typer.Option("--output", "-o", help="Output format"),
+    ] = OutputFormat.TABLE,
+) -> None:
+    """List firewall groups (address and port groups)."""
+    from ui_cli.commands.local.utils import run_with_spinner
+
+    async def _list():
+        client = UniFiLocalClient()
+        return await client.get_firewall_groups()
+
+    try:
+        groups = run_with_spinner(_list(), "Fetching firewall groups...")
+    except LocalAPIError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+    if not groups:
+        console.print("[dim]No firewall groups found[/dim]")
+        return
+
+    # Sort by type then name
+    groups.sort(key=lambda g: (g.get("group_type", ""), g.get("name", "")))
+
+    if output == OutputFormat.JSON:
+        output_json(groups)
+    elif output == OutputFormat.CSV:
+        columns = [
+            ("_id", "ID"),
+            ("name", "Name"),
+            ("group_type", "Type"),
+            ("members", "Members"),
+        ]
+        csv_data = []
+        for g in groups:
+            members = g.get("group_members", [])
+            csv_data.append({
+                "_id": g.get("_id", ""),
+                "name": g.get("name", ""),
+                "group_type": g.get("group_type", ""),
+                "members": ", ".join(members) if members else "",
+            })
+        output_csv(csv_data, columns)
+    else:
+        from rich.table import Table
+
+        table = Table(title="Firewall Groups", show_header=True, header_style="bold cyan")
+        table.add_column("ID", style="dim")
+        table.add_column("Name")
+        table.add_column("Type")
+        table.add_column("Members")
+
+        for g in groups:
+            group_id = g.get("_id", "")
+            name = g.get("name", "")
+            group_type = g.get("group_type", "")
+
+            # Format type for display
+            type_display = group_type.replace("-", " ").title()
+
+            # Format members
+            members = g.get("group_members", [])
+            if len(members) <= 3:
+                members_str = ", ".join(members) if members else "[dim]-[/dim]"
+            else:
+                members_str = f"{', '.join(members[:3])}... (+{len(members) - 3})"
+
+            table.add_row(group_id, name, type_display, members_str)
+
+        console.print(table)
+        console.print(f"\n[dim]{len(groups)} group(s)[/dim]")

ui_cli/commands/local/health.py

@@ -0,0 +1,195 @@
+"""Site health command for local controller."""
+
+from typing import Annotated, Any
+
+import typer
+
+from ui_cli.commands.local.utils import run_with_spinner
+from ui_cli.local_client import LocalAPIError, UniFiLocalClient
+from ui_cli.output import OutputFormat, console, output_json, print_error
+
+app = typer.Typer(name="health", help="Site health status", invoke_without_command=True)
+
+
+def get_status_indicator(status: str, score: int | None = None) -> tuple[str, str]:
+    """Get status indicator and style based on status/score."""
+    status_lower = status.lower() if status else ""
+
+    if status_lower == "ok" or (score is not None and score >= 90):
+        return "🟢", "green"
+    elif status_lower in ("warning", "warn") or (score is not None and score >= 70):
+        return "🟡", "yellow"
+    elif status_lower in ("error", "critical", "unhealthy") or (score is not None and score < 70):
+        return "🔴", "red"
+    else:
+        return "⚪", "dim"
+
+
+def format_subsystem_name(subsystem: str) -> str:
+    """Format subsystem name for display."""
+    name_map = {
+        "www": "Internet",
+        "wan": "WAN",
+        "lan": "LAN",
+        "wlan": "WLAN",
+        "vpn": "VPN",
+        "speedtest": "Speed Test",
+        "dhcp": "DHCP",
+        "dns": "DNS",
+    }
+    return name_map.get(subsystem.lower(), subsystem.upper())
+
+
+def extract_issues(health_data: list[dict[str, Any]]) -> list[str]:
+    """Extract issues from health data."""
+    issues = []
+
+    for subsystem in health_data:
+        name = format_subsystem_name(subsystem.get("subsystem", ""))
+        status = subsystem.get("status", "").lower()
+        sub_name = subsystem.get("subsystem", "")
+
+        # Check for disconnected devices (common across subsystems)
+        num_disconnected = subsystem.get("num_disconnected", 0)
+        if num_disconnected > 0:
+            if sub_name == "lan":
+                issues.append(f"{name}: {num_disconnected} switch(es) disconnected")
+            elif sub_name == "wlan":
+                issues.append(f"{name}: {num_disconnected} AP(s) disconnected")
+            elif sub_name == "wan":
+                issues.append(f"{name}: {num_disconnected} gateway(s) disconnected")
+            else:
+                issues.append(f"{name}: {num_disconnected} device(s) disconnected")
+
+        # Check for pending devices
+        num_pending = subsystem.get("num_pending", 0)
+        if num_pending > 0:
+            issues.append(f"{name}: {num_pending} device(s) pending adoption")
+
+        # WLAN specific checks
+        if sub_name == "wlan":
+            num_disabled = subsystem.get("num_disabled", 0)
+            if num_disabled > 0:
+                issues.append(f"WLAN: {num_disabled} AP(s) disabled")
+
+        # WAN specific checks
+        if sub_name == "wan":
+            if subsystem.get("gw_wan_uptime", float("inf")) < 3600:
+                uptime = subsystem.get("gw_wan_uptime", 0)
+                issues.append(f"WAN: Connection recently restored ({uptime // 60} min ago)")
+
+        # LAN specific checks
+        if sub_name == "lan":
+            num_sw = subsystem.get("num_sw", 0)
+            num_adopted = subsystem.get("num_adopted", 0)
+            if num_sw > 0 and num_adopted < num_sw:
+                pending = num_sw - num_adopted
+                issues.append(f"LAN: {pending} switch(es) not adopted")
+
+    return issues
+
+
+@app.callback(invoke_without_command=True)
+def health(
+    ctx: typer.Context,
+    output: Annotated[
+        OutputFormat,
+        typer.Option("--output", "-o", help="Output format"),
+    ] = OutputFormat.TABLE,
+    verbose: Annotated[
+        bool,
+        typer.Option("--verbose", "-v", help="Show additional details"),
+    ] = False,
+) -> None:
+    """Show site health summary."""
+    if ctx.invoked_subcommand is not None:
+        return
+
+    async def _health():
+        client = UniFiLocalClient()
+        return await client.get_health()
+
+    try:
+        health_data = run_with_spinner(_health(), "Checking health...")
+    except LocalAPIError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+    if not health_data:
+        console.print("[dim]No health data available[/dim]")
+        return
+
+    if output == OutputFormat.JSON:
+        output_json(health_data)
+        return
+
+    # Table output
+    from rich.table import Table
+
+    console.print()
+    console.print("[bold cyan]Site Health[/bold cyan]")
+    console.print("─" * 40)
+    console.print()
+
+    table = Table(show_header=True, header_style="bold", box=None)
+    table.add_column("Subsystem", style="cyan")
+    table.add_column("Status")
+    if verbose:
+        table.add_column("Details", style="dim")
+
+    overall_ok = True
+    overall_warning = False
+
+    for subsystem in health_data:
+        name = format_subsystem_name(subsystem.get("subsystem", "unknown"))
+        status = subsystem.get("status", "unknown")
+        indicator, style = get_status_indicator(status)
+
+        if status.lower() not in ("ok", ""):
+            if style == "red":
+                overall_ok = False
+            elif style == "yellow":
+                overall_warning = True
+
+        status_display = f"{indicator} [{style}]{status.upper()}[/{style}]"
+
+        if verbose:
+            # Build details string
+            details = []
+            if "num_user" in subsystem:
+                details.append(f"{subsystem['num_user']} users")
+            if "num_sta" in subsystem:
+                details.append(f"{subsystem['num_sta']} clients")
+            if "num_ap" in subsystem:
+                details.append(f"{subsystem['num_ap']} APs")
+            if "tx_bytes-r" in subsystem:
+                tx = subsystem.get("tx_bytes-r", 0) / 1024 / 1024
+                rx = subsystem.get("rx_bytes-r", 0) / 1024 / 1024
+                details.append(f"↑{tx:.1f} ↓{rx:.1f} MB/s")
+            if "latency" in subsystem:
+                details.append(f"{subsystem['latency']}ms latency")
+
+            table.add_row(name, status_display, ", ".join(details) if details else "-")
+        else:
+            table.add_row(name, status_display)
+
+    console.print(table)
+
+    # Overall status
+    console.print()
+    if overall_ok and not overall_warning:
+        console.print("  Overall: [green]🟢 Healthy[/green]")
+    elif overall_warning:
+        console.print("  Overall: [yellow]🟡 Warning[/yellow]")
+    else:
+        console.print("  Overall: [red]🔴 Issues Detected[/red]")
+
+    # Show issues if any
+    issues = extract_issues(health_data)
+    if issues:
+        console.print()
+        console.print("  [bold]Notes:[/bold]")
+        for issue in issues:
+            console.print(f"  • {issue}")
+
+    console.print()