machinaos 0.0.1

package/server/services/handlers/ai.py

@@ -0,0 +1,355 @@
+"""AI node handlers - AI Agent, Chat Agent, AI Chat Model, Simple Memory."""
+
+from typing import Dict, Any, List, Optional, TYPE_CHECKING
+from core.logging import get_logger
+from constants import ANDROID_SERVICE_NODE_TYPES
+
+if TYPE_CHECKING:
+    from services.ai import AIService
+    from core.database import Database
+
+logger = get_logger(__name__)
+
+
+async def handle_ai_agent(
+    node_id: str,
+    node_type: str,
+    parameters: Dict[str, Any],
+    context: Dict[str, Any],
+    ai_service: "AIService",
+    database: "Database"
+) -> Dict[str, Any]:
+    """Handle AI agent node execution with memory and tool support.
+
+    Args:
+        node_id: The node ID
+        node_type: The node type (aiAgent)
+        parameters: Resolved parameters
+        context: Execution context with nodes, edges, session_id, start_time, execution_id
+        ai_service: The AI service instance
+        database: The database instance
+
+    Returns:
+        Execution result dict
+    """
+    nodes = context.get('nodes')
+    edges = context.get('edges')
+    execution_id = context.get('execution_id', 'unknown')
+    workflow_id = context.get('workflow_id')  # Extract for status broadcasts
+    memory_data = None
+    tool_data: List[Dict[str, Any]] = []  # Collect connected tool nodes
+
+    logger.info(f"[AI Agent] Processing node {node_id}, edges={len(edges) if edges else 0}, nodes={len(nodes) if nodes else 0}, workflow_id={workflow_id}")
+
+    if edges and nodes:
+        # Log all edges targeting this AI Agent for debugging
+        incoming_edges = [e for e in edges if e.get('target') == node_id]
+        logger.info(f"[AI Agent] Incoming edges to {node_id}: {len(incoming_edges)}")
+        for e in incoming_edges:
+            logger.info(f"[AI Agent] Edge: source={e.get('source')}, targetHandle={e.get('targetHandle')}")
+
+        # Check for tool edges specifically
+        tool_incoming = [e for e in incoming_edges if e.get('targetHandle') == 'input-tools']
+        logger.info(f"[AI Agent] Tool edges (input-tools handle): {len(tool_incoming)}")
+
+        for edge in edges:
+            if edge.get('target') != node_id:
+                continue
+
+            target_handle = edge.get('targetHandle')
+            source_node_id = edge.get('source')
+            source_node = next((n for n in nodes if n.get('id') == source_node_id), None)
+
+            if not source_node:
+                continue
+
+            # Memory detection - load markdown content for editing
+            if target_handle == 'input-memory':
+                if source_node.get('type') == 'simpleMemory':
+                    memory_params = await database.get_node_parameters(source_node_id) or {}
+                    memory_session_id = memory_params.get('sessionId', 'default')
+                    window_size = int(memory_params.get('windowSize', 10))
+                    memory_content = memory_params.get('memoryContent', '# Conversation History\n\n*No messages yet.*\n')
+                    long_term_enabled = memory_params.get('longTermEnabled', False)
+                    retrieval_count = int(memory_params.get('retrievalCount', 3))
+
+                    memory_data = {
+                        'node_id': source_node_id,  # For saving updated content
+                        'session_id': memory_session_id,
+                        'window_size': window_size,
+                        'memory_content': memory_content,
+                        'long_term_enabled': long_term_enabled,
+                        'retrieval_count': retrieval_count
+                    }
+                    logger.debug("AI Agent connected memory node", memory_session=memory_session_id, content_length=len(memory_content))
+
+            # Tool detection (new) - any node connected to input-tools becomes a tool
+            elif target_handle == 'input-tools':
+                tool_type = source_node.get('type')
+                logger.info(f"[AI Agent] Found tool connected via input-tools: type={tool_type}, node_id={source_node_id}")
+                tool_params = await database.get_node_parameters(source_node_id) or {}
+
+                # Build base tool entry
+                tool_entry = {
+                    'node_id': source_node_id,
+                    'node_type': tool_type,
+                    'parameters': tool_params,
+                    'label': source_node.get('data', {}).get('label', tool_type)
+                }
+
+                # Special handling for androidTool - discover connected Android services
+                # Follows n8n Sub-Node pattern
+                if tool_type == 'androidTool':
+                    connected_services = []
+
+                    # Scan edges for Android nodes connected to this toolkit
+                    for service_edge in edges:
+                        # Skip if not targeting this androidTool node
+                        if service_edge.get('target') != source_node_id:
+                            continue
+
+                        target_handle = service_edge.get('targetHandle')
+                        # Accept input-main or no handle (ReactFlow may omit handle for single-input nodes)
+                        if target_handle is not None and target_handle != 'input-main':
+                            logger.debug(f"[Android Toolkit] Skipping edge with targetHandle: {target_handle}")
+                            continue
+
+                        android_node_id = service_edge.get('source')
+                        android_node = next((n for n in nodes if n.get('id') == android_node_id), None)
+
+                        if android_node and android_node.get('type') in ANDROID_SERVICE_NODE_TYPES:
+                            android_params = await database.get_node_parameters(android_node_id) or {}
+                            connected_services.append({
+                                'node_id': android_node_id,
+                                'node_type': android_node.get('type'),
+                                'service_id': android_params.get('service_id'),
+                                'action': android_params.get('action'),  # Default action
+                                'parameters': android_params,
+                                'label': android_node.get('data', {}).get('label', android_node.get('type'))
+                            })
+                            logger.debug(f"Android toolkit connected service: {android_params.get('service_id')}")
+
+                    tool_entry['connected_services'] = connected_services
+                    logger.debug(f"Android toolkit has {len(connected_services)} connected services")
+
+                tool_data.append(tool_entry)
+                logger.debug(f"AI Agent connected tool: {tool_type}")
+
+    # Log tool data collection results
+    logger.info(f"[AI Agent Handler] Collected tools: count={len(tool_data)}, workflow_id={workflow_id}")
+    for td in tool_data:
+        logger.info(f"[AI Agent Handler] Tool: type={td.get('node_type')}, node_id={td.get('node_id')}")
+
+    # Get broadcaster for real-time status updates
+    from services.status_broadcaster import get_status_broadcaster
+    broadcaster = get_status_broadcaster()
+
+    return await ai_service.execute_agent(
+        node_id,
+        parameters,
+        memory_data=memory_data,
+        tool_data=tool_data if tool_data else None,
+        broadcaster=broadcaster,
+        workflow_id=workflow_id
+    )
+
+
+async def handle_chat_agent(
+    node_id: str,
+    node_type: str,
+    parameters: Dict[str, Any],
+    context: Dict[str, Any],
+    ai_service: "AIService",
+    database: "Database"
+) -> Dict[str, Any]:
+    """Handle Chat Agent node execution with skill-based tool calling.
+
+    Chat Agent supports:
+    - Memory (input-memory): SimpleMemory node for conversation history
+    - Skills (input-skill): Provide context/instructions via SKILL.md
+    - Tools (input-tools): Tool nodes (httpRequest, etc.) for LangGraph tool calling
+
+    Args:
+        node_id: The node ID
+        node_type: The node type (chatAgent)
+        parameters: Resolved parameters
+        context: Execution context with nodes, edges, session_id, start_time, execution_id
+        ai_service: The AI service instance
+        database: The database instance
+
+    Returns:
+        Execution result dict
+    """
+    nodes = context.get('nodes')
+    edges = context.get('edges')
+    workflow_id = context.get('workflow_id')
+    memory_data = None
+    skill_data: List[Dict[str, Any]] = []
+    tool_data: List[Dict[str, Any]] = []  # Tools for LangGraph
+    input_data: Optional[Dict[str, Any]] = None
+
+    logger.info(f"[Chat Agent] Processing node {node_id}, workflow_id={workflow_id}")
+
+    if edges and nodes:
+        incoming_edges = [e for e in edges if e.get('target') == node_id]
+        logger.debug(f"[Chat Agent] Incoming edges: {len(incoming_edges)}")
+
+        for edge in edges:
+            if edge.get('target') != node_id:
+                continue
+
+            target_handle = edge.get('targetHandle')
+            source_node_id = edge.get('source')
+            source_node = next((n for n in nodes if n.get('id') == source_node_id), None)
+
+            if not source_node:
+                continue
+
+            # Memory detection - load markdown content (same as AI Agent)
+            if target_handle == 'input-memory':
+                if source_node.get('type') == 'simpleMemory':
+                    memory_params = await database.get_node_parameters(source_node_id) or {}
+                    memory_session_id = memory_params.get('sessionId', 'default')
+                    window_size = int(memory_params.get('windowSize', 10))
+                    memory_content = memory_params.get('memoryContent', '# Conversation History\n\n*No messages yet.*\n')
+                    long_term_enabled = memory_params.get('longTermEnabled', False)
+                    retrieval_count = int(memory_params.get('retrievalCount', 3))
+
+                    memory_data = {
+                        'node_id': source_node_id,
+                        'session_id': memory_session_id,
+                        'window_size': window_size,
+                        'memory_content': memory_content,
+                        'long_term_enabled': long_term_enabled,
+                        'retrieval_count': retrieval_count
+                    }
+                    logger.info(f"[Chat Agent] Connected memory node: session={memory_session_id}, content_length={len(memory_content)}")
+
+            # Skill detection - nodes connected to input-skill handle
+            elif target_handle == 'input-skill':
+                skill_type = source_node.get('type')
+                skill_params = await database.get_node_parameters(source_node_id) or {}
+                skill_entry = {
+                    'node_id': source_node_id,
+                    'node_type': skill_type,
+                    'skill_name': skill_params.get('skillName', skill_type),
+                    'parameters': skill_params,
+                    'label': source_node.get('data', {}).get('label', skill_type)
+                }
+                skill_data.append(skill_entry)
+                logger.debug(f"[Chat Agent] Connected skill: {skill_type}")
+
+            # Tool detection - nodes connected to input-tools handle (for LangGraph)
+            elif target_handle == 'input-tools':
+                tool_type = source_node.get('type')
+                tool_params = await database.get_node_parameters(source_node_id) or {}
+                tool_entry = {
+                    'node_id': source_node_id,
+                    'node_type': tool_type,
+                    'parameters': tool_params,
+                    'label': source_node.get('data', {}).get('label', tool_type)
+                }
+                tool_data.append(tool_entry)
+                logger.info(f"[Chat Agent] Connected tool: {tool_type} ({tool_entry['label']})")
+
+            # Input data detection - nodes connected to input-main
+            elif target_handle == 'input-main' or target_handle is None:
+                source_output = context.get('outputs', {}).get(source_node_id)
+                if source_output:
+                    input_data = source_output
+                    logger.debug(f"[Chat Agent] Input from {source_node.get('type')}: {list(source_output.keys())}")
+
+    # Log discovered connections
+    logger.info(f"[Chat Agent] Discovered: memory={'yes' if memory_data else 'no'}, {len(skill_data)} skills, {len(tool_data)} tools")
+    for td in tool_data:
+        logger.debug(f"[Chat Agent] Tool: type={td.get('node_type')}, label={td.get('label')}")
+
+    # Auto-use input data if prompt is empty (fallback for trigger nodes)
+    if not parameters.get('prompt') and input_data:
+        prompt = (
+            input_data.get('message') or
+            input_data.get('text') or
+            input_data.get('content') or
+            str(input_data)
+        )
+        parameters = {**parameters, 'prompt': prompt}
+        logger.info(f"[Chat Agent] Auto-using input as prompt: {prompt[:100] if len(str(prompt)) > 100 else prompt}...")
+
+    # Get broadcaster for real-time status updates
+    from services.status_broadcaster import get_status_broadcaster
+    broadcaster = get_status_broadcaster()
+
+    # Execute Chat Agent with memory, skills and tools
+    return await ai_service.execute_chat_agent(
+        node_id,
+        parameters,
+        memory_data=memory_data,
+        skill_data=skill_data if skill_data else None,
+        tool_data=tool_data if tool_data else None,
+        broadcaster=broadcaster,
+        workflow_id=workflow_id
+    )
+
+
+async def handle_ai_chat_model(
+    node_id: str,
+    node_type: str,
+    parameters: Dict[str, Any],
+    context: Dict[str, Any],
+    ai_service: "AIService"
+) -> Dict[str, Any]:
+    """Handle AI chat model node execution.
+
+    Args:
+        node_id: The node ID
+        node_type: The node type (openaiChatModel, anthropicChatModel, etc.)
+        parameters: Resolved parameters
+        context: Execution context
+        ai_service: The AI service instance
+
+    Returns:
+        Execution result dict
+    """
+    return await ai_service.execute_chat(node_id, node_type, parameters)
+
+
+async def handle_simple_memory(
+    node_id: str,
+    node_type: str,
+    parameters: Dict[str, Any],
+    context: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Handle simple memory node execution.
+
+    Args:
+        node_id: The node ID
+        node_type: The node type (simpleMemory)
+        parameters: Resolved parameters
+        context: Execution context
+
+    Returns:
+        Execution result dict with session info and messages
+    """
+    from services.memory_store import get_messages, clear_session
+
+    session_id = parameters.get('sessionId', 'default')
+    memory_type = parameters.get('memoryType', 'buffer')
+    window_size = int(parameters.get('windowSize', 10)) if memory_type == 'window' else None
+    clear_on_run = parameters.get('clearOnRun', False)
+
+    if clear_on_run:
+        cleared = clear_session(session_id)
+        logger.info(f"[Memory] Cleared {cleared} messages from session '{session_id}'")
+
+    messages = get_messages(session_id, window_size)
+
+    return {
+        "success": True,
+        "result": {
+            "session_id": session_id,
+            "messages": messages,
+            "message_count": len(messages),
+            "memory_type": memory_type,
+            "window_size": window_size
+        }
+    }

package/server/services/handlers/android.py

@@ -0,0 +1,260 @@
+"""Android node handlers - Device Setup and Android Services."""
+
+import json
+import time
+from datetime import datetime
+from typing import Dict, Any, TYPE_CHECKING
+from core.logging import get_logger
+from constants import ANDROID_SERVICE_NODE_TYPES
+
+if TYPE_CHECKING:
+    from services.android_service import AndroidService
+    from core.config import Settings
+
+logger = get_logger(__name__)
+
+
+async def handle_android_device_setup(
+    node_id: str,
+    node_type: str,
+    parameters: Dict[str, Any],
+    context: Dict[str, Any],
+    settings: "Settings"
+) -> Dict[str, Any]:
+    """Handle Android device setup node execution.
+
+    Supports two connection types:
+    - local: ADB connection with port forwarding
+    - remote: WebSocket connection to remote proxy
+
+    Args:
+        node_id: The node ID
+        node_type: The node type (androidDeviceSetup)
+        parameters: Resolved parameters
+        context: Execution context with start_time
+        settings: Application settings
+
+    Returns:
+        Execution result dict with connection info
+    """
+    start_time = context.get('start_time', time.time())
+    connection_type = parameters.get('connection_type', 'local')
+    device_id = parameters.get('device_id', '')
+    websocket_url = parameters.get('websocket_url', settings.websocket_url)
+    port = parameters.get('port', 8888)
+    auto_forward = parameters.get('auto_forward', True)
+
+    logger.info("[Android Device Setup] Executing", node_id=node_id, connection_type=connection_type,
+               device_id=device_id, websocket_url=websocket_url, port=port, auto_forward=auto_forward)
+
+    if connection_type == 'local' and auto_forward and device_id:
+        # Local ADB connection with port forwarding
+        import subprocess
+        try:
+            cmd = ["adb", "-s", device_id, "forward", f"tcp:{port}", f"tcp:{port}"]
+            subprocess_result = subprocess.run(cmd, capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=5)
+
+            if subprocess_result.returncode == 0:
+                connection_info = {
+                    "connection_type": "local",
+                    "device_id": device_id,
+                    "port": port,
+                    "port_forwarding": "active",
+                    "local_endpoint": f"http://localhost:{port}",
+                    "message": f"Port forwarding setup: localhost:{port} -> device:{port}",
+                    "timestamp": datetime.now().isoformat()
+                }
+                return {
+                    "success": True,
+                    "node_id": node_id,
+                    "node_type": node_type,
+                    "result": connection_info,
+                    "execution_time": time.time() - start_time,
+                    "timestamp": datetime.now().isoformat()
+                }
+            else:
+                error_msg = subprocess_result.stderr.strip() or subprocess_result.stdout.strip()
+                return {
+                    "success": False,
+                    "node_id": node_id,
+                    "node_type": node_type,
+                    "error": f"Port forwarding failed: {error_msg}",
+                    "execution_time": time.time() - start_time,
+                    "timestamp": datetime.now().isoformat()
+                }
+        except Exception as e:
+            return {
+                "success": False,
+                "node_id": node_id,
+                "node_type": node_type,
+                "error": f"Port forwarding error: {str(e)}",
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+    elif connection_type == 'remote' and websocket_url:
+        # Remote WebSocket connection via Android Services Relay
+        try:
+            from services.android import get_relay_client
+
+            api_key = settings.websocket_api_key
+            if not api_key:
+                raise ValueError("WEBSOCKET_API_KEY not configured in environment")
+
+            logger.info("[Android Device Setup] Connecting to Relay",
+                       url=websocket_url, api_key=api_key[:8] + "...")
+
+            relay_client = await get_relay_client(websocket_url, api_key)
+
+            if relay_client and relay_client.is_connected():
+                # Wait for Android device to pair via QR code
+                if not relay_client.is_paired():
+                    logger.info("[Android Device Setup] Waiting for Android device to pair...")
+                    paired = await relay_client.wait_for_pairing(timeout=5.0)
+                    if not paired:
+                        # Return QR data for pairing
+                        connection_info = {
+                            "connection_type": "remote",
+                            "websocket_url": websocket_url,
+                            "port": port,
+                            "status": "waiting_for_pairing",
+                            "qr_data": relay_client.qr_data,
+                            "session_token": relay_client.session_token,
+                            "message": "Scan QR code with Android app to pair",
+                            "timestamp": datetime.now().isoformat()
+                        }
+                        return {
+                            "success": True,
+                            "node_id": node_id,
+                            "node_type": node_type,
+                            "result": connection_info,
+                            "execution_time": time.time() - start_time,
+                            "timestamp": datetime.now().isoformat()
+                        }
+
+                # Device is paired
+                device_id = relay_client.paired_device_id
+                device_name = relay_client.paired_device_name
+
+                connection_info = {
+                    "connection_type": "remote",
+                    "websocket_url": websocket_url,
+                    "port": port,
+                    "status": "paired",
+                    "paired": True,
+                    "device_id": device_id,
+                    "device_name": device_name,
+                    "session_token": relay_client.session_token,
+                    "message": f"Paired with Android device: {device_name or device_id}",
+                    "timestamp": datetime.now().isoformat()
+                }
+
+                logger.info("[Android Device Setup] Relay connected and paired",
+                           device_id=device_id, device_name=device_name)
+
+                return {
+                    "success": True,
+                    "node_id": node_id,
+                    "node_type": node_type,
+                    "result": connection_info,
+                    "execution_time": time.time() - start_time,
+                    "timestamp": datetime.now().isoformat()
+                }
+            else:
+                logger.error("[Android Device Setup] Relay connection failed")
+                return {
+                    "success": False,
+                    "node_id": node_id,
+                    "node_type": node_type,
+                    "error": "Failed to connect to relay server",
+                    "execution_time": time.time() - start_time,
+                    "timestamp": datetime.now().isoformat()
+                }
+        except Exception as e:
+            logger.error("[Android Device Setup] Relay error", error=str(e))
+            return {
+                "success": False,
+                "node_id": node_id,
+                "node_type": node_type,
+                "error": f"Relay connection error: {str(e)}",
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+    else:
+        # Configuration saved without active setup
+        connection_info = {
+            "connection_type": connection_type,
+            "device_id": device_id if connection_type == 'local' else None,
+            "websocket_url": websocket_url if connection_type == 'remote' else None,
+            "port": port,
+            "port_forwarding": "not_setup",
+            "message": "Device configuration saved (auto_forward disabled or missing device info)",
+            "timestamp": datetime.now().isoformat()
+        }
+
+        return {
+            "success": True,
+            "node_id": node_id,
+            "node_type": node_type,
+            "result": connection_info,
+            "execution_time": time.time() - start_time,
+            "timestamp": datetime.now().isoformat()
+        }
+
+
+async def handle_android_service(
+    node_id: str,
+    node_type: str,
+    parameters: Dict[str, Any],
+    context: Dict[str, Any],
+    android_service: "AndroidService"
+) -> Dict[str, Any]:
+    """Handle Android service node execution.
+
+    Executes Android service actions like battery status, network info, etc.
+
+    Args:
+        node_id: The node ID
+        node_type: The node type (batteryMonitor, networkMonitor, etc.)
+        parameters: Resolved parameters
+        context: Execution context
+        android_service: The Android service instance
+
+    Returns:
+        Execution result dict
+    """
+    logger.debug(f"[ANDROID DEBUG] Matched! node_type={node_type}")
+
+    service_id = parameters.get('service_id', 'battery')
+    action = parameters.get('action', 'status')
+    service_params = parameters.get('parameters', {})
+    android_host = parameters.get('android_host', 'localhost')
+    android_port = parameters.get('android_port', 8888)
+
+    # Parse parameters if it's a JSON string
+    if isinstance(service_params, str):
+        try:
+            service_params = json.loads(service_params)
+        except json.JSONDecodeError:
+            service_params = {}
+
+    # Extract additional parameters that are at root level (from additionalProperties in node definitions)
+    # These include: package_name (appLauncher), and any future custom parameters
+    additional_param_keys = ['package_name']
+    for key in additional_param_keys:
+        if key in parameters and parameters[key]:
+            service_params[key] = parameters[key]
+
+    logger.debug(f"[ANDROID DEBUG] Extracted params: service_id={service_id}, action={action}, host={android_host}, port={android_port}, service_params={service_params}")
+    logger.debug(f"[ANDROID DEBUG] About to call android_service.execute_service")
+
+    result = await android_service.execute_service(
+        node_id=node_id,
+        service_id=service_id,
+        action=action,
+        parameters=service_params,
+        android_host=android_host,
+        android_port=android_port
+    )
+    logger.debug(f"[ANDROID DEBUG] Got result from android_service")
+    return result