kubiya-control-plane-api 0.1.0__py3-none-any.whl → 0.3.4__py3-none-any.whl

control_plane_api/app/services/temporal_cloud_provisioning.py

@@ -0,0 +1,150 @@
+"""
+Temporal Cloud Provisioning Service
+
+This service handles provisioning Temporal Cloud namespaces via the
+Vercel serverless function (api/provision-namespace.go).
+"""
+
+import os
+import httpx
+import structlog
+from typing import Dict, Any
+
+logger = structlog.get_logger()
+
+
+class TemporalCloudProvisioningService:
+    """Service for provisioning Temporal Cloud namespaces"""
+
+    def __init__(self):
+        # Get the Vercel function URL from environment
+        self.proxy_url = os.getenv("TEMPORAL_CLOUD_PROXY_URL")
+        if not self.proxy_url:
+            # If not set, use the Vercel production URL
+            self.proxy_url = "https://temporal-cloud-proxy.vercel.app/api/provision-namespace"
+
+        # Get the admin token for authorization (will be checked when actually used)
+        self.admin_token = os.getenv("TEMPORAL_CLOUD_ADMIN_TOKEN")
+
+    async def provision_namespace_for_organization(
+        self,
+        organization_id: str,
+        organization_name: str,
+        region: str = "aws-us-east-1",
+        retention_days: int = 7,
+    ) -> Dict[str, Any]:
+        """
+        Provision a Temporal Cloud namespace for an organization.
+
+        Args:
+            organization_id: The organization ID
+            organization_name: The organization name
+            region: The Temporal Cloud region (default: aws-us-east-1)
+            retention_days: Number of days to retain workflow history (default: 7)
+
+        Returns:
+            Dictionary with:
+            - success: Boolean indicating if provisioning succeeded
+            - namespace_name: The provisioned namespace name
+            - namespace: Dictionary with namespace details
+            - already_exists: Boolean indicating if namespace already existed
+            - error: Error message if failed
+            - timeout: Boolean indicating if operation timed out
+        """
+        logger.info(
+            "provisioning_temporal_namespace",
+            organization_id=organization_id,
+            organization_name=organization_name,
+            region=region,
+        )
+
+        # Check if token is available
+        if not self.admin_token:
+            error_msg = "TEMPORAL_CLOUD_ADMIN_TOKEN environment variable is required but not set"
+            logger.error("temporal_cloud_token_missing", organization_id=organization_id)
+            return {
+                "success": False,
+                "error": error_msg,
+                "timeout": False,
+            }
+
+        try:
+            # Prepare the request
+            payload = {
+                "organization_id": organization_id,
+                "organization_name": organization_name,
+                "region": region,
+                "retention_days": retention_days,
+            }
+
+            headers = {
+                "Authorization": f"Bearer {self.admin_token}",
+                "Content-Type": "application/json",
+            }
+
+            # Call the Vercel function
+            async with httpx.AsyncClient(timeout=60.0) as client:
+                response = await client.post(
+                    self.proxy_url,
+                    json=payload,
+                    headers=headers,
+                )
+
+                # Check response status
+                if response.status_code == 200:
+                    result = response.json()
+                    logger.info(
+                        "namespace_provisioned_successfully",
+                        organization_id=organization_id,
+                        namespace_name=result.get("namespace_name"),
+                        already_exists=result.get("already_exists", False),
+                    )
+                    return result
+                else:
+                    error_msg = response.text
+                    logger.error(
+                        "namespace_provisioning_failed",
+                        organization_id=organization_id,
+                        status_code=response.status_code,
+                        error=error_msg,
+                    )
+                    return {
+                        "success": False,
+                        "error": f"HTTP {response.status_code}: {error_msg}",
+                        "timeout": False,
+                    }
+
+        except httpx.TimeoutException as e:
+            logger.warning(
+                "namespace_provisioning_timeout",
+                organization_id=organization_id,
+                error=str(e),
+            )
+            return {
+                "success": False,
+                "error": "Provisioning timed out",
+                "timeout": True,
+            }
+        except Exception as e:
+            logger.error(
+                "namespace_provisioning_exception",
+                organization_id=organization_id,
+                error=str(e),
+            )
+            return {
+                "success": False,
+                "error": str(e),
+                "timeout": False,
+            }
+
+
+# Global instance
+_provisioning_service = None
+
+
+def get_provisioning_service() -> TemporalCloudProvisioningService:
+    """Get the provisioning service singleton"""
+    global _provisioning_service
+    if _provisioning_service is None:
+        _provisioning_service = TemporalCloudProvisioningService()
+    return _provisioning_service

control_plane_api/app/skills/__init__.py

