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

django_cfg/__init__.py

@@ -32,7 +32,7 @@ Example:
 default_app_config = "django_cfg.apps.DjangoCfgConfig"
 
 # Version information
-__version__ = "1.5.8"
+__version__ = "1.5.20"
 __license__ = "MIT"
 
 # Setup warnings debug early (checks env var only at this point)

django_cfg/apps/api/commands/serializers.py

@@ -0,0 +1,152 @@
+"""
+Django CFG Commands API Serializers.
+"""
+
+from rest_framework import serializers
+
+
+class CommandMetadataSerializer(serializers.Serializer):
+    """
+    Serializer for command metadata.
+
+    Includes security attributes from our base classes:
+    - web_executable: Can be executed via web interface
+    - requires_input: Requires interactive user input
+    - is_destructive: Modifies or deletes data
+    - is_allowed: Passes security checks
+    - risk_level: Security risk assessment
+    """
+
+    web_executable = serializers.BooleanField(
+        allow_null=True,
+        help_text="Whether command can be executed via web interface"
+    )
+    requires_input = serializers.BooleanField(
+        allow_null=True,
+        help_text="Whether command requires interactive user input"
+    )
+    is_destructive = serializers.BooleanField(
+        allow_null=True,
+        help_text="Whether command modifies or deletes data"
+    )
+    is_allowed = serializers.BooleanField(
+        help_text="Whether command passes security checks for web execution"
+    )
+    risk_level = serializers.ChoiceField(
+        choices=['safe', 'caution', 'dangerous', 'unknown'],
+        help_text="Security risk level assessment"
+    )
+
+
+class CommandSerializer(serializers.Serializer):
+    """
+    Serializer for Django management commands.
+
+    Returns command information including:
+    - Basic info (name, app, description)
+    - Security metadata (web_executable, requires_input, is_destructive)
+    - Execution status (is_allowed, risk_level)
+    """
+
+    name = serializers.CharField(
+        help_text="Command name"
+    )
+    app = serializers.CharField(
+        help_text="Django app that provides this command"
+    )
+    description = serializers.CharField(
+        help_text="Short description of what the command does"
+    )
+
+    # Security metadata - flattened for easier API consumption
+    web_executable = serializers.BooleanField(
+        allow_null=True,
+        help_text="Can be executed via web interface"
+    )
+    requires_input = serializers.BooleanField(
+        allow_null=True,
+        help_text="Requires interactive user input"
+    )
+    is_destructive = serializers.BooleanField(
+        allow_null=True,
+        help_text="Modifies or deletes data"
+    )
+    is_allowed = serializers.BooleanField(
+        help_text="Passes security checks"
+    )
+    risk_level = serializers.ChoiceField(
+        choices=['safe', 'caution', 'dangerous', 'unknown'],
+        help_text="Security risk level"
+    )
+
+
+class CommandListResponseSerializer(serializers.Serializer):
+    """
+    Serializer for list commands API response.
+
+    Returns categorized commands:
+    - django_cfg: Custom django-cfg commands
+    - django_core: Django built-in commands
+    - third_party: Third-party app commands
+    - project: Project-specific commands
+    """
+
+    status = serializers.ChoiceField(
+        choices=['success', 'error'],
+        help_text="Response status"
+    )
+    commands = serializers.DictField(
+        child=serializers.ListField(child=CommandSerializer()),
+        help_text="Categorized command lists"
+    )
+    total_commands = serializers.IntegerField(
+        help_text="Total number of commands available"
+    )
+    timestamp = serializers.DateTimeField(
+        help_text="Response timestamp"
+    )
+
+
+class CommandExecutionRequestSerializer(serializers.Serializer):
+    """
+    Serializer for command execution requests.
+    """
+
+    command = serializers.CharField(
+        required=True,
+        help_text="Name of the command to execute"
+    )
+    args = serializers.ListField(
+        child=serializers.CharField(),
+        required=False,
+        default=list,
+        help_text="Positional arguments for the command"
+    )
+    options = serializers.DictField(
+        required=False,
+        default=dict,
+        help_text="Named options for the command (e.g., {'--verbose': True})"
+    )
+
+
+class CommandHelpResponseSerializer(serializers.Serializer):
+    """
+    Serializer for command help API response.
+    """
+
+    status = serializers.ChoiceField(
+        choices=['success', 'error'],
+        help_text="Response status"
+    )
+    command = serializers.CharField(
+        help_text="Command name"
+    )
+    app = serializers.CharField(
+        help_text="Django app"
+    )
+    help = serializers.CharField(
+        help_text="Full help text from command --help"
+    )
+    timestamp = serializers.DateTimeField(
+        help_text="Response timestamp"
+    )

