machinaos 0.0.10 → 0.0.13

package/server/core/cleanup.py

@@ -0,0 +1,123 @@
+"""Periodic cleanup service for long-running daemon.
+
+Follows the RecoverySweeper pattern from execution/recovery.py.
+All configuration from Settings (environment variables).
+"""
+import asyncio
+import gc
+from typing import Optional, TYPE_CHECKING
+
+from core.logging import get_logger
+
+if TYPE_CHECKING:
+    from core.config import Settings
+    from core.database import Database
+    from core.cache import CacheService
+
+logger = get_logger(__name__)
+
+
+class CleanupService:
+    """Background cleanup to prevent resource exhaustion.
+
+    Periodically cleans up:
+    - Expired cache entries
+    - Old console logs (keeps configurable count)
+    - Old cache entries by age
+    - Forces garbage collection
+    """
+
+    def __init__(
+        self,
+        database: "Database",
+        cache: "CacheService",
+        settings: "Settings"
+    ):
+        self.database = database
+        self.cache = cache
+        self.settings = settings
+        self._running = False
+        self._task: Optional[asyncio.Task] = None
+
+    async def start(self) -> None:
+        """Start the cleanup service background task."""
+        if self._running:
+            return
+        self._running = True
+        self._task = asyncio.create_task(self._cleanup_loop())
+        logger.info(
+            "Cleanup service started",
+            interval=self.settings.cleanup_interval,
+            logs_max=self.settings.cleanup_logs_max_count,
+            cache_max_age_hours=self.settings.cleanup_cache_max_age_hours
+        )
+
+    async def stop(self) -> None:
+        """Stop the cleanup service gracefully."""
+        self._running = False
+        if self._task:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+        logger.info("Cleanup service stopped")
+
+    async def _cleanup_loop(self) -> None:
+        """Main cleanup loop - runs at configured interval."""
+        while self._running:
+            try:
+                await self._run_cleanup()
+            except Exception as e:
+                logger.error("Cleanup failed", error=str(e))
+            await asyncio.sleep(self.settings.cleanup_interval)
+
+    async def _run_cleanup(self) -> None:
+        """Execute all cleanup tasks."""
+        results = {}
+
+        # 1. Expired cache entries (TTL-based)
+        try:
+            results['expired_cache'] = await self.database.cleanup_expired_cache()
+        except Exception as e:
+            logger.warning("Failed to cleanup expired cache", error=str(e))
+            results['expired_cache'] = 0
+
+        # 2. Old console logs (keep last N)
+        try:
+            results['old_logs'] = await self.database.cleanup_old_console_logs(
+                keep=self.settings.cleanup_logs_max_count
+            )
+        except Exception as e:
+            logger.warning("Failed to cleanup old console logs", error=str(e))
+            results['old_logs'] = 0
+
+        # 3. Old cache entries by age
+        try:
+            results['old_cache'] = await self.database.cleanup_old_cache(
+                max_age_hours=self.settings.cleanup_cache_max_age_hours
+            )
+        except Exception as e:
+            logger.warning("Failed to cleanup old cache", error=str(e))
+            results['old_cache'] = 0
+
+        # 4. Force garbage collection
+        gc.collect()
+
+        # Only log if something was cleaned up
+        total_cleaned = sum(results.values())
+        if total_cleaned > 0:
+            logger.info("Cleanup completed", **results)
+
+    async def run_once(self) -> dict:
+        """Run cleanup once and return results. Useful for testing."""
+        results = {}
+        results['expired_cache'] = await self.database.cleanup_expired_cache()
+        results['old_logs'] = await self.database.cleanup_old_console_logs(
+            keep=self.settings.cleanup_logs_max_count
+        )
+        results['old_cache'] = await self.database.cleanup_old_cache(
+            max_age_hours=self.settings.cleanup_cache_max_age_hours
+        )
+        gc.collect()
+        return results

package/server/core/config.py

@@ -100,6 +100,22 @@ class Settings(BaseSettings):
     # Health Check
     health_check_interval: int = Field(default=30, env="HEALTH_CHECK_INTERVAL", ge=10)
 