@@ -0,0 +1,44 @@
+"""
+Skills Module
+
+This module manages all available skills (OS-level capabilities) that can be
+assigned to agents and teams. Each skill corresponds to a capability that agents
+can use during execution (file system, shell, Docker, Python, etc.).
+
+Skills are defined as Python classes that provide:
+- Metadata (name, description, icon)
+- Default configuration
+- Validation logic
+- Instantiation logic for the underlying framework
+"""
+
+from .base import SkillDefinition, SkillType, SkillCategory, SkillRequirements, SkillVariant
+from .registry import skill_registry, get_skill, get_all_skills, register_skill
+
+# Import all skill definitions to auto-register them
+from .file_system import FileSystemSkill
+from .shell import ShellSkill
+from .docker import DockerSkill
+from .python import PythonSkill
+from .file_generation import FileGenerationSkill
+from .data_visualization import DataVisualizationSkill
+from .workflow_executor import WorkflowExecutorSkill
+
+__all__ = [
+    "SkillDefinition",
+    "SkillType",
+    "SkillCategory",
+    "SkillRequirements",
+    "SkillVariant",
+    "skill_registry",
+    "get_skill",
+    "get_all_skills",
+    "register_skill",
+    "FileSystemSkill",
+    "ShellSkill",
+    "DockerSkill",
+    "PythonSkill",
+    "FileGenerationSkill",
+    "DataVisualizationSkill",
+    "WorkflowExecutorSkill",
+]

control_plane_api/app/skills/base.py

