WIP: Staged all changes

backend/src/api/auth.py

@@ -0,0 +1,52 @@
+# [DEF:AuthModule:Module]
+# @SEMANTICS: auth, authentication, adfs, oauth, middleware
+# @PURPOSE: Implements ADFS authentication using Authlib for FastAPI. It provides a dependency to protect endpoints.
+# @LAYER: UI (API)
+# @RELATION: Used by API routers to protect endpoints that require authentication.
+
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2AuthorizationCodeBearer
+from authlib.integrations.starlette_client import OAuth
+from starlette.config import Config
+
+# Placeholder for ADFS configuration. In a real app, this would come from a secure source.
+# Create an in-memory .env file
+from io import StringIO
+config_data = StringIO("""
+ADFS_CLIENT_ID=your-client-id
+ADFS_CLIENT_SECRET=your-client-secret
+ADFS_SERVER_METADATA_URL=https://your-adfs-server/.well-known/openid-configuration
+""")
+config = Config(config_data)
+oauth = OAuth(config)
+
+oauth.register(
+    name='adfs',
+    server_metadata_url=config('ADFS_SERVER_METADATA_URL'),
+    client_kwargs={'scope': 'openid profile email'}
+)
+
+oauth2_scheme = OAuth2AuthorizationCodeBearer(
+    authorizationUrl="https://your-adfs-server/adfs/oauth2/authorize",
+    tokenUrl="https://your-adfs-server/adfs/oauth2/token",
+)
+
+async def get_current_user(token: str = Depends(oauth2_scheme)):
+    """
+    Dependency to get the current user from the ADFS token.
+    This is a placeholder and needs to be fully implemented.
+    """
+    # In a real implementation, you would:
+    # 1. Validate the token with ADFS.
+    # 2. Fetch user information.
+    # 3. Create a user object.
+    # For now, we'll just check if a token exists.
+    if not token:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Not authenticated",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    # A real implementation would return a user object.
+    return {"placeholder_user": "user@example.com"}
+# [/DEF]

backend/src/api/routes/plugins.py

@@ -0,0 +1,22 @@
+# [DEF:PluginsRouter:Module]
+# @SEMANTICS: api, router, plugins, list
+# @PURPOSE: Defines the FastAPI router for plugin-related endpoints, allowing clients to list available plugins.
+# @LAYER: UI (API)
+# @RELATION: Depends on the PluginLoader and PluginConfig. It is included by the main app.
+from typing import List
+from fastapi import APIRouter, Depends
+
+from ...core.plugin_base import PluginConfig
+from ...dependencies import get_plugin_loader
+
+router = APIRouter()
+
+@router.get("/", response_model=List[PluginConfig])
+async def list_plugins(
+    plugin_loader = Depends(get_plugin_loader)
+):
+    """
+    Retrieve a list of all available plugins.
+    """
+    return plugin_loader.get_all_plugin_configs()
+# [/DEF]

backend/src/api/routes/tasks.py

@@ -0,0 +1,57 @@
+# [DEF:TasksRouter:Module]
+# @SEMANTICS: api, router, tasks, create, list, get
+# @PURPOSE: Defines the FastAPI router for task-related endpoints, allowing clients to create, list, and get the status of tasks.
+# @LAYER: UI (API)
+# @RELATION: Depends on the TaskManager. It is included by the main app.
+from typing import List, Dict, Any
+from fastapi import APIRouter, Depends, HTTPException, status
+from pydantic import BaseModel
+
+from ...core.task_manager import TaskManager, Task
+from ...dependencies import get_task_manager
+
+router = APIRouter()
+
+class CreateTaskRequest(BaseModel):
+    plugin_id: str
+    params: Dict[str, Any]
+
+@router.post("/", response_model=Task, status_code=status.HTTP_201_CREATED)
+async def create_task(
+    request: CreateTaskRequest,
+    task_manager: TaskManager = Depends(get_task_manager)
+):
+    """
+    Create and start a new task for a given plugin.
+    """
+    try:
+        task = await task_manager.create_task(
+            plugin_id=request.plugin_id,
+            params=request.params
+        )
+        return task
+    except ValueError as e:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(e))
+
+@router.get("/", response_model=List[Task])
+async def list_tasks(
+    task_manager: TaskManager = Depends(get_task_manager)
+):
+    """
+    Retrieve a list of all tasks.
+    """
+    return task_manager.get_all_tasks()
+
+@router.get("/{task_id}", response_model=Task)
+async def get_task(
+    task_id: str,
+    task_manager: TaskManager = Depends(get_task_manager)
+):
+    """
+    Retrieve the details of a specific task.
+    """
+    task = task_manager.get_task(task_id)
+    if not task:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Task not found")
+    return task
+# [/DEF]