vibesurf 0.1.32__py3-none-any.whl → 0.1.34__py3-none-any.whl

vibe_surf/backend/database/migrations/v005_add_composio_integration.sql

@@ -0,0 +1,33 @@
+-- Migration: v005_add_composio_integration.sql
+-- Description: Add composio_toolkits table for Composio integration management
+-- Version: 0.0.5
+
+-- Enable foreign keys
+PRAGMA foreign_keys = ON;
+
+-- Create Composio Toolkits table
+CREATE TABLE IF NOT EXISTS composio_toolkits (
+    id VARCHAR(36) NOT NULL PRIMARY KEY,
+    name VARCHAR(100) NOT NULL,
+    slug VARCHAR(100) NOT NULL UNIQUE,
+    description TEXT,
+    logo TEXT,
+    app_url TEXT,
+    enabled BOOLEAN NOT NULL DEFAULT 0,
+    tools TEXT,
+    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Create indexes for composio_toolkits
+CREATE INDEX IF NOT EXISTS idx_composio_toolkits_name ON composio_toolkits(name);
+CREATE INDEX IF NOT EXISTS idx_composio_toolkits_slug ON composio_toolkits(slug);
+CREATE INDEX IF NOT EXISTS idx_composio_toolkits_enabled ON composio_toolkits(enabled);
+
+-- Create trigger for automatic timestamp updates
+CREATE TRIGGER IF NOT EXISTS update_composio_toolkits_updated_at
+AFTER UPDATE ON composio_toolkits
+FOR EACH ROW
+BEGIN
+    UPDATE composio_toolkits SET updated_at = CURRENT_TIMESTAMP WHERE id = OLD.id;
+END;

vibe_surf/backend/database/migrations/v006_add_credentials_table.sql

@@ -0,0 +1,26 @@
+-- Migration v006: Add credentials table for storing encrypted API keys
+-- Created: 2025-01-10
+
+-- Enable foreign keys
+PRAGMA foreign_keys = ON;
+
+-- Create credentials table
+CREATE TABLE IF NOT EXISTS credentials (
+    id VARCHAR(36) PRIMARY KEY,
+    key_name VARCHAR(100) NOT NULL UNIQUE,
+    encrypted_value TEXT,
+    description TEXT,
+    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Create index for faster lookups
+CREATE INDEX IF NOT EXISTS idx_credentials_key_name ON credentials(key_name);
+
+-- Create trigger for automatic timestamp updates
+CREATE TRIGGER IF NOT EXISTS update_credentials_updated_at
+AFTER UPDATE ON credentials
+FOR EACH ROW
+BEGIN
+    UPDATE credentials SET updated_at = CURRENT_TIMESTAMP WHERE id = OLD.id;
+END;

vibe_surf/backend/database/models.py

@@ -189,6 +189,50 @@ class McpProfile(Base):
     def __repr__(self):
         return f"<McpProfile(display_name={self.display_name}, server_name={self.mcp_server_name}, active={self.is_active})>"
 
+class ComposioToolkit(Base):
+    """Composio Toolkit model for managing Composio app integrations"""
+    __tablename__ = 'composio_toolkits'
+    
+    # Primary identifier
+    id = Column(String(36), primary_key=True, default=lambda: str(uuid4()))
+    name = Column(String(100), nullable=False)
+    slug = Column(String(100), nullable=False, unique=True)
+    
+    # Toolkit information
+    description = Column(Text, nullable=True)
+    logo = Column(Text, nullable=True)  # URL to logo
+    app_url = Column(Text, nullable=True)
+    
+    # Configuration
+    enabled = Column(Boolean, default=False, nullable=False)
+    tools = Column(Text, nullable=True)  # JSON string storing tool_name: 0|1 mapping
+    
+    # Timestamps
+    created_at = Column(DateTime, nullable=False, default=func.now())
+    updated_at = Column(DateTime, nullable=False, default=func.now(), onupdate=func.now())
+    
+    def __repr__(self):
+        return f"<ComposioToolkit(name={self.name}, slug={self.slug}, enabled={self.enabled})>"
+
+class Credential(Base):
+    """Credential model for storing encrypted API keys and other sensitive data"""
+    __tablename__ = 'credentials'
+    
+    # Primary identifier
+    id = Column(String(36), primary_key=True, default=lambda: str(uuid4()))
+    key_name = Column(String(100), nullable=False, unique=True)  # e.g., "COMPOSIO_API_KEY"
+    encrypted_value = Column(Text, nullable=True)  # Encrypted value using MAC address
+    
+    # Metadata
+    description = Column(Text, nullable=True)
+    
+    # Timestamps
+    created_at = Column(DateTime, nullable=False, default=func.now())
+    updated_at = Column(DateTime, nullable=False, default=func.now(), onupdate=func.now())
+    
+    def __repr__(self):
+        return f"<Credential(key_name={self.key_name})>"
+
 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)
@@ -201,4 +245,12 @@ Index('idx_mcp_profiles_active', McpProfile.is_active)
 # Voice Profile indexes
 Index('idx_voice_profiles_name', VoiceProfile.voice_profile_name)
 Index('idx_voice_profiles_type', VoiceProfile.voice_model_type)
-Index('idx_voice_profiles_active', VoiceProfile.is_active)
+Index('idx_voice_profiles_active', VoiceProfile.is_active)
+
+# Composio Toolkit indexes
+Index('idx_composio_toolkits_name', ComposioToolkit.name)
+Index('idx_composio_toolkits_slug', ComposioToolkit.slug)
+Index('idx_composio_toolkits_enabled', ComposioToolkit.enabled)
+
+# Credential indexes
+Index('idx_credentials_key_name', Credential.key_name)

vibe_surf/backend/database/queries.py

@@ -3,12 +3,12 @@ Database Query Operations for VibeSurf Backend - With LLM Profile Management
 
 Centralized database operations for Task and LLMProfile tables.
 """
-
+import pdb
 from typing import List, Optional, Dict, Any
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select, update, delete, func, desc, and_, or_
 from sqlalchemy.orm import selectinload
-from .models import Task, TaskStatus, LLMProfile, UploadedFile, McpProfile, VoiceProfile, VoiceModelType
+from .models import Task, TaskStatus, LLMProfile, UploadedFile, McpProfile, VoiceProfile, VoiceModelType, ComposioToolkit, Credential
 from ..utils.encryption import encrypt_api_key, decrypt_api_key
 import logging
 import json
@@ -1117,3 +1117,313 @@ class VoiceProfileQueries:
         except Exception as e:
             logger.error(f"Failed to update last_used for Voice profile {voice_profile_name}: {e}")
             raise
+
+
+class ComposioToolkitQueries:
+    """Query operations for ComposioToolkit model"""
+
+    @staticmethod
+    async def create_toolkit(
+            db: AsyncSession,
+            name: str,
+            slug: str,
+            description: Optional[str] = None,
+            logo: Optional[str] = None,
+            app_url: Optional[str] = None,
+            enabled: bool = False,
+            tools: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Create a new Composio toolkit"""
+        try:
+            toolkit = ComposioToolkit(
+                name=name,
+                slug=slug,
+                description=description,
+                logo=logo,
+                app_url=app_url,
+                enabled=enabled,
+                tools=tools
+            )
+
+            db.add(toolkit)
+            await db.flush()
+            await db.refresh(toolkit)
+
+            # Extract data immediately to avoid greenlet issues
+            toolkit_data = {
+                "id": toolkit.id,
+                "name": toolkit.name,
+                "slug": toolkit.slug,
+                "description": toolkit.description,
+                "logo": toolkit.logo,
+                "app_url": toolkit.app_url,
+                "enabled": toolkit.enabled,
+                "tools": toolkit.tools,
+                "created_at": toolkit.created_at,
+                "updated_at": toolkit.updated_at
+            }
+
+            return toolkit_data
+        except Exception as e:
+            logger.error(f"Failed to create Composio toolkit {name}: {e}")
+            raise
+
+    @staticmethod
+    async def get_toolkit(db: AsyncSession, toolkit_id: str) -> Optional[ComposioToolkit]:
+        """Get Composio toolkit by ID"""
+        try:
+            result = await db.execute(
+                select(ComposioToolkit).where(ComposioToolkit.id == toolkit_id)
+            )
+            toolkit = result.scalar_one_or_none()
+            if toolkit:
+                # Ensure all attributes are loaded by accessing them
+                _ = (toolkit.id, toolkit.created_at, toolkit.updated_at, toolkit.enabled)
+            return toolkit
+        except Exception as e:
+            logger.error(f"Failed to get Composio toolkit {toolkit_id}: {e}")
+            raise
+
+    @staticmethod
+    async def get_toolkit_by_slug(db: AsyncSession, slug: str) -> Optional[ComposioToolkit]:
+        """Get Composio toolkit by slug"""
+        try:
+            result = await db.execute(
+                select(ComposioToolkit).where(ComposioToolkit.slug == slug)
+            )
+            toolkit = result.scalar_one_or_none()
+            if toolkit:
+                _ = (toolkit.id, toolkit.created_at, toolkit.updated_at, toolkit.enabled)
+            return toolkit
+        except Exception as e:
+            logger.error(f"Failed to get Composio toolkit by slug {slug}: {e}")
+            raise
+
+    @staticmethod
+    async def list_toolkits(
+            db: AsyncSession,
+            enabled_only: bool = False,
+            limit: int = -1,
+            offset: int = 0
+    ) -> List[ComposioToolkit]:
+        """List Composio toolkits"""
+        try:
+            query = select(ComposioToolkit)
+
+            if enabled_only:
+                query = query.where(ComposioToolkit.enabled == True)
+
+            # Handle -1 as "get all records"
+            if limit != -1:
+                query = query.limit(limit)
+            
+            # Always apply offset if provided
+            if offset > 0:
+                query = query.offset(offset)
+
+            result = await db.execute(query)
+            toolkits = result.scalars().all()
+
+            # Ensure all attributes are loaded for each toolkit
+            for toolkit in toolkits:
+                _ = (toolkit.id, toolkit.created_at, toolkit.updated_at, toolkit.enabled)
+
+            return toolkits
+        except Exception as e:
+            logger.error(f"Failed to list Composio toolkits: {e}")
+            raise
+
+    @staticmethod
+    async def get_enabled_toolkits(db: AsyncSession) -> List[ComposioToolkit]:
+        """Get all enabled Composio toolkits"""
+        try:
+            result = await db.execute(
+                select(ComposioToolkit).where(ComposioToolkit.enabled == True)
+            )
+            toolkits = result.scalars().all()
+
+            # Ensure all attributes are loaded for each toolkit
+            for toolkit in toolkits:
+                _ = (toolkit.id, toolkit.created_at, toolkit.updated_at, toolkit.enabled)
+
+            return toolkits
+        except Exception as e:
+            logger.error(f"Failed to get enabled Composio toolkits: {e}")
+            raise
+
+    @staticmethod
+    async def update_toolkit(
+            db: AsyncSession,
+            toolkit_id: str,
+            updates: Dict[str, Any]
+    ) -> bool:
+        """Update Composio toolkit"""
+        try:
+            result = await db.execute(
+                update(ComposioToolkit)
+                .where(ComposioToolkit.id == toolkit_id)
+                .values(**updates)
+            )
+
+            return result.rowcount > 0
+        except Exception as e:
+            logger.error(f"Failed to update Composio toolkit {toolkit_id}: {e}")
+            raise
+
+    @staticmethod
+    async def update_toolkit_by_slug(
+            db: AsyncSession,
+            slug: str,
+            updates: Dict[str, Any]
+    ) -> bool:
+        """Update Composio toolkit by slug"""
+        try:
+            result = await db.execute(
+                update(ComposioToolkit)
+                .where(ComposioToolkit.slug == slug)
+                .values(**updates)
+            )
+
+            return result.rowcount > 0
+        except Exception as e:
+            logger.error(f"Failed to update Composio toolkit by slug {slug}: {e}")
+            raise
+
+    @staticmethod
+    async def delete_toolkit(db: AsyncSession, toolkit_id: str) -> bool:
+        """Delete Composio toolkit"""
+        try:
+            result = await db.execute(
+                delete(ComposioToolkit).where(ComposioToolkit.id == toolkit_id)
+            )
+            return result.rowcount > 0
+        except Exception as e:
+            logger.error(f"Failed to delete Composio toolkit {toolkit_id}: {e}")
+            raise
+
+    @staticmethod
+    async def delete_toolkit_by_slug(db: AsyncSession, slug: str) -> bool:
+        """Delete Composio toolkit by slug"""
+        try:
+            result = await db.execute(
+                delete(ComposioToolkit).where(ComposioToolkit.slug == slug)
+            )
+            return result.rowcount > 0
+        except Exception as e:
+            logger.error(f"Failed to delete Composio toolkit by slug {slug}: {e}")
+            raise
+
+    @staticmethod
+    async def toggle_toolkit_enabled(db: AsyncSession, toolkit_id: str, enabled: bool) -> bool:
+        """Toggle toolkit enabled status"""
+        try:
+            result = await db.execute(
+                update(ComposioToolkit)
+                .where(ComposioToolkit.id == toolkit_id)
+                .values(enabled=enabled)
+            )
+            return result.rowcount > 0
+        except Exception as e:
+            logger.error(f"Failed to toggle Composio toolkit {toolkit_id} enabled status: {e}")
+            raise
+
+    @staticmethod
+    async def update_toolkit_tools(db: AsyncSession, toolkit_id: str, tools: str) -> bool:
+        """Update toolkit tools configuration"""
+        try:
+            result = await db.execute(
+                update(ComposioToolkit)
+                .where(ComposioToolkit.id == toolkit_id)
+                .values(tools=tools)
+            )
+            return result.rowcount > 0
+        except Exception as e:
+            logger.error(f"Failed to update Composio toolkit {toolkit_id} tools: {e}")
+            raise
+
+
+class CredentialQueries:
+    """Query operations for Credential model"""
+
+    @staticmethod
+    async def get_credential(db: AsyncSession, key_name: str) -> Optional[str]:
+        """Get decrypted credential value by key name"""
+        try:
+            result = await db.execute(
+                select(Credential).where(Credential.key_name == key_name)
+            )
+            credential = result.scalar_one_or_none()
+            if not credential or not credential.encrypted_value:
+                return None
+            
+            # Decrypt the value
+            decrypted_value = decrypt_api_key(credential.encrypted_value)
+            return decrypted_value
+            
+        except Exception as e:
+            logger.error(f"Failed to get credential {key_name}: {e}")
+            return None
+
+    @staticmethod
+    async def store_credential(db: AsyncSession, key_name: str, value: str, description: Optional[str] = None) -> bool:
+        """Store encrypted credential"""
+        try:
+            # Encrypt the value
+            encrypted_value = encrypt_api_key(value)
+            
+            # Check if credential exists
+            result = await db.execute(
+                select(Credential).where(Credential.key_name == key_name)
+            )
+            existing_credential = result.scalar_one_or_none()
+            
+            if existing_credential:
+                # Update existing credential
+                await db.execute(
+                    update(Credential)
+                    .where(Credential.key_name == key_name)
+                    .values(
+                        encrypted_value=encrypted_value,
+                        description=description,
+                        updated_at=func.now()
+                    )
+                )
+            else:
+                # Create new credential
+                credential = Credential(
+                    key_name=key_name,
+                    encrypted_value=encrypted_value,
+                    description=description
+                )
+                db.add(credential)
+            
+            await db.flush()
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to store credential {key_name}: {e}")
+            return False
+
+    @staticmethod
+    async def delete_credential(db: AsyncSession, key_name: str) -> bool:
+        """Delete credential"""
+        try:
+            result = await db.execute(
+                delete(Credential).where(Credential.key_name == key_name)
+            )
+            return result.rowcount > 0
+        except Exception as e:
+            logger.error(f"Failed to delete credential {key_name}: {e}")
+            return False
+
+    @staticmethod
+    async def list_credential_names(db: AsyncSession) -> List[str]:
+        """List all credential key names (for administrative purposes)"""
+        try:
+            result = await db.execute(
+                select(Credential.key_name).order_by(Credential.created_at)
+            )
+            return [row[0] for row in result.all()]
+        except Exception as e:
+            logger.error(f"Failed to list credential names: {e}")
+            return []

vibe_surf/backend/main.py

@@ -22,6 +22,7 @@ from .api.config import router as config_router
 from .api.browser import router as browser_router
 from .api.voices import router as voices_router
 from .api.agent import router as agent_router
+from .api.composio import router as composio_router
 
 # Import shared state
 from . import shared_state
@@ -29,6 +30,8 @@ from . import shared_state
 # Configure logging
 
 from vibe_surf.logger import get_logger
+from vibe_surf.telemetry.service import ProductTelemetry
+from vibe_surf.telemetry.views import BackendTelemetryEvent
 
 logger = get_logger(__name__)
 
@@ -55,6 +58,7 @@ app.include_router(config_router, prefix="/api", tags=["config"])
 app.include_router(browser_router, prefix="/api", tags=["browser"])
 app.include_router(voices_router, prefix="/api", tags=["voices"])
 app.include_router(agent_router, prefix="/api", tags=["agent"])
+app.include_router(composio_router, prefix="/api", tags=["composio"])
 
 # Global variable to control browser monitoring task
 browser_monitor_task = None
@@ -110,6 +114,15 @@ async def startup_event():
     """Initialize database and VibeSurf components on startup"""
     global browser_monitor_task
     
+    # Initialize telemetry and capture startup event
+    telemetry = ProductTelemetry()
+    import vibe_surf
+    startup_event = BackendTelemetryEvent(
+        version=vibe_surf.__version__,
+        action='startup'
+    )
+    telemetry.capture(startup_event)
+    
     # Initialize VibeSurf components and update shared state
     await shared_state.initialize_vibesurf_components()
 
@@ -118,6 +131,9 @@ async def startup_event():
     logger.info("🔍 Started browser connection monitor")
 
     logger.info("🚀 VibeSurf Backend API started with single-task execution model")
+    
+    # Flush telemetry
+    telemetry.flush()
 
 @app.on_event("shutdown")
 async def shutdown_event():
@@ -126,6 +142,15 @@ async def shutdown_event():
     
     logger.info("🛑 Starting graceful shutdown...")
     
+    # Capture telemetry shutdown event
+    telemetry = ProductTelemetry()
+    import vibe_surf
+    shutdown_event = BackendTelemetryEvent(
+        version=vibe_surf.__version__,
+        action='shutdown'
+    )
+    telemetry.capture(shutdown_event)
+    
     # Cancel browser monitor task
     if browser_monitor_task and not browser_monitor_task.done():
         browser_monitor_task.cancel()
@@ -153,6 +178,9 @@ async def shutdown_event():
             logger.error(f"❌ Error closing database manager: {e}")
     
     logger.info("🛑 VibeSurf Backend API stopped")
+    
+    # Flush telemetry before shutdown
+    telemetry.flush()
 
 # Health check endpoint
 @app.get("/health")