adapt-server 0.1.0__py3-none-any.whl

adapt/__init__.py

@@ -0,0 +1,3 @@
+"""Adapt package namespace."""
+
+__version__ = "0.1.0"

adapt/__main__.py

@@ -0,0 +1,5 @@
+import sys
+from adapt.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

adapt/admin/__init__.py

@@ -0,0 +1,10 @@
+from fastapi import APIRouter
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/admin", tags=["admin"])
+logger.debug("Admin router initialized with prefix /admin")
+
+# Import all submodules to register routes
+from . import ui, users, locks, groups, permissions, api_keys, audit_logs, cache

adapt/admin/api_keys.py

@@ -0,0 +1,123 @@
+from fastapi import Depends, HTTPException, Request, Query
+from sqlalchemy import asc, desc
+from sqlmodel import Session, select
+from typing import List
+from datetime import datetime, timedelta, timezone
+import logging
+
+from ..auth import require_superuser
+from ..storage import User, APIKey, get_db_session
+from ..api_keys import generate_api_key
+from ..audit import log_action
+from . import router
+from .models import APIKeyCreate
+
+logger = logging.getLogger(__name__)
+
+@router.get("/api-keys", response_model=List[APIKey])
+def list_api_keys(
+    db: Session = Depends(get_db_session),
+    user_id: int | None = Query(None, ge=1),
+    is_active: bool | None = Query(None),
+    limit: int = Query(None, ge=1, le=1000),
+    offset: int = Query(0, ge=0),
+    sort: str = Query(None, pattern="^(created_at|expires_at|last_used_at|is_active|description)$"),
+    order: str = Query("asc", pattern="^(asc|desc)$"),
+    filter: str = None,
+    user = Depends(require_superuser)
+):
+    """List all API keys in the system with optional query parameters."""
+    import json
+
+    stmt = select(APIKey)
+
+    if user_id is not None:
+        stmt = stmt.where(APIKey.user_id == user_id)
+    if is_active is not None:
+        stmt = stmt.where(APIKey.is_active == is_active)
+
+    if filter:
+        filter_dict = json.loads(filter)
+        allowed_filters = {
+            "user_id": APIKey.user_id,
+            "description": APIKey.description,
+            "is_active": APIKey.is_active,
+        }
+        for key, value in filter_dict.items():
+            column = allowed_filters.get(key)
+            if column is not None:
+                stmt = stmt.where(column == value)
+
+    sort_columns = {
+        "created_at": APIKey.created_at,
+        "expires_at": APIKey.expires_at,
+        "last_used_at": APIKey.last_used_at,
+        "is_active": APIKey.is_active,
+        "description": APIKey.description,
+    }
+    sort_column = sort_columns.get(sort, APIKey.created_at)
+    stmt = stmt.order_by(asc(sort_column) if order == "asc" else desc(sort_column))
+
+    stmt = stmt.offset(offset)
+    if limit is not None:
+        stmt = stmt.limit(limit)
+
+    result = db.exec(stmt).all()
+    logger.debug("Listed %d API keys with SQL query params", len(result))
+    return result
+
+@router.post("/api-keys")
+def create_api_key(key_data: APIKeyCreate, request: Request, db: Session = Depends(get_db_session), user = Depends(require_superuser)):
+    """Create a new API key for a user."""
+    target_user = db.get(User, key_data.user_id)
+    if not target_user:
+        logger.warning("Attempted to create API key for non-existent user %d", key_data.user_id)
+        raise HTTPException(status_code=404, detail="User not found")
+        
+    raw_key, key_hash = generate_api_key()
+    
+    expires_at = None
+    if key_data.expires_in_days is not None:
+        if key_data.expires_in_days > 365:
+            raise HTTPException(status_code=400, detail="Expiration cannot exceed 1 year (365 days)")
+        expires_at = datetime.now(tz=timezone.utc) + timedelta(days=key_data.expires_in_days)
+        
+    api_key = APIKey(
+        user_id=key_data.user_id,
+        key_hash=key_hash,
+        description=key_data.description,
+        expires_at=expires_at
+    )
+    db.add(api_key)
+    db.commit()
+    db.refresh(api_key)
+    
+    log_action(request, "create_api_key", "apikey", f"Created API key for user {target_user.username}", user.id)
+    logger.info("Created API key %d for user %s", api_key.id, target_user.username)
+    
+    # Return the raw key only once!
+    return {
+        "id": api_key.id,
+        "key": raw_key,
+        "user_id": api_key.user_id,
+        "description": api_key.description,
+        "expires_at": api_key.expires_at.isoformat() if api_key.expires_at else None,
+        "created_at": api_key.created_at.isoformat() if api_key.created_at else None,
+    }
+
+@router.delete("/api-keys/{key_id}")
+def revoke_api_key(key_id: int, request: Request, db: Session = Depends(get_db_session), user = Depends(require_superuser)):
+    """Revoke an API key by ID."""
+    api_key = db.get(APIKey, key_id)
+    if not api_key:
+        logger.warning("Attempted to revoke non-existent API key %d", key_id)
+        raise HTTPException(status_code=404, detail="API Key not found")
+        
+    api_key.is_active = False
+    db.add(api_key)
+    db.commit()
+    
+    log_action(request, "revoke_api_key", "apikey", f"Revoked API key {key_id}", user.id)
+    logger.info("Revoked API key %d", key_id)
+    
+    return {"success": True}

