vibesurf 0.1.0__py3-none-any.whl

vibe_surf/backend/database/schemas.py

@@ -0,0 +1,100 @@
+"""
+JSON Schema Definitions for VibeSurf Database - Simplified Single Task Model
+
+Pydantic models for validating JSON fields in the simplified Task table.
+"""
+
+from typing import Dict, Any, List, Optional
+from pydantic import BaseModel, Field
+from datetime import datetime
+
+class TaskMetadata(BaseModel):
+    """Schema for Task.task_metadata JSON field"""
+    
+    # Execution summary
+    execution_duration_seconds: Optional[float] = None
+    total_actions: Optional[int] = None
+    
+    # Results summary
+    generated_report_path: Optional[str] = None
+    final_summary: Optional[str] = None
+    
+    # Control state history
+    control_history: List[Dict[str, Any]] = Field(default_factory=list)
+    
+    # Error context
+    last_error: Optional[str] = None
+    error_recovery_attempts: int = 0
+    
+    # User context
+    created_via: str = "api"
+
+class LLMConfiguration(BaseModel):
+    """Schema for Task.llm_config JSON field"""
+    
+    model: str
+    base_url: Optional[str] = None
+    # Note: API key is intentionally excluded from stored config
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+    top_p: Optional[float] = None
+    frequency_penalty: Optional[float] = None
+    seed: Optional[int] = None
+    
+    # Provider-specific settings
+    provider: str = "openai"  # 'openai', 'azure', 'anthropic', etc.
+    provider_config: Dict[str, Any] = Field(default_factory=dict)
+
+class McpServerParams(BaseModel):
+    """Schema for MCP server parameters configuration"""
+    command: str  # e.g., "npx", "docker"
+    args: List[str]  # command arguments
+    env: Optional[Dict[str, str]] = None  # environment variables
+    cwd: Optional[str] = None  # working directory
+    timeout: Optional[int] = None  # timeout in seconds
+
+class McpServerConfig(BaseModel):
+    """Schema for MCP server configuration in Task.mcp_server_config"""
+    mcpServers: Dict[str, McpServerParams] = Field(default_factory=dict)
+
+class ControllerConfiguration(BaseModel):
+    """Schema for Task.mcp_server_config JSON field (legacy controller config)"""
+    
+    # Action control
+    exclude_actions: List[str] = Field(default_factory=list)
+    max_actions_per_task: Optional[int] = 100
+    
+    # Output configuration
+    display_files_in_done_text: bool = True
+    save_screenshots: bool = True
+    
+    # Error handling
+    continue_on_action_error: bool = False
+    max_retries_per_action: int = 3
+
+# Schema validation utilities
+JSON_SCHEMAS = {
+    'task_metadata': TaskMetadata,
+    'llm_configuration': LLMConfiguration,
+    'controller_configuration': ControllerConfiguration,
+    'mcp_server_config': McpServerConfig,
+    'mcp_server_params': McpServerParams,
+}
+
+def validate_json_field(schema_name: str, data: Dict[str, Any]) -> Dict[str, Any]:
+    """Validate and normalize JSON field data using appropriate schema"""
+    if schema_name not in JSON_SCHEMAS:
+        return data
+    
+    schema_class = JSON_SCHEMAS[schema_name]
+    validated = schema_class(**data)
+    return validated.model_dump(exclude_none=True)
+
+def get_schema_for_config_type(config_type: str) -> Optional[BaseModel]:
+    """Get appropriate schema based on configuration type"""
+    schema_mapping = {
+        'llm_config': LLMConfiguration,
+        'controller_config': ControllerConfiguration,  # Legacy support
+        'mcp_server_config': McpServerConfig,
+    }
+    return schema_mapping.get(config_type)

vibe_surf/backend/llm_config.py

