Merge branch 'main' into feat/dockerize

Author: shubham3121

backend/syftai_space/alembic/versions/e18675e6eecb_add_settings_table.py

@@ -0,0 +1,33 @@
+"""add settings table
+
+Revision ID: e18675e6eecb
+Revises: 9b73c6b77fa4
+Create Date: 2026-01-13 12:39:41.971893
+
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+import sqlmodel  # noqa: F401 - Added for SQLModel support
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "e18675e6eecb"
+down_revision: str | None = "9b73c6b77fa4"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "settings",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("public_url", sa.String(), nullable=True),
+        sa.Column("updated_at", sa.DateTime(), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+    )
+
+
+def downgrade() -> None:
+    op.drop_table("settings")

backend/syftai_space/components/auth/dependencies.py

@@ -53,9 +53,9 @@ def get_verified_user_email(
 
     # Otherwise, verify token with SyftHub
     try:
-        client = SyftHubClient(str(marketplace.url))
-        client.login(marketplace.email, marketplace.password)
-        result = client.verify_satellite_token(token)
+        with SyftHubClient(str(marketplace.url)) as client:
+            client.login(marketplace.email, marketplace.password)
+            result = client.verify_satellite_token(token)
     except SyftHubError as e:
         raise e.to_http_exception() from e
 

backend/syftai_space/components/auth/middleware.py

@@ -1,12 +1,12 @@
 """Admin API key authentication middleware."""
 
-from typing import Callable
+from collections.abc import Callable
 
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.requests import Request
 from starlette.responses import JSONResponse, Response
 
-from syftai_space.components.auth.public import PUBLIC_ROUTE_MARKER
+from syftai_space.components.auth.public import is_public_route
 
 
 class AdminKeyMiddleware(BaseHTTPMiddleware):
@@ -18,31 +18,24 @@ class AdminKeyMiddleware(BaseHTTPMiddleware):
     All other routes require Authorization: Bearer <key> header.
     """
 
-    # Static paths that don't have route handlers (can't use decorator)
-    STATIC_PUBLIC_PATHS = [
-        "/docs",
-        "/redoc",
-        "/openapi.json",
-        "/syftai-server",  # Frontend static files
-    ]
-
+    STATIC_PUBLIC_PATHS = ["/docs", "/redoc", "/openapi.json", "/syftai-server"]
     STATIC_PUBLIC_EXACT = ["/"]
 
     async def dispatch(
         self, request: Request, call_next: Callable[[Request], Response]
     ) -> Response:
         path = request.url.path
+        method = request.method
 
-        # Check if route is marked as public via @public_route decorator
-        endpoint = request.scope.get("endpoint")
-        if endpoint and getattr(endpoint, PUBLIC_ROUTE_MARKER, False):
+        # Allow static paths (docs, frontend)
+        if self._is_static_public_path(path):
             return await call_next(request)
 
-        # Allow static public paths (docs, frontend, etc.)
-        if self._is_static_public_path(path):
+        # Allow public API routes (discovered from @public_route decorator)
+        if is_public_route(path, method):
             return await call_next(request)
 