adapt/admin/audit_logs.py

@@ -0,0 +1,66 @@
+from fastapi import Depends, Query
+from sqlalchemy import asc, desc
+from sqlmodel import Session, select
+from typing import List
+import logging
+
+from ..auth import require_superuser
+from ..storage import AuditLog, get_db_session
+from . import router
+
+logger = logging.getLogger(__name__)
+
+@router.get("/audit-logs", response_model=List[AuditLog])
+def list_audit_logs(
+    db: Session = Depends(get_db_session),
+    user_id: int | None = Query(None, ge=1),
+    action: str | None = Query(None),
+    resource: str | None = Query(None),
+    limit: int = Query(None, ge=1, le=1000),
+    offset: int = Query(0, ge=0),
+    sort: str = Query(None, pattern="^(timestamp|action|resource)$"),
+    order: str = Query("desc", pattern="^(asc|desc)$"),
+    filter: str = None,
+    user = Depends(require_superuser)
+):
+    """List audit logs with optional query parameters."""
+    import json
+
+    stmt = select(AuditLog)
+
+    if user_id is not None:
+        stmt = stmt.where(AuditLog.user_id == user_id)
+    if action:
+        stmt = stmt.where(AuditLog.action == action)
+    if resource:
+        stmt = stmt.where(AuditLog.resource == resource)
+
+    if filter:
+        filter_dict = json.loads(filter)
+        allowed_filters = {
+            "user_id": AuditLog.user_id,
+            "action": AuditLog.action,
+            "resource": AuditLog.resource,
+            "details": AuditLog.details,
+            "ip_address": AuditLog.ip_address,
+        }
+        for key, value in filter_dict.items():
+            column = allowed_filters.get(key)
+            if column is not None:
+                stmt = stmt.where(column == value)
+
+    sort_columns = {
+        "timestamp": AuditLog.timestamp,
+        "action": AuditLog.action,
+        "resource": AuditLog.resource,
+    }
+    sort_column = sort_columns.get(sort, AuditLog.timestamp)
+    stmt = stmt.order_by(asc(sort_column) if order == "asc" else desc(sort_column))
+
+    stmt = stmt.offset(offset)
+    if limit is not None:
+        stmt = stmt.limit(limit)
+
+    result = db.exec(stmt).all()
+    logger.debug("Listed %d audit logs with SQL query params", len(result))
+    return result

adapt/admin/cache.py