+    # Cleanup Configuration (for long-running daemon)
+    cleanup_enabled: bool = Field(default=True, env="CLEANUP_ENABLED")
+    cleanup_interval: int = Field(default=3600, env="CLEANUP_INTERVAL", ge=60)
+    cleanup_logs_max_count: int = Field(default=1000, env="CLEANUP_LOGS_MAX_COUNT", ge=100)
+    cleanup_cache_max_age_hours: int = Field(default=24, env="CLEANUP_CACHE_MAX_AGE_HOURS", ge=1)
+
+    # Feature Toggles
+    ws_logging_enabled: bool = Field(default=True, env="WS_LOGGING_ENABLED")
+
+    # Gunicorn Configuration (for production deployment)
+    gunicorn_timeout: int = Field(default=120, env="GUNICORN_TIMEOUT", ge=30)
+    gunicorn_graceful_timeout: int = Field(default=30, env="GUNICORN_GRACEFUL_TIMEOUT", ge=10)
+    gunicorn_keepalive: int = Field(default=5, env="GUNICORN_KEEPALIVE", ge=1)
+    gunicorn_max_requests: int = Field(default=10000, env="GUNICORN_MAX_REQUESTS", ge=0)
+    gunicorn_max_requests_jitter: int = Field(default=1000, env="GUNICORN_MAX_REQUESTS_JITTER", ge=0)
+
     @field_validator("database_url")
     @classmethod
     def validate_database_url(cls, v):

package/server/core/database.py

@@ -5,7 +5,7 @@ from typing import Dict, Any, List, Optional
 from sqlmodel import SQLModel, select, Session
 from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
 from sqlalchemy.exc import IntegrityError
-from sqlalchemy import text
+from sqlalchemy import text, func
 from contextlib import asynccontextmanager
 
 from core.config import Settings
@@ -77,6 +77,12 @@ class Database:
                         "ALTER TABLE user_settings ADD COLUMN console_panel_default_open BOOLEAN DEFAULT 0"
                     ))
                     logger.info("Added console_panel_default_open column to user_settings")
+
+                if "examples_loaded" not in columns:
+                    await conn.execute(text(
+                        "ALTER TABLE user_settings ADD COLUMN examples_loaded BOOLEAN DEFAULT 0"
+                    ))
+                    logger.info("Added examples_loaded column to user_settings")
         except Exception as e:
             logger.warning(f"Migration check failed (table may not exist yet): {e}")
 
@@ -489,6 +495,27 @@ class Database:
             logger.error("Failed to get node output", node_id=node_id, error=str(e))
             return None
 
+    async def get_node_output_by_session(self, session_id: str,
+                                          output_name: str = "output_0") -> Optional[Dict[str, Any]]:
+        """Get node output by session_id only (for delegation result lookup).
+
+        Used when node_id is unknown but session_id encodes the lookup key.
+        """
+        try:
+            async with self.get_session() as session:
+                stmt = select(NodeOutput).where(
+                    NodeOutput.session_id == session_id,
+                    NodeOutput.output_name == output_name
+                )
+                result = await session.execute(stmt)
+                output = result.scalar_one_or_none()
+
+                return {"data": output.data} if output else None
+
+        except Exception as e:
+            logger.error("Failed to get node output by session", session_id=session_id, error=str(e))
+            return None
+
     async def delete_node_output(self, node_id: str) -> int:
         """Delete all outputs for a node (any session). Returns count deleted."""
         try:
@@ -814,6 +841,47 @@ class Database:
             logger.error("Failed to clear console logs", error=str(e))
             return 0
 
