machinaos 0.0.1

package/server/routers/android.py

@@ -0,0 +1,294 @@
+"""Android System Services routes."""
+
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel, Field
+from typing import Dict, Any, Optional
+
+from core.container import container
+from services.android_service import AndroidService
+from core.logging import get_logger
+
+logger = get_logger(__name__)
+router = APIRouter(prefix="/api/android", tags=["android"])
+
+
+class AndroidServiceRequest(BaseModel):
+    """Request model for Android service execution."""
+    service_id: str = Field(..., description="Android service ID (e.g., 'battery', 'network', 'app_launcher')")
+    action: str = Field(..., description="Service action to perform (e.g., 'status', 'launch', 'list')")
+    parameters: Dict[str, Any] = Field(default_factory=dict, description="Action-specific parameters")
+    android_host: str = Field(default="localhost", description="Android device API host")
+    android_port: int = Field(default=8888, description="Android device API port")
+
+
+@router.post("/execute")
+async def execute_android_service(
+    request: AndroidServiceRequest,
+    android_service: AndroidService = Depends(lambda: container.android_service())
+):
+    """Execute an Android system service action.
+
+    Examples:
+    - Battery status: {"service_id": "battery", "action": "status"}
+    - Launch app: {"service_id": "app_launcher", "action": "launch", "parameters": {"package_name": "com.android.settings"}}
+    - List apps: {"service_id": "app_list", "action": "list", "parameters": {"include_system": false}}
+    """
+    logger.info(
+        "[Android API] Executing service",
+        service_id=request.service_id,
+        action=request.action,
+        android_host=request.android_host,
+        android_port=request.android_port
+    )
+
+    result = await android_service.execute_service(
+        node_id="api_call",
+        service_id=request.service_id,
+        action=request.action,
+        parameters=request.parameters,
+        android_host=request.android_host,
+        android_port=request.android_port
+    )
+
+    return result
+
+
+@router.get("/status")
+async def check_device_status(
+    android_host: str = "localhost",
+    android_port: int = 8888,
+    android_service: AndroidService = Depends(lambda: container.android_service())
+):
+    """Check if Android device API is reachable."""
+    logger.info(
+        "[Android API] Checking device status",
+        android_host=android_host,
+        android_port=android_port
+    )
+
+    status = await android_service.check_device_status(
+        android_host=android_host,
+        android_port=android_port
+    )
+
+    return status
+
+
+@router.get("/services/{service_id}/actions")
+async def get_service_actions(
+    service_id: str,
+    android_service: AndroidService = Depends(lambda: container.android_service())
+):
+    """Get available actions for a specific Android service.
+
+    Returns list of action options that can be performed on the service.
+    """
+    logger.info(f"[Android API] Getting actions for service: {service_id}")
+
+    actions = android_service.get_service_actions(service_id)
+
+    if not actions:
+        return {
+            "success": False,
+            "error": f"Unknown service: {service_id}",
+            "actions": []
+        }
+
+    return {
+        "success": True,
+        "service_id": service_id,
+        "actions": actions
+    }
+
+
+@router.get("/services/{service_id}/actions/{action}/parameters")
+async def get_action_parameters(
+    service_id: str,
+    action: str,
+    android_service: AndroidService = Depends(lambda: container.android_service())
+):
+    """Get default parameters for a specific service action.
+
+    Returns default parameter template that can be used as a starting point.
+    """
+    logger.info(f"[Android API] Getting parameters for: {service_id}/{action}")
+
+    default_params = android_service.get_default_parameters(service_id, action)
+
+    return {
+        "success": True,
+        "service_id": service_id,
+        "action": action,
+        "default_parameters": default_params
+    }
+
+
+@router.get("/devices")
+async def list_android_devices():
+    """List all connected Android devices via ADB."""
+    import subprocess
+    try:
+        # Run adb devices command
+        result = subprocess.run(
+            ["adb", "devices", "-l"],
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=5
+        )
+
+        devices = []
+        lines = result.stdout.strip().split('\n')[1:]  # Skip header "List of devices attached"
+
+        for line in lines:
+            if not line.strip():
+                continue
+
+            parts = line.split()
+            if len(parts) >= 2:
+                device_id = parts[0]
+                state = parts[1]
+
+                # Extract model and other info
+                model = "Unknown"
+                android_version = None
+
+                for part in parts[2:]:
+                    if part.startswith("model:"):
+                        model = part.split(":")[1]
+                    elif part.startswith("device:"):
+                        pass  # Can use this for device codename
+
+                devices.append({
+                    "id": device_id,
+                    "state": state,
+                    "model": model,
+                    "android_version": android_version
+                })
+
+        return {
+            "success": True,
+            "devices": devices,
+            "count": len(devices)
+        }
+    except FileNotFoundError:
+        logger.error("[Android] ADB not found in PATH")
+        return {
+            "success": False,
+            "error": "ADB not found. Please install Android SDK Platform Tools",
+            "devices": []
+        }
+    except Exception as e:
+        logger.error(f"[Android] Failed to list devices: {e}")
+        return {
+            "success": False,
+            "error": str(e),
+            "devices": []
+        }
+
+
+@router.post("/port-forward")
+async def setup_port_forwarding(
+    device_id: str,
+    local_port: int = 8888,
+    device_port: int = 8888
+):
+    """Setup ADB port forwarding for Android device communication."""
+    import subprocess
+    try:
+        # Setup port forwarding: adb -s device_id forward tcp:local_port tcp:device_port
+        cmd = ["adb", "-s", device_id, "forward", f"tcp:{local_port}", f"tcp:{device_port}"]
+
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=5
+        )
+
+        if result.returncode == 0:
+            logger.info(
+                f"[Android] Port forwarding setup: {device_id} tcp:{local_port} -> tcp:{device_port}"
+            )
+            return {
+                "success": True,
+                "device_id": device_id,
+                "local_port": local_port,
+                "device_port": device_port,
+                "message": f"Port forwarding active: localhost:{local_port} -> device:{device_port}"
+            }
+        else:
+            error_msg = result.stderr.strip() or result.stdout.strip()
+            logger.error(f"[Android] Port forwarding failed: {error_msg}")
+            return {
+                "success": False,
+                "error": error_msg
+            }
+    except FileNotFoundError:
+        logger.error("[Android] ADB not found in PATH")
+        return {
+            "success": False,
+            "error": "ADB not found. Please install Android SDK Platform Tools"
+        }
+    except Exception as e:
+        logger.error(f"[Android] Port forwarding error: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+
+@router.get("/health")
+async def android_health_check():
+    """Android service health check."""
+    return {
+        "status": "OK",
+        "service": "android"
+    }
+
+
+@router.get("/relay-status")
+async def get_relay_connection_status():
+    """Get relay connection status for remote Android devices.
+
+    Returns connection status including whether a relay connection is active
+    and the paired Android device.
+    """
+    try:
+        from services.android import get_current_relay_client
+
+        relay_client = get_current_relay_client()
+
+        if relay_client and relay_client.is_connected():
+            return {
+                "success": True,
+                "connected": True,
+                "paired": relay_client.is_paired(),
+                "connection_type": "relay",
+                "device_id": relay_client.paired_device_id,
+                "device_name": relay_client.paired_device_name,
+                "session_token": relay_client.session_token,
+                "qr_data": relay_client.qr_data if not relay_client.is_paired() else None,
+                "status": "paired" if relay_client.is_paired() else "waiting_for_pairing"
+            }
+        else:
+            return {
+                "success": True,
+                "connected": False,
+                "paired": False,
+                "connection_type": None,
+                "device_id": None,
+                "device_name": None,
+                "status": "disconnected"
+            }
+    except Exception as e:
+        logger.error(f"[Android] Failed to get relay status: {e}")
+        return {
+            "success": False,
+            "connected": False,
+            "error": str(e),
+            "status": "error"
+        }

package/server/routers/auth.py

@@ -0,0 +1,203 @@
+"""Authentication routes for user login, registration, and session management."""
+
+from fastapi import APIRouter, Depends, HTTPException, Response, Request
+from pydantic import BaseModel, EmailStr
+from typing import Optional
+
+from core.container import container
+from core.config import Settings
+from core.logging import get_logger
+from services.user_auth import UserAuthService
+
+logger = get_logger(__name__)
+router = APIRouter(prefix="/api/auth", tags=["auth"])
+
+
+class RegisterRequest(BaseModel):
+    email: EmailStr
+    password: str
+    display_name: str
+
+
+class LoginRequest(BaseModel):
+    email: EmailStr
+    password: str
+
+
+class UserResponse(BaseModel):
+    id: int
+    email: str
+    display_name: str
+    is_owner: bool
+
+
+def get_user_auth_service() -> UserAuthService:
+    return container.user_auth_service()
+
+
+def get_settings() -> Settings:
+    return container.settings()
+
+
+@router.get("/status")
+async def get_auth_status(
+    request: Request,
+    user_auth: UserAuthService = Depends(get_user_auth_service),
+    settings: Settings = Depends(get_settings)
+):
+    """
+    Get authentication status.
+    Returns auth mode and current user if authenticated.
+    """
+    status = user_auth.get_auth_status()
+
+    # Check if user has a valid session
+    token = request.cookies.get(settings.jwt_cookie_name)
+    current_user = None
+
+    if token:
+        user = await user_auth.get_current_user(token)
+        if user:
+            current_user = {
+                "id": user.id,
+                "email": user.email,
+                "display_name": user.display_name,
+                "is_owner": user.is_owner
+            }
+
+    # Check if registration is available
+    can_register = await user_auth.can_register()
+
+    return {
+        "auth_mode": status["auth_mode"],
+        "authenticated": current_user is not None,
+        "user": current_user,
+        "can_register": can_register
+    }
+
+
+@router.post("/register")
+async def register(
+    request: RegisterRequest,
+    response: Response,
+    user_auth: UserAuthService = Depends(get_user_auth_service),
+    settings: Settings = Depends(get_settings)
+):
+    """
+    Register a new user.
+    In single-owner mode, only the first user can register.
+    In multi-user mode, anyone can register.
+    """
+    user, error = await user_auth.register(
+        email=request.email,
+        password=request.password,
+        display_name=request.display_name
+    )
+
+    if error:
+        raise HTTPException(status_code=400, detail=error)
+
+    # Create token and set cookie
+    token = user_auth.create_access_token(user)
+    response.set_cookie(
+        key=settings.jwt_cookie_name,
+        value=token,
+        httponly=True,
+        secure=settings.jwt_cookie_secure,
+        samesite=settings.jwt_cookie_samesite,
+        max_age=settings.jwt_expire_minutes * 60
+    )
+
+    return {
+        "success": True,
+        "user": {
+            "id": user.id,
+            "email": user.email,
+            "display_name": user.display_name,
+            "is_owner": user.is_owner
+        }
+    }
+
+
+@router.post("/login")
+async def login(
+    request: LoginRequest,
+    response: Response,
+    user_auth: UserAuthService = Depends(get_user_auth_service),
+    settings: Settings = Depends(get_settings)
+):
+    """
+    Login with email and password.
+    Sets HttpOnly cookie with JWT token.
+    """
+    user, error = await user_auth.login(
+        email=request.email,
+        password=request.password
+    )
+
+    if error:
+        raise HTTPException(status_code=401, detail=error)
+
+    # Create token and set cookie
+    token = user_auth.create_access_token(user)
+    response.set_cookie(
+        key=settings.jwt_cookie_name,
+        value=token,
+        httponly=True,
+        secure=settings.jwt_cookie_secure,
+        samesite=settings.jwt_cookie_samesite,
+        max_age=settings.jwt_expire_minutes * 60
+    )
+
+    return {
+        "success": True,
+        "user": {
+            "id": user.id,
+            "email": user.email,
+            "display_name": user.display_name,
+            "is_owner": user.is_owner
+        }
+    }
+
+
+@router.post("/logout")
+async def logout(
+    response: Response,
+    settings: Settings = Depends(get_settings)
+):
+    """
+    Logout by clearing the auth cookie.
+    """
+    response.delete_cookie(
+        key=settings.jwt_cookie_name,
+        httponly=True,
+        secure=settings.jwt_cookie_secure,
+        samesite=settings.jwt_cookie_samesite
+    )
+    return {"success": True}
+
+
+@router.get("/me")
+async def get_current_user(
+    request: Request,
+    user_auth: UserAuthService = Depends(get_user_auth_service),
+    settings: Settings = Depends(get_settings)
+):
+    """
+    Get current authenticated user.
+    Requires valid session cookie.
+    """
+    token = request.cookies.get(settings.jwt_cookie_name)
+    if not token:
+        raise HTTPException(status_code=401, detail="Not authenticated")
+
+    user = await user_auth.get_current_user(token)
+    if not user:
+        raise HTTPException(status_code=401, detail="Invalid or expired session")
+
+    return {
+        "id": user.id,
+        "email": user.email,
+        "display_name": user.display_name,
+        "is_owner": user.is_owner
+    }

package/server/routers/database.py

@@ -0,0 +1,151 @@
+"""Database operations routes (replaces frontend storage)."""
+
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel
+from typing import Dict, Any, Optional, List
+
+from core.container import container
+from core.database import Database
+from core.logging import get_logger
+
+logger = get_logger(__name__)
+router = APIRouter(prefix="/api/database", tags=["database"])
+
+
+class NodeParameterRequest(BaseModel):
+    node_id: str
+    parameters: Dict[str, Any]
+
+
+class WorkflowSaveRequest(BaseModel):
+    workflow_id: str
+    name: str
+    data: Dict[str, Any]
+
+
+@router.post("/node-parameters")
+async def save_node_parameters(
+    request: NodeParameterRequest,
+    database: Database = Depends(lambda: container.database())
+):
+    """Save node parameters (replaces frontend Dexie)."""
+    try:
+        success = await database.save_node_parameters(request.node_id, request.parameters)
+        return {"success": success}
+    except Exception as e:
+        logger.error("Failed to save node parameters", error=str(e))
+        return {"success": False, "error": str(e)}
+
+
+@router.get("/node-parameters/{node_id}")
+async def get_node_parameters(
+    node_id: str,
+    database: Database = Depends(lambda: container.database())
+):
+    """Get node parameters (replaces frontend Dexie)."""
+    try:
+        parameters = await database.get_node_parameters(node_id)
+        return {"success": True, "parameters": parameters}
+    except Exception as e:
+        logger.error("Failed to get node parameters", error=str(e))
+        return {"success": False, "error": str(e)}
+
+
+@router.delete("/node-parameters/{node_id}")
+async def delete_node_parameters(
+    node_id: str,
+    database: Database = Depends(lambda: container.database())
+):
+    """Delete node parameters (replaces frontend Dexie)."""
+    try:
+        success = await database.delete_node_parameters(node_id)
+        return {"success": success}
+    except Exception as e:
+        logger.error("Failed to delete node parameters", error=str(e))
+        return {"success": False, "error": str(e)}
+
+
+# ============================================================================
+# Workflow Operations
+# ============================================================================
+
+@router.post("/workflows")
+async def save_workflow(
+    request: WorkflowSaveRequest,
+    database: Database = Depends(lambda: container.database())
+):
+    """Save workflow to database."""
+    try:
+        success = await database.save_workflow(
+            workflow_id=request.workflow_id,
+            name=request.name,
+            data=request.data
+        )
+        return {"success": success, "workflow_id": request.workflow_id}
+    except Exception as e:
+        logger.error("Failed to save workflow", error=str(e))
+        return {"success": False, "error": str(e)}
+
+
+@router.get("/workflows")
+async def get_all_workflows(
+    database: Database = Depends(lambda: container.database())
+):
+    """Get all workflows."""
+    try:
+        workflows = await database.get_all_workflows()
+        return {
+            "success": True,
+            "workflows": [
+                {
+                    "id": w.id,
+                    "name": w.name,
+                    "nodeCount": len(w.data.get("nodes", [])) if w.data else 0,
+                    "createdAt": w.created_at.isoformat() if w.created_at else None,
+                    "lastModified": w.updated_at.isoformat() if w.updated_at else None
+                }
+                for w in workflows
+            ]
+        }
+    except Exception as e:
+        logger.error("Failed to get workflows", error=str(e))
+        return {"success": False, "error": str(e)}
+
+
+@router.get("/workflows/{workflow_id}")
+async def get_workflow(
+    workflow_id: str,
+    database: Database = Depends(lambda: container.database())
+):
+    """Get workflow by ID."""
+    try:
+        workflow = await database.get_workflow(workflow_id)
+        if workflow:
+            return {
+                "success": True,
+                "workflow": {
+                    "id": workflow.id,
+                    "name": workflow.name,
+                    "data": workflow.data,
+                    "createdAt": workflow.created_at.isoformat() if workflow.created_at else None,
+                    "lastModified": workflow.updated_at.isoformat() if workflow.updated_at else None
+                }
+            }
+        return {"success": False, "error": "Workflow not found"}
+    except Exception as e:
+        logger.error("Failed to get workflow", error=str(e))
+        return {"success": False, "error": str(e)}
+
+
+@router.delete("/workflows/{workflow_id}")
+async def delete_workflow(
+    workflow_id: str,
+    database: Database = Depends(lambda: container.database())
+):
+    """Delete workflow."""
+    try:
+        success = await database.delete_workflow(workflow_id)
+        return {"success": success, "workflow_id": workflow_id}
+    except Exception as e:
+        logger.error("Failed to delete workflow", error=str(e))
+        return {"success": False, "error": str(e)}