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

src/models/__init__.py

@@ -0,0 +1,126 @@
+"""Data models for UniFi MCP Server."""
+
+from .acl import ACLRule
+from .backup import (
+    BackupMetadata,
+    BackupOperation,
+    BackupSchedule,
+    BackupStatus,
+    BackupType,
+    BackupValidationResult,
+    RestoreOperation,
+    RestoreStatus,
+)
+from .client import Client
+from .device import Device
+from .dpi import Country, DPIApplication, DPICategory
+from .firewall_policy import (
+    ConnectionStateType,
+    FirewallPolicy,
+    FirewallPolicyCreate,
+    FirewallPolicyUpdate,
+    IPVersion,
+    MatchingTarget,
+    MatchTarget,
+    PolicyAction,
+    Schedule,
+)
+from .firewall_zone import FirewallZone
+from .network import Network
+from .qos_profile import (
+    DSCPValue,
+    MatchCriteria,
+    ProAVProtocol,
+    ProAVTemplate,
+    QoSAction,
+    QoSPriority,
+    QoSProfile,
+    QueueAlgorithm,
+    RouteAction,
+    RouteSchedule,
+    SmartQueueConfig,
+    TrafficRoute,
+)
+from .radius import RADIUSProfile
+from .reference_data import DeviceTag
+from .site import Site
+from .site_manager import (
+    CrossSiteStatistics,
+    InternetHealthMetrics,
+    SiteHealthSummary,
+    VantagePoint,
+)
+from .traffic_flow import FlowRisk, FlowStatistics, FlowView, TrafficFlow
+from .traffic_matching_list import (
+    TrafficMatchingList,
+    TrafficMatchingListCreate,
+    TrafficMatchingListType,
+    TrafficMatchingListUpdate,
+)
+from .voucher import Voucher
+from .vpn import VPNServer, VPNTunnel
+from .wan import WANConnection
+from .zbf_matrix import ApplicationBlockRule, ZoneNetworkAssignment, ZonePolicy, ZonePolicyMatrix
+
+__all__ = [
+    "Site",
+    "Device",
+    "Client",
+    "Network",
+    "ACLRule",
+    "Voucher",
+    "FirewallZone",
+    "FirewallPolicy",
+    "FirewallPolicyCreate",
+    "FirewallPolicyUpdate",
+    "PolicyAction",
+    "MatchingTarget",
+    "ConnectionStateType",
+    "IPVersion",
+    "MatchTarget",
+    "Schedule",
+    "WANConnection",
+    "DPICategory",
+    "DPIApplication",
+    "Country",
+    "ZonePolicyMatrix",
+    "ZonePolicy",
+    "ApplicationBlockRule",
+    "ZoneNetworkAssignment",
+    "TrafficFlow",
+    "FlowStatistics",
+    "FlowRisk",
+    "FlowView",
+    "TrafficMatchingList",
+    "TrafficMatchingListCreate",
+    "TrafficMatchingListUpdate",
+    "TrafficMatchingListType",
+    "VPNTunnel",
+    "VPNServer",
+    "RADIUSProfile",
+    "DeviceTag",
+    "SiteHealthSummary",
+    "InternetHealthMetrics",
+    "CrossSiteStatistics",
+    "VantagePoint",
+    "BackupMetadata",
+    "BackupOperation",
+    "BackupSchedule",
+    "BackupStatus",
+    "BackupType",
+    "BackupValidationResult",
+    "RestoreOperation",
+    "RestoreStatus",
+    "QoSProfile",
+    "QoSPriority",
+    "DSCPValue",
+    "QoSAction",
+    "RouteAction",
+    "QueueAlgorithm",
+    "ProAVProtocol",
+    "ProAVTemplate",
+    "MatchCriteria",
+    "RouteSchedule",
+    "TrafficRoute",
+    "SmartQueueConfig",
+]

src/models/acl.py