-        # All other routes require admin key
+        # Require admin key for all other routes
         if not self._verify_admin_key(request):
             return JSONResponse(
                 status_code=401,
@@ -55,20 +48,17 @@ def _is_static_public_path(self, path: str) -> bool:
         """Check static paths that can't use decorators."""
         if path in self.STATIC_PUBLIC_EXACT:
             return True
-        return any(path.startswith(prefix) for prefix in self.STATIC_PUBLIC_PATHS)
+        return any(path.startswith(p) for p in self.STATIC_PUBLIC_PATHS)
 
     def _verify_admin_key(self, request: Request) -> bool:
         """Verify the admin API key from Authorization header."""
         from syftai_space.config import app_settings
 
-        # If no admin key configured, allow all (dev mode)
         if not app_settings.admin_api_key:
             return True
 
-        # Check Authorization: Bearer <token> header
         auth_header = request.headers.get("Authorization", "")
         if auth_header.startswith("Bearer "):
-            provided_key = auth_header[7:]  # Strip "Bearer " prefix
-            return provided_key == app_settings.admin_api_key
+            return auth_header[7:] == app_settings.admin_api_key
 
         return False

backend/syftai_space/components/auth/public.py

@@ -1,23 +1,58 @@
-"""Public route decorator for marking routes that don't require authentication."""
+"""Public route decorator and discovery for routes that skip admin auth."""
 
-from typing import Callable, TypeVar
+import re
+from collections.abc import Callable
+from typing import TypeVar
 
-F = TypeVar("F", bound=Callable)
+from loguru import logger
+from starlette.routing import Mount, Route
 
+F = TypeVar("F", bound=Callable)
 PUBLIC_ROUTE_MARKER = "public_route"
 
+# Module-level storage (populated by discover_public_routes)
+_public_patterns: list[tuple[str, re.Pattern]] = []
+
 
 def public_route(func: F) -> F:
-    """Decorator to mark a route as public (no auth required).
+    """Decorator to mark a route as public (no admin auth required).
 
     Usage:
         @public_route
         @router.post("/{slug}/query")
         async def query_endpoint(...):
             ...
-
-    The middleware checks for this marker via:
-        getattr(endpoint, PUBLIC_ROUTE_MARKER, False)
     """
     setattr(func, PUBLIC_ROUTE_MARKER, True)
     return func
+
+
+def discover_public_routes(app) -> None:
+    """Scan app routes and register those marked with @public_route.
+
+    Call this after all routes are registered.
+    """
+    _public_patterns.clear()
+    _scan_routes(app.routes, "")
+    logger.info(f"Discovered {len(_public_patterns)} public routes")
+
+
+def is_public_route(path: str, method: str) -> bool:
+    """Check if path+method is a public route."""
+    return any(m == method and p.match(path) for m, p in _public_patterns)
+
+
+def _scan_routes(routes, prefix: str) -> None:
+    """Recursively scan routes for @public_route marker."""
+    for route in routes:
+        if isinstance(route, Mount):
+            _scan_routes(route.routes, prefix + route.path)
+        elif isinstance(route, Route):
+            endpoint = getattr(route, "endpoint", None)
+            if endpoint and getattr(endpoint, PUBLIC_ROUTE_MARKER, False):
+                full_path = prefix + route.path
+                pattern = re.compile(
+                    "^" + re.sub(r"\{[^}]+\}", r"[^/]+", full_path) + "$"
+                )
+                for method in route.methods or {"GET"}:
+                    _public_patterns.append((method, pattern))

backend/syftai_space/components/endpoints/handlers.py

@@ -16,12 +16,14 @@
     EndpointCreateResponse,
     EndpointDetailResponse,
     EndpointListItem,
+    MarketplaceAvailabilityResult,
     MessageResponse,
     ProviderInfo,
     PublishEndpointResponse,
     PublishResult,
     QueryEndpointResponse,
     ReferencesResponse,
+    SlugAvailabilityResponse,
     SummaryResponse,
     TokenUsage,
 )
@@ -607,7 +609,7 @@ def _publish_to_marketplace(
                         }
                     ],
                 }
-                client.publish_endpoint(payload)
+                client.publish_endpoint(payload, overwrite=True)
 
         except SyftHubError as e:
             return PublishResult(
@@ -636,3 +638,132 @@ def _publish_to_marketplace(
                 success=False,
                 error=str(e),
             )
+
+    def check_slug_availability(
+        self,
+        slug: str,
+        marketplace_ids: list[UUID] | None,
+        check_all_marketplaces: bool,
+        tenant: Tenant,
+    ) -> SlugAvailabilityResponse:
+        """Check if a slug is available locally and optionally on marketplaces.
+
+        Args:
+            slug: Slug to check
+            marketplace_ids: Optional list of marketplace IDs to check
+            check_all_marketplaces: If True, check all active marketplaces (takes precedence)
+            tenant: Tenant context
+
+        Returns:
+            Availability status for local and each requested marketplace
+        """
+        # Check local availability
+        existing_endpoint = self.endpoint_repository.get_by_slug(slug, tenant.id)
+        local_available = existing_endpoint is None
+
+        # Determine if we need to check marketplaces
+        should_check_marketplaces = check_all_marketplaces or marketplace_ids
+
+        # If no marketplace check needed, return local-only result
+        if not should_check_marketplaces:
+            return SlugAvailabilityResponse(
+                slug=slug,
+                local_available=local_available,
+                marketplaces=None,
+            )
+
+        # Check marketplace availability
+        if not self.marketplace_repository:
+            raise HTTPException(
+                status_code=500,
+                detail="Marketplace checking is not configured",
+            )
+
+        # Get marketplaces to check
+        if check_all_marketplaces:
+            # Get all active marketplaces (flag takes precedence)
+            marketplaces = self.marketplace_repository.get_active(tenant.id)
+            missing_ids: set[UUID] = set()
+        else:
+            # Get specific marketplaces by IDs
+            marketplaces = self.marketplace_repository.get_by_ids(
+                marketplace_ids, tenant.id
+            )
+            found_ids = {m.id for m in marketplaces}
+            missing_ids = set(marketplace_ids) - found_ids
+
+        # Build results for each requested marketplace
+        marketplace_results: list[MarketplaceAvailabilityResult] = []
+
+        # Add results for missing marketplaces (only when using marketplace_ids)
+        for missing_id in missing_ids:
+            marketplace_results.append(
+                MarketplaceAvailabilityResult(
+                    marketplace_id=missing_id,
+                    available=None,
+                    error="Marketplace not found",
+                )
+            )
+
+        # Check each found marketplace
+        for marketplace in marketplaces:
+            result = self._check_marketplace_availability(slug, marketplace)
+            marketplace_results.append(result)
+
+        return SlugAvailabilityResponse(
+            slug=slug,
+            local_available=local_available,
+            marketplaces=marketplace_results,
+        )
+
+    def _check_marketplace_availability(
+        self,
+        slug: str,
+        marketplace: Marketplace,
+    ) -> MarketplaceAvailabilityResult:
+        """Check if a slug is available on a specific marketplace.
+
+        Args:
+            slug: Slug to check
+            marketplace: Marketplace to check on
+
+        Returns:
+            Availability result for the marketplace
+        """
+        # Validate marketplace is active
+        if not marketplace.is_active:
+            return MarketplaceAvailabilityResult(
+                marketplace_id=marketplace.id,
+                available=None,
+                error="Marketplace is not active",
+            )
+
+        # Validate marketplace has credentials
+        if not marketplace.email or not marketplace.password:
+            return MarketplaceAvailabilityResult(
+                marketplace_id=marketplace.id,
+                available=None,
+                error="Marketplace credentials not configured",
+            )
+
+        try:
+            with SyftHubClient(base_url=marketplace.url) as client:
+                client.login(username=marketplace.email, password=marketplace.password)
+                exists = client.endpoint_exists(slug)
+                return MarketplaceAvailabilityResult(
+                    marketplace_id=marketplace.id,
+                    available=not exists,
+                    error=None,
+                )
+        except SyftHubError as e:
+            return MarketplaceAvailabilityResult(
+                marketplace_id=marketplace.id,
+                available=None,
+                error=e.message,
+            )
+        except Exception as e:
+            return MarketplaceAvailabilityResult(
+                marketplace_id=marketplace.id,
+                available=None,
+                error=str(e),
+            )

backend/syftai_space/components/endpoints/routes.py

@@ -15,6 +15,8 @@
     PublishEndpointResponse,
     QueryEndpointRequest,
     QueryEndpointResponse,
+    SlugAvailabilityRequest,
+    SlugAvailabilityResponse,
 )
 from syftai_space.components.tenants.dependency import get_tenant_dependency
 from syftai_space.components.tenants.entities import Tenant
@@ -91,6 +93,33 @@ async def list_endpoints(
         """
         return handler.list_endpoints(tenant)
 
+    @router.post("/validate-slug", response_model=SlugAvailabilityResponse)
+    async def validate_slug(
+        request: SlugAvailabilityRequest,
+        tenant: Tenant = Depends(get_tenant_dependency),
+        handler: EndpointHandler = Depends(get_handler),
+    ) -> SlugAvailabilityResponse:
+        """Validate if a slug is available locally and optionally on marketplaces.
+
+        This endpoint allows checking slug uniqueness before creating an endpoint.
+        - If neither marketplace_ids nor check_all_marketplaces is provided, only checks locally (fast)
+        - If check_all_marketplaces is True, checks all active marketplaces
+        - If marketplace_ids is provided, checks only those specific marketplaces
+
+        Args:
+            request: Slug and optional marketplace options
+            tenant: Current tenant (injected)
+
+        Returns:
+            Availability status for local and each requested marketplace
+        """
+        return handler.check_slug_availability(
+            request.slug,
+            request.marketplace_ids,
+            request.check_all_marketplaces,
+            tenant,
+        )
+
     @router.get("/{slug}", response_model=EndpointDetailResponse)
     async def get_endpoint(
         slug: str,