vibesurf 0.1.0__py3-none-any.whl

vibe_surf/backend/api/task.py

@@ -0,0 +1,300 @@
+"""
+VibeSurf Agent Execution Router
+
+Handles task submission, execution control (pause/resume/stop), and status monitoring
+for VibeSurf agents.
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks
+from sqlalchemy.ext.asyncio import AsyncSession
+from typing import List, Optional, Dict, Any
+import logging
+import os
+from datetime import datetime
+from uuid_extensions import uuid7str
+
+from ..database import get_db_session
+from .models import TaskCreateRequest, TaskControlRequest
+
+# Import global variables and functions from shared_state
+from ..shared_state import (
+    execute_task_background,
+    is_task_running,
+    get_active_task_info,
+    clear_active_task
+)
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/tasks", tags=["tasks"])
+
+
+@router.get("/status")
+async def check_task_status():
+    """Quick check if a task is currently running"""
+    return {
+        "has_active_task": is_task_running(),
+        "active_task": get_active_task_info()
+    }
+
+
+@router.post("/submit")
+async def submit_task(
+        task_request: "TaskCreateRequest",
+        background_tasks: BackgroundTasks,
+        db: AsyncSession = Depends(get_db_session)
+):
+    """Submit new task for execution (single task mode)"""
+    from ..database.queries import LLMProfileQueries
+    from ..shared_state import workspace_dir, active_task
+
+    # Check if task is already running
+    if is_task_running():
+        current_task = get_active_task_info()
+        return {
+            "success": False,
+            "message": "Cannot submit task: another task is currently running",
+            "active_task": {
+                "task_id": current_task.get("task_id"),
+                "status": current_task.get("status"),
+                "session_id": current_task.get("session_id"),
+                "start_time": current_task.get("start_time").isoformat() if current_task.get("start_time") else None
+            }
+        }
+
+    try:
+        # Get LLM profile from database
+        llm_profile = await LLMProfileQueries.get_profile_with_decrypted_key(db, task_request.llm_profile_name)
+        if not llm_profile:
+            raise HTTPException(
+                status_code=404,
+                detail=f"LLM profile '{task_request.llm_profile_name}' not found"
+            )
+
+        # Generate task ID
+        task_id = uuid7str()
+
+        # Get MCP server config for saving
+        from ..shared_state import controller, active_mcp_server
+        mcp_server_config = task_request.mcp_server_config
+        if not mcp_server_config and controller and hasattr(controller, 'mcp_server_config'):
+            mcp_server_config = controller.mcp_server_config
+        
+        # DEBUG: Log the type and content of mcp_server_config
+        logger.info(f"mcp_server_config type: {type(mcp_server_config)}, value: {mcp_server_config}")
+
+        # Create initial task record in database
+        from ..database.queries import TaskQueries
+        await TaskQueries.save_task(
+            db,
+            task_id=task_id,
+            session_id=task_request.session_id,
+            task_description=task_request.task_description,
+            upload_files_path=task_request.upload_files_path,
+            mcp_server_config=mcp_server_config,
+            llm_profile_name=task_request.llm_profile_name,
+            workspace_dir=workspace_dir,
+            task_status="pending"
+        )
+        await db.commit()
+
+        # Initialize LLM for this task if needed
+        if not active_task or active_task["llm_profile_name"] != task_request.llm_profile_name:
+            await _ensure_llm_initialized(llm_profile)
+
+        # Add background task
+        background_tasks.add_task(
+            execute_task_background,
+            task_id=task_id,
+            session_id=task_request.session_id,
+            task=task_request.task_description,
+            llm_profile_name=task_request.llm_profile_name,
+            upload_files=task_request.upload_files_path,
+            db_session=db
+        )
+
+        return {
+            "success": True,
+            "task_id": task_id,
+            "session_id": task_request.session_id,
+            "status": "submitted",
+            "message": "Task submitted for execution",
+            "llm_profile": task_request.llm_profile_name,
+            "workspace_dir": workspace_dir
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to submit task: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to submit task: {str(e)}")
+
+
+async def _ensure_llm_initialized(llm_profile):
+    """Ensure LLM is initialized with the specified profile"""
+    from ..utils.llm_factory import create_llm_from_profile
+    from ..shared_state import vibesurf_agent
+    
+    if not vibesurf_agent:
+        raise HTTPException(status_code=503, detail="VibeSurf agent not initialized")
+    
+    # Always create new LLM instance to ensure we're using the right profile
+    new_llm = create_llm_from_profile(llm_profile)
+    
+    # Update vibesurf agent's LLM
+    vibesurf_agent.llm = new_llm
+    logger.info(f"LLM updated for profile: {llm_profile['profile_name']}")
+
+
+@router.post("/pause")
+async def pause_task(control_request: TaskControlRequest):
+    """Pause current task execution"""
+    from ..shared_state import vibesurf_agent
+
+    if not vibesurf_agent:
+        raise HTTPException(status_code=503, detail="VibeSurf agent not initialized")
+
+    if not is_task_running():
+        raise HTTPException(status_code=400, detail="No active task to pause")
+
+    try:
+        result = await vibesurf_agent.pause(control_request.reason)
+
+        if result.success:
+            # Update active task status
+            current_task = get_active_task_info()
+            if current_task:
+                from ..shared_state import active_task
+                active_task["status"] = "paused"
+                active_task["pause_reason"] = control_request.reason
+
+            return {
+                "success": True,
+                "message": result.message,
+                "operation": "pause"
+            }
+        else:
+            raise HTTPException(status_code=500, detail=result.message)
+
+    except Exception as e:
+        logger.error(f"Failed to pause task: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to pause task: {str(e)}")
+
+
+@router.post("/resume")
+async def resume_task(control_request: TaskControlRequest):
+    """Resume current task execution"""
+    from ..shared_state import vibesurf_agent
+
+    if not vibesurf_agent:
+        raise HTTPException(status_code=503, detail="VibeSurf agent not initialized")
+
+    current_task = get_active_task_info()
+    if not current_task or current_task.get("status") != "paused":
+        raise HTTPException(status_code=400, detail="No paused task to resume")
+
+    try:
+        result = await vibesurf_agent.resume(control_request.reason)
+
+        if result.success:
+            # Update active task status
+            from ..shared_state import active_task
+            active_task["status"] = "running"
+            active_task["resume_reason"] = control_request.reason
+
+            return {
+                "success": True,
+                "message": result.message,
+                "operation": "resume"
+            }
+        else:
+            raise HTTPException(status_code=500, detail=result.message)
+
+    except Exception as e:
+        logger.error(f"Failed to resume task: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to resume task: {str(e)}")
+
+
+@router.post("/stop")
+async def stop_task(control_request: TaskControlRequest):
+    """Stop current task execution"""
+    from ..shared_state import vibesurf_agent
+
+    if not vibesurf_agent:
+        raise HTTPException(status_code=503, detail="VibeSurf agent not initialized")
+
+    if not is_task_running():
+        raise HTTPException(status_code=400, detail="No active task to stop")
+
+    try:
+        result = await vibesurf_agent.stop(control_request.reason)
+
+        if result.success:
+            # Update active task status and clear it
+            current_task = get_active_task_info()
+            if current_task:
+                from ..shared_state import active_task
+                active_task["status"] = "stopped"
+                active_task["stop_reason"] = control_request.reason
+                active_task["end_time"] = datetime.now()
+
+            # Clear active task
+            # clear_active_task()
+
+            return {
+                "success": True,
+                "message": result.message,
+                "operation": "stop"
+            }
+        else:
+            raise HTTPException(status_code=500, detail=result.message)
+
+    except Exception as e:
+        logger.error(f"Failed to stop task: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to stop task: {str(e)}")
+
+
+@router.get("/detailed-status")
+async def get_detailed_task_status():
+    """Get detailed task execution status with vibesurf information"""
+    from ..shared_state import vibesurf_agent
+
+    if not vibesurf_agent:
+        raise HTTPException(status_code=503, detail="VibeSurf agent not initialized")
+
+    try:
+        current_task = get_active_task_info()
+
+        if current_task:
+            # Get detailed vibesurf status
+            vibesurf_status = vibesurf_agent.get_status()
+
+            return {
+                "has_active_task": True,
+                "task_id": current_task["task_id"],
+                "status": current_task["status"],
+                "session_id": current_task["session_id"],
+                "task": current_task["task"],
+                "start_time": current_task["start_time"].isoformat() if current_task.get("start_time") else None,
+                "end_time": current_task.get("end_time").isoformat() if current_task.get("end_time") else None,
+                "result": current_task.get("result"),
+                "error": current_task.get("error"),
+                "pause_reason": current_task.get("pause_reason"),
+                "stop_reason": current_task.get("stop_reason"),
+                "vibesurf_status": {
+                    "overall_status": vibesurf_status.overall_status,
+                    "active_step": vibesurf_status.active_step,
+                    "agent_statuses": {k: v.dict() for k, v in vibesurf_status.agent_statuses.items()},
+                    "progress": vibesurf_status.progress,
+                    "last_update": vibesurf_status.last_update.isoformat()
+                }
+            }
+        else:
+            return {
+                "has_active_task": False,
+                "message": "No active task"
+            }
+
+    except Exception as e:
+        logger.error(f"Failed to get task status: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to get task status: {str(e)}")

vibe_surf/backend/database/__init__.py

@@ -0,0 +1,13 @@
+"""
+VibeSurf Backend Database Package - Simplified
+
+Single table design for task tracking and execution.
+"""
+
+from .manager import get_db_session
+from .models import (
+    Base,
+    Task,
+    TaskStatus,
+)
+from .queries import TaskQueries

vibe_surf/backend/database/manager.py

@@ -0,0 +1,129 @@
+"""
+Database Manager for VibeSurf Session Management
+
+Handles database connections, session management, and initialization
+with optimized configuration for real-time operations.
+"""
+
+import asyncio
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.pool import StaticPool
+from .models import Base
+from typing import AsyncGenerator
+import logging
+
+logger = logging.getLogger(__name__)
+
+class DatabaseManager:
+    """Database connection and session management"""
+    
+    def __init__(self, database_url: str = None):
+        """Initialize database manager
+        
+        Args:
+            database_url: Database connection URL. Defaults to SQLite if not provided.
+        """
+        from .. import shared_state
+        self.database_url = database_url or os.getenv(
+            'VIBESURF_DATABASE_URL',
+            f'sqlite+aiosqlite:///{os.path.join(shared_state.workspace_dir, "vibe_surf.db")}'
+        )
+        
+        # Configure engine based on database type
+        if self.database_url.startswith('sqlite'):
+            # SQLite configuration for development
+            self.engine = create_async_engine(
+                self.database_url,
+                poolclass=StaticPool,
+                connect_args={
+                    "check_same_thread": False,
+                    "timeout": 30
+                },
+                echo=False  # Set to True for SQL debugging
+            )
+        else:
+            # PostgreSQL/MySQL configuration for production
+            self.engine = create_async_engine(
+                self.database_url,
+                pool_size=20,
+                max_overflow=30,
+                pool_pre_ping=True,
+                pool_recycle=3600,
+                echo=False
+            )
+        
+        self.async_session_factory = sessionmaker(
+            self.engine, 
+            class_=AsyncSession, 
+            expire_on_commit=False
+        )
+    
+    async def create_tables(self):
+        """Create all database tables"""
+        async with self.engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+    
+    async def drop_tables(self):
+        """Drop all database tables"""
+        async with self.engine.begin() as conn:
+            await conn.run_sync(Base.metadata.drop_all)
+    
+    async def get_session(self) -> AsyncGenerator[AsyncSession, None]:
+        """Get async database session"""
+        async with self.async_session_factory() as session:
+            try:
+                yield session
+                await session.commit()
+            except Exception:
+                await session.rollback()
+                raise
+            finally:
+                await session.close()
+    
+    async def close(self):
+        """Close database connections"""
+        await self.engine.dispose()
+
+# Dependency for FastAPI
+async def get_db_session() -> AsyncGenerator[AsyncSession, None]:
+    """FastAPI dependency for database sessions"""
+    from .. import shared_state
+    
+    if not shared_state.db_manager:
+        raise RuntimeError("Database manager not initialized. Call initialize_vibesurf_components() first.")
+    
+    async for session in shared_state.db_manager.get_session():
+        yield session
+
+# Database initialization script
+async def init_database():
+    """Initialize database with tables"""
+    from .. import shared_state
+    
+    logger.info("🗄️ Initializing VibeSurf database...")
+    
+    try:
+        if not shared_state.db_manager:
+            raise RuntimeError("Database manager not initialized. Call initialize_vibesurf_components() first.")
+            
+        await shared_state.db_manager.create_tables()
+        logger.info("✅ Database tables created successfully")
+        logger.info("✅ VibeSurf database ready for single-task execution")
+        
+    except Exception as e:
+        logger.error(f"❌ Database initialization failed: {e}")
+        raise
+
+if __name__ == "__main__":
+    # For standalone execution, initialize a temporary db_manager
+    import os
+    from .. import shared_state
+    
+    workspace_dir = os.getenv("VIBESURF_WORKSPACE", os.path.join(os.path.dirname(__file__), "../vibesurf_workspace"))
+    database_url = os.getenv(
+        'VIBESURF_DATABASE_URL',
+        f'sqlite+aiosqlite:///{os.path.join(workspace_dir, "vibe_surf.db")}'
+    )
+    shared_state.db_manager = DatabaseManager(database_url)
+    asyncio.run(init_database())

vibe_surf/backend/database/models.py

@@ -0,0 +1,164 @@
+"""
+Database Models for VibeSurf Backend - With LLM Profile Management
+
+SQLAlchemy models for task execution system with LLM profile management.
+"""
+
+from sqlalchemy import Column, String, Text, DateTime, Enum, JSON, Boolean, Index, BigInteger
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.sql import func
+from datetime import datetime
+import enum
+from uuid import uuid4
+
+Base = declarative_base()
+
+# Enums for type safety
+class TaskStatus(enum.Enum):
+    PENDING = "pending"
+    RUNNING = "running"
+    PAUSED = "paused"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    STOPPED = "stopped"
+
+class LLMProfile(Base):
+    """LLM Profile model for managing LLM configurations with encrypted API keys"""
+    __tablename__ = 'llm_profiles'
+    
+    # Primary identifier
+    profile_id = Column(String(36), primary_key=True, default=lambda: str(uuid4()))
+    profile_name = Column(String(100), nullable=False, unique=True)  # User-defined unique name
+    
+    # LLM Configuration
+    provider = Column(String(50), nullable=False)  # openai, anthropic, google, azure_openai, etc.
+    model = Column(String(100), nullable=False)
+    base_url = Column(String(500), nullable=True)
+    encrypted_api_key = Column(Text, nullable=True)  # Encrypted API key using MAC address
+    
+    # LLM Parameters (stored as JSON to allow null values)
+    temperature = Column(JSON, nullable=True)  # Allow float or null
+    max_tokens = Column(JSON, nullable=True)   # Allow int or null
+    top_p = Column(JSON, nullable=True)
+    frequency_penalty = Column(JSON, nullable=True)
+    seed = Column(JSON, nullable=True)
+    
+    # Provider-specific configuration
+    provider_config = Column(JSON, nullable=True)
+    
+    # Profile metadata
+    description = Column(Text, nullable=True)
+    is_active = Column(Boolean, default=True, nullable=False)
+    is_default = Column(Boolean, default=False, nullable=False)
+    
+    # Timestamps
+    created_at = Column(DateTime, nullable=False, default=func.now())
+    updated_at = Column(DateTime, nullable=False, default=func.now(), onupdate=func.now())
+    last_used_at = Column(DateTime, nullable=True)
+    
+    def __repr__(self):
+        return f"<LLMProfile(profile_name={self.profile_name}, provider={self.provider}, model={self.model})>"
+
+class Task(Base):
+    """Task model with LLM profile reference and workspace directory"""
+    __tablename__ = 'tasks'
+    
+    # Primary identifier
+    task_id = Column(String(36), primary_key=True, default=lambda: str(uuid4()))
+    
+    # Session tracking
+    session_id = Column(String(36), nullable=False)
+    
+    # Task definition
+    task_description = Column(Text, nullable=False)
+    status = Column(Enum(TaskStatus), nullable=False, default=TaskStatus.PENDING)
+    
+    # LLM Profile reference (instead of storing LLM config directly)
+    llm_profile_name = Column(String(100), nullable=False)  # Reference to LLMProfile.profile_name
+    
+    # File uploads and workspace
+    upload_files_path = Column(String(500), nullable=True)  # Path to uploaded files
+    workspace_dir = Column(String(500), nullable=True)     # Workspace directory for this task
+    
+    # Configuration (JSON strings without API keys)
+    mcp_server_config = Column(Text, nullable=True)  # MCP server config as JSON string
+    
+    # Results
+    task_result = Column(Text, nullable=True)  # Final markdown result
+    error_message = Column(Text, nullable=True)
+    report_path = Column(String(500), nullable=True)  # Generated report file path
+    
+    # Timestamps
+    created_at = Column(DateTime, nullable=False, default=func.now())
+    updated_at = Column(DateTime, nullable=False, default=func.now(), onupdate=func.now())
+    started_at = Column(DateTime, nullable=True)
+    completed_at = Column(DateTime, nullable=True)
+    
+    # Additional metadata
+    task_metadata = Column(JSON, nullable=True)  # Additional context
+    
+    def __repr__(self):
+        return f"<Task(task_id={self.task_id}, status={self.status.value}, llm_profile={self.llm_profile_name})>"
+
+class UploadedFile(Base):
+    """Model for tracking uploaded files"""
+    __tablename__ = "uploaded_files"
+    
+    file_id = Column(String(36), primary_key=True)  # UUID7 string
+    original_filename = Column(String(255), nullable=False, index=True)
+    stored_filename = Column(String(255), nullable=False)
+    file_path = Column(Text, nullable=False)
+    session_id = Column(String(255), nullable=True, index=True)
+    file_size = Column(BigInteger, nullable=False)
+    mime_type = Column(String(100), nullable=False)
+    upload_time = Column(DateTime, default=func.now(), nullable=False, index=True)
+    relative_path = Column(Text, nullable=False)  # Relative to workspace_dir
+    is_deleted = Column(Boolean, default=False, nullable=False, index=True)
+    deleted_at = Column(DateTime, nullable=True)
+    
+    def __repr__(self):
+        return f"<UploadedFile(file_id={self.file_id}, filename={self.original_filename}, session={self.session_id})>"
+
+# Create useful indexes for performance
+Index('idx_llm_profiles_name', LLMProfile.profile_name)
+Index('idx_llm_profiles_active', LLMProfile.is_active)
+Index('idx_llm_profiles_default', LLMProfile.is_default)
+Index('idx_llm_profiles_provider', LLMProfile.provider)
+
+Index('idx_tasks_status', Task.status)
+Index('idx_tasks_session', Task.session_id)
+Index('idx_tasks_llm_profile', Task.llm_profile_name)
+Index('idx_tasks_created', Task.created_at)
+
+class McpProfile(Base):
+    """MCP Profile model for managing MCP server configurations"""
+    __tablename__ = 'mcp_profiles'
+    
+    # Primary identifier
+    mcp_id = Column(String(36), primary_key=True, default=lambda: str(uuid4()))
+    display_name = Column(String(100), nullable=False, unique=True)  # User-friendly name
+    mcp_server_name = Column(String(100), nullable=False, unique=True)  # Server identifier (e.g., "filesystem", "markitdown")
+    
+    # MCP Server Configuration
+    mcp_server_params = Column(JSON, nullable=False)  # {"command": "npx", "args": [...]}
+    
+    # Profile metadata
+    description = Column(Text, nullable=True)
+    is_active = Column(Boolean, default=True, nullable=False)
+    
+    # Timestamps
+    created_at = Column(DateTime, nullable=False, default=func.now())
+    updated_at = Column(DateTime, nullable=False, default=func.now(), onupdate=func.now())
+    last_used_at = Column(DateTime, nullable=True)
+    
+    def __repr__(self):
+        return f"<McpProfile(display_name={self.display_name}, server_name={self.mcp_server_name}, active={self.is_active})>"
+
+Index('idx_uploaded_files_session_time', UploadedFile.session_id, UploadedFile.upload_time)
+Index('idx_uploaded_files_active', UploadedFile.is_deleted, UploadedFile.upload_time)
+Index('idx_uploaded_files_filename', UploadedFile.original_filename)
+
+# MCP Profile indexes
+Index('idx_mcp_profiles_display_name', McpProfile.display_name)
+Index('idx_mcp_profiles_server_name', McpProfile.mcp_server_name)
+Index('idx_mcp_profiles_active', McpProfile.is_active)