machinaos 0.0.1

package/server/services/temporal/ws_client.py

@@ -0,0 +1,236 @@
+"""WebSocket client for Temporal activities.
+
+Uses aiohttp ClientSession for proper connection pooling and concurrent
+request handling. Each activity creates its own WebSocket connection
+to avoid race conditions, but the session manages connection reuse.
+
+References:
+- https://docs.aiohttp.org/en/stable/client_quickstart.html
+- https://websockets.readthedocs.io/en/stable/reference/asyncio/client.html
+"""
+
+import asyncio
+import json
+import uuid
+from typing import Any, Dict, Optional
+from contextlib import asynccontextmanager
+
+import aiohttp
+
+from core.logging import get_logger
+from core.config import Settings
+
+logger = get_logger(__name__)
+
+# Load settings
+_settings = Settings()
+WS_URL = f"ws://{_settings.host}:{_settings.port}/ws/internal"
+
+print(f"[Temporal WS Client] WebSocket URL configured: {WS_URL}")
+
+
+class WSConnectionPool:
+    """WebSocket connection pool using aiohttp ClientSession.
+
+    aiohttp ClientSession provides built-in connection pooling with:
+    - Connection reuse and keep-alive
+    - Configurable connection limits
+    - Proper concurrent request handling
+
+    Each execute_node call gets its own WebSocket connection from the pool,
+    avoiding the ConcurrencyError that occurs when sharing a single connection.
+    """
+
+    def __init__(self, url: str = WS_URL, pool_size: int = 100):
+        self.url = url
+        self.pool_size = pool_size
+        self._session: Optional[aiohttp.ClientSession] = None
+        self._lock = asyncio.Lock()
+
+    async def _get_session(self) -> aiohttp.ClientSession:
+        """Get or create the aiohttp session with connection pooling."""
+        if self._session is None or self._session.closed:
+            async with self._lock:
+                if self._session is None or self._session.closed:
+                    connector = aiohttp.TCPConnector(
+                        limit=self.pool_size,
+                        limit_per_host=self.pool_size,
+                        enable_cleanup_closed=True,
+                    )
+                    timeout = aiohttp.ClientTimeout(
+                        total=300,  # 5 min total timeout
+                        connect=10,  # 10 sec connect timeout
+                    )
+                    self._session = aiohttp.ClientSession(
+                        connector=connector,
+                        timeout=timeout,
+                    )
+                    print(f"[WS Pool] Created session with pool_size={self.pool_size}")
+        return self._session
+
+    @asynccontextmanager
+    async def connection(self):
+        """Get a WebSocket connection from the pool.
+
+        Usage:
+            async with pool.connection() as ws:
+                await ws.send_json(request)
+                response = await ws.receive_json()
+        """
+        session = await self._get_session()
+        async with session.ws_connect(
+            self.url,
+            heartbeat=20,
+            receive_timeout=120,
+        ) as ws:
+            yield ws
+
+    async def execute_node(
+        self,
+        node_id: str,
+        node_type: str,
+        data: Dict[str, Any],
+        context: Dict[str, Any],
+        timeout: float = 120.0,
+    ) -> Dict[str, Any]:
+        """Execute a node via WebSocket.
+
+        Each call gets its own connection from the pool, allowing
+        concurrent execution without race conditions.
+        """
+        request_id = str(uuid.uuid4())
+
+        message = {
+            "type": "execute_node",
+            "request_id": request_id,
+            "node_id": node_id,
+            "node_type": node_type,
+            "parameters": data,
+            "nodes": context.get("nodes", []),
+            "edges": context.get("edges", []),
+            "session_id": context.get("session_id", "default"),
+            "workflow_id": context.get("workflow_id"),
+        }
+
+        try:
+            async with self.connection() as ws:
+                await ws.send_json(message)
+                print(f"[WS Pool] Sent execute_node for {node_id}")
+
+                # Wait for response with matching request_id
+                async with asyncio.timeout(timeout):
+                    async for msg in ws:
+                        if msg.type == aiohttp.WSMsgType.TEXT:
+                            response = json.loads(msg.data)
+                            if response.get("request_id") == request_id:
+                                print(f"[WS Pool] Received response for {node_id}: success={response.get('success')}")
+                                return response
+                        elif msg.type == aiohttp.WSMsgType.ERROR:
+                            raise Exception(f"WebSocket error: {ws.exception()}")
+                        elif msg.type == aiohttp.WSMsgType.CLOSED:
+                            raise Exception("WebSocket closed unexpectedly")
+
+                raise Exception(f"No response received for request {request_id}")
+
+        except asyncio.TimeoutError:
+            raise Exception(f"WebSocket request timeout ({timeout}s) for node {node_id}")
+        except aiohttp.ClientError as e:
+            raise Exception(f"WebSocket connection error: {e}")
+
+    async def close(self):
+        """Close the connection pool."""
+        if self._session and not self._session.closed:
+            await self._session.close()
+            print("[WS Pool] Session closed")
+
+
+# Global connection pool instance
+_pool: Optional[WSConnectionPool] = None
+_pool_lock = asyncio.Lock()
+
+
+async def get_ws_pool() -> WSConnectionPool:
+    """Get or create the global WebSocket connection pool."""
+    global _pool
+
+    async with _pool_lock:
+        if _pool is None:
+            _pool = WSConnectionPool()
+        return _pool
+
+
+async def execute_node_ws(
+    node_id: str,
+    node_type: str,
+    data: Dict[str, Any],
+    context: Dict[str, Any],
+    timeout: float = 120.0,
+) -> Dict[str, Any]:
+    """Execute a node via WebSocket using the connection pool.
+
+    This is the recommended way to execute nodes from activities.
+    Each call gets its own connection from the pool.
+    """
+    pool = await get_ws_pool()
+    return await pool.execute_node(
+        node_id=node_id,
+        node_type=node_type,
+        data=data,
+        context=context,
+        timeout=timeout,
+    )
+
+
+async def close_ws_pool() -> None:
+    """Close the global WebSocket connection pool."""
+    global _pool
+
+    async with _pool_lock:
+        if _pool:
+            await _pool.close()
+            _pool = None
+
+
+# Backwards compatibility aliases
+async def get_ws_client() -> WSConnectionPool:
+    """Alias for get_ws_pool() for backwards compatibility."""
+    return await get_ws_pool()
+
+
+async def close_ws_client() -> None:
+    """Alias for close_ws_pool() for backwards compatibility."""
+    await close_ws_pool()
+
+
+# For backwards compatibility with old code that expects TemporalWSClient
+class TemporalWSClient:
+    """Backwards compatibility wrapper around WSConnectionPool."""
+
+    def __init__(self, url: str = WS_URL):
+        self._pool = WSConnectionPool(url=url)
+
+    @property
+    def connected(self) -> bool:
+        return True  # Pool manages connections
+
+    async def connect(self) -> None:
+        pass  # Pool connects on demand
+
+    async def disconnect(self) -> None:
+        await self._pool.close()
+
+    async def execute_node(
+        self,
+        node_id: str,
+        node_type: str,
+        data: Dict[str, Any],
+        context: Dict[str, Any],
+        timeout: float = 120.0,
+    ) -> Dict[str, Any]:
+        return await self._pool.execute_node(
+            node_id=node_id,
+            node_type=node_type,
+            data=data,
+            context=context,
+            timeout=timeout,
+        )