django_cfg/apps/api/commands/views.py

@@ -49,6 +49,7 @@ def list_commands_view(request):
                 "name": command_name,
                 "app": app_name,
                 "description": _get_command_description(command_name),
+                **_get_command_metadata(command_name, app_name),
             }
 
             if app_name == "django_cfg":
@@ -270,6 +271,37 @@ def _get_command_description(command_name: str) -> str:
         return f'Django management command: {command_name}'
 
 
+def _get_command_metadata(command_name: str, app_name: str) -> dict:
+    """
+    Get security metadata for a command.
+
+    Returns:
+        Dict with web_executable, requires_input, is_destructive, is_allowed
+    """
+    try:
+        from django.core.management import load_command_class
+        from django_cfg.apps.system.dashboard.services.commands_security import is_command_allowed, get_command_risk_level
+
+        command_instance = load_command_class(app_name, command_name)
+
+        return {
+            'web_executable': getattr(command_instance, 'web_executable', None),
+            'requires_input': getattr(command_instance, 'requires_input', None),
+            'is_destructive': getattr(command_instance, 'is_destructive', None),
+            'is_allowed': is_command_allowed(command_name, app_name),
+            'risk_level': get_command_risk_level(command_name, app_name),
+        }
+    except Exception as e:
+        logger.debug(f"Could not load metadata for {command_name}: {e}")
+        return {
+            'web_executable': None,
+            'requires_input': None,
+            'is_destructive': None,
+            'is_allowed': False,
+            'risk_level': 'unknown',
+        }
+
+
 def _get_command_help(command_name: str) -> str:
     """Get full help text for a command."""
     try:

django_cfg/apps/business/accounts/management/commands/otp_test.py