@@ -0,0 +1,41 @@
+"""Access Control List (ACL) models."""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ACLRule(BaseModel):
+    """ACL rule model."""
+
+    id: str = Field(..., alias="_id", description="ACL rule identifier")
+    site_id: str = Field(..., description="Site identifier")
+    name: str = Field(..., description="Rule name")
+    enabled: bool = Field(True, description="Whether the rule is enabled")
+    action: str = Field(..., description="Action to take (allow/deny)")
+
+    # Source configuration
+    source_type: str | None = Field(None, description="Source type (network/device/ip/any)")
+    source_id: str | None = Field(None, description="Source identifier")
+    source_network: str | None = Field(None, description="Source network CIDR")
+
+    # Destination configuration
+    destination_type: str | None = Field(
+        None, description="Destination type (network/ip/port/dpi-category/dpi-app)"
+    )
+    destination_id: str | None = Field(None, description="Destination identifier")
+    destination_network: str | None = Field(None, description="Destination network CIDR")
+
+    # Protocol and ports
+    protocol: str | None = Field(None, description="Protocol (tcp/udp/icmp/all)")
+    src_port: int | None = Field(None, description="Source port")
+    dst_port: int | None = Field(None, description="Destination port")
+
+    # Priority and metadata
+    priority: int = Field(100, description="Rule priority (lower = higher priority)")
+    description: str | None = Field(None, description="Rule description")
+    rule_index: int | None = Field(None, description="Rule index in the list")
+
+    # Statistics
+    byte_count: int | None = Field(None, description="Bytes matched by this rule")
+    packet_count: int | None = Field(None, description="Packets matched by this rule")
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")

src/models/backup.py

