machinaos 0.0.1

package/server/routers/maps.py

@@ -0,0 +1,142 @@
+"""Google Maps service routes."""
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from typing import Dict, Any, Optional
+import httpx
+
+from core.container import container
+from services.maps import MapsService
+from services.status_broadcaster import get_status_broadcaster
+from core.logging import get_logger
+
+logger = get_logger(__name__)
+router = APIRouter(prefix="/python", tags=["maps"])
+
+
+class GoogleMapsRequest(BaseModel):
+    node_id: str
+    node_type: str
+    parameters: Dict[str, Any]
+    api_key: Optional[str] = None
+
+
+class ApiKeyValidationRequest(BaseModel):
+    api_key: str
+
+
+@router.post("/maps/validate-key")
+async def validate_google_maps_key(request: ApiKeyValidationRequest):
+    """Validate Google Maps API key and broadcast status via WebSocket."""
+    broadcaster = get_status_broadcaster()
+
+    try:
+        api_key = request.api_key.strip()
+        if not api_key:
+            await broadcaster.update_api_key_status(
+                provider="google_maps",
+                valid=False,
+                message="API key is required"
+            )
+            raise HTTPException(status_code=400, detail="API key is required")
+
+        # Test the API key with a simple geocoding request
+        async with httpx.AsyncClient() as client:
+            response = await client.get(
+                "https://maps.googleapis.com/maps/api/geocode/json",
+                params={
+                    "address": "1600 Amphitheatre Parkway, Mountain View, CA",
+                    "key": api_key
+                },
+                timeout=10.0
+            )
+
+            data = response.json()
+
+            if data.get("status") == "OK":
+                await broadcaster.update_api_key_status(
+                    provider="google_maps",
+                    valid=True,
+                    message="API key validated successfully"
+                )
+                return {
+                    "success": True,
+                    "valid": True,
+                    "message": "Google Maps API key is valid"
+                }
+            elif data.get("status") == "REQUEST_DENIED":
+                error_msg = data.get("error_message", "Invalid API key")
+                await broadcaster.update_api_key_status(
+                    provider="google_maps",
+                    valid=False,
+                    message=error_msg
+                )
+                return {
+                    "success": True,
+                    "valid": False,
+                    "message": error_msg
+                }
+            else:
+                # Other statuses like ZERO_RESULTS still mean the key works
+                await broadcaster.update_api_key_status(
+                    provider="google_maps",
+                    valid=True,
+                    message="API key validated"
+                )
+                return {
+                    "success": True,
+                    "valid": True,
+                    "message": f"API key is valid (status: {data.get('status')})"
+                }
+
+    except httpx.TimeoutException:
+        await broadcaster.update_api_key_status(
+            provider="google_maps",
+            valid=False,
+            message="Validation request timed out"
+        )
+        raise HTTPException(status_code=504, detail="Validation request timed out")
+    except httpx.RequestError as e:
+        await broadcaster.update_api_key_status(
+            provider="google_maps",
+            valid=False,
+            message=f"Network error: {str(e)}"
+        )
+        raise HTTPException(status_code=503, detail=f"Network error: {str(e)}")
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"API key validation error: {e}")
+        await broadcaster.update_api_key_status(
+            provider="google_maps",
+            valid=False,
+            message=f"Validation failed: {str(e)}"
+        )
+        raise HTTPException(status_code=500, detail=f"Validation failed: {str(e)}")
+
+
+@router.post("/createmap/execute")
+async def execute_createmap_node(
+    request: GoogleMapsRequest,
+    maps_service: MapsService = Depends(lambda: container.maps_service())
+):
+    """Execute Create Map node - Google Maps initialization."""
+    return await maps_service.create_map(request.node_id, request.parameters)
+
+
+@router.post("/addlocations/execute")
+async def execute_addlocations_node(
+    request: GoogleMapsRequest,
+    maps_service: MapsService = Depends(lambda: container.maps_service())
+):
+    """Execute Add Locations node - Google Maps Geocoding."""
+    return await maps_service.geocode_location(request.node_id, request.parameters)
+
+
+@router.post("/shownearbyplaces/execute")
+async def execute_shownearbyplaces_node(
+    request: GoogleMapsRequest,
+    maps_service: MapsService = Depends(lambda: container.maps_service())
+):
+    """Execute Show Nearby Places node - Google Places API."""
+    return await maps_service.find_nearby_places(request.node_id, request.parameters)