@@ -2,17 +2,20 @@
 Management command to test OTP functionality.
 """
 
-from django.core.management.base import BaseCommand, CommandError
+from django.core.management.base import CommandError
 from django.utils import timezone
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
 
+from django_cfg.management.utils import SafeCommand
+
 from ...models import OTPSecret
 from ...services.otp_service import OTPService
 
 
-class Command(BaseCommand):
+class Command(SafeCommand):
+    command_name = 'otp_test'
     help = "Test OTP functionality with email and telegram delivery"
 
     def __init__(self, *args, **kwargs):

django_cfg/apps/business/accounts/serializers/profile.py

@@ -4,6 +4,24 @@ from rest_framework import serializers
 from ..models import CustomUser, RegistrationSource, UserRegistrationSource
 
 
+class CentrifugoTokenSerializer(serializers.Serializer):
+    """Nested serializer for Centrifugo WebSocket connection token."""
+
+    token = serializers.CharField(
+        help_text="JWT token for Centrifugo WebSocket connection"
+    )
+    centrifugo_url = serializers.URLField(
+        help_text="Centrifugo WebSocket URL"
+    )
+    expires_at = serializers.DateTimeField(
+        help_text="Token expiration time (ISO 8601)"
+    )
+    channels = serializers.ListField(
+        child=serializers.CharField(),
+        help_text="List of allowed channels for this user"
+    )
+
+
 class UserSerializer(serializers.ModelSerializer):
     """Serializer for user details."""
 
@@ -11,6 +29,7 @@ class UserSerializer(serializers.ModelSerializer):
     initials = serializers.ReadOnlyField()
     display_username = serializers.ReadOnlyField()
     avatar = serializers.SerializerMethodField()
+    centrifugo = serializers.SerializerMethodField()
 
     class Meta:
         model = CustomUser
@@ -31,6 +50,7 @@ class UserSerializer(serializers.ModelSerializer):
             "date_joined",
             "last_login",
             "unanswered_messages_count",
+            "centrifugo",
         ]
         read_only_fields = [
             "id",
@@ -52,6 +72,28 @@ class UserSerializer(serializers.ModelSerializer):
             return obj.avatar.url
         return None
 
+    @extend_schema_field(CentrifugoTokenSerializer(allow_null=True))
+    def get_centrifugo(self, obj):
+        """
+        Generate Centrifugo WebSocket connection token if enabled.
+
+        Returns None if Centrifugo is disabled in config.
+        """
+        try:
+            # Import here to avoid circular imports
+            from django_cfg.apps.integrations.centrifugo.services import generate_centrifugo_token
+
+            # Generate token with user's channels
+            token_data = generate_centrifugo_token(obj)
+            return token_data
+
+        except ValueError:
+            # Centrifugo not configured or disabled
+            return None
+        except Exception:
+            # If token generation fails, return None (don't break profile response)
+            return None
+
 
 
 class UserProfileUpdateSerializer(serializers.ModelSerializer):

django_cfg/apps/business/agents/management/commands/create_agent.py

@@ -5,14 +5,17 @@ Management command to create agent definitions.
 import asyncio
 
 from django.contrib.auth.models import User
-from django.core.management.base import BaseCommand, CommandError
+from django.core.management.base import CommandError
+
+from django_cfg.management.utils import AdminCommand
 
 from django_cfg.apps.business.agents.models.registry import AgentDefinition
 
 
-class Command(BaseCommand):
+class Command(AdminCommand):
     """Create agent definition from command line."""
 
+    command_name = 'create_agent'
     help = 'Create a new agent definition'
 
     def add_arguments(self, parser):
@@ -172,195 +175,3 @@ class Command(BaseCommand):
                 return await User.objects.filter(is_superuser=True).afirst()
             except User.DoesNotExist:
                 raise CommandError("No superuser found. Please create a superuser first or specify --creator")
-
-
-class Command(BaseCommand):
-    """Load agent definitions from templates."""
-
-    help = 'Load pre-built agent templates'
-
-    def add_arguments(self, parser):
-        """Add command arguments."""
-        parser.add_argument(
-            '--list',
-            action='store_true',
-            help='List available templates'
-        )
-        parser.add_argument(
-            '--load',
-            type=str,
-            nargs='*',
-            help='Load specific templates (space-separated names)'
-        )
-        parser.add_argument(
-            '--load-all',
-            action='store_true',
-            help='Load all available templates'
-        )
-        parser.add_argument(
-            '--creator',
-            type=str,
-            help='Username of agent creator (defaults to first superuser)'
-        )
-
-    def handle(self, *args, **options):
-        """Handle command execution."""
-        if options['list']:
-            self._list_templates()
-        elif options['load'] or options['load_all']:
-            asyncio.run(self._load_templates(options))
-        else:
-            self.stdout.write(
-                self.style.ERROR('Please specify --list, --load, or --load-all')
-            )
-
-    def _list_templates(self):
-        """List available templates."""
-        templates = self._get_available_templates()
-
-        self.stdout.write(self.style.SUCCESS('📋 Available Agent Templates:'))
-        self.stdout.write('=' * 40)
-
-        for category, agents in templates.items():
-            self.stdout.write(f"\n{category.upper()}:")
-            for agent_name, agent_info in agents.items():
-                self.stdout.write(f"  • {agent_name}: {agent_info['description']}")
-
-    async def _load_templates(self, options):
-        """Load templates."""
-        creator = await self._get_creator_user(options.get('creator'))
-        templates = self._get_available_templates()
-
-        if options['load_all']:
-            # Load all templates
-            to_load = []
-            for category_templates in templates.values():
-                to_load.extend(category_templates.keys())
-        else:
-            to_load = options['load']
-
-        loaded_count = 0
-
-        for template_name in to_load:
-            # Find template
-            template_info = None
-            for category_templates in templates.values():
-                if template_name in category_templates:
-                    template_info = category_templates[template_name]
-                    break
-
-            if not template_info:
-                self.stdout.write(
-                    self.style.WARNING(f"Template '{template_name}' not found")
-                )
-                continue
-
-            # Check if agent already exists
-            if await AgentDefinition.objects.filter(name=template_name).aexists():
-                self.stdout.write(
-                    self.style.WARNING(f"Agent '{template_name}' already exists, skipping")
-                )
-                continue
-
-            # Create agent
-            try:
-                agent_data = template_info.copy()
-                agent_data['name'] = template_name
-                agent_data['created_by'] = creator
-
-                await AgentDefinition.objects.acreate(**agent_data)
-
-                self.stdout.write(
-                    self.style.SUCCESS(f"✅ Loaded template: {template_name}")
-                )
-                loaded_count += 1
-
-            except Exception as e:
-                self.stdout.write(
-                    self.style.ERROR(f"Failed to load template '{template_name}': {e}")
-                )
-
-        self.stdout.write(
-            self.style.SUCCESS(f"\n🎉 Loaded {loaded_count} agent templates")
-        )
-
-    def _get_available_templates(self):
-        """Get available agent templates."""
-        return {
-            'content': {
-                'content_analyzer': {
-                    'description': 'Analyze content sentiment, topics, and quality',
-                    'instructions': 'Analyze content for sentiment, topics, keywords, and quality metrics.',
-                    'deps_type': 'ContentDeps',
-                    'output_type': 'AnalysisResult',
-                    'category': 'content',
-                    'model': 'openai:gpt-4o-mini',
-                },
-                'content_generator': {
-                    'description': 'Generate high-quality content based on requirements',
-                    'instructions': 'Generate engaging, well-structured content based on type, audience, and style requirements.',
-                    'deps_type': 'ContentDeps',
-                    'output_type': 'ProcessResult',
-                    'category': 'content',
-                    'model': 'openai:gpt-4o-mini',
-                },
-                'content_validator': {
-                    'description': 'Validate content quality and compliance',
-                    'instructions': 'Validate content for grammar, style, accuracy, and guideline compliance.',
-                    'deps_type': 'ContentDeps',
-                    'output_type': 'ValidationResult',
-                    'category': 'content',
-                    'model': 'openai:gpt-4o-mini',
-                },
-            },
-            'data': {
-                'data_processor': {
-                    'description': 'Process and transform data',
-                    'instructions': 'Process, clean, and transform data according to specifications.',
-                    'deps_type': 'DataProcessingDeps',
-                    'output_type': 'ProcessResult',
-                    'category': 'data',
-                    'model': 'openai:gpt-4o-mini',
-                },
-                'data_validator': {
-                    'description': 'Validate data quality and integrity',
-                    'instructions': 'Validate data quality, check for errors, and ensure integrity.',
-                    'deps_type': 'DataProcessingDeps',
-                    'output_type': 'ValidationResult',
-                    'category': 'data',
-                    'model': 'openai:gpt-4o-mini',
-                },
-            },
-            'business': {
-                'business_rules': {
-                    'description': 'Apply business rules and logic',
-                    'instructions': 'Apply business rules, validate decisions, and ensure compliance.',
-                    'deps_type': 'BusinessLogicDeps',
-                    'output_type': 'ProcessResult',
-                    'category': 'business',
-                    'model': 'openai:gpt-4o-mini',
-                },
-                'decision_maker': {
-                    'description': 'Make decisions based on criteria',
-                    'instructions': 'Analyze options and make informed decisions based on criteria and context.',
-                    'deps_type': 'BusinessLogicDeps',
-                    'output_type': 'ProcessResult',
-                    'category': 'business',
-                    'model': 'openai:gpt-4o-mini',
-                },
-            }
-        }
-
-    async def _get_creator_user(self, username):
-        """Get creator user."""
-        if username:
-            try:
-                return await User.objects.aget(username=username)
-            except User.DoesNotExist:
-                raise CommandError(f"User '{username}' not found")
-        else:
-            # Use first superuser
-            try:
-                return await User.objects.filter(is_superuser=True).afirst()
-            except User.DoesNotExist:
-                raise CommandError("No superuser found. Please create a superuser first or specify --creator")