+    async def cleanup_old_console_logs(self, keep: int = 1000) -> int:
+        """Keep only the most recent N console logs. Returns count deleted."""
+        from models.database import ConsoleLog
+
+        try:
+            async with self.get_session() as session:
+                # Count total logs
+                count_stmt = select(func.count()).select_from(ConsoleLog)
+                total_result = await session.execute(count_stmt)
+                total = total_result.scalar() or 0
+
+                if total <= keep:
+                    return 0
+
+                # Get IDs of logs to keep (most recent)
+                keep_stmt = (
+                    select(ConsoleLog.id)
+                    .order_by(ConsoleLog.created_at.desc())
+                    .limit(keep)
+                )
+                keep_result = await session.execute(keep_stmt)
+                keep_ids = {row[0] for row in keep_result.fetchall()}
+
+                # Delete logs not in keep list
+                delete_stmt = select(ConsoleLog).where(ConsoleLog.id.notin_(keep_ids))
+                result = await session.execute(delete_stmt)
+                old_logs = result.scalars().all()
+
+                count = len(old_logs)
+                for log in old_logs:
+                    await session.delete(log)
+
+                await session.commit()
+                if count > 0:
+                    logger.info("Cleaned up old console logs", deleted=count, kept=keep)
+                return count
+
+        except Exception as e:
+            logger.error("Failed to cleanup old console logs", error=str(e))
+            return 0
+
     # ============================================================================
     # Cache Entries (SQLite-backed Redis alternative)
     # ============================================================================
@@ -941,6 +1009,29 @@ class Database:
             logger.error("Failed to cleanup expired cache", error=str(e))
             return 0
 
+    async def cleanup_old_cache(self, max_age_hours: int = 24) -> int:
+        """Remove cache entries older than max_age_hours. Returns count deleted."""
+        import time
+        try:
+            async with self.get_session() as session:
+                cutoff_time = time.time() - (max_age_hours * 3600)
+                stmt = select(CacheEntry).where(CacheEntry.created_at < cutoff_time)
+                result = await session.execute(stmt)
+                entries = result.scalars().all()
+
+                count = len(entries)
+                for entry in entries:
+                    await session.delete(entry)
+
+                await session.commit()
+                if count > 0:
+                    logger.info("Cleaned up old cache entries", count=count, max_age_hours=max_age_hours)
+                return count
+
+        except Exception as e:
+            logger.error("Failed to cleanup old cache", error=str(e))
+            return 0
+
     async def cache_exists(self, key: str) -> bool:
         """Check if cache key exists and is not expired."""
         import time

package/server/core/health.py

@@ -0,0 +1,121 @@
+"""Health check utilities for daemon monitoring.
+
+Provides uptime tracking and comprehensive health status for /health endpoint.
+"""
+import time
+from typing import Dict, Any, TYPE_CHECKING
+
+try:
+    import psutil
+    PSUTIL_AVAILABLE = True
+except ImportError:
+    PSUTIL_AVAILABLE = False
+
+if TYPE_CHECKING:
+    from core.config import Settings
+    from core.database import Database
+    from core.cache import CacheService
+
+# Module-level startup time tracking
+_startup_time: float = 0.0
+
+
+def set_startup_time() -> None:
+    """Record the application startup time. Call once during lifespan startup."""
+    global _startup_time
+    _startup_time = time.time()
+
+
+def get_uptime() -> float:
+    """Get uptime in seconds since startup."""
+    return time.time() - _startup_time if _startup_time else 0.0
+
+
+def get_memory_mb() -> float:
+    """Get current process memory usage in MB."""
+    if not PSUTIL_AVAILABLE:
+        return 0.0
+    try:
+        return psutil.Process().memory_info().rss / (1024 * 1024)
+    except Exception:
+        return 0.0
+
+
+def get_disk_percent(path: str = ".") -> float:
+    """Get disk usage percentage for given path."""
+    if not PSUTIL_AVAILABLE:
+        return 0.0
+    try:
+        return psutil.disk_usage(path).percent
+    except Exception:
+        return 0.0
+
+
+def get_cpu_percent() -> float:
+    """Get current process CPU usage percentage."""
+    if not PSUTIL_AVAILABLE:
+        return 0.0
+    try:
+        return psutil.Process().cpu_percent(interval=0.1)
+    except Exception:
+        return 0.0
+
+
+async def check_database(database: "Database") -> bool:
+    """Check database connectivity."""
+    try:
+        async with database.get_session() as session:
+            from sqlalchemy import text
+            await session.execute(text("SELECT 1"))
+        return True
+    except Exception:
+        return False
+
+
+async def check_cache(cache: "CacheService") -> bool:
+    """Check cache connectivity."""
+    try:
+        test_key = "_health_check"
+        await cache.set(test_key, "ok", ttl=10)
+        result = await cache.get(test_key)
+        await cache.delete(test_key)
+        return result == "ok"
+    except Exception:
+        return False
+
+
+async def get_health_status(
+    database: "Database",
+    cache: "CacheService",
+    settings: "Settings"
+) -> Dict[str, Any]:
+    """Get comprehensive health status for /health endpoint.
+
+    Returns:
+        Dict containing status, uptime, resource usage, and feature flags.
+    """
+    # Run health checks
+    db_healthy = await check_database(database)
+    cache_healthy = await check_cache(cache)
+
+    # Determine overall status
+    overall_status = "healthy" if (db_healthy and cache_healthy) else "degraded"
+
+    return {
+        "status": overall_status,
+        "uptime_seconds": round(get_uptime(), 1),
+        "memory_mb": round(get_memory_mb(), 1),
+        "disk_percent": round(get_disk_percent(), 1),
+        "cpu_percent": round(get_cpu_percent(), 1),
+        "checks": {
+            "database": db_healthy,
+            "cache": cache_healthy,
+        },
+        "features": {
+            "redis": settings.redis_enabled,
+            "temporal": settings.temporal_enabled,
+            "cleanup": settings.cleanup_enabled,
+            "ws_logging": settings.ws_logging_enabled,
+        },
+        "psutil_available": PSUTIL_AVAILABLE,
+    }

