ui-cli 1.2.1__py3-none-any.whl

ui_cli/commands/status.py

@@ -0,0 +1,410 @@
+"""Status command - check API connectivity and authentication."""
+
+import asyncio
+import time
+from typing import Annotated
+
+import httpx
+import typer
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from ui_cli import __version__
+from ui_cli.config import settings
+from ui_cli.local_client import (
+    LocalAPIError,
+    LocalAuthenticationError,
+    LocalConnectionError,
+    UniFiLocalClient,
+)
+from ui_cli.output import OutputFormat, console, output_json
+
+# Timeout for status checks (seconds)
+STATUS_CHECK_TIMEOUT = 10
+
+
+app = typer.Typer(help="Check API connectivity and authentication status")
+
+
+def mask_api_key(key: str, show_full: bool = False) -> str:
+    """Mask API key for display."""
+    if not key:
+        return "(not configured)"
+    if show_full:
+        return key
+    if len(key) <= 8:
+        return "****"
+    return f"****...{key[-6:]}"
+
+
+async def check_site_manager_api(verbose: bool = False) -> dict:
+    """Check Site Manager API connectivity and auth."""
+    result = {
+        "name": "Site Manager API",
+        "url": settings.api_url,
+        "api_key_configured": bool(settings.api_key),
+        "api_key_display": mask_api_key(settings.api_key, show_full=verbose),
+        "connection": None,
+        "connection_time_ms": None,
+        "authentication": None,
+        "error": None,
+        "hosts_count": None,
+        "sites_count": None,
+        "devices_count": None,
+    }
+
+    if not settings.api_key:
+        result["error"] = "Set UNIFI_API_KEY in .env file"
+        return result
+
+    headers = {
+        "X-API-Key": settings.api_key,
+        "Accept": "application/json",
+    }
+
+    try:
+        async with httpx.AsyncClient(timeout=STATUS_CHECK_TIMEOUT) as client:
+            # Test connection and auth with hosts endpoint
+            start = time.perf_counter()
+            response = await client.get(
+                f"{settings.api_url}/hosts",
+                headers=headers,
+            )
+            elapsed_ms = (time.perf_counter() - start) * 1000
+
+            result["connection"] = "OK"
+            result["connection_time_ms"] = round(elapsed_ms, 1)
+
+            if response.status_code == 200:
+                result["authentication"] = "Valid"
+                data = response.json()
+                hosts = data.get("data", [])
+                result["hosts_count"] = len(hosts)
+
+                # Get sites count
+                sites_resp = await client.get(
+                    f"{settings.api_url}/sites",
+                    headers=headers,
+                )
+                if sites_resp.status_code == 200:
+                    sites_data = sites_resp.json()
+                    result["sites_count"] = len(sites_data.get("data", []))
+
+                # Get devices count
+                devices_resp = await client.get(
+                    f"{settings.api_url}/devices",
+                    headers=headers,
+                )
+                if devices_resp.status_code == 200:
+                    devices_data = devices_resp.json()
+                    # Flatten devices from host groups
+                    total_devices = 0
+                    for host_group in devices_data.get("data", []):
+                        total_devices += len(host_group.get("devices", []))
+                    result["devices_count"] = total_devices
+
+            elif response.status_code == 401:
+                result["authentication"] = "FAILED"
+                result["error"] = "Invalid API key"
+            elif response.status_code == 429:
+                result["authentication"] = "Valid"
+                result["error"] = "Rate limit exceeded"
+            else:
+                result["authentication"] = "FAILED"
+                result["error"] = f"HTTP {response.status_code}"
+
+    except httpx.ConnectError:
+        result["connection"] = "FAILED"
+        result["error"] = "Could not connect to api.ui.com"
+    except httpx.TimeoutException:
+        result["connection"] = "FAILED"
+        result["error"] = "Connection timeout"
+    except Exception as e:
+        result["connection"] = "FAILED"
+        result["error"] = str(e)
+
+    return result
+
+
+async def check_local_controller(verbose: bool = False) -> dict:
+    """Check Local Controller connectivity and auth."""
+    # Determine auth method for display
+    if settings.controller_api_key:
+        auth_method = "API Key"
+    elif settings.controller_username:
+        auth_method = "Username/Password"
+    else:
+        auth_method = "(not configured)"
+
+    result = {
+        "name": "Local Controller",
+        "url": settings.controller_url or "(not configured)",
+        "username": settings.controller_username or "(not configured)",
+        "site": settings.controller_site or "default",
+        "configured": settings.is_local_configured,
+        "auth_method": auth_method,
+        "connection": None,
+        "connection_time_ms": None,
+        "authentication": None,
+        "error": None,
+        "controller_type": None,
+        "clients_count": None,
+        "devices_count": None,
+    }
+
+    if not settings.controller_url:
+        result["error"] = "Set UNIFI_CONTROLLER_URL in .env file"
+        return result
+
+    if not settings.is_local_configured:
+        result["error"] = (
+            "Set UNIFI_CONTROLLER_API_KEY or "
+            "UNIFI_CONTROLLER_USERNAME/UNIFI_CONTROLLER_PASSWORD in .env file"
+        )
+        return result
+
+    try:
+        client = UniFiLocalClient(timeout=STATUS_CHECK_TIMEOUT)
+        start = time.perf_counter()
+        if settings.controller_api_key:
+            # API key mode: no session handshake needed — use a lightweight request
+            await client.get_health()
+        else:
+            await client.login()
+        elapsed_ms = (time.perf_counter() - start) * 1000
+
+        result["connection"] = "OK"
+        result["connection_time_ms"] = round(elapsed_ms, 1)
+        result["authentication"] = "Valid"
+        result["controller_type"] = "UDM" if client._is_udm else "Cloud Key/Self-hosted"
+
+        # Get counts
+        try:
+            clients = await client.list_clients()
+            result["clients_count"] = len(clients)
+        except LocalAPIError:
+            pass
+
+        try:
+            devices = await client.get_devices()
+            result["devices_count"] = len(devices)
+        except LocalAPIError:
+            pass
+
+    except LocalAuthenticationError as e:
+        result["connection"] = "OK"
+        result["authentication"] = "FAILED"
+        result["error"] = str(e)
+    except LocalConnectionError as e:
+        result["connection"] = "FAILED"
+        result["error"] = str(e)
+    except Exception as e:
+        result["connection"] = "FAILED"
+        result["error"] = str(e)
+
+    return result
+
+
+def print_status_table(cloud_status: dict, local_status: dict | None = None) -> None:
+    """Print status in formatted table."""
+    from rich.table import Table
+
+    console.print()
+    console.print(f"[bold cyan]UniFi CLI v{__version__}[/bold cyan]")
+    console.print("─" * 40)
+    console.print()
+
+    # Site Manager API section
+    console.print("[bold]Site Manager API[/bold] (api.ui.com)")
+
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column("Key", style="dim")
+    table.add_column("Value")
+
+    table.add_row("URL:", cloud_status["url"])
+
+    # API Key status
+    if cloud_status["api_key_configured"]:
+        table.add_row("API Key:", f"[green]{cloud_status['api_key_display']}[/green] (configured)")
+    else:
+        table.add_row("API Key:", f"[red]{cloud_status['api_key_display']}[/red]")
+
+    # Connection status
+    if cloud_status["connection"] == "OK":
+        table.add_row(
+            "Connection:",
+            f"[green]OK[/green] ({cloud_status['connection_time_ms']}ms)"
+        )
+    elif cloud_status["connection"] == "FAILED":
+        table.add_row("Connection:", "[red]FAILED[/red]")
+    else:
+        table.add_row("Connection:", "[dim]-[/dim]")
+
+    # Authentication status
+    if cloud_status["authentication"] == "Valid":
+        table.add_row("Authentication:", "[green]Valid[/green]")
+    elif cloud_status["authentication"] == "FAILED":
+        table.add_row("Authentication:", "[red]FAILED[/red]")
+    else:
+        table.add_row("Authentication:", "[dim]-[/dim]")
+
+    console.print(table)
+
+    # Error message
+    if cloud_status["error"]:
+        console.print()
+        console.print(f"  [red]Error:[/red] {cloud_status['error']}")
+
+    # Account info (if authenticated)
+    if cloud_status["authentication"] == "Valid" and cloud_status["hosts_count"] is not None:
+        console.print()
+        console.print("[bold]Account Summary:[/bold]")
+
+        info_table = Table(show_header=False, box=None, padding=(0, 2))
+        info_table.add_column("Key", style="dim")
+        info_table.add_column("Value")
+
+        info_table.add_row("Hosts:", str(cloud_status["hosts_count"]))
+        info_table.add_row("Sites:", str(cloud_status["sites_count"]))
+        info_table.add_row("Devices:", str(cloud_status["devices_count"]))
+
+        console.print(info_table)
+
+    # Local Controller section
+    if local_status:
+        console.print()
+        console.print("[bold]Local Controller[/bold]")
+
+        local_table = Table(show_header=False, box=None, padding=(0, 2))
+        local_table.add_column("Key", style="dim")
+        local_table.add_column("Value")
+
+        local_table.add_row("URL:", local_status["url"])
+        local_table.add_row("Site:", local_status["site"])
+
+        if local_status["configured"]:
+            local_table.add_row("Username:", f"[green]{local_status['username']}[/green]")
+        else:
+            local_table.add_row("Username:", f"[red]{local_status['username']}[/red]")
+
+        # Connection status
+        if local_status["connection"] == "OK":
+            local_table.add_row(
+                "Connection:",
+                f"[green]OK[/green] ({local_status['connection_time_ms']}ms)"
+            )
+        elif local_status["connection"] == "FAILED":
+            local_table.add_row("Connection:", "[red]FAILED[/red]")
+        else:
+            local_table.add_row("Connection:", "[dim]-[/dim]")
+
+        # Authentication status
+        if local_status["authentication"] == "Valid":
+            local_table.add_row("Authentication:", "[green]Valid[/green]")
+        elif local_status["authentication"] == "FAILED":
+            local_table.add_row("Authentication:", "[red]FAILED[/red]")
+        else:
+            local_table.add_row("Authentication:", "[dim]-[/dim]")
+
+        # Controller type
+        if local_status["controller_type"]:
+            local_table.add_row("Type:", local_status["controller_type"])
+
+        console.print(local_table)
+
+        # Error message
+        if local_status["error"]:
+            console.print()
+            console.print(f"  [red]Error:[/red] {local_status['error']}")
+
+        # Controller info (if authenticated)
+        if local_status["authentication"] == "Valid":
+            console.print()
+            console.print("[bold]Controller Summary:[/bold]")
+
+            ctrl_table = Table(show_header=False, box=None, padding=(0, 2))
+            ctrl_table.add_column("Key", style="dim")
+            ctrl_table.add_column("Value")
+
+            if local_status["clients_count"] is not None:
+                ctrl_table.add_row("Clients:", str(local_status["clients_count"]))
+            if local_status["devices_count"] is not None:
+                ctrl_table.add_row("Devices:", str(local_status["devices_count"]))
+
+            console.print(ctrl_table)
+
+    console.print()
+
+
+async def check_all_status(verbose: bool = False) -> tuple[dict, dict]:
+    """Check both Cloud API and Local Controller status."""
+    cloud_status = await check_site_manager_api(verbose=verbose)
+    local_status = await check_local_controller(verbose=verbose)
+    return cloud_status, local_status
+
+
+async def check_with_spinner(verbose: bool = False) -> tuple[dict, dict]:
+    """Check both APIs with progress spinner."""
+    cloud_status = None
+    local_status = None
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[cyan]{task.description}"),
+        console=console,
+        transient=True,
+    ) as progress:
+        # Check Cloud API
+        task = progress.add_task("Checking Cloud API...", total=None)
+        cloud_status = await check_site_manager_api(verbose=verbose)
+        progress.remove_task(task)
+
+        # Check Local Controller
+        if settings.controller_url:
+            task = progress.add_task("Checking Local Controller...", total=None)
+            local_status = await check_local_controller(verbose=verbose)
+            progress.remove_task(task)
+        else:
+            local_status = await check_local_controller(verbose=verbose)
+
+    return cloud_status, local_status
+
+
+@app.callback(invoke_without_command=True)
+def status(
+    ctx: typer.Context,
+    output: Annotated[
+        OutputFormat,
+        typer.Option(
+            "--output",
+            "-o",
+            help="Output format: table or json",
+        ),
+    ] = OutputFormat.TABLE,
+    verbose: Annotated[
+        bool,
+        typer.Option(
+            "--verbose",
+            "-v",
+            help="Show detailed information including full API key",
+        ),
+    ] = False,
+) -> None:
+    """Check API connectivity and authentication status."""
+
+    # Run async checks with spinner
+    cloud_status, local_status = asyncio.run(check_with_spinner(verbose=verbose))
+
+    if output == OutputFormat.JSON:
+        result = {
+            "cloud_api": cloud_status,
+            "local_controller": local_status,
+        }
+        output_json(result, verbose=verbose)
+    else:
+        print_status_table(cloud_status, local_status)
+
+    # Exit with error code if neither is authenticated
+    cloud_ok = cloud_status["authentication"] == "Valid"
+    local_ok = local_status["authentication"] == "Valid"
+    if not cloud_ok and not local_ok:
+        raise typer.Exit(1)

