Skip to content

A programming framework for agentic AI

Enable Auth in AGS (#5928)

Victor Dibiafe1feb3906fe
diff --git a/python/packages/autogen-core/docs/src/user-guide/autogenstudio-user-guide/experimental.md b/python/packages/autogen-core/docs/src/user-guide/autogenstudio-user-guide/experimental.md
new file mode 100644
index 000000000..d3c7ae4ba
--- /dev/null
+++ b/python/packages/autogen-core/docs/src/user-guide/autogenstudio-user-guide/experimental.md
@@ -0,0 +1,68 @@
+---
+myst:
+ html_meta:
+ "description lang=en": |
+ FAQ for AutoGen Studio - A low code tool for building and debugging multi-agent systems
+---
+
+# Experimental Features
+
+## Authentication
+
+AutoGen Studio offers an experimental authentication feature to enable personalized experiences (multiple users). Currently, only GitHub authentication is supported. You can extend the base authentication class to add support for other authentication methods.
+
+By default authenticatio is disabled and only enabled when you pass in the `--auth-config` argument when running the application.
+
+### Enable GitHub Authentication
+
+To enable GitHub authentication, create a `auth.yaml` file in your app directory:
+
+```yaml
+type: github
+jwt_secret: "your-secret-key" # keep secure!
+token_expiry_minutes: 60
+github:
+ client_id: "your-github-client-id"
+ client_secret: "your-github-client-secret"
+ callback_url: "http://localhost:8081/api/auth/callback"
+ scopes: ["user:email"]
+```
+
+```{note}
+
+**JWT Secret**
+
+
+- Generate a strong, unique JWT secret (at least 32 random bytes). You can run `openssl rand -hex 32` to generate a secure random key.
+- Never commit your JWT secret to version control
+- In production, store secrets in environment variables or secure secret management services
+- Regularly rotate your JWT secret to limit the impact of potential breaches
+
+**Callback URL**
+
+- The callback URL is the URL that GitHub will redirect to after the user has authenticated. It should match the URL you set in your GitHub OAuth application settings.
+- Ensure that the callback URL is accessible from the internet if you are running AutoGen Studio on a remote server.
+
+```
+
+Please see the documentation on [GitHub OAuth](https://docs.github.com/en/apps/oauth-apps/building-oauth-apps/authenticating-to-the-rest-api-with-an-oauth-app) for more details on obtaining the `client_id` and `client_secret`.
+
+To pass in this configuration you can use the `--auth-config` argument when running the application:
+
+```bash
+autogenstudio ui --auth-config /path/to/auth.yaml
+```
+
+Or set the environment variable:
+
+```bash
+export AUTOGENSTUDIO_AUTH_CONFIG="/path/to/auth.yaml"
+```
+
+```{note}
+- Authentication is currently experimental and may change in future releases
+- User data is stored in your configured database
+- When enabled, all API endpoints require authentication except for the authentication endpoints
+- WebSocket connections require the token to be passed as a query parameter (`?token=your-jwt-token`)
+
+```
diff --git a/python/packages/autogen-core/docs/src/user-guide/autogenstudio-user-guide/faq.md b/python/packages/autogen-core/docs/src/user-guide/autogenstudio-user-guide/faq.md
index 87c461106..577ce1bcf 100644
--- a/python/packages/autogen-core/docs/src/user-guide/autogenstudio-user-guide/faq.md
+++ b/python/packages/autogen-core/docs/src/user-guide/autogenstudio-user-guide/faq.md
@@ -21,6 +21,7 @@ In the following sample, we will define an OpenAI, AzureOpenAI and a local model
```python
from autogen_ext.models.openai import AzureOpenAIChatCompletionClient, OpenAIChatCompletionClient
+from autogen_ext.models.anthropic import AnthropicChatCompletionClient
from autogen_core.models import ModelInfo
model_client=OpenAIChatCompletionClient(
@@ -28,6 +29,7 @@ model_client=OpenAIChatCompletionClient(
)
print(model_client.dump_component().model_dump_json())
+
az_model_client = AzureOpenAIChatCompletionClient(
azure_deployment="{your-azure-deployment}",
model="gpt-4o",
@@ -37,6 +39,12 @@ az_model_client = AzureOpenAIChatCompletionClient(
)
print(az_model_client.dump_component().model_dump_json())
+anthropic_client = AnthropicChatCompletionClient(
+ model="claude-3-sonnet-20240229",
+ api_key="your-api-key", # Optional if ANTHROPIC_API_KEY is set in environment
+ )
+print(anthropic_client.dump_component().model_dump_json())
+
mistral_vllm_model = OpenAIChatCompletionClient(
model="TheBloke/Mistral-7B-Instruct-v0.2-GGUF",
base_url="http://localhost:1234/v1",
@@ -79,6 +87,25 @@ Azure OpenAI
}
```
+Anthropic
+
+```json
+{
+ "provider": "autogen_ext.models.anthropic.AnthropicChatCompletionClient",
+ "component_type": "model",
+ "version": 1,
+ "component_version": 1,
+ "description": "Chat completion client for Anthropic's Claude models.",
+ "label": "AnthropicChatCompletionClient",
+ "config": {
+ "model": "claude-3-sonnet-20240229",
+ "max_tokens": 4096,
+ "temperature": 1.0,
+ "api_key": "your-api-key"
+ }
+}
+```
+
Have a local model server like Ollama, vLLM or LMStudio that provide an OpenAI compliant endpoint? You can use that as well.
```json
diff --git a/python/packages/autogen-core/docs/src/user-guide/autogenstudio-user-guide/index.md b/python/packages/autogen-core/docs/src/user-guide/autogenstudio-user-guide/index.md
index 608adf78a..72ca01aed 100644
--- a/python/packages/autogen-core/docs/src/user-guide/autogenstudio-user-guide/index.md
+++ b/python/packages/autogen-core/docs/src/user-guide/autogenstudio-user-guide/index.md
@@ -100,5 +100,6 @@ To begin, follow the [installation instructions](installation.md) to install Aut
installation
usage
+experimental
faq
```
diff --git a/python/packages/autogen-studio/autogenstudio/cli.py b/python/packages/autogen-studio/autogenstudio/cli.py
index ef5025461..46299b86f 100644
--- a/python/packages/autogen-studio/autogenstudio/cli.py
+++ b/python/packages/autogen-studio/autogenstudio/cli.py
@@ -32,6 +32,7 @@ def ui(
docs: bool = True,
appdir: str | None = None,
database_uri: Optional[str] = None,
+ auth_config: Optional[str] = None,
upgrade_database: bool = False,
):
"""
@@ -44,19 +45,26 @@ def ui(
reload (bool, optional): Whether to reload the UI on code changes. Defaults to False.
docs (bool, optional): Whether to generate API docs. Defaults to False.
appdir (str, optional): Path to the AutoGen Studio app directory. Defaults to None.
- database-uri (str, optional): Database URI to connect to. Defaults to None.
+ database_uri (str, optional): Database URI to connect to. Defaults to None.
+ auth_config (str, optional): Path to authentication configuration YAML. Defaults to None.
+ upgrade_database (bool, optional): Whether to upgrade the database. Defaults to False.
"""
-
# Write configuration
env_vars = {
"AUTOGENSTUDIO_HOST": host,
"AUTOGENSTUDIO_PORT": port,
"AUTOGENSTUDIO_API_DOCS": str(docs),
}
+
if appdir:
env_vars["AUTOGENSTUDIO_APPDIR"] = appdir
if database_uri:
env_vars["AUTOGENSTUDIO_DATABASE_URI"] = database_uri
+ if auth_config:
+ if not os.path.exists(auth_config):
+ typer.echo(f"Error: Auth config file not found: {auth_config}", err=True)
+ raise typer.Exit(1)
+ env_vars["AUTOGENSTUDIO_AUTH_CONFIG"] = auth_config
if upgrade_database:
env_vars["AUTOGENSTUDIO_UPGRADE_DATABASE"] = "1"
diff --git a/python/packages/autogen-studio/autogenstudio/database/db_manager.py b/python/packages/autogen-studio/autogenstudio/database/db_manager.py
index 8ebe19141..aca1f4c99 100644
--- a/python/packages/autogen-studio/autogenstudio/database/db_manager.py
+++ b/python/packages/autogen-studio/autogenstudio/database/db_manager.py
@@ -103,7 +103,7 @@ class DatabaseManager:
try:
# Disable foreign key checks for SQLite
if "sqlite" in str(self.engine.url):
- session.exec(text("PRAGMA foreign_keys=OFF"))
+ session.exec(text("PRAGMA foreign_keys=OFF")) # type: ignore
# Drop all tables
SQLModel.metadata.drop_all(self.engine)
@@ -111,7 +111,7 @@ class DatabaseManager:
# Re-enable foreign key checks for SQLite
if "sqlite" in str(self.engine.url):
- session.exec(text("PRAGMA foreign_keys=ON"))
+ session.exec(text("PRAGMA foreign_keys=ON")) # type: ignore
session.commit()
diff --git a/python/packages/autogen-studio/autogenstudio/datamodel/types.py b/python/packages/autogen-studio/autogenstudio/datamodel/types.py
index 28b6d1b78..fe595ffcc 100644
--- a/python/packages/autogen-studio/autogenstudio/datamodel/types.py
+++ b/python/packages/autogen-studio/autogenstudio/datamodel/types.py
@@ -93,7 +93,9 @@ class UISettings(BaseModel):
class SettingsConfig(BaseModel):
environment: List[EnvironmentVariable] = []
- default_model_client: Optional[ComponentModel] = OpenAIChatCompletionClient(model="gpt-4o-mini").dump_component()
+ default_model_client: Optional[ComponentModel] = OpenAIChatCompletionClient(
+ model="gpt-4o-mini", api_key="your-api-key"
+ ).dump_component()
ui: UISettings = UISettings()
diff --git a/python/packages/autogen-studio/autogenstudio/web/app.py b/python/packages/autogen-studio/autogenstudio/web/app.py
index 8fb892e04..d69191c2d 100644
--- a/python/packages/autogen-studio/autogenstudio/web/app.py
+++ b/python/packages/autogen-studio/autogenstudio/web/app.py
@@ -10,8 +10,10 @@ from fastapi.staticfiles import StaticFiles
from loguru import logger
from ..version import VERSION
+from .auth import authroutes
+from .auth.middleware import AuthMiddleware
from .config import settings
-from .deps import cleanup_managers, init_managers
+from .deps import cleanup_managers, init_auth_manager, init_managers, register_auth_dependencies
from .initialization import AppInitializer
from .routes import gallery, runs, sessions, settingsroute, teams, validation, ws
@@ -31,6 +33,8 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
# Initialize managers (DB, Connection, Team)
await init_managers(initializer.database_uri, initializer.config_dir, initializer.app_root)
+ await register_auth_dependencies(app, auth_manager)
+
# Any other initialization code
logger.info(
f"Application startup complete. Navigate to http://{os.environ.get('AUTOGENSTUDIO_HOST', '127.0.0.1')}:{os.environ.get('AUTOGENSTUDIO_PORT', '8081')}"
@@ -51,6 +55,7 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
logger.error(f"Error during shutdown: {str(e)}")
+auth_manager = init_auth_manager(initializer.config_dir)
# Create FastAPI application
app = FastAPI(lifespan=lifespan, debug=True)
@@ -67,6 +72,7 @@ app.add_middleware(
allow_methods=["*"],
allow_headers=["*"],
)
+app.add_middleware(AuthMiddleware, auth_manager=auth_manager)
# Create API router with version and documentation
api = FastAPI(
@@ -127,6 +133,13 @@ api.include_router(
tags=["gallery"],
responses={404: {"description": "Not found"}},
)
+# Include authentication routes
+api.include_router(
+ authroutes.router,
+ prefix="/auth",
+ tags=["auth"],
+ responses={404: {"description": "Not found"}},
+)
# Version endpoint
diff --git a/python/packages/autogen-studio/autogenstudio/web/auth/__init__.py b/python/packages/autogen-studio/autogenstudio/web/auth/__init__.py
new file mode 100644
index 000000000..29c65e346
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/web/auth/__init__.py
@@ -0,0 +1,21 @@
+from .authroutes import router
+from .dependencies import get_current_user, require_admin, require_authenticated, require_roles
+from .exceptions import AuthException
+from .manager import AuthManager
+from .middleware import AuthMiddleware
+from .models import AuthConfig, User
+from .wsauth import WebSocketAuthHandler
+
+__all__ = [
+ "AuthManager",
+ "AuthMiddleware",
+ "AuthConfig",
+ "User",
+ "AuthException",
+ "router",
+ "get_current_user",
+ "require_authenticated",
+ "require_roles",
+ "require_admin",
+ "WebSocketAuthHandler",
+]
diff --git a/python/packages/autogen-studio/autogenstudio/web/auth/authroutes.py b/python/packages/autogen-studio/autogenstudio/web/auth/authroutes.py
new file mode 100644
index 000000000..d042f3bbb
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/web/auth/authroutes.py
@@ -0,0 +1,194 @@
+import html
+from typing import Optional
+
+from fastapi import APIRouter, Cookie, Depends, HTTPException, Request, Response
+from fastapi.responses import JSONResponse
+from loguru import logger
+
+from .exceptions import ProviderAuthException
+from .manager import AuthManager
+from .models import User
+
+router = APIRouter()
+
+
+def get_auth_manager(request: Request) -> AuthManager:
+ """Get the auth manager from app state."""
+ if not hasattr(request.app.state, "auth_manager"):
+ raise HTTPException(status_code=500, detail="Authentication system not initialized")
+ return request.app.state.auth_manager
+
+
+def get_current_user(request: Request) -> User:
+ """Get the current authenticated user."""
+ if hasattr(request.state, "user"):
+ return request.state.user
+
+ # This shouldn't normally happen as middleware should set user
+ logger.warning("User not found in request state")
+ return User(id="anonymous", name="Anonymous User")
+
+
[email protected]("/login-url")
+async def get_login_url(auth_manager: AuthManager = Depends(get_auth_manager)):
+ """Get the URL for the frontend to redirect to for login."""
+ try:
+ login_url = await auth_manager.provider.get_login_url()
+ return {"login_url": login_url}
+ except Exception as e:
+ logger.error(f"Error getting login URL: {str(e)}")
+ raise HTTPException(status_code=500, detail=f"Failed to generate login URL: {str(e)}") from e
+
+
[email protected]("/callback")
+async def oauth_callback(
+ request: Request,
+ code: Optional[str] = None,
+ state: Optional[str] = None,
+ error: Optional[str] = None,
+ auth_manager: AuthManager = Depends(get_auth_manager),
+):
+ """
+ OAuth callback handler - used by OAuth providers to redirect after auth. This endpoint renders an HTML page that communicates with the parent window
+ to pass the token back to the main application.
+ """
+ if error:
+ logger.error(f"OAuth callback error: {error}")
+ # Return HTML that sends error to parent window
+ escaped_error = html.escape(error)
+ html_content = f"""
+ <!DOCTYPE html>
+ <html>
+ <head>
+ <title>Authentication Result</title>
+ <script>
+ window.onload = function() {{
+ if (window.opener) {{
+ // Send error to parent window
+ window.opener.postMessage({{
+ type: 'auth-error',
+ error: '{escaped_error}'
+ }}, '*');
+ // Close this window
+ window.close();
+ }} else {{
+ // Redirect to main app with error
+ window.location.href = '/?auth_error={escaped_error}';
+ }}
+ }};
+ </script>
+ </head>
+ <body>
+ <p>Authentication failed. This window should close automatically.</p>
+ </html>
+ """
+ return Response(content=html_content, media_type="text/html")
+
+ # Add guard for code parameter
+ if not code:
+ logger.error("OAuth callback missing required 'code' parameter")
+ raise HTTPException(status_code=400, detail="Missing required 'code' parameter")
+
+ try:
+ # Process the authentication callback
+ user = await auth_manager.provider.process_callback(code, state)
+
+ # Create JWT token
+ token = auth_manager.create_token(user)
+
+ # Return HTML that sends token to parent window
+ html_content = f"""
+ <!DOCTYPE html>
+ <html>
+ <head>
+ <title>Authentication Complete</title>
+ <script>
+ window.onload = function() {{
+ const authResult = {{
+ type: 'auth-success',
+ token: '{token}',
+ user: {{
+ id: '{user.id}',
+ name: '{user.name}',
+ email: '{user.email or ""}',
+ provider: '{user.provider}'
+ }}
+ }};
+ if (window.opener) {{
+ // Send token to parent window
+ window.opener.postMessage(authResult, '*');
+ // Close this window
+ window.close();
+ }} else {{
+ // Redirect to main app with token
+ localStorage.setItem('auth_token', '{token}');
+ window.location.href = '/';
+ }}
+ }};
+ </script>
+ </head>
+ <body>
+ <p>Authentication successful. This window should close automatically.</p>
+ </body>
+ </html>
+ """
+ return Response(content=html_content, media_type="text/html")
+
+ except ProviderAuthException as e:
+ logger.error(f"OAuth callback provider error: {str(e)}")
+ raise HTTPException(status_code=401, detail=str(e)) from e
+ except Exception as e:
+ logger.error(f"Unexpected OAuth callback error: {str(e)}")
+ raise HTTPException(status_code=500, detail=f"Authentication failed: {str(e)}") from e
+
+
[email protected]("/callback-handler")
+async def handle_callback(request: Request, auth_manager: AuthManager = Depends(get_auth_manager)):
+ """
+ Handle authentication code/token from frontend.This endpoint is used when the frontend handles the OAuth flow and
+ needs to exchange the code for a token.
+ """
+ try:
+ data = await request.json()
+ code = data.get("code")
+ state = data.get("state")
+
+ if not code:
+ raise HTTPException(status_code=400, detail="Authorization code is required")
+
+ # Process the authentication code
+ user = await auth_manager.provider.process_callback(code, state)
+
+ # Create JWT token
+ token = auth_manager.create_token(user)
+
+ # Return token and user info
+ return {
+ "token": token,
+ "user": {"id": user.id, "name": user.name, "email": user.email, "provider": user.provider},
+ }
+
+ except ProviderAuthException as e:
+ logger.error(f"Callback handler provider error: {str(e)}")
+ raise HTTPException(status_code=401, detail=str(e)) from e
+ except Exception as e:
+ logger.error(f"Unexpected callback handler error: {str(e)}")
+ raise HTTPException(status_code=500, detail=f"Authentication failed: {str(e)}") from e
+
+
+async def get_user_info(current_user: User = Depends(get_current_user)):
+ """Get information about the currently authenticated user."""
+ return {
+ "id": current_user.id,
+ "name": current_user.name,
+ "email": current_user.email,
+ "provider": current_user.provider,
+ "roles": current_user.roles,
+ }
+
+
+async def get_auth_type(auth_manager: AuthManager = Depends(get_auth_manager)):
+ """Get the configured authentication type."""
+ return {"type": auth_manager.config.type, "exclude_paths": auth_manager.config.exclude_paths}
diff --git a/python/packages/autogen-studio/autogenstudio/web/auth/dependencies.py b/python/packages/autogen-studio/autogenstudio/web/auth/dependencies.py
new file mode 100644
index 000000000..8b21f559b
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/web/auth/dependencies.py
@@ -0,0 +1,68 @@
+from typing import List
+
+from fastapi import Depends, HTTPException, Request, WebSocket, status
+
+from .exceptions import ForbiddenException
+from .manager import AuthManager
+from .models import User
+
+
+async def get_auth_manager(request: Request) -> AuthManager:
+ """Dependency provider for auth manager"""
+ if hasattr(request.app.state, "auth_manager"):
+ return request.app.state.auth_manager
+ # We can remove this part since it depends on the global in deps.py
+ # It's better to throw the error directly
+ raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Auth manager not initialized")
+
+
+def get_ws_auth_manager(websocket: WebSocket) -> AuthManager:
+ """Get the auth manager from app state for WebSocket connections."""
+ if hasattr(websocket.app.state, "auth_manager"):
+ return websocket.app.state.auth_manager
+ # Similar to above, remove the global reference
+ raise HTTPException(
+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Authentication system not initialized"
+ )
+
+
+def get_current_user(request: Request) -> User:
+ """Get the current authenticated user."""
+ if hasattr(request.state, "user"):
+ return request.state.user
+
+ # Fall back to anonymous user if middleware didn't set user
+ # This should generally not happen
+ return User(id="anonymous", name="Anonymous User")
+
+
+def require_authenticated(user: User = Depends(get_current_user)) -> User:
+ """Require that the user is authenticated (not anonymous)."""
+ if user.id == "anonymous":
+ raise HTTPException(status_code=401, detail="Authentication required")
+ return user
+
+
+def require_roles(required_roles: List[str]):
+ """
+ Dependency factory to require specific roles.
+ Example:
+ @router.get("/admin-only")
+ async def admin_endpoint(user: User = Depends(require_roles(["admin"]))):
+ # Only users with admin role will get here
+ return {"message": "Welcome, admin!"}
+ """
+
+ def _require_roles(user: User = Depends(require_authenticated)) -> User:
+ """Require that the user has at least one of the specified roles."""
+ user_roles = set(user.roles or [])
+ if not any(role in user_roles for role in required_roles):
+ raise ForbiddenException(f"This endpoint requires one of these roles: {', '.join(required_roles)}")
+ return user
+
+ return _require_roles
+
+
+def require_admin(user: User = Depends(require_roles(["admin"]))) -> User:
+ """Convenience dependency to require admin role."""
+ return user
diff --git a/python/packages/autogen-studio/autogenstudio/web/auth/exceptions.py b/python/packages/autogen-studio/autogenstudio/web/auth/exceptions.py
new file mode 100644
index 000000000..1b6415977
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/web/auth/exceptions.py
@@ -0,0 +1,42 @@
+from fastapi import HTTPException
+
+
+class AuthException(HTTPException):
+ """Base class for authentication exceptions."""
+
+ def __init__(self, detail: str, headers: dict | None = None):
+ super().__init__(status_code=401, detail=detail, headers=headers)
+
+
+class InvalidTokenException(AuthException):
+ """Exception raised when token is invalid."""
+
+ def __init__(self):
+ super().__init__(detail="Invalid or expired token")
+
+
+class MissingTokenException(AuthException):
+ """Exception raised when token is missing."""
+
+ def __init__(self):
+ super().__init__(detail="Authentication token is missing")
+
+
+class ProviderAuthException(AuthException):
+ """Exception raised when authentication with provider fails."""
+
+ def __init__(self, provider: str, detail: str):
+ super().__init__(detail=f"Authentication failed with {provider}: {detail}")
+
+
+class ConfigurationException(Exception):
+ """Exception raised when there's an issue with auth configuration."""
+
+ pass
+
+
+class ForbiddenException(HTTPException):
+ """Exception raised when user doesn't have permission."""
+
+ def __init__(self, detail: str = "You don't have permission to access this resource"):
+ super().__init__(status_code=403, detail=detail)
diff --git a/python/packages/autogen-studio/autogenstudio/web/auth/manager.py b/python/packages/autogen-studio/autogenstudio/web/auth/manager.py
new file mode 100644
index 000000000..846f8f124
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/web/auth/manager.py
@@ -0,0 +1,150 @@
+import os
+from datetime import datetime, timedelta
+from typing import Any, Dict, Optional
+
+import jwt
+import yaml
+from fastapi import Request
+from loguru import logger
+from typing_extensions import Self
+
+from .exceptions import ConfigurationException, InvalidTokenException, MissingTokenException
+from .models import AuthConfig, User
+from .providers import AuthProvider, FirebaseAuthProvider, GithubAuthProvider, MSALAuthProvider, NoAuthProvider
+
+
+class AuthManager:
+ """
+ Manages authentication for the application.
+ Handles token creation, validation, and provider selection.
+ """
+
+ def __init__(self, config: AuthConfig):
+ """Initialize the auth manager with configuration."""
+ self.config = config
+ self.provider = self._create_provider()
+ logger.info(f"Initialized auth manager with provider: {config.type}")
+
+ def _create_provider(self) -> AuthProvider:
+ """Create the appropriate auth provider based on config."""
+ try:
+ if self.config.type == "github":
+ return GithubAuthProvider(self.config)
+ elif self.config.type == "msal":
+ return MSALAuthProvider(self.config)
+ elif self.config.type == "firebase":
+ return FirebaseAuthProvider(self.config)
+ else:
+ return NoAuthProvider()
+ except Exception as e:
+ logger.error(f"Failed to create auth provider: {str(e)}")
+ # Fall back to no auth if provider creation fails
+ return NoAuthProvider()
+
+ def create_token(self, user: User) -> str:
+ """Create a JWT token for authenticated user."""
+ if not self.config.jwt_secret:
+ logger.warning("JWT secret not configured, using insecure token")
+ return "dummy_token_" + user.id
+
+ expiry = datetime.utcnow() + timedelta(minutes=self.config.token_expiry_minutes)
+ payload = {
+ "sub": user.id,
+ "name": user.name,
+ "email": user.email,
+ "provider": user.provider,
+ "roles": user.roles,
+ "exp": expiry,
+ }
+ return jwt.encode(payload, self.config.jwt_secret, algorithm="HS256")
+
+ async def authenticate_request(self, request: Request) -> User:
+ """Authenticate a request and return user information."""
+ # Check if path should be excluded from auth
+ # print("************ authenticating request ************", request.url.path, self.config.type )
+ if request.url.path in self.config.exclude_paths:
+ return User(id="[email protected]", name="Default User", provider="none")
+
+ if self.config.type == "none":
+ # No auth mode - return default user
+ return User(id="[email protected]", name="Default User", provider="none")
+
+ # Extract token from Authorization header
+ auth_header = request.headers.get("Authorization")
+ if not auth_header or not auth_header.startswith("Bearer "):
+ raise MissingTokenException()
+
+ token = auth_header.replace("Bearer ", "")
+
+ try:
+ if not self.config.jwt_secret:
+ # For development with no JWT secret
+ logger.warning("JWT secret not configured, accepting all tokens")
+ return User(id="[email protected]", name="Default User", provider="none")
+
+ # Decode and validate JWT
+ payload = jwt.decode(token, self.config.jwt_secret, algorithms=["HS256"])
+
+ # Create User object from token payload
+ return User(
+ id=payload.get("sub"),
+ name=payload.get("name", "Unknown User"),
+ email=payload.get("email"),
+ provider=payload.get("provider", "jwt"),
+ roles=payload.get("roles", ["user"]),
+ )
+
+ except jwt.ExpiredSignatureError:
+ logger.warning(f"Expired token received: {token[:10]}...")
+ raise InvalidTokenException() from InvalidTokenException()
+ except jwt.InvalidTokenError:
+ logger.warning(f"Invalid token received: {token[:10]}...")
+ raise InvalidTokenException() from InvalidTokenException()
+
+ def is_valid_token(self, token: str) -> bool:
+ """Check if a JWT token is valid."""
+ if not self.config.jwt_secret:
+ return True # No validation in dev mode
+
+ try:
+ jwt.decode(token, self.config.jwt_secret, algorithms=["HS256"])
+ return True
+ except jwt.ExpiredSignatureError:
+ logger.warning("Token has expired")
+ return False
+
+ @classmethod
+ def from_yaml(cls, yaml_path: str) -> Self:
+ """Create AuthManager from YAML config file."""
+ try:
+ with open(yaml_path, "r") as f:
+ config_data = yaml.safe_load(f)
+ config = AuthConfig(**config_data)
+ return cls(config)
+ except Exception as e:
+ logger.error(f"Failed to load auth config from {yaml_path}: {str(e)}")
+ raise ConfigurationException(f"Failed to load auth config: {str(e)}") from ConfigurationException()
+
+ @classmethod
+ def from_env(cls) -> Self:
+ """Create AuthManager from environment variables."""
+ auth_type = os.environ.get("AUTOGENSTUDIO_AUTH_TYPE", "none")
+
+ config_dict = {
+ "type": auth_type,
+ "jwt_secret": os.environ.get("AUTOGENSTUDIO_JWT_SECRET"),
+ "token_expiry_minutes": int(os.environ.get("AUTOGENSTUDIO_TOKEN_EXPIRY", "60")),
+ }
+
+ # Add provider-specific config based on the auth type
+ if auth_type == "github":
+ config_dict["github"] = {
+ "client_id": os.environ.get("AUTOGENSTUDIO_GITHUB_CLIENT_ID", ""),
+ "client_secret": os.environ.get("AUTOGENSTUDIO_GITHUB_CLIENT_SECRET", ""),
+ "callback_url": os.environ.get("AUTOGENSTUDIO_GITHUB_CALLBACK_URL", ""),
+ "scopes": os.environ.get("AUTOGENSTUDIO_GITHUB_SCOPES", "user:email").split(","),
+ }
+ # Add other provider config parsing here
+
+ config = AuthConfig(**config_dict)
+ return cls(config)
diff --git a/python/packages/autogen-studio/autogenstudio/web/auth/middleware.py b/python/packages/autogen-studio/autogenstudio/web/auth/middleware.py
new file mode 100644
index 000000000..b6aef611c
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/web/auth/middleware.py
@@ -0,0 +1,119 @@
+import json
+import re
+
+from fastapi import Request, Response, WebSocket
+from loguru import logger
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.status import HTTP_401_UNAUTHORIZED
+
+from .exceptions import AuthException
+from .manager import AuthManager
+
+
+class AuthMiddleware(BaseHTTPMiddleware):
+ """
+ Middleware for handling authentication for all routes.
+ """
+
+ def __init__(self, app, auth_manager: AuthManager):
+ super().__init__(app)
+ self.auth_manager = auth_manager
+
+ async def dispatch(self, request: Request, call_next):
+ """Process each request, authenticating as needed."""
+ # Skip auth for OPTIONS requests (CORS preflight)
+ if request.method == "OPTIONS":
+ return await call_next(request)
+
+ path = request.url.path
+
+ if (
+ path == "/"
+ or path == "/login"
+ or path == "/callback"
+ or path == "/images"
+ or path.startswith("/page-data/")
+ or path in self.auth_manager.config.exclude_paths
+ or re.match(r"/[^/]+\.(js|css|png|ico|svg|jpg|webmanifest|json)$", path)
+ or re.match(r".*\.(js\.map|svg)$", path)
+ ):
+ return await call_next(request)
+
+ # Skip auth if disabled
+ if self.auth_manager.config.type == "none":
+ request.state.user = await self.auth_manager.authenticate_request(request)
+ return await call_next(request)
+
+ # WebSocket handling (special case)
+ if request.url.path.startswith("/api/ws"):
+ # For WebSockets, we'll add auth in the WebSocket accept handler
+ # Just pass through here
+ return await call_next(request)
+
+ # Handle authentication for all other requests
+ try:
+ user = await self.auth_manager.authenticate_request(request)
+ # Add user to request state for use in route handlers
+ request.state.user = user
+ return await call_next(request)
+
+ except AuthException as e:
+ # Handle authentication errors
+ return Response(
+ status_code=HTTP_401_UNAUTHORIZED,
+ content=json.dumps({"status": False, "detail": e.detail}),
+ media_type="application/json",
+ headers=e.headers or {},
+ )
+ except Exception as e:
+ # Log unexpected errors
+ logger.error(f"Unexpected error in auth middleware: {str(e)}")
+ return Response(
+ status_code=HTTP_401_UNAUTHORIZED,
+ content=json.dumps({"status": False, "detail": "Authentication failed"}),
+ media_type="application/json",
+ )
+
+
+class WebSocketAuthMiddleware:
+ """
+ Helper for authenticating WebSocket connections.
+ Not a middleware in the traditional sense - used in WebSocket endpoint.
+ """
+
+ def __init__(self, auth_manager: AuthManager):
+ self.auth_manager = auth_manager
+
+ async def authenticate(self, websocket: WebSocket) -> bool:
+ """
+ Authenticate a WebSocket connection.
+ Returns True if authenticated, False otherwise.
+ """
+ if self.auth_manager.config.type == "none":
+ return True
+
+ try:
+ # Extract token from query params or cookies
+ token = None
+ if "token" in websocket.query_params:
+ token = websocket.query_params["token"]
+ elif "authorization" in websocket.headers:
+ auth_header = websocket.headers["authorization"]
+ if auth_header.startswith("Bearer "):
+ token = auth_header.replace("Bearer ", "")
+
+ if not token:
+ logger.warning("No token found for WebSocket connection")
+ return False
+
+ # Validate token
+ valid = self.auth_manager.is_valid_token(token)
+ if not valid:
+ logger.warning("Invalid token for WebSocket connection")
+ return False
+
+ return True
+
+ except Exception as e:
+ logger.error(f"WebSocket auth error: {str(e)}")
+ return False
diff --git a/python/packages/autogen-studio/autogenstudio/web/auth/models.py b/python/packages/autogen-studio/autogenstudio/web/auth/models.py
new file mode 100644
index 000000000..431114fae
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/web/auth/models.py
@@ -0,0 +1,93 @@
+import os
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class GithubAuthConfig(BaseModel):
+ client_id: str
+ client_secret: str
+ callback_url: str
+ scopes: List[str] = ["user:email"]
+
+
+class MSALAuthConfig(BaseModel):
+ tenant_id: str
+ client_id: str
+ client_secret: str
+ callback_url: str
+ scopes: List[str] = ["User.Read"]
+
+
+class FirebaseAuthConfig(BaseModel):
+ api_key: str
+ auth_domain: str
+ project_id: str
+
+
+class AuthConfig(BaseModel):
+ """Authentication configuration model for the application."""
+
+ type: Literal["none", "github", "msal", "firebase"] = "none"
+ github: Optional[GithubAuthConfig] = None
+ msal: Optional[MSALAuthConfig] = None
+ firebase: Optional[FirebaseAuthConfig] = None
+ jwt_secret: Optional[str] = None
+ token_expiry_minutes: int = 60
+ exclude_paths: List[str] = [
+ "/", # root for serving frontend
+ "/api/health",
+ "/api/version",
+ "/api/auth/login-url",
+ "/api/auth/callback-handler",
+ "/api/auth/callback",
+ "/api/auth/type",
+ ]
+
+ @field_validator("github")
+ @classmethod
+ def validate_github_config(cls, v, info):
+ """Validate GitHub config is present when github type is selected."""
+ values = info.data
+ if values.get("type") == "github" and v is None:
+ raise ValueError("GitHub configuration required when type is 'github'")
+ return v
+
+ @field_validator("msal")
+ @classmethod
+ def validate_msal_config(cls, v, info):
+ """Validate MSAL config is present when msal type is selected."""
+ values = info.data
+ if values.get("type") == "msal" and v is None:
+ raise ValueError("MSAL configuration required when type is 'msal'")
+ return v
+
+ @field_validator("firebase")
+ @classmethod
+ def validate_firebase_config(cls, v, info):
+ """Validate Firebase config is present when firebase type is selected."""
+ values = info.data
+ if values.get("type") == "firebase" and v is None:
+ raise ValueError("Firebase configuration required when type is 'firebase'")
+ return v
+
+ @field_validator("jwt_secret")
+ @classmethod
+ def validate_jwt_secret(cls, v, info):
+ """Validate JWT secret is present for auth types other than 'none'."""
+ values = info.data
+ if values.get("type") != "none" and not v:
+ raise ValueError("JWT secret is required for authentication")
+ return v
+
+
+class User(BaseModel):
+ """User model for authenticated users."""
+
+ id: str
+ name: str
+ email: Optional[str] = None
+ avatar_url: Optional[str] = None
+ provider: Optional[str] = None
+ roles: List[str] = ["user"]
+ metadata: Optional[Dict[str, Any]] = None
diff --git a/python/packages/autogen-studio/autogenstudio/web/auth/providers.py b/python/packages/autogen-studio/autogenstudio/web/auth/providers.py
new file mode 100644
index 000000000..974c9bd90
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/web/auth/providers.py
@@ -0,0 +1,208 @@
+import json
+import secrets
+from abc import ABC, abstractmethod
+from urllib.parse import urlencode
+
+import httpx
+from loguru import logger
+
+from .exceptions import ConfigurationException, ProviderAuthException
+from .models import AuthConfig, GithubAuthConfig, User
+
+
+class AuthProvider(ABC):
+ """Base authentication provider interface."""
+
+ @abstractmethod
+ async def get_login_url(self) -> str:
+ """Return the URL for initiating login."""
+ pass
+
+ @abstractmethod
+ async def process_callback(self, code: str, state: str | None = None) -> User:
+ """Process the OAuth callback code and return user data."""
+ pass
+
+ @abstractmethod
+ async def validate_token(self, token: str) -> bool:
+ """Validate a provider token and return boolean indicating validity."""
+ pass
+
+
+class NoAuthProvider(AuthProvider):
+ """Default provider that always authenticates (for development)."""
+
+ def __init__(self):
+ self.default_user = User(
+ id="[email protected]", name="Default User", email="[email protected]", provider="none"
+ )
+
+ async def get_login_url(self) -> str:
+ """Return the URL for initiating login."""
+ return "/api/auth/callback?automatic=true"
+
+ async def process_callback(self, code: str | None = None, state: str | None = None) -> User:
+ """Process the OAuth callback code and return user data."""
+ return self.default_user
+
+ async def validate_token(self, token: str) -> bool:
+ """Validate a provider token and return boolean indicating validity."""
+ return True
+
+
+class GithubAuthProvider(AuthProvider):
+ """GitHub OAuth authentication provider."""
+
+ def __init__(self, config: AuthConfig):
+ if not config.github:
+ raise ConfigurationException("GitHub auth configuration is missing")
+
+ self.config = config.github
+ self.client_id = self.config.client_id
+ self.client_secret = self.config.client_secret
+ self.callback_url = self.config.callback_url
+ self.scopes = self.config.scopes
+
+ async def get_login_url(self) -> str:
+ """Return the GitHub OAuth login URL."""
+ state = secrets.token_urlsafe(32) # Generate a secure random state
+ params = {
+ "client_id": self.client_id,
+ "redirect_uri": self.callback_url,
+ "scope": " ".join(self.scopes),
+ "state": state,
+ "allow_signup": "true",
+ }
+ return f"https://github.com/login/oauth/authorize?{urlencode(params)}"
+
+ async def process_callback(self, code: str, state: str | None = None) -> User:
+ """Exchange code for access token and get user info."""
+ if not code:
+ raise ProviderAuthException("github", "Authorization code is missing")
+
+ # Exchange code for access token
+ token_url = "https://github.com/login/oauth/access_token"
+ token_data = {
+ "client_id": self.client_id,
+ "client_secret": self.client_secret,
+ "code": code,
+ "redirect_uri": self.callback_url,
+ }
+
+ async with httpx.AsyncClient() as client:
+ token_response = await client.post(token_url, data=token_data, headers={"Accept": "application/json"})
+
+ if token_response.status_code != 200:
+ logger.error(f"GitHub token exchange failed: {token_response.text}")
+ raise ProviderAuthException("github", "Failed to exchange code for access token")
+
+ token_json = token_response.json()
+ access_token = token_json.get("access_token")
+
+ if not access_token:
+ logger.error(f"No access token in GitHub response: {token_json}")
+ raise ProviderAuthException("github", "No access token received")
+
+ # Get user info with the access token
+ user_response = await client.get(
+ "https://api.github.com/user",
+ headers={"Authorization": f"token {access_token}", "Accept": "application/json"},
+ )
+
+ if user_response.status_code != 200:
+ logger.error(f"GitHub user info fetch failed: {user_response.text}")
+ raise ProviderAuthException("github", "Failed to fetch user information")
+
+ user_data = user_response.json()
+
+ # Get user emails if scope includes email
+ email = None
+ if "user:email" in self.scopes:
+ email_response = await client.get(
+ "https://api.github.com/user/emails",
+ headers={"Authorization": f"token {access_token}", "Accept": "application/json"},
+ )
+
+ if email_response.status_code == 200:
+ emails = email_response.json()
+ primary_emails = [e for e in emails if e.get("primary") is True]
+ if primary_emails:
+ email = primary_emails[0].get("email")
+
+ # Create User object
+ return User(
+ id=str(user_data.get("id")),
+ name=user_data.get("name") or user_data.get("login"),
+ email=email,
+ avatar_url=user_data.get("avatar_url"),
+ provider="github",
+ metadata={
+ "login": user_data.get("login"),
+ "github_id": user_data.get("id"),
+ "access_token": access_token,
+ },
+ )
+
+ async def validate_token(self, token: str) -> bool:
+ """Validate a GitHub access token."""
+ async with httpx.AsyncClient() as client:
+ response = await client.get(
+ "https://api.github.com/user", headers={"Authorization": f"token {token}", "Accept": "application/json"}
+ )
+ return response.status_code == 200
+
+
+class MSALAuthProvider(AuthProvider):
+ """Microsoft Authentication Library (MSAL) provider."""
+
+ def __init__(self, config: AuthConfig):
+ if not config.msal:
+ raise ConfigurationException("MSAL auth configuration is missing")
+
+ self.config = config.msal
+ # MSAL provider implementation would go here
+ # This is a placeholder - full implementation would use msal library
+
+ async def get_login_url(self) -> str:
+ """Return the MSAL OAuth login URL."""
+ # Placeholder - would use MSAL library to generate auth URL
+ return "https://login.microsoftonline.com/placeholder"
+
+ async def process_callback(self, code: str, state: str | None = None) -> User:
+ """Process the MSAL callback."""
+ # Placeholder - would use MSAL library to process code and get token/user info
+ return User(id="msal_user_id", name="MSAL User", provider="msal")
+
+ async def validate_token(self, token: str) -> bool:
+ """Validate an MSAL token."""
+ # Placeholder - would validate token with MSAL library
+ return False
+
+
+class FirebaseAuthProvider(AuthProvider):
+ """Firebase authentication provider."""
+
+ def __init__(self, config: AuthConfig):
+ if not config.firebase:
+ raise ConfigurationException("Firebase auth configuration is missing")
+
+ self.config = config.firebase
+ # Firebase provider implementation would go here
+ # This is a placeholder - full implementation would use Firebase Admin SDK
+
+ async def get_login_url(self) -> str:
+ """Return information for Firebase auth (used differently than OAuth)."""
+ # Firebase auth is typically handled on the client side
+ return json.dumps(
+ {"apiKey": self.config.api_key, "authDomain": self.config.auth_domain, "projectId": self.config.project_id}
+ )
+
+ async def process_callback(self, code: str, state: str | None = None) -> User:
+ """Process a Firebase ID token."""
+ # Placeholder - would verify Firebase ID token and get user info
+ return User(id="firebase_user_id", name="Firebase User", provider="firebase")
+
+ async def validate_token(self, token: str) -> bool:
+ """Validate a Firebase ID token."""
+ # Placeholder - would validate token with Firebase Admin SDK
+ return False
diff --git a/python/packages/autogen-studio/autogenstudio/web/auth/wsauth.py b/python/packages/autogen-studio/autogenstudio/web/auth/wsauth.py
new file mode 100644
index 000000000..bc2e2d79e
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/web/auth/wsauth.py
@@ -0,0 +1,87 @@
+import jwt
+from fastapi import WebSocket, WebSocketDisconnect, status
+from loguru import logger
+
+from .manager import AuthManager
+from .models import User
+
+
+class WebSocketAuthHandler:
+ """
+ Helper class for authenticating WebSocket connections.
+ """
+
+ def __init__(self, auth_manager: AuthManager):
+ self.auth_manager = auth_manager
+
+ async def authenticate(self, websocket: WebSocket) -> tuple[bool, User | None]:
+ """
+ Authenticate a WebSocket connection.
+ Returns (success, user) tuple.
+ """
+ if self.auth_manager.config.type == "none":
+ # No authentication required
+ return True, User(id="[email protected]", name="Default User", provider="none")
+
+ try:
+ # Extract token from query params or headers query_params)
+ token = None
+ if "token" in websocket.query_params:
+ token = websocket.query_params["token"]
+ elif "authorization" in websocket.headers:
+ auth_header = websocket.headers["authorization"]
+ if auth_header.startswith("Bearer "):
+ token = auth_header.replace("Bearer ", "")
+
+ if not token:
+ logger.warning("No token found for WebSocket connection")
+ return False, None
+
+ # Validate token
+ if not self.auth_manager.config.jwt_secret:
+ # Development mode with no JWT secret
+ return True, User(id="[email protected]", name="Default User", provider="none")
+
+ try:
+ # Decode and validate JWT
+ if not self.auth_manager.config.jwt_secret:
+ logger.warning("Invalid token for WebSocket connection")
+ return False, None
+ payload = jwt.decode(token, self.auth_manager.config.jwt_secret, algorithms=["HS256"])
+
+ # Create User object from token payload
+ user = User(
+ id=payload.get("sub"),
+ name=payload.get("name", "Unknown User"),
+ email=payload.get("email"),
+ provider=payload.get("provider", "jwt"),
+ roles=payload.get("roles", ["user"]),
+ )
+
+ return True, user
+
+ except jwt.ExpiredSignatureError:
+ logger.warning("Expired token for WebSocket connection")
+ return False, None
+ except jwt.InvalidTokenError:
+ logger.warning("Invalid token for WebSocket connection")
+ return False, None
+
+ except Exception as e:
+ logger.error(f"WebSocket auth error: {str(e)}")
+ return False, None
+
+ async def on_connect(self, websocket: WebSocket) -> User | None:
+ """
+ Handle WebSocket connection with authentication.
+ Returns authenticated user if successful, otherwise closes the connection.
+ """
+ success, user = await self.authenticate(websocket)
+
+ if not success:
+ # Authentication failed, close the connection
+ await websocket.close(code=status.WS_1008_POLICY_VIOLATION, reason="Authentication failed")
+ raise WebSocketDisconnect(code=status.WS_1008_POLICY_VIOLATION)
+
+ # Authentication successful, return the user
+ return user
diff --git a/python/packages/autogen-studio/autogenstudio/web/deps.py b/python/packages/autogen-studio/autogenstudio/web/deps.py
index d2623a6f2..50490f607 100644
--- a/python/packages/autogen-studio/autogenstudio/web/deps.py
+++ b/python/packages/autogen-studio/autogenstudio/web/deps.py
@@ -1,13 +1,16 @@
# api/deps.py
import logging
+import os
from contextlib import contextmanager
from pathlib import Path
from typing import Optional
-from fastapi import Depends, HTTPException, status
+from fastapi import Depends, FastAPI, HTTPException, Request, WebSocket, status
from ..database import DatabaseManager
from ..teammanager import TeamManager
+from .auth import AuthConfig, AuthManager, AuthMiddleware
+from .auth.dependencies import get_auth_manager
from .config import settings
from .managers.connection import WebSocketManager
@@ -17,7 +20,7 @@ logger = logging.getLogger(__name__)
_db_manager: Optional[DatabaseManager] = None
_websocket_manager: Optional[WebSocketManager] = None
_team_manager: Optional[TeamManager] = None
-
+_auth_manager: Optional[AuthManager] = None
# Context manager for database sessions
@@ -37,9 +40,6 @@ def get_db_context():
) from e
-# Dependency providers
-
-
async def get_db() -> DatabaseManager:
"""Dependency provider for database manager"""
if not _db_manager:
@@ -68,16 +68,49 @@ async def get_team_manager() -> TeamManager:
# Authentication dependency
-async def get_current_user(
- # Add your authentication logic here
- # For example: token: str = Depends(oauth2_scheme)
-) -> str:
- """
- Dependency for getting the current authenticated user.
- Replace with your actual authentication logic.
- """
- # Implement your user authentication here
- return "user_id" # Replace with actual user identification
+async def get_current_user(request: Request) -> str:
+ """Get the current authenticated user."""
+ if hasattr(request.state, "user"):
+ return request.state.user.id
+
+ # Fallback for routes not protected by auth middleware
+ auth_manager = await get_auth_manager(request)
+ if auth_manager.config.type == "none":
+ return settings.DEFAULT_USER_ID
+
+ raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Authentication required")
+
+
+def init_auth_manager(config_dir: Path) -> AuthManager:
+ """Initialize authentication manager"""
+ auth_config_path = os.environ.get("AUTOGENSTUDIO_AUTH_CONFIG")
+
+ if auth_config_path and os.path.exists(auth_config_path):
+ try:
+ auth_manager = AuthManager.from_yaml(auth_config_path)
+ logger.info(f"Authentication initialized with provider: {auth_manager.config.type}")
+ return auth_manager
+ except Exception as e:
+ logger.error(f"Failed to initialize authentication from config file: {str(e)}")
+ logger.warning("Falling back to no authentication")
+
+ # Default or fallback
+ config = AuthConfig(type="none")
+ auth_manager = AuthManager(config)
+ logger.info("Authentication disabled (no config provided)")
+ return auth_manager
+
+
+async def register_auth_dependencies(app: FastAPI, auth_manager: AuthManager) -> None:
+ """Register authentication manager with application"""
+ global _auth_manager
+ _auth_manager = auth_manager
+ app.state.auth_manager = auth_manager
+
+ for route in app.routes:
+ # print(" *** Route: ", route.path)
+ if hasattr(route, "app") and isinstance(route.app, FastAPI):
+ route.app.state.auth_manager = auth_manager
# Manager initialization and cleanup
@@ -113,7 +146,7 @@ async def init_managers(database_uri: str, config_dir: str | Path, app_root: str
async def cleanup_managers() -> None:
"""Cleanup and shutdown all manager instances"""
- global _db_manager, _websocket_manager, _team_manager
+ global _db_manager, _websocket_manager, _team_manager, _auth_manager
logger.info("Cleaning up managers...")
@@ -129,6 +162,8 @@ async def cleanup_managers() -> None:
# TeamManager doesn't need explicit cleanup since WebSocketManager handles it
_team_manager = None
+ _auth_manager = None
+
# Cleanup database manager last
if _db_manager:
try:
@@ -150,6 +185,7 @@ def get_manager_status() -> dict:
"database_manager": _db_manager is not None,
"websocket_manager": _websocket_manager is not None,
"team_manager": _team_manager is not None,
+ "auth_manager": _auth_manager is not None,
}
diff --git a/python/packages/autogen-studio/autogenstudio/web/routes/ws.py b/python/packages/autogen-studio/autogenstudio/web/routes/ws.py
index 06f4f9595..df183482e 100644
--- a/python/packages/autogen-studio/autogenstudio/web/routes/ws.py
+++ b/python/packages/autogen-studio/autogenstudio/web/routes/ws.py
@@ -4,9 +4,12 @@ import json
from datetime import datetime
from fastapi import APIRouter, Depends, WebSocket, WebSocketDisconnect
+from fastapi.websockets import WebSocketState
from loguru import logger
from ...datamodel import Run, RunStatus
+from ..auth.dependencies import get_ws_auth_manager
+from ..auth.wsauth import WebSocketAuthHandler
from ..deps import get_db, get_websocket_manager
from ..managers import WebSocketManager
@@ -19,27 +22,72 @@ async def run_websocket(
run_id: int,
ws_manager: WebSocketManager = Depends(get_websocket_manager),
db=Depends(get_db),
+ auth_manager=Depends(get_ws_auth_manager),
):
"""WebSocket endpoint for run communication"""
- # Verify run exists and is in valid state
- run_response = db.get(Run, filters={"id": run_id}, return_json=False)
- if not run_response.status or not run_response.data:
- logger.warning(f"Run not found: {run_id}")
- await websocket.close(code=4004, reason="Run not found")
- return
-
- run = run_response.data[0]
- if run.status not in [RunStatus.CREATED, RunStatus.ACTIVE]:
- await websocket.close(code=4003, reason="Run not in valid state")
- return
-
- # Connect websocket
- connected = await ws_manager.connect(websocket, run_id)
- if not connected:
- await websocket.close(code=4002, reason="Failed to establish connection")
- return
+
+ async def start_stream_wrapper(run_id, task, team_config):
+ try:
+ await ws_manager.start_stream(run_id, task, team_config)
+ except Exception as e:
+ logger.error(f"Error in start_stream for run {run_id}: {str(e)}")
+ # Optionally notify the client about the error
+ if websocket.client_state == WebSocketState.CONNECTED:
+ await websocket.send_json(
+ {
+ "type": "error",
+ "error": f"Stream processing error: {str(e)}",
+ "timestamp": datetime.utcnow().isoformat(),
+ }
+ )
try:
+ # Verify run exists before connecting
+ run_response = db.get(Run, filters={"id": run_id}, return_json=False)
+ if not run_response.status or not run_response.data:
+ await websocket.close(code=4004, reason="Run not found")
+ return
+
+ run = run_response.data[0]
+
+ if run.status not in [RunStatus.CREATED, RunStatus.ACTIVE]:
+ await websocket.close(code=4003, reason="Run not in valid state")
+ return
+
+ # Connect websocket (this handles acceptance internally)
+ connected = await ws_manager.connect(websocket, run_id)
+ if not connected:
+ return # No need to close here as connect() failure would have closed it
+
+ # Handle authentication if enabled
+ if auth_manager is not None:
+ ws_auth = WebSocketAuthHandler(auth_manager)
+ success, user = await ws_auth.authenticate(websocket)
+ if not success:
+ logger.warning(f"Authentication failed for WebSocket connection to run {run_id}")
+ await websocket.send_json(
+ {
+ "type": "error",
+ "error": "Authentication failed",
+ "timestamp": datetime.utcnow().isoformat(),
+ }
+ )
+ # Close the connection with a specific code
+ # await websocket.close(code=4001, reason="Authentication failed")
+ return
+
+ if user and run.user_id != user.id and "admin" not in (user.roles or []):
+ await websocket.send_json(
+ {
+ "type": "error",
+ "error": "Authentication failed",
+ "timestamp": datetime.utcnow().isoformat(),
+ }
+ )
+ logger.warning(f"User {user.id} not authorized to access run {run_id}")
+ # await websocket.close(code=4003, reason="Not authorized to access this run")
+ return
+
logger.info(f"WebSocket connection established for run {run_id}")
while True:
@@ -53,8 +101,8 @@ async def run_websocket(
task = message.get("task")
team_config = message.get("team_config")
if task and team_config:
- # await ws_manager.start_stream(run_id, task, team_config)
- asyncio.create_task(ws_manager.start_stream(run_id, task, team_config))
+ # Start the stream in a separate task
+ asyncio.create_task(start_stream_wrapper(run_id, task, team_config))
else:
logger.warning(f"Invalid start message format for run {run_id}")
await websocket.send_json(
diff --git a/python/packages/autogen-studio/frontend/gatsby-config.ts b/python/packages/autogen-studio/frontend/gatsby-config.ts
index 6497a72fe..f91b97cc5 100644
--- a/python/packages/autogen-studio/frontend/gatsby-config.ts
+++ b/python/packages/autogen-studio/frontend/gatsby-config.ts
@@ -16,7 +16,7 @@ require("dotenv").config({
const config: GatsbyConfig = {
pathPrefix: process.env.PREFIX_PATH_VALUE || "",
siteMetadata: {
- title: `AutoGen Studio [Beta]`,
+ title: `AutoGen Studio`,
description: `Build Multi-Agent Apps`,
siteUrl: `http://tbd.place`,
},
diff --git a/python/packages/autogen-studio/frontend/src/auth/api.ts b/python/packages/autogen-studio/frontend/src/auth/api.ts
new file mode 100644
index 000000000..aaad65fb8
--- /dev/null
+++ b/python/packages/autogen-studio/frontend/src/auth/api.ts
@@ -0,0 +1,106 @@
+import { getServerUrl } from "../components/utils/utils";
+
+export interface User {
+ id: string;
+ name: string;
+ email?: string;
+ avatar_url?: string;
+ provider?: string;
+ roles?: string[];
+}
+
+export class AuthAPI {
+ private getBaseUrl(): string {
+ return getServerUrl();
+ }
+
+ private getHeaders(token?: string): HeadersInit {
+ const headers: HeadersInit = {
+ "Content-Type": "application/json",
+ };
+
+ if (token) {
+ headers["Authorization"] = `Bearer ${token}`;
+ }
+
+ return headers;
+ }
+
+ async getLoginUrl(): Promise<string> {
+ try {
+ const response = await fetch(`${this.getBaseUrl()}/auth/login-url`, {
+ headers: this.getHeaders(),
+ });
+
+ const data = await response.json();
+ if (!data.login_url) {
+ throw new Error("Failed to get login URL");
+ }
+
+ return data.login_url;
+ } catch (error) {
+ console.error("Error getting login URL:", error);
+ throw error;
+ }
+ }
+
+ async handleCallback(
+ code: string,
+ state?: string
+ ): Promise<{ token: string; user: User }> {
+ try {
+ const response = await fetch(
+ `${this.getBaseUrl()}/auth/callback-handler`,
+ {
+ method: "POST",
+ headers: this.getHeaders(),
+ body: JSON.stringify({ code, state }),
+ }
+ );
+
+ const data = await response.json();
+ if (!data.token || !data.user) {
+ throw new Error("Authentication failed");
+ }
+
+ return data;
+ } catch (error) {
+ console.error("Error handling auth callback:", error);
+ throw error;
+ }
+ }
+
+ async getCurrentUser(token: string): Promise<User> {
+ try {
+ const response = await fetch(`${this.getBaseUrl()}/auth/me`, {
+ headers: this.getHeaders(token),
+ });
+
+ if (response.status === 401) {
+ throw new Error("Unauthorized");
+ }
+
+ const data = await response.json();
+ return data;
+ } catch (error) {
+ console.error("Error getting current user:", error);
+ throw error;
+ }
+ }
+
+ async checkAuthType(): Promise<{ type: string }> {
+ try {
+ const response = await fetch(`${this.getBaseUrl()}/auth/type`, {
+ headers: this.getHeaders(),
+ });
+
+ const data = await response.json();
+ return data;
+ } catch (error) {
+ console.error("Error checking auth type:", error);
+ return { type: "none" }; // Default to no auth
+ }
+ }
+}
+
+export const authAPI = new AuthAPI();
diff --git a/python/packages/autogen-studio/frontend/src/auth/context.tsx b/python/packages/autogen-studio/frontend/src/auth/context.tsx
new file mode 100644
index 000000000..5f7ecd947
--- /dev/null
+++ b/python/packages/autogen-studio/frontend/src/auth/context.tsx
@@ -0,0 +1,217 @@
+import React, { createContext, useState, useEffect, useContext } from "react";
+import { authAPI, User } from "./api";
+import { message } from "antd";
+import { navigate } from "gatsby";
+import {
+ sanitizeUrl,
+ sanitizeRedirectUrl,
+ isValidMessageOrigin,
+ isValidUserObject,
+} from "../components/utils/security-utils";
+
+interface AuthContextType {
+ user: User | null;
+ isAuthenticated: boolean;
+ isLoading: boolean;
+ authType: string;
+ login: () => Promise<string>;
+ logout: () => void;
+ handleAuthCallback: (code: string, state?: string) => Promise<void>;
+}
+
+const AuthContext = createContext<AuthContextType | undefined>(undefined);
+
+const TOKEN_KEY = "auth_token";
+
+export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({
+ children,
+}) => {
+ const [user, setUser] = useState<User | null>(null);
+ const [isLoading, setIsLoading] = useState<boolean>(true);
+ const [authType, setAuthType] = useState<string>("none");
+
+ // Function to get token from localStorage
+ const getToken = (): string | null => {
+ return localStorage.getItem(TOKEN_KEY);
+ };
+
+ // Function to save token to localStorage
+ const saveToken = (token: string): void => {
+ localStorage.setItem(TOKEN_KEY, token);
+ };
+
+ // Function to remove token from localStorage
+ const removeToken = (): void => {
+ localStorage.removeItem(TOKEN_KEY);
+ };
+
+ // Load user on initial render if token exists
+ useEffect(() => {
+ const loadUser = async () => {
+ try {
+ // Check auth type first
+ const { type } = await authAPI.checkAuthType();
+ setAuthType(type);
+
+ // If auth is disabled, set default user and complete loading
+ if (type === "none") {
+ setUser({
+ name: "Guest User",
+ });
+ setIsLoading(false);
+ return;
+ }
+
+ const token = getToken();
+ if (!token) {
+ setIsLoading(false);
+ return;
+ }
+
+ // Load user data with token
+ const userData = await authAPI.getCurrentUser(token);
+ setUser(userData);
+ } catch (error) {
+ console.error("Failed to load user:", error);
+ removeToken(); // Clear invalid token
+ } finally {
+ setIsLoading(false);
+ }
+ };
+
+ loadUser();
+ }, []);
+
+ // Setup message listener for popup window communication
+ useEffect(() => {
+ const handleAuthMessage = (event: MessageEvent) => {
+ if (!isValidMessageOrigin(event.origin)) {
+ console.error(
+ `Rejected message from untrusted origin: ${event.origin}`
+ );
+ return;
+ }
+
+ const data = event.data;
+
+ if (data.type === "auth-success" && data.token && data.user) {
+ if (!isValidUserObject(data.user)) {
+ console.error("Invalid user data structure received");
+ return;
+ }
+
+ if (data.user.avatar_url) {
+ data.user.avatar_url = sanitizeUrl(data.user.avatar_url);
+ }
+
+ // Store token
+ saveToken(data.token);
+
+ // Update user state
+ setUser(data.user);
+
+ // Show success message
+ message.success("Successfully logged in");
+
+ // Redirect to home
+ navigate(sanitizeRedirectUrl("/"));
+ } else if (data.type === "auth-error") {
+ message.error(`Authentication failed: ${data.error}`);
+ }
+ };
+
+ window.addEventListener("message", handleAuthMessage);
+
+ return () => {
+ window.removeEventListener("message", handleAuthMessage);
+ };
+ }, []);
+
+ // Login function - gets login URL but doesn't redirect
+ // (redirection is handled in the login component with popup)
+ const login = async (): Promise<string> => {
+ try {
+ if (authType === "none") {
+ // No auth required
+ return "";
+ }
+
+ const loginUrl = await authAPI.getLoginUrl();
+ return loginUrl || "";
+ } catch (error) {
+ message.error("Failed to initiate login");
+ console.error("Login error:", error);
+ return "";
+ }
+ };
+
+ // Handle auth callback from provider
+ const handleAuthCallback = async (
+ code: string,
+ state?: string
+ ): Promise<void> => {
+ try {
+ // For popup window approach
+ if (window.opener) {
+ // This is handled by the backend HTML response
+ // Just display a message in the popup
+ message.success(
+ "Authentication successful! You can close this window."
+ );
+ return;
+ }
+
+ // For direct redirect approach (backup)
+ const { token, user } = await authAPI.handleCallback(code, state);
+ saveToken(token);
+ setUser(user);
+ message.success("Successfully logged in");
+ navigate("/"); // Redirect to home after successful login
+ } catch (error) {
+ message.error("Authentication failed");
+ console.error("Auth callback error:", error);
+ }
+ };
+
+ // Logout function
+ const logout = (): void => {
+ removeToken();
+ setUser(null);
+ message.info("Successfully logged out");
+ navigate("/login");
+ };
+
+ const value = {
+ user,
+ isAuthenticated: !!user,
+ isLoading,
+ authType,
+ login,
+ logout,
+ handleAuthCallback,
+ };
+
+ return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
+};
+
+// Hook to use auth context
+export const useAuth = (): AuthContextType => {
+ if (typeof window === "undefined") {
+ // Return default values or empty implementation
+ return {
+ user: null,
+ isAuthenticated: false,
+ isLoading: true,
+ authType: "none",
+ login: async () => "",
+ logout: () => {},
+ handleAuthCallback: async () => {},
+ } as AuthContextType;
+ }
+ const context = useContext(AuthContext);
+ if (context === undefined) {
+ throw new Error("useAuth must be used within an AuthProvider");
+ }
+ return context;
+};
diff --git a/python/packages/autogen-studio/frontend/src/auth/protected.tsx b/python/packages/autogen-studio/frontend/src/auth/protected.tsx
new file mode 100644
index 000000000..1293dda23
--- /dev/null
+++ b/python/packages/autogen-studio/frontend/src/auth/protected.tsx
@@ -0,0 +1,42 @@
+import React, { useEffect } from "react";
+import { navigate } from "gatsby";
+import { useAuth } from "./context";
+import { Spin } from "antd";
+
+interface ProtectedRouteProps {
+ children: React.ReactNode;
+ redirectTo?: string;
+}
+
+const ProtectedRoute: React.FC<ProtectedRouteProps> = ({
+ children,
+ redirectTo = "/login",
+}) => {
+ const { isAuthenticated, isLoading, authType } = useAuth();
+
+ useEffect(() => {
+ // If not loading and auth is required (not 'none') and user is not authenticated, redirect
+ if (!isLoading && authType !== "none" && !isAuthenticated) {
+ navigate(redirectTo);
+ }
+ }, [isAuthenticated, isLoading, authType, redirectTo]);
+
+ // Show loading indicator while checking auth status
+ if (isLoading) {
+ return (
+ <div className="flex items-center justify-center h-screen">
+ <Spin size="large" tip="Loading..." />
+ </div>
+ );
+ }
+
+ // If auth type is 'none' or user is authenticated, render children
+ if (authType === "none" || isAuthenticated) {
+ return <>{children}</>;
+ }
+
+ // This should not be visible as we redirect, but as a fallback
+ return null;
+};
+
+export default ProtectedRoute;
diff --git a/python/packages/autogen-studio/frontend/src/components/contentheader.tsx b/python/packages/autogen-studio/frontend/src/components/contentheader.tsx
index 5001c174d..54f3fef89 100644
--- a/python/packages/autogen-studio/frontend/src/components/contentheader.tsx
+++ b/python/packages/autogen-studio/frontend/src/components/contentheader.tsx
@@ -1,21 +1,16 @@
import React from "react";
-import { Menu } from "@headlessui/react";
+import { Menu, MenuButton, MenuItem, MenuItems } from "@headlessui/react";
import {
BellIcon,
MoonIcon,
SunIcon,
MagnifyingGlassIcon,
} from "@heroicons/react/24/outline";
-import {
- ChevronDown,
- PanelLeftClose,
- PanelLeftOpen,
- Menu as MenuIcon,
-} from "lucide-react";
-import { Tooltip } from "antd";
+import { ChevronDown, Menu as MenuIcon } from "lucide-react";
import { appContext } from "../hooks/provider";
import { useConfigStore } from "../hooks/store";
import { Link } from "gatsby";
+import { sanitizeUrl } from "./utils/security-utils";
type ContentHeaderProps = {
onMobileMenuToggle: () => void;
@@ -150,11 +145,11 @@ const ContentHeader = ({
{/* User Menu */}
{user && (
<Menu as="div" className="relative">
- <Menu.Button className="flex items-center">
+ <MenuButton className="flex items-center">
{user.avatar_url ? (
<img
className="h-8 w-8 rounded-full"
- src={user.avatar_url}
+ src={sanitizeUrl(user.avatar_url)}
alt={user.name}
/>
) : (
@@ -168,9 +163,9 @@ const ContentHeader = ({
</span>
<ChevronDown className="ml-2 h-5 w-5 text-secondary" />
</span>
- </Menu.Button>
- <Menu.Items className="absolute right-0 mt-2 w-48 origin-top-right rounded-md bg-primary py-1 shadow-lg ring-1 ring-black ring-opacity-5 focus:outline-none">
- <Menu.Item>
+ </MenuButton>
+ <MenuItems className="absolute right-0 mt-2 w-48 origin-top-right rounded-md bg-primary py-1 shadow-lg ring-1 ring-black ring-opacity-5 focus:outline-none">
+ <MenuItem>
{({ active }) => (
<a
href="#"
@@ -182,8 +177,8 @@ const ContentHeader = ({
Sign out
</a>
)}
- </Menu.Item>
- </Menu.Items>
+ </MenuItem>
+ </MenuItems>
</Menu>
)}
</div>
diff --git a/python/packages/autogen-studio/frontend/src/components/footer.tsx b/python/packages/autogen-studio/frontend/src/components/footer.tsx
index 6a8828d5e..86c1be0d2 100644
--- a/python/packages/autogen-studio/frontend/src/components/footer.tsx
+++ b/python/packages/autogen-studio/frontend/src/components/footer.tsx
@@ -1,7 +1,7 @@
import * as React from "react";
import Icon from "./icons";
import { useConfigStore } from "../hooks/store";
-import { fetchVersion } from "./utils";
+import { fetchVersion } from "./utils/utils";
const Footer = () => {
const version = useConfigStore((state) => state.version);
diff --git a/python/packages/autogen-studio/frontend/src/components/header.tsx b/python/packages/autogen-studio/frontend/src/components/header.tsx
index d0adf2e0a..43fcbc404 100644
--- a/python/packages/autogen-studio/frontend/src/components/header.tsx
+++ b/python/packages/autogen-studio/frontend/src/components/header.tsx
@@ -1,5 +1,14 @@
import Icon from "./icons";
-import { Disclosure, Menu, Transition } from "@headlessui/react";
+import {
+ Disclosure,
+ DisclosureButton,
+ DisclosurePanel,
+ Menu,
+ MenuButton,
+ MenuItem,
+ MenuItems,
+ Transition,
+} from "@headlessui/react";
import {
XMarkIcon,
Bars3Icon,
@@ -11,6 +20,7 @@ import { Fragment } from "react";
import { appContext } from "../hooks/provider";
import { Link } from "gatsby";
import React from "react";
+import { sanitizeUrl } from "./utils/security-utils";
function classNames(...classes: string[]) {
return classes.filter(Boolean).join(" ");
@@ -19,8 +29,8 @@ function classNames(...classes: string[]) {
const Header = ({ meta, link }: any) => {
const { user, logout } = React.useContext(appContext);
const userName = user ? user.name : "Unknown";
- const userAvatarUrl = user ? user.avatar_url : "";
- const user_id = user ? user.username : "unknown";
+ const userAvatarUrl = user ? sanitizeUrl(user.avatar_url) : "";
+ const user_id = user ? user.id : "unknown";
const links: any[] = [
{ name: "Build", href: "/build" },
@@ -117,14 +127,14 @@ const Header = ({ meta, link }: any) => {
<div className="flex items-center md:hidden">
{/* Mobile menu button */}
- <Disclosure.Button className="inline-flex items-center justify-center p-2 rounded-md text-gray-400 hover:text-secondary hover:bg-secondary focus:outline-none focus:ring-2 focus:ring-inset focus:ring-accent">
+ <DisclosureButton className="inline-flex items-center justify-center p-2 rounded-md text-gray-400 hover:text-secondary hover:bg-secondary focus:outline-none focus:ring-2 focus:ring-inset focus:ring-accent">
<span className="sr-only">Open main menu</span>
{open ? (
<XMarkIcon className="block h-6 w-6" aria-hidden="true" />
) : (
<Bars3Icon className="block h-6 w-6" aria-hidden="true" />
)}
- </Disclosure.Button>
+ </DisclosureButton>
</div>
{
<div className="hidden lg:ml-4 md:flex md:items-center">
@@ -140,7 +150,7 @@ const Header = ({ meta, link }: any) => {
{/* Profile dropdown */}
<Menu as="div" className="ml-4 relative flex-shrink-0">
<div>
- <Menu.Button className="bg-primary rounded-full flex text-sm focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-accent">
+ <MenuButton className="bg-primary rounded-full flex text-sm focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-accent">
<span className="sr-only">Open user menu</span>
{userAvatarUrl && (
<img
@@ -154,7 +164,7 @@ const Header = ({ meta, link }: any) => {
{userName[0]}
</div>
)}
- </Menu.Button>
+ </MenuButton>
</div>
<Transition
as={Fragment}
@@ -165,8 +175,8 @@ const Header = ({ meta, link }: any) => {
leaveFrom="transform opacity-100 scale-100"
leaveTo="transform opacity-0 scale-95"
>
- <Menu.Items className="origin-top-right absolute right-0 mt-2 w-48 rounded-md shadow-lg py-1 bg-primary ring-1 ring-black ring-opacity-5 focus:outline-none">
- {/* <Menu.Item>
+ <MenuItems className="origin-top-right absolute right-0 mt-2 w-48 rounded-md shadow-lg py-1 bg-primary ring-1 ring-black ring-opacity-5 focus:outline-none">
+ {/* <MenuItem>
{({ active }) => (
<a
href="#"
@@ -175,9 +185,9 @@ const Header = ({ meta, link }: any) => {
Your Profile
</a>
)}
- </Menu.Item> */}
+ </MenuItem> */}
- <Menu.Item>
+ <MenuItem>
{({ active }) => (
<a
href="#"
@@ -192,8 +202,8 @@ const Header = ({ meta, link }: any) => {
Sign out
</a>
)}
- </Menu.Item>
- </Menu.Items>
+ </MenuItem>
+ </MenuItems>
</Transition>
</Menu>
</>
@@ -203,19 +213,19 @@ const Header = ({ meta, link }: any) => {
</div>
</div>
- <Disclosure.Panel className="md:hidden">
+ <DisclosurePanel className="md:hidden">
<div className="pt-2 pb-3 space-y-1">
{/* Current: "bg-indigo-50 border-accent text-accent", Default: "border-transparent text-gray-600 hover:bg-primary hover:border-gray-300 hover:text-primary" */}
{links.map((data, index) => {
return (
- <Disclosure.Button
+ <DisclosureButton
key={index + "linkrow"}
as="a"
href={data.href}
className="bg-secondary border-accent text-accent block pl-3 pr-4 py-2 border-l-4 text-base font-medium"
>
{data.name}
- </Disclosure.Button>
+ </DisclosureButton>
);
})}
</div>
@@ -253,18 +263,18 @@ const Header = ({ meta, link }: any) => {
</button>
</div>
<div className="mt-3 space-y-1">
- <Disclosure.Button
+ <DisclosureButton
as="a"
href="#"
onClick={() => logout()}
className="block px-4 py-2 text-base font-medium text-secondary hover:text-primary "
>
Sign out
- </Disclosure.Button>
+ </DisclosureButton>
</div>
</div>
)}
- </Disclosure.Panel>
+ </DisclosurePanel>
</>
)}
</Disclosure>
diff --git a/python/packages/autogen-studio/frontend/src/components/layout.tsx b/python/packages/autogen-studio/frontend/src/components/layout.tsx
index d3216d340..5982a7f77 100644
--- a/python/packages/autogen-studio/frontend/src/components/layout.tsx
+++ b/python/packages/autogen-studio/frontend/src/components/layout.tsx
@@ -8,6 +8,8 @@ import "antd/dist/reset.css";
import SideBar from "./sidebar";
import ContentHeader from "./contentheader";
import { ConfigProvider, theme } from "antd";
+import { useAuth } from "../auth/context";
+import ProtectedRoute from "../auth/protected";
const classNames = (...classes: (string | undefined | boolean)[]) => {
return classes.filter(Boolean).join(" ");
@@ -28,12 +30,13 @@ const Layout = ({
link,
children,
showHeader = true,
- restricted = false,
+ restricted = true, // Default to restricted for security
}: Props) => {
const { darkMode } = React.useContext(appContext);
const { sidebar } = useConfigStore();
const { isExpanded } = sidebar;
const [isMobileMenuOpen, setIsMobileMenuOpen] = React.useState(false);
+ const { authType } = useAuth();
// Close mobile menu on route change
React.useEffect(() => {
@@ -117,20 +120,12 @@ const Layout = ({
</div>
);
- // Handle restricted content
- if (restricted) {
- return (
- <appContext.Consumer>
- {(context: any) => {
- if (context.user) {
- return layoutContent;
- }
- return null;
- }}
- </appContext.Consumer>
- );
+ // If page is restricted and auth is not 'none', wrap with ProtectedRoute
+ if (restricted && authType !== "none") {
+ return <ProtectedRoute>{layoutContent}</ProtectedRoute>;
}
+ // Otherwise, render without protection
return layoutContent;
};
diff --git a/python/packages/autogen-studio/frontend/src/components/sidebar.tsx b/python/packages/autogen-studio/frontend/src/components/sidebar.tsx
index 8b060771e..e87eb30a9 100644
--- a/python/packages/autogen-studio/frontend/src/components/sidebar.tsx
+++ b/python/packages/autogen-studio/frontend/src/components/sidebar.tsx
@@ -105,7 +105,7 @@ const Sidebar = ({ link, meta, isMobile }: SidebarProps) => {
return (
<div
className={classNames(
- "flex grow border z-50 flex-col gap-y-5 overflow-y-auto border-r border-secondary bg-primary",
+ "flex grow z-50 flex-col gap-y-5 overflow-y-auto border-r border-secondary bg-primary",
"transition-all duration-300 ease-in-out",
showFull ? "w-72 px-6" : "w-16 px-2"
)}
diff --git a/python/packages/autogen-studio/frontend/src/components/utils/baseapi.ts b/python/packages/autogen-studio/frontend/src/components/utils/baseapi.ts
new file mode 100644
index 000000000..9db93e512
--- /dev/null
+++ b/python/packages/autogen-studio/frontend/src/components/utils/baseapi.ts
@@ -0,0 +1,26 @@
+import { getServerUrl } from "./utils";
+
+// baseApi.ts
+export abstract class BaseAPI {
+ protected getBaseUrl(): string {
+ return getServerUrl();
+ }
+
+ protected getHeaders(): HeadersInit {
+ // Get auth token from localStorage
+ const token = localStorage.getItem("auth_token");
+
+ const headers: HeadersInit = {
+ "Content-Type": "application/json",
+ };
+
+ // Add authorization header if token exists
+ if (token) {
+ headers["Authorization"] = `Bearer ${token}`;
+ }
+
+ return headers;
+ }
+
+ // Other common methods
+}
diff --git a/python/packages/autogen-studio/frontend/src/components/utils/security-utils.ts b/python/packages/autogen-studio/frontend/src/components/utils/security-utils.ts
new file mode 100644
index 000000000..25321cbad
--- /dev/null
+++ b/python/packages/autogen-studio/frontend/src/components/utils/security-utils.ts
@@ -0,0 +1,96 @@
+// security-utils.ts
+// Central location for security-related utility functions
+
+/**
+ * Sanitizes URLs to prevent XSS attacks via javascript: protocol
+ * Only allows http:// and https:// protocols
+ */
+// In security-utils.ts
+export const sanitizeUrl = (url: string | undefined | null): string => {
+ // return url;
+ console.log("sanitizeUrl", url);
+ if (!url || typeof url !== "string") return "";
+
+ // Only allow http and https protocols
+ if (url.startsWith("http://") || url.startsWith("https://")) {
+ try {
+ // Create URL object to validate structure
+ new URL(url);
+ // First encode URI characters
+ const encodedUrl = encodeURI(url);
+ // Then escape HTML special characters
+ return encodedUrl.replace(/[&<>"']/g, function (m) {
+ switch (m) {
+ case "&":
+ return "&amp;";
+ case "<":
+ return "&lt;";
+ case ">":
+ return "&gt;";
+ case '"':
+ return "&quot;";
+ case "'":
+ return "&#39;";
+ default:
+ return m;
+ }
+ });
+ } catch {
+ return "";
+ }
+ }
+
+ return "";
+};
+
+/**
+ * Sanitizes redirect URLs to prevent open redirect vulnerabilities
+ * Only allows relative URLs or URLs to the current origin
+ */
+export const sanitizeRedirectUrl = (url: string | undefined | null): string => {
+ if (!url || typeof url !== "string") return "/";
+
+ // Allow relative URLs
+ if (url.startsWith("/")) return url;
+
+ try {
+ // For absolute URLs, check if they point to your domain
+ const urlObj = new URL(url);
+ if (urlObj.origin === window.location.origin) {
+ return url;
+ }
+ } catch (e) {
+ // Invalid URL
+ }
+
+ // Default to homepage for security
+ return "/";
+};
+
+/**
+ * Validates if a message event is from a trusted origin
+ */
+export const isValidMessageOrigin = (origin: string): boolean => {
+ const trustedOrigins = [
+ window.location.origin,
+ "http://localhost:8000",
+ "http://localhost:8081",
+ ];
+
+ return trustedOrigins.includes(origin);
+};
+
+/**
+ * Validates user object structure to prevent prototype pollution
+ */
+export const isValidUserObject = (user: any): boolean => {
+ return (
+ user &&
+ typeof user === "object" &&
+ typeof user.id === "string" &&
+ typeof user.name === "string" &&
+ (user.email === undefined || typeof user.email === "string") &&
+ (user.avatar_url === undefined || typeof user.avatar_url === "string") &&
+ (user.provider === undefined || typeof user.provider === "string")
+ );
+};
diff --git a/python/packages/autogen-studio/frontend/src/components/utils.ts b/python/packages/autogen-studio/frontend/src/components/utils/utils.ts
similarity index 98%
rename from python/packages/autogen-studio/frontend/src/components/utils.ts
rename to python/packages/autogen-studio/frontend/src/components/utils/utils.ts
index f725e3233..062860799 100644
--- a/python/packages/autogen-studio/frontend/src/components/utils.ts
+++ b/python/packages/autogen-studio/frontend/src/components/utils/utils.ts
@@ -1,4 +1,4 @@
-import { IStatus } from "./types/app";
+import { IStatus } from "../types/app";
export const getServerUrl = () => {
return process.env.GATSBY_API_URL || "/api";
diff --git a/python/packages/autogen-studio/frontend/src/components/views/gallery/api.ts b/python/packages/autogen-studio/frontend/src/components/views/gallery/api.ts
index 60b5fb35e..f1a20220b 100644
--- a/python/packages/autogen-studio/frontend/src/components/views/gallery/api.ts
+++ b/python/packages/autogen-studio/frontend/src/components/views/gallery/api.ts
@@ -1,17 +1,7 @@
import { Gallery } from "../../types/datamodel";
-import { getServerUrl } from "../../utils";
-
-export class GalleryAPI {
- private getBaseUrl(): string {
- return getServerUrl();
- }
-
- private getHeaders(): HeadersInit {
- return {
- "Content-Type": "application/json",
- };
- }
+import { BaseAPI } from "../../utils/baseapi";
+export class GalleryAPI extends BaseAPI {
async listGalleries(userId: string): Promise<Gallery[]> {
const response = await fetch(
`${this.getBaseUrl()}/gallery/?user_id=${userId}`,
diff --git a/python/packages/autogen-studio/frontend/src/components/views/gallery/manager.tsx b/python/packages/autogen-studio/frontend/src/components/views/gallery/manager.tsx
index 06bf075b0..bd45029e0 100644
--- a/python/packages/autogen-studio/frontend/src/components/views/gallery/manager.tsx
+++ b/python/packages/autogen-studio/frontend/src/components/views/gallery/manager.tsx
@@ -33,11 +33,11 @@ export const GalleryManager: React.FC = () => {
}, [isSidebarOpen]);
const fetchGalleries = useCallback(async () => {
- if (!user?.email) return;
+ if (!user?.id) return;
try {
setIsLoading(true);
- const data = await galleryAPI.listGalleries(user.email);
+ const data = await galleryAPI.listGalleries(user.id);
setGalleries(data);
if (!currentGallery && data.length > 0) {
setCurrentGallery(data[0]);
@@ -48,7 +48,7 @@ export const GalleryManager: React.FC = () => {
} finally {
setIsLoading(false);
}
- }, [user?.email, currentGallery, messageApi]);
+ }, [user?.id, currentGallery, messageApi]);
useEffect(() => {
fetchGalleries();
@@ -79,7 +79,7 @@ export const GalleryManager: React.FC = () => {
}, [currentGallery?.id]);
const handleSelectGallery = async (galleryId: number) => {
- if (!user?.email) return;
+ if (!user?.id) return;
if (hasUnsavedChanges) {
Modal.confirm({
@@ -98,11 +98,11 @@ export const GalleryManager: React.FC = () => {
};
const switchToGallery = async (galleryId: number) => {
- if (!user?.email) return;
+ if (!user?.id) return;
setIsLoading(true);
try {
- const data = await galleryAPI.getGallery(galleryId, user.email);
+ const data = await galleryAPI.getGallery(galleryId, user.id);
setCurrentGallery(data);
} catch (error) {
console.error("Error loading gallery:", error);
@@ -113,14 +113,11 @@ export const GalleryManager: React.FC = () => {
};
const handleCreateGallery = async (galleryData: Gallery) => {
- if (!user?.email) return;
+ if (!user?.id) return;
- galleryData.user_id = user.email;
+ galleryData.user_id = user.id;
try {
- const savedGallery = await galleryAPI.createGallery(
- galleryData,
- user.email
- );
+ const savedGallery = await galleryAPI.createGallery(galleryData, user.id);
setGalleries([savedGallery, ...galleries]);
setCurrentGallery(savedGallery);
setIsCreateModalOpen(false);
@@ -132,7 +129,7 @@ export const GalleryManager: React.FC = () => {
};
const handleUpdateGallery = async (updates: Partial<Gallery>) => {
- if (!user?.email || !currentGallery?.id) return;
+ if (!user?.id || !currentGallery?.id) return;
try {
const sanitizedUpdates = {
@@ -143,7 +140,7 @@ export const GalleryManager: React.FC = () => {
const updatedGallery = await galleryAPI.updateGallery(
currentGallery.id,
sanitizedUpdates,
- user.email
+ user.id
);
setGalleries(
galleries.map((g) => (g.id === updatedGallery.id ? updatedGallery : g))
@@ -158,10 +155,10 @@ export const GalleryManager: React.FC = () => {
};
const handleDeleteGallery = async (galleryId: number) => {
- if (!user?.email) return;
+ if (!user?.id) return;
try {
- await galleryAPI.deleteGallery(galleryId, user.email);
+ await galleryAPI.deleteGallery(galleryId, user.id);
setGalleries(galleries.filter((g) => g.id !== galleryId));
if (currentGallery?.id === galleryId) {
setCurrentGallery(null);
@@ -174,7 +171,7 @@ export const GalleryManager: React.FC = () => {
};
const handleSyncGallery = async (galleryId: number) => {
- if (!user?.email) return;
+ if (!user?.id) return;
try {
setIsLoading(true);
@@ -203,7 +200,7 @@ export const GalleryManager: React.FC = () => {
}
};
- if (!user?.email) {
+ if (!user?.id) {
return (
<div className="flex items-center justify-center h-[calc(100vh-120px)] text-secondary">
Please log in to view galleries
diff --git a/python/packages/autogen-studio/frontend/src/components/views/playground/api.ts b/python/packages/autogen-studio/frontend/src/components/views/playground/api.ts
index c48c3bbfc..9c7215076 100644
--- a/python/packages/autogen-studio/frontend/src/components/views/playground/api.ts
+++ b/python/packages/autogen-studio/frontend/src/components/views/playground/api.ts
@@ -1,17 +1,7 @@
import { Session, SessionRuns } from "../../types/datamodel";
-import { getServerUrl } from "../../utils";
-
-export class SessionAPI {
- private getBaseUrl(): string {
- return getServerUrl();
- }
-
- private getHeaders(): HeadersInit {
- return {
- "Content-Type": "application/json",
- };
- }
+import { BaseAPI } from "../../utils/baseapi";
+export class SessionAPI extends BaseAPI {
async listSessions(userId: string): Promise<Session[]> {
const response = await fetch(
`${this.getBaseUrl()}/sessions/?user_id=${userId}`,
@@ -127,6 +117,20 @@ export class SessionAPI {
throw new Error(data.message || "Failed to fetch messages");
return data.data;
}
+
+ // New method to create a run
+ async createRun(sessionId: number, userId: string): Promise<number> {
+ const payload = { session_id: sessionId, user_id: userId };
+ const response = await fetch(`${this.getBaseUrl()}/runs/`, {
+ method: "POST",
+ headers: this.getHeaders(),
+ body: JSON.stringify(payload),
+ });
+
+ const data = await response.json();
+ if (!data.status) throw new Error(data.message || "Failed to create run");
+ return data.data.run_id;
+ }
}
export const sessionAPI = new SessionAPI();
diff --git a/python/packages/autogen-studio/frontend/src/components/views/playground/chat/chat.tsx b/python/packages/autogen-studio/frontend/src/components/views/playground/chat/chat.tsx
index aab771b78..0957d0adb 100644
--- a/python/packages/autogen-studio/frontend/src/components/views/playground/chat/chat.tsx
+++ b/python/packages/autogen-studio/frontend/src/components/views/playground/chat/chat.tsx
@@ -1,6 +1,6 @@
import * as React from "react";
import { message } from "antd";
-import { getServerUrl } from "../../../utils";
+import { getServerUrl } from "../../../utils/utils";
import { IStatus } from "../../../types/app";
import {
Run,
@@ -70,15 +70,15 @@ export default function ChatView({ session }: ChatViewProps) {
config,
session_id: sessionId,
run_id: runId,
- user_id: user?.email || undefined,
+ user_id: user?.id || undefined,
});
// Load existing runs when session changes
const loadSessionRuns = async () => {
- if (!session?.id || !user?.email) return;
+ if (!session?.id || !user?.id) return;
try {
- const response = await sessionAPI.getSessionRuns(session.id, user.email);
+ const response = await sessionAPI.getSessionRuns(session.id, user.id);
setExistingRuns(response.runs);
} catch (error) {
console.error("Error loading session runs:", error);
@@ -98,9 +98,9 @@ export default function ChatView({ session }: ChatViewProps) {
// Load team config
React.useEffect(() => {
- if (session?.team_id && user?.email) {
+ if (session?.team_id && user?.id) {
teamAPI
- .getTeam(session.team_id, user.email)
+ .getTeam(session.team_id, user.id)
.then((team) => {
setTeamConfig(team.component);
})
@@ -135,24 +135,13 @@ export default function ChatView({ session }: ChatViewProps) {
}, [activeSocket]);
const createRun = async (sessionId: number): Promise<number> => {
- const payload = { session_id: sessionId, user_id: user?.email || "" };
- const response = await fetch(`${serverUrl}/runs/`, {
- method: "POST",
- headers: { "Content-Type": "application/json" },
- body: JSON.stringify(payload),
- });
-
- if (!response.ok) {
- throw new Error("Failed to create run");
- }
-
- const data = await response.json();
- return data.data.run_id;
+ return await sessionAPI.createRun(sessionId, user?.id || "");
};
const handleWebSocketMessage = (message: WebSocketMessage) => {
setCurrentRun((current) => {
if (!current || !session?.id) return null;
+ // console.log("WebSocket message:", message);
switch (message.type) {
case "error":
@@ -167,6 +156,16 @@ export default function ChatView({ session }: ChatViewProps) {
}
console.log("Error: ", message.error);
+ const updatedErrorRun = {
+ ...current,
+ status: "error" as RunStatus,
+ error_message: message.error || "An error occurred",
+ };
+
+ // Add to existing runs
+ setExistingRuns((prev) => [...prev, updatedErrorRun]);
+ return null; // Clear current run
+
case "message_chunk":
if (!message.data) return current;
@@ -434,7 +433,8 @@ export default function ChatView({ session }: ChatViewProps) {
const baseUrl = getBaseUrl(serverUrl);
const wsProtocol = window.location.protocol === "https:" ? "wss:" : "ws:";
- const wsUrl = `${wsProtocol}//${baseUrl}/api/ws/runs/${runId}`;
+ const auth_token = localStorage.getItem("auth_token");
+ const wsUrl = `${wsProtocol}//${baseUrl}/api/ws/runs/${runId}?token=${auth_token}`;
const socket = new WebSocket(wsUrl);
diff --git a/python/packages/autogen-studio/frontend/src/components/views/playground/chat/runview.tsx b/python/packages/autogen-studio/frontend/src/components/views/playground/chat/runview.tsx
index 519a099b6..a960fd723 100644
--- a/python/packages/autogen-studio/frontend/src/components/views/playground/chat/runview.tsx
+++ b/python/packages/autogen-studio/frontend/src/components/views/playground/chat/runview.tsx
@@ -189,7 +189,7 @@ const RunView: React.FC<RunViewProps> = ({
}
};
- const lastResultMessage = run.team_result?.task_result.messages.slice(-1)[0];
+ const lastResultMessage = run.team_result?.task_result?.messages.slice(-1)[0];
const lastMessage = getLastMeaningfulMessage(visibleMessages);
return (
diff --git a/python/packages/autogen-studio/frontend/src/components/views/playground/editor.tsx b/python/packages/autogen-studio/frontend/src/components/views/playground/editor.tsx
index ba61c1d3e..6ca9dcc73 100644
--- a/python/packages/autogen-studio/frontend/src/components/views/playground/editor.tsx
+++ b/python/packages/autogen-studio/frontend/src/components/views/playground/editor.tsx
@@ -1,11 +1,8 @@
-import React, { useContext, useEffect, useState } from "react";
+import React, { useEffect, useState } from "react";
import { Modal, Form, message, Input, Button, Select, Spin } from "antd";
import { TriangleAlertIcon } from "lucide-react";
import type { FormProps } from "antd";
import { SessionEditorProps } from "./types";
-import { Team } from "../../types/datamodel";
-import { teamAPI } from "../teambuilder/api";
-import { appContext } from "../../../hooks/provider";
import { Link } from "gatsby";
type FieldType = {
@@ -22,7 +19,6 @@ export const SessionEditor: React.FC<SessionEditorProps> = ({
}) => {
const [form] = Form.useForm();
const [loading, setLoading] = useState(false);
- const { user } = useContext(appContext);
const [messageApi, contextHolder] = message.useMessage();
// Set form values when modal opens or session changes
diff --git a/python/packages/autogen-studio/frontend/src/components/views/playground/manager.tsx b/python/packages/autogen-studio/frontend/src/components/views/playground/manager.tsx
index c47a40419..911195caa 100644
--- a/python/packages/autogen-studio/frontend/src/components/views/playground/manager.tsx
+++ b/python/packages/autogen-studio/frontend/src/components/views/playground/manager.tsx
@@ -36,11 +36,11 @@ export const SessionManager: React.FC = () => {
}, [isSidebarOpen]);
const fetchSessions = useCallback(async () => {
- if (!user?.email) return;
+ if (!user?.id) return;
try {
setIsLoading(true);
- const data = await sessionAPI.listSessions(user.email);
+ const data = await sessionAPI.listSessions(user.id);
setSessions(data);
// Only set first session if there's no sessionId in URL
@@ -55,7 +55,7 @@ export const SessionManager: React.FC = () => {
} finally {
setIsLoading(false);
}
- }, [user?.email, setSessions, session, setSession]);
+ }, [user?.id, setSessions, session, setSession]);
// Handle initial URL params
useEffect(() => {
@@ -83,21 +83,21 @@ export const SessionManager: React.FC = () => {
}, [session]);
const handleSaveSession = async (sessionData: Partial<Session>) => {
- if (!user?.email) return;
+ if (!user?.id) return;
try {
if (sessionData.id) {
const updated = await sessionAPI.updateSession(
sessionData.id,
sessionData,
- user.email
+ user.id
);
setSessions(sessions.map((s) => (s.id === updated.id ? updated : s)));
if (session?.id === updated.id) {
setSession(updated);
}
} else {
- const created = await sessionAPI.createSession(sessionData, user.email);
+ const created = await sessionAPI.createSession(sessionData, user.id);
setSessions([created, ...sessions]);
setSession(created);
}
@@ -110,10 +110,10 @@ export const SessionManager: React.FC = () => {
};
const handleDeleteSession = async (sessionId: number) => {
- if (!user?.email) return;
+ if (!user?.id) return;
try {
- const response = await sessionAPI.deleteSession(sessionId, user.email);
+ const response = await sessionAPI.deleteSession(sessionId, user.id);
setSessions(sessions.filter((s) => s.id !== sessionId));
if (session?.id === sessionId || sessions.length === 0) {
setSession(sessions[0] || null);
@@ -127,7 +127,7 @@ export const SessionManager: React.FC = () => {
};
const handleQuickStart = async (teamId: number, teamName: string) => {
- if (!user?.email) return;
+ if (!user?.id) return;
try {
const defaultName = `${teamName.substring(
0,
@@ -138,7 +138,7 @@ export const SessionManager: React.FC = () => {
name: defaultName,
team_id: teamId,
},
- user.email
+ user.id
);
setSessions([created, ...sessions]);
@@ -150,11 +150,11 @@ export const SessionManager: React.FC = () => {
};
const handleSelectSession = async (selectedSession: Session) => {
- if (!user?.email || !selectedSession.id) return;
+ if (!user?.id || !selectedSession.id) return;
try {
setIsLoading(true);
- const data = await sessionAPI.getSession(selectedSession.id, user.email);
+ const data = await sessionAPI.getSession(selectedSession.id, user.id);
if (!data) {
// Session not found
messageApi.error("Session not found");
@@ -188,16 +188,17 @@ export const SessionManager: React.FC = () => {
// Add teams fetching
const fetchTeams = useCallback(async () => {
- if (!user?.email) return;
+ // console.log("Fetching teams", user);
+ if (!user?.id) return;
try {
setIsLoading(true);
- const teamsData = await teamAPI.listTeams(user.email);
+ const teamsData = await teamAPI.listTeams(user.id);
if (teamsData.length > 0) {
setTeams(teamsData);
} else {
console.log("No teams found, creating default team");
- await galleryStore.fetchGalleries(user.email);
+ await galleryStore.fetchGalleries(user.id);
const defaultGallery = galleryStore.getSelectedGallery();
const sampleTeam = defaultGallery?.config.components.teams[0];
@@ -207,7 +208,7 @@ export const SessionManager: React.FC = () => {
const teamData: Team = {
component: sampleTeam,
};
- const defaultTeam = await teamAPI.createTeam(teamData, user.email);
+ const defaultTeam = await teamAPI.createTeam(teamData, user.id);
console.log("Default team created:", teamData);
setTeams([defaultTeam]);
@@ -219,7 +220,7 @@ export const SessionManager: React.FC = () => {
} finally {
setIsLoading(false);
}
- }, [user?.email, messageApi]);
+ }, [user?.id, messageApi]);
// Fetch teams on mount
useEffect(() => {
diff --git a/python/packages/autogen-studio/frontend/src/components/views/playground/newsession.tsx b/python/packages/autogen-studio/frontend/src/components/views/playground/newsession.tsx
index 611b6bf57..8c5db9980 100644
--- a/python/packages/autogen-studio/frontend/src/components/views/playground/newsession.tsx
+++ b/python/packages/autogen-studio/frontend/src/components/views/playground/newsession.tsx
@@ -2,7 +2,7 @@ import React, { useState, useEffect } from "react";
import { Button, Dropdown, MenuProps, message, Select, Space } from "antd";
import { Plus, InfoIcon, Bot, TextSearch, ChevronDown } from "lucide-react";
import { Team } from "../../types/datamodel";
-import { truncateText } from "../../utils";
+import { truncateText } from "../../utils/utils";
import Input from "antd/es/input/Input";
interface NewSessionControlsProps {
diff --git a/python/packages/autogen-studio/frontend/src/components/views/settings/api.ts b/python/packages/autogen-studio/frontend/src/components/views/settings/api.ts
index 535c8f404..4fd2de90c 100644
--- a/python/packages/autogen-studio/frontend/src/components/views/settings/api.ts
+++ b/python/packages/autogen-studio/frontend/src/components/views/settings/api.ts
@@ -1,17 +1,7 @@
import { Settings } from "../../types/datamodel";
-import { getServerUrl } from "../../utils";
-
-export class SettingsAPI {
- private getBaseUrl(): string {
- return getServerUrl();
- }
-
- private getHeaders(): HeadersInit {
- return {
- "Content-Type": "application/json",
- };
- }
+import { BaseAPI } from "../../utils/baseapi";
+export class SettingsAPI extends BaseAPI {
async getSettings(userId: string): Promise<Settings> {
const response = await fetch(
`${this.getBaseUrl()}/settings/?user_id=${userId}`,
diff --git a/python/packages/autogen-studio/frontend/src/components/views/settings/manager.tsx b/python/packages/autogen-studio/frontend/src/components/views/settings/manager.tsx
index 3adfccd1d..37312d521 100644
--- a/python/packages/autogen-studio/frontend/src/components/views/settings/manager.tsx
+++ b/python/packages/autogen-studio/frontend/src/components/views/settings/manager.tsx
@@ -25,7 +25,7 @@ export const SettingsManager: React.FC = () => {
});
const { user } = useContext(appContext);
- const userId = user?.email || "";
+ const userId = user?.id || "";
const { serverSettings, resetUISettings, initializeSettings, isLoading } =
useSettingsStore();
diff --git a/python/packages/autogen-studio/frontend/src/components/views/settings/view/modelconfig.tsx b/python/packages/autogen-studio/frontend/src/components/views/settings/view/modelconfig.tsx
index f845756c2..b43705da2 100644
--- a/python/packages/autogen-studio/frontend/src/components/views/settings/view/modelconfig.tsx
+++ b/python/packages/autogen-studio/frontend/src/components/views/settings/view/modelconfig.tsx
@@ -1,7 +1,7 @@
import React, { useState } from "react";
import { Button, Tooltip, Drawer } from "antd";
import { Edit2, Settings } from "lucide-react";
-import { truncateText } from "../../../utils";
+import { truncateText } from "../../../utils/utils";
import {
Component,
ComponentConfig,
diff --git a/python/packages/autogen-studio/frontend/src/components/views/settings/view/panel.tsx b/python/packages/autogen-studio/frontend/src/components/views/settings/view/panel.tsx
index 47bd614dd..9a6f4967c 100644
--- a/python/packages/autogen-studio/frontend/src/components/views/settings/view/panel.tsx
+++ b/python/packages/autogen-studio/frontend/src/components/views/settings/view/panel.tsx
@@ -30,7 +30,7 @@ export const SettingsPanel: React.FC = () => {
const [isModelEditorOpen, setIsModelEditorOpen] = useState(false);
const { user } = useContext(appContext);
- const userId = user?.email || "";
+ const userId = user?.id || "";
// Get settings from the store
const { serverSettings, initializeSettings } = useSettingsStore();
diff --git a/python/packages/autogen-studio/frontend/src/components/views/teambuilder/api.ts b/python/packages/autogen-studio/frontend/src/components/views/teambuilder/api.ts
index c3059d8c9..034110740 100644
--- a/python/packages/autogen-studio/frontend/src/components/views/teambuilder/api.ts
+++ b/python/packages/autogen-studio/frontend/src/components/views/teambuilder/api.ts
@@ -1,5 +1,6 @@
import { Team, Component, ComponentConfig } from "../../types/datamodel";
-import { getServerUrl } from "../../utils";
+import { BaseAPI } from "../../utils/baseapi";
+import { getServerUrl } from "../../utils/utils";
interface ValidationError {
field: string;
@@ -13,17 +14,7 @@ export interface ValidationResponse {
warnings: ValidationError[];
}
-export class TeamAPI {
- private getBaseUrl(): string {
- return getServerUrl();
- }
-
- private getHeaders(): HeadersInit {
- return {
- "Content-Type": "application/json",
- };
- }
-
+export class TeamAPI extends BaseAPI {
async listTeams(userId: string): Promise<Team[]> {
const response = await fetch(
`${this.getBaseUrl()}/teams/?user_id=${userId}`,
@@ -93,17 +84,7 @@ export class TeamAPI {
// move validationapi to its own class
-export class ValidationAPI {
- private getBaseUrl(): string {
- return getServerUrl();
- }
-
- private getHeaders(): HeadersInit {
- return {
- "Content-Type": "application/json",
- };
- }
-
+export class ValidationAPI extends BaseAPI {
async validateComponent(
component: Component<ComponentConfig>
): Promise<ValidationResponse> {
diff --git a/python/packages/autogen-studio/frontend/src/components/views/teambuilder/builder/testdrawer.tsx b/python/packages/autogen-studio/frontend/src/components/views/teambuilder/builder/testdrawer.tsx
index 134fa5840..1332882ef 100644
--- a/python/packages/autogen-studio/frontend/src/components/views/teambuilder/builder/testdrawer.tsx
+++ b/python/packages/autogen-studio/frontend/src/components/views/teambuilder/builder/testdrawer.tsx
@@ -20,7 +20,7 @@ const TestDrawer = ({ isVisble, onClose, team }: TestDrawerProps) => {
const [messageApi, contextHolder] = message.useMessage();
const createSession = async (teamId: number, teamName: string) => {
- if (!user?.email) return;
+ if (!user?.id) return;
try {
const defaultName = `Test Session ${teamName.substring(
0,
@@ -31,7 +31,7 @@ const TestDrawer = ({ isVisble, onClose, team }: TestDrawerProps) => {
name: defaultName,
team_id: teamId,
},
- user.email
+ user.id
);
setSession(created);
} catch (error) {
@@ -40,9 +40,9 @@ const TestDrawer = ({ isVisble, onClose, team }: TestDrawerProps) => {
};
const deleteSession = async (sessionId: number) => {
- if (!user?.email) return;
+ if (!user?.id) return;
try {
- await sessionAPI.deleteSession(sessionId, user.email);
+ await sessionAPI.deleteSession(sessionId, user.id);
setSession(null); // Clear session state after successful deletion
} catch (error) {
messageApi.error("Error deleting session");
diff --git a/python/packages/autogen-studio/frontend/src/components/views/teambuilder/manager.tsx b/python/packages/autogen-studio/frontend/src/components/views/teambuilder/manager.tsx
index e36c3a425..f6ee8fcf0 100644
--- a/python/packages/autogen-studio/frontend/src/components/views/teambuilder/manager.tsx
+++ b/python/packages/autogen-studio/frontend/src/components/views/teambuilder/manager.tsx
@@ -26,10 +26,10 @@ export const TeamManager: React.FC = () => {
// Initialize galleries
const fetchGalleries = useGalleryStore((state) => state.fetchGalleries);
useEffect(() => {
- if (user?.email) {
- fetchGalleries(user.email);
+ if (user?.id) {
+ fetchGalleries(user.id);
}
- }, [user?.email, fetchGalleries]);
+ }, [user?.id, fetchGalleries]);
// Persist sidebar state
useEffect(() => {
@@ -39,11 +39,11 @@ export const TeamManager: React.FC = () => {
}, [isSidebarOpen]);
const fetchTeams = useCallback(async () => {
- if (!user?.email) return;
+ if (!user?.id) return;
try {
setIsLoading(true);
- const data = await teamAPI.listTeams(user.email);
+ const data = await teamAPI.listTeams(user.id);
setTeams(data);
if (!currentTeam && data.length > 0) {
setCurrentTeam(data[0]);
@@ -53,7 +53,7 @@ export const TeamManager: React.FC = () => {
} finally {
setIsLoading(false);
}
- }, [user?.email, currentTeam]);
+ }, [user?.id, currentTeam]);
useEffect(() => {
fetchTeams();
@@ -70,7 +70,7 @@ export const TeamManager: React.FC = () => {
}, []);
const handleSelectTeam = async (selectedTeam: Team) => {
- if (!user?.email || !selectedTeam.id) return;
+ if (!user?.id || !selectedTeam.id) return;
if (hasUnsavedChanges) {
Modal.confirm({
@@ -88,10 +88,10 @@ export const TeamManager: React.FC = () => {
};
const switchToTeam = async (teamId: number | undefined) => {
- if (!teamId || !user?.email) return;
+ if (!teamId || !user?.id) return;
setIsLoading(true);
try {
- const data = await teamAPI.getTeam(teamId, user.email!);
+ const data = await teamAPI.getTeam(teamId, user.id!);
setCurrentTeam(data);
window.history.pushState({}, "", `?teamId=${teamId}`);
} catch (error) {
@@ -103,10 +103,10 @@ export const TeamManager: React.FC = () => {
};
const handleDeleteTeam = async (teamId: number) => {
- if (!user?.email) return;
+ if (!user?.id) return;
try {
- await teamAPI.deleteTeam(teamId, user.email);
+ await teamAPI.deleteTeam(teamId, user.id);
setTeams(teams.filter((t) => t.id !== teamId));
if (currentTeam?.id === teamId) {
setCurrentTeam(null);
@@ -124,7 +124,7 @@ export const TeamManager: React.FC = () => {
};
const handleSaveTeam = async (teamData: Partial<Team>) => {
- if (!user?.email) return;
+ if (!user?.id) return;
try {
const sanitizedTeamData = {
@@ -133,7 +133,7 @@ export const TeamManager: React.FC = () => {
updated_at: undefined,
};
- const savedTeam = await teamAPI.createTeam(sanitizedTeamData, user.email);
+ const savedTeam = await teamAPI.createTeam(sanitizedTeamData, user.id);
messageApi.success(
`Team ${teamData.id ? "updated" : "created"} successfully`
);
diff --git a/python/packages/autogen-studio/frontend/src/hooks/provider.tsx b/python/packages/autogen-studio/frontend/src/hooks/provider.tsx
index b4251189d..dee941487 100644
--- a/python/packages/autogen-studio/frontend/src/hooks/provider.tsx
+++ b/python/packages/autogen-studio/frontend/src/hooks/provider.tsx
@@ -1,66 +1,43 @@
import React, { useState } from "react";
-import {
- eraseCookie,
- getLocalStorage,
- setLocalStorage,
-} from "../components/utils";
-import { message } from "antd";
-
-export interface IUser {
- name: string;
- email?: string;
- username?: string;
- avatar_url?: string;
- metadata?: any;
-}
+import { AuthProvider, useAuth } from "../auth/context";
+import { getLocalStorage, setLocalStorage } from "../components/utils/utils";
+import { User } from "../auth/api";
export interface AppContextType {
- user: IUser | null;
+ darkMode: string;
+ setDarkMode: any;
+ user: User | null;
setUser: any;
logout: any;
cookie_name: string;
- darkMode: string;
- setDarkMode: any;
}
-const cookie_name = "coral_app_cookie_";
-
export const appContext = React.createContext<AppContextType>(
{} as AppContextType
);
-const Provider = ({ children }: any) => {
+
+const AppProvider = ({ children }: any) => {
+ // Dark mode handling
const storedValue = getLocalStorage("darkmode", false);
const [darkMode, setDarkMode] = useState(
storedValue === null ? "light" : storedValue === "dark" ? "dark" : "light"
);
- const logout = () => {
- // setUser(null);
- // eraseCookie(cookie_name);
- console.log("Please implement your own logout logic");
- message.info("Please implement your own logout logic");
- };
-
const updateDarkMode = (darkMode: string) => {
setDarkMode(darkMode);
setLocalStorage("darkmode", darkMode, false);
};
- // Modify logic here to add your own authentication
- const initUser = {
- name: "Guest User",
- email: "[email protected]",
- username: "guestuser",
- };
- const [user, setUser] = useState<IUser | null>(initUser);
+ // We'll use auth context to get user and logout function
+ const { user, logout } = useAuth();
return (
<appContext.Provider
value={{
user,
- setUser,
+ setUser: () => {},
logout,
- cookie_name,
+ cookie_name: "coral_app_cookie_",
darkMode,
setDarkMode: updateDarkMode,
}}
@@ -70,4 +47,9 @@ const Provider = ({ children }: any) => {
);
};
-export default ({ element }: any) => <Provider>{element}</Provider>;
+// Combined provider that includes both Auth and App context
+export default ({ element }: any) => (
+ <AuthProvider>
+ <AppProvider>{element}</AppProvider>
+ </AuthProvider>
+);
diff --git a/python/packages/autogen-studio/frontend/src/pages/callback.tsx b/python/packages/autogen-studio/frontend/src/pages/callback.tsx
new file mode 100644
index 000000000..bb2c505ec
--- /dev/null
+++ b/python/packages/autogen-studio/frontend/src/pages/callback.tsx
@@ -0,0 +1,97 @@
+import React, { useEffect, useState } from "react";
+import { useAuth } from "../auth/context";
+import { Spin, Typography, Alert } from "antd";
+import Layout from "../components/layout";
+import { graphql } from "gatsby";
+
+const { Title } = Typography;
+
+const CallbackPage = ({ data, location }: any) => {
+ const { handleAuthCallback } = useAuth();
+ const [error, setError] = useState<string | null>(null);
+ const [isProcessing, setIsProcessing] = useState(true);
+
+ useEffect(() => {
+ const processAuth = async () => {
+ try {
+ // Get the authorization code and state from URL search params
+ const params = new URLSearchParams(location.search);
+ const code = params.get("code");
+ const state = params.get("state");
+ const authError = params.get("error");
+
+ if (authError) {
+ setError(`Authentication error: ${authError}`);
+ setIsProcessing(false);
+ return;
+ }
+
+ if (!code) {
+ setError("No authorization code found in the URL");
+ setIsProcessing(false);
+ return;
+ }
+
+ // Handle the authorization code - for popup window
+ // The actual token handling is done by the backend HTML response
+ await handleAuthCallback(code, state || undefined);
+ setIsProcessing(false);
+ } catch (err) {
+ console.error("Error during auth callback:", err);
+ setError("Failed to complete authentication");
+ setIsProcessing(false);
+ }
+ };
+
+ processAuth();
+ }, [location.search, handleAuthCallback]);
+
+ return (
+ <Layout
+ meta={data.site.siteMetadata}
+ title="Authenticating"
+ link="/callback"
+ showHeader={false}
+ >
+ <div className="flex flex-col items-center justify-center h-screen">
+ {isProcessing ? (
+ <>
+ <Spin size="large" />
+ <Title level={4} className="mt-4">
+ Completing Authentication...
+ </Title>
+ </>
+ ) : error ? (
+ <Alert
+ message="Authentication Error"
+ description={error}
+ type="error"
+ showIcon
+ className="max-w-md"
+ />
+ ) : (
+ <Alert
+ message="Authentication Successful"
+ description="You have been successfully authenticated. You can close this window now."
+ type="success"
+ showIcon
+ className="max-w-md"
+ />
+ )}
+ </div>
+ </Layout>
+ );
+};
+
+export const query = graphql`
+ query CallbackPageQuery {
+ site {
+ siteMetadata {
+ description
+ title
+ }
+ }
+ }
+`;
+
+export default CallbackPage;
diff --git a/python/packages/autogen-studio/frontend/src/pages/login.tsx b/python/packages/autogen-studio/frontend/src/pages/login.tsx
new file mode 100644
index 000000000..4401126a7
--- /dev/null
+++ b/python/packages/autogen-studio/frontend/src/pages/login.tsx
@@ -0,0 +1,141 @@
+import React, { useEffect, useState } from "react";
+import { useAuth } from "../auth/context";
+import { navigate } from "gatsby";
+import { Button, Card, Typography, Space, Spin, message } from "antd";
+import { GithubOutlined } from "@ant-design/icons";
+import Layout from "../components/layout";
+import { graphql } from "gatsby";
+import Icon from "../components/icons";
+
+const { Title, Text } = Typography;
+
+// Use the same token key as in context.tsx
+const TOKEN_KEY = "auth_token";
+
+const LoginPage = ({ data }: any) => {
+ const { isAuthenticated, isLoading, login, authType } = useAuth();
+ const [isLoggingIn, setIsLoggingIn] = useState(false);
+
+ useEffect(() => {
+ // If user is already authenticated, redirect to home
+ if (isAuthenticated && !isLoading) {
+ navigate("/");
+ }
+ }, [isAuthenticated, isLoading]);
+
+ // If auth type is 'none', redirect to home
+ useEffect(() => {
+ if (authType === "none" && !isLoading) {
+ navigate("/");
+ }
+ }, [authType, isLoading]);
+
+ const handleLogin = async () => {
+ try {
+ setIsLoggingIn(true);
+ const loginUrl = await login();
+
+ if (!loginUrl) {
+ message.error("Failed to get login URL");
+ setIsLoggingIn(false);
+ return;
+ }
+
+ // Open a popup window for auth
+ const width = 600;
+ const height = 700;
+ const left = window.screen.width / 2 - width / 2;
+ const top = window.screen.height / 2 - height / 2;
+
+ const popup = window.open(
+ loginUrl,
+ "github-auth",
+ `width=${width},height=${height},top=${top},left=${left}`
+ );
+
+ // Check if popup was blocked
+ if (!popup || popup.closed || typeof popup.closed === "undefined") {
+ message.error(
+ "Popup was blocked by browser. Please allow popups for this site."
+ );
+ setIsLoggingIn(false);
+ return;
+ }
+
+ // Set a timer to check if the popup is closed without completing authentication
+ const checkPopupInterval = setInterval(() => {
+ if (popup.closed) {
+ clearInterval(checkPopupInterval);
+ setIsLoggingIn(false);
+ }
+ }, 1000);
+ } catch (error) {
+ console.error("Login error:", error);
+ message.error("Failed to initiate login");
+ setIsLoggingIn(false);
+ }
+ };
+
+ if (isLoading) {
+ return (
+ <Layout meta={data.site.siteMetadata} title="Login" link="/login">
+ <div className="flex items-center justify-center h-screen">
+ <Spin size="large" tip="Loading..." />
+ </div>
+ </Layout>
+ );
+ }
+
+ return (
+ <Layout
+ meta={data.site.siteMetadata}
+ title="Login"
+ link="/login"
+ showHeader={true}
+ restricted={false}
+ >
+ <div className="flex items-center justify-center h-[calc(100vh-164px)]">
+ <div className="w-full rounded bg-secondary max-w-md p-8 sxhadow-sm">
+ <div className="text-center mb-8">
+ <div className="mb-3">
+ <Icon icon="app" size={12} />
+ </div>
+ <div className="text-2xl mb-1 font-semibold text-primary">
+ Sign in to {data.site.siteMetadata.title}
+ </div>
+ <div className="text-secondary text-sm">
+ {" "}
+ Build and prototype multi-agent applications
+ </div>
+ </div>
+
+ <Space direction="vertical" className="w-full">
+ <Button
+ type="primary"
+ size="large"
+ icon={<GithubOutlined />}
+ onClick={handleLogin}
+ loading={isLoggingIn}
+ block
+ >
+ {isLoggingIn ? "Connecting to GitHub..." : "Sign in with GitHub"}
+ </Button>
+ </Space>
+ </div>
+ </div>
+ </Layout>
+ );
+};
+
+export const query = graphql`
+ query LoginPageQuery {
+ site {
+ siteMetadata {
+ description
+ title
+ }
+ }
+ }
+`;
+
+export default LoginPage;
diff --git a/python/packages/autogen-studio/tests/test_db_manager.py b/python/packages/autogen-studio/tests/test_db_manager.py
index 02f5964bc..ac51caf26 100644
--- a/python/packages/autogen-studio/tests/test_db_manager.py
+++ b/python/packages/autogen-studio/tests/test_db_manager.py
@@ -1,9 +1,7 @@
-import os
import asyncio
import pytest
from sqlmodel import Session, text, select
from typing import Generator
-from pathlib import Path
from autogenstudio.database import DatabaseManager
from autogen_agentchat.agents import AssistantAgent