iflow-mcp_enuno-unifi-mcp-server 0.2.1__py3-none-any.whl

src/models/traffic_matching_list.py

@@ -0,0 +1,56 @@
+"""Traffic Matching List data models."""
+
+from enum import Enum
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class TrafficMatchingListType(str, Enum):
+    """Traffic matching list types."""
+
+    PORTS = "PORTS"
+    IPV4_ADDRESSES = "IPV4_ADDRESSES"
+    IPV6_ADDRESSES = "IPV6_ADDRESSES"
+
+
+class TrafficMatchingList(BaseModel):
+    """UniFi Traffic Matching List configuration."""
+
+    id: str = Field(..., description="Traffic matching list ID", alias="_id")
+    type: TrafficMatchingListType = Field(..., description="List type")
+    name: str = Field(..., description="List name")
+    items: list[str] = Field(default_factory=list, description="List items (ports, IPs, etc.)")
+    site_id: str | None = Field(None, description="Site ID")
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        json_schema_extra={
+            "example": {
+                "_id": "507f191e810c19729de860ea",
+                "type": "PORTS",
+                "name": "Common Web Ports",
+                "items": ["80", "443", "8080", "8443"],
+            }
+        },
+    )
+
+
+class TrafficMatchingListCreate(BaseModel):
+    """Request model for creating traffic matching list."""
+
+    type: TrafficMatchingListType = Field(..., description="List type")
+    name: str = Field(..., description="List name", min_length=1, max_length=128)
+    items: list[str] = Field(..., description="List items (non-empty)", min_length=1)
+
+    model_config = ConfigDict(use_enum_values=True)
+
+
+class TrafficMatchingListUpdate(BaseModel):
+    """Request model for updating traffic matching list."""
+
+    type: TrafficMatchingListType | None = Field(None, description="List type")
+    name: str | None = Field(None, description="List name", min_length=1, max_length=128)
+    items: list[str] | None = Field(None, description="List items", min_length=1)
+
+    model_config = ConfigDict(use_enum_values=True)

src/models/voucher.py

@@ -0,0 +1,42 @@
+"""Hotspot voucher models."""
+
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class Voucher(BaseModel):
+    """Hotspot voucher model."""
+
+    id: str = Field(..., alias="_id", description="Voucher identifier")
+    site_id: str = Field(..., description="Site identifier")
+    code: str = Field(..., description="Voucher code")
+
+    # Usage status
+    status: str = Field(..., description="Voucher status (unused/used/expired)")
+    used: int = Field(0, description="Number of times used")
+    quota: int = Field(1, description="Number of times voucher can be used")
+
+    # Time configuration
+    duration: int = Field(..., description="Duration in seconds")
+    start_time: datetime | None = Field(None, description="When voucher was first used")
+    end_time: datetime | None = Field(None, description="When voucher expires")
+    create_time: datetime = Field(..., description="When voucher was created")
+
+    # Bandwidth limits
+    upload_limit_kbps: int | None = Field(
+        None, alias="qos_rate_max_up", description="Upload speed limit in kbps"
+    )
+    download_limit_kbps: int | None = Field(
+        None, alias="qos_rate_max_down", description="Download speed limit in kbps"
+    )
+    upload_quota_mb: int | None = Field(
+        None, alias="qos_usage_quota", description="Upload quota in MB"
+    )
+    download_quota_mb: int | None = Field(None, description="Download quota in MB")
+
+    # Additional metadata
+    note: str | None = Field(None, description="Admin notes")
+    admin_name: str | None = Field(None, description="Admin who created voucher")
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")

src/models/vpn.py

