machinaos 0.0.1 → 0.0.6

package/server/services/auth.py

@@ -1,131 +1,131 @@
-"""Simple API key management service."""
-
-import hashlib
-import base64
-from datetime import datetime, timedelta, timezone
-from typing import Dict, Any, Optional, List
-
-from core.config import Settings
-from core.database import Database
-from core.cache import CacheService
-from core.logging import get_logger
-
-logger = get_logger(__name__)
-
-
-class AuthService:
-    """Simple API key management service."""
-
-    def __init__(self, database: Database, cache: CacheService, settings: Settings):
-        self.database = database
-        self.cache = cache
-        self.settings = settings
-
-    def encrypt_api_key(self, api_key: str) -> str:
-        """Simple base64 encoding (compatible with frontend)."""
-        return base64.b64encode(api_key.encode()).decode()
-
-    def decrypt_api_key(self, encrypted_key: str) -> str:
-        """Simple base64 decoding."""
-        try:
-            return base64.b64decode(encrypted_key.encode()).decode()
-        except Exception:
-            return ""
-
-    def hash_api_key(self, api_key: str) -> str:
-        """Create hash for API key identification."""
-        return hashlib.sha256(api_key.encode()).hexdigest()[:16]
-
-    async def store_api_key(self, provider: str, api_key: str, models: List[str],
-                          session_id: str = "default") -> bool:
-        """Store API key with models."""
-        try:
-            key_id = f"{session_id}_{provider}"
-            encrypted_key = self.encrypt_api_key(api_key)
-            key_hash = self.hash_api_key(api_key)
-
-            logger.info(f"Storing API key for provider: {provider}, session: {session_id}, key_id: {key_id}")
-
-            # Store in database
-            success = await self.database.save_api_key(
-                key_id=key_id,
-                provider=provider,
-                session_id=session_id,
-                key_encrypted=encrypted_key,
-                key_hash=key_hash,
-                models=models
-            )
-
-            logger.info(f"Database save result: {success}")
-
-            # Cache for quick access
-            if success:
-                cache_data = {
-                    "encrypted_key": encrypted_key,
-                    "models": models,
-                    "last_validated": datetime.utcnow().isoformat()
-                }
-                await self.cache.cache_api_key(provider, session_id, cache_data)
-                logger.info(f"Cached API key for {provider}")
-
-            return success
-
-        except Exception as e:
-            logger.error("Failed to store API key", provider=provider, error=str(e))
-            return False
-
-    async def get_api_key(self, provider: str, session_id: str = "default") -> Optional[str]:
-        """Get decrypted API key."""
-        try:
-            # Try cache first
-            cached_data = await self.cache.get_cached_api_key(provider, session_id)
-            if cached_data:
-                return self.decrypt_api_key(cached_data["encrypted_key"])
-
-            # Fallback to database
-            api_key_record = await self.database.get_api_key_by_provider(provider, session_id)
-            if api_key_record and api_key_record.is_valid:
-                # Check if not expired (30 days)
-                if datetime.now(timezone.utc) - api_key_record.last_validated < timedelta(days=30):
-                    return self.decrypt_api_key(api_key_record.key_encrypted)
-
-            return None
-
-        except Exception as e:
-            logger.error("Failed to get API key", provider=provider, error=str(e))
-            return None
-
-    async def get_stored_models(self, provider: str, session_id: str = "default") -> List[str]:
-        """Get stored models for provider."""
-        try:
-            # Try cache first
-            cached_data = await self.cache.get_cached_api_key(provider, session_id)
-            if cached_data and cached_data.get("models"):
-                return cached_data["models"]
-
-            # Fallback to database
-            api_key_record = await self.database.get_api_key_by_provider(provider, session_id)
-            if api_key_record and api_key_record.models:
-                return api_key_record.models.get("models", [])
-
-            return []
-
-        except Exception as e:
-            logger.error("Failed to get stored models", provider=provider, error=str(e))
-            return []
-
-    async def remove_api_key(self, provider: str, session_id: str = "default") -> bool:
-        """Remove API key."""
-        try:
-            # Remove from cache and database
-            await self.cache.remove_cached_api_key(provider, session_id)
-            return await self.database.delete_api_key(provider, session_id)
-
-        except Exception as e:
-            logger.error("Failed to remove API key", provider=provider, error=str(e))
-            return False
-
-    async def has_valid_key(self, provider: str, session_id: str = "default") -> bool:
-        """Check if valid API key exists."""
-        api_key = await self.get_api_key(provider, session_id)
+"""Simple API key management service."""
+
+import hashlib
+import base64
+from datetime import datetime, timedelta, timezone
+from typing import Dict, Any, Optional, List
+
+from core.config import Settings
+from core.database import Database
+from core.cache import CacheService
+from core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class AuthService:
+    """Simple API key management service."""
+
+    def __init__(self, database: Database, cache: CacheService, settings: Settings):
+        self.database = database
+        self.cache = cache
+        self.settings = settings
+
+    def encrypt_api_key(self, api_key: str) -> str:
+        """Simple base64 encoding (compatible with frontend)."""
+        return base64.b64encode(api_key.encode()).decode()
+
+    def decrypt_api_key(self, encrypted_key: str) -> str:
+        """Simple base64 decoding."""
+        try:
+            return base64.b64decode(encrypted_key.encode()).decode()
+        except Exception:
+            return ""
+
+    def hash_api_key(self, api_key: str) -> str:
+        """Create hash for API key identification."""
+        return hashlib.sha256(api_key.encode()).hexdigest()[:16]
+
+    async def store_api_key(self, provider: str, api_key: str, models: List[str],
+                          session_id: str = "default") -> bool:
+        """Store API key with models."""
+        try:
+            key_id = f"{session_id}_{provider}"
+            encrypted_key = self.encrypt_api_key(api_key)
+            key_hash = self.hash_api_key(api_key)
+
+            logger.info(f"Storing API key for provider: {provider}, session: {session_id}, key_id: {key_id}")
+
+            # Store in database
+            success = await self.database.save_api_key(
+                key_id=key_id,
+                provider=provider,
+                session_id=session_id,
+                key_encrypted=encrypted_key,
+                key_hash=key_hash,
+                models=models
+            )
+
+            logger.info(f"Database save result: {success}")
+
+            # Cache for quick access
+            if success:
+                cache_data = {
+                    "encrypted_key": encrypted_key,
+                    "models": models,
+                    "last_validated": datetime.utcnow().isoformat()
+                }
+                await self.cache.cache_api_key(provider, session_id, cache_data)
+                logger.info(f"Cached API key for {provider}")
+
+            return success
+
+        except Exception as e:
+            logger.error("Failed to store API key", provider=provider, error=str(e))
+            return False
+
+    async def get_api_key(self, provider: str, session_id: str = "default") -> Optional[str]:
+        """Get decrypted API key."""
+        try:
+            # Try cache first
+            cached_data = await self.cache.get_cached_api_key(provider, session_id)
+            if cached_data:
+                return self.decrypt_api_key(cached_data["encrypted_key"])
+
+            # Fallback to database
+            api_key_record = await self.database.get_api_key_by_provider(provider, session_id)
+            if api_key_record and api_key_record.is_valid:
+                # Check if not expired (30 days)
+                if datetime.now(timezone.utc) - api_key_record.last_validated < timedelta(days=30):
+                    return self.decrypt_api_key(api_key_record.key_encrypted)
+
+            return None
+
+        except Exception as e:
+            logger.error("Failed to get API key", provider=provider, error=str(e))
+            return None
+
+    async def get_stored_models(self, provider: str, session_id: str = "default") -> List[str]:
+        """Get stored models for provider."""
+        try:
+            # Try cache first
+            cached_data = await self.cache.get_cached_api_key(provider, session_id)
+            if cached_data and cached_data.get("models"):
+                return cached_data["models"]
+
+            # Fallback to database
+            api_key_record = await self.database.get_api_key_by_provider(provider, session_id)
+            if api_key_record and api_key_record.models:
+                return api_key_record.models.get("models", [])
+
+            return []
+
+        except Exception as e:
+            logger.error("Failed to get stored models", provider=provider, error=str(e))
+            return []
+
+    async def remove_api_key(self, provider: str, session_id: str = "default") -> bool:
+        """Remove API key."""
+        try:
+            # Remove from cache and database
+            await self.cache.remove_cached_api_key(provider, session_id)
+            return await self.database.delete_api_key(provider, session_id)
+
+        except Exception as e:
+            logger.error("Failed to remove API key", provider=provider, error=str(e))
+            return False
+
+    async def has_valid_key(self, provider: str, session_id: str = "default") -> bool:
+        """Check if valid API key exists."""
+        api_key = await self.get_api_key(provider, session_id)
         return api_key is not None