@@ -0,0 +1,182 @@
+"""
+LLM Provider Configuration
+
+Centralized configuration for all supported LLM providers and their models.
+"""
+
+# LLM Providers and their supported models
+LLM_PROVIDERS = {
+    "openai": [
+        "gpt-4o",
+        "gpt-4o-mini",
+        "gpt-4.1"
+        "gpt-4.1-mini",
+        "gpt-5",
+        "gpt-5-mini",
+    ],
+    "anthropic": [
+        "claude-opus-4-1-20250805",
+        "claude-sonnet-4-20250514",
+        "claude-3-7-sonnet-20250219",
+        "claude-3-5-haiku-20241022"
+    ],
+    "google": [
+        "gemini-2.5-pro",
+        "gemini-2.5-flash",
+    ],
+    "azure_openai": [
+        "gpt-4o",
+        "gpt-4o-mini",
+    ],
+    "groq": [
+        "moonshotai/kimi-k2-instruct",
+        "deepseek-r1-distill-llama-70b",
+        "qwen/qwen3-32b",
+    ],
+    "ollama": [
+        "deepseek-r1:14b",
+        "gpt-oss:20b",
+        "qwen3:latest",
+    ],
+    "openrouter": [
+        "deepseek/deepseek-chat-v3.1",
+        "qwen/qwen3-235b-a22b-thinking-2507",
+        "moonshotai/kimi-k2",
+        "z-ai/glm-4.5"
+    ],
+    "deepseek": [
+        "deepseek-chat",
+        "deepseek-reasoner"
+    ],
+    "aws_bedrock": [
+        "anthropic.claude-opus-4-1-20250805-v1:0",
+        "anthropic.claude-opus-4-20250514-v1:0",
+        "anthropic.claude-sonnet-4-20250514-v1:0",
+        "anthropic.claude-3-7-sonnet-20250219-v1:0",
+        "anthropic.claude-3-5-haiku-20241022-v1:0",
+    ],
+    "anthropic_bedrock": [
+    ],
+    "openai_compatible": [
+    ]
+}
+
+# Provider metadata
+PROVIDER_METADATA = {
+    "openai": {
+        "display_name": "OpenAI",
+        "requires_api_key": True,
+        "supports_base_url": False,
+        "supports_tools": True,
+        "supports_vision": True,
+        "default_model": "gpt-4.1-mini"
+    },
+    "anthropic": {
+        "display_name": "Anthropic",
+        "requires_api_key": True,
+        "supports_base_url": False,
+        "supports_tools": True,
+        "supports_vision": True,
+        "default_model": "claude-3-7-sonnet-20250219"
+    },
+    "google": {
+        "display_name": "Google Gemini",
+        "requires_api_key": True,
+        "supports_base_url": False,
+        "supports_tools": True,
+        "supports_vision": True,
+        "default_model": "gemini-2.5-flash"
+    },
+    "azure_openai": {
+        "display_name": "Azure OpenAI",
+        "requires_api_key": True,
+        "requires_base_url": True,
+        "supports_tools": True,
+        "supports_vision": True,
+        "default_model": "gpt-4o-mini"
+    },
+    "groq": {
+        "display_name": "Groq",
+        "requires_api_key": True,
+        "supports_base_url": False,
+        "supports_tools": True,
+        "supports_vision": True,
+        "default_model": "moonshotai/kimi-k2-instruct"
+    },
+    "ollama": {
+        "display_name": "Ollama",
+        "requires_api_key": False,
+        "requires_base_url": True,
+        "supports_tools": True,
+        "supports_vision": True,
+        "default_model": "qwen/qwen3-32b",
+        "default_base_url": "http://localhost:11434"
+    },
+    "openrouter": {
+        "display_name": "OpenRouter",
+        "requires_api_key": True,
+        "supports_base_url": False,
+        "supports_tools": True,
+        "supports_vision": True,
+        "default_model": "moonshotai/kimi-k2",
+        "base_url": "https://openrouter.ai/api/v1"
+    },
+    "deepseek": {
+        "display_name": "DeepSeek",
+        "requires_api_key": True,
+        "supports_base_url": False,
+        "supports_tools": True,
+        "supports_vision": True,
+        "default_model": "deepseek-chat"
+    },
+    "aws_bedrock": {
+        "display_name": "AWS Bedrock",
+        "requires_api_key": True,
+        "supports_base_url": False,
+        "supports_tools": True,
+        "supports_vision": True,
+        "default_model": "anthropic.claude-3-7-sonnet-20250219-v1:0"
+    },
+    "anthropic_bedrock": {
+        "display_name": "Anthropic via AWS Bedrock",
+        "requires_api_key": True,
+        "supports_base_url": False,
+        "supports_tools": True,
+        "supports_vision": True,
+        "default_model": ""
+    },
+    "openai_compatible": {
+        "display_name": "OpenAI Compatible",
+        "requires_api_key": True,
+        "requires_base_url": True,
+        "supports_tools": True,
+        "supports_vision": True,
+        "default_model": ""
+    }
+}
+
+
+def get_supported_providers():
+    """Get list of all supported provider names"""
+    return list(LLM_PROVIDERS.keys())
+
+
+def get_provider_models(provider_name: str):
+    """Get list of models for a specific provider"""
+    return LLM_PROVIDERS.get(provider_name, [])
+
+
+def get_provider_metadata(provider_name: str):
+    """Get metadata for a specific provider"""
+    return PROVIDER_METADATA.get(provider_name, {})
+
+
+def is_provider_supported(provider_name: str):
+    """Check if a provider is supported"""
+    return provider_name in LLM_PROVIDERS
+
+
+def get_default_model(provider_name: str):
+    """Get default model for a provider"""
+    metadata = get_provider_metadata(provider_name)
+    return metadata.get("default_model", "")