@@ -0,0 +1,73 @@
+"""VPN data models."""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class SiteToSiteVPN(BaseModel):
+    """UniFi Site-to-Site IPsec VPN configuration."""
+
+    id: str = Field(..., description="VPN ID", alias="_id")
+    name: str = Field(..., description="VPN name")
+    enabled: bool = Field(True, description="Whether VPN is enabled")
+    vpn_type: str = Field("ipsec-vpn", description="VPN type")
+    purpose: str = Field("site-vpn", description="Network purpose")
+
+    # IPsec peer settings
+    ipsec_peer_ip: str | None = Field(None, description="Remote peer IP address")
+    ipsec_local_ip: str | None = Field(None, description="Local WAN IP address")
+    remote_vpn_subnets: list[str] | None = Field(None, description="Remote subnets")
+    x_ipsec_pre_shared_key: str | None = Field(None, description="Pre-shared key")
+
+    # IKE settings
+    ipsec_key_exchange: str | None = Field(None, description="IKE version (ikev1/ikev2)")
+    ipsec_ike_encryption: str | None = Field(None, description="IKE encryption")
+    ipsec_ike_hash: str | None = Field(None, description="IKE hash algorithm")
+    ipsec_ike_dh_group: int | None = Field(None, description="IKE DH group")
+    ipsec_ike_lifetime: int | None = Field(None, description="IKE lifetime in seconds")
+
+    # ESP settings
+    ipsec_esp_encryption: str | None = Field(None, description="ESP encryption")
+    ipsec_esp_hash: str | None = Field(None, description="ESP hash algorithm")
+    ipsec_esp_dh_group: int | None = Field(None, description="ESP DH group")
+    ipsec_esp_lifetime: int | None = Field(None, description="ESP lifetime in seconds")
+    ipsec_pfs: bool | None = Field(None, description="Perfect Forward Secrecy")
+
+    # Other settings
+    ipsec_profile: str | None = Field(None, description="IPsec profile")
+    ipsec_interface: str | None = Field(None, description="WAN interface")
+    ipsec_dynamic_routing: bool | None = Field(None, description="Dynamic routing enabled")
+    route_distance: int | None = Field(None, description="Route distance/metric")
+    site_id: str | None = Field(None, description="Site ID")
+
+    model_config = ConfigDict(populate_by_name=True)
+
+
+class VPNTunnel(BaseModel):
+    """UniFi Site-to-Site VPN Tunnel."""
+
+    id: str = Field(..., description="VPN tunnel ID", alias="_id")
+    name: str = Field(..., description="Tunnel name")
+    enabled: bool | None = Field(None, description="Whether tunnel is enabled")
+    peer_address: str | None = Field(None, description="Remote peer address")
+    local_network: str | None = Field(None, description="Local network CIDR")
+    remote_network: str | None = Field(None, description="Remote network CIDR")
+    status: str | None = Field(None, description="Connection status")
+    ipsec_profile: str | None = Field(None, description="IPSec profile name")
+    site_id: str | None = Field(None, description="Site ID")
+
+    model_config = ConfigDict(populate_by_name=True)
+
+
+class VPNServer(BaseModel):
+    """UniFi VPN Server configuration."""
+
+    id: str = Field(..., description="VPN server ID", alias="_id")
+    name: str = Field(..., description="Server name")
+    enabled: bool | None = Field(None, description="Whether server is enabled")
+    server_type: str | None = Field(None, description="VPN type (L2TP, PPTP, etc.)")
+    network: str | None = Field(None, description="VPN client network")
+    dns_servers: list[str] | None = Field(None, description="DNS servers for clients")
+    max_connections: int | None = Field(None, description="Maximum concurrent connections")
+    site_id: str | None = Field(None, description="Site ID")
+
+    model_config = ConfigDict(populate_by_name=True)

src/models/wan.py

@@ -0,0 +1,48 @@
+"""WAN connection models."""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class WANConnection(BaseModel):
+    """WAN connection model."""
+
+    id: str = Field(..., alias="_id", description="WAN connection identifier")
+    site_id: str = Field(..., description="Site identifier")
+    name: str = Field(..., description="WAN connection name")
+
+    # Connection type
+    wan_type: str = Field(..., description="WAN type (dhcp/static/pppoe)")
+    interface: str = Field(..., description="Physical interface (eth0/eth1/etc)")
+
+    # IP configuration
+    ip_address: str | None = Field(None, description="WAN IP address")
+    netmask: str | None = Field(None, description="Subnet mask")
+    gateway: str | None = Field(None, description="Gateway IP")
+    dns_servers: list[str] = Field(default_factory=list, description="DNS server IPs")
+
+    # Connection status
+    status: str = Field(..., description="Connection status (online/offline/connecting)")
+    uptime: int | None = Field(None, description="Connection uptime in seconds")
+
+    # Statistics
+    rx_bytes: int | None = Field(None, description="Received bytes")
+    tx_bytes: int | None = Field(None, description="Transmitted bytes")
+    rx_packets: int | None = Field(None, description="Received packets")
+    tx_packets: int | None = Field(None, description="Transmitted packets")
+    rx_errors: int | None = Field(None, description="Receive errors")
+    tx_errors: int | None = Field(None, description="Transmit errors")
+
+    # Speed and link
+    speed: int | None = Field(None, description="Link speed in Mbps")
+    full_duplex: bool | None = Field(None, description="Full duplex status")
+
+    # Failover configuration
+    failover_priority: int | None = Field(
+        None, description="Failover priority (lower = higher priority)"
+    )
+    is_backup: bool = Field(False, description="Whether this is a backup WAN")
+
+    # ISP information
+    isp_name: str | None = Field(None, description="ISP name")
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")

