machinaos 0.0.1

package/server/services/handlers/whatsapp.py

@@ -0,0 +1,476 @@
+"""WhatsApp node handlers - Send and Connect."""
+
+import time
+from datetime import datetime
+from typing import Dict, Any
+from core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+async def handle_whatsapp_send(
+    node_id: str,
+    node_type: str,
+    parameters: Dict[str, Any],
+    context: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Handle WhatsApp send message node via Go RPC service.
+
+    Supports all message types: text, image, video, audio, document, sticker, location, contact
+    Recipients: phone number or group_id
+    Media sources: base64, file path, or URL
+
+    Args:
+        node_id: The node ID
+        node_type: The node type (whatsappSend)
+        parameters: Resolved parameters
+        context: Execution context
+
+    Returns:
+        Execution result dict
+    """
+    from routers.whatsapp import handle_whatsapp_send as whatsapp_send_handler
+    start_time = time.time()
+
+    try:
+        # Determine recipient (snake_case parameters)
+        recipient_type = parameters.get('recipient_type', 'phone')
+        group_id = parameters.get('group_id')
+        recipient = parameters.get('phone') if recipient_type == 'phone' else group_id
+        message_type = parameters.get('message_type', 'text')
+
+        if not recipient:
+            raise ValueError(f"{'Phone number' if recipient_type == 'phone' else 'Group ID'} is required")
+
+        # For text messages, validate message content
+        if message_type == 'text' and not parameters.get('message'):
+            raise ValueError("Message content is required for text messages")
+
+        # Call WhatsApp Go RPC service via handler - pass full params
+        data = await whatsapp_send_handler(parameters)
+
+        success = data.get('success', False)
+        if not success:
+            raise Exception(data.get('error', 'Send failed'))
+
+        # Build informative result based on message type (snake_case output)
+        result = {
+            "status": "sent",
+            "recipient": recipient,
+            "recipient_type": recipient_type,
+            "message_type": message_type,
+            "timestamp": datetime.now().isoformat()
+        }
+
+        # Add type-specific details using match statement
+        match message_type:
+            case 'text':
+                msg_content = parameters.get('message', '')
+                result["preview"] = msg_content[:100] + "..." if len(msg_content) > 100 else msg_content
+            case 'image' | 'video' | 'audio' | 'document' | 'sticker':
+                media_source = parameters.get('media_source', 'base64')
+                result["media_source"] = media_source
+                if parameters.get('caption'):
+                    result["caption"] = parameters.get('caption')
+                if parameters.get('filename'):
+                    result["filename"] = parameters.get('filename')
+                if parameters.get('mime_type'):
+                    result["mime_type"] = parameters.get('mime_type')
+                # For file uploads, include the uploaded filename
+                file_param = parameters.get('file_path')
+                if isinstance(file_param, dict) and file_param.get('type') == 'upload':
+                    result["uploaded_file"] = file_param.get('filename')
+                    result["mime_type"] = file_param.get('mimeType')
+            case 'location':
+                result["location"] = {
+                    "latitude": parameters.get('latitude'),
+                    "longitude": parameters.get('longitude'),
+                    "name": parameters.get('location_name'),
+                    "address": parameters.get('address')
+                }
+            case 'contact':
+                result["contact_name"] = parameters.get('contact_name')
+
+        return {
+            "success": success,
+            "node_id": node_id,
+            "node_type": "whatsappSend",
+            "result": result,
+            "execution_time": time.time() - start_time,
+            "timestamp": datetime.now().isoformat()
+        }
+
+    except Exception as e:
+        logger.error("WhatsApp send failed", node_id=node_id, error=str(e))
+        return {
+            "success": False,
+            "node_id": node_id,
+            "node_type": "whatsappSend",
+            "error": str(e),
+            "execution_time": time.time() - start_time,
+            "timestamp": datetime.now().isoformat()
+        }
+
+
+async def handle_whatsapp_connect(
+    node_id: str,
+    node_type: str,
+    parameters: Dict[str, Any],
+    context: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Handle WhatsApp connect - check status via Go RPC service.
+
+    Args:
+        node_id: The node ID
+        node_type: The node type (whatsappConnect)
+        parameters: Resolved parameters
+        context: Execution context
+
+    Returns:
+        Execution result dict with connection status
+    """
+    from routers.whatsapp import handle_whatsapp_status
+    start_time = time.time()
+
+    try:
+        # Call WhatsApp Go RPC service via handler
+        data = await handle_whatsapp_status()
+
+        result_data = data.get('data', {})
+        return {
+            "success": data.get('success', False),
+            "node_id": node_id,
+            "node_type": "whatsappConnect",
+            "result": {
+                "connected": result_data.get('connected', False),
+                "device_id": result_data.get('device_id'),
+                "has_session": result_data.get('has_session', False),
+                "running": result_data.get('running', False),
+                "status": "connected" if result_data.get('connected') else "disconnected",
+                "timestamp": datetime.now().isoformat()
+            },
+            "execution_time": time.time() - start_time,
+            "timestamp": datetime.now().isoformat()
+        }
+
+    except Exception as e:
+        logger.error("WhatsApp connect failed", node_id=node_id, error=str(e))
+        return {
+            "success": False,
+            "node_id": node_id,
+            "node_type": "whatsappConnect",
+            "error": str(e),
+            "execution_time": time.time() - start_time,
+            "timestamp": datetime.now().isoformat()
+        }
+
+
+async def handle_whatsapp_db(
+    node_id: str,
+    node_type: str,
+    parameters: Dict[str, Any],
+    context: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Handle WhatsApp DB node - query contacts, groups, messages.
+
+    Operations:
+    - chat_history: Retrieve messages from history store
+    - search_groups: Search groups by name
+    - get_group_info: Get group details with participant names
+    - get_contact_info: Get full contact info (name, phone, photo)
+    - list_contacts: List contacts with saved names
+    - check_contacts: Check WhatsApp registration
+
+    Args:
+        node_id: The node ID
+        node_type: The node type (whatsappDb)
+        parameters: Resolved parameters including operation and operation-specific params
+        context: Execution context
+
+    Returns:
+        Execution result dict
+    """
+    from routers.whatsapp import (
+        handle_whatsapp_chat_history as whatsapp_chat_history_handler,
+        whatsapp_rpc_call
+    )
+    start_time = time.time()
+
+    try:
+        operation = parameters.get('operation', 'chat_history')
+
+        if operation == 'chat_history':
+            return await _handle_chat_history(node_id, parameters, start_time, whatsapp_chat_history_handler)
+        elif operation == 'search_groups':
+            return await _handle_search_groups(node_id, parameters, start_time, whatsapp_rpc_call)
+        elif operation == 'get_group_info':
+            return await _handle_get_group_info(node_id, parameters, start_time, whatsapp_rpc_call)
+        elif operation == 'get_contact_info':
+            return await _handle_get_contact_info(node_id, parameters, start_time, whatsapp_rpc_call)
+        elif operation == 'list_contacts':
+            return await _handle_list_contacts(node_id, parameters, start_time, whatsapp_rpc_call)
+        elif operation == 'check_contacts':
+            return await _handle_check_contacts(node_id, parameters, start_time, whatsapp_rpc_call)
+        else:
+            raise ValueError(f"Unknown operation: {operation}")
+
+    except Exception as e:
+        logger.error("WhatsApp DB failed", node_id=node_id, operation=parameters.get('operation'), error=str(e))
+        return {
+            "success": False,
+            "node_id": node_id,
+            "node_type": "whatsappDb",
+            "error": str(e),
+            "execution_time": time.time() - start_time,
+            "timestamp": datetime.now().isoformat()
+        }
+
+
+async def _handle_chat_history(node_id: str, parameters: Dict[str, Any], start_time: float, handler) -> Dict[str, Any]:
+    """Handle chat_history operation."""
+    chat_type = parameters.get('chat_type', 'individual')
+    rpc_params: Dict[str, Any] = {}
+
+    if chat_type == 'individual':
+        phone = parameters.get('phone')
+        if not phone:
+            raise ValueError("Phone number is required for individual chats")
+        rpc_params['phone'] = phone
+    else:
+        group_id = parameters.get('group_id')
+        if not group_id:
+            raise ValueError("Group ID is required for group chats")
+        rpc_params['group_id'] = group_id
+
+        group_filter = parameters.get('group_filter', 'all')
+        if group_filter == 'contact':
+            sender_phone = parameters.get('sender_phone')
+            if sender_phone:
+                rpc_params['sender_phone'] = sender_phone
+
+    message_filter = parameters.get('message_filter', 'all')
+    rpc_params['text_only'] = message_filter == 'text_only'
+    rpc_params['limit'] = parameters.get('limit', 50)
+    rpc_params['offset'] = parameters.get('offset', 0)
+
+    data = await handler(rpc_params)
+
+    if not data.get('success', False):
+        raise Exception(data.get('error', 'Failed to retrieve chat history'))
+
+    messages = data.get('messages', [])
+    base_offset = rpc_params.get('offset', 0)
+    for i, msg in enumerate(messages):
+        msg['index'] = base_offset + i + 1
+
+    return {
+        "success": True,
+        "node_id": node_id,
+        "node_type": "whatsappDb",
+        "result": {
+            "operation": "chat_history",
+            "messages": messages,
+            "total": data.get('total', 0),
+            "has_more": data.get('has_more', False),
+            "count": len(messages),
+            "chat_type": chat_type,
+            "timestamp": datetime.now().isoformat()
+        },
+        "execution_time": time.time() - start_time,
+        "timestamp": datetime.now().isoformat()
+    }
+
+
+async def _handle_search_groups(node_id: str, parameters: Dict[str, Any], start_time: float, rpc_call) -> Dict[str, Any]:
+    """Handle search_groups operation."""
+    query = parameters.get('query', '')
+    limit = parameters.get('limit', 20)  # Default limit to prevent context overflow
+    data = await rpc_call('groups', {})
+
+    if not data.get('success', True):
+        raise Exception(data.get('error', 'Failed to get groups'))
+
+    groups = data if isinstance(data, list) else data.get('result', [])
+
+    # Filter by query if provided
+    if query:
+        query_lower = query.lower()
+        groups = [g for g in groups if query_lower in g.get('name', '').lower()]
+
+    total_found = len(groups)
+
+    # Apply limit to prevent context overflow (51 groups * ~4KB = 200KB+ tokens)
+    # Only return essential fields: jid and name
+    groups_limited = [
+        {"jid": g.get("jid", ""), "name": g.get("name", "")}
+        for g in groups[:limit]
+    ]
+
+    return {
+        "success": True,
+        "node_id": node_id,
+        "node_type": "whatsappDb",
+        "result": {
+            "operation": "search_groups",
+            "groups": groups_limited,
+            "total": total_found,
+            "returned": len(groups_limited),
+            "has_more": total_found > limit,
+            "query": query,
+            "hint": f"Showing {len(groups_limited)} of {total_found} groups. Use a more specific query or get_group_info for details." if total_found > limit else None,
+            "timestamp": datetime.now().isoformat()
+        },
+        "execution_time": time.time() - start_time,
+        "timestamp": datetime.now().isoformat()
+    }
+
+
+async def _handle_get_group_info(node_id: str, parameters: Dict[str, Any], start_time: float, rpc_call) -> Dict[str, Any]:
+    """Handle get_group_info operation."""
+    group_id = parameters.get('group_id_for_info') or parameters.get('group_id')
+    if not group_id:
+        raise ValueError("Group ID is required")
+
+    participant_limit = parameters.get('participant_limit', 50)  # Limit participants to prevent overflow
+
+    data = await rpc_call('group_info', {'group_id': group_id})
+
+    if not data.get('success', True) if isinstance(data, dict) else True:
+        raise Exception(data.get('error', 'Failed to get group info') if isinstance(data, dict) else 'Failed')
+
+    result = data if not isinstance(data, dict) or 'result' not in data else data.get('result', data)
+
+    # Limit participants and return only essential fields
+    participants = result.get('participants', [])
+    total_participants = len(participants)
+    participants_limited = [
+        {"phone": p.get("phone", ""), "name": p.get("name", ""), "is_admin": p.get("is_admin", False)}
+        for p in participants[:participant_limit]
+    ]
+
+    # Build limited result
+    limited_result = {
+        "name": result.get("name", ""),
+        "jid": result.get("jid", group_id),
+        "participants": participants_limited,
+        "total_participants": total_participants,
+        "participants_shown": len(participants_limited),
+    }
+
+    if total_participants > participant_limit:
+        limited_result["hint"] = f"Showing {participant_limit} of {total_participants} participants."
+
+    return {
+        "success": True,
+        "node_id": node_id,
+        "node_type": "whatsappDb",
+        "result": {
+            "operation": "get_group_info",
+            **limited_result,
+            "timestamp": datetime.now().isoformat()
+        },
+        "execution_time": time.time() - start_time,
+        "timestamp": datetime.now().isoformat()
+    }
+
+
+async def _handle_get_contact_info(node_id: str, parameters: Dict[str, Any], start_time: float, rpc_call) -> Dict[str, Any]:
+    """Handle get_contact_info operation."""
+    phone = parameters.get('contact_phone') or parameters.get('phone')
+    if not phone:
+        raise ValueError("Phone number is required")
+
+    data = await rpc_call('contact_info', {'phone': phone})
+
+    if isinstance(data, dict) and not data.get('success', True):
+        raise Exception(data.get('error', 'Failed to get contact info'))
+
+    result = data if not isinstance(data, dict) or 'result' not in data else data.get('result', data)
+
+    return {
+        "success": True,
+        "node_id": node_id,
+        "node_type": "whatsappDb",
+        "result": {
+            "operation": "get_contact_info",
+            **result,
+            "timestamp": datetime.now().isoformat()
+        },
+        "execution_time": time.time() - start_time,
+        "timestamp": datetime.now().isoformat()
+    }
+
+
+async def _handle_list_contacts(node_id: str, parameters: Dict[str, Any], start_time: float, rpc_call) -> Dict[str, Any]:
+    """Handle list_contacts operation."""
+    query = parameters.get('query', '')
+    limit = parameters.get('limit', 50)  # Default limit to prevent context overflow
+
+    data = await rpc_call('contacts', {'query': query})
+
+    if isinstance(data, dict) and not data.get('success', True):
+        raise Exception(data.get('error', 'Failed to list contacts'))
+
+    result = data if not isinstance(data, dict) or 'result' not in data else data.get('result', data)
+    contacts = result.get('contacts', []) if isinstance(result, dict) else result
+
+    total_found = len(contacts)
+
+    # Apply limit and return only essential fields: phone, name, jid
+    contacts_limited = [
+        {"phone": c.get("phone", ""), "name": c.get("name", ""), "jid": c.get("jid", "")}
+        for c in contacts[:limit]
+    ]
+
+    return {
+        "success": True,
+        "node_id": node_id,
+        "node_type": "whatsappDb",
+        "result": {
+            "operation": "list_contacts",
+            "contacts": contacts_limited,
+            "total": total_found,
+            "returned": len(contacts_limited),
+            "has_more": total_found > limit,
+            "query": query,
+            "hint": f"Showing {len(contacts_limited)} of {total_found} contacts. Use a more specific query to narrow results." if total_found > limit else None,
+            "timestamp": datetime.now().isoformat()
+        },
+        "execution_time": time.time() - start_time,
+        "timestamp": datetime.now().isoformat()
+    }
+
+
+async def _handle_check_contacts(node_id: str, parameters: Dict[str, Any], start_time: float, rpc_call) -> Dict[str, Any]:
+    """Handle check_contacts operation."""
+    phones_str = parameters.get('phones', '')
+    if not phones_str:
+        raise ValueError("Phone numbers are required")
+
+    # Parse comma-separated phones
+    phones = [p.strip() for p in phones_str.split(',') if p.strip()]
+    if not phones:
+        raise ValueError("At least one phone number is required")
+
+    data = await rpc_call('contact_check', {'phones': phones})
+
+    if isinstance(data, dict) and not data.get('success', True):
+        raise Exception(data.get('error', 'Failed to check contacts'))
+
+    results = data if isinstance(data, list) else data.get('result', [])
+
+    return {
+        "success": True,
+        "node_id": node_id,
+        "node_type": "whatsappDb",
+        "result": {
+            "operation": "check_contacts",
+            "results": results,
+            "total": len(results),
+            "timestamp": datetime.now().isoformat()
+        },
+        "execution_time": time.time() - start_time,
+        "timestamp": datetime.now().isoformat()
+    }
+
+