ui_cli/commands/version.py

@@ -0,0 +1,13 @@
+"""Version command - display CLI version."""
+
+import typer
+
+from ui_cli import __version__
+
+app = typer.Typer(help="Display CLI version")
+
+
+@app.callback(invoke_without_command=True)
+def version() -> None:
+    """Display the CLI version."""
+    typer.echo(f"ui-cli version {__version__}")

ui_cli/config.py

@@ -0,0 +1,106 @@
+"""Configuration management using pydantic-settings."""
+
+import os
+from pathlib import Path
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+def _get_config_files() -> tuple[str, ...]:
+    """Get config files in priority order (first found wins).
+
+    Priority:
+      1. XDG config (~/.config/ui-cli/config)
+      2. Home dotfile (~/.ui-cli.env)
+      3. Project local (.env)
+    """
+    xdg_config = os.environ.get("XDG_CONFIG_HOME", str(Path.home() / ".config"))
+    candidates = [
+        Path(xdg_config) / "ui-cli" / "config",
+        Path.home() / ".ui-cli.env",
+        Path(".env"),
+    ]
+    # Return all existing files (pydantic-settings will use first match per variable)
+    return tuple(str(p) for p in candidates if p.exists())
+
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables."""
+
+    model_config = SettingsConfigDict(
+        env_prefix="UNIFI_",
+        env_file=_get_config_files(),
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    # Site Manager API (cloud)
+    api_key: str = Field(
+        default="",
+        description="UniFi API key for authentication",
+    )
+    api_url: str = Field(
+        default="https://api.ui.com/v1",
+        description="UniFi API base URL",
+    )
+    timeout: int = Field(
+        default=15,
+        description="Request timeout in seconds",
+    )
+
+    # Local Controller API
+    controller_url: str = Field(
+        default="",
+        description="Local controller URL (e.g., https://192.168.1.1)",
+    )
+    controller_username: str = Field(
+        default="",
+        description="Local controller username",
+    )
+    controller_password: str = Field(
+        default="",
+        description="Local controller password",
+    )
+    controller_api_key: str = Field(
+        default="",
+        description="Local controller API key (UniFi OS Dashboard → Settings → Admins → API Keys). Env: UNIFI_CONTROLLER_API_KEY",
+    )
+    controller_site: str = Field(
+        default="default",
+        description="Site name for local controller",
+    )
+    controller_verify_ssl: bool = Field(
+        default=False,
+        description="Verify SSL certificates (disable for self-signed)",
+    )
+
+    @property
+    def is_configured(self) -> bool:
+        """Check if Site Manager API key is configured."""
+        return bool(self.api_key)
+
+    @property
+    def is_local_configured(self) -> bool:
+        """Check if local controller is configured.
+
+        Accepts either:
+        - controller_url + controller_api_key (API key auth, UniFi OS >= 5.0.3)
+        - controller_url + controller_username + controller_password (legacy auth)
+        """
+        if not self.controller_url:
+            return False
+        if self.controller_api_key:
+            return True
+        return bool(self.controller_username and self.controller_password)
+
+    @property
+    def session_file(self) -> Path:
+        """Path to session storage file."""
+        config_dir = Path.home() / ".config" / "ui-cli"
+        config_dir.mkdir(parents=True, exist_ok=True)
+        return config_dir / "session.json"
+
+
+# Global settings instance
+settings = Settings()