vibe_surf/backend/main.py

@@ -0,0 +1,137 @@
+"""
+VibeSurf Backend API
+
+uvicorn backend.main:app --host 127.0.0.1 --port 9335
+
+FastAPI application for simplified single-task execution model.
+"""
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+import logging
+import argparse
+import os
+from datetime import datetime
+
+# Import routers
+from .api.task import router as agents_router
+from .api.files import router as files_router
+from .api.activity import router as activity_router
+from .api.config import router as config_router
+
+# Import shared state
+from . import shared_state
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(
+    title="VibeSurf Backend API",
+    description="Simplified single-task execution model for VibeSurf",
+    version="2.0.0"
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(agents_router, prefix="/api", tags=["tasks"])
+app.include_router(files_router, prefix="/api", tags=["files"])
+app.include_router(activity_router, prefix="/api", tags=["activity"])
+app.include_router(config_router, prefix="/api", tags=["config"])
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize database and VibeSurf components on startup"""
+    # Initialize VibeSurf components and update shared state
+    await shared_state.initialize_vibesurf_components()
+
+    logger.info("🚀 VibeSurf Backend API started with single-task execution model")
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup on shutdown"""
+    
+    # Cleanup VibeSurf components
+    if shared_state.browser_manager:
+        try:
+            await shared_state.browser_manager.close()
+            await shared_state.browser_manager.main_browser_session.kill()
+            logger.info("✅ Browser manager closed")
+        except Exception as e:
+            logger.error(f"❌ Error closing browser manager: {e}")
+    
+    # Close database
+    if shared_state.db_manager:
+        await shared_state.db_manager.close()
+    logger.info("🛑 VibeSurf Backend API stopped")
+
+# Health check endpoint
+@app.get("/health")
+async def health_check():
+    """API health check"""
+    return {
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "service": "VibeSurf Backend API",
+        "model": "single-task-execution",
+        "version": "2.0.0"
+    }
+
+# Session ID generation endpoint
+@app.get("/generate-session-id")
+async def generate_session_id(prefix: str = ""):
+    """Generate a new session ID using uuid7str"""
+    from uuid_extensions import uuid7str
+    session_id = f"{uuid7str()}"
+    return {
+        "session_id": session_id,
+        "timestamp": datetime.now().isoformat()
+    }
+
+# Simple status endpoint for the active task
+@app.get("/api/status")
+async def get_system_status():
+    """Get current system status"""
+    task_info = shared_state.get_active_task_info()
+    
+    return {
+        "system_status": "operational",
+        "active_task": task_info,
+        "timestamp": datetime.now().isoformat()
+    }
+
+def parse_args():
+    """Parse command line arguments"""
+    parser = argparse.ArgumentParser(description="VibeSurf Backend API")
+    parser.add_argument(
+        "--vibesurf_port",
+        type=int,
+        default=9335,
+        help="Port for VibeSurf backend (default: 9335)"
+    )
+    parser.add_argument(
+        "--vibesurf_extension",
+        type=str,
+        help="VibeSurf chrome extension path (optional)"
+    )
+    return parser.parse_args()
+
+if __name__ == "__main__":
+    # Parse command line arguments
+    args = parse_args()
+    
+    # Set environment variables based on arguments
+    os.environ["VIBESURF_BACKEND_PORT"] = str(args.vibesurf_port)
+    if args.vibesurf_extension:
+        os.environ["VIBESURF_EXTENSION"] = args.vibesurf_extension
+    
+    import uvicorn
+    uvicorn.run(app, host="127.0.0.1", port=args.vibesurf_port)

vibe_surf/backend/migrations/__init__.py

@@ -0,0 +1,16 @@
+"""
+Database Migration Scripts for VibeSurf Backend
+
+Contains migration scripts for database schema initialization and updates.
+"""
+
+from .init_db import init_database, create_tables, drop_tables
+from .seed_data import seed_initial_data, create_sample_data
+
+__all__ = [
+    "init_database",
+    "create_tables", 
+    "drop_tables",
+    "seed_initial_data",
+    "create_sample_data"
+]