src/models/zbf_matrix.py

@@ -0,0 +1,49 @@
+"""Zone-Based Firewall matrix models."""
+
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+class ZonePolicy(BaseModel):
+    """Policy between two zones."""
+
+    source_zone_id: str = Field(..., description="Source zone identifier")
+    destination_zone_id: str = Field(..., description="Destination zone identifier")
+    action: Literal["allow", "deny"] = Field(..., description="Policy action")
+    description: str | None = Field(None, description="Policy description")
+    priority: int | None = Field(None, description="Policy priority")
+    enabled: bool = Field(True, description="Whether policy is enabled")
+
+
+class ApplicationBlockRule(BaseModel):
+    """Application blocking rule for a zone."""
+
+    zone_id: str = Field(..., description="Zone identifier")
+    application_id: str = Field(..., description="DPI application identifier")
+    application_name: str | None = Field(None, description="Application name")
+    action: Literal["block", "allow"] = Field(..., description="Block or allow action")
+    enabled: bool = Field(True, description="Whether rule is enabled")
+    description: str | None = Field(None, description="Rule description")
+
+
+class ZonePolicyMatrix(BaseModel):
+    """Matrix of zone-to-zone policies."""
+
+    site_id: str = Field(..., description="Site identifier")
+    zones: list[str] = Field(..., description="List of zone IDs in the matrix")
+    policies: list[ZonePolicy] = Field(
+        default_factory=list, description="List of inter-zone policies"
+    )
+    default_policy: Literal["allow", "deny"] = Field(
+        "allow", description="Default policy for unconfigured zone pairs"
+    )
+
+
+class ZoneNetworkAssignment(BaseModel):
+    """Network assignment to a zone."""
+
+    zone_id: str = Field(..., description="Zone identifier")
+    network_id: str = Field(..., description="Network identifier")
+    network_name: str | None = Field(None, description="Network name")
+    assigned_at: str | None = Field(None, description="ISO timestamp of assignment")

src/resources/__init__.py

@@ -0,0 +1,8 @@
+"""MCP resources for UniFi MCP Server."""
+
+from .clients import ClientsResource
+from .devices import DevicesResource
+from .networks import NetworksResource
+from .sites import SitesResource
+
+__all__ = ["SitesResource", "DevicesResource", "ClientsResource", "NetworksResource"]

src/resources/clients.py

@@ -0,0 +1,111 @@
+"""Clients MCP resource implementation."""
+
+from ..api import UniFiClient
+from ..config import Settings
+from ..models import Client
+from ..utils import get_logger, validate_limit_offset, validate_site_id
+
+
+class ClientsResource:
+    """MCP resource for UniFi network clients."""
+
+    def __init__(self, settings: Settings) -> None:
+        """Initialize clients resource.
+
+        Args:
+            settings: Application settings
+        """
+        self.settings = settings
+        self.logger = get_logger(__name__, settings.log_level)
+
+    async def list_clients(
+        self,
+        site_id: str,
+        limit: int | None = None,
+        offset: int | None = None,
+        active_only: bool = False,
+    ) -> list[Client]:
+        """List all clients for a specific site.
+
+        Args:
+            site_id: Site identifier
+            limit: Maximum number of clients to return
+            offset: Number of clients to skip
+            active_only: If True, only return currently connected clients
+
+        Returns:
+            List of Client objects
+        """
+        site_id = validate_site_id(site_id)
+        limit, offset = validate_limit_offset(limit, offset)
+
+        async with UniFiClient(self.settings) as client:
+            await client.authenticate()
+
+            # Fetch clients from API
+            # Use /sta for active clients or /stat/alluser for all
+            endpoint = (
+                f"/ea/sites/{site_id}/sta" if active_only else f"/ea/sites/{site_id}/stat/alluser"
+            )
+
+            response = await client.get(endpoint)
+
+            # Extract clients data
+            clients_data = response.get("data", [])
+
+            # Apply pagination
+            paginated_data = clients_data[offset : offset + limit]
+
+            # Parse into Client models
+            clients = [Client(**client_data) for client_data in paginated_data]
+
+            self.logger.info(
+                f"Retrieved {len(clients)} clients for site '{site_id}' "
+                f"(active_only={active_only}, offset={offset}, limit={limit})"
+            )
+
+            return clients
+
+    async def filter_by_connection(
+        self,
+        site_id: str,
+        is_wired: bool | None = None,
+        limit: int | None = None,
+        offset: int | None = None,
+    ) -> list[Client]:
+        """Filter clients by connection type.
+
+        Args:
+            site_id: Site identifier
+            is_wired: Filter by wired (True) or wireless (False)
+            limit: Maximum number of clients to return
+            offset: Number of clients to skip
+
+        Returns:
+            Filtered list of Client objects
+        """
+        clients = await self.list_clients(site_id, limit=1000, offset=0, active_only=True)
+
+        # Filter by connection type
+        if is_wired is not None:
+            filtered = [c for c in clients if c.is_wired == is_wired]
+        else:
+            filtered = clients
+
+        # Apply pagination to filtered results
+        limit, offset = validate_limit_offset(limit, offset)
+        return filtered[offset : offset + limit]
+
+    def get_uri(self, site_id: str, client_mac: str | None = None) -> str:
+        """Get the MCP resource URI.
+
+        Args:
+            site_id: Site identifier
+            client_mac: Optional client MAC address
+
+        Returns:
+            Resource URI
+        """
+        if client_mac:
+            return f"sites://{site_id}/clients/{client_mac}"
+        return f"sites://{site_id}/clients"

