machinaos 0.0.1

package/server/services/auth.py

@@ -0,0 +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)
+        return api_key is not None

package/server/services/chat_client.py

@@ -0,0 +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

package/server/services/deployment/__init__.py

@@ -0,0 +1,12 @@
+"""Deployment module - Event-driven workflow deployment."""
+
+from .state import DeploymentState, TriggerInfo
+from .triggers import TriggerManager
+from .manager import DeploymentManager
+
+__all__ = [
+    "DeploymentState",
+    "TriggerInfo",
+    "TriggerManager",
+    "DeploymentManager",
+]