package/server/examples/__init__.py

@@ -0,0 +1 @@
+# Example workflows package

package/server/gunicorn.conf.py

@@ -0,0 +1,46 @@
+"""Gunicorn configuration for production deployment.
+
+Reads settings from environment variables (same as config.py).
+No hardcoded values - everything from .env file.
+
+Usage:
+    gunicorn main:app -c gunicorn.conf.py
+"""
+import os
+import multiprocessing
+
+# Load from environment (same vars used by config.py)
+host = os.getenv("HOST", "0.0.0.0")
+port = os.getenv("PORT", "3010")
+workers_env = os.getenv("WORKERS", "0")  # 0 = auto-calculate
+log_level = os.getenv("LOG_LEVEL", "INFO").lower()
+debug = os.getenv("DEBUG", "false").lower() == "true"
+
+# Bind - use HOST and PORT from .env
+bind = f"{host}:{port}"
+
+# Workers - from WORKERS env or auto-calculate
+# WORKERS=0 means auto (2 * cpu + 1), WORKERS=N means use N
+workers_count = int(workers_env)
+workers = workers_count if workers_count > 0 else (multiprocessing.cpu_count() * 2 + 1)
+worker_class = "uvicorn.workers.UvicornWorker"
+
+# Timeouts - configurable via env
+timeout = int(os.getenv("GUNICORN_TIMEOUT", "120"))
+graceful_timeout = int(os.getenv("GUNICORN_GRACEFUL_TIMEOUT", "30"))
+keepalive = int(os.getenv("GUNICORN_KEEPALIVE", "5"))
+
+# Restart workers periodically to prevent memory leaks
+max_requests = int(os.getenv("GUNICORN_MAX_REQUESTS", "10000"))
+max_requests_jitter = int(os.getenv("GUNICORN_MAX_REQUESTS_JITTER", "1000"))
+
+# Logging - use LOG_LEVEL from .env
+accesslog = "-" if not debug else None
+errorlog = "-"
+loglevel = log_level
+
+# Process naming
+proc_name = "machina-backend"
+
+# Preload app for faster worker startup (disable in debug for reload)
+preload_app = not debug

package/server/main.py

@@ -104,6 +104,21 @@ async def lifespan(app: FastAPI):
     setup_websocket_logging(loop)
     logger.info("WebSocket logging handler started")
 
+    # Start cleanup service for long-running daemon
+    from core.cleanup import CleanupService
+    from core.health import set_startup_time
+    cleanup_service = None
+    if settings.cleanup_enabled:
+        cleanup_service = CleanupService(
+            database=container.database(),
+            cache=container.cache(),
+            settings=settings
+        )
+        await cleanup_service.start()
+
+    # Record startup time for health reporting
+    set_startup_time()
+
     # Initialize Temporal if enabled
     temporal_worker_manager = None
     if settings.temporal_enabled:
