machinaos 0.0.1 → 0.0.7

package/server/services/handlers/http.py

@@ -1,193 +1,193 @@
-"""HTTP node handlers - HTTP Request and Webhook Response."""
-
-import json
-import time
-from datetime import datetime
-from typing import Dict, Any
-from core.logging import get_logger
-
-logger = get_logger(__name__)
-
-
-async def handle_http_request(
-    node_id: str,
-    node_type: str,
-    parameters: Dict[str, Any],
-    context: Dict[str, Any]
-) -> Dict[str, Any]:
-    """Handle HTTP request node execution.
-
-    Makes HTTP requests to external APIs.
-
-    Args:
-        node_id: The node ID
-        node_type: The node type (httpRequest)
-        parameters: Resolved parameters
-        context: Execution context
-
-    Returns:
-        Execution result dict with response data
-    """
-    import httpx
-    start_time = time.time()
-
-    try:
-        method = parameters.get('method', 'GET')
-        url = parameters.get('url', '')
-        headers_str = parameters.get('headers', '{}')
-        body = parameters.get('body', '')
-        timeout = float(parameters.get('timeout', 30))
-
-        if not url:
-            raise ValueError("URL is required")
-
-        # Parse headers JSON
-        try:
-            headers = json.loads(headers_str) if headers_str else {}
-        except json.JSONDecodeError:
-            headers = {}
-
-        logger.info("[HTTP Request] Executing", node_id=node_id, method=method, url=url)
-
-        async with httpx.AsyncClient() as client:
-            kwargs = {
-                'method': method,
-                'url': url,
-                'headers': headers,
-                'timeout': timeout
-            }
-
-            # Add body for POST/PUT/PATCH
-            if method in ['POST', 'PUT', 'PATCH'] and body:
-                try:
-                    kwargs['json'] = json.loads(body)
-                except json.JSONDecodeError:
-                    kwargs['content'] = body
-
-            response = await client.request(**kwargs)
-
-            # Parse response data
-            try:
-                response_data = response.json()
-            except:
-                response_data = response.text
-
-            result_data = {
-                "status": response.status_code,
-                "data": response_data,
-                "headers": dict(response.headers),
-                "url": str(response.url),
-                "method": method
-            }
-
-            return {
-                "success": response.status_code < 400,
-                "node_id": node_id,
-                "node_type": "httpRequest",
-                "result": result_data,
-                "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
-            }
-
-    except Exception as e:
-        if "TimeoutException" in type(e).__name__:
-            logger.error("HTTP request timed out", node_id=node_id, url=parameters.get('url'))
-            return {
-                "success": False,
-                "node_id": node_id,
-                "node_type": "httpRequest",
-                "error": f"Request timed out after {parameters.get('timeout', 30)} seconds",
-                "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
-            }
-        logger.error("HTTP request failed", node_id=node_id, error=str(e))
-        return {
-            "success": False,
-            "node_id": node_id,
-            "node_type": "httpRequest",
-            "error": str(e),
-            "execution_time": time.time() - start_time,
-            "timestamp": datetime.now().isoformat()
-        }
-
-
-async def handle_webhook_response(
-    node_id: str,
-    node_type: str,
-    parameters: Dict[str, Any],
-    context: Dict[str, Any],
-    connected_outputs: Dict[str, Any] = None
-) -> Dict[str, Any]:
-    """Handle webhook response node execution.
-
-    Sends response back to waiting webhook caller.
-
-    Args:
-        node_id: The node ID
-        node_type: The node type (webhookResponse)
-        parameters: Resolved parameters
-        context: Execution context
-        connected_outputs: Outputs from connected nodes
-
-    Returns:
-        Execution result dict
-    """
-    from routers.webhook import resolve_webhook_response
-    start_time = time.time()
-
-    try:
-        status_code = int(parameters.get('statusCode', 200))
-        response_body = parameters.get('responseBody', '')
-        content_type = parameters.get('contentType', 'application/json')
-
-        # Resolve template variables in response body
-        if response_body and connected_outputs:
-            for node_type_key, output_data in connected_outputs.items():
-                if isinstance(output_data, dict):
-                    for key, value in output_data.items():
-                        template = f"{{{{input.{key}}}}}"
-                        response_body = response_body.replace(template, str(value))
-                        # Also support {{nodeType.key}} format
-                        template_alt = f"{{{{{node_type_key}.{key}}}}}"
-                        response_body = response_body.replace(template_alt, str(value))
-
-        # If response body is empty, serialize connected outputs as JSON
-        if not response_body and connected_outputs:
-            # Get the first connected output
-            first_output = next(iter(connected_outputs.values()), {})
-            response_body = json.dumps(first_output, default=str)
-
-        logger.info("[Webhook Response] Sending", node_id=node_id, status_code=status_code,
-                   content_type=content_type, body_length=len(response_body))
-
-        # Resolve the pending webhook response
-        resolve_webhook_response(node_id, {
-            'statusCode': status_code,
-            'body': response_body,
-            'contentType': content_type
-        })
-
-        return {
-            "success": True,
-            "node_id": node_id,
-            "node_type": "webhookResponse",
-            "result": {
-                "sent": True,
-                "statusCode": status_code,
-                "contentType": content_type,
-                "bodyLength": len(response_body)
-            },
-            "execution_time": time.time() - start_time,
-            "timestamp": datetime.now().isoformat()
-        }
-
-    except Exception as e:
-        logger.error("Webhook response failed", node_id=node_id, error=str(e))
-        return {
-            "success": False,
-            "node_id": node_id,
-            "node_type": "webhookResponse",
-            "error": str(e),
-            "execution_time": time.time() - start_time,
-            "timestamp": datetime.now().isoformat()
-        }
+"""HTTP node handlers - HTTP Request and Webhook Response."""
+
+import json
+import time
+from datetime import datetime
+from typing import Dict, Any
+from core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+async def handle_http_request(
+    node_id: str,
+    node_type: str,
+    parameters: Dict[str, Any],
+    context: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Handle HTTP request node execution.
+
+    Makes HTTP requests to external APIs.
+
+    Args:
+        node_id: The node ID
+        node_type: The node type (httpRequest)
+        parameters: Resolved parameters
+        context: Execution context
+
+    Returns:
+        Execution result dict with response data
+    """
+    import httpx
+    start_time = time.time()
+
+    try:
+        method = parameters.get('method', 'GET')
+        url = parameters.get('url', '')
+        headers_str = parameters.get('headers', '{}')
+        body = parameters.get('body', '')
+        timeout = float(parameters.get('timeout', 30))
+
+        if not url:
+            raise ValueError("URL is required")
+
+        # Parse headers JSON
+        try:
+            headers = json.loads(headers_str) if headers_str else {}
+        except json.JSONDecodeError:
+            headers = {}
+
+        logger.info("[HTTP Request] Executing", node_id=node_id, method=method, url=url)
+
+        async with httpx.AsyncClient() as client:
+            kwargs = {
+                'method': method,
+                'url': url,
+                'headers': headers,
+                'timeout': timeout
+            }
+
+            # Add body for POST/PUT/PATCH
+            if method in ['POST', 'PUT', 'PATCH'] and body:
+                try:
+                    kwargs['json'] = json.loads(body)
+                except json.JSONDecodeError:
+                    kwargs['content'] = body
+
+            response = await client.request(**kwargs)
+
+            # Parse response data
+            try:
+                response_data = response.json()
+            except:
+                response_data = response.text
+
+            result_data = {
+                "status": response.status_code,
+                "data": response_data,
+                "headers": dict(response.headers),
+                "url": str(response.url),
+                "method": method
+            }
+
+            return {
+                "success": response.status_code < 400,
+                "node_id": node_id,
+                "node_type": "httpRequest",
+                "result": result_data,
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+    except Exception as e:
+        if "TimeoutException" in type(e).__name__:
+            logger.error("HTTP request timed out", node_id=node_id, url=parameters.get('url'))
+            return {
+                "success": False,
+                "node_id": node_id,
+                "node_type": "httpRequest",
+                "error": f"Request timed out after {parameters.get('timeout', 30)} seconds",
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+        logger.error("HTTP request failed", node_id=node_id, error=str(e))
+        return {
+            "success": False,
+            "node_id": node_id,
+            "node_type": "httpRequest",
+            "error": str(e),
+            "execution_time": time.time() - start_time,
+            "timestamp": datetime.now().isoformat()
+        }
+
+
+async def handle_webhook_response(
+    node_id: str,
+    node_type: str,
+    parameters: Dict[str, Any],
+    context: Dict[str, Any],
+    connected_outputs: Dict[str, Any] = None
+) -> Dict[str, Any]:
+    """Handle webhook response node execution.
+
+    Sends response back to waiting webhook caller.
+
+    Args:
+        node_id: The node ID
+        node_type: The node type (webhookResponse)
+        parameters: Resolved parameters
+        context: Execution context
+        connected_outputs: Outputs from connected nodes
+
+    Returns:
+        Execution result dict
+    """
+    from routers.webhook import resolve_webhook_response
+    start_time = time.time()
+
+    try:
+        status_code = int(parameters.get('statusCode', 200))
+        response_body = parameters.get('responseBody', '')
+        content_type = parameters.get('contentType', 'application/json')
+
+        # Resolve template variables in response body
+        if response_body and connected_outputs:
+            for node_type_key, output_data in connected_outputs.items():
+                if isinstance(output_data, dict):
+                    for key, value in output_data.items():
+                        template = f"{{{{input.{key}}}}}"
+                        response_body = response_body.replace(template, str(value))
+                        # Also support {{nodeType.key}} format
+                        template_alt = f"{{{{{node_type_key}.{key}}}}}"
+                        response_body = response_body.replace(template_alt, str(value))
+
+        # If response body is empty, serialize connected outputs as JSON
+        if not response_body and connected_outputs:
+            # Get the first connected output
+            first_output = next(iter(connected_outputs.values()), {})
+            response_body = json.dumps(first_output, default=str)
+
+        logger.info("[Webhook Response] Sending", node_id=node_id, status_code=status_code,
+                   content_type=content_type, body_length=len(response_body))
+
+        # Resolve the pending webhook response
+        resolve_webhook_response(node_id, {
+            'statusCode': status_code,
+            'body': response_body,
+            'contentType': content_type
+        })
+
+        return {
+            "success": True,
+            "node_id": node_id,
+            "node_type": "webhookResponse",
+            "result": {
+                "sent": True,
+                "statusCode": status_code,
+                "contentType": content_type,
+                "bodyLength": len(response_body)
+            },
+            "execution_time": time.time() - start_time,
+            "timestamp": datetime.now().isoformat()
+        }
+
+    except Exception as e:
+        logger.error("Webhook response failed", node_id=node_id, error=str(e))
+        return {
+            "success": False,
+            "node_id": node_id,
+            "node_type": "webhookResponse",
+            "error": str(e),
+            "execution_time": time.time() - start_time,
+            "timestamp": datetime.now().isoformat()
+        }

package/server/services/handlers/tools.py

@@ -40,10 +40,14 @@ async def execute_tool(tool_name: str, tool_args: Dict[str, Any],
     if node_type in ('httpRequest', 'httpRequestTool'):
         return await _execute_http_request(tool_args, config.get('parameters', {}))
 
-    # Python executor tool
+    # Python executor tool (dual-purpose: workflow node + AI tool)
     if node_type == 'pythonExecutor':
         return await _execute_python_code(tool_args, config.get('parameters', {}))
 
+    # JavaScript executor tool (dual-purpose: workflow node + AI tool)
+    if node_type == 'javascriptExecutor':
+        return await _execute_javascript_code(tool_args, config.get('parameters', {}))
+
     # Current time tool
     if node_type == 'currentTimeTool':
         return await _execute_current_time(tool_args, config.get('parameters', {}))
@@ -191,44 +195,64 @@ async def _execute_http_request(args: Dict[str, Any],
 
 async def _execute_python_code(args: Dict[str, Any],
                                 node_params: Dict[str, Any]) -> Dict[str, Any]:
-    """Execute Python code tool.
+    """Execute Python code (dual-purpose: workflow node + AI tool).
 
     Args:
-        args: Dict with 'code'
-        node_params: Node parameters containing timeout, etc.
+        args: Dict with 'code' from LLM (when used as AI tool)
+        node_params: Node parameters containing code (when used as workflow node), timeout, etc.
 
     Returns:
-        Dict with result or output
+        Dict with success, result, output, or error
     """
     import subprocess
     import tempfile
     import os
 
-    code = args.get('code', '')
+    # Get code from LLM args first (AI tool mode), fall back to node parameters (workflow mode)
+    code = args.get('code', '') or node_params.get('code', '')
     timeout = int(node_params.get('timeout', 30))
 
     if not code:
-        return {"error": "No code provided"}
+        return {"error": "No code provided. When using as AI tool, the LLM must provide the 'code' argument with Python code to execute."}
 
-    # Create a temporary file with the code
-    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
-        # Wrap code to capture the result
-        wrapped_code = f"""
+    # Wrap code to capture output and result
+    wrapped_code = f'''
 import json
 import sys
+import math
+from datetime import datetime, timedelta
+from collections import Counter, defaultdict
 
-def main():
-{chr(10).join('    ' + line for line in code.split(chr(10)))}
+input_data = {{}}
+output = None
+_stdout_lines = []
+
+class _PrintCapture:
+    def write(self, text):
+        if text.strip():
+            _stdout_lines.append(text.rstrip())
+    def flush(self):
+        pass
+
+_old_stdout = sys.stdout
+sys.stdout = _PrintCapture()
 
 try:
-    result = main()
-    if result is not None:
-        print(json.dumps({{"result": result}}, default=str))
-    else:
-        print(json.dumps({{"result": "Code executed successfully"}}))
+{chr(10).join("    " + line for line in code.split(chr(10)))}
+
+    sys.stdout = _old_stdout
+    result = {{"success": True}}
+    if output is not None:
+        result["result"] = output
+    if _stdout_lines:
+        result["output"] = chr(10).join(_stdout_lines)
+    print(json.dumps(result, default=str))
 except Exception as e:
+    sys.stdout = _old_stdout
     print(json.dumps({{"error": str(e)}}))
-"""
+'''
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
         f.write(wrapped_code)
         temp_path = f.name
 
@@ -243,20 +267,102 @@ except Exception as e:
 
         if result.returncode == 0:
             try:
-                output = json.loads(result.stdout.strip())
-                return output
+                return json.loads(result.stdout.strip())
             except:
-                return {"output": result.stdout.strip()}
+                return {"success": True, "output": result.stdout.strip()}
         else:
-            return {"error": result.stderr or "Code execution failed"}
+            return {"error": result.stderr or "Python execution failed"}
 
     except subprocess.TimeoutExpired:
-        return {"error": f"Code execution timed out after {timeout} seconds"}
+        return {"error": f"Python execution timed out after {timeout} seconds"}
     except Exception as e:
         logger.error(f"[Python Tool] Error: {e}")
         return {"error": str(e)}
     finally:
-        # Clean up temp file
+        try:
+            os.unlink(temp_path)
+        except:
+            pass
+
+
+async def _execute_javascript_code(args: Dict[str, Any],
+                                    node_params: Dict[str, Any]) -> Dict[str, Any]:
+    """Execute JavaScript code (dual-purpose: workflow node + AI tool).
+
+    Args:
+        args: Dict with 'code' from LLM (when used as AI tool)
+        node_params: Node parameters containing code (when used as workflow node), timeout, etc.
+
+    Returns:
+        Dict with success, result, output, or error
+    """
+    import subprocess
+    import tempfile
+    import os
+
+    # Get code from LLM args first (AI tool mode), fall back to node parameters (workflow mode)
+    code = args.get('code', '') or node_params.get('code', '')
+    timeout = int(node_params.get('timeout', 30))
+
+    if not code:
+        return {"error": "No code provided. When using as AI tool, the LLM must provide the 'code' argument with JavaScript code to execute."}
+
+    # Wrap code to capture output and result
+    wrapped_code = f'''
+const input_data = {{}};
+let output = undefined;
+const _stdout_lines = [];
+
+const _originalLog = console.log;
+console.log = (...args) => {{
+    _stdout_lines.push(args.map(a => typeof a === 'object' ? JSON.stringify(a) : String(a)).join(' '));
+}};
+
+try {{
+{chr(10).join("    " + line for line in code.split(chr(10)))}
+
+    const result = {{ success: true }};
+    if (output !== undefined) {{
+        result.result = output;
+    }}
+    if (_stdout_lines.length > 0) {{
+        result.output = _stdout_lines.join('\\n');
+    }}
+    _originalLog(JSON.stringify(result));
+}} catch (e) {{
+    _originalLog(JSON.stringify({{ error: e.message }}));
+}}
+'''
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.js', delete=False) as f:
+        f.write(wrapped_code)
+        temp_path = f.name
+
+    try:
+        logger.info(f"[JavaScript Tool] Executing code (timeout: {timeout}s)")
+        result = subprocess.run(
+            ['node', temp_path],
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+
+        if result.returncode == 0:
+            try:
+                return json.loads(result.stdout.strip())
+            except:
+                return {"success": True, "output": result.stdout.strip()}
+        else:
+            return {"error": result.stderr or "JavaScript execution failed"}
+
+    except subprocess.TimeoutExpired:
+        return {"error": f"JavaScript execution timed out after {timeout} seconds"}
+    except FileNotFoundError:
+        return {"error": "Node.js is not installed. Cannot execute JavaScript code."}
+    except Exception as e:
+        logger.error(f"[JavaScript Tool] Error: {e}")
+        return {"error": str(e)}
+    finally:
         try:
             os.unlink(temp_path)
         except:
@@ -323,14 +429,14 @@ async def _execute_web_search(args: Dict[str, Any],
 
     try:
         if provider == 'duckduckgo':
-            # Use the duckduckgo-search library for proper web search results
+            # Use the ddgs library for proper web search results
             try:
-                from duckduckgo_search import DDGS
+                from ddgs import DDGS
 
                 # Run synchronous DDGS in a thread pool to not block async
                 def do_search():
-                    with DDGS() as ddgs:
-                        return list(ddgs.text(query, max_results=max_results))
+                    ddgs = DDGS()
+                    return list(ddgs.text(query, max_results=max_results))
 
                 search_results = await asyncio.get_event_loop().run_in_executor(
                     None, do_search
@@ -352,7 +458,7 @@ async def _execute_web_search(args: Dict[str, Any],
                 }
 
             except ImportError:
-                logger.warning("[WebSearch] duckduckgo-search not installed, falling back to Instant Answer API")
+                logger.warning("[WebSearch] ddgs not installed, falling back to Instant Answer API")
                 # Fallback to Instant Answer API (limited results)
                 async with httpx.AsyncClient(timeout=10.0) as client:
                     response = await client.get(
@@ -743,8 +849,12 @@ async def _execute_geocoding(args: Dict[str, Any],
     from services.handlers.utility import handle_add_locations
     from core.container import container
 
+    # Fetch API key from database (source of truth)
+    auth_service = container.auth_service()
+    api_key = await auth_service.get_api_key("google_maps", "default") or ''
+
     # Args use snake_case matching Pydantic schema and node params
-    parameters = {**args, 'api_key': node_params.get('api_key', '')}
+    parameters = {**args, 'api_key': api_key}
 
     service_type = parameters.get('service_type', 'geocode')
 
@@ -793,8 +903,12 @@ async def _execute_nearby_places(args: Dict[str, Any],
     from services.handlers.utility import handle_nearby_places
     from core.container import container
 
+    # Fetch API key from database (source of truth)
+    auth_service = container.auth_service()
+    api_key = await auth_service.get_api_key("google_maps", "default") or ''
+
     # Args use snake_case matching Pydantic schema and node params
-    parameters = {**args, 'api_key': node_params.get('api_key', '')}
+    parameters = {**args, 'api_key': api_key}
 
     # Validate required fields
     if parameters.get('lat') is None or parameters.get('lng') is None: