kubiya-control-plane-api 0.9.15__py3-none-any.whl

control_plane_api/app/lib/storage/provider_factory.py

@@ -0,0 +1,157 @@
+"""
+Storage provider factory for creating and managing storage provider instances.
+
+Supports multiple providers with environment-based configuration.
+"""
+
+from typing import Optional
+import os
+import structlog
+
+from .base_provider import StorageProvider
+from .vercel_blob_provider import VercelBlobStorageProvider
+
+logger = structlog.get_logger()
+
+
+class StorageProviderFactory:
+    """Factory for creating storage provider instances based on configuration."""
+
+    @staticmethod
+    def create_provider(
+        provider_type: Optional[str] = None,
+        config: Optional[dict] = None
+    ) -> StorageProvider:
+        """
+        Create a storage provider instance.
+
+        Args:
+            provider_type: Provider name ('vercel_blob', 's3', 'azure_blob', 'gcs')
+                          If None, uses STORAGE_PROVIDER environment variable
+            config: Provider-specific configuration dict (optional)
+
+        Returns:
+            StorageProvider instance
+
+        Raises:
+            ValueError: If provider is not configured, invalid, or missing required config
+        """
+        # Get provider from parameter or environment
+        provider_type = provider_type or os.environ.get("STORAGE_PROVIDER")
+
+        if not provider_type:
+            raise ValueError(
+                "No storage provider configured. "
+                "Set STORAGE_PROVIDER environment variable to one of: "
+                "vercel_blob, s3, azure_blob, gcs"
+            )
+
+        provider_type = provider_type.lower().strip()
+
+        logger.info("storage_provider_factory_creating", provider_type=provider_type)
+
+        # Vercel Blob Storage
+        if provider_type == "vercel_blob":
+            token = os.environ.get("VERCEL_BLOB_TOKEN")
+            if not token:
+                raise ValueError(
+                    "VERCEL_BLOB_TOKEN environment variable is required for Vercel Blob provider"
+                )
+
+            store_name = os.environ.get("VERCEL_BLOB_STORE_NAME")
+
+            logger.info(
+                "creating_vercel_blob_provider",
+                store_name=store_name if store_name else "default"
+            )
+
+            return VercelBlobStorageProvider(token=token, store_name=store_name)
+
+        # AWS S3 (future implementation)
+        elif provider_type == "s3":
+            raise NotImplementedError(
+                "S3 provider not yet implemented. "
+                "To add S3 support, implement S3StorageProvider class."
+            )
+
+        # Azure Blob Storage (future implementation)
+        elif provider_type == "azure_blob":
+            raise NotImplementedError(
+                "Azure Blob provider not yet implemented. "
+                "To add Azure Blob support, implement AzureBlobStorageProvider class."
+            )
+
+        # Google Cloud Storage (future implementation)
+        elif provider_type == "gcs":
+            raise NotImplementedError(
+                "GCS provider not yet implemented. "
+                "To add GCS support, implement GCSStorageProvider class."
+            )
+
+        # Unknown provider
+        else:
+            raise ValueError(
+                f"Unknown storage provider: {provider_type}. "
+                f"Supported providers: vercel_blob, s3, azure_blob, gcs"
+            )
+
+
+# Singleton instance
+_provider_instance: Optional[StorageProvider] = None
+_provider_lock = False  # Simple lock for singleton pattern
+
+
+def get_storage_provider(force_recreate: bool = False) -> StorageProvider:
+    """
+    Get or create storage provider singleton.
+
+    Args:
+        force_recreate: If True, recreates the provider instance
+
+    Returns:
+        StorageProvider instance
+
+    Raises:
+        ValueError: If provider is not configured
+
+    Note:
+        This is a singleton pattern to reuse HTTP clients and connections.
+        The provider is created once per application lifecycle.
+    """
+    global _provider_instance, _provider_lock
+
+    if force_recreate:
+        _provider_instance = None
+
+    if _provider_instance is None:
+        if _provider_lock:
+            # Simple wait if another thread is creating
+            import time
+            timeout = 5  # 5 second timeout
+            start = time.time()
+            while _provider_lock and (time.time() - start) < timeout:
+                time.sleep(0.1)
+
+        if _provider_instance is None:
+            _provider_lock = True
+            try:
+                _provider_instance = StorageProviderFactory.create_provider()
+                logger.info(
+                    "storage_provider_singleton_created",
+                    provider=_provider_instance.get_provider_name()
+                )
+            finally:
+                _provider_lock = False
+
+    return _provider_instance
+
+
+def reset_storage_provider():
+    """
+    Reset the singleton instance.
+
+    Useful for testing or when configuration changes.
+    """
+    global _provider_instance
+    _provider_instance = None
+    logger.info("storage_provider_singleton_reset")

control_plane_api/app/lib/storage/vercel_blob_provider.py

@@ -0,0 +1,468 @@
+"""
+Vercel Blob Storage provider implementation.
+
+Documentation: https://vercel.com/docs/storage/vercel-blob
+"""
+
+import httpx
+import hashlib
+from typing import BinaryIO, Dict, List, Optional, Tuple
+from datetime import datetime
+from io import BytesIO
+import structlog
+
+from .base_provider import StorageProvider, StorageFile, UploadResult
+
+logger = structlog.get_logger()
+
+
+class VercelBlobStorageProvider(StorageProvider):
+    """
+    Vercel Blob Storage implementation.
+
+    Uses Vercel's Blob Storage API for file storage with organization-level isolation.
+    Files are stored with organization prefix for multi-tenancy.
+    """
+
+    def __init__(self, token: str, store_name: Optional[str] = None):
+        """
+        Initialize Vercel Blob provider.
+
+        Args:
+            token: VERCEL_BLOB_TOKEN from environment
+            store_name: Optional store name (defaults to main store)
+        """
+        self.token = token
+        self.store_name = store_name
+        self.base_url = "https://blob.vercel-storage.com"
+        self.client = httpx.AsyncClient(timeout=300.0)
+
+        logger.info(
+            "vercel_blob_provider_initialized",
+            store_name=store_name,
+            base_url=self.base_url
+        )
+
+    def _get_blob_path(self, organization_id: str, file_path: str) -> str:
+        """
+        Construct organization-scoped blob path.
+
+        Args:
+            organization_id: Organization ID
+            file_path: Virtual file path
+
+        Returns:
+            Full blob path with organization prefix
+        """
+        # Ensure file_path starts with /
+        if not file_path.startswith("/"):
+            file_path = f"/{file_path}"
+
+        # Construct: {org_id}{file_path}
+        return f"{organization_id}{file_path}"
+
+    async def upload(
+        self,
+        file_content: BinaryIO,
+        file_name: str,
+        file_path: str,
+        content_type: str,
+        organization_id: str,
+        metadata: Optional[Dict[str, str]] = None
+    ) -> UploadResult:
+        """Upload file to Vercel Blob."""
+
+        # Construct org-scoped blob path
+        blob_path = self._get_blob_path(organization_id, file_path)
+
+        # Read content and calculate checksum
+        content = file_content.read()
+        if hasattr(file_content, 'seek'):
+            file_content.seek(0)
+        checksum = hashlib.sha256(content).hexdigest()
+
+        # Prepare headers
+        headers = {
+            "Authorization": f"Bearer {self.token}",
+            "X-Content-Type": content_type,
+        }
+
+        # Add metadata as headers
+        if metadata:
+            for key, value in metadata.items():
+                safe_key = key.replace(" ", "_").replace("-", "_")
+                headers[f"X-Meta-{safe_key}"] = str(value)
+
+        try:
+            # Upload to Vercel Blob
+            logger.info(
+                "vercel_blob_upload_started",
+                blob_path=blob_path,
+                file_name=file_name,
+                size_bytes=len(content),
+                organization_id=organization_id
+            )
+
+            response = await self.client.put(
+                f"{self.base_url}/{blob_path}",
+                content=content,
+                headers=headers
+            )
+            response.raise_for_status()
+
+            result = response.json()
+
+            logger.info(
+                "vercel_blob_upload_completed",
+                blob_path=blob_path,
+                url=result.get("url"),
+                organization_id=organization_id
+            )
+
+            return UploadResult(
+                file_id=result["url"],  # Vercel uses URL as ID
+                url=result["url"],
+                file_size_bytes=len(content),
+                checksum=checksum,
+                provider_metadata={
+                    "downloadUrl": result.get("downloadUrl"),
+                    "pathname": result.get("pathname"),
+                    "blob_path": blob_path,
+                }
+            )
+
+        except httpx.HTTPStatusError as e:
+            logger.error(
+                "vercel_blob_upload_failed",
+                error=str(e),
+                status_code=e.response.status_code,
+                blob_path=blob_path
+            )
+            raise Exception(f"Vercel Blob upload failed: {e.response.text}")
+        except Exception as e:
+            logger.error(
+                "vercel_blob_upload_error",
+                error=str(e),
+                blob_path=blob_path
+            )
+            raise
+
+    async def download(
+        self,
+        file_id: str,
+        organization_id: str
+    ) -> Tuple[BinaryIO, str, int]:
+        """Download file from Vercel Blob."""
+
+        try:
+            logger.info(
+                "vercel_blob_download_started",
+                file_id=file_id,
+                organization_id=organization_id
+            )
+
+            # file_id is the blob URL for Vercel
+            response = await self.client.get(file_id, follow_redirects=True)
+            response.raise_for_status()
+
+            content_type = response.headers.get("content-type", "application/octet-stream")
+            file_size = int(response.headers.get("content-length", 0))
+
+            logger.info(
+                "vercel_blob_download_completed",
+                file_id=file_id,
+                size_bytes=file_size,
+                organization_id=organization_id
+            )
+
+            # Return as BytesIO
+            return BytesIO(response.content), content_type, file_size
+
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 404:
+                raise FileNotFoundError(f"File not found: {file_id}")
+            logger.error(
+                "vercel_blob_download_failed",
+                error=str(e),
+                status_code=e.response.status_code,
+                file_id=file_id
+            )
+            raise Exception(f"Vercel Blob download failed: {e.response.text}")
+        except Exception as e:
+            logger.error(
+                "vercel_blob_download_error",
+                error=str(e),
+                file_id=file_id
+            )
+            raise
+
+    async def delete(self, file_id: str, organization_id: str) -> bool:
+        """Delete file from Vercel Blob."""
+
+        try:
+            logger.info(
+                "vercel_blob_delete_started",
+                file_id=file_id,
+                organization_id=organization_id
+            )
+
+            # Vercel Blob delete API
+            response = await self.client.post(
+                f"{self.base_url}/delete",
+                json={"urls": [file_id]},
+                headers={"Authorization": f"Bearer {self.token}"}
+            )
+
+            success = response.status_code == 200
+
+            if success:
+                logger.info(
+                    "vercel_blob_delete_completed",
+                    file_id=file_id,
+                    organization_id=organization_id
+                )
+            else:
+                logger.warning(
+                    "vercel_blob_delete_failed",
+                    status_code=response.status_code,
+                    file_id=file_id
+                )
+
+            return success
+
+        except Exception as e:
+            logger.error(
+                "vercel_blob_delete_error",
+                error=str(e),
+                file_id=file_id
+            )
+            return False
+
+    async def list_files(
+        self,
+        organization_id: str,
+        prefix: Optional[str] = None,
+        limit: int = 100,
+        cursor: Optional[str] = None
+    ) -> Tuple[List[StorageFile], Optional[str]]:
+        """
+        List files from Vercel Blob.
+
+        Note: Vercel Blob list API has limitations. For production use,
+        it's recommended to use database queries with provider_file_id instead.
+        """
+
+        try:
+            # Construct org-scoped prefix
+            org_prefix = organization_id
+            if prefix:
+                org_prefix = self._get_blob_path(organization_id, prefix)
+
+            params = {
+                "prefix": org_prefix,
+                "limit": limit
+            }
+            if cursor:
+                params["cursor"] = cursor
+
+            logger.info(
+                "vercel_blob_list_started",
+                organization_id=organization_id,
+                prefix=org_prefix,
+                limit=limit
+            )
+
+            response = await self.client.get(
+                f"{self.base_url}/list",
+                params=params,
+                headers={"Authorization": f"Bearer {self.token}"}
+            )
+            response.raise_for_status()
+
+            data = response.json()
+            blobs = data.get("blobs", [])
+            next_cursor = data.get("cursor")
+
+            # Convert to StorageFile objects
+            files = []
+            for blob in blobs:
+                # Extract file path by removing org prefix
+                pathname = blob.get("pathname", "")
+                if pathname.startswith(organization_id):
+                    file_path = pathname[len(organization_id):]
+                else:
+                    file_path = pathname
+
+                files.append(StorageFile(
+                    file_id=blob["url"],
+                    file_name=file_path.split("/")[-1],
+                    file_path=file_path,
+                    content_type=blob.get("contentType", "application/octet-stream"),
+                    file_size_bytes=blob.get("size", 0),
+                    checksum=None,  # Vercel doesn't provide checksum in list
+                    created_at=datetime.fromisoformat(blob["uploadedAt"].replace("Z", "+00:00"))
+                    if "uploadedAt" in blob else None,
+                    provider_metadata=blob
+                ))
+
+            logger.info(
+                "vercel_blob_list_completed",
+                organization_id=organization_id,
+                files_count=len(files),
+                has_more=next_cursor is not None
+            )
+
+            return files, next_cursor
+
+        except Exception as e:
+            logger.error(
+                "vercel_blob_list_error",
+                error=str(e),
+                organization_id=organization_id
+            )
+            raise
+
+    async def get_metadata(
+        self,
+        file_id: str,
+        organization_id: str
+    ) -> StorageFile:
+        """
+        Get file metadata.
+
+        Vercel Blob doesn't have a dedicated metadata endpoint,
+        so we use HEAD request to get headers.
+        """
+
+        try:
+            response = await self.client.head(file_id, follow_redirects=True)
+            response.raise_for_status()
+
+            # Extract metadata from headers
+            content_type = response.headers.get("content-type", "application/octet-stream")
+            file_size = int(response.headers.get("content-length", 0))
+
+            # Extract pathname from URL
+            pathname = file_id.split("/")[-1]
+
+            return StorageFile(
+                file_id=file_id,
+                file_name=pathname.split("/")[-1],
+                file_path=pathname,
+                content_type=content_type,
+                file_size_bytes=file_size,
+                checksum=None,
+                created_at=None,
+                provider_metadata={"url": file_id}
+            )
+
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 404:
+                raise FileNotFoundError(f"File not found: {file_id}")
+            raise Exception(f"Failed to get metadata: {e.response.text}")
+
+    async def copy(
+        self,
+        source_file_id: str,
+        destination_path: str,
+        organization_id: str
+    ) -> UploadResult:
+        """
+        Copy file to new location.
+
+        Vercel Blob doesn't have native copy, so we download and re-upload.
+        """
+
+        try:
+            logger.info(
+                "vercel_blob_copy_started",
+                source_file_id=source_file_id,
+                destination_path=destination_path,
+                organization_id=organization_id
+            )
+
+            # Download source file
+            file_stream, content_type, _ = await self.download(source_file_id, organization_id)
+
+            # Get filename from destination path
+            file_name = destination_path.split("/")[-1]
+
+            # Upload to new location
+            result = await self.upload(
+                file_content=file_stream,
+                file_name=file_name,
+                file_path=destination_path,
+                content_type=content_type,
+                organization_id=organization_id
+            )
+
+            logger.info(
+                "vercel_blob_copy_completed",
+                source_file_id=source_file_id,
+                destination_file_id=result.file_id,
+                organization_id=organization_id
+            )
+
+            return result
+
+        except Exception as e:
+            logger.error(
+                "vercel_blob_copy_error",
+                error=str(e),
+                source_file_id=source_file_id
+            )
+            raise
+
+    async def move(
+        self,
+        file_id: str,
+        new_path: str,
+        organization_id: str
+    ) -> StorageFile:
+        """
+        Move/rename file.
+
+        Vercel Blob doesn't have native move, so we copy and delete.
+        """
+
+        try:
+            logger.info(
+                "vercel_blob_move_started",
+                file_id=file_id,
+                new_path=new_path,
+                organization_id=organization_id
+            )
+
+            # Copy to new location
+            upload_result = await self.copy(file_id, new_path, organization_id)
+
+            # Delete original
+            await self.delete(file_id, organization_id)
+
+            # Get metadata of new file
+            new_file = await self.get_metadata(upload_result.file_id, organization_id)
+
+            logger.info(
+                "vercel_blob_move_completed",
+                old_file_id=file_id,
+                new_file_id=upload_result.file_id,
+                organization_id=organization_id
+            )
+
+            return new_file
+
+        except Exception as e:
+            logger.error(
+                "vercel_blob_move_error",
+                error=str(e),
+                file_id=file_id
+            )
+            raise
+
+    def get_provider_name(self) -> str:
+        """Return provider name."""
+        return "vercel_blob"
+
+    async def close(self):
+        """Close HTTP client."""
+        await self.client.aclose()

control_plane_api/app/lib/supabase.py

@@ -0,0 +1,71 @@
+"""Supabase client for Agent Control Plane"""
+
+import os
+from typing import Optional
+from supabase import create_client, Client
+import structlog
+
+logger = structlog.get_logger()
+
+_supabase_client: Optional[Client] = None
+
+
+def get_supabase() -> Client:
+    """
+    Get or create Supabase client singleton.
+
+    Uses service role key for admin operations with RLS bypass.
+    The API will set organization context via middleware.
+
+    Returns:
+        Supabase client instance
+    """
+    global _supabase_client
+
+    if _supabase_client is not None:
+        return _supabase_client
+
+    supabase_url = os.environ.get("SUPABASE_URL") or os.environ.get("SUPABASE_SUPABASE_URL")
+    # Try multiple env var names for service key (Vercel Supabase integration uses different names)
+    supabase_key = (
+        os.environ.get("SUPABASE_SERVICE_KEY") or
+        os.environ.get("SUPABASE_SUPABASE_SERVICE_ROLE_KEY") or
+        os.environ.get("SUPABASE_SERVICE_ROLE_KEY")
+    )
+
+    if not supabase_url or not supabase_key:
+        raise ValueError(
+            "SUPABASE_URL and SUPABASE_SERVICE_KEY environment variables are required. "
+            f"Found URL: {bool(supabase_url)}, Key: {bool(supabase_key)}"
+        )
+
+    _supabase_client = create_client(supabase_url, supabase_key)
+
+    logger.info("supabase_client_initialized", url=supabase_url)
+
+    return _supabase_client
+
+
+def execute_with_org_context(org_id: str, query_func):
+    """
+    Execute a Supabase query with organization context for RLS.
+
+    Sets the app.current_org_id config parameter that RLS policies use.
+
+    Args:
+        org_id: Organization UUID
+        query_func: Function that performs the database operation
+
+    Returns:
+        Query result
+    """
+    client = get_supabase()
+
+    # Set organization context for RLS
+    # This uses the PostgreSQL set_config function via RPC
+    client.rpc("set_organization_context", {"org_id": org_id}).execute()
+
+    # Execute the query
+    result = query_func()
+
+    return result