@@ -0,0 +1,78 @@
+from fastapi import Depends, HTTPException, Request, Query
+from pydantic import BaseModel
+from typing import List, Optional
+import logging
+
+from ..auth import require_superuser
+from ..cache import list_cache, invalidate_cache
+from ..audit import log_action
+from . import router
+
+logger = logging.getLogger(__name__)
+
+class CacheEntry(BaseModel):
+    """Model for cache entry representation."""
+    key: str
+    expires_at: str
+    resource: str
+    user: Optional[str]
+
+@router.get("/cache", response_model=List[CacheEntry])
+def list_cache_entries(
+    resource: Optional[str] = None,
+    limit: int = Query(None, ge=1, le=1000),
+    offset: int = Query(0, ge=0),
+    sort: str = Query(None, pattern="^(key|expires_at|resource|user)$"),
+    order: str = Query("asc", pattern="^(asc|desc)$"),
+    filter: str = None,
+    user = Depends(require_superuser)
+):
+    """List cache entries with optional query parameters."""
+    from ..utils.query import apply_filter, apply_sort, apply_pagination
+    import json
+    
+    entries = list_cache(resource)
+    
+    # Convert to dicts for filtering/sorting
+    entry_dicts = []
+    for e in entries:
+        entry_dicts.append({
+            "key": e['key'],
+            "expires_at": e['expires_at'],
+            "resource": e['resource'],
+            "user": e['user']
+        })
+    
+    # Apply filters
+    if filter:
+        filter_dict = json.loads(filter)
+        entry_dicts = apply_filter(entry_dicts, filter_dict)
+    
+    # Apply sorting
+    if sort:
+        entry_dicts = apply_sort(entry_dicts, sort, order)
+    
+    # Apply pagination
+    entry_dicts = apply_pagination(entry_dicts, offset, limit)
+    
+    # Convert back to CacheEntry objects
+    result = [CacheEntry(key=e['key'], expires_at=e['expires_at'], resource=e['resource'], user=e['user']) for e in entry_dicts]
+    
+    logger.debug("Listed %d cache entries with query params", len(result))
+    return result
+
+@router.delete("/cache")
+def clear_cache(request: Request, resource: Optional[str] = None, user = Depends(require_superuser)):
+    """Clear cache entries, optionally for a specific resource."""
+    invalidate_cache(resource)
+    log_action(request, "clear_cache", "cache", f"Cleared cache for resource {resource or 'all'}", user.id)
+    logger.info("Cleared cache for resource %s", resource or "all")
+    return {"success": True}
+
+@router.delete("/cache/{key}")
+def delete_cache_entry(key: str, resource: str, request: Request, user = Depends(require_superuser)):
+    """Delete a specific cache entry."""
+    invalidate_cache(resource, key)
+    log_action(request, "delete_cache_entry", "cache", f"Deleted cache entry {key} for {resource}", user.id)
+    logger.info("Deleted cache entry %s for resource %s", key, resource)
+    return {"success": True}

adapt/admin/groups.py