@@ -0,0 +1,229 @@
+"""
+Base classes for skill definitions
+"""
+from typing import Dict, Any, List, Optional, Set
+from enum import Enum
+from pydantic import BaseModel, Field
+from abc import ABC, abstractmethod
+import platform
+
+
+class SkillType(str, Enum):
+    """Supported skill types"""
+    FILE_SYSTEM = "file_system"
+    SHELL = "shell"
+    DOCKER = "docker"
+    PYTHON = "python"
+    FILE_GENERATION = "file_generation"
+    DATA_VISUALIZATION = "data_visualization"
+    SLEEP = "sleep"
+    WORKFLOW_EXECUTOR = "workflow_executor"
+    CUSTOM = "custom"
+
+
+class SkillCategory(str, Enum):
+    """Skill categories for organization"""
+    COMMON = "common"          # Frequently used, safe defaults
+    ADVANCED = "advanced"       # Advanced features, require more privileges
+    SECURITY = "security"       # Security-focused, restricted access
+    CUSTOM = "custom"           # User-defined custom skills
+
+
+class SkillRequirements(BaseModel):
+    """Runtime requirements for a skill"""
+    # Python packages required (will be checked/installed by worker)
+    python_packages: List[str] = Field(default_factory=list)
+
+    # System packages required (informational, worker should validate)
+    system_packages: List[str] = Field(default_factory=list)
+
+    # Supported operating systems (e.g., ["linux", "darwin", "windows"])
+    supported_os: Optional[List[str]] = None
+
+    # Minimum Python version (e.g., "3.10")
+    min_python_version: Optional[str] = None
+
+    # Environment variables required
+    required_env_vars: List[str] = Field(default_factory=list)
+
+    # External services/APIs required (informational)
+    external_dependencies: List[str] = Field(default_factory=list)
+
+    # Additional notes about requirements
+    notes: Optional[str] = None
+
+
+class SkillVariant(BaseModel):
+    """A specific variant/preset of a skill"""
+    id: str
+    name: str
+    description: str
+    category: SkillCategory
+    configuration: Dict[str, Any]
+    badge: Optional[str] = None  # e.g., "Safe", "Recommended", "Advanced"
+    icon: Optional[str] = None
+    is_default: bool = False
+
+
+class SkillDefinition(ABC):
+    """
+    Base class for all skill definitions.
+
+    Each skill type should subclass this and implement the required methods.
+    This provides a clean interface for defining new skills.
+    """
+
+    @property
+    @abstractmethod
+    def type(self) -> SkillType:
+        """The type identifier for this skill"""
+        pass
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Human-readable name"""
+        pass
+
+    @property
+    @abstractmethod
+    def description(self) -> str:
+        """Description of what this skill does"""
+        pass
+
+    @property
+    @abstractmethod
+    def icon(self) -> str:
+        """Icon name (Lucide or React Icons)"""
+        pass
+
+    @property
+    def icon_type(self) -> str:
+        """Icon type: 'lucide' or 'react-icon'"""
+        return "lucide"
+
+    @abstractmethod
+    def get_variants(self) -> List[SkillVariant]:
+        """
+        Get all predefined variants/presets for this skill.
+
+        Returns a list of variants with different configurations
+        (e.g., "Read Only", "Full Access", "Sandboxed")
+        """
+        pass
+
+    @abstractmethod
+    def validate_configuration(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Validate and normalize configuration.
+
+        Args:
+            config: Raw configuration dict
+
+        Returns:
+            Validated and normalized configuration
+
+        Raises:
+            ValueError: If configuration is invalid
+        """
+        pass
+
+    @abstractmethod
+    def get_default_configuration(self) -> Dict[str, Any]:
+        """Get the default configuration for this skill"""
+        pass
+
+    def get_framework_class_name(self) -> str:
+        """
+        Get the underlying framework tool class name.
+        This is used for instantiation during agent execution.
+
+        Returns:
+            Class name (e.g., "FileTools", "ShellTools")
+        """
+        # Default mapping based on type
+        mapping = {
+            SkillType.FILE_SYSTEM: "FileTools",
+            SkillType.SHELL: "ShellTools",
+            SkillType.DOCKER: "DockerTools",
+            SkillType.PYTHON: "PythonTools",
+            SkillType.FILE_GENERATION: "FileGenerationTools",
+            SkillType.DATA_VISUALIZATION: "DataVisualizationTools",
+            SkillType.SLEEP: "SleepTools",
+        }
+        return mapping.get(self.type, "BaseTool")
+
+    def get_requirements(self) -> SkillRequirements:
+        """
+        Get runtime requirements for this skill.
+
+        Override this method to specify requirements like:
+        - Python packages
+        - System packages
+        - OS requirements
+        - Environment variables
+
+        Returns:
+            SkillRequirements instance
+        """
+        # Default: no special requirements
+        return SkillRequirements()
+
+    def check_requirements(self) -> tuple[bool, List[str]]:
+        """
+        Check if requirements are met in current environment.
+
+        Returns:
+            Tuple of (is_satisfied, missing_requirements)
+        """
+        requirements = self.get_requirements()
+        missing = []
+
+        # Check OS
+        if requirements.supported_os:
+            current_os = platform.system().lower()
+            if current_os not in requirements.supported_os:
+                missing.append(f"OS '{current_os}' not supported (requires: {', '.join(requirements.supported_os)})")
+
+        # Check Python version
+        if requirements.min_python_version:
+            import sys
+            from packaging import version
+            current_version = f"{sys.version_info.major}.{sys.version_info.minor}"
+            if version.parse(current_version) < version.parse(requirements.min_python_version):
+                missing.append(f"Python {requirements.min_python_version}+ required (current: {current_version})")
+
+        # Check environment variables
+        import os
+        for env_var in requirements.required_env_vars:
+            if not os.getenv(env_var):
+                missing.append(f"Environment variable '{env_var}' not set")
+
+        # Check Python packages (basic import check)
+        for package in requirements.python_packages:
+            package_name = package.split('[')[0].split('>=')[0].split('==')[0].strip()
+            try:
+                __import__(package_name)
+            except ImportError:
+                missing.append(f"Python package '{package}' not installed")
+
+        return len(missing) == 0, missing
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary representation"""
+        requirements = self.get_requirements()
+        is_satisfied, missing = self.check_requirements()
+
+        return {
+            "type": self.type.value,
+            "name": self.name,
+            "description": self.description,
+            "icon": self.icon,
+            "icon_type": self.icon_type,
+            "default_configuration": self.get_default_configuration(),
+            "variants": [v.model_dump() for v in self.get_variants()],
+            "framework_class": self.get_framework_class_name(),
+            "requirements": requirements.model_dump(),
+            "requirements_satisfied": is_satisfied,
+            "missing_requirements": missing,
+        }

control_plane_api/app/skills/business_intelligence.py

@@ -0,0 +1,189 @@
+"""
+Business Intelligence Skill
+
+Provides comprehensive BI capabilities including database querying, analytics,
+visualization generation, and multi-agent analysis. Supports PostgreSQL, MySQL,
+MongoDB, and file-based data sources (CSV, JSON, Parquet, Excel).
+"""
+from typing import Dict, Any, List
+from .base import SkillDefinition, SkillType, SkillCategory, SkillVariant
+from .registry import register_skill
+
+
+class BusinessIntelligenceSkill(SkillDefinition):
+    """Business Intelligence and Analytics skill"""
+
+    @property
+    def type(self) -> SkillType:
+        return SkillType.BUSINESS_INTELLIGENCE
+
+    @property
+    def name(self) -> str:
+        return "Business Intelligence"
+
+    @property
+    def description(self) -> str:
+        return "Advanced BI and analytics with multi-agent analysis, database querying, and interactive visualizations"
+
+    @property
+    def icon(self) -> str:
+        return "BarChart"
+
+    def get_variants(self) -> List[SkillVariant]:
+        return [
+            SkillVariant(
+                id="bi_full",
+                name="Full BI Suite",
+                description="Complete BI capabilities with all data sources and analytics features",
+                category=SkillCategory.ADVANCED,
+                badge="Recommended",
+                icon="BarChart",
+                configuration={
+                    "data_sources": [
+                        {
+                            "id": "default_postgres",
+                            "name": "PostgreSQL Database",
+                            "type": "postgresql",
+                            "connection": {
+                                "host": "${POSTGRES_HOST}",
+                                "port": "${POSTGRES_PORT:5432}",
+                                "database": "${POSTGRES_DB}",
+                                "username": "${POSTGRES_USER}",
+                                "password": "${POSTGRES_PASSWORD}",
+                                "ssl": True,
+                                "pool_size": 5
+                            },
+                            "query_limits": {
+                                "max_rows": 10000,
+                                "timeout_seconds": 30
+                            }
+                        }
+                    ],
+                    "security": {
+                        "allowed_sql_commands": ["SELECT"],
+                        "deny_patterns": ["DROP", "DELETE", "TRUNCATE", "ALTER", "INSERT", "UPDATE"]
+                    },
+                    "features": {
+                        "enable_multi_agent": True,
+                        "enable_visualizations": True,
+                        "enable_schema_introspection": True,
+                        "enable_query_validation": True
+                    }
+                },
+                is_default=True,
+            ),
+            SkillVariant(
+                id="bi_read_only",
+                name="Read-Only BI",
+                description="Safe, read-only analytics with SELECT-only permissions",
+                category=SkillCategory.COMMON,
+                badge="Safe",
+                icon="Eye",
+                configuration={
+                    "data_sources": [],  # Configured per agent
+                    "security": {
+                        "allowed_sql_commands": ["SELECT"],
+                        "deny_patterns": ["DROP", "DELETE", "TRUNCATE", "ALTER", "INSERT", "UPDATE", "CREATE"]
+                    },
+                    "features": {
+                        "enable_multi_agent": True,
+                        "enable_visualizations": True,
+                        "enable_schema_introspection": True,
+                        "enable_query_validation": True
+                    }
+                },
+                is_default=False,
+            ),
+            SkillVariant(
+                id="bi_file_analysis",
+                name="File Analysis",
+                description="Analyze CSV, JSON, Parquet, and Excel files without database access",
+                category=SkillCategory.COMMON,
+                badge="Simple",
+                icon="FileSpreadsheet",
+                configuration={
+                    "data_sources": [],
+                    "security": {
+                        "allowed_sql_commands": ["SELECT"],
+                        "deny_patterns": []
+                    },
+                    "features": {
+                        "enable_multi_agent": True,
+                        "enable_visualizations": True,
+                        "enable_schema_introspection": True,
+                        "enable_query_validation": False,
+                        "supported_formats": ["csv", "json", "parquet", "excel"]
+                    }
+                },
+                is_default=False,
+            ),
+            SkillVariant(
+                id="bi_custom",
+                name="Custom BI Configuration",
+                description="Fully customizable BI setup with user-defined data sources and security policies",
+                category=SkillCategory.ADVANCED,
+                badge="Flexible",
+                icon="Settings",
+                configuration={
+                    "data_sources": [],
+                    "security": {
+                        "allowed_sql_commands": ["SELECT"],
+                        "deny_patterns": []
+                    },
+                    "features": {
+                        "enable_multi_agent": True,
+                        "enable_visualizations": True,
+                        "enable_schema_introspection": True,
+                        "enable_query_validation": True
+                    }
+                },
+                is_default=False,
+            ),
+        ]
+
+    def validate_configuration(self, config: Dict[str, Any]) -> bool:
+        """Validate BI skill configuration"""
+        required_keys = ["data_sources", "security", "features"]
+
+        # Check required top-level keys
+        for key in required_keys:
+            if key not in config:
+                return False
+
+        # Validate security config
+        if "security" in config:
+            security = config["security"]
+            if "allowed_sql_commands" not in security:
+                return False
+            if not isinstance(security["allowed_sql_commands"], list):
+                return False
+
+        # Validate data sources
+        if "data_sources" in config:
+            for ds in config["data_sources"]:
+                if "id" not in ds or "type" not in ds:
+                    return False
+                if "connection" not in ds:
+                    return False
+
+        return True
+
+    def get_default_configuration(self) -> Dict[str, Any]:
+        """Get default configuration for BI skill"""
+        return {
+            "data_sources": [],
+            "security": {
+                "allowed_sql_commands": ["SELECT"],
+                "deny_patterns": ["DROP", "DELETE", "TRUNCATE", "ALTER", "INSERT", "UPDATE"]
+            },
+            "features": {
+                "enable_multi_agent": True,
+                "enable_visualizations": True,
+                "enable_schema_introspection": True,
+                "enable_query_validation": True
+            }
+        }
+
+
+# Register the skill
+register_skill(BusinessIntelligenceToolSet())