package/server/routers/nodejs_compat.py

@@ -0,0 +1,289 @@
+"""Node.js API compatibility routes for seamless migration."""
+
+from datetime import datetime
+from uuid import uuid4
+from fastapi import APIRouter, HTTPException, Depends
+from pydantic import BaseModel
+from typing import Dict, Any, List, Optional
+
+from core.container import container
+from core.database import Database
+from services.workflow import WorkflowService
+from core.logging import get_logger
+
+logger = get_logger(__name__)
+router = APIRouter(tags=["nodejs-compatibility"])
+
+
+# Pydantic models matching Node.js API
+class NodeExecuteRequest(BaseModel):
+    nodeId: str
+    nodeType: str
+    parameters: Optional[Dict[str, Any]] = {}
+    nodes: Optional[List[Dict[str, Any]]] = []
+    edges: Optional[List[Dict[str, Any]]] = []
+
+
+class WorkflowSaveRequest(BaseModel):
+    name: str
+    data: Dict[str, Any]
+
+
+# Health and status endpoints
+@router.get("/")
+async def root():
+    """Node.js compatible root endpoint."""
+    return {
+        "message": "React Flow Project API Server",
+        "status": "running",
+        "version": "2.0.0-python",
+        "endpoints": {
+            "health": "/api/health",
+            "workflows": "/api/workflows",
+            "nodes": "/api/nodes",
+            "execute": "/api/nodes/execute"
+        },
+        "services": {
+            "main": "http://localhost:3010",
+            "python": "http://localhost:3010"
+        },
+        "timestamp": datetime.now().isoformat()
+    }
+
+
+@router.get("/api/health")
+async def health_check():
+    """Node.js compatible health check."""
+    return {
+        "status": "OK",
+        "message": "React Flow Server is running",
+        "timestamp": datetime.now().isoformat()
+    }
+
+
+# Workflow management endpoints
+@router.get("/api/workflows")
+async def get_workflows(database: Database = Depends(lambda: container.database())):
+    """Get all workflows (Node.js compatible)."""
+    try:
+        workflows = await database.get_all_workflows()
+        return {"workflows": workflows}
+    except Exception as e:
+        logger.error("Failed to get workflows", error=str(e))
+        return {"workflows": []}
+
+
+@router.post("/api/workflows")
+async def save_workflow(
+    request: WorkflowSaveRequest,
+    database: Database = Depends(lambda: container.database())
+):
+    """Save workflow (Node.js compatible)."""
+    try:
+        workflow_id = str(int(datetime.now().timestamp() * 1000))  # Node.js style ID
+        success = await database.save_workflow(
+            workflow_id=workflow_id,
+            name=request.name,
+            data=request.data
+        )
+
+        if success:
+            return {
+                "success": True,
+                "id": workflow_id,
+                "message": "Workflow saved successfully"
+            }
+        else:
+            raise HTTPException(status_code=500, detail="Failed to save workflow")
+
+    except Exception as e:
+        logger.error("Failed to save workflow", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/api/workflows/{workflow_id}")
+async def get_workflow(
+    workflow_id: str,
+    database: Database = Depends(lambda: container.database())
+):
+    """Get workflow by ID (Node.js compatible)."""
+    try:
+        workflow = await database.get_workflow(workflow_id)
+
+        if workflow:
+            return {
+                "id": workflow.id,
+                "name": workflow.name,
+                "data": workflow.data
+            }
+        else:
+            return {
+                "id": workflow_id,
+                "name": "Sample Workflow",
+                "data": {"nodes": [], "edges": []}
+            }
+
+    except Exception as e:
+        logger.error("Failed to get workflow", workflow_id=workflow_id, error=str(e))
+        return {
+            "id": workflow_id,
+            "name": "Sample Workflow",
+            "data": {"nodes": [], "edges": []}
+        }
+
+
+# Main execution endpoint - Node.js compatible
+@router.post("/api/nodes/execute")
+async def execute_node(
+    request: NodeExecuteRequest,
+    workflow_service: WorkflowService = Depends(lambda: container.workflow_service())
+):
+    """Execute a single node (Node.js compatible)."""
+    try:
+        if not request.nodeId or not request.nodeType:
+            raise HTTPException(status_code=400, detail="nodeId and nodeType are required")
+
+        execution_id = str(uuid4())
+        logger.info("Executing node", node_id=request.nodeId, execution_id=execution_id)
+
+        # Execute the node using workflow service
+        result = await workflow_service.execute_node(
+            node_id=request.nodeId,
+            node_type=request.nodeType,
+            parameters=request.parameters or {},
+            nodes=request.nodes or [],
+            edges=request.edges or [],
+            session_id="default"
+        )
+
+        # Transform result to match Node.js format
+        if result.get("success"):
+            return {
+                "success": True,
+                "executionId": execution_id,
+                "nodeId": request.nodeId,
+                "nodeType": request.nodeType,
+                "result": result.get("result", {}),
+                "executionTime": result.get("execution_time", 0),
+                "timestamp": result.get("timestamp", datetime.now().isoformat())
+            }
+        else:
+            return {
+                "success": False,
+                "executionId": execution_id,
+                "nodeId": request.nodeId,
+                "nodeType": request.nodeType,
+                "error": result.get("error", "Unknown error"),
+                "executionTime": result.get("execution_time", 0),
+                "timestamp": result.get("timestamp", datetime.now().isoformat())
+            }
+
+    except Exception as e:
+        logger.error("Node execution error", node_id=request.nodeId, error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# Execution status and output endpoints
+@router.get("/api/executions/{execution_id}")
+async def get_execution_status(execution_id: str):
+    """Get execution status (Node.js compatible)."""
+    # For simplicity, return success status
+    # In a full implementation, you'd track execution status
+    return {
+        "success": True,
+        "executionId": execution_id,
+        "status": "completed",
+        "timestamp": datetime.now().isoformat()
+    }
+
+
+@router.get("/api/nodes/{node_id}/output")
+async def get_node_output(
+    node_id: str,
+    workflow_service: WorkflowService = Depends(lambda: container.workflow_service())
+):
+    """Get node output data (Node.js compatible)."""
+    try:
+        result = await workflow_service.get_workflow_node_output(node_id)
+
+        if result.get("success"):
+            return {
+                "success": True,
+                "nodeId": node_id,
+                "output": result.get("data", {})
+            }
+        else:
+            return {
+                "success": False,
+                "nodeId": node_id,
+                "error": result.get("error", "Node output not found")
+            }
+
+    except Exception as e:
+        logger.error("Get node output error", node_id=node_id, error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/api/executions/clear")
+async def clear_execution_cache():
+    """Clear execution cache (Node.js compatible)."""
+    try:
+        # Clear workflow service cache if implemented
+        return {
+            "success": True,
+            "message": "Execution cache cleared"
+        }
+    except Exception as e:
+        logger.error("Clear cache error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# Legacy endpoint for backwards compatibility
+@router.post("/api/execute/{node_id}")
+async def legacy_execute_node(
+    node_id: str,
+    request: Dict[str, Any],
+    workflow_service: WorkflowService = Depends(lambda: container.workflow_service())
+):
+    """Legacy execution endpoint (Node.js compatible)."""
+    try:
+        node_type = request.get("nodeType")
+        if not node_type:
+            raise HTTPException(status_code=400, detail="nodeType is required")
+
+        execution_id = str(uuid4())
+
+        result = await workflow_service.execute_node(
+            node_id=node_id,
+            node_type=node_type,
+            parameters=request.get("parameters", {}),
+            nodes=request.get("nodes", []),
+            edges=request.get("edges", []),
+            session_id="default"
+        )
+
+        # Return in Node.js format
+        if result.get("success"):
+            return {
+                "success": True,
+                "executionId": execution_id,
+                "nodeId": node_id,
+                "nodeType": node_type,
+                "result": result.get("result", {}),
+                "executionTime": result.get("execution_time", 0),
+                "timestamp": result.get("timestamp", datetime.now().isoformat())
+            }
+        else:
+            return {
+                "success": False,
+                "executionId": execution_id,
+                "nodeId": node_id,
+                "nodeType": node_type,
+                "error": result.get("error", "Unknown error"),
+                "executionTime": result.get("execution_time", 0),
+                "timestamp": result.get("timestamp", datetime.now().isoformat())
+            }
+
+    except Exception as e:
+        logger.error("Legacy execution error", node_id=node_id, error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))

package/server/routers/webhook.py

@@ -0,0 +1,90 @@
+"""Dynamic webhook endpoint router for incoming HTTP requests.
+
+Works like WhatsApp trigger - uses broadcaster.send_custom_event() to dispatch
+to event_waiter which resolves waiting trigger nodes.
+"""
+from fastapi import APIRouter, Request, HTTPException, Response
+from fastapi.responses import JSONResponse
+from typing import Dict, Any
+import asyncio
+import logging
+
+from services.status_broadcaster import get_status_broadcaster
+
+logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/webhook", tags=["webhook"])
+
+# Pending responses: path -> asyncio.Future (for responseNode mode)
+_pending_responses: Dict[str, asyncio.Future] = {}
+
+
+def resolve_webhook_response(node_id: str, response_data: dict):
+    """Resolve a pending webhook response.
+
+    Called by webhookResponse node execution to send response back to caller.
+    Uses path from response_data to find the pending Future.
+    """
+    # Find pending response by path (stored when we started waiting)
+    for path, future in list(_pending_responses.items()):
+        if not future.done():
+            future.set_result(response_data)
+            logger.info(f"[Webhook] Response resolved for path: {path}")
+            return
+
+    logger.warning(f"[Webhook] No pending response found for node: {node_id}")
+
+
+@router.api_route("/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH"])
+async def handle_webhook(path: str, request: Request):
+    """Handle incoming webhook requests.
+
+    Dispatches webhook_received event to trigger waiting webhookTrigger nodes.
+    Similar to how WhatsApp events dispatch to whatsappReceive nodes.
+    """
+    # Build webhook request data
+    body = await request.body()
+    json_body = None
+    content_type = request.headers.get("content-type", "")
+
+    if "application/json" in content_type and body:
+        try:
+            json_body = await request.json()
+        except:
+            pass
+
+    webhook_data = {
+        "method": request.method,
+        "path": path,
+        "headers": dict(request.headers),
+        "query": dict(request.query_params),
+        "body": body.decode('utf-8') if isinstance(body, bytes) else (body if body else ""),
+        "json": json_body
+    }
+
+    logger.info(f"[Webhook] Received: {request.method} /webhook/{path}")
+
+    # Dispatch event using broadcaster (same pattern as WhatsApp)
+    broadcaster = get_status_broadcaster()
+    await broadcaster.send_custom_event("webhook_received", webhook_data)
+
+    # For now, always return immediate response
+    # TODO: Support responseNode mode by storing Future and waiting
+    return JSONResponse(
+        content={
+            "status": "received",
+            "path": path,
+            "message": "Webhook received and dispatched to workflow"
+        },
+        status_code=200
+    )
+
+
+@router.get("/")
+async def list_info():
+    """Get webhook endpoint info."""
+    return {
+        "endpoint": "/webhook/{path}",
+        "description": "Send HTTP requests to trigger webhookTrigger nodes",
+        "usage": "Deploy a workflow with webhookTrigger node, then send requests to /webhook/{path}",
+        "example": "POST /webhook/my-webhook with JSON body"
+    }