machinaos 0.0.1 → 0.0.7

package/server/services/text.py

@@ -1,111 +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()
+"""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

@@ -1,172 +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"
-        }
+"""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

@@ -1,29 +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",
-]
+"""
+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",
+]