@@ -0,0 +1,272 @@
+"""Backup and restore data models."""
+
+from datetime import datetime
+from enum import Enum
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class BackupType(str, Enum):
+    """Backup type enumeration."""
+
+    SYSTEM = "SYSTEM"  # Complete OS, application, and device configurations
+    NETWORK = "NETWORK"  # Network settings and device configurations only
+
+
+class BackupStatus(str, Enum):
+    """Backup operation status."""
+
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+class RestoreStatus(str, Enum):
+    """Restore operation status."""
+
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    ROLLED_BACK = "rolled_back"
+
+
+class BackupMetadata(BaseModel):
+    """Backup file metadata and information."""
+
+    backup_id: str = Field(..., description="Unique backup identifier")
+    filename: str = Field(..., description="Backup filename (e.g., backup_2025-01-29.unf)")
+    backup_type: BackupType = Field(..., description="Type of backup (SYSTEM or NETWORK)")
+    created_at: datetime = Field(..., description="Backup creation timestamp")
+    size_bytes: int | None = Field(None, description="Backup file size in bytes")
+    version: str | None = Field(None, description="UniFi Network version at backup time")
+
+    # Metadata about backup contents
+    device_count: int | None = Field(None, description="Number of devices in backup")
+    site_count: int | None = Field(None, description="Number of sites in backup")
+    network_count: int | None = Field(None, description="Number of networks in backup")
+
+    # Cloud backup status
+    cloud_synced: bool = Field(False, description="Whether backup is synced to cloud")
+    cloud_sync_time: datetime | None = Field(None, description="Last cloud sync timestamp")
+
+    # Backup location
+    download_url: str | None = Field(None, description="Download URL for backup file")
+    local_path: str | None = Field(None, description="Local filesystem path (if applicable)")
+
+    # Validation
+    checksum: str | None = Field(None, description="Backup file checksum (MD5 or SHA256)")
+    is_valid: bool = Field(True, description="Whether backup passed validation checks")
+    validation_message: str | None = Field(None, description="Validation error message if any")
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        json_schema_extra={
+            "example": {
+                "backup_id": "backup_20250129_123456",
+                "filename": "backup_2025-01-29_12-34-56.unf",
+                "backup_type": "NETWORK",
+                "created_at": "2025-01-29T12:34:56Z",
+                "size_bytes": 1048576,
+                "version": "10.0.160",
+                "device_count": 15,
+                "site_count": 1,
+                "network_count": 5,
+                "cloud_synced": True,
+                "is_valid": True,
+            }
+        },
+    )
+
+
+class BackupOperation(BaseModel):
+    """Backup operation status and details."""
+
+    operation_id: str = Field(..., description="Unique operation identifier")
+    backup_type: BackupType = Field(..., description="Type of backup being created")
+    status: BackupStatus = Field(..., description="Current operation status")
+    started_at: datetime = Field(..., description="Operation start time")
+    completed_at: datetime | None = Field(None, description="Operation completion time")
+
+    # Progress tracking
+    progress_percent: int = Field(0, ge=0, le=100, description="Progress percentage (0-100)")
+    current_step: str | None = Field(None, description="Current operation step description")
+
+    # Result
+    backup_metadata: BackupMetadata | None = Field(None, description="Metadata of created backup")
+    error_message: str | None = Field(None, description="Error message if failed")
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        json_schema_extra={
+            "example": {
+                "operation_id": "op_backup_abc123",
+                "backup_type": "NETWORK",
+                "status": "completed",
+                "started_at": "2025-01-29T12:34:00Z",
+                "completed_at": "2025-01-29T12:35:30Z",
+                "progress_percent": 100,
+                "current_step": "Finalizing backup",
+            }
+        },
+    )
+
+
+class RestoreOperation(BaseModel):
+    """Restore operation status and details."""
+
+    operation_id: str = Field(..., description="Unique operation identifier")
+    backup_id: str = Field(..., description="Backup being restored")
+    status: RestoreStatus = Field(..., description="Current operation status")
+    started_at: datetime = Field(..., description="Operation start time")
+    completed_at: datetime | None = Field(None, description="Operation completion time")
+
+    # Progress tracking
+    progress_percent: int = Field(0, ge=0, le=100, description="Progress percentage (0-100)")
+    current_step: str | None = Field(None, description="Current operation step description")
+
+    # Safety features
+    pre_restore_backup_id: str | None = Field(
+        None,
+        description="Backup ID of automatic pre-restore backup (for rollback)",
+    )
+    can_rollback: bool = Field(False, description="Whether rollback is available")
+
+    # Result
+    error_message: str | None = Field(None, description="Error message if failed")
+    rollback_reason: str | None = Field(None, description="Reason for rollback if applicable")
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        json_schema_extra={
+            "example": {
+                "operation_id": "op_restore_xyz789",
+                "backup_id": "backup_20250129_123456",
+                "status": "in_progress",
+                "started_at": "2025-01-29T14:00:00Z",
+                "progress_percent": 45,
+                "current_step": "Restoring device configurations",
+                "pre_restore_backup_id": "backup_20250129_140000_preRestore",
+                "can_rollback": True,
+            }
+        },
+    )
+
+
+class BackupSchedule(BaseModel):
+    """Automated backup schedule configuration."""
+
+    schedule_id: str = Field(..., description="Unique schedule identifier")
+    enabled: bool = Field(True, description="Whether schedule is enabled")
+    backup_type: BackupType = Field(..., description="Type of backup to create")
+
+    # Schedule configuration
+    frequency: Literal["daily", "weekly", "monthly"] = Field(
+        ...,
+        description="Backup frequency",
+    )
+    time_of_day: str = Field(
+        ...,
+        description="Time to run backup (HH:MM format, 24-hour)",
+        pattern=r"^([01]\d|2[0-3]):([0-5]\d)$",
+    )
+    day_of_week: int | None = Field(
+        None,
+        ge=0,
+        le=6,
+        description="Day of week for weekly backups (0=Monday, 6=Sunday)",
+    )
+    day_of_month: int | None = Field(
+        None,
+        ge=1,
+        le=31,
+        description="Day of month for monthly backups",
+    )
+
+    # Retention policy
+    retention_days: int = Field(
+        30,
+        ge=1,
+        le=365,
+        description="Number of days to retain backups",
+    )
+    max_backups: int = Field(
+        10,
+        ge=1,
+        le=100,
+        description="Maximum number of backups to keep",
+    )
+
+    # Cloud backup
+    cloud_backup_enabled: bool = Field(
+        False,
+        description="Whether to sync backups to cloud",
+    )
+
+    # Last run info
+    last_run: datetime | None = Field(None, description="Last execution timestamp")
+    last_backup_id: str | None = Field(None, description="Last created backup ID")
+    next_run: datetime | None = Field(None, description="Next scheduled execution")
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        json_schema_extra={
+            "example": {
+                "schedule_id": "schedule_daily_network",
+                "enabled": True,
+                "backup_type": "NETWORK",
+                "frequency": "daily",
+                "time_of_day": "03:00",
+                "retention_days": 30,
+                "max_backups": 10,
+                "cloud_backup_enabled": True,
+                "last_run": "2025-01-29T03:00:00Z",
+                "next_run": "2025-01-30T03:00:00Z",
+            }
+        },
+    )
+
+
+class BackupValidationResult(BaseModel):
+    """Result of backup file validation."""
+
+    backup_id: str = Field(..., description="Backup being validated")
+    is_valid: bool = Field(..., description="Whether backup is valid")
+
+    # Validation checks
+    checksum_valid: bool = Field(..., description="File integrity check passed")
+    format_valid: bool = Field(..., description="File format is correct")
+    version_compatible: bool = Field(..., description="Version is compatible with current system")
+
+    # Validation details
+    backup_version: str | None = Field(None, description="UniFi version of backup")
+    current_version: str | None = Field(None, description="Current UniFi version")
+    warnings: list[str] = Field(default_factory=list, description="Validation warnings")
+    errors: list[str] = Field(default_factory=list, description="Validation errors")
+
+    # Backup contents preview
+    contains_devices: int | None = Field(None, description="Number of devices in backup")
+    contains_networks: int | None = Field(None, description="Number of networks in backup")
+    contains_sites: int | None = Field(None, description="Number of sites in backup")
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        json_schema_extra={
+            "example": {
+                "backup_id": "backup_20250129_123456",
+                "is_valid": True,
+                "checksum_valid": True,
+                "format_valid": True,
+                "version_compatible": True,
+                "backup_version": "10.0.160",
+                "current_version": "10.0.160",
+                "warnings": [],
+                "errors": [],
+                "contains_devices": 15,
+                "contains_networks": 5,
+                "contains_sites": 1,
+            }
+        },
+    )

