@almadar/cli 0.3.2 → 1.0.3

package/shells/python-shell/src/orbital_app/core/firebase.py

@@ -0,0 +1,112 @@
+"""
+Firebase Admin SDK Configuration
+
+Supports multiple initialization modes:
+- Emulator mode (FIRESTORE_EMULATOR_HOST)
+- Service account file (FIREBASE_SERVICE_ACCOUNT_PATH)
+- Inline credentials (FIREBASE_PROJECT_ID + CLIENT_EMAIL + PRIVATE_KEY)
+- Application default credentials (Cloud Run, etc.)
+"""
+import os
+from typing import Optional
+import firebase_admin
+from firebase_admin import credentials, auth, firestore
+
+
+_app: Optional[firebase_admin.App] = None
+
+
+def _get_env(key: str, default: str = "") -> str:
+    """Get environment variable with default."""
+    return os.environ.get(key, default)
+
+
+def initialize_firebase() -> firebase_admin.App:
+    """
+    Initialize Firebase Admin SDK.
+
+    Returns the Firebase app instance, initializing if needed.
+    """
+    global _app
+
+    if _app is not None:
+        return _app
+
+    # Check if already initialized
+    if firebase_admin._apps:
+        _app = firebase_admin.get_app()
+        return _app
+
+    project_id = _get_env("FIREBASE_PROJECT_ID", "demo-project")
+    emulator_host = _get_env("FIRESTORE_EMULATOR_HOST")
+    service_account_path = _get_env("FIREBASE_SERVICE_ACCOUNT_PATH")
+    client_email = _get_env("FIREBASE_CLIENT_EMAIL")
+    private_key = _get_env("FIREBASE_PRIVATE_KEY")
+
+    # Check for emulator mode FIRST (no credentials needed)
+    if emulator_host:
+        _app = firebase_admin.initialize_app(options={"projectId": project_id})
+        print(f"Firebase Admin initialized for emulator: {emulator_host}")
+        return _app
+
+    # Production mode - need credentials
+    if service_account_path:
+        # Use service account file
+        cred = credentials.Certificate(service_account_path)
+        _app = firebase_admin.initialize_app(cred, {"projectId": project_id})
+    elif project_id and client_email and private_key:
+        # Use inline service account credentials
+        cred = credentials.Certificate(
+            {
+                "type": "service_account",
+                "project_id": project_id,
+                "client_email": client_email,
+                "private_key": private_key.replace("\\n", "\n"),
+                # These are required but can be empty for auth verification
+                "private_key_id": "",
+                "client_id": "",
+                "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+                "token_uri": "https://oauth2.googleapis.com/token",
+            }
+        )
+        _app = firebase_admin.initialize_app(cred, {"projectId": project_id})
+    elif project_id:
+        # Use application default credentials (for Cloud Run, etc.)
+        _app = firebase_admin.initialize_app(
+            credentials.ApplicationDefault(), {"projectId": project_id}
+        )
+    else:
+        # Fallback to demo project (emulator-like mode)
+        _app = firebase_admin.initialize_app(options={"projectId": "demo-project"})
+
+    return _app
+
+
+def get_auth() -> auth.Client:
+    """Get Firebase Auth client."""
+    initialize_firebase()
+    return auth
+
+
+def get_firestore() -> firestore.Client:
+    """Get Firestore client."""
+    initialize_firebase()
+    return firestore.client()
+
+
+def verify_id_token(token: str) -> dict:
+    """
+    Verify a Firebase ID token.
+
+    Args:
+        token: The Firebase ID token to verify
+
+    Returns:
+        Decoded token claims including uid, email, etc.
+
+    Raises:
+        firebase_admin.auth.InvalidIdTokenError: If token is invalid
+        firebase_admin.auth.ExpiredIdTokenError: If token is expired
+    """
+    initialize_firebase()
+    return auth.verify_id_token(token)

package/shells/python-shell/src/orbital_app/core/repository.py