src/resources/devices.py

@@ -0,0 +1,102 @@
+"""Devices MCP resource implementation."""
+
+from ..api import UniFiClient
+from ..config import Settings
+from ..models import Device
+from ..utils import get_logger, validate_limit_offset, validate_site_id
+
+
+class DevicesResource:
+    """MCP resource for UniFi devices."""
+
+    def __init__(self, settings: Settings) -> None:
+        """Initialize devices resource.
+
+        Args:
+            settings: Application settings
+        """
+        self.settings = settings
+        self.logger = get_logger(__name__, settings.log_level)
+
+    async def list_devices(
+        self, site_id: str, limit: int | None = None, offset: int | None = None
+    ) -> list[Device]:
+        """List all devices for a specific site.
+
+        Args:
+            site_id: Site identifier
+            limit: Maximum number of devices to return
+            offset: Number of devices to skip
+
+        Returns:
+            List of Device objects
+        """
+        site_id = validate_site_id(site_id)
+        limit, offset = validate_limit_offset(limit, offset)
+
+        async with UniFiClient(self.settings) as client:
+            await client.authenticate()
+
+            # Fetch devices from API
+            response = await client.get(f"/ea/sites/{site_id}/devices")
+
+            # Extract devices data
+            devices_data = response.get("data", [])
+
+            # Apply pagination
+            paginated_data = devices_data[offset : offset + limit]
+
+            # Parse into Device models
+            devices = [Device(**device) for device in paginated_data]
+
+            self.logger.info(
+                f"Retrieved {len(devices)} devices for site '{site_id}' "
+                f"(offset={offset}, limit={limit})"
+            )
+
+            return devices
+
+    async def filter_by_type(
+        self,
+        site_id: str,
+        device_type: str,
+        limit: int | None = None,
+        offset: int | None = None,
+    ) -> list[Device]:
+        """Filter devices by type.
+
+        Args:
+            site_id: Site identifier
+            device_type: Device type filter (ap, switch, gateway)
+            limit: Maximum number of devices to return
+            offset: Number of devices to skip
+
+        Returns:
+            Filtered list of Device objects
+        """
+        devices = await self.list_devices(site_id, limit=1000, offset=0)
+
+        # Filter by type
+        filtered = [
+            d
+            for d in devices
+            if d.type.lower() == device_type.lower() or device_type.lower() in d.model.lower()
+        ]
+
+        # Apply pagination to filtered results
+        limit, offset = validate_limit_offset(limit, offset)
+        return filtered[offset : offset + limit]
+
+    def get_uri(self, site_id: str, device_id: str | None = None) -> str:
+        """Get the MCP resource URI.
+
+        Args:
+            site_id: Site identifier
+            device_id: Optional device ID
+
+        Returns:
+            Resource URI
+        """
+        if device_id:
+            return f"sites://{site_id}/devices/{device_id}"
+        return f"sites://{site_id}/devices"

src/resources/networks.py

