django-cfg 1.5.8__py3-none-any.whl → 1.5.20__py3-none-any.whl

django_cfg/apps/integrations/grpc/views/testing.py

@@ -85,8 +85,9 @@ class GRPCTestingViewSet(AdminAPIMixin, viewsets.GenericViewSet):
                 "total_examples": len(examples),
             }
 
-            serializer = GRPCExamplesListSerializer(**response_data)
-            return Response(serializer.model_dump())
+            serializer = GRPCExamplesListSerializer(data=response_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
 
         except Exception as e:
             logger.error(f"Examples fetch error: {e}", exc_info=True)
@@ -147,35 +148,33 @@ class GRPCTestingViewSet(AdminAPIMixin, viewsets.GenericViewSet):
                 # Serialize paginated data
                 logs_list = []
                 for log in page:
-                    log_serializer = GRPCTestLogSerializer(
-                        request_id=log.request_id,
-                        service=log.service_name,
-                        method=log.method_name,
-                        status=log.status,
-                        grpc_status_code=log.grpc_status_code or "",
-                        error_message=log.error_message or "",
-                        duration_ms=log.duration_ms or 0,
-                        created_at=log.created_at.isoformat(),
-                        user=log.user.username if log.user else None,
-                    )
-                    logs_list.append(log_serializer.model_dump())
+                    logs_list.append({
+                        "request_id": log.request_id,
+                        "service": log.service_name,
+                        "method": log.method_name,
+                        "status": log.status,
+                        "grpc_status_code": log.grpc_status_code or "",
+                        "error_message": log.error_message or "",
+                        "duration_ms": log.duration_ms or 0,
+                        "created_at": log.created_at.isoformat(),
+                        "user": log.user.username if log.user else None,
+                    })
                 return self.get_paginated_response(logs_list)
 
             # No pagination (shouldn't happen with default pagination)
             logs_list = []
             for log in queryset[:100]:  # Safety limit
-                log_serializer = GRPCTestLogSerializer(
-                    request_id=log.request_id,
-                    service=log.service_name,
-                    method=log.method_name,
-                    status=log.status,
-                    grpc_status_code=log.grpc_status_code or "",
-                    error_message=log.error_message or "",
-                    duration_ms=log.duration_ms or 0,
-                    created_at=log.created_at.isoformat(),
-                    user=log.user.username if log.user else None,
-                )
-                logs_list.append(log_serializer.model_dump())
+                logs_list.append({
+                    "request_id": log.request_id,
+                    "service": log.service_name,
+                    "method": log.method_name,
+                    "status": log.status,
+                    "grpc_status_code": log.grpc_status_code or "",
+                    "error_message": log.error_message or "",
+                    "duration_ms": log.duration_ms or 0,
+                    "created_at": log.created_at.isoformat(),
+                    "user": log.user.username if log.user else None,
+                })
             return Response({"logs": logs_list, "count": len(logs_list)})
 
         except Exception as e:
@@ -221,9 +220,10 @@ class GRPCTestingViewSet(AdminAPIMixin, viewsets.GenericViewSet):
         from django.utils import timezone
 
         try:
-            # Validate request - Pydantic validation
-            serializer = GRPCCallRequestSerializer(**request.data)
-            data = serializer.model_dump()
+            # Validate request - DRF validation
+            serializer = GRPCCallRequestSerializer(data=request.data)
+            serializer.is_valid(raise_exception=True)
+            data = serializer.validated_data
 
             service_name = data["service"]
             method_name = data["method"]
@@ -275,21 +275,23 @@ class GRPCTestingViewSet(AdminAPIMixin, viewsets.GenericViewSet):
             if response_data and isinstance(response_data, dict):
                 response_data = json.dumps(response_data)
 
-            response_serializer = GRPCCallResponseSerializer(
-                success=result["success"],
-                request_id=request_id,
-                service=result["service"],
-                method=result["method"],
-                status=log.status,
-                grpc_status_code=result["grpc_status_code"],
-                duration_ms=result["duration_ms"],
-                response=response_data,
-                error=result.get("error_message"),
-                metadata={},
-                timestamp=end_time.isoformat(),
-            )
+            response_data_dict = {
+                "success": result["success"],
+                "request_id": request_id,
+                "service": result["service"],
+                "method": result["method"],
+                "status": log.status,
+                "grpc_status_code": result["grpc_status_code"],
+                "duration_ms": result["duration_ms"],
+                "response": response_data,
+                "error": result.get("error_message"),
+                "metadata": {},
+                "timestamp": end_time.isoformat(),
+            }
 
-            return Response(response_serializer.model_dump(), status=status.HTTP_200_OK)
+            response_serializer = GRPCCallResponseSerializer(data=response_data_dict)
+            response_serializer.is_valid(raise_exception=True)
+            return Response(response_serializer.data, status=status.HTTP_200_OK)
 
         except Exception as e:
             logger.error(f"gRPC call endpoint error: {e}", exc_info=True)

django_cfg/apps/integrations/rq/views/jobs.py

@@ -19,7 +19,7 @@ from ..services import job_to_model
 logger = get_logger("rq.jobs")
 
 
-class JobViewSet(AdminAPIMixin, viewsets.ViewSet):
+class JobViewSet(AdminAPIMixin, viewsets.GenericViewSet):
     """
     ViewSet for RQ job management.
 
@@ -33,6 +33,8 @@ class JobViewSet(AdminAPIMixin, viewsets.ViewSet):
     Requires admin authentication (JWT, Session, or Basic Auth).
     """
 
+    serializer_class = JobListSerializer
+
     @extend_schema(
         tags=["RQ Jobs"],
         summary="List all jobs",
@@ -455,9 +457,11 @@ class JobViewSet(AdminAPIMixin, viewsets.ViewSet):
                 except Exception as e:
                     logger.debug(f"Failed to get failed jobs for queue {queue_name}: {e}")
 
-            serializer = JobListSerializer(data=all_jobs, many=True)
+            # Use DRF pagination
+            page = self.paginate_queryset(all_jobs)
+            serializer = JobListSerializer(data=page, many=True)
             serializer.is_valid(raise_exception=True)
-            return Response(serializer.data)
+            return self.get_paginated_response(serializer.data)
 
         except Exception as e:
             logger.error(f"Failed jobs list error: {e}", exc_info=True)
@@ -530,9 +534,11 @@ class JobViewSet(AdminAPIMixin, viewsets.ViewSet):
                 except Exception as e:
                     logger.debug(f"Failed to get finished jobs for queue {queue_name}: {e}")
 
-            serializer = JobListSerializer(data=all_jobs, many=True)
+            # Use DRF pagination
+            page = self.paginate_queryset(all_jobs)
+            serializer = JobListSerializer(data=page, many=True)
             serializer.is_valid(raise_exception=True)
-            return Response(serializer.data)
+            return self.get_paginated_response(serializer.data)
 
         except Exception as e:
             logger.error(f"Finished jobs list error: {e}", exc_info=True)
@@ -795,9 +801,11 @@ class JobViewSet(AdminAPIMixin, viewsets.ViewSet):
                 except Exception as e:
                     logger.debug(f"Failed to get deferred jobs for queue {queue_name}: {e}")
 
-            serializer = JobListSerializer(data=all_jobs, many=True)
+            # Use DRF pagination
+            page = self.paginate_queryset(all_jobs)
+            serializer = JobListSerializer(data=page, many=True)
             serializer.is_valid(raise_exception=True)
-            return Response(serializer.data)
+            return self.get_paginated_response(serializer.data)
 
         except Exception as e:
             logger.error(f"Deferred jobs list error: {e}", exc_info=True)
@@ -870,9 +878,11 @@ class JobViewSet(AdminAPIMixin, viewsets.ViewSet):
                 except Exception as e:
                     logger.debug(f"Failed to get started jobs for queue {queue_name}: {e}")
 
-            serializer = JobListSerializer(data=all_jobs, many=True)
+            # Use DRF pagination
+            page = self.paginate_queryset(all_jobs)
+            serializer = JobListSerializer(data=page, many=True)
             serializer.is_valid(raise_exception=True)
-            return Response(serializer.data)
+            return self.get_paginated_response(serializer.data)
 
         except Exception as e:
             logger.error(f"Started jobs list error: {e}", exc_info=True)

django_cfg/apps/integrations/rq/views/schedule.py

@@ -23,7 +23,7 @@ from ..serializers import (
 logger = get_logger("rq.schedule")
 
 
-class ScheduleViewSet(AdminAPIMixin, viewsets.ViewSet):
+class ScheduleViewSet(AdminAPIMixin, viewsets.GenericViewSet):
     """
     ViewSet for RQ schedule management.
 
@@ -37,6 +37,8 @@ class ScheduleViewSet(AdminAPIMixin, viewsets.ViewSet):
     Requires rq-scheduler to be installed: pip install rq-scheduler
     """
 
+    serializer_class = ScheduledJobSerializer
+
     @extend_schema(
         tags=["RQ Schedules"],
         summary="List scheduled jobs",
@@ -131,9 +133,11 @@ class ScheduleViewSet(AdminAPIMixin, viewsets.ViewSet):
                         }
                         all_jobs.append(job_data)
 
-            serializer = ScheduledJobSerializer(data=all_jobs, many=True)
+            # Use DRF pagination
+            page = self.paginate_queryset(all_jobs)
+            serializer = ScheduledJobSerializer(data=page, many=True)
             serializer.is_valid(raise_exception=True)
-            return Response(serializer.data)
+            return self.get_paginated_response(serializer.data)
 
         except Exception as e:
             logger.error(f"Failed to list scheduled jobs: {e}", exc_info=True)

django_cfg/apps/system/dashboard/serializers/commands.py

@@ -8,7 +8,14 @@ from rest_framework import serializers
 
 
 class CommandSerializer(serializers.Serializer):
-    """Django management command serializer."""
+    """
+    Django management command serializer.
+
+    Includes security metadata from base classes (SafeCommand, InteractiveCommand, etc.):
+    - web_executable: Can be executed via web interface
+    - requires_input: Requires interactive user input
+    - is_destructive: Modifies or deletes data
+    """
     name = serializers.CharField()
     app = serializers.CharField()
     help = serializers.CharField()
@@ -17,6 +24,23 @@ class CommandSerializer(serializers.Serializer):
     is_allowed = serializers.BooleanField(required=False)
     risk_level = serializers.CharField(required=False)
 
+    # Security metadata from command base classes
+    web_executable = serializers.BooleanField(
+        required=False,
+        allow_null=True,
+        help_text="Can be executed via web interface"
+    )
+    requires_input = serializers.BooleanField(
+        required=False,
+        allow_null=True,
+        help_text="Requires interactive user input"
+    )
+    is_destructive = serializers.BooleanField(
+        required=False,
+        allow_null=True,
+        help_text="Modifies or deletes data"
+    )
+
 
 class CommandsSummarySerializer(serializers.Serializer):
     """Commands summary serializer."""

django_cfg/apps/system/dashboard/serializers/config.py

@@ -5,6 +5,8 @@ Serializers for displaying user's DjangoConfig settings.
 """
 
 from rest_framework import serializers
+from drf_spectacular.utils import extend_schema_field
+from drf_spectacular.types import OpenApiTypes
 
 
 # Nested serializers for complex structures
@@ -89,6 +91,18 @@ class RedisQueueConfigSerializer(serializers.Serializer):
     socket_timeout = serializers.IntegerField(required=False, allow_null=True)
 
 
+class RQScheduleSerializer(serializers.Serializer):
+    """Redis Queue schedule configuration."""
+    func = serializers.CharField(required=False, allow_null=True)
+    cron_string = serializers.CharField(required=False, allow_null=True)
+    queue = serializers.CharField(required=False, allow_null=True)
+    kwargs = serializers.DictField(required=False, allow_null=True)
+    args = serializers.ListField(required=False, allow_null=True)
+    meta = serializers.DictField(required=False, allow_null=True)
+    repeat = serializers.IntegerField(required=False, allow_null=True)
+    result_ttl = serializers.IntegerField(required=False, allow_null=True)
+
+
 class DjangoRQConfigSerializer(serializers.Serializer):
     """Django-RQ configuration."""
     enabled = serializers.BooleanField(required=False, allow_null=True)
@@ -97,7 +111,7 @@ class DjangoRQConfigSerializer(serializers.Serializer):
     exception_handlers = serializers.ListField(required=False, allow_null=True)
     api_token = serializers.CharField(required=False, allow_null=True)
     prometheus_enabled = serializers.BooleanField(required=False, allow_null=True)
-    schedules = serializers.ListField(child=serializers.DictField(), required=False, allow_null=True)
+    schedules = serializers.ListField(child=RQScheduleSerializer(), required=False, allow_null=True)
 
 
 class DRFConfigSerializer(serializers.Serializer):
@@ -126,6 +140,78 @@ class ConfigMetaSerializer(serializers.Serializer):
     secret_key_configured = serializers.BooleanField()
 
 
+class TelegramConfigSerializer(serializers.Serializer):
+    """Telegram service configuration."""
+    bot_token = serializers.CharField(required=False, allow_null=True)
+    chat_id = serializers.IntegerField(required=False, allow_null=True)
+    parse_mode = serializers.CharField(required=False, allow_null=True)
+    disable_notification = serializers.BooleanField(required=False, allow_null=True)
+    disable_web_page_preview = serializers.BooleanField(required=False, allow_null=True)
+    timeout = serializers.IntegerField(required=False, allow_null=True)
+    webhook_url = serializers.CharField(required=False, allow_null=True)
+    webhook_secret = serializers.CharField(required=False, allow_null=True)
+    max_retries = serializers.IntegerField(required=False, allow_null=True)
+    retry_delay = serializers.FloatField(required=False, allow_null=True)
+
+
+class NgrokConfigSerializer(serializers.Serializer):
+    """Ngrok tunneling configuration."""
+    enabled = serializers.BooleanField(required=False, allow_null=True)
+    authtoken = serializers.CharField(required=False, allow_null=True)
+    basic_auth = serializers.ListField(required=False, allow_null=True)
+    compression = serializers.BooleanField(required=False, allow_null=True)
+
+
+class AxesConfigSerializer(serializers.Serializer):
+    """Django-Axes brute-force protection configuration."""
+    enabled = serializers.BooleanField(required=False, allow_null=True)
+    failure_limit = serializers.IntegerField(required=False, allow_null=True)
+    cooloff_time = serializers.IntegerField(required=False, allow_null=True)
+    lock_out_at_failure = serializers.BooleanField(required=False, allow_null=True)
+    reset_on_success = serializers.BooleanField(required=False, allow_null=True)
+    only_user_failures = serializers.BooleanField(required=False, allow_null=True)
+    lockout_template = serializers.CharField(required=False, allow_null=True)
+    lockout_url = serializers.CharField(required=False, allow_null=True)
+    verbose = serializers.BooleanField(required=False, allow_null=True)
+    enable_access_failure_log = serializers.BooleanField(required=False, allow_null=True)
+    ipware_proxy_count = serializers.IntegerField(required=False, allow_null=True)
+    ipware_meta_precedence_order = serializers.ListField(required=False, allow_null=True)
+    allowed_ips = serializers.ListField(required=False, allow_null=True)
+    denied_ips = serializers.ListField(required=False, allow_null=True)
+    cache_name = serializers.CharField(required=False, allow_null=True)
+    use_user_agent = serializers.BooleanField(required=False, allow_null=True)
+    username_form_field = serializers.CharField(required=False, allow_null=True)
+
+
+class NextJSAdminConfigSerializer(serializers.Serializer):
+    """Next.js Admin application configuration."""
+    enabled = serializers.BooleanField(required=False, allow_null=True)
+    url = serializers.CharField(required=False, allow_null=True)
+    api_base_url = serializers.CharField(required=False, allow_null=True)
+
+
+class ConstanceConfigSerializer(serializers.Serializer):
+    """Django-Constance dynamic settings configuration."""
+    config = serializers.DictField(required=False, allow_null=True)
+    config_fieldsets = serializers.DictField(required=False, allow_null=True)
+    backend = serializers.CharField(required=False, allow_null=True)
+    database_prefix = serializers.CharField(required=False, allow_null=True)
+    database_cache_backend = serializers.CharField(required=False, allow_null=True)
+    additional_config = serializers.DictField(required=False, allow_null=True)
+
+
+class OpenAPIClientConfigSerializer(serializers.Serializer):
+    """OpenAPI Client generation configuration."""
+    enabled = serializers.BooleanField(required=False, allow_null=True)
+    output_dir = serializers.CharField(required=False, allow_null=True)
+    client_name = serializers.CharField(required=False, allow_null=True)
+    schema_url = serializers.CharField(required=False, allow_null=True)
+    generator = serializers.CharField(required=False, allow_null=True)
+    additional_properties = serializers.DictField(required=False, allow_null=True)
+    templates = serializers.ListField(required=False, allow_null=True)
+    global_properties = serializers.DictField(required=False, allow_null=True)
+
+
 class DjangoConfigSerializer(serializers.Serializer):
     """
     Typed serializer for user's DjangoConfig settings.
@@ -188,10 +274,10 @@ class DjangoConfigSerializer(serializers.Serializer):
     spectacular = SpectacularConfigSerializer(required=False, allow_null=True)
     jwt = JWTConfigSerializer(required=False, allow_null=True)
 
-    # Other configs (pass-through for flexibility)
-    telegram = serializers.DictField(required=False, allow_null=True)
-    ngrok = serializers.DictField(required=False, allow_null=True)
-    axes = serializers.DictField(required=False, allow_null=True)
+    # Services & Security (now typed!)
+    telegram = TelegramConfigSerializer(required=False, allow_null=True)
+    ngrok = NgrokConfigSerializer(required=False, allow_null=True)
+    axes = AxesConfigSerializer(required=False, allow_null=True)
     crypto_fields = serializers.DictField(required=False, allow_null=True)
     unfold = serializers.CharField(required=False, allow_null=True)  # String representation of Unfold config
     tailwind_app_name = serializers.CharField(required=False, allow_null=True)
@@ -199,10 +285,10 @@ class DjangoConfigSerializer(serializers.Serializer):
     limits = serializers.DictField(required=False, allow_null=True)
     api_keys = serializers.DictField(required=False, allow_null=True)
     custom_middleware = serializers.ListField(required=False, allow_null=True)
-    nextjs_admin = serializers.DictField(required=False, allow_null=True)
+    nextjs_admin = NextJSAdminConfigSerializer(required=False, allow_null=True)
     admin_emails = serializers.ListField(required=False, allow_null=True)
-    constance = serializers.DictField(required=False, allow_null=True)
-    openapi_client = serializers.DictField(required=False, allow_null=True)
+    constance = ConstanceConfigSerializer(required=False, allow_null=True)
+    openapi_client = OpenAPIClientConfigSerializer(required=False, allow_null=True)
 
     # Metadata
     _meta = ConfigMetaSerializer(required=False, allow_null=True)
@@ -238,7 +324,7 @@ class ConfigDataSerializer(serializers.Serializer):
         help_text="User's DjangoConfig settings"
     )
     django_settings = serializers.DictField(
-        help_text="Complete Django settings (sanitized)"
+        help_text="Complete Django settings (sanitized, contains mixed types)"
     )
     _validation = ConfigValidationSerializer(
         help_text="Validation result comparing serializer with actual config"

django_cfg/apps/system/dashboard/serializers/statistics.py

@@ -36,11 +36,16 @@ class UserStatisticsSerializer(serializers.Serializer):
     superusers = serializers.IntegerField(help_text="Number of superusers")
 
 
+class AppStatisticsDataSerializer(serializers.Serializer):
+    """Serializer for application statistics data."""
+
+    name = serializers.CharField(help_text="Human-readable app name")
+    total_records = serializers.IntegerField(help_text="Total records count")
+    model_count = serializers.IntegerField(help_text="Number of models")
+
+
 class AppStatisticsSerializer(serializers.Serializer):
     """Serializer for application-specific statistics."""
 
     app_name = serializers.CharField(help_text="Application name")
-    statistics = serializers.DictField(
-        child=serializers.IntegerField(),
-        help_text="Application statistics"
-    )
+    statistics = AppStatisticsDataSerializer(help_text="Application statistics")

django_cfg/apps/system/dashboard/services/commands_service.py

@@ -55,7 +55,7 @@ class CommandsService:
                     continue
 
                 try:
-                    # Try to load command to get help text
+                    # Try to load command to get help text and metadata
                     command = load_command_class(app_name, command_name)
                     help_text = getattr(command, 'help', 'No description available')
 
@@ -66,6 +66,11 @@ class CommandsService:
                     # Get risk level
                     risk_level = get_command_risk_level(command_name, app_name)
 
+                    # Extract security metadata from command instance
+                    web_executable = getattr(command, 'web_executable', None)
+                    requires_input = getattr(command, 'requires_input', None)
+                    is_destructive = getattr(command, 'is_destructive', None)
+
                     commands_list.append({
                         'name': command_name,
                         'app': app_name,
@@ -74,6 +79,9 @@ class CommandsService:
                         'is_custom': is_custom,
                         'is_allowed': is_allowed,
                         'risk_level': risk_level,
+                        'web_executable': web_executable,
+                        'requires_input': requires_input,
+                        'is_destructive': is_destructive,
                     })
                 except Exception as e:
                     # If we can't load the command, still include basic info
@@ -86,6 +94,9 @@ class CommandsService:
                         'is_custom': app_name == 'django_cfg',
                         'is_allowed': is_allowed,
                         'risk_level': get_command_risk_level(command_name, app_name),
+                        'web_executable': None,
+                        'requires_input': None,
+                        'is_destructive': None,
                     })
 
             # Sort by name

django_cfg/apps/system/frontend/views.py

@@ -130,17 +130,23 @@ class ZipExtractionMixin:
 @method_decorator(xframe_options_exempt, name='dispatch')
 class NextJSStaticView(ZipExtractionMixin, View):
     """
-    Serve Next.js static build files with automatic JWT token injection.
+    Serve Next.js static build files with automatic JWT token injection and precompression support.
 
     Features:
     - Serves Next.js static export files like a static file server
     - Smart ZIP extraction: compares ZIP metadata (size + mtime) with marker file
-    - Automatically injects JWT tokens for authenticated users
-    - Tokens injected into HTML responses only
+    - Automatically injects JWT tokens for authenticated users (HTML only)
+    - **Precompression support**: Automatically serves .br or .gz files if available
     - Handles Next.js client-side routing (.html fallback)
     - Automatically serves index.html for directory paths
     - X-Frame-Options exempt to allow embedding in iframes
 
+    Compression Strategy:
+    - Brotli (.br) preferred over Gzip (.gz) - ~5-15% better compression
+    - Automatically detects browser support via Accept-Encoding header
+    - Skips compression for HTML files (JWT injection requires uncompressed content)
+    - Only serves precompressed files, no runtime compression
+
     ZIP Extraction Logic:
     - If directory doesn't exist: extract from ZIP
     - If marker file missing: extract from ZIP
@@ -154,12 +160,18 @@ class NextJSStaticView(ZipExtractionMixin, View):
     - /cfg/admin/private/      → /cfg/admin/private.html (fallback)
     - /cfg/admin/tasks         → /cfg/admin/tasks.html
     - /cfg/admin/tasks         → /cfg/admin/tasks/index.html (fallback)
+
+    Compression examples:
+    - _app.js (br supported)   → _app.js.br + Content-Encoding: br
+    - _app.js (gzip supported) → _app.js.gz + Content-Encoding: gzip
+    - _app.js (no support)     → _app.js (uncompressed)
+    - index.html               → index.html (never compressed, needs JWT injection)
     """
 
     app_name = 'admin'
 
     def get(self, request, path=''):
-        """Serve static files from Next.js build with JWT injection."""
+        """Serve static files from Next.js build with JWT injection and compression support."""
         import django_cfg
 
         base_dir = Path(django_cfg.__file__).parent / 'static' / 'frontend' / self.app_name
@@ -191,8 +203,18 @@ class NextJSStaticView(ZipExtractionMixin, View):
             request.META.pop('HTTP_IF_MODIFIED_SINCE', None)
             request.META.pop('HTTP_IF_NONE_MATCH', None)
 
-        # Serve the static file
-        response = serve(request, path, document_root=str(base_dir))
+        # Try to serve precompressed file if browser supports it
+        compressed_path, encoding = self._find_precompressed_file(base_dir, path, request)
+        if compressed_path:
+            logger.debug(f"[Compression] Serving {encoding} for {path}")
+            response = serve(request, compressed_path, document_root=str(base_dir))
+            response['Content-Encoding'] = encoding
+            # Remove Content-Length as it's incorrect for compressed content
+            if 'Content-Length' in response:
+                del response['Content-Length']
+        else:
+            # Serve the static file normally
+            response = serve(request, path, document_root=str(base_dir))
 
         # Convert FileResponse to HttpResponse for HTML files to enable JWT injection
         if isinstance(response, FileResponse):
@@ -222,6 +244,65 @@ class NextJSStaticView(ZipExtractionMixin, View):
 
         return response
 
+    def _find_precompressed_file(self, base_dir, path, request):
+        """
+        Find and return precompressed file (.br or .gz) if available and supported by browser.
+
+        Brotli (.br) is preferred over Gzip (.gz) as it provides better compression.
+
+        Args:
+            base_dir: Base directory for static files
+            path: Requested file path
+            request: Django request object
+
+        Returns:
+            tuple: (compressed_path, encoding) if precompressed file found and supported,
+                   (None, None) otherwise
+
+        Examples:
+            _app.js → _app.js.br (if Accept-Encoding: br)
+            _app.js → _app.js.gz (if Accept-Encoding: gzip, no .br)
+            _app.js → (None, None) (if no precompressed files or not supported)
+        """
+        # Get Accept-Encoding header
+        accept_encoding = request.META.get('HTTP_ACCEPT_ENCODING', '').lower()
+
+        # Check if browser supports brotli (preferred) or gzip
+        supports_br = 'br' in accept_encoding
+        supports_gzip = 'gzip' in accept_encoding
+
+        if not (supports_br or supports_gzip):
+            return None, None
+
+        # Don't compress HTML files - we need to inject JWT tokens
+        # JWT injection requires modifying content, which is incompatible with compression
+        if path.endswith('.html'):
+            return None, None
+
+        # Build full file path
+        file_path = base_dir / path
+
+        # Check if original file exists (safety check)
+        if not file_path.exists() or not file_path.is_file():
+            return None, None
+
+        # Try Brotli first (better compression, ~5-15% smaller than gzip)
+        if supports_br:
+            br_path = f"{path}.br"
+            br_file = base_dir / br_path
+            if br_file.exists() and br_file.is_file():
+                return br_path, 'br'
+
+        # Fallback to Gzip
+        if supports_gzip:
+            gz_path = f"{path}.gz"
+            gz_file = base_dir / gz_path
+            if gz_file.exists() and gz_file.is_file():
+                return gz_path, 'gzip'
+
+        # No precompressed file found or not supported
+        return None, None
+
     def _resolve_spa_path(self, base_dir, path):
         """
         Resolve SPA path with multiple fallback strategies.

django_cfg/apps/system/maintenance/management/commands/maintenance.py

@@ -7,16 +7,19 @@ Usage: python manage.py maintenance enable/disable/status/sync domain.com
 
 from typing import Any
 
-from django.core.management.base import BaseCommand, CommandError
+from django.core.management.base import CommandError
 from django.db import transaction
 
+from django_cfg.management.utils import InteractiveCommand
+
 from ...models import CloudflareSite, MaintenanceLog
 from ...services import MaintenanceService
 
 
-class Command(BaseCommand):
+class Command(InteractiveCommand):
     """Simple maintenance management command."""
 
+    command_name = 'maintenance'
     help = 'Manage maintenance mode for Cloudflare sites'
 
     def add_arguments(self, parser) -> None:

django_cfg/apps/system/maintenance/management/commands/process_scheduled_maintenance.py

@@ -5,16 +5,18 @@ Handles automatic start/stop of scheduled maintenance windows.
 """
 
 
-from django.core.management.base import BaseCommand
 from django.utils import timezone
 
+from django_cfg.management.utils import AdminCommand
+
 from ...models import ScheduledMaintenance
 from ...services.scheduled_maintenance_service import scheduled_maintenance_service
 
 
-class Command(BaseCommand):
+class Command(AdminCommand):
     """Process scheduled maintenance events."""
 
+    command_name = 'process_scheduled_maintenance'
     help = 'Process scheduled maintenance events (start due, complete overdue)'
 
     def add_arguments(self, parser):