@@ -0,0 +1,257 @@
+"""
+Repository - Database abstraction layer.
+
+Supports multiple backends:
+- In-memory (for testing/development)
+- Firestore (Firebase)
+- SQLite (planned)
+- PostgreSQL (planned)
+"""
+from typing import Dict, Any, List, Optional
+from abc import ABC, abstractmethod
+import uuid
+
+from .firebase import get_firestore
+
+
+class Repository(ABC):
+    """Abstract repository interface."""
+
+    @abstractmethod
+    async def get(self, entity_type: str, entity_id: str) -> Optional[Dict[str, Any]]:
+        """Get a single entity by ID."""
+        pass
+
+    @abstractmethod
+    async def list(
+        self,
+        entity_type: str,
+        filter_expr: Any = None,
+        context: Dict[str, Any] = None,
+    ) -> List[Dict[str, Any]]:
+        """List entities with optional filtering."""
+        pass
+
+    @abstractmethod
+    async def create(self, entity_type: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create a new entity."""
+        pass
+
+    @abstractmethod
+    async def update(
+        self, entity_type: str, entity_id: str, data: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Update an existing entity."""
+        pass
+
+    @abstractmethod
+    async def delete(self, entity_type: str, entity_id: str) -> bool:
+        """Delete an entity."""
+        pass
+
+
+class InMemoryRepository(Repository):
+    """In-memory repository for testing and development."""
+
+    def __init__(self):
+        self._store: Dict[str, Dict[str, Dict[str, Any]]] = {}
+
+    async def get(self, entity_type: str, entity_id: str) -> Optional[Dict[str, Any]]:
+        """Get a single entity by ID."""
+        return self._store.get(entity_type, {}).get(entity_id)
+
+    async def list(
+        self,
+        entity_type: str,
+        filter_expr: Any = None,
+        context: Dict[str, Any] = None,
+    ) -> List[Dict[str, Any]]:
+        """List entities with optional filtering."""
+        entities = list(self._store.get(entity_type, {}).values())
+
+        # Apply simple filter if provided
+        if filter_expr and context:
+            entities = self._apply_filter(entities, filter_expr, context)
+
+        return entities
+
+    async def create(self, entity_type: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create a new entity."""
+        entity_id = data.get("id") or str(uuid.uuid4())
+        data = {**data, "id": entity_id}
+
+        if entity_type not in self._store:
+            self._store[entity_type] = {}
+        self._store[entity_type][entity_id] = data
+
+        return data
+
+    async def update(
+        self, entity_type: str, entity_id: str, data: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Update an existing entity (upsert - creates if not exists)."""
+        if entity_type not in self._store:
+            self._store[entity_type] = {}
+
+        if entity_id in self._store[entity_type]:
+            # Update existing
+            self._store[entity_type][entity_id].update(data)
+        else:
+            # Create new (upsert)
+            self._store[entity_type][entity_id] = {**data, "id": entity_id}
+
+        return self._store[entity_type][entity_id]
+
+    async def delete(self, entity_type: str, entity_id: str) -> bool:
+        """Delete an entity."""
+        if entity_type in self._store and entity_id in self._store[entity_type]:
+            del self._store[entity_type][entity_id]
+            return True
+        return False
+
+    def _apply_filter(
+        self,
+        entities: List[Dict[str, Any]],
+        filter_expr: Any,
+        context: Dict[str, Any],
+    ) -> List[Dict[str, Any]]:
+        """Apply a simple S-expression filter."""
+        if not filter_expr or not isinstance(filter_expr, list):
+            return entities
+
+        op = filter_expr[0]
+
+        if op == "=":
+            field_path = filter_expr[1]
+            expected_value = filter_expr[2]
+
+            # Resolve field path (e.g., "@entity.status")
+            if isinstance(field_path, str) and field_path.startswith("@entity."):
+                field_name = field_path.replace("@entity.", "")
+                return [e for e in entities if e.get(field_name) == expected_value]
+
+        return entities
+
+    def seed(self, entity_type: str, entities: List[Dict[str, Any]]):
+        """Seed the repository with test data."""
+        if entity_type not in self._store:
+            self._store[entity_type] = {}
+        for entity in entities:
+            entity_id = entity.get("id") or str(uuid.uuid4())
+            entity["id"] = entity_id
+            self._store[entity_type][entity_id] = entity
+
+
+class FirestoreRepository(Repository):
+    """
+    Firestore repository for production use.
+
+    Uses Firebase Admin SDK to interact with Cloud Firestore.
+    Entity types map to Firestore collections.
+    """
+
+    def __init__(self):
+        self._db = None
+
+    @property
+    def db(self):
+        """Lazy-load Firestore client."""
+        if self._db is None:
+            self._db = get_firestore()
+        return self._db
+
+    async def get(self, entity_type: str, entity_id: str) -> Optional[Dict[str, Any]]:
+        """Get a single entity by ID from Firestore."""
+        doc_ref = self.db.collection(entity_type).document(entity_id)
+        doc = doc_ref.get()
+
+        if doc.exists:
+            data = doc.to_dict()
+            data["id"] = doc.id
+            return data
+        return None
+
+    async def list(
+        self,
+        entity_type: str,
+        filter_expr: Any = None,
+        context: Dict[str, Any] = None,
+    ) -> List[Dict[str, Any]]:
+        """List entities from Firestore with optional filtering."""
+        collection_ref = self.db.collection(entity_type)
+
+        # Apply S-expression filter if provided
+        if filter_expr and context:
+            collection_ref = self._apply_filter(collection_ref, filter_expr, context)
+
+        docs = collection_ref.stream()
+        entities = []
+        for doc in docs:
+            data = doc.to_dict()
+            data["id"] = doc.id
+            entities.append(data)
+
+        return entities
+
+    async def create(self, entity_type: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create a new entity in Firestore."""
+        entity_id = data.get("id") or str(uuid.uuid4())
+
+        # Remove id from data to avoid duplication (id is the document key)
+        doc_data = {k: v for k, v in data.items() if k != "id"}
+
+        doc_ref = self.db.collection(entity_type).document(entity_id)
+        doc_ref.set(doc_data)
+
+        return {**doc_data, "id": entity_id}
+
+    async def update(
+        self, entity_type: str, entity_id: str, data: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Update an existing entity in Firestore."""
+        # Remove id from update data
+        update_data = {k: v for k, v in data.items() if k != "id"}
+
+        doc_ref = self.db.collection(entity_type).document(entity_id)
+        doc_ref.update(update_data)
+
+        # Return the updated document
+        updated_doc = doc_ref.get()
+        if updated_doc.exists:
+            result = updated_doc.to_dict()
+            result["id"] = updated_doc.id
+            return result
+        return {**update_data, "id": entity_id}
+
+    async def delete(self, entity_type: str, entity_id: str) -> bool:
+        """Delete an entity from Firestore."""
+        doc_ref = self.db.collection(entity_type).document(entity_id)
+
+        # Check if document exists before deleting
+        if doc_ref.get().exists:
+            doc_ref.delete()
+            return True
+        return False
+
+    def _apply_filter(self, collection_ref, filter_expr: Any, context: Dict[str, Any]):
+        """
+        Apply S-expression filter to Firestore query.
+
+        Supports basic equality filters like:
+        (= @entity.status "active")
+        """
+        if not filter_expr or not isinstance(filter_expr, list):
+            return collection_ref
+
+        op = filter_expr[0]
+
+        if op == "=":
+            field_path = filter_expr[1]
+            expected_value = filter_expr[2]
+
+            # Resolve field path (e.g., "@entity.status" -> "status")
+            if isinstance(field_path, str) and field_path.startswith("@entity."):
+                field_name = field_path.replace("@entity.", "")
+                return collection_ref.where(field_name, "==", expected_value)
+
+        return collection_ref

package/shells/python-shell/src/orbital_app/core/settings.py

@@ -0,0 +1,74 @@
+"""
+Application Settings - Environment configuration using pydantic-settings.
+
+Loads configuration from environment variables and .env files.
+"""
+from typing import List, Optional
+from functools import lru_cache
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    """
+    Application settings loaded from environment variables.
+
+    Environment variables take precedence over .env file values.
+    """
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore",
+    )
+
+    # Server Configuration
+    port: int = 8000
+    environment: str = "development"
+
+    # Firebase Configuration
+    firebase_project_id: Optional[str] = None
+    firebase_client_email: Optional[str] = None
+    firebase_private_key: Optional[str] = None
+    firebase_service_account_path: Optional[str] = None
+    firestore_emulator_host: Optional[str] = None
+
+    # CORS Configuration
+    cors_origins: str = "http://localhost:3000,http://localhost:5173"
+
+    # External Service API Keys
+    openai_api_key: Optional[str] = None
+    anthropic_api_key: Optional[str] = None
+    gemini_api_key: Optional[str] = None
+    youtube_api_key: Optional[str] = None
+    stripe_secret_key: Optional[str] = None
+
+    @property
+    def cors_origins_list(self) -> List[str]:
+        """Parse CORS origins from comma-separated string."""
+        return [origin.strip() for origin in self.cors_origins.split(",")]
+
+    @property
+    def is_production(self) -> bool:
+        """Check if running in production mode."""
+        return self.environment.lower() == "production"
+
+    @property
+    def is_development(self) -> bool:
+        """Check if running in development mode."""
+        return self.environment.lower() == "development"
+
+    @property
+    def is_emulator(self) -> bool:
+        """Check if using Firebase emulator."""
+        return bool(self.firestore_emulator_host)
+
+
+@lru_cache
+def get_settings() -> Settings:
+    """
+    Get cached settings instance.
+
+    Uses lru_cache to ensure settings are only loaded once.
+    """
+    return Settings()

package/shells/python-shell/src/orbital_app/core/websocket.py

@@ -0,0 +1,202 @@
+"""
+WebSocket Connection Manager
+
+Manages WebSocket connections for real-time updates across the application.
+Supports broadcasting client effects to connected frontends.
+"""
+from fastapi import WebSocket
+from typing import Dict, List, Any, Optional
+import json
+import asyncio
+
+
+def make_json_serializable(obj: Any) -> Any:
+    """Convert PyTorch tensors and other non-serializable types to JSON-serializable Python types."""
+    # Handle PyTorch types
+    try:
+        import torch
+        import torch.nn as nn
+        # Handle nn.Module (neural network modules) - convert to string representation
+        if isinstance(obj, nn.Module):
+            return f"<{obj.__class__.__name__}>"
+        # Handle tensors
+        if isinstance(obj, torch.Tensor):
+            # Convert tensor to Python list or scalar
+            if obj.dim() == 0:
+                return obj.item()
+            return obj.tolist()
+    except ImportError:
+        pass
+
+    # Handle numpy arrays
+    try:
+        import numpy as np
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        if isinstance(obj, (np.int64, np.int32, np.float64, np.float32)):
+            return obj.item()
+    except ImportError:
+        pass
+
+    # Handle dictionaries recursively
+    if isinstance(obj, dict):
+        return {k: make_json_serializable(v) for k, v in obj.items()}
+
+    # Handle lists recursively
+    if isinstance(obj, list):
+        return [make_json_serializable(item) for item in obj]
+
+    # Handle tuples
+    if isinstance(obj, tuple):
+        return [make_json_serializable(item) for item in obj]
+
+    # Return as-is for other types
+    return obj
+
+
+class ConnectionManager:
+    """Manages WebSocket connections and message broadcasting."""
+
+    def __init__(self):
+        # Map of entity_type -> entity_id -> list of connections
+        self.active_connections: Dict[str, Dict[str, List[WebSocket]]] = {}
+        # Global connections (receive all updates)
+        self.global_connections: List[WebSocket] = []
+        # Lock for thread-safe operations
+        self._lock = asyncio.Lock()
+
+    async def connect(
+        self,
+        websocket: WebSocket,
+        entity_type: Optional[str] = None,
+        entity_id: Optional[str] = None,
+    ):
+        """Accept a new WebSocket connection.
+
+        Args:
+            websocket: The WebSocket connection
+            entity_type: Optional entity type to subscribe to
+            entity_id: Optional entity ID to subscribe to
+        """
+        await websocket.accept()
+
+        async with self._lock:
+            if entity_type and entity_id:
+                # Subscribe to specific entity
+                if entity_type not in self.active_connections:
+                    self.active_connections[entity_type] = {}
+                if entity_id not in self.active_connections[entity_type]:
+                    self.active_connections[entity_type][entity_id] = []
+                self.active_connections[entity_type][entity_id].append(websocket)
+            else:
+                # Global subscription
+                self.global_connections.append(websocket)
+
+    async def disconnect(
+        self,
+        websocket: WebSocket,
+        entity_type: Optional[str] = None,
+        entity_id: Optional[str] = None,
+    ):
+        """Remove a WebSocket connection."""
+        async with self._lock:
+            if entity_type and entity_id:
+                if (
+                    entity_type in self.active_connections
+                    and entity_id in self.active_connections[entity_type]
+                ):
+                    connections = self.active_connections[entity_type][entity_id]
+                    if websocket in connections:
+                        connections.remove(websocket)
+                    # Clean up empty lists
+                    if not connections:
+                        del self.active_connections[entity_type][entity_id]
+                    if not self.active_connections[entity_type]:
+                        del self.active_connections[entity_type]
+            else:
+                if websocket in self.global_connections:
+                    self.global_connections.remove(websocket)
+
+    async def broadcast_to_entity(
+        self,
+        entity_type: str,
+        entity_id: str,
+        message: Dict[str, Any],
+    ):
+        """Broadcast a message to all connections subscribed to an entity."""
+        connections_to_notify: List[WebSocket] = []
+
+        async with self._lock:
+            # Get entity-specific connections
+            if (
+                entity_type in self.active_connections
+                and entity_id in self.active_connections[entity_type]
+            ):
+                connections_to_notify.extend(
+                    self.active_connections[entity_type][entity_id]
+                )
+            # Also notify global connections
+            connections_to_notify.extend(self.global_connections)
+
+        # Send to all connections outside the lock
+        await self._send_to_connections(connections_to_notify, message)
+
+    async def broadcast_global(self, message: Dict[str, Any]):
+        """Broadcast a message to all global connections."""
+        async with self._lock:
+            connections = list(self.global_connections)
+
+        await self._send_to_connections(connections, message)
+
+    async def broadcast_client_effects(
+        self,
+        entity_type: str,
+        entity_id: str,
+        event: str,
+        client_effects: List[Any],
+        data: Optional[Dict[str, Any]] = None,
+    ):
+        """Broadcast client effects from an event to relevant connections.
+
+        This is the main method called after processing an event.
+        """
+        message = {
+            "type": "client_effects",
+            "entityType": entity_type,
+            "entityId": entity_id,
+            "event": event,
+            "effects": client_effects,
+            "data": data or {},
+        }
+        await self.broadcast_to_entity(entity_type, entity_id, message)
+
+    async def _send_to_connections(
+        self, connections: List[WebSocket], message: Dict[str, Any]
+    ):
+        """Send a message to multiple connections, handling failures."""
+        # Convert any PyTorch tensors or numpy arrays to JSON-serializable types
+        serializable_message = make_json_serializable(message)
+        json_message = json.dumps(serializable_message)
+        disconnected: List[WebSocket] = []
+
+        for connection in connections:
+            try:
+                await connection.send_text(json_message)
+            except Exception:
+                disconnected.append(connection)
+
+        # Remove disconnected websockets
+        if disconnected:
+            async with self._lock:
+                for ws in disconnected:
+                    if ws in self.global_connections:
+                        self.global_connections.remove(ws)
+                    for entity_type in self.active_connections:
+                        for entity_id in self.active_connections[entity_type]:
+                            connections = self.active_connections[entity_type][entity_id]
+                            if ws in connections:
+                                connections.remove(ws)
+
+
+# Global connection manager instance
+connection_manager = ConnectionManager()