package/server/services/text.py

@@ -0,0 +1,111 @@
+"""Text generation service."""
+
+import time
+from datetime import datetime
+from typing import Dict, Any
+
+from core.logging import get_logger, log_execution_time
+
+logger = get_logger(__name__)
+
+
+class TextService:
+    """Text generation and processing service."""
+
+    def __init__(self):
+        pass
+
+    async def execute_text_generator(self, node_id: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute text generator node (migrated from Node.js)."""
+        start_time = time.time()
+
+        try:
+            text = parameters.get('text', 'Hello World')
+            include_timestamp = parameters.get('includeTimestamp', True)
+
+            result_data = {
+                "text": text,
+                "length": len(text),
+                "nodeId": node_id
+            }
+
+            if include_timestamp:
+                result_data["timestamp"] = datetime.now().isoformat()
+
+            result = {
+                "type": "text",
+                "data": result_data,
+                "nodeId": node_id,
+                "timestamp": datetime.now().isoformat()
+            }
+
+            log_execution_time(logger, "text_generator", start_time, time.time())
+
+            return {
+                "success": True,
+                "node_id": node_id,
+                "node_type": "textGenerator",
+                "result": result,
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+        except Exception as e:
+            logger.error("Text generator execution failed", node_id=node_id, error=str(e))
+            return {
+                "success": False,
+                "node_id": node_id,
+                "node_type": "textGenerator",
+                "error": str(e),
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+    async def execute_file_handler(self, node_id: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute file handler node (migrated from Node.js)."""
+        start_time = time.time()
+
+        try:
+            file_type = parameters.get('fileType', 'generic')
+            file_content = parameters.get('content', '')
+            file_name = parameters.get('fileName', 'untitled.txt')
+
+            # Basic file processing
+            result_data = {
+                "fileName": file_name,
+                "fileType": file_type,
+                "content": file_content,
+                "size": len(file_content),
+                "processed": True,
+                "processingType": file_type,
+                "nodeId": node_id
+            }
+
+            result = {
+                "type": "file",
+                "data": result_data,
+                "nodeId": node_id,
+                "timestamp": datetime.now().isoformat()
+            }
+
+            log_execution_time(logger, "file_handler", start_time, time.time())
+
+            return {
+                "success": True,
+                "node_id": node_id,
+                "node_type": "fileHandler",
+                "result": result,
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+        except Exception as e:
+            logger.error("File handler execution failed", node_id=node_id, error=str(e))
+            return {
+                "success": False,
+                "node_id": node_id,
+                "node_type": "fileHandler",
+                "error": str(e),
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }

package/server/services/user_auth.py

@@ -0,0 +1,172 @@
+"""User authentication service with JWT handling."""
+
+import logging
+from datetime import datetime, timezone, timedelta
+from typing import Optional, Dict, Any
+
+from jose import jwt, JWTError
+from sqlmodel import select
+
+from core.config import Settings
+from core.database import Database
+from models.auth import User
+
+logger = logging.getLogger(__name__)
+
+
+class UserAuthService:
+    """Handles user authentication, registration, and JWT token management."""
+
+    def __init__(self, database: Database, settings: Settings):
+        self.database = database
+        self.settings = settings
+        self._algorithm = "HS256"
+
+    async def get_user_count(self) -> int:
+        """Get total number of users."""
+        async with self.database.get_session() as session:
+            result = await session.execute(select(User))
+            return len(result.scalars().all())
+
+    async def get_user_by_email(self, email: str) -> Optional[User]:
+        """Get user by email address."""
+        async with self.database.get_session() as session:
+            result = await session.execute(
+                select(User).where(User.email == email.lower().strip())
+            )
+            return result.scalars().first()
+
+    async def get_user_by_id(self, user_id: int) -> Optional[User]:
+        """Get user by ID."""
+        async with self.database.get_session() as session:
+            result = await session.execute(
+                select(User).where(User.id == user_id)
+            )
+            return result.scalars().first()
+
+    async def can_register(self) -> bool:
+        """Check if registration is allowed based on auth mode."""
+        if self.settings.auth_mode == "multi":
+            return True
+        # Single-owner mode: only allow if no users exist
+        count = await self.get_user_count()
+        return count == 0
+
+    async def register(
+        self, email: str, password: str, display_name: str
+    ) -> tuple[Optional[User], Optional[str]]:
+        """
+        Register a new user.
+        Returns (user, None) on success, (None, error_message) on failure.
+        """
+        # Check if registration is allowed
+        if not await self.can_register():
+            if self.settings.auth_mode == "single":
+                return None, "Registration disabled - owner account already exists"
+            return None, "Registration is currently disabled"
+
+        # Check if email already exists
+        existing = await self.get_user_by_email(email)
+        if existing:
+            return None, "Email already registered"
+
+        # Validate password strength
+        if len(password) < 8:
+            return None, "Password must be at least 8 characters"
+
+        # Determine if this is the owner (first user in single-owner mode)
+        is_owner = self.settings.auth_mode == "single" and await self.get_user_count() == 0
+
+        # Create user
+        user = User.create(
+            email=email,
+            password=password,
+            display_name=display_name,
+            is_owner=is_owner
+        )
+
+        async with self.database.get_session() as session:
+            session.add(user)
+            await session.commit()
+            await session.refresh(user)
+
+        logger.info(f"User registered: {email} (owner={is_owner})")
+        return user, None
+
+    async def login(
+        self, email: str, password: str
+    ) -> tuple[Optional[User], Optional[str]]:
+        """
+        Authenticate user and return user object.
+        Returns (user, None) on success, (None, error_message) on failure.
+        """
+        user = await self.get_user_by_email(email)
+        if not user:
+            return None, "Invalid email or password"
+
+        if not user.is_active:
+            return None, "Account is disabled"
+
+        if not user.verify_password(password):
+            return None, "Invalid email or password"
+
+        # Update last login
+        async with self.database.get_session() as session:
+            result = await session.execute(
+                select(User).where(User.id == user.id)
+            )
+            db_user = result.scalars().first()
+            if db_user:
+                db_user.last_login = datetime.now(timezone.utc)
+                await session.commit()
+
+        logger.info(f"User logged in: {email}")
+        return user, None
+
+    def create_access_token(self, user: User) -> str:
+        """Create JWT access token for user."""
+        expire = datetime.now(timezone.utc) + timedelta(minutes=self.settings.jwt_expire_minutes)
+        payload = {
+            "sub": str(user.id),
+            "email": user.email,
+            "display_name": user.display_name,
+            "is_owner": user.is_owner,
+            "exp": expire,
+            "iat": datetime.now(timezone.utc)
+        }
+        return jwt.encode(payload, self.settings.jwt_secret_key, algorithm=self._algorithm)
+
+    def verify_token(self, token: str) -> Optional[Dict[str, Any]]:
+        """
+        Verify JWT token and return payload.
+        Returns None if token is invalid or expired.
+        """
+        try:
+            payload = jwt.decode(
+                token,
+                self.settings.jwt_secret_key,
+                algorithms=[self._algorithm]
+            )
+            return payload
+        except JWTError as e:
+            logger.debug(f"Token verification failed: {e}")
+            return None
+
+    async def get_current_user(self, token: str) -> Optional[User]:
+        """Get current user from token."""
+        payload = self.verify_token(token)
+        if not payload:
+            return None
+
+        user_id = payload.get("sub")
+        if not user_id:
+            return None
+
+        return await self.get_user_by_id(int(user_id))
+
+    def get_auth_status(self) -> Dict[str, Any]:
+        """Get authentication status and mode info."""
+        return {
+            "auth_mode": self.settings.auth_mode,
+            "registration_enabled": self.settings.auth_mode == "multi"
+        }

package/server/services/websocket_client.py

@@ -0,0 +1,29 @@
+"""
+Android WebSocket Client - DEPRECATED
+
+This module is deprecated. Use services.android instead:
+
+    from services.android import (
+        RelayWebSocketClient,
+        get_relay_client,
+        close_relay_client,
+        get_current_relay_client,
+    )
+
+This file re-exports from the new module for backwards compatibility.
+"""
+
+from services.android import (
+    RelayWebSocketClient,
+    get_relay_client,
+    close_relay_client,
+    get_current_relay_client,
+)
+
+# Re-export for backwards compatibility
+__all__ = [
+    "RelayWebSocketClient",
+    "get_relay_client",
+    "close_relay_client",
+    "get_current_relay_client",
+]