package/server/services/chat_client.py

@@ -1,160 +1,160 @@
-"""
-Chat WebSocket Client - JSON-RPC 2.0 Protocol
-
-Simple client for chat backend. Uses aiohttp (already in project).
-Connection URL: ws://{host}:{port}/ws/{sessionId}?api_key={apiKey}&client_type=web
-"""
-
-import asyncio
-import json
-import uuid
-import aiohttp
-from typing import Optional, Dict, Any
-import structlog
-
-logger = structlog.get_logger()
-
-
-async def send_chat_message(
-    host: str,
-    port: int,
-    session_id: str,
-    api_key: str,
-    content: str,
-    metadata: Optional[Dict[str, Any]] = None,
-    timeout: float = 10.0
-) -> Dict[str, Any]:
-    """Send a chat message via JSON-RPC 2.0 WebSocket.
-
-    Args:
-        host: Chat server host
-        port: Chat server port
-        session_id: Session identifier
-        api_key: API key for authentication
-        content: Message content
-        metadata: Optional message metadata
-        timeout: Request timeout in seconds
-
-    Returns:
-        JSON-RPC result or error dict
-    """
-    url = f"ws://{host}:{port}/ws/{session_id}?api_key={api_key}&client_type=web"
-    request_id = str(uuid.uuid4())
-
-    request = {
-        "jsonrpc": "2.0",
-        "method": "chat.sendMessage",
-        "params": {"content": content, **(metadata or {})},
-        "id": request_id
-    }
-
-    try:
-        async with aiohttp.ClientSession() as session:
-            async with session.ws_connect(url, timeout=timeout) as ws:
-                await ws.send_json(request)
-
-                # Wait for response with matching id
-                async with asyncio.timeout(timeout):
-                    async for msg in ws:
-                        if msg.type == aiohttp.WSMsgType.TEXT:
-                            data = json.loads(msg.data)
-                            if data.get("id") == request_id:
-                                if "error" in data:
-                                    return {"success": False, "error": data["error"].get("message", "Unknown error")}
-                                return {"success": True, "result": data.get("result", {})}
-                        elif msg.type in (aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.ERROR):
-                            break
-
-        return {"success": False, "error": "No response received"}
-
-    except asyncio.TimeoutError:
-        return {"success": False, "error": "Connection timeout"}
-    except Exception as e:
-        logger.error("[Chat] Send error", error=str(e))
-        return {"success": False, "error": str(e)}
-
-
-async def get_chat_history(
-    host: str,
-    port: int,
-    session_id: str,
-    api_key: str,
-    limit: int = 50,
-    timeout: float = 10.0
-) -> Dict[str, Any]:
-    """Get chat history via JSON-RPC 2.0 WebSocket.
-
-    Args:
-        host: Chat server host
-        port: Chat server port
-        session_id: Session identifier
-        api_key: API key for authentication
-        limit: Max messages to return
-        timeout: Request timeout in seconds
-
-    Returns:
-        JSON-RPC result with messages or error dict
-    """
-    url = f"ws://{host}:{port}/ws/{session_id}?api_key={api_key}&client_type=web"
-    request_id = str(uuid.uuid4())
-
-    request = {
-        "jsonrpc": "2.0",
-        "method": "chat.getHistory",
-        "params": {"limit": limit},
-        "id": request_id
-    }
-
-    try:
-        async with aiohttp.ClientSession() as session:
-            async with session.ws_connect(url, timeout=timeout) as ws:
-                await ws.send_json(request)
-
-                async with asyncio.timeout(timeout):
-                    async for msg in ws:
-                        if msg.type == aiohttp.WSMsgType.TEXT:
-                            data = json.loads(msg.data)
-                            if data.get("id") == request_id:
-                                if "error" in data:
-                                    return {"success": False, "error": data["error"].get("message", "Unknown error")}
-                                return {"success": True, "messages": data.get("result", {}).get("messages", [])}
-                        elif msg.type in (aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.ERROR):
-                            break
-
-        return {"success": False, "error": "No response received"}
-
-    except asyncio.TimeoutError:
-        return {"success": False, "error": "Connection timeout"}
-    except Exception as e:
-        logger.error("[Chat] History error", error=str(e))
-        return {"success": False, "error": str(e)}
-
-
-async def ping_chat_server(
-    host: str,
-    port: int,
-    session_id: str,
-    api_key: str,
-    timeout: float = 5.0
-) -> bool:
-    """Ping chat server to check connectivity."""
-    url = f"ws://{host}:{port}/ws/{session_id}?api_key={api_key}&client_type=web"
-    request_id = str(uuid.uuid4())
-
-    try:
-        async with aiohttp.ClientSession() as session:
-            async with session.ws_connect(url, timeout=timeout) as ws:
-                await ws.send_json({"jsonrpc": "2.0", "method": "ping", "params": {}, "id": request_id})
-
-                async with asyncio.timeout(timeout):
-                    async for msg in ws:
-                        if msg.type == aiohttp.WSMsgType.TEXT:
-                            data = json.loads(msg.data)
-                            if data.get("id") == request_id:
-                                return "error" not in data
-                        elif msg.type in (aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.ERROR):
-                            break
-        return False
-
-    except Exception:
-        return False
+"""
+Chat WebSocket Client - JSON-RPC 2.0 Protocol
+
+Simple client for chat backend. Uses aiohttp (already in project).
+Connection URL: ws://{host}:{port}/ws/{sessionId}?api_key={apiKey}&client_type=web
+"""
+
+import asyncio
+import json
+import uuid
+import aiohttp
+from typing import Optional, Dict, Any
+import structlog
+
+logger = structlog.get_logger()
+
+
+async def send_chat_message(
+    host: str,
+    port: int,
+    session_id: str,
+    api_key: str,
+    content: str,
+    metadata: Optional[Dict[str, Any]] = None,
+    timeout: float = 10.0
+) -> Dict[str, Any]:
+    """Send a chat message via JSON-RPC 2.0 WebSocket.
+
+    Args:
+        host: Chat server host
+        port: Chat server port
+        session_id: Session identifier
+        api_key: API key for authentication
+        content: Message content
+        metadata: Optional message metadata
+        timeout: Request timeout in seconds
+
+    Returns:
+        JSON-RPC result or error dict
+    """
+    url = f"ws://{host}:{port}/ws/{session_id}?api_key={api_key}&client_type=web"
+    request_id = str(uuid.uuid4())
+
+    request = {
+        "jsonrpc": "2.0",
+        "method": "chat.sendMessage",
+        "params": {"content": content, **(metadata or {})},
+        "id": request_id
+    }
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.ws_connect(url, timeout=timeout) as ws:
+                await ws.send_json(request)
+
+                # Wait for response with matching id
+                async with asyncio.timeout(timeout):
+                    async for msg in ws:
+                        if msg.type == aiohttp.WSMsgType.TEXT:
+                            data = json.loads(msg.data)
+                            if data.get("id") == request_id:
+                                if "error" in data:
+                                    return {"success": False, "error": data["error"].get("message", "Unknown error")}
+                                return {"success": True, "result": data.get("result", {})}
+                        elif msg.type in (aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.ERROR):
+                            break
+
+        return {"success": False, "error": "No response received"}
+
+    except asyncio.TimeoutError:
+        return {"success": False, "error": "Connection timeout"}
+    except Exception as e:
+        logger.error("[Chat] Send error", error=str(e))
+        return {"success": False, "error": str(e)}
+
+
+async def get_chat_history(
+    host: str,
+    port: int,
+    session_id: str,
+    api_key: str,
+    limit: int = 50,
+    timeout: float = 10.0
+) -> Dict[str, Any]:
+    """Get chat history via JSON-RPC 2.0 WebSocket.
+
+    Args:
+        host: Chat server host
+        port: Chat server port
+        session_id: Session identifier
+        api_key: API key for authentication
+        limit: Max messages to return
+        timeout: Request timeout in seconds
+
+    Returns:
+        JSON-RPC result with messages or error dict
+    """
+    url = f"ws://{host}:{port}/ws/{session_id}?api_key={api_key}&client_type=web"
+    request_id = str(uuid.uuid4())
+
+    request = {
+        "jsonrpc": "2.0",
+        "method": "chat.getHistory",
+        "params": {"limit": limit},
+        "id": request_id
+    }
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.ws_connect(url, timeout=timeout) as ws:
+                await ws.send_json(request)
+
+                async with asyncio.timeout(timeout):
+                    async for msg in ws:
+                        if msg.type == aiohttp.WSMsgType.TEXT:
+                            data = json.loads(msg.data)
+                            if data.get("id") == request_id:
+                                if "error" in data:
+                                    return {"success": False, "error": data["error"].get("message", "Unknown error")}
+                                return {"success": True, "messages": data.get("result", {}).get("messages", [])}
+                        elif msg.type in (aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.ERROR):
+                            break
+
+        return {"success": False, "error": "No response received"}
+
+    except asyncio.TimeoutError:
+        return {"success": False, "error": "Connection timeout"}
+    except Exception as e:
+        logger.error("[Chat] History error", error=str(e))
+        return {"success": False, "error": str(e)}
+
+
+async def ping_chat_server(
+    host: str,
+    port: int,
+    session_id: str,
+    api_key: str,
+    timeout: float = 5.0
+) -> bool:
+    """Ping chat server to check connectivity."""
+    url = f"ws://{host}:{port}/ws/{session_id}?api_key={api_key}&client_type=web"
+    request_id = str(uuid.uuid4())
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.ws_connect(url, timeout=timeout) as ws:
+                await ws.send_json({"jsonrpc": "2.0", "method": "ping", "params": {}, "id": request_id})
+
+                async with asyncio.timeout(timeout):
+                    async for msg in ws:
+                        if msg.type == aiohttp.WSMsgType.TEXT:
+                            data = json.loads(msg.data)
+                            if data.get("id") == request_id:
+                                return "error" not in data
+                        elif msg.type in (aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.ERROR):
+                            break
+        return False
+
+    except Exception:
+        return False