@@ -165,6 +180,10 @@ async def lifespan(app: FastAPI):
     from services.android.manager import close_relay_client
     await close_relay_client(clear_stored_session=False)
 
+    # Stop cleanup service
+    if cleanup_service is not None:
+        await cleanup_service.stop()
+
     # Stop recovery sweeper first
     if settings.redis_enabled:
         await recovery_sweeper.stop()
@@ -239,12 +258,20 @@ app.include_router(webhook.router)
 
 @app.get("/health")
 async def health_check():
-    """Detailed health check."""
+    """Detailed health check with resource monitoring."""
     from services import event_waiter
     from services.execution import get_recovery_sweeper
+    from core.health import get_health_status, get_uptime, get_memory_mb, get_disk_percent, get_cpu_percent
 
     sweeper = get_recovery_sweeper()
 
+    # Get comprehensive health status
+    health = await get_health_status(
+        database=container.database(),
+        cache=container.cache(),
+        settings=settings
+    )
+
     # Check Temporal status
     temporal_status = {
         "enabled": settings.temporal_enabled,
@@ -259,10 +286,18 @@ async def health_check():
             pass
 
     return {
-        "status": "OK",
+        "status": health["status"],
         "service": "python",
-        "version": "3.2.0",  # Bumped for Temporal integration
+        "version": "3.3.0",  # Bumped for daemon service support
         "environment": "development" if settings.debug else "production",
+        "uptime_seconds": health["uptime_seconds"],
+        "resources": {
+            "memory_mb": health["memory_mb"],
+            "disk_percent": health["disk_percent"],
+            "cpu_percent": health["cpu_percent"],
+        },
+        "checks": health["checks"],
+        "features": health["features"],
         "redis_enabled": settings.redis_enabled,
         "event_waiter_mode": event_waiter.get_backend_mode(),
         "execution_engine": {

package/server/models/database.py

@@ -252,6 +252,7 @@ class UserSettings(SQLModel, table=True):
     sidebar_default_open: bool = Field(default=True)
     component_palette_default_open: bool = Field(default=True)
     console_panel_default_open: bool = Field(default=False)
+    examples_loaded: bool = Field(default=False)  # Track if example workflows were imported
     created_at: datetime = Field(
         default_factory=lambda: datetime.now(timezone.utc),
         sa_column=Column(DateTime(timezone=True), server_default=func.now())

package/server/models/nodes.py

@@ -147,6 +147,22 @@ class WhatsAppReceiveParams(BaseNodeParams):
     include_media: bool = Field(default=False, alias="includeMediaData")
 
 
+class WhatsAppDbParams(BaseNodeParams):
+    """Parameters for WhatsApp database query node."""
+    type: Literal["whatsappDb"]
+    operation: Literal["chat_history", "search_groups", "get_group_info", "get_contact_info", "list_contacts", "check_contacts"] = "chat_history"
+    # chat_history params
+    phone_number: str = Field(default="", alias="phoneNumber")
+    group_id: str = Field(default="", alias="groupId")
+    group_name: str = Field(default="", alias="groupName")
+    limit: int = Field(default=50, ge=1, le=500)
+    offset: int = Field(default=0, ge=0)
+    # search_groups params
+    search_query: str = Field(default="", alias="searchQuery")
+    # check_contacts params
+    phone_numbers: str = Field(default="", alias="phoneNumbers")
+
+
 # =============================================================================
 # CODE EXECUTOR NODE MODELS
 # =============================================================================
@@ -277,7 +293,7 @@ MapsNodeParams = Annotated[
 
 # WhatsApp Nodes
 WhatsAppNodeParams = Annotated[
-    Union[WhatsAppSendParams, WhatsAppReceiveParams],
+    Union[WhatsAppSendParams, WhatsAppReceiveParams, WhatsAppDbParams],
     Field(discriminator="type")
 ]
 
@@ -319,7 +335,7 @@ KnownNodeParams = Annotated[
         # Maps
         CreateMapParams, GmapsLocationsParams, GmapsNearbyPlacesParams,
         # WhatsApp
-        WhatsAppSendParams, WhatsAppReceiveParams,
+        WhatsAppSendParams, WhatsAppReceiveParams, WhatsAppDbParams,
         # Code
         PythonExecutorParams, JavaScriptExecutorParams,
         # HTTP

package/server/requirements-docker.txt

@@ -0,0 +1,86 @@
+# Docker-specific requirements (CPU-only, no CUDA)
+# This file is used by Dockerfile to avoid large CUDA dependencies
+
+# Core Framework
+fastapi>=0.110.0
+uvicorn[standard]>=0.27.0
+
+# Performance optimization
+uvloop>=0.19.0;sys_platform!='win32'
+orjson>=3.10.0
+
+# Database & ORM (Python 3.13 compatible versions)
+sqlmodel>=0.0.18
+sqlalchemy[asyncio]>=2.0.35
+aiosqlite>=0.20.0
+
+# Settings & Configuration
+pydantic>=2.6.0
+pydantic-settings>=2.2.0
+python-dotenv>=1.0.0
+
+# Dependency Injection
+dependency-injector>=4.41.0
+
+# Caching (Redis) - Python 3.13 compatible
+redis>=5.0.0
+
+# HTTP Client
+httpx>=0.27.0
+
+# WebSocket Client (for WhatsApp RPC)
+websockets>=12.0
+
+# Async HTTP Client (for Android relay WebSocket)
+aiohttp>=3.9.0
+
+# QR Code Generation (for WhatsApp QR display)
+qrcode[pil]>=7.4.0
+
+# Logging
+structlog>=23.2.0
+
+# AI Providers (LangChain) - compatible versions
+langchain-core>=1.2.6
+langchain-openai>=1.0.0
+langchain-anthropic>=1.3.0
+langchain-google-genai>=3.1.0
+langchain-groq>=0.1.0
+langchain-cerebras>=0.1.0
+
+# LangGraph - State machine for AI agents
+langgraph>=1.0.6
+
+# Temporal - Durable workflow execution (optional)
+temporalio>=1.21.1
+
+# Google Services
+googlemaps>=4.10.0
+
+# Scheduling
+APScheduler>=3.10.0
+
+# Web Search
+ddgs>=9.0.0
+
+# Authentication
+bcrypt>=4.1.0
+python-jose[cryptography]>=3.3.0
+email-validator>=2.0.0
+
+# Timezone support
+pytz>=2024.1
+
+# Document Processing (CPU-only)
+beautifulsoup4>=4.12.0
+langchain-text-splitters>=0.3.0
+pypdf>=4.0.0
+
+# Note: The following are excluded for Docker builds (CUDA/GPU heavy):
+# - sentence-transformers (pulls PyTorch with CUDA)
+# - langchain-huggingface (pulls sentence-transformers)
+# - chromadb (pulls sentence-transformers for embeddings)
+# - qdrant-client (optional, can be re-added if needed without embeddings)
+#
+# For production with embeddings, use external embedding APIs (OpenAI, etc.)
+# or build a separate GPU-enabled image.

package/server/routers/database.py

@@ -7,6 +7,7 @@ from typing import Dict, Any, Optional, List
 from core.container import container
 from core.database import Database
 from core.logging import get_logger
+from services.example_loader import import_examples_for_user
 
 logger = get_logger(__name__)
 router = APIRouter(prefix="/api/database", tags=["database"])
@@ -93,6 +94,21 @@ async def get_all_workflows(
 ):
     """Get all workflows."""
     try:
+        # Auto-load example workflows on first fetch
+        user_id = "default"
+        settings = await database.get_user_settings(user_id)
+
+        if not settings or not settings.get("examples_loaded", False):
+            # First time - import examples
+            count = await import_examples_for_user(database)
+            if count > 0:
+                logger.info(f"Auto-loaded {count} example workflows")
+
+            # Mark as loaded using existing save_user_settings
+            current = settings or {}
+            current["examples_loaded"] = True
+            await database.save_user_settings(current, user_id)
+
         workflows = await database.get_all_workflows()
         return {
             "success": True,