src/models/client.py

@@ -0,0 +1,74 @@
+"""Client data model."""
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+
+class Client(BaseModel):
+    """UniFi network client information."""
+
+    mac: str = Field(..., description="Client MAC address")
+    ip: str | None = Field(None, description="Client IP address")
+    hostname: str | None = Field(None, description="Client hostname")
+    name: str | None = Field(None, description="Client name (user-assigned)")
+
+    # Connection info
+    is_wired: bool | None = Field(None, description="Whether client is wired")
+    is_guest: bool | None = Field(None, description="Whether client is on guest network")
+    essid: str | None = Field(None, description="SSID name (for wireless clients)")
+    channel: int | None = Field(None, description="WiFi channel (for wireless clients)")
+    radio: str | None = Field(None, description="Radio type (ng, na, etc.)")
+
+    # Signal strength (wireless only)
+    signal: int | None = Field(None, description="Signal strength in dBm")
+    rssi: int | None = Field(None, description="RSSI value")
+    noise: int | None = Field(None, description="Noise level in dBm")
+
+    # Network statistics
+    tx_bytes: int | None = Field(None, description="Transmitted bytes")
+    rx_bytes: int | None = Field(None, description="Received bytes")
+    tx_packets: int | None = Field(None, description="Transmitted packets")
+    rx_packets: int | None = Field(None, description="Received packets")
+    tx_rate: int | None = Field(None, description="Transmission rate in Kbps")
+    rx_rate: int | None = Field(None, description="Receiving rate in Kbps")
+
+    # Session info
+    uptime: int | None = Field(None, description="Session uptime in seconds")
+    last_seen: int | None = Field(None, description="Last seen timestamp")
+    first_seen: int | None = Field(None, description="First seen timestamp")
+
+    # Device info
+    oui: str | None = Field(None, description="MAC OUI manufacturer")
+    os_class: int | None = Field(None, description="Operating system class")
+    os_name: str | None = Field(None, description="Operating system name")
+
+    # Associated device
+    ap_mac: str | None = Field(None, description="Access point MAC address")
+    sw_mac: str | None = Field(None, description="Switch MAC address")
+    gw_mac: str | None = Field(None, description="Gateway MAC address")
+
+    # VLAN
+    vlan: int | None = Field(None, description="VLAN ID")
+    network: str | None = Field(None, description="Network name")
+
+    @field_validator("os_name", mode="before")
+    @classmethod
+    def coerce_os_name_to_str(cls, v: int | str | None) -> str | None:
+        """Convert os_name from int to str if needed (local API returns int)."""
+        if v is None:
+            return None
+        return str(v)
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        json_schema_extra={
+            "example": {
+                "mac": "aa:bb:cc:dd:ee:01",
+                "ip": "192.168.1.100",
+                "hostname": "laptop-001",
+                "is_wired": False,
+                "signal": -45,
+                "tx_bytes": 1024000,
+                "rx_bytes": 2048000,
+            }
+        },
+    )