@@ -0,0 +1,170 @@
+from fastapi import Depends, HTTPException, Request, Query
+from sqlmodel import Session, select
+from typing import List
+import logging
+
+from ..auth import require_superuser
+from ..storage import User, Group, UserGroup, get_db_session
+from ..audit import log_action
+from . import router
+from .models import GroupCreate, GroupRead
+
+logger = logging.getLogger(__name__)
+
+@router.get("/groups", response_model=List[Group])
+def list_groups(
+    db: Session = Depends(get_db_session),
+    limit: int = Query(None, ge=1, le=1000),
+    offset: int = Query(0, ge=0),
+    sort: str = Query(None, pattern="^(name|description)$"),
+    order: str = Query("asc", pattern="^(asc|desc)$"),
+    filter: str = None,
+    user = Depends(require_superuser)
+):
+    """List all groups with optional query parameters."""
+    from ..utils.query import apply_filter, apply_sort, apply_pagination
+    import json
+    
+    groups = db.exec(select(Group)).all()
+    
+    # Convert to dicts
+    group_dicts = []
+    for g in groups:
+        group_dicts.append({
+            "id": g.id,
+            "name": g.name,
+            "description": g.description
+        })
+    
+    # Apply filters
+    if filter:
+        filter_dict = json.loads(filter)
+        group_dicts = apply_filter(group_dicts, filter_dict)
+    
+    # Apply sorting
+    if sort:
+        group_dicts = apply_sort(group_dicts, sort, order)
+    
+    # Apply pagination
+    group_dicts = apply_pagination(group_dicts, offset, limit)
+    
+    # Convert back to Group objects
+    result = []
+    for gd in group_dicts:
+        g = db.get(Group, gd["id"])
+        if g:
+            result.append(g)
+    
+    logger.debug("Listed %d groups with query params", len(result))
+    return result
+
+@router.get("/groups/{group_id}", response_model=GroupRead)
+def get_group(group_id: int, db: Session = Depends(get_db_session), user = Depends(require_superuser)):
+    """Get a group by ID, including its users."""
+    group = db.get(Group, group_id)
+    if not group:
+        logger.warning("Attempted to get non-existent group %d", group_id)
+        raise HTTPException(status_code=404, detail="Group not found")
+    # Manually load users since it's a many-to-many relationship
+    # Note: SQLModel should handle this if configured correctly, but let's be explicit
+    # We need to join UserGroup and User
+    stmt = select(User).join(UserGroup).where(UserGroup.group_id == group_id)
+    users = db.exec(stmt).all()
+    
+    logger.debug("Retrieved group %s with %d users", group.name, len(users))
+    return GroupRead(
+        id=group.id,
+        name=group.name,
+        description=group.description,
+        users=users
+    )
+
+@router.post("/groups", response_model=Group)
+def create_group(group_data: GroupCreate, request: Request, db: Session = Depends(get_db_session), user = Depends(require_superuser)):
+    """Create a new group."""
+    # Check if server is in read-only mode
+    if request.app.state.config.readonly:
+        raise HTTPException(status_code=405, detail="Server is in read-only mode")
+    
+    existing = db.exec(select(Group).where(Group.name == group_data.name)).first()
+    if existing:
+        logger.warning("Attempted to create group with existing name %s", group_data.name)
+        raise HTTPException(status_code=400, detail="Group already exists")
+    
+    group = Group(name=group_data.name, description=group_data.description)
+    db.add(group)
+    db.commit()
+    db.refresh(group)
+    
+    log_action(request, "create_group", "group", f"Created group {group.name}", user.id)
+    logger.info("Created group %s", group.name)
+    
+    return group
+
+@router.delete("/groups/{group_id}")
+def delete_group(group_id: int, request: Request, db: Session = Depends(get_db_session), user = Depends(require_superuser)):
+    """Delete a group by ID."""
+    # Check if server is in read-only mode
+    if request.app.state.config.readonly:
+        raise HTTPException(status_code=405, detail="Server is in read-only mode")
+    
+    group = db.get(Group, group_id)
+    if not group:
+        logger.warning("Attempted to delete non-existent group %d", group_id)
+        raise HTTPException(status_code=404, detail="Group not found")
+    db.delete(group)
+    db.commit()
+    
+    log_action(request, "delete_group", "group", f"Deleted group {group.name}", user.id)
+    logger.info("Deleted group %s", group.name)
+    
+    return {"success": True}
+
+@router.post("/groups/{group_id}/users/{user_id}")
+def add_user_to_group(group_id: int, user_id: int, request: Request, db: Session = Depends(get_db_session), user = Depends(require_superuser)):
+    """Add a user to a group."""
+    # Check if server is in read-only mode
+    if request.app.state.config.readonly:
+        raise HTTPException(status_code=405, detail="Server is in read-only mode")
+    
+    # Check existence
+    target_user = db.get(User, user_id)
+    target_group = db.get(Group, group_id)
+    if not target_user or not target_group:
+         logger.warning("Attempted to add user %d to group %d: user or group not found", user_id, group_id)
+         raise HTTPException(status_code=404, detail="User or Group not found")
+         
+    link = db.get(UserGroup, (user_id, group_id))
+    if link:
+        logger.debug("User %s already in group %s", target_user.username, target_group.name)
+        return {"success": True} # Already member
+        
+    link = UserGroup(user_id=user_id, group_id=group_id)
+    db.add(link)
+    db.commit()
+    log_action(request, "add_user_to_group", "group", f"Added user {target_user.username} to group {target_group.name}", user.id)
+    logger.info("Added user %s to group %s", target_user.username, target_group.name)
+    return {"success": True}
+
+@router.delete("/groups/{group_id}/users/{user_id}")
+def remove_user_from_group(group_id: int, user_id: int, request: Request, db: Session = Depends(get_db_session), user = Depends(require_superuser)):
+    """Remove a user from a group."""
+    # Check if server is in read-only mode
+    if request.app.state.config.readonly:
+        raise HTTPException(status_code=405, detail="Server is in read-only mode")
+    
+    target_user = db.get(User, user_id)
+    target_group = db.get(Group, group_id)
+    if not target_user or not target_group:
+         logger.warning("Attempted to remove user %d from group %d: user or group not found", user_id, group_id)
+         raise HTTPException(status_code=404, detail="User or Group not found")
+
+    link = db.get(UserGroup, (user_id, group_id))
+    if link:
+        db.delete(link)
+        db.commit()
+        log_action(request, "remove_user_from_group", "group", f"Removed user {target_user.username} from group {target_group.name}", user.id)
+        logger.info("Removed user %s from group %s", target_user.username, target_group.name)
+    else:
+        logger.debug("User %s not in group %s", target_user.username, target_group.name)
+    return {"success": True}