@@ -0,0 +1,93 @@
+"""Networks MCP resource implementation."""
+
+from ..api import UniFiClient
+from ..config import Settings
+from ..models import Network
+from ..utils import get_logger, validate_limit_offset, validate_site_id
+
+
+class NetworksResource:
+    """MCP resource for UniFi networks."""
+
+    def __init__(self, settings: Settings) -> None:
+        """Initialize networks resource.
+
+        Args:
+            settings: Application settings
+        """
+        self.settings = settings
+        self.logger = get_logger(__name__, settings.log_level)
+
+    async def list_networks(
+        self, site_id: str, limit: int | None = None, offset: int | None = None
+    ) -> list[Network]:
+        """List all networks for a specific site.
+
+        Args:
+            site_id: Site identifier
+            limit: Maximum number of networks to return
+            offset: Number of networks to skip
+
+        Returns:
+            List of Network objects
+        """
+        site_id = validate_site_id(site_id)
+        limit, offset = validate_limit_offset(limit, offset)
+
+        async with UniFiClient(self.settings) as client:
+            await client.authenticate()
+
+            # Fetch networks from API
+            response = await client.get(f"/ea/sites/{site_id}/rest/networkconf")
+
+            # Extract networks data
+            networks_data = response.get("data", [])
+
+            # Apply pagination
+            paginated_data = networks_data[offset : offset + limit]
+
+            # Parse into Network models
+            networks = [Network(**network) for network in paginated_data]
+
+            self.logger.info(
+                f"Retrieved {len(networks)} networks for site '{site_id}' "
+                f"(offset={offset}, limit={limit})"
+            )
+
+            return networks
+
+    async def list_vlans(
+        self, site_id: str, limit: int | None = None, offset: int | None = None
+    ) -> list[Network]:
+        """List all VLANs for a specific site.
+
+        Args:
+            site_id: Site identifier
+            limit: Maximum number of VLANs to return
+            offset: Number of VLANs to skip
+
+        Returns:
+            List of Network objects that are VLANs
+        """
+        networks = await self.list_networks(site_id, limit=1000, offset=0)
+
+        # Filter for networks with VLAN configuration
+        vlans = [n for n in networks if n.vlan_id is not None]
+
+        # Apply pagination to filtered results
+        limit, offset = validate_limit_offset(limit, offset)
+        return vlans[offset : offset + limit]
+
+    def get_uri(self, site_id: str, network_id: str | None = None) -> str:
+        """Get the MCP resource URI.
+
+        Args:
+            site_id: Site identifier
+            network_id: Optional network ID
+
+        Returns:
+            Resource URI
+        """
+        if network_id:
+            return f"sites://{site_id}/networks/{network_id}"
+        return f"sites://{site_id}/networks"

src/resources/site_manager.py

@@ -0,0 +1,64 @@
+"""Site Manager API resources."""
+
+from ..api.site_manager_client import SiteManagerClient
+from ..config import Settings
+from ..utils import get_logger
+
+logger = get_logger(__name__)
+
+
+class SiteManagerResource:
+    """Resource handler for Site Manager API."""
+
+    def __init__(self, settings: Settings) -> None:
+        """Initialize Site Manager resource handler.
+
+        Args:
+            settings: Application settings
+        """
+        self.settings = settings
+        self.logger = get_logger(__name__, settings.log_level)
+
+    async def get_all_sites(self) -> str:
+        """Get all sites across organization.
+
+        Returns:
+            JSON string of sites list
+        """
+        if not self.settings.site_manager_enabled:
+            return "Site Manager API is not enabled. Set UNIFI_SITE_MANAGER_ENABLED=true"
+
+        async with SiteManagerClient(self.settings) as client:
+            response = await client.list_sites()
+            sites = response.get("data", response.get("sites", []))
+            return "\n".join(
+                [f"Site: {s.get('name', 'Unknown')} ({s.get('id', 'unknown')})" for s in sites]
+            )
+
+    async def get_health_metrics(self) -> str:
+        """Get cross-site health metrics.
+
+        Returns:
+            JSON string of health metrics
+        """
+        if not self.settings.site_manager_enabled:
+            return "Site Manager API is not enabled. Set UNIFI_SITE_MANAGER_ENABLED=true"
+
+        async with SiteManagerClient(self.settings) as client:
+            response = await client.get_site_health()
+            health_data = response.get("data", response)
+            return f"Health Status: {health_data}"
+
+    async def get_internet_health_status(self) -> str:
+        """Get internet connectivity status.
+
+        Returns:
+            JSON string of internet health
+        """
+        if not self.settings.site_manager_enabled:
+            return "Site Manager API is not enabled. Set UNIFI_SITE_MANAGER_ENABLED=true"
+
+        async with SiteManagerClient(self.settings) as client:
+            response = await client.get_internet_health()
+            health_data = response.get("data", response)
+            return f"Internet Health: {health_data}"