ui-cli 1.2.1__py3-none-any.whl

ui_cli/commands/local/dpi.py

@@ -0,0 +1,369 @@
+"""DPI (Deep Packet Inspection) 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,
+    print_warning,
+)
+
+app = typer.Typer(name="dpi", help="Deep Packet Inspection statistics", no_args_is_help=True)
+
+
+async def check_dpi_enabled(client: UniFiLocalClient) -> bool:
+    """Check if DPI is enabled in site settings."""
+    try:
+        settings = await client.get_site_settings()
+        for setting in settings:
+            if setting.get("key") == "dpi":
+                return setting.get("dpi_enabled", False)
+        return False
+    except LocalAPIError:
+        # Can't determine, assume it might be enabled
+        return True
+
+
+# DPI category mapping (UniFi uses numeric codes)
+DPI_CATEGORIES = {
+    0: "Instant Messaging",
+    1: "P2P",
+    2: "File Transfer",
+    3: "Streaming Media",
+    4: "Mail & Collaboration",
+    5: "VoIP",
+    6: "Database",
+    7: "Games",
+    8: "Network Management",
+    9: "Remote Access",
+    10: "Bypass Proxies",
+    11: "Stock Market",
+    12: "Web",
+    13: "Security Update",
+    14: "E-Commerce",
+    15: "Social Network",
+    16: "News",
+    18: "Business",
+    19: "Network Protocol",
+    20: "VPN & Tunneling",
+    21: "IoT",
+}
+
+# Common application names
+DPI_APPS = {
+    # Streaming
+    "youtube": "YouTube",
+    "netflix": "Netflix",
+    "amazonvideo": "Amazon Video",
+    "hulu": "Hulu",
+    "twitch": "Twitch",
+    "spotify": "Spotify",
+    "appletv": "Apple TV+",
+    "disneyplus": "Disney+",
+    # Social
+    "facebook": "Facebook",
+    "instagram": "Instagram",
+    "twitter": "Twitter/X",
+    "tiktok": "TikTok",
+    "snapchat": "Snapchat",
+    "whatsapp": "WhatsApp",
+    "discord": "Discord",
+    "telegram": "Telegram",
+    # Productivity
+    "microsoft": "Microsoft",
+    "office365": "Office 365",
+    "teams": "MS Teams",
+    "zoom": "Zoom",
+    "slack": "Slack",
+    "dropbox": "Dropbox",
+    "gdrive": "Google Drive",
+    # Cloud
+    "aws": "AWS",
+    "azure": "Azure",
+    "googlecloud": "Google Cloud",
+    "icloud": "iCloud",
+    # Other
+    "apple": "Apple",
+    "google": "Google",
+    "amazon": "Amazon",
+}
+
+
+def format_bytes(bytes_val: int | float | None) -> str:
+    """Format bytes to human-readable form."""
+    if not bytes_val or bytes_val == 0:
+        return "0 B"
+
+    units = ["B", "KB", "MB", "GB", "TB"]
+    unit_index = 0
+    value = float(bytes_val)
+
+    while value >= 1024 and unit_index < len(units) - 1:
+        value /= 1024
+        unit_index += 1
+
+    if unit_index == 0:
+        return f"{int(value)} {units[unit_index]}"
+    return f"{value:.1f} {units[unit_index]}"
+
+
+def get_category_name(cat_id: int) -> str:
+    """Get category name from ID."""
+    return DPI_CATEGORIES.get(cat_id, f"Category {cat_id}")
+
+
+def get_app_name(app_key: str) -> str:
+    """Get friendly app name."""
+    # Try direct lookup
+    key_lower = app_key.lower()
+    if key_lower in DPI_APPS:
+        return DPI_APPS[key_lower]
+
+    # Check partial matches
+    for k, v in DPI_APPS.items():
+        if k in key_lower:
+            return v
+
+    # Fallback: title case the key
+    return app_key.replace("_", " ").title()
+
+
+def aggregate_dpi_data(dpi_data: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Aggregate DPI data by category or app."""
+    aggregated = {}
+
+    for item in dpi_data:
+        # Try to get app name or category
+        app = item.get("app")
+        cat = item.get("cat")
+
+        if app:
+            key = f"app_{app}"
+            name = get_app_name(str(app))
+        elif cat is not None:
+            key = f"cat_{cat}"
+            name = get_category_name(cat)
+        else:
+            continue
+
+        if key not in aggregated:
+            aggregated[key] = {
+                "name": name,
+                "rx_bytes": 0,
+                "tx_bytes": 0,
+                "clients": set(),
+            }
+
+        aggregated[key]["rx_bytes"] += item.get("rx_bytes", 0)
+        aggregated[key]["tx_bytes"] += item.get("tx_bytes", 0)
+
+        # Track unique clients if available
+        mac = item.get("mac")
+        if mac:
+            aggregated[key]["clients"].add(mac)
+
+    # Convert to list and sort by total bytes
+    result = []
+    for key, data in aggregated.items():
+        result.append({
+            "name": data["name"],
+            "rx_bytes": data["rx_bytes"],
+            "tx_bytes": data["tx_bytes"],
+            "total_bytes": data["rx_bytes"] + data["tx_bytes"],
+            "client_count": len(data["clients"]),
+        })
+
+    result.sort(key=lambda x: x["total_bytes"], reverse=True)
+    return result
+
+
+@app.command("site")
+def site_dpi(
+    output: Annotated[
+        OutputFormat,
+        typer.Option("--output", "-o", help="Output format"),
+    ] = OutputFormat.TABLE,
+    limit: Annotated[
+        int,
+        typer.Option("--limit", "-l", help="Limit number of results"),
+    ] = 20,
+) -> None:
+    """Show site-level DPI statistics."""
+    from ui_cli.commands.local.utils import run_with_spinner
+
+    async def _dpi():
+        client = UniFiLocalClient()
+        dpi_enabled = await check_dpi_enabled(client)
+        dpi_data = await client.get_site_dpi()
+        return dpi_data, dpi_enabled
+
+    try:
+        dpi_data, dpi_enabled = run_with_spinner(_dpi(), "Fetching DPI stats...")
+    except LocalAPIError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+    # Aggregate the data
+    aggregated = aggregate_dpi_data(dpi_data)[:limit] if dpi_data else []
+
+    if not aggregated:
+        if not dpi_enabled:
+            print_warning("DPI is not enabled on this controller")
+            console.print("[dim]Enable Traffic Identification in Network Settings to use DPI.[/dim]")
+        else:
+            console.print("[dim]No DPI data collected yet.[/dim]")
+        return
+
+    if output == OutputFormat.JSON:
+        output_json(aggregated)
+    elif output == OutputFormat.CSV:
+        columns = [
+            ("name", "Application"),
+            ("rx_bytes", "Download (bytes)"),
+            ("tx_bytes", "Upload (bytes)"),
+            ("client_count", "Clients"),
+        ]
+        output_csv(aggregated, columns)
+    else:
+        from rich.table import Table
+
+        table = Table(title="Site DPI Statistics", show_header=True, header_style="bold cyan")
+        table.add_column("Application")
+        table.add_column("Download", justify="right")
+        table.add_column("Upload", justify="right")
+        table.add_column("Clients", justify="right")
+
+        total_rx = 0
+        total_tx = 0
+
+        for item in aggregated:
+            rx = item["rx_bytes"]
+            tx = item["tx_bytes"]
+            total_rx += rx
+            total_tx += tx
+
+            table.add_row(
+                item["name"],
+                format_bytes(rx),
+                format_bytes(tx),
+                str(item["client_count"]) if item["client_count"] > 0 else "-",
+            )
+
+        console.print(table)
+        console.print()
+        console.print(f"[dim]Total: {format_bytes(total_rx)} down, {format_bytes(total_tx)} up[/dim]")
+        console.print()
+
+
+@app.command("client")
+def client_dpi(
+    identifier: Annotated[str, typer.Argument(help="Client MAC address or name")],
+    output: Annotated[
+        OutputFormat,
+        typer.Option("--output", "-o", help="Output format"),
+    ] = OutputFormat.TABLE,
+    limit: Annotated[
+        int,
+        typer.Option("--limit", "-l", help="Limit number of results"),
+    ] = 15,
+) -> None:
+    """Show DPI statistics for a specific client."""
+
+    async def _dpi():
+        client = UniFiLocalClient()
+        dpi_enabled = await check_dpi_enabled(client)
+
+        # If not a MAC address, try to find by name
+        mac = identifier
+        if ":" not in identifier and "-" not in identifier:
+            # Search for client by name
+            clients = await client.list_clients()
+            all_clients = await client.list_all_clients()
+            all_clients.extend(clients)
+
+            found = None
+            for c in all_clients:
+                name = c.get("name", c.get("hostname", ""))
+                if name.lower() == identifier.lower():
+                    found = c
+                    break
+                if identifier.lower() in name.lower():
+                    found = c
+
+            if found:
+                mac = found.get("mac", identifier)
+            else:
+                return None, identifier, dpi_enabled
+
+        dpi_data = await client.get_client_dpi(mac)
+        return dpi_data, mac, dpi_enabled
+
+    try:
+        dpi_data, mac, dpi_enabled = run_with_spinner(_dpi(), "Fetching client DPI...")
+    except LocalAPIError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+    if dpi_data is None:
+        print_error(f"Client '{identifier}' not found")
+        raise typer.Exit(1)
+
+    # Aggregate the data
+    aggregated = aggregate_dpi_data(dpi_data)[:limit] if dpi_data else []
+
+    if not aggregated:
+        if not dpi_enabled:
+            print_warning("DPI is not enabled on this controller")
+            console.print("[dim]Enable Traffic Identification in Network Settings to use DPI.[/dim]")
+        else:
+            console.print(f"[dim]No DPI data collected for {mac}.[/dim]")
+        return
+
+    if output == OutputFormat.JSON:
+        output_json(aggregated)
+    elif output == OutputFormat.CSV:
+        columns = [
+            ("name", "Application"),
+            ("rx_bytes", "Download (bytes)"),
+            ("tx_bytes", "Upload (bytes)"),
+        ]
+        output_csv(aggregated, columns)
+    else:
+        from rich.table import Table
+
+        console.print()
+        console.print(f"[bold cyan]DPI Statistics: {mac}[/bold cyan]")
+        console.print("─" * 40)
+        console.print()
+
+        table = Table(show_header=True, header_style="bold")
+        table.add_column("Application")
+        table.add_column("Download", justify="right")
+        table.add_column("Upload", justify="right")
+
+        total_rx = 0
+        total_tx = 0
+
+        for item in aggregated:
+            rx = item["rx_bytes"]
+            tx = item["tx_bytes"]
+            total_rx += rx
+            total_tx += tx
+
+            table.add_row(
+                item["name"],
+                format_bytes(rx),
+                format_bytes(tx),
+            )
+
+        console.print(table)
+        console.print()
+        console.print(f"[dim]Total: {format_bytes(total_rx)} down, {format_bytes(total_tx)} up[/dim]")
+        console.print()