adapt/admin/locks.py

@@ -0,0 +1,82 @@
+from fastapi import Depends, HTTPException, Request, Query
+from sqlmodel import Session, select
+from typing import List
+import logging
+
+from ..auth import require_superuser
+from ..storage import LockRecord, get_db_session
+from ..locks import LockManager
+from ..audit import log_action
+from . import router
+
+logger = logging.getLogger(__name__)
+
+@router.get("/locks", response_model=List[LockRecord])
+def list_locks(
+    db: Session = Depends(get_db_session),
+    limit: int = Query(None, ge=1, le=1000),
+    offset: int = Query(0, ge=0),
+    sort: str = Query(None, pattern="^(id|resource|owner|acquired_at|expires_at|reason)$"),
+    order: str = Query("asc", pattern="^(asc|desc)$"),
+    filter: str = None,
+    user = Depends(require_superuser)
+):
+    """List all active locks with optional query parameters."""
+    from ..utils.query import apply_filter, apply_sort, apply_pagination
+    import json
+    
+    locks = db.exec(select(LockRecord)).all()
+    
+    # Convert to dicts for filtering/sorting
+    lock_dicts = []
+    for l in locks:
+        lock_dicts.append({
+            "id": l.id,
+            "resource": l.resource,
+            "owner": l.owner,
+            "acquired_at": l.acquired_at.isoformat() if l.acquired_at else None,
+            "expires_at": l.expires_at.isoformat() if l.expires_at else None,
+            "reason": l.reason
+        })
+    
+    # Apply filters
+    if filter:
+        filter_dict = json.loads(filter)
+        lock_dicts = apply_filter(lock_dicts, filter_dict)
+    
+    # Apply sorting
+    if sort:
+        lock_dicts = apply_sort(lock_dicts, sort, order)
+    
+    # Apply pagination
+    lock_dicts = apply_pagination(lock_dicts, offset, limit)
+    
+    # Convert back to LockRecord objects
+    result = []
+    for ld in lock_dicts:
+        l = db.get(LockRecord, ld["id"])
+        if l:
+            result.append(l)
+    
+    logger.debug("Listed %d active locks with query params", len(result))
+    return result
+
+@router.delete("/locks/{lock_id}")
+def release_lock(lock_id: int, request: Request, user = Depends(require_superuser)):
+    """Release a specific lock by ID."""
+    manager: LockManager = request.app.state.lock_manager
+    if manager.release_lock(lock_id):
+        log_action(request, "release_lock", "lock", f"Released lock {lock_id}", user.id)
+        logger.info("Released lock %d", lock_id)
+        return {"success": True}
+    logger.warning("Attempted to release non-existent lock %d", lock_id)
+    raise HTTPException(status_code=404, detail="Lock not found")
+
+@router.post("/locks/clean")
+def clean_stale_locks(request: Request, user = Depends(require_superuser)):
+    """Clean up stale locks."""
+    manager: LockManager = request.app.state.lock_manager
+    count = manager.release_stale_locks()
+    log_action(request, "clean_stale_locks", "lock", f"Released {count} stale locks", user.id)
+    logger.info("Cleaned up %d stale locks", count)
+    return {"released": count}

adapt/admin/models.py

@@ -0,0 +1,37 @@
+from pydantic import BaseModel
+from typing import List, Optional
+import logging
+
+from ..storage import User
+
+logger = logging.getLogger(__name__)
+
+class UserCreate(BaseModel):
+    """Model for creating a new user."""
+    username: str
+    password: str
+    is_superuser: bool = False
+
+class GroupCreate(BaseModel):
+    """Model for creating a new group."""
+    name: str
+    description: Optional[str] = None
+
+class GroupRead(BaseModel):
+    """Model for reading group data with users."""
+    id: int
+    name: str
+    description: Optional[str] = None
+    users: List[User] = []
+
+class PermissionCreate(BaseModel):
+    """Model for creating a new permission."""
+    resource: str
+    action: str
+    description: Optional[str] = None
+
+class APIKeyCreate(BaseModel):
+    """Model for creating a new API key."""
+    user_id: int
+    description: Optional[str] = None
+    expires_in_days: Optional[int] = None