src/models/device.py

@@ -0,0 +1,53 @@
+"""Device data model."""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class Device(BaseModel):
+    """UniFi network device information."""
+
+    id: str = Field(..., description="Device ID", alias="_id")
+    name: str | None = Field(None, description="Device name")
+    model: str = Field(..., description="Device model")
+    type: str = Field(..., description="Device type (uap, usw, ugw, etc.)")
+    mac: str = Field(..., description="Device MAC address")
+    ip: str | None = Field(None, description="Device IP address")
+
+    # Status fields
+    state: int = Field(..., description="Device state (0=offline, 1=online, etc.)")
+    adopted: bool | None = Field(None, description="Whether device is adopted")
+    disabled: bool | None = Field(None, description="Whether device is disabled")
+
+    # Hardware info
+    version: str | None = Field(None, description="Firmware version")
+    uptime: int | None = Field(None, description="Uptime in seconds")
+
+    # Performance metrics
+    cpu: float | None = Field(None, description="CPU usage percentage")
+    mem: float | None = Field(None, description="Memory usage percentage")
+    uplink_depth: int | None = Field(None, description="Uplink depth in network topology")
+
+    # Network stats
+    bytes: int | None = Field(None, description="Total bytes transferred")
+    tx_bytes: int | None = Field(None, description="Transmitted bytes")
+    rx_bytes: int | None = Field(None, description="Received bytes")
+
+    # Additional metadata
+    serial: str | None = Field(None, description="Device serial number")
+    license_state: str | None = Field(None, description="License state")
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        json_schema_extra={
+            "example": {
+                "_id": "507f1f77bcf86cd799439011",
+                "name": "AP-Office",
+                "model": "U6-LR",
+                "type": "uap",
+                "mac": "aa:bb:cc:dd:ee:ff",
+                "ip": "192.168.1.10",
+                "state": 1,
+                "uptime": 86400,
+            }
+        },
+    )

src/models/dpi.py

@@ -0,0 +1,50 @@
+"""Deep Packet Inspection (DPI) models."""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class DPICategory(BaseModel):
+    """DPI category model."""
+
+    id: str = Field(..., alias="_id", description="Category identifier")
+    name: str = Field(..., description="Category name")
+    description: str | None = Field(None, description="Category description")
+
+    # Application count
+    app_count: int | None = Field(None, description="Number of applications in this category")
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class DPIApplication(BaseModel):
+    """DPI application model."""
+
+    id: str = Field(..., alias="_id", description="Application identifier")
+    name: str = Field(..., description="Application name")
+    category_id: str = Field(..., description="Category identifier")
+    category_name: str | None = Field(None, description="Category name")
+
+    # Application metadata
+    enabled: bool = Field(True, description="Whether application detection is enabled")
+
+    # Traffic classification
+    protocols: list[str] = Field(
+        default_factory=list, description="Protocols used by this application"
+    )
+    ports: list[int] = Field(default_factory=list, description="Common ports used")
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class Country(BaseModel):
+    """Country information model."""
+
+    code: str = Field(..., description="ISO country code")
+    name: str = Field(..., description="Country name")
+    iso_code: str | None = Field(None, description="ISO 3166-1 alpha-2 code")
+    iso3_code: str | None = Field(None, description="ISO 3166-1 alpha-3 code")
+
+    # Regulatory information
+    regulatory_domain: str | None = Field(None, description="Regulatory domain for wireless")
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")