vibesurf 0.1.0__py3-none-any.whl

vibe_surf/backend/api/files.py

@@ -0,0 +1,322 @@
+"""
+File Upload and Management Router
+
+Handles file uploads to workspace directories, file retrieval, and listing
+of uploaded files for VibeSurf sessions.
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Form
+from fastapi.responses import FileResponse
+from sqlalchemy.ext.asyncio import AsyncSession
+from typing import List, Optional, Dict, Any
+import os
+import shutil
+import logging
+from datetime import datetime
+from uuid_extensions import uuid7str
+import mimetypes
+from pathlib import Path
+
+from ..database import get_db_session
+from ..database.queries import UploadedFileQueries
+from .models import FileListQueryRequest, SessionFilesQueryRequest
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/files", tags=["files"])
+
+def get_upload_directory(session_id: Optional[str] = None) -> str:
+    from ..shared_state import workspace_dir
+    """Get the upload directory path for a session or global uploads"""
+    if session_id:
+        upload_dir = os.path.join(workspace_dir, session_id, "upload_files")
+    else:
+        upload_dir = os.path.join(workspace_dir, "upload_files")
+    
+    # Create directory if it doesn't exist
+    os.makedirs(upload_dir, exist_ok=True)
+    return upload_dir
+
+def is_safe_path(basedir: str, path: str) -> bool:
+    """Check if the path is safe (within basedir)"""
+    try:
+        # Resolve both paths to absolute paths
+        basedir = os.path.abspath(basedir)
+        path = os.path.abspath(path)
+        
+        # Check if path starts with basedir
+        return path.startswith(basedir)
+    except:
+        return False
+
+@router.post("/upload")
+async def upload_files(
+    files: List[UploadFile] = File(...),
+    session_id: Optional[str] = Form(None),
+    db: AsyncSession = Depends(get_db_session)
+):
+    """Upload files to workspace/upload_files folder or session-specific folder"""
+    try:
+        from ..shared_state import workspace_dir
+
+        upload_dir = get_upload_directory(session_id)
+        uploaded_file_info = []
+        
+        for file in files:
+            if not file.filename:
+                continue
+                
+            # Generate unique file ID
+            file_id = uuid7str()
+            
+            # Create safe filename
+            filename = file.filename
+            file_path = os.path.join(upload_dir, filename)
+            
+            # Handle duplicate filenames by adding suffix
+            counter = 1
+            base_name, ext = os.path.splitext(filename)
+            while os.path.exists(file_path):
+                new_filename = f"{base_name}_{counter}{ext}"
+                file_path = os.path.join(upload_dir, new_filename)
+                filename = new_filename
+                counter += 1
+            
+            # Ensure path is safe
+            if not is_safe_path(upload_dir, file_path):
+                raise HTTPException(status_code=400, detail=f"Invalid file path: {filename}")
+            
+            # Save file
+            try:
+                with open(file_path, "wb") as buffer:
+                    shutil.copyfileobj(file.file, buffer)
+                
+                # Get file info
+                file_size = os.path.getsize(file_path)
+                mime_type, _ = mimetypes.guess_type(file_path)
+                relative_path = os.path.relpath(file_path, workspace_dir)
+                
+                # Store file metadata in database
+                uploaded_file = await UploadedFileQueries.create_file_record(
+                    db=db,
+                    file_id=file_id,
+                    original_filename=file.filename,
+                    stored_filename=filename,
+                    file_path=file_path,
+                    session_id=session_id,
+                    file_size=file_size,
+                    mime_type=mime_type or "application/octet-stream",
+                    relative_path=relative_path
+                )
+                
+                # Create response metadata
+                file_metadata = {
+                    "file_id": uploaded_file.file_id,
+                    "original_filename": uploaded_file.original_filename,
+                    "stored_filename": uploaded_file.stored_filename,
+                    "session_id": uploaded_file.session_id,
+                    "file_size": uploaded_file.file_size,
+                    "mime_type": uploaded_file.mime_type,
+                    "upload_time": uploaded_file.upload_time.isoformat(),
+                    "file_path": file_path
+                }
+                
+                uploaded_file_info.append(file_metadata)
+                
+                logger.info(f"File uploaded: {filename} (ID: {file_id}) to {upload_dir}")
+                
+            except Exception as e:
+                logger.error(f"Failed to save file {filename}: {e}")
+                # If database record was created but file save failed, clean up
+                try:
+                    await UploadedFileQueries.hard_delete_file(db, file_id)
+                except:
+                    pass
+                raise HTTPException(status_code=500, detail=f"Failed to save file {filename}: {str(e)}")
+        
+        # Commit all database changes
+        await db.commit()
+        
+        return {
+            "message": f"Successfully uploaded {len(uploaded_file_info)} files",
+            "files": uploaded_file_info,
+            "upload_directory": upload_dir
+        }
+        
+    except Exception as e:
+        logger.error(f"File upload failed: {e}")
+        raise HTTPException(status_code=500, detail=f"File upload failed: {str(e)}")
+
+@router.get("/{file_id}")
+async def download_file(file_id: str, db: AsyncSession = Depends(get_db_session)):
+    """Download file by file ID"""
+    from ..shared_state import workspace_dir
+
+    uploaded_file = await UploadedFileQueries.get_file(db, file_id)
+    if not uploaded_file:
+        raise HTTPException(status_code=404, detail="File not found")
+    
+    file_path = uploaded_file.file_path
+    
+    if not os.path.exists(file_path):
+        raise HTTPException(status_code=404, detail="File not found on disk")
+    
+    # Ensure path is safe
+    if not is_safe_path(workspace_dir, file_path):
+        raise HTTPException(status_code=403, detail="Access denied")
+    
+    return FileResponse(
+        path=file_path,
+        filename=uploaded_file.original_filename,
+        media_type=uploaded_file.mime_type
+    )
+
+@router.get("")
+async def list_uploaded_files(
+    query: FileListQueryRequest = Depends(),
+    db: AsyncSession = Depends(get_db_session)
+):
+    """List uploaded files, optionally filtered by session"""
+    try:
+        # Get files from database
+        uploaded_files = await UploadedFileQueries.list_files(
+            db=db,
+            session_id=query.session_id,
+            limit=query.limit,
+            offset=query.offset,
+            active_only=True
+        )
+        
+        # Get total count
+        total_count = await UploadedFileQueries.count_files(
+            db=db,
+            session_id=query.session_id,
+            active_only=True
+        )
+        
+        # Convert to response format (exclude file_path for security)
+        files_response = []
+        for file_record in uploaded_files:
+            files_response.append({
+                "file_id": file_record.file_id,
+                "original_filename": file_record.original_filename,
+                "stored_filename": file_record.stored_filename,
+                "session_id": file_record.session_id,
+                "file_size": file_record.file_size,
+                "mime_type": file_record.mime_type,
+                "upload_time": file_record.upload_time.isoformat(),
+                "file_path": file_record.file_path
+            })
+        
+        return {
+            "files": files_response,
+            "total_count": total_count,
+            "limit": query.limit,
+            "offset": query.offset,
+            "has_more": query.limit != -1 and (query.offset + query.limit < total_count),
+            "session_id": query.session_id
+        }
+        
+    except Exception as e:
+        logger.error(f"Failed to list files: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to list files: {str(e)}")
+
+@router.delete("/{file_id}")
+async def delete_file(file_id: str, db: AsyncSession = Depends(get_db_session)):
+    """Delete uploaded file by file ID"""
+    # Get file record
+    uploaded_file = await UploadedFileQueries.get_file(db, file_id)
+    if not uploaded_file:
+        raise HTTPException(status_code=404, detail="File not found")
+    
+    try:
+        # Remove file from disk
+        if os.path.exists(uploaded_file.file_path):
+            os.remove(uploaded_file.file_path)
+        
+        # Soft delete from database
+        success = await UploadedFileQueries.delete_file(db, file_id)
+        if not success:
+            raise HTTPException(status_code=500, detail="Failed to delete file record")
+        
+        await db.commit()
+        
+        return {
+            "message": f"File {uploaded_file.original_filename} deleted successfully",
+            "file_id": file_id
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to delete file {file_id}: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to delete file: {str(e)}")
+
+@router.get("/session/{session_id}")
+async def list_session_files(
+    session_id: str,
+    query: SessionFilesQueryRequest = Depends()
+):
+    """List all files in a session directory"""
+    try:
+        from ..shared_state import workspace_dir
+        session_dir = os.path.join(workspace_dir, session_id)
+        
+        if not os.path.exists(session_dir):
+            return {
+                "session_id": session_id,
+                "files": [],
+                "directories": [],
+                "message": "Session directory not found"
+            }
+        
+        files = []
+        directories = []
+        
+        for root, dirs, filenames in os.walk(session_dir):
+            # Calculate relative path from session directory
+            rel_root = os.path.relpath(root, session_dir)
+            if rel_root == ".":
+                rel_root = ""
+            
+            # Add directories if requested
+            if query.include_directories:
+                for dirname in dirs:
+                    dir_path = os.path.join(rel_root, dirname) if rel_root else dirname
+                    directories.append({
+                        "name": dirname,
+                        "path": dir_path,
+                        "type": "directory"
+                    })
+            
+            # Add files
+            for filename in filenames:
+                file_path = os.path.join(root, filename)
+                rel_path = os.path.join(rel_root, filename) if rel_root else filename
+                
+                try:
+                    stat = os.stat(file_path)
+                    mime_type, _ = mimetypes.guess_type(file_path)
+                    
+                    files.append({
+                        "name": filename,
+                        "path": rel_path,
+                        "size": stat.st_size,
+                        "mime_type": mime_type or "application/octet-stream",
+                        "modified_time": datetime.fromtimestamp(stat.st_mtime).isoformat(),
+                        "type": "file"
+                    })
+                except Exception as e:
+                    logger.warning(f"Could not get stats for file {file_path}: {e}")
+        
+        return {
+            "session_id": session_id,
+            "files": files,
+            "directories": directories if query.include_directories else [],
+            "total_files": len(files),
+            "total_directories": len(directories) if query.include_directories else 0
+        }
+        
+    except Exception as e:
+        logger.error(f"Failed to list session files for {session_id}: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to list session files: {str(e)}")

vibe_surf/backend/api/models.py

@@ -0,0 +1,257 @@
+"""
+API Request/Response Models for VibeSurf Backend
+
+Pydantic models for API serialization and validation.
+With LLM Profile management support.
+"""
+
+from pydantic import BaseModel, Field, validator
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+from enum import Enum
+
+# LLM Profile Models
+class LLMProfileCreateRequest(BaseModel):
+    """Request model for creating a new LLM profile"""
+    profile_name: str = Field(description="Unique profile name", min_length=1, max_length=100)
+    provider: str = Field(description="LLM provider (openai, anthropic, google, azure_openai)")
+    model: str = Field(description="Model name")
+    api_key: Optional[str] = Field(default=None, description="API key (will be encrypted)")
+    base_url: Optional[str] = Field(default=None, description="Custom base URL")
+    temperature: Optional[float] = Field(default=None, ge=0.0, le=2.0)
+    max_tokens: Optional[int] = Field(default=None, gt=0)
+    top_p: Optional[float] = Field(default=None, ge=0.0, le=1.0)
+    frequency_penalty: Optional[float] = Field(default=None, ge=-2.0, le=2.0)
+    seed: Optional[int] = Field(default=None)
+    provider_config: Optional[Dict[str, Any]] = Field(default=None, description="Provider-specific config")
+    description: Optional[str] = Field(default=None, description="Profile description")
+    is_default: bool = Field(default=False, description="Set as default profile")
+
+class LLMProfileUpdateRequest(BaseModel):
+    """Request model for updating an LLM profile"""
+    provider: Optional[str] = None
+    model: Optional[str] = None
+    api_key: Optional[str] = None
+    base_url: Optional[str] = None
+    temperature: Optional[float] = Field(default=None, ge=0.0, le=2.0)
+    max_tokens: Optional[int] = Field(default=None, gt=0)
+    top_p: Optional[float] = Field(default=None, ge=0.0, le=1.0)
+    frequency_penalty: Optional[float] = Field(default=None, ge=-2.0, le=2.0)
+    seed: Optional[int] = None
+    provider_config: Optional[Dict[str, Any]] = None
+    description: Optional[str] = None
+    is_active: Optional[bool] = None
+    is_default: Optional[bool] = None
+
+class LLMProfileResponse(BaseModel):
+    """Response model for LLM profile data (without API key)"""
+    profile_id: str
+    profile_name: str
+    provider: str
+    model: str
+    base_url: Optional[str] = None
+    # Note: API key is intentionally excluded from response
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+    top_p: Optional[float] = None
+    frequency_penalty: Optional[float] = None
+    seed: Optional[int] = None
+    provider_config: Optional[Dict[str, Any]] = None
+    description: Optional[str] = None
+    is_active: bool
+    is_default: bool
+    created_at: datetime
+    updated_at: datetime
+    last_used_at: Optional[datetime] = None
+    
+    class Config:
+        from_attributes = True
+
+# MCP Profile Models
+class McpProfileCreateRequest(BaseModel):
+    """Request model for creating a new MCP profile"""
+    display_name: str = Field(description="Display name for MCP profile", min_length=1, max_length=100)
+    mcp_server_name: str = Field(description="MCP server name/identifier", min_length=1, max_length=100)
+    mcp_server_params: Dict[str, Any] = Field(description="MCP server parameters (command, args, etc.)")
+    description: Optional[str] = Field(default=None, description="Profile description")
+
+class McpProfileUpdateRequest(BaseModel):
+    """Request model for updating an MCP profile"""
+    display_name: Optional[str] = Field(default=None, min_length=1, max_length=100)
+    mcp_server_name: Optional[str] = Field(default=None, min_length=1, max_length=100)
+    mcp_server_params: Optional[Dict[str, Any]] = None
+    description: Optional[str] = None
+    is_active: Optional[bool] = None
+
+class McpProfileResponse(BaseModel):
+    """Response model for MCP profile data"""
+    mcp_id: str
+    display_name: str
+    mcp_server_name: str
+    mcp_server_params: Dict[str, Any]
+    description: Optional[str] = None
+    is_active: bool
+    created_at: datetime
+    updated_at: datetime
+    last_used_at: Optional[datetime] = None
+    
+    class Config:
+        from_attributes = True
+
+# Task Models
+class TaskCreateRequest(BaseModel):
+    """Request model for creating a new task"""
+    session_id: str = Field(description="Session identifier")
+    task_description: str = Field(description="The task description")
+    llm_profile_name: str = Field(description="LLM profile name to use")
+    upload_files_path: Optional[str] = Field(default=None, description="Path to uploaded files")
+    mcp_server_config: Optional[Dict[str, Any]] = Field(default=None, description="MCP server configuration")
+
+class TaskControlRequest(BaseModel):
+    """Request model for task control operations (pause/resume/stop)"""
+    reason: Optional[str] = Field(default=None, description="Reason for the operation")
+
+class TaskResponse(BaseModel):
+    """Response model for task data"""
+    task_id: str
+    session_id: str
+    task_description: str
+    status: str
+    llm_profile_name: str
+    upload_files_path: Optional[str] = None
+    workspace_dir: Optional[str] = None
+    mcp_server_config: Optional[Dict[str, Any]] = None
+    task_result: Optional[str] = None
+    error_message: Optional[str] = None
+    report_path: Optional[str] = None
+    created_at: datetime
+    updated_at: datetime
+    started_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+    task_metadata: Optional[Dict[str, Any]] = None
+    
+    class Config:
+        from_attributes = True
+    
+    @classmethod
+    def from_orm(cls, task):
+        """Create response from SQLAlchemy Task model"""
+        return cls(
+            task_id=task.task_id,
+            session_id=task.session_id,
+            task_description=task.task_description,
+            status=task.status.value,
+            llm_profile_name=task.llm_profile_name,
+            upload_files_path=task.upload_files_path,
+            workspace_dir=task.workspace_dir,
+            mcp_server_config=task.mcp_server_config,
+            task_result=task.task_result,
+            error_message=task.error_message,
+            report_path=task.report_path,
+            created_at=task.created_at,
+            updated_at=task.updated_at,
+            started_at=task.started_at,
+            completed_at=task.completed_at,
+            task_metadata=task.task_metadata
+        )
+
+class TaskStatusResponse(BaseModel):
+    """Response model for task status information"""
+    task_id: Optional[str] = None
+    session_id: Optional[str] = None
+    status: Optional[str] = None
+    task_description: Optional[str] = None
+    created_at: Optional[datetime] = None
+    started_at: Optional[datetime] = None
+    error_message: Optional[str] = None
+    is_running: bool = False
+
+class TaskListResponse(BaseModel):
+    """Response model for task list"""
+    tasks: List[TaskResponse]
+    total_count: int
+    session_id: Optional[str] = None
+
+class ErrorResponse(BaseModel):
+    """Standard error response model"""
+    error: str
+    detail: Optional[str] = None
+    timestamp: datetime = Field(default_factory=datetime.now)
+
+class ControlOperationResponse(BaseModel):
+    """Response model for control operations"""
+    success: bool
+    message: str
+    operation: str
+    timestamp: datetime
+    details: Optional[Dict[str, Any]] = None
+
+# Activity Log Models (for VibeSurf agent activity)
+class ActivityLogEntry(BaseModel):
+    """Model for VibeSurf agent activity log entry"""
+    timestamp: datetime
+    level: str
+    message: str
+    metadata: Optional[Dict[str, Any]] = None
+
+class ActivityLogResponse(BaseModel):
+    """Response model for activity logs"""
+    logs: List[ActivityLogEntry]
+    total_count: int
+    session_id: Optional[str] = None
+    task_id: Optional[str] = None
+
+# Activity API Request Models
+class ActivityQueryRequest(BaseModel):
+    """Request model for getting recent tasks"""
+    limit: int = Field(default=-1, ge=-1, le=1000, description="Number of recent tasks to retrieve (-1 for all)")
+
+class SessionActivityQueryRequest(BaseModel):
+    """Request model for getting session activity logs"""
+    limit: int = Field(default=-1, ge=-1, le=1000, description="Number of activity logs to retrieve (-1 for all)")
+    message_index: Optional[int] = Field(default=None, ge=0, description="Specific message index to retrieve")
+
+# File API Request Models
+class FileUploadRequest(BaseModel):
+    """Request model for file upload (for form validation)"""
+    session_id: Optional[str] = Field(default=None, description="Session ID for file association")
+
+class FileListQueryRequest(BaseModel):
+    """Request model for listing uploaded files"""
+    session_id: Optional[str] = Field(default=None, description="Filter by session ID")
+    limit: int = Field(default=-1, ge=-1, le=1000, description="Number of files to retrieve (-1 for all)")
+    offset: int = Field(default=0, ge=0, description="Number of files to skip")
+
+class SessionFilesQueryRequest(BaseModel):
+    """Request model for listing session files"""
+    include_directories: bool = Field(default=False, description="Whether to include directories in the response")
+
+# File Upload Models
+class UploadedFileResponse(BaseModel):
+    """Response model for uploaded file information"""
+    filename: str
+    file_path: str
+    file_size: Optional[int] = None
+    mime_type: Optional[str] = None
+    uploaded_at: datetime
+
+# Configuration Models (for config endpoints)
+class LLMConfigResponse(BaseModel):
+    """Response model for LLM configuration"""
+    provider: str
+    model: str
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+    available_providers: List[str] = []
+
+class ControllerConfigRequest(BaseModel):
+    """Request model for updating controller configuration"""
+    exclude_actions: Optional[List[str]] = Field(default=None, description="Actions to exclude from execution")
+    max_actions_per_task: Optional[int] = Field(default=None, gt=0, description="Maximum actions per task")
+    display_files_in_done_text: Optional[bool] = Field(default=None, description="Whether to display files in done text")
+
+class ControllerConfigResponse(BaseModel):
+    """Response model for controller configuration"""
+    exclude_actions: List[str] = []
+    max_actions_per_task: int = 100
+    display_files_in_done_text: bool = True