ui_cli/commands/local/events.py

@@ -0,0 +1,289 @@
+"""Events and alarms commands for local controller."""
+
+import asyncio
+from datetime import datetime, timezone
+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,
+    output_table,
+    print_error,
+    print_success,
+)
+
+app = typer.Typer(name="events", help="Events and alarms management", no_args_is_help=True)
+alarms_app = typer.Typer(name="alarms", help="Alarm management", no_args_is_help=True)
+app.add_typer(alarms_app, name="alarms")
+
+
+def format_timestamp(ts: int | None) -> str:
+    """Format Unix timestamp to readable string."""
+    if not ts:
+        return ""
+    try:
+        dt = datetime.fromtimestamp(ts / 1000, tz=timezone.utc)
+        return dt.strftime("%Y-%m-%d %H:%M:%S")
+    except (ValueError, OSError):
+        return str(ts)
+
+
+def format_event_message(event: dict[str, Any]) -> str:
+    """Format event into human-readable message."""
+    key = event.get("key", "")
+    msg = event.get("msg", "")
+
+    # If there's a direct message, use it
+    if msg:
+        return msg
+
+    # Build message from event data
+    parts = []
+
+    # Client events
+    if "user" in event or "client" in event:
+        client_name = event.get("user", event.get("client", ""))
+        if client_name:
+            parts.append(client_name)
+
+    # Network/SSID
+    if "ssid" in event:
+        parts.append(f"on {event['ssid']}")
+
+    # AP name
+    if "ap_name" in event:
+        parts.append(f"via {event['ap_name']}")
+
+    # Device events
+    if "sw_name" in event:
+        parts.append(event["sw_name"])
+    elif "gw_name" in event:
+        parts.append(event["gw_name"])
+
+    if parts:
+        return " ".join(parts)
+
+    # Fallback to key
+    return key.replace("EVT_", "").replace("_", " ").title()
+
+
+def get_event_type(event: dict[str, Any]) -> str:
+    """Extract event type from event key."""
+    key = event.get("key", "unknown")
+    # Remove EVT_ prefix and clean up
+    if key.startswith("EVT_"):
+        key = key[4:]
+    return key.lower()
+
+
+def get_alarm_severity(alarm: dict[str, Any]) -> tuple[str, str]:
+    """Get severity display and style for alarm."""
+    # Check for severity hints in the alarm
+    key = alarm.get("key", "").lower()
+
+    if any(x in key for x in ["critical", "disconnect", "lost", "down", "offline"]):
+        return "critical", "red"
+    elif any(x in key for x in ["warning", "rogue", "radar", "high"]):
+        return "warning", "yellow"
+    else:
+        return "info", "cyan"
+
+
+# ========== Events Commands ==========
+
+@app.command("list")
+def list_events(
+    limit: Annotated[
+        int,
+        typer.Option("--limit", "-l", help="Number of events to retrieve"),
+    ] = 50,
+    event_type: Annotated[
+        str | None,
+        typer.Option("--type", "-t", help="Filter by event type"),
+    ] = None,
+    output: Annotated[
+        OutputFormat,
+        typer.Option("--output", "-o", help="Output format"),
+    ] = OutputFormat.TABLE,
+) -> None:
+    """List recent events."""
+    from ui_cli.commands.local.utils import run_with_spinner
+
+    async def _list():
+        client = UniFiLocalClient()
+        return await client.get_events(limit=limit)
+
+    try:
+        events = run_with_spinner(_list(), "Fetching events...")
+    except LocalAPIError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+    if not events:
+        console.print("[dim]No events found[/dim]")
+        return
+
+    # Filter by type if specified
+    if event_type:
+        event_type_lower = event_type.lower()
+        events = [e for e in events if event_type_lower in get_event_type(e)]
+
+    if output == OutputFormat.JSON:
+        output_json(events)
+    elif output == OutputFormat.CSV:
+        columns = [
+            ("time", "Time"),
+            ("key", "Type"),
+            ("msg", "Message"),
+        ]
+        # Transform for CSV
+        csv_data = []
+        for e in events:
+            csv_data.append({
+                "time": format_timestamp(e.get("time")),
+                "key": get_event_type(e),
+                "msg": format_event_message(e),
+            })
+        output_csv(csv_data, columns)
+    else:
+        from rich.table import Table
+
+        table = Table(title="Recent Events", show_header=True, header_style="bold cyan")
+        table.add_column("Time", style="dim")
+        table.add_column("Type")
+        table.add_column("Message")
+
+        for event in events:
+            time_str = format_timestamp(event.get("time"))
+            evt_type = get_event_type(event)
+            message = format_event_message(event)
+            table.add_row(time_str, evt_type, message)
+
+        console.print(table)
+        console.print(f"\n[dim]{len(events)} event(s)[/dim]")
+
+
+# ========== Alarms Commands ==========
+
+@alarms_app.command("list")
+def list_alarms(
+    include_archived: Annotated[
+        bool,
+        typer.Option("--all", "-a", help="Include archived alarms"),
+    ] = False,
+    output: Annotated[
+        OutputFormat,
+        typer.Option("--output", "-o", help="Output format"),
+    ] = OutputFormat.TABLE,
+) -> None:
+    """List alarms."""
+    from ui_cli.commands.local.utils import run_with_spinner
+
+    async def _list():
+        client = UniFiLocalClient()
+        return await client.get_alarms(archived=include_archived)
+
+    try:
+        alarms = run_with_spinner(_list(), "Fetching alarms...")
+    except LocalAPIError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+    if not alarms:
+        console.print("[green]No active alarms[/green]")
+        return
+
+    if output == OutputFormat.JSON:
+        output_json(alarms)
+    elif output == OutputFormat.CSV:
+        columns = [
+            ("_id", "ID"),
+            ("time", "Time"),
+            ("key", "Type"),
+            ("msg", "Message"),
+            ("archived", "Archived"),
+        ]
+        csv_data = []
+        for a in alarms:
+            csv_data.append({
+                "_id": a.get("_id", ""),
+                "time": format_timestamp(a.get("time")),
+                "key": get_event_type(a),
+                "msg": format_event_message(a),
+                "archived": "Yes" if a.get("archived") else "No",
+            })
+        output_csv(csv_data, columns)
+    else:
+        from rich.table import Table
+
+        title = "All Alarms" if include_archived else "Active Alarms"
+        table = Table(title=title, show_header=True, header_style="bold cyan")
+        table.add_column("ID", style="dim")
+        table.add_column("Time", style="dim")
+        table.add_column("Severity")
+        table.add_column("Message")
+        if include_archived:
+            table.add_column("Status")
+
+        for alarm in alarms:
+            alarm_id = alarm.get("_id", "")
+            time_str = format_timestamp(alarm.get("time"))
+            severity, style = get_alarm_severity(alarm)
+            message = format_event_message(alarm)
+
+            severity_display = f"[{style}]{severity}[/{style}]"
+
+            if include_archived:
+                status = "[dim]archived[/dim]" if alarm.get("archived") else "[green]active[/green]"
+                table.add_row(alarm_id, time_str, severity_display, message, status)
+            else:
+                table.add_row(alarm_id, time_str, severity_display, message)
+
+        console.print(table)
+
+        active_count = sum(1 for a in alarms if not a.get("archived"))
+        if include_archived:
+            archived_count = sum(1 for a in alarms if a.get("archived"))
+            console.print(f"\n[dim]{active_count} active, {archived_count} archived[/dim]")
+        else:
+            console.print(f"\n[dim]{active_count} active alarm(s)[/dim]")
+
+
+@alarms_app.command("archive")
+def archive_alarm(
+    alarm_id: Annotated[str, typer.Argument(help="Alarm ID to archive")],
+    yes: Annotated[
+        bool,
+        typer.Option("--yes", "-y", help="Skip confirmation"),
+    ] = False,
+) -> None:
+    """Archive an alarm."""
+
+    if not yes:
+        confirm = typer.confirm(f"Archive alarm {alarm_id}?")
+        if not confirm:
+            console.print("[dim]Cancelled[/dim]")
+            raise typer.Exit(0)
+
+    from ui_cli.commands.local.utils import run_with_spinner
+
+    async def _archive():
+        client = UniFiLocalClient()
+        return await client.archive_alarm(alarm_id)
+
+    try:
+        success = run_with_spinner(_archive(), "Archiving alarm...")
+    except LocalAPIError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+    if success:
+        print_success(f"Alarm {alarm_id} archived")
+    else:
+        print_error(f"Failed to archive alarm {alarm_id}")
+        raise typer.Exit(1)